blob: 031edf1515b38f9375048ba74f92abe43c6c1614 [file] [log] [blame]
Chris Lattner199abbc2008-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 McCall83024632010-08-25 22:03:47 +000014#include "clang/Sema/SemaInternal.h"
Argyrios Kyrtzidis2f67f372008-08-09 00:58:37 +000015#include "clang/AST/ASTConsumer.h"
Douglas Gregor556877c2008-04-13 21:30:24 +000016#include "clang/AST/ASTContext.h"
Faisal Vali2b391ab2013-09-26 19:54:12 +000017#include "clang/AST/ASTLambda.h"
Sebastian Redlab238a72011-04-24 16:28:06 +000018#include "clang/AST/ASTMutationListener.h"
Douglas Gregor36d1b142009-10-06 17:59:45 +000019#include "clang/AST/CXXInheritance.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000020#include "clang/AST/CharUnits.h"
Richard Trieu4fc85362012-06-14 23:11:34 +000021#include "clang/AST/EvaluatedExprVisitor.h"
Alexis Huntc5575cc2011-02-26 19:13:13 +000022#include "clang/AST/ExprCXX.h"
Douglas Gregorb139cd52010-05-01 20:49:11 +000023#include "clang/AST/RecordLayout.h"
Douglas Gregor3024f072012-04-16 07:05:22 +000024#include "clang/AST/RecursiveASTVisitor.h"
Douglas Gregorb139cd52010-05-01 20:49:11 +000025#include "clang/AST/StmtVisitor.h"
Douglas Gregorc8c44b5d2009-12-02 22:36:29 +000026#include "clang/AST/TypeLoc.h"
Douglas Gregordff6a8e2008-10-22 21:13:31 +000027#include "clang/AST/TypeOrdering.h"
Anders Carlssond624e162009-08-26 23:45:07 +000028#include "clang/Basic/PartialDiagnostic.h"
Aaron Ballman02df2e02012-12-09 17:45:41 +000029#include "clang/Basic/TargetInfo.h"
Richard Smithf4198b72013-07-23 08:14:48 +000030#include "clang/Lex/LiteralSupport.h"
Argyrios Kyrtzidis153d9672008-10-06 18:37:09 +000031#include "clang/Lex/Preprocessor.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000032#include "clang/Sema/CXXFieldCollector.h"
33#include "clang/Sema/DeclSpec.h"
34#include "clang/Sema/Initialization.h"
35#include "clang/Sema/Lookup.h"
36#include "clang/Sema/ParsedTemplate.h"
37#include "clang/Sema/Scope.h"
38#include "clang/Sema/ScopeInfo.h"
Douglas Gregor55297ac2008-12-23 00:26:44 +000039#include "llvm/ADT/STLExtras.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000040#include "llvm/ADT/SmallString.h"
Douglas Gregor29a92472008-10-22 17:49:05 +000041#include <map>
Douglas Gregor36d1b142009-10-06 17:59:45 +000042#include <set>
Chris Lattner199abbc2008-04-08 05:04:30 +000043
44using namespace clang;
45
Chris Lattner58258242008-04-10 02:22:51 +000046//===----------------------------------------------------------------------===//
47// CheckDefaultArgumentVisitor
48//===----------------------------------------------------------------------===//
49
Chris Lattnerb0d38442008-04-12 23:52:44 +000050namespace {
51 /// CheckDefaultArgumentVisitor - C++ [dcl.fct.default] Traverses
52 /// the default argument of a parameter to determine whether it
53 /// contains any ill-formed subexpressions. For example, this will
54 /// diagnose the use of local variables or parameters within the
55 /// default argument expression.
Benjamin Kramer337e3a52009-11-28 19:45:26 +000056 class CheckDefaultArgumentVisitor
Chris Lattner574dee62008-07-26 22:17:49 +000057 : public StmtVisitor<CheckDefaultArgumentVisitor, bool> {
Chris Lattnerb0d38442008-04-12 23:52:44 +000058 Expr *DefaultArg;
59 Sema *S;
Chris Lattner58258242008-04-10 02:22:51 +000060
Chris Lattnerb0d38442008-04-12 23:52:44 +000061 public:
Mike Stump11289f42009-09-09 15:08:12 +000062 CheckDefaultArgumentVisitor(Expr *defarg, Sema *s)
Chris Lattnerb0d38442008-04-12 23:52:44 +000063 : DefaultArg(defarg), S(s) {}
Chris Lattner58258242008-04-10 02:22:51 +000064
Chris Lattnerb0d38442008-04-12 23:52:44 +000065 bool VisitExpr(Expr *Node);
66 bool VisitDeclRefExpr(DeclRefExpr *DRE);
Douglas Gregor97a9c812008-11-04 14:32:21 +000067 bool VisitCXXThisExpr(CXXThisExpr *ThisE);
Douglas Gregorf0d49512012-02-10 23:30:22 +000068 bool VisitLambdaExpr(LambdaExpr *Lambda);
John McCall7353c862013-04-09 01:56:28 +000069 bool VisitPseudoObjectExpr(PseudoObjectExpr *POE);
Chris Lattnerb0d38442008-04-12 23:52:44 +000070 };
Chris Lattner58258242008-04-10 02:22:51 +000071
Chris Lattnerb0d38442008-04-12 23:52:44 +000072 /// VisitExpr - Visit all of the children of this expression.
73 bool CheckDefaultArgumentVisitor::VisitExpr(Expr *Node) {
74 bool IsInvalid = false;
John McCall8322c3a2011-02-13 04:07:26 +000075 for (Stmt::child_range I = Node->children(); I; ++I)
Chris Lattner574dee62008-07-26 22:17:49 +000076 IsInvalid |= Visit(*I);
Chris Lattnerb0d38442008-04-12 23:52:44 +000077 return IsInvalid;
Chris Lattner58258242008-04-10 02:22:51 +000078 }
79
Chris Lattnerb0d38442008-04-12 23:52:44 +000080 /// VisitDeclRefExpr - Visit a reference to a declaration, to
81 /// determine whether this declaration can be used in the default
82 /// argument expression.
83 bool CheckDefaultArgumentVisitor::VisitDeclRefExpr(DeclRefExpr *DRE) {
Douglas Gregor5251f1b2008-10-21 16:13:35 +000084 NamedDecl *Decl = DRE->getDecl();
Chris Lattnerb0d38442008-04-12 23:52:44 +000085 if (ParmVarDecl *Param = dyn_cast<ParmVarDecl>(Decl)) {
86 // C++ [dcl.fct.default]p9
87 // Default arguments are evaluated each time the function is
88 // called. The order of evaluation of function arguments is
89 // unspecified. Consequently, parameters of a function shall not
90 // be used in default argument expressions, even if they are not
91 // evaluated. Parameters of a function declared before a default
92 // argument expression are in scope and can hide namespace and
93 // class member names.
Daniel Dunbar62ee6412012-03-09 18:35:03 +000094 return S->Diag(DRE->getLocStart(),
Chris Lattner3b054132008-11-19 05:08:23 +000095 diag::err_param_default_argument_references_param)
Chris Lattnere3d20d92008-11-23 21:45:46 +000096 << Param->getDeclName() << DefaultArg->getSourceRange();
Steve Naroff08899ff2008-04-15 22:42:06 +000097 } else if (VarDecl *VDecl = dyn_cast<VarDecl>(Decl)) {
Chris Lattnerb0d38442008-04-12 23:52:44 +000098 // C++ [dcl.fct.default]p7
99 // Local variables shall not be used in default argument
100 // expressions.
John McCall1c9c3fd2010-10-15 04:57:14 +0000101 if (VDecl->isLocalVarDecl())
Daniel Dunbar62ee6412012-03-09 18:35:03 +0000102 return S->Diag(DRE->getLocStart(),
Chris Lattner3b054132008-11-19 05:08:23 +0000103 diag::err_param_default_argument_references_local)
Chris Lattnere3d20d92008-11-23 21:45:46 +0000104 << VDecl->getDeclName() << DefaultArg->getSourceRange();
Chris Lattnerb0d38442008-04-12 23:52:44 +0000105 }
Chris Lattner58258242008-04-10 02:22:51 +0000106
Douglas Gregor8e12c382008-11-04 13:41:56 +0000107 return false;
108 }
Chris Lattnerb0d38442008-04-12 23:52:44 +0000109
Douglas Gregor97a9c812008-11-04 14:32:21 +0000110 /// VisitCXXThisExpr - Visit a C++ "this" expression.
111 bool CheckDefaultArgumentVisitor::VisitCXXThisExpr(CXXThisExpr *ThisE) {
112 // C++ [dcl.fct.default]p8:
113 // The keyword this shall not be used in a default argument of a
114 // member function.
Daniel Dunbar62ee6412012-03-09 18:35:03 +0000115 return S->Diag(ThisE->getLocStart(),
Chris Lattner3b054132008-11-19 05:08:23 +0000116 diag::err_param_default_argument_references_this)
117 << ThisE->getSourceRange();
Chris Lattnerb0d38442008-04-12 23:52:44 +0000118 }
Douglas Gregorf0d49512012-02-10 23:30:22 +0000119
John McCall7353c862013-04-09 01:56:28 +0000120 bool CheckDefaultArgumentVisitor::VisitPseudoObjectExpr(PseudoObjectExpr *POE) {
121 bool Invalid = false;
122 for (PseudoObjectExpr::semantics_iterator
123 i = POE->semantics_begin(), e = POE->semantics_end(); i != e; ++i) {
124 Expr *E = *i;
125
126 // Look through bindings.
127 if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) {
128 E = OVE->getSourceExpr();
129 assert(E && "pseudo-object binding without source expression?");
130 }
131
132 Invalid |= Visit(E);
133 }
134 return Invalid;
135 }
136
Douglas Gregorf0d49512012-02-10 23:30:22 +0000137 bool CheckDefaultArgumentVisitor::VisitLambdaExpr(LambdaExpr *Lambda) {
138 // C++11 [expr.lambda.prim]p13:
139 // A lambda-expression appearing in a default argument shall not
140 // implicitly or explicitly capture any entity.
141 if (Lambda->capture_begin() == Lambda->capture_end())
142 return false;
143
144 return S->Diag(Lambda->getLocStart(),
145 diag::err_lambda_capture_default_arg);
146 }
Chris Lattner58258242008-04-10 02:22:51 +0000147}
148
Richard Smithb7151b92013-04-10 06:11:48 +0000149void
150Sema::ImplicitExceptionSpecification::CalledDecl(SourceLocation CallLoc,
151 const CXXMethodDecl *Method) {
Richard Smithd3b5c9082012-07-27 04:22:15 +0000152 // If we have an MSAny spec already, don't bother.
153 if (!Method || ComputedEST == EST_MSAny)
Alexis Hunt6d5b96c2011-05-10 00:49:42 +0000154 return;
155
156 const FunctionProtoType *Proto
157 = Method->getType()->getAs<FunctionProtoType>();
Richard Smithf623c962012-04-17 00:58:00 +0000158 Proto = Self->ResolveExceptionSpec(CallLoc, Proto);
159 if (!Proto)
160 return;
Alexis Hunt6d5b96c2011-05-10 00:49:42 +0000161
162 ExceptionSpecificationType EST = Proto->getExceptionSpecType();
163
164 // If this function can throw any exceptions, make a note of that.
Richard Smithd3b5c9082012-07-27 04:22:15 +0000165 if (EST == EST_MSAny || EST == EST_None) {
Alexis Hunt6d5b96c2011-05-10 00:49:42 +0000166 ClearExceptions();
167 ComputedEST = EST;
168 return;
169 }
170
Richard Smith938f40b2011-06-11 17:19:42 +0000171 // FIXME: If the call to this decl is using any of its default arguments, we
172 // need to search them for potentially-throwing calls.
173
Alexis Hunt6d5b96c2011-05-10 00:49:42 +0000174 // If this function has a basic noexcept, it doesn't affect the outcome.
175 if (EST == EST_BasicNoexcept)
176 return;
177
178 // If we have a throw-all spec at this point, ignore the function.
179 if (ComputedEST == EST_None)
180 return;
181
182 // If we're still at noexcept(true) and there's a nothrow() callee,
183 // change to that specification.
184 if (EST == EST_DynamicNone) {
185 if (ComputedEST == EST_BasicNoexcept)
186 ComputedEST = EST_DynamicNone;
187 return;
188 }
189
190 // Check out noexcept specs.
191 if (EST == EST_ComputedNoexcept) {
Richard Smithf623c962012-04-17 00:58:00 +0000192 FunctionProtoType::NoexceptResult NR =
193 Proto->getNoexceptSpec(Self->Context);
Alexis Hunt6d5b96c2011-05-10 00:49:42 +0000194 assert(NR != FunctionProtoType::NR_NoNoexcept &&
195 "Must have noexcept result for EST_ComputedNoexcept.");
196 assert(NR != FunctionProtoType::NR_Dependent &&
197 "Should not generate implicit declarations for dependent cases, "
198 "and don't know how to handle them anyway.");
199
200 // noexcept(false) -> no spec on the new function
201 if (NR == FunctionProtoType::NR_Throw) {
202 ClearExceptions();
203 ComputedEST = EST_None;
204 }
205 // noexcept(true) won't change anything either.
206 return;
207 }
208
209 assert(EST == EST_Dynamic && "EST case not considered earlier.");
210 assert(ComputedEST != EST_None &&
211 "Shouldn't collect exceptions when throw-all is guaranteed.");
212 ComputedEST = EST_Dynamic;
213 // Record the exceptions in this function's exception specification.
Aaron Ballmanb088fbe2014-03-17 15:38:09 +0000214 for (const auto &E : Proto->exceptions())
215 if (ExceptionsSeen.insert(Self->Context.getCanonicalType(E)))
216 Exceptions.push_back(E);
Alexis Hunt6d5b96c2011-05-10 00:49:42 +0000217}
218
Richard Smith938f40b2011-06-11 17:19:42 +0000219void Sema::ImplicitExceptionSpecification::CalledExpr(Expr *E) {
Richard Smithd3b5c9082012-07-27 04:22:15 +0000220 if (!E || ComputedEST == EST_MSAny)
Richard Smith938f40b2011-06-11 17:19:42 +0000221 return;
222
223 // FIXME:
224 //
225 // C++0x [except.spec]p14:
NAKAMURA Takumi53648472011-06-21 03:19:28 +0000226 // [An] implicit exception-specification specifies the type-id T if and
227 // only if T is allowed by the exception-specification of a function directly
228 // invoked by f's implicit definition; f shall allow all exceptions if any
Richard Smith938f40b2011-06-11 17:19:42 +0000229 // function it directly invokes allows all exceptions, and f shall allow no
230 // exceptions if every function it directly invokes allows no exceptions.
231 //
232 // Note in particular that if an implicit exception-specification is generated
233 // for a function containing a throw-expression, that specification can still
234 // be noexcept(true).
235 //
236 // Note also that 'directly invoked' is not defined in the standard, and there
237 // is no indication that we should only consider potentially-evaluated calls.
238 //
239 // Ultimately we should implement the intent of the standard: the exception
240 // specification should be the set of exceptions which can be thrown by the
241 // implicit definition. For now, we assume that any non-nothrow expression can
242 // throw any exception.
243
Richard Smithf623c962012-04-17 00:58:00 +0000244 if (Self->canThrow(E))
Richard Smith938f40b2011-06-11 17:19:42 +0000245 ComputedEST = EST_None;
246}
247
Anders Carlssonc80a1272009-08-25 02:29:20 +0000248bool
John McCallb268a282010-08-23 23:25:46 +0000249Sema::SetParamDefaultArgument(ParmVarDecl *Param, Expr *Arg,
Mike Stump11289f42009-09-09 15:08:12 +0000250 SourceLocation EqualLoc) {
Anders Carlsson114056f2009-08-25 13:46:13 +0000251 if (RequireCompleteType(Param->getLocation(), Param->getType(),
252 diag::err_typecheck_decl_incomplete_type)) {
253 Param->setInvalidDecl();
254 return true;
255 }
256
Anders Carlssonc80a1272009-08-25 02:29:20 +0000257 // C++ [dcl.fct.default]p5
258 // A default argument expression is implicitly converted (clause
259 // 4) to the parameter type. The default argument expression has
260 // the same semantic constraints as the initializer expression in
261 // a declaration of a variable of the parameter type, using the
262 // copy-initialization semantics (8.5).
Fariborz Jahanian8fb87ae2010-09-24 17:30:16 +0000263 InitializedEntity Entity = InitializedEntity::InitializeParameter(Context,
264 Param);
Douglas Gregor85dabae2009-12-16 01:38:02 +0000265 InitializationKind Kind = InitializationKind::CreateCopy(Param->getLocation(),
266 EqualLoc);
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +0000267 InitializationSequence InitSeq(*this, Entity, Kind, Arg);
Benjamin Kramercc4c49d2012-08-23 23:38:35 +0000268 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Arg);
Eli Friedman5f101b92009-12-22 02:46:13 +0000269 if (Result.isInvalid())
Anders Carlsson4562f1f2009-08-25 03:18:48 +0000270 return true;
Nikola Smiljanic01a75982014-05-29 10:55:11 +0000271 Arg = Result.getAs<Expr>();
Anders Carlssonc80a1272009-08-25 02:29:20 +0000272
Richard Smithc406cb72013-01-17 01:17:56 +0000273 CheckCompletedExpr(Arg, EqualLoc);
John McCall5d413782010-12-06 08:20:24 +0000274 Arg = MaybeCreateExprWithCleanups(Arg);
Mike Stump11289f42009-09-09 15:08:12 +0000275
Anders Carlssonc80a1272009-08-25 02:29:20 +0000276 // Okay: add the default argument to the parameter
277 Param->setDefaultArg(Arg);
Mike Stump11289f42009-09-09 15:08:12 +0000278
Douglas Gregor758cb672010-10-12 18:23:32 +0000279 // We have already instantiated this parameter; provide each of the
280 // instantiations with the uninstantiated default argument.
281 UnparsedDefaultArgInstantiationsMap::iterator InstPos
282 = UnparsedDefaultArgInstantiations.find(Param);
283 if (InstPos != UnparsedDefaultArgInstantiations.end()) {
284 for (unsigned I = 0, N = InstPos->second.size(); I != N; ++I)
285 InstPos->second[I]->setUninstantiatedDefaultArg(Arg);
286
287 // We're done tracking this parameter's instantiations.
288 UnparsedDefaultArgInstantiations.erase(InstPos);
289 }
290
Anders Carlsson4562f1f2009-08-25 03:18:48 +0000291 return false;
Anders Carlssonc80a1272009-08-25 02:29:20 +0000292}
293
Chris Lattner58258242008-04-10 02:22:51 +0000294/// ActOnParamDefaultArgument - Check whether the default argument
295/// provided for a function parameter is well-formed. If so, attach it
296/// to the parameter declaration.
Chris Lattner199abbc2008-04-08 05:04:30 +0000297void
John McCall48871652010-08-21 09:40:31 +0000298Sema::ActOnParamDefaultArgument(Decl *param, SourceLocation EqualLoc,
John McCallb268a282010-08-23 23:25:46 +0000299 Expr *DefaultArg) {
300 if (!param || !DefaultArg)
Douglas Gregor71a57182009-06-22 23:20:33 +0000301 return;
Mike Stump11289f42009-09-09 15:08:12 +0000302
John McCall48871652010-08-21 09:40:31 +0000303 ParmVarDecl *Param = cast<ParmVarDecl>(param);
Anders Carlsson84613c42009-06-12 16:51:40 +0000304 UnparsedDefaultArgLocs.erase(Param);
305
Chris Lattner199abbc2008-04-08 05:04:30 +0000306 // Default arguments are only permitted in C++
David Blaikiebbafb8a2012-03-11 07:00:24 +0000307 if (!getLangOpts().CPlusPlus) {
Chris Lattner3b054132008-11-19 05:08:23 +0000308 Diag(EqualLoc, diag::err_param_default_argument)
309 << DefaultArg->getSourceRange();
Douglas Gregor4d87df52008-12-16 21:30:33 +0000310 Param->setInvalidDecl();
Chris Lattner199abbc2008-04-08 05:04:30 +0000311 return;
312 }
313
Douglas Gregor6ff1fbf2010-12-16 08:48:57 +0000314 // Check for unexpanded parameter packs.
315 if (DiagnoseUnexpandedParameterPack(DefaultArg, UPPC_DefaultArgument)) {
316 Param->setInvalidDecl();
317 return;
318 }
319
Anders Carlssonf1c26952009-08-25 01:02:06 +0000320 // Check that the default argument is well-formed
John McCallb268a282010-08-23 23:25:46 +0000321 CheckDefaultArgumentVisitor DefaultArgChecker(DefaultArg, this);
322 if (DefaultArgChecker.Visit(DefaultArg)) {
Anders Carlssonf1c26952009-08-25 01:02:06 +0000323 Param->setInvalidDecl();
324 return;
325 }
Mike Stump11289f42009-09-09 15:08:12 +0000326
John McCallb268a282010-08-23 23:25:46 +0000327 SetParamDefaultArgument(Param, DefaultArg, EqualLoc);
Chris Lattner199abbc2008-04-08 05:04:30 +0000328}
329
Douglas Gregor58354032008-12-24 00:01:03 +0000330/// ActOnParamUnparsedDefaultArgument - We've seen a default
331/// argument for a function parameter, but we can't parse it yet
332/// because we're inside a class definition. Note that this default
333/// argument will be parsed later.
John McCall48871652010-08-21 09:40:31 +0000334void Sema::ActOnParamUnparsedDefaultArgument(Decl *param,
Anders Carlsson84613c42009-06-12 16:51:40 +0000335 SourceLocation EqualLoc,
336 SourceLocation ArgLoc) {
Douglas Gregor71a57182009-06-22 23:20:33 +0000337 if (!param)
338 return;
Mike Stump11289f42009-09-09 15:08:12 +0000339
John McCall48871652010-08-21 09:40:31 +0000340 ParmVarDecl *Param = cast<ParmVarDecl>(param);
Nick Lewycky0f292892013-09-22 10:06:57 +0000341 Param->setUnparsedDefaultArg();
Anders Carlsson84613c42009-06-12 16:51:40 +0000342 UnparsedDefaultArgLocs[Param] = ArgLoc;
Douglas Gregor58354032008-12-24 00:01:03 +0000343}
344
Douglas Gregor4d87df52008-12-16 21:30:33 +0000345/// ActOnParamDefaultArgumentError - Parsing or semantic analysis of
346/// the default argument for the parameter param failed.
Serge Pavlovb4b35782014-07-22 01:54:49 +0000347void Sema::ActOnParamDefaultArgumentError(Decl *param,
348 SourceLocation EqualLoc) {
Douglas Gregor71a57182009-06-22 23:20:33 +0000349 if (!param)
350 return;
Mike Stump11289f42009-09-09 15:08:12 +0000351
John McCall48871652010-08-21 09:40:31 +0000352 ParmVarDecl *Param = cast<ParmVarDecl>(param);
Anders Carlsson84613c42009-06-12 16:51:40 +0000353 Param->setInvalidDecl();
Anders Carlsson84613c42009-06-12 16:51:40 +0000354 UnparsedDefaultArgLocs.erase(Param);
Serge Pavlovb4b35782014-07-22 01:54:49 +0000355 Param->setDefaultArg(new(Context)
Fariborz Jahanian7bd22e92014-10-01 18:03:51 +0000356 OpaqueValueExpr(EqualLoc,
357 Param->getType().getNonReferenceType(),
358 VK_RValue));
Douglas Gregor4d87df52008-12-16 21:30:33 +0000359}
360
Douglas Gregorcaa8ace2008-05-07 04:49:29 +0000361/// CheckExtraCXXDefaultArguments - Check for any extra default
362/// arguments in the declarator, which is not a function declaration
363/// or definition and therefore is not permitted to have default
364/// arguments. This routine should be invoked for every declarator
365/// that is not a function declaration or definition.
366void Sema::CheckExtraCXXDefaultArguments(Declarator &D) {
367 // C++ [dcl.fct.default]p3
368 // A default argument expression shall be specified only in the
369 // parameter-declaration-clause of a function declaration or in a
370 // template-parameter (14.1). It shall not be specified for a
371 // parameter pack. If it is specified in a
372 // parameter-declaration-clause, it shall not occur within a
373 // declarator or abstract-declarator of a parameter-declaration.
Richard Smith5afcdf3f2013-03-06 01:37:38 +0000374 bool MightBeFunction = D.isFunctionDeclarationContext();
Chris Lattner83f095c2009-03-28 19:18:32 +0000375 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
Douglas Gregorcaa8ace2008-05-07 04:49:29 +0000376 DeclaratorChunk &chunk = D.getTypeObject(i);
377 if (chunk.Kind == DeclaratorChunk::Function) {
Richard Smith5afcdf3f2013-03-06 01:37:38 +0000378 if (MightBeFunction) {
379 // This is a function declaration. It can have default arguments, but
380 // keep looking in case its return type is a function type with default
381 // arguments.
382 MightBeFunction = false;
383 continue;
384 }
Alp Tokerc5350722014-02-26 22:27:52 +0000385 for (unsigned argIdx = 0, e = chunk.Fun.NumParams; argIdx != e;
386 ++argIdx) {
387 ParmVarDecl *Param = cast<ParmVarDecl>(chunk.Fun.Params[argIdx].Param);
Douglas Gregor58354032008-12-24 00:01:03 +0000388 if (Param->hasUnparsedDefaultArg()) {
Alp Tokerc5350722014-02-26 22:27:52 +0000389 CachedTokens *Toks = chunk.Fun.Params[argIdx].DefaultArgTokens;
Douglas Gregor4d87df52008-12-16 21:30:33 +0000390 Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
Richard Smith5afcdf3f2013-03-06 01:37:38 +0000391 << SourceRange((*Toks)[1].getLocation(),
392 Toks->back().getLocation());
Douglas Gregor4d87df52008-12-16 21:30:33 +0000393 delete Toks;
Craig Topperc3ec1492014-05-26 06:22:03 +0000394 chunk.Fun.Params[argIdx].DefaultArgTokens = nullptr;
Douglas Gregor58354032008-12-24 00:01:03 +0000395 } else if (Param->getDefaultArg()) {
396 Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
397 << Param->getDefaultArg()->getSourceRange();
Craig Topperc3ec1492014-05-26 06:22:03 +0000398 Param->setDefaultArg(nullptr);
Douglas Gregorcaa8ace2008-05-07 04:49:29 +0000399 }
400 }
Richard Smith5afcdf3f2013-03-06 01:37:38 +0000401 } else if (chunk.Kind != DeclaratorChunk::Paren) {
402 MightBeFunction = false;
Douglas Gregorcaa8ace2008-05-07 04:49:29 +0000403 }
404 }
405}
406
David Majnemer502b0ed2013-06-25 23:09:30 +0000407static bool functionDeclHasDefaultArgument(const FunctionDecl *FD) {
408 for (unsigned NumParams = FD->getNumParams(); NumParams > 0; --NumParams) {
409 const ParmVarDecl *PVD = FD->getParamDecl(NumParams-1);
410 if (!PVD->hasDefaultArg())
411 return false;
412 if (!PVD->hasInheritedDefaultArg())
413 return true;
414 }
415 return false;
416}
417
Craig Toppere4794282012-09-21 04:33:26 +0000418/// MergeCXXFunctionDecl - Merge two declarations of the same C++
419/// function, once we already know that they have the same
420/// type. Subroutine of MergeFunctionDecl. Returns true if there was an
421/// error, false otherwise.
James Molloye9430032012-03-13 08:55:35 +0000422bool Sema::MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old,
423 Scope *S) {
Douglas Gregor75a45ba2009-02-16 17:45:42 +0000424 bool Invalid = false;
425
Chris Lattner199abbc2008-04-08 05:04:30 +0000426 // C++ [dcl.fct.default]p4:
Chris Lattner199abbc2008-04-08 05:04:30 +0000427 // For non-template functions, default arguments can be added in
428 // later declarations of a function in the same
429 // scope. Declarations in different scopes have completely
430 // distinct sets of default arguments. That is, declarations in
431 // inner scopes do not acquire default arguments from
432 // declarations in outer scopes, and vice versa. In a given
433 // function declaration, all parameters subsequent to a
434 // parameter with a default argument shall have default
435 // arguments supplied in this or previous declarations. A
436 // default argument shall not be redefined by a later
437 // declaration (not even to the same value).
Douglas Gregorc732aba2009-09-11 18:44:32 +0000438 //
439 // C++ [dcl.fct.default]p6:
Richard Smith541b38b2013-09-20 01:15:31 +0000440 // Except for member functions of class templates, the default arguments
441 // in a member function definition that appears outside of the class
442 // definition are added to the set of default arguments provided by the
Douglas Gregorc732aba2009-09-11 18:44:32 +0000443 // member function declaration in the class definition.
Chris Lattner199abbc2008-04-08 05:04:30 +0000444 for (unsigned p = 0, NumParams = Old->getNumParams(); p < NumParams; ++p) {
445 ParmVarDecl *OldParam = Old->getParamDecl(p);
446 ParmVarDecl *NewParam = New->getParamDecl(p);
447
James Molloye9430032012-03-13 08:55:35 +0000448 bool OldParamHasDfl = OldParam->hasDefaultArg();
449 bool NewParamHasDfl = NewParam->hasDefaultArg();
450
Richard Smith541b38b2013-09-20 01:15:31 +0000451 // The declaration context corresponding to the scope is the semantic
452 // parent, unless this is a local function declaration, in which case
453 // it is that surrounding function.
Richard Smith5971e8c2014-08-27 22:31:34 +0000454 DeclContext *ScopeDC = New->isLocalExternDecl()
455 ? New->getLexicalDeclContext()
456 : New->getDeclContext();
457 if (S && !isDeclInScope(Old, ScopeDC, S) &&
Richard Smith541b38b2013-09-20 01:15:31 +0000458 !New->getDeclContext()->isRecord())
James Molloye9430032012-03-13 08:55:35 +0000459 // Ignore default parameters of old decl if they are not in
Richard Smith541b38b2013-09-20 01:15:31 +0000460 // the same scope and this is not an out-of-line definition of
461 // a member function.
James Molloye9430032012-03-13 08:55:35 +0000462 OldParamHasDfl = false;
Richard Smith5971e8c2014-08-27 22:31:34 +0000463 if (New->isLocalExternDecl() != Old->isLocalExternDecl())
464 // If only one of these is a local function declaration, then they are
465 // declared in different scopes, even though isDeclInScope may think
466 // they're in the same scope. (If both are local, the scope check is
467 // sufficent, and if neither is local, then they are in the same scope.)
468 OldParamHasDfl = false;
James Molloye9430032012-03-13 08:55:35 +0000469
470 if (OldParamHasDfl && NewParamHasDfl) {
Francois Pichet8cb243a2011-04-10 04:58:30 +0000471
Francois Pichet53fe2bb2011-04-10 03:03:52 +0000472 unsigned DiagDefaultParamID =
473 diag::err_param_default_argument_redefinition;
474
475 // MSVC accepts that default parameters be redefined for member functions
476 // of template class. The new default parameter's value is ignored.
477 Invalid = true;
David Blaikiebbafb8a2012-03-11 07:00:24 +0000478 if (getLangOpts().MicrosoftExt) {
Francois Pichet53fe2bb2011-04-10 03:03:52 +0000479 CXXMethodDecl* MD = dyn_cast<CXXMethodDecl>(New);
480 if (MD && MD->getParent()->getDescribedClassTemplate()) {
Francois Pichet8cb243a2011-04-10 04:58:30 +0000481 // Merge the old default argument into the new parameter.
482 NewParam->setHasInheritedDefaultArg();
483 if (OldParam->hasUninstantiatedDefaultArg())
484 NewParam->setUninstantiatedDefaultArg(
485 OldParam->getUninstantiatedDefaultArg());
486 else
487 NewParam->setDefaultArg(OldParam->getInit());
Richard Smith1b98ccc2014-07-19 01:39:17 +0000488 DiagDefaultParamID = diag::ext_param_default_argument_redefinition;
Francois Pichet53fe2bb2011-04-10 03:03:52 +0000489 Invalid = false;
490 }
491 }
Douglas Gregor08dc5842010-01-13 00:12:48 +0000492
Francois Pichet8cb243a2011-04-10 04:58:30 +0000493 // FIXME: If we knew where the '=' was, we could easily provide a fix-it
494 // hint here. Alternatively, we could walk the type-source information
495 // for NewParam to find the last source location in the type... but it
496 // isn't worth the effort right now. This is the kind of test case that
497 // is hard to get right:
Douglas Gregor08dc5842010-01-13 00:12:48 +0000498 // int f(int);
499 // void g(int (*fp)(int) = f);
500 // void g(int (*fp)(int) = &f);
Francois Pichet53fe2bb2011-04-10 03:03:52 +0000501 Diag(NewParam->getLocation(), DiagDefaultParamID)
Douglas Gregor08dc5842010-01-13 00:12:48 +0000502 << NewParam->getDefaultArgRange();
Douglas Gregorc732aba2009-09-11 18:44:32 +0000503
504 // Look for the function declaration where the default argument was
505 // actually written, which may be a declaration prior to Old.
Douglas Gregorec9fd132012-01-14 16:38:05 +0000506 for (FunctionDecl *Older = Old->getPreviousDecl();
507 Older; Older = Older->getPreviousDecl()) {
Douglas Gregorc732aba2009-09-11 18:44:32 +0000508 if (!Older->getParamDecl(p)->hasDefaultArg())
509 break;
510
511 OldParam = Older->getParamDecl(p);
512 }
513
514 Diag(OldParam->getLocation(), diag::note_previous_definition)
515 << OldParam->getDefaultArgRange();
James Molloye9430032012-03-13 08:55:35 +0000516 } else if (OldParamHasDfl) {
John McCalle61b02b2010-05-04 01:53:42 +0000517 // Merge the old default argument into the new parameter.
518 // It's important to use getInit() here; getDefaultArg()
John McCall5d413782010-12-06 08:20:24 +0000519 // strips off any top-level ExprWithCleanups.
John McCallf3cd6652010-03-12 18:31:32 +0000520 NewParam->setHasInheritedDefaultArg();
Douglas Gregor4f15f4d2009-09-17 19:51:30 +0000521 if (OldParam->hasUninstantiatedDefaultArg())
522 NewParam->setUninstantiatedDefaultArg(
523 OldParam->getUninstantiatedDefaultArg());
524 else
John McCalle61b02b2010-05-04 01:53:42 +0000525 NewParam->setDefaultArg(OldParam->getInit());
James Molloye9430032012-03-13 08:55:35 +0000526 } else if (NewParamHasDfl) {
Douglas Gregorc732aba2009-09-11 18:44:32 +0000527 if (New->getDescribedFunctionTemplate()) {
528 // Paragraph 4, quoted above, only applies to non-template functions.
529 Diag(NewParam->getLocation(),
530 diag::err_param_default_argument_template_redecl)
531 << NewParam->getDefaultArgRange();
532 Diag(Old->getLocation(), diag::note_template_prev_declaration)
533 << false;
Douglas Gregor62e10f02009-10-13 17:02:54 +0000534 } else if (New->getTemplateSpecializationKind()
535 != TSK_ImplicitInstantiation &&
536 New->getTemplateSpecializationKind() != TSK_Undeclared) {
537 // C++ [temp.expr.spec]p21:
538 // Default function arguments shall not be specified in a declaration
539 // or a definition for one of the following explicit specializations:
540 // - the explicit specialization of a function template;
Douglas Gregor3362bde2009-10-13 23:52:38 +0000541 // - the explicit specialization of a member function template;
542 // - the explicit specialization of a member function of a class
Douglas Gregor62e10f02009-10-13 17:02:54 +0000543 // template where the class template specialization to which the
544 // member function specialization belongs is implicitly
545 // instantiated.
546 Diag(NewParam->getLocation(), diag::err_template_spec_default_arg)
547 << (New->getTemplateSpecializationKind() ==TSK_ExplicitSpecialization)
548 << New->getDeclName()
549 << NewParam->getDefaultArgRange();
Douglas Gregorc732aba2009-09-11 18:44:32 +0000550 } else if (New->getDeclContext()->isDependentContext()) {
551 // C++ [dcl.fct.default]p6 (DR217):
552 // Default arguments for a member function of a class template shall
553 // be specified on the initial declaration of the member function
554 // within the class template.
555 //
556 // Reading the tea leaves a bit in DR217 and its reference to DR205
557 // leads me to the conclusion that one cannot add default function
558 // arguments for an out-of-line definition of a member function of a
559 // dependent type.
560 int WhichKind = 2;
561 if (CXXRecordDecl *Record
562 = dyn_cast<CXXRecordDecl>(New->getDeclContext())) {
563 if (Record->getDescribedClassTemplate())
564 WhichKind = 0;
565 else if (isa<ClassTemplatePartialSpecializationDecl>(Record))
566 WhichKind = 1;
567 else
568 WhichKind = 2;
569 }
570
571 Diag(NewParam->getLocation(),
572 diag::err_param_default_argument_member_template_redecl)
573 << WhichKind
574 << NewParam->getDefaultArgRange();
575 }
Chris Lattner199abbc2008-04-08 05:04:30 +0000576 }
577 }
578
Richard Smith58c3cc12012-11-28 03:45:24 +0000579 // DR1344: If a default argument is added outside a class definition and that
580 // default argument makes the function a special member function, the program
581 // is ill-formed. This can only happen for constructors.
582 if (isa<CXXConstructorDecl>(New) &&
583 New->getMinRequiredArguments() < Old->getMinRequiredArguments()) {
584 CXXSpecialMember NewSM = getSpecialMember(cast<CXXMethodDecl>(New)),
585 OldSM = getSpecialMember(cast<CXXMethodDecl>(Old));
586 if (NewSM != OldSM) {
587 ParmVarDecl *NewParam = New->getParamDecl(New->getMinRequiredArguments());
588 assert(NewParam->hasDefaultArg());
589 Diag(NewParam->getLocation(), diag::err_default_arg_makes_ctor_special)
590 << NewParam->getDefaultArgRange() << NewSM;
591 Diag(Old->getLocation(), diag::note_previous_declaration);
592 }
593 }
594
David Majnemeree4f4022014-03-30 06:44:54 +0000595 const FunctionDecl *Def;
Richard Smith5b8b3db2012-02-20 23:28:05 +0000596 // C++11 [dcl.constexpr]p1: If any declaration of a function or function
Richard Smitheb3c10c2011-10-01 02:31:28 +0000597 // template has a constexpr specifier then all its declarations shall
Richard Smith5b8b3db2012-02-20 23:28:05 +0000598 // contain the constexpr specifier.
Richard Smitheb3c10c2011-10-01 02:31:28 +0000599 if (New->isConstexpr() != Old->isConstexpr()) {
600 Diag(New->getLocation(), diag::err_constexpr_redecl_mismatch)
601 << New << New->isConstexpr();
602 Diag(Old->getLocation(), diag::note_previous_declaration);
603 Invalid = true;
David Majnemeree4f4022014-03-30 06:44:54 +0000604 } else if (!Old->isInlined() && New->isInlined() && Old->isDefined(Def)) {
605 // C++11 [dcl.fcn.spec]p4:
606 // If the definition of a function appears in a translation unit before its
607 // first declaration as inline, the program is ill-formed.
608 Diag(New->getLocation(), diag::err_inline_decl_follows_def) << New;
609 Diag(Def->getLocation(), diag::note_previous_definition);
610 Invalid = true;
Richard Smitheb3c10c2011-10-01 02:31:28 +0000611 }
612
David Majnemer502b0ed2013-06-25 23:09:30 +0000613 // C++11 [dcl.fct.default]p4: If a friend declaration specifies a default
NAKAMURA Takumi3e7db842013-07-17 17:57:52 +0000614 // argument expression, that declaration shall be a definition and shall be
David Majnemer502b0ed2013-06-25 23:09:30 +0000615 // the only declaration of the function or function template in the
616 // translation unit.
617 if (Old->getFriendObjectKind() == Decl::FOK_Undeclared &&
618 functionDeclHasDefaultArgument(Old)) {
619 Diag(New->getLocation(), diag::err_friend_decl_with_def_arg_redeclared);
620 Diag(Old->getLocation(), diag::note_previous_declaration);
621 Invalid = true;
622 }
623
Douglas Gregorf40863c2010-02-12 07:32:17 +0000624 if (CheckEquivalentExceptionSpec(Old, New))
Sebastian Redl4f4d7b52009-07-04 11:39:00 +0000625 Invalid = true;
Sebastian Redl4f4d7b52009-07-04 11:39:00 +0000626
Douglas Gregor75a45ba2009-02-16 17:45:42 +0000627 return Invalid;
Chris Lattner199abbc2008-04-08 05:04:30 +0000628}
629
Sebastian Redlfa453cf2011-03-12 11:50:43 +0000630/// \brief Merge the exception specifications of two variable declarations.
631///
632/// This is called when there's a redeclaration of a VarDecl. The function
633/// checks if the redeclaration might have an exception specification and
634/// validates compatibility and merges the specs if necessary.
635void Sema::MergeVarDeclExceptionSpecs(VarDecl *New, VarDecl *Old) {
636 // Shortcut if exceptions are disabled.
David Blaikiebbafb8a2012-03-11 07:00:24 +0000637 if (!getLangOpts().CXXExceptions)
Sebastian Redlfa453cf2011-03-12 11:50:43 +0000638 return;
639
640 assert(Context.hasSameType(New->getType(), Old->getType()) &&
641 "Should only be called if types are otherwise the same.");
642
643 QualType NewType = New->getType();
644 QualType OldType = Old->getType();
645
646 // We're only interested in pointers and references to functions, as well
647 // as pointers to member functions.
648 if (const ReferenceType *R = NewType->getAs<ReferenceType>()) {
649 NewType = R->getPointeeType();
650 OldType = OldType->getAs<ReferenceType>()->getPointeeType();
651 } else if (const PointerType *P = NewType->getAs<PointerType>()) {
652 NewType = P->getPointeeType();
653 OldType = OldType->getAs<PointerType>()->getPointeeType();
654 } else if (const MemberPointerType *M = NewType->getAs<MemberPointerType>()) {
655 NewType = M->getPointeeType();
656 OldType = OldType->getAs<MemberPointerType>()->getPointeeType();
657 }
658
659 if (!NewType->isFunctionProtoType())
660 return;
661
662 // There's lots of special cases for functions. For function pointers, system
663 // libraries are hopefully not as broken so that we don't need these
664 // workarounds.
665 if (CheckEquivalentExceptionSpec(
666 OldType->getAs<FunctionProtoType>(), Old->getLocation(),
667 NewType->getAs<FunctionProtoType>(), New->getLocation())) {
668 New->setInvalidDecl();
669 }
670}
671
Chris Lattner199abbc2008-04-08 05:04:30 +0000672/// CheckCXXDefaultArguments - Verify that the default arguments for a
673/// function declaration are well-formed according to C++
674/// [dcl.fct.default].
675void Sema::CheckCXXDefaultArguments(FunctionDecl *FD) {
676 unsigned NumParams = FD->getNumParams();
677 unsigned p;
678
679 // Find first parameter with a default argument
680 for (p = 0; p < NumParams; ++p) {
681 ParmVarDecl *Param = FD->getParamDecl(p);
Richard Smith3cb4c632013-04-17 16:25:20 +0000682 if (Param->hasDefaultArg())
Chris Lattner199abbc2008-04-08 05:04:30 +0000683 break;
684 }
685
686 // C++ [dcl.fct.default]p4:
687 // In a given function declaration, all parameters
688 // subsequent to a parameter with a default argument shall
689 // have default arguments supplied in this or previous
690 // declarations. A default argument shall not be redefined
691 // by a later declaration (not even to the same value).
692 unsigned LastMissingDefaultArg = 0;
Mike Stump11289f42009-09-09 15:08:12 +0000693 for (; p < NumParams; ++p) {
Chris Lattner199abbc2008-04-08 05:04:30 +0000694 ParmVarDecl *Param = FD->getParamDecl(p);
Anders Carlsson5a532382009-08-25 01:23:32 +0000695 if (!Param->hasDefaultArg()) {
Douglas Gregor4d87df52008-12-16 21:30:33 +0000696 if (Param->isInvalidDecl())
697 /* We already complained about this parameter. */;
698 else if (Param->getIdentifier())
Mike Stump11289f42009-09-09 15:08:12 +0000699 Diag(Param->getLocation(),
Chris Lattner3b054132008-11-19 05:08:23 +0000700 diag::err_param_default_argument_missing_name)
Chris Lattnerb91fd172008-11-19 07:32:16 +0000701 << Param->getIdentifier();
Chris Lattner199abbc2008-04-08 05:04:30 +0000702 else
Mike Stump11289f42009-09-09 15:08:12 +0000703 Diag(Param->getLocation(),
Chris Lattner199abbc2008-04-08 05:04:30 +0000704 diag::err_param_default_argument_missing);
Mike Stump11289f42009-09-09 15:08:12 +0000705
Chris Lattner199abbc2008-04-08 05:04:30 +0000706 LastMissingDefaultArg = p;
707 }
708 }
709
710 if (LastMissingDefaultArg > 0) {
711 // Some default arguments were missing. Clear out all of the
712 // default arguments up to (and including) the last missing
713 // default argument, so that we leave the function parameters
714 // in a semantically valid state.
715 for (p = 0; p <= LastMissingDefaultArg; ++p) {
716 ParmVarDecl *Param = FD->getParamDecl(p);
Anders Carlsson84613c42009-06-12 16:51:40 +0000717 if (Param->hasDefaultArg()) {
Craig Topperc3ec1492014-05-26 06:22:03 +0000718 Param->setDefaultArg(nullptr);
Chris Lattner199abbc2008-04-08 05:04:30 +0000719 }
720 }
721 }
722}
Douglas Gregor556877c2008-04-13 21:30:24 +0000723
Richard Smitheb3c10c2011-10-01 02:31:28 +0000724// CheckConstexprParameterTypes - Check whether a function's parameter types
725// are all literal types. If so, return true. If not, produce a suitable
Richard Smith3607ffe2012-02-13 03:54:03 +0000726// diagnostic and return false.
727static bool CheckConstexprParameterTypes(Sema &SemaRef,
728 const FunctionDecl *FD) {
Richard Smitheb3c10c2011-10-01 02:31:28 +0000729 unsigned ArgIndex = 0;
730 const FunctionProtoType *FT = FD->getType()->getAs<FunctionProtoType>();
Alp Toker9cacbab2014-01-20 20:26:09 +0000731 for (FunctionProtoType::param_type_iterator i = FT->param_type_begin(),
732 e = FT->param_type_end();
733 i != e; ++i, ++ArgIndex) {
Richard Smitheb3c10c2011-10-01 02:31:28 +0000734 const ParmVarDecl *PD = FD->getParamDecl(ArgIndex);
735 SourceLocation ParamLoc = PD->getLocation();
736 if (!(*i)->isDependentType() &&
Richard Smith3607ffe2012-02-13 03:54:03 +0000737 SemaRef.RequireLiteralType(ParamLoc, *i,
Douglas Gregora6c5abb2012-05-04 16:48:41 +0000738 diag::err_constexpr_non_literal_param,
739 ArgIndex+1, PD->getSourceRange(),
740 isa<CXXConstructorDecl>(FD)))
Richard Smitheb3c10c2011-10-01 02:31:28 +0000741 return false;
Richard Smitheb3c10c2011-10-01 02:31:28 +0000742 }
Joao Matose9a3ed42012-08-31 22:18:20 +0000743 return true;
744}
745
746/// \brief Get diagnostic %select index for tag kind for
747/// record diagnostic message.
748/// WARNING: Indexes apply to particular diagnostics only!
749///
750/// \returns diagnostic %select index.
Joao Matosa5c42e92012-09-01 00:13:24 +0000751static unsigned getRecordDiagFromTagKind(TagTypeKind Tag) {
Joao Matose9a3ed42012-08-31 22:18:20 +0000752 switch (Tag) {
Joao Matosa5c42e92012-09-01 00:13:24 +0000753 case TTK_Struct: return 0;
754 case TTK_Interface: return 1;
755 case TTK_Class: return 2;
756 default: llvm_unreachable("Invalid tag kind for record diagnostic!");
Joao Matose9a3ed42012-08-31 22:18:20 +0000757 }
Joao Matose9a3ed42012-08-31 22:18:20 +0000758}
759
760// CheckConstexprFunctionDecl - Check whether a function declaration satisfies
761// the requirements of a constexpr function definition or a constexpr
762// constructor definition. If so, return true. If not, produce appropriate
Richard Smith3607ffe2012-02-13 03:54:03 +0000763// diagnostics and return false.
Richard Smitheb3c10c2011-10-01 02:31:28 +0000764//
Richard Smith3607ffe2012-02-13 03:54:03 +0000765// This implements C++11 [dcl.constexpr]p3,4, as amended by DR1360.
766bool Sema::CheckConstexprFunctionDecl(const FunctionDecl *NewFD) {
Richard Smith7971b692012-01-13 04:54:00 +0000767 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
768 if (MD && MD->isInstance()) {
Richard Smith3607ffe2012-02-13 03:54:03 +0000769 // C++11 [dcl.constexpr]p4:
770 // The definition of a constexpr constructor shall satisfy the following
771 // constraints:
Richard Smitheb3c10c2011-10-01 02:31:28 +0000772 // - the class shall not have any virtual base classes;
Joao Matose9a3ed42012-08-31 22:18:20 +0000773 const CXXRecordDecl *RD = MD->getParent();
774 if (RD->getNumVBases()) {
775 Diag(NewFD->getLocation(), diag::err_constexpr_virtual_base)
776 << isa<CXXConstructorDecl>(NewFD)
777 << getRecordDiagFromTagKind(RD->getTagKind()) << RD->getNumVBases();
Aaron Ballman445a9392014-03-13 16:15:17 +0000778 for (const auto &I : RD->vbases())
779 Diag(I.getLocStart(),
780 diag::note_constexpr_virtual_base_here) << I.getSourceRange();
Richard Smitheb3c10c2011-10-01 02:31:28 +0000781 return false;
782 }
Richard Smith7971b692012-01-13 04:54:00 +0000783 }
784
785 if (!isa<CXXConstructorDecl>(NewFD)) {
786 // C++11 [dcl.constexpr]p3:
Richard Smitheb3c10c2011-10-01 02:31:28 +0000787 // The definition of a constexpr function shall satisfy the following
788 // constraints:
789 // - it shall not be virtual;
790 const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD);
791 if (Method && Method->isVirtual()) {
Richard Smith3607ffe2012-02-13 03:54:03 +0000792 Diag(NewFD->getLocation(), diag::err_constexpr_virtual);
Richard Smitheb3c10c2011-10-01 02:31:28 +0000793
Richard Smith3607ffe2012-02-13 03:54:03 +0000794 // If it's not obvious why this function is virtual, find an overridden
795 // function which uses the 'virtual' keyword.
796 const CXXMethodDecl *WrittenVirtual = Method;
797 while (!WrittenVirtual->isVirtualAsWritten())
798 WrittenVirtual = *WrittenVirtual->begin_overridden_methods();
799 if (WrittenVirtual != Method)
800 Diag(WrittenVirtual->getLocation(),
801 diag::note_overridden_virtual_function);
Richard Smitheb3c10c2011-10-01 02:31:28 +0000802 return false;
803 }
804
805 // - its return type shall be a literal type;
Alp Toker314cc812014-01-25 16:55:45 +0000806 QualType RT = NewFD->getReturnType();
Richard Smitheb3c10c2011-10-01 02:31:28 +0000807 if (!RT->isDependentType() &&
Richard Smith3607ffe2012-02-13 03:54:03 +0000808 RequireLiteralType(NewFD->getLocation(), RT,
Douglas Gregora6c5abb2012-05-04 16:48:41 +0000809 diag::err_constexpr_non_literal_return))
Richard Smitheb3c10c2011-10-01 02:31:28 +0000810 return false;
Richard Smitheb3c10c2011-10-01 02:31:28 +0000811 }
812
Richard Smith7971b692012-01-13 04:54:00 +0000813 // - each of its parameter types shall be a literal type;
Richard Smith3607ffe2012-02-13 03:54:03 +0000814 if (!CheckConstexprParameterTypes(*this, NewFD))
Richard Smith7971b692012-01-13 04:54:00 +0000815 return false;
816
Richard Smitheb3c10c2011-10-01 02:31:28 +0000817 return true;
818}
819
820/// Check the given declaration statement is legal within a constexpr function
Richard Smithd9f663b2013-04-22 15:31:51 +0000821/// body. C++11 [dcl.constexpr]p3,p4, and C++1y [dcl.constexpr]p3.
Richard Smitheb3c10c2011-10-01 02:31:28 +0000822///
Richard Smithd9f663b2013-04-22 15:31:51 +0000823/// \return true if the body is OK (maybe only as an extension), false if we
824/// have diagnosed a problem.
Richard Smitheb3c10c2011-10-01 02:31:28 +0000825static bool CheckConstexprDeclStmt(Sema &SemaRef, const FunctionDecl *Dcl,
Richard Smithd9f663b2013-04-22 15:31:51 +0000826 DeclStmt *DS, SourceLocation &Cxx1yLoc) {
827 // C++11 [dcl.constexpr]p3 and p4:
Richard Smitheb3c10c2011-10-01 02:31:28 +0000828 // The definition of a constexpr function(p3) or constructor(p4) [...] shall
829 // contain only
Aaron Ballman535bbcc2014-03-14 17:01:24 +0000830 for (const auto *DclIt : DS->decls()) {
831 switch (DclIt->getKind()) {
Richard Smitheb3c10c2011-10-01 02:31:28 +0000832 case Decl::StaticAssert:
833 case Decl::Using:
834 case Decl::UsingShadow:
835 case Decl::UsingDirective:
836 case Decl::UnresolvedUsingTypename:
Richard Smithd9f663b2013-04-22 15:31:51 +0000837 case Decl::UnresolvedUsingValue:
Richard Smitheb3c10c2011-10-01 02:31:28 +0000838 // - static_assert-declarations
839 // - using-declarations,
840 // - using-directives,
841 continue;
842
843 case Decl::Typedef:
844 case Decl::TypeAlias: {
845 // - typedef declarations and alias-declarations that do not define
846 // classes or enumerations,
Aaron Ballman535bbcc2014-03-14 17:01:24 +0000847 const auto *TN = cast<TypedefNameDecl>(DclIt);
Richard Smitheb3c10c2011-10-01 02:31:28 +0000848 if (TN->getUnderlyingType()->isVariablyModifiedType()) {
849 // Don't allow variably-modified types in constexpr functions.
850 TypeLoc TL = TN->getTypeSourceInfo()->getTypeLoc();
851 SemaRef.Diag(TL.getBeginLoc(), diag::err_constexpr_vla)
852 << TL.getSourceRange() << TL.getType()
853 << isa<CXXConstructorDecl>(Dcl);
854 return false;
855 }
856 continue;
857 }
858
859 case Decl::Enum:
860 case Decl::CXXRecord:
Richard Smithd9f663b2013-04-22 15:31:51 +0000861 // C++1y allows types to be defined, not just declared.
Aaron Ballman535bbcc2014-03-14 17:01:24 +0000862 if (cast<TagDecl>(DclIt)->isThisDeclarationADefinition())
Richard Smithd9f663b2013-04-22 15:31:51 +0000863 SemaRef.Diag(DS->getLocStart(),
Aaron Ballmandd69ef32014-08-19 15:55:55 +0000864 SemaRef.getLangOpts().CPlusPlus14
Richard Smithd9f663b2013-04-22 15:31:51 +0000865 ? diag::warn_cxx11_compat_constexpr_type_definition
866 : diag::ext_constexpr_type_definition)
Richard Smitheb3c10c2011-10-01 02:31:28 +0000867 << isa<CXXConstructorDecl>(Dcl);
Richard Smitheb3c10c2011-10-01 02:31:28 +0000868 continue;
869
Richard Smithd9f663b2013-04-22 15:31:51 +0000870 case Decl::EnumConstant:
871 case Decl::IndirectField:
872 case Decl::ParmVar:
873 // These can only appear with other declarations which are banned in
874 // C++11 and permitted in C++1y, so ignore them.
875 continue;
876
877 case Decl::Var: {
878 // C++1y [dcl.constexpr]p3 allows anything except:
879 // a definition of a variable of non-literal type or of static or
880 // thread storage duration or for which no initialization is performed.
Aaron Ballman535bbcc2014-03-14 17:01:24 +0000881 const auto *VD = cast<VarDecl>(DclIt);
Richard Smithd9f663b2013-04-22 15:31:51 +0000882 if (VD->isThisDeclarationADefinition()) {
883 if (VD->isStaticLocal()) {
884 SemaRef.Diag(VD->getLocation(),
885 diag::err_constexpr_local_var_static)
886 << isa<CXXConstructorDecl>(Dcl)
887 << (VD->getTLSKind() == VarDecl::TLS_Dynamic);
888 return false;
889 }
Richard Smith3da88fa2013-04-26 14:36:30 +0000890 if (!VD->getType()->isDependentType() &&
891 SemaRef.RequireLiteralType(
Richard Smithd9f663b2013-04-22 15:31:51 +0000892 VD->getLocation(), VD->getType(),
893 diag::err_constexpr_local_var_non_literal_type,
894 isa<CXXConstructorDecl>(Dcl)))
895 return false;
Richard Smithab44d5b2013-12-10 08:25:00 +0000896 if (!VD->getType()->isDependentType() &&
897 !VD->hasInit() && !VD->isCXXForRangeDecl()) {
Richard Smithd9f663b2013-04-22 15:31:51 +0000898 SemaRef.Diag(VD->getLocation(),
899 diag::err_constexpr_local_var_no_init)
900 << isa<CXXConstructorDecl>(Dcl);
901 return false;
902 }
903 }
904 SemaRef.Diag(VD->getLocation(),
Aaron Ballmandd69ef32014-08-19 15:55:55 +0000905 SemaRef.getLangOpts().CPlusPlus14
Richard Smithd9f663b2013-04-22 15:31:51 +0000906 ? diag::warn_cxx11_compat_constexpr_local_var
907 : diag::ext_constexpr_local_var)
Richard Smitheb3c10c2011-10-01 02:31:28 +0000908 << isa<CXXConstructorDecl>(Dcl);
Richard Smithd9f663b2013-04-22 15:31:51 +0000909 continue;
910 }
911
912 case Decl::NamespaceAlias:
913 case Decl::Function:
914 // These are disallowed in C++11 and permitted in C++1y. Allow them
915 // everywhere as an extension.
916 if (!Cxx1yLoc.isValid())
917 Cxx1yLoc = DS->getLocStart();
918 continue;
Richard Smitheb3c10c2011-10-01 02:31:28 +0000919
920 default:
921 SemaRef.Diag(DS->getLocStart(), diag::err_constexpr_body_invalid_stmt)
922 << isa<CXXConstructorDecl>(Dcl);
923 return false;
924 }
925 }
926
927 return true;
928}
929
930/// Check that the given field is initialized within a constexpr constructor.
931///
932/// \param Dcl The constexpr constructor being checked.
933/// \param Field The field being checked. This may be a member of an anonymous
934/// struct or union nested within the class being checked.
935/// \param Inits All declarations, including anonymous struct/union members and
936/// indirect members, for which any initialization was provided.
937/// \param Diagnosed Set to true if an error is produced.
938static void CheckConstexprCtorInitializer(Sema &SemaRef,
939 const FunctionDecl *Dcl,
940 FieldDecl *Field,
941 llvm::SmallSet<Decl*, 16> &Inits,
942 bool &Diagnosed) {
Eli Friedmanb13e64e2013-06-28 21:07:41 +0000943 if (Field->isInvalidDecl())
944 return;
945
Douglas Gregor556e5862011-10-10 17:22:13 +0000946 if (Field->isUnnamedBitfield())
947 return;
Richard Smith4d59eeb2012-02-09 06:40:58 +0000948
Richard Smithab44d5b2013-12-10 08:25:00 +0000949 // Anonymous unions with no variant members and empty anonymous structs do not
950 // need to be explicitly initialized. FIXME: Anonymous structs that contain no
951 // indirect fields don't need initializing.
Richard Smith4d59eeb2012-02-09 06:40:58 +0000952 if (Field->isAnonymousStructOrUnion() &&
Richard Smithab44d5b2013-12-10 08:25:00 +0000953 (Field->getType()->isUnionType()
954 ? !Field->getType()->getAsCXXRecordDecl()->hasVariantMembers()
955 : Field->getType()->getAsCXXRecordDecl()->isEmpty()))
Richard Smith4d59eeb2012-02-09 06:40:58 +0000956 return;
957
Richard Smitheb3c10c2011-10-01 02:31:28 +0000958 if (!Inits.count(Field)) {
959 if (!Diagnosed) {
960 SemaRef.Diag(Dcl->getLocation(), diag::err_constexpr_ctor_missing_init);
961 Diagnosed = true;
962 }
963 SemaRef.Diag(Field->getLocation(), diag::note_constexpr_ctor_missing_init);
964 } else if (Field->isAnonymousStructOrUnion()) {
965 const RecordDecl *RD = Field->getType()->castAs<RecordType>()->getDecl();
Aaron Ballmane8a8bae2014-03-08 20:12:42 +0000966 for (auto *I : RD->fields())
Richard Smitheb3c10c2011-10-01 02:31:28 +0000967 // If an anonymous union contains an anonymous struct of which any member
968 // is initialized, all members must be initialized.
Aaron Ballmane8a8bae2014-03-08 20:12:42 +0000969 if (!RD->isUnion() || Inits.count(I))
970 CheckConstexprCtorInitializer(SemaRef, Dcl, I, Inits, Diagnosed);
Richard Smitheb3c10c2011-10-01 02:31:28 +0000971 }
972}
973
Richard Smithd9f663b2013-04-22 15:31:51 +0000974/// Check the provided statement is allowed in a constexpr function
975/// definition.
976static bool
977CheckConstexprFunctionStmt(Sema &SemaRef, const FunctionDecl *Dcl, Stmt *S,
Robert Wilhelmb869a8f2013-08-10 12:33:24 +0000978 SmallVectorImpl<SourceLocation> &ReturnStmts,
Richard Smithd9f663b2013-04-22 15:31:51 +0000979 SourceLocation &Cxx1yLoc) {
980 // - its function-body shall be [...] a compound-statement that contains only
981 switch (S->getStmtClass()) {
982 case Stmt::NullStmtClass:
983 // - null statements,
984 return true;
985
986 case Stmt::DeclStmtClass:
987 // - static_assert-declarations
988 // - using-declarations,
989 // - using-directives,
990 // - typedef declarations and alias-declarations that do not define
991 // classes or enumerations,
992 if (!CheckConstexprDeclStmt(SemaRef, Dcl, cast<DeclStmt>(S), Cxx1yLoc))
993 return false;
994 return true;
995
996 case Stmt::ReturnStmtClass:
997 // - and exactly one return statement;
998 if (isa<CXXConstructorDecl>(Dcl)) {
999 // C++1y allows return statements in constexpr constructors.
1000 if (!Cxx1yLoc.isValid())
1001 Cxx1yLoc = S->getLocStart();
1002 return true;
1003 }
1004
1005 ReturnStmts.push_back(S->getLocStart());
1006 return true;
1007
1008 case Stmt::CompoundStmtClass: {
1009 // C++1y allows compound-statements.
1010 if (!Cxx1yLoc.isValid())
1011 Cxx1yLoc = S->getLocStart();
1012
1013 CompoundStmt *CompStmt = cast<CompoundStmt>(S);
Aaron Ballmanc7e4e212014-03-17 14:19:37 +00001014 for (auto *BodyIt : CompStmt->body()) {
1015 if (!CheckConstexprFunctionStmt(SemaRef, Dcl, BodyIt, ReturnStmts,
Richard Smithd9f663b2013-04-22 15:31:51 +00001016 Cxx1yLoc))
1017 return false;
1018 }
1019 return true;
1020 }
1021
1022 case Stmt::AttributedStmtClass:
1023 if (!Cxx1yLoc.isValid())
1024 Cxx1yLoc = S->getLocStart();
1025 return true;
1026
1027 case Stmt::IfStmtClass: {
1028 // C++1y allows if-statements.
1029 if (!Cxx1yLoc.isValid())
1030 Cxx1yLoc = S->getLocStart();
1031
1032 IfStmt *If = cast<IfStmt>(S);
1033 if (!CheckConstexprFunctionStmt(SemaRef, Dcl, If->getThen(), ReturnStmts,
1034 Cxx1yLoc))
1035 return false;
1036 if (If->getElse() &&
1037 !CheckConstexprFunctionStmt(SemaRef, Dcl, If->getElse(), ReturnStmts,
1038 Cxx1yLoc))
1039 return false;
1040 return true;
1041 }
1042
1043 case Stmt::WhileStmtClass:
1044 case Stmt::DoStmtClass:
1045 case Stmt::ForStmtClass:
1046 case Stmt::CXXForRangeStmtClass:
1047 case Stmt::ContinueStmtClass:
1048 // C++1y allows all of these. We don't allow them as extensions in C++11,
1049 // because they don't make sense without variable mutation.
Aaron Ballmandd69ef32014-08-19 15:55:55 +00001050 if (!SemaRef.getLangOpts().CPlusPlus14)
Richard Smithd9f663b2013-04-22 15:31:51 +00001051 break;
1052 if (!Cxx1yLoc.isValid())
1053 Cxx1yLoc = S->getLocStart();
1054 for (Stmt::child_range Children = S->children(); Children; ++Children)
1055 if (*Children &&
1056 !CheckConstexprFunctionStmt(SemaRef, Dcl, *Children, ReturnStmts,
1057 Cxx1yLoc))
1058 return false;
1059 return true;
1060
1061 case Stmt::SwitchStmtClass:
1062 case Stmt::CaseStmtClass:
1063 case Stmt::DefaultStmtClass:
1064 case Stmt::BreakStmtClass:
1065 // C++1y allows switch-statements, and since they don't need variable
1066 // mutation, we can reasonably allow them in C++11 as an extension.
1067 if (!Cxx1yLoc.isValid())
1068 Cxx1yLoc = S->getLocStart();
1069 for (Stmt::child_range Children = S->children(); Children; ++Children)
1070 if (*Children &&
1071 !CheckConstexprFunctionStmt(SemaRef, Dcl, *Children, ReturnStmts,
1072 Cxx1yLoc))
1073 return false;
1074 return true;
1075
1076 default:
1077 if (!isa<Expr>(S))
1078 break;
1079
1080 // C++1y allows expression-statements.
1081 if (!Cxx1yLoc.isValid())
1082 Cxx1yLoc = S->getLocStart();
1083 return true;
1084 }
1085
1086 SemaRef.Diag(S->getLocStart(), diag::err_constexpr_body_invalid_stmt)
1087 << isa<CXXConstructorDecl>(Dcl);
1088 return false;
1089}
1090
Richard Smitheb3c10c2011-10-01 02:31:28 +00001091/// Check the body for the given constexpr function declaration only contains
1092/// the permitted types of statement. C++11 [dcl.constexpr]p3,p4.
1093///
1094/// \return true if the body is OK, false if we have diagnosed a problem.
Richard Smith3607ffe2012-02-13 03:54:03 +00001095bool Sema::CheckConstexprFunctionBody(const FunctionDecl *Dcl, Stmt *Body) {
Richard Smitheb3c10c2011-10-01 02:31:28 +00001096 if (isa<CXXTryStmt>(Body)) {
Richard Smith74388b42012-02-04 00:33:54 +00001097 // C++11 [dcl.constexpr]p3:
Richard Smitheb3c10c2011-10-01 02:31:28 +00001098 // The definition of a constexpr function shall satisfy the following
1099 // constraints: [...]
1100 // - its function-body shall be = delete, = default, or a
1101 // compound-statement
1102 //
Richard Smith74388b42012-02-04 00:33:54 +00001103 // C++11 [dcl.constexpr]p4:
Richard Smitheb3c10c2011-10-01 02:31:28 +00001104 // In the definition of a constexpr constructor, [...]
1105 // - its function-body shall not be a function-try-block;
1106 Diag(Body->getLocStart(), diag::err_constexpr_function_try_block)
1107 << isa<CXXConstructorDecl>(Dcl);
1108 return false;
1109 }
1110
Dmitri Gribenkof8579502013-01-12 19:30:44 +00001111 SmallVector<SourceLocation, 4> ReturnStmts;
Richard Smithd9f663b2013-04-22 15:31:51 +00001112
1113 // - its function-body shall be [...] a compound-statement that contains only
1114 // [... list of cases ...]
1115 CompoundStmt *CompBody = cast<CompoundStmt>(Body);
1116 SourceLocation Cxx1yLoc;
Aaron Ballmanc7e4e212014-03-17 14:19:37 +00001117 for (auto *BodyIt : CompBody->body()) {
1118 if (!CheckConstexprFunctionStmt(*this, Dcl, BodyIt, ReturnStmts, Cxx1yLoc))
Richard Smithd9f663b2013-04-22 15:31:51 +00001119 return false;
Richard Smitheb3c10c2011-10-01 02:31:28 +00001120 }
1121
Richard Smithd9f663b2013-04-22 15:31:51 +00001122 if (Cxx1yLoc.isValid())
1123 Diag(Cxx1yLoc,
Aaron Ballmandd69ef32014-08-19 15:55:55 +00001124 getLangOpts().CPlusPlus14
Richard Smithd9f663b2013-04-22 15:31:51 +00001125 ? diag::warn_cxx11_compat_constexpr_body_invalid_stmt
1126 : diag::ext_constexpr_body_invalid_stmt)
1127 << isa<CXXConstructorDecl>(Dcl);
1128
Richard Smitheb3c10c2011-10-01 02:31:28 +00001129 if (const CXXConstructorDecl *Constructor
1130 = dyn_cast<CXXConstructorDecl>(Dcl)) {
1131 const CXXRecordDecl *RD = Constructor->getParent();
Richard Smith4d59eeb2012-02-09 06:40:58 +00001132 // DR1359:
1133 // - every non-variant non-static data member and base class sub-object
1134 // shall be initialized;
Richard Smithab44d5b2013-12-10 08:25:00 +00001135 // DR1460:
1136 // - if the class is a union having variant members, exactly one of them
Richard Smith4d59eeb2012-02-09 06:40:58 +00001137 // shall be initialized;
Richard Smitheb3c10c2011-10-01 02:31:28 +00001138 if (RD->isUnion()) {
Richard Smithab44d5b2013-12-10 08:25:00 +00001139 if (Constructor->getNumCtorInitializers() == 0 &&
1140 RD->hasVariantMembers()) {
Richard Smitheb3c10c2011-10-01 02:31:28 +00001141 Diag(Dcl->getLocation(), diag::err_constexpr_union_ctor_no_init);
1142 return false;
1143 }
Richard Smithf368fb42011-10-10 16:38:04 +00001144 } else if (!Constructor->isDependentContext() &&
1145 !Constructor->isDelegatingConstructor()) {
Richard Smitheb3c10c2011-10-01 02:31:28 +00001146 assert(RD->getNumVBases() == 0 && "constexpr ctor with virtual bases");
1147
1148 // Skip detailed checking if we have enough initializers, and we would
1149 // allow at most one initializer per member.
1150 bool AnyAnonStructUnionMembers = false;
1151 unsigned Fields = 0;
1152 for (CXXRecordDecl::field_iterator I = RD->field_begin(),
1153 E = RD->field_end(); I != E; ++I, ++Fields) {
David Blaikie2d7c57e2012-04-30 02:36:29 +00001154 if (I->isAnonymousStructOrUnion()) {
Richard Smitheb3c10c2011-10-01 02:31:28 +00001155 AnyAnonStructUnionMembers = true;
1156 break;
1157 }
1158 }
Richard Smithab44d5b2013-12-10 08:25:00 +00001159 // DR1460:
1160 // - if the class is a union-like class, but is not a union, for each of
1161 // its anonymous union members having variant members, exactly one of
1162 // them shall be initialized;
Richard Smitheb3c10c2011-10-01 02:31:28 +00001163 if (AnyAnonStructUnionMembers ||
1164 Constructor->getNumCtorInitializers() != RD->getNumBases() + Fields) {
1165 // Check initialization of non-static data members. Base classes are
1166 // always initialized so do not need to be checked. Dependent bases
1167 // might not have initializers in the member initializer list.
1168 llvm::SmallSet<Decl*, 16> Inits;
Aaron Ballman0ad78302014-03-13 17:34:31 +00001169 for (const auto *I: Constructor->inits()) {
1170 if (FieldDecl *FD = I->getMember())
Richard Smitheb3c10c2011-10-01 02:31:28 +00001171 Inits.insert(FD);
Aaron Ballman0ad78302014-03-13 17:34:31 +00001172 else if (IndirectFieldDecl *ID = I->getIndirectMember())
Richard Smitheb3c10c2011-10-01 02:31:28 +00001173 Inits.insert(ID->chain_begin(), ID->chain_end());
1174 }
1175
1176 bool Diagnosed = false;
Aaron Ballmane8a8bae2014-03-08 20:12:42 +00001177 for (auto *I : RD->fields())
1178 CheckConstexprCtorInitializer(*this, Dcl, I, Inits, Diagnosed);
Richard Smitheb3c10c2011-10-01 02:31:28 +00001179 if (Diagnosed)
1180 return false;
1181 }
1182 }
Richard Smitheb3c10c2011-10-01 02:31:28 +00001183 } else {
1184 if (ReturnStmts.empty()) {
Richard Smithd9f663b2013-04-22 15:31:51 +00001185 // C++1y doesn't require constexpr functions to contain a 'return'
Richard Smith06ffb452014-04-22 23:14:23 +00001186 // statement. We still do, unless the return type might be void, because
Richard Smithd9f663b2013-04-22 15:31:51 +00001187 // otherwise if there's no return statement, the function cannot
1188 // be used in a core constant expression.
Aaron Ballmandd69ef32014-08-19 15:55:55 +00001189 bool OK = getLangOpts().CPlusPlus14 &&
Richard Smith06ffb452014-04-22 23:14:23 +00001190 (Dcl->getReturnType()->isVoidType() ||
1191 Dcl->getReturnType()->isDependentType());
Richard Smithd9f663b2013-04-22 15:31:51 +00001192 Diag(Dcl->getLocation(),
Richard Smith3da88fa2013-04-26 14:36:30 +00001193 OK ? diag::warn_cxx11_compat_constexpr_body_no_return
1194 : diag::err_constexpr_body_no_return);
1195 return OK;
Richard Smitheb3c10c2011-10-01 02:31:28 +00001196 }
1197 if (ReturnStmts.size() > 1) {
Richard Smithd9f663b2013-04-22 15:31:51 +00001198 Diag(ReturnStmts.back(),
Aaron Ballmandd69ef32014-08-19 15:55:55 +00001199 getLangOpts().CPlusPlus14
Richard Smithd9f663b2013-04-22 15:31:51 +00001200 ? diag::warn_cxx11_compat_constexpr_body_multiple_return
1201 : diag::ext_constexpr_body_multiple_return);
Richard Smitheb3c10c2011-10-01 02:31:28 +00001202 for (unsigned I = 0; I < ReturnStmts.size() - 1; ++I)
1203 Diag(ReturnStmts[I], diag::note_constexpr_body_previous_return);
Richard Smitheb3c10c2011-10-01 02:31:28 +00001204 }
1205 }
1206
Richard Smith74388b42012-02-04 00:33:54 +00001207 // C++11 [dcl.constexpr]p5:
1208 // if no function argument values exist such that the function invocation
1209 // substitution would produce a constant expression, the program is
1210 // ill-formed; no diagnostic required.
1211 // C++11 [dcl.constexpr]p3:
1212 // - every constructor call and implicit conversion used in initializing the
1213 // return value shall be one of those allowed in a constant expression.
1214 // C++11 [dcl.constexpr]p4:
1215 // - every constructor involved in initializing non-static data members and
1216 // base class sub-objects shall be a constexpr constructor.
Dmitri Gribenkof8579502013-01-12 19:30:44 +00001217 SmallVector<PartialDiagnosticAt, 8> Diags;
Richard Smith3607ffe2012-02-13 03:54:03 +00001218 if (!Expr::isPotentialConstantExpr(Dcl, Diags)) {
Richard Smithf86b5dc2012-12-09 05:55:43 +00001219 Diag(Dcl->getLocation(), diag::ext_constexpr_function_never_constant_expr)
Richard Smith253c2a32012-01-27 01:14:48 +00001220 << isa<CXXConstructorDecl>(Dcl);
1221 for (size_t I = 0, N = Diags.size(); I != N; ++I)
1222 Diag(Diags[I].first, Diags[I].second);
Richard Smithf86b5dc2012-12-09 05:55:43 +00001223 // Don't return false here: we allow this for compatibility in
1224 // system headers.
Richard Smith253c2a32012-01-27 01:14:48 +00001225 }
1226
Richard Smitheb3c10c2011-10-01 02:31:28 +00001227 return true;
1228}
1229
Douglas Gregor61956c42008-10-31 09:07:45 +00001230/// isCurrentClassName - Determine whether the identifier II is the
1231/// name of the class type currently being defined. In the case of
1232/// nested classes, this will only return true if II is the name of
1233/// the innermost class.
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +00001234bool Sema::isCurrentClassName(const IdentifierInfo &II, Scope *,
1235 const CXXScopeSpec *SS) {
David Blaikiebbafb8a2012-03-11 07:00:24 +00001236 assert(getLangOpts().CPlusPlus && "No class names in C!");
Douglas Gregor411e5ac2010-01-11 23:29:10 +00001237
Argyrios Kyrtzidis16ac9be2008-11-08 17:17:31 +00001238 CXXRecordDecl *CurDecl;
Douglas Gregor52537682009-03-19 00:18:19 +00001239 if (SS && SS->isSet() && !SS->isInvalid()) {
Douglas Gregore5bbb7d2009-08-21 22:16:40 +00001240 DeclContext *DC = computeDeclContext(*SS, true);
Argyrios Kyrtzidis16ac9be2008-11-08 17:17:31 +00001241 CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC);
1242 } else
1243 CurDecl = dyn_cast_or_null<CXXRecordDecl>(CurContext);
1244
Douglas Gregor1aa3edb2010-02-05 06:12:42 +00001245 if (CurDecl && CurDecl->getIdentifier())
Douglas Gregor61956c42008-10-31 09:07:45 +00001246 return &II == CurDecl->getIdentifier();
Benjamin Kramer8bf44352013-07-24 15:28:33 +00001247 return false;
Douglas Gregor61956c42008-10-31 09:07:45 +00001248}
1249
Richard Smithfb8b7b92013-10-15 00:00:26 +00001250/// \brief Determine whether the identifier II is a typo for the name of
1251/// the class type currently being defined. If so, update it to the identifier
1252/// that should have been used.
1253bool Sema::isCurrentClassNameTypo(IdentifierInfo *&II, const CXXScopeSpec *SS) {
1254 assert(getLangOpts().CPlusPlus && "No class names in C!");
1255
1256 if (!getLangOpts().SpellChecking)
1257 return false;
1258
1259 CXXRecordDecl *CurDecl;
1260 if (SS && SS->isSet() && !SS->isInvalid()) {
1261 DeclContext *DC = computeDeclContext(*SS, true);
1262 CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC);
1263 } else
1264 CurDecl = dyn_cast_or_null<CXXRecordDecl>(CurContext);
1265
1266 if (CurDecl && CurDecl->getIdentifier() && II != CurDecl->getIdentifier() &&
1267 3 * II->getName().edit_distance(CurDecl->getIdentifier()->getName())
1268 < II->getLength()) {
1269 II = CurDecl->getIdentifier();
1270 return true;
1271 }
1272
1273 return false;
1274}
1275
Douglas Gregordc974572012-11-10 07:24:09 +00001276/// \brief Determine whether the given class is a base class of the given
1277/// class, including looking at dependent bases.
1278static bool findCircularInheritance(const CXXRecordDecl *Class,
1279 const CXXRecordDecl *Current) {
1280 SmallVector<const CXXRecordDecl*, 8> Queue;
1281
1282 Class = Class->getCanonicalDecl();
1283 while (true) {
Aaron Ballman574705e2014-03-13 15:41:46 +00001284 for (const auto &I : Current->bases()) {
1285 CXXRecordDecl *Base = I.getType()->getAsCXXRecordDecl();
Douglas Gregordc974572012-11-10 07:24:09 +00001286 if (!Base)
1287 continue;
1288
1289 Base = Base->getDefinition();
1290 if (!Base)
1291 continue;
1292
1293 if (Base->getCanonicalDecl() == Class)
1294 return true;
1295
1296 Queue.push_back(Base);
1297 }
1298
1299 if (Queue.empty())
1300 return false;
1301
Robert Wilhelm25284cc2013-08-23 16:11:15 +00001302 Current = Queue.pop_back_val();
Douglas Gregordc974572012-11-10 07:24:09 +00001303 }
1304
1305 return false;
Douglas Gregor62004702012-11-10 01:18:17 +00001306}
1307
Hans Wennborg9bea9cc2014-06-25 18:25:57 +00001308/// \brief Perform propagation of DLL attributes from a derived class to a
1309/// templated base class for MS compatibility.
1310static void propagateDLLAttrToBaseClassTemplate(
1311 Sema &S, CXXRecordDecl *Class, Attr *ClassAttr,
1312 ClassTemplateSpecializationDecl *BaseTemplateSpec, SourceLocation BaseLoc) {
1313 if (getDLLAttr(
1314 BaseTemplateSpec->getSpecializedTemplate()->getTemplatedDecl())) {
1315 // If the base class template has a DLL attribute, don't try to change it.
1316 return;
1317 }
1318
1319 if (BaseTemplateSpec->getSpecializationKind() == TSK_Undeclared) {
1320 // If the base class is not already specialized, we can do the propagation.
1321 auto *NewAttr = cast<InheritableAttr>(ClassAttr->clone(S.getASTContext()));
1322 NewAttr->setInherited(true);
1323 BaseTemplateSpec->addAttr(NewAttr);
1324 return;
1325 }
1326
1327 bool DifferentAttribute = false;
1328 if (Attr *SpecializationAttr = getDLLAttr(BaseTemplateSpec)) {
1329 if (!SpecializationAttr->isInherited()) {
1330 // The template has previously been specialized or instantiated with an
1331 // explicit attribute. We should not try to change it.
1332 return;
1333 }
1334 if (SpecializationAttr->getKind() == ClassAttr->getKind()) {
1335 // The specialization already has the right attribute.
1336 return;
1337 }
1338 DifferentAttribute = true;
1339 }
1340
1341 // The template was previously instantiated or explicitly specialized without
1342 // a dll attribute, or the template was previously instantiated with a
1343 // different inherited attribute. It's too late for us to change the
1344 // attribute, so warn that this is unsupported.
1345 S.Diag(BaseLoc, diag::warn_attribute_dll_instantiated_base_class)
1346 << BaseTemplateSpec->isExplicitSpecialization() << DifferentAttribute;
1347 S.Diag(ClassAttr->getLocation(), diag::note_attribute);
1348 if (BaseTemplateSpec->isExplicitSpecialization()) {
1349 S.Diag(BaseTemplateSpec->getLocation(),
1350 diag::note_template_class_explicit_specialization_was_here)
1351 << BaseTemplateSpec;
1352 } else {
1353 S.Diag(BaseTemplateSpec->getPointOfInstantiation(),
1354 diag::note_template_class_instantiation_was_here)
1355 << BaseTemplateSpec;
1356 }
1357}
1358
Mike Stump11289f42009-09-09 15:08:12 +00001359/// \brief Check the validity of a C++ base class specifier.
Douglas Gregor463421d2009-03-03 04:44:36 +00001360///
1361/// \returns a new CXXBaseSpecifier if well-formed, emits diagnostics
1362/// and returns NULL otherwise.
1363CXXBaseSpecifier *
1364Sema::CheckBaseSpecifier(CXXRecordDecl *Class,
1365 SourceRange SpecifierRange,
1366 bool Virtual, AccessSpecifier Access,
Douglas Gregor752a5952011-01-03 22:36:02 +00001367 TypeSourceInfo *TInfo,
1368 SourceLocation EllipsisLoc) {
Nick Lewycky19b9f952010-07-26 16:56:01 +00001369 QualType BaseType = TInfo->getType();
1370
Douglas Gregor463421d2009-03-03 04:44:36 +00001371 // C++ [class.union]p1:
1372 // A union shall not have base classes.
1373 if (Class->isUnion()) {
1374 Diag(Class->getLocation(), diag::err_base_clause_on_union)
1375 << SpecifierRange;
Craig Topperc3ec1492014-05-26 06:22:03 +00001376 return nullptr;
Douglas Gregor463421d2009-03-03 04:44:36 +00001377 }
1378
Douglas Gregor752a5952011-01-03 22:36:02 +00001379 if (EllipsisLoc.isValid() &&
1380 !TInfo->getType()->containsUnexpandedParameterPack()) {
1381 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
1382 << TInfo->getTypeLoc().getSourceRange();
1383 EllipsisLoc = SourceLocation();
1384 }
Douglas Gregor62004702012-11-10 01:18:17 +00001385
1386 SourceLocation BaseLoc = TInfo->getTypeLoc().getBeginLoc();
1387
1388 if (BaseType->isDependentType()) {
1389 // Make sure that we don't have circular inheritance among our dependent
1390 // bases. For non-dependent bases, the check for completeness below handles
1391 // this.
1392 if (CXXRecordDecl *BaseDecl = BaseType->getAsCXXRecordDecl()) {
1393 if (BaseDecl->getCanonicalDecl() == Class->getCanonicalDecl() ||
1394 ((BaseDecl = BaseDecl->getDefinition()) &&
Douglas Gregordc974572012-11-10 07:24:09 +00001395 findCircularInheritance(Class, BaseDecl))) {
Douglas Gregor62004702012-11-10 01:18:17 +00001396 Diag(BaseLoc, diag::err_circular_inheritance)
1397 << BaseType << Context.getTypeDeclType(Class);
1398
1399 if (BaseDecl->getCanonicalDecl() != Class->getCanonicalDecl())
1400 Diag(BaseDecl->getLocation(), diag::note_previous_decl)
1401 << BaseType;
Craig Topperc3ec1492014-05-26 06:22:03 +00001402
1403 return nullptr;
Douglas Gregor62004702012-11-10 01:18:17 +00001404 }
1405 }
1406
Mike Stump11289f42009-09-09 15:08:12 +00001407 return new (Context) CXXBaseSpecifier(SpecifierRange, Virtual,
Nick Lewycky19b9f952010-07-26 16:56:01 +00001408 Class->getTagKind() == TTK_Class,
Douglas Gregor752a5952011-01-03 22:36:02 +00001409 Access, TInfo, EllipsisLoc);
Douglas Gregor62004702012-11-10 01:18:17 +00001410 }
Douglas Gregor463421d2009-03-03 04:44:36 +00001411
1412 // Base specifiers must be record types.
1413 if (!BaseType->isRecordType()) {
1414 Diag(BaseLoc, diag::err_base_must_be_class) << SpecifierRange;
Craig Topperc3ec1492014-05-26 06:22:03 +00001415 return nullptr;
Douglas Gregor463421d2009-03-03 04:44:36 +00001416 }
1417
1418 // C++ [class.union]p1:
1419 // A union shall not be used as a base class.
1420 if (BaseType->isUnionType()) {
1421 Diag(BaseLoc, diag::err_union_as_base_class) << SpecifierRange;
Craig Topperc3ec1492014-05-26 06:22:03 +00001422 return nullptr;
Douglas Gregor463421d2009-03-03 04:44:36 +00001423 }
1424
Hans Wennborg9bea9cc2014-06-25 18:25:57 +00001425 // For the MS ABI, propagate DLL attributes to base class templates.
1426 if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
1427 if (Attr *ClassAttr = getDLLAttr(Class)) {
1428 if (auto *BaseTemplate = dyn_cast_or_null<ClassTemplateSpecializationDecl>(
1429 BaseType->getAsCXXRecordDecl())) {
1430 propagateDLLAttrToBaseClassTemplate(*this, Class, ClassAttr,
1431 BaseTemplate, BaseLoc);
1432 }
1433 }
1434 }
1435
Douglas Gregor463421d2009-03-03 04:44:36 +00001436 // C++ [class.derived]p2:
1437 // The class-name in a base-specifier shall not be an incompletely
1438 // defined class.
Mike Stump11289f42009-09-09 15:08:12 +00001439 if (RequireCompleteType(BaseLoc, BaseType,
Douglas Gregor7bfb2d02012-05-04 16:32:21 +00001440 diag::err_incomplete_base_class, SpecifierRange)) {
John McCall3696dcb2010-08-17 07:23:57 +00001441 Class->setInvalidDecl();
Craig Topperc3ec1492014-05-26 06:22:03 +00001442 return nullptr;
John McCall3696dcb2010-08-17 07:23:57 +00001443 }
Douglas Gregor463421d2009-03-03 04:44:36 +00001444
Eli Friedmanc96d4962009-08-15 21:55:26 +00001445 // If the base class is polymorphic or isn't empty, the new one is/isn't, too.
Ted Kremenekc23c7e62009-07-29 21:53:49 +00001446 RecordDecl *BaseDecl = BaseType->getAs<RecordType>()->getDecl();
Douglas Gregor463421d2009-03-03 04:44:36 +00001447 assert(BaseDecl && "Record type has no declaration");
Douglas Gregor0a5a2212010-02-11 01:04:33 +00001448 BaseDecl = BaseDecl->getDefinition();
Douglas Gregor463421d2009-03-03 04:44:36 +00001449 assert(BaseDecl && "Base type is not incomplete, but has no definition");
David Majnemer626032f2013-06-22 06:43:58 +00001450 CXXRecordDecl *CXXBaseDecl = cast<CXXRecordDecl>(BaseDecl);
Eli Friedmanc96d4962009-08-15 21:55:26 +00001451 assert(CXXBaseDecl && "Base type is not a C++ type");
Eli Friedman89c038e2009-12-05 23:03:49 +00001452
David Majnemer9b1754d2013-11-02 12:00:36 +00001453 // A class which contains a flexible array member is not suitable for use as a
1454 // base class:
1455 // - If the layout determines that a base comes before another base,
1456 // the flexible array member would index into the subsequent base.
1457 // - If the layout determines that base comes before the derived class,
1458 // the flexible array member would index into the derived class.
1459 if (CXXBaseDecl->hasFlexibleArrayMember()) {
1460 Diag(BaseLoc, diag::err_base_class_has_flexible_array_member)
1461 << CXXBaseDecl->getDeclName();
Craig Topperc3ec1492014-05-26 06:22:03 +00001462 return nullptr;
David Majnemer9b1754d2013-11-02 12:00:36 +00001463 }
1464
Anders Carlsson65c76d32011-03-25 14:55:14 +00001465 // C++ [class]p3:
David Majnemer45897602013-11-02 11:24:41 +00001466 // If a class is marked final and it appears as a base-type-specifier in
Anders Carlsson65c76d32011-03-25 14:55:14 +00001467 // base-clause, the program is ill-formed.
David Majnemera5433082013-10-18 00:33:31 +00001468 if (FinalAttr *FA = CXXBaseDecl->getAttr<FinalAttr>()) {
David Majnemer45897602013-11-02 11:24:41 +00001469 Diag(BaseLoc, diag::err_class_marked_final_used_as_base)
David Majnemera5433082013-10-18 00:33:31 +00001470 << CXXBaseDecl->getDeclName()
1471 << FA->isSpelledAsSealed();
Alp Toker2afa8782014-05-28 12:20:14 +00001472 Diag(CXXBaseDecl->getLocation(), diag::note_entity_declared_at)
1473 << CXXBaseDecl->getDeclName() << FA->getRange();
Craig Topperc3ec1492014-05-26 06:22:03 +00001474 return nullptr;
Anders Carlssonfc1eef42011-01-22 17:51:53 +00001475 }
1476
John McCall3696dcb2010-08-17 07:23:57 +00001477 if (BaseDecl->isInvalidDecl())
1478 Class->setInvalidDecl();
David Majnemer45897602013-11-02 11:24:41 +00001479
Anders Carlssonae3c5cf2009-12-03 17:49:57 +00001480 // Create the base specifier.
Anders Carlssonae3c5cf2009-12-03 17:49:57 +00001481 return new (Context) CXXBaseSpecifier(SpecifierRange, Virtual,
Nick Lewycky19b9f952010-07-26 16:56:01 +00001482 Class->getTagKind() == TTK_Class,
Douglas Gregor752a5952011-01-03 22:36:02 +00001483 Access, TInfo, EllipsisLoc);
Anders Carlssonae3c5cf2009-12-03 17:49:57 +00001484}
1485
Douglas Gregor556877c2008-04-13 21:30:24 +00001486/// ActOnBaseSpecifier - Parsed a base specifier. A base specifier is
1487/// one entry in the base class list of a class specifier, for
Mike Stump11289f42009-09-09 15:08:12 +00001488/// example:
1489/// class foo : public bar, virtual private baz {
Douglas Gregor556877c2008-04-13 21:30:24 +00001490/// 'public bar' and 'virtual private baz' are each base-specifiers.
John McCallfaf5fb42010-08-26 23:41:50 +00001491BaseResult
John McCall48871652010-08-21 09:40:31 +00001492Sema::ActOnBaseSpecifier(Decl *classdecl, SourceRange SpecifierRange,
Richard Smith4c96e992013-02-19 23:47:15 +00001493 ParsedAttributes &Attributes,
Douglas Gregor29a92472008-10-22 17:49:05 +00001494 bool Virtual, AccessSpecifier Access,
Douglas Gregor752a5952011-01-03 22:36:02 +00001495 ParsedType basetype, SourceLocation BaseLoc,
1496 SourceLocation EllipsisLoc) {
Douglas Gregor71a57182009-06-22 23:20:33 +00001497 if (!classdecl)
1498 return true;
1499
Douglas Gregorc40290e2009-03-09 23:48:35 +00001500 AdjustDeclIfTemplate(classdecl);
John McCall48871652010-08-21 09:40:31 +00001501 CXXRecordDecl *Class = dyn_cast<CXXRecordDecl>(classdecl);
Douglas Gregorbeab56e2010-02-27 00:25:28 +00001502 if (!Class)
1503 return true;
1504
David Majnemer5ef4fe72014-06-13 06:43:46 +00001505 // We haven't yet attached the base specifiers.
1506 Class->setIsParsingBaseSpecifiers();
1507
Richard Smith4c96e992013-02-19 23:47:15 +00001508 // We do not support any C++11 attributes on base-specifiers yet.
1509 // Diagnose any attributes we see.
1510 if (!Attributes.empty()) {
1511 for (AttributeList *Attr = Attributes.getList(); Attr;
1512 Attr = Attr->getNext()) {
1513 if (Attr->isInvalid() ||
1514 Attr->getKind() == AttributeList::IgnoredAttribute)
1515 continue;
1516 Diag(Attr->getLoc(),
1517 Attr->getKind() == AttributeList::UnknownAttribute
1518 ? diag::warn_unknown_attribute_ignored
1519 : diag::err_base_specifier_attribute)
1520 << Attr->getName();
1521 }
1522 }
1523
Craig Topperc3ec1492014-05-26 06:22:03 +00001524 TypeSourceInfo *TInfo = nullptr;
Nick Lewycky19b9f952010-07-26 16:56:01 +00001525 GetTypeFromParser(basetype, &TInfo);
Douglas Gregor506bd562010-12-13 22:49:22 +00001526
Douglas Gregor752a5952011-01-03 22:36:02 +00001527 if (EllipsisLoc.isInvalid() &&
1528 DiagnoseUnexpandedParameterPack(SpecifierRange.getBegin(), TInfo,
Douglas Gregor506bd562010-12-13 22:49:22 +00001529 UPPC_BaseType))
1530 return true;
Douglas Gregor752a5952011-01-03 22:36:02 +00001531
Douglas Gregor463421d2009-03-03 04:44:36 +00001532 if (CXXBaseSpecifier *BaseSpec = CheckBaseSpecifier(Class, SpecifierRange,
Douglas Gregor752a5952011-01-03 22:36:02 +00001533 Virtual, Access, TInfo,
1534 EllipsisLoc))
Douglas Gregor463421d2009-03-03 04:44:36 +00001535 return BaseSpec;
Douglas Gregorb9b8b812012-07-02 21:00:41 +00001536 else
1537 Class->setInvalidDecl();
Mike Stump11289f42009-09-09 15:08:12 +00001538
Douglas Gregor463421d2009-03-03 04:44:36 +00001539 return true;
Douglas Gregor29a92472008-10-22 17:49:05 +00001540}
Douglas Gregor556877c2008-04-13 21:30:24 +00001541
Douglas Gregor463421d2009-03-03 04:44:36 +00001542/// \brief Performs the actual work of attaching the given base class
1543/// specifiers to a C++ class.
1544bool Sema::AttachBaseSpecifiers(CXXRecordDecl *Class, CXXBaseSpecifier **Bases,
1545 unsigned NumBases) {
1546 if (NumBases == 0)
1547 return false;
Douglas Gregor29a92472008-10-22 17:49:05 +00001548
1549 // Used to keep track of which base types we have already seen, so
1550 // that we can properly diagnose redundant direct base types. Note
Douglas Gregor9d6290b2008-10-23 18:13:27 +00001551 // that the key is always the unqualified canonical type of the base
1552 // class.
Douglas Gregor29a92472008-10-22 17:49:05 +00001553 std::map<QualType, CXXBaseSpecifier*, QualTypeOrdering> KnownBaseTypes;
1554
1555 // Copy non-redundant base specifiers into permanent storage.
Douglas Gregor9d6290b2008-10-23 18:13:27 +00001556 unsigned NumGoodBases = 0;
Douglas Gregor463421d2009-03-03 04:44:36 +00001557 bool Invalid = false;
Douglas Gregor9d6290b2008-10-23 18:13:27 +00001558 for (unsigned idx = 0; idx < NumBases; ++idx) {
Mike Stump11289f42009-09-09 15:08:12 +00001559 QualType NewBaseType
Douglas Gregor463421d2009-03-03 04:44:36 +00001560 = Context.getCanonicalType(Bases[idx]->getType());
Douglas Gregor1b8fe5b72009-11-16 21:35:15 +00001561 NewBaseType = NewBaseType.getLocalUnqualifiedType();
Benjamin Kramer73ecd702012-03-05 17:20:04 +00001562
1563 CXXBaseSpecifier *&KnownBase = KnownBaseTypes[NewBaseType];
1564 if (KnownBase) {
Douglas Gregor29a92472008-10-22 17:49:05 +00001565 // C++ [class.mi]p3:
1566 // A class shall not be specified as a direct base class of a
1567 // derived class more than once.
Daniel Dunbar62ee6412012-03-09 18:35:03 +00001568 Diag(Bases[idx]->getLocStart(),
Chris Lattner3b054132008-11-19 05:08:23 +00001569 diag::err_duplicate_base_class)
Benjamin Kramer73ecd702012-03-05 17:20:04 +00001570 << KnownBase->getType()
Douglas Gregor463421d2009-03-03 04:44:36 +00001571 << Bases[idx]->getSourceRange();
Douglas Gregor9d6290b2008-10-23 18:13:27 +00001572
1573 // Delete the duplicate base class specifier; we're going to
1574 // overwrite its pointer later.
Douglas Gregorb77af8f2009-07-22 20:55:49 +00001575 Context.Deallocate(Bases[idx]);
Douglas Gregor463421d2009-03-03 04:44:36 +00001576
1577 Invalid = true;
Douglas Gregor29a92472008-10-22 17:49:05 +00001578 } else {
1579 // Okay, add this new base class.
Benjamin Kramer73ecd702012-03-05 17:20:04 +00001580 KnownBase = Bases[idx];
Douglas Gregor463421d2009-03-03 04:44:36 +00001581 Bases[NumGoodBases++] = Bases[idx];
John McCalldb632ac2012-09-25 07:32:39 +00001582 if (const RecordType *Record = NewBaseType->getAs<RecordType>()) {
1583 const CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl());
1584 if (Class->isInterface() &&
1585 (!RD->isInterface() ||
1586 KnownBase->getAccessSpecifier() != AS_public)) {
1587 // The Microsoft extension __interface does not permit bases that
1588 // are not themselves public interfaces.
1589 Diag(KnownBase->getLocStart(), diag::err_invalid_base_in_interface)
1590 << getRecordDiagFromTagKind(RD->getTagKind()) << RD->getName()
1591 << RD->getSourceRange();
1592 Invalid = true;
1593 }
1594 if (RD->hasAttr<WeakAttr>())
Aaron Ballman36a53502014-01-16 13:03:14 +00001595 Class->addAttr(WeakAttr::CreateImplicit(Context));
John McCalldb632ac2012-09-25 07:32:39 +00001596 }
Douglas Gregor29a92472008-10-22 17:49:05 +00001597 }
1598 }
1599
1600 // Attach the remaining base class specifiers to the derived class.
Douglas Gregor4a62bdf2010-02-11 01:30:34 +00001601 Class->setBases(Bases, NumGoodBases);
Douglas Gregor9d6290b2008-10-23 18:13:27 +00001602
1603 // Delete the remaining (good) base class specifiers, since their
1604 // data has been copied into the CXXRecordDecl.
1605 for (unsigned idx = 0; idx < NumGoodBases; ++idx)
Douglas Gregorb77af8f2009-07-22 20:55:49 +00001606 Context.Deallocate(Bases[idx]);
Douglas Gregor463421d2009-03-03 04:44:36 +00001607
1608 return Invalid;
1609}
1610
1611/// ActOnBaseSpecifiers - Attach the given base specifiers to the
1612/// class, after checking whether there are any duplicate base
1613/// classes.
Richard Trieu9becef62011-09-09 03:18:59 +00001614void Sema::ActOnBaseSpecifiers(Decl *ClassDecl, CXXBaseSpecifier **Bases,
Douglas Gregor463421d2009-03-03 04:44:36 +00001615 unsigned NumBases) {
1616 if (!ClassDecl || !Bases || !NumBases)
1617 return;
1618
1619 AdjustDeclIfTemplate(ClassDecl);
Robert Wilhelme3cea802013-07-22 05:04:01 +00001620 AttachBaseSpecifiers(cast<CXXRecordDecl>(ClassDecl), Bases, NumBases);
Douglas Gregor556877c2008-04-13 21:30:24 +00001621}
Argyrios Kyrtzidis08114892008-04-27 13:50:30 +00001622
Douglas Gregor36d1b142009-10-06 17:59:45 +00001623/// \brief Determine whether the type \p Derived is a C++ class that is
1624/// derived from the type \p Base.
1625bool Sema::IsDerivedFrom(QualType Derived, QualType Base) {
David Blaikiebbafb8a2012-03-11 07:00:24 +00001626 if (!getLangOpts().CPlusPlus)
Douglas Gregor36d1b142009-10-06 17:59:45 +00001627 return false;
John McCalle78aac42010-03-10 03:28:59 +00001628
Douglas Gregor45bb4832013-03-26 23:36:30 +00001629 CXXRecordDecl *DerivedRD = Derived->getAsCXXRecordDecl();
John McCalle78aac42010-03-10 03:28:59 +00001630 if (!DerivedRD)
Douglas Gregor36d1b142009-10-06 17:59:45 +00001631 return false;
1632
Douglas Gregor45bb4832013-03-26 23:36:30 +00001633 CXXRecordDecl *BaseRD = Base->getAsCXXRecordDecl();
John McCalle78aac42010-03-10 03:28:59 +00001634 if (!BaseRD)
Douglas Gregor36d1b142009-10-06 17:59:45 +00001635 return false;
Douglas Gregor45bb4832013-03-26 23:36:30 +00001636
1637 // If either the base or the derived type is invalid, don't try to
1638 // check whether one is derived from the other.
1639 if (BaseRD->isInvalidDecl() || DerivedRD->isInvalidDecl())
1640 return false;
1641
John McCall67da35c2010-02-04 22:26:26 +00001642 // FIXME: instantiate DerivedRD if necessary. We need a PoI for this.
1643 return DerivedRD->hasDefinition() && DerivedRD->isDerivedFrom(BaseRD);
Douglas Gregor36d1b142009-10-06 17:59:45 +00001644}
1645
1646/// \brief Determine whether the type \p Derived is a C++ class that is
1647/// derived from the type \p Base.
1648bool Sema::IsDerivedFrom(QualType Derived, QualType Base, CXXBasePaths &Paths) {
David Blaikiebbafb8a2012-03-11 07:00:24 +00001649 if (!getLangOpts().CPlusPlus)
Douglas Gregor36d1b142009-10-06 17:59:45 +00001650 return false;
1651
Douglas Gregor45bb4832013-03-26 23:36:30 +00001652 CXXRecordDecl *DerivedRD = Derived->getAsCXXRecordDecl();
John McCalle78aac42010-03-10 03:28:59 +00001653 if (!DerivedRD)
Douglas Gregor36d1b142009-10-06 17:59:45 +00001654 return false;
1655
Douglas Gregor45bb4832013-03-26 23:36:30 +00001656 CXXRecordDecl *BaseRD = Base->getAsCXXRecordDecl();
John McCalle78aac42010-03-10 03:28:59 +00001657 if (!BaseRD)
Douglas Gregor36d1b142009-10-06 17:59:45 +00001658 return false;
1659
Douglas Gregor36d1b142009-10-06 17:59:45 +00001660 return DerivedRD->isDerivedFrom(BaseRD, Paths);
1661}
1662
Anders Carlssona70cff62010-04-24 19:06:50 +00001663void Sema::BuildBasePathArray(const CXXBasePaths &Paths,
John McCallcf142162010-08-07 06:22:56 +00001664 CXXCastPath &BasePathArray) {
Anders Carlssona70cff62010-04-24 19:06:50 +00001665 assert(BasePathArray.empty() && "Base path array must be empty!");
1666 assert(Paths.isRecordingPaths() && "Must record paths!");
1667
1668 const CXXBasePath &Path = Paths.front();
1669
1670 // We first go backward and check if we have a virtual base.
1671 // FIXME: It would be better if CXXBasePath had the base specifier for
1672 // the nearest virtual base.
1673 unsigned Start = 0;
1674 for (unsigned I = Path.size(); I != 0; --I) {
1675 if (Path[I - 1].Base->isVirtual()) {
1676 Start = I - 1;
1677 break;
1678 }
1679 }
1680
1681 // Now add all bases.
1682 for (unsigned I = Start, E = Path.size(); I != E; ++I)
John McCallcf142162010-08-07 06:22:56 +00001683 BasePathArray.push_back(const_cast<CXXBaseSpecifier*>(Path[I].Base));
Anders Carlssona70cff62010-04-24 19:06:50 +00001684}
1685
Douglas Gregor88d292c2010-05-13 16:44:06 +00001686/// \brief Determine whether the given base path includes a virtual
1687/// base class.
John McCallcf142162010-08-07 06:22:56 +00001688bool Sema::BasePathInvolvesVirtualBase(const CXXCastPath &BasePath) {
1689 for (CXXCastPath::const_iterator B = BasePath.begin(),
1690 BEnd = BasePath.end();
Douglas Gregor88d292c2010-05-13 16:44:06 +00001691 B != BEnd; ++B)
1692 if ((*B)->isVirtual())
1693 return true;
1694
1695 return false;
1696}
1697
Douglas Gregor36d1b142009-10-06 17:59:45 +00001698/// CheckDerivedToBaseConversion - Check whether the Derived-to-Base
1699/// conversion (where Derived and Base are class types) is
1700/// well-formed, meaning that the conversion is unambiguous (and
1701/// that all of the base classes are accessible). Returns true
1702/// and emits a diagnostic if the code is ill-formed, returns false
1703/// otherwise. Loc is the location where this routine should point to
1704/// if there is an error, and Range is the source range to highlight
1705/// if there is an error.
1706bool
1707Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base,
John McCall1064d7e2010-03-16 05:22:47 +00001708 unsigned InaccessibleBaseID,
Douglas Gregor36d1b142009-10-06 17:59:45 +00001709 unsigned AmbigiousBaseConvID,
1710 SourceLocation Loc, SourceRange Range,
Anders Carlsson7afe4242010-04-24 17:11:09 +00001711 DeclarationName Name,
John McCallcf142162010-08-07 06:22:56 +00001712 CXXCastPath *BasePath) {
Douglas Gregor36d1b142009-10-06 17:59:45 +00001713 // First, determine whether the path from Derived to Base is
1714 // ambiguous. This is slightly more expensive than checking whether
1715 // the Derived to Base conversion exists, because here we need to
1716 // explore multiple paths to determine if there is an ambiguity.
1717 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
1718 /*DetectVirtual=*/false);
1719 bool DerivationOkay = IsDerivedFrom(Derived, Base, Paths);
1720 assert(DerivationOkay &&
1721 "Can only be used with a derived-to-base conversion");
1722 (void)DerivationOkay;
1723
1724 if (!Paths.isAmbiguous(Context.getCanonicalType(Base).getUnqualifiedType())) {
Anders Carlssona70cff62010-04-24 19:06:50 +00001725 if (InaccessibleBaseID) {
1726 // Check that the base class can be accessed.
1727 switch (CheckBaseClassAccess(Loc, Base, Derived, Paths.front(),
1728 InaccessibleBaseID)) {
1729 case AR_inaccessible:
1730 return true;
1731 case AR_accessible:
1732 case AR_dependent:
1733 case AR_delayed:
1734 break;
Anders Carlsson7afe4242010-04-24 17:11:09 +00001735 }
John McCall5b0829a2010-02-10 09:31:12 +00001736 }
Anders Carlssona70cff62010-04-24 19:06:50 +00001737
1738 // Build a base path if necessary.
1739 if (BasePath)
1740 BuildBasePathArray(Paths, *BasePath);
1741 return false;
Douglas Gregor36d1b142009-10-06 17:59:45 +00001742 }
1743
David Majnemer626032f2013-06-22 06:43:58 +00001744 if (AmbigiousBaseConvID) {
1745 // We know that the derived-to-base conversion is ambiguous, and
1746 // we're going to produce a diagnostic. Perform the derived-to-base
1747 // search just one more time to compute all of the possible paths so
1748 // that we can print them out. This is more expensive than any of
1749 // the previous derived-to-base checks we've done, but at this point
1750 // performance isn't as much of an issue.
1751 Paths.clear();
1752 Paths.setRecordingPaths(true);
1753 bool StillOkay = IsDerivedFrom(Derived, Base, Paths);
1754 assert(StillOkay && "Can only be used with a derived-to-base conversion");
1755 (void)StillOkay;
1756
1757 // Build up a textual representation of the ambiguous paths, e.g.,
1758 // D -> B -> A, that will be used to illustrate the ambiguous
1759 // conversions in the diagnostic. We only print one of the paths
1760 // to each base class subobject.
1761 std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
1762
1763 Diag(Loc, AmbigiousBaseConvID)
1764 << Derived << Base << PathDisplayStr << Range << Name;
1765 }
Douglas Gregor36d1b142009-10-06 17:59:45 +00001766 return true;
1767}
1768
1769bool
1770Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base,
Sebastian Redl7c353682009-11-14 21:15:49 +00001771 SourceLocation Loc, SourceRange Range,
John McCallcf142162010-08-07 06:22:56 +00001772 CXXCastPath *BasePath,
Sebastian Redl7c353682009-11-14 21:15:49 +00001773 bool IgnoreAccess) {
Douglas Gregor36d1b142009-10-06 17:59:45 +00001774 return CheckDerivedToBaseConversion(Derived, Base,
John McCall1064d7e2010-03-16 05:22:47 +00001775 IgnoreAccess ? 0
1776 : diag::err_upcast_to_inaccessible_base,
Douglas Gregor36d1b142009-10-06 17:59:45 +00001777 diag::err_ambiguous_derived_to_base_conv,
Anders Carlsson7afe4242010-04-24 17:11:09 +00001778 Loc, Range, DeclarationName(),
1779 BasePath);
Douglas Gregor36d1b142009-10-06 17:59:45 +00001780}
1781
1782
1783/// @brief Builds a string representing ambiguous paths from a
1784/// specific derived class to different subobjects of the same base
1785/// class.
1786///
1787/// This function builds a string that can be used in error messages
1788/// to show the different paths that one can take through the
1789/// inheritance hierarchy to go from the derived class to different
1790/// subobjects of a base class. The result looks something like this:
1791/// @code
1792/// struct D -> struct B -> struct A
1793/// struct D -> struct C -> struct A
1794/// @endcode
1795std::string Sema::getAmbiguousPathsDisplayString(CXXBasePaths &Paths) {
1796 std::string PathDisplayStr;
1797 std::set<unsigned> DisplayedPaths;
1798 for (CXXBasePaths::paths_iterator Path = Paths.begin();
1799 Path != Paths.end(); ++Path) {
1800 if (DisplayedPaths.insert(Path->back().SubobjectNumber).second) {
1801 // We haven't displayed a path to this particular base
1802 // class subobject yet.
1803 PathDisplayStr += "\n ";
1804 PathDisplayStr += Context.getTypeDeclType(Paths.getOrigin()).getAsString();
1805 for (CXXBasePath::const_iterator Element = Path->begin();
1806 Element != Path->end(); ++Element)
1807 PathDisplayStr += " -> " + Element->Base->getType().getAsString();
1808 }
1809 }
1810
1811 return PathDisplayStr;
1812}
1813
Argyrios Kyrtzidised983422008-07-01 10:37:29 +00001814//===----------------------------------------------------------------------===//
1815// C++ class member Handling
1816//===----------------------------------------------------------------------===//
1817
Abramo Bagnarad7340582010-06-05 05:09:32 +00001818/// ActOnAccessSpecifier - Parsed an access specifier followed by a colon.
Erik Verbruggenca98f2a2011-10-13 09:41:32 +00001819bool Sema::ActOnAccessSpecifier(AccessSpecifier Access,
1820 SourceLocation ASLoc,
1821 SourceLocation ColonLoc,
1822 AttributeList *Attrs) {
Abramo Bagnarad7340582010-06-05 05:09:32 +00001823 assert(Access != AS_none && "Invalid kind for syntactic access specifier!");
John McCall48871652010-08-21 09:40:31 +00001824 AccessSpecDecl *ASDecl = AccessSpecDecl::Create(Context, Access, CurContext,
Abramo Bagnarad7340582010-06-05 05:09:32 +00001825 ASLoc, ColonLoc);
1826 CurContext->addHiddenDecl(ASDecl);
Erik Verbruggenca98f2a2011-10-13 09:41:32 +00001827 return ProcessAccessDeclAttributeList(ASDecl, Attrs);
Abramo Bagnarad7340582010-06-05 05:09:32 +00001828}
1829
Richard Smith18f07db2012-08-06 03:25:17 +00001830/// CheckOverrideControl - Check C++11 override control semantics.
Eli Friedmanaf65120b2013-09-05 23:51:03 +00001831void Sema::CheckOverrideControl(NamedDecl *D) {
Richard Smith09b031f2012-09-06 18:32:18 +00001832 if (D->isInvalidDecl())
1833 return;
1834
Eli Friedmanaf65120b2013-09-05 23:51:03 +00001835 // We only care about "override" and "final" declarations.
1836 if (!D->hasAttr<OverrideAttr>() && !D->hasAttr<FinalAttr>())
1837 return;
Anders Carlssonfd835532011-01-20 05:57:14 +00001838
Eli Friedmanaf65120b2013-09-05 23:51:03 +00001839 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D);
Anders Carlssonfa8e5d32011-01-20 06:33:26 +00001840
Eli Friedmanaf65120b2013-09-05 23:51:03 +00001841 // We can't check dependent instance methods.
1842 if (MD && MD->isInstance() &&
1843 (MD->getParent()->hasAnyDependentBases() ||
1844 MD->getType()->isDependentType()))
1845 return;
1846
1847 if (MD && !MD->isVirtual()) {
1848 // If we have a non-virtual method, check if if hides a virtual method.
1849 // (In that case, it's most likely the method has the wrong type.)
1850 SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
1851 FindHiddenVirtualMethods(MD, OverloadedMethods);
1852
1853 if (!OverloadedMethods.empty()) {
Richard Smith18f07db2012-08-06 03:25:17 +00001854 if (OverrideAttr *OA = D->getAttr<OverrideAttr>()) {
1855 Diag(OA->getLocation(),
Eli Friedmanaf65120b2013-09-05 23:51:03 +00001856 diag::override_keyword_hides_virtual_member_function)
1857 << "override" << (OverloadedMethods.size() > 1);
1858 } else if (FinalAttr *FA = D->getAttr<FinalAttr>()) {
Richard Smith18f07db2012-08-06 03:25:17 +00001859 Diag(FA->getLocation(),
Eli Friedmanaf65120b2013-09-05 23:51:03 +00001860 diag::override_keyword_hides_virtual_member_function)
David Majnemera5433082013-10-18 00:33:31 +00001861 << (FA->isSpelledAsSealed() ? "sealed" : "final")
1862 << (OverloadedMethods.size() > 1);
Richard Smith18f07db2012-08-06 03:25:17 +00001863 }
Eli Friedmanaf65120b2013-09-05 23:51:03 +00001864 NoteHiddenVirtualMethods(MD, OverloadedMethods);
1865 MD->setInvalidDecl();
1866 return;
1867 }
1868 // Fall through into the general case diagnostic.
1869 // FIXME: We might want to attempt typo correction here.
1870 }
1871
1872 if (!MD || !MD->isVirtual()) {
1873 if (OverrideAttr *OA = D->getAttr<OverrideAttr>()) {
1874 Diag(OA->getLocation(),
1875 diag::override_keyword_only_allowed_on_virtual_member_functions)
1876 << "override" << FixItHint::CreateRemoval(OA->getLocation());
1877 D->dropAttr<OverrideAttr>();
1878 }
1879 if (FinalAttr *FA = D->getAttr<FinalAttr>()) {
1880 Diag(FA->getLocation(),
1881 diag::override_keyword_only_allowed_on_virtual_member_functions)
David Majnemera5433082013-10-18 00:33:31 +00001882 << (FA->isSpelledAsSealed() ? "sealed" : "final")
1883 << FixItHint::CreateRemoval(FA->getLocation());
Eli Friedmanaf65120b2013-09-05 23:51:03 +00001884 D->dropAttr<FinalAttr>();
Richard Smith18f07db2012-08-06 03:25:17 +00001885 }
Anders Carlssonfd835532011-01-20 05:57:14 +00001886 return;
1887 }
Richard Smith18f07db2012-08-06 03:25:17 +00001888
Richard Smith18f07db2012-08-06 03:25:17 +00001889 // C++11 [class.virtual]p5:
1890 // If a virtual function is marked with the virt-specifier override and
1891 // does not override a member function of a base class, the program is
1892 // ill-formed.
1893 bool HasOverriddenMethods =
1894 MD->begin_overridden_methods() != MD->end_overridden_methods();
1895 if (MD->hasAttr<OverrideAttr>() && !HasOverriddenMethods)
1896 Diag(MD->getLocation(), diag::err_function_marked_override_not_overriding)
1897 << MD->getDeclName();
Anders Carlssonfd835532011-01-20 05:57:14 +00001898}
1899
Fariborz Jahanianf920a0a2014-10-27 19:11:51 +00001900void Sema::DiagnoseAbsenceOfOverrideControl(NamedDecl *D) {
1901 if (D->isInvalidDecl() || D->hasAttr<OverrideAttr>())
1902 return;
1903 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D);
1904 if (!MD || MD->isImplicit() || MD->hasAttr<FinalAttr>() ||
1905 isa<CXXDestructorDecl>(MD))
1906 return;
1907
Fariborz Jahanian6e213382014-10-31 19:56:27 +00001908 if (MD->getLocation().isMacroID()) {
1909 SourceLocation MacroLoc = getSourceManager().getSpellingLoc(MD->getLocation());
1910 if (getSourceManager().isInSystemHeader(MacroLoc))
1911 return;
1912 }
1913
Fariborz Jahanianf920a0a2014-10-27 19:11:51 +00001914 if (MD->size_overridden_methods() > 0) {
1915 Diag(MD->getLocation(), diag::warn_function_marked_not_override_overriding)
1916 << MD->getDeclName();
1917 const CXXMethodDecl *OMD = *MD->begin_overridden_methods();
1918 Diag(OMD->getLocation(), diag::note_overridden_virtual_function);
1919 }
1920}
1921
Richard Smith18f07db2012-08-06 03:25:17 +00001922/// CheckIfOverriddenFunctionIsMarkedFinal - Checks whether a virtual member
Anders Carlsson3f610c72011-01-20 16:25:36 +00001923/// function overrides a virtual member function marked 'final', according to
Richard Smith18f07db2012-08-06 03:25:17 +00001924/// C++11 [class.virtual]p4.
Anders Carlsson3f610c72011-01-20 16:25:36 +00001925bool Sema::CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl *New,
1926 const CXXMethodDecl *Old) {
David Majnemera5433082013-10-18 00:33:31 +00001927 FinalAttr *FA = Old->getAttr<FinalAttr>();
1928 if (!FA)
Anders Carlsson19588aa2011-01-23 21:07:30 +00001929 return false;
1930
1931 Diag(New->getLocation(), diag::err_final_function_overridden)
David Majnemera5433082013-10-18 00:33:31 +00001932 << New->getDeclName()
1933 << FA->isSpelledAsSealed();
Anders Carlsson19588aa2011-01-23 21:07:30 +00001934 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
1935 return true;
Anders Carlsson3f610c72011-01-20 16:25:36 +00001936}
1937
Daniel Jasper0baec5492012-06-06 08:32:04 +00001938static bool InitializationHasSideEffects(const FieldDecl &FD) {
Richard Smith0a8cfc72012-08-07 21:30:42 +00001939 const Type *T = FD.getType()->getBaseElementTypeUnsafe();
1940 // FIXME: Destruction of ObjC lifetime types has side-effects.
1941 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
1942 return !RD->isCompleteDefinition() ||
1943 !RD->hasTrivialDefaultConstructor() ||
1944 !RD->hasTrivialDestructor();
Daniel Jasper0baec5492012-06-06 08:32:04 +00001945 return false;
1946}
1947
John McCall5e77d762013-04-16 07:28:30 +00001948static AttributeList *getMSPropertyAttr(AttributeList *list) {
Craig Topperc3ec1492014-05-26 06:22:03 +00001949 for (AttributeList *it = list; it != nullptr; it = it->getNext())
John McCall5e77d762013-04-16 07:28:30 +00001950 if (it->isDeclspecPropertyAttribute())
1951 return it;
Craig Topperc3ec1492014-05-26 06:22:03 +00001952 return nullptr;
John McCall5e77d762013-04-16 07:28:30 +00001953}
1954
Argyrios Kyrtzidised983422008-07-01 10:37:29 +00001955/// ActOnCXXMemberDeclarator - This is invoked when a C++ class member
1956/// declarator is parsed. 'AS' is the access specifier, 'BW' specifies the
Richard Smith938f40b2011-06-11 17:19:42 +00001957/// bitfield width if there is one, 'InitExpr' specifies the initializer if
Richard Smith2b013182012-06-10 03:12:00 +00001958/// one has been parsed, and 'InitStyle' is set if an in-class initializer is
1959/// present (but parsing it has been deferred).
Rafael Espindola0a67e2f2013-01-08 20:44:06 +00001960NamedDecl *
Argyrios Kyrtzidised983422008-07-01 10:37:29 +00001961Sema::ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS, Declarator &D,
Douglas Gregor3447e762009-08-20 22:52:58 +00001962 MultiTemplateParamsArg TemplateParameterLists,
Richard Trieu2bd04012011-09-09 02:00:50 +00001963 Expr *BW, const VirtSpecifiers &VS,
Richard Smith2b013182012-06-10 03:12:00 +00001964 InClassInitStyle InitStyle) {
Argyrios Kyrtzidised983422008-07-01 10:37:29 +00001965 const DeclSpec &DS = D.getDeclSpec();
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001966 DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
1967 DeclarationName Name = NameInfo.getName();
1968 SourceLocation Loc = NameInfo.getLoc();
Douglas Gregor23ab7452010-11-09 03:31:16 +00001969
1970 // For anonymous bitfields, the location should point to the type.
1971 if (Loc.isInvalid())
Daniel Dunbar62ee6412012-03-09 18:35:03 +00001972 Loc = D.getLocStart();
Douglas Gregor23ab7452010-11-09 03:31:16 +00001973
Argyrios Kyrtzidised983422008-07-01 10:37:29 +00001974 Expr *BitWidth = static_cast<Expr*>(BW);
Argyrios Kyrtzidised983422008-07-01 10:37:29 +00001975
John McCallb1cd7da2010-06-04 08:34:12 +00001976 assert(isa<CXXRecordDecl>(CurContext));
John McCall07e91c02009-08-06 02:15:43 +00001977 assert(!DS.isFriendSpecified());
1978
Richard Smithcfcdf3a2011-06-25 02:28:38 +00001979 bool isFunc = D.isDeclarationOfFunction();
John McCallb1cd7da2010-06-04 08:34:12 +00001980
John McCalldb632ac2012-09-25 07:32:39 +00001981 if (cast<CXXRecordDecl>(CurContext)->isInterface()) {
1982 // The Microsoft extension __interface only permits public member functions
1983 // and prohibits constructors, destructors, operators, non-public member
1984 // functions, static methods and data members.
1985 unsigned InvalidDecl;
1986 bool ShowDeclName = true;
1987 if (!isFunc)
1988 InvalidDecl = (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) ? 0 : 1;
1989 else if (AS != AS_public)
1990 InvalidDecl = 2;
1991 else if (DS.getStorageClassSpec() == DeclSpec::SCS_static)
1992 InvalidDecl = 3;
1993 else switch (Name.getNameKind()) {
1994 case DeclarationName::CXXConstructorName:
1995 InvalidDecl = 4;
1996 ShowDeclName = false;
1997 break;
1998
1999 case DeclarationName::CXXDestructorName:
2000 InvalidDecl = 5;
2001 ShowDeclName = false;
2002 break;
2003
2004 case DeclarationName::CXXOperatorName:
2005 case DeclarationName::CXXConversionFunctionName:
2006 InvalidDecl = 6;
2007 break;
2008
2009 default:
2010 InvalidDecl = 0;
2011 break;
2012 }
2013
2014 if (InvalidDecl) {
2015 if (ShowDeclName)
2016 Diag(Loc, diag::err_invalid_member_in_interface)
2017 << (InvalidDecl-1) << Name;
2018 else
2019 Diag(Loc, diag::err_invalid_member_in_interface)
2020 << (InvalidDecl-1) << "";
Craig Topperc3ec1492014-05-26 06:22:03 +00002021 return nullptr;
John McCalldb632ac2012-09-25 07:32:39 +00002022 }
2023 }
2024
Argyrios Kyrtzidised983422008-07-01 10:37:29 +00002025 // C++ 9.2p6: A member shall not be declared to have automatic storage
2026 // duration (auto, register) or with the extern storage-class-specifier.
Sebastian Redlccdfaba2008-11-14 23:42:31 +00002027 // C++ 7.1.1p8: The mutable specifier can be applied only to names of class
2028 // data members and cannot be applied to names declared const or static,
2029 // and cannot be applied to reference members.
Argyrios Kyrtzidised983422008-07-01 10:37:29 +00002030 switch (DS.getStorageClassSpec()) {
Richard Smithb4a9e862013-04-12 22:46:28 +00002031 case DeclSpec::SCS_unspecified:
2032 case DeclSpec::SCS_typedef:
2033 case DeclSpec::SCS_static:
2034 break;
2035 case DeclSpec::SCS_mutable:
2036 if (isFunc) {
2037 Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_function);
Mike Stump11289f42009-09-09 15:08:12 +00002038
Richard Smithb4a9e862013-04-12 22:46:28 +00002039 // FIXME: It would be nicer if the keyword was ignored only for this
2040 // declarator. Otherwise we could get follow-up errors.
Argyrios Kyrtzidised983422008-07-01 10:37:29 +00002041 D.getMutableDeclSpec().ClearStorageClassSpecs();
Richard Smithb4a9e862013-04-12 22:46:28 +00002042 }
2043 break;
2044 default:
2045 Diag(DS.getStorageClassSpecLoc(),
2046 diag::err_storageclass_invalid_for_member);
2047 D.getMutableDeclSpec().ClearStorageClassSpecs();
2048 break;
Argyrios Kyrtzidised983422008-07-01 10:37:29 +00002049 }
2050
Sebastian Redlccdfaba2008-11-14 23:42:31 +00002051 bool isInstField = ((DS.getStorageClassSpec() == DeclSpec::SCS_unspecified ||
2052 DS.getStorageClassSpec() == DeclSpec::SCS_mutable) &&
Argyrios Kyrtzidis1207d312008-10-08 22:20:31 +00002053 !isFunc);
Argyrios Kyrtzidised983422008-07-01 10:37:29 +00002054
David Blaikie35506f82013-01-30 01:22:18 +00002055 if (DS.isConstexprSpecified() && isInstField) {
2056 SemaDiagnosticBuilder B =
2057 Diag(DS.getConstexprSpecLoc(), diag::err_invalid_constexpr_member);
2058 SourceLocation ConstexprLoc = DS.getConstexprSpecLoc();
2059 if (InitStyle == ICIS_NoInit) {
Richard Smith82dce552014-04-14 21:00:40 +00002060 B << 0 << 0;
2061 if (D.getDeclSpec().getTypeQualifiers() & DeclSpec::TQ_const)
2062 B << FixItHint::CreateRemoval(ConstexprLoc);
2063 else {
2064 B << FixItHint::CreateReplacement(ConstexprLoc, "const");
2065 D.getMutableDeclSpec().ClearConstexprSpec();
2066 const char *PrevSpec;
2067 unsigned DiagID;
2068 bool Failed = D.getMutableDeclSpec().SetTypeQual(
2069 DeclSpec::TQ_const, ConstexprLoc, PrevSpec, DiagID, getLangOpts());
2070 (void)Failed;
2071 assert(!Failed && "Making a constexpr member const shouldn't fail");
2072 }
David Blaikie35506f82013-01-30 01:22:18 +00002073 } else {
2074 B << 1;
2075 const char *PrevSpec;
2076 unsigned DiagID;
David Blaikie35506f82013-01-30 01:22:18 +00002077 if (D.getMutableDeclSpec().SetStorageClassSpec(
Erik Verbruggen888d52a2014-01-15 09:15:43 +00002078 *this, DeclSpec::SCS_static, ConstexprLoc, PrevSpec, DiagID,
2079 Context.getPrintingPolicy())) {
Matt Beaumont-Gayefc270d2013-01-31 00:08:03 +00002080 assert(DS.getStorageClassSpec() == DeclSpec::SCS_mutable &&
David Blaikie35506f82013-01-30 01:22:18 +00002081 "This is the only DeclSpec that should fail to be applied");
2082 B << 1;
2083 } else {
2084 B << 0 << FixItHint::CreateInsertion(ConstexprLoc, "static ");
2085 isInstField = false;
2086 }
2087 }
2088 }
2089
Rafael Espindola0a67e2f2013-01-08 20:44:06 +00002090 NamedDecl *Member;
Chris Lattner73bf7b42009-03-05 22:45:59 +00002091 if (isInstField) {
Douglas Gregora007d362010-10-13 22:19:53 +00002092 CXXScopeSpec &SS = D.getCXXScopeSpec();
Douglas Gregorbb64afc2011-10-09 18:55:59 +00002093
2094 // Data members must have identifiers for names.
Benjamin Kramer365082d2012-05-19 16:34:46 +00002095 if (!Name.isIdentifier()) {
Douglas Gregorbb64afc2011-10-09 18:55:59 +00002096 Diag(Loc, diag::err_bad_variable_name)
2097 << Name;
Craig Topperc3ec1492014-05-26 06:22:03 +00002098 return nullptr;
Douglas Gregorbb64afc2011-10-09 18:55:59 +00002099 }
Douglas Gregor7c26c042011-09-21 14:40:46 +00002100
Benjamin Kramer365082d2012-05-19 16:34:46 +00002101 IdentifierInfo *II = Name.getAsIdentifierInfo();
2102
Douglas Gregor7c26c042011-09-21 14:40:46 +00002103 // Member field could not be with "template" keyword.
2104 // So TemplateParameterLists should be empty in this case.
2105 if (TemplateParameterLists.size()) {
Benjamin Kramer62b95d82012-08-23 21:35:17 +00002106 TemplateParameterList* TemplateParams = TemplateParameterLists[0];
Douglas Gregor7c26c042011-09-21 14:40:46 +00002107 if (TemplateParams->size()) {
2108 // There is no such thing as a member field template.
2109 Diag(D.getIdentifierLoc(), diag::err_template_member)
2110 << II
2111 << SourceRange(TemplateParams->getTemplateLoc(),
2112 TemplateParams->getRAngleLoc());
2113 } else {
2114 // There is an extraneous 'template<>' for this member.
2115 Diag(TemplateParams->getTemplateLoc(),
2116 diag::err_template_member_noparams)
2117 << II
2118 << SourceRange(TemplateParams->getTemplateLoc(),
2119 TemplateParams->getRAngleLoc());
2120 }
Craig Topperc3ec1492014-05-26 06:22:03 +00002121 return nullptr;
Douglas Gregor7c26c042011-09-21 14:40:46 +00002122 }
2123
Douglas Gregora007d362010-10-13 22:19:53 +00002124 if (SS.isSet() && !SS.isInvalid()) {
2125 // The user provided a superfluous scope specifier inside a class
2126 // definition:
2127 //
2128 // class X {
2129 // int X::member;
2130 // };
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00002131 if (DeclContext *DC = computeDeclContext(SS, false))
2132 diagnoseQualifiedDeclaration(SS, DC, Name, D.getIdentifierLoc());
Douglas Gregora007d362010-10-13 22:19:53 +00002133 else
2134 Diag(D.getIdentifierLoc(), diag::err_member_qualification)
2135 << Name << SS.getRange();
Douglas Gregorc3ae7c32011-11-01 22:13:30 +00002136
Douglas Gregora007d362010-10-13 22:19:53 +00002137 SS.clear();
2138 }
Douglas Gregor7c26c042011-09-21 14:40:46 +00002139
John McCall5e77d762013-04-16 07:28:30 +00002140 AttributeList *MSPropertyAttr =
2141 getMSPropertyAttr(D.getDeclSpec().getAttributes().getList());
Eli Friedmanc37dbf72013-06-28 20:48:34 +00002142 if (MSPropertyAttr) {
2143 Member = HandleMSProperty(S, cast<CXXRecordDecl>(CurContext), Loc, D,
2144 BitWidth, InitStyle, AS, MSPropertyAttr);
2145 if (!Member)
Craig Topperc3ec1492014-05-26 06:22:03 +00002146 return nullptr;
Eli Friedmanc37dbf72013-06-28 20:48:34 +00002147 isInstField = false;
2148 } else {
2149 Member = HandleField(S, cast<CXXRecordDecl>(CurContext), Loc, D,
2150 BitWidth, InitStyle, AS);
2151 assert(Member && "HandleField never returns null");
2152 }
2153 } else {
2154 assert(InitStyle == ICIS_NoInit || D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_static);
2155
2156 Member = HandleDeclarator(S, D, TemplateParameterLists);
2157 if (!Member)
Craig Topperc3ec1492014-05-26 06:22:03 +00002158 return nullptr;
Eli Friedmanc37dbf72013-06-28 20:48:34 +00002159
2160 // Non-instance-fields can't have a bitfield.
2161 if (BitWidth) {
Chris Lattnerd26760a2009-03-05 23:01:03 +00002162 if (Member->isInvalidDecl()) {
2163 // don't emit another diagnostic.
Douglas Gregor212cab32009-03-11 20:22:50 +00002164 } else if (isa<VarDecl>(Member)) {
Chris Lattnerd26760a2009-03-05 23:01:03 +00002165 // C++ 9.6p3: A bit-field shall not be a static member.
2166 // "static member 'A' cannot be a bit-field"
2167 Diag(Loc, diag::err_static_not_bitfield)
2168 << Name << BitWidth->getSourceRange();
2169 } else if (isa<TypedefDecl>(Member)) {
2170 // "typedef member 'x' cannot be a bit-field"
2171 Diag(Loc, diag::err_typedef_not_bitfield)
2172 << Name << BitWidth->getSourceRange();
2173 } else {
2174 // A function typedef ("typedef int f(); f a;").
2175 // C++ 9.6p3: A bit-field shall have integral or enumeration type.
2176 Diag(Loc, diag::err_not_integral_type_bitfield)
Mike Stump11289f42009-09-09 15:08:12 +00002177 << Name << cast<ValueDecl>(Member)->getType()
Douglas Gregor1efa4372009-03-11 18:59:21 +00002178 << BitWidth->getSourceRange();
Chris Lattnerd26760a2009-03-05 23:01:03 +00002179 }
Mike Stump11289f42009-09-09 15:08:12 +00002180
Craig Topperc3ec1492014-05-26 06:22:03 +00002181 BitWidth = nullptr;
Chris Lattnerd26760a2009-03-05 23:01:03 +00002182 Member->setInvalidDecl();
2183 }
Douglas Gregor4261e4c2009-03-11 20:50:30 +00002184
2185 Member->setAccess(AS);
Mike Stump11289f42009-09-09 15:08:12 +00002186
Larisse Voufo39a1e502013-08-06 01:03:05 +00002187 // If we have declared a member function template or static data member
2188 // template, set the access of the templated declaration as well.
Douglas Gregor3447e762009-08-20 22:52:58 +00002189 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Member))
2190 FunTmpl->getTemplatedDecl()->setAccess(AS);
Larisse Voufo39a1e502013-08-06 01:03:05 +00002191 else if (VarTemplateDecl *VarTmpl = dyn_cast<VarTemplateDecl>(Member))
2192 VarTmpl->getTemplatedDecl()->setAccess(AS);
Chris Lattner73bf7b42009-03-05 22:45:59 +00002193 }
Argyrios Kyrtzidised983422008-07-01 10:37:29 +00002194
Richard Smith18f07db2012-08-06 03:25:17 +00002195 if (VS.isOverrideSpecified())
Aaron Ballman36a53502014-01-16 13:03:14 +00002196 Member->addAttr(new (Context) OverrideAttr(VS.getOverrideLoc(), Context, 0));
Richard Smith18f07db2012-08-06 03:25:17 +00002197 if (VS.isFinalSpecified())
David Majnemera5433082013-10-18 00:33:31 +00002198 Member->addAttr(new (Context) FinalAttr(VS.getFinalLoc(), Context,
2199 VS.isFinalSpelledSealed()));
Anders Carlssonfd835532011-01-20 05:57:14 +00002200
Douglas Gregorf2f08062011-03-08 17:10:18 +00002201 if (VS.getLastLocation().isValid()) {
2202 // Update the end location of a method that has a virt-specifiers.
2203 if (CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(Member))
2204 MD->setRangeEnd(VS.getLastLocation());
2205 }
Richard Smith18f07db2012-08-06 03:25:17 +00002206
Anders Carlssonc87f8612011-01-20 06:29:02 +00002207 CheckOverrideControl(Member);
Anders Carlssonfd835532011-01-20 05:57:14 +00002208
Douglas Gregor92751d42008-11-17 22:58:34 +00002209 assert((Name || isInstField) && "No identifier for non-field ?");
Argyrios Kyrtzidised983422008-07-01 10:37:29 +00002210
Daniel Jasper0baec5492012-06-06 08:32:04 +00002211 if (isInstField) {
2212 FieldDecl *FD = cast<FieldDecl>(Member);
2213 FieldCollector->Add(FD);
2214
Alp Tokerd4a3f0e2014-06-15 23:30:39 +00002215 if (!Diags.isIgnored(diag::warn_unused_private_field, FD->getLocation())) {
Daniel Jasper0baec5492012-06-06 08:32:04 +00002216 // Remember all explicit private FieldDecls that have a name, no side
2217 // effects and are not part of a dependent type declaration.
2218 if (!FD->isImplicit() && FD->getDeclName() &&
2219 FD->getAccess() == AS_private &&
Daniel Jasper429c1342012-06-13 18:31:09 +00002220 !FD->hasAttr<UnusedAttr>() &&
Richard Smith0a8cfc72012-08-07 21:30:42 +00002221 !FD->getParent()->isDependentContext() &&
Daniel Jasper0baec5492012-06-06 08:32:04 +00002222 !InitializationHasSideEffects(*FD))
2223 UnusedPrivateFields.insert(FD);
2224 }
2225 }
2226
John McCall48871652010-08-21 09:40:31 +00002227 return Member;
Argyrios Kyrtzidised983422008-07-01 10:37:29 +00002228}
2229
Hans Wennborg44fd70a2012-09-18 15:58:06 +00002230namespace {
2231 class UninitializedFieldVisitor
2232 : public EvaluatedExprVisitor<UninitializedFieldVisitor> {
2233 Sema &S;
Richard Trieuef64e942013-10-25 00:56:00 +00002234 // List of Decls to generate a warning on. Also remove Decls that become
2235 // initialized.
Craig Topper4dd9b432014-08-17 23:49:53 +00002236 llvm::SmallPtrSetImpl<ValueDecl*> &Decls;
Richard Trieu8d08a272014-08-28 03:23:47 +00002237 // Vector of decls to be removed from the Decl set prior to visiting the
2238 // nodes. These Decls may have been initialized in the prior initializer.
2239 llvm::SmallVector<ValueDecl*, 4> DeclsToRemove;
Richard Trieu406e65c2013-09-20 03:03:06 +00002240 // If non-null, add a note to the warning pointing back to the constructor.
NAKAMURA Takumi1af7cd72014-10-17 23:46:34 +00002241 const CXXConstructorDecl *Constructor;
Nick Lewycky314a4492014-10-17 22:45:44 +00002242 // Variables to hold state when processing an initializer list. When
Richard Trieufa1d0a72014-10-17 20:56:10 +00002243 // InitList is true, special case initialization of FieldDecls matching
2244 // InitListFieldDecl.
NAKAMURA Takumi1af7cd72014-10-17 23:46:34 +00002245 bool InitList;
2246 FieldDecl *InitListFieldDecl;
Richard Trieufa1d0a72014-10-17 20:56:10 +00002247 llvm::SmallVector<unsigned, 4> InitFieldIndex;
2248
Hans Wennborg44fd70a2012-09-18 15:58:06 +00002249 public:
2250 typedef EvaluatedExprVisitor<UninitializedFieldVisitor> Inherited;
Richard Trieuef64e942013-10-25 00:56:00 +00002251 UninitializedFieldVisitor(Sema &S,
Richard Trieu8d08a272014-08-28 03:23:47 +00002252 llvm::SmallPtrSetImpl<ValueDecl*> &Decls)
NAKAMURA Takumi1af7cd72014-10-17 23:46:34 +00002253 : Inherited(S.Context), S(S), Decls(Decls), Constructor(nullptr),
2254 InitList(false), InitListFieldDecl(nullptr) {}
Hans Wennborg44fd70a2012-09-18 15:58:06 +00002255
Richard Trieufa1d0a72014-10-17 20:56:10 +00002256 // Returns true if the use of ME is not an uninitialized use.
2257 bool IsInitListMemberExprInitialized(MemberExpr *ME,
2258 bool CheckReferenceOnly) {
2259 llvm::SmallVector<FieldDecl*, 4> Fields;
2260 bool ReferenceField = false;
2261 while (ME) {
2262 FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
2263 if (!FD)
2264 return false;
2265 Fields.push_back(FD);
2266 if (FD->getType()->isReferenceType())
2267 ReferenceField = true;
2268 ME = dyn_cast<MemberExpr>(ME->getBase()->IgnoreParenImpCasts());
2269 }
2270
2271 // Binding a reference to an unintialized field is not an
2272 // uninitialized use.
2273 if (CheckReferenceOnly && !ReferenceField)
2274 return true;
2275
2276 llvm::SmallVector<unsigned, 4> UsedFieldIndex;
2277 // Discard the first field since it is the field decl that is being
2278 // initialized.
2279 for (auto I = Fields.rbegin() + 1, E = Fields.rend(); I != E; ++I) {
2280 UsedFieldIndex.push_back((*I)->getFieldIndex());
2281 }
2282
2283 for (auto UsedIter = UsedFieldIndex.begin(),
2284 UsedEnd = UsedFieldIndex.end(),
2285 OrigIter = InitFieldIndex.begin(),
2286 OrigEnd = InitFieldIndex.end();
2287 UsedIter != UsedEnd && OrigIter != OrigEnd; ++UsedIter, ++OrigIter) {
2288 if (*UsedIter < *OrigIter)
2289 return true;
2290 if (*UsedIter > *OrigIter)
2291 break;
2292 }
2293
2294 return false;
2295 }
2296
Richard Trieu2d779b92014-10-01 03:44:58 +00002297 void HandleMemberExpr(MemberExpr *ME, bool CheckReferenceOnly,
2298 bool AddressOf) {
Richard Trieu1bc22c12013-09-13 03:20:53 +00002299 if (isa<EnumConstantDecl>(ME->getMemberDecl()))
2300 return;
Hans Wennborg44fd70a2012-09-18 15:58:06 +00002301
Richard Trieu1bc22c12013-09-13 03:20:53 +00002302 // FieldME is the inner-most MemberExpr that is not an anonymous struct
2303 // or union.
2304 MemberExpr *FieldME = ME;
2305
Richard Trieu2d779b92014-10-01 03:44:58 +00002306 bool AllPODFields = FieldME->getType().isPODType(S.Context);
2307
Richard Trieu1bc22c12013-09-13 03:20:53 +00002308 Expr *Base = ME;
Richard Trieufa1d0a72014-10-17 20:56:10 +00002309 while (MemberExpr *SubME = dyn_cast<MemberExpr>(Base)) {
Richard Trieu1bc22c12013-09-13 03:20:53 +00002310
Richard Trieufa1d0a72014-10-17 20:56:10 +00002311 if (isa<VarDecl>(SubME->getMemberDecl()))
Richard Trieu1bc22c12013-09-13 03:20:53 +00002312 return;
2313
Richard Trieufa1d0a72014-10-17 20:56:10 +00002314 if (FieldDecl *FD = dyn_cast<FieldDecl>(SubME->getMemberDecl()))
Richard Trieu1bc22c12013-09-13 03:20:53 +00002315 if (!FD->isAnonymousStructOrUnion())
Richard Trieufa1d0a72014-10-17 20:56:10 +00002316 FieldME = SubME;
Richard Trieu1bc22c12013-09-13 03:20:53 +00002317
Richard Trieu2d779b92014-10-01 03:44:58 +00002318 if (!FieldME->getType().isPODType(S.Context))
2319 AllPODFields = false;
2320
Richard Trieufa1d0a72014-10-17 20:56:10 +00002321 Base = SubME->getBase()->IgnoreParenImpCasts();
Richard Trieu1bc22c12013-09-13 03:20:53 +00002322 }
2323
Richard Trieufd687772013-09-16 20:46:50 +00002324 if (!isa<CXXThisExpr>(Base))
2325 return;
2326
Richard Trieu2d779b92014-10-01 03:44:58 +00002327 if (AddressOf && AllPODFields)
2328 return;
2329
Richard Trieu406e65c2013-09-20 03:03:06 +00002330 ValueDecl* FoundVD = FieldME->getMemberDecl();
2331
Richard Trieuef64e942013-10-25 00:56:00 +00002332 if (!Decls.count(FoundVD))
Richard Trieu406e65c2013-09-20 03:03:06 +00002333 return;
2334
Richard Trieuef64e942013-10-25 00:56:00 +00002335 const bool IsReference = FoundVD->getType()->isReferenceType();
Richard Trieu406e65c2013-09-20 03:03:06 +00002336
Richard Trieufa1d0a72014-10-17 20:56:10 +00002337 if (InitList && !AddressOf && FoundVD == InitListFieldDecl) {
2338 // Special checking for initializer lists.
2339 if (IsInitListMemberExprInitialized(ME, CheckReferenceOnly)) {
2340 return;
2341 }
2342 } else {
2343 // Prevent double warnings on use of unbounded references.
2344 if (CheckReferenceOnly && !IsReference)
2345 return;
2346 }
Richard Trieuef64e942013-10-25 00:56:00 +00002347
2348 unsigned diag = IsReference
2349 ? diag::warn_reference_field_is_uninit
2350 : diag::warn_field_is_uninit;
2351 S.Diag(FieldME->getExprLoc(), diag) << FoundVD;
2352 if (Constructor)
2353 S.Diag(Constructor->getLocation(),
2354 diag::note_uninit_in_this_constructor)
2355 << (Constructor->isDefaultConstructor() && Constructor->isImplicit());
2356
Hans Wennborg44fd70a2012-09-18 15:58:06 +00002357 }
2358
Richard Trieu2d779b92014-10-01 03:44:58 +00002359 void HandleValue(Expr *E, bool AddressOf) {
Hans Wennborg44fd70a2012-09-18 15:58:06 +00002360 E = E->IgnoreParens();
2361
2362 if (MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
Richard Trieu2d779b92014-10-01 03:44:58 +00002363 HandleMemberExpr(ME, false /*CheckReferenceOnly*/,
2364 AddressOf /*AddressOf*/);
Nick Lewyckyc363afb2012-11-15 08:19:20 +00002365 return;
Hans Wennborg44fd70a2012-09-18 15:58:06 +00002366 }
2367
2368 if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) {
Richard Trieu2d779b92014-10-01 03:44:58 +00002369 Visit(CO->getCond());
2370 HandleValue(CO->getTrueExpr(), AddressOf);
2371 HandleValue(CO->getFalseExpr(), AddressOf);
Hans Wennborg44fd70a2012-09-18 15:58:06 +00002372 return;
2373 }
2374
2375 if (BinaryConditionalOperator *BCO =
2376 dyn_cast<BinaryConditionalOperator>(E)) {
Richard Trieu2d779b92014-10-01 03:44:58 +00002377 Visit(BCO->getCond());
2378 HandleValue(BCO->getFalseExpr(), AddressOf);
Hans Wennborg44fd70a2012-09-18 15:58:06 +00002379 return;
2380 }
2381
Richard Trieuabf6ec42014-08-27 22:15:10 +00002382 if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) {
Richard Trieu2d779b92014-10-01 03:44:58 +00002383 HandleValue(OVE->getSourceExpr(), AddressOf);
Richard Trieuabf6ec42014-08-27 22:15:10 +00002384 return;
2385 }
2386
Hans Wennborg44fd70a2012-09-18 15:58:06 +00002387 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
2388 switch (BO->getOpcode()) {
2389 default:
Richard Trieu2d779b92014-10-01 03:44:58 +00002390 break;
Hans Wennborg44fd70a2012-09-18 15:58:06 +00002391 case(BO_PtrMemD):
2392 case(BO_PtrMemI):
Richard Trieu2d779b92014-10-01 03:44:58 +00002393 HandleValue(BO->getLHS(), AddressOf);
2394 Visit(BO->getRHS());
Hans Wennborg44fd70a2012-09-18 15:58:06 +00002395 return;
2396 case(BO_Comma):
Richard Trieu2d779b92014-10-01 03:44:58 +00002397 Visit(BO->getLHS());
2398 HandleValue(BO->getRHS(), AddressOf);
Hans Wennborg44fd70a2012-09-18 15:58:06 +00002399 return;
2400 }
2401 }
Richard Trieu2d779b92014-10-01 03:44:58 +00002402
2403 Visit(E);
Hans Wennborg44fd70a2012-09-18 15:58:06 +00002404 }
2405
Richard Trieufa1d0a72014-10-17 20:56:10 +00002406 void CheckInitListExpr(InitListExpr *ILE) {
2407 InitFieldIndex.push_back(0);
2408 for (auto Child : ILE->children()) {
2409 if (InitListExpr *SubList = dyn_cast<InitListExpr>(Child)) {
2410 CheckInitListExpr(SubList);
2411 } else {
2412 Visit(Child);
2413 }
2414 ++InitFieldIndex.back();
2415 }
2416 InitFieldIndex.pop_back();
2417 }
2418
Richard Trieu8d08a272014-08-28 03:23:47 +00002419 void CheckInitializer(Expr *E, const CXXConstructorDecl *FieldConstructor,
2420 FieldDecl *Field) {
2421 // Remove Decls that may have been initialized in the previous
2422 // initializer.
2423 for (ValueDecl* VD : DeclsToRemove)
2424 Decls.erase(VD);
Richard Trieu8d08a272014-08-28 03:23:47 +00002425 DeclsToRemove.clear();
Richard Trieufa1d0a72014-10-17 20:56:10 +00002426
Richard Trieu8d08a272014-08-28 03:23:47 +00002427 Constructor = FieldConstructor;
Richard Trieufa1d0a72014-10-17 20:56:10 +00002428 InitListExpr *ILE = dyn_cast<InitListExpr>(E);
2429
2430 if (ILE && Field) {
2431 InitList = true;
2432 InitListFieldDecl = Field;
2433 InitFieldIndex.clear();
2434 CheckInitListExpr(ILE);
2435 } else {
2436 InitList = false;
2437 Visit(E);
2438 }
2439
Richard Trieu8d08a272014-08-28 03:23:47 +00002440 if (Field)
2441 Decls.erase(Field);
2442 }
2443
Richard Trieu1bc22c12013-09-13 03:20:53 +00002444 void VisitMemberExpr(MemberExpr *ME) {
Richard Trieuef64e942013-10-25 00:56:00 +00002445 // All uses of unbounded reference fields will warn.
Richard Trieu2d779b92014-10-01 03:44:58 +00002446 HandleMemberExpr(ME, true /*CheckReferenceOnly*/, false /*AddressOf*/);
Richard Trieu1bc22c12013-09-13 03:20:53 +00002447 }
2448
Hans Wennborg44fd70a2012-09-18 15:58:06 +00002449 void VisitImplicitCastExpr(ImplicitCastExpr *E) {
Richard Trieu2d779b92014-10-01 03:44:58 +00002450 if (E->getCastKind() == CK_LValueToRValue) {
2451 HandleValue(E->getSubExpr(), false /*AddressOf*/);
2452 return;
2453 }
Hans Wennborg44fd70a2012-09-18 15:58:06 +00002454
2455 Inherited::VisitImplicitCastExpr(E);
2456 }
2457
Richard Trieu1bc22c12013-09-13 03:20:53 +00002458 void VisitCXXConstructExpr(CXXConstructExpr *E) {
Richard Trieu4834ad22014-08-12 21:05:04 +00002459 if (E->getConstructor()->isCopyConstructor()) {
2460 Expr *ArgExpr = E->getArg(0);
Richard Trieu2d779b92014-10-01 03:44:58 +00002461 if (InitListExpr *ILE = dyn_cast<InitListExpr>(ArgExpr))
2462 if (ILE->getNumInits() == 1)
2463 ArgExpr = ILE->getInit(0);
2464 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgExpr))
2465 if (ICE->getCastKind() == CK_NoOp)
Richard Trieu4834ad22014-08-12 21:05:04 +00002466 ArgExpr = ICE->getSubExpr();
Richard Trieu2d779b92014-10-01 03:44:58 +00002467 HandleValue(ArgExpr, false /*AddressOf*/);
2468 return;
Richard Trieu4834ad22014-08-12 21:05:04 +00002469 }
Richard Trieu1bc22c12013-09-13 03:20:53 +00002470 Inherited::VisitCXXConstructExpr(E);
2471 }
2472
Hans Wennborg44fd70a2012-09-18 15:58:06 +00002473 void VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
2474 Expr *Callee = E->getCallee();
Richard Trieu2d779b92014-10-01 03:44:58 +00002475 if (isa<MemberExpr>(Callee)) {
2476 HandleValue(Callee, false /*AddressOf*/);
Richard Trieu46847422014-11-01 00:46:54 +00002477 for (auto Arg : E->arguments())
2478 Visit(Arg);
Richard Trieu2d779b92014-10-01 03:44:58 +00002479 return;
2480 }
Hans Wennborg44fd70a2012-09-18 15:58:06 +00002481
2482 Inherited::VisitCXXMemberCallExpr(E);
2483 }
Richard Trieu406e65c2013-09-20 03:03:06 +00002484
Richard Trieu11fd0792014-08-26 04:30:55 +00002485 void VisitCallExpr(CallExpr *E) {
2486 // Treat std::move as a use.
2487 if (E->getNumArgs() == 1) {
2488 if (FunctionDecl *FD = E->getDirectCallee()) {
2489 if (FD->getIdentifier() && FD->getIdentifier()->isStr("move")) {
Richard Trieu2d779b92014-10-01 03:44:58 +00002490 HandleValue(E->getArg(0), false /*AddressOf*/);
2491 return;
Richard Trieu11fd0792014-08-26 04:30:55 +00002492 }
2493 }
2494 }
2495
2496 Inherited::VisitCallExpr(E);
2497 }
2498
Richard Trieud4a01362014-10-31 21:10:22 +00002499 void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
2500 Expr *Callee = E->getCallee();
2501
2502 if (isa<UnresolvedLookupExpr>(Callee))
2503 return Inherited::VisitCXXOperatorCallExpr(E);
2504
2505 Visit(Callee);
2506 for (auto Arg : E->arguments())
2507 HandleValue(Arg->IgnoreParenImpCasts(), false /*AddressOf*/);
2508 }
2509
Richard Trieu406e65c2013-09-20 03:03:06 +00002510 void VisitBinaryOperator(BinaryOperator *E) {
2511 // If a field assignment is detected, remove the field from the
2512 // uninitiailized field set.
2513 if (E->getOpcode() == BO_Assign)
2514 if (MemberExpr *ME = dyn_cast<MemberExpr>(E->getLHS()))
2515 if (FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl()))
Richard Trieuef64e942013-10-25 00:56:00 +00002516 if (!FD->getType()->isReferenceType())
Richard Trieu8d08a272014-08-28 03:23:47 +00002517 DeclsToRemove.push_back(FD);
Richard Trieu406e65c2013-09-20 03:03:06 +00002518
Richard Trieu52b8b602014-09-25 01:15:40 +00002519 if (E->isCompoundAssignmentOp()) {
Richard Trieu2d779b92014-10-01 03:44:58 +00002520 HandleValue(E->getLHS(), false /*AddressOf*/);
2521 Visit(E->getRHS());
2522 return;
Richard Trieu52b8b602014-09-25 01:15:40 +00002523 }
2524
Richard Trieu406e65c2013-09-20 03:03:06 +00002525 Inherited::VisitBinaryOperator(E);
2526 }
Richard Trieu52b8b602014-09-25 01:15:40 +00002527
2528 void VisitUnaryOperator(UnaryOperator *E) {
Richard Trieu2d779b92014-10-01 03:44:58 +00002529 if (E->isIncrementDecrementOp()) {
2530 HandleValue(E->getSubExpr(), false /*AddressOf*/);
2531 return;
2532 }
2533 if (E->getOpcode() == UO_AddrOf) {
2534 if (MemberExpr *ME = dyn_cast<MemberExpr>(E->getSubExpr())) {
2535 HandleValue(ME->getBase(), true /*AddressOf*/);
2536 return;
2537 }
2538 }
Richard Trieu52b8b602014-09-25 01:15:40 +00002539
2540 Inherited::VisitUnaryOperator(E);
2541 }
Hans Wennborg44fd70a2012-09-18 15:58:06 +00002542 };
Richard Trieuef64e942013-10-25 00:56:00 +00002543
2544 // Diagnose value-uses of fields to initialize themselves, e.g.
2545 // foo(foo)
2546 // where foo is not also a parameter to the constructor.
2547 // Also diagnose across field uninitialized use such as
2548 // x(y), y(x)
2549 // TODO: implement -Wuninitialized and fold this into that framework.
2550 static void DiagnoseUninitializedFields(
2551 Sema &SemaRef, const CXXConstructorDecl *Constructor) {
2552
Alp Tokerd4a3f0e2014-06-15 23:30:39 +00002553 if (SemaRef.getDiagnostics().isIgnored(diag::warn_field_is_uninit,
2554 Constructor->getLocation())) {
Richard Trieuef64e942013-10-25 00:56:00 +00002555 return;
2556 }
2557
2558 if (Constructor->isInvalidDecl())
2559 return;
2560
2561 const CXXRecordDecl *RD = Constructor->getParent();
2562
Richard Trieu353a4b42014-10-22 05:21:59 +00002563 if (RD->getDescribedClassTemplate())
Richard Trieu277ace02014-10-22 02:52:00 +00002564 return;
2565
Richard Trieuef64e942013-10-25 00:56:00 +00002566 // Holds fields that are uninitialized.
2567 llvm::SmallPtrSet<ValueDecl*, 4> UninitializedFields;
2568
2569 // At the beginning, all fields are uninitialized.
Aaron Ballman629afae2014-03-07 19:56:05 +00002570 for (auto *I : RD->decls()) {
2571 if (auto *FD = dyn_cast<FieldDecl>(I)) {
Richard Trieuef64e942013-10-25 00:56:00 +00002572 UninitializedFields.insert(FD);
Aaron Ballman629afae2014-03-07 19:56:05 +00002573 } else if (auto *IFD = dyn_cast<IndirectFieldDecl>(I)) {
Richard Trieuef64e942013-10-25 00:56:00 +00002574 UninitializedFields.insert(IFD->getAnonField());
2575 }
2576 }
2577
Richard Trieu8d08a272014-08-28 03:23:47 +00002578 if (UninitializedFields.empty())
2579 return;
2580
2581 UninitializedFieldVisitor UninitializedChecker(SemaRef,
2582 UninitializedFields);
2583
Aaron Ballman0ad78302014-03-13 17:34:31 +00002584 for (const auto *FieldInit : Constructor->inits()) {
Richard Trieu8d08a272014-08-28 03:23:47 +00002585 if (UninitializedFields.empty())
2586 break;
2587
Aaron Ballman0ad78302014-03-13 17:34:31 +00002588 Expr *InitExpr = FieldInit->getInit();
Richard Trieu8d08a272014-08-28 03:23:47 +00002589 if (!InitExpr)
2590 continue;
Richard Trieuef64e942013-10-25 00:56:00 +00002591
Richard Trieu8d08a272014-08-28 03:23:47 +00002592 if (CXXDefaultInitExpr *Default =
2593 dyn_cast<CXXDefaultInitExpr>(InitExpr)) {
2594 InitExpr = Default->getExpr();
2595 if (!InitExpr)
2596 continue;
2597 // In class initializers will point to the constructor.
2598 UninitializedChecker.CheckInitializer(InitExpr, Constructor,
2599 FieldInit->getAnyMember());
2600 } else {
2601 UninitializedChecker.CheckInitializer(InitExpr, nullptr,
2602 FieldInit->getAnyMember());
2603 }
Richard Trieuef64e942013-10-25 00:56:00 +00002604 }
Hans Wennborg44fd70a2012-09-18 15:58:06 +00002605 }
2606} // namespace
2607
Richard Smith74108172014-01-17 03:11:34 +00002608/// \brief Enter a new C++ default initializer scope. After calling this, the
2609/// caller must call \ref ActOnFinishCXXInClassMemberInitializer, even if
2610/// parsing or instantiating the initializer failed.
2611void Sema::ActOnStartCXXInClassMemberInitializer() {
2612 // Create a synthetic function scope to represent the call to the constructor
2613 // that notionally surrounds a use of this initializer.
2614 PushFunctionScope();
2615}
2616
2617/// \brief This is invoked after parsing an in-class initializer for a
2618/// non-static C++ class member, and after instantiating an in-class initializer
2619/// in a class template. Such actions are deferred until the class is complete.
2620void Sema::ActOnFinishCXXInClassMemberInitializer(Decl *D,
2621 SourceLocation InitLoc,
2622 Expr *InitExpr) {
2623 // Pop the notional constructor scope we created earlier.
Craig Topperc3ec1492014-05-26 06:22:03 +00002624 PopFunctionScopeInfo(nullptr, D);
Richard Smith74108172014-01-17 03:11:34 +00002625
Richard Smith938f40b2011-06-11 17:19:42 +00002626 FieldDecl *FD = cast<FieldDecl>(D);
Richard Smith2b013182012-06-10 03:12:00 +00002627 assert(FD->getInClassInitStyle() != ICIS_NoInit &&
2628 "must set init style when field is created");
Richard Smith938f40b2011-06-11 17:19:42 +00002629
2630 if (!InitExpr) {
2631 FD->setInvalidDecl();
2632 FD->removeInClassInitializer();
2633 return;
2634 }
2635
Peter Collingbourne9f58d7b2011-10-23 18:59:44 +00002636 if (DiagnoseUnexpandedParameterPack(InitExpr, UPPC_Initializer)) {
2637 FD->setInvalidDecl();
2638 FD->removeInClassInitializer();
2639 return;
2640 }
2641
Richard Smith938f40b2011-06-11 17:19:42 +00002642 ExprResult Init = InitExpr;
Richard Smithd59b8322012-12-19 01:39:02 +00002643 if (!FD->getType()->isDependentType() && !InitExpr->isTypeDependent()) {
Sebastian Redleef474c2012-02-22 10:50:08 +00002644 InitializedEntity Entity = InitializedEntity::InitializeMember(FD);
Richard Smith2b013182012-06-10 03:12:00 +00002645 InitializationKind Kind = FD->getInClassInitStyle() == ICIS_ListInit
Sebastian Redleef474c2012-02-22 10:50:08 +00002646 ? InitializationKind::CreateDirectList(InitExpr->getLocStart())
Richard Smith2b013182012-06-10 03:12:00 +00002647 : InitializationKind::CreateCopy(InitExpr->getLocStart(), InitLoc);
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00002648 InitializationSequence Seq(*this, Entity, Kind, InitExpr);
2649 Init = Seq.Perform(*this, Entity, Kind, InitExpr);
Richard Smith938f40b2011-06-11 17:19:42 +00002650 if (Init.isInvalid()) {
2651 FD->setInvalidDecl();
2652 return;
2653 }
Richard Smith938f40b2011-06-11 17:19:42 +00002654 }
2655
Richard Smith945f8d32013-01-14 22:39:08 +00002656 // C++11 [class.base.init]p7:
Richard Smith938f40b2011-06-11 17:19:42 +00002657 // The initialization of each base and member constitutes a
2658 // full-expression.
Nikola Smiljanic01a75982014-05-29 10:55:11 +00002659 Init = ActOnFinishFullExpr(Init.get(), InitLoc);
Richard Smith938f40b2011-06-11 17:19:42 +00002660 if (Init.isInvalid()) {
2661 FD->setInvalidDecl();
2662 return;
2663 }
2664
Nikola Smiljanic01a75982014-05-29 10:55:11 +00002665 InitExpr = Init.get();
Richard Smith938f40b2011-06-11 17:19:42 +00002666
2667 FD->setInClassInitializer(InitExpr);
2668}
2669
Douglas Gregor15e77a22009-12-31 09:10:24 +00002670/// \brief Find the direct and/or virtual base specifiers that
2671/// correspond to the given base type, for use in base initialization
2672/// within a constructor.
2673static bool FindBaseInitializer(Sema &SemaRef,
2674 CXXRecordDecl *ClassDecl,
2675 QualType BaseType,
2676 const CXXBaseSpecifier *&DirectBaseSpec,
2677 const CXXBaseSpecifier *&VirtualBaseSpec) {
2678 // First, check for a direct base class.
Craig Topperc3ec1492014-05-26 06:22:03 +00002679 DirectBaseSpec = nullptr;
Aaron Ballman574705e2014-03-13 15:41:46 +00002680 for (const auto &Base : ClassDecl->bases()) {
2681 if (SemaRef.Context.hasSameUnqualifiedType(BaseType, Base.getType())) {
Douglas Gregor15e77a22009-12-31 09:10:24 +00002682 // We found a direct base of this type. That's what we're
2683 // initializing.
Aaron Ballman574705e2014-03-13 15:41:46 +00002684 DirectBaseSpec = &Base;
Douglas Gregor15e77a22009-12-31 09:10:24 +00002685 break;
2686 }
2687 }
2688
2689 // Check for a virtual base class.
2690 // FIXME: We might be able to short-circuit this if we know in advance that
2691 // there are no virtual bases.
Craig Topperc3ec1492014-05-26 06:22:03 +00002692 VirtualBaseSpec = nullptr;
Douglas Gregor15e77a22009-12-31 09:10:24 +00002693 if (!DirectBaseSpec || !DirectBaseSpec->isVirtual()) {
2694 // We haven't found a base yet; search the class hierarchy for a
2695 // virtual base class.
2696 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
2697 /*DetectVirtual=*/false);
2698 if (SemaRef.IsDerivedFrom(SemaRef.Context.getTypeDeclType(ClassDecl),
2699 BaseType, Paths)) {
2700 for (CXXBasePaths::paths_iterator Path = Paths.begin();
2701 Path != Paths.end(); ++Path) {
2702 if (Path->back().Base->isVirtual()) {
2703 VirtualBaseSpec = Path->back().Base;
2704 break;
2705 }
2706 }
2707 }
2708 }
2709
2710 return DirectBaseSpec || VirtualBaseSpec;
2711}
2712
Sebastian Redla74948d2011-09-24 17:48:25 +00002713/// \brief Handle a C++ member initializer using braced-init-list syntax.
2714MemInitResult
2715Sema::ActOnMemInitializer(Decl *ConstructorD,
2716 Scope *S,
2717 CXXScopeSpec &SS,
2718 IdentifierInfo *MemberOrBase,
2719 ParsedType TemplateTypeTy,
David Blaikie186a8892012-01-24 06:03:59 +00002720 const DeclSpec &DS,
Sebastian Redla74948d2011-09-24 17:48:25 +00002721 SourceLocation IdLoc,
2722 Expr *InitList,
2723 SourceLocation EllipsisLoc) {
2724 return BuildMemInitializer(ConstructorD, S, SS, MemberOrBase, TemplateTypeTy,
Sebastian Redla9351792012-02-11 23:51:47 +00002725 DS, IdLoc, InitList,
David Blaikie186a8892012-01-24 06:03:59 +00002726 EllipsisLoc);
Sebastian Redla74948d2011-09-24 17:48:25 +00002727}
2728
2729/// \brief Handle a C++ member initializer using parentheses syntax.
John McCallfaf5fb42010-08-26 23:41:50 +00002730MemInitResult
John McCall48871652010-08-21 09:40:31 +00002731Sema::ActOnMemInitializer(Decl *ConstructorD,
Douglas Gregore8381c02008-11-05 04:29:56 +00002732 Scope *S,
Jeffrey Yasskinc76498d2010-04-08 16:38:48 +00002733 CXXScopeSpec &SS,
Douglas Gregore8381c02008-11-05 04:29:56 +00002734 IdentifierInfo *MemberOrBase,
John McCallba7bf592010-08-24 05:47:05 +00002735 ParsedType TemplateTypeTy,
David Blaikie186a8892012-01-24 06:03:59 +00002736 const DeclSpec &DS,
Douglas Gregore8381c02008-11-05 04:29:56 +00002737 SourceLocation IdLoc,
2738 SourceLocation LParenLoc,
Dmitri Gribenko139474d2013-05-09 23:51:52 +00002739 ArrayRef<Expr *> Args,
Douglas Gregor44e7df62011-01-04 00:32:56 +00002740 SourceLocation RParenLoc,
2741 SourceLocation EllipsisLoc) {
Benjamin Kramerc215e762012-08-24 11:54:20 +00002742 Expr *List = new (Context) ParenListExpr(Context, LParenLoc,
Dmitri Gribenko139474d2013-05-09 23:51:52 +00002743 Args, RParenLoc);
Sebastian Redla74948d2011-09-24 17:48:25 +00002744 return BuildMemInitializer(ConstructorD, S, SS, MemberOrBase, TemplateTypeTy,
Sebastian Redla9351792012-02-11 23:51:47 +00002745 DS, IdLoc, List, EllipsisLoc);
Sebastian Redla74948d2011-09-24 17:48:25 +00002746}
2747
Kaelyn Uhrain2d317ed2012-01-11 19:37:46 +00002748namespace {
2749
Kaelyn Uhrain8811b392012-01-11 21:17:51 +00002750// Callback to only accept typo corrections that can be a valid C++ member
2751// intializer: either a non-static field member or a base class.
Kaelyn Uhrain2d317ed2012-01-11 19:37:46 +00002752class MemInitializerValidatorCCC : public CorrectionCandidateCallback {
Benjamin Kramer8bf44352013-07-24 15:28:33 +00002753public:
Kaelyn Uhrain2d317ed2012-01-11 19:37:46 +00002754 explicit MemInitializerValidatorCCC(CXXRecordDecl *ClassDecl)
2755 : ClassDecl(ClassDecl) {}
2756
Craig Toppera798a9d2014-03-02 09:32:10 +00002757 bool ValidateCandidate(const TypoCorrection &candidate) override {
Kaelyn Uhrain2d317ed2012-01-11 19:37:46 +00002758 if (NamedDecl *ND = candidate.getCorrectionDecl()) {
2759 if (FieldDecl *Member = dyn_cast<FieldDecl>(ND))
2760 return Member->getDeclContext()->getRedeclContext()->Equals(ClassDecl);
Benjamin Kramer8bf44352013-07-24 15:28:33 +00002761 return isa<TypeDecl>(ND);
Kaelyn Uhrain2d317ed2012-01-11 19:37:46 +00002762 }
2763 return false;
2764 }
2765
Benjamin Kramer8bf44352013-07-24 15:28:33 +00002766private:
Kaelyn Uhrain2d317ed2012-01-11 19:37:46 +00002767 CXXRecordDecl *ClassDecl;
2768};
2769
2770}
2771
Sebastian Redla74948d2011-09-24 17:48:25 +00002772/// \brief Handle a C++ member initializer.
2773MemInitResult
2774Sema::BuildMemInitializer(Decl *ConstructorD,
2775 Scope *S,
2776 CXXScopeSpec &SS,
2777 IdentifierInfo *MemberOrBase,
2778 ParsedType TemplateTypeTy,
David Blaikie186a8892012-01-24 06:03:59 +00002779 const DeclSpec &DS,
Sebastian Redla74948d2011-09-24 17:48:25 +00002780 SourceLocation IdLoc,
Sebastian Redla9351792012-02-11 23:51:47 +00002781 Expr *Init,
Sebastian Redla74948d2011-09-24 17:48:25 +00002782 SourceLocation EllipsisLoc) {
Douglas Gregor71a57182009-06-22 23:20:33 +00002783 if (!ConstructorD)
2784 return true;
Mike Stump11289f42009-09-09 15:08:12 +00002785
Douglas Gregorc8c277a2009-08-24 11:57:43 +00002786 AdjustDeclIfTemplate(ConstructorD);
Mike Stump11289f42009-09-09 15:08:12 +00002787
2788 CXXConstructorDecl *Constructor
John McCall48871652010-08-21 09:40:31 +00002789 = dyn_cast<CXXConstructorDecl>(ConstructorD);
Douglas Gregore8381c02008-11-05 04:29:56 +00002790 if (!Constructor) {
2791 // The user wrote a constructor initializer on a function that is
2792 // not a C++ constructor. Ignore the error for now, because we may
2793 // have more member initializers coming; we'll diagnose it just
2794 // once in ActOnMemInitializers.
2795 return true;
2796 }
2797
2798 CXXRecordDecl *ClassDecl = Constructor->getParent();
2799
2800 // C++ [class.base.init]p2:
2801 // Names in a mem-initializer-id are looked up in the scope of the
Nick Lewycky9331ed82010-11-20 01:29:55 +00002802 // constructor's class and, if not found in that scope, are looked
2803 // up in the scope containing the constructor's definition.
2804 // [Note: if the constructor's class contains a member with the
2805 // same name as a direct or virtual base class of the class, a
2806 // mem-initializer-id naming the member or base class and composed
2807 // of a single identifier refers to the class member. A
Douglas Gregore8381c02008-11-05 04:29:56 +00002808 // mem-initializer-id for the hidden base class may be specified
2809 // using a qualified name. ]
Fariborz Jahanianc1fc3ec2009-07-01 19:21:19 +00002810 if (!SS.getScopeRep() && !TemplateTypeTy) {
Fariborz Jahanian302bb662009-06-30 23:26:25 +00002811 // Look for a member, first.
Mike Stump11289f42009-09-09 15:08:12 +00002812 DeclContext::lookup_result Result
Fariborz Jahanian302bb662009-06-30 23:26:25 +00002813 = ClassDecl->lookup(MemberOrBase);
David Blaikieff7d47a2012-12-19 00:45:41 +00002814 if (!Result.empty()) {
Peter Collingbourne05156e32011-10-23 18:59:37 +00002815 ValueDecl *Member;
David Blaikieff7d47a2012-12-19 00:45:41 +00002816 if ((Member = dyn_cast<FieldDecl>(Result.front())) ||
2817 (Member = dyn_cast<IndirectFieldDecl>(Result.front()))) {
Douglas Gregor44e7df62011-01-04 00:32:56 +00002818 if (EllipsisLoc.isValid())
2819 Diag(EllipsisLoc, diag::err_pack_expansion_member_init)
Sebastian Redla9351792012-02-11 23:51:47 +00002820 << MemberOrBase
2821 << SourceRange(IdLoc, Init->getSourceRange().getEnd());
Sebastian Redla74948d2011-09-24 17:48:25 +00002822
Sebastian Redla9351792012-02-11 23:51:47 +00002823 return BuildMemberInitializer(Member, Init, IdLoc);
Douglas Gregor44e7df62011-01-04 00:32:56 +00002824 }
Francois Pichetd583da02010-12-04 09:14:42 +00002825 }
Douglas Gregore8381c02008-11-05 04:29:56 +00002826 }
Douglas Gregore8381c02008-11-05 04:29:56 +00002827 // It didn't name a member, so see if it names a class.
Douglas Gregorc8c44b5d2009-12-02 22:36:29 +00002828 QualType BaseType;
Craig Topperc3ec1492014-05-26 06:22:03 +00002829 TypeSourceInfo *TInfo = nullptr;
John McCallb5a0d312009-12-21 10:41:20 +00002830
2831 if (TemplateTypeTy) {
John McCallbcd03502009-12-07 02:54:59 +00002832 BaseType = GetTypeFromParser(TemplateTypeTy, &TInfo);
David Blaikie186a8892012-01-24 06:03:59 +00002833 } else if (DS.getTypeSpecType() == TST_decltype) {
2834 BaseType = BuildDecltypeType(DS.getRepAsExpr(), DS.getTypeSpecTypeLoc());
John McCallb5a0d312009-12-21 10:41:20 +00002835 } else {
2836 LookupResult R(*this, MemberOrBase, IdLoc, LookupOrdinaryName);
2837 LookupParsedName(R, S, &SS);
2838
2839 TypeDecl *TyD = R.getAsSingle<TypeDecl>();
2840 if (!TyD) {
2841 if (R.isAmbiguous()) return true;
2842
John McCallda6841b2010-04-09 19:01:14 +00002843 // We don't want access-control diagnostics here.
2844 R.suppressDiagnostics();
2845
Douglas Gregora3b624a2010-01-19 06:46:48 +00002846 if (SS.isSet() && isDependentScopeSpecifier(SS)) {
2847 bool NotUnknownSpecialization = false;
2848 DeclContext *DC = computeDeclContext(SS, false);
2849 if (CXXRecordDecl *Record = dyn_cast_or_null<CXXRecordDecl>(DC))
2850 NotUnknownSpecialization = !Record->hasAnyDependentBases();
2851
2852 if (!NotUnknownSpecialization) {
2853 // When the scope specifier can refer to a member of an unknown
2854 // specialization, we take it as a type name.
Douglas Gregor9cbc22b2011-02-28 22:42:13 +00002855 BaseType = CheckTypenameType(ETK_None, SourceLocation(),
2856 SS.getWithLocInContext(Context),
2857 *MemberOrBase, IdLoc);
Douglas Gregor281c4862010-03-07 23:26:22 +00002858 if (BaseType.isNull())
2859 return true;
2860
Douglas Gregora3b624a2010-01-19 06:46:48 +00002861 R.clear();
Douglas Gregorc048c522010-06-29 19:27:42 +00002862 R.setLookupName(MemberOrBase);
Douglas Gregora3b624a2010-01-19 06:46:48 +00002863 }
2864 }
2865
Douglas Gregor15e77a22009-12-31 09:10:24 +00002866 // If no results were found, try to correct typos.
Douglas Gregorc2fa1692011-06-28 16:20:02 +00002867 TypoCorrection Corr;
Douglas Gregora3b624a2010-01-19 06:46:48 +00002868 if (R.empty() && BaseType.isNull() &&
Kaelyn Takata89c881b2014-10-27 18:07:29 +00002869 (Corr = CorrectTypo(
2870 R.getLookupNameInfo(), R.getLookupKind(), S, &SS,
2871 llvm::make_unique<MemInitializerValidatorCCC>(ClassDecl),
2872 CTK_ErrorRecovery, ClassDecl))) {
Douglas Gregorc2fa1692011-06-28 16:20:02 +00002873 if (FieldDecl *Member = Corr.getCorrectionDeclAs<FieldDecl>()) {
Kaelyn Uhrain2d317ed2012-01-11 19:37:46 +00002874 // We have found a non-static data member with a similar
2875 // name to what was typed; complain and initialize that
2876 // member.
Richard Smithf9b15102013-08-17 00:46:16 +00002877 diagnoseTypo(Corr,
2878 PDiag(diag::err_mem_init_not_member_or_class_suggest)
2879 << MemberOrBase << true);
Sebastian Redla9351792012-02-11 23:51:47 +00002880 return BuildMemberInitializer(Member, Init, IdLoc);
Douglas Gregorc2fa1692011-06-28 16:20:02 +00002881 } else if (TypeDecl *Type = Corr.getCorrectionDeclAs<TypeDecl>()) {
Douglas Gregor15e77a22009-12-31 09:10:24 +00002882 const CXXBaseSpecifier *DirectBaseSpec;
2883 const CXXBaseSpecifier *VirtualBaseSpec;
2884 if (FindBaseInitializer(*this, ClassDecl,
2885 Context.getTypeDeclType(Type),
2886 DirectBaseSpec, VirtualBaseSpec)) {
2887 // We have found a direct or virtual base class with a
2888 // similar name to what was typed; complain and initialize
2889 // that base class.
Richard Smithf9b15102013-08-17 00:46:16 +00002890 diagnoseTypo(Corr,
2891 PDiag(diag::err_mem_init_not_member_or_class_suggest)
2892 << MemberOrBase << false,
2893 PDiag() /*Suppress note, we provide our own.*/);
Douglas Gregor43a08572010-01-07 00:26:25 +00002894
Richard Smithf9b15102013-08-17 00:46:16 +00002895 const CXXBaseSpecifier *BaseSpec = DirectBaseSpec ? DirectBaseSpec
2896 : VirtualBaseSpec;
Daniel Dunbar62ee6412012-03-09 18:35:03 +00002897 Diag(BaseSpec->getLocStart(),
Douglas Gregor43a08572010-01-07 00:26:25 +00002898 diag::note_base_class_specified_here)
2899 << BaseSpec->getType()
2900 << BaseSpec->getSourceRange();
2901
Douglas Gregor15e77a22009-12-31 09:10:24 +00002902 TyD = Type;
2903 }
2904 }
2905 }
2906
Douglas Gregora3b624a2010-01-19 06:46:48 +00002907 if (!TyD && BaseType.isNull()) {
Douglas Gregor15e77a22009-12-31 09:10:24 +00002908 Diag(IdLoc, diag::err_mem_init_not_member_or_class)
Sebastian Redla9351792012-02-11 23:51:47 +00002909 << MemberOrBase << SourceRange(IdLoc,Init->getSourceRange().getEnd());
Douglas Gregor15e77a22009-12-31 09:10:24 +00002910 return true;
2911 }
John McCallb5a0d312009-12-21 10:41:20 +00002912 }
2913
Douglas Gregora3b624a2010-01-19 06:46:48 +00002914 if (BaseType.isNull()) {
2915 BaseType = Context.getTypeDeclType(TyD);
Aaron Ballman4a979672014-01-03 13:56:08 +00002916 if (SS.isSet())
Douglas Gregora3b624a2010-01-19 06:46:48 +00002917 // FIXME: preserve source range information
Aaron Ballman4a979672014-01-03 13:56:08 +00002918 BaseType = Context.getElaboratedType(ETK_None, SS.getScopeRep(),
2919 BaseType);
John McCallb5a0d312009-12-21 10:41:20 +00002920 }
2921 }
Mike Stump11289f42009-09-09 15:08:12 +00002922
John McCallbcd03502009-12-07 02:54:59 +00002923 if (!TInfo)
2924 TInfo = Context.getTrivialTypeSourceInfo(BaseType, IdLoc);
Douglas Gregore8381c02008-11-05 04:29:56 +00002925
Sebastian Redla9351792012-02-11 23:51:47 +00002926 return BuildBaseInitializer(BaseType, TInfo, Init, ClassDecl, EllipsisLoc);
Eli Friedman8e1433b2009-07-29 19:44:27 +00002927}
2928
Chandler Carruth599deef2011-09-03 01:14:15 +00002929/// Checks a member initializer expression for cases where reference (or
2930/// pointer) members are bound to by-value parameters (or their addresses).
Chandler Carruth599deef2011-09-03 01:14:15 +00002931static void CheckForDanglingReferenceOrPointer(Sema &S, ValueDecl *Member,
2932 Expr *Init,
2933 SourceLocation IdLoc) {
2934 QualType MemberTy = Member->getType();
2935
2936 // We only handle pointers and references currently.
2937 // FIXME: Would this be relevant for ObjC object pointers? Or block pointers?
2938 if (!MemberTy->isReferenceType() && !MemberTy->isPointerType())
2939 return;
2940
2941 const bool IsPointer = MemberTy->isPointerType();
2942 if (IsPointer) {
2943 if (const UnaryOperator *Op
2944 = dyn_cast<UnaryOperator>(Init->IgnoreParenImpCasts())) {
2945 // The only case we're worried about with pointers requires taking the
2946 // address.
2947 if (Op->getOpcode() != UO_AddrOf)
2948 return;
2949
2950 Init = Op->getSubExpr();
2951 } else {
2952 // We only handle address-of expression initializers for pointers.
2953 return;
2954 }
2955 }
2956
Richard Smithe3b28bc2013-06-12 21:51:50 +00002957 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Init->IgnoreParens())) {
Chandler Carruthd551d4e2011-09-03 02:21:57 +00002958 // We only warn when referring to a non-reference parameter declaration.
2959 const ParmVarDecl *Parameter = dyn_cast<ParmVarDecl>(DRE->getDecl());
2960 if (!Parameter || Parameter->getType()->isReferenceType())
Chandler Carruth599deef2011-09-03 01:14:15 +00002961 return;
2962
2963 S.Diag(Init->getExprLoc(),
2964 IsPointer ? diag::warn_init_ptr_member_to_parameter_addr
2965 : diag::warn_bind_ref_member_to_parameter)
2966 << Member << Parameter << Init->getSourceRange();
Chandler Carruthd551d4e2011-09-03 02:21:57 +00002967 } else {
2968 // Other initializers are fine.
2969 return;
Chandler Carruth599deef2011-09-03 01:14:15 +00002970 }
Chandler Carruthd551d4e2011-09-03 02:21:57 +00002971
2972 S.Diag(Member->getLocation(), diag::note_ref_or_ptr_member_declared_here)
2973 << (unsigned)IsPointer;
Chandler Carruth599deef2011-09-03 01:14:15 +00002974}
2975
John McCallfaf5fb42010-08-26 23:41:50 +00002976MemInitResult
Sebastian Redla9351792012-02-11 23:51:47 +00002977Sema::BuildMemberInitializer(ValueDecl *Member, Expr *Init,
Sebastian Redla74948d2011-09-24 17:48:25 +00002978 SourceLocation IdLoc) {
Chandler Carruthd44c3102010-12-06 09:23:57 +00002979 FieldDecl *DirectMember = dyn_cast<FieldDecl>(Member);
2980 IndirectFieldDecl *IndirectMember = dyn_cast<IndirectFieldDecl>(Member);
2981 assert((DirectMember || IndirectMember) &&
Francois Pichetd583da02010-12-04 09:14:42 +00002982 "Member must be a FieldDecl or IndirectFieldDecl");
2983
Sebastian Redla9351792012-02-11 23:51:47 +00002984 if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer))
Peter Collingbourne9f58d7b2011-10-23 18:59:44 +00002985 return true;
2986
Douglas Gregor266bb5f2010-11-05 22:21:31 +00002987 if (Member->isInvalidDecl())
2988 return true;
Chandler Carruthd44c3102010-12-06 09:23:57 +00002989
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00002990 MultiExprArg Args;
Sebastian Redla9351792012-02-11 23:51:47 +00002991 if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00002992 Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
Richard Smithd59b8322012-12-19 01:39:02 +00002993 } else if (InitListExpr *InitList = dyn_cast<InitListExpr>(Init)) {
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00002994 Args = MultiExprArg(InitList->getInits(), InitList->getNumInits());
Richard Smithd59b8322012-12-19 01:39:02 +00002995 } else {
2996 // Template instantiation doesn't reconstruct ParenListExprs for us.
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00002997 Args = Init;
Sebastian Redla9351792012-02-11 23:51:47 +00002998 }
Daniel Jasper0baec5492012-06-06 08:32:04 +00002999
Sebastian Redla9351792012-02-11 23:51:47 +00003000 SourceRange InitRange = Init->getSourceRange();
Eli Friedman8e1433b2009-07-29 19:44:27 +00003001
Sebastian Redla9351792012-02-11 23:51:47 +00003002 if (Member->getType()->isDependentType() || Init->isTypeDependent()) {
Douglas Gregor7ae2d772010-01-31 09:12:51 +00003003 // Can't check initialization for a member of dependent type or when
3004 // any of the arguments are type-dependent expressions.
John McCall31168b02011-06-15 23:02:42 +00003005 DiscardCleanupsInEvaluationContext();
Chandler Carruthd44c3102010-12-06 09:23:57 +00003006 } else {
Sebastian Redl0501c632012-02-12 16:37:36 +00003007 bool InitList = false;
3008 if (isa<InitListExpr>(Init)) {
3009 InitList = true;
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00003010 Args = Init;
Sebastian Redl0501c632012-02-12 16:37:36 +00003011 }
3012
Chandler Carruthd44c3102010-12-06 09:23:57 +00003013 // Initialize the member.
3014 InitializedEntity MemberEntity =
Craig Topperc3ec1492014-05-26 06:22:03 +00003015 DirectMember ? InitializedEntity::InitializeMember(DirectMember, nullptr)
3016 : InitializedEntity::InitializeMember(IndirectMember,
3017 nullptr);
Chandler Carruthd44c3102010-12-06 09:23:57 +00003018 InitializationKind Kind =
Sebastian Redl0501c632012-02-12 16:37:36 +00003019 InitList ? InitializationKind::CreateDirectList(IdLoc)
3020 : InitializationKind::CreateDirect(IdLoc, InitRange.getBegin(),
3021 InitRange.getEnd());
John McCallacf0ee52010-10-08 02:01:28 +00003022
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00003023 InitializationSequence InitSeq(*this, MemberEntity, Kind, Args);
Craig Topperc3ec1492014-05-26 06:22:03 +00003024 ExprResult MemberInit = InitSeq.Perform(*this, MemberEntity, Kind, Args,
3025 nullptr);
Chandler Carruthd44c3102010-12-06 09:23:57 +00003026 if (MemberInit.isInvalid())
3027 return true;
3028
Richard Smith736a9472013-06-12 20:42:33 +00003029 CheckForDanglingReferenceOrPointer(*this, Member, MemberInit.get(), IdLoc);
3030
Richard Smith945f8d32013-01-14 22:39:08 +00003031 // C++11 [class.base.init]p7:
Chandler Carruthd44c3102010-12-06 09:23:57 +00003032 // The initialization of each base and member constitutes a
3033 // full-expression.
Richard Smith945f8d32013-01-14 22:39:08 +00003034 MemberInit = ActOnFinishFullExpr(MemberInit.get(), InitRange.getBegin());
Chandler Carruthd44c3102010-12-06 09:23:57 +00003035 if (MemberInit.isInvalid())
3036 return true;
3037
Richard Smithd59b8322012-12-19 01:39:02 +00003038 Init = MemberInit.get();
Douglas Gregor7ae2d772010-01-31 09:12:51 +00003039 }
3040
Chandler Carruthd44c3102010-12-06 09:23:57 +00003041 if (DirectMember) {
Sebastian Redla9351792012-02-11 23:51:47 +00003042 return new (Context) CXXCtorInitializer(Context, DirectMember, IdLoc,
3043 InitRange.getBegin(), Init,
3044 InitRange.getEnd());
Chandler Carruthd44c3102010-12-06 09:23:57 +00003045 } else {
Sebastian Redla9351792012-02-11 23:51:47 +00003046 return new (Context) CXXCtorInitializer(Context, IndirectMember, IdLoc,
3047 InitRange.getBegin(), Init,
3048 InitRange.getEnd());
Chandler Carruthd44c3102010-12-06 09:23:57 +00003049 }
Eli Friedman8e1433b2009-07-29 19:44:27 +00003050}
3051
John McCallfaf5fb42010-08-26 23:41:50 +00003052MemInitResult
Sebastian Redla9351792012-02-11 23:51:47 +00003053Sema::BuildDelegatingInitializer(TypeSourceInfo *TInfo, Expr *Init,
Alexis Huntc5575cc2011-02-26 19:13:13 +00003054 CXXRecordDecl *ClassDecl) {
Douglas Gregord73f3dd2011-11-01 01:16:03 +00003055 SourceLocation NameLoc = TInfo->getTypeLoc().getLocalSourceRange().getBegin();
Richard Smith2bf7fdb2013-01-02 11:42:31 +00003056 if (!LangOpts.CPlusPlus11)
Douglas Gregord73f3dd2011-11-01 01:16:03 +00003057 return Diag(NameLoc, diag::err_delegating_ctor)
Alexis Hunt4049b8d2011-01-08 19:20:43 +00003058 << TInfo->getTypeLoc().getLocalSourceRange();
Douglas Gregord73f3dd2011-11-01 01:16:03 +00003059 Diag(NameLoc, diag::warn_cxx98_compat_delegating_ctor);
Sebastian Redl9cb4be22011-03-12 13:53:51 +00003060
Sebastian Redl0501c632012-02-12 16:37:36 +00003061 bool InitList = true;
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00003062 MultiExprArg Args = Init;
Sebastian Redl0501c632012-02-12 16:37:36 +00003063 if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
3064 InitList = false;
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00003065 Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
Sebastian Redl0501c632012-02-12 16:37:36 +00003066 }
3067
Sebastian Redla9351792012-02-11 23:51:47 +00003068 SourceRange InitRange = Init->getSourceRange();
Alexis Huntc5575cc2011-02-26 19:13:13 +00003069 // Initialize the object.
3070 InitializedEntity DelegationEntity = InitializedEntity::InitializeDelegation(
3071 QualType(ClassDecl->getTypeForDecl(), 0));
3072 InitializationKind Kind =
Sebastian Redl0501c632012-02-12 16:37:36 +00003073 InitList ? InitializationKind::CreateDirectList(NameLoc)
3074 : InitializationKind::CreateDirect(NameLoc, InitRange.getBegin(),
3075 InitRange.getEnd());
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00003076 InitializationSequence InitSeq(*this, DelegationEntity, Kind, Args);
Sebastian Redla9351792012-02-11 23:51:47 +00003077 ExprResult DelegationInit = InitSeq.Perform(*this, DelegationEntity, Kind,
Craig Topperc3ec1492014-05-26 06:22:03 +00003078 Args, nullptr);
Alexis Huntc5575cc2011-02-26 19:13:13 +00003079 if (DelegationInit.isInvalid())
3080 return true;
3081
Matt Beaumont-Gay3e59fac2011-11-01 18:10:22 +00003082 assert(cast<CXXConstructExpr>(DelegationInit.get())->getConstructor() &&
3083 "Delegating constructor with no target?");
Alexis Huntc5575cc2011-02-26 19:13:13 +00003084
Richard Smith945f8d32013-01-14 22:39:08 +00003085 // C++11 [class.base.init]p7:
Alexis Huntc5575cc2011-02-26 19:13:13 +00003086 // The initialization of each base and member constitutes a
3087 // full-expression.
Richard Smith945f8d32013-01-14 22:39:08 +00003088 DelegationInit = ActOnFinishFullExpr(DelegationInit.get(),
3089 InitRange.getBegin());
Alexis Huntc5575cc2011-02-26 19:13:13 +00003090 if (DelegationInit.isInvalid())
3091 return true;
3092
Eli Friedmana9e9ebc2012-05-19 23:35:23 +00003093 // If we are in a dependent context, template instantiation will
3094 // perform this type-checking again. Just save the arguments that we
3095 // received in a ParenListExpr.
3096 // FIXME: This isn't quite ideal, since our ASTs don't capture all
3097 // of the information that we have about the base
3098 // initializer. However, deconstructing the ASTs is a dicey process,
3099 // and this approach is far more likely to get the corner cases right.
3100 if (CurContext->isDependentContext())
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00003101 DelegationInit = Init;
Eli Friedmana9e9ebc2012-05-19 23:35:23 +00003102
Sebastian Redla9351792012-02-11 23:51:47 +00003103 return new (Context) CXXCtorInitializer(Context, TInfo, InitRange.getBegin(),
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003104 DelegationInit.getAs<Expr>(),
Sebastian Redla9351792012-02-11 23:51:47 +00003105 InitRange.getEnd());
Alexis Hunt4049b8d2011-01-08 19:20:43 +00003106}
3107
3108MemInitResult
John McCallbcd03502009-12-07 02:54:59 +00003109Sema::BuildBaseInitializer(QualType BaseType, TypeSourceInfo *BaseTInfo,
Sebastian Redla9351792012-02-11 23:51:47 +00003110 Expr *Init, CXXRecordDecl *ClassDecl,
Douglas Gregor44e7df62011-01-04 00:32:56 +00003111 SourceLocation EllipsisLoc) {
Douglas Gregor1c69bf02010-06-16 16:03:14 +00003112 SourceLocation BaseLoc
3113 = BaseTInfo->getTypeLoc().getLocalSourceRange().getBegin();
Sebastian Redla74948d2011-09-24 17:48:25 +00003114
Douglas Gregor1c69bf02010-06-16 16:03:14 +00003115 if (!BaseType->isDependentType() && !BaseType->isRecordType())
3116 return Diag(BaseLoc, diag::err_base_init_does_not_name_class)
3117 << BaseType << BaseTInfo->getTypeLoc().getLocalSourceRange();
3118
3119 // C++ [class.base.init]p2:
3120 // [...] Unless the mem-initializer-id names a nonstatic data
Nick Lewycky9331ed82010-11-20 01:29:55 +00003121 // member of the constructor's class or a direct or virtual base
Douglas Gregor1c69bf02010-06-16 16:03:14 +00003122 // of that class, the mem-initializer is ill-formed. A
3123 // mem-initializer-list can initialize a base class using any
3124 // name that denotes that base class type.
Sebastian Redla9351792012-02-11 23:51:47 +00003125 bool Dependent = BaseType->isDependentType() || Init->isTypeDependent();
Douglas Gregor1c69bf02010-06-16 16:03:14 +00003126
Sebastian Redla9351792012-02-11 23:51:47 +00003127 SourceRange InitRange = Init->getSourceRange();
Douglas Gregor44e7df62011-01-04 00:32:56 +00003128 if (EllipsisLoc.isValid()) {
3129 // This is a pack expansion.
3130 if (!BaseType->containsUnexpandedParameterPack()) {
3131 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
Sebastian Redla9351792012-02-11 23:51:47 +00003132 << SourceRange(BaseLoc, InitRange.getEnd());
Sebastian Redla74948d2011-09-24 17:48:25 +00003133
Douglas Gregor44e7df62011-01-04 00:32:56 +00003134 EllipsisLoc = SourceLocation();
3135 }
3136 } else {
3137 // Check for any unexpanded parameter packs.
3138 if (DiagnoseUnexpandedParameterPack(BaseLoc, BaseTInfo, UPPC_Initializer))
3139 return true;
Sebastian Redla74948d2011-09-24 17:48:25 +00003140
Sebastian Redla9351792012-02-11 23:51:47 +00003141 if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer))
Sebastian Redla74948d2011-09-24 17:48:25 +00003142 return true;
Douglas Gregor44e7df62011-01-04 00:32:56 +00003143 }
Sebastian Redla74948d2011-09-24 17:48:25 +00003144
Douglas Gregor1c69bf02010-06-16 16:03:14 +00003145 // Check for direct and virtual base classes.
Craig Topperc3ec1492014-05-26 06:22:03 +00003146 const CXXBaseSpecifier *DirectBaseSpec = nullptr;
3147 const CXXBaseSpecifier *VirtualBaseSpec = nullptr;
Douglas Gregor1c69bf02010-06-16 16:03:14 +00003148 if (!Dependent) {
Alexis Hunt4049b8d2011-01-08 19:20:43 +00003149 if (Context.hasSameUnqualifiedType(QualType(ClassDecl->getTypeForDecl(),0),
3150 BaseType))
Sebastian Redla9351792012-02-11 23:51:47 +00003151 return BuildDelegatingInitializer(BaseTInfo, Init, ClassDecl);
Alexis Hunt4049b8d2011-01-08 19:20:43 +00003152
Douglas Gregor1c69bf02010-06-16 16:03:14 +00003153 FindBaseInitializer(*this, ClassDecl, BaseType, DirectBaseSpec,
3154 VirtualBaseSpec);
3155
3156 // C++ [base.class.init]p2:
3157 // Unless the mem-initializer-id names a nonstatic data member of the
3158 // constructor's class or a direct or virtual base of that class, the
3159 // mem-initializer is ill-formed.
3160 if (!DirectBaseSpec && !VirtualBaseSpec) {
3161 // If the class has any dependent bases, then it's possible that
3162 // one of those types will resolve to the same type as
3163 // BaseType. Therefore, just treat this as a dependent base
3164 // class initialization. FIXME: Should we try to check the
3165 // initialization anyway? It seems odd.
3166 if (ClassDecl->hasAnyDependentBases())
3167 Dependent = true;
3168 else
3169 return Diag(BaseLoc, diag::err_not_direct_base_or_virtual)
3170 << BaseType << Context.getTypeDeclType(ClassDecl)
3171 << BaseTInfo->getTypeLoc().getLocalSourceRange();
3172 }
3173 }
3174
3175 if (Dependent) {
John McCall31168b02011-06-15 23:02:42 +00003176 DiscardCleanupsInEvaluationContext();
Mike Stump11289f42009-09-09 15:08:12 +00003177
Sebastian Redla74948d2011-09-24 17:48:25 +00003178 return new (Context) CXXCtorInitializer(Context, BaseTInfo,
3179 /*IsVirtual=*/false,
Sebastian Redla9351792012-02-11 23:51:47 +00003180 InitRange.getBegin(), Init,
3181 InitRange.getEnd(), EllipsisLoc);
Douglas Gregore8381c02008-11-05 04:29:56 +00003182 }
Douglas Gregor7ae2d772010-01-31 09:12:51 +00003183
3184 // C++ [base.class.init]p2:
3185 // If a mem-initializer-id is ambiguous because it designates both
3186 // a direct non-virtual base class and an inherited virtual base
3187 // class, the mem-initializer is ill-formed.
3188 if (DirectBaseSpec && VirtualBaseSpec)
3189 return Diag(BaseLoc, diag::err_base_init_direct_and_virtual)
Abramo Bagnara1108e7b2010-05-20 10:00:11 +00003190 << BaseType << BaseTInfo->getTypeLoc().getLocalSourceRange();
Douglas Gregor7ae2d772010-01-31 09:12:51 +00003191
Benjamin Kramer8bf44352013-07-24 15:28:33 +00003192 const CXXBaseSpecifier *BaseSpec = DirectBaseSpec;
Douglas Gregor7ae2d772010-01-31 09:12:51 +00003193 if (!BaseSpec)
Benjamin Kramer8bf44352013-07-24 15:28:33 +00003194 BaseSpec = VirtualBaseSpec;
Douglas Gregor7ae2d772010-01-31 09:12:51 +00003195
3196 // Initialize the base.
Sebastian Redl0501c632012-02-12 16:37:36 +00003197 bool InitList = true;
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00003198 MultiExprArg Args = Init;
Sebastian Redla9351792012-02-11 23:51:47 +00003199 if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
Sebastian Redl0501c632012-02-12 16:37:36 +00003200 InitList = false;
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00003201 Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
Sebastian Redla9351792012-02-11 23:51:47 +00003202 }
Sebastian Redl0501c632012-02-12 16:37:36 +00003203
3204 InitializedEntity BaseEntity =
3205 InitializedEntity::InitializeBase(Context, BaseSpec, VirtualBaseSpec);
3206 InitializationKind Kind =
3207 InitList ? InitializationKind::CreateDirectList(BaseLoc)
3208 : InitializationKind::CreateDirect(BaseLoc, InitRange.getBegin(),
3209 InitRange.getEnd());
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00003210 InitializationSequence InitSeq(*this, BaseEntity, Kind, Args);
Craig Topperc3ec1492014-05-26 06:22:03 +00003211 ExprResult BaseInit = InitSeq.Perform(*this, BaseEntity, Kind, Args, nullptr);
Douglas Gregor7ae2d772010-01-31 09:12:51 +00003212 if (BaseInit.isInvalid())
3213 return true;
John McCallacf0ee52010-10-08 02:01:28 +00003214
Richard Smith945f8d32013-01-14 22:39:08 +00003215 // C++11 [class.base.init]p7:
3216 // The initialization of each base and member constitutes a
Douglas Gregor7ae2d772010-01-31 09:12:51 +00003217 // full-expression.
Richard Smith945f8d32013-01-14 22:39:08 +00003218 BaseInit = ActOnFinishFullExpr(BaseInit.get(), InitRange.getBegin());
Douglas Gregor7ae2d772010-01-31 09:12:51 +00003219 if (BaseInit.isInvalid())
3220 return true;
3221
3222 // If we are in a dependent context, template instantiation will
3223 // perform this type-checking again. Just save the arguments that we
3224 // received in a ParenListExpr.
3225 // FIXME: This isn't quite ideal, since our ASTs don't capture all
3226 // of the information that we have about the base
3227 // initializer. However, deconstructing the ASTs is a dicey process,
3228 // and this approach is far more likely to get the corner cases right.
Sebastian Redla74948d2011-09-24 17:48:25 +00003229 if (CurContext->isDependentContext())
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00003230 BaseInit = Init;
Douglas Gregor7ae2d772010-01-31 09:12:51 +00003231
Alexis Hunt1d792652011-01-08 20:30:50 +00003232 return new (Context) CXXCtorInitializer(Context, BaseTInfo,
Sebastian Redla74948d2011-09-24 17:48:25 +00003233 BaseSpec->isVirtual(),
Sebastian Redla9351792012-02-11 23:51:47 +00003234 InitRange.getBegin(),
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003235 BaseInit.getAs<Expr>(),
Sebastian Redla9351792012-02-11 23:51:47 +00003236 InitRange.getEnd(), EllipsisLoc);
Douglas Gregore8381c02008-11-05 04:29:56 +00003237}
3238
Sebastian Redl22653ba2011-08-30 19:58:05 +00003239// Create a static_cast\<T&&>(expr).
Richard Smithc2bc61b2013-03-18 21:12:30 +00003240static Expr *CastForMoving(Sema &SemaRef, Expr *E, QualType T = QualType()) {
3241 if (T.isNull()) T = E->getType();
3242 QualType TargetType = SemaRef.BuildReferenceType(
3243 T, /*SpelledAsLValue*/false, SourceLocation(), DeclarationName());
Sebastian Redl22653ba2011-08-30 19:58:05 +00003244 SourceLocation ExprLoc = E->getLocStart();
3245 TypeSourceInfo *TargetLoc = SemaRef.Context.getTrivialTypeSourceInfo(
3246 TargetType, ExprLoc);
3247
3248 return SemaRef.BuildCXXNamedCast(ExprLoc, tok::kw_static_cast, TargetLoc, E,
3249 SourceRange(ExprLoc, ExprLoc),
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003250 E->getSourceRange()).get();
Sebastian Redl22653ba2011-08-30 19:58:05 +00003251}
3252
Anders Carlsson1b00e242010-04-23 03:10:23 +00003253/// ImplicitInitializerKind - How an implicit base or member initializer should
3254/// initialize its base or member.
3255enum ImplicitInitializerKind {
3256 IIK_Default,
3257 IIK_Copy,
Richard Smithc2bc61b2013-03-18 21:12:30 +00003258 IIK_Move,
3259 IIK_Inherit
Anders Carlsson1b00e242010-04-23 03:10:23 +00003260};
3261
Anders Carlsson6bd91c32010-04-23 02:00:02 +00003262static bool
Anders Carlsson3c1db572010-04-23 02:15:47 +00003263BuildImplicitBaseInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor,
Anders Carlsson1b00e242010-04-23 03:10:23 +00003264 ImplicitInitializerKind ImplicitInitKind,
Anders Carlsson43c64af2010-04-21 19:52:01 +00003265 CXXBaseSpecifier *BaseSpec,
Anders Carlsson6bd91c32010-04-23 02:00:02 +00003266 bool IsInheritedVirtualBase,
Alexis Hunt1d792652011-01-08 20:30:50 +00003267 CXXCtorInitializer *&CXXBaseInit) {
Anders Carlssoncedc0a42010-04-20 23:11:20 +00003268 InitializedEntity InitEntity
Anders Carlsson43c64af2010-04-21 19:52:01 +00003269 = InitializedEntity::InitializeBase(SemaRef.Context, BaseSpec,
3270 IsInheritedVirtualBase);
Anders Carlssoncedc0a42010-04-20 23:11:20 +00003271
John McCalldadc5752010-08-24 06:29:42 +00003272 ExprResult BaseInit;
Anders Carlsson1b00e242010-04-23 03:10:23 +00003273
3274 switch (ImplicitInitKind) {
Richard Smithc2bc61b2013-03-18 21:12:30 +00003275 case IIK_Inherit: {
3276 const CXXRecordDecl *Inherited =
3277 Constructor->getInheritedConstructor()->getParent();
3278 const CXXRecordDecl *Base = BaseSpec->getType()->getAsCXXRecordDecl();
3279 if (Base && Inherited->getCanonicalDecl() == Base->getCanonicalDecl()) {
3280 // C++11 [class.inhctor]p8:
3281 // Each expression in the expression-list is of the form
3282 // static_cast<T&&>(p), where p is the name of the corresponding
3283 // constructor parameter and T is the declared type of p.
3284 SmallVector<Expr*, 16> Args;
3285 for (unsigned I = 0, E = Constructor->getNumParams(); I != E; ++I) {
3286 ParmVarDecl *PD = Constructor->getParamDecl(I);
3287 ExprResult ArgExpr =
3288 SemaRef.BuildDeclRefExpr(PD, PD->getType().getNonReferenceType(),
3289 VK_LValue, SourceLocation());
3290 if (ArgExpr.isInvalid())
3291 return true;
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003292 Args.push_back(CastForMoving(SemaRef, ArgExpr.get(), PD->getType()));
Richard Smithc2bc61b2013-03-18 21:12:30 +00003293 }
3294
3295 InitializationKind InitKind = InitializationKind::CreateDirect(
3296 Constructor->getLocation(), SourceLocation(), SourceLocation());
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00003297 InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, Args);
Richard Smithc2bc61b2013-03-18 21:12:30 +00003298 BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind, Args);
3299 break;
3300 }
3301 }
3302 // Fall through.
Anders Carlsson1b00e242010-04-23 03:10:23 +00003303 case IIK_Default: {
3304 InitializationKind InitKind
3305 = InitializationKind::CreateDefault(Constructor->getLocation());
Dmitri Gribenko78852e92013-05-05 20:40:26 +00003306 InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, None);
3307 BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind, None);
Anders Carlsson1b00e242010-04-23 03:10:23 +00003308 break;
3309 }
Anders Carlssoncedc0a42010-04-20 23:11:20 +00003310
Sebastian Redl22653ba2011-08-30 19:58:05 +00003311 case IIK_Move:
Anders Carlsson1b00e242010-04-23 03:10:23 +00003312 case IIK_Copy: {
Sebastian Redl22653ba2011-08-30 19:58:05 +00003313 bool Moving = ImplicitInitKind == IIK_Move;
Anders Carlsson1b00e242010-04-23 03:10:23 +00003314 ParmVarDecl *Param = Constructor->getParamDecl(0);
3315 QualType ParamType = Param->getType().getNonReferenceType();
Eli Friedman2dfa7932012-01-16 21:00:51 +00003316
Anders Carlsson1b00e242010-04-23 03:10:23 +00003317 Expr *CopyCtorArg =
Abramo Bagnara7945c982012-01-27 09:46:47 +00003318 DeclRefExpr::Create(SemaRef.Context, NestedNameSpecifierLoc(),
John McCall113bee02012-03-10 09:33:50 +00003319 SourceLocation(), Param, false,
John McCall7decc9e2010-11-18 06:31:45 +00003320 Constructor->getLocation(), ParamType,
Craig Topperc3ec1492014-05-26 06:22:03 +00003321 VK_LValue, nullptr);
Sebastian Redl22653ba2011-08-30 19:58:05 +00003322
Eli Friedmanfa0df832012-02-02 03:46:19 +00003323 SemaRef.MarkDeclRefReferenced(cast<DeclRefExpr>(CopyCtorArg));
3324
Anders Carlssonaf13c7b2010-04-24 22:02:54 +00003325 // Cast to the base class to avoid ambiguities.
Anders Carlsson79111502010-05-01 16:39:01 +00003326 QualType ArgTy =
3327 SemaRef.Context.getQualifiedType(BaseSpec->getType().getUnqualifiedType(),
3328 ParamType.getQualifiers());
John McCallcf142162010-08-07 06:22:56 +00003329
Sebastian Redl22653ba2011-08-30 19:58:05 +00003330 if (Moving) {
3331 CopyCtorArg = CastForMoving(SemaRef, CopyCtorArg);
3332 }
3333
John McCallcf142162010-08-07 06:22:56 +00003334 CXXCastPath BasePath;
3335 BasePath.push_back(BaseSpec);
John Wiegley01296292011-04-08 18:41:53 +00003336 CopyCtorArg = SemaRef.ImpCastExprToType(CopyCtorArg, ArgTy,
3337 CK_UncheckedDerivedToBase,
Sebastian Redle9c4e842011-09-04 18:14:28 +00003338 Moving ? VK_XValue : VK_LValue,
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003339 &BasePath).get();
Anders Carlssonaf13c7b2010-04-24 22:02:54 +00003340
Anders Carlsson1b00e242010-04-23 03:10:23 +00003341 InitializationKind InitKind
3342 = InitializationKind::CreateDirect(Constructor->getLocation(),
3343 SourceLocation(), SourceLocation());
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00003344 InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, CopyCtorArg);
3345 BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind, CopyCtorArg);
Anders Carlsson1b00e242010-04-23 03:10:23 +00003346 break;
3347 }
Anders Carlsson1b00e242010-04-23 03:10:23 +00003348 }
John McCallb268a282010-08-23 23:25:46 +00003349
Douglas Gregora40433a2010-12-07 00:41:46 +00003350 BaseInit = SemaRef.MaybeCreateExprWithCleanups(BaseInit);
Anders Carlssoncedc0a42010-04-20 23:11:20 +00003351 if (BaseInit.isInvalid())
Anders Carlsson6bd91c32010-04-23 02:00:02 +00003352 return true;
Anders Carlssoncedc0a42010-04-20 23:11:20 +00003353
Anders Carlsson6bd91c32010-04-23 02:00:02 +00003354 CXXBaseInit =
Alexis Hunt1d792652011-01-08 20:30:50 +00003355 new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
Anders Carlssoncedc0a42010-04-20 23:11:20 +00003356 SemaRef.Context.getTrivialTypeSourceInfo(BaseSpec->getType(),
3357 SourceLocation()),
3358 BaseSpec->isVirtual(),
3359 SourceLocation(),
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003360 BaseInit.getAs<Expr>(),
Douglas Gregor44e7df62011-01-04 00:32:56 +00003361 SourceLocation(),
Anders Carlssoncedc0a42010-04-20 23:11:20 +00003362 SourceLocation());
3363
Anders Carlsson6bd91c32010-04-23 02:00:02 +00003364 return false;
Anders Carlssoncedc0a42010-04-20 23:11:20 +00003365}
3366
Sebastian Redl22653ba2011-08-30 19:58:05 +00003367static bool RefersToRValueRef(Expr *MemRef) {
3368 ValueDecl *Referenced = cast<MemberExpr>(MemRef)->getMemberDecl();
3369 return Referenced->getType()->isRValueReferenceType();
3370}
3371
Anders Carlsson3c1db572010-04-23 02:15:47 +00003372static bool
3373BuildImplicitMemberInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor,
Anders Carlsson1b00e242010-04-23 03:10:23 +00003374 ImplicitInitializerKind ImplicitInitKind,
Douglas Gregor493627b2011-08-10 15:22:55 +00003375 FieldDecl *Field, IndirectFieldDecl *Indirect,
Alexis Hunt1d792652011-01-08 20:30:50 +00003376 CXXCtorInitializer *&CXXMemberInit) {
Douglas Gregor3f4f03a2010-05-20 22:12:02 +00003377 if (Field->isInvalidDecl())
3378 return true;
3379
Chandler Carruth9c9286b2010-06-29 23:50:44 +00003380 SourceLocation Loc = Constructor->getLocation();
3381
Sebastian Redl22653ba2011-08-30 19:58:05 +00003382 if (ImplicitInitKind == IIK_Copy || ImplicitInitKind == IIK_Move) {
3383 bool Moving = ImplicitInitKind == IIK_Move;
Anders Carlsson423f5d82010-04-23 16:04:08 +00003384 ParmVarDecl *Param = Constructor->getParamDecl(0);
3385 QualType ParamType = Param->getType().getNonReferenceType();
John McCall1b1a1db2011-06-17 00:18:42 +00003386
3387 // Suppress copying zero-width bitfields.
Richard Smithcaf33902011-10-10 18:28:20 +00003388 if (Field->isBitField() && Field->getBitWidthValue(SemaRef.Context) == 0)
3389 return false;
Douglas Gregor10f939c2011-11-02 23:04:16 +00003390
Anders Carlsson423f5d82010-04-23 16:04:08 +00003391 Expr *MemberExprBase =
Abramo Bagnara7945c982012-01-27 09:46:47 +00003392 DeclRefExpr::Create(SemaRef.Context, NestedNameSpecifierLoc(),
John McCall113bee02012-03-10 09:33:50 +00003393 SourceLocation(), Param, false,
Craig Topperc3ec1492014-05-26 06:22:03 +00003394 Loc, ParamType, VK_LValue, nullptr);
Douglas Gregor94f9a482010-05-05 05:51:00 +00003395
Eli Friedmanfa0df832012-02-02 03:46:19 +00003396 SemaRef.MarkDeclRefReferenced(cast<DeclRefExpr>(MemberExprBase));
3397
Sebastian Redl22653ba2011-08-30 19:58:05 +00003398 if (Moving) {
3399 MemberExprBase = CastForMoving(SemaRef, MemberExprBase);
3400 }
3401
Douglas Gregor94f9a482010-05-05 05:51:00 +00003402 // Build a reference to this field within the parameter.
3403 CXXScopeSpec SS;
3404 LookupResult MemberLookup(SemaRef, Field->getDeclName(), Loc,
3405 Sema::LookupMemberName);
Sebastian Redl22653ba2011-08-30 19:58:05 +00003406 MemberLookup.addDecl(Indirect ? cast<ValueDecl>(Indirect)
3407 : cast<ValueDecl>(Field), AS_public);
Douglas Gregor94f9a482010-05-05 05:51:00 +00003408 MemberLookup.resolveKind();
Sebastian Redle9c4e842011-09-04 18:14:28 +00003409 ExprResult CtorArg
John McCallb268a282010-08-23 23:25:46 +00003410 = SemaRef.BuildMemberReferenceExpr(MemberExprBase,
Douglas Gregor94f9a482010-05-05 05:51:00 +00003411 ParamType, Loc,
3412 /*IsArrow=*/false,
3413 SS,
Abramo Bagnara7945c982012-01-27 09:46:47 +00003414 /*TemplateKWLoc=*/SourceLocation(),
Craig Topperc3ec1492014-05-26 06:22:03 +00003415 /*FirstQualifierInScope=*/nullptr,
Douglas Gregor94f9a482010-05-05 05:51:00 +00003416 MemberLookup,
Craig Topperc3ec1492014-05-26 06:22:03 +00003417 /*TemplateArgs=*/nullptr);
Sebastian Redle9c4e842011-09-04 18:14:28 +00003418 if (CtorArg.isInvalid())
Anders Carlsson423f5d82010-04-23 16:04:08 +00003419 return true;
Sebastian Redl22653ba2011-08-30 19:58:05 +00003420
3421 // C++11 [class.copy]p15:
3422 // - if a member m has rvalue reference type T&&, it is direct-initialized
3423 // with static_cast<T&&>(x.m);
Sebastian Redle9c4e842011-09-04 18:14:28 +00003424 if (RefersToRValueRef(CtorArg.get())) {
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003425 CtorArg = CastForMoving(SemaRef, CtorArg.get());
Sebastian Redl22653ba2011-08-30 19:58:05 +00003426 }
3427
Douglas Gregor94f9a482010-05-05 05:51:00 +00003428 // When the field we are copying is an array, create index variables for
3429 // each dimension of the array. We use these index variables to subscript
3430 // the source array, and other clients (e.g., CodeGen) will perform the
3431 // necessary iteration with these index variables.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003432 SmallVector<VarDecl *, 4> IndexVariables;
Douglas Gregor94f9a482010-05-05 05:51:00 +00003433 QualType BaseType = Field->getType();
3434 QualType SizeType = SemaRef.Context.getSizeType();
Sebastian Redl22653ba2011-08-30 19:58:05 +00003435 bool InitializingArray = false;
Douglas Gregor94f9a482010-05-05 05:51:00 +00003436 while (const ConstantArrayType *Array
3437 = SemaRef.Context.getAsConstantArrayType(BaseType)) {
Sebastian Redl22653ba2011-08-30 19:58:05 +00003438 InitializingArray = true;
Douglas Gregor94f9a482010-05-05 05:51:00 +00003439 // Create the iteration variable for this array index.
Craig Topperc3ec1492014-05-26 06:22:03 +00003440 IdentifierInfo *IterationVarName = nullptr;
Douglas Gregor94f9a482010-05-05 05:51:00 +00003441 {
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00003442 SmallString<8> Str;
Douglas Gregor94f9a482010-05-05 05:51:00 +00003443 llvm::raw_svector_ostream OS(Str);
3444 OS << "__i" << IndexVariables.size();
3445 IterationVarName = &SemaRef.Context.Idents.get(OS.str());
3446 }
3447 VarDecl *IterationVar
Abramo Bagnaradff19302011-03-08 08:55:46 +00003448 = VarDecl::Create(SemaRef.Context, SemaRef.CurContext, Loc, Loc,
Douglas Gregor94f9a482010-05-05 05:51:00 +00003449 IterationVarName, SizeType,
3450 SemaRef.Context.getTrivialTypeSourceInfo(SizeType, Loc),
Rafael Espindola6ae7e502013-04-03 19:27:57 +00003451 SC_None);
Douglas Gregor94f9a482010-05-05 05:51:00 +00003452 IndexVariables.push_back(IterationVar);
3453
3454 // Create a reference to the iteration variable.
John McCalldadc5752010-08-24 06:29:42 +00003455 ExprResult IterationVarRef
Eli Friedman844f9452012-01-23 02:35:22 +00003456 = SemaRef.BuildDeclRefExpr(IterationVar, SizeType, VK_LValue, Loc);
Douglas Gregor94f9a482010-05-05 05:51:00 +00003457 assert(!IterationVarRef.isInvalid() &&
3458 "Reference to invented variable cannot fail!");
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003459 IterationVarRef = SemaRef.DefaultLvalueConversion(IterationVarRef.get());
Eli Friedman844f9452012-01-23 02:35:22 +00003460 assert(!IterationVarRef.isInvalid() &&
3461 "Conversion of invented variable cannot fail!");
Sebastian Redle9c4e842011-09-04 18:14:28 +00003462
Douglas Gregor94f9a482010-05-05 05:51:00 +00003463 // Subscript the array with this iteration variable.
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003464 CtorArg = SemaRef.CreateBuiltinArraySubscriptExpr(CtorArg.get(), Loc,
3465 IterationVarRef.get(),
Sebastian Redle9c4e842011-09-04 18:14:28 +00003466 Loc);
3467 if (CtorArg.isInvalid())
Douglas Gregor94f9a482010-05-05 05:51:00 +00003468 return true;
Sebastian Redl22653ba2011-08-30 19:58:05 +00003469
Douglas Gregor94f9a482010-05-05 05:51:00 +00003470 BaseType = Array->getElementType();
3471 }
Sebastian Redl22653ba2011-08-30 19:58:05 +00003472
3473 // The array subscript expression is an lvalue, which is wrong for moving.
3474 if (Moving && InitializingArray)
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003475 CtorArg = CastForMoving(SemaRef, CtorArg.get());
Sebastian Redl22653ba2011-08-30 19:58:05 +00003476
Douglas Gregor94f9a482010-05-05 05:51:00 +00003477 // Construct the entity that we will be initializing. For an array, this
3478 // will be first element in the array, which may require several levels
3479 // of array-subscript entities.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003480 SmallVector<InitializedEntity, 4> Entities;
Douglas Gregor94f9a482010-05-05 05:51:00 +00003481 Entities.reserve(1 + IndexVariables.size());
Douglas Gregor493627b2011-08-10 15:22:55 +00003482 if (Indirect)
3483 Entities.push_back(InitializedEntity::InitializeMember(Indirect));
3484 else
3485 Entities.push_back(InitializedEntity::InitializeMember(Field));
Douglas Gregor94f9a482010-05-05 05:51:00 +00003486 for (unsigned I = 0, N = IndexVariables.size(); I != N; ++I)
3487 Entities.push_back(InitializedEntity::InitializeElement(SemaRef.Context,
3488 0,
3489 Entities.back()));
3490
3491 // Direct-initialize to use the copy constructor.
3492 InitializationKind InitKind =
3493 InitializationKind::CreateDirect(Loc, SourceLocation(), SourceLocation());
3494
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003495 Expr *CtorArgE = CtorArg.getAs<Expr>();
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00003496 InitializationSequence InitSeq(SemaRef, Entities.back(), InitKind, CtorArgE);
Douglas Gregor94f9a482010-05-05 05:51:00 +00003497
John McCalldadc5752010-08-24 06:29:42 +00003498 ExprResult MemberInit
Douglas Gregor94f9a482010-05-05 05:51:00 +00003499 = InitSeq.Perform(SemaRef, Entities.back(), InitKind,
Sebastian Redle9c4e842011-09-04 18:14:28 +00003500 MultiExprArg(&CtorArgE, 1));
Douglas Gregora40433a2010-12-07 00:41:46 +00003501 MemberInit = SemaRef.MaybeCreateExprWithCleanups(MemberInit);
Douglas Gregor94f9a482010-05-05 05:51:00 +00003502 if (MemberInit.isInvalid())
3503 return true;
3504
Douglas Gregor493627b2011-08-10 15:22:55 +00003505 if (Indirect) {
3506 assert(IndexVariables.size() == 0 &&
3507 "Indirect field improperly initialized");
3508 CXXMemberInit
3509 = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, Indirect,
3510 Loc, Loc,
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003511 MemberInit.getAs<Expr>(),
Douglas Gregor493627b2011-08-10 15:22:55 +00003512 Loc);
3513 } else
3514 CXXMemberInit = CXXCtorInitializer::Create(SemaRef.Context, Field, Loc,
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003515 Loc, MemberInit.getAs<Expr>(),
Douglas Gregor493627b2011-08-10 15:22:55 +00003516 Loc,
3517 IndexVariables.data(),
3518 IndexVariables.size());
Anders Carlsson1b00e242010-04-23 03:10:23 +00003519 return false;
3520 }
3521
Richard Smithc2bc61b2013-03-18 21:12:30 +00003522 assert((ImplicitInitKind == IIK_Default || ImplicitInitKind == IIK_Inherit) &&
3523 "Unhandled implicit init kind!");
Anders Carlsson423f5d82010-04-23 16:04:08 +00003524
Anders Carlsson3c1db572010-04-23 02:15:47 +00003525 QualType FieldBaseElementType =
3526 SemaRef.Context.getBaseElementType(Field->getType());
3527
Anders Carlsson3c1db572010-04-23 02:15:47 +00003528 if (FieldBaseElementType->isRecordType()) {
Douglas Gregor493627b2011-08-10 15:22:55 +00003529 InitializedEntity InitEntity
3530 = Indirect? InitializedEntity::InitializeMember(Indirect)
3531 : InitializedEntity::InitializeMember(Field);
Anders Carlsson423f5d82010-04-23 16:04:08 +00003532 InitializationKind InitKind =
Chandler Carruth9c9286b2010-06-29 23:50:44 +00003533 InitializationKind::CreateDefault(Loc);
Dmitri Gribenko78852e92013-05-05 20:40:26 +00003534
3535 InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, None);
3536 ExprResult MemberInit =
3537 InitSeq.Perform(SemaRef, InitEntity, InitKind, None);
John McCallb268a282010-08-23 23:25:46 +00003538
Douglas Gregora40433a2010-12-07 00:41:46 +00003539 MemberInit = SemaRef.MaybeCreateExprWithCleanups(MemberInit);
Anders Carlsson3c1db572010-04-23 02:15:47 +00003540 if (MemberInit.isInvalid())
3541 return true;
3542
Douglas Gregor493627b2011-08-10 15:22:55 +00003543 if (Indirect)
3544 CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
3545 Indirect, Loc,
3546 Loc,
3547 MemberInit.get(),
3548 Loc);
3549 else
3550 CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
3551 Field, Loc, Loc,
3552 MemberInit.get(),
3553 Loc);
Anders Carlsson3c1db572010-04-23 02:15:47 +00003554 return false;
3555 }
Anders Carlssondca6be02010-04-23 03:07:47 +00003556
Alexis Hunt8b455182011-05-17 00:19:05 +00003557 if (!Field->getParent()->isUnion()) {
3558 if (FieldBaseElementType->isReferenceType()) {
3559 SemaRef.Diag(Constructor->getLocation(),
3560 diag::err_uninitialized_member_in_ctor)
3561 << (int)Constructor->isImplicit()
3562 << SemaRef.Context.getTagDeclType(Constructor->getParent())
3563 << 0 << Field->getDeclName();
3564 SemaRef.Diag(Field->getLocation(), diag::note_declared_at);
3565 return true;
3566 }
Anders Carlssondca6be02010-04-23 03:07:47 +00003567
Alexis Hunt8b455182011-05-17 00:19:05 +00003568 if (FieldBaseElementType.isConstQualified()) {
3569 SemaRef.Diag(Constructor->getLocation(),
3570 diag::err_uninitialized_member_in_ctor)
3571 << (int)Constructor->isImplicit()
3572 << SemaRef.Context.getTagDeclType(Constructor->getParent())
3573 << 1 << Field->getDeclName();
3574 SemaRef.Diag(Field->getLocation(), diag::note_declared_at);
3575 return true;
3576 }
Anders Carlssondca6be02010-04-23 03:07:47 +00003577 }
Anders Carlsson3c1db572010-04-23 02:15:47 +00003578
David Blaikiebbafb8a2012-03-11 07:00:24 +00003579 if (SemaRef.getLangOpts().ObjCAutoRefCount &&
John McCall31168b02011-06-15 23:02:42 +00003580 FieldBaseElementType->isObjCRetainableType() &&
3581 FieldBaseElementType.getObjCLifetime() != Qualifiers::OCL_None &&
3582 FieldBaseElementType.getObjCLifetime() != Qualifiers::OCL_ExplicitNone) {
Douglas Gregor6fa69422012-07-23 04:23:39 +00003583 // ARC:
John McCall31168b02011-06-15 23:02:42 +00003584 // Default-initialize Objective-C pointers to NULL.
3585 CXXMemberInit
3586 = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, Field,
3587 Loc, Loc,
3588 new (SemaRef.Context) ImplicitValueInitExpr(Field->getType()),
3589 Loc);
3590 return false;
3591 }
3592
Anders Carlsson3c1db572010-04-23 02:15:47 +00003593 // Nothing to initialize.
Craig Topperc3ec1492014-05-26 06:22:03 +00003594 CXXMemberInit = nullptr;
Anders Carlsson3c1db572010-04-23 02:15:47 +00003595 return false;
3596}
John McCallbc83b3f2010-05-20 23:23:51 +00003597
3598namespace {
3599struct BaseAndFieldInfo {
3600 Sema &S;
3601 CXXConstructorDecl *Ctor;
3602 bool AnyErrorsInInits;
3603 ImplicitInitializerKind IIK;
Alexis Hunt1d792652011-01-08 20:30:50 +00003604 llvm::DenseMap<const void *, CXXCtorInitializer*> AllBaseFields;
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003605 SmallVector<CXXCtorInitializer*, 8> AllToInit;
Richard Smithab44d5b2013-12-10 08:25:00 +00003606 llvm::DenseMap<TagDecl*, FieldDecl*> ActiveUnionMember;
John McCallbc83b3f2010-05-20 23:23:51 +00003607
3608 BaseAndFieldInfo(Sema &S, CXXConstructorDecl *Ctor, bool ErrorsInInits)
3609 : S(S), Ctor(Ctor), AnyErrorsInInits(ErrorsInInits) {
Sebastian Redl22653ba2011-08-30 19:58:05 +00003610 bool Generated = Ctor->isImplicit() || Ctor->isDefaulted();
3611 if (Generated && Ctor->isCopyConstructor())
John McCallbc83b3f2010-05-20 23:23:51 +00003612 IIK = IIK_Copy;
Sebastian Redl22653ba2011-08-30 19:58:05 +00003613 else if (Generated && Ctor->isMoveConstructor())
3614 IIK = IIK_Move;
Richard Smithc2bc61b2013-03-18 21:12:30 +00003615 else if (Ctor->getInheritedConstructor())
3616 IIK = IIK_Inherit;
John McCallbc83b3f2010-05-20 23:23:51 +00003617 else
3618 IIK = IIK_Default;
3619 }
Douglas Gregor7db3e952011-11-28 20:03:15 +00003620
3621 bool isImplicitCopyOrMove() const {
3622 switch (IIK) {
3623 case IIK_Copy:
3624 case IIK_Move:
3625 return true;
3626
3627 case IIK_Default:
Richard Smithc2bc61b2013-03-18 21:12:30 +00003628 case IIK_Inherit:
Douglas Gregor7db3e952011-11-28 20:03:15 +00003629 return false;
3630 }
David Blaikiee4d798f2012-01-20 21:50:17 +00003631
3632 llvm_unreachable("Invalid ImplicitInitializerKind!");
Douglas Gregor7db3e952011-11-28 20:03:15 +00003633 }
Richard Smith0a8cfc72012-08-07 21:30:42 +00003634
3635 bool addFieldInitializer(CXXCtorInitializer *Init) {
3636 AllToInit.push_back(Init);
3637
3638 // Check whether this initializer makes the field "used".
Richard Smith852c9db2013-04-20 22:23:05 +00003639 if (Init->getInit()->HasSideEffects(S.Context))
Richard Smith0a8cfc72012-08-07 21:30:42 +00003640 S.UnusedPrivateFields.remove(Init->getAnyMember());
3641
3642 return false;
3643 }
John McCallbc83b3f2010-05-20 23:23:51 +00003644
Richard Smithab44d5b2013-12-10 08:25:00 +00003645 bool isInactiveUnionMember(FieldDecl *Field) {
3646 RecordDecl *Record = Field->getParent();
3647 if (!Record->isUnion())
3648 return false;
3649
Richard Smith8d183852013-12-10 20:56:03 +00003650 if (FieldDecl *Active =
3651 ActiveUnionMember.lookup(Record->getCanonicalDecl()))
Richard Smithab44d5b2013-12-10 08:25:00 +00003652 return Active != Field->getCanonicalDecl();
3653
3654 // In an implicit copy or move constructor, ignore any in-class initializer.
3655 if (isImplicitCopyOrMove())
3656 return true;
3657
3658 // If there's no explicit initialization, the field is active only if it
3659 // has an in-class initializer...
3660 if (Field->hasInClassInitializer())
3661 return false;
3662 // ... or it's an anonymous struct or union whose class has an in-class
3663 // initializer.
3664 if (!Field->isAnonymousStructOrUnion())
3665 return true;
3666 CXXRecordDecl *FieldRD = Field->getType()->getAsCXXRecordDecl();
3667 return !FieldRD->hasInClassInitializer();
3668 }
3669
3670 /// \brief Determine whether the given field is, or is within, a union member
3671 /// that is inactive (because there was an initializer given for a different
3672 /// member of the union, or because the union was not initialized at all).
3673 bool isWithinInactiveUnionMember(FieldDecl *Field,
3674 IndirectFieldDecl *Indirect) {
3675 if (!Indirect)
3676 return isInactiveUnionMember(Field);
3677
Aaron Ballman29c94602014-03-07 18:36:15 +00003678 for (auto *C : Indirect->chain()) {
Aaron Ballman13916082014-03-07 18:11:58 +00003679 FieldDecl *Field = dyn_cast<FieldDecl>(C);
Richard Smithab44d5b2013-12-10 08:25:00 +00003680 if (Field && isInactiveUnionMember(Field))
Richard Smithc94ec842011-09-19 13:34:43 +00003681 return true;
Richard Smithab44d5b2013-12-10 08:25:00 +00003682 }
3683 return false;
3684 }
3685};
Richard Smithc94ec842011-09-19 13:34:43 +00003686}
3687
Douglas Gregor10f939c2011-11-02 23:04:16 +00003688/// \brief Determine whether the given type is an incomplete or zero-lenfgth
3689/// array type.
3690static bool isIncompleteOrZeroLengthArrayType(ASTContext &Context, QualType T) {
3691 if (T->isIncompleteArrayType())
3692 return true;
3693
3694 while (const ConstantArrayType *ArrayT = Context.getAsConstantArrayType(T)) {
3695 if (!ArrayT->getSize())
3696 return true;
3697
3698 T = ArrayT->getElementType();
3699 }
3700
3701 return false;
3702}
3703
Richard Smith938f40b2011-06-11 17:19:42 +00003704static bool CollectFieldInitializer(Sema &SemaRef, BaseAndFieldInfo &Info,
Douglas Gregor493627b2011-08-10 15:22:55 +00003705 FieldDecl *Field,
Craig Topperc3ec1492014-05-26 06:22:03 +00003706 IndirectFieldDecl *Indirect = nullptr) {
Eli Friedmanb13e64e2013-06-28 21:07:41 +00003707 if (Field->isInvalidDecl())
3708 return false;
John McCallbc83b3f2010-05-20 23:23:51 +00003709
Chandler Carruth139e9622010-06-30 02:59:29 +00003710 // Overwhelmingly common case: we have a direct initializer for this field.
Richard Smithcd45dbc2014-04-19 03:48:30 +00003711 if (CXXCtorInitializer *Init =
3712 Info.AllBaseFields.lookup(Field->getCanonicalDecl()))
Richard Smith0a8cfc72012-08-07 21:30:42 +00003713 return Info.addFieldInitializer(Init);
John McCallbc83b3f2010-05-20 23:23:51 +00003714
Richard Smithab44d5b2013-12-10 08:25:00 +00003715 // C++11 [class.base.init]p8:
3716 // if the entity is a non-static data member that has a
3717 // brace-or-equal-initializer and either
3718 // -- the constructor's class is a union and no other variant member of that
3719 // union is designated by a mem-initializer-id or
3720 // -- the constructor's class is not a union, and, if the entity is a member
3721 // of an anonymous union, no other member of that union is designated by
3722 // a mem-initializer-id,
3723 // the entity is initialized as specified in [dcl.init].
3724 //
3725 // We also apply the same rules to handle anonymous structs within anonymous
3726 // unions.
3727 if (Info.isWithinInactiveUnionMember(Field, Indirect))
3728 return false;
3729
Douglas Gregor7db3e952011-11-28 20:03:15 +00003730 if (Field->hasInClassInitializer() && !Info.isImplicitCopyOrMove()) {
Richard Smith852c9db2013-04-20 22:23:05 +00003731 Expr *DIE = CXXDefaultInitExpr::Create(SemaRef.Context,
3732 Info.Ctor->getLocation(), Field);
Douglas Gregor493627b2011-08-10 15:22:55 +00003733 CXXCtorInitializer *Init;
3734 if (Indirect)
3735 Init = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, Indirect,
3736 SourceLocation(),
Richard Smith852c9db2013-04-20 22:23:05 +00003737 SourceLocation(), DIE,
Douglas Gregor493627b2011-08-10 15:22:55 +00003738 SourceLocation());
3739 else
3740 Init = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, Field,
3741 SourceLocation(),
Richard Smith852c9db2013-04-20 22:23:05 +00003742 SourceLocation(), DIE,
Douglas Gregor493627b2011-08-10 15:22:55 +00003743 SourceLocation());
Richard Smith0a8cfc72012-08-07 21:30:42 +00003744 return Info.addFieldInitializer(Init);
Richard Smith938f40b2011-06-11 17:19:42 +00003745 }
3746
Douglas Gregor10f939c2011-11-02 23:04:16 +00003747 // Don't initialize incomplete or zero-length arrays.
3748 if (isIncompleteOrZeroLengthArrayType(SemaRef.Context, Field->getType()))
3749 return false;
3750
John McCallbc83b3f2010-05-20 23:23:51 +00003751 // Don't try to build an implicit initializer if there were semantic
3752 // errors in any of the initializers (and therefore we might be
3753 // missing some that the user actually wrote).
Eli Friedmanb13e64e2013-06-28 21:07:41 +00003754 if (Info.AnyErrorsInInits)
John McCallbc83b3f2010-05-20 23:23:51 +00003755 return false;
3756
Craig Topperc3ec1492014-05-26 06:22:03 +00003757 CXXCtorInitializer *Init = nullptr;
Douglas Gregor493627b2011-08-10 15:22:55 +00003758 if (BuildImplicitMemberInitializer(Info.S, Info.Ctor, Info.IIK, Field,
3759 Indirect, Init))
John McCallbc83b3f2010-05-20 23:23:51 +00003760 return true;
John McCallbc83b3f2010-05-20 23:23:51 +00003761
Richard Smith0a8cfc72012-08-07 21:30:42 +00003762 if (!Init)
3763 return false;
Francois Pichetd583da02010-12-04 09:14:42 +00003764
Richard Smith0a8cfc72012-08-07 21:30:42 +00003765 return Info.addFieldInitializer(Init);
John McCallbc83b3f2010-05-20 23:23:51 +00003766}
Alexis Hunt61bc1732011-05-01 07:04:31 +00003767
3768bool
3769Sema::SetDelegatingInitializer(CXXConstructorDecl *Constructor,
3770 CXXCtorInitializer *Initializer) {
Alexis Hunt6118d662011-05-04 05:57:24 +00003771 assert(Initializer->isDelegatingInitializer());
Alexis Hunt5583d562011-05-03 20:43:02 +00003772 Constructor->setNumCtorInitializers(1);
3773 CXXCtorInitializer **initializer =
3774 new (Context) CXXCtorInitializer*[1];
3775 memcpy(initializer, &Initializer, sizeof (CXXCtorInitializer*));
3776 Constructor->setCtorInitializers(initializer);
3777
Alexis Hunt9d47faf2011-05-03 23:05:34 +00003778 if (CXXDestructorDecl *Dtor = LookupDestructor(Constructor->getParent())) {
Eli Friedmanfa0df832012-02-02 03:46:19 +00003779 MarkFunctionReferenced(Initializer->getSourceLocation(), Dtor);
Alexis Hunt9d47faf2011-05-03 23:05:34 +00003780 DiagnoseUseOfDecl(Dtor, Initializer->getSourceLocation());
3781 }
3782
Alexis Hunte2622992011-05-05 00:05:47 +00003783 DelegatingCtorDecls.push_back(Constructor);
Alexis Hunt6118d662011-05-04 05:57:24 +00003784
Richard Trieu8a0c9e62014-09-12 22:47:58 +00003785 DiagnoseUninitializedFields(*this, Constructor);
3786
Alexis Hunt61bc1732011-05-01 07:04:31 +00003787 return false;
3788}
Douglas Gregor493627b2011-08-10 15:22:55 +00003789
David Blaikie3fc2f912013-01-17 05:26:25 +00003790bool Sema::SetCtorInitializers(CXXConstructorDecl *Constructor, bool AnyErrors,
3791 ArrayRef<CXXCtorInitializer *> Initializers) {
Douglas Gregor52235292011-09-22 23:04:35 +00003792 if (Constructor->isDependentContext()) {
Anders Carlssondb0a9652010-04-02 06:26:44 +00003793 // Just store the initializers as written, they will be checked during
3794 // instantiation.
David Blaikie3fc2f912013-01-17 05:26:25 +00003795 if (!Initializers.empty()) {
3796 Constructor->setNumCtorInitializers(Initializers.size());
Alexis Hunt1d792652011-01-08 20:30:50 +00003797 CXXCtorInitializer **baseOrMemberInitializers =
David Blaikie3fc2f912013-01-17 05:26:25 +00003798 new (Context) CXXCtorInitializer*[Initializers.size()];
3799 memcpy(baseOrMemberInitializers, Initializers.data(),
3800 Initializers.size() * sizeof(CXXCtorInitializer*));
Alexis Hunt1d792652011-01-08 20:30:50 +00003801 Constructor->setCtorInitializers(baseOrMemberInitializers);
Anders Carlssondb0a9652010-04-02 06:26:44 +00003802 }
Richard Smith60f2e1e2012-09-25 00:23:05 +00003803
3804 // Let template instantiation know whether we had errors.
3805 if (AnyErrors)
3806 Constructor->setInvalidDecl();
3807
Anders Carlssondb0a9652010-04-02 06:26:44 +00003808 return false;
3809 }
3810
John McCallbc83b3f2010-05-20 23:23:51 +00003811 BaseAndFieldInfo Info(*this, Constructor, AnyErrors);
Anders Carlsson1b00e242010-04-23 03:10:23 +00003812
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00003813 // We need to build the initializer AST according to order of construction
3814 // and not what user specified in the Initializers list.
Anders Carlsson7b3f2782010-04-02 05:42:15 +00003815 CXXRecordDecl *ClassDecl = Constructor->getParent()->getDefinition();
Douglas Gregorc14922f2010-03-26 22:43:07 +00003816 if (!ClassDecl)
3817 return true;
3818
Eli Friedman9cf6b592009-11-09 19:20:36 +00003819 bool HadError = false;
Mike Stump11289f42009-09-09 15:08:12 +00003820
David Blaikie3fc2f912013-01-17 05:26:25 +00003821 for (unsigned i = 0; i < Initializers.size(); i++) {
Alexis Hunt1d792652011-01-08 20:30:50 +00003822 CXXCtorInitializer *Member = Initializers[i];
Richard Smithbc46e432013-07-22 02:56:56 +00003823
Anders Carlssondb0a9652010-04-02 06:26:44 +00003824 if (Member->isBaseInitializer())
John McCallbc83b3f2010-05-20 23:23:51 +00003825 Info.AllBaseFields[Member->getBaseClass()->getAs<RecordType>()] = Member;
Richard Smithab44d5b2013-12-10 08:25:00 +00003826 else {
Richard Smithcd45dbc2014-04-19 03:48:30 +00003827 Info.AllBaseFields[Member->getAnyMember()->getCanonicalDecl()] = Member;
Richard Smithab44d5b2013-12-10 08:25:00 +00003828
3829 if (IndirectFieldDecl *F = Member->getIndirectMember()) {
Aaron Ballman29c94602014-03-07 18:36:15 +00003830 for (auto *C : F->chain()) {
Aaron Ballman13916082014-03-07 18:11:58 +00003831 FieldDecl *FD = dyn_cast<FieldDecl>(C);
Richard Smithab44d5b2013-12-10 08:25:00 +00003832 if (FD && FD->getParent()->isUnion())
3833 Info.ActiveUnionMember.insert(std::make_pair(
3834 FD->getParent()->getCanonicalDecl(), FD->getCanonicalDecl()));
3835 }
3836 } else if (FieldDecl *FD = Member->getMember()) {
3837 if (FD->getParent()->isUnion())
3838 Info.ActiveUnionMember.insert(std::make_pair(
3839 FD->getParent()->getCanonicalDecl(), FD->getCanonicalDecl()));
3840 }
3841 }
Anders Carlssondb0a9652010-04-02 06:26:44 +00003842 }
3843
Anders Carlsson43c64af2010-04-21 19:52:01 +00003844 // Keep track of the direct virtual bases.
3845 llvm::SmallPtrSet<CXXBaseSpecifier *, 16> DirectVBases;
Aaron Ballman574705e2014-03-13 15:41:46 +00003846 for (auto &I : ClassDecl->bases()) {
3847 if (I.isVirtual())
3848 DirectVBases.insert(&I);
Anders Carlsson43c64af2010-04-21 19:52:01 +00003849 }
3850
Anders Carlssondb0a9652010-04-02 06:26:44 +00003851 // Push virtual bases before others.
Aaron Ballman445a9392014-03-13 16:15:17 +00003852 for (auto &VBase : ClassDecl->vbases()) {
Alexis Hunt1d792652011-01-08 20:30:50 +00003853 if (CXXCtorInitializer *Value
Aaron Ballman445a9392014-03-13 16:15:17 +00003854 = Info.AllBaseFields.lookup(VBase.getType()->getAs<RecordType>())) {
Richard Smithbc46e432013-07-22 02:56:56 +00003855 // [class.base.init]p7, per DR257:
3856 // A mem-initializer where the mem-initializer-id names a virtual base
3857 // class is ignored during execution of a constructor of any class that
3858 // is not the most derived class.
3859 if (ClassDecl->isAbstract()) {
3860 // FIXME: Provide a fixit to remove the base specifier. This requires
3861 // tracking the location of the associated comma for a base specifier.
3862 Diag(Value->getSourceLocation(), diag::warn_abstract_vbase_init_ignored)
Aaron Ballman445a9392014-03-13 16:15:17 +00003863 << VBase.getType() << ClassDecl;
Richard Smithbc46e432013-07-22 02:56:56 +00003864 DiagnoseAbstractType(ClassDecl);
3865 }
3866
John McCallbc83b3f2010-05-20 23:23:51 +00003867 Info.AllToInit.push_back(Value);
Richard Smithbc46e432013-07-22 02:56:56 +00003868 } else if (!AnyErrors && !ClassDecl->isAbstract()) {
3869 // [class.base.init]p8, per DR257:
3870 // If a given [...] base class is not named by a mem-initializer-id
3871 // [...] and the entity is not a virtual base class of an abstract
3872 // class, then [...] the entity is default-initialized.
Aaron Ballman445a9392014-03-13 16:15:17 +00003873 bool IsInheritedVirtualBase = !DirectVBases.count(&VBase);
Alexis Hunt1d792652011-01-08 20:30:50 +00003874 CXXCtorInitializer *CXXBaseInit;
John McCallbc83b3f2010-05-20 23:23:51 +00003875 if (BuildImplicitBaseInitializer(*this, Constructor, Info.IIK,
Aaron Ballman445a9392014-03-13 16:15:17 +00003876 &VBase, IsInheritedVirtualBase,
Anders Carlsson1b00e242010-04-23 03:10:23 +00003877 CXXBaseInit)) {
Anders Carlssondb0a9652010-04-02 06:26:44 +00003878 HadError = true;
3879 continue;
3880 }
Anders Carlssoncedc0a42010-04-20 23:11:20 +00003881
John McCallbc83b3f2010-05-20 23:23:51 +00003882 Info.AllToInit.push_back(CXXBaseInit);
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00003883 }
3884 }
Mike Stump11289f42009-09-09 15:08:12 +00003885
John McCallbc83b3f2010-05-20 23:23:51 +00003886 // Non-virtual bases.
Aaron Ballman574705e2014-03-13 15:41:46 +00003887 for (auto &Base : ClassDecl->bases()) {
Anders Carlssondb0a9652010-04-02 06:26:44 +00003888 // Virtuals are in the virtual base list and already constructed.
Aaron Ballman574705e2014-03-13 15:41:46 +00003889 if (Base.isVirtual())
Anders Carlssondb0a9652010-04-02 06:26:44 +00003890 continue;
Mike Stump11289f42009-09-09 15:08:12 +00003891
Alexis Hunt1d792652011-01-08 20:30:50 +00003892 if (CXXCtorInitializer *Value
Aaron Ballman574705e2014-03-13 15:41:46 +00003893 = Info.AllBaseFields.lookup(Base.getType()->getAs<RecordType>())) {
John McCallbc83b3f2010-05-20 23:23:51 +00003894 Info.AllToInit.push_back(Value);
Anders Carlssondb0a9652010-04-02 06:26:44 +00003895 } else if (!AnyErrors) {
Alexis Hunt1d792652011-01-08 20:30:50 +00003896 CXXCtorInitializer *CXXBaseInit;
John McCallbc83b3f2010-05-20 23:23:51 +00003897 if (BuildImplicitBaseInitializer(*this, Constructor, Info.IIK,
Aaron Ballman574705e2014-03-13 15:41:46 +00003898 &Base, /*IsInheritedVirtualBase=*/false,
Anders Carlsson6bd91c32010-04-23 02:00:02 +00003899 CXXBaseInit)) {
Anders Carlssondb0a9652010-04-02 06:26:44 +00003900 HadError = true;
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00003901 continue;
Anders Carlssondb0a9652010-04-02 06:26:44 +00003902 }
Fariborz Jahanian59a1cd42009-09-03 21:32:41 +00003903
John McCallbc83b3f2010-05-20 23:23:51 +00003904 Info.AllToInit.push_back(CXXBaseInit);
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00003905 }
3906 }
Mike Stump11289f42009-09-09 15:08:12 +00003907
John McCallbc83b3f2010-05-20 23:23:51 +00003908 // Fields.
Aaron Ballman629afae2014-03-07 19:56:05 +00003909 for (auto *Mem : ClassDecl->decls()) {
3910 if (auto *F = dyn_cast<FieldDecl>(Mem)) {
Douglas Gregor556e5862011-10-10 17:22:13 +00003911 // C++ [class.bit]p2:
3912 // A declaration for a bit-field that omits the identifier declares an
3913 // unnamed bit-field. Unnamed bit-fields are not members and cannot be
3914 // initialized.
3915 if (F->isUnnamedBitfield())
3916 continue;
Douglas Gregor10f939c2011-11-02 23:04:16 +00003917
Sebastian Redl22653ba2011-08-30 19:58:05 +00003918 // If we're not generating the implicit copy/move constructor, then we'll
Douglas Gregor493627b2011-08-10 15:22:55 +00003919 // handle anonymous struct/union fields based on their individual
3920 // indirect fields.
Richard Smithc2bc61b2013-03-18 21:12:30 +00003921 if (F->isAnonymousStructOrUnion() && !Info.isImplicitCopyOrMove())
Douglas Gregor493627b2011-08-10 15:22:55 +00003922 continue;
3923
3924 if (CollectFieldInitializer(*this, Info, F))
3925 HadError = true;
Fariborz Jahanian1138ba62010-05-26 20:19:07 +00003926 continue;
3927 }
Douglas Gregor493627b2011-08-10 15:22:55 +00003928
3929 // Beyond this point, we only consider default initialization.
Richard Smithc2bc61b2013-03-18 21:12:30 +00003930 if (Info.isImplicitCopyOrMove())
Douglas Gregor493627b2011-08-10 15:22:55 +00003931 continue;
3932
Aaron Ballman629afae2014-03-07 19:56:05 +00003933 if (auto *F = dyn_cast<IndirectFieldDecl>(Mem)) {
Douglas Gregor493627b2011-08-10 15:22:55 +00003934 if (F->getType()->isIncompleteArrayType()) {
3935 assert(ClassDecl->hasFlexibleArrayMember() &&
3936 "Incomplete array type is not valid");
3937 continue;
3938 }
3939
Douglas Gregor493627b2011-08-10 15:22:55 +00003940 // Initialize each field of an anonymous struct individually.
3941 if (CollectFieldInitializer(*this, Info, F->getAnonField(), F))
3942 HadError = true;
3943
3944 continue;
3945 }
Fariborz Jahanian1138ba62010-05-26 20:19:07 +00003946 }
Mike Stump11289f42009-09-09 15:08:12 +00003947
David Blaikie3fc2f912013-01-17 05:26:25 +00003948 unsigned NumInitializers = Info.AllToInit.size();
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00003949 if (NumInitializers > 0) {
Alexis Hunt1d792652011-01-08 20:30:50 +00003950 Constructor->setNumCtorInitializers(NumInitializers);
3951 CXXCtorInitializer **baseOrMemberInitializers =
3952 new (Context) CXXCtorInitializer*[NumInitializers];
John McCallbc83b3f2010-05-20 23:23:51 +00003953 memcpy(baseOrMemberInitializers, Info.AllToInit.data(),
Alexis Hunt1d792652011-01-08 20:30:50 +00003954 NumInitializers * sizeof(CXXCtorInitializer*));
3955 Constructor->setCtorInitializers(baseOrMemberInitializers);
Rafael Espindola13327bb2010-03-13 18:12:56 +00003956
John McCalla6309952010-03-16 21:39:52 +00003957 // Constructors implicitly reference the base and member
3958 // destructors.
3959 MarkBaseAndMemberDestructorsReferenced(Constructor->getLocation(),
3960 Constructor->getParent());
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00003961 }
Eli Friedman9cf6b592009-11-09 19:20:36 +00003962
3963 return HadError;
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00003964}
3965
David Blaikieb61b8152013-01-17 08:49:22 +00003966static void PopulateKeysForFields(FieldDecl *Field, SmallVectorImpl<const void*> &IdealInits) {
Ted Kremenekc23c7e62009-07-29 21:53:49 +00003967 if (const RecordType *RT = Field->getType()->getAs<RecordType>()) {
David Blaikieb61b8152013-01-17 08:49:22 +00003968 const RecordDecl *RD = RT->getDecl();
3969 if (RD->isAnonymousStructOrUnion()) {
Aaron Ballmane8a8bae2014-03-08 20:12:42 +00003970 for (auto *Field : RD->fields())
3971 PopulateKeysForFields(Field, IdealInits);
David Blaikieb61b8152013-01-17 08:49:22 +00003972 return;
3973 }
Eli Friedman952c15d2009-07-21 19:28:10 +00003974 }
Richard Smithcd45dbc2014-04-19 03:48:30 +00003975 IdealInits.push_back(Field->getCanonicalDecl());
Eli Friedman952c15d2009-07-21 19:28:10 +00003976}
3977
Benjamin Kramer8bf44352013-07-24 15:28:33 +00003978static const void *GetKeyForBase(ASTContext &Context, QualType BaseType) {
3979 return Context.getCanonicalType(BaseType).getTypePtr();
Anders Carlssonbcec05c2009-09-01 06:22:14 +00003980}
3981
Benjamin Kramer8bf44352013-07-24 15:28:33 +00003982static const void *GetKeyForMember(ASTContext &Context,
3983 CXXCtorInitializer *Member) {
Francois Pichetd583da02010-12-04 09:14:42 +00003984 if (!Member->isAnyMemberInitializer())
Anders Carlsson7b3f2782010-04-02 05:42:15 +00003985 return GetKeyForBase(Context, QualType(Member->getBaseClass(), 0));
Anders Carlssona942dcd2010-03-30 15:39:27 +00003986
Richard Smithcd45dbc2014-04-19 03:48:30 +00003987 return Member->getAnyMember()->getCanonicalDecl();
Eli Friedman952c15d2009-07-21 19:28:10 +00003988}
3989
David Blaikie3fc2f912013-01-17 05:26:25 +00003990static void DiagnoseBaseOrMemInitializerOrder(
3991 Sema &SemaRef, const CXXConstructorDecl *Constructor,
3992 ArrayRef<CXXCtorInitializer *> Inits) {
John McCallbb7b6582010-04-10 07:37:23 +00003993 if (Constructor->getDeclContext()->isDependentContext())
Anders Carlsson35d6e3e2009-08-27 05:57:30 +00003994 return;
Mike Stump11289f42009-09-09 15:08:12 +00003995
Argyrios Kyrtzidis1cb0de12010-12-15 18:44:22 +00003996 // Don't check initializers order unless the warning is enabled at the
3997 // location of at least one initializer.
3998 bool ShouldCheckOrder = false;
David Blaikie3fc2f912013-01-17 05:26:25 +00003999 for (unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {
Alexis Hunt1d792652011-01-08 20:30:50 +00004000 CXXCtorInitializer *Init = Inits[InitIndex];
Alp Tokerd4a3f0e2014-06-15 23:30:39 +00004001 if (!SemaRef.Diags.isIgnored(diag::warn_initializer_out_of_order,
4002 Init->getSourceLocation())) {
Argyrios Kyrtzidis1cb0de12010-12-15 18:44:22 +00004003 ShouldCheckOrder = true;
4004 break;
4005 }
4006 }
4007 if (!ShouldCheckOrder)
Anders Carlssone0eebb32009-08-27 05:45:01 +00004008 return;
Anders Carlssone857b292010-04-02 03:37:03 +00004009
John McCallbb7b6582010-04-10 07:37:23 +00004010 // Build the list of bases and members in the order that they'll
4011 // actually be initialized. The explicit initializers should be in
4012 // this same order but may be missing things.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004013 SmallVector<const void*, 32> IdealInitKeys;
Mike Stump11289f42009-09-09 15:08:12 +00004014
Anders Carlsson96b8fc62010-04-02 03:38:04 +00004015 const CXXRecordDecl *ClassDecl = Constructor->getParent();
4016
John McCallbb7b6582010-04-10 07:37:23 +00004017 // 1. Virtual bases.
Aaron Ballman445a9392014-03-13 16:15:17 +00004018 for (const auto &VBase : ClassDecl->vbases())
4019 IdealInitKeys.push_back(GetKeyForBase(SemaRef.Context, VBase.getType()));
Mike Stump11289f42009-09-09 15:08:12 +00004020
John McCallbb7b6582010-04-10 07:37:23 +00004021 // 2. Non-virtual bases.
Aaron Ballman574705e2014-03-13 15:41:46 +00004022 for (const auto &Base : ClassDecl->bases()) {
4023 if (Base.isVirtual())
Anders Carlssone0eebb32009-08-27 05:45:01 +00004024 continue;
Aaron Ballman574705e2014-03-13 15:41:46 +00004025 IdealInitKeys.push_back(GetKeyForBase(SemaRef.Context, Base.getType()));
Anders Carlssone0eebb32009-08-27 05:45:01 +00004026 }
Mike Stump11289f42009-09-09 15:08:12 +00004027
John McCallbb7b6582010-04-10 07:37:23 +00004028 // 3. Direct fields.
Aaron Ballmane8a8bae2014-03-08 20:12:42 +00004029 for (auto *Field : ClassDecl->fields()) {
Douglas Gregor556e5862011-10-10 17:22:13 +00004030 if (Field->isUnnamedBitfield())
4031 continue;
4032
Aaron Ballmane8a8bae2014-03-08 20:12:42 +00004033 PopulateKeysForFields(Field, IdealInitKeys);
Douglas Gregor556e5862011-10-10 17:22:13 +00004034 }
4035
John McCallbb7b6582010-04-10 07:37:23 +00004036 unsigned NumIdealInits = IdealInitKeys.size();
4037 unsigned IdealIndex = 0;
Eli Friedman952c15d2009-07-21 19:28:10 +00004038
Craig Topperc3ec1492014-05-26 06:22:03 +00004039 CXXCtorInitializer *PrevInit = nullptr;
David Blaikie3fc2f912013-01-17 05:26:25 +00004040 for (unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {
Alexis Hunt1d792652011-01-08 20:30:50 +00004041 CXXCtorInitializer *Init = Inits[InitIndex];
Benjamin Kramer8bf44352013-07-24 15:28:33 +00004042 const void *InitKey = GetKeyForMember(SemaRef.Context, Init);
John McCallbb7b6582010-04-10 07:37:23 +00004043
4044 // Scan forward to try to find this initializer in the idealized
4045 // initializers list.
4046 for (; IdealIndex != NumIdealInits; ++IdealIndex)
4047 if (InitKey == IdealInitKeys[IdealIndex])
Anders Carlssone0eebb32009-08-27 05:45:01 +00004048 break;
John McCallbb7b6582010-04-10 07:37:23 +00004049
4050 // If we didn't find this initializer, it must be because we
4051 // scanned past it on a previous iteration. That can only
4052 // happen if we're out of order; emit a warning.
Douglas Gregoraabdfcb2010-05-20 23:49:34 +00004053 if (IdealIndex == NumIdealInits && PrevInit) {
John McCallbb7b6582010-04-10 07:37:23 +00004054 Sema::SemaDiagnosticBuilder D =
4055 SemaRef.Diag(PrevInit->getSourceLocation(),
4056 diag::warn_initializer_out_of_order);
4057
Francois Pichetd583da02010-12-04 09:14:42 +00004058 if (PrevInit->isAnyMemberInitializer())
4059 D << 0 << PrevInit->getAnyMember()->getDeclName();
John McCallbb7b6582010-04-10 07:37:23 +00004060 else
Douglas Gregord73f3dd2011-11-01 01:16:03 +00004061 D << 1 << PrevInit->getTypeSourceInfo()->getType();
John McCallbb7b6582010-04-10 07:37:23 +00004062
Francois Pichetd583da02010-12-04 09:14:42 +00004063 if (Init->isAnyMemberInitializer())
4064 D << 0 << Init->getAnyMember()->getDeclName();
John McCallbb7b6582010-04-10 07:37:23 +00004065 else
Douglas Gregord73f3dd2011-11-01 01:16:03 +00004066 D << 1 << Init->getTypeSourceInfo()->getType();
John McCallbb7b6582010-04-10 07:37:23 +00004067
4068 // Move back to the initializer's location in the ideal list.
4069 for (IdealIndex = 0; IdealIndex != NumIdealInits; ++IdealIndex)
4070 if (InitKey == IdealInitKeys[IdealIndex])
Anders Carlssone0eebb32009-08-27 05:45:01 +00004071 break;
John McCallbb7b6582010-04-10 07:37:23 +00004072
4073 assert(IdealIndex != NumIdealInits &&
4074 "initializer not found in initializer list");
Fariborz Jahanian341583c2009-07-09 19:59:47 +00004075 }
John McCallbb7b6582010-04-10 07:37:23 +00004076
4077 PrevInit = Init;
Fariborz Jahanian341583c2009-07-09 19:59:47 +00004078 }
Anders Carlsson75fdaa42009-03-25 02:58:17 +00004079}
4080
John McCall23eebd92010-04-10 09:28:51 +00004081namespace {
4082bool CheckRedundantInit(Sema &S,
Alexis Hunt1d792652011-01-08 20:30:50 +00004083 CXXCtorInitializer *Init,
4084 CXXCtorInitializer *&PrevInit) {
John McCall23eebd92010-04-10 09:28:51 +00004085 if (!PrevInit) {
4086 PrevInit = Init;
4087 return false;
4088 }
4089
Douglas Gregorea306a12013-03-25 23:28:23 +00004090 if (FieldDecl *Field = Init->getAnyMember())
John McCall23eebd92010-04-10 09:28:51 +00004091 S.Diag(Init->getSourceLocation(),
4092 diag::err_multiple_mem_initialization)
4093 << Field->getDeclName()
4094 << Init->getSourceRange();
4095 else {
John McCall424cec92011-01-19 06:33:43 +00004096 const Type *BaseClass = Init->getBaseClass();
John McCall23eebd92010-04-10 09:28:51 +00004097 assert(BaseClass && "neither field nor base");
4098 S.Diag(Init->getSourceLocation(),
4099 diag::err_multiple_base_initialization)
4100 << QualType(BaseClass, 0)
4101 << Init->getSourceRange();
4102 }
4103 S.Diag(PrevInit->getSourceLocation(), diag::note_previous_initializer)
4104 << 0 << PrevInit->getSourceRange();
4105
4106 return true;
4107}
4108
Alexis Hunt1d792652011-01-08 20:30:50 +00004109typedef std::pair<NamedDecl *, CXXCtorInitializer *> UnionEntry;
John McCall23eebd92010-04-10 09:28:51 +00004110typedef llvm::DenseMap<RecordDecl*, UnionEntry> RedundantUnionMap;
4111
4112bool CheckRedundantUnionInit(Sema &S,
Alexis Hunt1d792652011-01-08 20:30:50 +00004113 CXXCtorInitializer *Init,
John McCall23eebd92010-04-10 09:28:51 +00004114 RedundantUnionMap &Unions) {
Francois Pichetd583da02010-12-04 09:14:42 +00004115 FieldDecl *Field = Init->getAnyMember();
John McCall23eebd92010-04-10 09:28:51 +00004116 RecordDecl *Parent = Field->getParent();
John McCall23eebd92010-04-10 09:28:51 +00004117 NamedDecl *Child = Field;
David Blaikie0f65d592011-11-17 06:01:57 +00004118
4119 while (Parent->isAnonymousStructOrUnion() || Parent->isUnion()) {
John McCall23eebd92010-04-10 09:28:51 +00004120 if (Parent->isUnion()) {
4121 UnionEntry &En = Unions[Parent];
4122 if (En.first && En.first != Child) {
4123 S.Diag(Init->getSourceLocation(),
4124 diag::err_multiple_mem_union_initialization)
4125 << Field->getDeclName()
4126 << Init->getSourceRange();
4127 S.Diag(En.second->getSourceLocation(), diag::note_previous_initializer)
4128 << 0 << En.second->getSourceRange();
4129 return true;
David Blaikie256ee192011-11-12 20:54:14 +00004130 }
4131 if (!En.first) {
John McCall23eebd92010-04-10 09:28:51 +00004132 En.first = Child;
4133 En.second = Init;
4134 }
David Blaikie0f65d592011-11-17 06:01:57 +00004135 if (!Parent->isAnonymousStructOrUnion())
4136 return false;
John McCall23eebd92010-04-10 09:28:51 +00004137 }
4138
4139 Child = Parent;
4140 Parent = cast<RecordDecl>(Parent->getDeclContext());
David Blaikie0f65d592011-11-17 06:01:57 +00004141 }
John McCall23eebd92010-04-10 09:28:51 +00004142
4143 return false;
4144}
4145}
4146
Anders Carlssone857b292010-04-02 03:37:03 +00004147/// ActOnMemInitializers - Handle the member initializers for a constructor.
John McCall48871652010-08-21 09:40:31 +00004148void Sema::ActOnMemInitializers(Decl *ConstructorDecl,
Anders Carlssone857b292010-04-02 03:37:03 +00004149 SourceLocation ColonLoc,
David Blaikie3fc2f912013-01-17 05:26:25 +00004150 ArrayRef<CXXCtorInitializer*> MemInits,
Anders Carlssone857b292010-04-02 03:37:03 +00004151 bool AnyErrors) {
4152 if (!ConstructorDecl)
4153 return;
4154
4155 AdjustDeclIfTemplate(ConstructorDecl);
4156
4157 CXXConstructorDecl *Constructor
John McCall48871652010-08-21 09:40:31 +00004158 = dyn_cast<CXXConstructorDecl>(ConstructorDecl);
Anders Carlssone857b292010-04-02 03:37:03 +00004159
4160 if (!Constructor) {
4161 Diag(ColonLoc, diag::err_only_constructors_take_base_inits);
4162 return;
4163 }
4164
John McCall23eebd92010-04-10 09:28:51 +00004165 // Mapping for the duplicate initializers check.
4166 // For member initializers, this is keyed with a FieldDecl*.
4167 // For base initializers, this is keyed with a Type*.
Benjamin Kramer8bf44352013-07-24 15:28:33 +00004168 llvm::DenseMap<const void *, CXXCtorInitializer *> Members;
John McCall23eebd92010-04-10 09:28:51 +00004169
4170 // Mapping for the inconsistent anonymous-union initializers check.
4171 RedundantUnionMap MemberUnions;
4172
Anders Carlsson7b3f2782010-04-02 05:42:15 +00004173 bool HadError = false;
David Blaikie3fc2f912013-01-17 05:26:25 +00004174 for (unsigned i = 0; i < MemInits.size(); i++) {
Alexis Hunt1d792652011-01-08 20:30:50 +00004175 CXXCtorInitializer *Init = MemInits[i];
Anders Carlssone857b292010-04-02 03:37:03 +00004176
Abramo Bagnara341d7832010-05-26 18:09:23 +00004177 // Set the source order index.
4178 Init->setSourceOrder(i);
4179
Francois Pichetd583da02010-12-04 09:14:42 +00004180 if (Init->isAnyMemberInitializer()) {
Richard Smithcd45dbc2014-04-19 03:48:30 +00004181 const void *Key = GetKeyForMember(Context, Init);
4182 if (CheckRedundantInit(*this, Init, Members[Key]) ||
John McCall23eebd92010-04-10 09:28:51 +00004183 CheckRedundantUnionInit(*this, Init, MemberUnions))
4184 HadError = true;
Alexis Huntc5575cc2011-02-26 19:13:13 +00004185 } else if (Init->isBaseInitializer()) {
Richard Smithcd45dbc2014-04-19 03:48:30 +00004186 const void *Key = GetKeyForMember(Context, Init);
John McCall23eebd92010-04-10 09:28:51 +00004187 if (CheckRedundantInit(*this, Init, Members[Key]))
4188 HadError = true;
Alexis Huntc5575cc2011-02-26 19:13:13 +00004189 } else {
4190 assert(Init->isDelegatingInitializer());
4191 // This must be the only initializer
David Blaikie3fc2f912013-01-17 05:26:25 +00004192 if (MemInits.size() != 1) {
Richard Smith21f06f02012-09-14 18:21:10 +00004193 Diag(Init->getSourceLocation(),
Alexis Huntc5575cc2011-02-26 19:13:13 +00004194 diag::err_delegating_initializer_alone)
Richard Smith21f06f02012-09-14 18:21:10 +00004195 << Init->getSourceRange() << MemInits[i ? 0 : 1]->getSourceRange();
Alexis Hunt61bc1732011-05-01 07:04:31 +00004196 // We will treat this as being the only initializer.
Alexis Huntc5575cc2011-02-26 19:13:13 +00004197 }
Alexis Hunt6118d662011-05-04 05:57:24 +00004198 SetDelegatingInitializer(Constructor, MemInits[i]);
Alexis Hunt61bc1732011-05-01 07:04:31 +00004199 // Return immediately as the initializer is set.
4200 return;
Anders Carlssone857b292010-04-02 03:37:03 +00004201 }
Anders Carlssone857b292010-04-02 03:37:03 +00004202 }
4203
Anders Carlsson7b3f2782010-04-02 05:42:15 +00004204 if (HadError)
4205 return;
4206
David Blaikie3fc2f912013-01-17 05:26:25 +00004207 DiagnoseBaseOrMemInitializerOrder(*this, Constructor, MemInits);
Anders Carlsson4c8cb012010-04-02 03:43:34 +00004208
David Blaikie3fc2f912013-01-17 05:26:25 +00004209 SetCtorInitializers(Constructor, AnyErrors, MemInits);
Richard Trieu3a446ff2013-09-16 21:54:53 +00004210
Richard Trieuef64e942013-10-25 00:56:00 +00004211 DiagnoseUninitializedFields(*this, Constructor);
Anders Carlssone857b292010-04-02 03:37:03 +00004212}
4213
Fariborz Jahanian37d06562009-09-03 23:18:17 +00004214void
John McCalla6309952010-03-16 21:39:52 +00004215Sema::MarkBaseAndMemberDestructorsReferenced(SourceLocation Location,
4216 CXXRecordDecl *ClassDecl) {
Richard Smith20104042011-09-18 12:11:43 +00004217 // Ignore dependent contexts. Also ignore unions, since their members never
4218 // have destructors implicitly called.
4219 if (ClassDecl->isDependentContext() || ClassDecl->isUnion())
Anders Carlssondee9a302009-11-17 04:44:12 +00004220 return;
John McCall1064d7e2010-03-16 05:22:47 +00004221
4222 // FIXME: all the access-control diagnostics are positioned on the
4223 // field/base declaration. That's probably good; that said, the
4224 // user might reasonably want to know why the destructor is being
4225 // emitted, and we currently don't say.
Anders Carlssondee9a302009-11-17 04:44:12 +00004226
Anders Carlssondee9a302009-11-17 04:44:12 +00004227 // Non-static data members.
Aaron Ballmane8a8bae2014-03-08 20:12:42 +00004228 for (auto *Field : ClassDecl->fields()) {
Fariborz Jahanian16f94c62010-05-17 18:15:18 +00004229 if (Field->isInvalidDecl())
4230 continue;
Douglas Gregor10f939c2011-11-02 23:04:16 +00004231
4232 // Don't destroy incomplete or zero-length arrays.
4233 if (isIncompleteOrZeroLengthArrayType(Context, Field->getType()))
4234 continue;
4235
Anders Carlssondee9a302009-11-17 04:44:12 +00004236 QualType FieldType = Context.getBaseElementType(Field->getType());
4237
4238 const RecordType* RT = FieldType->getAs<RecordType>();
4239 if (!RT)
4240 continue;
4241
4242 CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl());
Matt Beaumont-Gay93615d92011-03-28 01:39:13 +00004243 if (FieldClassDecl->isInvalidDecl())
4244 continue;
Richard Smitheec915d62012-02-18 04:13:32 +00004245 if (FieldClassDecl->hasIrrelevantDestructor())
Anders Carlssondee9a302009-11-17 04:44:12 +00004246 continue;
Richard Smith921bd202012-02-26 09:11:52 +00004247 // The destructor for an implicit anonymous union member is never invoked.
4248 if (FieldClassDecl->isUnion() && FieldClassDecl->isAnonymousStructOrUnion())
4249 continue;
Anders Carlssondee9a302009-11-17 04:44:12 +00004250
Douglas Gregore71edda2010-07-01 22:47:18 +00004251 CXXDestructorDecl *Dtor = LookupDestructor(FieldClassDecl);
Matt Beaumont-Gay93615d92011-03-28 01:39:13 +00004252 assert(Dtor && "No dtor found for FieldClassDecl!");
John McCall1064d7e2010-03-16 05:22:47 +00004253 CheckDestructorAccess(Field->getLocation(), Dtor,
Douglas Gregor89336232010-03-29 23:34:08 +00004254 PDiag(diag::err_access_dtor_field)
John McCall1064d7e2010-03-16 05:22:47 +00004255 << Field->getDeclName()
4256 << FieldType);
4257
Benjamin Kramer8bf44352013-07-24 15:28:33 +00004258 MarkFunctionReferenced(Location, Dtor);
Richard Smitheec915d62012-02-18 04:13:32 +00004259 DiagnoseUseOfDecl(Dtor, Location);
Anders Carlssondee9a302009-11-17 04:44:12 +00004260 }
4261
John McCall1064d7e2010-03-16 05:22:47 +00004262 llvm::SmallPtrSet<const RecordType *, 8> DirectVirtualBases;
4263
Anders Carlssondee9a302009-11-17 04:44:12 +00004264 // Bases.
Aaron Ballman574705e2014-03-13 15:41:46 +00004265 for (const auto &Base : ClassDecl->bases()) {
John McCall1064d7e2010-03-16 05:22:47 +00004266 // Bases are always records in a well-formed non-dependent class.
Aaron Ballman574705e2014-03-13 15:41:46 +00004267 const RecordType *RT = Base.getType()->getAs<RecordType>();
John McCall1064d7e2010-03-16 05:22:47 +00004268
4269 // Remember direct virtual bases.
Aaron Ballman574705e2014-03-13 15:41:46 +00004270 if (Base.isVirtual())
John McCall1064d7e2010-03-16 05:22:47 +00004271 DirectVirtualBases.insert(RT);
Anders Carlssondee9a302009-11-17 04:44:12 +00004272
John McCall1064d7e2010-03-16 05:22:47 +00004273 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(RT->getDecl());
Matt Beaumont-Gay93615d92011-03-28 01:39:13 +00004274 // If our base class is invalid, we probably can't get its dtor anyway.
4275 if (BaseClassDecl->isInvalidDecl())
4276 continue;
Richard Smitheec915d62012-02-18 04:13:32 +00004277 if (BaseClassDecl->hasIrrelevantDestructor())
Anders Carlssondee9a302009-11-17 04:44:12 +00004278 continue;
John McCall1064d7e2010-03-16 05:22:47 +00004279
Douglas Gregore71edda2010-07-01 22:47:18 +00004280 CXXDestructorDecl *Dtor = LookupDestructor(BaseClassDecl);
Matt Beaumont-Gay93615d92011-03-28 01:39:13 +00004281 assert(Dtor && "No dtor found for BaseClassDecl!");
John McCall1064d7e2010-03-16 05:22:47 +00004282
4283 // FIXME: caret should be on the start of the class name
Aaron Ballman574705e2014-03-13 15:41:46 +00004284 CheckDestructorAccess(Base.getLocStart(), Dtor,
Douglas Gregor89336232010-03-29 23:34:08 +00004285 PDiag(diag::err_access_dtor_base)
Aaron Ballman574705e2014-03-13 15:41:46 +00004286 << Base.getType()
4287 << Base.getSourceRange(),
John McCall5dadb652012-04-07 03:04:20 +00004288 Context.getTypeDeclType(ClassDecl));
Anders Carlssondee9a302009-11-17 04:44:12 +00004289
Benjamin Kramer8bf44352013-07-24 15:28:33 +00004290 MarkFunctionReferenced(Location, Dtor);
Richard Smitheec915d62012-02-18 04:13:32 +00004291 DiagnoseUseOfDecl(Dtor, Location);
Anders Carlssondee9a302009-11-17 04:44:12 +00004292 }
4293
4294 // Virtual bases.
Aaron Ballman445a9392014-03-13 16:15:17 +00004295 for (const auto &VBase : ClassDecl->vbases()) {
John McCall1064d7e2010-03-16 05:22:47 +00004296 // Bases are always records in a well-formed non-dependent class.
Aaron Ballman445a9392014-03-13 16:15:17 +00004297 const RecordType *RT = VBase.getType()->castAs<RecordType>();
John McCall1064d7e2010-03-16 05:22:47 +00004298
4299 // Ignore direct virtual bases.
4300 if (DirectVirtualBases.count(RT))
4301 continue;
4302
John McCall1064d7e2010-03-16 05:22:47 +00004303 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(RT->getDecl());
Matt Beaumont-Gay93615d92011-03-28 01:39:13 +00004304 // If our base class is invalid, we probably can't get its dtor anyway.
4305 if (BaseClassDecl->isInvalidDecl())
4306 continue;
Richard Smitheec915d62012-02-18 04:13:32 +00004307 if (BaseClassDecl->hasIrrelevantDestructor())
Fariborz Jahanian37d06562009-09-03 23:18:17 +00004308 continue;
John McCall1064d7e2010-03-16 05:22:47 +00004309
Douglas Gregore71edda2010-07-01 22:47:18 +00004310 CXXDestructorDecl *Dtor = LookupDestructor(BaseClassDecl);
Matt Beaumont-Gay93615d92011-03-28 01:39:13 +00004311 assert(Dtor && "No dtor found for BaseClassDecl!");
David Majnemer626032f2013-06-22 06:43:58 +00004312 if (CheckDestructorAccess(
4313 ClassDecl->getLocation(), Dtor,
4314 PDiag(diag::err_access_dtor_vbase)
Aaron Ballman445a9392014-03-13 16:15:17 +00004315 << Context.getTypeDeclType(ClassDecl) << VBase.getType(),
David Majnemer626032f2013-06-22 06:43:58 +00004316 Context.getTypeDeclType(ClassDecl)) ==
4317 AR_accessible) {
4318 CheckDerivedToBaseConversion(
Aaron Ballman445a9392014-03-13 16:15:17 +00004319 Context.getTypeDeclType(ClassDecl), VBase.getType(),
David Majnemer626032f2013-06-22 06:43:58 +00004320 diag::err_access_dtor_vbase, 0, ClassDecl->getLocation(),
Craig Topperc3ec1492014-05-26 06:22:03 +00004321 SourceRange(), DeclarationName(), nullptr);
David Majnemer626032f2013-06-22 06:43:58 +00004322 }
John McCall1064d7e2010-03-16 05:22:47 +00004323
Benjamin Kramer8bf44352013-07-24 15:28:33 +00004324 MarkFunctionReferenced(Location, Dtor);
Richard Smitheec915d62012-02-18 04:13:32 +00004325 DiagnoseUseOfDecl(Dtor, Location);
Fariborz Jahanian37d06562009-09-03 23:18:17 +00004326 }
4327}
4328
John McCall48871652010-08-21 09:40:31 +00004329void Sema::ActOnDefaultCtorInitializers(Decl *CDtorDecl) {
Fariborz Jahanian16094c22009-07-15 22:34:08 +00004330 if (!CDtorDecl)
Fariborz Jahanian49c81792009-07-14 18:24:21 +00004331 return;
Mike Stump11289f42009-09-09 15:08:12 +00004332
Mike Stump11289f42009-09-09 15:08:12 +00004333 if (CXXConstructorDecl *Constructor
Richard Trieuef64e942013-10-25 00:56:00 +00004334 = dyn_cast<CXXConstructorDecl>(CDtorDecl)) {
David Blaikie3fc2f912013-01-17 05:26:25 +00004335 SetCtorInitializers(Constructor, /*AnyErrors=*/false);
Richard Trieuef64e942013-10-25 00:56:00 +00004336 DiagnoseUninitializedFields(*this, Constructor);
4337 }
Fariborz Jahanian49c81792009-07-14 18:24:21 +00004338}
4339
Mike Stump11289f42009-09-09 15:08:12 +00004340bool Sema::RequireNonAbstractType(SourceLocation Loc, QualType T,
John McCall02db245d2010-08-18 09:41:07 +00004341 unsigned DiagID, AbstractDiagSelID SelID) {
Douglas Gregorae298422012-05-04 17:09:59 +00004342 class NonAbstractTypeDiagnoser : public TypeDiagnoser {
4343 unsigned DiagID;
4344 AbstractDiagSelID SelID;
4345
4346 public:
4347 NonAbstractTypeDiagnoser(unsigned DiagID, AbstractDiagSelID SelID)
4348 : TypeDiagnoser(DiagID == 0), DiagID(DiagID), SelID(SelID) { }
Benjamin Kramer8bf44352013-07-24 15:28:33 +00004349
Craig Toppera798a9d2014-03-02 09:32:10 +00004350 void diagnose(Sema &S, SourceLocation Loc, QualType T) override {
Eli Friedman1d4c3cf2012-08-14 02:06:07 +00004351 if (Suppressed) return;
Douglas Gregorae298422012-05-04 17:09:59 +00004352 if (SelID == -1)
4353 S.Diag(Loc, DiagID) << T;
4354 else
4355 S.Diag(Loc, DiagID) << SelID << T;
4356 }
4357 } Diagnoser(DiagID, SelID);
4358
4359 return RequireNonAbstractType(Loc, T, Diagnoser);
Mike Stump11289f42009-09-09 15:08:12 +00004360}
4361
Anders Carlssoneabf7702009-08-27 00:13:57 +00004362bool Sema::RequireNonAbstractType(SourceLocation Loc, QualType T,
Douglas Gregorae298422012-05-04 17:09:59 +00004363 TypeDiagnoser &Diagnoser) {
David Blaikiebbafb8a2012-03-11 07:00:24 +00004364 if (!getLangOpts().CPlusPlus)
Anders Carlsson576cc6f2009-03-22 20:18:17 +00004365 return false;
Mike Stump11289f42009-09-09 15:08:12 +00004366
Anders Carlssoneb0c5322009-03-23 19:10:31 +00004367 if (const ArrayType *AT = Context.getAsArrayType(T))
Douglas Gregorae298422012-05-04 17:09:59 +00004368 return RequireNonAbstractType(Loc, AT->getElementType(), Diagnoser);
Mike Stump11289f42009-09-09 15:08:12 +00004369
Ted Kremenekc23c7e62009-07-29 21:53:49 +00004370 if (const PointerType *PT = T->getAs<PointerType>()) {
Anders Carlsson8f0d2182009-03-24 01:46:45 +00004371 // Find the innermost pointer type.
Ted Kremenekc23c7e62009-07-29 21:53:49 +00004372 while (const PointerType *T = PT->getPointeeType()->getAs<PointerType>())
Anders Carlsson8f0d2182009-03-24 01:46:45 +00004373 PT = T;
Mike Stump11289f42009-09-09 15:08:12 +00004374
Anders Carlsson8f0d2182009-03-24 01:46:45 +00004375 if (const ArrayType *AT = Context.getAsArrayType(PT->getPointeeType()))
Douglas Gregorae298422012-05-04 17:09:59 +00004376 return RequireNonAbstractType(Loc, AT->getElementType(), Diagnoser);
Anders Carlsson8f0d2182009-03-24 01:46:45 +00004377 }
Mike Stump11289f42009-09-09 15:08:12 +00004378
Ted Kremenekc23c7e62009-07-29 21:53:49 +00004379 const RecordType *RT = T->getAs<RecordType>();
Anders Carlsson576cc6f2009-03-22 20:18:17 +00004380 if (!RT)
4381 return false;
Mike Stump11289f42009-09-09 15:08:12 +00004382
John McCall67da35c2010-02-04 22:26:26 +00004383 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
Anders Carlsson576cc6f2009-03-22 20:18:17 +00004384
John McCall02db245d2010-08-18 09:41:07 +00004385 // We can't answer whether something is abstract until it has a
4386 // definition. If it's currently being defined, we'll walk back
4387 // over all the declarations when we have a full definition.
4388 const CXXRecordDecl *Def = RD->getDefinition();
4389 if (!Def || Def->isBeingDefined())
John McCall67da35c2010-02-04 22:26:26 +00004390 return false;
4391
Anders Carlsson576cc6f2009-03-22 20:18:17 +00004392 if (!RD->isAbstract())
4393 return false;
Mike Stump11289f42009-09-09 15:08:12 +00004394
Douglas Gregorae298422012-05-04 17:09:59 +00004395 Diagnoser.diagnose(*this, Loc, T);
John McCall02db245d2010-08-18 09:41:07 +00004396 DiagnoseAbstractType(RD);
Mike Stump11289f42009-09-09 15:08:12 +00004397
John McCall02db245d2010-08-18 09:41:07 +00004398 return true;
4399}
4400
4401void Sema::DiagnoseAbstractType(const CXXRecordDecl *RD) {
4402 // Check if we've already emitted the list of pure virtual functions
4403 // for this class.
Anders Carlsson576cc6f2009-03-22 20:18:17 +00004404 if (PureVirtualClassDiagSet && PureVirtualClassDiagSet->count(RD))
John McCall02db245d2010-08-18 09:41:07 +00004405 return;
Mike Stump11289f42009-09-09 15:08:12 +00004406
Richard Smithbc46e432013-07-22 02:56:56 +00004407 // If the diagnostic is suppressed, don't emit the notes. We're only
4408 // going to emit them once, so try to attach them to a diagnostic we're
4409 // actually going to show.
4410 if (Diags.isLastDiagnosticIgnored())
4411 return;
4412
Douglas Gregor4165bd62010-03-23 23:47:56 +00004413 CXXFinalOverriderMap FinalOverriders;
4414 RD->getFinalOverriders(FinalOverriders);
Mike Stump11289f42009-09-09 15:08:12 +00004415
Anders Carlssona2f74f32010-06-03 01:00:02 +00004416 // Keep a set of seen pure methods so we won't diagnose the same method
4417 // more than once.
4418 llvm::SmallPtrSet<const CXXMethodDecl *, 8> SeenPureMethods;
4419
Douglas Gregor4165bd62010-03-23 23:47:56 +00004420 for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
4421 MEnd = FinalOverriders.end();
4422 M != MEnd;
4423 ++M) {
4424 for (OverridingMethods::iterator SO = M->second.begin(),
4425 SOEnd = M->second.end();
4426 SO != SOEnd; ++SO) {
4427 // C++ [class.abstract]p4:
4428 // A class is abstract if it contains or inherits at least one
4429 // pure virtual function for which the final overrider is pure
4430 // virtual.
Mike Stump11289f42009-09-09 15:08:12 +00004431
Douglas Gregor4165bd62010-03-23 23:47:56 +00004432 //
4433 if (SO->second.size() != 1)
4434 continue;
4435
4436 if (!SO->second.front().Method->isPure())
4437 continue;
4438
Anders Carlssona2f74f32010-06-03 01:00:02 +00004439 if (!SeenPureMethods.insert(SO->second.front().Method))
4440 continue;
4441
Douglas Gregor4165bd62010-03-23 23:47:56 +00004442 Diag(SO->second.front().Method->getLocation(),
4443 diag::note_pure_virtual_function)
Chandler Carruth98e3c562011-02-18 23:59:51 +00004444 << SO->second.front().Method->getDeclName() << RD->getDeclName();
Douglas Gregor4165bd62010-03-23 23:47:56 +00004445 }
Anders Carlsson576cc6f2009-03-22 20:18:17 +00004446 }
4447
4448 if (!PureVirtualClassDiagSet)
4449 PureVirtualClassDiagSet.reset(new RecordDeclSetTy);
4450 PureVirtualClassDiagSet->insert(RD);
Anders Carlsson576cc6f2009-03-22 20:18:17 +00004451}
4452
Anders Carlssonb5a27b42009-03-24 01:19:16 +00004453namespace {
John McCall02db245d2010-08-18 09:41:07 +00004454struct AbstractUsageInfo {
4455 Sema &S;
4456 CXXRecordDecl *Record;
4457 CanQualType AbstractType;
4458 bool Invalid;
Mike Stump11289f42009-09-09 15:08:12 +00004459
John McCall02db245d2010-08-18 09:41:07 +00004460 AbstractUsageInfo(Sema &S, CXXRecordDecl *Record)
4461 : S(S), Record(Record),
4462 AbstractType(S.Context.getCanonicalType(
4463 S.Context.getTypeDeclType(Record))),
4464 Invalid(false) {}
Anders Carlssonb5a27b42009-03-24 01:19:16 +00004465
John McCall02db245d2010-08-18 09:41:07 +00004466 void DiagnoseAbstractType() {
4467 if (Invalid) return;
4468 S.DiagnoseAbstractType(Record);
4469 Invalid = true;
4470 }
Anders Carlssonb57738b2009-03-24 17:23:42 +00004471
John McCall02db245d2010-08-18 09:41:07 +00004472 void CheckType(const NamedDecl *D, TypeLoc TL, Sema::AbstractDiagSelID Sel);
4473};
4474
4475struct CheckAbstractUsage {
4476 AbstractUsageInfo &Info;
4477 const NamedDecl *Ctx;
4478
4479 CheckAbstractUsage(AbstractUsageInfo &Info, const NamedDecl *Ctx)
4480 : Info(Info), Ctx(Ctx) {}
4481
4482 void Visit(TypeLoc TL, Sema::AbstractDiagSelID Sel) {
4483 switch (TL.getTypeLocClass()) {
4484#define ABSTRACT_TYPELOC(CLASS, PARENT)
4485#define TYPELOC(CLASS, PARENT) \
David Blaikie6adc78e2013-02-18 22:06:02 +00004486 case TypeLoc::CLASS: Check(TL.castAs<CLASS##TypeLoc>(), Sel); break;
John McCall02db245d2010-08-18 09:41:07 +00004487#include "clang/AST/TypeLocNodes.def"
Anders Carlssonb5a27b42009-03-24 01:19:16 +00004488 }
John McCall02db245d2010-08-18 09:41:07 +00004489 }
Mike Stump11289f42009-09-09 15:08:12 +00004490
John McCall02db245d2010-08-18 09:41:07 +00004491 void Check(FunctionProtoTypeLoc TL, Sema::AbstractDiagSelID Sel) {
Alp Toker42a16a62014-01-25 23:51:36 +00004492 Visit(TL.getReturnLoc(), Sema::AbstractReturnType);
Alp Tokerb3fd5cf2014-01-21 00:32:38 +00004493 for (unsigned I = 0, E = TL.getNumParams(); I != E; ++I) {
4494 if (!TL.getParam(I))
Douglas Gregor385d3fd2011-02-22 23:21:06 +00004495 continue;
Alp Tokerb3fd5cf2014-01-21 00:32:38 +00004496
4497 TypeSourceInfo *TSI = TL.getParam(I)->getTypeSourceInfo();
John McCall02db245d2010-08-18 09:41:07 +00004498 if (TSI) Visit(TSI->getTypeLoc(), Sema::AbstractParamType);
Anders Carlssonb57738b2009-03-24 17:23:42 +00004499 }
John McCall02db245d2010-08-18 09:41:07 +00004500 }
Anders Carlssonb5a27b42009-03-24 01:19:16 +00004501
John McCall02db245d2010-08-18 09:41:07 +00004502 void Check(ArrayTypeLoc TL, Sema::AbstractDiagSelID Sel) {
4503 Visit(TL.getElementLoc(), Sema::AbstractArrayType);
4504 }
Mike Stump11289f42009-09-09 15:08:12 +00004505
John McCall02db245d2010-08-18 09:41:07 +00004506 void Check(TemplateSpecializationTypeLoc TL, Sema::AbstractDiagSelID Sel) {
4507 // Visit the type parameters from a permissive context.
4508 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) {
4509 TemplateArgumentLoc TAL = TL.getArgLoc(I);
4510 if (TAL.getArgument().getKind() == TemplateArgument::Type)
4511 if (TypeSourceInfo *TSI = TAL.getTypeSourceInfo())
4512 Visit(TSI->getTypeLoc(), Sema::AbstractNone);
4513 // TODO: other template argument types?
Anders Carlssonb5a27b42009-03-24 01:19:16 +00004514 }
John McCall02db245d2010-08-18 09:41:07 +00004515 }
Mike Stump11289f42009-09-09 15:08:12 +00004516
John McCall02db245d2010-08-18 09:41:07 +00004517 // Visit pointee types from a permissive context.
4518#define CheckPolymorphic(Type) \
4519 void Check(Type TL, Sema::AbstractDiagSelID Sel) { \
4520 Visit(TL.getNextTypeLoc(), Sema::AbstractNone); \
4521 }
4522 CheckPolymorphic(PointerTypeLoc)
4523 CheckPolymorphic(ReferenceTypeLoc)
4524 CheckPolymorphic(MemberPointerTypeLoc)
4525 CheckPolymorphic(BlockPointerTypeLoc)
Eli Friedman0dfb8892011-10-06 23:00:33 +00004526 CheckPolymorphic(AtomicTypeLoc)
Mike Stump11289f42009-09-09 15:08:12 +00004527
John McCall02db245d2010-08-18 09:41:07 +00004528 /// Handle all the types we haven't given a more specific
4529 /// implementation for above.
4530 void Check(TypeLoc TL, Sema::AbstractDiagSelID Sel) {
4531 // Every other kind of type that we haven't called out already
4532 // that has an inner type is either (1) sugar or (2) contains that
4533 // inner type in some way as a subobject.
4534 if (TypeLoc Next = TL.getNextTypeLoc())
4535 return Visit(Next, Sel);
4536
4537 // If there's no inner type and we're in a permissive context,
4538 // don't diagnose.
4539 if (Sel == Sema::AbstractNone) return;
4540
4541 // Check whether the type matches the abstract type.
4542 QualType T = TL.getType();
4543 if (T->isArrayType()) {
4544 Sel = Sema::AbstractArrayType;
4545 T = Info.S.Context.getBaseElementType(T);
Anders Carlssonb57738b2009-03-24 17:23:42 +00004546 }
John McCall02db245d2010-08-18 09:41:07 +00004547 CanQualType CT = T->getCanonicalTypeUnqualified().getUnqualifiedType();
4548 if (CT != Info.AbstractType) return;
4549
4550 // It matched; do some magic.
4551 if (Sel == Sema::AbstractArrayType) {
4552 Info.S.Diag(Ctx->getLocation(), diag::err_array_of_abstract_type)
4553 << T << TL.getSourceRange();
4554 } else {
4555 Info.S.Diag(Ctx->getLocation(), diag::err_abstract_type_in_decl)
4556 << Sel << T << TL.getSourceRange();
4557 }
4558 Info.DiagnoseAbstractType();
4559 }
4560};
4561
4562void AbstractUsageInfo::CheckType(const NamedDecl *D, TypeLoc TL,
4563 Sema::AbstractDiagSelID Sel) {
4564 CheckAbstractUsage(*this, D).Visit(TL, Sel);
4565}
4566
4567}
4568
4569/// Check for invalid uses of an abstract type in a method declaration.
4570static void CheckAbstractClassUsage(AbstractUsageInfo &Info,
4571 CXXMethodDecl *MD) {
4572 // No need to do the check on definitions, which require that
4573 // the return/param types be complete.
Alexis Hunt4a8ea102011-05-06 20:44:56 +00004574 if (MD->doesThisDeclarationHaveABody())
John McCall02db245d2010-08-18 09:41:07 +00004575 return;
4576
4577 // For safety's sake, just ignore it if we don't have type source
4578 // information. This should never happen for non-implicit methods,
4579 // but...
4580 if (TypeSourceInfo *TSI = MD->getTypeSourceInfo())
4581 Info.CheckType(MD, TSI->getTypeLoc(), Sema::AbstractNone);
4582}
4583
4584/// Check for invalid uses of an abstract type within a class definition.
4585static void CheckAbstractClassUsage(AbstractUsageInfo &Info,
4586 CXXRecordDecl *RD) {
Aaron Ballman629afae2014-03-07 19:56:05 +00004587 for (auto *D : RD->decls()) {
John McCall02db245d2010-08-18 09:41:07 +00004588 if (D->isImplicit()) continue;
4589
4590 // Methods and method templates.
4591 if (isa<CXXMethodDecl>(D)) {
4592 CheckAbstractClassUsage(Info, cast<CXXMethodDecl>(D));
4593 } else if (isa<FunctionTemplateDecl>(D)) {
4594 FunctionDecl *FD = cast<FunctionTemplateDecl>(D)->getTemplatedDecl();
4595 CheckAbstractClassUsage(Info, cast<CXXMethodDecl>(FD));
4596
4597 // Fields and static variables.
4598 } else if (isa<FieldDecl>(D)) {
4599 FieldDecl *FD = cast<FieldDecl>(D);
4600 if (TypeSourceInfo *TSI = FD->getTypeSourceInfo())
4601 Info.CheckType(FD, TSI->getTypeLoc(), Sema::AbstractFieldType);
4602 } else if (isa<VarDecl>(D)) {
4603 VarDecl *VD = cast<VarDecl>(D);
4604 if (TypeSourceInfo *TSI = VD->getTypeSourceInfo())
4605 Info.CheckType(VD, TSI->getTypeLoc(), Sema::AbstractVariableType);
4606
4607 // Nested classes and class templates.
4608 } else if (isa<CXXRecordDecl>(D)) {
4609 CheckAbstractClassUsage(Info, cast<CXXRecordDecl>(D));
4610 } else if (isa<ClassTemplateDecl>(D)) {
4611 CheckAbstractClassUsage(Info,
4612 cast<ClassTemplateDecl>(D)->getTemplatedDecl());
4613 }
4614 }
Anders Carlssonb5a27b42009-03-24 01:19:16 +00004615}
4616
Hans Wennborg853ae942014-05-30 16:59:42 +00004617/// \brief Check class-level dllimport/dllexport attribute.
4618static void checkDLLAttribute(Sema &S, CXXRecordDecl *Class) {
4619 Attr *ClassAttr = getDLLAttr(Class);
Hans Wennborg205c39b2014-08-23 22:34:43 +00004620
4621 // MSVC inherits DLL attributes to partial class template specializations.
4622 if (S.Context.getTargetInfo().getCXXABI().isMicrosoft() && !ClassAttr) {
4623 if (auto *Spec = dyn_cast<ClassTemplatePartialSpecializationDecl>(Class)) {
4624 if (Attr *TemplateAttr =
4625 getDLLAttr(Spec->getSpecializedTemplate()->getTemplatedDecl())) {
4626 auto *A = cast<InheritableAttr>(TemplateAttr->clone(S.getASTContext()));
4627 A->setInherited(true);
4628 ClassAttr = A;
4629 }
4630 }
4631 }
4632
Hans Wennborg853ae942014-05-30 16:59:42 +00004633 if (!ClassAttr)
4634 return;
4635
Hans Wennborgc2b7f7a2014-08-24 00:12:36 +00004636 if (S.Context.getTargetInfo().getCXXABI().isMicrosoft() &&
4637 !ClassAttr->isInherited()) {
4638 // Diagnose dll attributes on members of class with dll attribute.
4639 for (Decl *Member : Class->decls()) {
4640 if (!isa<VarDecl>(Member) && !isa<CXXMethodDecl>(Member))
4641 continue;
4642 InheritableAttr *MemberAttr = getDLLAttr(Member);
4643 if (!MemberAttr || MemberAttr->isInherited() || Member->isInvalidDecl())
4644 continue;
4645
4646 S.Diag(MemberAttr->getLocation(),
4647 diag::err_attribute_dll_member_of_dll_class)
4648 << MemberAttr << ClassAttr;
4649 S.Diag(ClassAttr->getLocation(), diag::note_previous_attribute);
4650 Member->setInvalidDecl();
4651 }
4652 }
4653
4654 if (Class->getDescribedClassTemplate())
4655 // Don't inherit dll attribute until the template is instantiated.
4656 return;
4657
Hans Wennborg606bd6d2014-11-03 14:24:45 +00004658 // The class is either imported or exported.
4659 const bool ClassExported = ClassAttr->getKind() == attr::DLLExport;
4660 const bool ClassImported = !ClassExported;
Hans Wennborg853ae942014-05-30 16:59:42 +00004661
4662 // Force declaration of implicit members so they can inherit the attribute.
4663 S.ForceDeclarationOfImplicitMembers(Class);
4664
4665 // FIXME: MSVC's docs say all bases must be exportable, but this doesn't
4666 // seem to be true in practice?
4667
Hans Wennborg334e4ff2014-08-21 01:14:01 +00004668 TemplateSpecializationKind TSK =
4669 Class->getTemplateSpecializationKind();
4670
Hans Wennborg853ae942014-05-30 16:59:42 +00004671 for (Decl *Member : Class->decls()) {
Hans Wennborge8ad3832014-06-11 22:44:39 +00004672 VarDecl *VD = dyn_cast<VarDecl>(Member);
4673 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Member);
4674
4675 // Only methods and static fields inherit the attributes.
4676 if (!VD && !MD)
Hans Wennborg853ae942014-05-30 16:59:42 +00004677 continue;
Hans Wennborge8ad3832014-06-11 22:44:39 +00004678
Hans Wennborg606bd6d2014-11-03 14:24:45 +00004679 if (MD) {
4680 // Don't process deleted methods.
4681 if (MD->isDeleted())
4682 continue;
Hans Wennborg853ae942014-05-30 16:59:42 +00004683
Hans Wennborg606bd6d2014-11-03 14:24:45 +00004684 if (MD->isMoveAssignmentOperator() && ClassImported && MD->isInlined()) {
4685 // Current MSVC versions don't export the move assignment operators, so
4686 // don't attempt to import them if we have a definition.
4687 continue;
4688 }
4689
4690 if (MD->isInlined() && ClassImported &&
4691 !S.Context.getTargetInfo().getCXXABI().isMicrosoft()) {
4692 // MinGW does not import inline functions.
4693 continue;
4694 }
Hans Wennborge8ad3832014-06-11 22:44:39 +00004695 }
4696
Hans Wennborgc2b7f7a2014-08-24 00:12:36 +00004697 if (!getDLLAttr(Member)) {
Hans Wennborg496524b2014-05-31 02:08:49 +00004698 auto *NewAttr =
4699 cast<InheritableAttr>(ClassAttr->clone(S.getASTContext()));
4700 NewAttr->setInherited(true);
4701 Member->addAttr(NewAttr);
4702 }
Hans Wennborg853ae942014-05-30 16:59:42 +00004703
Hans Wennborg2f9e2932014-08-23 21:10:39 +00004704 if (MD && ClassExported) {
4705 if (MD->isUserProvided()) {
4706 // Instantiate non-default methods..
Hans Wennborg334e4ff2014-08-21 01:14:01 +00004707
Hans Wennborg2f9e2932014-08-23 21:10:39 +00004708 // .. except for certain kinds of template specializations.
4709 if (TSK == TSK_ExplicitInstantiationDeclaration)
4710 continue;
4711 if (TSK == TSK_ImplicitInstantiation && !ClassAttr->isInherited())
4712 continue;
Hans Wennborg334e4ff2014-08-21 01:14:01 +00004713
Hans Wennborg2f9e2932014-08-23 21:10:39 +00004714 S.MarkFunctionReferenced(Class->getLocation(), MD);
4715 } else if (!MD->isTrivial() || MD->isExplicitlyDefaulted() ||
4716 MD->isCopyAssignmentOperator() ||
4717 MD->isMoveAssignmentOperator()) {
4718 // Instantiate non-trivial or explicitly defaulted methods, and the
4719 // copy assignment / move assignment operators.
4720 S.MarkFunctionReferenced(Class->getLocation(), MD);
4721 // Resolve its exception specification; CodeGen needs it.
4722 auto *FPT = MD->getType()->getAs<FunctionProtoType>();
4723 S.ResolveExceptionSpec(Class->getLocation(), FPT);
4724 S.ActOnFinishInlineMethodDef(MD);
Hans Wennborg853ae942014-05-30 16:59:42 +00004725 }
4726 }
4727 }
4728}
4729
Douglas Gregorc99f1552009-12-03 18:33:45 +00004730/// \brief Perform semantic checks on a class definition that has been
4731/// completing, introducing implicitly-declared members, checking for
4732/// abstract types, etc.
Douglas Gregor0be31a22010-07-02 17:43:08 +00004733void Sema::CheckCompletedCXXClass(CXXRecordDecl *Record) {
Douglas Gregor8fb95122010-09-29 00:15:42 +00004734 if (!Record)
Douglas Gregorc99f1552009-12-03 18:33:45 +00004735 return;
4736
John McCall02db245d2010-08-18 09:41:07 +00004737 if (Record->isAbstract() && !Record->isInvalidDecl()) {
4738 AbstractUsageInfo Info(*this, Record);
4739 CheckAbstractClassUsage(Info, Record);
4740 }
Douglas Gregor454a5b62010-04-15 00:00:53 +00004741
4742 // If this is not an aggregate type and has no user-declared constructor,
4743 // complain about any non-static data members of reference or const scalar
4744 // type, since they will never get initializers.
4745 if (!Record->isInvalidDecl() && !Record->isDependentType() &&
Douglas Gregorfbf19a02012-02-09 02:20:38 +00004746 !Record->isAggregate() && !Record->hasUserDeclaredConstructor() &&
4747 !Record->isLambda()) {
Douglas Gregor454a5b62010-04-15 00:00:53 +00004748 bool Complained = false;
Aaron Ballmane8a8bae2014-03-08 20:12:42 +00004749 for (const auto *F : Record->fields()) {
Douglas Gregor556e5862011-10-10 17:22:13 +00004750 if (F->hasInClassInitializer() || F->isUnnamedBitfield())
Richard Smith938f40b2011-06-11 17:19:42 +00004751 continue;
4752
Douglas Gregor454a5b62010-04-15 00:00:53 +00004753 if (F->getType()->isReferenceType() ||
Benjamin Kramer659d7fc2010-04-16 17:43:15 +00004754 (F->getType().isConstQualified() && F->getType()->isScalarType())) {
Douglas Gregor454a5b62010-04-15 00:00:53 +00004755 if (!Complained) {
4756 Diag(Record->getLocation(), diag::warn_no_constructor_for_refconst)
4757 << Record->getTagKind() << Record;
4758 Complained = true;
4759 }
4760
4761 Diag(F->getLocation(), diag::note_refconst_member_not_initialized)
4762 << F->getType()->isReferenceType()
4763 << F->getDeclName();
4764 }
4765 }
4766 }
Douglas Gregor88d292c2010-05-13 16:44:06 +00004767
Anders Carlssone771e762011-01-25 18:08:22 +00004768 if (Record->isDynamicClass() && !Record->isDependentType())
Douglas Gregor88d292c2010-05-13 16:44:06 +00004769 DynamicClasses.push_back(Record);
Douglas Gregor36c22a22010-10-15 13:21:21 +00004770
4771 if (Record->getIdentifier()) {
4772 // C++ [class.mem]p13:
4773 // If T is the name of a class, then each of the following shall have a
4774 // name different from T:
4775 // - every member of every anonymous union that is a member of class T.
4776 //
4777 // C++ [class.mem]p14:
4778 // In addition, if class T has a user-declared constructor (12.1), every
4779 // non-static data member of class T shall have a name different from T.
David Blaikieff7d47a2012-12-19 00:45:41 +00004780 DeclContext::lookup_result R = Record->lookup(Record->getDeclName());
4781 for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E;
4782 ++I) {
4783 NamedDecl *D = *I;
Francois Pichet783dd6e2010-11-21 06:08:52 +00004784 if ((isa<FieldDecl>(D) && Record->hasUserDeclaredConstructor()) ||
4785 isa<IndirectFieldDecl>(D)) {
4786 Diag(D->getLocation(), diag::err_member_name_of_class)
4787 << D->getDeclName();
Douglas Gregor36c22a22010-10-15 13:21:21 +00004788 break;
4789 }
Francois Pichet783dd6e2010-11-21 06:08:52 +00004790 }
Douglas Gregor36c22a22010-10-15 13:21:21 +00004791 }
Argyrios Kyrtzidis7f3986d2011-01-31 07:05:00 +00004792
Argyrios Kyrtzidis33799ca2011-01-31 17:10:25 +00004793 // Warn if the class has virtual methods but non-virtual public destructor.
Douglas Gregor0cf82f62011-02-19 19:14:36 +00004794 if (Record->isPolymorphic() && !Record->isDependentType()) {
Argyrios Kyrtzidis7f3986d2011-01-31 07:05:00 +00004795 CXXDestructorDecl *dtor = Record->getDestructor();
David Blaikie04e2e662014-05-09 22:02:28 +00004796 if ((!dtor || (!dtor->isVirtual() && dtor->getAccess() == AS_public)) &&
4797 !Record->hasAttr<FinalAttr>())
Argyrios Kyrtzidis7f3986d2011-01-31 07:05:00 +00004798 Diag(dtor ? dtor->getLocation() : Record->getLocation(),
4799 diag::warn_non_virtual_dtor) << Context.getRecordType(Record);
4800 }
Argyrios Kyrtzidis7272d9c2011-02-03 18:01:15 +00004801
David Majnemera5433082013-10-18 00:33:31 +00004802 if (Record->isAbstract()) {
4803 if (FinalAttr *FA = Record->getAttr<FinalAttr>()) {
4804 Diag(Record->getLocation(), diag::warn_abstract_final_class)
4805 << FA->isSpelledAsSealed();
4806 DiagnoseAbstractType(Record);
4807 }
David Blaikie348df502012-09-21 03:21:07 +00004808 }
4809
Fariborz Jahanianf920a0a2014-10-27 19:11:51 +00004810 bool HasMethodWithOverrideControl = false,
4811 HasOverridingMethodWithoutOverrideControl = false;
Argyrios Kyrtzidis7272d9c2011-02-03 18:01:15 +00004812 if (!Record->isDependentType()) {
Aaron Ballman2b124d12014-03-13 16:36:16 +00004813 for (auto *M : Record->methods()) {
Richard Smithbd305122012-12-11 01:14:52 +00004814 // See if a method overloads virtual methods in a base
4815 // class without overriding any.
David Blaikie2d7c57e2012-04-30 02:36:29 +00004816 if (!M->isStatic())
Aaron Ballman2b124d12014-03-13 16:36:16 +00004817 DiagnoseHiddenVirtualMethods(M);
Fariborz Jahanianf920a0a2014-10-27 19:11:51 +00004818 if (M->hasAttr<OverrideAttr>())
4819 HasMethodWithOverrideControl = true;
4820 else if (M->size_overridden_methods() > 0)
4821 HasOverridingMethodWithoutOverrideControl = true;
Richard Smithbd305122012-12-11 01:14:52 +00004822 // Check whether the explicitly-defaulted special members are valid.
4823 if (!M->isInvalidDecl() && M->isExplicitlyDefaulted())
Aaron Ballman2b124d12014-03-13 16:36:16 +00004824 CheckExplicitlyDefaultedSpecialMember(M);
Richard Smithbd305122012-12-11 01:14:52 +00004825
4826 // For an explicitly defaulted or deleted special member, we defer
4827 // determining triviality until the class is complete. That time is now!
4828 if (!M->isImplicit() && !M->isUserProvided()) {
Aaron Ballman2b124d12014-03-13 16:36:16 +00004829 CXXSpecialMember CSM = getSpecialMember(M);
Richard Smithbd305122012-12-11 01:14:52 +00004830 if (CSM != CXXInvalid) {
Aaron Ballman2b124d12014-03-13 16:36:16 +00004831 M->setTrivial(SpecialMemberIsTrivial(M, CSM));
Richard Smithbd305122012-12-11 01:14:52 +00004832
4833 // Inform the class that we've finished declaring this member.
Aaron Ballman2b124d12014-03-13 16:36:16 +00004834 Record->finishedDefaultedOrDeletedMember(M);
Richard Smithbd305122012-12-11 01:14:52 +00004835 }
4836 }
4837 }
4838 }
4839
Fariborz Jahanianf920a0a2014-10-27 19:11:51 +00004840 if (HasMethodWithOverrideControl &&
4841 HasOverridingMethodWithoutOverrideControl) {
4842 // At least one method has the 'override' control declared.
4843 // Diagnose all other overridden methods which do not have 'override' specified on them.
4844 for (auto *M : Record->methods())
4845 DiagnoseAbsenceOfOverrideControl(M);
4846 }
Richard Smithbd305122012-12-11 01:14:52 +00004847 // C++11 [dcl.constexpr]p8: A constexpr specifier for a non-static member
4848 // function that is not a constructor declares that member function to be
4849 // const. [...] The class of which that function is a member shall be
4850 // a literal type.
4851 //
4852 // If the class has virtual bases, any constexpr members will already have
4853 // been diagnosed by the checks performed on the member declaration, so
4854 // suppress this (less useful) diagnostic.
4855 //
4856 // We delay this until we know whether an explicitly-defaulted (or deleted)
4857 // destructor for the class is trivial.
Richard Smith2bf7fdb2013-01-02 11:42:31 +00004858 if (LangOpts.CPlusPlus11 && !Record->isDependentType() &&
Richard Smithbd305122012-12-11 01:14:52 +00004859 !Record->isLiteral() && !Record->getNumVBases()) {
Aaron Ballman2b124d12014-03-13 16:36:16 +00004860 for (const auto *M : Record->methods()) {
4861 if (M->isConstexpr() && M->isInstance() && !isa<CXXConstructorDecl>(M)) {
Richard Smithbd305122012-12-11 01:14:52 +00004862 switch (Record->getTemplateSpecializationKind()) {
4863 case TSK_ImplicitInstantiation:
4864 case TSK_ExplicitInstantiationDeclaration:
4865 case TSK_ExplicitInstantiationDefinition:
4866 // If a template instantiates to a non-literal type, but its members
4867 // instantiate to constexpr functions, the template is technically
4868 // ill-formed, but we allow it for sanity.
4869 continue;
4870
4871 case TSK_Undeclared:
4872 case TSK_ExplicitSpecialization:
4873 RequireLiteralType(M->getLocation(), Context.getRecordType(Record),
4874 diag::err_constexpr_method_non_literal);
4875 break;
4876 }
4877
4878 // Only produce one error per class.
4879 break;
4880 }
Argyrios Kyrtzidis7272d9c2011-02-03 18:01:15 +00004881 }
4882 }
Sebastian Redl08905022011-02-05 19:23:19 +00004883
John McCall95833f32014-02-27 20:30:49 +00004884 // ms_struct is a request to use the same ABI rules as MSVC. Check
4885 // whether this class uses any C++ features that are implemented
4886 // completely differently in MSVC, and if so, emit a diagnostic.
4887 // That diagnostic defaults to an error, but we allow projects to
4888 // map it down to a warning (or ignore it). It's a fairly common
4889 // practice among users of the ms_struct pragma to mass-annotate
4890 // headers, sweeping up a bunch of types that the project doesn't
4891 // really rely on MSVC-compatible layout for. We must therefore
4892 // support "ms_struct except for C++ stuff" as a secondary ABI.
4893 if (Record->isMsStruct(Context) &&
4894 (Record->isPolymorphic() || Record->getNumBases())) {
4895 Diag(Record->getLocation(), diag::warn_cxx_ms_struct);
Warren Hunt8f8bad72013-10-11 20:19:00 +00004896 }
4897
Richard Smithc2bc61b2013-03-18 21:12:30 +00004898 // Declare inheriting constructors. We do this eagerly here because:
4899 // - The standard requires an eager diagnostic for conflicting inheriting
Sebastian Redl08905022011-02-05 19:23:19 +00004900 // constructors from different classes.
4901 // - The lazy declaration of the other implicit constructors is so as to not
4902 // waste space and performance on classes that are not meant to be
4903 // instantiated (e.g. meta-functions). This doesn't apply to classes that
Richard Smithc2bc61b2013-03-18 21:12:30 +00004904 // have inheriting constructors.
4905 DeclareInheritingConstructors(Record);
Hans Wennborg853ae942014-05-30 16:59:42 +00004906
4907 checkDLLAttribute(*this, Record);
Alexis Hunt6d5b96c2011-05-10 00:49:42 +00004908}
4909
Richard Smith41c35d62013-11-27 03:39:20 +00004910/// Look up the special member function that would be called by a special
4911/// member function for a subobject of class type.
4912///
4913/// \param Class The class type of the subobject.
4914/// \param CSM The kind of special member function.
4915/// \param FieldQuals If the subobject is a field, its cv-qualifiers.
4916/// \param ConstRHS True if this is a copy operation with a const object
4917/// on its RHS, that is, if the argument to the outer special member
4918/// function is 'const' and this is not a field marked 'mutable'.
4919static Sema::SpecialMemberOverloadResult *lookupCallFromSpecialMember(
4920 Sema &S, CXXRecordDecl *Class, Sema::CXXSpecialMember CSM,
4921 unsigned FieldQuals, bool ConstRHS) {
4922 unsigned LHSQuals = 0;
4923 if (CSM == Sema::CXXCopyAssignment || CSM == Sema::CXXMoveAssignment)
4924 LHSQuals = FieldQuals;
4925
4926 unsigned RHSQuals = FieldQuals;
4927 if (CSM == Sema::CXXDefaultConstructor || CSM == Sema::CXXDestructor)
4928 RHSQuals = 0;
4929 else if (ConstRHS)
4930 RHSQuals |= Qualifiers::Const;
4931
4932 return S.LookupSpecialMember(Class, CSM,
4933 RHSQuals & Qualifiers::Const,
4934 RHSQuals & Qualifiers::Volatile,
4935 false,
4936 LHSQuals & Qualifiers::Const,
4937 LHSQuals & Qualifiers::Volatile);
4938}
4939
Richard Smithb5800092012-06-10 05:43:50 +00004940/// Is the special member function which would be selected to perform the
4941/// specified operation on the specified class type a constexpr constructor?
4942static bool specialMemberIsConstexpr(Sema &S, CXXRecordDecl *ClassDecl,
4943 Sema::CXXSpecialMember CSM,
Richard Smith41c35d62013-11-27 03:39:20 +00004944 unsigned Quals, bool ConstRHS) {
Richard Smithb5800092012-06-10 05:43:50 +00004945 Sema::SpecialMemberOverloadResult *SMOR =
Richard Smith41c35d62013-11-27 03:39:20 +00004946 lookupCallFromSpecialMember(S, ClassDecl, CSM, Quals, ConstRHS);
Richard Smithb5800092012-06-10 05:43:50 +00004947 if (!SMOR || !SMOR->getMethod())
4948 // A constructor we wouldn't select can't be "involved in initializing"
4949 // anything.
4950 return true;
4951 return SMOR->getMethod()->isConstexpr();
4952}
4953
4954/// Determine whether the specified special member function would be constexpr
4955/// if it were implicitly defined.
4956static bool defaultedSpecialMemberIsConstexpr(Sema &S, CXXRecordDecl *ClassDecl,
4957 Sema::CXXSpecialMember CSM,
4958 bool ConstArg) {
Richard Smith2bf7fdb2013-01-02 11:42:31 +00004959 if (!S.getLangOpts().CPlusPlus11)
Richard Smithb5800092012-06-10 05:43:50 +00004960 return false;
4961
4962 // C++11 [dcl.constexpr]p4:
4963 // In the definition of a constexpr constructor [...]
Richard Smith99005e62013-05-07 03:19:20 +00004964 bool Ctor = true;
Richard Smithb5800092012-06-10 05:43:50 +00004965 switch (CSM) {
4966 case Sema::CXXDefaultConstructor:
Richard Smith4086a132012-06-10 07:07:24 +00004967 // Since default constructor lookup is essentially trivial (and cannot
4968 // involve, for instance, template instantiation), we compute whether a
4969 // defaulted default constructor is constexpr directly within CXXRecordDecl.
4970 //
4971 // This is important for performance; we need to know whether the default
4972 // constructor is constexpr to determine whether the type is a literal type.
4973 return ClassDecl->defaultedDefaultConstructorIsConstexpr();
4974
Richard Smithb5800092012-06-10 05:43:50 +00004975 case Sema::CXXCopyConstructor:
4976 case Sema::CXXMoveConstructor:
Richard Smith4086a132012-06-10 07:07:24 +00004977 // For copy or move constructors, we need to perform overload resolution.
Richard Smithb5800092012-06-10 05:43:50 +00004978 break;
4979
4980 case Sema::CXXCopyAssignment:
4981 case Sema::CXXMoveAssignment:
Aaron Ballmandd69ef32014-08-19 15:55:55 +00004982 if (!S.getLangOpts().CPlusPlus14)
Richard Smith99005e62013-05-07 03:19:20 +00004983 return false;
4984 // In C++1y, we need to perform overload resolution.
4985 Ctor = false;
4986 break;
4987
Richard Smithb5800092012-06-10 05:43:50 +00004988 case Sema::CXXDestructor:
4989 case Sema::CXXInvalid:
4990 return false;
4991 }
4992
4993 // -- if the class is a non-empty union, or for each non-empty anonymous
4994 // union member of a non-union class, exactly one non-static data member
4995 // shall be initialized; [DR1359]
Richard Smith4086a132012-06-10 07:07:24 +00004996 //
4997 // If we squint, this is guaranteed, since exactly one non-static data member
4998 // will be initialized (if the constructor isn't deleted), we just don't know
4999 // which one.
Richard Smith99005e62013-05-07 03:19:20 +00005000 if (Ctor && ClassDecl->isUnion())
Richard Smith4086a132012-06-10 07:07:24 +00005001 return true;
Richard Smithb5800092012-06-10 05:43:50 +00005002
5003 // -- the class shall not have any virtual base classes;
Richard Smith99005e62013-05-07 03:19:20 +00005004 if (Ctor && ClassDecl->getNumVBases())
5005 return false;
5006
5007 // C++1y [class.copy]p26:
5008 // -- [the class] is a literal type, and
5009 if (!Ctor && !ClassDecl->isLiteral())
Richard Smithb5800092012-06-10 05:43:50 +00005010 return false;
5011
5012 // -- every constructor involved in initializing [...] base class
5013 // sub-objects shall be a constexpr constructor;
Richard Smith99005e62013-05-07 03:19:20 +00005014 // -- the assignment operator selected to copy/move each direct base
5015 // class is a constexpr function, and
Aaron Ballman574705e2014-03-13 15:41:46 +00005016 for (const auto &B : ClassDecl->bases()) {
5017 const RecordType *BaseType = B.getType()->getAs<RecordType>();
Richard Smithb5800092012-06-10 05:43:50 +00005018 if (!BaseType) continue;
5019
5020 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
Richard Smith41c35d62013-11-27 03:39:20 +00005021 if (!specialMemberIsConstexpr(S, BaseClassDecl, CSM, 0, ConstArg))
Richard Smithb5800092012-06-10 05:43:50 +00005022 return false;
5023 }
5024
5025 // -- every constructor involved in initializing non-static data members
5026 // [...] shall be a constexpr constructor;
5027 // -- every non-static data member and base class sub-object shall be
5028 // initialized
Richard Smith41c35d62013-11-27 03:39:20 +00005029 // -- for each non-static data member of X that is of class type (or array
Richard Smith99005e62013-05-07 03:19:20 +00005030 // thereof), the assignment operator selected to copy/move that member is
5031 // a constexpr function
Aaron Ballmane8a8bae2014-03-08 20:12:42 +00005032 for (const auto *F : ClassDecl->fields()) {
Richard Smithb5800092012-06-10 05:43:50 +00005033 if (F->isInvalidDecl())
5034 continue;
Richard Smith41c35d62013-11-27 03:39:20 +00005035 QualType BaseType = S.Context.getBaseElementType(F->getType());
5036 if (const RecordType *RecordTy = BaseType->getAs<RecordType>()) {
Richard Smithb5800092012-06-10 05:43:50 +00005037 CXXRecordDecl *FieldRecDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
Richard Smith41c35d62013-11-27 03:39:20 +00005038 if (!specialMemberIsConstexpr(S, FieldRecDecl, CSM,
5039 BaseType.getCVRQualifiers(),
5040 ConstArg && !F->isMutable()))
Richard Smithb5800092012-06-10 05:43:50 +00005041 return false;
Richard Smithb5800092012-06-10 05:43:50 +00005042 }
5043 }
5044
5045 // All OK, it's constexpr!
5046 return true;
5047}
5048
Richard Smithd3b5c9082012-07-27 04:22:15 +00005049static Sema::ImplicitExceptionSpecification
5050computeImplicitExceptionSpec(Sema &S, SourceLocation Loc, CXXMethodDecl *MD) {
5051 switch (S.getSpecialMember(MD)) {
5052 case Sema::CXXDefaultConstructor:
5053 return S.ComputeDefaultedDefaultCtorExceptionSpec(Loc, MD);
5054 case Sema::CXXCopyConstructor:
5055 return S.ComputeDefaultedCopyCtorExceptionSpec(MD);
5056 case Sema::CXXCopyAssignment:
5057 return S.ComputeDefaultedCopyAssignmentExceptionSpec(MD);
5058 case Sema::CXXMoveConstructor:
5059 return S.ComputeDefaultedMoveCtorExceptionSpec(MD);
5060 case Sema::CXXMoveAssignment:
5061 return S.ComputeDefaultedMoveAssignmentExceptionSpec(MD);
5062 case Sema::CXXDestructor:
5063 return S.ComputeDefaultedDtorExceptionSpec(MD);
5064 case Sema::CXXInvalid:
5065 break;
5066 }
Richard Smithc2bc61b2013-03-18 21:12:30 +00005067 assert(cast<CXXConstructorDecl>(MD)->getInheritedConstructor() &&
5068 "only special members have implicit exception specs");
5069 return S.ComputeInheritingCtorExceptionSpec(cast<CXXConstructorDecl>(MD));
Richard Smithd3b5c9082012-07-27 04:22:15 +00005070}
5071
Reid Kleckner78af0702013-08-27 23:08:25 +00005072static FunctionProtoType::ExtProtoInfo getImplicitMethodEPI(Sema &S,
5073 CXXMethodDecl *MD) {
5074 FunctionProtoType::ExtProtoInfo EPI;
5075
5076 // Build an exception specification pointing back at this member.
Richard Smith8acb4282014-07-31 21:57:55 +00005077 EPI.ExceptionSpec.Type = EST_Unevaluated;
5078 EPI.ExceptionSpec.SourceDecl = MD;
Reid Kleckner78af0702013-08-27 23:08:25 +00005079
5080 // Set the calling convention to the default for C++ instance methods.
5081 EPI.ExtInfo = EPI.ExtInfo.withCallingConv(
5082 S.Context.getDefaultCallingConvention(/*IsVariadic=*/false,
5083 /*IsCXXMethod=*/true));
5084 return EPI;
5085}
5086
Richard Smithd3b5c9082012-07-27 04:22:15 +00005087void Sema::EvaluateImplicitExceptionSpec(SourceLocation Loc, CXXMethodDecl *MD) {
5088 const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>();
5089 if (FPT->getExceptionSpecType() != EST_Unevaluated)
5090 return;
5091
Richard Smith7f782272012-07-30 23:48:14 +00005092 // Evaluate the exception specification.
Richard Smith8acb4282014-07-31 21:57:55 +00005093 auto ESI = computeImplicitExceptionSpec(*this, Loc, MD).getExceptionSpec();
Richard Smith564417a2014-03-20 21:47:22 +00005094
Richard Smith7f782272012-07-30 23:48:14 +00005095 // Update the type of the special member to use it.
Richard Smith8acb4282014-07-31 21:57:55 +00005096 UpdateExceptionSpec(MD, ESI);
Richard Smith7f782272012-07-30 23:48:14 +00005097
5098 // A user-provided destructor can be defined outside the class. When that
5099 // happens, be sure to update the exception specification on both
5100 // declarations.
5101 const FunctionProtoType *CanonicalFPT =
5102 MD->getCanonicalDecl()->getType()->castAs<FunctionProtoType>();
5103 if (CanonicalFPT->getExceptionSpecType() == EST_Unevaluated)
Richard Smith8acb4282014-07-31 21:57:55 +00005104 UpdateExceptionSpec(MD->getCanonicalDecl(), ESI);
Richard Smithd3b5c9082012-07-27 04:22:15 +00005105}
5106
Richard Smithb9e90b12012-05-15 04:39:51 +00005107void Sema::CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl *MD) {
5108 CXXRecordDecl *RD = MD->getParent();
5109 CXXSpecialMember CSM = getSpecialMember(MD);
Alexis Hunt6d5b96c2011-05-10 00:49:42 +00005110
Richard Smithb9e90b12012-05-15 04:39:51 +00005111 assert(MD->isExplicitlyDefaulted() && CSM != CXXInvalid &&
5112 "not an explicitly-defaulted special member");
Alexis Hunt913820d2011-05-13 06:10:58 +00005113
5114 // Whether this was the first-declared instance of the constructor.
Richard Smithb9e90b12012-05-15 04:39:51 +00005115 // This affects whether we implicitly add an exception spec and constexpr.
Alexis Huntc9a55732011-05-14 05:23:28 +00005116 bool First = MD == MD->getCanonicalDecl();
5117
5118 bool HadError = false;
Richard Smithb9e90b12012-05-15 04:39:51 +00005119
5120 // C++11 [dcl.fct.def.default]p1:
5121 // A function that is explicitly defaulted shall
5122 // -- be a special member function (checked elsewhere),
5123 // -- have the same type (except for ref-qualifiers, and except that a
5124 // copy operation can take a non-const reference) as an implicit
5125 // declaration, and
5126 // -- not have default arguments.
5127 unsigned ExpectedParams = 1;
5128 if (CSM == CXXDefaultConstructor || CSM == CXXDestructor)
5129 ExpectedParams = 0;
5130 if (MD->getNumParams() != ExpectedParams) {
5131 // This also checks for default arguments: a copy or move constructor with a
5132 // default argument is classified as a default constructor, and assignment
5133 // operations and destructors can't have default arguments.
5134 Diag(MD->getLocation(), diag::err_defaulted_special_member_params)
5135 << CSM << MD->getSourceRange();
Alexis Huntc9a55732011-05-14 05:23:28 +00005136 HadError = true;
Richard Smith50d705b2012-12-07 02:10:28 +00005137 } else if (MD->isVariadic()) {
5138 Diag(MD->getLocation(), diag::err_defaulted_special_member_variadic)
5139 << CSM << MD->getSourceRange();
5140 HadError = true;
Alexis Huntc9a55732011-05-14 05:23:28 +00005141 }
5142
Richard Smithb9e90b12012-05-15 04:39:51 +00005143 const FunctionProtoType *Type = MD->getType()->getAs<FunctionProtoType>();
Alexis Huntc9a55732011-05-14 05:23:28 +00005144
Richard Smithb5800092012-06-10 05:43:50 +00005145 bool CanHaveConstParam = false;
Richard Smith92f241f2012-12-08 02:53:02 +00005146 if (CSM == CXXCopyConstructor)
Richard Smith1c33fe82012-11-28 06:23:12 +00005147 CanHaveConstParam = RD->implicitCopyConstructorHasConstParam();
Richard Smith92f241f2012-12-08 02:53:02 +00005148 else if (CSM == CXXCopyAssignment)
Richard Smith1c33fe82012-11-28 06:23:12 +00005149 CanHaveConstParam = RD->implicitCopyAssignmentHasConstParam();
Alexis Huntc9a55732011-05-14 05:23:28 +00005150
Richard Smithb9e90b12012-05-15 04:39:51 +00005151 QualType ReturnType = Context.VoidTy;
5152 if (CSM == CXXCopyAssignment || CSM == CXXMoveAssignment) {
5153 // Check for return type matching.
Alp Toker314cc812014-01-25 16:55:45 +00005154 ReturnType = Type->getReturnType();
Richard Smithb9e90b12012-05-15 04:39:51 +00005155 QualType ExpectedReturnType =
5156 Context.getLValueReferenceType(Context.getTypeDeclType(RD));
5157 if (!Context.hasSameType(ReturnType, ExpectedReturnType)) {
5158 Diag(MD->getLocation(), diag::err_defaulted_special_member_return_type)
5159 << (CSM == CXXMoveAssignment) << ExpectedReturnType;
5160 HadError = true;
5161 }
5162
5163 // A defaulted special member cannot have cv-qualifiers.
5164 if (Type->getTypeQuals()) {
5165 Diag(MD->getLocation(), diag::err_defaulted_special_member_quals)
Aaron Ballmandd69ef32014-08-19 15:55:55 +00005166 << (CSM == CXXMoveAssignment) << getLangOpts().CPlusPlus14;
Richard Smithb9e90b12012-05-15 04:39:51 +00005167 HadError = true;
5168 }
5169 }
5170
5171 // Check for parameter type matching.
Alp Toker9cacbab2014-01-20 20:26:09 +00005172 QualType ArgType = ExpectedParams ? Type->getParamType(0) : QualType();
Richard Smithb5800092012-06-10 05:43:50 +00005173 bool HasConstParam = false;
Richard Smithb9e90b12012-05-15 04:39:51 +00005174 if (ExpectedParams && ArgType->isReferenceType()) {
5175 // Argument must be reference to possibly-const T.
5176 QualType ReferentType = ArgType->getPointeeType();
Richard Smithb5800092012-06-10 05:43:50 +00005177 HasConstParam = ReferentType.isConstQualified();
Richard Smithb9e90b12012-05-15 04:39:51 +00005178
5179 if (ReferentType.isVolatileQualified()) {
5180 Diag(MD->getLocation(),
5181 diag::err_defaulted_special_member_volatile_param) << CSM;
5182 HadError = true;
5183 }
5184
Richard Smithb5800092012-06-10 05:43:50 +00005185 if (HasConstParam && !CanHaveConstParam) {
Richard Smithb9e90b12012-05-15 04:39:51 +00005186 if (CSM == CXXCopyConstructor || CSM == CXXCopyAssignment) {
5187 Diag(MD->getLocation(),
5188 diag::err_defaulted_special_member_copy_const_param)
5189 << (CSM == CXXCopyAssignment);
5190 // FIXME: Explain why this special member can't be const.
5191 } else {
5192 Diag(MD->getLocation(),
5193 diag::err_defaulted_special_member_move_const_param)
5194 << (CSM == CXXMoveAssignment);
5195 }
5196 HadError = true;
5197 }
Richard Smithb9e90b12012-05-15 04:39:51 +00005198 } else if (ExpectedParams) {
5199 // A copy assignment operator can take its argument by value, but a
5200 // defaulted one cannot.
5201 assert(CSM == CXXCopyAssignment && "unexpected non-ref argument");
Alexis Hunt604aeb32011-05-17 20:44:43 +00005202 Diag(MD->getLocation(), diag::err_defaulted_copy_assign_not_ref);
Alexis Huntc9a55732011-05-14 05:23:28 +00005203 HadError = true;
5204 }
Alexis Hunt604aeb32011-05-17 20:44:43 +00005205
Richard Smithcc36f692011-12-22 02:22:31 +00005206 // C++11 [dcl.fct.def.default]p2:
5207 // An explicitly-defaulted function may be declared constexpr only if it
5208 // would have been implicitly declared as constexpr,
Richard Smithb9e90b12012-05-15 04:39:51 +00005209 // Do not apply this rule to members of class templates, since core issue 1358
5210 // makes such functions always instantiate to constexpr functions. For
Richard Smith99005e62013-05-07 03:19:20 +00005211 // functions which cannot be constexpr (for non-constructors in C++11 and for
5212 // destructors in C++1y), this is checked elsewhere.
Richard Smithb5800092012-06-10 05:43:50 +00005213 bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, RD, CSM,
5214 HasConstParam);
Aaron Ballmandd69ef32014-08-19 15:55:55 +00005215 if ((getLangOpts().CPlusPlus14 ? !isa<CXXDestructorDecl>(MD)
Richard Smith99005e62013-05-07 03:19:20 +00005216 : isa<CXXConstructorDecl>(MD)) &&
5217 MD->isConstexpr() && !Constexpr &&
Richard Smithb9e90b12012-05-15 04:39:51 +00005218 MD->getTemplatedKind() == FunctionDecl::TK_NonTemplate) {
5219 Diag(MD->getLocStart(), diag::err_incorrect_defaulted_constexpr) << CSM;
Richard Smith99005e62013-05-07 03:19:20 +00005220 // FIXME: Explain why the special member can't be constexpr.
Richard Smithb9e90b12012-05-15 04:39:51 +00005221 HadError = true;
Richard Smithcc36f692011-12-22 02:22:31 +00005222 }
Richard Smithbd305122012-12-11 01:14:52 +00005223
Richard Smithcc36f692011-12-22 02:22:31 +00005224 // and may have an explicit exception-specification only if it is compatible
5225 // with the exception-specification on the implicit declaration.
Richard Smithbd305122012-12-11 01:14:52 +00005226 if (Type->hasExceptionSpec()) {
5227 // Delay the check if this is the first declaration of the special member,
5228 // since we may not have parsed some necessary in-class initializers yet.
Richard Smith3901dfe2013-03-27 00:22:47 +00005229 if (First) {
5230 // If the exception specification needs to be instantiated, do so now,
5231 // before we clobber it with an EST_Unevaluated specification below.
5232 if (Type->getExceptionSpecType() == EST_Uninstantiated) {
5233 InstantiateExceptionSpec(MD->getLocStart(), MD);
5234 Type = MD->getType()->getAs<FunctionProtoType>();
5235 }
Richard Smithbd305122012-12-11 01:14:52 +00005236 DelayedDefaultedMemberExceptionSpecs.push_back(std::make_pair(MD, Type));
Richard Smith3901dfe2013-03-27 00:22:47 +00005237 } else
Richard Smithbd305122012-12-11 01:14:52 +00005238 CheckExplicitlyDefaultedMemberExceptionSpec(MD, Type);
5239 }
Richard Smithcc36f692011-12-22 02:22:31 +00005240
5241 // If a function is explicitly defaulted on its first declaration,
5242 if (First) {
5243 // -- it is implicitly considered to be constexpr if the implicit
5244 // definition would be,
Richard Smithb9e90b12012-05-15 04:39:51 +00005245 MD->setConstexpr(Constexpr);
Richard Smithcc36f692011-12-22 02:22:31 +00005246
Richard Smithb9e90b12012-05-15 04:39:51 +00005247 // -- it is implicitly considered to have the same exception-specification
5248 // as if it had been implicitly declared,
Richard Smithbd305122012-12-11 01:14:52 +00005249 FunctionProtoType::ExtProtoInfo EPI = Type->getExtProtoInfo();
Richard Smith8acb4282014-07-31 21:57:55 +00005250 EPI.ExceptionSpec.Type = EST_Unevaluated;
5251 EPI.ExceptionSpec.SourceDecl = MD;
Jordan Rose5c382722013-03-08 21:51:21 +00005252 MD->setType(Context.getFunctionType(ReturnType,
Craig Topper5fc8fc22014-08-27 06:28:36 +00005253 llvm::makeArrayRef(&ArgType,
Jordan Rose5c382722013-03-08 21:51:21 +00005254 ExpectedParams),
5255 EPI));
Sebastian Redl22653ba2011-08-30 19:58:05 +00005256 }
5257
Richard Smithb9e90b12012-05-15 04:39:51 +00005258 if (ShouldDeleteSpecialMember(MD, CSM)) {
Sebastian Redl22653ba2011-08-30 19:58:05 +00005259 if (First) {
Richard Smithb4d2a152013-04-02 19:38:47 +00005260 SetDeclDeleted(MD, MD->getLocation());
Sebastian Redl22653ba2011-08-30 19:58:05 +00005261 } else {
Richard Smithb9e90b12012-05-15 04:39:51 +00005262 // C++11 [dcl.fct.def.default]p4:
5263 // [For a] user-provided explicitly-defaulted function [...] if such a
5264 // function is implicitly defined as deleted, the program is ill-formed.
5265 Diag(MD->getLocation(), diag::err_out_of_line_default_deletes) << CSM;
Richard Smith566184a2014-01-22 20:09:10 +00005266 ShouldDeleteSpecialMember(MD, CSM, /*Diagnose*/true);
Richard Smithb9e90b12012-05-15 04:39:51 +00005267 HadError = true;
Sebastian Redl22653ba2011-08-30 19:58:05 +00005268 }
5269 }
Sebastian Redl22653ba2011-08-30 19:58:05 +00005270
Richard Smithb9e90b12012-05-15 04:39:51 +00005271 if (HadError)
5272 MD->setInvalidDecl();
Alexis Huntf91729462011-05-12 22:46:25 +00005273}
5274
Richard Smithbd305122012-12-11 01:14:52 +00005275/// Check whether the exception specification provided for an
5276/// explicitly-defaulted special member matches the exception specification
5277/// that would have been generated for an implicit special member, per
5278/// C++11 [dcl.fct.def.default]p2.
5279void Sema::CheckExplicitlyDefaultedMemberExceptionSpec(
5280 CXXMethodDecl *MD, const FunctionProtoType *SpecifiedType) {
5281 // Compute the implicit exception specification.
Reid Kleckner78af0702013-08-27 23:08:25 +00005282 CallingConv CC = Context.getDefaultCallingConvention(/*IsVariadic=*/false,
5283 /*IsCXXMethod=*/true);
5284 FunctionProtoType::ExtProtoInfo EPI(CC);
Richard Smith8acb4282014-07-31 21:57:55 +00005285 EPI.ExceptionSpec = computeImplicitExceptionSpec(*this, MD->getLocation(), MD)
5286 .getExceptionSpec();
Richard Smithbd305122012-12-11 01:14:52 +00005287 const FunctionProtoType *ImplicitType = cast<FunctionProtoType>(
Dmitri Gribenko44ebbd52013-05-05 00:41:58 +00005288 Context.getFunctionType(Context.VoidTy, None, EPI));
Richard Smithbd305122012-12-11 01:14:52 +00005289
5290 // Ensure that it matches.
5291 CheckEquivalentExceptionSpec(
5292 PDiag(diag::err_incorrect_defaulted_exception_spec)
5293 << getSpecialMember(MD), PDiag(),
5294 ImplicitType, SourceLocation(),
5295 SpecifiedType, MD->getLocation());
5296}
5297
Alp Tokerae3a9442013-10-18 05:54:19 +00005298void Sema::CheckDelayedMemberExceptionSpecs() {
5299 SmallVector<std::pair<const CXXDestructorDecl *, const CXXDestructorDecl *>,
5300 2> Checks;
5301 SmallVector<std::pair<CXXMethodDecl *, const FunctionProtoType *>, 2> Specs;
Richard Smithbd305122012-12-11 01:14:52 +00005302
Alp Tokerae3a9442013-10-18 05:54:19 +00005303 std::swap(Checks, DelayedDestructorExceptionSpecChecks);
5304 std::swap(Specs, DelayedDefaultedMemberExceptionSpecs);
5305
5306 // Perform any deferred checking of exception specifications for virtual
5307 // destructors.
5308 for (unsigned i = 0, e = Checks.size(); i != e; ++i) {
5309 const CXXDestructorDecl *Dtor = Checks[i].first;
5310 assert(!Dtor->getParent()->isDependentType() &&
5311 "Should not ever add destructors of templates into the list.");
5312 CheckOverridingFunctionExceptionSpec(Dtor, Checks[i].second);
5313 }
5314
5315 // Check that any explicitly-defaulted methods have exception specifications
5316 // compatible with their implicit exception specifications.
5317 for (unsigned I = 0, N = Specs.size(); I != N; ++I)
5318 CheckExplicitlyDefaultedMemberExceptionSpec(Specs[I].first,
5319 Specs[I].second);
Richard Smithbd305122012-12-11 01:14:52 +00005320}
5321
Richard Smithd951a1d2012-02-18 02:02:13 +00005322namespace {
5323struct SpecialMemberDeletionInfo {
5324 Sema &S;
5325 CXXMethodDecl *MD;
5326 Sema::CXXSpecialMember CSM;
Richard Smith852265f2012-03-30 20:53:28 +00005327 bool Diagnose;
Richard Smithd951a1d2012-02-18 02:02:13 +00005328
5329 // Properties of the special member, computed for convenience.
Richard Smith41c35d62013-11-27 03:39:20 +00005330 bool IsConstructor, IsAssignment, IsMove, ConstArg;
Richard Smithd951a1d2012-02-18 02:02:13 +00005331 SourceLocation Loc;
5332
5333 bool AllFieldsAreConst;
5334
5335 SpecialMemberDeletionInfo(Sema &S, CXXMethodDecl *MD,
Richard Smith852265f2012-03-30 20:53:28 +00005336 Sema::CXXSpecialMember CSM, bool Diagnose)
5337 : S(S), MD(MD), CSM(CSM), Diagnose(Diagnose),
Richard Smithd951a1d2012-02-18 02:02:13 +00005338 IsConstructor(false), IsAssignment(false), IsMove(false),
Richard Smith41c35d62013-11-27 03:39:20 +00005339 ConstArg(false), Loc(MD->getLocation()),
Richard Smithd951a1d2012-02-18 02:02:13 +00005340 AllFieldsAreConst(true) {
5341 switch (CSM) {
5342 case Sema::CXXDefaultConstructor:
5343 case Sema::CXXCopyConstructor:
5344 IsConstructor = true;
5345 break;
5346 case Sema::CXXMoveConstructor:
5347 IsConstructor = true;
5348 IsMove = true;
5349 break;
5350 case Sema::CXXCopyAssignment:
5351 IsAssignment = true;
5352 break;
5353 case Sema::CXXMoveAssignment:
5354 IsAssignment = true;
5355 IsMove = true;
5356 break;
5357 case Sema::CXXDestructor:
5358 break;
5359 case Sema::CXXInvalid:
5360 llvm_unreachable("invalid special member kind");
5361 }
5362
5363 if (MD->getNumParams()) {
Richard Smith41c35d62013-11-27 03:39:20 +00005364 if (const ReferenceType *RT =
5365 MD->getParamDecl(0)->getType()->getAs<ReferenceType>())
5366 ConstArg = RT->getPointeeType().isConstQualified();
Richard Smithd951a1d2012-02-18 02:02:13 +00005367 }
5368 }
5369
5370 bool inUnion() const { return MD->getParent()->isUnion(); }
5371
5372 /// Look up the corresponding special member in the given class.
Richard Smithaf136f82012-07-18 03:51:16 +00005373 Sema::SpecialMemberOverloadResult *lookupIn(CXXRecordDecl *Class,
Richard Smith41c35d62013-11-27 03:39:20 +00005374 unsigned Quals, bool IsMutable) {
5375 return lookupCallFromSpecialMember(S, Class, CSM, Quals,
5376 ConstArg && !IsMutable);
Richard Smithd951a1d2012-02-18 02:02:13 +00005377 }
5378
Richard Smith852265f2012-03-30 20:53:28 +00005379 typedef llvm::PointerUnion<CXXBaseSpecifier*, FieldDecl*> Subobject;
Richard Smith921bd202012-02-26 09:11:52 +00005380
Richard Smith852265f2012-03-30 20:53:28 +00005381 bool shouldDeleteForBase(CXXBaseSpecifier *Base);
Richard Smithd951a1d2012-02-18 02:02:13 +00005382 bool shouldDeleteForField(FieldDecl *FD);
5383 bool shouldDeleteForAllConstMembers();
Richard Smith852265f2012-03-30 20:53:28 +00005384
Richard Smithaf136f82012-07-18 03:51:16 +00005385 bool shouldDeleteForClassSubobject(CXXRecordDecl *Class, Subobject Subobj,
5386 unsigned Quals);
Richard Smith852265f2012-03-30 20:53:28 +00005387 bool shouldDeleteForSubobjectCall(Subobject Subobj,
5388 Sema::SpecialMemberOverloadResult *SMOR,
5389 bool IsDtorCallInCtor);
John McCalld4274212012-04-09 20:53:23 +00005390
5391 bool isAccessible(Subobject Subobj, CXXMethodDecl *D);
Richard Smithd951a1d2012-02-18 02:02:13 +00005392};
5393}
5394
John McCalld4274212012-04-09 20:53:23 +00005395/// Is the given special member inaccessible when used on the given
5396/// sub-object.
5397bool SpecialMemberDeletionInfo::isAccessible(Subobject Subobj,
5398 CXXMethodDecl *target) {
5399 /// If we're operating on a base class, the object type is the
5400 /// type of this special member.
5401 QualType objectTy;
Dmitri Gribenko76bb5cabfa2012-09-10 21:20:09 +00005402 AccessSpecifier access = target->getAccess();
John McCalld4274212012-04-09 20:53:23 +00005403 if (CXXBaseSpecifier *base = Subobj.dyn_cast<CXXBaseSpecifier*>()) {
5404 objectTy = S.Context.getTypeDeclType(MD->getParent());
5405 access = CXXRecordDecl::MergeAccess(base->getAccessSpecifier(), access);
5406
5407 // If we're operating on a field, the object type is the type of the field.
5408 } else {
5409 objectTy = S.Context.getTypeDeclType(target->getParent());
5410 }
5411
5412 return S.isSpecialMemberAccessibleForDeletion(target, access, objectTy);
5413}
5414
Richard Smith852265f2012-03-30 20:53:28 +00005415/// Check whether we should delete a special member due to the implicit
5416/// definition containing a call to a special member of a subobject.
5417bool SpecialMemberDeletionInfo::shouldDeleteForSubobjectCall(
5418 Subobject Subobj, Sema::SpecialMemberOverloadResult *SMOR,
5419 bool IsDtorCallInCtor) {
5420 CXXMethodDecl *Decl = SMOR->getMethod();
5421 FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>();
5422
5423 int DiagKind = -1;
5424
5425 if (SMOR->getKind() == Sema::SpecialMemberOverloadResult::NoMemberOrDeleted)
5426 DiagKind = !Decl ? 0 : 1;
5427 else if (SMOR->getKind() == Sema::SpecialMemberOverloadResult::Ambiguous)
5428 DiagKind = 2;
John McCalld4274212012-04-09 20:53:23 +00005429 else if (!isAccessible(Subobj, Decl))
Richard Smith852265f2012-03-30 20:53:28 +00005430 DiagKind = 3;
5431 else if (!IsDtorCallInCtor && Field && Field->getParent()->isUnion() &&
5432 !Decl->isTrivial()) {
5433 // A member of a union must have a trivial corresponding special member.
5434 // As a weird special case, a destructor call from a union's constructor
5435 // must be accessible and non-deleted, but need not be trivial. Such a
5436 // destructor is never actually called, but is semantically checked as
5437 // if it were.
5438 DiagKind = 4;
5439 }
5440
5441 if (DiagKind == -1)
5442 return false;
5443
5444 if (Diagnose) {
5445 if (Field) {
5446 S.Diag(Field->getLocation(),
5447 diag::note_deleted_special_member_class_subobject)
5448 << CSM << MD->getParent() << /*IsField*/true
5449 << Field << DiagKind << IsDtorCallInCtor;
5450 } else {
5451 CXXBaseSpecifier *Base = Subobj.get<CXXBaseSpecifier*>();
5452 S.Diag(Base->getLocStart(),
5453 diag::note_deleted_special_member_class_subobject)
5454 << CSM << MD->getParent() << /*IsField*/false
5455 << Base->getType() << DiagKind << IsDtorCallInCtor;
5456 }
5457
5458 if (DiagKind == 1)
5459 S.NoteDeletedFunction(Decl);
5460 // FIXME: Explain inaccessibility if DiagKind == 3.
5461 }
5462
5463 return true;
5464}
5465
Richard Smith921bd202012-02-26 09:11:52 +00005466/// Check whether we should delete a special member function due to having a
Richard Smithaf136f82012-07-18 03:51:16 +00005467/// direct or virtual base class or non-static data member of class type M.
Richard Smith921bd202012-02-26 09:11:52 +00005468bool SpecialMemberDeletionInfo::shouldDeleteForClassSubobject(
Richard Smithaf136f82012-07-18 03:51:16 +00005469 CXXRecordDecl *Class, Subobject Subobj, unsigned Quals) {
Richard Smith852265f2012-03-30 20:53:28 +00005470 FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>();
Richard Smith41c35d62013-11-27 03:39:20 +00005471 bool IsMutable = Field && Field->isMutable();
Richard Smithd951a1d2012-02-18 02:02:13 +00005472
5473 // C++11 [class.ctor]p5:
Richard Smith5704fe82012-03-29 19:00:10 +00005474 // -- any direct or virtual base class, or non-static data member with no
5475 // brace-or-equal-initializer, has class type M (or array thereof) and
Richard Smithd951a1d2012-02-18 02:02:13 +00005476 // either M has no default constructor or overload resolution as applied
5477 // to M's default constructor results in an ambiguity or in a function
5478 // that is deleted or inaccessible
5479 // C++11 [class.copy]p11, C++11 [class.copy]p23:
5480 // -- a direct or virtual base class B that cannot be copied/moved because
5481 // overload resolution, as applied to B's corresponding special member,
5482 // results in an ambiguity or a function that is deleted or inaccessible
5483 // from the defaulted special member
Richard Smith852265f2012-03-30 20:53:28 +00005484 // C++11 [class.dtor]p5:
5485 // -- any direct or virtual base class [...] has a type with a destructor
5486 // that is deleted or inaccessible
5487 if (!(CSM == Sema::CXXDefaultConstructor &&
Richard Smithcf8ec8d2012-04-02 18:40:40 +00005488 Field && Field->hasInClassInitializer()) &&
Richard Smith41c35d62013-11-27 03:39:20 +00005489 shouldDeleteForSubobjectCall(Subobj, lookupIn(Class, Quals, IsMutable),
5490 false))
Richard Smithcf8ec8d2012-04-02 18:40:40 +00005491 return true;
Richard Smithd951a1d2012-02-18 02:02:13 +00005492
Richard Smith852265f2012-03-30 20:53:28 +00005493 // C++11 [class.ctor]p5, C++11 [class.copy]p11:
5494 // -- any direct or virtual base class or non-static data member has a
5495 // type with a destructor that is deleted or inaccessible
5496 if (IsConstructor) {
5497 Sema::SpecialMemberOverloadResult *SMOR =
5498 S.LookupSpecialMember(Class, Sema::CXXDestructor,
5499 false, false, false, false, false);
5500 if (shouldDeleteForSubobjectCall(Subobj, SMOR, true))
5501 return true;
5502 }
5503
Richard Smith921bd202012-02-26 09:11:52 +00005504 return false;
5505}
5506
5507/// Check whether we should delete a special member function due to the class
5508/// having a particular direct or virtual base class.
Richard Smith852265f2012-03-30 20:53:28 +00005509bool SpecialMemberDeletionInfo::shouldDeleteForBase(CXXBaseSpecifier *Base) {
Richard Smithcf8ec8d2012-04-02 18:40:40 +00005510 CXXRecordDecl *BaseClass = Base->getType()->getAsCXXRecordDecl();
Richard Smithaf136f82012-07-18 03:51:16 +00005511 return shouldDeleteForClassSubobject(BaseClass, Base, 0);
Richard Smithd951a1d2012-02-18 02:02:13 +00005512}
5513
5514/// Check whether we should delete a special member function due to the class
5515/// having a particular non-static data member.
5516bool SpecialMemberDeletionInfo::shouldDeleteForField(FieldDecl *FD) {
5517 QualType FieldType = S.Context.getBaseElementType(FD->getType());
5518 CXXRecordDecl *FieldRecord = FieldType->getAsCXXRecordDecl();
5519
5520 if (CSM == Sema::CXXDefaultConstructor) {
5521 // For a default constructor, all references must be initialized in-class
5522 // and, if a union, it must have a non-const member.
Richard Smith852265f2012-03-30 20:53:28 +00005523 if (FieldType->isReferenceType() && !FD->hasInClassInitializer()) {
5524 if (Diagnose)
5525 S.Diag(FD->getLocation(), diag::note_deleted_default_ctor_uninit_field)
5526 << MD->getParent() << FD << FieldType << /*Reference*/0;
Richard Smithd951a1d2012-02-18 02:02:13 +00005527 return true;
Richard Smith852265f2012-03-30 20:53:28 +00005528 }
Richard Smith619ecdc2012-02-27 06:07:25 +00005529 // C++11 [class.ctor]p5: any non-variant non-static data member of
5530 // const-qualified type (or array thereof) with no
5531 // brace-or-equal-initializer does not have a user-provided default
5532 // constructor.
5533 if (!inUnion() && FieldType.isConstQualified() &&
5534 !FD->hasInClassInitializer() &&
Richard Smith852265f2012-03-30 20:53:28 +00005535 (!FieldRecord || !FieldRecord->hasUserProvidedDefaultConstructor())) {
5536 if (Diagnose)
5537 S.Diag(FD->getLocation(), diag::note_deleted_default_ctor_uninit_field)
Richard Smithc5f98f32012-04-29 06:32:34 +00005538 << MD->getParent() << FD << FD->getType() << /*Const*/1;
Richard Smith619ecdc2012-02-27 06:07:25 +00005539 return true;
Richard Smith852265f2012-03-30 20:53:28 +00005540 }
5541
5542 if (inUnion() && !FieldType.isConstQualified())
5543 AllFieldsAreConst = false;
Richard Smithd951a1d2012-02-18 02:02:13 +00005544 } else if (CSM == Sema::CXXCopyConstructor) {
5545 // For a copy constructor, data members must not be of rvalue reference
5546 // type.
Richard Smith852265f2012-03-30 20:53:28 +00005547 if (FieldType->isRValueReferenceType()) {
5548 if (Diagnose)
5549 S.Diag(FD->getLocation(), diag::note_deleted_copy_ctor_rvalue_reference)
5550 << MD->getParent() << FD << FieldType;
Richard Smithd951a1d2012-02-18 02:02:13 +00005551 return true;
Richard Smith852265f2012-03-30 20:53:28 +00005552 }
Richard Smithd951a1d2012-02-18 02:02:13 +00005553 } else if (IsAssignment) {
5554 // For an assignment operator, data members must not be of reference type.
Richard Smith852265f2012-03-30 20:53:28 +00005555 if (FieldType->isReferenceType()) {
5556 if (Diagnose)
5557 S.Diag(FD->getLocation(), diag::note_deleted_assign_field)
5558 << IsMove << MD->getParent() << FD << FieldType << /*Reference*/0;
Richard Smithd951a1d2012-02-18 02:02:13 +00005559 return true;
Richard Smith852265f2012-03-30 20:53:28 +00005560 }
5561 if (!FieldRecord && FieldType.isConstQualified()) {
5562 // C++11 [class.copy]p23:
5563 // -- a non-static data member of const non-class type (or array thereof)
5564 if (Diagnose)
5565 S.Diag(FD->getLocation(), diag::note_deleted_assign_field)
Richard Smithc5f98f32012-04-29 06:32:34 +00005566 << IsMove << MD->getParent() << FD << FD->getType() << /*Const*/1;
Richard Smith852265f2012-03-30 20:53:28 +00005567 return true;
5568 }
Richard Smithd951a1d2012-02-18 02:02:13 +00005569 }
5570
5571 if (FieldRecord) {
Richard Smithd951a1d2012-02-18 02:02:13 +00005572 // Some additional restrictions exist on the variant members.
5573 if (!inUnion() && FieldRecord->isUnion() &&
5574 FieldRecord->isAnonymousStructOrUnion()) {
5575 bool AllVariantFieldsAreConst = true;
5576
Richard Smith5704fe82012-03-29 19:00:10 +00005577 // FIXME: Handle anonymous unions declared within anonymous unions.
Aaron Ballmane8a8bae2014-03-08 20:12:42 +00005578 for (auto *UI : FieldRecord->fields()) {
Richard Smithd951a1d2012-02-18 02:02:13 +00005579 QualType UnionFieldType = S.Context.getBaseElementType(UI->getType());
Richard Smithd951a1d2012-02-18 02:02:13 +00005580
5581 if (!UnionFieldType.isConstQualified())
5582 AllVariantFieldsAreConst = false;
5583
Richard Smith921bd202012-02-26 09:11:52 +00005584 CXXRecordDecl *UnionFieldRecord = UnionFieldType->getAsCXXRecordDecl();
5585 if (UnionFieldRecord &&
Aaron Ballmane8a8bae2014-03-08 20:12:42 +00005586 shouldDeleteForClassSubobject(UnionFieldRecord, UI,
Richard Smithaf136f82012-07-18 03:51:16 +00005587 UnionFieldType.getCVRQualifiers()))
Richard Smith921bd202012-02-26 09:11:52 +00005588 return true;
Richard Smithd951a1d2012-02-18 02:02:13 +00005589 }
5590
5591 // At least one member in each anonymous union must be non-const
Douglas Gregor232ee492012-02-24 21:25:53 +00005592 if (CSM == Sema::CXXDefaultConstructor && AllVariantFieldsAreConst &&
Aaron Ballmane8a8bae2014-03-08 20:12:42 +00005593 !FieldRecord->field_empty()) {
Richard Smith852265f2012-03-30 20:53:28 +00005594 if (Diagnose)
5595 S.Diag(FieldRecord->getLocation(),
5596 diag::note_deleted_default_ctor_all_const)
5597 << MD->getParent() << /*anonymous union*/1;
Richard Smithd951a1d2012-02-18 02:02:13 +00005598 return true;
Richard Smith852265f2012-03-30 20:53:28 +00005599 }
Richard Smithd951a1d2012-02-18 02:02:13 +00005600
Richard Smith5704fe82012-03-29 19:00:10 +00005601 // Don't check the implicit member of the anonymous union type.
Richard Smithd951a1d2012-02-18 02:02:13 +00005602 // This is technically non-conformant, but sanity demands it.
5603 return false;
5604 }
5605
Richard Smithaf136f82012-07-18 03:51:16 +00005606 if (shouldDeleteForClassSubobject(FieldRecord, FD,
5607 FieldType.getCVRQualifiers()))
Richard Smith5704fe82012-03-29 19:00:10 +00005608 return true;
Richard Smithd951a1d2012-02-18 02:02:13 +00005609 }
5610
5611 return false;
5612}
5613
5614/// C++11 [class.ctor] p5:
5615/// A defaulted default constructor for a class X is defined as deleted if
5616/// X is a union and all of its variant members are of const-qualified type.
5617bool SpecialMemberDeletionInfo::shouldDeleteForAllConstMembers() {
Douglas Gregor232ee492012-02-24 21:25:53 +00005618 // This is a silly definition, because it gives an empty union a deleted
5619 // default constructor. Don't do that.
Richard Smith852265f2012-03-30 20:53:28 +00005620 if (CSM == Sema::CXXDefaultConstructor && inUnion() && AllFieldsAreConst &&
Aaron Ballmane8a8bae2014-03-08 20:12:42 +00005621 !MD->getParent()->field_empty()) {
Richard Smith852265f2012-03-30 20:53:28 +00005622 if (Diagnose)
5623 S.Diag(MD->getParent()->getLocation(),
5624 diag::note_deleted_default_ctor_all_const)
5625 << MD->getParent() << /*not anonymous union*/0;
5626 return true;
5627 }
5628 return false;
Richard Smithd951a1d2012-02-18 02:02:13 +00005629}
5630
5631/// Determine whether a defaulted special member function should be defined as
5632/// deleted, as specified in C++11 [class.ctor]p5, C++11 [class.copy]p11,
5633/// C++11 [class.copy]p23, and C++11 [class.dtor]p5.
Richard Smith852265f2012-03-30 20:53:28 +00005634bool Sema::ShouldDeleteSpecialMember(CXXMethodDecl *MD, CXXSpecialMember CSM,
5635 bool Diagnose) {
Richard Smithf716bb82012-08-06 02:25:10 +00005636 if (MD->isInvalidDecl())
5637 return false;
Alexis Huntd6da8762011-10-10 06:18:57 +00005638 CXXRecordDecl *RD = MD->getParent();
Alexis Huntea6f0322011-05-11 22:34:38 +00005639 assert(!RD->isDependentType() && "do deletion after instantiation");
Richard Smith2bf7fdb2013-01-02 11:42:31 +00005640 if (!LangOpts.CPlusPlus11 || RD->isInvalidDecl())
Alexis Huntea6f0322011-05-11 22:34:38 +00005641 return false;
5642
Richard Smithd951a1d2012-02-18 02:02:13 +00005643 // C++11 [expr.lambda.prim]p19:
5644 // The closure type associated with a lambda-expression has a
5645 // deleted (8.4.3) default constructor and a deleted copy
5646 // assignment operator.
5647 if (RD->isLambda() &&
Richard Smith852265f2012-03-30 20:53:28 +00005648 (CSM == CXXDefaultConstructor || CSM == CXXCopyAssignment)) {
5649 if (Diagnose)
5650 Diag(RD->getLocation(), diag::note_lambda_decl);
Richard Smithd951a1d2012-02-18 02:02:13 +00005651 return true;
Richard Smith852265f2012-03-30 20:53:28 +00005652 }
5653
Richard Smith6f1e2c62012-04-02 20:59:25 +00005654 // For an anonymous struct or union, the copy and assignment special members
5655 // will never be used, so skip the check. For an anonymous union declared at
5656 // namespace scope, the constructor and destructor are used.
5657 if (CSM != CXXDefaultConstructor && CSM != CXXDestructor &&
5658 RD->isAnonymousStructOrUnion())
5659 return false;
5660
Richard Smith852265f2012-03-30 20:53:28 +00005661 // C++11 [class.copy]p7, p18:
5662 // If the class definition declares a move constructor or move assignment
5663 // operator, an implicitly declared copy constructor or copy assignment
5664 // operator is defined as deleted.
5665 if (MD->isImplicit() &&
5666 (CSM == CXXCopyConstructor || CSM == CXXCopyAssignment)) {
Craig Topperc3ec1492014-05-26 06:22:03 +00005667 CXXMethodDecl *UserDeclaredMove = nullptr;
Richard Smith852265f2012-03-30 20:53:28 +00005668
5669 // In Microsoft mode, a user-declared move only causes the deletion of the
5670 // corresponding copy operation, not both copy operations.
5671 if (RD->hasUserDeclaredMoveConstructor() &&
Alp Tokerbfa39342014-01-14 12:51:41 +00005672 (!getLangOpts().MSVCCompat || CSM == CXXCopyConstructor)) {
Richard Smith852265f2012-03-30 20:53:28 +00005673 if (!Diagnose) return true;
Richard Smith1a2532b2012-12-08 04:10:18 +00005674
5675 // Find any user-declared move constructor.
Aaron Ballman2a4bd6d2014-03-13 16:51:27 +00005676 for (auto *I : RD->ctors()) {
Richard Smith1a2532b2012-12-08 04:10:18 +00005677 if (I->isMoveConstructor()) {
Aaron Ballman2a4bd6d2014-03-13 16:51:27 +00005678 UserDeclaredMove = I;
Richard Smith1a2532b2012-12-08 04:10:18 +00005679 break;
5680 }
5681 }
Richard Smithcf8ec8d2012-04-02 18:40:40 +00005682 assert(UserDeclaredMove);
Richard Smith852265f2012-03-30 20:53:28 +00005683 } else if (RD->hasUserDeclaredMoveAssignment() &&
Alp Tokerbfa39342014-01-14 12:51:41 +00005684 (!getLangOpts().MSVCCompat || CSM == CXXCopyAssignment)) {
Richard Smith852265f2012-03-30 20:53:28 +00005685 if (!Diagnose) return true;
Richard Smith1a2532b2012-12-08 04:10:18 +00005686
5687 // Find any user-declared move assignment operator.
Aaron Ballman2b124d12014-03-13 16:36:16 +00005688 for (auto *I : RD->methods()) {
Richard Smith1a2532b2012-12-08 04:10:18 +00005689 if (I->isMoveAssignmentOperator()) {
Aaron Ballman2b124d12014-03-13 16:36:16 +00005690 UserDeclaredMove = I;
Richard Smith1a2532b2012-12-08 04:10:18 +00005691 break;
5692 }
5693 }
Richard Smithcf8ec8d2012-04-02 18:40:40 +00005694 assert(UserDeclaredMove);
Richard Smith852265f2012-03-30 20:53:28 +00005695 }
5696
5697 if (UserDeclaredMove) {
5698 Diag(UserDeclaredMove->getLocation(),
5699 diag::note_deleted_copy_user_declared_move)
Richard Smithf989e512012-04-02 21:07:48 +00005700 << (CSM == CXXCopyAssignment) << RD
Richard Smith852265f2012-03-30 20:53:28 +00005701 << UserDeclaredMove->isMoveAssignmentOperator();
5702 return true;
5703 }
5704 }
Alexis Huntd6da8762011-10-10 06:18:57 +00005705
Richard Smith6f1e2c62012-04-02 20:59:25 +00005706 // Do access control from the special member function
5707 ContextRAII MethodContext(*this, MD);
5708
Richard Smith921bd202012-02-26 09:11:52 +00005709 // C++11 [class.dtor]p5:
5710 // -- for a virtual destructor, lookup of the non-array deallocation function
5711 // results in an ambiguity or in a function that is deleted or inaccessible
Richard Smith852265f2012-03-30 20:53:28 +00005712 if (CSM == CXXDestructor && MD->isVirtual()) {
Craig Topperc3ec1492014-05-26 06:22:03 +00005713 FunctionDecl *OperatorDelete = nullptr;
Richard Smith921bd202012-02-26 09:11:52 +00005714 DeclarationName Name =
5715 Context.DeclarationNames.getCXXOperatorName(OO_Delete);
5716 if (FindDeallocationFunction(MD->getLocation(), MD->getParent(), Name,
Richard Smith852265f2012-03-30 20:53:28 +00005717 OperatorDelete, false)) {
5718 if (Diagnose)
5719 Diag(RD->getLocation(), diag::note_deleted_dtor_no_operator_delete);
Richard Smith921bd202012-02-26 09:11:52 +00005720 return true;
Richard Smith852265f2012-03-30 20:53:28 +00005721 }
Richard Smith921bd202012-02-26 09:11:52 +00005722 }
5723
Richard Smith852265f2012-03-30 20:53:28 +00005724 SpecialMemberDeletionInfo SMI(*this, MD, CSM, Diagnose);
Alexis Huntea6f0322011-05-11 22:34:38 +00005725
Aaron Ballman574705e2014-03-13 15:41:46 +00005726 for (auto &BI : RD->bases())
5727 if (!BI.isVirtual() &&
5728 SMI.shouldDeleteForBase(&BI))
Richard Smithd951a1d2012-02-18 02:02:13 +00005729 return true;
Alexis Huntea6f0322011-05-11 22:34:38 +00005730
Richard Smithd1627032013-07-22 18:06:23 +00005731 // Per DR1611, do not consider virtual bases of constructors of abstract
5732 // classes, since we are not going to construct them.
Richard Smithbc46e432013-07-22 02:56:56 +00005733 if (!RD->isAbstract() || !SMI.IsConstructor) {
Aaron Ballman445a9392014-03-13 16:15:17 +00005734 for (auto &BI : RD->vbases())
5735 if (SMI.shouldDeleteForBase(&BI))
Richard Smithbc46e432013-07-22 02:56:56 +00005736 return true;
5737 }
Alexis Huntea6f0322011-05-11 22:34:38 +00005738
Aaron Ballmane8a8bae2014-03-08 20:12:42 +00005739 for (auto *FI : RD->fields())
Richard Smithd951a1d2012-02-18 02:02:13 +00005740 if (!FI->isInvalidDecl() && !FI->isUnnamedBitfield() &&
Aaron Ballmane8a8bae2014-03-08 20:12:42 +00005741 SMI.shouldDeleteForField(FI))
Alexis Hunta671bca2011-05-20 21:43:47 +00005742 return true;
Alexis Huntea6f0322011-05-11 22:34:38 +00005743
Richard Smithd951a1d2012-02-18 02:02:13 +00005744 if (SMI.shouldDeleteForAllConstMembers())
Alexis Huntea6f0322011-05-11 22:34:38 +00005745 return true;
5746
Eli Bendersky9a220fc2014-09-29 20:38:29 +00005747 if (getLangOpts().CUDA) {
5748 // We should delete the special member in CUDA mode if target inference
5749 // failed.
5750 return inferCUDATargetForImplicitSpecialMember(RD, CSM, MD, SMI.ConstArg,
5751 Diagnose);
5752 }
5753
Alexis Huntea6f0322011-05-11 22:34:38 +00005754 return false;
Argyrios Kyrtzidis7272d9c2011-02-03 18:01:15 +00005755}
5756
Richard Smith92f241f2012-12-08 02:53:02 +00005757/// Perform lookup for a special member of the specified kind, and determine
5758/// whether it is trivial. If the triviality can be determined without the
5759/// lookup, skip it. This is intended for use when determining whether a
5760/// special member of a containing object is trivial, and thus does not ever
5761/// perform overload resolution for default constructors.
5762///
5763/// If \p Selected is not \c NULL, \c *Selected will be filled in with the
5764/// member that was most likely to be intended to be trivial, if any.
5765static bool findTrivialSpecialMember(Sema &S, CXXRecordDecl *RD,
5766 Sema::CXXSpecialMember CSM, unsigned Quals,
Richard Smith41c35d62013-11-27 03:39:20 +00005767 bool ConstRHS, CXXMethodDecl **Selected) {
Richard Smith92f241f2012-12-08 02:53:02 +00005768 if (Selected)
Craig Topperc3ec1492014-05-26 06:22:03 +00005769 *Selected = nullptr;
Richard Smith92f241f2012-12-08 02:53:02 +00005770
5771 switch (CSM) {
5772 case Sema::CXXInvalid:
5773 llvm_unreachable("not a special member");
5774
5775 case Sema::CXXDefaultConstructor:
5776 // C++11 [class.ctor]p5:
5777 // A default constructor is trivial if:
5778 // - all the [direct subobjects] have trivial default constructors
5779 //
5780 // Note, no overload resolution is performed in this case.
5781 if (RD->hasTrivialDefaultConstructor())
5782 return true;
5783
5784 if (Selected) {
5785 // If there's a default constructor which could have been trivial, dig it
5786 // out. Otherwise, if there's any user-provided default constructor, point
5787 // to that as an example of why there's not a trivial one.
Craig Topperc3ec1492014-05-26 06:22:03 +00005788 CXXConstructorDecl *DefCtor = nullptr;
Richard Smith92f241f2012-12-08 02:53:02 +00005789 if (RD->needsImplicitDefaultConstructor())
5790 S.DeclareImplicitDefaultConstructor(RD);
Aaron Ballman2a4bd6d2014-03-13 16:51:27 +00005791 for (auto *CI : RD->ctors()) {
Richard Smith92f241f2012-12-08 02:53:02 +00005792 if (!CI->isDefaultConstructor())
5793 continue;
Aaron Ballman2a4bd6d2014-03-13 16:51:27 +00005794 DefCtor = CI;
Richard Smith92f241f2012-12-08 02:53:02 +00005795 if (!DefCtor->isUserProvided())
5796 break;
5797 }
5798
5799 *Selected = DefCtor;
5800 }
5801
5802 return false;
5803
5804 case Sema::CXXDestructor:
5805 // C++11 [class.dtor]p5:
5806 // A destructor is trivial if:
5807 // - all the direct [subobjects] have trivial destructors
5808 if (RD->hasTrivialDestructor())
5809 return true;
5810
5811 if (Selected) {
5812 if (RD->needsImplicitDestructor())
5813 S.DeclareImplicitDestructor(RD);
5814 *Selected = RD->getDestructor();
5815 }
5816
5817 return false;
5818
5819 case Sema::CXXCopyConstructor:
5820 // C++11 [class.copy]p12:
5821 // A copy constructor is trivial if:
5822 // - the constructor selected to copy each direct [subobject] is trivial
5823 if (RD->hasTrivialCopyConstructor()) {
5824 if (Quals == Qualifiers::Const)
5825 // We must either select the trivial copy constructor or reach an
5826 // ambiguity; no need to actually perform overload resolution.
5827 return true;
5828 } else if (!Selected) {
5829 return false;
5830 }
5831 // In C++98, we are not supposed to perform overload resolution here, but we
5832 // treat that as a language defect, as suggested on cxx-abi-dev, to treat
5833 // cases like B as having a non-trivial copy constructor:
5834 // struct A { template<typename T> A(T&); };
5835 // struct B { mutable A a; };
5836 goto NeedOverloadResolution;
5837
5838 case Sema::CXXCopyAssignment:
5839 // C++11 [class.copy]p25:
5840 // A copy assignment operator is trivial if:
5841 // - the assignment operator selected to copy each direct [subobject] is
5842 // trivial
5843 if (RD->hasTrivialCopyAssignment()) {
5844 if (Quals == Qualifiers::Const)
5845 return true;
5846 } else if (!Selected) {
5847 return false;
5848 }
5849 // In C++98, we are not supposed to perform overload resolution here, but we
5850 // treat that as a language defect.
5851 goto NeedOverloadResolution;
5852
5853 case Sema::CXXMoveConstructor:
5854 case Sema::CXXMoveAssignment:
5855 NeedOverloadResolution:
5856 Sema::SpecialMemberOverloadResult *SMOR =
Richard Smith41c35d62013-11-27 03:39:20 +00005857 lookupCallFromSpecialMember(S, RD, CSM, Quals, ConstRHS);
Richard Smith92f241f2012-12-08 02:53:02 +00005858
5859 // The standard doesn't describe how to behave if the lookup is ambiguous.
5860 // We treat it as not making the member non-trivial, just like the standard
5861 // mandates for the default constructor. This should rarely matter, because
5862 // the member will also be deleted.
5863 if (SMOR->getKind() == Sema::SpecialMemberOverloadResult::Ambiguous)
5864 return true;
5865
5866 if (!SMOR->getMethod()) {
5867 assert(SMOR->getKind() ==
5868 Sema::SpecialMemberOverloadResult::NoMemberOrDeleted);
5869 return false;
5870 }
5871
5872 // We deliberately don't check if we found a deleted special member. We're
5873 // not supposed to!
5874 if (Selected)
5875 *Selected = SMOR->getMethod();
5876 return SMOR->getMethod()->isTrivial();
5877 }
5878
5879 llvm_unreachable("unknown special method kind");
5880}
5881
Benjamin Kramer3e350262013-02-15 12:30:38 +00005882static CXXConstructorDecl *findUserDeclaredCtor(CXXRecordDecl *RD) {
Aaron Ballman2a4bd6d2014-03-13 16:51:27 +00005883 for (auto *CI : RD->ctors())
Richard Smith92f241f2012-12-08 02:53:02 +00005884 if (!CI->isImplicit())
Aaron Ballman2a4bd6d2014-03-13 16:51:27 +00005885 return CI;
Richard Smith92f241f2012-12-08 02:53:02 +00005886
5887 // Look for constructor templates.
5888 typedef CXXRecordDecl::specific_decl_iterator<FunctionTemplateDecl> tmpl_iter;
5889 for (tmpl_iter TI(RD->decls_begin()), TE(RD->decls_end()); TI != TE; ++TI) {
5890 if (CXXConstructorDecl *CD =
5891 dyn_cast<CXXConstructorDecl>(TI->getTemplatedDecl()))
5892 return CD;
5893 }
5894
Craig Topperc3ec1492014-05-26 06:22:03 +00005895 return nullptr;
Richard Smith92f241f2012-12-08 02:53:02 +00005896}
5897
5898/// The kind of subobject we are checking for triviality. The values of this
5899/// enumeration are used in diagnostics.
5900enum TrivialSubobjectKind {
5901 /// The subobject is a base class.
5902 TSK_BaseClass,
5903 /// The subobject is a non-static data member.
5904 TSK_Field,
5905 /// The object is actually the complete object.
5906 TSK_CompleteObject
5907};
5908
5909/// Check whether the special member selected for a given type would be trivial.
5910static bool checkTrivialSubobjectCall(Sema &S, SourceLocation SubobjLoc,
Richard Smith41c35d62013-11-27 03:39:20 +00005911 QualType SubType, bool ConstRHS,
Richard Smith92f241f2012-12-08 02:53:02 +00005912 Sema::CXXSpecialMember CSM,
5913 TrivialSubobjectKind Kind,
5914 bool Diagnose) {
5915 CXXRecordDecl *SubRD = SubType->getAsCXXRecordDecl();
5916 if (!SubRD)
5917 return true;
5918
5919 CXXMethodDecl *Selected;
5920 if (findTrivialSpecialMember(S, SubRD, CSM, SubType.getCVRQualifiers(),
Craig Topperc3ec1492014-05-26 06:22:03 +00005921 ConstRHS, Diagnose ? &Selected : nullptr))
Richard Smith92f241f2012-12-08 02:53:02 +00005922 return true;
5923
5924 if (Diagnose) {
Richard Smith41c35d62013-11-27 03:39:20 +00005925 if (ConstRHS)
5926 SubType.addConst();
5927
Richard Smith92f241f2012-12-08 02:53:02 +00005928 if (!Selected && CSM == Sema::CXXDefaultConstructor) {
5929 S.Diag(SubobjLoc, diag::note_nontrivial_no_def_ctor)
5930 << Kind << SubType.getUnqualifiedType();
5931 if (CXXConstructorDecl *CD = findUserDeclaredCtor(SubRD))
5932 S.Diag(CD->getLocation(), diag::note_user_declared_ctor);
5933 } else if (!Selected)
5934 S.Diag(SubobjLoc, diag::note_nontrivial_no_copy)
5935 << Kind << SubType.getUnqualifiedType() << CSM << SubType;
5936 else if (Selected->isUserProvided()) {
5937 if (Kind == TSK_CompleteObject)
5938 S.Diag(Selected->getLocation(), diag::note_nontrivial_user_provided)
5939 << Kind << SubType.getUnqualifiedType() << CSM;
5940 else {
5941 S.Diag(SubobjLoc, diag::note_nontrivial_user_provided)
5942 << Kind << SubType.getUnqualifiedType() << CSM;
5943 S.Diag(Selected->getLocation(), diag::note_declared_at);
5944 }
5945 } else {
5946 if (Kind != TSK_CompleteObject)
5947 S.Diag(SubobjLoc, diag::note_nontrivial_subobject)
5948 << Kind << SubType.getUnqualifiedType() << CSM;
5949
5950 // Explain why the defaulted or deleted special member isn't trivial.
5951 S.SpecialMemberIsTrivial(Selected, CSM, Diagnose);
5952 }
5953 }
5954
5955 return false;
5956}
5957
5958/// Check whether the members of a class type allow a special member to be
5959/// trivial.
5960static bool checkTrivialClassMembers(Sema &S, CXXRecordDecl *RD,
5961 Sema::CXXSpecialMember CSM,
5962 bool ConstArg, bool Diagnose) {
Aaron Ballmane8a8bae2014-03-08 20:12:42 +00005963 for (const auto *FI : RD->fields()) {
Richard Smith92f241f2012-12-08 02:53:02 +00005964 if (FI->isInvalidDecl() || FI->isUnnamedBitfield())
5965 continue;
5966
5967 QualType FieldType = S.Context.getBaseElementType(FI->getType());
5968
5969 // Pretend anonymous struct or union members are members of this class.
5970 if (FI->isAnonymousStructOrUnion()) {
5971 if (!checkTrivialClassMembers(S, FieldType->getAsCXXRecordDecl(),
5972 CSM, ConstArg, Diagnose))
5973 return false;
5974 continue;
5975 }
5976
5977 // C++11 [class.ctor]p5:
5978 // A default constructor is trivial if [...]
5979 // -- no non-static data member of its class has a
5980 // brace-or-equal-initializer
5981 if (CSM == Sema::CXXDefaultConstructor && FI->hasInClassInitializer()) {
5982 if (Diagnose)
Aaron Ballmane8a8bae2014-03-08 20:12:42 +00005983 S.Diag(FI->getLocation(), diag::note_nontrivial_in_class_init) << FI;
Richard Smith92f241f2012-12-08 02:53:02 +00005984 return false;
5985 }
5986
5987 // Objective C ARC 4.3.5:
5988 // [...] nontrivally ownership-qualified types are [...] not trivially
5989 // default constructible, copy constructible, move constructible, copy
5990 // assignable, move assignable, or destructible [...]
5991 if (S.getLangOpts().ObjCAutoRefCount &&
5992 FieldType.hasNonTrivialObjCLifetime()) {
5993 if (Diagnose)
5994 S.Diag(FI->getLocation(), diag::note_nontrivial_objc_ownership)
5995 << RD << FieldType.getObjCLifetime();
5996 return false;
5997 }
5998
Richard Smith41c35d62013-11-27 03:39:20 +00005999 bool ConstRHS = ConstArg && !FI->isMutable();
6000 if (!checkTrivialSubobjectCall(S, FI->getLocation(), FieldType, ConstRHS,
6001 CSM, TSK_Field, Diagnose))
Richard Smith92f241f2012-12-08 02:53:02 +00006002 return false;
6003 }
6004
6005 return true;
6006}
6007
6008/// Diagnose why the specified class does not have a trivial special member of
6009/// the given kind.
6010void Sema::DiagnoseNontrivial(const CXXRecordDecl *RD, CXXSpecialMember CSM) {
6011 QualType Ty = Context.getRecordType(RD);
Richard Smith92f241f2012-12-08 02:53:02 +00006012
Richard Smith41c35d62013-11-27 03:39:20 +00006013 bool ConstArg = (CSM == CXXCopyConstructor || CSM == CXXCopyAssignment);
6014 checkTrivialSubobjectCall(*this, RD->getLocation(), Ty, ConstArg, CSM,
Richard Smith92f241f2012-12-08 02:53:02 +00006015 TSK_CompleteObject, /*Diagnose*/true);
6016}
6017
6018/// Determine whether a defaulted or deleted special member function is trivial,
6019/// as specified in C++11 [class.ctor]p5, C++11 [class.copy]p12,
6020/// C++11 [class.copy]p25, and C++11 [class.dtor]p5.
6021bool Sema::SpecialMemberIsTrivial(CXXMethodDecl *MD, CXXSpecialMember CSM,
6022 bool Diagnose) {
Richard Smith92f241f2012-12-08 02:53:02 +00006023 assert(!MD->isUserProvided() && CSM != CXXInvalid && "not special enough");
6024
6025 CXXRecordDecl *RD = MD->getParent();
6026
6027 bool ConstArg = false;
Richard Smith92f241f2012-12-08 02:53:02 +00006028
Richard Smith2002bfe2013-11-04 02:02:27 +00006029 // C++11 [class.copy]p12, p25: [DR1593]
6030 // A [special member] is trivial if [...] its parameter-type-list is
6031 // equivalent to the parameter-type-list of an implicit declaration [...]
Richard Smith92f241f2012-12-08 02:53:02 +00006032 switch (CSM) {
6033 case CXXDefaultConstructor:
6034 case CXXDestructor:
6035 // Trivial default constructors and destructors cannot have parameters.
6036 break;
6037
6038 case CXXCopyConstructor:
6039 case CXXCopyAssignment: {
6040 // Trivial copy operations always have const, non-volatile parameter types.
6041 ConstArg = true;
Jordan Rosed03d99d2013-03-05 01:27:54 +00006042 const ParmVarDecl *Param0 = MD->getParamDecl(0);
Richard Smith92f241f2012-12-08 02:53:02 +00006043 const ReferenceType *RT = Param0->getType()->getAs<ReferenceType>();
6044 if (!RT || RT->getPointeeType().getCVRQualifiers() != Qualifiers::Const) {
6045 if (Diagnose)
6046 Diag(Param0->getLocation(), diag::note_nontrivial_param_type)
6047 << Param0->getSourceRange() << Param0->getType()
6048 << Context.getLValueReferenceType(
6049 Context.getRecordType(RD).withConst());
6050 return false;
6051 }
6052 break;
6053 }
6054
6055 case CXXMoveConstructor:
6056 case CXXMoveAssignment: {
6057 // Trivial move operations always have non-cv-qualified parameters.
Jordan Rosed03d99d2013-03-05 01:27:54 +00006058 const ParmVarDecl *Param0 = MD->getParamDecl(0);
Richard Smith92f241f2012-12-08 02:53:02 +00006059 const RValueReferenceType *RT =
6060 Param0->getType()->getAs<RValueReferenceType>();
6061 if (!RT || RT->getPointeeType().getCVRQualifiers()) {
6062 if (Diagnose)
6063 Diag(Param0->getLocation(), diag::note_nontrivial_param_type)
6064 << Param0->getSourceRange() << Param0->getType()
6065 << Context.getRValueReferenceType(Context.getRecordType(RD));
6066 return false;
6067 }
6068 break;
6069 }
6070
6071 case CXXInvalid:
6072 llvm_unreachable("not a special member");
6073 }
6074
Richard Smith92f241f2012-12-08 02:53:02 +00006075 if (MD->getMinRequiredArguments() < MD->getNumParams()) {
6076 if (Diagnose)
6077 Diag(MD->getParamDecl(MD->getMinRequiredArguments())->getLocation(),
6078 diag::note_nontrivial_default_arg)
6079 << MD->getParamDecl(MD->getMinRequiredArguments())->getSourceRange();
6080 return false;
6081 }
6082 if (MD->isVariadic()) {
6083 if (Diagnose)
6084 Diag(MD->getLocation(), diag::note_nontrivial_variadic);
6085 return false;
6086 }
6087
6088 // C++11 [class.ctor]p5, C++11 [class.dtor]p5:
6089 // A copy/move [constructor or assignment operator] is trivial if
6090 // -- the [member] selected to copy/move each direct base class subobject
6091 // is trivial
6092 //
6093 // C++11 [class.copy]p12, C++11 [class.copy]p25:
6094 // A [default constructor or destructor] is trivial if
6095 // -- all the direct base classes have trivial [default constructors or
6096 // destructors]
Aaron Ballman574705e2014-03-13 15:41:46 +00006097 for (const auto &BI : RD->bases())
6098 if (!checkTrivialSubobjectCall(*this, BI.getLocStart(), BI.getType(),
Richard Smith41c35d62013-11-27 03:39:20 +00006099 ConstArg, CSM, TSK_BaseClass, Diagnose))
Richard Smith92f241f2012-12-08 02:53:02 +00006100 return false;
6101
6102 // C++11 [class.ctor]p5, C++11 [class.dtor]p5:
6103 // A copy/move [constructor or assignment operator] for a class X is
6104 // trivial if
6105 // -- for each non-static data member of X that is of class type (or array
6106 // thereof), the constructor selected to copy/move that member is
6107 // trivial
6108 //
6109 // C++11 [class.copy]p12, C++11 [class.copy]p25:
6110 // A [default constructor or destructor] is trivial if
6111 // -- for all of the non-static data members of its class that are of class
6112 // type (or array thereof), each such class has a trivial [default
6113 // constructor or destructor]
6114 if (!checkTrivialClassMembers(*this, RD, CSM, ConstArg, Diagnose))
6115 return false;
6116
6117 // C++11 [class.dtor]p5:
6118 // A destructor is trivial if [...]
6119 // -- the destructor is not virtual
6120 if (CSM == CXXDestructor && MD->isVirtual()) {
6121 if (Diagnose)
6122 Diag(MD->getLocation(), diag::note_nontrivial_virtual_dtor) << RD;
6123 return false;
6124 }
6125
6126 // C++11 [class.ctor]p5, C++11 [class.copy]p12, C++11 [class.copy]p25:
6127 // A [special member] for class X is trivial if [...]
6128 // -- class X has no virtual functions and no virtual base classes
6129 if (CSM != CXXDestructor && MD->getParent()->isDynamicClass()) {
6130 if (!Diagnose)
6131 return false;
6132
6133 if (RD->getNumVBases()) {
6134 // Check for virtual bases. We already know that the corresponding
6135 // member in all bases is trivial, so vbases must all be direct.
6136 CXXBaseSpecifier &BS = *RD->vbases_begin();
6137 assert(BS.isVirtual());
6138 Diag(BS.getLocStart(), diag::note_nontrivial_has_virtual) << RD << 1;
6139 return false;
6140 }
6141
6142 // Must have a virtual method.
Aaron Ballman2b124d12014-03-13 16:36:16 +00006143 for (const auto *MI : RD->methods()) {
Richard Smith92f241f2012-12-08 02:53:02 +00006144 if (MI->isVirtual()) {
6145 SourceLocation MLoc = MI->getLocStart();
6146 Diag(MLoc, diag::note_nontrivial_has_virtual) << RD << 0;
6147 return false;
6148 }
6149 }
6150
6151 llvm_unreachable("dynamic class with no vbases and no virtual functions");
6152 }
6153
6154 // Looks like it's trivial!
6155 return true;
6156}
6157
Argyrios Kyrtzidis7272d9c2011-02-03 18:01:15 +00006158/// \brief Data used with FindHiddenVirtualMethod
Benjamin Kramer024e6192011-03-04 13:12:48 +00006159namespace {
6160 struct FindHiddenVirtualMethodData {
6161 Sema *S;
6162 CXXMethodDecl *Method;
6163 llvm::SmallPtrSet<const CXXMethodDecl *, 8> OverridenAndUsingBaseMethods;
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006164 SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
Benjamin Kramer024e6192011-03-04 13:12:48 +00006165 };
6166}
Argyrios Kyrtzidis7272d9c2011-02-03 18:01:15 +00006167
David Blaikie282c92a2012-10-19 00:53:08 +00006168/// \brief Check whether any most overriden method from MD in Methods
6169static bool CheckMostOverridenMethods(const CXXMethodDecl *MD,
Craig Topper4dd9b432014-08-17 23:49:53 +00006170 const llvm::SmallPtrSetImpl<const CXXMethodDecl *>& Methods) {
David Blaikie282c92a2012-10-19 00:53:08 +00006171 if (MD->size_overridden_methods() == 0)
6172 return Methods.count(MD->getCanonicalDecl());
6173 for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(),
6174 E = MD->end_overridden_methods();
6175 I != E; ++I)
6176 if (CheckMostOverridenMethods(*I, Methods))
6177 return true;
6178 return false;
6179}
6180
Argyrios Kyrtzidis7272d9c2011-02-03 18:01:15 +00006181/// \brief Member lookup function that determines whether a given C++
6182/// method overloads virtual methods in a base class without overriding any,
6183/// to be used with CXXRecordDecl::lookupInBases().
6184static bool FindHiddenVirtualMethod(const CXXBaseSpecifier *Specifier,
6185 CXXBasePath &Path,
6186 void *UserData) {
6187 RecordDecl *BaseRecord = Specifier->getType()->getAs<RecordType>()->getDecl();
6188
6189 FindHiddenVirtualMethodData &Data
6190 = *static_cast<FindHiddenVirtualMethodData*>(UserData);
6191
6192 DeclarationName Name = Data.Method->getDeclName();
6193 assert(Name.getNameKind() == DeclarationName::Identifier);
6194
6195 bool foundSameNameMethod = false;
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006196 SmallVector<CXXMethodDecl *, 8> overloadedMethods;
Argyrios Kyrtzidis7272d9c2011-02-03 18:01:15 +00006197 for (Path.Decls = BaseRecord->lookup(Name);
David Blaikieff7d47a2012-12-19 00:45:41 +00006198 !Path.Decls.empty();
6199 Path.Decls = Path.Decls.slice(1)) {
6200 NamedDecl *D = Path.Decls.front();
Argyrios Kyrtzidis7272d9c2011-02-03 18:01:15 +00006201 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
Argyrios Kyrtzidis7dd856a2011-02-10 18:13:41 +00006202 MD = MD->getCanonicalDecl();
Argyrios Kyrtzidis7272d9c2011-02-03 18:01:15 +00006203 foundSameNameMethod = true;
6204 // Interested only in hidden virtual methods.
6205 if (!MD->isVirtual())
6206 continue;
6207 // If the method we are checking overrides a method from its base
Aaron Ballman04559a72014-07-30 23:50:53 +00006208 // don't warn about the other overloaded methods. Clang deviates from GCC
6209 // by only diagnosing overloads of inherited virtual functions that do not
6210 // override any other virtual functions in the base. GCC's
6211 // -Woverloaded-virtual diagnoses any derived function hiding a virtual
6212 // function from a base class. These cases may be better served by a
6213 // warning (not specific to virtual functions) on call sites when the call
6214 // would select a different function from the base class, were it visible.
6215 // See FIXME in test/SemaCXX/warn-overload-virtual.cpp for an example.
Argyrios Kyrtzidis7272d9c2011-02-03 18:01:15 +00006216 if (!Data.S->IsOverload(Data.Method, MD, false))
6217 return true;
6218 // Collect the overload only if its hidden.
David Blaikie282c92a2012-10-19 00:53:08 +00006219 if (!CheckMostOverridenMethods(MD, Data.OverridenAndUsingBaseMethods))
Argyrios Kyrtzidis7272d9c2011-02-03 18:01:15 +00006220 overloadedMethods.push_back(MD);
6221 }
6222 }
6223
6224 if (foundSameNameMethod)
6225 Data.OverloadedMethods.append(overloadedMethods.begin(),
6226 overloadedMethods.end());
6227 return foundSameNameMethod;
6228}
6229
David Blaikie282c92a2012-10-19 00:53:08 +00006230/// \brief Add the most overriden methods from MD to Methods
6231static void AddMostOverridenMethods(const CXXMethodDecl *MD,
Craig Topper4dd9b432014-08-17 23:49:53 +00006232 llvm::SmallPtrSetImpl<const CXXMethodDecl *>& Methods) {
David Blaikie282c92a2012-10-19 00:53:08 +00006233 if (MD->size_overridden_methods() == 0)
6234 Methods.insert(MD->getCanonicalDecl());
6235 for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(),
6236 E = MD->end_overridden_methods();
6237 I != E; ++I)
6238 AddMostOverridenMethods(*I, Methods);
6239}
6240
Eli Friedmanaf65120b2013-09-05 23:51:03 +00006241/// \brief Check if a method overloads virtual methods in a base class without
Argyrios Kyrtzidis7272d9c2011-02-03 18:01:15 +00006242/// overriding any.
Eli Friedmanaf65120b2013-09-05 23:51:03 +00006243void Sema::FindHiddenVirtualMethods(CXXMethodDecl *MD,
6244 SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods) {
Benjamin Kramer1458c1c2012-05-19 16:03:58 +00006245 if (!MD->getDeclName().isIdentifier())
Argyrios Kyrtzidis7272d9c2011-02-03 18:01:15 +00006246 return;
6247
6248 CXXBasePaths Paths(/*FindAmbiguities=*/true, // true to look in all bases.
6249 /*bool RecordPaths=*/false,
6250 /*bool DetectVirtual=*/false);
6251 FindHiddenVirtualMethodData Data;
6252 Data.Method = MD;
6253 Data.S = this;
6254
6255 // Keep the base methods that were overriden or introduced in the subclass
6256 // by 'using' in a set. A base method not in this set is hidden.
Eli Friedmanaf65120b2013-09-05 23:51:03 +00006257 CXXRecordDecl *DC = MD->getParent();
David Blaikieff7d47a2012-12-19 00:45:41 +00006258 DeclContext::lookup_result R = DC->lookup(MD->getDeclName());
6259 for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E; ++I) {
6260 NamedDecl *ND = *I;
6261 if (UsingShadowDecl *shad = dyn_cast<UsingShadowDecl>(*I))
David Blaikie282c92a2012-10-19 00:53:08 +00006262 ND = shad->getTargetDecl();
6263 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(ND))
6264 AddMostOverridenMethods(MD, Data.OverridenAndUsingBaseMethods);
Argyrios Kyrtzidis7272d9c2011-02-03 18:01:15 +00006265 }
6266
Eli Friedmanaf65120b2013-09-05 23:51:03 +00006267 if (DC->lookupInBases(&FindHiddenVirtualMethod, &Data, Paths))
6268 OverloadedMethods = Data.OverloadedMethods;
6269}
Argyrios Kyrtzidis7272d9c2011-02-03 18:01:15 +00006270
Eli Friedmanaf65120b2013-09-05 23:51:03 +00006271void Sema::NoteHiddenVirtualMethods(CXXMethodDecl *MD,
6272 SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods) {
6273 for (unsigned i = 0, e = OverloadedMethods.size(); i != e; ++i) {
6274 CXXMethodDecl *overloadedMD = OverloadedMethods[i];
6275 PartialDiagnostic PD = PDiag(
6276 diag::note_hidden_overloaded_virtual_declared_here) << overloadedMD;
6277 HandleFunctionTypeMismatch(PD, MD->getType(), overloadedMD->getType());
6278 Diag(overloadedMD->getLocation(), PD);
6279 }
6280}
6281
6282/// \brief Diagnose methods which overload virtual methods in a base class
6283/// without overriding any.
6284void Sema::DiagnoseHiddenVirtualMethods(CXXMethodDecl *MD) {
6285 if (MD->isInvalidDecl())
6286 return;
6287
Alp Tokerd4a3f0e2014-06-15 23:30:39 +00006288 if (Diags.isIgnored(diag::warn_overloaded_virtual, MD->getLocation()))
Eli Friedmanaf65120b2013-09-05 23:51:03 +00006289 return;
6290
6291 SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
6292 FindHiddenVirtualMethods(MD, OverloadedMethods);
6293 if (!OverloadedMethods.empty()) {
6294 Diag(MD->getLocation(), diag::warn_overloaded_virtual)
6295 << MD << (OverloadedMethods.size() > 1);
6296
6297 NoteHiddenVirtualMethods(MD, OverloadedMethods);
Argyrios Kyrtzidis7272d9c2011-02-03 18:01:15 +00006298 }
Douglas Gregorc99f1552009-12-03 18:33:45 +00006299}
6300
Argyrios Kyrtzidised983422008-07-01 10:37:29 +00006301void Sema::ActOnFinishCXXMemberSpecification(Scope* S, SourceLocation RLoc,
John McCall48871652010-08-21 09:40:31 +00006302 Decl *TagDecl,
Argyrios Kyrtzidised983422008-07-01 10:37:29 +00006303 SourceLocation LBrac,
Douglas Gregorc48a10d2010-03-29 14:42:08 +00006304 SourceLocation RBrac,
6305 AttributeList *AttrList) {
Douglas Gregor71a57182009-06-22 23:20:33 +00006306 if (!TagDecl)
6307 return;
Mike Stump11289f42009-09-09 15:08:12 +00006308
Douglas Gregorc9f9b862009-05-11 19:58:34 +00006309 AdjustDeclIfTemplate(TagDecl);
Douglas Gregorc99f1552009-12-03 18:33:45 +00006310
Rafael Espindola06e1b132012-07-12 04:32:30 +00006311 for (const AttributeList* l = AttrList; l; l = l->getNext()) {
6312 if (l->getKind() != AttributeList::AT_Visibility)
6313 continue;
6314 l->setInvalid();
6315 Diag(l->getLoc(), diag::warn_attribute_after_definition_ignored) <<
6316 l->getName();
6317 }
6318
David Blaikie751c5582011-09-22 02:58:26 +00006319 ActOnFields(S, RLoc, TagDecl, llvm::makeArrayRef(
John McCall48871652010-08-21 09:40:31 +00006320 // strict aliasing violation!
6321 reinterpret_cast<Decl**>(FieldCollector->getCurFields()),
David Blaikie751c5582011-09-22 02:58:26 +00006322 FieldCollector->getCurNumFields()), LBrac, RBrac, AttrList);
Douglas Gregor463421d2009-03-03 04:44:36 +00006323
Douglas Gregor0be31a22010-07-02 17:43:08 +00006324 CheckCompletedCXXClass(
John McCall48871652010-08-21 09:40:31 +00006325 dyn_cast_or_null<CXXRecordDecl>(TagDecl));
Argyrios Kyrtzidised983422008-07-01 10:37:29 +00006326}
6327
Douglas Gregor05379422008-11-03 17:51:48 +00006328/// AddImplicitlyDeclaredMembersToClass - Adds any implicitly-declared
6329/// special functions, such as the default constructor, copy
6330/// constructor, or destructor, to the given C++ class (C++
6331/// [special]p1). This routine can only be executed just before the
6332/// definition of the class is complete.
Douglas Gregor0be31a22010-07-02 17:43:08 +00006333void Sema::AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl) {
Douglas Gregor4e8b5fb2010-07-01 22:02:46 +00006334 if (!ClassDecl->hasUserDeclaredConstructor())
Douglas Gregor9672f922010-07-03 00:47:00 +00006335 ++ASTContext::NumImplicitDefaultConstructors;
Douglas Gregor05379422008-11-03 17:51:48 +00006336
Richard Smith6b02d462012-12-08 08:32:28 +00006337 if (!ClassDecl->hasUserDeclaredCopyConstructor()) {
Douglas Gregora6d69502010-07-02 23:41:54 +00006338 ++ASTContext::NumImplicitCopyConstructors;
Douglas Gregor05379422008-11-03 17:51:48 +00006339
Richard Smith6b02d462012-12-08 08:32:28 +00006340 // If the properties or semantics of the copy constructor couldn't be
6341 // determined while the class was being declared, force a declaration
6342 // of it now.
6343 if (ClassDecl->needsOverloadResolutionForCopyConstructor())
6344 DeclareImplicitCopyConstructor(ClassDecl);
6345 }
6346
Richard Smith2bf7fdb2013-01-02 11:42:31 +00006347 if (getLangOpts().CPlusPlus11 && ClassDecl->needsImplicitMoveConstructor()) {
Richard Smith966c1fb2011-12-24 21:56:24 +00006348 ++ASTContext::NumImplicitMoveConstructors;
6349
Richard Smith6b02d462012-12-08 08:32:28 +00006350 if (ClassDecl->needsOverloadResolutionForMoveConstructor())
6351 DeclareImplicitMoveConstructor(ClassDecl);
6352 }
6353
Douglas Gregor330b9cf2010-07-02 21:50:04 +00006354 if (!ClassDecl->hasUserDeclaredCopyAssignment()) {
6355 ++ASTContext::NumImplicitCopyAssignmentOperators;
Richard Smith6b02d462012-12-08 08:32:28 +00006356
6357 // If we have a dynamic class, then the copy assignment operator may be
Douglas Gregor330b9cf2010-07-02 21:50:04 +00006358 // virtual, so we have to declare it immediately. This ensures that, e.g.,
Richard Smith6b02d462012-12-08 08:32:28 +00006359 // it shows up in the right place in the vtable and that we diagnose
6360 // problems with the implicit exception specification.
6361 if (ClassDecl->isDynamicClass() ||
6362 ClassDecl->needsOverloadResolutionForCopyAssignment())
Douglas Gregor330b9cf2010-07-02 21:50:04 +00006363 DeclareImplicitCopyAssignment(ClassDecl);
6364 }
Sebastian Redlbaad4e72009-01-05 20:52:13 +00006365
Richard Smith2bf7fdb2013-01-02 11:42:31 +00006366 if (getLangOpts().CPlusPlus11 && ClassDecl->needsImplicitMoveAssignment()) {
Richard Smith966c1fb2011-12-24 21:56:24 +00006367 ++ASTContext::NumImplicitMoveAssignmentOperators;
6368
6369 // Likewise for the move assignment operator.
Richard Smith6b02d462012-12-08 08:32:28 +00006370 if (ClassDecl->isDynamicClass() ||
6371 ClassDecl->needsOverloadResolutionForMoveAssignment())
Richard Smith966c1fb2011-12-24 21:56:24 +00006372 DeclareImplicitMoveAssignment(ClassDecl);
6373 }
6374
Douglas Gregor7454c562010-07-02 20:37:36 +00006375 if (!ClassDecl->hasUserDeclaredDestructor()) {
6376 ++ASTContext::NumImplicitDestructors;
Richard Smith6b02d462012-12-08 08:32:28 +00006377
6378 // If we have a dynamic class, then the destructor may be virtual, so we
Douglas Gregor7454c562010-07-02 20:37:36 +00006379 // have to declare the destructor immediately. This ensures that, e.g., it
6380 // shows up in the right place in the vtable and that we diagnose problems
6381 // with the implicit exception specification.
Richard Smith6b02d462012-12-08 08:32:28 +00006382 if (ClassDecl->isDynamicClass() ||
6383 ClassDecl->needsOverloadResolutionForDestructor())
Douglas Gregor7454c562010-07-02 20:37:36 +00006384 DeclareImplicitDestructor(ClassDecl);
6385 }
Douglas Gregor05379422008-11-03 17:51:48 +00006386}
6387
Hans Wennborgb6d4e8c2014-05-02 02:01:07 +00006388unsigned Sema::ActOnReenterTemplateScope(Scope *S, Decl *D) {
Francois Pichet1c229c02011-04-22 22:18:13 +00006389 if (!D)
Hans Wennborgb6d4e8c2014-05-02 02:01:07 +00006390 return 0;
Francois Pichet1c229c02011-04-22 22:18:13 +00006391
Hans Wennborgb6d4e8c2014-05-02 02:01:07 +00006392 // The order of template parameters is not important here. All names
6393 // get added to the same scope.
6394 SmallVector<TemplateParameterList *, 4> ParameterLists;
6395
6396 if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D))
6397 D = TD->getTemplatedDecl();
6398
6399 if (auto *PSD = dyn_cast<ClassTemplatePartialSpecializationDecl>(D))
6400 ParameterLists.push_back(PSD->getTemplateParameters());
6401
6402 if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
6403 for (unsigned i = 0; i < DD->getNumTemplateParameterLists(); ++i)
6404 ParameterLists.push_back(DD->getTemplateParameterList(i));
6405
6406 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
6407 if (FunctionTemplateDecl *FTD = FD->getDescribedFunctionTemplate())
6408 ParameterLists.push_back(FTD->getTemplateParameters());
6409 }
6410 }
6411
6412 if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
6413 for (unsigned i = 0; i < TD->getNumTemplateParameterLists(); ++i)
6414 ParameterLists.push_back(TD->getTemplateParameterList(i));
6415
6416 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(TD)) {
6417 if (ClassTemplateDecl *CTD = RD->getDescribedClassTemplate())
6418 ParameterLists.push_back(CTD->getTemplateParameters());
6419 }
6420 }
6421
6422 unsigned Count = 0;
6423 for (TemplateParameterList *Params : ParameterLists) {
6424 if (Params->size() > 0)
6425 // Ignore explicit specializations; they don't contribute to the template
6426 // depth.
6427 ++Count;
6428 for (NamedDecl *Param : *Params) {
6429 if (Param->getDeclName()) {
6430 S->AddDecl(Param);
6431 IdResolver.AddDecl(Param);
Francois Pichet1c229c02011-04-22 22:18:13 +00006432 }
6433 }
6434 }
Francois Pichet1c229c02011-04-22 22:18:13 +00006435
Hans Wennborgb6d4e8c2014-05-02 02:01:07 +00006436 return Count;
Douglas Gregore44a2ad2009-05-27 23:11:45 +00006437}
6438
John McCall48871652010-08-21 09:40:31 +00006439void Sema::ActOnStartDelayedMemberDeclarations(Scope *S, Decl *RecordD) {
John McCall6df5fef2009-12-19 10:49:29 +00006440 if (!RecordD) return;
6441 AdjustDeclIfTemplate(RecordD);
John McCall48871652010-08-21 09:40:31 +00006442 CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordD);
John McCall6df5fef2009-12-19 10:49:29 +00006443 PushDeclContext(S, Record);
6444}
6445
John McCall48871652010-08-21 09:40:31 +00006446void Sema::ActOnFinishDelayedMemberDeclarations(Scope *S, Decl *RecordD) {
John McCall6df5fef2009-12-19 10:49:29 +00006447 if (!RecordD) return;
6448 PopDeclContext();
6449}
6450
Nick Lewycky35a6ef42014-01-11 02:50:57 +00006451/// This is used to implement the constant expression evaluation part of the
6452/// attribute enable_if extension. There is nothing in standard C++ which would
6453/// require reentering parameters.
6454void Sema::ActOnReenterCXXMethodParameter(Scope *S, ParmVarDecl *Param) {
6455 if (!Param)
6456 return;
6457
6458 S->AddDecl(Param);
6459 if (Param->getDeclName())
6460 IdResolver.AddDecl(Param);
6461}
6462
Douglas Gregor4d87df52008-12-16 21:30:33 +00006463/// ActOnStartDelayedCXXMethodDeclaration - We have completed
6464/// parsing a top-level (non-nested) C++ class, and we are now
6465/// parsing those parts of the given Method declaration that could
6466/// not be parsed earlier (C++ [class.mem]p2), such as default
6467/// arguments. This action should enter the scope of the given
6468/// Method declaration as if we had just parsed the qualified method
6469/// name. However, it should not bring the parameters into scope;
6470/// that will be performed by ActOnDelayedCXXMethodParameter.
John McCall48871652010-08-21 09:40:31 +00006471void Sema::ActOnStartDelayedCXXMethodDeclaration(Scope *S, Decl *MethodD) {
Douglas Gregor4d87df52008-12-16 21:30:33 +00006472}
6473
6474/// ActOnDelayedCXXMethodParameter - We've already started a delayed
6475/// C++ method declaration. We're (re-)introducing the given
6476/// function parameter into scope for use in parsing later parts of
6477/// the method declaration. For example, we could see an
6478/// ActOnParamDefaultArgument event for this parameter.
John McCall48871652010-08-21 09:40:31 +00006479void Sema::ActOnDelayedCXXMethodParameter(Scope *S, Decl *ParamD) {
Douglas Gregor71a57182009-06-22 23:20:33 +00006480 if (!ParamD)
6481 return;
Mike Stump11289f42009-09-09 15:08:12 +00006482
John McCall48871652010-08-21 09:40:31 +00006483 ParmVarDecl *Param = cast<ParmVarDecl>(ParamD);
Douglas Gregor58354032008-12-24 00:01:03 +00006484
6485 // If this parameter has an unparsed default argument, clear it out
6486 // to make way for the parsed default argument.
6487 if (Param->hasUnparsedDefaultArg())
Craig Topperc3ec1492014-05-26 06:22:03 +00006488 Param->setDefaultArg(nullptr);
Douglas Gregor58354032008-12-24 00:01:03 +00006489
John McCall48871652010-08-21 09:40:31 +00006490 S->AddDecl(Param);
Douglas Gregor4d87df52008-12-16 21:30:33 +00006491 if (Param->getDeclName())
6492 IdResolver.AddDecl(Param);
6493}
6494
6495/// ActOnFinishDelayedCXXMethodDeclaration - We have finished
6496/// processing the delayed method declaration for Method. The method
6497/// declaration is now considered finished. There may be a separate
6498/// ActOnStartOfFunctionDef action later (not necessarily
6499/// immediately!) for this method, if it was also defined inside the
6500/// class body.
John McCall48871652010-08-21 09:40:31 +00006501void Sema::ActOnFinishDelayedCXXMethodDeclaration(Scope *S, Decl *MethodD) {
Douglas Gregor71a57182009-06-22 23:20:33 +00006502 if (!MethodD)
6503 return;
Mike Stump11289f42009-09-09 15:08:12 +00006504
Douglas Gregorc8c277a2009-08-24 11:57:43 +00006505 AdjustDeclIfTemplate(MethodD);
Mike Stump11289f42009-09-09 15:08:12 +00006506
John McCall48871652010-08-21 09:40:31 +00006507 FunctionDecl *Method = cast<FunctionDecl>(MethodD);
Douglas Gregor4d87df52008-12-16 21:30:33 +00006508
6509 // Now that we have our default arguments, check the constructor
6510 // again. It could produce additional diagnostics or affect whether
6511 // the class has implicitly-declared destructors, among other
6512 // things.
Chris Lattnerb41df4f2009-04-25 08:35:12 +00006513 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Method))
6514 CheckConstructor(Constructor);
Douglas Gregor4d87df52008-12-16 21:30:33 +00006515
6516 // Check the default arguments, which we may have added.
6517 if (!Method->isInvalidDecl())
6518 CheckCXXDefaultArguments(Method);
6519}
6520
Douglas Gregor831c93f2008-11-05 20:51:48 +00006521/// CheckConstructorDeclarator - Called by ActOnDeclarator to check
Douglas Gregor4d87df52008-12-16 21:30:33 +00006522/// the well-formedness of the constructor declarator @p D with type @p
Douglas Gregor831c93f2008-11-05 20:51:48 +00006523/// R. If there are any errors in the declarator, this routine will
Chris Lattner38378bf2009-04-25 08:28:21 +00006524/// emit diagnostics and set the invalid bit to true. In any case, the type
6525/// will be updated to reflect a well-formed type for the constructor and
6526/// returned.
6527QualType Sema::CheckConstructorDeclarator(Declarator &D, QualType R,
John McCall8e7d6562010-08-26 03:08:43 +00006528 StorageClass &SC) {
Douglas Gregor831c93f2008-11-05 20:51:48 +00006529 bool isVirtual = D.getDeclSpec().isVirtualSpecified();
Douglas Gregor831c93f2008-11-05 20:51:48 +00006530
6531 // C++ [class.ctor]p3:
6532 // A constructor shall not be virtual (10.3) or static (9.4). A
6533 // constructor can be invoked for a const, volatile or const
6534 // volatile object. A constructor shall not be declared const,
6535 // volatile, or const volatile (9.3.2).
6536 if (isVirtual) {
Chris Lattner38378bf2009-04-25 08:28:21 +00006537 if (!D.isInvalidType())
6538 Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
6539 << "virtual" << SourceRange(D.getDeclSpec().getVirtualSpecLoc())
6540 << SourceRange(D.getIdentifierLoc());
6541 D.setInvalidType();
Douglas Gregor831c93f2008-11-05 20:51:48 +00006542 }
John McCall8e7d6562010-08-26 03:08:43 +00006543 if (SC == SC_Static) {
Chris Lattner38378bf2009-04-25 08:28:21 +00006544 if (!D.isInvalidType())
6545 Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
6546 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
6547 << SourceRange(D.getIdentifierLoc());
6548 D.setInvalidType();
John McCall8e7d6562010-08-26 03:08:43 +00006549 SC = SC_None;
Douglas Gregor831c93f2008-11-05 20:51:48 +00006550 }
Mike Stump11289f42009-09-09 15:08:12 +00006551
David Majnemer03f705f2014-07-08 18:18:04 +00006552 if (unsigned TypeQuals = D.getDeclSpec().getTypeQualifiers()) {
6553 diagnoseIgnoredQualifiers(
6554 diag::err_constructor_return_type, TypeQuals, SourceLocation(),
6555 D.getDeclSpec().getConstSpecLoc(), D.getDeclSpec().getVolatileSpecLoc(),
6556 D.getDeclSpec().getRestrictSpecLoc(),
6557 D.getDeclSpec().getAtomicSpecLoc());
6558 D.setInvalidType();
6559 }
6560
Abramo Bagnara924a8f32010-12-10 16:29:40 +00006561 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
Chris Lattner38378bf2009-04-25 08:28:21 +00006562 if (FTI.TypeQuals != 0) {
John McCall8ccfcb52009-09-24 19:53:00 +00006563 if (FTI.TypeQuals & Qualifiers::Const)
Chris Lattner3b054132008-11-19 05:08:23 +00006564 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
6565 << "const" << SourceRange(D.getIdentifierLoc());
John McCall8ccfcb52009-09-24 19:53:00 +00006566 if (FTI.TypeQuals & Qualifiers::Volatile)
Chris Lattner3b054132008-11-19 05:08:23 +00006567 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
6568 << "volatile" << SourceRange(D.getIdentifierLoc());
John McCall8ccfcb52009-09-24 19:53:00 +00006569 if (FTI.TypeQuals & Qualifiers::Restrict)
Chris Lattner3b054132008-11-19 05:08:23 +00006570 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
6571 << "restrict" << SourceRange(D.getIdentifierLoc());
John McCalldb40c7f2010-12-14 08:05:40 +00006572 D.setInvalidType();
Douglas Gregor831c93f2008-11-05 20:51:48 +00006573 }
Mike Stump11289f42009-09-09 15:08:12 +00006574
Douglas Gregordb9d6642011-01-26 05:01:58 +00006575 // C++0x [class.ctor]p4:
6576 // A constructor shall not be declared with a ref-qualifier.
6577 if (FTI.hasRefQualifier()) {
6578 Diag(FTI.getRefQualifierLoc(), diag::err_ref_qualifier_constructor)
6579 << FTI.RefQualifierIsLValueRef
6580 << FixItHint::CreateRemoval(FTI.getRefQualifierLoc());
6581 D.setInvalidType();
6582 }
6583
Douglas Gregor831c93f2008-11-05 20:51:48 +00006584 // Rebuild the function type "R" without any type qualifiers (in
6585 // case any of the errors above fired) and with "void" as the
Douglas Gregor95755162010-07-01 05:10:53 +00006586 // return type, since constructors don't have return types.
John McCall9dd450b2009-09-21 23:43:11 +00006587 const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
Alp Toker314cc812014-01-25 16:55:45 +00006588 if (Proto->getReturnType() == Context.VoidTy && !D.isInvalidType())
John McCalldb40c7f2010-12-14 08:05:40 +00006589 return R;
6590
6591 FunctionProtoType::ExtProtoInfo EPI = Proto->getExtProtoInfo();
6592 EPI.TypeQuals = 0;
Douglas Gregordb9d6642011-01-26 05:01:58 +00006593 EPI.RefQualifier = RQ_None;
Alp Toker9cacbab2014-01-20 20:26:09 +00006594
6595 return Context.getFunctionType(Context.VoidTy, Proto->getParamTypes(), EPI);
Douglas Gregor831c93f2008-11-05 20:51:48 +00006596}
6597
Douglas Gregor4d87df52008-12-16 21:30:33 +00006598/// CheckConstructor - Checks a fully-formed constructor for
6599/// well-formedness, issuing any diagnostics required. Returns true if
6600/// the constructor declarator is invalid.
Chris Lattnerb41df4f2009-04-25 08:35:12 +00006601void Sema::CheckConstructor(CXXConstructorDecl *Constructor) {
Mike Stump11289f42009-09-09 15:08:12 +00006602 CXXRecordDecl *ClassDecl
Douglas Gregorf4d17c42009-03-27 04:38:56 +00006603 = dyn_cast<CXXRecordDecl>(Constructor->getDeclContext());
6604 if (!ClassDecl)
Chris Lattnerb41df4f2009-04-25 08:35:12 +00006605 return Constructor->setInvalidDecl();
Douglas Gregor4d87df52008-12-16 21:30:33 +00006606
6607 // C++ [class.copy]p3:
6608 // A declaration of a constructor for a class X is ill-formed if
6609 // its first parameter is of type (optionally cv-qualified) X and
6610 // either there are no other parameters or else all other
6611 // parameters have default arguments.
Douglas Gregorf4d17c42009-03-27 04:38:56 +00006612 if (!Constructor->isInvalidDecl() &&
Mike Stump11289f42009-09-09 15:08:12 +00006613 ((Constructor->getNumParams() == 1) ||
6614 (Constructor->getNumParams() > 1 &&
Douglas Gregorffe14e32009-11-14 01:20:54 +00006615 Constructor->getParamDecl(1)->hasDefaultArg())) &&
6616 Constructor->getTemplateSpecializationKind()
6617 != TSK_ImplicitInstantiation) {
Douglas Gregor4d87df52008-12-16 21:30:33 +00006618 QualType ParamType = Constructor->getParamDecl(0)->getType();
6619 QualType ClassTy = Context.getTagDeclType(ClassDecl);
6620 if (Context.getCanonicalType(ParamType).getUnqualifiedType() == ClassTy) {
Douglas Gregor170512f2009-04-01 23:51:29 +00006621 SourceLocation ParamLoc = Constructor->getParamDecl(0)->getLocation();
Douglas Gregorfd42e952010-05-27 21:28:21 +00006622 const char *ConstRef
6623 = Constructor->getParamDecl(0)->getIdentifier() ? "const &"
6624 : " const &";
Douglas Gregor170512f2009-04-01 23:51:29 +00006625 Diag(ParamLoc, diag::err_constructor_byvalue_arg)
Douglas Gregorfd42e952010-05-27 21:28:21 +00006626 << FixItHint::CreateInsertion(ParamLoc, ConstRef);
Douglas Gregorffe14e32009-11-14 01:20:54 +00006627
6628 // FIXME: Rather that making the constructor invalid, we should endeavor
6629 // to fix the type.
Chris Lattnerb41df4f2009-04-25 08:35:12 +00006630 Constructor->setInvalidDecl();
Douglas Gregor4d87df52008-12-16 21:30:33 +00006631 }
6632 }
Douglas Gregor4d87df52008-12-16 21:30:33 +00006633}
6634
John McCalldeb646e2010-08-04 01:04:25 +00006635/// CheckDestructor - Checks a fully-formed destructor definition for
6636/// well-formedness, issuing any diagnostics required. Returns true
6637/// on error.
Anders Carlssonf98849e2009-12-02 17:15:43 +00006638bool Sema::CheckDestructor(CXXDestructorDecl *Destructor) {
Anders Carlsson2a50e952009-11-15 22:49:34 +00006639 CXXRecordDecl *RD = Destructor->getParent();
6640
Peter Collingbourneb289fe62013-05-20 14:12:25 +00006641 if (!Destructor->getOperatorDelete() && Destructor->isVirtual()) {
Anders Carlsson2a50e952009-11-15 22:49:34 +00006642 SourceLocation Loc;
6643
6644 if (!Destructor->isImplicit())
6645 Loc = Destructor->getLocation();
6646 else
6647 Loc = RD->getLocation();
6648
6649 // If we have a virtual destructor, look up the deallocation function
Craig Topperc3ec1492014-05-26 06:22:03 +00006650 FunctionDecl *OperatorDelete = nullptr;
Anders Carlsson2a50e952009-11-15 22:49:34 +00006651 DeclarationName Name =
6652 Context.DeclarationNames.getCXXOperatorName(OO_Delete);
Anders Carlssonf98849e2009-12-02 17:15:43 +00006653 if (FindDeallocationFunction(Loc, RD, Name, OperatorDelete))
Anders Carlsson26a807d2009-11-30 21:24:50 +00006654 return true;
Richard Smithf03bd302013-12-05 08:30:59 +00006655 // If there's no class-specific operator delete, look up the global
6656 // non-array delete.
6657 if (!OperatorDelete)
6658 OperatorDelete = FindUsualDeallocationFunction(Loc, true, Name);
John McCall1e5d75d2010-07-03 18:33:00 +00006659
Eli Friedmanfa0df832012-02-02 03:46:19 +00006660 MarkFunctionReferenced(Loc, OperatorDelete);
Anders Carlsson26a807d2009-11-30 21:24:50 +00006661
6662 Destructor->setOperatorDelete(OperatorDelete);
Anders Carlsson2a50e952009-11-15 22:49:34 +00006663 }
Anders Carlsson26a807d2009-11-30 21:24:50 +00006664
6665 return false;
Anders Carlsson2a50e952009-11-15 22:49:34 +00006666}
6667
Douglas Gregor831c93f2008-11-05 20:51:48 +00006668/// CheckDestructorDeclarator - Called by ActOnDeclarator to check
6669/// the well-formednes of the destructor declarator @p D with type @p
6670/// R. If there are any errors in the declarator, this routine will
Chris Lattner38378bf2009-04-25 08:28:21 +00006671/// emit diagnostics and set the declarator to invalid. Even if this happens,
6672/// will be updated to reflect a well-formed type for the destructor and
6673/// returned.
Douglas Gregor95755162010-07-01 05:10:53 +00006674QualType Sema::CheckDestructorDeclarator(Declarator &D, QualType R,
John McCall8e7d6562010-08-26 03:08:43 +00006675 StorageClass& SC) {
Douglas Gregor831c93f2008-11-05 20:51:48 +00006676 // C++ [class.dtor]p1:
6677 // [...] A typedef-name that names a class is a class-name
6678 // (7.1.3); however, a typedef-name that names a class shall not
6679 // be used as the identifier in the declarator for a destructor
6680 // declaration.
Douglas Gregor7861a802009-11-03 01:35:08 +00006681 QualType DeclaratorType = GetTypeFromParser(D.getName().DestructorName);
Richard Smithdda56e42011-04-15 14:24:37 +00006682 if (const TypedefType *TT = DeclaratorType->getAs<TypedefType>())
Chris Lattner38378bf2009-04-25 08:28:21 +00006683 Diag(D.getIdentifierLoc(), diag::err_destructor_typedef_name)
Richard Smithdda56e42011-04-15 14:24:37 +00006684 << DeclaratorType << isa<TypeAliasDecl>(TT->getDecl());
Richard Smith3f1b5d02011-05-05 21:57:07 +00006685 else if (const TemplateSpecializationType *TST =
6686 DeclaratorType->getAs<TemplateSpecializationType>())
6687 if (TST->isTypeAlias())
6688 Diag(D.getIdentifierLoc(), diag::err_destructor_typedef_name)
6689 << DeclaratorType << 1;
Douglas Gregor831c93f2008-11-05 20:51:48 +00006690
6691 // C++ [class.dtor]p2:
6692 // A destructor is used to destroy objects of its class type. A
6693 // destructor takes no parameters, and no return type can be
6694 // specified for it (not even void). The address of a destructor
6695 // shall not be taken. A destructor shall not be static. A
6696 // destructor can be invoked for a const, volatile or const
6697 // volatile object. A destructor shall not be declared const,
6698 // volatile or const volatile (9.3.2).
John McCall8e7d6562010-08-26 03:08:43 +00006699 if (SC == SC_Static) {
Chris Lattner38378bf2009-04-25 08:28:21 +00006700 if (!D.isInvalidType())
6701 Diag(D.getIdentifierLoc(), diag::err_destructor_cannot_be)
6702 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
Douglas Gregor95755162010-07-01 05:10:53 +00006703 << SourceRange(D.getIdentifierLoc())
6704 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
6705
John McCall8e7d6562010-08-26 03:08:43 +00006706 SC = SC_None;
Douglas Gregor831c93f2008-11-05 20:51:48 +00006707 }
David Majnemer03f705f2014-07-08 18:18:04 +00006708 if (!D.isInvalidType()) {
Douglas Gregor831c93f2008-11-05 20:51:48 +00006709 // Destructors don't have return types, but the parser will
6710 // happily parse something like:
6711 //
6712 // class X {
6713 // float ~X();
6714 // };
6715 //
6716 // The return type will be eliminated later.
David Majnemer03f705f2014-07-08 18:18:04 +00006717 if (D.getDeclSpec().hasTypeSpecifier())
6718 Diag(D.getIdentifierLoc(), diag::err_destructor_return_type)
6719 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
6720 << SourceRange(D.getIdentifierLoc());
6721 else if (unsigned TypeQuals = D.getDeclSpec().getTypeQualifiers()) {
6722 diagnoseIgnoredQualifiers(diag::err_destructor_return_type, TypeQuals,
6723 SourceLocation(),
6724 D.getDeclSpec().getConstSpecLoc(),
6725 D.getDeclSpec().getVolatileSpecLoc(),
6726 D.getDeclSpec().getRestrictSpecLoc(),
6727 D.getDeclSpec().getAtomicSpecLoc());
6728 D.setInvalidType();
6729 }
Douglas Gregor831c93f2008-11-05 20:51:48 +00006730 }
Mike Stump11289f42009-09-09 15:08:12 +00006731
Abramo Bagnara924a8f32010-12-10 16:29:40 +00006732 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
Chris Lattner38378bf2009-04-25 08:28:21 +00006733 if (FTI.TypeQuals != 0 && !D.isInvalidType()) {
John McCall8ccfcb52009-09-24 19:53:00 +00006734 if (FTI.TypeQuals & Qualifiers::Const)
Chris Lattner3b054132008-11-19 05:08:23 +00006735 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
6736 << "const" << SourceRange(D.getIdentifierLoc());
John McCall8ccfcb52009-09-24 19:53:00 +00006737 if (FTI.TypeQuals & Qualifiers::Volatile)
Chris Lattner3b054132008-11-19 05:08:23 +00006738 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
6739 << "volatile" << SourceRange(D.getIdentifierLoc());
John McCall8ccfcb52009-09-24 19:53:00 +00006740 if (FTI.TypeQuals & Qualifiers::Restrict)
Chris Lattner3b054132008-11-19 05:08:23 +00006741 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
6742 << "restrict" << SourceRange(D.getIdentifierLoc());
Chris Lattner38378bf2009-04-25 08:28:21 +00006743 D.setInvalidType();
Douglas Gregor831c93f2008-11-05 20:51:48 +00006744 }
6745
Douglas Gregordb9d6642011-01-26 05:01:58 +00006746 // C++0x [class.dtor]p2:
6747 // A destructor shall not be declared with a ref-qualifier.
6748 if (FTI.hasRefQualifier()) {
6749 Diag(FTI.getRefQualifierLoc(), diag::err_ref_qualifier_destructor)
6750 << FTI.RefQualifierIsLValueRef
6751 << FixItHint::CreateRemoval(FTI.getRefQualifierLoc());
6752 D.setInvalidType();
6753 }
6754
Douglas Gregor831c93f2008-11-05 20:51:48 +00006755 // Make sure we don't have any parameters.
Alp Toker4284c6e2014-05-11 16:05:55 +00006756 if (FTIHasNonVoidParameters(FTI)) {
Douglas Gregor831c93f2008-11-05 20:51:48 +00006757 Diag(D.getIdentifierLoc(), diag::err_destructor_with_params);
6758
6759 // Delete the parameters.
Alp Tokerc5350722014-02-26 22:27:52 +00006760 FTI.freeParams();
Chris Lattner38378bf2009-04-25 08:28:21 +00006761 D.setInvalidType();
Douglas Gregor831c93f2008-11-05 20:51:48 +00006762 }
6763
Mike Stump11289f42009-09-09 15:08:12 +00006764 // Make sure the destructor isn't variadic.
Chris Lattner38378bf2009-04-25 08:28:21 +00006765 if (FTI.isVariadic) {
Douglas Gregor831c93f2008-11-05 20:51:48 +00006766 Diag(D.getIdentifierLoc(), diag::err_destructor_variadic);
Chris Lattner38378bf2009-04-25 08:28:21 +00006767 D.setInvalidType();
6768 }
Douglas Gregor831c93f2008-11-05 20:51:48 +00006769
6770 // Rebuild the function type "R" without any type qualifiers or
6771 // parameters (in case any of the errors above fired) and with
6772 // "void" as the return type, since destructors don't have return
Douglas Gregor95755162010-07-01 05:10:53 +00006773 // types.
John McCalldb40c7f2010-12-14 08:05:40 +00006774 if (!D.isInvalidType())
6775 return R;
6776
Douglas Gregor95755162010-07-01 05:10:53 +00006777 const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
John McCalldb40c7f2010-12-14 08:05:40 +00006778 FunctionProtoType::ExtProtoInfo EPI = Proto->getExtProtoInfo();
6779 EPI.Variadic = false;
6780 EPI.TypeQuals = 0;
Douglas Gregordb9d6642011-01-26 05:01:58 +00006781 EPI.RefQualifier = RQ_None;
Dmitri Gribenko44ebbd52013-05-05 00:41:58 +00006782 return Context.getFunctionType(Context.VoidTy, None, EPI);
Douglas Gregor831c93f2008-11-05 20:51:48 +00006783}
6784
Douglas Gregordbc5daf2008-11-07 20:08:42 +00006785/// CheckConversionDeclarator - Called by ActOnDeclarator to check the
6786/// well-formednes of the conversion function declarator @p D with
6787/// type @p R. If there are any errors in the declarator, this routine
6788/// will emit diagnostics and return true. Otherwise, it will return
6789/// false. Either way, the type @p R will be updated to reflect a
6790/// well-formed type for the conversion operator.
Chris Lattnerb41df4f2009-04-25 08:35:12 +00006791void Sema::CheckConversionDeclarator(Declarator &D, QualType &R,
John McCall8e7d6562010-08-26 03:08:43 +00006792 StorageClass& SC) {
Douglas Gregordbc5daf2008-11-07 20:08:42 +00006793 // C++ [class.conv.fct]p1:
6794 // Neither parameter types nor return type can be specified. The
Eli Friedman44b83ee2009-08-05 19:21:58 +00006795 // type of a conversion function (8.3.5) is "function taking no
Mike Stump11289f42009-09-09 15:08:12 +00006796 // parameter returning conversion-type-id."
John McCall8e7d6562010-08-26 03:08:43 +00006797 if (SC == SC_Static) {
Chris Lattnerb41df4f2009-04-25 08:35:12 +00006798 if (!D.isInvalidType())
6799 Diag(D.getIdentifierLoc(), diag::err_conv_function_not_member)
Eli Friedman600bc242013-06-20 20:58:02 +00006800 << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
6801 << D.getName().getSourceRange();
Chris Lattnerb41df4f2009-04-25 08:35:12 +00006802 D.setInvalidType();
John McCall8e7d6562010-08-26 03:08:43 +00006803 SC = SC_None;
Douglas Gregordbc5daf2008-11-07 20:08:42 +00006804 }
John McCall212fa2e2010-04-13 00:04:31 +00006805
6806 QualType ConvType = GetTypeFromParser(D.getName().ConversionFunctionId);
6807
Chris Lattnerb41df4f2009-04-25 08:35:12 +00006808 if (D.getDeclSpec().hasTypeSpecifier() && !D.isInvalidType()) {
Douglas Gregordbc5daf2008-11-07 20:08:42 +00006809 // Conversion functions don't have return types, but the parser will
6810 // happily parse something like:
6811 //
6812 // class X {
6813 // float operator bool();
6814 // };
6815 //
6816 // The return type will be changed later anyway.
Chris Lattner3b054132008-11-19 05:08:23 +00006817 Diag(D.getIdentifierLoc(), diag::err_conv_function_return_type)
6818 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
6819 << SourceRange(D.getIdentifierLoc());
John McCall212fa2e2010-04-13 00:04:31 +00006820 D.setInvalidType();
Douglas Gregordbc5daf2008-11-07 20:08:42 +00006821 }
6822
John McCall212fa2e2010-04-13 00:04:31 +00006823 const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
6824
Douglas Gregordbc5daf2008-11-07 20:08:42 +00006825 // Make sure we don't have any parameters.
Alp Toker9cacbab2014-01-20 20:26:09 +00006826 if (Proto->getNumParams() > 0) {
Douglas Gregordbc5daf2008-11-07 20:08:42 +00006827 Diag(D.getIdentifierLoc(), diag::err_conv_function_with_params);
6828
6829 // Delete the parameters.
Alp Tokerc5350722014-02-26 22:27:52 +00006830 D.getFunctionTypeInfo().freeParams();
Chris Lattnerb41df4f2009-04-25 08:35:12 +00006831 D.setInvalidType();
John McCall212fa2e2010-04-13 00:04:31 +00006832 } else if (Proto->isVariadic()) {
Douglas Gregordbc5daf2008-11-07 20:08:42 +00006833 Diag(D.getIdentifierLoc(), diag::err_conv_function_variadic);
Chris Lattnerb41df4f2009-04-25 08:35:12 +00006834 D.setInvalidType();
6835 }
Douglas Gregordbc5daf2008-11-07 20:08:42 +00006836
John McCall212fa2e2010-04-13 00:04:31 +00006837 // Diagnose "&operator bool()" and other such nonsense. This
6838 // is actually a gcc extension which we don't support.
Alp Toker314cc812014-01-25 16:55:45 +00006839 if (Proto->getReturnType() != ConvType) {
John McCall212fa2e2010-04-13 00:04:31 +00006840 Diag(D.getIdentifierLoc(), diag::err_conv_function_with_complex_decl)
Alp Toker314cc812014-01-25 16:55:45 +00006841 << Proto->getReturnType();
John McCall212fa2e2010-04-13 00:04:31 +00006842 D.setInvalidType();
Alp Toker314cc812014-01-25 16:55:45 +00006843 ConvType = Proto->getReturnType();
John McCall212fa2e2010-04-13 00:04:31 +00006844 }
6845
Douglas Gregordbc5daf2008-11-07 20:08:42 +00006846 // C++ [class.conv.fct]p4:
6847 // The conversion-type-id shall not represent a function type nor
6848 // an array type.
Douglas Gregordbc5daf2008-11-07 20:08:42 +00006849 if (ConvType->isArrayType()) {
6850 Diag(D.getIdentifierLoc(), diag::err_conv_function_to_array);
6851 ConvType = Context.getPointerType(ConvType);
Chris Lattnerb41df4f2009-04-25 08:35:12 +00006852 D.setInvalidType();
Douglas Gregordbc5daf2008-11-07 20:08:42 +00006853 } else if (ConvType->isFunctionType()) {
6854 Diag(D.getIdentifierLoc(), diag::err_conv_function_to_function);
6855 ConvType = Context.getPointerType(ConvType);
Chris Lattnerb41df4f2009-04-25 08:35:12 +00006856 D.setInvalidType();
Douglas Gregordbc5daf2008-11-07 20:08:42 +00006857 }
6858
6859 // Rebuild the function type "R" without any parameters (in case any
6860 // of the errors above fired) and with the conversion type as the
Mike Stump11289f42009-09-09 15:08:12 +00006861 // return type.
John McCalldb40c7f2010-12-14 08:05:40 +00006862 if (D.isInvalidType())
Dmitri Gribenko44ebbd52013-05-05 00:41:58 +00006863 R = Context.getFunctionType(ConvType, None, Proto->getExtProtoInfo());
Douglas Gregordbc5daf2008-11-07 20:08:42 +00006864
Douglas Gregor5fb53972009-01-14 15:45:31 +00006865 // C++0x explicit conversion operators.
Richard Smith0bf8a4922011-10-18 20:49:44 +00006866 if (D.getDeclSpec().isExplicitSpecified())
Mike Stump11289f42009-09-09 15:08:12 +00006867 Diag(D.getDeclSpec().getExplicitSpecLoc(),
Richard Smith2bf7fdb2013-01-02 11:42:31 +00006868 getLangOpts().CPlusPlus11 ?
Richard Smith0bf8a4922011-10-18 20:49:44 +00006869 diag::warn_cxx98_compat_explicit_conversion_functions :
6870 diag::ext_explicit_conversion_functions)
Douglas Gregor5fb53972009-01-14 15:45:31 +00006871 << SourceRange(D.getDeclSpec().getExplicitSpecLoc());
Douglas Gregordbc5daf2008-11-07 20:08:42 +00006872}
6873
Douglas Gregordbc5daf2008-11-07 20:08:42 +00006874/// ActOnConversionDeclarator - Called by ActOnDeclarator to complete
6875/// the declaration of the given C++ conversion function. This routine
6876/// is responsible for recording the conversion function in the C++
6877/// class, if possible.
John McCall48871652010-08-21 09:40:31 +00006878Decl *Sema::ActOnConversionDeclarator(CXXConversionDecl *Conversion) {
Douglas Gregordbc5daf2008-11-07 20:08:42 +00006879 assert(Conversion && "Expected to receive a conversion function declaration");
6880
Douglas Gregor4287b372008-12-12 08:25:50 +00006881 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Conversion->getDeclContext());
Douglas Gregordbc5daf2008-11-07 20:08:42 +00006882
6883 // Make sure we aren't redeclaring the conversion function.
6884 QualType ConvType = Context.getCanonicalType(Conversion->getConversionType());
Douglas Gregordbc5daf2008-11-07 20:08:42 +00006885
6886 // C++ [class.conv.fct]p1:
6887 // [...] A conversion function is never used to convert a
6888 // (possibly cv-qualified) object to the (possibly cv-qualified)
6889 // same object type (or a reference to it), to a (possibly
6890 // cv-qualified) base class of that type (or a reference to it),
6891 // or to (possibly cv-qualified) void.
Mike Stump87c57ac2009-05-16 07:39:55 +00006892 // FIXME: Suppress this warning if the conversion function ends up being a
6893 // virtual function that overrides a virtual function in a base class.
Mike Stump11289f42009-09-09 15:08:12 +00006894 QualType ClassType
Douglas Gregordbc5daf2008-11-07 20:08:42 +00006895 = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
Ted Kremenekc23c7e62009-07-29 21:53:49 +00006896 if (const ReferenceType *ConvTypeRef = ConvType->getAs<ReferenceType>())
Douglas Gregordbc5daf2008-11-07 20:08:42 +00006897 ConvType = ConvTypeRef->getPointeeType();
Douglas Gregor6309e3d2010-09-12 07:22:28 +00006898 if (Conversion->getTemplateSpecializationKind() != TSK_Undeclared &&
6899 Conversion->getTemplateSpecializationKind() != TSK_ExplicitSpecialization)
Douglas Gregore47191c2010-09-13 16:44:26 +00006900 /* Suppress diagnostics for instantiations. */;
Douglas Gregor6309e3d2010-09-12 07:22:28 +00006901 else if (ConvType->isRecordType()) {
Douglas Gregordbc5daf2008-11-07 20:08:42 +00006902 ConvType = Context.getCanonicalType(ConvType).getUnqualifiedType();
6903 if (ConvType == ClassType)
Chris Lattnerf7e3f6d2008-11-20 06:13:02 +00006904 Diag(Conversion->getLocation(), diag::warn_conv_to_self_not_used)
Chris Lattner1e5665e2008-11-24 06:25:27 +00006905 << ClassType;
Douglas Gregordbc5daf2008-11-07 20:08:42 +00006906 else if (IsDerivedFrom(ClassType, ConvType))
Chris Lattnerf7e3f6d2008-11-20 06:13:02 +00006907 Diag(Conversion->getLocation(), diag::warn_conv_to_base_not_used)
Chris Lattner1e5665e2008-11-24 06:25:27 +00006908 << ClassType << ConvType;
Douglas Gregordbc5daf2008-11-07 20:08:42 +00006909 } else if (ConvType->isVoidType()) {
Chris Lattnerf7e3f6d2008-11-20 06:13:02 +00006910 Diag(Conversion->getLocation(), diag::warn_conv_to_void_not_used)
Chris Lattner1e5665e2008-11-24 06:25:27 +00006911 << ClassType << ConvType;
Douglas Gregordbc5daf2008-11-07 20:08:42 +00006912 }
6913
Douglas Gregor457104e2010-09-29 04:25:11 +00006914 if (FunctionTemplateDecl *ConversionTemplate
6915 = Conversion->getDescribedFunctionTemplate())
6916 return ConversionTemplate;
6917
John McCall48871652010-08-21 09:40:31 +00006918 return Conversion;
Douglas Gregordbc5daf2008-11-07 20:08:42 +00006919}
6920
Argyrios Kyrtzidis08114892008-04-27 13:50:30 +00006921//===----------------------------------------------------------------------===//
6922// Namespace Handling
6923//===----------------------------------------------------------------------===//
6924
Richard Smith45bb8852012-10-04 22:13:39 +00006925/// \brief Diagnose a mismatch in 'inline' qualifiers when a namespace is
6926/// reopened.
6927static void DiagnoseNamespaceInlineMismatch(Sema &S, SourceLocation KeywordLoc,
6928 SourceLocation Loc,
6929 IdentifierInfo *II, bool *IsInline,
6930 NamespaceDecl *PrevNS) {
6931 assert(*IsInline != PrevNS->isInline());
John McCallb1be5232010-08-26 09:15:37 +00006932
Richard Smithf501cc32012-10-05 01:46:25 +00006933 // HACK: Work around a bug in libstdc++4.6's <atomic>, where
6934 // std::__atomic[0,1,2] are defined as non-inline namespaces, then reopened as
6935 // inline namespaces, with the intention of bringing names into namespace std.
6936 //
6937 // We support this just well enough to get that case working; this is not
6938 // sufficient to support reopening namespaces as inline in general.
Richard Smith45bb8852012-10-04 22:13:39 +00006939 if (*IsInline && II && II->getName().startswith("__atomic") &&
6940 S.getSourceManager().isInSystemHeader(Loc)) {
Richard Smithf501cc32012-10-05 01:46:25 +00006941 // Mark all prior declarations of the namespace as inline.
Richard Smith45bb8852012-10-04 22:13:39 +00006942 for (NamespaceDecl *NS = PrevNS->getMostRecentDecl(); NS;
6943 NS = NS->getPreviousDecl())
6944 NS->setInline(*IsInline);
6945 // Patch up the lookup table for the containing namespace. This isn't really
6946 // correct, but it's good enough for this particular case.
Aaron Ballman629afae2014-03-07 19:56:05 +00006947 for (auto *I : PrevNS->decls())
6948 if (auto *ND = dyn_cast<NamedDecl>(I))
Richard Smith45bb8852012-10-04 22:13:39 +00006949 PrevNS->getParent()->makeDeclVisibleInContext(ND);
6950 return;
6951 }
6952
6953 if (PrevNS->isInline())
6954 // The user probably just forgot the 'inline', so suggest that it
6955 // be added back.
6956 S.Diag(Loc, diag::warn_inline_namespace_reopened_noninline)
6957 << FixItHint::CreateInsertion(KeywordLoc, "inline ");
6958 else
Richard Smith5b5d21e2014-03-12 23:36:42 +00006959 S.Diag(Loc, diag::err_inline_namespace_mismatch) << *IsInline;
Richard Smith45bb8852012-10-04 22:13:39 +00006960
6961 S.Diag(PrevNS->getLocation(), diag::note_previous_definition);
6962 *IsInline = PrevNS->isInline();
6963}
John McCallb1be5232010-08-26 09:15:37 +00006964
Argyrios Kyrtzidis08114892008-04-27 13:50:30 +00006965/// ActOnStartNamespaceDef - This is called at the start of a namespace
6966/// definition.
John McCall48871652010-08-21 09:40:31 +00006967Decl *Sema::ActOnStartNamespaceDef(Scope *NamespcScope,
Sebastian Redl67667942010-08-27 23:12:46 +00006968 SourceLocation InlineLoc,
Abramo Bagnarab5545be2011-03-08 12:38:20 +00006969 SourceLocation NamespaceLoc,
John McCallb1be5232010-08-26 09:15:37 +00006970 SourceLocation IdentLoc,
6971 IdentifierInfo *II,
6972 SourceLocation LBrace,
6973 AttributeList *AttrList) {
Abramo Bagnarab5545be2011-03-08 12:38:20 +00006974 SourceLocation StartLoc = InlineLoc.isValid() ? InlineLoc : NamespaceLoc;
6975 // For anonymous namespace, take the location of the left brace.
6976 SourceLocation Loc = II ? IdentLoc : LBrace;
Douglas Gregore57e7522012-01-07 09:11:48 +00006977 bool IsInline = InlineLoc.isValid();
Douglas Gregor21b3b292012-01-10 22:14:10 +00006978 bool IsInvalid = false;
Douglas Gregore57e7522012-01-07 09:11:48 +00006979 bool IsStd = false;
6980 bool AddToKnown = false;
Argyrios Kyrtzidis08114892008-04-27 13:50:30 +00006981 Scope *DeclRegionScope = NamespcScope->getParent();
6982
Craig Topperc3ec1492014-05-26 06:22:03 +00006983 NamespaceDecl *PrevNS = nullptr;
Argyrios Kyrtzidis08114892008-04-27 13:50:30 +00006984 if (II) {
6985 // C++ [namespace.def]p2:
Douglas Gregor412c3622010-10-22 15:24:46 +00006986 // The identifier in an original-namespace-definition shall not
6987 // have been previously defined in the declarative region in
6988 // which the original-namespace-definition appears. The
6989 // identifier in an original-namespace-definition is the name of
6990 // the namespace. Subsequently in that declarative region, it is
6991 // treated as an original-namespace-name.
6992 //
6993 // Since namespace names are unique in their scope, and we don't
Douglas Gregorb578fbe2011-05-06 23:28:47 +00006994 // look through using directives, just look for any ordinary names.
6995
6996 const unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_Member |
Douglas Gregore57e7522012-01-07 09:11:48 +00006997 Decl::IDNS_Type | Decl::IDNS_Using | Decl::IDNS_Tag |
6998 Decl::IDNS_Namespace;
Craig Topperc3ec1492014-05-26 06:22:03 +00006999 NamedDecl *PrevDecl = nullptr;
David Blaikieff7d47a2012-12-19 00:45:41 +00007000 DeclContext::lookup_result R = CurContext->getRedeclContext()->lookup(II);
7001 for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E;
7002 ++I) {
7003 if ((*I)->getIdentifierNamespace() & IDNS) {
7004 PrevDecl = *I;
Douglas Gregorb578fbe2011-05-06 23:28:47 +00007005 break;
7006 }
7007 }
7008
Douglas Gregore57e7522012-01-07 09:11:48 +00007009 PrevNS = dyn_cast_or_null<NamespaceDecl>(PrevDecl);
7010
7011 if (PrevNS) {
Douglas Gregor91f84212008-12-11 16:49:14 +00007012 // This is an extended namespace definition.
Richard Smith45bb8852012-10-04 22:13:39 +00007013 if (IsInline != PrevNS->isInline())
7014 DiagnoseNamespaceInlineMismatch(*this, NamespaceLoc, Loc, II,
7015 &IsInline, PrevNS);
Douglas Gregor91f84212008-12-11 16:49:14 +00007016 } else if (PrevDecl) {
7017 // This is an invalid name redefinition.
Douglas Gregore57e7522012-01-07 09:11:48 +00007018 Diag(Loc, diag::err_redefinition_different_kind)
7019 << II;
Douglas Gregor91f84212008-12-11 16:49:14 +00007020 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
Douglas Gregor21b3b292012-01-10 22:14:10 +00007021 IsInvalid = true;
Douglas Gregor91f84212008-12-11 16:49:14 +00007022 // Continue on to push Namespc as current DeclContext and return it.
Douglas Gregore57e7522012-01-07 09:11:48 +00007023 } else if (II->isStr("std") &&
Sebastian Redl50c68252010-08-31 00:36:30 +00007024 CurContext->getRedeclContext()->isTranslationUnit()) {
Douglas Gregor87f54062009-09-15 22:30:29 +00007025 // This is the first "real" definition of the namespace "std", so update
7026 // our cache of the "std" namespace to point at this definition.
Douglas Gregore57e7522012-01-07 09:11:48 +00007027 PrevNS = getStdNamespace();
7028 IsStd = true;
7029 AddToKnown = !IsInline;
7030 } else {
7031 // We've seen this namespace for the first time.
7032 AddToKnown = !IsInline;
Mike Stump11289f42009-09-09 15:08:12 +00007033 }
Douglas Gregor91f84212008-12-11 16:49:14 +00007034 } else {
John McCall4fa53422009-10-01 00:25:31 +00007035 // Anonymous namespaces.
Douglas Gregore57e7522012-01-07 09:11:48 +00007036
7037 // Determine whether the parent already has an anonymous namespace.
Sebastian Redl50c68252010-08-31 00:36:30 +00007038 DeclContext *Parent = CurContext->getRedeclContext();
John McCall0db42252009-12-16 02:06:49 +00007039 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(Parent)) {
Douglas Gregore57e7522012-01-07 09:11:48 +00007040 PrevNS = TU->getAnonymousNamespace();
John McCall0db42252009-12-16 02:06:49 +00007041 } else {
7042 NamespaceDecl *ND = cast<NamespaceDecl>(Parent);
Douglas Gregore57e7522012-01-07 09:11:48 +00007043 PrevNS = ND->getAnonymousNamespace();
John McCall0db42252009-12-16 02:06:49 +00007044 }
7045
Richard Smith45bb8852012-10-04 22:13:39 +00007046 if (PrevNS && IsInline != PrevNS->isInline())
7047 DiagnoseNamespaceInlineMismatch(*this, NamespaceLoc, NamespaceLoc, II,
7048 &IsInline, PrevNS);
Douglas Gregore57e7522012-01-07 09:11:48 +00007049 }
7050
7051 NamespaceDecl *Namespc = NamespaceDecl::Create(Context, CurContext, IsInline,
7052 StartLoc, Loc, II, PrevNS);
Douglas Gregor21b3b292012-01-10 22:14:10 +00007053 if (IsInvalid)
7054 Namespc->setInvalidDecl();
Douglas Gregore57e7522012-01-07 09:11:48 +00007055
7056 ProcessDeclAttributeList(DeclRegionScope, Namespc, AttrList);
Sebastian Redlb5c2baa2010-08-31 00:36:36 +00007057
Douglas Gregore57e7522012-01-07 09:11:48 +00007058 // FIXME: Should we be merging attributes?
7059 if (const VisibilityAttr *Attr = Namespc->getAttr<VisibilityAttr>())
Rafael Espindola6d65d7b2012-02-01 23:24:59 +00007060 PushNamespaceVisibilityAttr(Attr, Loc);
Douglas Gregore57e7522012-01-07 09:11:48 +00007061
7062 if (IsStd)
7063 StdNamespace = Namespc;
7064 if (AddToKnown)
7065 KnownNamespaces[Namespc] = false;
7066
7067 if (II) {
7068 PushOnScopeChains(Namespc, DeclRegionScope);
7069 } else {
7070 // Link the anonymous namespace into its parent.
7071 DeclContext *Parent = CurContext->getRedeclContext();
7072 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(Parent)) {
7073 TU->setAnonymousNamespace(Namespc);
7074 } else {
7075 cast<NamespaceDecl>(Parent)->setAnonymousNamespace(Namespc);
John McCall0db42252009-12-16 02:06:49 +00007076 }
John McCall4fa53422009-10-01 00:25:31 +00007077
Douglas Gregorf9f54ea2010-03-24 00:46:35 +00007078 CurContext->addDecl(Namespc);
7079
John McCall4fa53422009-10-01 00:25:31 +00007080 // C++ [namespace.unnamed]p1. An unnamed-namespace-definition
7081 // behaves as if it were replaced by
7082 // namespace unique { /* empty body */ }
7083 // using namespace unique;
7084 // namespace unique { namespace-body }
7085 // where all occurrences of 'unique' in a translation unit are
7086 // replaced by the same identifier and this identifier differs
7087 // from all other identifiers in the entire program.
7088
7089 // We just create the namespace with an empty name and then add an
7090 // implicit using declaration, just like the standard suggests.
7091 //
7092 // CodeGen enforces the "universally unique" aspect by giving all
7093 // declarations semantically contained within an anonymous
7094 // namespace internal linkage.
7095
Douglas Gregore57e7522012-01-07 09:11:48 +00007096 if (!PrevNS) {
John McCall0db42252009-12-16 02:06:49 +00007097 UsingDirectiveDecl* UD
Nick Lewycky38115822012-11-04 20:21:54 +00007098 = UsingDirectiveDecl::Create(Context, Parent,
John McCall0db42252009-12-16 02:06:49 +00007099 /* 'using' */ LBrace,
7100 /* 'namespace' */ SourceLocation(),
Douglas Gregor12441b32011-02-25 16:33:46 +00007101 /* qualifier */ NestedNameSpecifierLoc(),
John McCall0db42252009-12-16 02:06:49 +00007102 /* identifier */ SourceLocation(),
7103 Namespc,
Nick Lewycky38115822012-11-04 20:21:54 +00007104 /* Ancestor */ Parent);
John McCall0db42252009-12-16 02:06:49 +00007105 UD->setImplicit();
Nick Lewycky38115822012-11-04 20:21:54 +00007106 Parent->addDecl(UD);
John McCall0db42252009-12-16 02:06:49 +00007107 }
Argyrios Kyrtzidis08114892008-04-27 13:50:30 +00007108 }
7109
Dmitri Gribenkof26054f2012-07-11 21:38:39 +00007110 ActOnDocumentableDecl(Namespc);
7111
Argyrios Kyrtzidis08114892008-04-27 13:50:30 +00007112 // Although we could have an invalid decl (i.e. the namespace name is a
7113 // redefinition), push it as current DeclContext and try to continue parsing.
Mike Stump87c57ac2009-05-16 07:39:55 +00007114 // FIXME: We should be able to push Namespc here, so that the each DeclContext
7115 // for the namespace has the declarations that showed up in that particular
7116 // namespace definition.
Douglas Gregor91f84212008-12-11 16:49:14 +00007117 PushDeclContext(NamespcScope, Namespc);
John McCall48871652010-08-21 09:40:31 +00007118 return Namespc;
Argyrios Kyrtzidis08114892008-04-27 13:50:30 +00007119}
7120
Sebastian Redla6602e92009-11-23 15:34:23 +00007121/// getNamespaceDecl - Returns the namespace a decl represents. If the decl
7122/// is a namespace alias, returns the namespace it points to.
7123static inline NamespaceDecl *getNamespaceDecl(NamedDecl *D) {
7124 if (NamespaceAliasDecl *AD = dyn_cast_or_null<NamespaceAliasDecl>(D))
7125 return AD->getNamespace();
7126 return dyn_cast_or_null<NamespaceDecl>(D);
7127}
7128
Argyrios Kyrtzidis08114892008-04-27 13:50:30 +00007129/// ActOnFinishNamespaceDef - This callback is called after a namespace is
7130/// exited. Decl is the DeclTy returned by ActOnStartNamespaceDef.
John McCall48871652010-08-21 09:40:31 +00007131void Sema::ActOnFinishNamespaceDef(Decl *Dcl, SourceLocation RBrace) {
Argyrios Kyrtzidis08114892008-04-27 13:50:30 +00007132 NamespaceDecl *Namespc = dyn_cast_or_null<NamespaceDecl>(Dcl);
7133 assert(Namespc && "Invalid parameter, expected NamespaceDecl");
Abramo Bagnarab5545be2011-03-08 12:38:20 +00007134 Namespc->setRBraceLoc(RBrace);
Argyrios Kyrtzidis08114892008-04-27 13:50:30 +00007135 PopDeclContext();
Eli Friedman570024a2010-08-05 06:57:20 +00007136 if (Namespc->hasAttr<VisibilityAttr>())
Rafael Espindola6d65d7b2012-02-01 23:24:59 +00007137 PopPragmaVisibility(true, RBrace);
Argyrios Kyrtzidis08114892008-04-27 13:50:30 +00007138}
Argyrios Kyrtzidis9a1191c2008-10-06 17:10:33 +00007139
John McCall28a0cf72010-08-25 07:42:41 +00007140CXXRecordDecl *Sema::getStdBadAlloc() const {
7141 return cast_or_null<CXXRecordDecl>(
7142 StdBadAlloc.get(Context.getExternalSource()));
7143}
7144
7145NamespaceDecl *Sema::getStdNamespace() const {
7146 return cast_or_null<NamespaceDecl>(
7147 StdNamespace.get(Context.getExternalSource()));
7148}
7149
Douglas Gregorcdf87022010-06-29 17:53:46 +00007150/// \brief Retrieve the special "std" namespace, which may require us to
7151/// implicitly define the namespace.
Argyrios Kyrtzidis4f8e1732010-08-02 07:14:39 +00007152NamespaceDecl *Sema::getOrCreateStdNamespace() {
Douglas Gregorcdf87022010-06-29 17:53:46 +00007153 if (!StdNamespace) {
7154 // The "std" namespace has not yet been defined, so build one implicitly.
7155 StdNamespace = NamespaceDecl::Create(Context,
7156 Context.getTranslationUnitDecl(),
Douglas Gregore57e7522012-01-07 09:11:48 +00007157 /*Inline=*/false,
Abramo Bagnarab5545be2011-03-08 12:38:20 +00007158 SourceLocation(), SourceLocation(),
Douglas Gregore57e7522012-01-07 09:11:48 +00007159 &PP.getIdentifierTable().get("std"),
Craig Topperc3ec1492014-05-26 06:22:03 +00007160 /*PrevDecl=*/nullptr);
Argyrios Kyrtzidis2d688102010-08-02 07:14:54 +00007161 getStdNamespace()->setImplicit(true);
Douglas Gregorcdf87022010-06-29 17:53:46 +00007162 }
Eli Bendersky9a220fc2014-09-29 20:38:29 +00007163
Argyrios Kyrtzidis2d688102010-08-02 07:14:54 +00007164 return getStdNamespace();
Douglas Gregorcdf87022010-06-29 17:53:46 +00007165}
7166
Sebastian Redl2bfa1042012-01-17 22:49:33 +00007167bool Sema::isStdInitializerList(QualType Ty, QualType *Element) {
David Blaikiebbafb8a2012-03-11 07:00:24 +00007168 assert(getLangOpts().CPlusPlus &&
Sebastian Redl2bfa1042012-01-17 22:49:33 +00007169 "Looking for std::initializer_list outside of C++.");
7170
7171 // We're looking for implicit instantiations of
7172 // template <typename E> class std::initializer_list.
7173
7174 if (!StdNamespace) // If we haven't seen namespace std yet, this can't be it.
7175 return false;
7176
Craig Topperc3ec1492014-05-26 06:22:03 +00007177 ClassTemplateDecl *Template = nullptr;
7178 const TemplateArgument *Arguments = nullptr;
Sebastian Redl2bfa1042012-01-17 22:49:33 +00007179
Sebastian Redl43144e72012-01-17 22:49:58 +00007180 if (const RecordType *RT = Ty->getAs<RecordType>()) {
Sebastian Redl2bfa1042012-01-17 22:49:33 +00007181
Sebastian Redl43144e72012-01-17 22:49:58 +00007182 ClassTemplateSpecializationDecl *Specialization =
7183 dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl());
7184 if (!Specialization)
7185 return false;
Sebastian Redl2bfa1042012-01-17 22:49:33 +00007186
Sebastian Redl43144e72012-01-17 22:49:58 +00007187 Template = Specialization->getSpecializedTemplate();
7188 Arguments = Specialization->getTemplateArgs().data();
7189 } else if (const TemplateSpecializationType *TST =
7190 Ty->getAs<TemplateSpecializationType>()) {
7191 Template = dyn_cast_or_null<ClassTemplateDecl>(
7192 TST->getTemplateName().getAsTemplateDecl());
7193 Arguments = TST->getArgs();
7194 }
7195 if (!Template)
7196 return false;
Sebastian Redl2bfa1042012-01-17 22:49:33 +00007197
7198 if (!StdInitializerList) {
7199 // Haven't recognized std::initializer_list yet, maybe this is it.
7200 CXXRecordDecl *TemplateClass = Template->getTemplatedDecl();
7201 if (TemplateClass->getIdentifier() !=
7202 &PP.getIdentifierTable().get("initializer_list") ||
Sebastian Redl09edce02012-01-23 22:09:39 +00007203 !getStdNamespace()->InEnclosingNamespaceSetOf(
7204 TemplateClass->getDeclContext()))
Sebastian Redl2bfa1042012-01-17 22:49:33 +00007205 return false;
7206 // This is a template called std::initializer_list, but is it the right
7207 // template?
7208 TemplateParameterList *Params = Template->getTemplateParameters();
Sebastian Redl09edce02012-01-23 22:09:39 +00007209 if (Params->getMinRequiredArguments() != 1)
Sebastian Redl2bfa1042012-01-17 22:49:33 +00007210 return false;
7211 if (!isa<TemplateTypeParmDecl>(Params->getParam(0)))
7212 return false;
7213
7214 // It's the right template.
7215 StdInitializerList = Template;
7216 }
7217
7218 if (Template != StdInitializerList)
7219 return false;
7220
7221 // This is an instance of std::initializer_list. Find the argument type.
Sebastian Redl43144e72012-01-17 22:49:58 +00007222 if (Element)
7223 *Element = Arguments[0].getAsType();
Sebastian Redl2bfa1042012-01-17 22:49:33 +00007224 return true;
7225}
7226
Sebastian Redl42acd4a2012-01-17 22:50:08 +00007227static ClassTemplateDecl *LookupStdInitializerList(Sema &S, SourceLocation Loc){
7228 NamespaceDecl *Std = S.getStdNamespace();
7229 if (!Std) {
7230 S.Diag(Loc, diag::err_implied_std_initializer_list_not_found);
Craig Topperc3ec1492014-05-26 06:22:03 +00007231 return nullptr;
Sebastian Redl42acd4a2012-01-17 22:50:08 +00007232 }
7233
7234 LookupResult Result(S, &S.PP.getIdentifierTable().get("initializer_list"),
7235 Loc, Sema::LookupOrdinaryName);
7236 if (!S.LookupQualifiedName(Result, Std)) {
7237 S.Diag(Loc, diag::err_implied_std_initializer_list_not_found);
Craig Topperc3ec1492014-05-26 06:22:03 +00007238 return nullptr;
Sebastian Redl42acd4a2012-01-17 22:50:08 +00007239 }
7240 ClassTemplateDecl *Template = Result.getAsSingle<ClassTemplateDecl>();
7241 if (!Template) {
7242 Result.suppressDiagnostics();
7243 // We found something weird. Complain about the first thing we found.
7244 NamedDecl *Found = *Result.begin();
7245 S.Diag(Found->getLocation(), diag::err_malformed_std_initializer_list);
Craig Topperc3ec1492014-05-26 06:22:03 +00007246 return nullptr;
Sebastian Redl42acd4a2012-01-17 22:50:08 +00007247 }
7248
7249 // We found some template called std::initializer_list. Now verify that it's
7250 // correct.
7251 TemplateParameterList *Params = Template->getTemplateParameters();
Sebastian Redl09edce02012-01-23 22:09:39 +00007252 if (Params->getMinRequiredArguments() != 1 ||
7253 !isa<TemplateTypeParmDecl>(Params->getParam(0))) {
Sebastian Redl42acd4a2012-01-17 22:50:08 +00007254 S.Diag(Template->getLocation(), diag::err_malformed_std_initializer_list);
Craig Topperc3ec1492014-05-26 06:22:03 +00007255 return nullptr;
Sebastian Redl42acd4a2012-01-17 22:50:08 +00007256 }
7257
7258 return Template;
7259}
7260
7261QualType Sema::BuildStdInitializerList(QualType Element, SourceLocation Loc) {
7262 if (!StdInitializerList) {
7263 StdInitializerList = LookupStdInitializerList(*this, Loc);
7264 if (!StdInitializerList)
7265 return QualType();
7266 }
7267
7268 TemplateArgumentListInfo Args(Loc, Loc);
7269 Args.addArgument(TemplateArgumentLoc(TemplateArgument(Element),
7270 Context.getTrivialTypeSourceInfo(Element,
7271 Loc)));
7272 return Context.getCanonicalType(
7273 CheckTemplateIdType(TemplateName(StdInitializerList), Loc, Args));
7274}
7275
Sebastian Redlbe24ec22012-01-17 22:50:14 +00007276bool Sema::isInitListConstructor(const CXXConstructorDecl* Ctor) {
7277 // C++ [dcl.init.list]p2:
7278 // A constructor is an initializer-list constructor if its first parameter
7279 // is of type std::initializer_list<E> or reference to possibly cv-qualified
7280 // std::initializer_list<E> for some type E, and either there are no other
7281 // parameters or else all other parameters have default arguments.
7282 if (Ctor->getNumParams() < 1 ||
7283 (Ctor->getNumParams() > 1 && !Ctor->getParamDecl(1)->hasDefaultArg()))
7284 return false;
7285
7286 QualType ArgType = Ctor->getParamDecl(0)->getType();
7287 if (const ReferenceType *RT = ArgType->getAs<ReferenceType>())
7288 ArgType = RT->getPointeeType().getUnqualifiedType();
7289
Craig Topperc3ec1492014-05-26 06:22:03 +00007290 return isStdInitializerList(ArgType, nullptr);
Sebastian Redlbe24ec22012-01-17 22:50:14 +00007291}
7292
Douglas Gregora172e082011-03-26 22:25:30 +00007293/// \brief Determine whether a using statement is in a context where it will be
7294/// apply in all contexts.
7295static bool IsUsingDirectiveInToplevelContext(DeclContext *CurContext) {
7296 switch (CurContext->getDeclKind()) {
7297 case Decl::TranslationUnit:
7298 return true;
7299 case Decl::LinkageSpec:
7300 return IsUsingDirectiveInToplevelContext(CurContext->getParent());
7301 default:
7302 return false;
7303 }
7304}
7305
Kaelyn Uhrain2d317ed2012-01-11 19:37:46 +00007306namespace {
7307
7308// Callback to only accept typo corrections that are namespaces.
7309class NamespaceValidatorCCC : public CorrectionCandidateCallback {
Benjamin Kramer8bf44352013-07-24 15:28:33 +00007310public:
Craig Toppera798a9d2014-03-02 09:32:10 +00007311 bool ValidateCandidate(const TypoCorrection &candidate) override {
Benjamin Kramer8bf44352013-07-24 15:28:33 +00007312 if (NamedDecl *ND = candidate.getCorrectionDecl())
Kaelyn Uhrain2d317ed2012-01-11 19:37:46 +00007313 return isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND);
Kaelyn Uhrain2d317ed2012-01-11 19:37:46 +00007314 return false;
7315 }
7316};
7317
7318}
7319
Douglas Gregorc2fa1692011-06-28 16:20:02 +00007320static bool TryNamespaceTypoCorrection(Sema &S, LookupResult &R, Scope *Sc,
7321 CXXScopeSpec &SS,
7322 SourceLocation IdentLoc,
7323 IdentifierInfo *Ident) {
7324 R.clear();
Kaelyn Takata89c881b2014-10-27 18:07:29 +00007325 if (TypoCorrection Corrected =
7326 S.CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), Sc, &SS,
7327 llvm::make_unique<NamespaceValidatorCCC>(),
7328 Sema::CTK_ErrorRecovery)) {
Kaelyn Uhrain10413a42013-07-02 23:47:44 +00007329 if (DeclContext *DC = S.computeDeclContext(SS, false)) {
Richard Smithf9b15102013-08-17 00:46:16 +00007330 std::string CorrectedStr(Corrected.getAsString(S.getLangOpts()));
7331 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
Kaelyn Uhrain10413a42013-07-02 23:47:44 +00007332 Ident->getName().equals(CorrectedStr);
Richard Smithf9b15102013-08-17 00:46:16 +00007333 S.diagnoseTypo(Corrected,
7334 S.PDiag(diag::err_using_directive_member_suggest)
7335 << Ident << DC << DroppedSpecifier << SS.getRange(),
7336 S.PDiag(diag::note_namespace_defined_here));
Kaelyn Uhrain10413a42013-07-02 23:47:44 +00007337 } else {
Richard Smithf9b15102013-08-17 00:46:16 +00007338 S.diagnoseTypo(Corrected,
7339 S.PDiag(diag::err_using_directive_suggest) << Ident,
7340 S.PDiag(diag::note_namespace_defined_here));
Kaelyn Uhrain10413a42013-07-02 23:47:44 +00007341 }
Kaelyn Uhrain2d317ed2012-01-11 19:37:46 +00007342 R.addDecl(Corrected.getCorrectionDecl());
7343 return true;
Douglas Gregorc2fa1692011-06-28 16:20:02 +00007344 }
7345 return false;
7346}
7347
John McCall48871652010-08-21 09:40:31 +00007348Decl *Sema::ActOnUsingDirective(Scope *S,
Chris Lattner83f095c2009-03-28 19:18:32 +00007349 SourceLocation UsingLoc,
7350 SourceLocation NamespcLoc,
Jeffrey Yasskinc76498d2010-04-08 16:38:48 +00007351 CXXScopeSpec &SS,
Chris Lattner83f095c2009-03-28 19:18:32 +00007352 SourceLocation IdentLoc,
7353 IdentifierInfo *NamespcName,
7354 AttributeList *AttrList) {
Douglas Gregord7c4d982008-12-30 03:27:21 +00007355 assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
7356 assert(NamespcName && "Invalid NamespcName.");
7357 assert(IdentLoc.isValid() && "Invalid NamespceName location.");
John McCall9b72f892010-11-10 02:40:36 +00007358
7359 // This can only happen along a recovery path.
7360 while (S->getFlags() & Scope::TemplateParamScope)
7361 S = S->getParent();
Douglas Gregor889ceb72009-02-03 19:21:40 +00007362 assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
Douglas Gregord7c4d982008-12-30 03:27:21 +00007363
Craig Topperc3ec1492014-05-26 06:22:03 +00007364 UsingDirectiveDecl *UDir = nullptr;
7365 NestedNameSpecifier *Qualifier = nullptr;
Douglas Gregorcdf87022010-06-29 17:53:46 +00007366 if (SS.isSet())
Aaron Ballman4a979672014-01-03 13:56:08 +00007367 Qualifier = SS.getScopeRep();
Douglas Gregorcdf87022010-06-29 17:53:46 +00007368
Douglas Gregor34074322009-01-14 22:20:51 +00007369 // Lookup namespace name.
John McCall27b18f82009-11-17 02:14:36 +00007370 LookupResult R(*this, NamespcName, IdentLoc, LookupNamespaceName);
7371 LookupParsedName(R, S, &SS);
7372 if (R.isAmbiguous())
Craig Topperc3ec1492014-05-26 06:22:03 +00007373 return nullptr;
John McCall27b18f82009-11-17 02:14:36 +00007374
Douglas Gregorcdf87022010-06-29 17:53:46 +00007375 if (R.empty()) {
Douglas Gregorc2fa1692011-06-28 16:20:02 +00007376 R.clear();
Douglas Gregorcdf87022010-06-29 17:53:46 +00007377 // Allow "using namespace std;" or "using namespace ::std;" even if
7378 // "std" hasn't been defined yet, for GCC compatibility.
7379 if ((!Qualifier || Qualifier->getKind() == NestedNameSpecifier::Global) &&
7380 NamespcName->isStr("std")) {
7381 Diag(IdentLoc, diag::ext_using_undefined_std);
Argyrios Kyrtzidis4f8e1732010-08-02 07:14:39 +00007382 R.addDecl(getOrCreateStdNamespace());
Douglas Gregorcdf87022010-06-29 17:53:46 +00007383 R.resolveKind();
7384 }
7385 // Otherwise, attempt typo correction.
Douglas Gregorc2fa1692011-06-28 16:20:02 +00007386 else TryNamespaceTypoCorrection(*this, R, S, SS, IdentLoc, NamespcName);
Douglas Gregorcdf87022010-06-29 17:53:46 +00007387 }
7388
John McCall9f3059a2009-10-09 21:13:30 +00007389 if (!R.empty()) {
Sebastian Redla6602e92009-11-23 15:34:23 +00007390 NamedDecl *Named = R.getFoundDecl();
7391 assert((isa<NamespaceDecl>(Named) || isa<NamespaceAliasDecl>(Named))
7392 && "expected namespace decl");
Douglas Gregor889ceb72009-02-03 19:21:40 +00007393 // C++ [namespace.udir]p1:
7394 // A using-directive specifies that the names in the nominated
7395 // namespace can be used in the scope in which the
7396 // using-directive appears after the using-directive. During
7397 // unqualified name lookup (3.4.1), the names appear as if they
7398 // were declared in the nearest enclosing namespace which
7399 // contains both the using-directive and the nominated
Eli Friedman44b83ee2009-08-05 19:21:58 +00007400 // namespace. [Note: in this context, "contains" means "contains
7401 // directly or indirectly". ]
Douglas Gregor889ceb72009-02-03 19:21:40 +00007402
7403 // Find enclosing context containing both using-directive and
7404 // nominated namespace.
Sebastian Redla6602e92009-11-23 15:34:23 +00007405 NamespaceDecl *NS = getNamespaceDecl(Named);
Douglas Gregor889ceb72009-02-03 19:21:40 +00007406 DeclContext *CommonAncestor = cast<DeclContext>(NS);
7407 while (CommonAncestor && !CommonAncestor->Encloses(CurContext))
7408 CommonAncestor = CommonAncestor->getParent();
7409
Sebastian Redla6602e92009-11-23 15:34:23 +00007410 UDir = UsingDirectiveDecl::Create(Context, CurContext, UsingLoc, NamespcLoc,
Douglas Gregor12441b32011-02-25 16:33:46 +00007411 SS.getWithLocInContext(Context),
Sebastian Redla6602e92009-11-23 15:34:23 +00007412 IdentLoc, Named, CommonAncestor);
Douglas Gregor96a4bdd2011-03-18 16:10:52 +00007413
Douglas Gregora172e082011-03-26 22:25:30 +00007414 if (IsUsingDirectiveInToplevelContext(CurContext) &&
Eli Friedman5ba37d52013-08-22 00:27:10 +00007415 !SourceMgr.isInMainFile(SourceMgr.getExpansionLoc(IdentLoc))) {
Douglas Gregor96a4bdd2011-03-18 16:10:52 +00007416 Diag(IdentLoc, diag::warn_using_directive_in_header);
7417 }
7418
Douglas Gregor889ceb72009-02-03 19:21:40 +00007419 PushUsingDirective(S, UDir);
Douglas Gregord7c4d982008-12-30 03:27:21 +00007420 } else {
Chris Lattner8dca2e92009-01-06 07:24:29 +00007421 Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
Douglas Gregord7c4d982008-12-30 03:27:21 +00007422 }
7423
Richard Smith54ecd982013-02-20 19:22:51 +00007424 if (UDir)
7425 ProcessDeclAttributeList(S, UDir, AttrList);
7426
John McCall48871652010-08-21 09:40:31 +00007427 return UDir;
Douglas Gregor889ceb72009-02-03 19:21:40 +00007428}
7429
7430void Sema::PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir) {
Richard Smith05afe5e2012-03-13 03:12:56 +00007431 // If the scope has an associated entity and the using directive is at
7432 // namespace or translation unit scope, add the UsingDirectiveDecl into
7433 // its lookup structure so qualified name lookup can find it.
Ted Kremenekc37877d2013-10-08 17:08:03 +00007434 DeclContext *Ctx = S->getEntity();
Richard Smith05afe5e2012-03-13 03:12:56 +00007435 if (Ctx && !Ctx->isFunctionOrMethod())
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00007436 Ctx->addDecl(UDir);
Douglas Gregor889ceb72009-02-03 19:21:40 +00007437 else
Yaron Keren065da7c2014-05-20 18:23:05 +00007438 // Otherwise, it is at block scope. The using-directives will affect lookup
Richard Smith05afe5e2012-03-13 03:12:56 +00007439 // only to the end of the scope.
John McCall48871652010-08-21 09:40:31 +00007440 S->PushUsingDirective(UDir);
Douglas Gregord7c4d982008-12-30 03:27:21 +00007441}
Argyrios Kyrtzidis9a1191c2008-10-06 17:10:33 +00007442
Douglas Gregorfec52632009-06-20 00:51:54 +00007443
John McCall48871652010-08-21 09:40:31 +00007444Decl *Sema::ActOnUsingDeclaration(Scope *S,
John McCall9b72f892010-11-10 02:40:36 +00007445 AccessSpecifier AS,
7446 bool HasUsingKeyword,
7447 SourceLocation UsingLoc,
7448 CXXScopeSpec &SS,
7449 UnqualifiedId &Name,
7450 AttributeList *AttrList,
Enea Zaffanellae05a3cf2013-07-22 10:54:09 +00007451 bool HasTypenameKeyword,
John McCall9b72f892010-11-10 02:40:36 +00007452 SourceLocation TypenameLoc) {
Douglas Gregorfec52632009-06-20 00:51:54 +00007453 assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
Mike Stump11289f42009-09-09 15:08:12 +00007454
Douglas Gregor220f4272009-11-04 16:30:06 +00007455 switch (Name.getKind()) {
Fariborz Jahanian7f4427f2011-07-12 17:16:56 +00007456 case UnqualifiedId::IK_ImplicitSelfParam:
Douglas Gregor220f4272009-11-04 16:30:06 +00007457 case UnqualifiedId::IK_Identifier:
7458 case UnqualifiedId::IK_OperatorFunctionId:
Alexis Hunt34458502009-11-28 04:44:28 +00007459 case UnqualifiedId::IK_LiteralOperatorId:
Douglas Gregor220f4272009-11-04 16:30:06 +00007460 case UnqualifiedId::IK_ConversionFunctionId:
7461 break;
7462
7463 case UnqualifiedId::IK_ConstructorName:
Douglas Gregor9de54ea2010-01-13 17:31:36 +00007464 case UnqualifiedId::IK_ConstructorTemplateId:
Richard Smithd494c502012-04-27 19:33:05 +00007465 // C++11 inheriting constructors.
Daniel Dunbar62ee6412012-03-09 18:35:03 +00007466 Diag(Name.getLocStart(),
Richard Smith2bf7fdb2013-01-02 11:42:31 +00007467 getLangOpts().CPlusPlus11 ?
Richard Smithc2bc61b2013-03-18 21:12:30 +00007468 diag::warn_cxx98_compat_using_decl_constructor :
Richard Smith0bf8a4922011-10-18 20:49:44 +00007469 diag::err_using_decl_constructor)
7470 << SS.getRange();
7471
Richard Smith2bf7fdb2013-01-02 11:42:31 +00007472 if (getLangOpts().CPlusPlus11) break;
John McCall3969e302009-12-08 07:46:18 +00007473
Craig Topperc3ec1492014-05-26 06:22:03 +00007474 return nullptr;
7475
Douglas Gregor220f4272009-11-04 16:30:06 +00007476 case UnqualifiedId::IK_DestructorName:
Daniel Dunbar62ee6412012-03-09 18:35:03 +00007477 Diag(Name.getLocStart(), diag::err_using_decl_destructor)
Douglas Gregor220f4272009-11-04 16:30:06 +00007478 << SS.getRange();
Craig Topperc3ec1492014-05-26 06:22:03 +00007479 return nullptr;
7480
Douglas Gregor220f4272009-11-04 16:30:06 +00007481 case UnqualifiedId::IK_TemplateId:
Daniel Dunbar62ee6412012-03-09 18:35:03 +00007482 Diag(Name.getLocStart(), diag::err_using_decl_template_id)
Douglas Gregor220f4272009-11-04 16:30:06 +00007483 << SourceRange(Name.TemplateId->LAngleLoc, Name.TemplateId->RAngleLoc);
Craig Topperc3ec1492014-05-26 06:22:03 +00007484 return nullptr;
Douglas Gregor220f4272009-11-04 16:30:06 +00007485 }
Abramo Bagnara8de74e92010-08-12 11:46:03 +00007486
7487 DeclarationNameInfo TargetNameInfo = GetNameFromUnqualifiedId(Name);
7488 DeclarationName TargetName = TargetNameInfo.getName();
John McCall3969e302009-12-08 07:46:18 +00007489 if (!TargetName)
Craig Topperc3ec1492014-05-26 06:22:03 +00007490 return nullptr;
John McCall3969e302009-12-08 07:46:18 +00007491
Richard Smithc2bc61b2013-03-18 21:12:30 +00007492 // Warn about access declarations.
John McCalla0097262009-12-11 02:10:03 +00007493 if (!HasUsingKeyword) {
Enea Zaffanellac70b2512013-07-17 17:28:56 +00007494 Diag(Name.getLocStart(),
Richard Smithf026b602013-06-13 02:12:17 +00007495 getLangOpts().CPlusPlus11 ? diag::err_access_decl
7496 : diag::warn_access_decl_deprecated)
Douglas Gregora771f462010-03-31 17:46:05 +00007497 << FixItHint::CreateInsertion(SS.getRange().getBegin(), "using ");
John McCalla0097262009-12-11 02:10:03 +00007498 }
7499
Douglas Gregorc4356532010-12-16 00:46:58 +00007500 if (DiagnoseUnexpandedParameterPack(SS, UPPC_UsingDeclaration) ||
7501 DiagnoseUnexpandedParameterPack(TargetNameInfo, UPPC_UsingDeclaration))
Craig Topperc3ec1492014-05-26 06:22:03 +00007502 return nullptr;
Douglas Gregorc4356532010-12-16 00:46:58 +00007503
John McCall3f746822009-11-17 05:59:44 +00007504 NamedDecl *UD = BuildUsingDeclaration(S, AS, UsingLoc, SS,
Abramo Bagnara8de74e92010-08-12 11:46:03 +00007505 TargetNameInfo, AttrList,
John McCalle61f2ba2009-11-18 02:36:19 +00007506 /* IsInstantiation */ false,
Enea Zaffanellae05a3cf2013-07-22 10:54:09 +00007507 HasTypenameKeyword, TypenameLoc);
John McCallb96ec562009-12-04 22:46:56 +00007508 if (UD)
7509 PushOnScopeChains(UD, S, /*AddToContext*/ false);
Mike Stump11289f42009-09-09 15:08:12 +00007510
John McCall48871652010-08-21 09:40:31 +00007511 return UD;
Anders Carlsson696a3f12009-08-28 05:40:36 +00007512}
7513
Douglas Gregor1d9ef842010-07-07 23:08:52 +00007514/// \brief Determine whether a using declaration considers the given
7515/// declarations as "equivalent", e.g., if they are redeclarations of
7516/// the same entity or are both typedefs of the same type.
Richard Smithfd8634a2013-10-23 02:17:46 +00007517static bool
7518IsEquivalentForUsingDecl(ASTContext &Context, NamedDecl *D1, NamedDecl *D2) {
7519 if (D1->getCanonicalDecl() == D2->getCanonicalDecl())
Douglas Gregor1d9ef842010-07-07 23:08:52 +00007520 return true;
Douglas Gregor1d9ef842010-07-07 23:08:52 +00007521
Richard Smithdda56e42011-04-15 14:24:37 +00007522 if (TypedefNameDecl *TD1 = dyn_cast<TypedefNameDecl>(D1))
Richard Smithfd8634a2013-10-23 02:17:46 +00007523 if (TypedefNameDecl *TD2 = dyn_cast<TypedefNameDecl>(D2))
Douglas Gregor1d9ef842010-07-07 23:08:52 +00007524 return Context.hasSameType(TD1->getUnderlyingType(),
7525 TD2->getUnderlyingType());
Douglas Gregor1d9ef842010-07-07 23:08:52 +00007526
7527 return false;
7528}
7529
7530
John McCall84d87672009-12-10 09:41:52 +00007531/// Determines whether to create a using shadow decl for a particular
7532/// decl, given the set of decls existing prior to this using lookup.
7533bool Sema::CheckUsingShadowDecl(UsingDecl *Using, NamedDecl *Orig,
Richard Smithfd8634a2013-10-23 02:17:46 +00007534 const LookupResult &Previous,
7535 UsingShadowDecl *&PrevShadow) {
John McCall84d87672009-12-10 09:41:52 +00007536 // Diagnose finding a decl which is not from a base class of the
7537 // current class. We do this now because there are cases where this
7538 // function will silently decide not to build a shadow decl, which
7539 // will pre-empt further diagnostics.
7540 //
7541 // We don't need to do this in C++0x because we do the check once on
7542 // the qualifier.
7543 //
7544 // FIXME: diagnose the following if we care enough:
7545 // struct A { int foo; };
7546 // struct B : A { using A::foo; };
7547 // template <class T> struct C : A {};
7548 // template <class T> struct D : C<T> { using B::foo; } // <---
7549 // This is invalid (during instantiation) in C++03 because B::foo
7550 // resolves to the using decl in B, which is not a base class of D<T>.
7551 // We can't diagnose it immediately because C<T> is an unknown
7552 // specialization. The UsingShadowDecl in D<T> then points directly
7553 // to A::foo, which will look well-formed when we instantiate.
7554 // The right solution is to not collapse the shadow-decl chain.
Richard Smith2bf7fdb2013-01-02 11:42:31 +00007555 if (!getLangOpts().CPlusPlus11 && CurContext->isRecord()) {
John McCall84d87672009-12-10 09:41:52 +00007556 DeclContext *OrigDC = Orig->getDeclContext();
7557
7558 // Handle enums and anonymous structs.
7559 if (isa<EnumDecl>(OrigDC)) OrigDC = OrigDC->getParent();
7560 CXXRecordDecl *OrigRec = cast<CXXRecordDecl>(OrigDC);
7561 while (OrigRec->isAnonymousStructOrUnion())
7562 OrigRec = cast<CXXRecordDecl>(OrigRec->getDeclContext());
7563
7564 if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(OrigRec)) {
7565 if (OrigDC == CurContext) {
7566 Diag(Using->getLocation(),
7567 diag::err_using_decl_nested_name_specifier_is_current_class)
Douglas Gregora9d87bc2011-02-25 00:36:19 +00007568 << Using->getQualifierLoc().getSourceRange();
John McCall84d87672009-12-10 09:41:52 +00007569 Diag(Orig->getLocation(), diag::note_using_decl_target);
7570 return true;
7571 }
7572
Douglas Gregora9d87bc2011-02-25 00:36:19 +00007573 Diag(Using->getQualifierLoc().getBeginLoc(),
John McCall84d87672009-12-10 09:41:52 +00007574 diag::err_using_decl_nested_name_specifier_is_not_base_class)
Douglas Gregora9d87bc2011-02-25 00:36:19 +00007575 << Using->getQualifier()
John McCall84d87672009-12-10 09:41:52 +00007576 << cast<CXXRecordDecl>(CurContext)
Douglas Gregora9d87bc2011-02-25 00:36:19 +00007577 << Using->getQualifierLoc().getSourceRange();
John McCall84d87672009-12-10 09:41:52 +00007578 Diag(Orig->getLocation(), diag::note_using_decl_target);
7579 return true;
7580 }
7581 }
7582
7583 if (Previous.empty()) return false;
7584
7585 NamedDecl *Target = Orig;
7586 if (isa<UsingShadowDecl>(Target))
7587 Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
7588
John McCalla17e83e2009-12-11 02:33:26 +00007589 // If the target happens to be one of the previous declarations, we
7590 // don't have a conflict.
7591 //
7592 // FIXME: but we might be increasing its access, in which case we
7593 // should redeclare it.
Craig Topperc3ec1492014-05-26 06:22:03 +00007594 NamedDecl *NonTag = nullptr, *Tag = nullptr;
Richard Smithfd8634a2013-10-23 02:17:46 +00007595 bool FoundEquivalentDecl = false;
John McCalla17e83e2009-12-11 02:33:26 +00007596 for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
7597 I != E; ++I) {
7598 NamedDecl *D = (*I)->getUnderlyingDecl();
Richard Smithfd8634a2013-10-23 02:17:46 +00007599 if (IsEquivalentForUsingDecl(Context, D, Target)) {
7600 if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(*I))
7601 PrevShadow = Shadow;
7602 FoundEquivalentDecl = true;
7603 }
John McCalla17e83e2009-12-11 02:33:26 +00007604
7605 (isa<TagDecl>(D) ? Tag : NonTag) = D;
7606 }
7607
Richard Smithfd8634a2013-10-23 02:17:46 +00007608 if (FoundEquivalentDecl)
7609 return false;
7610
Alp Tokera2794f92014-01-22 07:29:52 +00007611 if (FunctionDecl *FD = Target->getAsFunction()) {
Craig Topperc3ec1492014-05-26 06:22:03 +00007612 NamedDecl *OldDecl = nullptr;
7613 switch (CheckOverload(nullptr, FD, Previous, OldDecl,
7614 /*IsForUsingDecl*/ true)) {
John McCall84d87672009-12-10 09:41:52 +00007615 case Ovl_Overload:
7616 return false;
7617
7618 case Ovl_NonFunction:
John McCalle29c5cd2009-12-10 19:51:03 +00007619 Diag(Using->getLocation(), diag::err_using_decl_conflict);
John McCall84d87672009-12-10 09:41:52 +00007620 break;
Richard Smith18819302014-02-06 01:31:33 +00007621
John McCall84d87672009-12-10 09:41:52 +00007622 // We found a decl with the exact signature.
7623 case Ovl_Match:
John McCall84d87672009-12-10 09:41:52 +00007624 // If we're in a record, we want to hide the target, so we
7625 // return true (without a diagnostic) to tell the caller not to
7626 // build a shadow decl.
7627 if (CurContext->isRecord())
7628 return true;
7629
7630 // If we're not in a record, this is an error.
John McCalle29c5cd2009-12-10 19:51:03 +00007631 Diag(Using->getLocation(), diag::err_using_decl_conflict);
John McCall84d87672009-12-10 09:41:52 +00007632 break;
7633 }
7634
7635 Diag(Target->getLocation(), diag::note_using_decl_target);
7636 Diag(OldDecl->getLocation(), diag::note_using_decl_conflict);
7637 return true;
7638 }
7639
7640 // Target is not a function.
7641
John McCall84d87672009-12-10 09:41:52 +00007642 if (isa<TagDecl>(Target)) {
7643 // No conflict between a tag and a non-tag.
7644 if (!Tag) return false;
7645
John McCalle29c5cd2009-12-10 19:51:03 +00007646 Diag(Using->getLocation(), diag::err_using_decl_conflict);
John McCall84d87672009-12-10 09:41:52 +00007647 Diag(Target->getLocation(), diag::note_using_decl_target);
7648 Diag(Tag->getLocation(), diag::note_using_decl_conflict);
7649 return true;
7650 }
7651
7652 // No conflict between a tag and a non-tag.
7653 if (!NonTag) return false;
7654
John McCalle29c5cd2009-12-10 19:51:03 +00007655 Diag(Using->getLocation(), diag::err_using_decl_conflict);
John McCall84d87672009-12-10 09:41:52 +00007656 Diag(Target->getLocation(), diag::note_using_decl_target);
7657 Diag(NonTag->getLocation(), diag::note_using_decl_conflict);
7658 return true;
7659}
7660
John McCall3f746822009-11-17 05:59:44 +00007661/// Builds a shadow declaration corresponding to a 'using' declaration.
John McCall3969e302009-12-08 07:46:18 +00007662UsingShadowDecl *Sema::BuildUsingShadowDecl(Scope *S,
John McCall3969e302009-12-08 07:46:18 +00007663 UsingDecl *UD,
Richard Smithfd8634a2013-10-23 02:17:46 +00007664 NamedDecl *Orig,
7665 UsingShadowDecl *PrevDecl) {
John McCall3f746822009-11-17 05:59:44 +00007666
7667 // If we resolved to another shadow declaration, just coalesce them.
John McCall3969e302009-12-08 07:46:18 +00007668 NamedDecl *Target = Orig;
7669 if (isa<UsingShadowDecl>(Target)) {
7670 Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
7671 assert(!isa<UsingShadowDecl>(Target) && "nested shadow declaration");
John McCall3f746822009-11-17 05:59:44 +00007672 }
Richard Smithfd8634a2013-10-23 02:17:46 +00007673
John McCall3f746822009-11-17 05:59:44 +00007674 UsingShadowDecl *Shadow
John McCall3969e302009-12-08 07:46:18 +00007675 = UsingShadowDecl::Create(Context, CurContext,
7676 UD->getLocation(), UD, Target);
John McCall3f746822009-11-17 05:59:44 +00007677 UD->addShadowDecl(Shadow);
Richard Smithfd8634a2013-10-23 02:17:46 +00007678
Douglas Gregor457104e2010-09-29 04:25:11 +00007679 Shadow->setAccess(UD->getAccess());
7680 if (Orig->isInvalidDecl() || UD->isInvalidDecl())
7681 Shadow->setInvalidDecl();
Richard Smithfd8634a2013-10-23 02:17:46 +00007682
7683 Shadow->setPreviousDecl(PrevDecl);
7684
John McCall3f746822009-11-17 05:59:44 +00007685 if (S)
John McCall3969e302009-12-08 07:46:18 +00007686 PushOnScopeChains(Shadow, S);
John McCall3f746822009-11-17 05:59:44 +00007687 else
John McCall3969e302009-12-08 07:46:18 +00007688 CurContext->addDecl(Shadow);
John McCall3f746822009-11-17 05:59:44 +00007689
John McCall3969e302009-12-08 07:46:18 +00007690
John McCall84d87672009-12-10 09:41:52 +00007691 return Shadow;
7692}
John McCall3969e302009-12-08 07:46:18 +00007693
John McCall84d87672009-12-10 09:41:52 +00007694/// Hides a using shadow declaration. This is required by the current
7695/// using-decl implementation when a resolvable using declaration in a
7696/// class is followed by a declaration which would hide or override
7697/// one or more of the using decl's targets; for example:
7698///
7699/// struct Base { void foo(int); };
7700/// struct Derived : Base {
7701/// using Base::foo;
7702/// void foo(int);
7703/// };
7704///
7705/// The governing language is C++03 [namespace.udecl]p12:
7706///
7707/// When a using-declaration brings names from a base class into a
7708/// derived class scope, member functions in the derived class
7709/// override and/or hide member functions with the same name and
7710/// parameter types in a base class (rather than conflicting).
7711///
7712/// There are two ways to implement this:
7713/// (1) optimistically create shadow decls when they're not hidden
7714/// by existing declarations, or
7715/// (2) don't create any shadow decls (or at least don't make them
7716/// visible) until we've fully parsed/instantiated the class.
7717/// The problem with (1) is that we might have to retroactively remove
7718/// a shadow decl, which requires several O(n) operations because the
7719/// decl structures are (very reasonably) not designed for removal.
7720/// (2) avoids this but is very fiddly and phase-dependent.
7721void Sema::HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow) {
John McCallda4458e2010-03-31 01:36:47 +00007722 if (Shadow->getDeclName().getNameKind() ==
7723 DeclarationName::CXXConversionFunctionName)
7724 cast<CXXRecordDecl>(Shadow->getDeclContext())->removeConversion(Shadow);
7725
John McCall84d87672009-12-10 09:41:52 +00007726 // Remove it from the DeclContext...
7727 Shadow->getDeclContext()->removeDecl(Shadow);
John McCall3969e302009-12-08 07:46:18 +00007728
John McCall84d87672009-12-10 09:41:52 +00007729 // ...and the scope, if applicable...
7730 if (S) {
John McCall48871652010-08-21 09:40:31 +00007731 S->RemoveDecl(Shadow);
John McCall84d87672009-12-10 09:41:52 +00007732 IdResolver.RemoveDecl(Shadow);
John McCall3969e302009-12-08 07:46:18 +00007733 }
7734
John McCall84d87672009-12-10 09:41:52 +00007735 // ...and the using decl.
7736 Shadow->getUsingDecl()->removeShadowDecl(Shadow);
7737
7738 // TODO: complain somehow if Shadow was used. It shouldn't
John McCallda4458e2010-03-31 01:36:47 +00007739 // be possible for this to happen, because...?
John McCall3f746822009-11-17 05:59:44 +00007740}
7741
Richard Smith09d5b3a2014-05-01 00:35:04 +00007742/// Find the base specifier for a base class with the given type.
7743static CXXBaseSpecifier *findDirectBaseWithType(CXXRecordDecl *Derived,
7744 QualType DesiredBase,
7745 bool &AnyDependentBases) {
7746 // Check whether the named type is a direct base class.
7747 CanQualType CanonicalDesiredBase = DesiredBase->getCanonicalTypeUnqualified();
7748 for (auto &Base : Derived->bases()) {
7749 CanQualType BaseType = Base.getType()->getCanonicalTypeUnqualified();
7750 if (CanonicalDesiredBase == BaseType)
7751 return &Base;
7752 if (BaseType->isDependentType())
7753 AnyDependentBases = true;
7754 }
Craig Topperc3ec1492014-05-26 06:22:03 +00007755 return nullptr;
Richard Smith09d5b3a2014-05-01 00:35:04 +00007756}
7757
Benjamin Kramer8bf44352013-07-24 15:28:33 +00007758namespace {
Kaelyn Uhrain8ec9f5f2013-07-10 17:34:22 +00007759class UsingValidatorCCC : public CorrectionCandidateCallback {
7760public:
Kaelyn Uhrain8aa8da82013-10-19 00:05:00 +00007761 UsingValidatorCCC(bool HasTypenameKeyword, bool IsInstantiation,
Richard Smith09d5b3a2014-05-01 00:35:04 +00007762 NestedNameSpecifier *NNS, CXXRecordDecl *RequireMemberOf)
Enea Zaffanellae05a3cf2013-07-22 10:54:09 +00007763 : HasTypenameKeyword(HasTypenameKeyword),
Richard Smith09d5b3a2014-05-01 00:35:04 +00007764 IsInstantiation(IsInstantiation), OldNNS(NNS),
7765 RequireMemberOf(RequireMemberOf) {}
Enea Zaffanellae05a3cf2013-07-22 10:54:09 +00007766
Craig Toppera798a9d2014-03-02 09:32:10 +00007767 bool ValidateCandidate(const TypoCorrection &Candidate) override {
Benjamin Kramer8bf44352013-07-24 15:28:33 +00007768 NamedDecl *ND = Candidate.getCorrectionDecl();
7769
7770 // Keywords are not valid here.
7771 if (!ND || isa<NamespaceDecl>(ND))
Kaelyn Uhrain8ec9f5f2013-07-10 17:34:22 +00007772 return false;
Benjamin Kramer8bf44352013-07-24 15:28:33 +00007773
7774 // Completely unqualified names are invalid for a 'using' declaration.
7775 if (Candidate.WillReplaceSpecifier() && !Candidate.getCorrectionSpecifier())
7776 return false;
7777
Richard Smith09d5b3a2014-05-01 00:35:04 +00007778 if (RequireMemberOf) {
7779 auto *FoundRecord = dyn_cast<CXXRecordDecl>(ND);
7780 if (FoundRecord && FoundRecord->isInjectedClassName()) {
7781 // No-one ever wants a using-declaration to name an injected-class-name
7782 // of a base class, unless they're declaring an inheriting constructor.
7783 ASTContext &Ctx = ND->getASTContext();
7784 if (!Ctx.getLangOpts().CPlusPlus11)
7785 return false;
7786 QualType FoundType = Ctx.getRecordType(FoundRecord);
7787
7788 // Check that the injected-class-name is named as a member of its own
7789 // type; we don't want to suggest 'using Derived::Base;', since that
7790 // means something else.
7791 NestedNameSpecifier *Specifier =
7792 Candidate.WillReplaceSpecifier()
7793 ? Candidate.getCorrectionSpecifier()
7794 : OldNNS;
7795 if (!Specifier->getAsType() ||
7796 !Ctx.hasSameType(QualType(Specifier->getAsType(), 0), FoundType))
7797 return false;
7798
7799 // Check that this inheriting constructor declaration actually names a
7800 // direct base class of the current class.
7801 bool AnyDependentBases = false;
7802 if (!findDirectBaseWithType(RequireMemberOf,
7803 Ctx.getRecordType(FoundRecord),
7804 AnyDependentBases) &&
7805 !AnyDependentBases)
7806 return false;
7807 } else {
7808 auto *RD = dyn_cast<CXXRecordDecl>(ND->getDeclContext());
7809 if (!RD || RequireMemberOf->isProvablyNotDerivedFrom(RD))
7810 return false;
7811
7812 // FIXME: Check that the base class member is accessible?
7813 }
7814 }
7815
Benjamin Kramer8bf44352013-07-24 15:28:33 +00007816 if (isa<TypeDecl>(ND))
7817 return HasTypenameKeyword || !IsInstantiation;
7818
7819 return !HasTypenameKeyword;
Kaelyn Uhrain8ec9f5f2013-07-10 17:34:22 +00007820 }
7821
7822private:
Enea Zaffanellae05a3cf2013-07-22 10:54:09 +00007823 bool HasTypenameKeyword;
Kaelyn Uhrain8ec9f5f2013-07-10 17:34:22 +00007824 bool IsInstantiation;
Richard Smith09d5b3a2014-05-01 00:35:04 +00007825 NestedNameSpecifier *OldNNS;
Richard Smith21866c32014-04-30 18:03:21 +00007826 CXXRecordDecl *RequireMemberOf;
Kaelyn Uhrain8ec9f5f2013-07-10 17:34:22 +00007827};
Benjamin Kramer8bf44352013-07-24 15:28:33 +00007828} // end anonymous namespace
Kaelyn Uhrain8ec9f5f2013-07-10 17:34:22 +00007829
John McCalle61f2ba2009-11-18 02:36:19 +00007830/// Builds a using declaration.
7831///
7832/// \param IsInstantiation - Whether this call arises from an
7833/// instantiation of an unresolved using declaration. We treat
7834/// the lookup differently for these declarations.
John McCall3f746822009-11-17 05:59:44 +00007835NamedDecl *Sema::BuildUsingDeclaration(Scope *S, AccessSpecifier AS,
7836 SourceLocation UsingLoc,
Jeffrey Yasskinc76498d2010-04-08 16:38:48 +00007837 CXXScopeSpec &SS,
Richard Smith09d5b3a2014-05-01 00:35:04 +00007838 DeclarationNameInfo NameInfo,
Anders Carlsson696a3f12009-08-28 05:40:36 +00007839 AttributeList *AttrList,
John McCalle61f2ba2009-11-18 02:36:19 +00007840 bool IsInstantiation,
Enea Zaffanellae05a3cf2013-07-22 10:54:09 +00007841 bool HasTypenameKeyword,
John McCalle61f2ba2009-11-18 02:36:19 +00007842 SourceLocation TypenameLoc) {
Anders Carlsson696a3f12009-08-28 05:40:36 +00007843 assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
Abramo Bagnara8de74e92010-08-12 11:46:03 +00007844 SourceLocation IdentLoc = NameInfo.getLoc();
Anders Carlsson696a3f12009-08-28 05:40:36 +00007845 assert(IdentLoc.isValid() && "Invalid TargetName location.");
Eli Friedman561154d2009-08-27 05:09:36 +00007846
Anders Carlssonf038fc22009-08-28 05:49:21 +00007847 // FIXME: We ignore attributes for now.
Mike Stump11289f42009-09-09 15:08:12 +00007848
Anders Carlsson59140b32009-08-28 03:16:11 +00007849 if (SS.isEmpty()) {
7850 Diag(IdentLoc, diag::err_using_requires_qualname);
Craig Topperc3ec1492014-05-26 06:22:03 +00007851 return nullptr;
Anders Carlsson59140b32009-08-28 03:16:11 +00007852 }
Mike Stump11289f42009-09-09 15:08:12 +00007853
John McCall84d87672009-12-10 09:41:52 +00007854 // Do the redeclaration lookup in the current scope.
Abramo Bagnara8de74e92010-08-12 11:46:03 +00007855 LookupResult Previous(*this, NameInfo, LookupUsingDeclName,
John McCall84d87672009-12-10 09:41:52 +00007856 ForRedeclaration);
7857 Previous.setHideTags(false);
7858 if (S) {
7859 LookupName(Previous, S);
7860
7861 // It is really dumb that we have to do this.
7862 LookupResult::Filter F = Previous.makeFilter();
7863 while (F.hasNext()) {
7864 NamedDecl *D = F.next();
7865 if (!isDeclInScope(D, CurContext, S))
7866 F.erase();
Richard Smith83e78f52014-04-11 01:03:38 +00007867 // If we found a local extern declaration that's not ordinarily visible,
7868 // and this declaration is being added to a non-block scope, ignore it.
7869 // We're only checking for scope conflicts here, not also for violations
7870 // of the linkage rules.
7871 else if (!CurContext->isFunctionOrMethod() && D->isLocalExternDecl() &&
7872 !(D->getIdentifierNamespace() & Decl::IDNS_Ordinary))
7873 F.erase();
John McCall84d87672009-12-10 09:41:52 +00007874 }
7875 F.done();
7876 } else {
7877 assert(IsInstantiation && "no scope in non-instantiation");
7878 assert(CurContext->isRecord() && "scope not record in instantiation");
7879 LookupQualifiedName(Previous, CurContext);
7880 }
7881
John McCall84d87672009-12-10 09:41:52 +00007882 // Check for invalid redeclarations.
Enea Zaffanellae05a3cf2013-07-22 10:54:09 +00007883 if (CheckUsingDeclRedeclaration(UsingLoc, HasTypenameKeyword,
7884 SS, IdentLoc, Previous))
Craig Topperc3ec1492014-05-26 06:22:03 +00007885 return nullptr;
John McCall84d87672009-12-10 09:41:52 +00007886
7887 // Check for bad qualifiers.
Richard Smith7ad0b882014-04-02 21:44:35 +00007888 if (CheckUsingDeclQualifier(UsingLoc, SS, NameInfo, IdentLoc))
Craig Topperc3ec1492014-05-26 06:22:03 +00007889 return nullptr;
John McCallb96ec562009-12-04 22:46:56 +00007890
John McCall84c16cf2009-11-12 03:15:40 +00007891 DeclContext *LookupContext = computeDeclContext(SS);
John McCallb96ec562009-12-04 22:46:56 +00007892 NamedDecl *D;
Douglas Gregora9d87bc2011-02-25 00:36:19 +00007893 NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
John McCall84c16cf2009-11-12 03:15:40 +00007894 if (!LookupContext) {
Enea Zaffanellae05a3cf2013-07-22 10:54:09 +00007895 if (HasTypenameKeyword) {
John McCallb96ec562009-12-04 22:46:56 +00007896 // FIXME: not all declaration name kinds are legal here
7897 D = UnresolvedUsingTypenameDecl::Create(Context, CurContext,
7898 UsingLoc, TypenameLoc,
Douglas Gregora9d87bc2011-02-25 00:36:19 +00007899 QualifierLoc,
Abramo Bagnara8de74e92010-08-12 11:46:03 +00007900 IdentLoc, NameInfo.getName());
John McCallb96ec562009-12-04 22:46:56 +00007901 } else {
Douglas Gregora9d87bc2011-02-25 00:36:19 +00007902 D = UnresolvedUsingValueDecl::Create(Context, CurContext, UsingLoc,
7903 QualifierLoc, NameInfo);
John McCalle61f2ba2009-11-18 02:36:19 +00007904 }
Richard Smith09d5b3a2014-05-01 00:35:04 +00007905 D->setAccess(AS);
7906 CurContext->addDecl(D);
7907 return D;
Anders Carlssonf038fc22009-08-28 05:49:21 +00007908 }
John McCallb96ec562009-12-04 22:46:56 +00007909
Richard Smith09d5b3a2014-05-01 00:35:04 +00007910 auto Build = [&](bool Invalid) {
7911 UsingDecl *UD =
7912 UsingDecl::Create(Context, CurContext, UsingLoc, QualifierLoc, NameInfo,
7913 HasTypenameKeyword);
7914 UD->setAccess(AS);
7915 CurContext->addDecl(UD);
7916 UD->setInvalidDecl(Invalid);
John McCall3969e302009-12-08 07:46:18 +00007917 return UD;
Richard Smith09d5b3a2014-05-01 00:35:04 +00007918 };
7919 auto BuildInvalid = [&]{ return Build(true); };
7920 auto BuildValid = [&]{ return Build(false); };
7921
7922 if (RequireCompleteDeclContext(SS, LookupContext))
7923 return BuildInvalid();
Anders Carlsson59140b32009-08-28 03:16:11 +00007924
Richard Smith23d55872012-04-02 01:30:27 +00007925 // The normal rules do not apply to inheriting constructor declarations.
Sebastian Redl08905022011-02-05 19:23:19 +00007926 if (NameInfo.getName().getNameKind() == DeclarationName::CXXConstructorName) {
Richard Smith09d5b3a2014-05-01 00:35:04 +00007927 UsingDecl *UD = BuildValid();
7928 CheckInheritingConstructorUsingDecl(UD);
Sebastian Redl08905022011-02-05 19:23:19 +00007929 return UD;
7930 }
7931
7932 // Otherwise, look up the target name.
John McCall3969e302009-12-08 07:46:18 +00007933
Abramo Bagnara8de74e92010-08-12 11:46:03 +00007934 LookupResult R(*this, NameInfo, LookupOrdinaryName);
John McCalle61f2ba2009-11-18 02:36:19 +00007935
John McCall3969e302009-12-08 07:46:18 +00007936 // Unlike most lookups, we don't always want to hide tag
7937 // declarations: tag names are visible through the using declaration
7938 // even if hidden by ordinary names, *except* in a dependent context
7939 // where it's important for the sanity of two-phase lookup.
John McCalle61f2ba2009-11-18 02:36:19 +00007940 if (!IsInstantiation)
7941 R.setHideTags(false);
John McCall3f746822009-11-17 05:59:44 +00007942
John McCall5dadb652012-04-07 03:04:20 +00007943 // For the purposes of this lookup, we have a base object type
7944 // equal to that of the current context.
7945 if (CurContext->isRecord()) {
7946 R.setBaseObjectType(
7947 Context.getTypeDeclType(cast<CXXRecordDecl>(CurContext)));
7948 }
7949
John McCall27b18f82009-11-17 02:14:36 +00007950 LookupQualifiedName(R, LookupContext);
Mike Stump11289f42009-09-09 15:08:12 +00007951
Kaelyn Uhrain8ec9f5f2013-07-10 17:34:22 +00007952 // Try to correct typos if possible.
John McCall9f3059a2009-10-09 21:13:30 +00007953 if (R.empty()) {
Kaelyn Takata89c881b2014-10-27 18:07:29 +00007954 if (TypoCorrection Corrected = CorrectTypo(
7955 R.getLookupNameInfo(), R.getLookupKind(), S, &SS,
7956 llvm::make_unique<UsingValidatorCCC>(
7957 HasTypenameKeyword, IsInstantiation, SS.getScopeRep(),
7958 dyn_cast<CXXRecordDecl>(CurContext)),
7959 CTK_ErrorRecovery)) {
Kaelyn Uhrain8ec9f5f2013-07-10 17:34:22 +00007960 // We reject any correction for which ND would be NULL.
7961 NamedDecl *ND = Corrected.getCorrectionDecl();
Richard Smith09d5b3a2014-05-01 00:35:04 +00007962
Richard Smithf9b15102013-08-17 00:46:16 +00007963 // We reject candidates where DroppedSpecifier == true, hence the
Kaelyn Uhrain8ec9f5f2013-07-10 17:34:22 +00007964 // literal '0' below.
Richard Smithf9b15102013-08-17 00:46:16 +00007965 diagnoseTypo(Corrected, PDiag(diag::err_no_member_suggest)
7966 << NameInfo.getName() << LookupContext << 0
7967 << SS.getRange());
Richard Smith09d5b3a2014-05-01 00:35:04 +00007968
7969 // If we corrected to an inheriting constructor, handle it as one.
7970 auto *RD = dyn_cast<CXXRecordDecl>(ND);
7971 if (RD && RD->isInjectedClassName()) {
7972 // Fix up the information we'll use to build the using declaration.
7973 if (Corrected.WillReplaceSpecifier()) {
7974 NestedNameSpecifierLocBuilder Builder;
7975 Builder.MakeTrivial(Context, Corrected.getCorrectionSpecifier(),
7976 QualifierLoc.getSourceRange());
7977 QualifierLoc = Builder.getWithLocInContext(Context);
7978 }
7979
7980 NameInfo.setName(Context.DeclarationNames.getCXXConstructorName(
7981 Context.getCanonicalType(Context.getRecordType(RD))));
Craig Topperc3ec1492014-05-26 06:22:03 +00007982 NameInfo.setNamedTypeInfo(nullptr);
Richard Smith09d5b3a2014-05-01 00:35:04 +00007983
7984 // Build it and process it as an inheriting constructor.
7985 UsingDecl *UD = BuildValid();
7986 CheckInheritingConstructorUsingDecl(UD);
7987 return UD;
7988 }
7989
7990 // FIXME: Pick up all the declarations if we found an overloaded function.
7991 R.setLookupName(Corrected.getCorrection());
7992 R.addDecl(ND);
Kaelyn Uhrain8ec9f5f2013-07-10 17:34:22 +00007993 } else {
Richard Smithf9b15102013-08-17 00:46:16 +00007994 Diag(IdentLoc, diag::err_no_member)
Kaelyn Uhrain8ec9f5f2013-07-10 17:34:22 +00007995 << NameInfo.getName() << LookupContext << SS.getRange();
Richard Smith09d5b3a2014-05-01 00:35:04 +00007996 return BuildInvalid();
Kaelyn Uhrain8ec9f5f2013-07-10 17:34:22 +00007997 }
Douglas Gregorfec52632009-06-20 00:51:54 +00007998 }
7999
Richard Smith09d5b3a2014-05-01 00:35:04 +00008000 if (R.isAmbiguous())
8001 return BuildInvalid();
Mike Stump11289f42009-09-09 15:08:12 +00008002
Enea Zaffanellae05a3cf2013-07-22 10:54:09 +00008003 if (HasTypenameKeyword) {
John McCalle61f2ba2009-11-18 02:36:19 +00008004 // If we asked for a typename and got a non-type decl, error out.
John McCallb96ec562009-12-04 22:46:56 +00008005 if (!R.getAsSingle<TypeDecl>()) {
John McCalle61f2ba2009-11-18 02:36:19 +00008006 Diag(IdentLoc, diag::err_using_typename_non_type);
8007 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I)
8008 Diag((*I)->getUnderlyingDecl()->getLocation(),
8009 diag::note_using_decl_target);
Richard Smith09d5b3a2014-05-01 00:35:04 +00008010 return BuildInvalid();
John McCalle61f2ba2009-11-18 02:36:19 +00008011 }
8012 } else {
8013 // If we asked for a non-typename and we got a type, error out,
8014 // but only if this is an instantiation of an unresolved using
8015 // decl. Otherwise just silently find the type name.
John McCallb96ec562009-12-04 22:46:56 +00008016 if (IsInstantiation && R.getAsSingle<TypeDecl>()) {
John McCalle61f2ba2009-11-18 02:36:19 +00008017 Diag(IdentLoc, diag::err_using_dependent_value_is_type);
8018 Diag(R.getFoundDecl()->getLocation(), diag::note_using_decl_target);
Richard Smith09d5b3a2014-05-01 00:35:04 +00008019 return BuildInvalid();
John McCalle61f2ba2009-11-18 02:36:19 +00008020 }
Anders Carlsson59140b32009-08-28 03:16:11 +00008021 }
8022
Anders Carlsson5a9c5ac2009-08-28 03:35:18 +00008023 // C++0x N2914 [namespace.udecl]p6:
8024 // A using-declaration shall not name a namespace.
John McCallb96ec562009-12-04 22:46:56 +00008025 if (R.getAsSingle<NamespaceDecl>()) {
Anders Carlsson5a9c5ac2009-08-28 03:35:18 +00008026 Diag(IdentLoc, diag::err_using_decl_can_not_refer_to_namespace)
8027 << SS.getRange();
Richard Smith09d5b3a2014-05-01 00:35:04 +00008028 return BuildInvalid();
Anders Carlsson5a9c5ac2009-08-28 03:35:18 +00008029 }
Mike Stump11289f42009-09-09 15:08:12 +00008030
Richard Smith09d5b3a2014-05-01 00:35:04 +00008031 UsingDecl *UD = BuildValid();
John McCall84d87672009-12-10 09:41:52 +00008032 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {
Craig Topperc3ec1492014-05-26 06:22:03 +00008033 UsingShadowDecl *PrevDecl = nullptr;
Richard Smithfd8634a2013-10-23 02:17:46 +00008034 if (!CheckUsingShadowDecl(UD, *I, Previous, PrevDecl))
8035 BuildUsingShadowDecl(S, UD, *I, PrevDecl);
John McCall84d87672009-12-10 09:41:52 +00008036 }
John McCall3f746822009-11-17 05:59:44 +00008037
8038 return UD;
Douglas Gregorfec52632009-06-20 00:51:54 +00008039}
8040
Sebastian Redl08905022011-02-05 19:23:19 +00008041/// Additional checks for a using declaration referring to a constructor name.
Richard Smith23d55872012-04-02 01:30:27 +00008042bool Sema::CheckInheritingConstructorUsingDecl(UsingDecl *UD) {
Enea Zaffanellae05a3cf2013-07-22 10:54:09 +00008043 assert(!UD->hasTypename() && "expecting a constructor name");
Sebastian Redl08905022011-02-05 19:23:19 +00008044
Douglas Gregora9d87bc2011-02-25 00:36:19 +00008045 const Type *SourceType = UD->getQualifier()->getAsType();
Sebastian Redl08905022011-02-05 19:23:19 +00008046 assert(SourceType &&
8047 "Using decl naming constructor doesn't have type in scope spec.");
8048 CXXRecordDecl *TargetClass = cast<CXXRecordDecl>(CurContext);
8049
8050 // Check whether the named type is a direct base class.
Richard Smith09d5b3a2014-05-01 00:35:04 +00008051 bool AnyDependentBases = false;
8052 auto *Base = findDirectBaseWithType(TargetClass, QualType(SourceType, 0),
8053 AnyDependentBases);
8054 if (!Base && !AnyDependentBases) {
Enea Zaffanellae05a3cf2013-07-22 10:54:09 +00008055 Diag(UD->getUsingLoc(),
Sebastian Redl08905022011-02-05 19:23:19 +00008056 diag::err_using_decl_constructor_not_in_direct_base)
8057 << UD->getNameInfo().getSourceRange()
8058 << QualType(SourceType, 0) << TargetClass;
Richard Smith09d5b3a2014-05-01 00:35:04 +00008059 UD->setInvalidDecl();
Sebastian Redl08905022011-02-05 19:23:19 +00008060 return true;
8061 }
8062
Richard Smith09d5b3a2014-05-01 00:35:04 +00008063 if (Base)
8064 Base->setInheritConstructors();
Sebastian Redl08905022011-02-05 19:23:19 +00008065
8066 return false;
8067}
8068
John McCall84d87672009-12-10 09:41:52 +00008069/// Checks that the given using declaration is not an invalid
8070/// redeclaration. Note that this is checking only for the using decl
8071/// itself, not for any ill-formedness among the UsingShadowDecls.
8072bool Sema::CheckUsingDeclRedeclaration(SourceLocation UsingLoc,
Enea Zaffanellae05a3cf2013-07-22 10:54:09 +00008073 bool HasTypenameKeyword,
John McCall84d87672009-12-10 09:41:52 +00008074 const CXXScopeSpec &SS,
8075 SourceLocation NameLoc,
8076 const LookupResult &Prev) {
8077 // C++03 [namespace.udecl]p8:
8078 // C++0x [namespace.udecl]p10:
8079 // A using-declaration is a declaration and can therefore be used
8080 // repeatedly where (and only where) multiple declarations are
8081 // allowed.
Douglas Gregor4b718ee2010-05-06 23:31:27 +00008082 //
John McCall032092f2010-11-29 18:01:58 +00008083 // That's in non-member contexts.
8084 if (!CurContext->getRedeclContext()->isRecord())
John McCall84d87672009-12-10 09:41:52 +00008085 return false;
8086
Aaron Ballman4a979672014-01-03 13:56:08 +00008087 NestedNameSpecifier *Qual = SS.getScopeRep();
John McCall84d87672009-12-10 09:41:52 +00008088
8089 for (LookupResult::iterator I = Prev.begin(), E = Prev.end(); I != E; ++I) {
8090 NamedDecl *D = *I;
8091
8092 bool DTypename;
8093 NestedNameSpecifier *DQual;
8094 if (UsingDecl *UD = dyn_cast<UsingDecl>(D)) {
Enea Zaffanellae05a3cf2013-07-22 10:54:09 +00008095 DTypename = UD->hasTypename();
Douglas Gregora9d87bc2011-02-25 00:36:19 +00008096 DQual = UD->getQualifier();
John McCall84d87672009-12-10 09:41:52 +00008097 } else if (UnresolvedUsingValueDecl *UD
8098 = dyn_cast<UnresolvedUsingValueDecl>(D)) {
8099 DTypename = false;
Douglas Gregora9d87bc2011-02-25 00:36:19 +00008100 DQual = UD->getQualifier();
John McCall84d87672009-12-10 09:41:52 +00008101 } else if (UnresolvedUsingTypenameDecl *UD
8102 = dyn_cast<UnresolvedUsingTypenameDecl>(D)) {
8103 DTypename = true;
Douglas Gregora9d87bc2011-02-25 00:36:19 +00008104 DQual = UD->getQualifier();
John McCall84d87672009-12-10 09:41:52 +00008105 } else continue;
8106
8107 // using decls differ if one says 'typename' and the other doesn't.
8108 // FIXME: non-dependent using decls?
Enea Zaffanellae05a3cf2013-07-22 10:54:09 +00008109 if (HasTypenameKeyword != DTypename) continue;
John McCall84d87672009-12-10 09:41:52 +00008110
8111 // using decls differ if they name different scopes (but note that
8112 // template instantiation can cause this check to trigger when it
8113 // didn't before instantiation).
8114 if (Context.getCanonicalNestedNameSpecifier(Qual) !=
8115 Context.getCanonicalNestedNameSpecifier(DQual))
8116 continue;
8117
8118 Diag(NameLoc, diag::err_using_decl_redeclaration) << SS.getRange();
John McCalle29c5cd2009-12-10 19:51:03 +00008119 Diag(D->getLocation(), diag::note_using_decl) << 1;
John McCall84d87672009-12-10 09:41:52 +00008120 return true;
8121 }
8122
8123 return false;
8124}
8125
John McCall3969e302009-12-08 07:46:18 +00008126
John McCallb96ec562009-12-04 22:46:56 +00008127/// Checks that the given nested-name qualifier used in a using decl
8128/// in the current context is appropriately related to the current
8129/// scope. If an error is found, diagnoses it and returns true.
8130bool Sema::CheckUsingDeclQualifier(SourceLocation UsingLoc,
8131 const CXXScopeSpec &SS,
Richard Smith7ad0b882014-04-02 21:44:35 +00008132 const DeclarationNameInfo &NameInfo,
John McCallb96ec562009-12-04 22:46:56 +00008133 SourceLocation NameLoc) {
John McCall3969e302009-12-08 07:46:18 +00008134 DeclContext *NamedContext = computeDeclContext(SS);
John McCallb96ec562009-12-04 22:46:56 +00008135
John McCall3969e302009-12-08 07:46:18 +00008136 if (!CurContext->isRecord()) {
8137 // C++03 [namespace.udecl]p3:
8138 // C++0x [namespace.udecl]p8:
8139 // A using-declaration for a class member shall be a member-declaration.
8140
8141 // If we weren't able to compute a valid scope, it must be a
8142 // dependent class scope.
8143 if (!NamedContext || NamedContext->isRecord()) {
Richard Smith7ad0b882014-04-02 21:44:35 +00008144 auto *RD = dyn_cast<CXXRecordDecl>(NamedContext);
8145 if (RD && RequireCompleteDeclContext(const_cast<CXXScopeSpec&>(SS), RD))
Craig Topperc3ec1492014-05-26 06:22:03 +00008146 RD = nullptr;
Richard Smith7ad0b882014-04-02 21:44:35 +00008147
John McCall3969e302009-12-08 07:46:18 +00008148 Diag(NameLoc, diag::err_using_decl_can_not_refer_to_class_member)
8149 << SS.getRange();
Richard Smith7ad0b882014-04-02 21:44:35 +00008150
8151 // If we have a complete, non-dependent source type, try to suggest a
8152 // way to get the same effect.
8153 if (!RD)
8154 return true;
8155
8156 // Find what this using-declaration was referring to.
8157 LookupResult R(*this, NameInfo, LookupOrdinaryName);
8158 R.setHideTags(false);
8159 R.suppressDiagnostics();
8160 LookupQualifiedName(R, RD);
8161
8162 if (R.getAsSingle<TypeDecl>()) {
8163 if (getLangOpts().CPlusPlus11) {
8164 // Convert 'using X::Y;' to 'using Y = X::Y;'.
8165 Diag(SS.getBeginLoc(), diag::note_using_decl_class_member_workaround)
8166 << 0 // alias declaration
8167 << FixItHint::CreateInsertion(SS.getBeginLoc(),
8168 NameInfo.getName().getAsString() +
8169 " = ");
8170 } else {
8171 // Convert 'using X::Y;' to 'typedef X::Y Y;'.
8172 SourceLocation InsertLoc =
8173 PP.getLocForEndOfToken(NameInfo.getLocEnd());
8174 Diag(InsertLoc, diag::note_using_decl_class_member_workaround)
8175 << 1 // typedef declaration
8176 << FixItHint::CreateReplacement(UsingLoc, "typedef")
8177 << FixItHint::CreateInsertion(
8178 InsertLoc, " " + NameInfo.getName().getAsString());
8179 }
8180 } else if (R.getAsSingle<VarDecl>()) {
8181 // Don't provide a fixit outside C++11 mode; we don't want to suggest
8182 // repeating the type of the static data member here.
8183 FixItHint FixIt;
8184 if (getLangOpts().CPlusPlus11) {
8185 // Convert 'using X::Y;' to 'auto &Y = X::Y;'.
8186 FixIt = FixItHint::CreateReplacement(
8187 UsingLoc, "auto &" + NameInfo.getName().getAsString() + " = ");
8188 }
8189
8190 Diag(UsingLoc, diag::note_using_decl_class_member_workaround)
8191 << 2 // reference declaration
8192 << FixIt;
8193 }
John McCall3969e302009-12-08 07:46:18 +00008194 return true;
8195 }
8196
8197 // Otherwise, everything is known to be fine.
8198 return false;
8199 }
8200
8201 // The current scope is a record.
8202
8203 // If the named context is dependent, we can't decide much.
8204 if (!NamedContext) {
8205 // FIXME: in C++0x, we can diagnose if we can prove that the
8206 // nested-name-specifier does not refer to a base class, which is
8207 // still possible in some cases.
8208
8209 // Otherwise we have to conservatively report that things might be
8210 // okay.
8211 return false;
8212 }
8213
8214 if (!NamedContext->isRecord()) {
8215 // Ideally this would point at the last name in the specifier,
8216 // but we don't have that level of source info.
8217 Diag(SS.getRange().getBegin(),
8218 diag::err_using_decl_nested_name_specifier_is_not_class)
Aaron Ballman5fe6c802014-01-03 13:45:46 +00008219 << SS.getScopeRep() << SS.getRange();
John McCall3969e302009-12-08 07:46:18 +00008220 return true;
8221 }
8222
Douglas Gregor7c842292010-12-21 07:41:49 +00008223 if (!NamedContext->isDependentContext() &&
8224 RequireCompleteDeclContext(const_cast<CXXScopeSpec&>(SS), NamedContext))
8225 return true;
8226
Richard Smith2bf7fdb2013-01-02 11:42:31 +00008227 if (getLangOpts().CPlusPlus11) {
John McCall3969e302009-12-08 07:46:18 +00008228 // C++0x [namespace.udecl]p3:
8229 // In a using-declaration used as a member-declaration, the
8230 // nested-name-specifier shall name a base class of the class
8231 // being defined.
8232
8233 if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(
8234 cast<CXXRecordDecl>(NamedContext))) {
8235 if (CurContext == NamedContext) {
8236 Diag(NameLoc,
8237 diag::err_using_decl_nested_name_specifier_is_current_class)
8238 << SS.getRange();
8239 return true;
8240 }
8241
8242 Diag(SS.getRange().getBegin(),
8243 diag::err_using_decl_nested_name_specifier_is_not_base_class)
Aaron Ballman4a979672014-01-03 13:56:08 +00008244 << SS.getScopeRep()
John McCall3969e302009-12-08 07:46:18 +00008245 << cast<CXXRecordDecl>(CurContext)
8246 << SS.getRange();
8247 return true;
8248 }
8249
8250 return false;
8251 }
8252
8253 // C++03 [namespace.udecl]p4:
8254 // A using-declaration used as a member-declaration shall refer
8255 // to a member of a base class of the class being defined [etc.].
8256
8257 // Salient point: SS doesn't have to name a base class as long as
8258 // lookup only finds members from base classes. Therefore we can
8259 // diagnose here only if we can prove that that can't happen,
8260 // i.e. if the class hierarchies provably don't intersect.
8261
8262 // TODO: it would be nice if "definitely valid" results were cached
8263 // in the UsingDecl and UsingShadowDecl so that these checks didn't
8264 // need to be repeated.
8265
8266 struct UserData {
Benjamin Kramer3adbe1c2012-02-23 16:06:01 +00008267 llvm::SmallPtrSet<const CXXRecordDecl*, 4> Bases;
John McCall3969e302009-12-08 07:46:18 +00008268
8269 static bool collect(const CXXRecordDecl *Base, void *OpaqueData) {
8270 UserData *Data = reinterpret_cast<UserData*>(OpaqueData);
8271 Data->Bases.insert(Base);
8272 return true;
8273 }
8274
8275 bool hasDependentBases(const CXXRecordDecl *Class) {
8276 return !Class->forallBases(collect, this);
8277 }
8278
8279 /// Returns true if the base is dependent or is one of the
8280 /// accumulated base classes.
8281 static bool doesNotContain(const CXXRecordDecl *Base, void *OpaqueData) {
8282 UserData *Data = reinterpret_cast<UserData*>(OpaqueData);
8283 return !Data->Bases.count(Base);
8284 }
8285
8286 bool mightShareBases(const CXXRecordDecl *Class) {
8287 return Bases.count(Class) || !Class->forallBases(doesNotContain, this);
8288 }
8289 };
8290
8291 UserData Data;
8292
8293 // Returns false if we find a dependent base.
8294 if (Data.hasDependentBases(cast<CXXRecordDecl>(CurContext)))
8295 return false;
8296
8297 // Returns false if the class has a dependent base or if it or one
8298 // of its bases is present in the base set of the current context.
8299 if (Data.mightShareBases(cast<CXXRecordDecl>(NamedContext)))
8300 return false;
8301
8302 Diag(SS.getRange().getBegin(),
8303 diag::err_using_decl_nested_name_specifier_is_not_base_class)
Aaron Ballman4a979672014-01-03 13:56:08 +00008304 << SS.getScopeRep()
John McCall3969e302009-12-08 07:46:18 +00008305 << cast<CXXRecordDecl>(CurContext)
8306 << SS.getRange();
8307
8308 return true;
John McCallb96ec562009-12-04 22:46:56 +00008309}
8310
Richard Smithdda56e42011-04-15 14:24:37 +00008311Decl *Sema::ActOnAliasDeclaration(Scope *S,
8312 AccessSpecifier AS,
Richard Smith3f1b5d02011-05-05 21:57:07 +00008313 MultiTemplateParamsArg TemplateParamLists,
Richard Smithdda56e42011-04-15 14:24:37 +00008314 SourceLocation UsingLoc,
8315 UnqualifiedId &Name,
Richard Smith54ecd982013-02-20 19:22:51 +00008316 AttributeList *AttrList,
Richard Smithdda56e42011-04-15 14:24:37 +00008317 TypeResult Type) {
Richard Smith3f1b5d02011-05-05 21:57:07 +00008318 // Skip up to the relevant declaration scope.
8319 while (S->getFlags() & Scope::TemplateParamScope)
8320 S = S->getParent();
Richard Smithdda56e42011-04-15 14:24:37 +00008321 assert((S->getFlags() & Scope::DeclScope) &&
8322 "got alias-declaration outside of declaration scope");
8323
8324 if (Type.isInvalid())
Craig Topperc3ec1492014-05-26 06:22:03 +00008325 return nullptr;
Richard Smithdda56e42011-04-15 14:24:37 +00008326
8327 bool Invalid = false;
8328 DeclarationNameInfo NameInfo = GetNameFromUnqualifiedId(Name);
Craig Topperc3ec1492014-05-26 06:22:03 +00008329 TypeSourceInfo *TInfo = nullptr;
Nick Lewycky82e47802011-05-02 01:07:19 +00008330 GetTypeFromParser(Type.get(), &TInfo);
Richard Smithdda56e42011-04-15 14:24:37 +00008331
8332 if (DiagnoseClassNameShadow(CurContext, NameInfo))
Craig Topperc3ec1492014-05-26 06:22:03 +00008333 return nullptr;
Richard Smithdda56e42011-04-15 14:24:37 +00008334
8335 if (DiagnoseUnexpandedParameterPack(Name.StartLocation, TInfo,
Richard Smith3f1b5d02011-05-05 21:57:07 +00008336 UPPC_DeclarationType)) {
Richard Smithdda56e42011-04-15 14:24:37 +00008337 Invalid = true;
Richard Smith3f1b5d02011-05-05 21:57:07 +00008338 TInfo = Context.getTrivialTypeSourceInfo(Context.IntTy,
8339 TInfo->getTypeLoc().getBeginLoc());
8340 }
Richard Smithdda56e42011-04-15 14:24:37 +00008341
8342 LookupResult Previous(*this, NameInfo, LookupOrdinaryName, ForRedeclaration);
8343 LookupName(Previous, S);
8344
8345 // Warn about shadowing the name of a template parameter.
8346 if (Previous.isSingleResult() &&
8347 Previous.getFoundDecl()->isTemplateParameter()) {
Douglas Gregorf4ef4d22011-10-20 17:58:49 +00008348 DiagnoseTemplateParameterShadow(Name.StartLocation,Previous.getFoundDecl());
Richard Smithdda56e42011-04-15 14:24:37 +00008349 Previous.clear();
8350 }
8351
8352 assert(Name.Kind == UnqualifiedId::IK_Identifier &&
8353 "name in alias declaration must be an identifier");
8354 TypeAliasDecl *NewTD = TypeAliasDecl::Create(Context, CurContext, UsingLoc,
8355 Name.StartLocation,
8356 Name.Identifier, TInfo);
8357
8358 NewTD->setAccess(AS);
8359
8360 if (Invalid)
8361 NewTD->setInvalidDecl();
8362
Richard Smith54ecd982013-02-20 19:22:51 +00008363 ProcessDeclAttributeList(S, NewTD, AttrList);
8364
Richard Smith3f1b5d02011-05-05 21:57:07 +00008365 CheckTypedefForVariablyModifiedType(S, NewTD);
8366 Invalid |= NewTD->isInvalidDecl();
8367
Richard Smithdda56e42011-04-15 14:24:37 +00008368 bool Redeclaration = false;
Richard Smith3f1b5d02011-05-05 21:57:07 +00008369
8370 NamedDecl *NewND;
8371 if (TemplateParamLists.size()) {
Craig Topperc3ec1492014-05-26 06:22:03 +00008372 TypeAliasTemplateDecl *OldDecl = nullptr;
8373 TemplateParameterList *OldTemplateParams = nullptr;
Richard Smith3f1b5d02011-05-05 21:57:07 +00008374
8375 if (TemplateParamLists.size() != 1) {
8376 Diag(UsingLoc, diag::err_alias_template_extra_headers)
Benjamin Kramer62b95d82012-08-23 21:35:17 +00008377 << SourceRange(TemplateParamLists[1]->getTemplateLoc(),
8378 TemplateParamLists[TemplateParamLists.size()-1]->getRAngleLoc());
Richard Smith3f1b5d02011-05-05 21:57:07 +00008379 }
Benjamin Kramer62b95d82012-08-23 21:35:17 +00008380 TemplateParameterList *TemplateParams = TemplateParamLists[0];
Richard Smith3f1b5d02011-05-05 21:57:07 +00008381
8382 // Only consider previous declarations in the same scope.
8383 FilterLookupForScope(Previous, CurContext, S, /*ConsiderLinkage*/false,
8384 /*ExplicitInstantiationOrSpecialization*/false);
8385 if (!Previous.empty()) {
8386 Redeclaration = true;
8387
8388 OldDecl = Previous.getAsSingle<TypeAliasTemplateDecl>();
8389 if (!OldDecl && !Invalid) {
8390 Diag(UsingLoc, diag::err_redefinition_different_kind)
8391 << Name.Identifier;
8392
8393 NamedDecl *OldD = Previous.getRepresentativeDecl();
8394 if (OldD->getLocation().isValid())
8395 Diag(OldD->getLocation(), diag::note_previous_definition);
8396
8397 Invalid = true;
8398 }
8399
8400 if (!Invalid && OldDecl && !OldDecl->isInvalidDecl()) {
8401 if (TemplateParameterListsAreEqual(TemplateParams,
8402 OldDecl->getTemplateParameters(),
8403 /*Complain=*/true,
8404 TPL_TemplateMatch))
8405 OldTemplateParams = OldDecl->getTemplateParameters();
8406 else
8407 Invalid = true;
8408
8409 TypeAliasDecl *OldTD = OldDecl->getTemplatedDecl();
8410 if (!Invalid &&
8411 !Context.hasSameType(OldTD->getUnderlyingType(),
8412 NewTD->getUnderlyingType())) {
8413 // FIXME: The C++0x standard does not clearly say this is ill-formed,
8414 // but we can't reasonably accept it.
8415 Diag(NewTD->getLocation(), diag::err_redefinition_different_typedef)
8416 << 2 << NewTD->getUnderlyingType() << OldTD->getUnderlyingType();
8417 if (OldTD->getLocation().isValid())
8418 Diag(OldTD->getLocation(), diag::note_previous_definition);
8419 Invalid = true;
8420 }
8421 }
8422 }
8423
8424 // Merge any previous default template arguments into our parameters,
8425 // and check the parameter list.
8426 if (CheckTemplateParameterList(TemplateParams, OldTemplateParams,
8427 TPC_TypeAliasTemplate))
Craig Topperc3ec1492014-05-26 06:22:03 +00008428 return nullptr;
Richard Smith3f1b5d02011-05-05 21:57:07 +00008429
8430 TypeAliasTemplateDecl *NewDecl =
8431 TypeAliasTemplateDecl::Create(Context, CurContext, UsingLoc,
8432 Name.Identifier, TemplateParams,
8433 NewTD);
Richard Smith43ccec8e2014-08-26 03:52:16 +00008434 NewTD->setDescribedAliasTemplate(NewDecl);
Richard Smith3f1b5d02011-05-05 21:57:07 +00008435
8436 NewDecl->setAccess(AS);
8437
8438 if (Invalid)
8439 NewDecl->setInvalidDecl();
8440 else if (OldDecl)
Rafael Espindola8db352d2013-10-17 15:37:26 +00008441 NewDecl->setPreviousDecl(OldDecl);
Richard Smith3f1b5d02011-05-05 21:57:07 +00008442
8443 NewND = NewDecl;
8444 } else {
8445 ActOnTypedefNameDecl(S, CurContext, NewTD, Previous, Redeclaration);
8446 NewND = NewTD;
8447 }
Richard Smithdda56e42011-04-15 14:24:37 +00008448
8449 if (!Redeclaration)
Richard Smith3f1b5d02011-05-05 21:57:07 +00008450 PushOnScopeChains(NewND, S);
Richard Smithdda56e42011-04-15 14:24:37 +00008451
Dmitri Gribenko7f4b3772012-08-02 20:49:51 +00008452 ActOnDocumentableDecl(NewND);
Richard Smith3f1b5d02011-05-05 21:57:07 +00008453 return NewND;
Richard Smithdda56e42011-04-15 14:24:37 +00008454}
8455
Richard Smithf4634362014-09-03 23:11:22 +00008456Decl *Sema::ActOnNamespaceAliasDef(Scope *S, SourceLocation NamespaceLoc,
8457 SourceLocation AliasLoc,
8458 IdentifierInfo *Alias, CXXScopeSpec &SS,
8459 SourceLocation IdentLoc,
8460 IdentifierInfo *Ident) {
Mike Stump11289f42009-09-09 15:08:12 +00008461
Anders Carlssonbb1e4722009-03-28 23:53:49 +00008462 // Lookup the namespace name.
John McCall27b18f82009-11-17 02:14:36 +00008463 LookupResult R(*this, Ident, IdentLoc, LookupNamespaceName);
8464 LookupParsedName(R, S, &SS);
Anders Carlssonbb1e4722009-03-28 23:53:49 +00008465
John McCall27b18f82009-11-17 02:14:36 +00008466 if (R.isAmbiguous())
Craig Topperc3ec1492014-05-26 06:22:03 +00008467 return nullptr;
Mike Stump11289f42009-09-09 15:08:12 +00008468
John McCall9f3059a2009-10-09 21:13:30 +00008469 if (R.empty()) {
Douglas Gregorc2fa1692011-06-28 16:20:02 +00008470 if (!TryNamespaceTypoCorrection(*this, R, S, SS, IdentLoc, Ident)) {
Richard Smitha9746882012-04-05 23:13:23 +00008471 Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
Craig Topperc3ec1492014-05-26 06:22:03 +00008472 return nullptr;
Douglas Gregor9629e9a2010-06-29 18:55:19 +00008473 }
Anders Carlssonac2c9652009-03-28 06:42:02 +00008474 }
Richard Smithf4634362014-09-03 23:11:22 +00008475 assert(!R.isAmbiguous() && !R.empty());
8476
8477 // Check if we have a previous declaration with the same name.
8478 NamedDecl *PrevDecl = LookupSingleName(S, Alias, AliasLoc, LookupOrdinaryName,
8479 ForRedeclaration);
8480 if (PrevDecl && !isDeclInScope(PrevDecl, CurContext, S))
8481 PrevDecl = nullptr;
8482
8483 if (PrevDecl) {
8484 if (NamespaceAliasDecl *AD = dyn_cast<NamespaceAliasDecl>(PrevDecl)) {
8485 // We already have an alias with the same name that points to the same
8486 // namespace; check that it matches.
8487 if (!AD->getNamespace()->Equals(getNamespaceDecl(R.getFoundDecl()))) {
8488 Diag(AliasLoc, diag::err_redefinition_different_namespace_alias)
8489 << Alias;
8490 Diag(PrevDecl->getLocation(), diag::note_previous_namespace_alias)
8491 << AD->getNamespace();
8492 return nullptr;
8493 }
8494 } else {
8495 unsigned DiagID = isa<NamespaceDecl>(PrevDecl)
8496 ? diag::err_redefinition
8497 : diag::err_redefinition_different_kind;
8498 Diag(AliasLoc, DiagID) << Alias;
8499 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
8500 return nullptr;
8501 }
8502 }
Mike Stump11289f42009-09-09 15:08:12 +00008503
Fariborz Jahanian423a81f2009-06-19 19:55:27 +00008504 NamespaceAliasDecl *AliasDecl =
Mike Stump11289f42009-09-09 15:08:12 +00008505 NamespaceAliasDecl::Create(Context, CurContext, NamespaceLoc, AliasLoc,
Douglas Gregorc05ba2e2011-02-25 17:08:07 +00008506 Alias, SS.getWithLocInContext(Context),
John McCall9f3059a2009-10-09 21:13:30 +00008507 IdentLoc, R.getFoundDecl());
Richard Smithf4634362014-09-03 23:11:22 +00008508 if (PrevDecl)
8509 AliasDecl->setPreviousDecl(cast<NamespaceAliasDecl>(PrevDecl));
Mike Stump11289f42009-09-09 15:08:12 +00008510
John McCalld8d0d432010-02-16 06:53:13 +00008511 PushOnScopeChains(AliasDecl, S);
John McCall48871652010-08-21 09:40:31 +00008512 return AliasDecl;
Anders Carlsson9205d552009-03-28 05:27:17 +00008513}
8514
Alexis Hunt6d5b96c2011-05-10 00:49:42 +00008515Sema::ImplicitExceptionSpecification
Richard Smithd3b5c9082012-07-27 04:22:15 +00008516Sema::ComputeDefaultedDefaultCtorExceptionSpec(SourceLocation Loc,
8517 CXXMethodDecl *MD) {
8518 CXXRecordDecl *ClassDecl = MD->getParent();
8519
Douglas Gregor6d880b12010-07-01 22:31:05 +00008520 // C++ [except.spec]p14:
8521 // An implicitly declared special member function (Clause 12) shall have an
8522 // exception-specification. [...]
Richard Smithf623c962012-04-17 00:58:00 +00008523 ImplicitExceptionSpecification ExceptSpec(*this);
Abramo Bagnaradd8fc042011-07-11 08:52:40 +00008524 if (ClassDecl->isInvalidDecl())
8525 return ExceptSpec;
Douglas Gregor6d880b12010-07-01 22:31:05 +00008526
Sebastian Redlfa453cf2011-03-12 11:50:43 +00008527 // Direct base-class constructors.
Aaron Ballman574705e2014-03-13 15:41:46 +00008528 for (const auto &B : ClassDecl->bases()) {
8529 if (B.isVirtual()) // Handled below.
Douglas Gregor6d880b12010-07-01 22:31:05 +00008530 continue;
8531
Aaron Ballman574705e2014-03-13 15:41:46 +00008532 if (const RecordType *BaseType = B.getType()->getAs<RecordType>()) {
Douglas Gregor9672f922010-07-03 00:47:00 +00008533 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
Alexis Hunteef8ee02011-06-10 03:50:41 +00008534 CXXConstructorDecl *Constructor = LookupDefaultConstructor(BaseClassDecl);
8535 // If this is a deleted function, add it anyway. This might be conformant
8536 // with the standard. This might not. I'm not sure. It might not matter.
8537 if (Constructor)
Aaron Ballman574705e2014-03-13 15:41:46 +00008538 ExceptSpec.CalledDecl(B.getLocStart(), Constructor);
Douglas Gregor9672f922010-07-03 00:47:00 +00008539 }
Douglas Gregor6d880b12010-07-01 22:31:05 +00008540 }
Sebastian Redlfa453cf2011-03-12 11:50:43 +00008541
8542 // Virtual base-class constructors.
Aaron Ballman445a9392014-03-13 16:15:17 +00008543 for (const auto &B : ClassDecl->vbases()) {
8544 if (const RecordType *BaseType = B.getType()->getAs<RecordType>()) {
Douglas Gregor9672f922010-07-03 00:47:00 +00008545 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
Alexis Hunteef8ee02011-06-10 03:50:41 +00008546 CXXConstructorDecl *Constructor = LookupDefaultConstructor(BaseClassDecl);
8547 // If this is a deleted function, add it anyway. This might be conformant
8548 // with the standard. This might not. I'm not sure. It might not matter.
8549 if (Constructor)
Aaron Ballman445a9392014-03-13 16:15:17 +00008550 ExceptSpec.CalledDecl(B.getLocStart(), Constructor);
Douglas Gregor9672f922010-07-03 00:47:00 +00008551 }
Douglas Gregor6d880b12010-07-01 22:31:05 +00008552 }
Sebastian Redlfa453cf2011-03-12 11:50:43 +00008553
8554 // Field constructors.
Aaron Ballmane8a8bae2014-03-08 20:12:42 +00008555 for (const auto *F : ClassDecl->fields()) {
Richard Smith938f40b2011-06-11 17:19:42 +00008556 if (F->hasInClassInitializer()) {
8557 if (Expr *E = F->getInClassInitializer())
8558 ExceptSpec.CalledExpr(E);
8559 else if (!F->isInvalidDecl())
Richard Smithd3b5c9082012-07-27 04:22:15 +00008560 // DR1351:
8561 // If the brace-or-equal-initializer of a non-static data member
8562 // invokes a defaulted default constructor of its class or of an
8563 // enclosing class in a potentially evaluated subexpression, the
8564 // program is ill-formed.
8565 //
8566 // This resolution is unworkable: the exception specification of the
8567 // default constructor can be needed in an unevaluated context, in
8568 // particular, in the operand of a noexcept-expression, and we can be
8569 // unable to compute an exception specification for an enclosed class.
8570 //
8571 // We do not allow an in-class initializer to require the evaluation
8572 // of the exception specification for any in-class initializer whose
8573 // definition is not lexically complete.
8574 Diag(Loc, diag::err_in_class_initializer_references_def_ctor) << MD;
Richard Smith938f40b2011-06-11 17:19:42 +00008575 } else if (const RecordType *RecordTy
Douglas Gregor9672f922010-07-03 00:47:00 +00008576 = Context.getBaseElementType(F->getType())->getAs<RecordType>()) {
Alexis Hunteef8ee02011-06-10 03:50:41 +00008577 CXXRecordDecl *FieldRecDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
8578 CXXConstructorDecl *Constructor = LookupDefaultConstructor(FieldRecDecl);
8579 // If this is a deleted function, add it anyway. This might be conformant
8580 // with the standard. This might not. I'm not sure. It might not matter.
8581 // In particular, the problem is that this function never gets called. It
8582 // might just be ill-formed because this function attempts to refer to
8583 // a deleted function here.
8584 if (Constructor)
Richard Smithf623c962012-04-17 00:58:00 +00008585 ExceptSpec.CalledDecl(F->getLocation(), Constructor);
Douglas Gregor9672f922010-07-03 00:47:00 +00008586 }
Douglas Gregor6d880b12010-07-01 22:31:05 +00008587 }
John McCalldb40c7f2010-12-14 08:05:40 +00008588
Alexis Hunt6d5b96c2011-05-10 00:49:42 +00008589 return ExceptSpec;
8590}
8591
Richard Smithc2bc61b2013-03-18 21:12:30 +00008592Sema::ImplicitExceptionSpecification
Richard Smithb7151b92013-04-10 06:11:48 +00008593Sema::ComputeInheritingCtorExceptionSpec(CXXConstructorDecl *CD) {
8594 CXXRecordDecl *ClassDecl = CD->getParent();
8595
8596 // C++ [except.spec]p14:
8597 // An inheriting constructor [...] shall have an exception-specification. [...]
Richard Smithc2bc61b2013-03-18 21:12:30 +00008598 ImplicitExceptionSpecification ExceptSpec(*this);
Richard Smithb7151b92013-04-10 06:11:48 +00008599 if (ClassDecl->isInvalidDecl())
8600 return ExceptSpec;
8601
8602 // Inherited constructor.
8603 const CXXConstructorDecl *InheritedCD = CD->getInheritedConstructor();
8604 const CXXRecordDecl *InheritedDecl = InheritedCD->getParent();
8605 // FIXME: Copying or moving the parameters could add extra exceptions to the
8606 // set, as could the default arguments for the inherited constructor. This
8607 // will be addressed when we implement the resolution of core issue 1351.
8608 ExceptSpec.CalledDecl(CD->getLocStart(), InheritedCD);
8609
8610 // Direct base-class constructors.
Aaron Ballman574705e2014-03-13 15:41:46 +00008611 for (const auto &B : ClassDecl->bases()) {
8612 if (B.isVirtual()) // Handled below.
Richard Smithb7151b92013-04-10 06:11:48 +00008613 continue;
8614
Aaron Ballman574705e2014-03-13 15:41:46 +00008615 if (const RecordType *BaseType = B.getType()->getAs<RecordType>()) {
Richard Smithb7151b92013-04-10 06:11:48 +00008616 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
8617 if (BaseClassDecl == InheritedDecl)
8618 continue;
8619 CXXConstructorDecl *Constructor = LookupDefaultConstructor(BaseClassDecl);
8620 if (Constructor)
Aaron Ballman574705e2014-03-13 15:41:46 +00008621 ExceptSpec.CalledDecl(B.getLocStart(), Constructor);
Richard Smithb7151b92013-04-10 06:11:48 +00008622 }
8623 }
8624
8625 // Virtual base-class constructors.
Aaron Ballman445a9392014-03-13 16:15:17 +00008626 for (const auto &B : ClassDecl->vbases()) {
8627 if (const RecordType *BaseType = B.getType()->getAs<RecordType>()) {
Richard Smithb7151b92013-04-10 06:11:48 +00008628 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
8629 if (BaseClassDecl == InheritedDecl)
8630 continue;
8631 CXXConstructorDecl *Constructor = LookupDefaultConstructor(BaseClassDecl);
8632 if (Constructor)
Aaron Ballman445a9392014-03-13 16:15:17 +00008633 ExceptSpec.CalledDecl(B.getLocStart(), Constructor);
Richard Smithb7151b92013-04-10 06:11:48 +00008634 }
8635 }
8636
8637 // Field constructors.
Aaron Ballmane8a8bae2014-03-08 20:12:42 +00008638 for (const auto *F : ClassDecl->fields()) {
Richard Smithb7151b92013-04-10 06:11:48 +00008639 if (F->hasInClassInitializer()) {
8640 if (Expr *E = F->getInClassInitializer())
8641 ExceptSpec.CalledExpr(E);
8642 else if (!F->isInvalidDecl())
8643 Diag(CD->getLocation(),
8644 diag::err_in_class_initializer_references_def_ctor) << CD;
8645 } else if (const RecordType *RecordTy
8646 = Context.getBaseElementType(F->getType())->getAs<RecordType>()) {
8647 CXXRecordDecl *FieldRecDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
8648 CXXConstructorDecl *Constructor = LookupDefaultConstructor(FieldRecDecl);
8649 if (Constructor)
8650 ExceptSpec.CalledDecl(F->getLocation(), Constructor);
8651 }
8652 }
8653
Richard Smithc2bc61b2013-03-18 21:12:30 +00008654 return ExceptSpec;
8655}
8656
Richard Smith8bf22e52012-11-29 01:34:07 +00008657namespace {
8658/// RAII object to register a special member as being currently declared.
8659struct DeclaringSpecialMember {
8660 Sema &S;
8661 Sema::SpecialMemberDecl D;
8662 bool WasAlreadyBeingDeclared;
8663
8664 DeclaringSpecialMember(Sema &S, CXXRecordDecl *RD, Sema::CXXSpecialMember CSM)
8665 : S(S), D(RD, CSM) {
8666 WasAlreadyBeingDeclared = !S.SpecialMembersBeingDeclared.insert(D);
8667 if (WasAlreadyBeingDeclared)
8668 // This almost never happens, but if it does, ensure that our cache
8669 // doesn't contain a stale result.
8670 S.SpecialMemberCache.clear();
8671
8672 // FIXME: Register a note to be produced if we encounter an error while
8673 // declaring the special member.
8674 }
8675 ~DeclaringSpecialMember() {
8676 if (!WasAlreadyBeingDeclared)
8677 S.SpecialMembersBeingDeclared.erase(D);
8678 }
8679
8680 /// \brief Are we already trying to declare this special member?
8681 bool isAlreadyBeingDeclared() const {
8682 return WasAlreadyBeingDeclared;
8683 }
8684};
8685}
8686
Alexis Hunt6d5b96c2011-05-10 00:49:42 +00008687CXXConstructorDecl *Sema::DeclareImplicitDefaultConstructor(
8688 CXXRecordDecl *ClassDecl) {
8689 // C++ [class.ctor]p5:
8690 // A default constructor for a class X is a constructor of class X
8691 // that can be called without an argument. If there is no
8692 // user-declared constructor for class X, a default constructor is
8693 // implicitly declared. An implicitly-declared default constructor
8694 // is an inline public member of its class.
Eli Bendersky9a220fc2014-09-29 20:38:29 +00008695 assert(ClassDecl->needsImplicitDefaultConstructor() &&
Alexis Hunt6d5b96c2011-05-10 00:49:42 +00008696 "Should not build implicit default constructor!");
8697
Richard Smith8bf22e52012-11-29 01:34:07 +00008698 DeclaringSpecialMember DSM(*this, ClassDecl, CXXDefaultConstructor);
8699 if (DSM.isAlreadyBeingDeclared())
Craig Topperc3ec1492014-05-26 06:22:03 +00008700 return nullptr;
Richard Smith8bf22e52012-11-29 01:34:07 +00008701
Richard Smithb5800092012-06-10 05:43:50 +00008702 bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
8703 CXXDefaultConstructor,
8704 false);
8705
Douglas Gregor6d880b12010-07-01 22:31:05 +00008706 // Create the actual constructor declaration.
Douglas Gregor4e8b5fb2010-07-01 22:02:46 +00008707 CanQualType ClassType
8708 = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
Abramo Bagnaradff19302011-03-08 08:55:46 +00008709 SourceLocation ClassLoc = ClassDecl->getLocation();
Douglas Gregor4e8b5fb2010-07-01 22:02:46 +00008710 DeclarationName Name
8711 = Context.DeclarationNames.getCXXConstructorName(ClassType);
Abramo Bagnaradff19302011-03-08 08:55:46 +00008712 DeclarationNameInfo NameInfo(Name, ClassLoc);
Richard Smithcc36f692011-12-22 02:22:31 +00008713 CXXConstructorDecl *DefaultCon = CXXConstructorDecl::Create(
Craig Topperc3ec1492014-05-26 06:22:03 +00008714 Context, ClassDecl, ClassLoc, NameInfo, /*Type*/QualType(),
8715 /*TInfo=*/nullptr, /*isExplicit=*/false, /*isInline=*/true,
8716 /*isImplicitlyDeclared=*/true, Constexpr);
Douglas Gregor4e8b5fb2010-07-01 22:02:46 +00008717 DefaultCon->setAccess(AS_public);
Alexis Huntf92197c2011-05-12 03:51:51 +00008718 DefaultCon->setDefaulted();
Eli Bendersky9a220fc2014-09-29 20:38:29 +00008719
8720 if (getLangOpts().CUDA) {
8721 inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXDefaultConstructor,
8722 DefaultCon,
8723 /* ConstRHS */ false,
8724 /* Diagnose */ false);
8725 }
Richard Smithd3b5c9082012-07-27 04:22:15 +00008726
8727 // Build an exception specification pointing back at this constructor.
Reid Kleckner78af0702013-08-27 23:08:25 +00008728 FunctionProtoType::ExtProtoInfo EPI = getImplicitMethodEPI(*this, DefaultCon);
Dmitri Gribenko44ebbd52013-05-05 00:41:58 +00008729 DefaultCon->setType(Context.getFunctionType(Context.VoidTy, None, EPI));
Richard Smithd3b5c9082012-07-27 04:22:15 +00008730
Richard Smith6b02d462012-12-08 08:32:28 +00008731 // We don't need to use SpecialMemberIsTrivial here; triviality for default
8732 // constructors is easy to compute.
8733 DefaultCon->setTrivial(ClassDecl->hasTrivialDefaultConstructor());
8734
8735 if (ShouldDeleteSpecialMember(DefaultCon, CXXDefaultConstructor))
Richard Smithb4d2a152013-04-02 19:38:47 +00008736 SetDeclDeleted(DefaultCon, ClassLoc);
Richard Smith6b02d462012-12-08 08:32:28 +00008737
Douglas Gregor9672f922010-07-03 00:47:00 +00008738 // Note that we have declared this constructor.
Douglas Gregor9672f922010-07-03 00:47:00 +00008739 ++ASTContext::NumImplicitDefaultConstructorsDeclared;
Richard Smith6b02d462012-12-08 08:32:28 +00008740
Douglas Gregor0be31a22010-07-02 17:43:08 +00008741 if (Scope *S = getScopeForContext(ClassDecl))
Douglas Gregor9672f922010-07-03 00:47:00 +00008742 PushOnScopeChains(DefaultCon, S, false);
8743 ClassDecl->addDecl(DefaultCon);
Alexis Hunte77a28f2011-05-18 03:41:58 +00008744
Douglas Gregor4e8b5fb2010-07-01 22:02:46 +00008745 return DefaultCon;
8746}
8747
Fariborz Jahanian423a81f2009-06-19 19:55:27 +00008748void Sema::DefineImplicitDefaultConstructor(SourceLocation CurrentLocation,
8749 CXXConstructorDecl *Constructor) {
Alexis Huntf92197c2011-05-12 03:51:51 +00008750 assert((Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&
Alexis Hunt61ae8d32011-05-23 23:14:04 +00008751 !Constructor->doesThisDeclarationHaveABody() &&
8752 !Constructor->isDeleted()) &&
Fariborz Jahanian18eb69a2009-06-22 20:37:23 +00008753 "DefineImplicitDefaultConstructor - call it for implicit default ctor");
Mike Stump11289f42009-09-09 15:08:12 +00008754
Anders Carlsson423f5d82010-04-23 16:04:08 +00008755 CXXRecordDecl *ClassDecl = Constructor->getParent();
Eli Friedman9cf6b592009-11-09 19:20:36 +00008756 assert(ClassDecl && "DefineImplicitDefaultConstructor - invalid constructor");
Eli Friedmand7686ef2009-11-09 01:05:47 +00008757
Eli Friedmaneaf34142012-10-18 20:14:08 +00008758 SynthesizedFunctionScope Scope(*this, Constructor);
Argyrios Kyrtzidis18653422010-11-19 00:19:12 +00008759 DiagnosticErrorTrap Trap(Diags);
David Blaikie3fc2f912013-01-17 05:26:25 +00008760 if (SetCtorInitializers(Constructor, /*AnyErrors=*/false) ||
Douglas Gregor54818f02010-05-12 16:39:35 +00008761 Trap.hasErrorOccurred()) {
Anders Carlsson26a807d2009-11-30 21:24:50 +00008762 Diag(CurrentLocation, diag::note_member_synthesized_at)
Alexis Hunt80f00ff2011-05-10 19:08:14 +00008763 << CXXDefaultConstructor << Context.getTagDeclType(ClassDecl);
Eli Friedman9cf6b592009-11-09 19:20:36 +00008764 Constructor->setInvalidDecl();
Douglas Gregor73193272010-09-20 16:48:21 +00008765 return;
Eli Friedman9cf6b592009-11-09 19:20:36 +00008766 }
Douglas Gregor73193272010-09-20 16:48:21 +00008767
Ben Langmuir2f8e6b82014-09-25 20:55:00 +00008768 // The exception specification is needed because we are defining the
8769 // function.
8770 ResolveExceptionSpec(CurrentLocation,
8771 Constructor->getType()->castAs<FunctionProtoType>());
8772
Daniel Jasperb3b0b802014-06-20 08:44:22 +00008773 SourceLocation Loc = Constructor->getLocEnd().isValid()
8774 ? Constructor->getLocEnd()
8775 : Constructor->getLocation();
Benjamin Kramere2a929d2012-07-04 17:03:41 +00008776 Constructor->setBody(new (Context) CompoundStmt(Loc));
Douglas Gregor73193272010-09-20 16:48:21 +00008777
Eli Friedman276dd182013-09-05 00:02:25 +00008778 Constructor->markUsed(Context);
Douglas Gregor73193272010-09-20 16:48:21 +00008779 MarkVTableUsed(CurrentLocation, ClassDecl);
Sebastian Redlab238a72011-04-24 16:28:06 +00008780
8781 if (ASTMutationListener *L = getASTMutationListener()) {
8782 L->CompletedImplicitDefinition(Constructor);
8783 }
Richard Trieuef64e942013-10-25 00:56:00 +00008784
8785 DiagnoseUninitializedFields(*this, Constructor);
Fariborz Jahanian423a81f2009-06-19 19:55:27 +00008786}
8787
Richard Smith938f40b2011-06-11 17:19:42 +00008788void Sema::ActOnFinishDelayedMemberInitializers(Decl *D) {
Alp Tokerae3a9442013-10-18 05:54:19 +00008789 // Perform any delayed checks on exception specifications.
8790 CheckDelayedMemberExceptionSpecs();
Richard Smith938f40b2011-06-11 17:19:42 +00008791}
8792
Richard Smith185be182013-04-10 05:48:59 +00008793namespace {
8794/// Information on inheriting constructors to declare.
8795class InheritingConstructorInfo {
8796public:
8797 InheritingConstructorInfo(Sema &SemaRef, CXXRecordDecl *Derived)
8798 : SemaRef(SemaRef), Derived(Derived) {
8799 // Mark the constructors that we already have in the derived class.
8800 //
8801 // C++11 [class.inhctor]p3: [...] a constructor is implicitly declared [...]
8802 // unless there is a user-declared constructor with the same signature in
8803 // the class where the using-declaration appears.
8804 visitAll(Derived, &InheritingConstructorInfo::noteDeclaredInDerived);
8805 }
8806
8807 void inheritAll(CXXRecordDecl *RD) {
8808 visitAll(RD, &InheritingConstructorInfo::inherit);
8809 }
8810
8811private:
8812 /// Information about an inheriting constructor.
8813 struct InheritingConstructor {
8814 InheritingConstructor()
Craig Topperc3ec1492014-05-26 06:22:03 +00008815 : DeclaredInDerived(false), BaseCtor(nullptr), DerivedCtor(nullptr) {}
Richard Smith185be182013-04-10 05:48:59 +00008816
8817 /// If \c true, a constructor with this signature is already declared
8818 /// in the derived class.
8819 bool DeclaredInDerived;
8820
8821 /// The constructor which is inherited.
8822 const CXXConstructorDecl *BaseCtor;
8823
8824 /// The derived constructor we declared.
8825 CXXConstructorDecl *DerivedCtor;
8826 };
8827
8828 /// Inheriting constructors with a given canonical type. There can be at
8829 /// most one such non-template constructor, and any number of templated
8830 /// constructors.
8831 struct InheritingConstructorsForType {
8832 InheritingConstructor NonTemplate;
Robert Wilhelmb869a8f2013-08-10 12:33:24 +00008833 SmallVector<std::pair<TemplateParameterList *, InheritingConstructor>, 4>
8834 Templates;
Richard Smith185be182013-04-10 05:48:59 +00008835
8836 InheritingConstructor &getEntry(Sema &S, const CXXConstructorDecl *Ctor) {
8837 if (FunctionTemplateDecl *FTD = Ctor->getDescribedFunctionTemplate()) {
8838 TemplateParameterList *ParamList = FTD->getTemplateParameters();
8839 for (unsigned I = 0, N = Templates.size(); I != N; ++I)
8840 if (S.TemplateParameterListsAreEqual(ParamList, Templates[I].first,
8841 false, S.TPL_TemplateMatch))
8842 return Templates[I].second;
8843 Templates.push_back(std::make_pair(ParamList, InheritingConstructor()));
8844 return Templates.back().second;
Sebastian Redl08905022011-02-05 19:23:19 +00008845 }
Richard Smith185be182013-04-10 05:48:59 +00008846
8847 return NonTemplate;
8848 }
8849 };
8850
8851 /// Get or create the inheriting constructor record for a constructor.
8852 InheritingConstructor &getEntry(const CXXConstructorDecl *Ctor,
8853 QualType CtorType) {
8854 return Map[CtorType.getCanonicalType()->castAs<FunctionProtoType>()]
8855 .getEntry(SemaRef, Ctor);
8856 }
8857
8858 typedef void (InheritingConstructorInfo::*VisitFn)(const CXXConstructorDecl*);
8859
8860 /// Process all constructors for a class.
8861 void visitAll(const CXXRecordDecl *RD, VisitFn Callback) {
Aaron Ballman2a4bd6d2014-03-13 16:51:27 +00008862 for (const auto *Ctor : RD->ctors())
8863 (this->*Callback)(Ctor);
Richard Smith185be182013-04-10 05:48:59 +00008864 for (CXXRecordDecl::specific_decl_iterator<FunctionTemplateDecl>
8865 I(RD->decls_begin()), E(RD->decls_end());
8866 I != E; ++I) {
8867 const FunctionDecl *FD = (*I)->getTemplatedDecl();
8868 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(FD))
8869 (this->*Callback)(CD);
Sebastian Redl08905022011-02-05 19:23:19 +00008870 }
8871 }
Richard Smith185be182013-04-10 05:48:59 +00008872
8873 /// Note that a constructor (or constructor template) was declared in Derived.
8874 void noteDeclaredInDerived(const CXXConstructorDecl *Ctor) {
8875 getEntry(Ctor, Ctor->getType()).DeclaredInDerived = true;
8876 }
8877
8878 /// Inherit a single constructor.
8879 void inherit(const CXXConstructorDecl *Ctor) {
8880 const FunctionProtoType *CtorType =
8881 Ctor->getType()->castAs<FunctionProtoType>();
Craig Topper5fc8fc22014-08-27 06:28:36 +00008882 ArrayRef<QualType> ArgTypes = CtorType->getParamTypes();
Richard Smith185be182013-04-10 05:48:59 +00008883 FunctionProtoType::ExtProtoInfo EPI = CtorType->getExtProtoInfo();
8884
8885 SourceLocation UsingLoc = getUsingLoc(Ctor->getParent());
8886
8887 // Core issue (no number yet): the ellipsis is always discarded.
8888 if (EPI.Variadic) {
8889 SemaRef.Diag(UsingLoc, diag::warn_using_decl_constructor_ellipsis);
8890 SemaRef.Diag(Ctor->getLocation(),
8891 diag::note_using_decl_constructor_ellipsis);
8892 EPI.Variadic = false;
8893 }
8894
8895 // Declare a constructor for each number of parameters.
8896 //
8897 // C++11 [class.inhctor]p1:
8898 // The candidate set of inherited constructors from the class X named in
8899 // the using-declaration consists of [... modulo defects ...] for each
8900 // constructor or constructor template of X, the set of constructors or
8901 // constructor templates that results from omitting any ellipsis parameter
8902 // specification and successively omitting parameters with a default
8903 // argument from the end of the parameter-type-list
Richard Smith3c626ed2013-04-17 19:00:52 +00008904 unsigned MinParams = minParamsToInherit(Ctor);
8905 unsigned Params = Ctor->getNumParams();
8906 if (Params >= MinParams) {
8907 do
8908 declareCtor(UsingLoc, Ctor,
8909 SemaRef.Context.getFunctionType(
Alp Toker314cc812014-01-25 16:55:45 +00008910 Ctor->getReturnType(), ArgTypes.slice(0, Params), EPI));
Richard Smith3c626ed2013-04-17 19:00:52 +00008911 while (Params > MinParams &&
8912 Ctor->getParamDecl(--Params)->hasDefaultArg());
8913 }
Richard Smith185be182013-04-10 05:48:59 +00008914 }
8915
8916 /// Find the using-declaration which specified that we should inherit the
8917 /// constructors of \p Base.
8918 SourceLocation getUsingLoc(const CXXRecordDecl *Base) {
8919 // No fancy lookup required; just look for the base constructor name
8920 // directly within the derived class.
8921 ASTContext &Context = SemaRef.Context;
8922 DeclarationName Name = Context.DeclarationNames.getCXXConstructorName(
8923 Context.getCanonicalType(Context.getRecordType(Base)));
8924 DeclContext::lookup_const_result Decls = Derived->lookup(Name);
8925 return Decls.empty() ? Derived->getLocation() : Decls[0]->getLocation();
8926 }
8927
8928 unsigned minParamsToInherit(const CXXConstructorDecl *Ctor) {
8929 // C++11 [class.inhctor]p3:
8930 // [F]or each constructor template in the candidate set of inherited
8931 // constructors, a constructor template is implicitly declared
8932 if (Ctor->getDescribedFunctionTemplate())
8933 return 0;
8934
8935 // For each non-template constructor in the candidate set of inherited
8936 // constructors other than a constructor having no parameters or a
8937 // copy/move constructor having a single parameter, a constructor is
8938 // implicitly declared [...]
8939 if (Ctor->getNumParams() == 0)
8940 return 1;
8941 if (Ctor->isCopyOrMoveConstructor())
8942 return 2;
8943
8944 // Per discussion on core reflector, never inherit a constructor which
8945 // would become a default, copy, or move constructor of Derived either.
8946 const ParmVarDecl *PD = Ctor->getParamDecl(0);
8947 const ReferenceType *RT = PD->getType()->getAs<ReferenceType>();
8948 return (RT && RT->getPointeeCXXRecordDecl() == Derived) ? 2 : 1;
8949 }
8950
8951 /// Declare a single inheriting constructor, inheriting the specified
8952 /// constructor, with the given type.
8953 void declareCtor(SourceLocation UsingLoc, const CXXConstructorDecl *BaseCtor,
8954 QualType DerivedType) {
8955 InheritingConstructor &Entry = getEntry(BaseCtor, DerivedType);
8956
8957 // C++11 [class.inhctor]p3:
8958 // ... a constructor is implicitly declared with the same constructor
8959 // characteristics unless there is a user-declared constructor with
8960 // the same signature in the class where the using-declaration appears
8961 if (Entry.DeclaredInDerived)
8962 return;
8963
8964 // C++11 [class.inhctor]p7:
8965 // If two using-declarations declare inheriting constructors with the
8966 // same signature, the program is ill-formed
8967 if (Entry.DerivedCtor) {
8968 if (BaseCtor->getParent() != Entry.BaseCtor->getParent()) {
8969 // Only diagnose this once per constructor.
8970 if (Entry.DerivedCtor->isInvalidDecl())
8971 return;
8972 Entry.DerivedCtor->setInvalidDecl();
8973
8974 SemaRef.Diag(UsingLoc, diag::err_using_decl_constructor_conflict);
8975 SemaRef.Diag(BaseCtor->getLocation(),
8976 diag::note_using_decl_constructor_conflict_current_ctor);
8977 SemaRef.Diag(Entry.BaseCtor->getLocation(),
8978 diag::note_using_decl_constructor_conflict_previous_ctor);
8979 SemaRef.Diag(Entry.DerivedCtor->getLocation(),
8980 diag::note_using_decl_constructor_conflict_previous_using);
8981 } else {
8982 // Core issue (no number): if the same inheriting constructor is
8983 // produced by multiple base class constructors from the same base
8984 // class, the inheriting constructor is defined as deleted.
8985 SemaRef.SetDeclDeleted(Entry.DerivedCtor, UsingLoc);
8986 }
8987
8988 return;
8989 }
8990
8991 ASTContext &Context = SemaRef.Context;
8992 DeclarationName Name = Context.DeclarationNames.getCXXConstructorName(
8993 Context.getCanonicalType(Context.getRecordType(Derived)));
8994 DeclarationNameInfo NameInfo(Name, UsingLoc);
8995
Craig Topperc3ec1492014-05-26 06:22:03 +00008996 TemplateParameterList *TemplateParams = nullptr;
Richard Smith185be182013-04-10 05:48:59 +00008997 if (const FunctionTemplateDecl *FTD =
8998 BaseCtor->getDescribedFunctionTemplate()) {
8999 TemplateParams = FTD->getTemplateParameters();
9000 // We're reusing template parameters from a different DeclContext. This
9001 // is questionable at best, but works out because the template depth in
9002 // both places is guaranteed to be 0.
9003 // FIXME: Rebuild the template parameters in the new context, and
9004 // transform the function type to refer to them.
9005 }
9006
9007 // Build type source info pointing at the using-declaration. This is
9008 // required by template instantiation.
9009 TypeSourceInfo *TInfo =
9010 Context.getTrivialTypeSourceInfo(DerivedType, UsingLoc);
9011 FunctionProtoTypeLoc ProtoLoc =
9012 TInfo->getTypeLoc().IgnoreParens().castAs<FunctionProtoTypeLoc>();
9013
9014 CXXConstructorDecl *DerivedCtor = CXXConstructorDecl::Create(
9015 Context, Derived, UsingLoc, NameInfo, DerivedType,
9016 TInfo, BaseCtor->isExplicit(), /*Inline=*/true,
9017 /*ImplicitlyDeclared=*/true, /*Constexpr=*/BaseCtor->isConstexpr());
9018
9019 // Build an unevaluated exception specification for this constructor.
9020 const FunctionProtoType *FPT = DerivedType->castAs<FunctionProtoType>();
9021 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
Richard Smith8acb4282014-07-31 21:57:55 +00009022 EPI.ExceptionSpec.Type = EST_Unevaluated;
9023 EPI.ExceptionSpec.SourceDecl = DerivedCtor;
Alp Toker314cc812014-01-25 16:55:45 +00009024 DerivedCtor->setType(Context.getFunctionType(FPT->getReturnType(),
Alp Toker9cacbab2014-01-20 20:26:09 +00009025 FPT->getParamTypes(), EPI));
Richard Smith185be182013-04-10 05:48:59 +00009026
9027 // Build the parameter declarations.
9028 SmallVector<ParmVarDecl *, 16> ParamDecls;
Alp Toker9cacbab2014-01-20 20:26:09 +00009029 for (unsigned I = 0, N = FPT->getNumParams(); I != N; ++I) {
Richard Smith185be182013-04-10 05:48:59 +00009030 TypeSourceInfo *TInfo =
Alp Toker9cacbab2014-01-20 20:26:09 +00009031 Context.getTrivialTypeSourceInfo(FPT->getParamType(I), UsingLoc);
Richard Smith185be182013-04-10 05:48:59 +00009032 ParmVarDecl *PD = ParmVarDecl::Create(
Craig Topperc3ec1492014-05-26 06:22:03 +00009033 Context, DerivedCtor, UsingLoc, UsingLoc, /*IdentifierInfo=*/nullptr,
9034 FPT->getParamType(I), TInfo, SC_None, /*DefaultArg=*/nullptr);
Richard Smith185be182013-04-10 05:48:59 +00009035 PD->setScopeInfo(0, I);
9036 PD->setImplicit();
9037 ParamDecls.push_back(PD);
Alp Tokerb3fd5cf2014-01-21 00:32:38 +00009038 ProtoLoc.setParam(I, PD);
Richard Smith185be182013-04-10 05:48:59 +00009039 }
9040
9041 // Set up the new constructor.
9042 DerivedCtor->setAccess(BaseCtor->getAccess());
9043 DerivedCtor->setParams(ParamDecls);
9044 DerivedCtor->setInheritedConstructor(BaseCtor);
9045 if (BaseCtor->isDeleted())
9046 SemaRef.SetDeclDeleted(DerivedCtor, UsingLoc);
9047
9048 // If this is a constructor template, build the template declaration.
9049 if (TemplateParams) {
9050 FunctionTemplateDecl *DerivedTemplate =
9051 FunctionTemplateDecl::Create(SemaRef.Context, Derived, UsingLoc, Name,
9052 TemplateParams, DerivedCtor);
9053 DerivedTemplate->setAccess(BaseCtor->getAccess());
9054 DerivedCtor->setDescribedFunctionTemplate(DerivedTemplate);
9055 Derived->addDecl(DerivedTemplate);
9056 } else {
9057 Derived->addDecl(DerivedCtor);
9058 }
9059
9060 Entry.BaseCtor = BaseCtor;
9061 Entry.DerivedCtor = DerivedCtor;
9062 }
9063
9064 Sema &SemaRef;
9065 CXXRecordDecl *Derived;
9066 typedef llvm::DenseMap<const Type *, InheritingConstructorsForType> MapType;
9067 MapType Map;
9068};
9069}
9070
9071void Sema::DeclareInheritingConstructors(CXXRecordDecl *ClassDecl) {
9072 // Defer declaring the inheriting constructors until the class is
9073 // instantiated.
9074 if (ClassDecl->isDependentContext())
Sebastian Redl08905022011-02-05 19:23:19 +00009075 return;
9076
Richard Smith185be182013-04-10 05:48:59 +00009077 // Find base classes from which we might inherit constructors.
9078 SmallVector<CXXRecordDecl*, 4> InheritedBases;
Aaron Ballman574705e2014-03-13 15:41:46 +00009079 for (const auto &BaseIt : ClassDecl->bases())
9080 if (BaseIt.getInheritConstructors())
9081 InheritedBases.push_back(BaseIt.getType()->getAsCXXRecordDecl());
Richard Smithc2bc61b2013-03-18 21:12:30 +00009082
Richard Smith185be182013-04-10 05:48:59 +00009083 // Go no further if we're not inheriting any constructors.
9084 if (InheritedBases.empty())
9085 return;
Sebastian Redl08905022011-02-05 19:23:19 +00009086
Richard Smith185be182013-04-10 05:48:59 +00009087 // Declare the inherited constructors.
9088 InheritingConstructorInfo ICI(*this, ClassDecl);
9089 for (unsigned I = 0, N = InheritedBases.size(); I != N; ++I)
9090 ICI.inheritAll(InheritedBases[I]);
Sebastian Redl08905022011-02-05 19:23:19 +00009091}
9092
Richard Smithc2bc61b2013-03-18 21:12:30 +00009093void Sema::DefineInheritingConstructor(SourceLocation CurrentLocation,
9094 CXXConstructorDecl *Constructor) {
9095 CXXRecordDecl *ClassDecl = Constructor->getParent();
9096 assert(Constructor->getInheritedConstructor() &&
9097 !Constructor->doesThisDeclarationHaveABody() &&
9098 !Constructor->isDeleted());
9099
9100 SynthesizedFunctionScope Scope(*this, Constructor);
9101 DiagnosticErrorTrap Trap(Diags);
9102 if (SetCtorInitializers(Constructor, /*AnyErrors=*/false) ||
9103 Trap.hasErrorOccurred()) {
9104 Diag(CurrentLocation, diag::note_inhctor_synthesized_at)
9105 << Context.getTagDeclType(ClassDecl);
9106 Constructor->setInvalidDecl();
9107 return;
9108 }
9109
9110 SourceLocation Loc = Constructor->getLocation();
9111 Constructor->setBody(new (Context) CompoundStmt(Loc));
9112
Eli Friedman276dd182013-09-05 00:02:25 +00009113 Constructor->markUsed(Context);
Richard Smithc2bc61b2013-03-18 21:12:30 +00009114 MarkVTableUsed(CurrentLocation, ClassDecl);
9115
9116 if (ASTMutationListener *L = getASTMutationListener()) {
9117 L->CompletedImplicitDefinition(Constructor);
9118 }
9119}
9120
9121
Alexis Huntf91729462011-05-12 22:46:25 +00009122Sema::ImplicitExceptionSpecification
Richard Smithd3b5c9082012-07-27 04:22:15 +00009123Sema::ComputeDefaultedDtorExceptionSpec(CXXMethodDecl *MD) {
9124 CXXRecordDecl *ClassDecl = MD->getParent();
9125
Douglas Gregorf1203042010-07-01 19:09:28 +00009126 // C++ [except.spec]p14:
9127 // An implicitly declared special member function (Clause 12) shall have
9128 // an exception-specification.
Richard Smithf623c962012-04-17 00:58:00 +00009129 ImplicitExceptionSpecification ExceptSpec(*this);
Abramo Bagnaradd8fc042011-07-11 08:52:40 +00009130 if (ClassDecl->isInvalidDecl())
9131 return ExceptSpec;
9132
Douglas Gregorf1203042010-07-01 19:09:28 +00009133 // Direct base-class destructors.
Aaron Ballman574705e2014-03-13 15:41:46 +00009134 for (const auto &B : ClassDecl->bases()) {
9135 if (B.isVirtual()) // Handled below.
Douglas Gregorf1203042010-07-01 19:09:28 +00009136 continue;
9137
Aaron Ballman574705e2014-03-13 15:41:46 +00009138 if (const RecordType *BaseType = B.getType()->getAs<RecordType>())
9139 ExceptSpec.CalledDecl(B.getLocStart(),
Sebastian Redl623ea822011-05-19 05:13:44 +00009140 LookupDestructor(cast<CXXRecordDecl>(BaseType->getDecl())));
Douglas Gregorf1203042010-07-01 19:09:28 +00009141 }
Sebastian Redl623ea822011-05-19 05:13:44 +00009142
Douglas Gregorf1203042010-07-01 19:09:28 +00009143 // Virtual base-class destructors.
Aaron Ballman445a9392014-03-13 16:15:17 +00009144 for (const auto &B : ClassDecl->vbases()) {
9145 if (const RecordType *BaseType = B.getType()->getAs<RecordType>())
9146 ExceptSpec.CalledDecl(B.getLocStart(),
Sebastian Redl623ea822011-05-19 05:13:44 +00009147 LookupDestructor(cast<CXXRecordDecl>(BaseType->getDecl())));
Douglas Gregorf1203042010-07-01 19:09:28 +00009148 }
Sebastian Redl623ea822011-05-19 05:13:44 +00009149
Douglas Gregorf1203042010-07-01 19:09:28 +00009150 // Field destructors.
Aaron Ballmane8a8bae2014-03-08 20:12:42 +00009151 for (const auto *F : ClassDecl->fields()) {
Douglas Gregorf1203042010-07-01 19:09:28 +00009152 if (const RecordType *RecordTy
9153 = Context.getBaseElementType(F->getType())->getAs<RecordType>())
Richard Smithf623c962012-04-17 00:58:00 +00009154 ExceptSpec.CalledDecl(F->getLocation(),
Sebastian Redl623ea822011-05-19 05:13:44 +00009155 LookupDestructor(cast<CXXRecordDecl>(RecordTy->getDecl())));
Douglas Gregorf1203042010-07-01 19:09:28 +00009156 }
Sebastian Redlfa453cf2011-03-12 11:50:43 +00009157
Alexis Huntf91729462011-05-12 22:46:25 +00009158 return ExceptSpec;
9159}
9160
9161CXXDestructorDecl *Sema::DeclareImplicitDestructor(CXXRecordDecl *ClassDecl) {
9162 // C++ [class.dtor]p2:
9163 // If a class has no user-declared destructor, a destructor is
9164 // declared implicitly. An implicitly-declared destructor is an
9165 // inline public member of its class.
Richard Smith2be35f52012-12-01 02:35:44 +00009166 assert(ClassDecl->needsImplicitDestructor());
Alexis Huntf91729462011-05-12 22:46:25 +00009167
Richard Smith8bf22e52012-11-29 01:34:07 +00009168 DeclaringSpecialMember DSM(*this, ClassDecl, CXXDestructor);
9169 if (DSM.isAlreadyBeingDeclared())
Craig Topperc3ec1492014-05-26 06:22:03 +00009170 return nullptr;
Richard Smith8bf22e52012-11-29 01:34:07 +00009171
Douglas Gregor7454c562010-07-02 20:37:36 +00009172 // Create the actual destructor declaration.
Douglas Gregorf1203042010-07-01 19:09:28 +00009173 CanQualType ClassType
9174 = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
Abramo Bagnaradff19302011-03-08 08:55:46 +00009175 SourceLocation ClassLoc = ClassDecl->getLocation();
Douglas Gregorf1203042010-07-01 19:09:28 +00009176 DeclarationName Name
9177 = Context.DeclarationNames.getCXXDestructorName(ClassType);
Abramo Bagnaradff19302011-03-08 08:55:46 +00009178 DeclarationNameInfo NameInfo(Name, ClassLoc);
Douglas Gregorf1203042010-07-01 19:09:28 +00009179 CXXDestructorDecl *Destructor
Richard Smithd3b5c9082012-07-27 04:22:15 +00009180 = CXXDestructorDecl::Create(Context, ClassDecl, ClassLoc, NameInfo,
Craig Topperc3ec1492014-05-26 06:22:03 +00009181 QualType(), nullptr, /*isInline=*/true,
Sebastian Redlfa453cf2011-03-12 11:50:43 +00009182 /*isImplicitlyDeclared=*/true);
Douglas Gregorf1203042010-07-01 19:09:28 +00009183 Destructor->setAccess(AS_public);
Alexis Huntf91729462011-05-12 22:46:25 +00009184 Destructor->setDefaulted();
Eli Bendersky9a220fc2014-09-29 20:38:29 +00009185
9186 if (getLangOpts().CUDA) {
9187 inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXDestructor,
9188 Destructor,
9189 /* ConstRHS */ false,
9190 /* Diagnose */ false);
9191 }
Richard Smithd3b5c9082012-07-27 04:22:15 +00009192
9193 // Build an exception specification pointing back at this destructor.
Reid Kleckner78af0702013-08-27 23:08:25 +00009194 FunctionProtoType::ExtProtoInfo EPI = getImplicitMethodEPI(*this, Destructor);
Dmitri Gribenko44ebbd52013-05-05 00:41:58 +00009195 Destructor->setType(Context.getFunctionType(Context.VoidTy, None, EPI));
Richard Smithd3b5c9082012-07-27 04:22:15 +00009196
Richard Smith6b02d462012-12-08 08:32:28 +00009197 AddOverriddenMethods(ClassDecl, Destructor);
9198
9199 // We don't need to use SpecialMemberIsTrivial here; triviality for
9200 // destructors is easy to compute.
9201 Destructor->setTrivial(ClassDecl->hasTrivialDestructor());
9202
9203 if (ShouldDeleteSpecialMember(Destructor, CXXDestructor))
Richard Smithb4d2a152013-04-02 19:38:47 +00009204 SetDeclDeleted(Destructor, ClassLoc);
Richard Smith6b02d462012-12-08 08:32:28 +00009205
Douglas Gregor7454c562010-07-02 20:37:36 +00009206 // Note that we have declared this destructor.
Douglas Gregor7454c562010-07-02 20:37:36 +00009207 ++ASTContext::NumImplicitDestructorsDeclared;
Richard Smithd3b5c9082012-07-27 04:22:15 +00009208
Douglas Gregor7454c562010-07-02 20:37:36 +00009209 // Introduce this destructor into its scope.
Douglas Gregor0be31a22010-07-02 17:43:08 +00009210 if (Scope *S = getScopeForContext(ClassDecl))
Douglas Gregor7454c562010-07-02 20:37:36 +00009211 PushOnScopeChains(Destructor, S, false);
9212 ClassDecl->addDecl(Destructor);
Alexis Huntf91729462011-05-12 22:46:25 +00009213
Douglas Gregorf1203042010-07-01 19:09:28 +00009214 return Destructor;
9215}
9216
Fariborz Jahanian24a175b2009-06-26 23:49:16 +00009217void Sema::DefineImplicitDestructor(SourceLocation CurrentLocation,
Douglas Gregord94105a2009-09-04 19:04:08 +00009218 CXXDestructorDecl *Destructor) {
Alexis Hunt61ae8d32011-05-23 23:14:04 +00009219 assert((Destructor->isDefaulted() &&
Richard Smith273c4e92012-02-26 07:51:39 +00009220 !Destructor->doesThisDeclarationHaveABody() &&
9221 !Destructor->isDeleted()) &&
Fariborz Jahanian24a175b2009-06-26 23:49:16 +00009222 "DefineImplicitDestructor - call it for implicit default dtor");
Anders Carlsson2a50e952009-11-15 22:49:34 +00009223 CXXRecordDecl *ClassDecl = Destructor->getParent();
Fariborz Jahanian24a175b2009-06-26 23:49:16 +00009224 assert(ClassDecl && "DefineImplicitDestructor - invalid destructor");
Douglas Gregor7ae2d772010-01-31 09:12:51 +00009225
Douglas Gregor54818f02010-05-12 16:39:35 +00009226 if (Destructor->isInvalidDecl())
9227 return;
9228
Eli Friedmaneaf34142012-10-18 20:14:08 +00009229 SynthesizedFunctionScope Scope(*this, Destructor);
Douglas Gregor7ae2d772010-01-31 09:12:51 +00009230
Argyrios Kyrtzidis18653422010-11-19 00:19:12 +00009231 DiagnosticErrorTrap Trap(Diags);
John McCalla6309952010-03-16 21:39:52 +00009232 MarkBaseAndMemberDestructorsReferenced(Destructor->getLocation(),
9233 Destructor->getParent());
Mike Stump11289f42009-09-09 15:08:12 +00009234
Douglas Gregor54818f02010-05-12 16:39:35 +00009235 if (CheckDestructor(Destructor) || Trap.hasErrorOccurred()) {
Anders Carlsson26a807d2009-11-30 21:24:50 +00009236 Diag(CurrentLocation, diag::note_member_synthesized_at)
9237 << CXXDestructor << Context.getTagDeclType(ClassDecl);
9238
9239 Destructor->setInvalidDecl();
9240 return;
9241 }
9242
Ben Langmuir2f8e6b82014-09-25 20:55:00 +00009243 // The exception specification is needed because we are defining the
9244 // function.
9245 ResolveExceptionSpec(CurrentLocation,
9246 Destructor->getType()->castAs<FunctionProtoType>());
9247
Daniel Jasperb3b0b802014-06-20 08:44:22 +00009248 SourceLocation Loc = Destructor->getLocEnd().isValid()
9249 ? Destructor->getLocEnd()
9250 : Destructor->getLocation();
Benjamin Kramere2a929d2012-07-04 17:03:41 +00009251 Destructor->setBody(new (Context) CompoundStmt(Loc));
Eli Friedman276dd182013-09-05 00:02:25 +00009252 Destructor->markUsed(Context);
Douglas Gregor88d292c2010-05-13 16:44:06 +00009253 MarkVTableUsed(CurrentLocation, ClassDecl);
Sebastian Redlab238a72011-04-24 16:28:06 +00009254
9255 if (ASTMutationListener *L = getASTMutationListener()) {
9256 L->CompletedImplicitDefinition(Destructor);
9257 }
Fariborz Jahanian24a175b2009-06-26 23:49:16 +00009258}
9259
Richard Smith84973e52012-04-21 18:42:51 +00009260/// \brief Perform any semantic analysis which needs to be delayed until all
9261/// pending class member declarations have been parsed.
9262void Sema::ActOnFinishCXXMemberDecls() {
Douglas Gregorbc0e5c02013-02-01 04:49:10 +00009263 // If the context is an invalid C++ class, just suppress these checks.
9264 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(CurContext)) {
9265 if (Record->isInvalidDecl()) {
Alp Tokerae3a9442013-10-18 05:54:19 +00009266 DelayedDefaultedMemberExceptionSpecs.clear();
Douglas Gregorbc0e5c02013-02-01 04:49:10 +00009267 DelayedDestructorExceptionSpecChecks.clear();
9268 return;
9269 }
9270 }
Richard Smith84973e52012-04-21 18:42:51 +00009271}
9272
Richard Smithd3b5c9082012-07-27 04:22:15 +00009273void Sema::AdjustDestructorExceptionSpec(CXXRecordDecl *ClassDecl,
9274 CXXDestructorDecl *Destructor) {
Richard Smith2bf7fdb2013-01-02 11:42:31 +00009275 assert(getLangOpts().CPlusPlus11 &&
Richard Smithd3b5c9082012-07-27 04:22:15 +00009276 "adjusting dtor exception specs was introduced in c++11");
9277
Sebastian Redl623ea822011-05-19 05:13:44 +00009278 // C++11 [class.dtor]p3:
9279 // A declaration of a destructor that does not have an exception-
9280 // specification is implicitly considered to have the same exception-
9281 // specification as an implicit declaration.
Richard Smithd3b5c9082012-07-27 04:22:15 +00009282 const FunctionProtoType *DtorType = Destructor->getType()->
Sebastian Redl623ea822011-05-19 05:13:44 +00009283 getAs<FunctionProtoType>();
Richard Smithd3b5c9082012-07-27 04:22:15 +00009284 if (DtorType->hasExceptionSpec())
Sebastian Redl623ea822011-05-19 05:13:44 +00009285 return;
9286
Chandler Carruth9a797572011-09-20 04:55:26 +00009287 // Replace the destructor's type, building off the existing one. Fortunately,
9288 // the only thing of interest in the destructor type is its extended info.
9289 // The return and arguments are fixed.
Richard Smithd3b5c9082012-07-27 04:22:15 +00009290 FunctionProtoType::ExtProtoInfo EPI = DtorType->getExtProtoInfo();
Richard Smith8acb4282014-07-31 21:57:55 +00009291 EPI.ExceptionSpec.Type = EST_Unevaluated;
9292 EPI.ExceptionSpec.SourceDecl = Destructor;
Dmitri Gribenko44ebbd52013-05-05 00:41:58 +00009293 Destructor->setType(Context.getFunctionType(Context.VoidTy, None, EPI));
Richard Smith84973e52012-04-21 18:42:51 +00009294
Sebastian Redl623ea822011-05-19 05:13:44 +00009295 // FIXME: If the destructor has a body that could throw, and the newly created
9296 // spec doesn't allow exceptions, we should emit a warning, because this
9297 // change in behavior can break conforming C++03 programs at runtime.
Richard Smithd3b5c9082012-07-27 04:22:15 +00009298 // However, we don't have a body or an exception specification yet, so it
9299 // needs to be done somewhere else.
Sebastian Redl623ea822011-05-19 05:13:44 +00009300}
9301
Pavel Labath58934982013-08-30 08:52:28 +00009302namespace {
9303/// \brief An abstract base class for all helper classes used in building the
9304// copy/move operators. These classes serve as factory functions and help us
9305// avoid using the same Expr* in the AST twice.
9306class ExprBuilder {
9307 ExprBuilder(const ExprBuilder&) LLVM_DELETED_FUNCTION;
9308 ExprBuilder &operator=(const ExprBuilder&) LLVM_DELETED_FUNCTION;
9309
9310protected:
9311 static Expr *assertNotNull(Expr *E) {
9312 assert(E && "Expression construction must not fail.");
9313 return E;
9314 }
9315
9316public:
9317 ExprBuilder() {}
9318 virtual ~ExprBuilder() {}
9319
9320 virtual Expr *build(Sema &S, SourceLocation Loc) const = 0;
9321};
9322
9323class RefBuilder: public ExprBuilder {
9324 VarDecl *Var;
9325 QualType VarType;
9326
9327public:
Craig Toppera798a9d2014-03-02 09:32:10 +00009328 virtual Expr *build(Sema &S, SourceLocation Loc) const override {
Nikola Smiljanic01a75982014-05-29 10:55:11 +00009329 return assertNotNull(S.BuildDeclRefExpr(Var, VarType, VK_LValue, Loc).get());
Pavel Labath58934982013-08-30 08:52:28 +00009330 }
9331
9332 RefBuilder(VarDecl *Var, QualType VarType)
9333 : Var(Var), VarType(VarType) {}
9334};
9335
9336class ThisBuilder: public ExprBuilder {
9337public:
Craig Toppera798a9d2014-03-02 09:32:10 +00009338 virtual Expr *build(Sema &S, SourceLocation Loc) const override {
Nikola Smiljanic01a75982014-05-29 10:55:11 +00009339 return assertNotNull(S.ActOnCXXThis(Loc).getAs<Expr>());
Pavel Labath58934982013-08-30 08:52:28 +00009340 }
9341};
9342
9343class CastBuilder: public ExprBuilder {
9344 const ExprBuilder &Builder;
9345 QualType Type;
9346 ExprValueKind Kind;
9347 const CXXCastPath &Path;
9348
9349public:
Craig Toppera798a9d2014-03-02 09:32:10 +00009350 virtual Expr *build(Sema &S, SourceLocation Loc) const override {
Pavel Labath58934982013-08-30 08:52:28 +00009351 return assertNotNull(S.ImpCastExprToType(Builder.build(S, Loc), Type,
9352 CK_UncheckedDerivedToBase, Kind,
Nikola Smiljanic01a75982014-05-29 10:55:11 +00009353 &Path).get());
Pavel Labath58934982013-08-30 08:52:28 +00009354 }
9355
9356 CastBuilder(const ExprBuilder &Builder, QualType Type, ExprValueKind Kind,
9357 const CXXCastPath &Path)
9358 : Builder(Builder), Type(Type), Kind(Kind), Path(Path) {}
9359};
9360
9361class DerefBuilder: public ExprBuilder {
9362 const ExprBuilder &Builder;
9363
9364public:
Craig Toppera798a9d2014-03-02 09:32:10 +00009365 virtual Expr *build(Sema &S, SourceLocation Loc) const override {
Pavel Labath58934982013-08-30 08:52:28 +00009366 return assertNotNull(
Nikola Smiljanic01a75982014-05-29 10:55:11 +00009367 S.CreateBuiltinUnaryOp(Loc, UO_Deref, Builder.build(S, Loc)).get());
Pavel Labath58934982013-08-30 08:52:28 +00009368 }
9369
9370 DerefBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
9371};
9372
9373class MemberBuilder: public ExprBuilder {
9374 const ExprBuilder &Builder;
9375 QualType Type;
9376 CXXScopeSpec SS;
9377 bool IsArrow;
9378 LookupResult &MemberLookup;
9379
9380public:
Craig Toppera798a9d2014-03-02 09:32:10 +00009381 virtual Expr *build(Sema &S, SourceLocation Loc) const override {
Pavel Labath58934982013-08-30 08:52:28 +00009382 return assertNotNull(S.BuildMemberReferenceExpr(
Craig Topperc3ec1492014-05-26 06:22:03 +00009383 Builder.build(S, Loc), Type, Loc, IsArrow, SS, SourceLocation(),
Nikola Smiljanic01a75982014-05-29 10:55:11 +00009384 nullptr, MemberLookup, nullptr).get());
Pavel Labath58934982013-08-30 08:52:28 +00009385 }
9386
9387 MemberBuilder(const ExprBuilder &Builder, QualType Type, bool IsArrow,
9388 LookupResult &MemberLookup)
9389 : Builder(Builder), Type(Type), IsArrow(IsArrow),
9390 MemberLookup(MemberLookup) {}
9391};
9392
9393class MoveCastBuilder: public ExprBuilder {
9394 const ExprBuilder &Builder;
9395
9396public:
Craig Toppera798a9d2014-03-02 09:32:10 +00009397 virtual Expr *build(Sema &S, SourceLocation Loc) const override {
Pavel Labath58934982013-08-30 08:52:28 +00009398 return assertNotNull(CastForMoving(S, Builder.build(S, Loc)));
9399 }
9400
9401 MoveCastBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
9402};
9403
9404class LvalueConvBuilder: public ExprBuilder {
9405 const ExprBuilder &Builder;
9406
9407public:
Craig Toppera798a9d2014-03-02 09:32:10 +00009408 virtual Expr *build(Sema &S, SourceLocation Loc) const override {
Pavel Labath58934982013-08-30 08:52:28 +00009409 return assertNotNull(
Nikola Smiljanic01a75982014-05-29 10:55:11 +00009410 S.DefaultLvalueConversion(Builder.build(S, Loc)).get());
Pavel Labath58934982013-08-30 08:52:28 +00009411 }
9412
9413 LvalueConvBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
9414};
9415
9416class SubscriptBuilder: public ExprBuilder {
9417 const ExprBuilder &Base;
9418 const ExprBuilder &Index;
9419
9420public:
Craig Toppera798a9d2014-03-02 09:32:10 +00009421 virtual Expr *build(Sema &S, SourceLocation Loc) const override {
Pavel Labath58934982013-08-30 08:52:28 +00009422 return assertNotNull(S.CreateBuiltinArraySubscriptExpr(
Nikola Smiljanic01a75982014-05-29 10:55:11 +00009423 Base.build(S, Loc), Loc, Index.build(S, Loc), Loc).get());
Pavel Labath58934982013-08-30 08:52:28 +00009424 }
9425
9426 SubscriptBuilder(const ExprBuilder &Base, const ExprBuilder &Index)
9427 : Base(Base), Index(Index) {}
9428};
9429
9430} // end anonymous namespace
9431
Richard Smith41ae3282012-11-14 00:50:40 +00009432/// When generating a defaulted copy or move assignment operator, if a field
9433/// should be copied with __builtin_memcpy rather than via explicit assignments,
9434/// do so. This optimization only applies for arrays of scalars, and for arrays
9435/// of class type where the selected copy/move-assignment operator is trivial.
9436static StmtResult
9437buildMemcpyForAssignmentOp(Sema &S, SourceLocation Loc, QualType T,
Pavel Labath58934982013-08-30 08:52:28 +00009438 const ExprBuilder &ToB, const ExprBuilder &FromB) {
Richard Smith41ae3282012-11-14 00:50:40 +00009439 // Compute the size of the memory buffer to be copied.
9440 QualType SizeType = S.Context.getSizeType();
9441 llvm::APInt Size(S.Context.getTypeSize(SizeType),
9442 S.Context.getTypeSizeInChars(T).getQuantity());
9443
9444 // Take the address of the field references for "from" and "to". We
9445 // directly construct UnaryOperators here because semantic analysis
9446 // does not permit us to take the address of an xvalue.
Pavel Labath58934982013-08-30 08:52:28 +00009447 Expr *From = FromB.build(S, Loc);
Richard Smith41ae3282012-11-14 00:50:40 +00009448 From = new (S.Context) UnaryOperator(From, UO_AddrOf,
9449 S.Context.getPointerType(From->getType()),
9450 VK_RValue, OK_Ordinary, Loc);
Pavel Labath58934982013-08-30 08:52:28 +00009451 Expr *To = ToB.build(S, Loc);
Richard Smith41ae3282012-11-14 00:50:40 +00009452 To = new (S.Context) UnaryOperator(To, UO_AddrOf,
9453 S.Context.getPointerType(To->getType()),
9454 VK_RValue, OK_Ordinary, Loc);
9455
9456 const Type *E = T->getBaseElementTypeUnsafe();
9457 bool NeedsCollectableMemCpy =
9458 E->isRecordType() && E->getAs<RecordType>()->getDecl()->hasObjectMember();
9459
9460 // Create a reference to the __builtin_objc_memmove_collectable function
9461 StringRef MemCpyName = NeedsCollectableMemCpy ?
9462 "__builtin_objc_memmove_collectable" :
9463 "__builtin_memcpy";
9464 LookupResult R(S, &S.Context.Idents.get(MemCpyName), Loc,
9465 Sema::LookupOrdinaryName);
9466 S.LookupName(R, S.TUScope, true);
9467
9468 FunctionDecl *MemCpy = R.getAsSingle<FunctionDecl>();
9469 if (!MemCpy)
9470 // Something went horribly wrong earlier, and we will have complained
9471 // about it.
9472 return StmtError();
9473
9474 ExprResult MemCpyRef = S.BuildDeclRefExpr(MemCpy, S.Context.BuiltinFnTy,
Craig Topperc3ec1492014-05-26 06:22:03 +00009475 VK_RValue, Loc, nullptr);
Richard Smith41ae3282012-11-14 00:50:40 +00009476 assert(MemCpyRef.isUsable() && "Builtin reference cannot fail");
9477
9478 Expr *CallArgs[] = {
9479 To, From, IntegerLiteral::Create(S.Context, Size, SizeType, Loc)
9480 };
Nikola Smiljanic01a75982014-05-29 10:55:11 +00009481 ExprResult Call = S.ActOnCallExpr(/*Scope=*/nullptr, MemCpyRef.get(),
Richard Smith41ae3282012-11-14 00:50:40 +00009482 Loc, CallArgs, Loc);
9483
9484 assert(!Call.isInvalid() && "Call to __builtin_memcpy cannot fail!");
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00009485 return Call.getAs<Stmt>();
Richard Smith41ae3282012-11-14 00:50:40 +00009486}
9487
Sebastian Redl22653ba2011-08-30 19:58:05 +00009488/// \brief Builds a statement that copies/moves the given entity from \p From to
Douglas Gregorb139cd52010-05-01 20:49:11 +00009489/// \c To.
9490///
Sebastian Redl22653ba2011-08-30 19:58:05 +00009491/// This routine is used to copy/move the members of a class with an
9492/// implicitly-declared copy/move assignment operator. When the entities being
Douglas Gregorb139cd52010-05-01 20:49:11 +00009493/// copied are arrays, this routine builds for loops to copy them.
9494///
9495/// \param S The Sema object used for type-checking.
9496///
Sebastian Redl22653ba2011-08-30 19:58:05 +00009497/// \param Loc The location where the implicit copy/move is being generated.
Douglas Gregorb139cd52010-05-01 20:49:11 +00009498///
Sebastian Redl22653ba2011-08-30 19:58:05 +00009499/// \param T The type of the expressions being copied/moved. Both expressions
9500/// must have this type.
Douglas Gregorb139cd52010-05-01 20:49:11 +00009501///
Sebastian Redl22653ba2011-08-30 19:58:05 +00009502/// \param To The expression we are copying/moving to.
Douglas Gregorb139cd52010-05-01 20:49:11 +00009503///
Sebastian Redl22653ba2011-08-30 19:58:05 +00009504/// \param From The expression we are copying/moving from.
Douglas Gregorb139cd52010-05-01 20:49:11 +00009505///
Sebastian Redl22653ba2011-08-30 19:58:05 +00009506/// \param CopyingBaseSubobject Whether we're copying/moving a base subobject.
Douglas Gregor40c92bb2010-05-04 15:20:55 +00009507/// Otherwise, it's a non-static member subobject.
9508///
Sebastian Redl22653ba2011-08-30 19:58:05 +00009509/// \param Copying Whether we're copying or moving.
9510///
Douglas Gregorb139cd52010-05-01 20:49:11 +00009511/// \param Depth Internal parameter recording the depth of the recursion.
9512///
Richard Smith41ae3282012-11-14 00:50:40 +00009513/// \returns A statement or a loop that copies the expressions, or StmtResult(0)
9514/// if a memcpy should be used instead.
John McCalldadc5752010-08-24 06:29:42 +00009515static StmtResult
Richard Smith41ae3282012-11-14 00:50:40 +00009516buildSingleCopyAssignRecursively(Sema &S, SourceLocation Loc, QualType T,
Pavel Labath58934982013-08-30 08:52:28 +00009517 const ExprBuilder &To, const ExprBuilder &From,
Richard Smith41ae3282012-11-14 00:50:40 +00009518 bool CopyingBaseSubobject, bool Copying,
9519 unsigned Depth = 0) {
Richard Smith52c0b582012-11-13 00:54:12 +00009520 // C++11 [class.copy]p28:
Douglas Gregorb139cd52010-05-01 20:49:11 +00009521 // Each subobject is assigned in the manner appropriate to its type:
9522 //
Sebastian Redl22653ba2011-08-30 19:58:05 +00009523 // - if the subobject is of class type, as if by a call to operator= with
9524 // the subobject as the object expression and the corresponding
9525 // subobject of x as a single function argument (as if by explicit
9526 // qualification; that is, ignoring any possible virtual overriding
9527 // functions in more derived classes);
Richard Smith52c0b582012-11-13 00:54:12 +00009528 //
9529 // C++03 [class.copy]p13:
9530 // - if the subobject is of class type, the copy assignment operator for
9531 // the class is used (as if by explicit qualification; that is,
9532 // ignoring any possible virtual overriding functions in more derived
9533 // classes);
Douglas Gregorb139cd52010-05-01 20:49:11 +00009534 if (const RecordType *RecordTy = T->getAs<RecordType>()) {
9535 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
Richard Smith52c0b582012-11-13 00:54:12 +00009536
Douglas Gregorb139cd52010-05-01 20:49:11 +00009537 // Look for operator=.
9538 DeclarationName Name
9539 = S.Context.DeclarationNames.getCXXOperatorName(OO_Equal);
9540 LookupResult OpLookup(S, Name, Loc, Sema::LookupOrdinaryName);
9541 S.LookupQualifiedName(OpLookup, ClassDecl, false);
Sebastian Redl22653ba2011-08-30 19:58:05 +00009542
Richard Smith52c0b582012-11-13 00:54:12 +00009543 // Prior to C++11, filter out any result that isn't a copy/move-assignment
9544 // operator.
Richard Smith2bf7fdb2013-01-02 11:42:31 +00009545 if (!S.getLangOpts().CPlusPlus11) {
Richard Smith52c0b582012-11-13 00:54:12 +00009546 LookupResult::Filter F = OpLookup.makeFilter();
9547 while (F.hasNext()) {
9548 NamedDecl *D = F.next();
9549 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D))
9550 if (Method->isCopyAssignmentOperator() ||
9551 (!Copying && Method->isMoveAssignmentOperator()))
9552 continue;
9553
9554 F.erase();
9555 }
9556 F.done();
John McCallab8c2732010-03-16 06:11:48 +00009557 }
Richard Smith52c0b582012-11-13 00:54:12 +00009558
Douglas Gregor40c92bb2010-05-04 15:20:55 +00009559 // Suppress the protected check (C++ [class.protected]) for each of the
Richard Smith52c0b582012-11-13 00:54:12 +00009560 // assignment operators we found. This strange dance is required when
Douglas Gregor40c92bb2010-05-04 15:20:55 +00009561 // we're assigning via a base classes's copy-assignment operator. To
Richard Smith52c0b582012-11-13 00:54:12 +00009562 // ensure that we're getting the right base class subobject (without
Douglas Gregor40c92bb2010-05-04 15:20:55 +00009563 // ambiguities), we need to cast "this" to that subobject type; to
9564 // ensure that we don't go through the virtual call mechanism, we need
9565 // to qualify the operator= name with the base class (see below). However,
9566 // this means that if the base class has a protected copy assignment
9567 // operator, the protected member access check will fail. So, we
9568 // rewrite "protected" access to "public" access in this case, since we
9569 // know by construction that we're calling from a derived class.
9570 if (CopyingBaseSubobject) {
9571 for (LookupResult::iterator L = OpLookup.begin(), LEnd = OpLookup.end();
9572 L != LEnd; ++L) {
9573 if (L.getAccess() == AS_protected)
9574 L.setAccess(AS_public);
9575 }
9576 }
Richard Smith52c0b582012-11-13 00:54:12 +00009577
Douglas Gregorb139cd52010-05-01 20:49:11 +00009578 // Create the nested-name-specifier that will be used to qualify the
9579 // reference to operator=; this is required to suppress the virtual
9580 // call mechanism.
9581 CXXScopeSpec SS;
Manuel Klimeke7167412012-02-06 21:51:39 +00009582 const Type *CanonicalT = S.Context.getCanonicalType(T.getTypePtr());
Richard Smith52c0b582012-11-13 00:54:12 +00009583 SS.MakeTrivial(S.Context,
Craig Topperc3ec1492014-05-26 06:22:03 +00009584 NestedNameSpecifier::Create(S.Context, nullptr, false,
Manuel Klimeke7167412012-02-06 21:51:39 +00009585 CanonicalT),
Douglas Gregor869ad452011-02-24 17:54:50 +00009586 Loc);
Richard Smith52c0b582012-11-13 00:54:12 +00009587
Douglas Gregorb139cd52010-05-01 20:49:11 +00009588 // Create the reference to operator=.
John McCalldadc5752010-08-24 06:29:42 +00009589 ExprResult OpEqualRef
Pavel Labath58934982013-08-30 08:52:28 +00009590 = S.BuildMemberReferenceExpr(To.build(S, Loc), T, Loc, /*isArrow=*/false,
9591 SS, /*TemplateKWLoc=*/SourceLocation(),
Craig Topperc3ec1492014-05-26 06:22:03 +00009592 /*FirstQualifierInScope=*/nullptr,
Abramo Bagnara7945c982012-01-27 09:46:47 +00009593 OpLookup,
Craig Topperc3ec1492014-05-26 06:22:03 +00009594 /*TemplateArgs=*/nullptr,
Douglas Gregorb139cd52010-05-01 20:49:11 +00009595 /*SuppressQualifierCheck=*/true);
9596 if (OpEqualRef.isInvalid())
John McCallfaf5fb42010-08-26 23:41:50 +00009597 return StmtError();
Richard Smith52c0b582012-11-13 00:54:12 +00009598
Douglas Gregorb139cd52010-05-01 20:49:11 +00009599 // Build the call to the assignment operator.
John McCallb268a282010-08-23 23:25:46 +00009600
Pavel Labath58934982013-08-30 08:52:28 +00009601 Expr *FromInst = From.build(S, Loc);
Craig Topperc3ec1492014-05-26 06:22:03 +00009602 ExprResult Call = S.BuildCallToMemberFunction(/*Scope=*/nullptr,
Nikola Smiljanic01a75982014-05-29 10:55:11 +00009603 OpEqualRef.getAs<Expr>(),
Pavel Labath58934982013-08-30 08:52:28 +00009604 Loc, FromInst, Loc);
Douglas Gregorb139cd52010-05-01 20:49:11 +00009605 if (Call.isInvalid())
John McCallfaf5fb42010-08-26 23:41:50 +00009606 return StmtError();
Richard Smith52c0b582012-11-13 00:54:12 +00009607
Richard Smith41ae3282012-11-14 00:50:40 +00009608 // If we built a call to a trivial 'operator=' while copying an array,
9609 // bail out. We'll replace the whole shebang with a memcpy.
9610 CXXMemberCallExpr *CE = dyn_cast<CXXMemberCallExpr>(Call.get());
9611 if (CE && CE->getMethodDecl()->isTrivial() && Depth)
Craig Topperc3ec1492014-05-26 06:22:03 +00009612 return StmtResult((Stmt*)nullptr);
Richard Smith41ae3282012-11-14 00:50:40 +00009613
Richard Smith52c0b582012-11-13 00:54:12 +00009614 // Convert to an expression-statement, and clean up any produced
9615 // temporaries.
Richard Smith945f8d32013-01-14 22:39:08 +00009616 return S.ActOnExprStmt(Call);
Fariborz Jahanian41f79272009-06-25 21:45:19 +00009617 }
John McCallab8c2732010-03-16 06:11:48 +00009618
Richard Smith52c0b582012-11-13 00:54:12 +00009619 // - if the subobject is of scalar type, the built-in assignment
Douglas Gregorb139cd52010-05-01 20:49:11 +00009620 // operator is used.
Richard Smith52c0b582012-11-13 00:54:12 +00009621 const ConstantArrayType *ArrayTy = S.Context.getAsConstantArrayType(T);
Douglas Gregorb139cd52010-05-01 20:49:11 +00009622 if (!ArrayTy) {
Pavel Labath58934982013-08-30 08:52:28 +00009623 ExprResult Assignment = S.CreateBuiltinBinOp(
9624 Loc, BO_Assign, To.build(S, Loc), From.build(S, Loc));
Douglas Gregorb139cd52010-05-01 20:49:11 +00009625 if (Assignment.isInvalid())
John McCallfaf5fb42010-08-26 23:41:50 +00009626 return StmtError();
Richard Smith945f8d32013-01-14 22:39:08 +00009627 return S.ActOnExprStmt(Assignment);
Fariborz Jahanian41f79272009-06-25 21:45:19 +00009628 }
Richard Smith52c0b582012-11-13 00:54:12 +00009629
9630 // - if the subobject is an array, each element is assigned, in the
Douglas Gregorb139cd52010-05-01 20:49:11 +00009631 // manner appropriate to the element type;
Richard Smith52c0b582012-11-13 00:54:12 +00009632
Douglas Gregorb139cd52010-05-01 20:49:11 +00009633 // Construct a loop over the array bounds, e.g.,
9634 //
9635 // for (__SIZE_TYPE__ i0 = 0; i0 != array-size; ++i0)
9636 //
9637 // that will copy each of the array elements.
9638 QualType SizeType = S.Context.getSizeType();
Richard Smith41ae3282012-11-14 00:50:40 +00009639
Douglas Gregorb139cd52010-05-01 20:49:11 +00009640 // Create the iteration variable.
Craig Topperc3ec1492014-05-26 06:22:03 +00009641 IdentifierInfo *IterationVarName = nullptr;
Douglas Gregorb139cd52010-05-01 20:49:11 +00009642 {
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00009643 SmallString<8> Str;
Douglas Gregorb139cd52010-05-01 20:49:11 +00009644 llvm::raw_svector_ostream OS(Str);
9645 OS << "__i" << Depth;
9646 IterationVarName = &S.Context.Idents.get(OS.str());
9647 }
Abramo Bagnaradff19302011-03-08 08:55:46 +00009648 VarDecl *IterationVar = VarDecl::Create(S.Context, S.CurContext, Loc, Loc,
Douglas Gregorb139cd52010-05-01 20:49:11 +00009649 IterationVarName, SizeType,
9650 S.Context.getTrivialTypeSourceInfo(SizeType, Loc),
Rafael Espindola6ae7e502013-04-03 19:27:57 +00009651 SC_None);
Richard Smith41ae3282012-11-14 00:50:40 +00009652
Douglas Gregorb139cd52010-05-01 20:49:11 +00009653 // Initialize the iteration variable to zero.
9654 llvm::APInt Zero(S.Context.getTypeSize(SizeType), 0);
Argyrios Kyrtzidis43b20572010-08-28 09:06:06 +00009655 IterationVar->setInit(IntegerLiteral::Create(S.Context, Zero, SizeType, Loc));
Douglas Gregorb139cd52010-05-01 20:49:11 +00009656
Pavel Labath58934982013-08-30 08:52:28 +00009657 // Creates a reference to the iteration variable.
9658 RefBuilder IterationVarRef(IterationVar, SizeType);
9659 LvalueConvBuilder IterationVarRefRVal(IterationVarRef);
Eli Friedman844f9452012-01-23 02:35:22 +00009660
Douglas Gregorb139cd52010-05-01 20:49:11 +00009661 // Create the DeclStmt that holds the iteration variable.
9662 Stmt *InitStmt = new (S.Context) DeclStmt(DeclGroupRef(IterationVar),Loc,Loc);
Richard Smith41ae3282012-11-14 00:50:40 +00009663
Douglas Gregorb139cd52010-05-01 20:49:11 +00009664 // Subscript the "from" and "to" expressions with the iteration variable.
Pavel Labath58934982013-08-30 08:52:28 +00009665 SubscriptBuilder FromIndexCopy(From, IterationVarRefRVal);
9666 MoveCastBuilder FromIndexMove(FromIndexCopy);
9667 const ExprBuilder *FromIndex;
9668 if (Copying)
9669 FromIndex = &FromIndexCopy;
9670 else
9671 FromIndex = &FromIndexMove;
9672
9673 SubscriptBuilder ToIndex(To, IterationVarRefRVal);
Sebastian Redl22653ba2011-08-30 19:58:05 +00009674
9675 // Build the copy/move for an individual element of the array.
Richard Smith41ae3282012-11-14 00:50:40 +00009676 StmtResult Copy =
9677 buildSingleCopyAssignRecursively(S, Loc, ArrayTy->getElementType(),
Pavel Labath58934982013-08-30 08:52:28 +00009678 ToIndex, *FromIndex, CopyingBaseSubobject,
Richard Smith41ae3282012-11-14 00:50:40 +00009679 Copying, Depth + 1);
9680 // Bail out if copying fails or if we determined that we should use memcpy.
9681 if (Copy.isInvalid() || !Copy.get())
9682 return Copy;
9683
9684 // Create the comparison against the array bound.
9685 llvm::APInt Upper
9686 = ArrayTy->getSize().zextOrTrunc(S.Context.getTypeSize(SizeType));
9687 Expr *Comparison
Pavel Labath58934982013-08-30 08:52:28 +00009688 = new (S.Context) BinaryOperator(IterationVarRefRVal.build(S, Loc),
Richard Smith41ae3282012-11-14 00:50:40 +00009689 IntegerLiteral::Create(S.Context, Upper, SizeType, Loc),
9690 BO_NE, S.Context.BoolTy,
9691 VK_RValue, OK_Ordinary, Loc, false);
9692
9693 // Create the pre-increment of the iteration variable.
9694 Expr *Increment
Pavel Labath58934982013-08-30 08:52:28 +00009695 = new (S.Context) UnaryOperator(IterationVarRef.build(S, Loc), UO_PreInc,
9696 SizeType, VK_LValue, OK_Ordinary, Loc);
Richard Smith41ae3282012-11-14 00:50:40 +00009697
Douglas Gregorb139cd52010-05-01 20:49:11 +00009698 // Construct the loop that copies all elements of this array.
John McCallb268a282010-08-23 23:25:46 +00009699 return S.ActOnForStmt(Loc, Loc, InitStmt,
Douglas Gregorb139cd52010-05-01 20:49:11 +00009700 S.MakeFullExpr(Comparison),
Craig Topperc3ec1492014-05-26 06:22:03 +00009701 nullptr, S.MakeFullDiscardedValueExpr(Increment),
Nikola Smiljanic01a75982014-05-29 10:55:11 +00009702 Loc, Copy.get());
Fariborz Jahanian41f79272009-06-25 21:45:19 +00009703}
9704
Richard Smith41ae3282012-11-14 00:50:40 +00009705static StmtResult
9706buildSingleCopyAssign(Sema &S, SourceLocation Loc, QualType T,
Pavel Labath58934982013-08-30 08:52:28 +00009707 const ExprBuilder &To, const ExprBuilder &From,
Richard Smith41ae3282012-11-14 00:50:40 +00009708 bool CopyingBaseSubobject, bool Copying) {
9709 // Maybe we should use a memcpy?
9710 if (T->isArrayType() && !T.isConstQualified() && !T.isVolatileQualified() &&
9711 T.isTriviallyCopyableType(S.Context))
9712 return buildMemcpyForAssignmentOp(S, Loc, T, To, From);
9713
9714 StmtResult Result(buildSingleCopyAssignRecursively(S, Loc, T, To, From,
9715 CopyingBaseSubobject,
9716 Copying, 0));
9717
9718 // If we ended up picking a trivial assignment operator for an array of a
9719 // non-trivially-copyable class type, just emit a memcpy.
9720 if (!Result.isInvalid() && !Result.get())
9721 return buildMemcpyForAssignmentOp(S, Loc, T, To, From);
9722
9723 return Result;
9724}
9725
Richard Smithd3b5c9082012-07-27 04:22:15 +00009726Sema::ImplicitExceptionSpecification
9727Sema::ComputeDefaultedCopyAssignmentExceptionSpec(CXXMethodDecl *MD) {
9728 CXXRecordDecl *ClassDecl = MD->getParent();
9729
9730 ImplicitExceptionSpecification ExceptSpec(*this);
9731 if (ClassDecl->isInvalidDecl())
9732 return ExceptSpec;
9733
9734 const FunctionProtoType *T = MD->getType()->castAs<FunctionProtoType>();
Alp Toker9cacbab2014-01-20 20:26:09 +00009735 assert(T->getNumParams() == 1 && "not a copy assignment op");
9736 unsigned ArgQuals =
9737 T->getParamType(0).getNonReferenceType().getCVRQualifiers();
Richard Smithd3b5c9082012-07-27 04:22:15 +00009738
Douglas Gregor68e11362010-07-01 17:48:08 +00009739 // C++ [except.spec]p14:
Richard Smithd3b5c9082012-07-27 04:22:15 +00009740 // An implicitly declared special member function (Clause 12) shall have an
Douglas Gregor68e11362010-07-01 17:48:08 +00009741 // exception-specification. [...]
Alexis Hunt491ec602011-06-21 23:42:56 +00009742
9743 // It is unspecified whether or not an implicit copy assignment operator
9744 // attempts to deduplicate calls to assignment operators of virtual bases are
9745 // made. As such, this exception specification is effectively unspecified.
9746 // Based on a similar decision made for constness in C++0x, we're erring on
9747 // the side of assuming such calls to be made regardless of whether they
9748 // actually happen.
Aaron Ballman574705e2014-03-13 15:41:46 +00009749 for (const auto &Base : ClassDecl->bases()) {
9750 if (Base.isVirtual())
Alexis Hunt491ec602011-06-21 23:42:56 +00009751 continue;
9752
Douglas Gregor330b9cf2010-07-02 21:50:04 +00009753 CXXRecordDecl *BaseClassDecl
Aaron Ballman574705e2014-03-13 15:41:46 +00009754 = cast<CXXRecordDecl>(Base.getType()->getAs<RecordType>()->getDecl());
Alexis Hunt491ec602011-06-21 23:42:56 +00009755 if (CXXMethodDecl *CopyAssign = LookupCopyingAssignment(BaseClassDecl,
9756 ArgQuals, false, 0))
Aaron Ballman574705e2014-03-13 15:41:46 +00009757 ExceptSpec.CalledDecl(Base.getLocStart(), CopyAssign);
Douglas Gregor68e11362010-07-01 17:48:08 +00009758 }
Alexis Hunt491ec602011-06-21 23:42:56 +00009759
Aaron Ballman445a9392014-03-13 16:15:17 +00009760 for (const auto &Base : ClassDecl->vbases()) {
Alexis Hunt491ec602011-06-21 23:42:56 +00009761 CXXRecordDecl *BaseClassDecl
Aaron Ballman445a9392014-03-13 16:15:17 +00009762 = cast<CXXRecordDecl>(Base.getType()->getAs<RecordType>()->getDecl());
Alexis Hunt491ec602011-06-21 23:42:56 +00009763 if (CXXMethodDecl *CopyAssign = LookupCopyingAssignment(BaseClassDecl,
9764 ArgQuals, false, 0))
Aaron Ballman445a9392014-03-13 16:15:17 +00009765 ExceptSpec.CalledDecl(Base.getLocStart(), CopyAssign);
Alexis Hunt491ec602011-06-21 23:42:56 +00009766 }
9767
Aaron Ballmane8a8bae2014-03-08 20:12:42 +00009768 for (const auto *Field : ClassDecl->fields()) {
David Blaikie2d7c57e2012-04-30 02:36:29 +00009769 QualType FieldType = Context.getBaseElementType(Field->getType());
Alexis Hunt491ec602011-06-21 23:42:56 +00009770 if (CXXRecordDecl *FieldClassDecl = FieldType->getAsCXXRecordDecl()) {
9771 if (CXXMethodDecl *CopyAssign =
Richard Smith1c6461e2012-07-18 03:36:00 +00009772 LookupCopyingAssignment(FieldClassDecl,
9773 ArgQuals | FieldType.getCVRQualifiers(),
9774 false, 0))
Richard Smithf623c962012-04-17 00:58:00 +00009775 ExceptSpec.CalledDecl(Field->getLocation(), CopyAssign);
Abramo Bagnaradd8fc042011-07-11 08:52:40 +00009776 }
Douglas Gregor68e11362010-07-01 17:48:08 +00009777 }
Sebastian Redlfa453cf2011-03-12 11:50:43 +00009778
Richard Smithd3b5c9082012-07-27 04:22:15 +00009779 return ExceptSpec;
Alexis Hunt119f3652011-05-14 05:23:20 +00009780}
9781
9782CXXMethodDecl *Sema::DeclareImplicitCopyAssignment(CXXRecordDecl *ClassDecl) {
9783 // Note: The following rules are largely analoguous to the copy
9784 // constructor rules. Note that virtual bases are not taken into account
9785 // for determining the argument type of the operator. Note also that
9786 // operators taking an object instead of a reference are allowed.
Richard Smith2be35f52012-12-01 02:35:44 +00009787 assert(ClassDecl->needsImplicitCopyAssignment());
Alexis Hunt119f3652011-05-14 05:23:20 +00009788
Richard Smith8bf22e52012-11-29 01:34:07 +00009789 DeclaringSpecialMember DSM(*this, ClassDecl, CXXCopyAssignment);
9790 if (DSM.isAlreadyBeingDeclared())
Craig Topperc3ec1492014-05-26 06:22:03 +00009791 return nullptr;
Richard Smith8bf22e52012-11-29 01:34:07 +00009792
Alexis Hunt119f3652011-05-14 05:23:20 +00009793 QualType ArgType = Context.getTypeDeclType(ClassDecl);
9794 QualType RetType = Context.getLValueReferenceType(ArgType);
Richard Smith99005e62013-05-07 03:19:20 +00009795 bool Const = ClassDecl->implicitCopyAssignmentHasConstParam();
9796 if (Const)
Alexis Hunt119f3652011-05-14 05:23:20 +00009797 ArgType = ArgType.withConst();
9798 ArgType = Context.getLValueReferenceType(ArgType);
9799
Richard Smith99005e62013-05-07 03:19:20 +00009800 bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
9801 CXXCopyAssignment,
9802 Const);
9803
Douglas Gregorf56ab7b2010-07-01 16:36:15 +00009804 // An implicitly-declared copy assignment operator is an inline public
9805 // member of its class.
9806 DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Equal);
Abramo Bagnaradff19302011-03-08 08:55:46 +00009807 SourceLocation ClassLoc = ClassDecl->getLocation();
9808 DeclarationNameInfo NameInfo(Name, ClassLoc);
Richard Smith99005e62013-05-07 03:19:20 +00009809 CXXMethodDecl *CopyAssignment =
9810 CXXMethodDecl::Create(Context, ClassDecl, ClassLoc, NameInfo, QualType(),
Craig Topperc3ec1492014-05-26 06:22:03 +00009811 /*TInfo=*/nullptr, /*StorageClass=*/SC_None,
9812 /*isInline=*/true, Constexpr, SourceLocation());
Douglas Gregorf56ab7b2010-07-01 16:36:15 +00009813 CopyAssignment->setAccess(AS_public);
Alexis Huntb2f27802011-05-14 05:23:24 +00009814 CopyAssignment->setDefaulted();
Douglas Gregorf56ab7b2010-07-01 16:36:15 +00009815 CopyAssignment->setImplicit();
Richard Smithd3b5c9082012-07-27 04:22:15 +00009816
Eli Bendersky9a220fc2014-09-29 20:38:29 +00009817 if (getLangOpts().CUDA) {
9818 inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXCopyAssignment,
9819 CopyAssignment,
9820 /* ConstRHS */ Const,
9821 /* Diagnose */ false);
9822 }
9823
Richard Smithd3b5c9082012-07-27 04:22:15 +00009824 // Build an exception specification pointing back at this member.
Reid Kleckner78af0702013-08-27 23:08:25 +00009825 FunctionProtoType::ExtProtoInfo EPI =
9826 getImplicitMethodEPI(*this, CopyAssignment);
Jordan Rose5c382722013-03-08 21:51:21 +00009827 CopyAssignment->setType(Context.getFunctionType(RetType, ArgType, EPI));
Richard Smithd3b5c9082012-07-27 04:22:15 +00009828
Douglas Gregorf56ab7b2010-07-01 16:36:15 +00009829 // Add the parameter to the operator.
9830 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyAssignment,
Craig Topperc3ec1492014-05-26 06:22:03 +00009831 ClassLoc, ClassLoc,
9832 /*Id=*/nullptr, ArgType,
9833 /*TInfo=*/nullptr, SC_None,
9834 nullptr);
David Blaikie9c70e042011-09-21 18:16:56 +00009835 CopyAssignment->setParams(FromParam);
Alexis Huntb2f27802011-05-14 05:23:24 +00009836
Richard Smith6b02d462012-12-08 08:32:28 +00009837 AddOverriddenMethods(ClassDecl, CopyAssignment);
9838
9839 CopyAssignment->setTrivial(
9840 ClassDecl->needsOverloadResolutionForCopyAssignment()
9841 ? SpecialMemberIsTrivial(CopyAssignment, CXXCopyAssignment)
9842 : ClassDecl->hasTrivialCopyAssignment());
9843
Richard Smith852265f2012-03-30 20:53:28 +00009844 if (ShouldDeleteSpecialMember(CopyAssignment, CXXCopyAssignment))
Richard Smithb4d2a152013-04-02 19:38:47 +00009845 SetDeclDeleted(CopyAssignment, ClassLoc);
Richard Smith852265f2012-03-30 20:53:28 +00009846
Richard Smith6b02d462012-12-08 08:32:28 +00009847 // Note that we have added this copy-assignment operator.
9848 ++ASTContext::NumImplicitCopyAssignmentOperatorsDeclared;
9849
9850 if (Scope *S = getScopeForContext(ClassDecl))
9851 PushOnScopeChains(CopyAssignment, S, false);
9852 ClassDecl->addDecl(CopyAssignment);
9853
Douglas Gregorf56ab7b2010-07-01 16:36:15 +00009854 return CopyAssignment;
9855}
9856
Richard Smithd577fbb2013-06-13 03:23:42 +00009857/// Diagnose an implicit copy operation for a class which is odr-used, but
9858/// which is deprecated because the class has a user-declared copy constructor,
9859/// copy assignment operator, or destructor.
9860static void diagnoseDeprecatedCopyOperation(Sema &S, CXXMethodDecl *CopyOp,
9861 SourceLocation UseLoc) {
9862 assert(CopyOp->isImplicit());
9863
9864 CXXRecordDecl *RD = CopyOp->getParent();
Craig Topperc3ec1492014-05-26 06:22:03 +00009865 CXXMethodDecl *UserDeclaredOperation = nullptr;
Richard Smithd577fbb2013-06-13 03:23:42 +00009866
9867 // In Microsoft mode, assignment operations don't affect constructors and
9868 // vice versa.
9869 if (RD->hasUserDeclaredDestructor()) {
9870 UserDeclaredOperation = RD->getDestructor();
9871 } else if (!isa<CXXConstructorDecl>(CopyOp) &&
9872 RD->hasUserDeclaredCopyConstructor() &&
Alp Tokerbfa39342014-01-14 12:51:41 +00009873 !S.getLangOpts().MSVCCompat) {
Richard Smithd577fbb2013-06-13 03:23:42 +00009874 // Find any user-declared copy constructor.
Aaron Ballman2a4bd6d2014-03-13 16:51:27 +00009875 for (auto *I : RD->ctors()) {
Richard Smithd577fbb2013-06-13 03:23:42 +00009876 if (I->isCopyConstructor()) {
Aaron Ballman2a4bd6d2014-03-13 16:51:27 +00009877 UserDeclaredOperation = I;
Richard Smithd577fbb2013-06-13 03:23:42 +00009878 break;
9879 }
9880 }
9881 assert(UserDeclaredOperation);
9882 } else if (isa<CXXConstructorDecl>(CopyOp) &&
9883 RD->hasUserDeclaredCopyAssignment() &&
Alp Tokerbfa39342014-01-14 12:51:41 +00009884 !S.getLangOpts().MSVCCompat) {
Richard Smithd577fbb2013-06-13 03:23:42 +00009885 // Find any user-declared move assignment operator.
Aaron Ballman2b124d12014-03-13 16:36:16 +00009886 for (auto *I : RD->methods()) {
Richard Smithd577fbb2013-06-13 03:23:42 +00009887 if (I->isCopyAssignmentOperator()) {
Aaron Ballman2b124d12014-03-13 16:36:16 +00009888 UserDeclaredOperation = I;
Richard Smithd577fbb2013-06-13 03:23:42 +00009889 break;
9890 }
9891 }
9892 assert(UserDeclaredOperation);
9893 }
9894
9895 if (UserDeclaredOperation) {
9896 S.Diag(UserDeclaredOperation->getLocation(),
9897 diag::warn_deprecated_copy_operation)
9898 << RD << /*copy assignment*/!isa<CXXConstructorDecl>(CopyOp)
9899 << /*destructor*/isa<CXXDestructorDecl>(UserDeclaredOperation);
9900 S.Diag(UseLoc, diag::note_member_synthesized_at)
9901 << (isa<CXXConstructorDecl>(CopyOp) ? Sema::CXXCopyConstructor
9902 : Sema::CXXCopyAssignment)
9903 << RD;
9904 }
9905}
9906
Douglas Gregorb139cd52010-05-01 20:49:11 +00009907void Sema::DefineImplicitCopyAssignment(SourceLocation CurrentLocation,
9908 CXXMethodDecl *CopyAssignOperator) {
Alexis Huntb2f27802011-05-14 05:23:24 +00009909 assert((CopyAssignOperator->isDefaulted() &&
Douglas Gregorb139cd52010-05-01 20:49:11 +00009910 CopyAssignOperator->isOverloadedOperator() &&
9911 CopyAssignOperator->getOverloadedOperator() == OO_Equal &&
Richard Smith273c4e92012-02-26 07:51:39 +00009912 !CopyAssignOperator->doesThisDeclarationHaveABody() &&
9913 !CopyAssignOperator->isDeleted()) &&
Douglas Gregorb139cd52010-05-01 20:49:11 +00009914 "DefineImplicitCopyAssignment called for wrong function");
9915
9916 CXXRecordDecl *ClassDecl = CopyAssignOperator->getParent();
9917
9918 if (ClassDecl->isInvalidDecl() || CopyAssignOperator->isInvalidDecl()) {
9919 CopyAssignOperator->setInvalidDecl();
9920 return;
9921 }
Richard Smithd577fbb2013-06-13 03:23:42 +00009922
9923 // C++11 [class.copy]p18:
9924 // The [definition of an implicitly declared copy assignment operator] is
9925 // deprecated if the class has a user-declared copy constructor or a
9926 // user-declared destructor.
9927 if (getLangOpts().CPlusPlus11 && CopyAssignOperator->isImplicit())
9928 diagnoseDeprecatedCopyOperation(*this, CopyAssignOperator, CurrentLocation);
9929
Eli Friedman276dd182013-09-05 00:02:25 +00009930 CopyAssignOperator->markUsed(Context);
Douglas Gregorb139cd52010-05-01 20:49:11 +00009931
Eli Friedmaneaf34142012-10-18 20:14:08 +00009932 SynthesizedFunctionScope Scope(*this, CopyAssignOperator);
Argyrios Kyrtzidis18653422010-11-19 00:19:12 +00009933 DiagnosticErrorTrap Trap(Diags);
Douglas Gregorb139cd52010-05-01 20:49:11 +00009934
9935 // C++0x [class.copy]p30:
9936 // The implicitly-defined or explicitly-defaulted copy assignment operator
9937 // for a non-union class X performs memberwise copy assignment of its
9938 // subobjects. The direct base classes of X are assigned first, in the
9939 // order of their declaration in the base-specifier-list, and then the
9940 // immediate non-static data members of X are assigned, in the order in
9941 // which they were declared in the class definition.
9942
9943 // The statements that form the synthesized function body.
Benjamin Kramerf0623432012-08-23 22:51:59 +00009944 SmallVector<Stmt*, 8> Statements;
Douglas Gregorb139cd52010-05-01 20:49:11 +00009945
9946 // The parameter for the "other" object, which we are copying from.
9947 ParmVarDecl *Other = CopyAssignOperator->getParamDecl(0);
9948 Qualifiers OtherQuals = Other->getType().getQualifiers();
9949 QualType OtherRefType = Other->getType();
9950 if (const LValueReferenceType *OtherRef
9951 = OtherRefType->getAs<LValueReferenceType>()) {
9952 OtherRefType = OtherRef->getPointeeType();
9953 OtherQuals = OtherRefType.getQualifiers();
9954 }
9955
9956 // Our location for everything implicitly-generated.
Daniel Jasperb3b0b802014-06-20 08:44:22 +00009957 SourceLocation Loc = CopyAssignOperator->getLocEnd().isValid()
9958 ? CopyAssignOperator->getLocEnd()
9959 : CopyAssignOperator->getLocation();
9960
Pavel Labath58934982013-08-30 08:52:28 +00009961 // Builds a DeclRefExpr for the "other" object.
9962 RefBuilder OtherRef(Other, OtherRefType);
9963
9964 // Builds the "this" pointer.
9965 ThisBuilder This;
Douglas Gregorb139cd52010-05-01 20:49:11 +00009966
9967 // Assign base classes.
9968 bool Invalid = false;
Aaron Ballman574705e2014-03-13 15:41:46 +00009969 for (auto &Base : ClassDecl->bases()) {
Douglas Gregorb139cd52010-05-01 20:49:11 +00009970 // Form the assignment:
9971 // static_cast<Base*>(this)->Base::operator=(static_cast<Base&>(other));
Aaron Ballman574705e2014-03-13 15:41:46 +00009972 QualType BaseType = Base.getType().getUnqualifiedType();
Jeffrey Yasskin8dfa5f12011-01-18 02:00:16 +00009973 if (!BaseType->isRecordType()) {
Douglas Gregorb139cd52010-05-01 20:49:11 +00009974 Invalid = true;
9975 continue;
9976 }
9977
John McCallcf142162010-08-07 06:22:56 +00009978 CXXCastPath BasePath;
Aaron Ballman574705e2014-03-13 15:41:46 +00009979 BasePath.push_back(&Base);
John McCallcf142162010-08-07 06:22:56 +00009980
Douglas Gregorb139cd52010-05-01 20:49:11 +00009981 // Construct the "from" expression, which is an implicit cast to the
9982 // appropriately-qualified base type.
Pavel Labath58934982013-08-30 08:52:28 +00009983 CastBuilder From(OtherRef, Context.getQualifiedType(BaseType, OtherQuals),
9984 VK_LValue, BasePath);
Douglas Gregorb139cd52010-05-01 20:49:11 +00009985
9986 // Dereference "this".
Pavel Labath58934982013-08-30 08:52:28 +00009987 DerefBuilder DerefThis(This);
9988 CastBuilder To(DerefThis,
9989 Context.getCVRQualifiedType(
9990 BaseType, CopyAssignOperator->getTypeQualifiers()),
9991 VK_LValue, BasePath);
Douglas Gregorb139cd52010-05-01 20:49:11 +00009992
9993 // Build the copy.
Richard Smith41ae3282012-11-14 00:50:40 +00009994 StmtResult Copy = buildSingleCopyAssign(*this, Loc, BaseType,
Pavel Labath58934982013-08-30 08:52:28 +00009995 To, From,
Sebastian Redl22653ba2011-08-30 19:58:05 +00009996 /*CopyingBaseSubobject=*/true,
9997 /*Copying=*/true);
Douglas Gregorb139cd52010-05-01 20:49:11 +00009998 if (Copy.isInvalid()) {
Douglas Gregorbf1fb442010-05-05 22:38:15 +00009999 Diag(CurrentLocation, diag::note_member_synthesized_at)
10000 << CXXCopyAssignment << Context.getTagDeclType(ClassDecl);
10001 CopyAssignOperator->setInvalidDecl();
10002 return;
Douglas Gregorb139cd52010-05-01 20:49:11 +000010003 }
10004
10005 // Success! Record the copy.
Nikola Smiljanic01a75982014-05-29 10:55:11 +000010006 Statements.push_back(Copy.getAs<Expr>());
Douglas Gregorb139cd52010-05-01 20:49:11 +000010007 }
10008
Douglas Gregorb139cd52010-05-01 20:49:11 +000010009 // Assign non-static members.
Aaron Ballmane8a8bae2014-03-08 20:12:42 +000010010 for (auto *Field : ClassDecl->fields()) {
Douglas Gregor556e5862011-10-10 17:22:13 +000010011 if (Field->isUnnamedBitfield())
10012 continue;
Eli Friedmanc9817fd2013-06-07 01:48:56 +000010013
10014 if (Field->isInvalidDecl()) {
10015 Invalid = true;
10016 continue;
10017 }
10018
Douglas Gregorb139cd52010-05-01 20:49:11 +000010019 // Check for members of reference type; we can't copy those.
10020 if (Field->getType()->isReferenceType()) {
10021 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
10022 << Context.getTagDeclType(ClassDecl) << 0 << Field->getDeclName();
10023 Diag(Field->getLocation(), diag::note_declared_at);
Douglas Gregorbf1fb442010-05-05 22:38:15 +000010024 Diag(CurrentLocation, diag::note_member_synthesized_at)
10025 << CXXCopyAssignment << Context.getTagDeclType(ClassDecl);
Douglas Gregorb139cd52010-05-01 20:49:11 +000010026 Invalid = true;
10027 continue;
10028 }
10029
10030 // Check for members of const-qualified, non-class type.
10031 QualType BaseType = Context.getBaseElementType(Field->getType());
10032 if (!BaseType->getAs<RecordType>() && BaseType.isConstQualified()) {
10033 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
10034 << Context.getTagDeclType(ClassDecl) << 1 << Field->getDeclName();
10035 Diag(Field->getLocation(), diag::note_declared_at);
Douglas Gregorbf1fb442010-05-05 22:38:15 +000010036 Diag(CurrentLocation, diag::note_member_synthesized_at)
10037 << CXXCopyAssignment << Context.getTagDeclType(ClassDecl);
Douglas Gregorb139cd52010-05-01 20:49:11 +000010038 Invalid = true;
10039 continue;
10040 }
John McCall1b1a1db2011-06-17 00:18:42 +000010041
10042 // Suppress assigning zero-width bitfields.
Richard Smithcaf33902011-10-10 18:28:20 +000010043 if (Field->isBitField() && Field->getBitWidthValue(Context) == 0)
10044 continue;
Douglas Gregorb139cd52010-05-01 20:49:11 +000010045
10046 QualType FieldType = Field->getType().getNonReferenceType();
Fariborz Jahanian1138ba62010-05-26 20:19:07 +000010047 if (FieldType->isIncompleteArrayType()) {
10048 assert(ClassDecl->hasFlexibleArrayMember() &&
10049 "Incomplete array type is not valid");
10050 continue;
10051 }
Douglas Gregorb139cd52010-05-01 20:49:11 +000010052
10053 // Build references to the field in the object we're copying from and to.
10054 CXXScopeSpec SS; // Intentionally empty
10055 LookupResult MemberLookup(*this, Field->getDeclName(), Loc,
10056 LookupMemberName);
Aaron Ballmane8a8bae2014-03-08 20:12:42 +000010057 MemberLookup.addDecl(Field);
Douglas Gregorb139cd52010-05-01 20:49:11 +000010058 MemberLookup.resolveKind();
Pavel Labath58934982013-08-30 08:52:28 +000010059
10060 MemberBuilder From(OtherRef, OtherRefType, /*IsArrow=*/false, MemberLookup);
10061
10062 MemberBuilder To(This, getCurrentThisType(), /*IsArrow=*/true, MemberLookup);
Douglas Gregorb139cd52010-05-01 20:49:11 +000010063
Douglas Gregorb139cd52010-05-01 20:49:11 +000010064 // Build the copy of this field.
Richard Smith41ae3282012-11-14 00:50:40 +000010065 StmtResult Copy = buildSingleCopyAssign(*this, Loc, FieldType,
Pavel Labath58934982013-08-30 08:52:28 +000010066 To, From,
Sebastian Redl22653ba2011-08-30 19:58:05 +000010067 /*CopyingBaseSubobject=*/false,
10068 /*Copying=*/true);
Douglas Gregorb139cd52010-05-01 20:49:11 +000010069 if (Copy.isInvalid()) {
Douglas Gregorbf1fb442010-05-05 22:38:15 +000010070 Diag(CurrentLocation, diag::note_member_synthesized_at)
10071 << CXXCopyAssignment << Context.getTagDeclType(ClassDecl);
10072 CopyAssignOperator->setInvalidDecl();
10073 return;
Douglas Gregorb139cd52010-05-01 20:49:11 +000010074 }
10075
10076 // Success! Record the copy.
Nikola Smiljanic01a75982014-05-29 10:55:11 +000010077 Statements.push_back(Copy.getAs<Stmt>());
Douglas Gregorb139cd52010-05-01 20:49:11 +000010078 }
10079
10080 if (!Invalid) {
10081 // Add a "return *this;"
Pavel Labath58934982013-08-30 08:52:28 +000010082 ExprResult ThisObj = CreateBuiltinUnaryOp(Loc, UO_Deref, This.build(*this, Loc));
Douglas Gregorb139cd52010-05-01 20:49:11 +000010083
Nick Lewyckyd78f92f2014-05-03 00:41:18 +000010084 StmtResult Return = BuildReturnStmt(Loc, ThisObj.get());
Douglas Gregorb139cd52010-05-01 20:49:11 +000010085 if (Return.isInvalid())
10086 Invalid = true;
10087 else {
Nikola Smiljanic01a75982014-05-29 10:55:11 +000010088 Statements.push_back(Return.getAs<Stmt>());
Douglas Gregor54818f02010-05-12 16:39:35 +000010089
10090 if (Trap.hasErrorOccurred()) {
10091 Diag(CurrentLocation, diag::note_member_synthesized_at)
10092 << CXXCopyAssignment << Context.getTagDeclType(ClassDecl);
10093 Invalid = true;
10094 }
Douglas Gregorb139cd52010-05-01 20:49:11 +000010095 }
10096 }
10097
Ben Langmuir2f8e6b82014-09-25 20:55:00 +000010098 // The exception specification is needed because we are defining the
10099 // function.
10100 ResolveExceptionSpec(CurrentLocation,
10101 CopyAssignOperator->getType()->castAs<FunctionProtoType>());
10102
Douglas Gregorb139cd52010-05-01 20:49:11 +000010103 if (Invalid) {
10104 CopyAssignOperator->setInvalidDecl();
10105 return;
10106 }
Dmitri Gribenko800ddf32012-02-14 22:14:32 +000010107
10108 StmtResult Body;
10109 {
10110 CompoundScopeRAII CompoundScope(*this);
Benjamin Kramer62b95d82012-08-23 21:35:17 +000010111 Body = ActOnCompoundStmt(Loc, Loc, Statements,
Dmitri Gribenko800ddf32012-02-14 22:14:32 +000010112 /*isStmtExpr=*/false);
10113 assert(!Body.isInvalid() && "Compound statement creation cannot fail");
10114 }
Nikola Smiljanic01a75982014-05-29 10:55:11 +000010115 CopyAssignOperator->setBody(Body.getAs<Stmt>());
Sebastian Redlab238a72011-04-24 16:28:06 +000010116
10117 if (ASTMutationListener *L = getASTMutationListener()) {
10118 L->CompletedImplicitDefinition(CopyAssignOperator);
10119 }
Fariborz Jahanian41f79272009-06-25 21:45:19 +000010120}
10121
Sebastian Redl22653ba2011-08-30 19:58:05 +000010122Sema::ImplicitExceptionSpecification
Richard Smithd3b5c9082012-07-27 04:22:15 +000010123Sema::ComputeDefaultedMoveAssignmentExceptionSpec(CXXMethodDecl *MD) {
10124 CXXRecordDecl *ClassDecl = MD->getParent();
Sebastian Redl22653ba2011-08-30 19:58:05 +000010125
Richard Smithd3b5c9082012-07-27 04:22:15 +000010126 ImplicitExceptionSpecification ExceptSpec(*this);
Sebastian Redl22653ba2011-08-30 19:58:05 +000010127 if (ClassDecl->isInvalidDecl())
10128 return ExceptSpec;
10129
10130 // C++0x [except.spec]p14:
10131 // An implicitly declared special member function (Clause 12) shall have an
10132 // exception-specification. [...]
10133
10134 // It is unspecified whether or not an implicit move assignment operator
10135 // attempts to deduplicate calls to assignment operators of virtual bases are
10136 // made. As such, this exception specification is effectively unspecified.
10137 // Based on a similar decision made for constness in C++0x, we're erring on
10138 // the side of assuming such calls to be made regardless of whether they
10139 // actually happen.
10140 // Note that a move constructor is not implicitly declared when there are
10141 // virtual bases, but it can still be user-declared and explicitly defaulted.
Aaron Ballman574705e2014-03-13 15:41:46 +000010142 for (const auto &Base : ClassDecl->bases()) {
10143 if (Base.isVirtual())
Sebastian Redl22653ba2011-08-30 19:58:05 +000010144 continue;
10145
10146 CXXRecordDecl *BaseClassDecl
Aaron Ballman574705e2014-03-13 15:41:46 +000010147 = cast<CXXRecordDecl>(Base.getType()->getAs<RecordType>()->getDecl());
Sebastian Redl22653ba2011-08-30 19:58:05 +000010148 if (CXXMethodDecl *MoveAssign = LookupMovingAssignment(BaseClassDecl,
Richard Smith1c6461e2012-07-18 03:36:00 +000010149 0, false, 0))
Aaron Ballman574705e2014-03-13 15:41:46 +000010150 ExceptSpec.CalledDecl(Base.getLocStart(), MoveAssign);
Sebastian Redl22653ba2011-08-30 19:58:05 +000010151 }
10152
Aaron Ballman445a9392014-03-13 16:15:17 +000010153 for (const auto &Base : ClassDecl->vbases()) {
Sebastian Redl22653ba2011-08-30 19:58:05 +000010154 CXXRecordDecl *BaseClassDecl
Aaron Ballman445a9392014-03-13 16:15:17 +000010155 = cast<CXXRecordDecl>(Base.getType()->getAs<RecordType>()->getDecl());
Sebastian Redl22653ba2011-08-30 19:58:05 +000010156 if (CXXMethodDecl *MoveAssign = LookupMovingAssignment(BaseClassDecl,
Richard Smith1c6461e2012-07-18 03:36:00 +000010157 0, false, 0))
Aaron Ballman445a9392014-03-13 16:15:17 +000010158 ExceptSpec.CalledDecl(Base.getLocStart(), MoveAssign);
Sebastian Redl22653ba2011-08-30 19:58:05 +000010159 }
10160
Aaron Ballmane8a8bae2014-03-08 20:12:42 +000010161 for (const auto *Field : ClassDecl->fields()) {
David Blaikie2d7c57e2012-04-30 02:36:29 +000010162 QualType FieldType = Context.getBaseElementType(Field->getType());
Sebastian Redl22653ba2011-08-30 19:58:05 +000010163 if (CXXRecordDecl *FieldClassDecl = FieldType->getAsCXXRecordDecl()) {
Richard Smith1c6461e2012-07-18 03:36:00 +000010164 if (CXXMethodDecl *MoveAssign =
10165 LookupMovingAssignment(FieldClassDecl,
10166 FieldType.getCVRQualifiers(),
10167 false, 0))
Richard Smithf623c962012-04-17 00:58:00 +000010168 ExceptSpec.CalledDecl(Field->getLocation(), MoveAssign);
Sebastian Redl22653ba2011-08-30 19:58:05 +000010169 }
10170 }
10171
10172 return ExceptSpec;
10173}
10174
10175CXXMethodDecl *Sema::DeclareImplicitMoveAssignment(CXXRecordDecl *ClassDecl) {
Richard Smithcf8ec8d2012-04-02 18:40:40 +000010176 assert(ClassDecl->needsImplicitMoveAssignment());
10177
Richard Smith8bf22e52012-11-29 01:34:07 +000010178 DeclaringSpecialMember DSM(*this, ClassDecl, CXXMoveAssignment);
10179 if (DSM.isAlreadyBeingDeclared())
Craig Topperc3ec1492014-05-26 06:22:03 +000010180 return nullptr;
Richard Smith8bf22e52012-11-29 01:34:07 +000010181
Sebastian Redl22653ba2011-08-30 19:58:05 +000010182 // Note: The following rules are largely analoguous to the move
10183 // constructor rules.
10184
Sebastian Redl22653ba2011-08-30 19:58:05 +000010185 QualType ArgType = Context.getTypeDeclType(ClassDecl);
10186 QualType RetType = Context.getLValueReferenceType(ArgType);
10187 ArgType = Context.getRValueReferenceType(ArgType);
10188
Richard Smith99005e62013-05-07 03:19:20 +000010189 bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
10190 CXXMoveAssignment,
10191 false);
10192
Sebastian Redl22653ba2011-08-30 19:58:05 +000010193 // An implicitly-declared move assignment operator is an inline public
10194 // member of its class.
Sebastian Redl22653ba2011-08-30 19:58:05 +000010195 DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Equal);
10196 SourceLocation ClassLoc = ClassDecl->getLocation();
10197 DeclarationNameInfo NameInfo(Name, ClassLoc);
Richard Smith99005e62013-05-07 03:19:20 +000010198 CXXMethodDecl *MoveAssignment =
10199 CXXMethodDecl::Create(Context, ClassDecl, ClassLoc, NameInfo, QualType(),
Craig Topperc3ec1492014-05-26 06:22:03 +000010200 /*TInfo=*/nullptr, /*StorageClass=*/SC_None,
Richard Smith99005e62013-05-07 03:19:20 +000010201 /*isInline=*/true, Constexpr, SourceLocation());
Sebastian Redl22653ba2011-08-30 19:58:05 +000010202 MoveAssignment->setAccess(AS_public);
10203 MoveAssignment->setDefaulted();
10204 MoveAssignment->setImplicit();
Sebastian Redl22653ba2011-08-30 19:58:05 +000010205
Eli Bendersky9a220fc2014-09-29 20:38:29 +000010206 if (getLangOpts().CUDA) {
10207 inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXMoveAssignment,
10208 MoveAssignment,
10209 /* ConstRHS */ false,
10210 /* Diagnose */ false);
10211 }
10212
Richard Smithd3b5c9082012-07-27 04:22:15 +000010213 // Build an exception specification pointing back at this member.
Reid Kleckner78af0702013-08-27 23:08:25 +000010214 FunctionProtoType::ExtProtoInfo EPI =
10215 getImplicitMethodEPI(*this, MoveAssignment);
Jordan Rose5c382722013-03-08 21:51:21 +000010216 MoveAssignment->setType(Context.getFunctionType(RetType, ArgType, EPI));
Richard Smithd3b5c9082012-07-27 04:22:15 +000010217
Sebastian Redl22653ba2011-08-30 19:58:05 +000010218 // Add the parameter to the operator.
10219 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, MoveAssignment,
Craig Topperc3ec1492014-05-26 06:22:03 +000010220 ClassLoc, ClassLoc,
10221 /*Id=*/nullptr, ArgType,
10222 /*TInfo=*/nullptr, SC_None,
10223 nullptr);
David Blaikie9c70e042011-09-21 18:16:56 +000010224 MoveAssignment->setParams(FromParam);
Sebastian Redl22653ba2011-08-30 19:58:05 +000010225
Richard Smith6b02d462012-12-08 08:32:28 +000010226 AddOverriddenMethods(ClassDecl, MoveAssignment);
10227
10228 MoveAssignment->setTrivial(
10229 ClassDecl->needsOverloadResolutionForMoveAssignment()
10230 ? SpecialMemberIsTrivial(MoveAssignment, CXXMoveAssignment)
10231 : ClassDecl->hasTrivialMoveAssignment());
Sebastian Redl22653ba2011-08-30 19:58:05 +000010232
Richard Smithd951a1d2012-02-18 02:02:13 +000010233 if (ShouldDeleteSpecialMember(MoveAssignment, CXXMoveAssignment)) {
Richard Smith8b86f2d2013-11-04 01:48:18 +000010234 ClassDecl->setImplicitMoveAssignmentIsDeleted();
10235 SetDeclDeleted(MoveAssignment, ClassLoc);
Sebastian Redl22653ba2011-08-30 19:58:05 +000010236 }
10237
Richard Smith6b02d462012-12-08 08:32:28 +000010238 // Note that we have added this copy-assignment operator.
10239 ++ASTContext::NumImplicitMoveAssignmentOperatorsDeclared;
10240
Sebastian Redl22653ba2011-08-30 19:58:05 +000010241 if (Scope *S = getScopeForContext(ClassDecl))
10242 PushOnScopeChains(MoveAssignment, S, false);
10243 ClassDecl->addDecl(MoveAssignment);
10244
Sebastian Redl22653ba2011-08-30 19:58:05 +000010245 return MoveAssignment;
10246}
10247
Richard Smithb2504bd2013-11-04 04:26:14 +000010248/// Check if we're implicitly defining a move assignment operator for a class
10249/// with virtual bases. Such a move assignment might move-assign the virtual
10250/// base multiple times.
10251static void checkMoveAssignmentForRepeatedMove(Sema &S, CXXRecordDecl *Class,
10252 SourceLocation CurrentLocation) {
10253 assert(!Class->isDependentContext() && "should not define dependent move");
10254
10255 // Only a virtual base could get implicitly move-assigned multiple times.
10256 // Only a non-trivial move assignment can observe this. We only want to
10257 // diagnose if we implicitly define an assignment operator that assigns
10258 // two base classes, both of which move-assign the same virtual base.
10259 if (Class->getNumVBases() == 0 || Class->hasTrivialMoveAssignment() ||
10260 Class->getNumBases() < 2)
10261 return;
10262
10263 llvm::SmallVector<CXXBaseSpecifier *, 16> Worklist;
10264 typedef llvm::DenseMap<CXXRecordDecl*, CXXBaseSpecifier*> VBaseMap;
10265 VBaseMap VBases;
10266
Aaron Ballman574705e2014-03-13 15:41:46 +000010267 for (auto &BI : Class->bases()) {
10268 Worklist.push_back(&BI);
Richard Smithb2504bd2013-11-04 04:26:14 +000010269 while (!Worklist.empty()) {
10270 CXXBaseSpecifier *BaseSpec = Worklist.pop_back_val();
10271 CXXRecordDecl *Base = BaseSpec->getType()->getAsCXXRecordDecl();
10272
10273 // If the base has no non-trivial move assignment operators,
10274 // we don't care about moves from it.
10275 if (!Base->hasNonTrivialMoveAssignment())
10276 continue;
10277
10278 // If there's nothing virtual here, skip it.
10279 if (!BaseSpec->isVirtual() && !Base->getNumVBases())
10280 continue;
10281
10282 // If we're not actually going to call a move assignment for this base,
10283 // or the selected move assignment is trivial, skip it.
10284 Sema::SpecialMemberOverloadResult *SMOR =
10285 S.LookupSpecialMember(Base, Sema::CXXMoveAssignment,
10286 /*ConstArg*/false, /*VolatileArg*/false,
10287 /*RValueThis*/true, /*ConstThis*/false,
10288 /*VolatileThis*/false);
10289 if (!SMOR->getMethod() || SMOR->getMethod()->isTrivial() ||
10290 !SMOR->getMethod()->isMoveAssignmentOperator())
10291 continue;
10292
10293 if (BaseSpec->isVirtual()) {
10294 // We're going to move-assign this virtual base, and its move
10295 // assignment operator is not trivial. If this can happen for
10296 // multiple distinct direct bases of Class, diagnose it. (If it
10297 // only happens in one base, we'll diagnose it when synthesizing
10298 // that base class's move assignment operator.)
10299 CXXBaseSpecifier *&Existing =
Aaron Ballman574705e2014-03-13 15:41:46 +000010300 VBases.insert(std::make_pair(Base->getCanonicalDecl(), &BI))
Richard Smithb2504bd2013-11-04 04:26:14 +000010301 .first->second;
Aaron Ballman574705e2014-03-13 15:41:46 +000010302 if (Existing && Existing != &BI) {
Richard Smithb2504bd2013-11-04 04:26:14 +000010303 S.Diag(CurrentLocation, diag::warn_vbase_moved_multiple_times)
10304 << Class << Base;
10305 S.Diag(Existing->getLocStart(), diag::note_vbase_moved_here)
10306 << (Base->getCanonicalDecl() ==
10307 Existing->getType()->getAsCXXRecordDecl()->getCanonicalDecl())
10308 << Base << Existing->getType() << Existing->getSourceRange();
Aaron Ballman574705e2014-03-13 15:41:46 +000010309 S.Diag(BI.getLocStart(), diag::note_vbase_moved_here)
Richard Smithb2504bd2013-11-04 04:26:14 +000010310 << (Base->getCanonicalDecl() ==
Aaron Ballman574705e2014-03-13 15:41:46 +000010311 BI.getType()->getAsCXXRecordDecl()->getCanonicalDecl())
10312 << Base << BI.getType() << BaseSpec->getSourceRange();
Richard Smithb2504bd2013-11-04 04:26:14 +000010313
10314 // Only diagnose each vbase once.
Craig Topperc3ec1492014-05-26 06:22:03 +000010315 Existing = nullptr;
Richard Smithb2504bd2013-11-04 04:26:14 +000010316 }
10317 } else {
10318 // Only walk over bases that have defaulted move assignment operators.
10319 // We assume that any user-provided move assignment operator handles
10320 // the multiple-moves-of-vbase case itself somehow.
10321 if (!SMOR->getMethod()->isDefaulted())
10322 continue;
10323
10324 // We're going to move the base classes of Base. Add them to the list.
Aaron Ballman574705e2014-03-13 15:41:46 +000010325 for (auto &BI : Base->bases())
10326 Worklist.push_back(&BI);
Richard Smithb2504bd2013-11-04 04:26:14 +000010327 }
10328 }
10329 }
10330}
10331
Sebastian Redl22653ba2011-08-30 19:58:05 +000010332void Sema::DefineImplicitMoveAssignment(SourceLocation CurrentLocation,
10333 CXXMethodDecl *MoveAssignOperator) {
10334 assert((MoveAssignOperator->isDefaulted() &&
10335 MoveAssignOperator->isOverloadedOperator() &&
10336 MoveAssignOperator->getOverloadedOperator() == OO_Equal &&
Richard Smith273c4e92012-02-26 07:51:39 +000010337 !MoveAssignOperator->doesThisDeclarationHaveABody() &&
10338 !MoveAssignOperator->isDeleted()) &&
Sebastian Redl22653ba2011-08-30 19:58:05 +000010339 "DefineImplicitMoveAssignment called for wrong function");
10340
10341 CXXRecordDecl *ClassDecl = MoveAssignOperator->getParent();
10342
10343 if (ClassDecl->isInvalidDecl() || MoveAssignOperator->isInvalidDecl()) {
10344 MoveAssignOperator->setInvalidDecl();
10345 return;
10346 }
10347
Eli Friedman276dd182013-09-05 00:02:25 +000010348 MoveAssignOperator->markUsed(Context);
Sebastian Redl22653ba2011-08-30 19:58:05 +000010349
Eli Friedmaneaf34142012-10-18 20:14:08 +000010350 SynthesizedFunctionScope Scope(*this, MoveAssignOperator);
Sebastian Redl22653ba2011-08-30 19:58:05 +000010351 DiagnosticErrorTrap Trap(Diags);
10352
10353 // C++0x [class.copy]p28:
10354 // The implicitly-defined or move assignment operator for a non-union class
10355 // X performs memberwise move assignment of its subobjects. The direct base
10356 // classes of X are assigned first, in the order of their declaration in the
10357 // base-specifier-list, and then the immediate non-static data members of X
10358 // are assigned, in the order in which they were declared in the class
10359 // definition.
10360
Richard Smithb2504bd2013-11-04 04:26:14 +000010361 // Issue a warning if our implicit move assignment operator will move
10362 // from a virtual base more than once.
10363 checkMoveAssignmentForRepeatedMove(*this, ClassDecl, CurrentLocation);
Richard Smith8b86f2d2013-11-04 01:48:18 +000010364
Sebastian Redl22653ba2011-08-30 19:58:05 +000010365 // The statements that form the synthesized function body.
Benjamin Kramerf0623432012-08-23 22:51:59 +000010366 SmallVector<Stmt*, 8> Statements;
Sebastian Redl22653ba2011-08-30 19:58:05 +000010367
10368 // The parameter for the "other" object, which we are move from.
10369 ParmVarDecl *Other = MoveAssignOperator->getParamDecl(0);
10370 QualType OtherRefType = Other->getType()->
10371 getAs<RValueReferenceType>()->getPointeeType();
David Blaikie7d170102013-05-15 07:37:26 +000010372 assert(!OtherRefType.getQualifiers() &&
Sebastian Redl22653ba2011-08-30 19:58:05 +000010373 "Bad argument type of defaulted move assignment");
10374
10375 // Our location for everything implicitly-generated.
Daniel Jasperb3b0b802014-06-20 08:44:22 +000010376 SourceLocation Loc = MoveAssignOperator->getLocEnd().isValid()
10377 ? MoveAssignOperator->getLocEnd()
10378 : MoveAssignOperator->getLocation();
Sebastian Redl22653ba2011-08-30 19:58:05 +000010379
Pavel Labath58934982013-08-30 08:52:28 +000010380 // Builds a reference to the "other" object.
10381 RefBuilder OtherRef(Other, OtherRefType);
Sebastian Redl22653ba2011-08-30 19:58:05 +000010382 // Cast to rvalue.
Pavel Labath58934982013-08-30 08:52:28 +000010383 MoveCastBuilder MoveOther(OtherRef);
Sebastian Redl22653ba2011-08-30 19:58:05 +000010384
Pavel Labath58934982013-08-30 08:52:28 +000010385 // Builds the "this" pointer.
10386 ThisBuilder This;
Richard Smithcf8ec8d2012-04-02 18:40:40 +000010387
Sebastian Redl22653ba2011-08-30 19:58:05 +000010388 // Assign base classes.
10389 bool Invalid = false;
Aaron Ballman574705e2014-03-13 15:41:46 +000010390 for (auto &Base : ClassDecl->bases()) {
Richard Smithb2504bd2013-11-04 04:26:14 +000010391 // C++11 [class.copy]p28:
10392 // It is unspecified whether subobjects representing virtual base classes
10393 // are assigned more than once by the implicitly-defined copy assignment
10394 // operator.
10395 // FIXME: Do not assign to a vbase that will be assigned by some other base
10396 // class. For a move-assignment, this can result in the vbase being moved
10397 // multiple times.
10398
Sebastian Redl22653ba2011-08-30 19:58:05 +000010399 // Form the assignment:
10400 // static_cast<Base*>(this)->Base::operator=(static_cast<Base&&>(other));
Aaron Ballman574705e2014-03-13 15:41:46 +000010401 QualType BaseType = Base.getType().getUnqualifiedType();
Sebastian Redl22653ba2011-08-30 19:58:05 +000010402 if (!BaseType->isRecordType()) {
10403 Invalid = true;
10404 continue;
10405 }
10406
10407 CXXCastPath BasePath;
Aaron Ballman574705e2014-03-13 15:41:46 +000010408 BasePath.push_back(&Base);
Sebastian Redl22653ba2011-08-30 19:58:05 +000010409
10410 // Construct the "from" expression, which is an implicit cast to the
10411 // appropriately-qualified base type.
Pavel Labath58934982013-08-30 08:52:28 +000010412 CastBuilder From(OtherRef, BaseType, VK_XValue, BasePath);
Sebastian Redl22653ba2011-08-30 19:58:05 +000010413
10414 // Dereference "this".
Pavel Labath58934982013-08-30 08:52:28 +000010415 DerefBuilder DerefThis(This);
Sebastian Redl22653ba2011-08-30 19:58:05 +000010416
10417 // Implicitly cast "this" to the appropriately-qualified base type.
Pavel Labath58934982013-08-30 08:52:28 +000010418 CastBuilder To(DerefThis,
10419 Context.getCVRQualifiedType(
10420 BaseType, MoveAssignOperator->getTypeQualifiers()),
10421 VK_LValue, BasePath);
Sebastian Redl22653ba2011-08-30 19:58:05 +000010422
10423 // Build the move.
Richard Smith41ae3282012-11-14 00:50:40 +000010424 StmtResult Move = buildSingleCopyAssign(*this, Loc, BaseType,
Pavel Labath58934982013-08-30 08:52:28 +000010425 To, From,
Sebastian Redl22653ba2011-08-30 19:58:05 +000010426 /*CopyingBaseSubobject=*/true,
10427 /*Copying=*/false);
10428 if (Move.isInvalid()) {
10429 Diag(CurrentLocation, diag::note_member_synthesized_at)
10430 << CXXMoveAssignment << Context.getTagDeclType(ClassDecl);
10431 MoveAssignOperator->setInvalidDecl();
10432 return;
10433 }
10434
10435 // Success! Record the move.
Nikola Smiljanic01a75982014-05-29 10:55:11 +000010436 Statements.push_back(Move.getAs<Expr>());
Sebastian Redl22653ba2011-08-30 19:58:05 +000010437 }
10438
Sebastian Redl22653ba2011-08-30 19:58:05 +000010439 // Assign non-static members.
Aaron Ballmane8a8bae2014-03-08 20:12:42 +000010440 for (auto *Field : ClassDecl->fields()) {
Douglas Gregor556e5862011-10-10 17:22:13 +000010441 if (Field->isUnnamedBitfield())
10442 continue;
10443
Eli Friedmanc9817fd2013-06-07 01:48:56 +000010444 if (Field->isInvalidDecl()) {
10445 Invalid = true;
10446 continue;
10447 }
10448
Sebastian Redl22653ba2011-08-30 19:58:05 +000010449 // Check for members of reference type; we can't move those.
10450 if (Field->getType()->isReferenceType()) {
10451 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
10452 << Context.getTagDeclType(ClassDecl) << 0 << Field->getDeclName();
10453 Diag(Field->getLocation(), diag::note_declared_at);
10454 Diag(CurrentLocation, diag::note_member_synthesized_at)
10455 << CXXMoveAssignment << Context.getTagDeclType(ClassDecl);
10456 Invalid = true;
10457 continue;
10458 }
10459
10460 // Check for members of const-qualified, non-class type.
10461 QualType BaseType = Context.getBaseElementType(Field->getType());
10462 if (!BaseType->getAs<RecordType>() && BaseType.isConstQualified()) {
10463 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
10464 << Context.getTagDeclType(ClassDecl) << 1 << Field->getDeclName();
10465 Diag(Field->getLocation(), diag::note_declared_at);
10466 Diag(CurrentLocation, diag::note_member_synthesized_at)
10467 << CXXMoveAssignment << Context.getTagDeclType(ClassDecl);
10468 Invalid = true;
10469 continue;
10470 }
10471
10472 // Suppress assigning zero-width bitfields.
Richard Smithcaf33902011-10-10 18:28:20 +000010473 if (Field->isBitField() && Field->getBitWidthValue(Context) == 0)
10474 continue;
Sebastian Redl22653ba2011-08-30 19:58:05 +000010475
10476 QualType FieldType = Field->getType().getNonReferenceType();
10477 if (FieldType->isIncompleteArrayType()) {
10478 assert(ClassDecl->hasFlexibleArrayMember() &&
10479 "Incomplete array type is not valid");
10480 continue;
10481 }
10482
10483 // Build references to the field in the object we're copying from and to.
Sebastian Redl22653ba2011-08-30 19:58:05 +000010484 LookupResult MemberLookup(*this, Field->getDeclName(), Loc,
10485 LookupMemberName);
Aaron Ballmane8a8bae2014-03-08 20:12:42 +000010486 MemberLookup.addDecl(Field);
Sebastian Redl22653ba2011-08-30 19:58:05 +000010487 MemberLookup.resolveKind();
Pavel Labath58934982013-08-30 08:52:28 +000010488 MemberBuilder From(MoveOther, OtherRefType,
10489 /*IsArrow=*/false, MemberLookup);
10490 MemberBuilder To(This, getCurrentThisType(),
10491 /*IsArrow=*/true, MemberLookup);
Sebastian Redl22653ba2011-08-30 19:58:05 +000010492
Pavel Labath58934982013-08-30 08:52:28 +000010493 assert(!From.build(*this, Loc)->isLValue() && // could be xvalue or prvalue
Sebastian Redl22653ba2011-08-30 19:58:05 +000010494 "Member reference with rvalue base must be rvalue except for reference "
10495 "members, which aren't allowed for move assignment.");
10496
Sebastian Redl22653ba2011-08-30 19:58:05 +000010497 // Build the move of this field.
Richard Smith41ae3282012-11-14 00:50:40 +000010498 StmtResult Move = buildSingleCopyAssign(*this, Loc, FieldType,
Pavel Labath58934982013-08-30 08:52:28 +000010499 To, From,
Sebastian Redl22653ba2011-08-30 19:58:05 +000010500 /*CopyingBaseSubobject=*/false,
10501 /*Copying=*/false);
10502 if (Move.isInvalid()) {
10503 Diag(CurrentLocation, diag::note_member_synthesized_at)
10504 << CXXMoveAssignment << Context.getTagDeclType(ClassDecl);
10505 MoveAssignOperator->setInvalidDecl();
10506 return;
10507 }
Richard Smith11d19592012-11-12 23:33:00 +000010508
Sebastian Redl22653ba2011-08-30 19:58:05 +000010509 // Success! Record the copy.
Nikola Smiljanic01a75982014-05-29 10:55:11 +000010510 Statements.push_back(Move.getAs<Stmt>());
Sebastian Redl22653ba2011-08-30 19:58:05 +000010511 }
10512
10513 if (!Invalid) {
10514 // Add a "return *this;"
Daniel Jasperb3b0b802014-06-20 08:44:22 +000010515 ExprResult ThisObj =
10516 CreateBuiltinUnaryOp(Loc, UO_Deref, This.build(*this, Loc));
10517
Nick Lewyckyd78f92f2014-05-03 00:41:18 +000010518 StmtResult Return = BuildReturnStmt(Loc, ThisObj.get());
Sebastian Redl22653ba2011-08-30 19:58:05 +000010519 if (Return.isInvalid())
10520 Invalid = true;
10521 else {
Nikola Smiljanic01a75982014-05-29 10:55:11 +000010522 Statements.push_back(Return.getAs<Stmt>());
Sebastian Redl22653ba2011-08-30 19:58:05 +000010523
10524 if (Trap.hasErrorOccurred()) {
10525 Diag(CurrentLocation, diag::note_member_synthesized_at)
10526 << CXXMoveAssignment << Context.getTagDeclType(ClassDecl);
10527 Invalid = true;
10528 }
10529 }
10530 }
10531
Ben Langmuir2f8e6b82014-09-25 20:55:00 +000010532 // The exception specification is needed because we are defining the
10533 // function.
10534 ResolveExceptionSpec(CurrentLocation,
10535 MoveAssignOperator->getType()->castAs<FunctionProtoType>());
10536
Sebastian Redl22653ba2011-08-30 19:58:05 +000010537 if (Invalid) {
10538 MoveAssignOperator->setInvalidDecl();
10539 return;
10540 }
Dmitri Gribenko800ddf32012-02-14 22:14:32 +000010541
10542 StmtResult Body;
10543 {
10544 CompoundScopeRAII CompoundScope(*this);
Benjamin Kramer62b95d82012-08-23 21:35:17 +000010545 Body = ActOnCompoundStmt(Loc, Loc, Statements,
Dmitri Gribenko800ddf32012-02-14 22:14:32 +000010546 /*isStmtExpr=*/false);
10547 assert(!Body.isInvalid() && "Compound statement creation cannot fail");
10548 }
Nikola Smiljanic01a75982014-05-29 10:55:11 +000010549 MoveAssignOperator->setBody(Body.getAs<Stmt>());
Sebastian Redl22653ba2011-08-30 19:58:05 +000010550
10551 if (ASTMutationListener *L = getASTMutationListener()) {
10552 L->CompletedImplicitDefinition(MoveAssignOperator);
10553 }
10554}
10555
Richard Smithd3b5c9082012-07-27 04:22:15 +000010556Sema::ImplicitExceptionSpecification
10557Sema::ComputeDefaultedCopyCtorExceptionSpec(CXXMethodDecl *MD) {
10558 CXXRecordDecl *ClassDecl = MD->getParent();
10559
10560 ImplicitExceptionSpecification ExceptSpec(*this);
10561 if (ClassDecl->isInvalidDecl())
10562 return ExceptSpec;
10563
10564 const FunctionProtoType *T = MD->getType()->castAs<FunctionProtoType>();
Alp Toker9cacbab2014-01-20 20:26:09 +000010565 assert(T->getNumParams() >= 1 && "not a copy ctor");
10566 unsigned Quals = T->getParamType(0).getNonReferenceType().getCVRQualifiers();
Richard Smithd3b5c9082012-07-27 04:22:15 +000010567
Douglas Gregor8453ddb2010-07-01 20:59:04 +000010568 // C++ [except.spec]p14:
10569 // An implicitly declared special member function (Clause 12) shall have an
10570 // exception-specification. [...]
Aaron Ballman574705e2014-03-13 15:41:46 +000010571 for (const auto &Base : ClassDecl->bases()) {
Douglas Gregor8453ddb2010-07-01 20:59:04 +000010572 // Virtual bases are handled below.
Aaron Ballman574705e2014-03-13 15:41:46 +000010573 if (Base.isVirtual())
Douglas Gregor8453ddb2010-07-01 20:59:04 +000010574 continue;
10575
Douglas Gregora6d69502010-07-02 23:41:54 +000010576 CXXRecordDecl *BaseClassDecl
Aaron Ballman574705e2014-03-13 15:41:46 +000010577 = cast<CXXRecordDecl>(Base.getType()->getAs<RecordType>()->getDecl());
Alexis Hunt899bd442011-06-10 04:44:37 +000010578 if (CXXConstructorDecl *CopyConstructor =
Alexis Hunt491ec602011-06-21 23:42:56 +000010579 LookupCopyingConstructor(BaseClassDecl, Quals))
Aaron Ballman574705e2014-03-13 15:41:46 +000010580 ExceptSpec.CalledDecl(Base.getLocStart(), CopyConstructor);
Douglas Gregor8453ddb2010-07-01 20:59:04 +000010581 }
Aaron Ballman445a9392014-03-13 16:15:17 +000010582 for (const auto &Base : ClassDecl->vbases()) {
Douglas Gregora6d69502010-07-02 23:41:54 +000010583 CXXRecordDecl *BaseClassDecl
Aaron Ballman445a9392014-03-13 16:15:17 +000010584 = cast<CXXRecordDecl>(Base.getType()->getAs<RecordType>()->getDecl());
Alexis Hunt899bd442011-06-10 04:44:37 +000010585 if (CXXConstructorDecl *CopyConstructor =
Alexis Hunt491ec602011-06-21 23:42:56 +000010586 LookupCopyingConstructor(BaseClassDecl, Quals))
Aaron Ballman445a9392014-03-13 16:15:17 +000010587 ExceptSpec.CalledDecl(Base.getLocStart(), CopyConstructor);
Douglas Gregor8453ddb2010-07-01 20:59:04 +000010588 }
Aaron Ballmane8a8bae2014-03-08 20:12:42 +000010589 for (const auto *Field : ClassDecl->fields()) {
David Blaikie2d7c57e2012-04-30 02:36:29 +000010590 QualType FieldType = Context.getBaseElementType(Field->getType());
Alexis Hunt899bd442011-06-10 04:44:37 +000010591 if (CXXRecordDecl *FieldClassDecl = FieldType->getAsCXXRecordDecl()) {
10592 if (CXXConstructorDecl *CopyConstructor =
Richard Smith1c6461e2012-07-18 03:36:00 +000010593 LookupCopyingConstructor(FieldClassDecl,
10594 Quals | FieldType.getCVRQualifiers()))
Richard Smithf623c962012-04-17 00:58:00 +000010595 ExceptSpec.CalledDecl(Field->getLocation(), CopyConstructor);
Douglas Gregor8453ddb2010-07-01 20:59:04 +000010596 }
10597 }
Sebastian Redlfa453cf2011-03-12 11:50:43 +000010598
Richard Smithd3b5c9082012-07-27 04:22:15 +000010599 return ExceptSpec;
Alexis Hunt913820d2011-05-13 06:10:58 +000010600}
10601
10602CXXConstructorDecl *Sema::DeclareImplicitCopyConstructor(
10603 CXXRecordDecl *ClassDecl) {
10604 // C++ [class.copy]p4:
10605 // If the class definition does not explicitly declare a copy
10606 // constructor, one is declared implicitly.
Richard Smith2be35f52012-12-01 02:35:44 +000010607 assert(ClassDecl->needsImplicitCopyConstructor());
Alexis Hunt913820d2011-05-13 06:10:58 +000010608
Richard Smith8bf22e52012-11-29 01:34:07 +000010609 DeclaringSpecialMember DSM(*this, ClassDecl, CXXCopyConstructor);
10610 if (DSM.isAlreadyBeingDeclared())
Craig Topperc3ec1492014-05-26 06:22:03 +000010611 return nullptr;
Richard Smith8bf22e52012-11-29 01:34:07 +000010612
Alexis Hunt913820d2011-05-13 06:10:58 +000010613 QualType ClassType = Context.getTypeDeclType(ClassDecl);
10614 QualType ArgType = ClassType;
Richard Smith1c33fe82012-11-28 06:23:12 +000010615 bool Const = ClassDecl->implicitCopyConstructorHasConstParam();
Alexis Hunt913820d2011-05-13 06:10:58 +000010616 if (Const)
10617 ArgType = ArgType.withConst();
10618 ArgType = Context.getLValueReferenceType(ArgType);
Alexis Hunt913820d2011-05-13 06:10:58 +000010619
Richard Smithb5800092012-06-10 05:43:50 +000010620 bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
10621 CXXCopyConstructor,
10622 Const);
10623
Douglas Gregor54be3392010-07-01 17:57:27 +000010624 DeclarationName Name
10625 = Context.DeclarationNames.getCXXConstructorName(
10626 Context.getCanonicalType(ClassType));
Abramo Bagnaradff19302011-03-08 08:55:46 +000010627 SourceLocation ClassLoc = ClassDecl->getLocation();
10628 DeclarationNameInfo NameInfo(Name, ClassLoc);
Alexis Hunt913820d2011-05-13 06:10:58 +000010629
10630 // An implicitly-declared copy constructor is an inline public
Richard Smithcc36f692011-12-22 02:22:31 +000010631 // member of its class.
10632 CXXConstructorDecl *CopyConstructor = CXXConstructorDecl::Create(
Craig Topperc3ec1492014-05-26 06:22:03 +000010633 Context, ClassDecl, ClassLoc, NameInfo, QualType(), /*TInfo=*/nullptr,
Richard Smithcc36f692011-12-22 02:22:31 +000010634 /*isExplicit=*/false, /*isInline=*/true, /*isImplicitlyDeclared=*/true,
Richard Smithb5800092012-06-10 05:43:50 +000010635 Constexpr);
Douglas Gregor54be3392010-07-01 17:57:27 +000010636 CopyConstructor->setAccess(AS_public);
Alexis Hunt913820d2011-05-13 06:10:58 +000010637 CopyConstructor->setDefaulted();
Richard Smithcc36f692011-12-22 02:22:31 +000010638
Eli Bendersky9a220fc2014-09-29 20:38:29 +000010639 if (getLangOpts().CUDA) {
10640 inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXCopyConstructor,
10641 CopyConstructor,
10642 /* ConstRHS */ Const,
10643 /* Diagnose */ false);
10644 }
10645
Richard Smithd3b5c9082012-07-27 04:22:15 +000010646 // Build an exception specification pointing back at this member.
Reid Kleckner78af0702013-08-27 23:08:25 +000010647 FunctionProtoType::ExtProtoInfo EPI =
10648 getImplicitMethodEPI(*this, CopyConstructor);
Richard Smithd3b5c9082012-07-27 04:22:15 +000010649 CopyConstructor->setType(
Jordan Rose5c382722013-03-08 21:51:21 +000010650 Context.getFunctionType(Context.VoidTy, ArgType, EPI));
Richard Smithd3b5c9082012-07-27 04:22:15 +000010651
Douglas Gregor54be3392010-07-01 17:57:27 +000010652 // Add the parameter to the constructor.
10653 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyConstructor,
Abramo Bagnaradff19302011-03-08 08:55:46 +000010654 ClassLoc, ClassLoc,
Craig Topperc3ec1492014-05-26 06:22:03 +000010655 /*IdentifierInfo=*/nullptr,
10656 ArgType, /*TInfo=*/nullptr,
10657 SC_None, nullptr);
David Blaikie9c70e042011-09-21 18:16:56 +000010658 CopyConstructor->setParams(FromParam);
Alexis Hunt913820d2011-05-13 06:10:58 +000010659
Richard Smith6b02d462012-12-08 08:32:28 +000010660 CopyConstructor->setTrivial(
10661 ClassDecl->needsOverloadResolutionForCopyConstructor()
10662 ? SpecialMemberIsTrivial(CopyConstructor, CXXCopyConstructor)
10663 : ClassDecl->hasTrivialCopyConstructor());
Alexis Hunte77a28f2011-05-18 03:41:58 +000010664
Richard Smith852265f2012-03-30 20:53:28 +000010665 if (ShouldDeleteSpecialMember(CopyConstructor, CXXCopyConstructor))
Richard Smithb4d2a152013-04-02 19:38:47 +000010666 SetDeclDeleted(CopyConstructor, ClassLoc);
Richard Smith852265f2012-03-30 20:53:28 +000010667
Richard Smith6b02d462012-12-08 08:32:28 +000010668 // Note that we have declared this constructor.
10669 ++ASTContext::NumImplicitCopyConstructorsDeclared;
10670
10671 if (Scope *S = getScopeForContext(ClassDecl))
10672 PushOnScopeChains(CopyConstructor, S, false);
10673 ClassDecl->addDecl(CopyConstructor);
10674
Douglas Gregor54be3392010-07-01 17:57:27 +000010675 return CopyConstructor;
10676}
10677
Fariborz Jahanian477d2422009-06-22 23:34:40 +000010678void Sema::DefineImplicitCopyConstructor(SourceLocation CurrentLocation,
Alexis Hunt913820d2011-05-13 06:10:58 +000010679 CXXConstructorDecl *CopyConstructor) {
10680 assert((CopyConstructor->isDefaulted() &&
10681 CopyConstructor->isCopyConstructor() &&
Richard Smith273c4e92012-02-26 07:51:39 +000010682 !CopyConstructor->doesThisDeclarationHaveABody() &&
10683 !CopyConstructor->isDeleted()) &&
Fariborz Jahanian477d2422009-06-22 23:34:40 +000010684 "DefineImplicitCopyConstructor - call it for implicit copy ctor");
Mike Stump11289f42009-09-09 15:08:12 +000010685
Anders Carlsson7a0ffdb2010-04-23 16:24:12 +000010686 CXXRecordDecl *ClassDecl = CopyConstructor->getParent();
Fariborz Jahanian477d2422009-06-22 23:34:40 +000010687 assert(ClassDecl && "DefineImplicitCopyConstructor - invalid constructor");
Douglas Gregor7ae2d772010-01-31 09:12:51 +000010688
Richard Smithd577fbb2013-06-13 03:23:42 +000010689 // C++11 [class.copy]p7:
Benjamin Kramer60509af2013-09-09 14:48:42 +000010690 // The [definition of an implicitly declared copy constructor] is
Richard Smithd577fbb2013-06-13 03:23:42 +000010691 // deprecated if the class has a user-declared copy assignment operator
10692 // or a user-declared destructor.
10693 if (getLangOpts().CPlusPlus11 && CopyConstructor->isImplicit())
10694 diagnoseDeprecatedCopyOperation(*this, CopyConstructor, CurrentLocation);
10695
Eli Friedmaneaf34142012-10-18 20:14:08 +000010696 SynthesizedFunctionScope Scope(*this, CopyConstructor);
Argyrios Kyrtzidis18653422010-11-19 00:19:12 +000010697 DiagnosticErrorTrap Trap(Diags);
Douglas Gregor7ae2d772010-01-31 09:12:51 +000010698
David Blaikie3fc2f912013-01-17 05:26:25 +000010699 if (SetCtorInitializers(CopyConstructor, /*AnyErrors=*/false) ||
Douglas Gregor54818f02010-05-12 16:39:35 +000010700 Trap.hasErrorOccurred()) {
Anders Carlsson79111502010-05-01 16:39:01 +000010701 Diag(CurrentLocation, diag::note_member_synthesized_at)
Douglas Gregor94f9a482010-05-05 05:51:00 +000010702 << CXXCopyConstructor << Context.getTagDeclType(ClassDecl);
Anders Carlsson79111502010-05-01 16:39:01 +000010703 CopyConstructor->setInvalidDecl();
Douglas Gregor94f9a482010-05-05 05:51:00 +000010704 } else {
Daniel Jasperb3b0b802014-06-20 08:44:22 +000010705 SourceLocation Loc = CopyConstructor->getLocEnd().isValid()
10706 ? CopyConstructor->getLocEnd()
10707 : CopyConstructor->getLocation();
Dmitri Gribenko800ddf32012-02-14 22:14:32 +000010708 Sema::CompoundScopeRAII CompoundScope(*this);
Daniel Jasperb3b0b802014-06-20 08:44:22 +000010709 CopyConstructor->setBody(
10710 ActOnCompoundStmt(Loc, Loc, None, /*isStmtExpr=*/false).getAs<Stmt>());
Anders Carlsson53e1ba92010-04-25 00:52:09 +000010711 }
Robert Wilhelm27b2c9a32013-08-19 20:51:20 +000010712
Ben Langmuir2f8e6b82014-09-25 20:55:00 +000010713 // The exception specification is needed because we are defining the
10714 // function.
10715 ResolveExceptionSpec(CurrentLocation,
10716 CopyConstructor->getType()->castAs<FunctionProtoType>());
10717
Eli Friedman276dd182013-09-05 00:02:25 +000010718 CopyConstructor->markUsed(Context);
Reid Kleckner3be586f2014-07-18 01:48:10 +000010719 MarkVTableUsed(CurrentLocation, ClassDecl);
10720
Sebastian Redlab238a72011-04-24 16:28:06 +000010721 if (ASTMutationListener *L = getASTMutationListener()) {
10722 L->CompletedImplicitDefinition(CopyConstructor);
10723 }
Fariborz Jahanian477d2422009-06-22 23:34:40 +000010724}
10725
Sebastian Redl22653ba2011-08-30 19:58:05 +000010726Sema::ImplicitExceptionSpecification
Richard Smithd3b5c9082012-07-27 04:22:15 +000010727Sema::ComputeDefaultedMoveCtorExceptionSpec(CXXMethodDecl *MD) {
10728 CXXRecordDecl *ClassDecl = MD->getParent();
10729
Sebastian Redl22653ba2011-08-30 19:58:05 +000010730 // C++ [except.spec]p14:
10731 // An implicitly declared special member function (Clause 12) shall have an
10732 // exception-specification. [...]
Richard Smithf623c962012-04-17 00:58:00 +000010733 ImplicitExceptionSpecification ExceptSpec(*this);
Sebastian Redl22653ba2011-08-30 19:58:05 +000010734 if (ClassDecl->isInvalidDecl())
10735 return ExceptSpec;
10736
10737 // Direct base-class constructors.
Aaron Ballman574705e2014-03-13 15:41:46 +000010738 for (const auto &B : ClassDecl->bases()) {
10739 if (B.isVirtual()) // Handled below.
Sebastian Redl22653ba2011-08-30 19:58:05 +000010740 continue;
10741
Aaron Ballman574705e2014-03-13 15:41:46 +000010742 if (const RecordType *BaseType = B.getType()->getAs<RecordType>()) {
Sebastian Redl22653ba2011-08-30 19:58:05 +000010743 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
Richard Smith1c6461e2012-07-18 03:36:00 +000010744 CXXConstructorDecl *Constructor =
10745 LookupMovingConstructor(BaseClassDecl, 0);
Sebastian Redl22653ba2011-08-30 19:58:05 +000010746 // If this is a deleted function, add it anyway. This might be conformant
10747 // with the standard. This might not. I'm not sure. It might not matter.
10748 if (Constructor)
Aaron Ballman574705e2014-03-13 15:41:46 +000010749 ExceptSpec.CalledDecl(B.getLocStart(), Constructor);
Sebastian Redl22653ba2011-08-30 19:58:05 +000010750 }
10751 }
10752
10753 // Virtual base-class constructors.
Aaron Ballman445a9392014-03-13 16:15:17 +000010754 for (const auto &B : ClassDecl->vbases()) {
10755 if (const RecordType *BaseType = B.getType()->getAs<RecordType>()) {
Sebastian Redl22653ba2011-08-30 19:58:05 +000010756 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
Richard Smith1c6461e2012-07-18 03:36:00 +000010757 CXXConstructorDecl *Constructor =
10758 LookupMovingConstructor(BaseClassDecl, 0);
Sebastian Redl22653ba2011-08-30 19:58:05 +000010759 // If this is a deleted function, add it anyway. This might be conformant
10760 // with the standard. This might not. I'm not sure. It might not matter.
10761 if (Constructor)
Aaron Ballman445a9392014-03-13 16:15:17 +000010762 ExceptSpec.CalledDecl(B.getLocStart(), Constructor);
Sebastian Redl22653ba2011-08-30 19:58:05 +000010763 }
10764 }
10765
10766 // Field constructors.
Aaron Ballmane8a8bae2014-03-08 20:12:42 +000010767 for (const auto *F : ClassDecl->fields()) {
Richard Smith1c6461e2012-07-18 03:36:00 +000010768 QualType FieldType = Context.getBaseElementType(F->getType());
10769 if (CXXRecordDecl *FieldRecDecl = FieldType->getAsCXXRecordDecl()) {
10770 CXXConstructorDecl *Constructor =
10771 LookupMovingConstructor(FieldRecDecl, FieldType.getCVRQualifiers());
Sebastian Redl22653ba2011-08-30 19:58:05 +000010772 // If this is a deleted function, add it anyway. This might be conformant
10773 // with the standard. This might not. I'm not sure. It might not matter.
10774 // In particular, the problem is that this function never gets called. It
10775 // might just be ill-formed because this function attempts to refer to
10776 // a deleted function here.
10777 if (Constructor)
Richard Smithf623c962012-04-17 00:58:00 +000010778 ExceptSpec.CalledDecl(F->getLocation(), Constructor);
Sebastian Redl22653ba2011-08-30 19:58:05 +000010779 }
10780 }
10781
10782 return ExceptSpec;
10783}
10784
10785CXXConstructorDecl *Sema::DeclareImplicitMoveConstructor(
10786 CXXRecordDecl *ClassDecl) {
Richard Smithcf8ec8d2012-04-02 18:40:40 +000010787 assert(ClassDecl->needsImplicitMoveConstructor());
10788
Richard Smith8bf22e52012-11-29 01:34:07 +000010789 DeclaringSpecialMember DSM(*this, ClassDecl, CXXMoveConstructor);
10790 if (DSM.isAlreadyBeingDeclared())
Craig Topperc3ec1492014-05-26 06:22:03 +000010791 return nullptr;
Richard Smith8bf22e52012-11-29 01:34:07 +000010792
Sebastian Redl22653ba2011-08-30 19:58:05 +000010793 QualType ClassType = Context.getTypeDeclType(ClassDecl);
10794 QualType ArgType = Context.getRValueReferenceType(ClassType);
Sebastian Redl22653ba2011-08-30 19:58:05 +000010795
Richard Smithb5800092012-06-10 05:43:50 +000010796 bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
10797 CXXMoveConstructor,
10798 false);
10799
Sebastian Redl22653ba2011-08-30 19:58:05 +000010800 DeclarationName Name
10801 = Context.DeclarationNames.getCXXConstructorName(
10802 Context.getCanonicalType(ClassType));
10803 SourceLocation ClassLoc = ClassDecl->getLocation();
10804 DeclarationNameInfo NameInfo(Name, ClassLoc);
10805
Richard Smith99005e62013-05-07 03:19:20 +000010806 // C++11 [class.copy]p11:
Sebastian Redl22653ba2011-08-30 19:58:05 +000010807 // An implicitly-declared copy/move constructor is an inline public
Richard Smithcc36f692011-12-22 02:22:31 +000010808 // member of its class.
10809 CXXConstructorDecl *MoveConstructor = CXXConstructorDecl::Create(
Craig Topperc3ec1492014-05-26 06:22:03 +000010810 Context, ClassDecl, ClassLoc, NameInfo, QualType(), /*TInfo=*/nullptr,
Richard Smithcc36f692011-12-22 02:22:31 +000010811 /*isExplicit=*/false, /*isInline=*/true, /*isImplicitlyDeclared=*/true,
Richard Smithb5800092012-06-10 05:43:50 +000010812 Constexpr);
Sebastian Redl22653ba2011-08-30 19:58:05 +000010813 MoveConstructor->setAccess(AS_public);
10814 MoveConstructor->setDefaulted();
Richard Smithcc36f692011-12-22 02:22:31 +000010815
Eli Bendersky9a220fc2014-09-29 20:38:29 +000010816 if (getLangOpts().CUDA) {
10817 inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXMoveConstructor,
10818 MoveConstructor,
10819 /* ConstRHS */ false,
10820 /* Diagnose */ false);
10821 }
10822
Richard Smithd3b5c9082012-07-27 04:22:15 +000010823 // Build an exception specification pointing back at this member.
Reid Kleckner78af0702013-08-27 23:08:25 +000010824 FunctionProtoType::ExtProtoInfo EPI =
10825 getImplicitMethodEPI(*this, MoveConstructor);
Richard Smithd3b5c9082012-07-27 04:22:15 +000010826 MoveConstructor->setType(
Jordan Rose5c382722013-03-08 21:51:21 +000010827 Context.getFunctionType(Context.VoidTy, ArgType, EPI));
Richard Smithd3b5c9082012-07-27 04:22:15 +000010828
Sebastian Redl22653ba2011-08-30 19:58:05 +000010829 // Add the parameter to the constructor.
10830 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, MoveConstructor,
10831 ClassLoc, ClassLoc,
Craig Topperc3ec1492014-05-26 06:22:03 +000010832 /*IdentifierInfo=*/nullptr,
10833 ArgType, /*TInfo=*/nullptr,
10834 SC_None, nullptr);
David Blaikie9c70e042011-09-21 18:16:56 +000010835 MoveConstructor->setParams(FromParam);
Sebastian Redl22653ba2011-08-30 19:58:05 +000010836
Richard Smith6b02d462012-12-08 08:32:28 +000010837 MoveConstructor->setTrivial(
10838 ClassDecl->needsOverloadResolutionForMoveConstructor()
10839 ? SpecialMemberIsTrivial(MoveConstructor, CXXMoveConstructor)
10840 : ClassDecl->hasTrivialMoveConstructor());
10841
Alexis Hunt77c1f9f2011-10-11 06:43:29 +000010842 if (ShouldDeleteSpecialMember(MoveConstructor, CXXMoveConstructor)) {
Richard Smith8b86f2d2013-11-04 01:48:18 +000010843 ClassDecl->setImplicitMoveConstructorIsDeleted();
10844 SetDeclDeleted(MoveConstructor, ClassLoc);
Sebastian Redl22653ba2011-08-30 19:58:05 +000010845 }
10846
10847 // Note that we have declared this constructor.
10848 ++ASTContext::NumImplicitMoveConstructorsDeclared;
10849
10850 if (Scope *S = getScopeForContext(ClassDecl))
10851 PushOnScopeChains(MoveConstructor, S, false);
10852 ClassDecl->addDecl(MoveConstructor);
10853
10854 return MoveConstructor;
10855}
10856
10857void Sema::DefineImplicitMoveConstructor(SourceLocation CurrentLocation,
10858 CXXConstructorDecl *MoveConstructor) {
10859 assert((MoveConstructor->isDefaulted() &&
10860 MoveConstructor->isMoveConstructor() &&
Richard Smith273c4e92012-02-26 07:51:39 +000010861 !MoveConstructor->doesThisDeclarationHaveABody() &&
10862 !MoveConstructor->isDeleted()) &&
Sebastian Redl22653ba2011-08-30 19:58:05 +000010863 "DefineImplicitMoveConstructor - call it for implicit move ctor");
10864
10865 CXXRecordDecl *ClassDecl = MoveConstructor->getParent();
10866 assert(ClassDecl && "DefineImplicitMoveConstructor - invalid constructor");
10867
Eli Friedmaneaf34142012-10-18 20:14:08 +000010868 SynthesizedFunctionScope Scope(*this, MoveConstructor);
Sebastian Redl22653ba2011-08-30 19:58:05 +000010869 DiagnosticErrorTrap Trap(Diags);
10870
David Blaikie3fc2f912013-01-17 05:26:25 +000010871 if (SetCtorInitializers(MoveConstructor, /*AnyErrors=*/false) ||
Sebastian Redl22653ba2011-08-30 19:58:05 +000010872 Trap.hasErrorOccurred()) {
10873 Diag(CurrentLocation, diag::note_member_synthesized_at)
10874 << CXXMoveConstructor << Context.getTagDeclType(ClassDecl);
10875 MoveConstructor->setInvalidDecl();
10876 } else {
Daniel Jasperb3b0b802014-06-20 08:44:22 +000010877 SourceLocation Loc = MoveConstructor->getLocEnd().isValid()
10878 ? MoveConstructor->getLocEnd()
10879 : MoveConstructor->getLocation();
Dmitri Gribenko800ddf32012-02-14 22:14:32 +000010880 Sema::CompoundScopeRAII CompoundScope(*this);
Robert Wilhelm27b2c9a32013-08-19 20:51:20 +000010881 MoveConstructor->setBody(ActOnCompoundStmt(
Daniel Jasperb3b0b802014-06-20 08:44:22 +000010882 Loc, Loc, None, /*isStmtExpr=*/ false).getAs<Stmt>());
Sebastian Redl22653ba2011-08-30 19:58:05 +000010883 }
10884
Ben Langmuir2f8e6b82014-09-25 20:55:00 +000010885 // The exception specification is needed because we are defining the
10886 // function.
10887 ResolveExceptionSpec(CurrentLocation,
10888 MoveConstructor->getType()->castAs<FunctionProtoType>());
10889
Eli Friedman276dd182013-09-05 00:02:25 +000010890 MoveConstructor->markUsed(Context);
Reid Kleckner3be586f2014-07-18 01:48:10 +000010891 MarkVTableUsed(CurrentLocation, ClassDecl);
Sebastian Redl22653ba2011-08-30 19:58:05 +000010892
10893 if (ASTMutationListener *L = getASTMutationListener()) {
10894 L->CompletedImplicitDefinition(MoveConstructor);
10895 }
10896}
10897
Douglas Gregor74f7d502012-02-15 19:33:52 +000010898bool Sema::isImplicitlyDeleted(FunctionDecl *FD) {
Eli Friedmanebea0f22013-07-18 23:29:14 +000010899 return FD->isDeleted() && FD->isDefaulted() && isa<CXXMethodDecl>(FD);
Douglas Gregor74f7d502012-02-15 19:33:52 +000010900}
Douglas Gregord3b672c2012-02-16 01:06:16 +000010901
10902void Sema::DefineImplicitLambdaToFunctionPointerConversion(
Faisal Vali571df122013-09-29 08:45:24 +000010903 SourceLocation CurrentLocation,
10904 CXXConversionDecl *Conv) {
10905 CXXRecordDecl *Lambda = Conv->getParent();
10906 CXXMethodDecl *CallOp = Lambda->getLambdaCallOperator();
10907 // If we are defining a specialization of a conversion to function-ptr
10908 // cache the deduced template arguments for this specialization
10909 // so that we can use them to retrieve the corresponding call-operator
10910 // and static-invoker.
Craig Topperc3ec1492014-05-26 06:22:03 +000010911 const TemplateArgumentList *DeducedTemplateArgs = nullptr;
10912
Faisal Vali571df122013-09-29 08:45:24 +000010913 // Retrieve the corresponding call-operator specialization.
10914 if (Lambda->isGenericLambda()) {
10915 assert(Conv->isFunctionTemplateSpecialization());
10916 FunctionTemplateDecl *CallOpTemplate =
10917 CallOp->getDescribedFunctionTemplate();
10918 DeducedTemplateArgs = Conv->getTemplateSpecializationArgs();
Craig Topperc3ec1492014-05-26 06:22:03 +000010919 void *InsertPos = nullptr;
Faisal Vali571df122013-09-29 08:45:24 +000010920 FunctionDecl *CallOpSpec = CallOpTemplate->findSpecialization(
Craig Topper7e0daca2014-06-26 04:58:53 +000010921 DeducedTemplateArgs->asArray(),
Faisal Vali571df122013-09-29 08:45:24 +000010922 InsertPos);
10923 assert(CallOpSpec &&
10924 "Conversion operator must have a corresponding call operator");
10925 CallOp = cast<CXXMethodDecl>(CallOpSpec);
10926 }
10927 // Mark the call operator referenced (and add to pending instantiations
10928 // if necessary).
10929 // For both the conversion and static-invoker template specializations
10930 // we construct their body's in this function, so no need to add them
10931 // to the PendingInstantiations.
10932 MarkFunctionReferenced(CurrentLocation, CallOp);
10933
Eli Friedmaneaf34142012-10-18 20:14:08 +000010934 SynthesizedFunctionScope Scope(*this, Conv);
Douglas Gregord3b672c2012-02-16 01:06:16 +000010935 DiagnosticErrorTrap Trap(Diags);
Faisal Vali571df122013-09-29 08:45:24 +000010936
Alp Tokerf6a24ce2013-12-05 16:25:25 +000010937 // Retrieve the static invoker...
Faisal Vali571df122013-09-29 08:45:24 +000010938 CXXMethodDecl *Invoker = Lambda->getLambdaStaticInvoker();
10939 // ... and get the corresponding specialization for a generic lambda.
10940 if (Lambda->isGenericLambda()) {
10941 assert(DeducedTemplateArgs &&
10942 "Must have deduced template arguments from Conversion Operator");
10943 FunctionTemplateDecl *InvokeTemplate =
10944 Invoker->getDescribedFunctionTemplate();
Craig Topperc3ec1492014-05-26 06:22:03 +000010945 void *InsertPos = nullptr;
Faisal Vali571df122013-09-29 08:45:24 +000010946 FunctionDecl *InvokeSpec = InvokeTemplate->findSpecialization(
Craig Topper7e0daca2014-06-26 04:58:53 +000010947 DeducedTemplateArgs->asArray(),
Faisal Vali571df122013-09-29 08:45:24 +000010948 InsertPos);
10949 assert(InvokeSpec &&
10950 "Must have a corresponding static invoker specialization");
10951 Invoker = cast<CXXMethodDecl>(InvokeSpec);
10952 }
10953 // Construct the body of the conversion function { return __invoke; }.
10954 Expr *FunctionRef = BuildDeclRefExpr(Invoker, Invoker->getType(),
Nikola Smiljanic01a75982014-05-29 10:55:11 +000010955 VK_LValue, Conv->getLocation()).get();
Faisal Vali571df122013-09-29 08:45:24 +000010956 assert(FunctionRef && "Can't refer to __invoke function?");
Nikola Smiljanic01a75982014-05-29 10:55:11 +000010957 Stmt *Return = BuildReturnStmt(Conv->getLocation(), FunctionRef).get();
Faisal Vali571df122013-09-29 08:45:24 +000010958 Conv->setBody(new (Context) CompoundStmt(Context, Return,
10959 Conv->getLocation(),
10960 Conv->getLocation()));
10961
10962 Conv->markUsed(Context);
10963 Conv->setReferenced();
Douglas Gregord3b672c2012-02-16 01:06:16 +000010964
Faisal Vali571df122013-09-29 08:45:24 +000010965 // Fill in the __invoke function with a dummy implementation. IR generation
10966 // will fill in the actual details.
10967 Invoker->markUsed(Context);
10968 Invoker->setReferenced();
10969 Invoker->setBody(new (Context) CompoundStmt(Conv->getLocation()));
10970
Douglas Gregord3b672c2012-02-16 01:06:16 +000010971 if (ASTMutationListener *L = getASTMutationListener()) {
10972 L->CompletedImplicitDefinition(Conv);
Faisal Vali571df122013-09-29 08:45:24 +000010973 L->CompletedImplicitDefinition(Invoker);
10974 }
Douglas Gregord3b672c2012-02-16 01:06:16 +000010975}
10976
Faisal Vali571df122013-09-29 08:45:24 +000010977
10978
Douglas Gregord3b672c2012-02-16 01:06:16 +000010979void Sema::DefineImplicitLambdaToBlockPointerConversion(
10980 SourceLocation CurrentLocation,
10981 CXXConversionDecl *Conv)
10982{
Faisal Vali850da1a2013-09-29 17:08:32 +000010983 assert(!Conv->getParent()->isGenericLambda());
Faisal Vali571df122013-09-29 08:45:24 +000010984
Eli Friedman276dd182013-09-05 00:02:25 +000010985 Conv->markUsed(Context);
Douglas Gregord3b672c2012-02-16 01:06:16 +000010986
Eli Friedmaneaf34142012-10-18 20:14:08 +000010987 SynthesizedFunctionScope Scope(*this, Conv);
Douglas Gregord3b672c2012-02-16 01:06:16 +000010988 DiagnosticErrorTrap Trap(Diags);
10989
Douglas Gregored90df32012-02-22 05:02:47 +000010990 // Copy-initialize the lambda object as needed to capture it.
Nikola Smiljanic01a75982014-05-29 10:55:11 +000010991 Expr *This = ActOnCXXThis(CurrentLocation).get();
10992 Expr *DerefThis =CreateBuiltinUnaryOp(CurrentLocation, UO_Deref, This).get();
Douglas Gregord3b672c2012-02-16 01:06:16 +000010993
Eli Friedman98b01ed2012-03-01 04:01:32 +000010994 ExprResult BuildBlock = BuildBlockForLambdaConversion(CurrentLocation,
10995 Conv->getLocation(),
10996 Conv, DerefThis);
10997
10998 // If we're not under ARC, make sure we still get the _Block_copy/autorelease
10999 // behavior. Note that only the general conversion function does this
11000 // (since it's unusable otherwise); in the case where we inline the
11001 // block literal, it has block literal lifetime semantics.
David Blaikiebbafb8a2012-03-11 07:00:24 +000011002 if (!BuildBlock.isInvalid() && !getLangOpts().ObjCAutoRefCount)
Eli Friedman98b01ed2012-03-01 04:01:32 +000011003 BuildBlock = ImplicitCastExpr::Create(Context, BuildBlock.get()->getType(),
11004 CK_CopyAndAutoreleaseBlockObject,
Craig Topperc3ec1492014-05-26 06:22:03 +000011005 BuildBlock.get(), nullptr, VK_RValue);
Eli Friedman98b01ed2012-03-01 04:01:32 +000011006
11007 if (BuildBlock.isInvalid()) {
Douglas Gregord3b672c2012-02-16 01:06:16 +000011008 Diag(CurrentLocation, diag::note_lambda_to_block_conv);
Douglas Gregored90df32012-02-22 05:02:47 +000011009 Conv->setInvalidDecl();
11010 return;
Douglas Gregord3b672c2012-02-16 01:06:16 +000011011 }
Douglas Gregored90df32012-02-22 05:02:47 +000011012
Douglas Gregored90df32012-02-22 05:02:47 +000011013 // Create the return statement that returns the block from the conversion
11014 // function.
Nick Lewyckyd78f92f2014-05-03 00:41:18 +000011015 StmtResult Return = BuildReturnStmt(Conv->getLocation(), BuildBlock.get());
Douglas Gregored90df32012-02-22 05:02:47 +000011016 if (Return.isInvalid()) {
11017 Diag(CurrentLocation, diag::note_lambda_to_block_conv);
11018 Conv->setInvalidDecl();
11019 return;
11020 }
11021
11022 // Set the body of the conversion function.
Nikola Smiljanic01a75982014-05-29 10:55:11 +000011023 Stmt *ReturnS = Return.get();
Nico Webera2a0eb92012-12-29 20:03:39 +000011024 Conv->setBody(new (Context) CompoundStmt(Context, ReturnS,
Douglas Gregored90df32012-02-22 05:02:47 +000011025 Conv->getLocation(),
Douglas Gregord3b672c2012-02-16 01:06:16 +000011026 Conv->getLocation()));
11027
Douglas Gregored90df32012-02-22 05:02:47 +000011028 // We're done; notify the mutation listener, if any.
Douglas Gregord3b672c2012-02-16 01:06:16 +000011029 if (ASTMutationListener *L = getASTMutationListener()) {
11030 L->CompletedImplicitDefinition(Conv);
11031 }
11032}
11033
Douglas Gregord2f70072012-03-10 06:53:13 +000011034/// \brief Determine whether the given list arguments contains exactly one
11035/// "real" (non-default) argument.
11036static bool hasOneRealArgument(MultiExprArg Args) {
11037 switch (Args.size()) {
11038 case 0:
11039 return false;
11040
11041 default:
Benjamin Kramer62b95d82012-08-23 21:35:17 +000011042 if (!Args[1]->isDefaultArgument())
Douglas Gregord2f70072012-03-10 06:53:13 +000011043 return false;
11044
11045 // fall through
11046 case 1:
Benjamin Kramer62b95d82012-08-23 21:35:17 +000011047 return !Args[0]->isDefaultArgument();
Douglas Gregord2f70072012-03-10 06:53:13 +000011048 }
11049
11050 return false;
11051}
11052
John McCalldadc5752010-08-24 06:29:42 +000011053ExprResult
Anders Carlsson1b4ebfa2009-09-05 07:40:38 +000011054Sema::BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
Mike Stump11289f42009-09-09 15:08:12 +000011055 CXXConstructorDecl *Constructor,
Douglas Gregor4f4b1862009-12-16 18:50:27 +000011056 MultiExprArg ExprArgs,
Abramo Bagnara635ed24e2011-10-05 07:56:41 +000011057 bool HadMultipleCandidates,
Richard Smithd59b8322012-12-19 01:39:02 +000011058 bool IsListInitialization,
Richard Smithf8adcdc2014-07-17 05:12:35 +000011059 bool IsStdInitListInitialization,
Douglas Gregor7ae2d772010-01-31 09:12:51 +000011060 bool RequiresZeroInit,
Chandler Carruth01718152010-10-25 08:47:36 +000011061 unsigned ConstructKind,
11062 SourceRange ParenRange) {
Anders Carlsson250aada2009-08-16 05:13:48 +000011063 bool Elidable = false;
Mike Stump11289f42009-09-09 15:08:12 +000011064
Douglas Gregor45cf7e32010-04-02 18:24:57 +000011065 // C++0x [class.copy]p34:
11066 // When certain criteria are met, an implementation is allowed to
11067 // omit the copy/move construction of a class object, even if the
11068 // copy/move constructor and/or destructor for the object have
11069 // side effects. [...]
11070 // - when a temporary class object that has not been bound to a
11071 // reference (12.2) would be copied/moved to a class object
11072 // with the same cv-unqualified type, the copy/move operation
11073 // can be omitted by constructing the temporary object
11074 // directly into the target of the omitted copy/move
John McCall7a626f62010-09-15 10:14:12 +000011075 if (ConstructKind == CXXConstructExpr::CK_Complete &&
Douglas Gregord2f70072012-03-10 06:53:13 +000011076 Constructor->isCopyOrMoveConstructor() && hasOneRealArgument(ExprArgs)) {
Benjamin Kramercc4c49d2012-08-23 23:38:35 +000011077 Expr *SubExpr = ExprArgs[0];
John McCall7a626f62010-09-15 10:14:12 +000011078 Elidable = SubExpr->isTemporaryObject(Context, Constructor->getParent());
Anders Carlsson250aada2009-08-16 05:13:48 +000011079 }
Mike Stump11289f42009-09-09 15:08:12 +000011080
11081 return BuildCXXConstructExpr(ConstructLoc, DeclInitType, Constructor,
Benjamin Kramer62b95d82012-08-23 21:35:17 +000011082 Elidable, ExprArgs, HadMultipleCandidates,
Richard Smithf8adcdc2014-07-17 05:12:35 +000011083 IsListInitialization,
11084 IsStdInitListInitialization, RequiresZeroInit,
Richard Smithd59b8322012-12-19 01:39:02 +000011085 ConstructKind, ParenRange);
Anders Carlsson250aada2009-08-16 05:13:48 +000011086}
11087
Fariborz Jahanianaa890bf2009-08-05 17:03:54 +000011088/// BuildCXXConstructExpr - Creates a complete call to a constructor,
11089/// including handling of its default argument expressions.
John McCalldadc5752010-08-24 06:29:42 +000011090ExprResult
Anders Carlsson1b4ebfa2009-09-05 07:40:38 +000011091Sema::BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
11092 CXXConstructorDecl *Constructor, bool Elidable,
Douglas Gregor4f4b1862009-12-16 18:50:27 +000011093 MultiExprArg ExprArgs,
Abramo Bagnara635ed24e2011-10-05 07:56:41 +000011094 bool HadMultipleCandidates,
Richard Smithd59b8322012-12-19 01:39:02 +000011095 bool IsListInitialization,
Richard Smithf8adcdc2014-07-17 05:12:35 +000011096 bool IsStdInitListInitialization,
Douglas Gregor7ae2d772010-01-31 09:12:51 +000011097 bool RequiresZeroInit,
Chandler Carruth01718152010-10-25 08:47:36 +000011098 unsigned ConstructKind,
11099 SourceRange ParenRange) {
Eli Friedmanfa0df832012-02-02 03:46:19 +000011100 MarkFunctionReferenced(ConstructLoc, Constructor);
Nikola Smiljanic03ff2592014-05-29 14:05:12 +000011101 return CXXConstructExpr::Create(
11102 Context, DeclInitType, ConstructLoc, Constructor, Elidable, ExprArgs,
Richard Smithf8adcdc2014-07-17 05:12:35 +000011103 HadMultipleCandidates, IsListInitialization, IsStdInitListInitialization,
11104 RequiresZeroInit,
Nikola Smiljanic03ff2592014-05-29 14:05:12 +000011105 static_cast<CXXConstructExpr::ConstructionKind>(ConstructKind),
11106 ParenRange);
Fariborz Jahanianaa890bf2009-08-05 17:03:54 +000011107}
11108
John McCall03c48482010-02-02 09:10:11 +000011109void Sema::FinalizeVarWithDestructor(VarDecl *VD, const RecordType *Record) {
Chandler Carruth86d17d32011-03-27 21:26:48 +000011110 if (VD->isInvalidDecl()) return;
11111
John McCall03c48482010-02-02 09:10:11 +000011112 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Record->getDecl());
Chandler Carruth86d17d32011-03-27 21:26:48 +000011113 if (ClassDecl->isInvalidDecl()) return;
Richard Smitheec915d62012-02-18 04:13:32 +000011114 if (ClassDecl->hasIrrelevantDestructor()) return;
Chandler Carruth86d17d32011-03-27 21:26:48 +000011115 if (ClassDecl->isDependentContext()) return;
John McCall47e40932010-08-01 20:20:59 +000011116
Chandler Carruth86d17d32011-03-27 21:26:48 +000011117 CXXDestructorDecl *Destructor = LookupDestructor(ClassDecl);
Eli Friedmanfa0df832012-02-02 03:46:19 +000011118 MarkFunctionReferenced(VD->getLocation(), Destructor);
Chandler Carruth86d17d32011-03-27 21:26:48 +000011119 CheckDestructorAccess(VD->getLocation(), Destructor,
11120 PDiag(diag::err_access_dtor_var)
11121 << VD->getDeclName()
11122 << VD->getType());
Richard Smitheec915d62012-02-18 04:13:32 +000011123 DiagnoseUseOfDecl(Destructor, VD->getLocation());
Anders Carlsson98766db2011-03-24 01:01:41 +000011124
Stephan Tolksdorf5604a272014-03-27 20:23:36 +000011125 if (Destructor->isTrivial()) return;
Chandler Carruth86d17d32011-03-27 21:26:48 +000011126 if (!VD->hasGlobalStorage()) return;
11127
11128 // Emit warning for non-trivial dtor in global scope (a real global,
11129 // class-static, function-static).
11130 Diag(VD->getLocation(), diag::warn_exit_time_destructor);
11131
11132 // TODO: this should be re-enabled for static locals by !CXAAtExit
Stephan Tolksdorf5604a272014-03-27 20:23:36 +000011133 if (!VD->isStaticLocal())
Chandler Carruth86d17d32011-03-27 21:26:48 +000011134 Diag(VD->getLocation(), diag::warn_global_destructor);
Fariborz Jahanian24a175b2009-06-26 23:49:16 +000011135}
11136
Douglas Gregor5d3507d2009-09-09 23:08:42 +000011137/// \brief Given a constructor and the set of arguments provided for the
11138/// constructor, convert the arguments and add any required default arguments
11139/// to form a proper call to this constructor.
11140///
11141/// \returns true if an error occurred, false otherwise.
11142bool
11143Sema::CompleteConstructorCall(CXXConstructorDecl *Constructor,
11144 MultiExprArg ArgsPtr,
Richard Smith55ce3522012-06-25 20:30:08 +000011145 SourceLocation Loc,
Benjamin Kramerf0623432012-08-23 22:51:59 +000011146 SmallVectorImpl<Expr*> &ConvertedArgs,
Richard Smith6b216962013-02-05 05:52:24 +000011147 bool AllowExplicit,
11148 bool IsListInitialization) {
Douglas Gregor5d3507d2009-09-09 23:08:42 +000011149 // FIXME: This duplicates a lot of code from Sema::ConvertArgumentsForCall.
11150 unsigned NumArgs = ArgsPtr.size();
Benjamin Kramercc4c49d2012-08-23 23:38:35 +000011151 Expr **Args = ArgsPtr.data();
Douglas Gregor5d3507d2009-09-09 23:08:42 +000011152
11153 const FunctionProtoType *Proto
11154 = Constructor->getType()->getAs<FunctionProtoType>();
11155 assert(Proto && "Constructor without a prototype?");
Alp Tokerb3fd5cf2014-01-21 00:32:38 +000011156 unsigned NumParams = Proto->getNumParams();
Alp Toker9cacbab2014-01-20 20:26:09 +000011157
Douglas Gregor5d3507d2009-09-09 23:08:42 +000011158 // If too few arguments are available, we'll fill in the rest with defaults.
Alp Tokerb3fd5cf2014-01-21 00:32:38 +000011159 if (NumArgs < NumParams)
11160 ConvertedArgs.reserve(NumParams);
Fariborz Jahanian4fa66ce2009-11-24 21:37:28 +000011161 else
Douglas Gregor5d3507d2009-09-09 23:08:42 +000011162 ConvertedArgs.reserve(NumArgs);
Fariborz Jahanian4fa66ce2009-11-24 21:37:28 +000011163
11164 VariadicCallType CallType =
11165 Proto->isVariadic() ? VariadicConstructor : VariadicDoesNotApply;
Chris Lattner0e62c1c2011-07-23 10:55:15 +000011166 SmallVector<Expr *, 8> AllArgs;
Fariborz Jahanian4fa66ce2009-11-24 21:37:28 +000011167 bool Invalid = GatherArgumentsForCall(Loc, Constructor,
Dmitri Gribenko9c785c22013-05-09 21:02:07 +000011168 Proto, 0,
11169 llvm::makeArrayRef(Args, NumArgs),
11170 AllArgs,
Richard Smith6b216962013-02-05 05:52:24 +000011171 CallType, AllowExplicit,
11172 IsListInitialization);
Benjamin Kramer8001f742012-02-14 12:06:21 +000011173 ConvertedArgs.append(AllArgs.begin(), AllArgs.end());
Eli Friedmanff4b4072012-02-18 04:48:30 +000011174
Dmitri Gribenko9c785c22013-05-09 21:02:07 +000011175 DiagnoseSentinelCalls(Constructor, Loc, AllArgs);
Eli Friedmanff4b4072012-02-18 04:48:30 +000011176
Dmitri Gribenko765396f2013-01-13 20:46:02 +000011177 CheckConstructorCall(Constructor,
Craig Topper8c2a2a02014-08-30 16:55:39 +000011178 llvm::makeArrayRef(AllArgs.data(), AllArgs.size()),
Richard Smith55ce3522012-06-25 20:30:08 +000011179 Proto, Loc);
Eli Friedmanff4b4072012-02-18 04:48:30 +000011180
Fariborz Jahanian4fa66ce2009-11-24 21:37:28 +000011181 return Invalid;
Douglas Gregorc28b57d2008-11-03 20:45:27 +000011182}
11183
Anders Carlssone363c8e2009-12-12 00:32:00 +000011184static inline bool
11185CheckOperatorNewDeleteDeclarationScope(Sema &SemaRef,
11186 const FunctionDecl *FnDecl) {
Sebastian Redl50c68252010-08-31 00:36:30 +000011187 const DeclContext *DC = FnDecl->getDeclContext()->getRedeclContext();
Anders Carlssone363c8e2009-12-12 00:32:00 +000011188 if (isa<NamespaceDecl>(DC)) {
11189 return SemaRef.Diag(FnDecl->getLocation(),
11190 diag::err_operator_new_delete_declared_in_namespace)
11191 << FnDecl->getDeclName();
11192 }
11193
11194 if (isa<TranslationUnitDecl>(DC) &&
John McCall8e7d6562010-08-26 03:08:43 +000011195 FnDecl->getStorageClass() == SC_Static) {
Anders Carlssone363c8e2009-12-12 00:32:00 +000011196 return SemaRef.Diag(FnDecl->getLocation(),
11197 diag::err_operator_new_delete_declared_static)
11198 << FnDecl->getDeclName();
11199 }
11200
Anders Carlsson60659a82009-12-12 02:43:16 +000011201 return false;
Anders Carlssone363c8e2009-12-12 00:32:00 +000011202}
11203
Anders Carlsson7e0b2072009-12-13 17:53:43 +000011204static inline bool
11205CheckOperatorNewDeleteTypes(Sema &SemaRef, const FunctionDecl *FnDecl,
11206 CanQualType ExpectedResultType,
11207 CanQualType ExpectedFirstParamType,
11208 unsigned DependentParamTypeDiag,
11209 unsigned InvalidParamTypeDiag) {
Alp Toker314cc812014-01-25 16:55:45 +000011210 QualType ResultType =
11211 FnDecl->getType()->getAs<FunctionType>()->getReturnType();
Anders Carlsson7e0b2072009-12-13 17:53:43 +000011212
11213 // Check that the result type is not dependent.
11214 if (ResultType->isDependentType())
11215 return SemaRef.Diag(FnDecl->getLocation(),
11216 diag::err_operator_new_delete_dependent_result_type)
11217 << FnDecl->getDeclName() << ExpectedResultType;
11218
11219 // Check that the result type is what we expect.
11220 if (SemaRef.Context.getCanonicalType(ResultType) != ExpectedResultType)
11221 return SemaRef.Diag(FnDecl->getLocation(),
11222 diag::err_operator_new_delete_invalid_result_type)
11223 << FnDecl->getDeclName() << ExpectedResultType;
11224
11225 // A function template must have at least 2 parameters.
11226 if (FnDecl->getDescribedFunctionTemplate() && FnDecl->getNumParams() < 2)
11227 return SemaRef.Diag(FnDecl->getLocation(),
11228 diag::err_operator_new_delete_template_too_few_parameters)
11229 << FnDecl->getDeclName();
11230
11231 // The function decl must have at least 1 parameter.
11232 if (FnDecl->getNumParams() == 0)
11233 return SemaRef.Diag(FnDecl->getLocation(),
11234 diag::err_operator_new_delete_too_few_parameters)
11235 << FnDecl->getDeclName();
11236
Sylvestre Ledru830885c2012-07-23 08:59:39 +000011237 // Check the first parameter type is not dependent.
Anders Carlsson7e0b2072009-12-13 17:53:43 +000011238 QualType FirstParamType = FnDecl->getParamDecl(0)->getType();
11239 if (FirstParamType->isDependentType())
11240 return SemaRef.Diag(FnDecl->getLocation(), DependentParamTypeDiag)
11241 << FnDecl->getDeclName() << ExpectedFirstParamType;
11242
11243 // Check that the first parameter type is what we expect.
Douglas Gregor684d7bd2009-12-22 23:42:49 +000011244 if (SemaRef.Context.getCanonicalType(FirstParamType).getUnqualifiedType() !=
Anders Carlsson7e0b2072009-12-13 17:53:43 +000011245 ExpectedFirstParamType)
11246 return SemaRef.Diag(FnDecl->getLocation(), InvalidParamTypeDiag)
11247 << FnDecl->getDeclName() << ExpectedFirstParamType;
11248
11249 return false;
11250}
11251
Anders Carlsson12308f42009-12-11 23:23:22 +000011252static bool
Anders Carlsson7e0b2072009-12-13 17:53:43 +000011253CheckOperatorNewDeclaration(Sema &SemaRef, const FunctionDecl *FnDecl) {
Anders Carlssone363c8e2009-12-12 00:32:00 +000011254 // C++ [basic.stc.dynamic.allocation]p1:
11255 // A program is ill-formed if an allocation function is declared in a
11256 // namespace scope other than global scope or declared static in global
11257 // scope.
11258 if (CheckOperatorNewDeleteDeclarationScope(SemaRef, FnDecl))
11259 return true;
Anders Carlsson7e0b2072009-12-13 17:53:43 +000011260
11261 CanQualType SizeTy =
11262 SemaRef.Context.getCanonicalType(SemaRef.Context.getSizeType());
11263
11264 // C++ [basic.stc.dynamic.allocation]p1:
11265 // The return type shall be void*. The first parameter shall have type
11266 // std::size_t.
11267 if (CheckOperatorNewDeleteTypes(SemaRef, FnDecl, SemaRef.Context.VoidPtrTy,
11268 SizeTy,
11269 diag::err_operator_new_dependent_param_type,
11270 diag::err_operator_new_param_type))
11271 return true;
11272
11273 // C++ [basic.stc.dynamic.allocation]p1:
11274 // The first parameter shall not have an associated default argument.
11275 if (FnDecl->getParamDecl(0)->hasDefaultArg())
Anders Carlsson22f443f2009-12-12 00:26:23 +000011276 return SemaRef.Diag(FnDecl->getLocation(),
Anders Carlsson7e0b2072009-12-13 17:53:43 +000011277 diag::err_operator_new_default_arg)
11278 << FnDecl->getDeclName() << FnDecl->getParamDecl(0)->getDefaultArgRange();
11279
11280 return false;
Anders Carlsson22f443f2009-12-12 00:26:23 +000011281}
11282
11283static bool
Richard Smith66f3ac92012-10-20 08:26:51 +000011284CheckOperatorDeleteDeclaration(Sema &SemaRef, FunctionDecl *FnDecl) {
Anders Carlsson12308f42009-12-11 23:23:22 +000011285 // C++ [basic.stc.dynamic.deallocation]p1:
11286 // A program is ill-formed if deallocation functions are declared in a
11287 // namespace scope other than global scope or declared static in global
11288 // scope.
Anders Carlssone363c8e2009-12-12 00:32:00 +000011289 if (CheckOperatorNewDeleteDeclarationScope(SemaRef, FnDecl))
11290 return true;
Anders Carlsson12308f42009-12-11 23:23:22 +000011291
11292 // C++ [basic.stc.dynamic.deallocation]p2:
11293 // Each deallocation function shall return void and its first parameter
11294 // shall be void*.
Anders Carlsson7e0b2072009-12-13 17:53:43 +000011295 if (CheckOperatorNewDeleteTypes(SemaRef, FnDecl, SemaRef.Context.VoidTy,
11296 SemaRef.Context.VoidPtrTy,
11297 diag::err_operator_delete_dependent_param_type,
11298 diag::err_operator_delete_param_type))
11299 return true;
Anders Carlsson12308f42009-12-11 23:23:22 +000011300
Anders Carlsson12308f42009-12-11 23:23:22 +000011301 return false;
11302}
11303
Douglas Gregor11d0c4c2008-11-06 22:13:31 +000011304/// CheckOverloadedOperatorDeclaration - Check whether the declaration
11305/// of this overloaded operator is well-formed. If so, returns false;
11306/// otherwise, emits appropriate diagnostics and returns true.
11307bool Sema::CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl) {
Douglas Gregord69246b2008-11-17 16:14:12 +000011308 assert(FnDecl && FnDecl->isOverloadedOperator() &&
Douglas Gregor11d0c4c2008-11-06 22:13:31 +000011309 "Expected an overloaded operator declaration");
11310
Douglas Gregor11d0c4c2008-11-06 22:13:31 +000011311 OverloadedOperatorKind Op = FnDecl->getOverloadedOperator();
11312
Mike Stump11289f42009-09-09 15:08:12 +000011313 // C++ [over.oper]p5:
Douglas Gregor11d0c4c2008-11-06 22:13:31 +000011314 // The allocation and deallocation functions, operator new,
11315 // operator new[], operator delete and operator delete[], are
11316 // described completely in 3.7.3. The attributes and restrictions
11317 // found in the rest of this subclause do not apply to them unless
11318 // explicitly stated in 3.7.3.
Anders Carlssonf1f46952009-12-11 23:31:21 +000011319 if (Op == OO_Delete || Op == OO_Array_Delete)
Anders Carlsson12308f42009-12-11 23:23:22 +000011320 return CheckOperatorDeleteDeclaration(*this, FnDecl);
Fariborz Jahanian4e088942009-11-10 23:47:18 +000011321
Anders Carlsson22f443f2009-12-12 00:26:23 +000011322 if (Op == OO_New || Op == OO_Array_New)
11323 return CheckOperatorNewDeclaration(*this, FnDecl);
Douglas Gregor11d0c4c2008-11-06 22:13:31 +000011324
11325 // C++ [over.oper]p6:
11326 // An operator function shall either be a non-static member
11327 // function or be a non-member function and have at least one
11328 // parameter whose type is a class, a reference to a class, an
11329 // enumeration, or a reference to an enumeration.
Douglas Gregord69246b2008-11-17 16:14:12 +000011330 if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) {
11331 if (MethodDecl->isStatic())
11332 return Diag(FnDecl->getLocation(),
Chris Lattnerf3d3fae2008-11-24 05:29:24 +000011333 diag::err_operator_overload_static) << FnDecl->getDeclName();
Douglas Gregor11d0c4c2008-11-06 22:13:31 +000011334 } else {
11335 bool ClassOrEnumParam = false;
Aaron Ballmanf6bf62e2014-03-07 15:12:56 +000011336 for (auto Param : FnDecl->params()) {
11337 QualType ParamType = Param->getType().getNonReferenceType();
Eli Friedman173e0b7a2009-06-27 05:59:59 +000011338 if (ParamType->isDependentType() || ParamType->isRecordType() ||
11339 ParamType->isEnumeralType()) {
Douglas Gregor11d0c4c2008-11-06 22:13:31 +000011340 ClassOrEnumParam = true;
11341 break;
11342 }
11343 }
11344
Douglas Gregord69246b2008-11-17 16:14:12 +000011345 if (!ClassOrEnumParam)
11346 return Diag(FnDecl->getLocation(),
Chris Lattner651d42d2008-11-20 06:38:18 +000011347 diag::err_operator_overload_needs_class_or_enum)
Chris Lattnerf3d3fae2008-11-24 05:29:24 +000011348 << FnDecl->getDeclName();
Douglas Gregor11d0c4c2008-11-06 22:13:31 +000011349 }
11350
11351 // C++ [over.oper]p8:
11352 // An operator function cannot have default arguments (8.3.6),
11353 // except where explicitly stated below.
11354 //
Mike Stump11289f42009-09-09 15:08:12 +000011355 // Only the function-call operator allows default arguments
Douglas Gregor11d0c4c2008-11-06 22:13:31 +000011356 // (C++ [over.call]p1).
11357 if (Op != OO_Call) {
Aaron Ballmanf6bf62e2014-03-07 15:12:56 +000011358 for (auto Param : FnDecl->params()) {
11359 if (Param->hasDefaultArg())
11360 return Diag(Param->getLocation(),
Douglas Gregor58354032008-12-24 00:01:03 +000011361 diag::err_operator_overload_default_arg)
Aaron Ballmanf6bf62e2014-03-07 15:12:56 +000011362 << FnDecl->getDeclName() << Param->getDefaultArgRange();
Douglas Gregor11d0c4c2008-11-06 22:13:31 +000011363 }
11364 }
11365
Douglas Gregor6cf08062008-11-10 13:38:07 +000011366 static const bool OperatorUses[NUM_OVERLOADED_OPERATORS][3] = {
11367 { false, false, false }
11368#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
11369 , { Unary, Binary, MemberOnly }
11370#include "clang/Basic/OperatorKinds.def"
11371 };
Douglas Gregor11d0c4c2008-11-06 22:13:31 +000011372
Douglas Gregor6cf08062008-11-10 13:38:07 +000011373 bool CanBeUnaryOperator = OperatorUses[Op][0];
11374 bool CanBeBinaryOperator = OperatorUses[Op][1];
11375 bool MustBeMemberOperator = OperatorUses[Op][2];
Douglas Gregor11d0c4c2008-11-06 22:13:31 +000011376
11377 // C++ [over.oper]p8:
11378 // [...] Operator functions cannot have more or fewer parameters
11379 // than the number required for the corresponding operator, as
11380 // described in the rest of this subclause.
Mike Stump11289f42009-09-09 15:08:12 +000011381 unsigned NumParams = FnDecl->getNumParams()
Douglas Gregord69246b2008-11-17 16:14:12 +000011382 + (isa<CXXMethodDecl>(FnDecl)? 1 : 0);
Douglas Gregor11d0c4c2008-11-06 22:13:31 +000011383 if (Op != OO_Call &&
11384 ((NumParams == 1 && !CanBeUnaryOperator) ||
11385 (NumParams == 2 && !CanBeBinaryOperator) ||
11386 (NumParams < 1) || (NumParams > 2))) {
11387 // We have the wrong number of parameters.
Chris Lattnerc5bab9f2008-11-21 07:57:12 +000011388 unsigned ErrorKind;
Douglas Gregor6cf08062008-11-10 13:38:07 +000011389 if (CanBeUnaryOperator && CanBeBinaryOperator) {
Chris Lattnerc5bab9f2008-11-21 07:57:12 +000011390 ErrorKind = 2; // 2 -> unary or binary.
Douglas Gregor6cf08062008-11-10 13:38:07 +000011391 } else if (CanBeUnaryOperator) {
Chris Lattnerc5bab9f2008-11-21 07:57:12 +000011392 ErrorKind = 0; // 0 -> unary
Douglas Gregor6cf08062008-11-10 13:38:07 +000011393 } else {
Chris Lattner2b786902008-11-21 07:50:02 +000011394 assert(CanBeBinaryOperator &&
11395 "All non-call overloaded operators are unary or binary!");
Chris Lattnerc5bab9f2008-11-21 07:57:12 +000011396 ErrorKind = 1; // 1 -> binary
Douglas Gregor6cf08062008-11-10 13:38:07 +000011397 }
Douglas Gregor11d0c4c2008-11-06 22:13:31 +000011398
Chris Lattnerc5bab9f2008-11-21 07:57:12 +000011399 return Diag(FnDecl->getLocation(), diag::err_operator_overload_must_be)
Chris Lattnerf3d3fae2008-11-24 05:29:24 +000011400 << FnDecl->getDeclName() << NumParams << ErrorKind;
Douglas Gregor11d0c4c2008-11-06 22:13:31 +000011401 }
Sebastian Redlbaad4e72009-01-05 20:52:13 +000011402
Douglas Gregord69246b2008-11-17 16:14:12 +000011403 // Overloaded operators other than operator() cannot be variadic.
11404 if (Op != OO_Call &&
John McCall9dd450b2009-09-21 23:43:11 +000011405 FnDecl->getType()->getAs<FunctionProtoType>()->isVariadic()) {
Chris Lattner651d42d2008-11-20 06:38:18 +000011406 return Diag(FnDecl->getLocation(), diag::err_operator_overload_variadic)
Chris Lattnerf3d3fae2008-11-24 05:29:24 +000011407 << FnDecl->getDeclName();
Douglas Gregor11d0c4c2008-11-06 22:13:31 +000011408 }
11409
11410 // Some operators must be non-static member functions.
Douglas Gregord69246b2008-11-17 16:14:12 +000011411 if (MustBeMemberOperator && !isa<CXXMethodDecl>(FnDecl)) {
11412 return Diag(FnDecl->getLocation(),
Chris Lattner651d42d2008-11-20 06:38:18 +000011413 diag::err_operator_overload_must_be_member)
Chris Lattnerf3d3fae2008-11-24 05:29:24 +000011414 << FnDecl->getDeclName();
Douglas Gregor11d0c4c2008-11-06 22:13:31 +000011415 }
11416
11417 // C++ [over.inc]p1:
11418 // The user-defined function called operator++ implements the
11419 // prefix and postfix ++ operator. If this function is a member
11420 // function with no parameters, or a non-member function with one
11421 // parameter of class or enumeration type, it defines the prefix
11422 // increment operator ++ for objects of that type. If the function
11423 // is a member function with one parameter (which shall be of type
11424 // int) or a non-member function with two parameters (the second
11425 // of which shall be of type int), it defines the postfix
11426 // increment operator ++ for objects of that type.
11427 if ((Op == OO_PlusPlus || Op == OO_MinusMinus) && NumParams == 2) {
11428 ParmVarDecl *LastParam = FnDecl->getParamDecl(FnDecl->getNumParams() - 1);
Richard Smith538b52a2014-01-30 22:24:05 +000011429 QualType ParamType = LastParam->getType();
Douglas Gregor11d0c4c2008-11-06 22:13:31 +000011430
Richard Smith538b52a2014-01-30 22:24:05 +000011431 if (!ParamType->isSpecificBuiltinType(BuiltinType::Int) &&
11432 !ParamType->isDependentType())
Chris Lattner2b786902008-11-21 07:50:02 +000011433 return Diag(LastParam->getLocation(),
Mike Stump11289f42009-09-09 15:08:12 +000011434 diag::err_operator_overload_post_incdec_must_be_int)
Chris Lattner1e5665e2008-11-24 06:25:27 +000011435 << LastParam->getType() << (Op == OO_MinusMinus);
Douglas Gregor11d0c4c2008-11-06 22:13:31 +000011436 }
11437
Douglas Gregord69246b2008-11-17 16:14:12 +000011438 return false;
Douglas Gregor11d0c4c2008-11-06 22:13:31 +000011439}
Chris Lattner3b024a32008-12-17 07:09:26 +000011440
Alexis Huntc88db062010-01-13 09:01:02 +000011441/// CheckLiteralOperatorDeclaration - Check whether the declaration
11442/// of this literal operator function is well-formed. If so, returns
11443/// false; otherwise, emits appropriate diagnostics and returns true.
11444bool Sema::CheckLiteralOperatorDeclaration(FunctionDecl *FnDecl) {
Richard Smith5731c752012-03-10 22:18:57 +000011445 if (isa<CXXMethodDecl>(FnDecl)) {
Alexis Huntc88db062010-01-13 09:01:02 +000011446 Diag(FnDecl->getLocation(), diag::err_literal_operator_outside_namespace)
11447 << FnDecl->getDeclName();
11448 return true;
11449 }
11450
Richard Smith72eebee2012-03-04 09:41:16 +000011451 if (FnDecl->isExternC()) {
11452 Diag(FnDecl->getLocation(), diag::err_literal_operator_extern_c);
11453 return true;
11454 }
11455
Alexis Huntc88db062010-01-13 09:01:02 +000011456 bool Valid = false;
11457
Richard Smithbcc22fc2012-03-09 08:00:36 +000011458 // This might be the definition of a literal operator template.
11459 FunctionTemplateDecl *TpDecl = FnDecl->getDescribedFunctionTemplate();
11460 // This might be a specialization of a literal operator template.
11461 if (!TpDecl)
11462 TpDecl = FnDecl->getPrimaryTemplate();
11463
Richard Smithb8b41d32013-10-07 19:57:58 +000011464 // template <char...> type operator "" name() and
11465 // template <class T, T...> type operator "" name() are the only valid
11466 // template signatures, and the only valid signatures with no parameters.
Richard Smithbcc22fc2012-03-09 08:00:36 +000011467 if (TpDecl) {
Richard Smith72eebee2012-03-04 09:41:16 +000011468 if (FnDecl->param_size() == 0) {
Richard Smithb8b41d32013-10-07 19:57:58 +000011469 // Must have one or two template parameters
Alexis Hunt7dd26172010-04-07 23:11:06 +000011470 TemplateParameterList *Params = TpDecl->getTemplateParameters();
11471 if (Params->size() == 1) {
11472 NonTypeTemplateParmDecl *PmDecl =
Richard Smithed943022012-08-03 21:14:57 +000011473 dyn_cast<NonTypeTemplateParmDecl>(Params->getParam(0));
Alexis Huntc88db062010-01-13 09:01:02 +000011474
Alexis Hunt7dd26172010-04-07 23:11:06 +000011475 // The template parameter must be a char parameter pack.
Alexis Hunt7dd26172010-04-07 23:11:06 +000011476 if (PmDecl && PmDecl->isTemplateParameterPack() &&
11477 Context.hasSameType(PmDecl->getType(), Context.CharTy))
11478 Valid = true;
Richard Smithb8b41d32013-10-07 19:57:58 +000011479 } else if (Params->size() == 2) {
11480 TemplateTypeParmDecl *PmType =
11481 dyn_cast<TemplateTypeParmDecl>(Params->getParam(0));
11482 NonTypeTemplateParmDecl *PmArgs =
11483 dyn_cast<NonTypeTemplateParmDecl>(Params->getParam(1));
11484
11485 // The second template parameter must be a parameter pack with the
11486 // first template parameter as its type.
11487 if (PmType && PmArgs &&
11488 !PmType->isTemplateParameterPack() &&
11489 PmArgs->isTemplateParameterPack()) {
11490 const TemplateTypeParmType *TArgs =
11491 PmArgs->getType()->getAs<TemplateTypeParmType>();
11492 if (TArgs && TArgs->getDepth() == PmType->getDepth() &&
11493 TArgs->getIndex() == PmType->getIndex()) {
11494 Valid = true;
11495 if (ActiveTemplateInstantiations.empty())
11496 Diag(FnDecl->getLocation(),
11497 diag::ext_string_literal_operator_template);
11498 }
11499 }
Alexis Hunt7dd26172010-04-07 23:11:06 +000011500 }
11501 }
Richard Smith72eebee2012-03-04 09:41:16 +000011502 } else if (FnDecl->param_size()) {
Alexis Huntc88db062010-01-13 09:01:02 +000011503 // Check the first parameter
Alexis Hunt7dd26172010-04-07 23:11:06 +000011504 FunctionDecl::param_iterator Param = FnDecl->param_begin();
11505
Richard Smith72eebee2012-03-04 09:41:16 +000011506 QualType T = (*Param)->getType().getUnqualifiedType();
Alexis Huntc88db062010-01-13 09:01:02 +000011507
Alexis Hunt079a6f72010-04-07 22:57:35 +000011508 // unsigned long long int, long double, and any character type are allowed
11509 // as the only parameters.
Alexis Huntc88db062010-01-13 09:01:02 +000011510 if (Context.hasSameType(T, Context.UnsignedLongLongTy) ||
11511 Context.hasSameType(T, Context.LongDoubleTy) ||
11512 Context.hasSameType(T, Context.CharTy) ||
Hans Wennborg0d81e012013-05-10 10:08:40 +000011513 Context.hasSameType(T, Context.WideCharTy) ||
Alexis Huntc88db062010-01-13 09:01:02 +000011514 Context.hasSameType(T, Context.Char16Ty) ||
11515 Context.hasSameType(T, Context.Char32Ty)) {
11516 if (++Param == FnDecl->param_end())
11517 Valid = true;
11518 goto FinishedParams;
11519 }
11520
Alexis Hunt079a6f72010-04-07 22:57:35 +000011521 // Otherwise it must be a pointer to const; let's strip those qualifiers.
Alexis Huntc88db062010-01-13 09:01:02 +000011522 const PointerType *PT = T->getAs<PointerType>();
11523 if (!PT)
11524 goto FinishedParams;
11525 T = PT->getPointeeType();
Richard Smith72eebee2012-03-04 09:41:16 +000011526 if (!T.isConstQualified() || T.isVolatileQualified())
Alexis Huntc88db062010-01-13 09:01:02 +000011527 goto FinishedParams;
11528 T = T.getUnqualifiedType();
11529
11530 // Move on to the second parameter;
11531 ++Param;
11532
11533 // If there is no second parameter, the first must be a const char *
11534 if (Param == FnDecl->param_end()) {
11535 if (Context.hasSameType(T, Context.CharTy))
11536 Valid = true;
11537 goto FinishedParams;
11538 }
11539
11540 // const char *, const wchar_t*, const char16_t*, and const char32_t*
11541 // are allowed as the first parameter to a two-parameter function
11542 if (!(Context.hasSameType(T, Context.CharTy) ||
Hans Wennborg0d81e012013-05-10 10:08:40 +000011543 Context.hasSameType(T, Context.WideCharTy) ||
Alexis Huntc88db062010-01-13 09:01:02 +000011544 Context.hasSameType(T, Context.Char16Ty) ||
11545 Context.hasSameType(T, Context.Char32Ty)))
11546 goto FinishedParams;
11547
11548 // The second and final parameter must be an std::size_t
11549 T = (*Param)->getType().getUnqualifiedType();
11550 if (Context.hasSameType(T, Context.getSizeType()) &&
11551 ++Param == FnDecl->param_end())
11552 Valid = true;
11553 }
11554
11555 // FIXME: This diagnostic is absolutely terrible.
11556FinishedParams:
11557 if (!Valid) {
11558 Diag(FnDecl->getLocation(), diag::err_literal_operator_params)
11559 << FnDecl->getDeclName();
11560 return true;
11561 }
11562
Richard Smith768cecc2012-03-09 08:16:22 +000011563 // A parameter-declaration-clause containing a default argument is not
11564 // equivalent to any of the permitted forms.
Aaron Ballmanf6bf62e2014-03-07 15:12:56 +000011565 for (auto Param : FnDecl->params()) {
11566 if (Param->hasDefaultArg()) {
11567 Diag(Param->getDefaultArgRange().getBegin(),
Richard Smith768cecc2012-03-09 08:16:22 +000011568 diag::err_literal_operator_default_argument)
Aaron Ballmanf6bf62e2014-03-07 15:12:56 +000011569 << Param->getDefaultArgRange();
Richard Smith768cecc2012-03-09 08:16:22 +000011570 break;
11571 }
11572 }
11573
Richard Smith0df56f42012-03-08 02:39:21 +000011574 StringRef LiteralName
Douglas Gregor86325ad2011-08-30 22:40:35 +000011575 = FnDecl->getDeclName().getCXXLiteralIdentifier()->getName();
11576 if (LiteralName[0] != '_') {
Richard Smith0df56f42012-03-08 02:39:21 +000011577 // C++11 [usrlit.suffix]p1:
11578 // Literal suffix identifiers that do not start with an underscore
11579 // are reserved for future standardization.
Richard Smithf4198b72013-07-23 08:14:48 +000011580 Diag(FnDecl->getLocation(), diag::warn_user_literal_reserved)
11581 << NumericLiteralParser::isValidUDSuffix(getLangOpts(), LiteralName);
Douglas Gregor86325ad2011-08-30 22:40:35 +000011582 }
Richard Smith0df56f42012-03-08 02:39:21 +000011583
Alexis Huntc88db062010-01-13 09:01:02 +000011584 return false;
11585}
11586
Douglas Gregor07665a62009-01-05 19:45:36 +000011587/// ActOnStartLinkageSpecification - Parsed the beginning of a C++
11588/// linkage specification, including the language and (if present)
Richard Smith4ee696d2014-02-17 23:25:27 +000011589/// the '{'. ExternLoc is the location of the 'extern', Lang is the
11590/// language string literal. LBraceLoc, if valid, provides the location of
Douglas Gregor07665a62009-01-05 19:45:36 +000011591/// the '{' brace. Otherwise, this linkage specification does not
11592/// have any braces.
Chris Lattner8ea64422010-11-09 20:15:55 +000011593Decl *Sema::ActOnStartLinkageSpecification(Scope *S, SourceLocation ExternLoc,
Richard Smith4ee696d2014-02-17 23:25:27 +000011594 Expr *LangStr,
Chris Lattner8ea64422010-11-09 20:15:55 +000011595 SourceLocation LBraceLoc) {
Richard Smith4ee696d2014-02-17 23:25:27 +000011596 StringLiteral *Lit = cast<StringLiteral>(LangStr);
11597 if (!Lit->isAscii()) {
11598 Diag(LangStr->getExprLoc(), diag::err_language_linkage_spec_not_ascii)
11599 << LangStr->getSourceRange();
Craig Topperc3ec1492014-05-26 06:22:03 +000011600 return nullptr;
Richard Smith4ee696d2014-02-17 23:25:27 +000011601 }
11602
11603 StringRef Lang = Lit->getString();
Chris Lattner438e5012008-12-17 07:13:27 +000011604 LinkageSpecDecl::LanguageIDs Language;
Richard Smith4ee696d2014-02-17 23:25:27 +000011605 if (Lang == "C")
Chris Lattner438e5012008-12-17 07:13:27 +000011606 Language = LinkageSpecDecl::lang_c;
Richard Smith4ee696d2014-02-17 23:25:27 +000011607 else if (Lang == "C++")
Chris Lattner438e5012008-12-17 07:13:27 +000011608 Language = LinkageSpecDecl::lang_cxx;
11609 else {
Richard Smith4ee696d2014-02-17 23:25:27 +000011610 Diag(LangStr->getExprLoc(), diag::err_language_linkage_spec_unknown)
11611 << LangStr->getSourceRange();
Craig Topperc3ec1492014-05-26 06:22:03 +000011612 return nullptr;
Chris Lattner438e5012008-12-17 07:13:27 +000011613 }
Mike Stump11289f42009-09-09 15:08:12 +000011614
Chris Lattner438e5012008-12-17 07:13:27 +000011615 // FIXME: Add all the various semantics of linkage specifications
Mike Stump11289f42009-09-09 15:08:12 +000011616
Richard Smith4ee696d2014-02-17 23:25:27 +000011617 LinkageSpecDecl *D = LinkageSpecDecl::Create(Context, CurContext, ExternLoc,
11618 LangStr->getExprLoc(), Language,
Rafael Espindola327be3c2013-04-26 01:30:23 +000011619 LBraceLoc.isValid());
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +000011620 CurContext->addDecl(D);
Douglas Gregor07665a62009-01-05 19:45:36 +000011621 PushDeclContext(S, D);
John McCall48871652010-08-21 09:40:31 +000011622 return D;
Chris Lattner438e5012008-12-17 07:13:27 +000011623}
11624
Abramo Bagnaraed5b6892010-07-30 16:47:02 +000011625/// ActOnFinishLinkageSpecification - Complete the definition of
Douglas Gregor07665a62009-01-05 19:45:36 +000011626/// the C++ linkage specification LinkageSpec. If RBraceLoc is
11627/// valid, it's the position of the closing '}' brace in a linkage
11628/// specification that uses braces.
John McCall48871652010-08-21 09:40:31 +000011629Decl *Sema::ActOnFinishLinkageSpecification(Scope *S,
Abramo Bagnara4a8cda82011-03-03 14:52:38 +000011630 Decl *LinkageSpec,
11631 SourceLocation RBraceLoc) {
Richard Smith4ee696d2014-02-17 23:25:27 +000011632 if (RBraceLoc.isValid()) {
11633 LinkageSpecDecl* LSDecl = cast<LinkageSpecDecl>(LinkageSpec);
11634 LSDecl->setRBraceLoc(RBraceLoc);
Abramo Bagnara4a8cda82011-03-03 14:52:38 +000011635 }
Richard Smith4ee696d2014-02-17 23:25:27 +000011636 PopDeclContext();
Douglas Gregor07665a62009-01-05 19:45:36 +000011637 return LinkageSpec;
Chris Lattner3b024a32008-12-17 07:09:26 +000011638}
11639
Michael Han84324352013-02-22 17:15:32 +000011640Decl *Sema::ActOnEmptyDeclaration(Scope *S,
11641 AttributeList *AttrList,
11642 SourceLocation SemiLoc) {
11643 Decl *ED = EmptyDecl::Create(Context, CurContext, SemiLoc);
11644 // Attribute declarations appertain to empty declaration so we handle
11645 // them here.
11646 if (AttrList)
11647 ProcessDeclAttributeList(S, ED, AttrList);
Richard Smith54ecd982013-02-20 19:22:51 +000011648
Michael Han84324352013-02-22 17:15:32 +000011649 CurContext->addDecl(ED);
11650 return ED;
Richard Smith54ecd982013-02-20 19:22:51 +000011651}
11652
Douglas Gregor5e16fbe2009-05-18 20:51:54 +000011653/// \brief Perform semantic analysis for the variable declaration that
11654/// occurs within a C++ catch clause, returning the newly-created
11655/// variable.
Abramo Bagnaradff19302011-03-08 08:55:46 +000011656VarDecl *Sema::BuildExceptionDeclaration(Scope *S,
John McCallbcd03502009-12-07 02:54:59 +000011657 TypeSourceInfo *TInfo,
Abramo Bagnaradff19302011-03-08 08:55:46 +000011658 SourceLocation StartLoc,
11659 SourceLocation Loc,
11660 IdentifierInfo *Name) {
Douglas Gregor5e16fbe2009-05-18 20:51:54 +000011661 bool Invalid = false;
Douglas Gregor9f0e1aa2010-09-09 17:09:21 +000011662 QualType ExDeclType = TInfo->getType();
11663
Sebastian Redl54c04d42008-12-22 19:15:10 +000011664 // Arrays and functions decay.
11665 if (ExDeclType->isArrayType())
11666 ExDeclType = Context.getArrayDecayedType(ExDeclType);
11667 else if (ExDeclType->isFunctionType())
11668 ExDeclType = Context.getPointerType(ExDeclType);
11669
11670 // C++ 15.3p1: The exception-declaration shall not denote an incomplete type.
11671 // The exception-declaration shall not denote a pointer or reference to an
11672 // incomplete type, other than [cv] void*.
Sebastian Redlb28b4072009-03-22 23:49:27 +000011673 // N2844 forbids rvalue references.
Mike Stump11289f42009-09-09 15:08:12 +000011674 if (!ExDeclType->isDependentType() && ExDeclType->isRValueReferenceType()) {
Douglas Gregor9f0e1aa2010-09-09 17:09:21 +000011675 Diag(Loc, diag::err_catch_rvalue_ref);
Sebastian Redlb28b4072009-03-22 23:49:27 +000011676 Invalid = true;
11677 }
Douglas Gregor5e16fbe2009-05-18 20:51:54 +000011678
Sebastian Redl54c04d42008-12-22 19:15:10 +000011679 QualType BaseType = ExDeclType;
11680 int Mode = 0; // 0 for direct type, 1 for pointer, 2 for reference
Douglas Gregordd430f72009-01-19 19:26:10 +000011681 unsigned DK = diag::err_catch_incomplete;
Ted Kremenekc23c7e62009-07-29 21:53:49 +000011682 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) {
Sebastian Redl54c04d42008-12-22 19:15:10 +000011683 BaseType = Ptr->getPointeeType();
11684 Mode = 1;
Douglas Gregor3ecbc3d2012-01-24 19:01:26 +000011685 DK = diag::err_catch_incomplete_ptr;
Mike Stump11289f42009-09-09 15:08:12 +000011686 } else if (const ReferenceType *Ref = BaseType->getAs<ReferenceType>()) {
Sebastian Redlb28b4072009-03-22 23:49:27 +000011687 // For the purpose of error recovery, we treat rvalue refs like lvalue refs.
Sebastian Redl54c04d42008-12-22 19:15:10 +000011688 BaseType = Ref->getPointeeType();
11689 Mode = 2;
Douglas Gregor3ecbc3d2012-01-24 19:01:26 +000011690 DK = diag::err_catch_incomplete_ref;
Sebastian Redl54c04d42008-12-22 19:15:10 +000011691 }
Sebastian Redlb28b4072009-03-22 23:49:27 +000011692 if (!Invalid && (Mode == 0 || !BaseType->isVoidType()) &&
Douglas Gregor3ecbc3d2012-01-24 19:01:26 +000011693 !BaseType->isDependentType() && RequireCompleteType(Loc, BaseType, DK))
Sebastian Redl54c04d42008-12-22 19:15:10 +000011694 Invalid = true;
Sebastian Redl54c04d42008-12-22 19:15:10 +000011695
Mike Stump11289f42009-09-09 15:08:12 +000011696 if (!Invalid && !ExDeclType->isDependentType() &&
Douglas Gregor5e16fbe2009-05-18 20:51:54 +000011697 RequireNonAbstractType(Loc, ExDeclType,
11698 diag::err_abstract_type_in_decl,
11699 AbstractVariableType))
Sebastian Redl2f38ba52009-04-27 21:03:30 +000011700 Invalid = true;
11701
John McCall2ca705e2010-07-24 00:37:23 +000011702 // Only the non-fragile NeXT runtime currently supports C++ catches
11703 // of ObjC types, and no runtime supports catching ObjC types by value.
David Blaikiebbafb8a2012-03-11 07:00:24 +000011704 if (!Invalid && getLangOpts().ObjC1) {
John McCall2ca705e2010-07-24 00:37:23 +000011705 QualType T = ExDeclType;
11706 if (const ReferenceType *RT = T->getAs<ReferenceType>())
11707 T = RT->getPointeeType();
11708
11709 if (T->isObjCObjectType()) {
11710 Diag(Loc, diag::err_objc_object_catch);
11711 Invalid = true;
11712 } else if (T->isObjCObjectPointerType()) {
John McCall5fb5df92012-06-20 06:18:46 +000011713 // FIXME: should this be a test for macosx-fragile specifically?
11714 if (getLangOpts().ObjCRuntime.isFragile())
Fariborz Jahanian831f0fc2011-06-23 19:00:08 +000011715 Diag(Loc, diag::warn_objc_pointer_cxx_catch_fragile);
John McCall2ca705e2010-07-24 00:37:23 +000011716 }
11717 }
11718
Abramo Bagnaradff19302011-03-08 08:55:46 +000011719 VarDecl *ExDecl = VarDecl::Create(Context, CurContext, StartLoc, Loc, Name,
Rafael Espindola6ae7e502013-04-03 19:27:57 +000011720 ExDeclType, TInfo, SC_None);
Douglas Gregor3f324d562010-05-03 18:51:14 +000011721 ExDecl->setExceptionVariable(true);
11722
Douglas Gregor8ca0c642011-12-10 01:22:52 +000011723 // In ARC, infer 'retaining' for variables of retainable type.
David Blaikiebbafb8a2012-03-11 07:00:24 +000011724 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(ExDecl))
Douglas Gregor8ca0c642011-12-10 01:22:52 +000011725 Invalid = true;
11726
Douglas Gregor750734c2011-07-06 18:14:43 +000011727 if (!Invalid && !ExDeclType->isDependentType()) {
John McCall1bf58462011-02-16 08:02:54 +000011728 if (const RecordType *recordType = ExDeclType->getAs<RecordType>()) {
John McCalleaef89b2013-03-22 02:10:40 +000011729 // Insulate this from anything else we might currently be parsing.
11730 EnterExpressionEvaluationContext scope(*this, PotentiallyEvaluated);
11731
Douglas Gregor6de584c2010-03-05 23:38:39 +000011732 // C++ [except.handle]p16:
Nick Lewycky0f292892013-09-22 10:06:57 +000011733 // The object declared in an exception-declaration or, if the
11734 // exception-declaration does not specify a name, a temporary (12.2) is
Douglas Gregor6de584c2010-03-05 23:38:39 +000011735 // copy-initialized (8.5) from the exception object. [...]
11736 // The object is destroyed when the handler exits, after the destruction
11737 // of any automatic objects initialized within the handler.
11738 //
Nick Lewycky0f292892013-09-22 10:06:57 +000011739 // We just pretend to initialize the object with itself, then make sure
Douglas Gregor6de584c2010-03-05 23:38:39 +000011740 // it can be destroyed later.
John McCall1bf58462011-02-16 08:02:54 +000011741 QualType initType = ExDeclType;
11742
11743 InitializedEntity entity =
11744 InitializedEntity::InitializeVariable(ExDecl);
11745 InitializationKind initKind =
11746 InitializationKind::CreateCopy(Loc, SourceLocation());
11747
11748 Expr *opaqueValue =
11749 new (Context) OpaqueValueExpr(Loc, initType, VK_LValue, OK_Ordinary);
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +000011750 InitializationSequence sequence(*this, entity, initKind, opaqueValue);
11751 ExprResult result = sequence.Perform(*this, entity, initKind, opaqueValue);
John McCall1bf58462011-02-16 08:02:54 +000011752 if (result.isInvalid())
Douglas Gregor6de584c2010-03-05 23:38:39 +000011753 Invalid = true;
John McCall1bf58462011-02-16 08:02:54 +000011754 else {
11755 // If the constructor used was non-trivial, set this as the
11756 // "initializer".
Nikola Smiljanic01a75982014-05-29 10:55:11 +000011757 CXXConstructExpr *construct = result.getAs<CXXConstructExpr>();
John McCall1bf58462011-02-16 08:02:54 +000011758 if (!construct->getConstructor()->isTrivial()) {
11759 Expr *init = MaybeCreateExprWithCleanups(construct);
11760 ExDecl->setInit(init);
11761 }
11762
11763 // And make sure it's destructable.
11764 FinalizeVarWithDestructor(ExDecl, recordType);
11765 }
Douglas Gregor6de584c2010-03-05 23:38:39 +000011766 }
11767 }
11768
Douglas Gregor5e16fbe2009-05-18 20:51:54 +000011769 if (Invalid)
11770 ExDecl->setInvalidDecl();
11771
11772 return ExDecl;
11773}
11774
11775/// ActOnExceptionDeclarator - Parsed the exception-declarator in a C++ catch
11776/// handler.
John McCall48871652010-08-21 09:40:31 +000011777Decl *Sema::ActOnExceptionDeclarator(Scope *S, Declarator &D) {
John McCall8cb7bdf2010-06-04 23:28:52 +000011778 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
Douglas Gregor72772f62010-12-16 17:48:04 +000011779 bool Invalid = D.isInvalidType();
11780
11781 // Check for unexpanded parameter packs.
Jordan Rosed03d99d2013-03-05 01:27:54 +000011782 if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
11783 UPPC_ExceptionType)) {
Douglas Gregor72772f62010-12-16 17:48:04 +000011784 TInfo = Context.getTrivialTypeSourceInfo(Context.IntTy,
11785 D.getIdentifierLoc());
11786 Invalid = true;
11787 }
11788
Sebastian Redl54c04d42008-12-22 19:15:10 +000011789 IdentifierInfo *II = D.getIdentifier();
Douglas Gregorb2ccf012010-04-15 22:33:43 +000011790 if (NamedDecl *PrevDecl = LookupSingleName(S, II, D.getIdentifierLoc(),
Douglas Gregorb8eaf292010-04-15 23:40:53 +000011791 LookupOrdinaryName,
11792 ForRedeclaration)) {
Sebastian Redl54c04d42008-12-22 19:15:10 +000011793 // The scope should be freshly made just for us. There is just no way
Aaron Ballman9ef622e2014-06-02 13:10:07 +000011794 // it contains any previous declaration, except for function parameters in
11795 // a function-try-block's catch statement.
John McCall48871652010-08-21 09:40:31 +000011796 assert(!S->isDeclScope(PrevDecl));
Aaron Ballman9ef622e2014-06-02 13:10:07 +000011797 if (isDeclInScope(PrevDecl, CurContext, S)) {
11798 Diag(D.getIdentifierLoc(), diag::err_redefinition)
11799 << D.getIdentifier();
11800 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
11801 Invalid = true;
11802 } else if (PrevDecl->isTemplateParameter())
Sebastian Redl54c04d42008-12-22 19:15:10 +000011803 // Maybe we will complain about the shadowed template parameter.
11804 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
Sebastian Redl54c04d42008-12-22 19:15:10 +000011805 }
11806
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +000011807 if (D.getCXXScopeSpec().isSet() && !Invalid) {
Sebastian Redl54c04d42008-12-22 19:15:10 +000011808 Diag(D.getIdentifierLoc(), diag::err_qualified_catch_declarator)
11809 << D.getCXXScopeSpec().getRange();
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +000011810 Invalid = true;
Sebastian Redl54c04d42008-12-22 19:15:10 +000011811 }
11812
Douglas Gregor9f0e1aa2010-09-09 17:09:21 +000011813 VarDecl *ExDecl = BuildExceptionDeclaration(S, TInfo,
Daniel Dunbar62ee6412012-03-09 18:35:03 +000011814 D.getLocStart(),
Abramo Bagnaradff19302011-03-08 08:55:46 +000011815 D.getIdentifierLoc(),
11816 D.getIdentifier());
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +000011817 if (Invalid)
11818 ExDecl->setInvalidDecl();
Mike Stump11289f42009-09-09 15:08:12 +000011819
Sebastian Redl54c04d42008-12-22 19:15:10 +000011820 // Add the exception declaration into this scope.
Sebastian Redl54c04d42008-12-22 19:15:10 +000011821 if (II)
Douglas Gregor5e16fbe2009-05-18 20:51:54 +000011822 PushOnScopeChains(ExDecl, S);
11823 else
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +000011824 CurContext->addDecl(ExDecl);
Sebastian Redl54c04d42008-12-22 19:15:10 +000011825
Douglas Gregor758a8692009-06-17 21:51:59 +000011826 ProcessDeclAttributes(S, ExDecl, D);
John McCall48871652010-08-21 09:40:31 +000011827 return ExDecl;
Sebastian Redl54c04d42008-12-22 19:15:10 +000011828}
Anders Carlsson5bbe1d72009-03-14 00:25:26 +000011829
Abramo Bagnaraea947882011-03-08 16:41:52 +000011830Decl *Sema::ActOnStaticAssertDeclaration(SourceLocation StaticAssertLoc,
John McCallb268a282010-08-23 23:25:46 +000011831 Expr *AssertExpr,
Richard Smithded9c2e2012-07-11 22:37:56 +000011832 Expr *AssertMessageExpr,
Abramo Bagnaraea947882011-03-08 16:41:52 +000011833 SourceLocation RParenLoc) {
Richard Smith085a64f2014-06-20 19:57:12 +000011834 StringLiteral *AssertMessage =
11835 AssertMessageExpr ? cast<StringLiteral>(AssertMessageExpr) : nullptr;
Anders Carlsson5bbe1d72009-03-14 00:25:26 +000011836
Richard Smithded9c2e2012-07-11 22:37:56 +000011837 if (DiagnoseUnexpandedParameterPack(AssertExpr, UPPC_StaticAssertExpression))
Craig Topperc3ec1492014-05-26 06:22:03 +000011838 return nullptr;
Richard Smithded9c2e2012-07-11 22:37:56 +000011839
11840 return BuildStaticAssertDeclaration(StaticAssertLoc, AssertExpr,
11841 AssertMessage, RParenLoc, false);
11842}
11843
11844Decl *Sema::BuildStaticAssertDeclaration(SourceLocation StaticAssertLoc,
11845 Expr *AssertExpr,
11846 StringLiteral *AssertMessage,
11847 SourceLocation RParenLoc,
11848 bool Failed) {
Richard Smith085a64f2014-06-20 19:57:12 +000011849 assert(AssertExpr != nullptr && "Expected non-null condition");
Richard Smithded9c2e2012-07-11 22:37:56 +000011850 if (!AssertExpr->isTypeDependent() && !AssertExpr->isValueDependent() &&
11851 !Failed) {
Richard Smithf4c51d92012-02-04 09:53:13 +000011852 // In a static_assert-declaration, the constant-expression shall be a
11853 // constant expression that can be contextually converted to bool.
11854 ExprResult Converted = PerformContextuallyConvertToBool(AssertExpr);
11855 if (Converted.isInvalid())
Richard Smithded9c2e2012-07-11 22:37:56 +000011856 Failed = true;
Richard Smithf4c51d92012-02-04 09:53:13 +000011857
Richard Smith902ca212011-12-14 23:32:26 +000011858 llvm::APSInt Cond;
Richard Smithded9c2e2012-07-11 22:37:56 +000011859 if (!Failed && VerifyIntegerConstantExpression(Converted.get(), &Cond,
Douglas Gregore2b37442012-05-04 22:38:52 +000011860 diag::err_static_assert_expression_is_not_constant,
Richard Smithf4c51d92012-02-04 09:53:13 +000011861 /*AllowFold=*/false).isInvalid())
Richard Smithded9c2e2012-07-11 22:37:56 +000011862 Failed = true;
Anders Carlsson5bbe1d72009-03-14 00:25:26 +000011863
Richard Smithded9c2e2012-07-11 22:37:56 +000011864 if (!Failed && !Cond) {
Dmitri Gribenkof8579502013-01-12 19:30:44 +000011865 SmallString<256> MsgBuffer;
Richard Smithf506eaf2012-03-05 23:20:05 +000011866 llvm::raw_svector_ostream Msg(MsgBuffer);
Richard Smith085a64f2014-06-20 19:57:12 +000011867 if (AssertMessage)
11868 AssertMessage->printPretty(Msg, nullptr, getPrintingPolicy());
Abramo Bagnaraea947882011-03-08 16:41:52 +000011869 Diag(StaticAssertLoc, diag::err_static_assert_failed)
Richard Smith085a64f2014-06-20 19:57:12 +000011870 << !AssertMessage << Msg.str() << AssertExpr->getSourceRange();
Richard Smithded9c2e2012-07-11 22:37:56 +000011871 Failed = true;
Richard Smithf506eaf2012-03-05 23:20:05 +000011872 }
Anders Carlsson54b26982009-03-14 00:33:21 +000011873 }
Mike Stump11289f42009-09-09 15:08:12 +000011874
Abramo Bagnaraea947882011-03-08 16:41:52 +000011875 Decl *Decl = StaticAssertDecl::Create(Context, CurContext, StaticAssertLoc,
Richard Smithded9c2e2012-07-11 22:37:56 +000011876 AssertExpr, AssertMessage, RParenLoc,
11877 Failed);
Mike Stump11289f42009-09-09 15:08:12 +000011878
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +000011879 CurContext->addDecl(Decl);
John McCall48871652010-08-21 09:40:31 +000011880 return Decl;
Anders Carlsson5bbe1d72009-03-14 00:25:26 +000011881}
Sebastian Redlf769df52009-03-24 22:27:57 +000011882
Douglas Gregorafb9bc12010-04-07 16:53:43 +000011883/// \brief Perform semantic analysis of the given friend type declaration.
11884///
11885/// \returns A friend declaration that.
Richard Smitha31a89a2012-09-20 01:31:00 +000011886FriendDecl *Sema::CheckFriendTypeDecl(SourceLocation LocStart,
Abramo Bagnara254b6302011-10-29 20:52:52 +000011887 SourceLocation FriendLoc,
Douglas Gregorafb9bc12010-04-07 16:53:43 +000011888 TypeSourceInfo *TSInfo) {
11889 assert(TSInfo && "NULL TypeSourceInfo for friend type declaration");
11890
11891 QualType T = TSInfo->getType();
Abramo Bagnara1108e7b2010-05-20 10:00:11 +000011892 SourceRange TypeRange = TSInfo->getTypeLoc().getLocalSourceRange();
Douglas Gregorafb9bc12010-04-07 16:53:43 +000011893
Richard Smithc8239732011-10-18 21:39:00 +000011894 // C++03 [class.friend]p2:
11895 // An elaborated-type-specifier shall be used in a friend declaration
11896 // for a class.*
11897 //
11898 // * The class-key of the elaborated-type-specifier is required.
11899 if (!ActiveTemplateInstantiations.empty()) {
11900 // Do not complain about the form of friend template types during
11901 // template instantiation; we will already have complained when the
11902 // template was declared.
Nick Lewycky36722d22013-02-06 05:59:33 +000011903 } else {
11904 if (!T->isElaboratedTypeSpecifier()) {
11905 // If we evaluated the type to a record type, suggest putting
11906 // a tag in front.
11907 if (const RecordType *RT = T->getAs<RecordType>()) {
11908 RecordDecl *RD = RT->getDecl();
Alp Tokera030cd02014-05-05 12:38:48 +000011909
11910 SmallString<16> InsertionText(" ");
11911 InsertionText += RD->getKindName();
11912
Nick Lewycky36722d22013-02-06 05:59:33 +000011913 Diag(TypeRange.getBegin(),
11914 getLangOpts().CPlusPlus11 ?
11915 diag::warn_cxx98_compat_unelaborated_friend_type :
11916 diag::ext_unelaborated_friend_type)
11917 << (unsigned) RD->getTagKind()
11918 << T
11919 << FixItHint::CreateInsertion(PP.getLocForEndOfToken(FriendLoc),
11920 InsertionText);
11921 } else {
11922 Diag(FriendLoc,
11923 getLangOpts().CPlusPlus11 ?
11924 diag::warn_cxx98_compat_nonclass_type_friend :
11925 diag::ext_nonclass_type_friend)
11926 << T
11927 << TypeRange;
11928 }
11929 } else if (T->getAs<EnumType>()) {
Richard Smithc8239732011-10-18 21:39:00 +000011930 Diag(FriendLoc,
Richard Smith2bf7fdb2013-01-02 11:42:31 +000011931 getLangOpts().CPlusPlus11 ?
Nick Lewycky36722d22013-02-06 05:59:33 +000011932 diag::warn_cxx98_compat_enum_friend :
11933 diag::ext_enum_friend)
Douglas Gregorafb9bc12010-04-07 16:53:43 +000011934 << T
Richard Smitha31a89a2012-09-20 01:31:00 +000011935 << TypeRange;
Douglas Gregorafb9bc12010-04-07 16:53:43 +000011936 }
Douglas Gregorafb9bc12010-04-07 16:53:43 +000011937
Nick Lewycky36722d22013-02-06 05:59:33 +000011938 // C++11 [class.friend]p3:
11939 // A friend declaration that does not declare a function shall have one
11940 // of the following forms:
11941 // friend elaborated-type-specifier ;
11942 // friend simple-type-specifier ;
11943 // friend typename-specifier ;
11944 if (getLangOpts().CPlusPlus11 && LocStart != FriendLoc)
11945 Diag(FriendLoc, diag::err_friend_not_first_in_declaration) << T;
11946 }
Richard Smitha31a89a2012-09-20 01:31:00 +000011947
Douglas Gregor3b4abb62010-04-07 17:57:12 +000011948 // If the type specifier in a friend declaration designates a (possibly
Richard Smitha31a89a2012-09-20 01:31:00 +000011949 // cv-qualified) class type, that class is declared as a friend; otherwise,
Douglas Gregor3b4abb62010-04-07 17:57:12 +000011950 // the friend declaration is ignored.
Nikola Smiljanic3a01af02014-05-23 12:48:27 +000011951 return FriendDecl::Create(Context, CurContext,
11952 TSInfo->getTypeLoc().getLocStart(), TSInfo,
11953 FriendLoc);
Douglas Gregorafb9bc12010-04-07 16:53:43 +000011954}
11955
John McCallace48cd2010-10-19 01:40:49 +000011956/// Handle a friend tag declaration where the scope specifier was
11957/// templated.
11958Decl *Sema::ActOnTemplatedFriendTag(Scope *S, SourceLocation FriendLoc,
11959 unsigned TagSpec, SourceLocation TagLoc,
11960 CXXScopeSpec &SS,
Enea Zaffanellaeb22c872013-01-31 09:54:08 +000011961 IdentifierInfo *Name,
11962 SourceLocation NameLoc,
John McCallace48cd2010-10-19 01:40:49 +000011963 AttributeList *Attr,
11964 MultiTemplateParamsArg TempParamLists) {
11965 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
11966
11967 bool isExplicitSpecialization = false;
John McCallace48cd2010-10-19 01:40:49 +000011968 bool Invalid = false;
11969
Robert Wilhelmf2d2e8f2013-07-21 15:20:44 +000011970 if (TemplateParameterList *TemplateParams =
11971 MatchTemplateParametersToScopeSpecifier(
Craig Topperc3ec1492014-05-26 06:22:03 +000011972 TagLoc, NameLoc, SS, nullptr, TempParamLists, /*friend*/ true,
Robert Wilhelmf2d2e8f2013-07-21 15:20:44 +000011973 isExplicitSpecialization, Invalid)) {
John McCallace48cd2010-10-19 01:40:49 +000011974 if (TemplateParams->size() > 0) {
11975 // This is a declaration of a class template.
11976 if (Invalid)
Craig Topperc3ec1492014-05-26 06:22:03 +000011977 return nullptr;
Abramo Bagnara0adf29a2011-03-10 13:28:31 +000011978
Nikola Smiljanic4fc91532014-07-17 01:59:34 +000011979 return CheckClassTemplate(S, TagSpec, TUK_Friend, TagLoc, SS, Name,
11980 NameLoc, Attr, TemplateParams, AS_public,
Douglas Gregor2820e692011-09-09 19:05:14 +000011981 /*ModulePrivateLoc=*/SourceLocation(),
Nikola Smiljanic4fc91532014-07-17 01:59:34 +000011982 FriendLoc, TempParamLists.size() - 1,
Nikola Smiljanic01a75982014-05-29 10:55:11 +000011983 TempParamLists.data()).get();
John McCallace48cd2010-10-19 01:40:49 +000011984 } else {
11985 // The "template<>" header is extraneous.
11986 Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams)
11987 << TypeWithKeyword::getTagTypeKindName(Kind) << Name;
11988 isExplicitSpecialization = true;
11989 }
11990 }
11991
Craig Topperc3ec1492014-05-26 06:22:03 +000011992 if (Invalid) return nullptr;
John McCallace48cd2010-10-19 01:40:49 +000011993
John McCallace48cd2010-10-19 01:40:49 +000011994 bool isAllExplicitSpecializations = true;
Abramo Bagnara60804e12011-03-18 15:16:37 +000011995 for (unsigned I = TempParamLists.size(); I-- > 0; ) {
Benjamin Kramer62b95d82012-08-23 21:35:17 +000011996 if (TempParamLists[I]->size()) {
John McCallace48cd2010-10-19 01:40:49 +000011997 isAllExplicitSpecializations = false;
11998 break;
11999 }
12000 }
12001
12002 // FIXME: don't ignore attributes.
12003
12004 // If it's explicit specializations all the way down, just forget
12005 // about the template header and build an appropriate non-templated
12006 // friend. TODO: for source fidelity, remember the headers.
12007 if (isAllExplicitSpecializations) {
Douglas Gregorf65d8ff2011-10-20 15:58:54 +000012008 if (SS.isEmpty()) {
12009 bool Owned = false;
12010 bool IsDependent = false;
12011 return ActOnTag(S, TagSpec, TUK_Friend, TagLoc, SS, Name, NameLoc,
Richard Smith649c7b062014-01-08 00:56:48 +000012012 Attr, AS_public,
Douglas Gregorf65d8ff2011-10-20 15:58:54 +000012013 /*ModulePrivateLoc=*/SourceLocation(),
Richard Smith649c7b062014-01-08 00:56:48 +000012014 MultiTemplateParamsArg(), Owned, IsDependent,
Richard Smith0f8ee222012-01-10 01:33:14 +000012015 /*ScopedEnumKWLoc=*/SourceLocation(),
Douglas Gregorf65d8ff2011-10-20 15:58:54 +000012016 /*ScopedEnumUsesClassTag=*/false,
Richard Smith649c7b062014-01-08 00:56:48 +000012017 /*UnderlyingType=*/TypeResult(),
12018 /*IsTypeSpecifier=*/false);
Douglas Gregorf65d8ff2011-10-20 15:58:54 +000012019 }
Richard Smith649c7b062014-01-08 00:56:48 +000012020
Douglas Gregor3d0da5f2011-03-01 01:34:45 +000012021 NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
John McCallace48cd2010-10-19 01:40:49 +000012022 ElaboratedTypeKeyword Keyword
12023 = TypeWithKeyword::getKeywordForTagTypeKind(Kind);
Douglas Gregor3d0da5f2011-03-01 01:34:45 +000012024 QualType T = CheckTypenameType(Keyword, TagLoc, QualifierLoc,
Douglas Gregor9cbc22b2011-02-28 22:42:13 +000012025 *Name, NameLoc);
John McCallace48cd2010-10-19 01:40:49 +000012026 if (T.isNull())
Craig Topperc3ec1492014-05-26 06:22:03 +000012027 return nullptr;
John McCallace48cd2010-10-19 01:40:49 +000012028
12029 TypeSourceInfo *TSI = Context.CreateTypeSourceInfo(T);
12030 if (isa<DependentNameType>(T)) {
David Blaikie6adc78e2013-02-18 22:06:02 +000012031 DependentNameTypeLoc TL =
12032 TSI->getTypeLoc().castAs<DependentNameTypeLoc>();
Abramo Bagnara9033e2b2012-02-06 19:09:27 +000012033 TL.setElaboratedKeywordLoc(TagLoc);
Douglas Gregor3d0da5f2011-03-01 01:34:45 +000012034 TL.setQualifierLoc(QualifierLoc);
John McCallace48cd2010-10-19 01:40:49 +000012035 TL.setNameLoc(NameLoc);
12036 } else {
David Blaikie6adc78e2013-02-18 22:06:02 +000012037 ElaboratedTypeLoc TL = TSI->getTypeLoc().castAs<ElaboratedTypeLoc>();
Abramo Bagnara9033e2b2012-02-06 19:09:27 +000012038 TL.setElaboratedKeywordLoc(TagLoc);
Douglas Gregor844cb502011-03-01 18:12:44 +000012039 TL.setQualifierLoc(QualifierLoc);
David Blaikie6adc78e2013-02-18 22:06:02 +000012040 TL.getNamedTypeLoc().castAs<TypeSpecTypeLoc>().setNameLoc(NameLoc);
John McCallace48cd2010-10-19 01:40:49 +000012041 }
12042
12043 FriendDecl *Friend = FriendDecl::Create(Context, CurContext, NameLoc,
Enea Zaffanellaeb22c872013-01-31 09:54:08 +000012044 TSI, FriendLoc, TempParamLists);
John McCallace48cd2010-10-19 01:40:49 +000012045 Friend->setAccess(AS_public);
12046 CurContext->addDecl(Friend);
12047 return Friend;
12048 }
Douglas Gregorf65d8ff2011-10-20 15:58:54 +000012049
12050 assert(SS.isNotEmpty() && "valid templated tag with no SS and no direct?");
12051
12052
John McCallace48cd2010-10-19 01:40:49 +000012053
12054 // Handle the case of a templated-scope friend class. e.g.
12055 // template <class T> class A<T>::B;
12056 // FIXME: we don't support these right now.
Richard Smithcd556eb2013-11-08 18:59:56 +000012057 Diag(NameLoc, diag::warn_template_qualified_friend_unsupported)
12058 << SS.getScopeRep() << SS.getRange() << cast<CXXRecordDecl>(CurContext);
John McCallace48cd2010-10-19 01:40:49 +000012059 ElaboratedTypeKeyword ETK = TypeWithKeyword::getKeywordForTagTypeKind(Kind);
12060 QualType T = Context.getDependentNameType(ETK, SS.getScopeRep(), Name);
12061 TypeSourceInfo *TSI = Context.CreateTypeSourceInfo(T);
David Blaikie6adc78e2013-02-18 22:06:02 +000012062 DependentNameTypeLoc TL = TSI->getTypeLoc().castAs<DependentNameTypeLoc>();
Abramo Bagnara9033e2b2012-02-06 19:09:27 +000012063 TL.setElaboratedKeywordLoc(TagLoc);
Douglas Gregor3d0da5f2011-03-01 01:34:45 +000012064 TL.setQualifierLoc(SS.getWithLocInContext(Context));
John McCallace48cd2010-10-19 01:40:49 +000012065 TL.setNameLoc(NameLoc);
12066
12067 FriendDecl *Friend = FriendDecl::Create(Context, CurContext, NameLoc,
Enea Zaffanellaeb22c872013-01-31 09:54:08 +000012068 TSI, FriendLoc, TempParamLists);
John McCallace48cd2010-10-19 01:40:49 +000012069 Friend->setAccess(AS_public);
12070 Friend->setUnsupportedFriend(true);
12071 CurContext->addDecl(Friend);
12072 return Friend;
12073}
12074
12075
John McCall11083da2009-09-16 22:47:08 +000012076/// Handle a friend type declaration. This works in tandem with
12077/// ActOnTag.
12078///
12079/// Notes on friend class templates:
12080///
12081/// We generally treat friend class declarations as if they were
12082/// declaring a class. So, for example, the elaborated type specifier
12083/// in a friend declaration is required to obey the restrictions of a
12084/// class-head (i.e. no typedefs in the scope chain), template
12085/// parameters are required to match up with simple template-ids, &c.
12086/// However, unlike when declaring a template specialization, it's
12087/// okay to refer to a template specialization without an empty
12088/// template parameter declaration, e.g.
12089/// friend class A<T>::B<unsigned>;
12090/// We permit this as a special case; if there are any template
12091/// parameters present at all, require proper matching, i.e.
James Dennettf14a6e52012-06-15 22:23:43 +000012092/// template <> template \<class T> friend class A<int>::B;
John McCall48871652010-08-21 09:40:31 +000012093Decl *Sema::ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS,
John McCallc9739e32010-10-16 07:23:36 +000012094 MultiTemplateParamsArg TempParams) {
Daniel Dunbar62ee6412012-03-09 18:35:03 +000012095 SourceLocation Loc = DS.getLocStart();
John McCall07e91c02009-08-06 02:15:43 +000012096
12097 assert(DS.isFriendSpecified());
12098 assert(DS.getStorageClassSpec() == DeclSpec::SCS_unspecified);
12099
John McCall11083da2009-09-16 22:47:08 +000012100 // Try to convert the decl specifier to a type. This works for
12101 // friend templates because ActOnTag never produces a ClassTemplateDecl
12102 // for a TUK_Friend.
Chris Lattner1fb66f42009-10-25 17:47:27 +000012103 Declarator TheDeclarator(DS, Declarator::MemberContext);
John McCall8cb7bdf2010-06-04 23:28:52 +000012104 TypeSourceInfo *TSI = GetTypeForDeclarator(TheDeclarator, S);
12105 QualType T = TSI->getType();
Chris Lattner1fb66f42009-10-25 17:47:27 +000012106 if (TheDeclarator.isInvalidType())
Craig Topperc3ec1492014-05-26 06:22:03 +000012107 return nullptr;
John McCall07e91c02009-08-06 02:15:43 +000012108
Douglas Gregor6c110f32010-12-16 01:14:37 +000012109 if (DiagnoseUnexpandedParameterPack(Loc, TSI, UPPC_FriendDeclaration))
Craig Topperc3ec1492014-05-26 06:22:03 +000012110 return nullptr;
Douglas Gregor6c110f32010-12-16 01:14:37 +000012111
John McCall11083da2009-09-16 22:47:08 +000012112 // This is definitely an error in C++98. It's probably meant to
12113 // be forbidden in C++0x, too, but the specification is just
12114 // poorly written.
12115 //
12116 // The problem is with declarations like the following:
12117 // template <T> friend A<T>::foo;
12118 // where deciding whether a class C is a friend or not now hinges
12119 // on whether there exists an instantiation of A that causes
12120 // 'foo' to equal C. There are restrictions on class-heads
12121 // (which we declare (by fiat) elaborated friend declarations to
12122 // be) that makes this tractable.
12123 //
12124 // FIXME: handle "template <> friend class A<T>;", which
12125 // is possibly well-formed? Who even knows?
Douglas Gregore677daf2010-03-31 22:19:08 +000012126 if (TempParams.size() && !T->isElaboratedTypeSpecifier()) {
John McCall11083da2009-09-16 22:47:08 +000012127 Diag(Loc, diag::err_tagless_friend_type_template)
12128 << DS.getSourceRange();
Craig Topperc3ec1492014-05-26 06:22:03 +000012129 return nullptr;
John McCall11083da2009-09-16 22:47:08 +000012130 }
Douglas Gregorafb9bc12010-04-07 16:53:43 +000012131
John McCallaa74a0c2009-08-28 07:59:38 +000012132 // C++98 [class.friend]p1: A friend of a class is a function
12133 // or class that is not a member of the class . . .
John McCall463e10c2009-12-22 00:59:39 +000012134 // This is fixed in DR77, which just barely didn't make the C++03
12135 // deadline. It's also a very silly restriction that seriously
12136 // affects inner classes and which nobody else seems to implement;
12137 // thus we never diagnose it, not even in -pedantic.
John McCall15ad0962010-03-25 18:04:51 +000012138 //
12139 // But note that we could warn about it: it's always useless to
12140 // friend one of your own members (it's not, however, worthless to
12141 // friend a member of an arbitrary specialization of your template).
John McCallaa74a0c2009-08-28 07:59:38 +000012142
John McCall11083da2009-09-16 22:47:08 +000012143 Decl *D;
Douglas Gregorafb9bc12010-04-07 16:53:43 +000012144 if (unsigned NumTempParamLists = TempParams.size())
John McCall11083da2009-09-16 22:47:08 +000012145 D = FriendTemplateDecl::Create(Context, CurContext, Loc,
Douglas Gregorafb9bc12010-04-07 16:53:43 +000012146 NumTempParamLists,
Benjamin Kramercc4c49d2012-08-23 23:38:35 +000012147 TempParams.data(),
John McCall15ad0962010-03-25 18:04:51 +000012148 TSI,
John McCall11083da2009-09-16 22:47:08 +000012149 DS.getFriendSpecLoc());
12150 else
Abramo Bagnara254b6302011-10-29 20:52:52 +000012151 D = CheckFriendTypeDecl(Loc, DS.getFriendSpecLoc(), TSI);
Douglas Gregorafb9bc12010-04-07 16:53:43 +000012152
12153 if (!D)
Craig Topperc3ec1492014-05-26 06:22:03 +000012154 return nullptr;
12155
John McCall11083da2009-09-16 22:47:08 +000012156 D->setAccess(AS_public);
12157 CurContext->addDecl(D);
John McCallaa74a0c2009-08-28 07:59:38 +000012158
John McCall48871652010-08-21 09:40:31 +000012159 return D;
John McCallaa74a0c2009-08-28 07:59:38 +000012160}
12161
Rafael Espindola0a67e2f2013-01-08 20:44:06 +000012162NamedDecl *Sema::ActOnFriendFunctionDecl(Scope *S, Declarator &D,
12163 MultiTemplateParamsArg TemplateParams) {
John McCallaa74a0c2009-08-28 07:59:38 +000012164 const DeclSpec &DS = D.getDeclSpec();
12165
12166 assert(DS.isFriendSpecified());
12167 assert(DS.getStorageClassSpec() == DeclSpec::SCS_unspecified);
12168
12169 SourceLocation Loc = D.getIdentifierLoc();
John McCall8cb7bdf2010-06-04 23:28:52 +000012170 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
John McCall07e91c02009-08-06 02:15:43 +000012171
12172 // C++ [class.friend]p1
12173 // A friend of a class is a function or class....
12174 // Note that this sees through typedefs, which is intended.
John McCallaa74a0c2009-08-28 07:59:38 +000012175 // It *doesn't* see through dependent types, which is correct
12176 // according to [temp.arg.type]p3:
12177 // If a declaration acquires a function type through a
12178 // type dependent on a template-parameter and this causes
12179 // a declaration that does not use the syntactic form of a
12180 // function declarator to have a function type, the program
12181 // is ill-formed.
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +000012182 if (!TInfo->getType()->isFunctionType()) {
John McCall07e91c02009-08-06 02:15:43 +000012183 Diag(Loc, diag::err_unexpected_friend);
12184
12185 // It might be worthwhile to try to recover by creating an
12186 // appropriate declaration.
Craig Topperc3ec1492014-05-26 06:22:03 +000012187 return nullptr;
John McCall07e91c02009-08-06 02:15:43 +000012188 }
12189
12190 // C++ [namespace.memdef]p3
12191 // - If a friend declaration in a non-local class first declares a
12192 // class or function, the friend class or function is a member
12193 // of the innermost enclosing namespace.
12194 // - The name of the friend is not found by simple name lookup
12195 // until a matching declaration is provided in that namespace
12196 // scope (either before or after the class declaration granting
12197 // friendship).
12198 // - If a friend function is called, its name may be found by the
12199 // name lookup that considers functions from namespaces and
12200 // classes associated with the types of the function arguments.
12201 // - When looking for a prior declaration of a class or a function
12202 // declared as a friend, scopes outside the innermost enclosing
12203 // namespace scope are not considered.
12204
John McCallde3fd222010-10-12 23:13:28 +000012205 CXXScopeSpec &SS = D.getCXXScopeSpec();
Abramo Bagnarad6d2f182010-08-11 22:01:17 +000012206 DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
12207 DeclarationName Name = NameInfo.getName();
John McCall07e91c02009-08-06 02:15:43 +000012208 assert(Name);
12209
Douglas Gregor6c110f32010-12-16 01:14:37 +000012210 // Check for unexpanded parameter packs.
12211 if (DiagnoseUnexpandedParameterPack(Loc, TInfo, UPPC_FriendDeclaration) ||
12212 DiagnoseUnexpandedParameterPack(NameInfo, UPPC_FriendDeclaration) ||
12213 DiagnoseUnexpandedParameterPack(SS, UPPC_FriendDeclaration))
Craig Topperc3ec1492014-05-26 06:22:03 +000012214 return nullptr;
Douglas Gregor6c110f32010-12-16 01:14:37 +000012215
John McCall07e91c02009-08-06 02:15:43 +000012216 // The context we found the declaration in, or in which we should
12217 // create the declaration.
12218 DeclContext *DC;
John McCallccbc0322010-10-13 06:22:15 +000012219 Scope *DCScope = S;
Abramo Bagnarad6d2f182010-08-11 22:01:17 +000012220 LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
John McCall1f82f242009-11-18 22:49:29 +000012221 ForRedeclaration);
John McCall07e91c02009-08-06 02:15:43 +000012222
Richard Smith114394f2013-08-09 04:35:01 +000012223 // There are five cases here.
12224 // - There's no scope specifier and we're in a local class. Only look
12225 // for functions declared in the immediately-enclosing block scope.
12226 // We recover from invalid scope qualifiers as if they just weren't there.
Craig Topperc3ec1492014-05-26 06:22:03 +000012227 FunctionDecl *FunctionContainingLocalClass = nullptr;
Richard Smith114394f2013-08-09 04:35:01 +000012228 if ((SS.isInvalid() || !SS.isSet()) &&
12229 (FunctionContainingLocalClass =
12230 cast<CXXRecordDecl>(CurContext)->isLocalClass())) {
12231 // C++11 [class.friend]p11:
John McCallf7cfb222010-10-13 05:45:15 +000012232 // If a friend declaration appears in a local class and the name
12233 // specified is an unqualified name, a prior declaration is
12234 // looked up without considering scopes that are outside the
12235 // innermost enclosing non-class scope. For a friend function
12236 // declaration, if there is no prior declaration, the program is
12237 // ill-formed.
Richard Smith114394f2013-08-09 04:35:01 +000012238
12239 // Find the innermost enclosing non-class scope. This is the block
12240 // scope containing the local class definition (or for a nested class,
12241 // the outer local class).
12242 DCScope = S->getFnParent();
12243
12244 // Look up the function name in the scope.
12245 Previous.clear(LookupLocalFriendName);
12246 LookupName(Previous, S, /*AllowBuiltinCreation*/false);
12247
12248 if (!Previous.empty()) {
12249 // All possible previous declarations must have the same context:
12250 // either they were declared at block scope or they are members of
12251 // one of the enclosing local classes.
12252 DC = Previous.getRepresentativeDecl()->getDeclContext();
12253 } else {
12254 // This is ill-formed, but provide the context that we would have
12255 // declared the function in, if we were permitted to, for error recovery.
12256 DC = FunctionContainingLocalClass;
12257 }
Richard Smith541b38b2013-09-20 01:15:31 +000012258 adjustContextForLocalExternDecl(DC);
Richard Smith114394f2013-08-09 04:35:01 +000012259
12260 // C++ [class.friend]p6:
12261 // A function can be defined in a friend declaration of a class if and
12262 // only if the class is a non-local class (9.8), the function name is
12263 // unqualified, and the function has namespace scope.
12264 if (D.isFunctionDefinition()) {
12265 Diag(NameInfo.getBeginLoc(), diag::err_friend_def_in_local_class);
12266 }
12267
12268 // - There's no scope specifier, in which case we just go to the
12269 // appropriate scope and look for a function or function template
12270 // there as appropriate.
12271 } else if (SS.isInvalid() || !SS.isSet()) {
12272 // C++11 [namespace.memdef]p3:
12273 // If the name in a friend declaration is neither qualified nor
12274 // a template-id and the declaration is a function or an
12275 // elaborated-type-specifier, the lookup to determine whether
12276 // the entity has been previously declared shall not consider
12277 // any scopes outside the innermost enclosing namespace.
John McCallf4776592010-10-14 22:22:28 +000012278 bool isTemplateId = D.getName().getKind() == UnqualifiedId::IK_TemplateId;
John McCall07e91c02009-08-06 02:15:43 +000012279
John McCallf7cfb222010-10-13 05:45:15 +000012280 // Find the appropriate context according to the above.
John McCall07e91c02009-08-06 02:15:43 +000012281 DC = CurContext;
John McCall07e91c02009-08-06 02:15:43 +000012282
Rafael Espindola3626b7e2013-04-25 20:12:36 +000012283 // Skip class contexts. If someone can cite chapter and verse
12284 // for this behavior, that would be nice --- it's what GCC and
12285 // EDG do, and it seems like a reasonable intent, but the spec
12286 // really only says that checks for unqualified existing
12287 // declarations should stop at the nearest enclosing namespace,
12288 // not that they should only consider the nearest enclosing
12289 // namespace.
12290 while (DC->isRecord())
12291 DC = DC->getParent();
12292
12293 DeclContext *LookupDC = DC;
12294 while (LookupDC->isTransparentContext())
12295 LookupDC = LookupDC->getParent();
12296
12297 while (true) {
12298 LookupQualifiedName(Previous, LookupDC);
John McCall07e91c02009-08-06 02:15:43 +000012299
Rafael Espindola3626b7e2013-04-25 20:12:36 +000012300 if (!Previous.empty()) {
12301 DC = LookupDC;
12302 break;
John McCallf4776592010-10-14 22:22:28 +000012303 }
Rafael Espindola3626b7e2013-04-25 20:12:36 +000012304
12305 if (isTemplateId) {
12306 if (isa<TranslationUnitDecl>(LookupDC)) break;
12307 } else {
12308 if (LookupDC->isFileContext()) break;
12309 }
12310 LookupDC = LookupDC->getParent();
John McCall07e91c02009-08-06 02:15:43 +000012311 }
12312
John McCallccbc0322010-10-13 06:22:15 +000012313 DCScope = getScopeForDeclContext(S, DC);
Richard Smith114394f2013-08-09 04:35:01 +000012314
John McCallde3fd222010-10-12 23:13:28 +000012315 // - There's a non-dependent scope specifier, in which case we
12316 // compute it and do a previous lookup there for a function
12317 // or function template.
12318 } else if (!SS.getScopeRep()->isDependent()) {
12319 DC = computeDeclContext(SS);
Craig Topperc3ec1492014-05-26 06:22:03 +000012320 if (!DC) return nullptr;
John McCallde3fd222010-10-12 23:13:28 +000012321
Craig Topperc3ec1492014-05-26 06:22:03 +000012322 if (RequireCompleteDeclContext(SS, DC)) return nullptr;
John McCallde3fd222010-10-12 23:13:28 +000012323
12324 LookupQualifiedName(Previous, DC);
12325
12326 // Ignore things found implicitly in the wrong scope.
12327 // TODO: better diagnostics for this case. Suggesting the right
12328 // qualified scope would be nice...
12329 LookupResult::Filter F = Previous.makeFilter();
12330 while (F.hasNext()) {
12331 NamedDecl *D = F.next();
12332 if (!DC->InEnclosingNamespaceSetOf(
12333 D->getDeclContext()->getRedeclContext()))
12334 F.erase();
12335 }
12336 F.done();
12337
12338 if (Previous.empty()) {
12339 D.setInvalidType();
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +000012340 Diag(Loc, diag::err_qualified_friend_not_found)
12341 << Name << TInfo->getType();
Craig Topperc3ec1492014-05-26 06:22:03 +000012342 return nullptr;
John McCallde3fd222010-10-12 23:13:28 +000012343 }
12344
12345 // C++ [class.friend]p1: A friend of a class is a function or
12346 // class that is not a member of the class . . .
Richard Smith0bf8a4922011-10-18 20:49:44 +000012347 if (DC->Equals(CurContext))
12348 Diag(DS.getFriendSpecLoc(),
Richard Smith2bf7fdb2013-01-02 11:42:31 +000012349 getLangOpts().CPlusPlus11 ?
Richard Smith0bf8a4922011-10-18 20:49:44 +000012350 diag::warn_cxx98_compat_friend_is_member :
12351 diag::err_friend_is_member);
Douglas Gregor16e65612011-10-10 01:11:59 +000012352
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +000012353 if (D.isFunctionDefinition()) {
Douglas Gregor16e65612011-10-10 01:11:59 +000012354 // C++ [class.friend]p6:
12355 // A function can be defined in a friend declaration of a class if and
12356 // only if the class is a non-local class (9.8), the function name is
12357 // unqualified, and the function has namespace scope.
12358 SemaDiagnosticBuilder DB
12359 = Diag(SS.getRange().getBegin(), diag::err_qualified_friend_def);
12360
12361 DB << SS.getScopeRep();
12362 if (DC->isFileContext())
12363 DB << FixItHint::CreateRemoval(SS.getRange());
12364 SS.clear();
12365 }
John McCallde3fd222010-10-12 23:13:28 +000012366
12367 // - There's a scope specifier that does not match any template
12368 // parameter lists, in which case we use some arbitrary context,
12369 // create a method or method template, and wait for instantiation.
12370 // - There's a scope specifier that does match some template
12371 // parameter lists, which we don't handle right now.
12372 } else {
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +000012373 if (D.isFunctionDefinition()) {
Douglas Gregor16e65612011-10-10 01:11:59 +000012374 // C++ [class.friend]p6:
12375 // A function can be defined in a friend declaration of a class if and
12376 // only if the class is a non-local class (9.8), the function name is
12377 // unqualified, and the function has namespace scope.
12378 Diag(SS.getRange().getBegin(), diag::err_qualified_friend_def)
12379 << SS.getScopeRep();
12380 }
12381
John McCallde3fd222010-10-12 23:13:28 +000012382 DC = CurContext;
12383 assert(isa<CXXRecordDecl>(DC) && "friend declaration not in class?");
John McCall07e91c02009-08-06 02:15:43 +000012384 }
Douglas Gregor16e65612011-10-10 01:11:59 +000012385
John McCallf7cfb222010-10-13 05:45:15 +000012386 if (!DC->isRecord()) {
John McCall07e91c02009-08-06 02:15:43 +000012387 // This implies that it has to be an operator or function.
Douglas Gregor7861a802009-11-03 01:35:08 +000012388 if (D.getName().getKind() == UnqualifiedId::IK_ConstructorName ||
12389 D.getName().getKind() == UnqualifiedId::IK_DestructorName ||
12390 D.getName().getKind() == UnqualifiedId::IK_ConversionFunctionId) {
John McCall07e91c02009-08-06 02:15:43 +000012391 Diag(Loc, diag::err_introducing_special_friend) <<
Douglas Gregor7861a802009-11-03 01:35:08 +000012392 (D.getName().getKind() == UnqualifiedId::IK_ConstructorName ? 0 :
12393 D.getName().getKind() == UnqualifiedId::IK_DestructorName ? 1 : 2);
Craig Topperc3ec1492014-05-26 06:22:03 +000012394 return nullptr;
John McCall07e91c02009-08-06 02:15:43 +000012395 }
John McCall07e91c02009-08-06 02:15:43 +000012396 }
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +000012397
Douglas Gregordd847ba2011-11-03 16:37:14 +000012398 // FIXME: This is an egregious hack to cope with cases where the scope stack
12399 // does not contain the declaration context, i.e., in an out-of-line
12400 // definition of a class.
12401 Scope FakeDCScope(S, Scope::DeclScope, Diags);
12402 if (!DCScope) {
12403 FakeDCScope.setEntity(DC);
12404 DCScope = &FakeDCScope;
12405 }
Richard Smith114394f2013-08-09 04:35:01 +000012406
Francois Pichet00c7e6c2011-08-14 03:52:19 +000012407 bool AddToScope = true;
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +000012408 NamedDecl *ND = ActOnFunctionDeclarator(DCScope, D, DC, TInfo, Previous,
Benjamin Kramer62b95d82012-08-23 21:35:17 +000012409 TemplateParams, AddToScope);
Craig Topperc3ec1492014-05-26 06:22:03 +000012410 if (!ND) return nullptr;
John McCall759e32b2009-08-31 22:39:49 +000012411
Douglas Gregora29a3ff2009-09-28 00:08:27 +000012412 assert(ND->getLexicalDeclContext() == CurContext);
John McCall5ed6e8f2009-08-18 00:00:49 +000012413
Richard Smith114394f2013-08-09 04:35:01 +000012414 // If we performed typo correction, we might have added a scope specifier
12415 // and changed the decl context.
12416 DC = ND->getDeclContext();
12417
John McCall759e32b2009-08-31 22:39:49 +000012418 // Add the function declaration to the appropriate lookup tables,
12419 // adjusting the redeclarations list as necessary. We don't
12420 // want to do this yet if the friending class is dependent.
Mike Stump11289f42009-09-09 15:08:12 +000012421 //
John McCall759e32b2009-08-31 22:39:49 +000012422 // Also update the scope-based lookup if the target context's
12423 // lookup context is in lexical scope.
12424 if (!CurContext->isDependentContext()) {
Sebastian Redl50c68252010-08-31 00:36:30 +000012425 DC = DC->getRedeclContext();
Richard Smith05afe5e2012-03-13 03:12:56 +000012426 DC->makeDeclVisibleInContext(ND);
John McCall759e32b2009-08-31 22:39:49 +000012427 if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
Douglas Gregora29a3ff2009-09-28 00:08:27 +000012428 PushOnScopeChains(ND, EnclosingScope, /*AddToContext=*/ false);
John McCall759e32b2009-08-31 22:39:49 +000012429 }
John McCallaa74a0c2009-08-28 07:59:38 +000012430
12431 FriendDecl *FrD = FriendDecl::Create(Context, CurContext,
Douglas Gregora29a3ff2009-09-28 00:08:27 +000012432 D.getIdentifierLoc(), ND,
John McCallaa74a0c2009-08-28 07:59:38 +000012433 DS.getFriendSpecLoc());
John McCall75c03bb2009-08-29 03:50:18 +000012434 FrD->setAccess(AS_public);
John McCallaa74a0c2009-08-28 07:59:38 +000012435 CurContext->addDecl(FrD);
John McCall07e91c02009-08-06 02:15:43 +000012436
John McCalla0a96892012-08-10 03:15:35 +000012437 if (ND->isInvalidDecl()) {
John McCallde3fd222010-10-12 23:13:28 +000012438 FrD->setInvalidDecl();
John McCalla0a96892012-08-10 03:15:35 +000012439 } else {
12440 if (DC->isRecord()) CheckFriendAccess(ND);
12441
John McCall2c2eb122010-10-16 06:59:13 +000012442 FunctionDecl *FD;
12443 if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(ND))
12444 FD = FTD->getTemplatedDecl();
12445 else
12446 FD = cast<FunctionDecl>(ND);
12447
David Majnemer502b0ed2013-06-25 23:09:30 +000012448 // C++11 [dcl.fct.default]p4: If a friend declaration specifies a
12449 // default argument expression, that declaration shall be a definition
12450 // and shall be the only declaration of the function or function
12451 // template in the translation unit.
12452 if (functionDeclHasDefaultArgument(FD)) {
12453 if (FunctionDecl *OldFD = FD->getPreviousDecl()) {
12454 Diag(FD->getLocation(), diag::err_friend_decl_with_def_arg_redeclared);
12455 Diag(OldFD->getLocation(), diag::note_previous_declaration);
12456 } else if (!D.isFunctionDefinition())
12457 Diag(FD->getLocation(), diag::err_friend_decl_with_def_arg_must_be_def);
12458 }
12459
John McCall2c2eb122010-10-16 06:59:13 +000012460 // Mark templated-scope function declarations as unsupported.
Richard Smith04b35e92014-09-29 05:57:29 +000012461 if (FD->getNumTemplateParameterLists() && SS.isValid()) {
12462 Diag(FD->getLocation(), diag::warn_template_qualified_friend_unsupported)
12463 << SS.getScopeRep() << SS.getRange()
12464 << cast<CXXRecordDecl>(CurContext);
John McCall2c2eb122010-10-16 06:59:13 +000012465 FrD->setUnsupportedFriend(true);
Richard Smith04b35e92014-09-29 05:57:29 +000012466 }
John McCall2c2eb122010-10-16 06:59:13 +000012467 }
John McCallde3fd222010-10-12 23:13:28 +000012468
John McCall48871652010-08-21 09:40:31 +000012469 return ND;
Anders Carlsson38811702009-05-11 22:55:49 +000012470}
12471
John McCall48871652010-08-21 09:40:31 +000012472void Sema::SetDeclDeleted(Decl *Dcl, SourceLocation DelLoc) {
12473 AdjustDeclIfTemplate(Dcl);
Mike Stump11289f42009-09-09 15:08:12 +000012474
Aaron Ballmanf96361e2013-01-16 23:39:10 +000012475 FunctionDecl *Fn = dyn_cast_or_null<FunctionDecl>(Dcl);
Sebastian Redlf769df52009-03-24 22:27:57 +000012476 if (!Fn) {
12477 Diag(DelLoc, diag::err_deleted_non_function);
12478 return;
12479 }
Richard Smithb4d2a152013-04-02 19:38:47 +000012480
Douglas Gregorec9fd132012-01-14 16:38:05 +000012481 if (const FunctionDecl *Prev = Fn->getPreviousDecl()) {
David Blaikie36805522012-06-25 21:55:30 +000012482 // Don't consider the implicit declaration we generate for explicit
12483 // specializations. FIXME: Do not generate these implicit declarations.
Richard Smithbdd14642014-02-04 01:14:30 +000012484 if ((Prev->getTemplateSpecializationKind() != TSK_ExplicitSpecialization ||
12485 Prev->getPreviousDecl()) &&
12486 !Prev->isDefined()) {
David Blaikie36805522012-06-25 21:55:30 +000012487 Diag(DelLoc, diag::err_deleted_decl_not_first);
Richard Smithbdd14642014-02-04 01:14:30 +000012488 Diag(Prev->getLocation().isInvalid() ? DelLoc : Prev->getLocation(),
12489 Prev->isImplicit() ? diag::note_previous_implicit_declaration
12490 : diag::note_previous_declaration);
David Blaikie36805522012-06-25 21:55:30 +000012491 }
Sebastian Redlf769df52009-03-24 22:27:57 +000012492 // If the declaration wasn't the first, we delete the function anyway for
12493 // recovery.
Richard Smithb4d2a152013-04-02 19:38:47 +000012494 Fn = Fn->getCanonicalDecl();
Sebastian Redlf769df52009-03-24 22:27:57 +000012495 }
Richard Smithb4d2a152013-04-02 19:38:47 +000012496
Nico Rieck9de0a572014-05-29 16:51:19 +000012497 // dllimport/dllexport cannot be deleted.
12498 if (const InheritableAttr *DLLAttr = getDLLAttr(Fn)) {
12499 Diag(Fn->getLocation(), diag::err_attribute_dll_deleted) << DLLAttr;
12500 Fn->setInvalidDecl();
12501 }
12502
Richard Smithb4d2a152013-04-02 19:38:47 +000012503 if (Fn->isDeleted())
12504 return;
12505
12506 // See if we're deleting a function which is already known to override a
12507 // non-deleted virtual function.
12508 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Fn)) {
12509 bool IssuedDiagnostic = false;
12510 for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(),
12511 E = MD->end_overridden_methods();
12512 I != E; ++I) {
12513 if (!(*MD->begin_overridden_methods())->isDeleted()) {
12514 if (!IssuedDiagnostic) {
12515 Diag(DelLoc, diag::err_deleted_override) << MD->getDeclName();
12516 IssuedDiagnostic = true;
12517 }
12518 Diag((*I)->getLocation(), diag::note_overridden_virtual_function);
12519 }
12520 }
12521 }
12522
Richard Smithb63b6ee2014-01-22 01:43:19 +000012523 // C++11 [basic.start.main]p3:
12524 // A program that defines main as deleted [...] is ill-formed.
12525 if (Fn->isMain())
12526 Diag(DelLoc, diag::err_deleted_main);
12527
Alexis Hunt4a8ea102011-05-06 20:44:56 +000012528 Fn->setDeletedAsWritten();
Sebastian Redlf769df52009-03-24 22:27:57 +000012529}
Sebastian Redl4c018662009-04-27 21:33:24 +000012530
Alexis Hunt5a7fa252011-05-12 06:15:49 +000012531void Sema::SetDeclDefaulted(Decl *Dcl, SourceLocation DefaultLoc) {
Aaron Ballmanf96361e2013-01-16 23:39:10 +000012532 CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(Dcl);
Alexis Hunt5a7fa252011-05-12 06:15:49 +000012533
12534 if (MD) {
Alexis Hunt1fb4e762011-05-23 21:07:59 +000012535 if (MD->getParent()->isDependentType()) {
12536 MD->setDefaulted();
12537 MD->setExplicitlyDefaulted();
12538 return;
12539 }
12540
Alexis Hunt5a7fa252011-05-12 06:15:49 +000012541 CXXSpecialMember Member = getSpecialMember(MD);
12542 if (Member == CXXInvalid) {
Eli Friedman84c0143e2013-07-11 23:55:07 +000012543 if (!MD->isInvalidDecl())
12544 Diag(DefaultLoc, diag::err_default_special_members);
Alexis Hunt5a7fa252011-05-12 06:15:49 +000012545 return;
12546 }
12547
12548 MD->setDefaulted();
12549 MD->setExplicitlyDefaulted();
12550
Alexis Hunt61ae8d32011-05-23 23:14:04 +000012551 // If this definition appears within the record, do the checking when
12552 // the record is complete.
12553 const FunctionDecl *Primary = MD;
Richard Smith802c4b72012-08-23 06:16:52 +000012554 if (const FunctionDecl *Pattern = MD->getTemplateInstantiationPattern())
Alexis Hunt61ae8d32011-05-23 23:14:04 +000012555 // Find the uninstantiated declaration that actually had the '= default'
12556 // on it.
Richard Smith802c4b72012-08-23 06:16:52 +000012557 Pattern->isDefined(Primary);
Alexis Hunt61ae8d32011-05-23 23:14:04 +000012558
Richard Smith3901dfe2013-03-27 00:22:47 +000012559 // If the method was defaulted on its first declaration, we will have
12560 // already performed the checking in CheckCompletedCXXClass. Such a
12561 // declaration doesn't trigger an implicit definition.
Alexis Hunt61ae8d32011-05-23 23:14:04 +000012562 if (Primary == Primary->getCanonicalDecl())
Alexis Hunt5a7fa252011-05-12 06:15:49 +000012563 return;
12564
Richard Smithd3b5c9082012-07-27 04:22:15 +000012565 CheckExplicitlyDefaultedSpecialMember(MD);
12566
Benjamin Kramer8bf44352013-07-24 15:28:33 +000012567 if (MD->isInvalidDecl())
12568 return;
12569
Alexis Hunt5a7fa252011-05-12 06:15:49 +000012570 switch (Member) {
Benjamin Kramer8bf44352013-07-24 15:28:33 +000012571 case CXXDefaultConstructor:
12572 DefineImplicitDefaultConstructor(DefaultLoc,
12573 cast<CXXConstructorDecl>(MD));
Alexis Hunt913820d2011-05-13 06:10:58 +000012574 break;
Benjamin Kramer8bf44352013-07-24 15:28:33 +000012575 case CXXCopyConstructor:
12576 DefineImplicitCopyConstructor(DefaultLoc, cast<CXXConstructorDecl>(MD));
Alexis Hunt5a7fa252011-05-12 06:15:49 +000012577 break;
Benjamin Kramer8bf44352013-07-24 15:28:33 +000012578 case CXXCopyAssignment:
12579 DefineImplicitCopyAssignment(DefaultLoc, MD);
Alexis Huntc9a55732011-05-14 05:23:28 +000012580 break;
Benjamin Kramer8bf44352013-07-24 15:28:33 +000012581 case CXXDestructor:
12582 DefineImplicitDestructor(DefaultLoc, cast<CXXDestructorDecl>(MD));
Alexis Huntf91729462011-05-12 22:46:25 +000012583 break;
Benjamin Kramer8bf44352013-07-24 15:28:33 +000012584 case CXXMoveConstructor:
12585 DefineImplicitMoveConstructor(DefaultLoc, cast<CXXConstructorDecl>(MD));
Alexis Hunt119c10e2011-05-25 23:16:36 +000012586 break;
Benjamin Kramer8bf44352013-07-24 15:28:33 +000012587 case CXXMoveAssignment:
12588 DefineImplicitMoveAssignment(DefaultLoc, MD);
Sebastian Redl22653ba2011-08-30 19:58:05 +000012589 break;
Sebastian Redl22653ba2011-08-30 19:58:05 +000012590 case CXXInvalid:
David Blaikie83d382b2011-09-23 05:06:16 +000012591 llvm_unreachable("Invalid special member.");
Alexis Hunt5a7fa252011-05-12 06:15:49 +000012592 }
12593 } else {
12594 Diag(DefaultLoc, diag::err_default_special_members);
12595 }
12596}
12597
Sebastian Redl4c018662009-04-27 21:33:24 +000012598static void SearchForReturnInStmt(Sema &Self, Stmt *S) {
John McCall8322c3a2011-02-13 04:07:26 +000012599 for (Stmt::child_range CI = S->children(); CI; ++CI) {
Sebastian Redl4c018662009-04-27 21:33:24 +000012600 Stmt *SubStmt = *CI;
12601 if (!SubStmt)
12602 continue;
12603 if (isa<ReturnStmt>(SubStmt))
Daniel Dunbar62ee6412012-03-09 18:35:03 +000012604 Self.Diag(SubStmt->getLocStart(),
Sebastian Redl4c018662009-04-27 21:33:24 +000012605 diag::err_return_in_constructor_handler);
12606 if (!isa<Expr>(SubStmt))
12607 SearchForReturnInStmt(Self, SubStmt);
12608 }
12609}
12610
12611void Sema::DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock) {
12612 for (unsigned I = 0, E = TryBlock->getNumHandlers(); I != E; ++I) {
12613 CXXCatchStmt *Handler = TryBlock->getHandler(I);
12614 SearchForReturnInStmt(*this, Handler);
12615 }
12616}
Anders Carlssonf2a2e332009-05-14 01:09:04 +000012617
David Blaikie68f71a32013-01-18 23:03:15 +000012618bool Sema::CheckOverridingFunctionAttributes(const CXXMethodDecl *New,
Aaron Ballman02df2e02012-12-09 17:45:41 +000012619 const CXXMethodDecl *Old) {
12620 const FunctionType *NewFT = New->getType()->getAs<FunctionType>();
12621 const FunctionType *OldFT = Old->getType()->getAs<FunctionType>();
12622
12623 CallingConv NewCC = NewFT->getCallConv(), OldCC = OldFT->getCallConv();
12624
12625 // If the calling conventions match, everything is fine
12626 if (NewCC == OldCC)
12627 return false;
12628
Hans Wennborg2545efe2013-12-11 17:42:11 +000012629 // If the calling conventions mismatch because the new function is static,
12630 // suppress the calling convention mismatch error; the error about static
12631 // function override (err_static_overrides_virtual from
12632 // Sema::CheckFunctionDeclaration) is more clear.
12633 if (New->getStorageClass() == SC_Static)
12634 return false;
12635
Reid Kleckner78af0702013-08-27 23:08:25 +000012636 Diag(New->getLocation(),
12637 diag::err_conflicting_overriding_cc_attributes)
12638 << New->getDeclName() << New->getType() << Old->getType();
12639 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
12640 return true;
Aaron Ballman02df2e02012-12-09 17:45:41 +000012641}
12642
Mike Stump11289f42009-09-09 15:08:12 +000012643bool Sema::CheckOverridingFunctionReturnType(const CXXMethodDecl *New,
Anders Carlssonf2a2e332009-05-14 01:09:04 +000012644 const CXXMethodDecl *Old) {
Alp Toker314cc812014-01-25 16:55:45 +000012645 QualType NewTy = New->getType()->getAs<FunctionType>()->getReturnType();
12646 QualType OldTy = Old->getType()->getAs<FunctionType>()->getReturnType();
Anders Carlssonf2a2e332009-05-14 01:09:04 +000012647
Chandler Carruth284bb2e2010-02-15 11:53:20 +000012648 if (Context.hasSameType(NewTy, OldTy) ||
12649 NewTy->isDependentType() || OldTy->isDependentType())
Anders Carlssonf2a2e332009-05-14 01:09:04 +000012650 return false;
Mike Stump11289f42009-09-09 15:08:12 +000012651
Anders Carlsson8fb0b8a2009-05-14 19:52:19 +000012652 // Check if the return types are covariant
12653 QualType NewClassTy, OldClassTy;
Mike Stump11289f42009-09-09 15:08:12 +000012654
Anders Carlsson8fb0b8a2009-05-14 19:52:19 +000012655 /// Both types must be pointers or references to classes.
Anders Carlsson7caa4cb2010-01-22 17:37:20 +000012656 if (const PointerType *NewPT = NewTy->getAs<PointerType>()) {
12657 if (const PointerType *OldPT = OldTy->getAs<PointerType>()) {
Anders Carlsson8fb0b8a2009-05-14 19:52:19 +000012658 NewClassTy = NewPT->getPointeeType();
12659 OldClassTy = OldPT->getPointeeType();
12660 }
Anders Carlsson7caa4cb2010-01-22 17:37:20 +000012661 } else if (const ReferenceType *NewRT = NewTy->getAs<ReferenceType>()) {
12662 if (const ReferenceType *OldRT = OldTy->getAs<ReferenceType>()) {
12663 if (NewRT->getTypeClass() == OldRT->getTypeClass()) {
12664 NewClassTy = NewRT->getPointeeType();
12665 OldClassTy = OldRT->getPointeeType();
12666 }
Anders Carlsson8fb0b8a2009-05-14 19:52:19 +000012667 }
12668 }
Mike Stump11289f42009-09-09 15:08:12 +000012669
Anders Carlsson8fb0b8a2009-05-14 19:52:19 +000012670 // The return types aren't either both pointers or references to a class type.
12671 if (NewClassTy.isNull()) {
Mike Stump11289f42009-09-09 15:08:12 +000012672 Diag(New->getLocation(),
Anders Carlsson8fb0b8a2009-05-14 19:52:19 +000012673 diag::err_different_return_type_for_overriding_virtual_function)
Alp Tokerd0787eb2014-07-02 01:47:15 +000012674 << New->getDeclName() << NewTy << OldTy
12675 << New->getReturnTypeSourceRange();
12676 Diag(Old->getLocation(), diag::note_overridden_virtual_function)
12677 << Old->getReturnTypeSourceRange();
Mike Stump11289f42009-09-09 15:08:12 +000012678
Anders Carlsson8fb0b8a2009-05-14 19:52:19 +000012679 return true;
12680 }
Anders Carlssonf2a2e332009-05-14 01:09:04 +000012681
Anders Carlssone60365b2009-12-31 18:34:24 +000012682 // C++ [class.virtual]p6:
12683 // If the return type of D::f differs from the return type of B::f, the
12684 // class type in the return type of D::f shall be complete at the point of
12685 // declaration of D::f or shall be the class type D.
Anders Carlsson0c9dd842009-12-31 18:54:35 +000012686 if (const RecordType *RT = NewClassTy->getAs<RecordType>()) {
12687 if (!RT->isBeingDefined() &&
12688 RequireCompleteType(New->getLocation(), NewClassTy,
Douglas Gregor7bfb2d02012-05-04 16:32:21 +000012689 diag::err_covariant_return_incomplete,
12690 New->getDeclName()))
Anders Carlssone60365b2009-12-31 18:34:24 +000012691 return true;
Anders Carlsson0c9dd842009-12-31 18:54:35 +000012692 }
Anders Carlssone60365b2009-12-31 18:34:24 +000012693
Douglas Gregor1b8fe5b72009-11-16 21:35:15 +000012694 if (!Context.hasSameUnqualifiedType(NewClassTy, OldClassTy)) {
Anders Carlsson8fb0b8a2009-05-14 19:52:19 +000012695 // Check if the new class derives from the old class.
12696 if (!IsDerivedFrom(NewClassTy, OldClassTy)) {
Alp Tokerd0787eb2014-07-02 01:47:15 +000012697 Diag(New->getLocation(), diag::err_covariant_return_not_derived)
12698 << New->getDeclName() << NewTy << OldTy
12699 << New->getReturnTypeSourceRange();
12700 Diag(Old->getLocation(), diag::note_overridden_virtual_function)
12701 << Old->getReturnTypeSourceRange();
Anders Carlsson8fb0b8a2009-05-14 19:52:19 +000012702 return true;
12703 }
Mike Stump11289f42009-09-09 15:08:12 +000012704
Anders Carlsson8fb0b8a2009-05-14 19:52:19 +000012705 // Check if we the conversion from derived to base is valid.
Alp Tokerd0787eb2014-07-02 01:47:15 +000012706 if (CheckDerivedToBaseConversion(
12707 NewClassTy, OldClassTy,
12708 diag::err_covariant_return_inaccessible_base,
12709 diag::err_covariant_return_ambiguous_derived_to_base_conv,
12710 New->getLocation(), New->getReturnTypeSourceRange(),
12711 New->getDeclName(), nullptr)) {
John McCallc1465822011-02-14 07:13:47 +000012712 // FIXME: this note won't trigger for delayed access control
12713 // diagnostics, and it's impossible to get an undelayed error
12714 // here from access control during the original parse because
12715 // the ParsingDeclSpec/ParsingDeclarator are still in scope.
Alp Tokerd0787eb2014-07-02 01:47:15 +000012716 Diag(Old->getLocation(), diag::note_overridden_virtual_function)
12717 << Old->getReturnTypeSourceRange();
Anders Carlsson8fb0b8a2009-05-14 19:52:19 +000012718 return true;
12719 }
12720 }
Mike Stump11289f42009-09-09 15:08:12 +000012721
Anders Carlsson8fb0b8a2009-05-14 19:52:19 +000012722 // The qualifiers of the return types must be the same.
Anders Carlsson7caa4cb2010-01-22 17:37:20 +000012723 if (NewTy.getLocalCVRQualifiers() != OldTy.getLocalCVRQualifiers()) {
Anders Carlsson8fb0b8a2009-05-14 19:52:19 +000012724 Diag(New->getLocation(),
12725 diag::err_covariant_return_type_different_qualifications)
Alp Tokerd0787eb2014-07-02 01:47:15 +000012726 << New->getDeclName() << NewTy << OldTy
12727 << New->getReturnTypeSourceRange();
12728 Diag(Old->getLocation(), diag::note_overridden_virtual_function)
12729 << Old->getReturnTypeSourceRange();
Anders Carlsson8fb0b8a2009-05-14 19:52:19 +000012730 return true;
12731 };
Mike Stump11289f42009-09-09 15:08:12 +000012732
Anders Carlsson8fb0b8a2009-05-14 19:52:19 +000012733
12734 // The new class type must have the same or less qualifiers as the old type.
12735 if (NewClassTy.isMoreQualifiedThan(OldClassTy)) {
12736 Diag(New->getLocation(),
12737 diag::err_covariant_return_type_class_type_more_qualified)
Alp Tokerd0787eb2014-07-02 01:47:15 +000012738 << New->getDeclName() << NewTy << OldTy
12739 << New->getReturnTypeSourceRange();
12740 Diag(Old->getLocation(), diag::note_overridden_virtual_function)
12741 << Old->getReturnTypeSourceRange();
Anders Carlsson8fb0b8a2009-05-14 19:52:19 +000012742 return true;
12743 };
Mike Stump11289f42009-09-09 15:08:12 +000012744
Anders Carlsson8fb0b8a2009-05-14 19:52:19 +000012745 return false;
Anders Carlssonf2a2e332009-05-14 01:09:04 +000012746}
Argyrios Kyrtzidis3df19782009-06-17 22:50:06 +000012747
Douglas Gregor21920e372009-12-01 17:24:26 +000012748/// \brief Mark the given method pure.
12749///
12750/// \param Method the method to be marked pure.
12751///
12752/// \param InitRange the source range that covers the "0" initializer.
12753bool Sema::CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange) {
Abramo Bagnaraf2a79d92011-03-12 11:17:06 +000012754 SourceLocation EndLoc = InitRange.getEnd();
12755 if (EndLoc.isValid())
12756 Method->setRangeEnd(EndLoc);
12757
Douglas Gregor21920e372009-12-01 17:24:26 +000012758 if (Method->isVirtual() || Method->getParent()->isDependentContext()) {
12759 Method->setPure();
Douglas Gregor21920e372009-12-01 17:24:26 +000012760 return false;
Abramo Bagnaraf2a79d92011-03-12 11:17:06 +000012761 }
Douglas Gregor21920e372009-12-01 17:24:26 +000012762
12763 if (!Method->isInvalidDecl())
12764 Diag(Method->getLocation(), diag::err_non_virtual_pure)
12765 << Method->getDeclName() << InitRange;
12766 return true;
12767}
12768
Douglas Gregor926410d2012-02-21 02:22:07 +000012769/// \brief Determine whether the given declaration is a static data member.
Benjamin Kramer8bf44352013-07-24 15:28:33 +000012770static bool isStaticDataMember(const Decl *D) {
12771 if (const VarDecl *Var = dyn_cast_or_null<VarDecl>(D))
12772 return Var->isStaticDataMember();
12773
12774 return false;
Douglas Gregor926410d2012-02-21 02:22:07 +000012775}
Benjamin Kramer8bf44352013-07-24 15:28:33 +000012776
John McCall1f4ee7b2009-12-19 09:28:58 +000012777/// ActOnCXXEnterDeclInitializer - Invoked when we are about to parse
12778/// an initializer for the out-of-line declaration 'Dcl'. The scope
12779/// is a fresh scope pushed for just this purpose.
12780///
Argyrios Kyrtzidis3df19782009-06-17 22:50:06 +000012781/// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
12782/// static data member of class X, names should be looked up in the scope of
12783/// class X.
John McCall48871652010-08-21 09:40:31 +000012784void Sema::ActOnCXXEnterDeclInitializer(Scope *S, Decl *D) {
Argyrios Kyrtzidis3df19782009-06-17 22:50:06 +000012785 // If there is no declaration, there was an error parsing it.
Craig Topperc3ec1492014-05-26 06:22:03 +000012786 if (!D || D->isInvalidDecl())
12787 return;
Argyrios Kyrtzidis3df19782009-06-17 22:50:06 +000012788
Richard Smitha2302242013-12-05 07:51:02 +000012789 // We will always have a nested name specifier here, but this declaration
12790 // might not be out of line if the specifier names the current namespace:
12791 // extern int n;
12792 // int ::n = 0;
12793 if (D->isOutOfLine())
12794 EnterDeclaratorContext(S, D->getDeclContext());
12795
Douglas Gregor926410d2012-02-21 02:22:07 +000012796 // If we are parsing the initializer for a static data member, push a
12797 // new expression evaluation context that is associated with this static
12798 // data member.
12799 if (isStaticDataMember(D))
12800 PushExpressionEvaluationContext(PotentiallyEvaluated, D);
Argyrios Kyrtzidis3df19782009-06-17 22:50:06 +000012801}
12802
12803/// ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an
John McCall48871652010-08-21 09:40:31 +000012804/// initializer for the out-of-line declaration 'D'.
12805void Sema::ActOnCXXExitDeclInitializer(Scope *S, Decl *D) {
Argyrios Kyrtzidis3df19782009-06-17 22:50:06 +000012806 // If there is no declaration, there was an error parsing it.
Craig Topperc3ec1492014-05-26 06:22:03 +000012807 if (!D || D->isInvalidDecl())
12808 return;
Argyrios Kyrtzidis3df19782009-06-17 22:50:06 +000012809
Douglas Gregor926410d2012-02-21 02:22:07 +000012810 if (isStaticDataMember(D))
Richard Smitha2302242013-12-05 07:51:02 +000012811 PopExpressionEvaluationContext();
Douglas Gregor926410d2012-02-21 02:22:07 +000012812
Richard Smitha2302242013-12-05 07:51:02 +000012813 if (D->isOutOfLine())
12814 ExitDeclaratorContext(S);
Argyrios Kyrtzidis3df19782009-06-17 22:50:06 +000012815}
Douglas Gregor7bab5ff2009-11-25 00:27:52 +000012816
12817/// ActOnCXXConditionDeclarationExpr - Parsed a condition declaration of a
12818/// C++ if/switch/while/for statement.
12819/// e.g: "if (int x = f()) {...}"
John McCall48871652010-08-21 09:40:31 +000012820DeclResult Sema::ActOnCXXConditionDeclaration(Scope *S, Declarator &D) {
Douglas Gregor7bab5ff2009-11-25 00:27:52 +000012821 // C++ 6.4p2:
12822 // The declarator shall not specify a function or an array.
12823 // The type-specifier-seq shall not contain typedef and shall not declare a
12824 // new class or enumeration.
12825 assert(D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef &&
12826 "Parser allowed 'typedef' as storage class of condition decl.");
Argyrios Kyrtzidis8ea7e582011-06-28 03:01:12 +000012827
12828 Decl *Dcl = ActOnDeclarator(S, D);
Douglas Gregor1fe12c92011-07-05 16:13:20 +000012829 if (!Dcl)
12830 return true;
12831
Argyrios Kyrtzidis8ea7e582011-06-28 03:01:12 +000012832 if (isa<FunctionDecl>(Dcl)) { // The declarator shall not specify a function.
12833 Diag(Dcl->getLocation(), diag::err_invalid_use_of_function_type)
Douglas Gregor7bab5ff2009-11-25 00:27:52 +000012834 << D.getSourceRange();
Douglas Gregor1fe12c92011-07-05 16:13:20 +000012835 return true;
Douglas Gregor7bab5ff2009-11-25 00:27:52 +000012836 }
Douglas Gregor7bab5ff2009-11-25 00:27:52 +000012837
Douglas Gregor7bab5ff2009-11-25 00:27:52 +000012838 return Dcl;
12839}
Anders Carlssonf98849e2009-12-02 17:15:43 +000012840
Douglas Gregor4daf6a32011-07-28 19:11:31 +000012841void Sema::LoadExternalVTableUses() {
12842 if (!ExternalSource)
12843 return;
12844
12845 SmallVector<ExternalVTableUse, 4> VTables;
12846 ExternalSource->ReadUsedVTables(VTables);
12847 SmallVector<VTableUse, 4> NewUses;
12848 for (unsigned I = 0, N = VTables.size(); I != N; ++I) {
12849 llvm::DenseMap<CXXRecordDecl *, bool>::iterator Pos
12850 = VTablesUsed.find(VTables[I].Record);
12851 // Even if a definition wasn't required before, it may be required now.
12852 if (Pos != VTablesUsed.end()) {
12853 if (!Pos->second && VTables[I].DefinitionRequired)
12854 Pos->second = true;
12855 continue;
12856 }
12857
12858 VTablesUsed[VTables[I].Record] = VTables[I].DefinitionRequired;
12859 NewUses.push_back(VTableUse(VTables[I].Record, VTables[I].Location));
12860 }
12861
12862 VTableUses.insert(VTableUses.begin(), NewUses.begin(), NewUses.end());
12863}
12864
Douglas Gregor88d292c2010-05-13 16:44:06 +000012865void Sema::MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class,
12866 bool DefinitionRequired) {
12867 // Ignore any vtable uses in unevaluated operands or for classes that do
12868 // not have a vtable.
12869 if (!Class->isDynamicClass() || Class->isDependentContext() ||
John McCallf413f5e2013-05-03 00:10:13 +000012870 CurContext->isDependentContext() || isUnevaluatedContext())
Rafael Espindolae7113ca2010-03-10 02:19:29 +000012871 return;
12872
Douglas Gregor88d292c2010-05-13 16:44:06 +000012873 // Try to insert this class into the map.
Douglas Gregor4daf6a32011-07-28 19:11:31 +000012874 LoadExternalVTableUses();
Douglas Gregor88d292c2010-05-13 16:44:06 +000012875 Class = cast<CXXRecordDecl>(Class->getCanonicalDecl());
12876 std::pair<llvm::DenseMap<CXXRecordDecl *, bool>::iterator, bool>
12877 Pos = VTablesUsed.insert(std::make_pair(Class, DefinitionRequired));
12878 if (!Pos.second) {
Daniel Dunbar53217762010-05-25 00:33:13 +000012879 // If we already had an entry, check to see if we are promoting this vtable
12880 // to required a definition. If so, we need to reappend to the VTableUses
12881 // list, since we may have already processed the first entry.
12882 if (DefinitionRequired && !Pos.first->second) {
12883 Pos.first->second = true;
12884 } else {
12885 // Otherwise, we can early exit.
12886 return;
12887 }
Hans Wennborg3d791542014-02-24 15:58:24 +000012888 } else {
12889 // The Microsoft ABI requires that we perform the destructor body
12890 // checks (i.e. operator delete() lookup) when the vtable is marked used, as
12891 // the deleting destructor is emitted with the vtable, not with the
12892 // destructor definition as in the Itanium ABI.
12893 // If it has a definition, we do the check at that point instead.
12894 if (Context.getTargetInfo().getCXXABI().isMicrosoft() &&
12895 Class->hasUserDeclaredDestructor() &&
12896 !Class->getDestructor()->isDefined() &&
12897 !Class->getDestructor()->isDeleted()) {
Reid Kleckner67130862014-06-12 22:39:12 +000012898 CXXDestructorDecl *DD = Class->getDestructor();
12899 ContextRAII SavedContext(*this, DD);
12900 CheckDestructor(DD);
Hans Wennborg3d791542014-02-24 15:58:24 +000012901 }
Douglas Gregor88d292c2010-05-13 16:44:06 +000012902 }
12903
12904 // Local classes need to have their virtual members marked
12905 // immediately. For all other classes, we mark their virtual members
12906 // at the end of the translation unit.
12907 if (Class->isLocalClass())
12908 MarkVirtualMembersReferenced(Loc, Class);
Daniel Dunbar0547ad32010-05-11 21:32:35 +000012909 else
Douglas Gregor88d292c2010-05-13 16:44:06 +000012910 VTableUses.push_back(std::make_pair(Class, Loc));
Douglas Gregor0c4aad12010-05-11 20:24:17 +000012911}
12912
Douglas Gregor88d292c2010-05-13 16:44:06 +000012913bool Sema::DefineUsedVTables() {
Douglas Gregor4daf6a32011-07-28 19:11:31 +000012914 LoadExternalVTableUses();
Douglas Gregor88d292c2010-05-13 16:44:06 +000012915 if (VTableUses.empty())
Anders Carlsson82fccd02009-12-07 08:24:59 +000012916 return false;
Chandler Carruth88bfa5e2010-12-12 21:36:11 +000012917
Douglas Gregor88d292c2010-05-13 16:44:06 +000012918 // Note: The VTableUses vector could grow as a result of marking
12919 // the members of a class as "used", so we check the size each
Richard Smithd3b5c9082012-07-27 04:22:15 +000012920 // time through the loop and prefer indices (which are stable) to
Douglas Gregor88d292c2010-05-13 16:44:06 +000012921 // iterators (which are not).
Douglas Gregor97509692011-04-22 22:25:37 +000012922 bool DefinedAnything = false;
Douglas Gregor88d292c2010-05-13 16:44:06 +000012923 for (unsigned I = 0; I != VTableUses.size(); ++I) {
Daniel Dunbar105ce6d2010-05-25 00:32:58 +000012924 CXXRecordDecl *Class = VTableUses[I].first->getDefinition();
Douglas Gregor88d292c2010-05-13 16:44:06 +000012925 if (!Class)
12926 continue;
12927
12928 SourceLocation Loc = VTableUses[I].second;
12929
Richard Smithd3b5c9082012-07-27 04:22:15 +000012930 bool DefineVTable = true;
12931
Douglas Gregor88d292c2010-05-13 16:44:06 +000012932 // If this class has a key function, but that key function is
12933 // defined in another translation unit, we don't need to emit the
12934 // vtable even though we're using it.
John McCall6bd2a892013-01-25 22:31:03 +000012935 const CXXMethodDecl *KeyFunction = Context.getCurrentKeyFunction(Class);
Argyrios Kyrtzidis36ea3222010-07-07 11:31:19 +000012936 if (KeyFunction && !KeyFunction->hasBody()) {
Rafael Espindolaef7fe1f2013-08-26 23:23:21 +000012937 // The key function is in another translation unit.
12938 DefineVTable = false;
12939 TemplateSpecializationKind TSK =
12940 KeyFunction->getTemplateSpecializationKind();
12941 assert(TSK != TSK_ExplicitInstantiationDefinition &&
12942 TSK != TSK_ImplicitInstantiation &&
12943 "Instantiations don't have key functions");
12944 (void)TSK;
Douglas Gregor88d292c2010-05-13 16:44:06 +000012945 } else if (!KeyFunction) {
12946 // If we have a class with no key function that is the subject
12947 // of an explicit instantiation declaration, suppress the
12948 // vtable; it will live with the explicit instantiation
12949 // definition.
12950 bool IsExplicitInstantiationDeclaration
12951 = Class->getTemplateSpecializationKind()
12952 == TSK_ExplicitInstantiationDeclaration;
Aaron Ballman86c93902014-03-06 23:45:36 +000012953 for (auto R : Class->redecls()) {
Douglas Gregor88d292c2010-05-13 16:44:06 +000012954 TemplateSpecializationKind TSK
Aaron Ballman86c93902014-03-06 23:45:36 +000012955 = cast<CXXRecordDecl>(R)->getTemplateSpecializationKind();
Douglas Gregor88d292c2010-05-13 16:44:06 +000012956 if (TSK == TSK_ExplicitInstantiationDeclaration)
12957 IsExplicitInstantiationDeclaration = true;
12958 else if (TSK == TSK_ExplicitInstantiationDefinition) {
12959 IsExplicitInstantiationDeclaration = false;
12960 break;
12961 }
12962 }
12963
12964 if (IsExplicitInstantiationDeclaration)
Richard Smithd3b5c9082012-07-27 04:22:15 +000012965 DefineVTable = false;
12966 }
12967
12968 // The exception specifications for all virtual members may be needed even
12969 // if we are not providing an authoritative form of the vtable in this TU.
12970 // We may choose to emit it available_externally anyway.
12971 if (!DefineVTable) {
12972 MarkVirtualMemberExceptionSpecsNeeded(Loc, Class);
12973 continue;
Douglas Gregor88d292c2010-05-13 16:44:06 +000012974 }
12975
12976 // Mark all of the virtual members of this class as referenced, so
12977 // that we can build a vtable. Then, tell the AST consumer that a
12978 // vtable for this class is required.
Douglas Gregor97509692011-04-22 22:25:37 +000012979 DefinedAnything = true;
Douglas Gregor88d292c2010-05-13 16:44:06 +000012980 MarkVirtualMembersReferenced(Loc, Class);
12981 CXXRecordDecl *Canonical = cast<CXXRecordDecl>(Class->getCanonicalDecl());
12982 Consumer.HandleVTable(Class, VTablesUsed[Canonical]);
12983
12984 // Optionally warn if we're emitting a weak vtable.
Rafael Espindola3ae00052013-05-13 00:12:11 +000012985 if (Class->isExternallyVisible() &&
Douglas Gregor88d292c2010-05-13 16:44:06 +000012986 Class->getTemplateSpecializationKind() != TSK_ImplicitInstantiation) {
Craig Topperc3ec1492014-05-26 06:22:03 +000012987 const FunctionDecl *KeyFunctionDef = nullptr;
Douglas Gregor34bc6e52011-09-23 19:04:03 +000012988 if (!KeyFunction ||
12989 (KeyFunction->hasBody(KeyFunctionDef) &&
12990 KeyFunctionDef->isInlined()))
David Blaikie72b61202011-12-09 18:32:50 +000012991 Diag(Class->getLocation(), Class->getTemplateSpecializationKind() ==
12992 TSK_ExplicitInstantiationDefinition
12993 ? diag::warn_weak_template_vtable : diag::warn_weak_vtable)
12994 << Class;
Douglas Gregor88d292c2010-05-13 16:44:06 +000012995 }
Anders Carlssonf98849e2009-12-02 17:15:43 +000012996 }
Douglas Gregor88d292c2010-05-13 16:44:06 +000012997 VTableUses.clear();
12998
Douglas Gregor97509692011-04-22 22:25:37 +000012999 return DefinedAnything;
Anders Carlssonf98849e2009-12-02 17:15:43 +000013000}
Anders Carlsson82fccd02009-12-07 08:24:59 +000013001
Richard Smithd3b5c9082012-07-27 04:22:15 +000013002void Sema::MarkVirtualMemberExceptionSpecsNeeded(SourceLocation Loc,
13003 const CXXRecordDecl *RD) {
Aaron Ballman2b124d12014-03-13 16:36:16 +000013004 for (const auto *I : RD->methods())
13005 if (I->isVirtual() && !I->isPure())
13006 ResolveExceptionSpec(Loc, I->getType()->castAs<FunctionProtoType>());
Richard Smithd3b5c9082012-07-27 04:22:15 +000013007}
13008
Rafael Espindola5b334082010-03-26 00:36:59 +000013009void Sema::MarkVirtualMembersReferenced(SourceLocation Loc,
13010 const CXXRecordDecl *RD) {
Richard Smith4ff9ff92012-07-07 06:59:51 +000013011 // Mark all functions which will appear in RD's vtable as used.
13012 CXXFinalOverriderMap FinalOverriders;
13013 RD->getFinalOverriders(FinalOverriders);
13014 for (CXXFinalOverriderMap::const_iterator I = FinalOverriders.begin(),
13015 E = FinalOverriders.end();
13016 I != E; ++I) {
13017 for (OverridingMethods::const_iterator OI = I->second.begin(),
13018 OE = I->second.end();
13019 OI != OE; ++OI) {
13020 assert(OI->second.size() > 0 && "no final overrider");
13021 CXXMethodDecl *Overrider = OI->second.front().Method;
Anders Carlsson82fccd02009-12-07 08:24:59 +000013022
Richard Smith4ff9ff92012-07-07 06:59:51 +000013023 // C++ [basic.def.odr]p2:
13024 // [...] A virtual member function is used if it is not pure. [...]
13025 if (!Overrider->isPure())
13026 MarkFunctionReferenced(Loc, Overrider);
13027 }
Anders Carlsson82fccd02009-12-07 08:24:59 +000013028 }
Rafael Espindola5b334082010-03-26 00:36:59 +000013029
13030 // Only classes that have virtual bases need a VTT.
13031 if (RD->getNumVBases() == 0)
13032 return;
13033
Aaron Ballman574705e2014-03-13 15:41:46 +000013034 for (const auto &I : RD->bases()) {
Rafael Espindola5b334082010-03-26 00:36:59 +000013035 const CXXRecordDecl *Base =
Aaron Ballman574705e2014-03-13 15:41:46 +000013036 cast<CXXRecordDecl>(I.getType()->getAs<RecordType>()->getDecl());
Rafael Espindola5b334082010-03-26 00:36:59 +000013037 if (Base->getNumVBases() == 0)
13038 continue;
13039 MarkVirtualMembersReferenced(Loc, Base);
13040 }
Anders Carlsson82fccd02009-12-07 08:24:59 +000013041}
Fariborz Jahanianc83726e2010-04-28 16:11:27 +000013042
13043/// SetIvarInitializers - This routine builds initialization ASTs for the
13044/// Objective-C implementation whose ivars need be initialized.
13045void Sema::SetIvarInitializers(ObjCImplementationDecl *ObjCImplementation) {
David Blaikiebbafb8a2012-03-11 07:00:24 +000013046 if (!getLangOpts().CPlusPlus)
Fariborz Jahanianc83726e2010-04-28 16:11:27 +000013047 return;
Fariborz Jahaniana50b3a22010-08-20 21:21:08 +000013048 if (ObjCInterfaceDecl *OID = ObjCImplementation->getClassInterface()) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +000013049 SmallVector<ObjCIvarDecl*, 8> ivars;
Fariborz Jahanianc83726e2010-04-28 16:11:27 +000013050 CollectIvarsToConstructOrDestruct(OID, ivars);
13051 if (ivars.empty())
13052 return;
Chris Lattner0e62c1c2011-07-23 10:55:15 +000013053 SmallVector<CXXCtorInitializer*, 32> AllToInit;
Fariborz Jahanianc83726e2010-04-28 16:11:27 +000013054 for (unsigned i = 0; i < ivars.size(); i++) {
13055 FieldDecl *Field = ivars[i];
Douglas Gregor527786e2010-05-20 02:24:22 +000013056 if (Field->isInvalidDecl())
13057 continue;
13058
Alexis Hunt1d792652011-01-08 20:30:50 +000013059 CXXCtorInitializer *Member;
Fariborz Jahanianc83726e2010-04-28 16:11:27 +000013060 InitializedEntity InitEntity = InitializedEntity::InitializeMember(Field);
13061 InitializationKind InitKind =
13062 InitializationKind::CreateDefault(ObjCImplementation->getLocation());
Dmitri Gribenko78852e92013-05-05 20:40:26 +000013063
13064 InitializationSequence InitSeq(*this, InitEntity, InitKind, None);
13065 ExprResult MemberInit =
13066 InitSeq.Perform(*this, InitEntity, InitKind, None);
Douglas Gregora40433a2010-12-07 00:41:46 +000013067 MemberInit = MaybeCreateExprWithCleanups(MemberInit);
Fariborz Jahanianc83726e2010-04-28 16:11:27 +000013068 // Note, MemberInit could actually come back empty if no initialization
13069 // is required (e.g., because it would call a trivial default constructor)
13070 if (!MemberInit.get() || MemberInit.isInvalid())
13071 continue;
John McCallacf0ee52010-10-08 02:01:28 +000013072
Fariborz Jahanianc83726e2010-04-28 16:11:27 +000013073 Member =
Alexis Hunt1d792652011-01-08 20:30:50 +000013074 new (Context) CXXCtorInitializer(Context, Field, SourceLocation(),
13075 SourceLocation(),
Nikola Smiljanic01a75982014-05-29 10:55:11 +000013076 MemberInit.getAs<Expr>(),
Alexis Hunt1d792652011-01-08 20:30:50 +000013077 SourceLocation());
Fariborz Jahanianc83726e2010-04-28 16:11:27 +000013078 AllToInit.push_back(Member);
Douglas Gregor527786e2010-05-20 02:24:22 +000013079
13080 // Be sure that the destructor is accessible and is marked as referenced.
13081 if (const RecordType *RecordTy
13082 = Context.getBaseElementType(Field->getType())
13083 ->getAs<RecordType>()) {
13084 CXXRecordDecl *RD = cast<CXXRecordDecl>(RecordTy->getDecl());
Douglas Gregore71edda2010-07-01 22:47:18 +000013085 if (CXXDestructorDecl *Destructor = LookupDestructor(RD)) {
Eli Friedmanfa0df832012-02-02 03:46:19 +000013086 MarkFunctionReferenced(Field->getLocation(), Destructor);
Douglas Gregor527786e2010-05-20 02:24:22 +000013087 CheckDestructorAccess(Field->getLocation(), Destructor,
13088 PDiag(diag::err_access_dtor_ivar)
13089 << Context.getBaseElementType(Field->getType()));
13090 }
13091 }
Fariborz Jahanianc83726e2010-04-28 16:11:27 +000013092 }
13093 ObjCImplementation->setIvarInitializers(Context,
13094 AllToInit.data(), AllToInit.size());
13095 }
13096}
Alexis Hunt6118d662011-05-04 05:57:24 +000013097
Alexis Hunt27a761d2011-05-04 23:29:54 +000013098static
13099void DelegatingCycleHelper(CXXConstructorDecl* Ctor,
13100 llvm::SmallSet<CXXConstructorDecl*, 4> &Valid,
13101 llvm::SmallSet<CXXConstructorDecl*, 4> &Invalid,
13102 llvm::SmallSet<CXXConstructorDecl*, 4> &Current,
13103 Sema &S) {
Alexis Hunt27a761d2011-05-04 23:29:54 +000013104 if (Ctor->isInvalidDecl())
13105 return;
13106
Richard Smith802c4b72012-08-23 06:16:52 +000013107 CXXConstructorDecl *Target = Ctor->getTargetConstructor();
13108
13109 // Target may not be determinable yet, for instance if this is a dependent
13110 // call in an uninstantiated template.
13111 if (Target) {
Craig Topperc3ec1492014-05-26 06:22:03 +000013112 const FunctionDecl *FNTarget = nullptr;
Richard Smith802c4b72012-08-23 06:16:52 +000013113 (void)Target->hasBody(FNTarget);
13114 Target = const_cast<CXXConstructorDecl*>(
13115 cast_or_null<CXXConstructorDecl>(FNTarget));
13116 }
Alexis Hunt27a761d2011-05-04 23:29:54 +000013117
13118 CXXConstructorDecl *Canonical = Ctor->getCanonicalDecl(),
13119 // Avoid dereferencing a null pointer here.
Craig Topperc3ec1492014-05-26 06:22:03 +000013120 *TCanonical = Target? Target->getCanonicalDecl() : nullptr;
Alexis Hunt27a761d2011-05-04 23:29:54 +000013121
13122 if (!Current.insert(Canonical))
13123 return;
13124
13125 // We know that beyond here, we aren't chaining into a cycle.
13126 if (!Target || !Target->isDelegatingConstructor() ||
13127 Target->isInvalidDecl() || Valid.count(TCanonical)) {
Benjamin Kramer8bf44352013-07-24 15:28:33 +000013128 Valid.insert(Current.begin(), Current.end());
Alexis Hunt27a761d2011-05-04 23:29:54 +000013129 Current.clear();
13130 // We've hit a cycle.
13131 } else if (TCanonical == Canonical || Invalid.count(TCanonical) ||
13132 Current.count(TCanonical)) {
13133 // If we haven't diagnosed this cycle yet, do so now.
13134 if (!Invalid.count(TCanonical)) {
13135 S.Diag((*Ctor->init_begin())->getSourceLocation(),
Alexis Hunte2622992011-05-05 00:05:47 +000013136 diag::warn_delegating_ctor_cycle)
Alexis Hunt27a761d2011-05-04 23:29:54 +000013137 << Ctor;
13138
Richard Smith802c4b72012-08-23 06:16:52 +000013139 // Don't add a note for a function delegating directly to itself.
Alexis Hunt27a761d2011-05-04 23:29:54 +000013140 if (TCanonical != Canonical)
13141 S.Diag(Target->getLocation(), diag::note_it_delegates_to);
13142
13143 CXXConstructorDecl *C = Target;
13144 while (C->getCanonicalDecl() != Canonical) {
Craig Topperc3ec1492014-05-26 06:22:03 +000013145 const FunctionDecl *FNTarget = nullptr;
Alexis Hunt27a761d2011-05-04 23:29:54 +000013146 (void)C->getTargetConstructor()->hasBody(FNTarget);
13147 assert(FNTarget && "Ctor cycle through bodiless function");
13148
Richard Smith802c4b72012-08-23 06:16:52 +000013149 C = const_cast<CXXConstructorDecl*>(
13150 cast<CXXConstructorDecl>(FNTarget));
Alexis Hunt27a761d2011-05-04 23:29:54 +000013151 S.Diag(C->getLocation(), diag::note_which_delegates_to);
13152 }
13153 }
13154
Benjamin Kramer8bf44352013-07-24 15:28:33 +000013155 Invalid.insert(Current.begin(), Current.end());
Alexis Hunt27a761d2011-05-04 23:29:54 +000013156 Current.clear();
13157 } else {
13158 DelegatingCycleHelper(Target, Valid, Invalid, Current, S);
13159 }
13160}
13161
13162
Alexis Hunt6118d662011-05-04 05:57:24 +000013163void Sema::CheckDelegatingCtorCycles() {
13164 llvm::SmallSet<CXXConstructorDecl*, 4> Valid, Invalid, Current;
13165
Douglas Gregorbae31202011-07-27 21:57:17 +000013166 for (DelegatingCtorDeclsType::iterator
13167 I = DelegatingCtorDecls.begin(ExternalSource),
Alexis Hunt27a761d2011-05-04 23:29:54 +000013168 E = DelegatingCtorDecls.end();
Richard Smith802c4b72012-08-23 06:16:52 +000013169 I != E; ++I)
13170 DelegatingCycleHelper(*I, Valid, Invalid, Current, *this);
Alexis Hunt27a761d2011-05-04 23:29:54 +000013171
Benjamin Kramer8bf44352013-07-24 15:28:33 +000013172 for (llvm::SmallSet<CXXConstructorDecl *, 4>::iterator CI = Invalid.begin(),
13173 CE = Invalid.end();
13174 CI != CE; ++CI)
Alexis Hunt27a761d2011-05-04 23:29:54 +000013175 (*CI)->setInvalidDecl();
Alexis Hunt6118d662011-05-04 05:57:24 +000013176}
Peter Collingbourne7277fe82011-10-02 23:49:40 +000013177
Douglas Gregor3024f072012-04-16 07:05:22 +000013178namespace {
13179 /// \brief AST visitor that finds references to the 'this' expression.
13180 class FindCXXThisExpr : public RecursiveASTVisitor<FindCXXThisExpr> {
13181 Sema &S;
13182
13183 public:
13184 explicit FindCXXThisExpr(Sema &S) : S(S) { }
13185
13186 bool VisitCXXThisExpr(CXXThisExpr *E) {
13187 S.Diag(E->getLocation(), diag::err_this_static_member_func)
13188 << E->isImplicit();
13189 return false;
13190 }
13191 };
13192}
13193
13194bool Sema::checkThisInStaticMemberFunctionType(CXXMethodDecl *Method) {
13195 TypeSourceInfo *TSInfo = Method->getTypeSourceInfo();
13196 if (!TSInfo)
13197 return false;
13198
13199 TypeLoc TL = TSInfo->getTypeLoc();
David Blaikie6adc78e2013-02-18 22:06:02 +000013200 FunctionProtoTypeLoc ProtoTL = TL.getAs<FunctionProtoTypeLoc>();
Douglas Gregor3024f072012-04-16 07:05:22 +000013201 if (!ProtoTL)
13202 return false;
13203
13204 // C++11 [expr.prim.general]p3:
13205 // [The expression this] shall not appear before the optional
13206 // cv-qualifier-seq and it shall not appear within the declaration of a
13207 // static member function (although its type and value category are defined
13208 // within a static member function as they are within a non-static member
13209 // function). [ Note: this is because declaration matching does not occur
NAKAMURA Takumi40edb2a2012-04-21 09:40:04 +000013210 // until the complete declarator is known. - end note ]
David Blaikie6adc78e2013-02-18 22:06:02 +000013211 const FunctionProtoType *Proto = ProtoTL.getTypePtr();
Douglas Gregor3024f072012-04-16 07:05:22 +000013212 FindCXXThisExpr Finder(*this);
13213
13214 // If the return type came after the cv-qualifier-seq, check it now.
13215 if (Proto->hasTrailingReturn() &&
Alp Toker42a16a62014-01-25 23:51:36 +000013216 !Finder.TraverseTypeLoc(ProtoTL.getReturnLoc()))
Douglas Gregor3024f072012-04-16 07:05:22 +000013217 return true;
13218
13219 // Check the exception specification.
Douglas Gregor433e0532012-04-16 18:27:27 +000013220 if (checkThisInStaticMemberFunctionExceptionSpec(Method))
13221 return true;
13222
13223 return checkThisInStaticMemberFunctionAttributes(Method);
13224}
13225
13226bool Sema::checkThisInStaticMemberFunctionExceptionSpec(CXXMethodDecl *Method) {
13227 TypeSourceInfo *TSInfo = Method->getTypeSourceInfo();
13228 if (!TSInfo)
13229 return false;
13230
13231 TypeLoc TL = TSInfo->getTypeLoc();
David Blaikie6adc78e2013-02-18 22:06:02 +000013232 FunctionProtoTypeLoc ProtoTL = TL.getAs<FunctionProtoTypeLoc>();
Douglas Gregor433e0532012-04-16 18:27:27 +000013233 if (!ProtoTL)
13234 return false;
13235
David Blaikie6adc78e2013-02-18 22:06:02 +000013236 const FunctionProtoType *Proto = ProtoTL.getTypePtr();
Douglas Gregor433e0532012-04-16 18:27:27 +000013237 FindCXXThisExpr Finder(*this);
13238
Douglas Gregor3024f072012-04-16 07:05:22 +000013239 switch (Proto->getExceptionSpecType()) {
Richard Smithf623c962012-04-17 00:58:00 +000013240 case EST_Uninstantiated:
Richard Smithd3b5c9082012-07-27 04:22:15 +000013241 case EST_Unevaluated:
Douglas Gregor3024f072012-04-16 07:05:22 +000013242 case EST_BasicNoexcept:
Douglas Gregor3024f072012-04-16 07:05:22 +000013243 case EST_DynamicNone:
13244 case EST_MSAny:
13245 case EST_None:
13246 break;
Douglas Gregor433e0532012-04-16 18:27:27 +000013247
Douglas Gregor3024f072012-04-16 07:05:22 +000013248 case EST_ComputedNoexcept:
13249 if (!Finder.TraverseStmt(Proto->getNoexceptExpr()))
13250 return true;
Douglas Gregor433e0532012-04-16 18:27:27 +000013251
Douglas Gregor3024f072012-04-16 07:05:22 +000013252 case EST_Dynamic:
Aaron Ballmanb088fbe2014-03-17 15:38:09 +000013253 for (const auto &E : Proto->exceptions()) {
13254 if (!Finder.TraverseType(E))
Douglas Gregor3024f072012-04-16 07:05:22 +000013255 return true;
13256 }
13257 break;
13258 }
Douglas Gregor433e0532012-04-16 18:27:27 +000013259
13260 return false;
Douglas Gregor3024f072012-04-16 07:05:22 +000013261}
13262
13263bool Sema::checkThisInStaticMemberFunctionAttributes(CXXMethodDecl *Method) {
13264 FindCXXThisExpr Finder(*this);
13265
13266 // Check attributes.
Aaron Ballmanb97112e2014-03-08 22:19:01 +000013267 for (const auto *A : Method->attrs()) {
Douglas Gregor3024f072012-04-16 07:05:22 +000013268 // FIXME: This should be emitted by tblgen.
Craig Topperc3ec1492014-05-26 06:22:03 +000013269 Expr *Arg = nullptr;
Douglas Gregor3024f072012-04-16 07:05:22 +000013270 ArrayRef<Expr *> Args;
Aaron Ballmanb97112e2014-03-08 22:19:01 +000013271 if (const auto *G = dyn_cast<GuardedByAttr>(A))
Douglas Gregor3024f072012-04-16 07:05:22 +000013272 Arg = G->getArg();
Aaron Ballmanb97112e2014-03-08 22:19:01 +000013273 else if (const auto *G = dyn_cast<PtGuardedByAttr>(A))
Douglas Gregor3024f072012-04-16 07:05:22 +000013274 Arg = G->getArg();
Aaron Ballmanb97112e2014-03-08 22:19:01 +000013275 else if (const auto *AA = dyn_cast<AcquiredAfterAttr>(A))
Craig Topper5fc8fc22014-08-27 06:28:36 +000013276 Args = llvm::makeArrayRef(AA->args_begin(), AA->args_size());
Aaron Ballmanb97112e2014-03-08 22:19:01 +000013277 else if (const auto *AB = dyn_cast<AcquiredBeforeAttr>(A))
Craig Topper5fc8fc22014-08-27 06:28:36 +000013278 Args = llvm::makeArrayRef(AB->args_begin(), AB->args_size());
Aaron Ballmanb97112e2014-03-08 22:19:01 +000013279 else if (const auto *ETLF = dyn_cast<ExclusiveTrylockFunctionAttr>(A)) {
Douglas Gregor3024f072012-04-16 07:05:22 +000013280 Arg = ETLF->getSuccessValue();
Craig Topper5fc8fc22014-08-27 06:28:36 +000013281 Args = llvm::makeArrayRef(ETLF->args_begin(), ETLF->args_size());
Aaron Ballmanb97112e2014-03-08 22:19:01 +000013282 } else if (const auto *STLF = dyn_cast<SharedTrylockFunctionAttr>(A)) {
Douglas Gregor3024f072012-04-16 07:05:22 +000013283 Arg = STLF->getSuccessValue();
Craig Topper5fc8fc22014-08-27 06:28:36 +000013284 Args = llvm::makeArrayRef(STLF->args_begin(), STLF->args_size());
Aaron Ballman18d85ae2014-03-20 16:02:49 +000013285 } else if (const auto *LR = dyn_cast<LockReturnedAttr>(A))
Douglas Gregor3024f072012-04-16 07:05:22 +000013286 Arg = LR->getArg();
Aaron Ballmanb97112e2014-03-08 22:19:01 +000013287 else if (const auto *LE = dyn_cast<LocksExcludedAttr>(A))
Craig Topper5fc8fc22014-08-27 06:28:36 +000013288 Args = llvm::makeArrayRef(LE->args_begin(), LE->args_size());
Aaron Ballmanb97112e2014-03-08 22:19:01 +000013289 else if (const auto *RC = dyn_cast<RequiresCapabilityAttr>(A))
Craig Topper5fc8fc22014-08-27 06:28:36 +000013290 Args = llvm::makeArrayRef(RC->args_begin(), RC->args_size());
Aaron Ballmanb97112e2014-03-08 22:19:01 +000013291 else if (const auto *AC = dyn_cast<AcquireCapabilityAttr>(A))
Craig Topper5fc8fc22014-08-27 06:28:36 +000013292 Args = llvm::makeArrayRef(AC->args_begin(), AC->args_size());
Aaron Ballmanb97112e2014-03-08 22:19:01 +000013293 else if (const auto *AC = dyn_cast<TryAcquireCapabilityAttr>(A))
Craig Topper5fc8fc22014-08-27 06:28:36 +000013294 Args = llvm::makeArrayRef(AC->args_begin(), AC->args_size());
Aaron Ballmanb97112e2014-03-08 22:19:01 +000013295 else if (const auto *RC = dyn_cast<ReleaseCapabilityAttr>(A))
Craig Topper5fc8fc22014-08-27 06:28:36 +000013296 Args = llvm::makeArrayRef(RC->args_begin(), RC->args_size());
Douglas Gregor3024f072012-04-16 07:05:22 +000013297
13298 if (Arg && !Finder.TraverseStmt(Arg))
13299 return true;
13300
13301 for (unsigned I = 0, N = Args.size(); I != N; ++I) {
13302 if (!Finder.TraverseStmt(Args[I]))
13303 return true;
13304 }
13305 }
13306
13307 return false;
13308}
13309
NAKAMURA Takumi23224152014-10-17 12:48:37 +000013310void
13311Sema::checkExceptionSpecification(ExceptionSpecificationType EST,
13312 ArrayRef<ParsedType> DynamicExceptions,
13313 ArrayRef<SourceRange> DynamicExceptionRanges,
13314 Expr *NoexceptExpr,
13315 SmallVectorImpl<QualType> &Exceptions,
13316 FunctionProtoType::ExceptionSpecInfo &ESI) {
Douglas Gregor433e0532012-04-16 18:27:27 +000013317 Exceptions.clear();
Richard Smith8acb4282014-07-31 21:57:55 +000013318 ESI.Type = EST;
Douglas Gregor433e0532012-04-16 18:27:27 +000013319 if (EST == EST_Dynamic) {
13320 Exceptions.reserve(DynamicExceptions.size());
13321 for (unsigned ei = 0, ee = DynamicExceptions.size(); ei != ee; ++ei) {
13322 // FIXME: Preserve type source info.
13323 QualType ET = GetTypeFromParser(DynamicExceptions[ei]);
13324
NAKAMURA Takumi23224152014-10-17 12:48:37 +000013325 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
13326 collectUnexpandedParameterPacks(ET, Unexpanded);
13327 if (!Unexpanded.empty()) {
13328 DiagnoseUnexpandedParameterPacks(DynamicExceptionRanges[ei].getBegin(),
13329 UPPC_ExceptionType,
13330 Unexpanded);
13331 continue;
Douglas Gregor433e0532012-04-16 18:27:27 +000013332 }
13333
13334 // Check that the type is valid for an exception spec, and
13335 // drop it if not.
13336 if (!CheckSpecifiedExceptionType(ET, DynamicExceptionRanges[ei]))
13337 Exceptions.push_back(ET);
13338 }
Richard Smith8acb4282014-07-31 21:57:55 +000013339 ESI.Exceptions = Exceptions;
Douglas Gregor433e0532012-04-16 18:27:27 +000013340 return;
13341 }
Richard Smith8acb4282014-07-31 21:57:55 +000013342
Douglas Gregor433e0532012-04-16 18:27:27 +000013343 if (EST == EST_ComputedNoexcept) {
13344 // If an error occurred, there's no expression here.
13345 if (NoexceptExpr) {
13346 assert((NoexceptExpr->isTypeDependent() ||
13347 NoexceptExpr->getType()->getCanonicalTypeUnqualified() ==
13348 Context.BoolTy) &&
13349 "Parser should have made sure that the expression is boolean");
NAKAMURA Takumi23224152014-10-17 12:48:37 +000013350 if (NoexceptExpr && DiagnoseUnexpandedParameterPack(NoexceptExpr)) {
Richard Smith8acb4282014-07-31 21:57:55 +000013351 ESI.Type = EST_BasicNoexcept;
Douglas Gregor433e0532012-04-16 18:27:27 +000013352 return;
13353 }
Richard Smith8acb4282014-07-31 21:57:55 +000013354
Douglas Gregor433e0532012-04-16 18:27:27 +000013355 if (!NoexceptExpr->isValueDependent())
Craig Topperc3ec1492014-05-26 06:22:03 +000013356 NoexceptExpr = VerifyIntegerConstantExpression(NoexceptExpr, nullptr,
Douglas Gregore2b37442012-05-04 22:38:52 +000013357 diag::err_noexcept_needs_constant_expression,
Nikola Smiljanic01a75982014-05-29 10:55:11 +000013358 /*AllowFold*/ false).get();
Richard Smith8acb4282014-07-31 21:57:55 +000013359 ESI.NoexceptExpr = NoexceptExpr;
Douglas Gregor433e0532012-04-16 18:27:27 +000013360 }
13361 return;
13362 }
13363}
13364
John McCall5e77d762013-04-16 07:28:30 +000013365/// HandleMSProperty - Analyze a __delcspec(property) field of a C++ class.
13366///
13367MSPropertyDecl *Sema::HandleMSProperty(Scope *S, RecordDecl *Record,
13368 SourceLocation DeclStart,
13369 Declarator &D, Expr *BitWidth,
13370 InClassInitStyle InitStyle,
13371 AccessSpecifier AS,
13372 AttributeList *MSPropertyAttr) {
13373 IdentifierInfo *II = D.getIdentifier();
13374 if (!II) {
13375 Diag(DeclStart, diag::err_anonymous_property);
Craig Topperc3ec1492014-05-26 06:22:03 +000013376 return nullptr;
John McCall5e77d762013-04-16 07:28:30 +000013377 }
13378 SourceLocation Loc = D.getIdentifierLoc();
13379
13380 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
13381 QualType T = TInfo->getType();
13382 if (getLangOpts().CPlusPlus) {
13383 CheckExtraCXXDefaultArguments(D);
13384
13385 if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
13386 UPPC_DataMemberType)) {
13387 D.setInvalidType();
13388 T = Context.IntTy;
13389 TInfo = Context.getTrivialTypeSourceInfo(T, Loc);
13390 }
13391 }
13392
13393 DiagnoseFunctionSpecifiers(D.getDeclSpec());
13394
13395 if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec())
13396 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
13397 diag::err_invalid_thread)
13398 << DeclSpec::getSpecifierName(TSCS);
13399
13400 // Check to see if this name was declared as a member previously
Craig Topperc3ec1492014-05-26 06:22:03 +000013401 NamedDecl *PrevDecl = nullptr;
John McCall5e77d762013-04-16 07:28:30 +000013402 LookupResult Previous(*this, II, Loc, LookupMemberName, ForRedeclaration);
13403 LookupName(Previous, S);
13404 switch (Previous.getResultKind()) {
13405 case LookupResult::Found:
13406 case LookupResult::FoundUnresolvedValue:
13407 PrevDecl = Previous.getAsSingle<NamedDecl>();
13408 break;
13409
13410 case LookupResult::FoundOverloaded:
13411 PrevDecl = Previous.getRepresentativeDecl();
13412 break;
13413
13414 case LookupResult::NotFound:
13415 case LookupResult::NotFoundInCurrentInstantiation:
13416 case LookupResult::Ambiguous:
13417 break;
13418 }
13419
13420 if (PrevDecl && PrevDecl->isTemplateParameter()) {
13421 // Maybe we will complain about the shadowed template parameter.
13422 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
13423 // Just pretend that we didn't see the previous declaration.
Craig Topperc3ec1492014-05-26 06:22:03 +000013424 PrevDecl = nullptr;
John McCall5e77d762013-04-16 07:28:30 +000013425 }
13426
13427 if (PrevDecl && !isDeclInScope(PrevDecl, Record, S))
Craig Topperc3ec1492014-05-26 06:22:03 +000013428 PrevDecl = nullptr;
John McCall5e77d762013-04-16 07:28:30 +000013429
13430 SourceLocation TSSL = D.getLocStart();
John McCall5e77d762013-04-16 07:28:30 +000013431 const AttributeList::PropertyData &Data = MSPropertyAttr->getPropertyData();
Richard Smithf7981722013-11-22 09:01:48 +000013432 MSPropertyDecl *NewPD = MSPropertyDecl::Create(
13433 Context, Record, Loc, II, T, TInfo, TSSL, Data.GetterId, Data.SetterId);
John McCall5e77d762013-04-16 07:28:30 +000013434 ProcessDeclAttributes(TUScope, NewPD, D);
13435 NewPD->setAccess(AS);
13436
13437 if (NewPD->isInvalidDecl())
13438 Record->setInvalidDecl();
13439
13440 if (D.getDeclSpec().isModulePrivateSpecified())
13441 NewPD->setModulePrivate();
13442
13443 if (NewPD->isInvalidDecl() && PrevDecl) {
13444 // Don't introduce NewFD into scope; there's already something
13445 // with the same name in the same scope.
13446 } else if (II) {
13447 PushOnScopeChains(NewPD, S);
13448 } else
13449 Record->addDecl(NewPD);
13450
13451 return NewPD;
13452}