blob: f65dc4bd668d861efa5ce0d5be09c2de17f66ea2 [file] [log] [blame]
Chris Lattner3d1cee32008-04-08 05:04:30 +00001//===------ SemaDeclCXX.cpp - Semantic Analysis for C++ Declarations ------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements semantic analysis for C++ declarations.
11//
12//===----------------------------------------------------------------------===//
13
14#include "Sema.h"
Douglas Gregor20093b42009-12-09 23:02:17 +000015#include "SemaInit.h"
John McCall7d384dd2009-11-18 07:57:50 +000016#include "Lookup.h"
Argyrios Kyrtzidisa4755c62008-08-09 00:58:37 +000017#include "clang/AST/ASTConsumer.h"
Douglas Gregore37ac4f2008-04-13 21:30:24 +000018#include "clang/AST/ASTContext.h"
Anders Carlsson5ec02ae2009-12-02 17:15:43 +000019#include "clang/AST/RecordLayout.h"
Douglas Gregora8f32e02009-10-06 17:59:45 +000020#include "clang/AST/CXXInheritance.h"
Anders Carlsson8211eff2009-03-24 01:19:16 +000021#include "clang/AST/DeclVisitor.h"
Douglas Gregor802ab452009-12-02 22:36:29 +000022#include "clang/AST/TypeLoc.h"
Douglas Gregor02189362008-10-22 21:13:31 +000023#include "clang/AST/TypeOrdering.h"
Chris Lattner8123a952008-04-10 02:22:51 +000024#include "clang/AST/StmtVisitor.h"
Douglas Gregor314b97f2009-11-10 19:49:08 +000025#include "clang/Parse/DeclSpec.h"
26#include "clang/Parse/Template.h"
Anders Carlssonb7906612009-08-26 23:45:07 +000027#include "clang/Basic/PartialDiagnostic.h"
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +000028#include "clang/Lex/Preprocessor.h"
Douglas Gregor3fc749d2008-12-23 00:26:44 +000029#include "llvm/ADT/STLExtras.h"
Douglas Gregorf8268ae2008-10-22 17:49:05 +000030#include <map>
Douglas Gregora8f32e02009-10-06 17:59:45 +000031#include <set>
Chris Lattner3d1cee32008-04-08 05:04:30 +000032
33using namespace clang;
34
Chris Lattner8123a952008-04-10 02:22:51 +000035//===----------------------------------------------------------------------===//
36// CheckDefaultArgumentVisitor
37//===----------------------------------------------------------------------===//
38
Chris Lattner9e979552008-04-12 23:52:44 +000039namespace {
40 /// CheckDefaultArgumentVisitor - C++ [dcl.fct.default] Traverses
41 /// the default argument of a parameter to determine whether it
42 /// contains any ill-formed subexpressions. For example, this will
43 /// diagnose the use of local variables or parameters within the
44 /// default argument expression.
Benjamin Kramer85b45212009-11-28 19:45:26 +000045 class CheckDefaultArgumentVisitor
Chris Lattnerb77792e2008-07-26 22:17:49 +000046 : public StmtVisitor<CheckDefaultArgumentVisitor, bool> {
Chris Lattner9e979552008-04-12 23:52:44 +000047 Expr *DefaultArg;
48 Sema *S;
Chris Lattner8123a952008-04-10 02:22:51 +000049
Chris Lattner9e979552008-04-12 23:52:44 +000050 public:
Mike Stump1eb44332009-09-09 15:08:12 +000051 CheckDefaultArgumentVisitor(Expr *defarg, Sema *s)
Chris Lattner9e979552008-04-12 23:52:44 +000052 : DefaultArg(defarg), S(s) {}
Chris Lattner8123a952008-04-10 02:22:51 +000053
Chris Lattner9e979552008-04-12 23:52:44 +000054 bool VisitExpr(Expr *Node);
55 bool VisitDeclRefExpr(DeclRefExpr *DRE);
Douglas Gregor796da182008-11-04 14:32:21 +000056 bool VisitCXXThisExpr(CXXThisExpr *ThisE);
Chris Lattner9e979552008-04-12 23:52:44 +000057 };
Chris Lattner8123a952008-04-10 02:22:51 +000058
Chris Lattner9e979552008-04-12 23:52:44 +000059 /// VisitExpr - Visit all of the children of this expression.
60 bool CheckDefaultArgumentVisitor::VisitExpr(Expr *Node) {
61 bool IsInvalid = false;
Mike Stump1eb44332009-09-09 15:08:12 +000062 for (Stmt::child_iterator I = Node->child_begin(),
Chris Lattnerb77792e2008-07-26 22:17:49 +000063 E = Node->child_end(); I != E; ++I)
64 IsInvalid |= Visit(*I);
Chris Lattner9e979552008-04-12 23:52:44 +000065 return IsInvalid;
Chris Lattner8123a952008-04-10 02:22:51 +000066 }
67
Chris Lattner9e979552008-04-12 23:52:44 +000068 /// VisitDeclRefExpr - Visit a reference to a declaration, to
69 /// determine whether this declaration can be used in the default
70 /// argument expression.
71 bool CheckDefaultArgumentVisitor::VisitDeclRefExpr(DeclRefExpr *DRE) {
Douglas Gregor8e9bebd2008-10-21 16:13:35 +000072 NamedDecl *Decl = DRE->getDecl();
Chris Lattner9e979552008-04-12 23:52:44 +000073 if (ParmVarDecl *Param = dyn_cast<ParmVarDecl>(Decl)) {
74 // C++ [dcl.fct.default]p9
75 // Default arguments are evaluated each time the function is
76 // called. The order of evaluation of function arguments is
77 // unspecified. Consequently, parameters of a function shall not
78 // be used in default argument expressions, even if they are not
79 // evaluated. Parameters of a function declared before a default
80 // argument expression are in scope and can hide namespace and
81 // class member names.
Mike Stump1eb44332009-09-09 15:08:12 +000082 return S->Diag(DRE->getSourceRange().getBegin(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +000083 diag::err_param_default_argument_references_param)
Chris Lattner08631c52008-11-23 21:45:46 +000084 << Param->getDeclName() << DefaultArg->getSourceRange();
Steve Naroff248a7532008-04-15 22:42:06 +000085 } else if (VarDecl *VDecl = dyn_cast<VarDecl>(Decl)) {
Chris Lattner9e979552008-04-12 23:52:44 +000086 // C++ [dcl.fct.default]p7
87 // Local variables shall not be used in default argument
88 // expressions.
Steve Naroff248a7532008-04-15 22:42:06 +000089 if (VDecl->isBlockVarDecl())
Mike Stump1eb44332009-09-09 15:08:12 +000090 return S->Diag(DRE->getSourceRange().getBegin(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +000091 diag::err_param_default_argument_references_local)
Chris Lattner08631c52008-11-23 21:45:46 +000092 << VDecl->getDeclName() << DefaultArg->getSourceRange();
Chris Lattner9e979552008-04-12 23:52:44 +000093 }
Chris Lattner8123a952008-04-10 02:22:51 +000094
Douglas Gregor3996f232008-11-04 13:41:56 +000095 return false;
96 }
Chris Lattner9e979552008-04-12 23:52:44 +000097
Douglas Gregor796da182008-11-04 14:32:21 +000098 /// VisitCXXThisExpr - Visit a C++ "this" expression.
99 bool CheckDefaultArgumentVisitor::VisitCXXThisExpr(CXXThisExpr *ThisE) {
100 // C++ [dcl.fct.default]p8:
101 // The keyword this shall not be used in a default argument of a
102 // member function.
103 return S->Diag(ThisE->getSourceRange().getBegin(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000104 diag::err_param_default_argument_references_this)
105 << ThisE->getSourceRange();
Chris Lattner9e979552008-04-12 23:52:44 +0000106 }
Chris Lattner8123a952008-04-10 02:22:51 +0000107}
108
Anders Carlssoned961f92009-08-25 02:29:20 +0000109bool
110Sema::SetParamDefaultArgument(ParmVarDecl *Param, ExprArg DefaultArg,
Mike Stump1eb44332009-09-09 15:08:12 +0000111 SourceLocation EqualLoc) {
Anders Carlsson5653ca52009-08-25 13:46:13 +0000112 if (RequireCompleteType(Param->getLocation(), Param->getType(),
113 diag::err_typecheck_decl_incomplete_type)) {
114 Param->setInvalidDecl();
115 return true;
116 }
117
Anders Carlssoned961f92009-08-25 02:29:20 +0000118 Expr *Arg = (Expr *)DefaultArg.get();
Mike Stump1eb44332009-09-09 15:08:12 +0000119
Anders Carlssoned961f92009-08-25 02:29:20 +0000120 // C++ [dcl.fct.default]p5
121 // A default argument expression is implicitly converted (clause
122 // 4) to the parameter type. The default argument expression has
123 // the same semantic constraints as the initializer expression in
124 // a declaration of a variable of the parameter type, using the
125 // copy-initialization semantics (8.5).
Douglas Gregor99a2e602009-12-16 01:38:02 +0000126 InitializedEntity Entity = InitializedEntity::InitializeParameter(Param);
127 InitializationKind Kind = InitializationKind::CreateCopy(Param->getLocation(),
128 EqualLoc);
Eli Friedman4a2c19b2009-12-22 02:46:13 +0000129 InitializationSequence InitSeq(*this, Entity, Kind, &Arg, 1);
130 OwningExprResult Result = InitSeq.Perform(*this, Entity, Kind,
131 MultiExprArg(*this, (void**)&Arg, 1));
132 if (Result.isInvalid())
Anders Carlsson9351c172009-08-25 03:18:48 +0000133 return true;
Eli Friedman4a2c19b2009-12-22 02:46:13 +0000134 Arg = Result.takeAs<Expr>();
Anders Carlssoned961f92009-08-25 02:29:20 +0000135
Anders Carlsson0ece4912009-12-15 20:51:39 +0000136 Arg = MaybeCreateCXXExprWithTemporaries(Arg);
Mike Stump1eb44332009-09-09 15:08:12 +0000137
Anders Carlssoned961f92009-08-25 02:29:20 +0000138 // Okay: add the default argument to the parameter
139 Param->setDefaultArg(Arg);
Mike Stump1eb44332009-09-09 15:08:12 +0000140
Anders Carlssoned961f92009-08-25 02:29:20 +0000141 DefaultArg.release();
Mike Stump1eb44332009-09-09 15:08:12 +0000142
Anders Carlsson9351c172009-08-25 03:18:48 +0000143 return false;
Anders Carlssoned961f92009-08-25 02:29:20 +0000144}
145
Chris Lattner8123a952008-04-10 02:22:51 +0000146/// ActOnParamDefaultArgument - Check whether the default argument
147/// provided for a function parameter is well-formed. If so, attach it
148/// to the parameter declaration.
Chris Lattner3d1cee32008-04-08 05:04:30 +0000149void
Mike Stump1eb44332009-09-09 15:08:12 +0000150Sema::ActOnParamDefaultArgument(DeclPtrTy param, SourceLocation EqualLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +0000151 ExprArg defarg) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +0000152 if (!param || !defarg.get())
153 return;
Mike Stump1eb44332009-09-09 15:08:12 +0000154
Chris Lattnerb28317a2009-03-28 19:18:32 +0000155 ParmVarDecl *Param = cast<ParmVarDecl>(param.getAs<Decl>());
Anders Carlsson5e300d12009-06-12 16:51:40 +0000156 UnparsedDefaultArgLocs.erase(Param);
157
Anders Carlssonf1b1d592009-05-01 19:30:39 +0000158 ExprOwningPtr<Expr> DefaultArg(this, defarg.takeAs<Expr>());
Chris Lattner3d1cee32008-04-08 05:04:30 +0000159
160 // Default arguments are only permitted in C++
161 if (!getLangOptions().CPlusPlus) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000162 Diag(EqualLoc, diag::err_param_default_argument)
163 << DefaultArg->getSourceRange();
Douglas Gregor72b505b2008-12-16 21:30:33 +0000164 Param->setInvalidDecl();
Chris Lattner3d1cee32008-04-08 05:04:30 +0000165 return;
166 }
167
Anders Carlsson66e30672009-08-25 01:02:06 +0000168 // Check that the default argument is well-formed
169 CheckDefaultArgumentVisitor DefaultArgChecker(DefaultArg.get(), this);
170 if (DefaultArgChecker.Visit(DefaultArg.get())) {
171 Param->setInvalidDecl();
172 return;
173 }
Mike Stump1eb44332009-09-09 15:08:12 +0000174
Anders Carlssoned961f92009-08-25 02:29:20 +0000175 SetParamDefaultArgument(Param, move(DefaultArg), EqualLoc);
Chris Lattner3d1cee32008-04-08 05:04:30 +0000176}
177
Douglas Gregor61366e92008-12-24 00:01:03 +0000178/// ActOnParamUnparsedDefaultArgument - We've seen a default
179/// argument for a function parameter, but we can't parse it yet
180/// because we're inside a class definition. Note that this default
181/// argument will be parsed later.
Mike Stump1eb44332009-09-09 15:08:12 +0000182void Sema::ActOnParamUnparsedDefaultArgument(DeclPtrTy param,
Anders Carlsson5e300d12009-06-12 16:51:40 +0000183 SourceLocation EqualLoc,
184 SourceLocation ArgLoc) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +0000185 if (!param)
186 return;
Mike Stump1eb44332009-09-09 15:08:12 +0000187
Chris Lattnerb28317a2009-03-28 19:18:32 +0000188 ParmVarDecl *Param = cast<ParmVarDecl>(param.getAs<Decl>());
Douglas Gregor61366e92008-12-24 00:01:03 +0000189 if (Param)
190 Param->setUnparsedDefaultArg();
Mike Stump1eb44332009-09-09 15:08:12 +0000191
Anders Carlsson5e300d12009-06-12 16:51:40 +0000192 UnparsedDefaultArgLocs[Param] = ArgLoc;
Douglas Gregor61366e92008-12-24 00:01:03 +0000193}
194
Douglas Gregor72b505b2008-12-16 21:30:33 +0000195/// ActOnParamDefaultArgumentError - Parsing or semantic analysis of
196/// the default argument for the parameter param failed.
Chris Lattnerb28317a2009-03-28 19:18:32 +0000197void Sema::ActOnParamDefaultArgumentError(DeclPtrTy param) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +0000198 if (!param)
199 return;
Mike Stump1eb44332009-09-09 15:08:12 +0000200
Anders Carlsson5e300d12009-06-12 16:51:40 +0000201 ParmVarDecl *Param = cast<ParmVarDecl>(param.getAs<Decl>());
Mike Stump1eb44332009-09-09 15:08:12 +0000202
Anders Carlsson5e300d12009-06-12 16:51:40 +0000203 Param->setInvalidDecl();
Mike Stump1eb44332009-09-09 15:08:12 +0000204
Anders Carlsson5e300d12009-06-12 16:51:40 +0000205 UnparsedDefaultArgLocs.erase(Param);
Douglas Gregor72b505b2008-12-16 21:30:33 +0000206}
207
Douglas Gregor6d6eb572008-05-07 04:49:29 +0000208/// CheckExtraCXXDefaultArguments - Check for any extra default
209/// arguments in the declarator, which is not a function declaration
210/// or definition and therefore is not permitted to have default
211/// arguments. This routine should be invoked for every declarator
212/// that is not a function declaration or definition.
213void Sema::CheckExtraCXXDefaultArguments(Declarator &D) {
214 // C++ [dcl.fct.default]p3
215 // A default argument expression shall be specified only in the
216 // parameter-declaration-clause of a function declaration or in a
217 // template-parameter (14.1). It shall not be specified for a
218 // parameter pack. If it is specified in a
219 // parameter-declaration-clause, it shall not occur within a
220 // declarator or abstract-declarator of a parameter-declaration.
Chris Lattnerb28317a2009-03-28 19:18:32 +0000221 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
Douglas Gregor6d6eb572008-05-07 04:49:29 +0000222 DeclaratorChunk &chunk = D.getTypeObject(i);
223 if (chunk.Kind == DeclaratorChunk::Function) {
Chris Lattnerb28317a2009-03-28 19:18:32 +0000224 for (unsigned argIdx = 0, e = chunk.Fun.NumArgs; argIdx != e; ++argIdx) {
225 ParmVarDecl *Param =
226 cast<ParmVarDecl>(chunk.Fun.ArgInfo[argIdx].Param.getAs<Decl>());
Douglas Gregor61366e92008-12-24 00:01:03 +0000227 if (Param->hasUnparsedDefaultArg()) {
228 CachedTokens *Toks = chunk.Fun.ArgInfo[argIdx].DefaultArgTokens;
Douglas Gregor72b505b2008-12-16 21:30:33 +0000229 Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
230 << SourceRange((*Toks)[1].getLocation(), Toks->back().getLocation());
231 delete Toks;
232 chunk.Fun.ArgInfo[argIdx].DefaultArgTokens = 0;
Douglas Gregor61366e92008-12-24 00:01:03 +0000233 } else if (Param->getDefaultArg()) {
234 Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
235 << Param->getDefaultArg()->getSourceRange();
236 Param->setDefaultArg(0);
Douglas Gregor6d6eb572008-05-07 04:49:29 +0000237 }
238 }
239 }
240 }
241}
242
Chris Lattner3d1cee32008-04-08 05:04:30 +0000243// MergeCXXFunctionDecl - Merge two declarations of the same C++
244// function, once we already know that they have the same
Douglas Gregorcda9c672009-02-16 17:45:42 +0000245// type. Subroutine of MergeFunctionDecl. Returns true if there was an
246// error, false otherwise.
247bool Sema::MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old) {
248 bool Invalid = false;
249
Chris Lattner3d1cee32008-04-08 05:04:30 +0000250 // C++ [dcl.fct.default]p4:
Chris Lattner3d1cee32008-04-08 05:04:30 +0000251 // For non-template functions, default arguments can be added in
252 // later declarations of a function in the same
253 // scope. Declarations in different scopes have completely
254 // distinct sets of default arguments. That is, declarations in
255 // inner scopes do not acquire default arguments from
256 // declarations in outer scopes, and vice versa. In a given
257 // function declaration, all parameters subsequent to a
258 // parameter with a default argument shall have default
259 // arguments supplied in this or previous declarations. A
260 // default argument shall not be redefined by a later
261 // declaration (not even to the same value).
Douglas Gregor6cc15182009-09-11 18:44:32 +0000262 //
263 // C++ [dcl.fct.default]p6:
264 // Except for member functions of class templates, the default arguments
265 // in a member function definition that appears outside of the class
266 // definition are added to the set of default arguments provided by the
267 // member function declaration in the class definition.
Chris Lattner3d1cee32008-04-08 05:04:30 +0000268 for (unsigned p = 0, NumParams = Old->getNumParams(); p < NumParams; ++p) {
269 ParmVarDecl *OldParam = Old->getParamDecl(p);
270 ParmVarDecl *NewParam = New->getParamDecl(p);
271
Douglas Gregor6cc15182009-09-11 18:44:32 +0000272 if (OldParam->hasDefaultArg() && NewParam->hasDefaultArg()) {
Douglas Gregor4f123ff2010-01-13 00:12:48 +0000273 // FIXME: If we knew where the '=' was, we could easily provide a fix-it
274 // hint here. Alternatively, we could walk the type-source information
275 // for NewParam to find the last source location in the type... but it
276 // isn't worth the effort right now. This is the kind of test case that
277 // is hard to get right:
278
279 // int f(int);
280 // void g(int (*fp)(int) = f);
281 // void g(int (*fp)(int) = &f);
Mike Stump1eb44332009-09-09 15:08:12 +0000282 Diag(NewParam->getLocation(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000283 diag::err_param_default_argument_redefinition)
Douglas Gregor4f123ff2010-01-13 00:12:48 +0000284 << NewParam->getDefaultArgRange();
Douglas Gregor6cc15182009-09-11 18:44:32 +0000285
286 // Look for the function declaration where the default argument was
287 // actually written, which may be a declaration prior to Old.
288 for (FunctionDecl *Older = Old->getPreviousDeclaration();
289 Older; Older = Older->getPreviousDeclaration()) {
290 if (!Older->getParamDecl(p)->hasDefaultArg())
291 break;
292
293 OldParam = Older->getParamDecl(p);
294 }
295
296 Diag(OldParam->getLocation(), diag::note_previous_definition)
297 << OldParam->getDefaultArgRange();
Douglas Gregorcda9c672009-02-16 17:45:42 +0000298 Invalid = true;
Douglas Gregord85cef52009-09-17 19:51:30 +0000299 } else if (OldParam->hasDefaultArg()) {
Chris Lattner3d1cee32008-04-08 05:04:30 +0000300 // Merge the old default argument into the new parameter
Douglas Gregord85cef52009-09-17 19:51:30 +0000301 if (OldParam->hasUninstantiatedDefaultArg())
302 NewParam->setUninstantiatedDefaultArg(
303 OldParam->getUninstantiatedDefaultArg());
304 else
305 NewParam->setDefaultArg(OldParam->getDefaultArg());
Douglas Gregor6cc15182009-09-11 18:44:32 +0000306 } else if (NewParam->hasDefaultArg()) {
307 if (New->getDescribedFunctionTemplate()) {
308 // Paragraph 4, quoted above, only applies to non-template functions.
309 Diag(NewParam->getLocation(),
310 diag::err_param_default_argument_template_redecl)
311 << NewParam->getDefaultArgRange();
312 Diag(Old->getLocation(), diag::note_template_prev_declaration)
313 << false;
Douglas Gregor096ebfd2009-10-13 17:02:54 +0000314 } else if (New->getTemplateSpecializationKind()
315 != TSK_ImplicitInstantiation &&
316 New->getTemplateSpecializationKind() != TSK_Undeclared) {
317 // C++ [temp.expr.spec]p21:
318 // Default function arguments shall not be specified in a declaration
319 // or a definition for one of the following explicit specializations:
320 // - the explicit specialization of a function template;
Douglas Gregor8c638ab2009-10-13 23:52:38 +0000321 // - the explicit specialization of a member function template;
322 // - the explicit specialization of a member function of a class
Douglas Gregor096ebfd2009-10-13 17:02:54 +0000323 // template where the class template specialization to which the
324 // member function specialization belongs is implicitly
325 // instantiated.
326 Diag(NewParam->getLocation(), diag::err_template_spec_default_arg)
327 << (New->getTemplateSpecializationKind() ==TSK_ExplicitSpecialization)
328 << New->getDeclName()
329 << NewParam->getDefaultArgRange();
Douglas Gregor6cc15182009-09-11 18:44:32 +0000330 } else if (New->getDeclContext()->isDependentContext()) {
331 // C++ [dcl.fct.default]p6 (DR217):
332 // Default arguments for a member function of a class template shall
333 // be specified on the initial declaration of the member function
334 // within the class template.
335 //
336 // Reading the tea leaves a bit in DR217 and its reference to DR205
337 // leads me to the conclusion that one cannot add default function
338 // arguments for an out-of-line definition of a member function of a
339 // dependent type.
340 int WhichKind = 2;
341 if (CXXRecordDecl *Record
342 = dyn_cast<CXXRecordDecl>(New->getDeclContext())) {
343 if (Record->getDescribedClassTemplate())
344 WhichKind = 0;
345 else if (isa<ClassTemplatePartialSpecializationDecl>(Record))
346 WhichKind = 1;
347 else
348 WhichKind = 2;
349 }
350
351 Diag(NewParam->getLocation(),
352 diag::err_param_default_argument_member_template_redecl)
353 << WhichKind
354 << NewParam->getDefaultArgRange();
355 }
Chris Lattner3d1cee32008-04-08 05:04:30 +0000356 }
357 }
358
Sebastian Redl4994d2d2009-07-04 11:39:00 +0000359 if (CheckEquivalentExceptionSpec(
John McCall183700f2009-09-21 23:43:11 +0000360 Old->getType()->getAs<FunctionProtoType>(), Old->getLocation(),
Douglas Gregor5b6d70e2009-11-25 17:50:39 +0000361 New->getType()->getAs<FunctionProtoType>(), New->getLocation()))
Sebastian Redl4994d2d2009-07-04 11:39:00 +0000362 Invalid = true;
Sebastian Redl4994d2d2009-07-04 11:39:00 +0000363
Douglas Gregorcda9c672009-02-16 17:45:42 +0000364 return Invalid;
Chris Lattner3d1cee32008-04-08 05:04:30 +0000365}
366
367/// CheckCXXDefaultArguments - Verify that the default arguments for a
368/// function declaration are well-formed according to C++
369/// [dcl.fct.default].
370void Sema::CheckCXXDefaultArguments(FunctionDecl *FD) {
371 unsigned NumParams = FD->getNumParams();
372 unsigned p;
373
374 // Find first parameter with a default argument
375 for (p = 0; p < NumParams; ++p) {
376 ParmVarDecl *Param = FD->getParamDecl(p);
Anders Carlsson5f49a0c2009-08-25 01:23:32 +0000377 if (Param->hasDefaultArg())
Chris Lattner3d1cee32008-04-08 05:04:30 +0000378 break;
379 }
380
381 // C++ [dcl.fct.default]p4:
382 // In a given function declaration, all parameters
383 // subsequent to a parameter with a default argument shall
384 // have default arguments supplied in this or previous
385 // declarations. A default argument shall not be redefined
386 // by a later declaration (not even to the same value).
387 unsigned LastMissingDefaultArg = 0;
Mike Stump1eb44332009-09-09 15:08:12 +0000388 for (; p < NumParams; ++p) {
Chris Lattner3d1cee32008-04-08 05:04:30 +0000389 ParmVarDecl *Param = FD->getParamDecl(p);
Anders Carlsson5f49a0c2009-08-25 01:23:32 +0000390 if (!Param->hasDefaultArg()) {
Douglas Gregor72b505b2008-12-16 21:30:33 +0000391 if (Param->isInvalidDecl())
392 /* We already complained about this parameter. */;
393 else if (Param->getIdentifier())
Mike Stump1eb44332009-09-09 15:08:12 +0000394 Diag(Param->getLocation(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000395 diag::err_param_default_argument_missing_name)
Chris Lattner43b628c2008-11-19 07:32:16 +0000396 << Param->getIdentifier();
Chris Lattner3d1cee32008-04-08 05:04:30 +0000397 else
Mike Stump1eb44332009-09-09 15:08:12 +0000398 Diag(Param->getLocation(),
Chris Lattner3d1cee32008-04-08 05:04:30 +0000399 diag::err_param_default_argument_missing);
Mike Stump1eb44332009-09-09 15:08:12 +0000400
Chris Lattner3d1cee32008-04-08 05:04:30 +0000401 LastMissingDefaultArg = p;
402 }
403 }
404
405 if (LastMissingDefaultArg > 0) {
406 // Some default arguments were missing. Clear out all of the
407 // default arguments up to (and including) the last missing
408 // default argument, so that we leave the function parameters
409 // in a semantically valid state.
410 for (p = 0; p <= LastMissingDefaultArg; ++p) {
411 ParmVarDecl *Param = FD->getParamDecl(p);
Anders Carlsson5e300d12009-06-12 16:51:40 +0000412 if (Param->hasDefaultArg()) {
Douglas Gregor61366e92008-12-24 00:01:03 +0000413 if (!Param->hasUnparsedDefaultArg())
414 Param->getDefaultArg()->Destroy(Context);
Chris Lattner3d1cee32008-04-08 05:04:30 +0000415 Param->setDefaultArg(0);
416 }
417 }
418 }
419}
Douglas Gregore37ac4f2008-04-13 21:30:24 +0000420
Douglas Gregorb48fe382008-10-31 09:07:45 +0000421/// isCurrentClassName - Determine whether the identifier II is the
422/// name of the class type currently being defined. In the case of
423/// nested classes, this will only return true if II is the name of
424/// the innermost class.
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +0000425bool Sema::isCurrentClassName(const IdentifierInfo &II, Scope *,
426 const CXXScopeSpec *SS) {
Douglas Gregorb862b8f2010-01-11 23:29:10 +0000427 assert(getLangOptions().CPlusPlus && "No class names in C!");
428
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000429 CXXRecordDecl *CurDecl;
Douglas Gregore4e5b052009-03-19 00:18:19 +0000430 if (SS && SS->isSet() && !SS->isInvalid()) {
Douglas Gregorac373c42009-08-21 22:16:40 +0000431 DeclContext *DC = computeDeclContext(*SS, true);
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000432 CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC);
433 } else
434 CurDecl = dyn_cast_or_null<CXXRecordDecl>(CurContext);
435
436 if (CurDecl)
Douglas Gregorb48fe382008-10-31 09:07:45 +0000437 return &II == CurDecl->getIdentifier();
438 else
439 return false;
440}
441
Mike Stump1eb44332009-09-09 15:08:12 +0000442/// \brief Check the validity of a C++ base class specifier.
Douglas Gregor2943aed2009-03-03 04:44:36 +0000443///
444/// \returns a new CXXBaseSpecifier if well-formed, emits diagnostics
445/// and returns NULL otherwise.
446CXXBaseSpecifier *
447Sema::CheckBaseSpecifier(CXXRecordDecl *Class,
448 SourceRange SpecifierRange,
449 bool Virtual, AccessSpecifier Access,
Mike Stump1eb44332009-09-09 15:08:12 +0000450 QualType BaseType,
Douglas Gregor2943aed2009-03-03 04:44:36 +0000451 SourceLocation BaseLoc) {
452 // C++ [class.union]p1:
453 // A union shall not have base classes.
454 if (Class->isUnion()) {
455 Diag(Class->getLocation(), diag::err_base_clause_on_union)
456 << SpecifierRange;
457 return 0;
458 }
459
460 if (BaseType->isDependentType())
Mike Stump1eb44332009-09-09 15:08:12 +0000461 return new (Context) CXXBaseSpecifier(SpecifierRange, Virtual,
Douglas Gregor2943aed2009-03-03 04:44:36 +0000462 Class->getTagKind() == RecordDecl::TK_class,
463 Access, BaseType);
464
465 // Base specifiers must be record types.
466 if (!BaseType->isRecordType()) {
467 Diag(BaseLoc, diag::err_base_must_be_class) << SpecifierRange;
468 return 0;
469 }
470
471 // C++ [class.union]p1:
472 // A union shall not be used as a base class.
473 if (BaseType->isUnionType()) {
474 Diag(BaseLoc, diag::err_union_as_base_class) << SpecifierRange;
475 return 0;
476 }
477
478 // C++ [class.derived]p2:
479 // The class-name in a base-specifier shall not be an incompletely
480 // defined class.
Mike Stump1eb44332009-09-09 15:08:12 +0000481 if (RequireCompleteType(BaseLoc, BaseType,
Anders Carlssonb7906612009-08-26 23:45:07 +0000482 PDiag(diag::err_incomplete_base_class)
483 << SpecifierRange))
Douglas Gregor2943aed2009-03-03 04:44:36 +0000484 return 0;
485
Eli Friedman1d954f62009-08-15 21:55:26 +0000486 // If the base class is polymorphic or isn't empty, the new one is/isn't, too.
Ted Kremenek6217b802009-07-29 21:53:49 +0000487 RecordDecl *BaseDecl = BaseType->getAs<RecordType>()->getDecl();
Douglas Gregor2943aed2009-03-03 04:44:36 +0000488 assert(BaseDecl && "Record type has no declaration");
489 BaseDecl = BaseDecl->getDefinition(Context);
490 assert(BaseDecl && "Base type is not incomplete, but has no definition");
Eli Friedman1d954f62009-08-15 21:55:26 +0000491 CXXRecordDecl * CXXBaseDecl = cast<CXXRecordDecl>(BaseDecl);
492 assert(CXXBaseDecl && "Base type is not a C++ type");
Eli Friedmand0137332009-12-05 23:03:49 +0000493
Sean Huntbbd37c62009-11-21 08:43:09 +0000494 // C++0x CWG Issue #817 indicates that [[final]] classes shouldn't be bases.
495 if (CXXBaseDecl->hasAttr<FinalAttr>()) {
496 Diag(BaseLoc, diag::err_final_base) << BaseType.getAsString();
Douglas Gregor9af2f522009-12-01 16:58:18 +0000497 Diag(CXXBaseDecl->getLocation(), diag::note_previous_decl)
498 << BaseType;
Sean Huntbbd37c62009-11-21 08:43:09 +0000499 return 0;
500 }
Douglas Gregor2943aed2009-03-03 04:44:36 +0000501
Eli Friedmand0137332009-12-05 23:03:49 +0000502 SetClassDeclAttributesFromBase(Class, CXXBaseDecl, Virtual);
Anders Carlsson51f94042009-12-03 17:49:57 +0000503
504 // Create the base specifier.
505 // FIXME: Allocate via ASTContext?
506 return new (Context) CXXBaseSpecifier(SpecifierRange, Virtual,
507 Class->getTagKind() == RecordDecl::TK_class,
508 Access, BaseType);
509}
510
511void Sema::SetClassDeclAttributesFromBase(CXXRecordDecl *Class,
512 const CXXRecordDecl *BaseClass,
513 bool BaseIsVirtual) {
Eli Friedmand0137332009-12-05 23:03:49 +0000514 // A class with a non-empty base class is not empty.
515 // FIXME: Standard ref?
516 if (!BaseClass->isEmpty())
517 Class->setEmpty(false);
518
519 // C++ [class.virtual]p1:
520 // A class that [...] inherits a virtual function is called a polymorphic
521 // class.
522 if (BaseClass->isPolymorphic())
523 Class->setPolymorphic(true);
Anders Carlsson51f94042009-12-03 17:49:57 +0000524
Douglas Gregor2943aed2009-03-03 04:44:36 +0000525 // C++ [dcl.init.aggr]p1:
526 // An aggregate is [...] a class with [...] no base classes [...].
527 Class->setAggregate(false);
Eli Friedmand0137332009-12-05 23:03:49 +0000528
529 // C++ [class]p4:
530 // A POD-struct is an aggregate class...
Douglas Gregor2943aed2009-03-03 04:44:36 +0000531 Class->setPOD(false);
532
Anders Carlsson51f94042009-12-03 17:49:57 +0000533 if (BaseIsVirtual) {
Anders Carlsson347ba892009-04-16 00:08:20 +0000534 // C++ [class.ctor]p5:
535 // A constructor is trivial if its class has no virtual base classes.
536 Class->setHasTrivialConstructor(false);
Douglas Gregor1f2023a2009-07-22 18:25:24 +0000537
538 // C++ [class.copy]p6:
539 // A copy constructor is trivial if its class has no virtual base classes.
540 Class->setHasTrivialCopyConstructor(false);
541
542 // C++ [class.copy]p11:
543 // A copy assignment operator is trivial if its class has no virtual
544 // base classes.
545 Class->setHasTrivialCopyAssignment(false);
Eli Friedman1d954f62009-08-15 21:55:26 +0000546
547 // C++0x [meta.unary.prop] is_empty:
548 // T is a class type, but not a union type, with ... no virtual base
549 // classes
550 Class->setEmpty(false);
Anders Carlsson347ba892009-04-16 00:08:20 +0000551 } else {
552 // C++ [class.ctor]p5:
Mike Stump1eb44332009-09-09 15:08:12 +0000553 // A constructor is trivial if all the direct base classes of its
Anders Carlsson347ba892009-04-16 00:08:20 +0000554 // class have trivial constructors.
Anders Carlsson51f94042009-12-03 17:49:57 +0000555 if (!BaseClass->hasTrivialConstructor())
Douglas Gregor1f2023a2009-07-22 18:25:24 +0000556 Class->setHasTrivialConstructor(false);
557
558 // C++ [class.copy]p6:
559 // A copy constructor is trivial if all the direct base classes of its
560 // class have trivial copy constructors.
Anders Carlsson51f94042009-12-03 17:49:57 +0000561 if (!BaseClass->hasTrivialCopyConstructor())
Douglas Gregor1f2023a2009-07-22 18:25:24 +0000562 Class->setHasTrivialCopyConstructor(false);
563
564 // C++ [class.copy]p11:
565 // A copy assignment operator is trivial if all the direct base classes
566 // of its class have trivial copy assignment operators.
Anders Carlsson51f94042009-12-03 17:49:57 +0000567 if (!BaseClass->hasTrivialCopyAssignment())
Douglas Gregor1f2023a2009-07-22 18:25:24 +0000568 Class->setHasTrivialCopyAssignment(false);
Anders Carlsson347ba892009-04-16 00:08:20 +0000569 }
Anders Carlsson072abef2009-04-17 02:34:54 +0000570
571 // C++ [class.ctor]p3:
572 // A destructor is trivial if all the direct base classes of its class
573 // have trivial destructors.
Anders Carlsson51f94042009-12-03 17:49:57 +0000574 if (!BaseClass->hasTrivialDestructor())
Douglas Gregor1f2023a2009-07-22 18:25:24 +0000575 Class->setHasTrivialDestructor(false);
Douglas Gregor2943aed2009-03-03 04:44:36 +0000576}
577
Douglas Gregore37ac4f2008-04-13 21:30:24 +0000578/// ActOnBaseSpecifier - Parsed a base specifier. A base specifier is
579/// one entry in the base class list of a class specifier, for
Mike Stump1eb44332009-09-09 15:08:12 +0000580/// example:
581/// class foo : public bar, virtual private baz {
Douglas Gregore37ac4f2008-04-13 21:30:24 +0000582/// 'public bar' and 'virtual private baz' are each base-specifiers.
Mike Stump1eb44332009-09-09 15:08:12 +0000583Sema::BaseResult
Chris Lattnerb28317a2009-03-28 19:18:32 +0000584Sema::ActOnBaseSpecifier(DeclPtrTy classdecl, SourceRange SpecifierRange,
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000585 bool Virtual, AccessSpecifier Access,
586 TypeTy *basetype, SourceLocation BaseLoc) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +0000587 if (!classdecl)
588 return true;
589
Douglas Gregor40808ce2009-03-09 23:48:35 +0000590 AdjustDeclIfTemplate(classdecl);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000591 CXXRecordDecl *Class = cast<CXXRecordDecl>(classdecl.getAs<Decl>());
Argyrios Kyrtzidise8661902009-08-19 01:28:28 +0000592 QualType BaseType = GetTypeFromParser(basetype);
Douglas Gregor2943aed2009-03-03 04:44:36 +0000593 if (CXXBaseSpecifier *BaseSpec = CheckBaseSpecifier(Class, SpecifierRange,
594 Virtual, Access,
595 BaseType, BaseLoc))
596 return BaseSpec;
Mike Stump1eb44332009-09-09 15:08:12 +0000597
Douglas Gregor2943aed2009-03-03 04:44:36 +0000598 return true;
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000599}
Douglas Gregore37ac4f2008-04-13 21:30:24 +0000600
Douglas Gregor2943aed2009-03-03 04:44:36 +0000601/// \brief Performs the actual work of attaching the given base class
602/// specifiers to a C++ class.
603bool Sema::AttachBaseSpecifiers(CXXRecordDecl *Class, CXXBaseSpecifier **Bases,
604 unsigned NumBases) {
605 if (NumBases == 0)
606 return false;
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000607
608 // Used to keep track of which base types we have already seen, so
609 // that we can properly diagnose redundant direct base types. Note
Douglas Gregor57c856b2008-10-23 18:13:27 +0000610 // that the key is always the unqualified canonical type of the base
611 // class.
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000612 std::map<QualType, CXXBaseSpecifier*, QualTypeOrdering> KnownBaseTypes;
613
614 // Copy non-redundant base specifiers into permanent storage.
Douglas Gregor57c856b2008-10-23 18:13:27 +0000615 unsigned NumGoodBases = 0;
Douglas Gregor2943aed2009-03-03 04:44:36 +0000616 bool Invalid = false;
Douglas Gregor57c856b2008-10-23 18:13:27 +0000617 for (unsigned idx = 0; idx < NumBases; ++idx) {
Mike Stump1eb44332009-09-09 15:08:12 +0000618 QualType NewBaseType
Douglas Gregor2943aed2009-03-03 04:44:36 +0000619 = Context.getCanonicalType(Bases[idx]->getType());
Douglas Gregora4923eb2009-11-16 21:35:15 +0000620 NewBaseType = NewBaseType.getLocalUnqualifiedType();
Douglas Gregor57c856b2008-10-23 18:13:27 +0000621
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000622 if (KnownBaseTypes[NewBaseType]) {
623 // C++ [class.mi]p3:
624 // A class shall not be specified as a direct base class of a
625 // derived class more than once.
Douglas Gregor2943aed2009-03-03 04:44:36 +0000626 Diag(Bases[idx]->getSourceRange().getBegin(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000627 diag::err_duplicate_base_class)
Chris Lattnerd1625842008-11-24 06:25:27 +0000628 << KnownBaseTypes[NewBaseType]->getType()
Douglas Gregor2943aed2009-03-03 04:44:36 +0000629 << Bases[idx]->getSourceRange();
Douglas Gregor57c856b2008-10-23 18:13:27 +0000630
631 // Delete the duplicate base class specifier; we're going to
632 // overwrite its pointer later.
Douglas Gregor2aef06d2009-07-22 20:55:49 +0000633 Context.Deallocate(Bases[idx]);
Douglas Gregor2943aed2009-03-03 04:44:36 +0000634
635 Invalid = true;
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000636 } else {
637 // Okay, add this new base class.
Douglas Gregor2943aed2009-03-03 04:44:36 +0000638 KnownBaseTypes[NewBaseType] = Bases[idx];
639 Bases[NumGoodBases++] = Bases[idx];
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000640 }
641 }
642
643 // Attach the remaining base class specifiers to the derived class.
Fariborz Jahanian5ffcd7b2009-07-02 18:26:15 +0000644 Class->setBases(Context, Bases, NumGoodBases);
Douglas Gregor57c856b2008-10-23 18:13:27 +0000645
646 // Delete the remaining (good) base class specifiers, since their
647 // data has been copied into the CXXRecordDecl.
648 for (unsigned idx = 0; idx < NumGoodBases; ++idx)
Douglas Gregor2aef06d2009-07-22 20:55:49 +0000649 Context.Deallocate(Bases[idx]);
Douglas Gregor2943aed2009-03-03 04:44:36 +0000650
651 return Invalid;
652}
653
654/// ActOnBaseSpecifiers - Attach the given base specifiers to the
655/// class, after checking whether there are any duplicate base
656/// classes.
Mike Stump1eb44332009-09-09 15:08:12 +0000657void Sema::ActOnBaseSpecifiers(DeclPtrTy ClassDecl, BaseTy **Bases,
Douglas Gregor2943aed2009-03-03 04:44:36 +0000658 unsigned NumBases) {
659 if (!ClassDecl || !Bases || !NumBases)
660 return;
661
662 AdjustDeclIfTemplate(ClassDecl);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000663 AttachBaseSpecifiers(cast<CXXRecordDecl>(ClassDecl.getAs<Decl>()),
Douglas Gregor2943aed2009-03-03 04:44:36 +0000664 (CXXBaseSpecifier**)(Bases), NumBases);
Douglas Gregore37ac4f2008-04-13 21:30:24 +0000665}
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +0000666
Douglas Gregora8f32e02009-10-06 17:59:45 +0000667/// \brief Determine whether the type \p Derived is a C++ class that is
668/// derived from the type \p Base.
669bool Sema::IsDerivedFrom(QualType Derived, QualType Base) {
670 if (!getLangOptions().CPlusPlus)
671 return false;
672
673 const RecordType *DerivedRT = Derived->getAs<RecordType>();
674 if (!DerivedRT)
675 return false;
676
677 const RecordType *BaseRT = Base->getAs<RecordType>();
678 if (!BaseRT)
679 return false;
680
681 CXXRecordDecl *DerivedRD = cast<CXXRecordDecl>(DerivedRT->getDecl());
682 CXXRecordDecl *BaseRD = cast<CXXRecordDecl>(BaseRT->getDecl());
683 return DerivedRD->isDerivedFrom(BaseRD);
684}
685
686/// \brief Determine whether the type \p Derived is a C++ class that is
687/// derived from the type \p Base.
688bool Sema::IsDerivedFrom(QualType Derived, QualType Base, CXXBasePaths &Paths) {
689 if (!getLangOptions().CPlusPlus)
690 return false;
691
692 const RecordType *DerivedRT = Derived->getAs<RecordType>();
693 if (!DerivedRT)
694 return false;
695
696 const RecordType *BaseRT = Base->getAs<RecordType>();
697 if (!BaseRT)
698 return false;
699
700 CXXRecordDecl *DerivedRD = cast<CXXRecordDecl>(DerivedRT->getDecl());
701 CXXRecordDecl *BaseRD = cast<CXXRecordDecl>(BaseRT->getDecl());
702 return DerivedRD->isDerivedFrom(BaseRD, Paths);
703}
704
705/// CheckDerivedToBaseConversion - Check whether the Derived-to-Base
706/// conversion (where Derived and Base are class types) is
707/// well-formed, meaning that the conversion is unambiguous (and
708/// that all of the base classes are accessible). Returns true
709/// and emits a diagnostic if the code is ill-formed, returns false
710/// otherwise. Loc is the location where this routine should point to
711/// if there is an error, and Range is the source range to highlight
712/// if there is an error.
713bool
714Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base,
715 unsigned InaccessibleBaseID,
716 unsigned AmbigiousBaseConvID,
717 SourceLocation Loc, SourceRange Range,
718 DeclarationName Name) {
719 // First, determine whether the path from Derived to Base is
720 // ambiguous. This is slightly more expensive than checking whether
721 // the Derived to Base conversion exists, because here we need to
722 // explore multiple paths to determine if there is an ambiguity.
723 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
724 /*DetectVirtual=*/false);
725 bool DerivationOkay = IsDerivedFrom(Derived, Base, Paths);
726 assert(DerivationOkay &&
727 "Can only be used with a derived-to-base conversion");
728 (void)DerivationOkay;
729
730 if (!Paths.isAmbiguous(Context.getCanonicalType(Base).getUnqualifiedType())) {
Sebastian Redla82e4ae2009-11-14 21:15:49 +0000731 if (InaccessibleBaseID == 0)
732 return false;
Douglas Gregora8f32e02009-10-06 17:59:45 +0000733 // Check that the base class can be accessed.
734 return CheckBaseClassAccess(Derived, Base, InaccessibleBaseID, Paths, Loc,
735 Name);
736 }
737
738 // We know that the derived-to-base conversion is ambiguous, and
739 // we're going to produce a diagnostic. Perform the derived-to-base
740 // search just one more time to compute all of the possible paths so
741 // that we can print them out. This is more expensive than any of
742 // the previous derived-to-base checks we've done, but at this point
743 // performance isn't as much of an issue.
744 Paths.clear();
745 Paths.setRecordingPaths(true);
746 bool StillOkay = IsDerivedFrom(Derived, Base, Paths);
747 assert(StillOkay && "Can only be used with a derived-to-base conversion");
748 (void)StillOkay;
749
750 // Build up a textual representation of the ambiguous paths, e.g.,
751 // D -> B -> A, that will be used to illustrate the ambiguous
752 // conversions in the diagnostic. We only print one of the paths
753 // to each base class subobject.
754 std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
755
756 Diag(Loc, AmbigiousBaseConvID)
757 << Derived << Base << PathDisplayStr << Range << Name;
758 return true;
759}
760
761bool
762Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base,
Sebastian Redla82e4ae2009-11-14 21:15:49 +0000763 SourceLocation Loc, SourceRange Range,
764 bool IgnoreAccess) {
Douglas Gregora8f32e02009-10-06 17:59:45 +0000765 return CheckDerivedToBaseConversion(Derived, Base,
Sebastian Redla82e4ae2009-11-14 21:15:49 +0000766 IgnoreAccess ? 0 :
767 diag::err_conv_to_inaccessible_base,
Douglas Gregora8f32e02009-10-06 17:59:45 +0000768 diag::err_ambiguous_derived_to_base_conv,
769 Loc, Range, DeclarationName());
770}
771
772
773/// @brief Builds a string representing ambiguous paths from a
774/// specific derived class to different subobjects of the same base
775/// class.
776///
777/// This function builds a string that can be used in error messages
778/// to show the different paths that one can take through the
779/// inheritance hierarchy to go from the derived class to different
780/// subobjects of a base class. The result looks something like this:
781/// @code
782/// struct D -> struct B -> struct A
783/// struct D -> struct C -> struct A
784/// @endcode
785std::string Sema::getAmbiguousPathsDisplayString(CXXBasePaths &Paths) {
786 std::string PathDisplayStr;
787 std::set<unsigned> DisplayedPaths;
788 for (CXXBasePaths::paths_iterator Path = Paths.begin();
789 Path != Paths.end(); ++Path) {
790 if (DisplayedPaths.insert(Path->back().SubobjectNumber).second) {
791 // We haven't displayed a path to this particular base
792 // class subobject yet.
793 PathDisplayStr += "\n ";
794 PathDisplayStr += Context.getTypeDeclType(Paths.getOrigin()).getAsString();
795 for (CXXBasePath::const_iterator Element = Path->begin();
796 Element != Path->end(); ++Element)
797 PathDisplayStr += " -> " + Element->Base->getType().getAsString();
798 }
799 }
800
801 return PathDisplayStr;
802}
803
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000804//===----------------------------------------------------------------------===//
805// C++ class member Handling
806//===----------------------------------------------------------------------===//
807
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000808/// ActOnCXXMemberDeclarator - This is invoked when a C++ class member
809/// declarator is parsed. 'AS' is the access specifier, 'BW' specifies the
810/// bitfield width if there is one and 'InitExpr' specifies the initializer if
Chris Lattnerb6688e02009-04-12 22:37:57 +0000811/// any.
Chris Lattnerb28317a2009-03-28 19:18:32 +0000812Sema::DeclPtrTy
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000813Sema::ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS, Declarator &D,
Douglas Gregor37b372b2009-08-20 22:52:58 +0000814 MultiTemplateParamsArg TemplateParameterLists,
Sebastian Redld1a78462009-11-24 23:38:44 +0000815 ExprTy *BW, ExprTy *InitExpr, bool IsDefinition,
816 bool Deleted) {
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000817 const DeclSpec &DS = D.getDeclSpec();
Douglas Gregor10bd3682008-11-17 22:58:34 +0000818 DeclarationName Name = GetNameForDeclarator(D);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000819 Expr *BitWidth = static_cast<Expr*>(BW);
820 Expr *Init = static_cast<Expr*>(InitExpr);
821 SourceLocation Loc = D.getIdentifierLoc();
822
Sebastian Redl669d5d72008-11-14 23:42:31 +0000823 bool isFunc = D.isFunctionDeclarator();
824
John McCall67d1a672009-08-06 02:15:43 +0000825 assert(!DS.isFriendSpecified());
826
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000827 // C++ 9.2p6: A member shall not be declared to have automatic storage
828 // duration (auto, register) or with the extern storage-class-specifier.
Sebastian Redl669d5d72008-11-14 23:42:31 +0000829 // C++ 7.1.1p8: The mutable specifier can be applied only to names of class
830 // data members and cannot be applied to names declared const or static,
831 // and cannot be applied to reference members.
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000832 switch (DS.getStorageClassSpec()) {
833 case DeclSpec::SCS_unspecified:
834 case DeclSpec::SCS_typedef:
835 case DeclSpec::SCS_static:
836 // FALL THROUGH.
837 break;
Sebastian Redl669d5d72008-11-14 23:42:31 +0000838 case DeclSpec::SCS_mutable:
839 if (isFunc) {
840 if (DS.getStorageClassSpecLoc().isValid())
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000841 Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_function);
Sebastian Redl669d5d72008-11-14 23:42:31 +0000842 else
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000843 Diag(DS.getThreadSpecLoc(), diag::err_mutable_function);
Mike Stump1eb44332009-09-09 15:08:12 +0000844
Sebastian Redla11f42f2008-11-17 23:24:37 +0000845 // FIXME: It would be nicer if the keyword was ignored only for this
846 // declarator. Otherwise we could get follow-up errors.
Sebastian Redl669d5d72008-11-14 23:42:31 +0000847 D.getMutableDeclSpec().ClearStorageClassSpecs();
848 } else {
849 QualType T = GetTypeForDeclarator(D, S);
850 diag::kind err = static_cast<diag::kind>(0);
851 if (T->isReferenceType())
852 err = diag::err_mutable_reference;
853 else if (T.isConstQualified())
854 err = diag::err_mutable_const;
855 if (err != 0) {
856 if (DS.getStorageClassSpecLoc().isValid())
857 Diag(DS.getStorageClassSpecLoc(), err);
858 else
859 Diag(DS.getThreadSpecLoc(), err);
Sebastian Redla11f42f2008-11-17 23:24:37 +0000860 // FIXME: It would be nicer if the keyword was ignored only for this
861 // declarator. Otherwise we could get follow-up errors.
Sebastian Redl669d5d72008-11-14 23:42:31 +0000862 D.getMutableDeclSpec().ClearStorageClassSpecs();
863 }
864 }
865 break;
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000866 default:
867 if (DS.getStorageClassSpecLoc().isValid())
868 Diag(DS.getStorageClassSpecLoc(),
869 diag::err_storageclass_invalid_for_member);
870 else
871 Diag(DS.getThreadSpecLoc(), diag::err_storageclass_invalid_for_member);
872 D.getMutableDeclSpec().ClearStorageClassSpecs();
873 }
874
Argyrios Kyrtzidisd6caa9e2008-10-15 20:23:22 +0000875 if (!isFunc &&
Douglas Gregor1a51b4a2009-02-09 15:09:02 +0000876 D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_typename &&
Argyrios Kyrtzidisd6caa9e2008-10-15 20:23:22 +0000877 D.getNumTypeObjects() == 0) {
Argyrios Kyrtzidisde933f02008-10-08 22:20:31 +0000878 // Check also for this case:
879 //
880 // typedef int f();
881 // f a;
882 //
Argyrios Kyrtzidise8661902009-08-19 01:28:28 +0000883 QualType TDType = GetTypeFromParser(DS.getTypeRep());
Douglas Gregor1a51b4a2009-02-09 15:09:02 +0000884 isFunc = TDType->isFunctionType();
Argyrios Kyrtzidisde933f02008-10-08 22:20:31 +0000885 }
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000886
Sebastian Redl669d5d72008-11-14 23:42:31 +0000887 bool isInstField = ((DS.getStorageClassSpec() == DeclSpec::SCS_unspecified ||
888 DS.getStorageClassSpec() == DeclSpec::SCS_mutable) &&
Argyrios Kyrtzidisde933f02008-10-08 22:20:31 +0000889 !isFunc);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000890
891 Decl *Member;
Chris Lattner24793662009-03-05 22:45:59 +0000892 if (isInstField) {
Douglas Gregor37b372b2009-08-20 22:52:58 +0000893 // FIXME: Check for template parameters!
Douglas Gregor4dd55f52009-03-11 20:50:30 +0000894 Member = HandleField(S, cast<CXXRecordDecl>(CurContext), Loc, D, BitWidth,
895 AS);
Chris Lattner6f8ce142009-03-05 23:03:49 +0000896 assert(Member && "HandleField never returns null");
Chris Lattner24793662009-03-05 22:45:59 +0000897 } else {
Sebastian Redld1a78462009-11-24 23:38:44 +0000898 Member = HandleDeclarator(S, D, move(TemplateParameterLists), IsDefinition)
Douglas Gregor37b372b2009-08-20 22:52:58 +0000899 .getAs<Decl>();
Chris Lattner6f8ce142009-03-05 23:03:49 +0000900 if (!Member) {
901 if (BitWidth) DeleteExpr(BitWidth);
Chris Lattner682bf922009-03-29 16:50:03 +0000902 return DeclPtrTy();
Chris Lattner6f8ce142009-03-05 23:03:49 +0000903 }
Chris Lattner8b963ef2009-03-05 23:01:03 +0000904
905 // Non-instance-fields can't have a bitfield.
906 if (BitWidth) {
907 if (Member->isInvalidDecl()) {
908 // don't emit another diagnostic.
Douglas Gregor2d2e9cf2009-03-11 20:22:50 +0000909 } else if (isa<VarDecl>(Member)) {
Chris Lattner8b963ef2009-03-05 23:01:03 +0000910 // C++ 9.6p3: A bit-field shall not be a static member.
911 // "static member 'A' cannot be a bit-field"
912 Diag(Loc, diag::err_static_not_bitfield)
913 << Name << BitWidth->getSourceRange();
914 } else if (isa<TypedefDecl>(Member)) {
915 // "typedef member 'x' cannot be a bit-field"
916 Diag(Loc, diag::err_typedef_not_bitfield)
917 << Name << BitWidth->getSourceRange();
918 } else {
919 // A function typedef ("typedef int f(); f a;").
920 // C++ 9.6p3: A bit-field shall have integral or enumeration type.
921 Diag(Loc, diag::err_not_integral_type_bitfield)
Mike Stump1eb44332009-09-09 15:08:12 +0000922 << Name << cast<ValueDecl>(Member)->getType()
Douglas Gregor3cf538d2009-03-11 18:59:21 +0000923 << BitWidth->getSourceRange();
Chris Lattner8b963ef2009-03-05 23:01:03 +0000924 }
Mike Stump1eb44332009-09-09 15:08:12 +0000925
Chris Lattner8b963ef2009-03-05 23:01:03 +0000926 DeleteExpr(BitWidth);
927 BitWidth = 0;
928 Member->setInvalidDecl();
929 }
Douglas Gregor4dd55f52009-03-11 20:50:30 +0000930
931 Member->setAccess(AS);
Mike Stump1eb44332009-09-09 15:08:12 +0000932
Douglas Gregor37b372b2009-08-20 22:52:58 +0000933 // If we have declared a member function template, set the access of the
934 // templated declaration as well.
935 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Member))
936 FunTmpl->getTemplatedDecl()->setAccess(AS);
Chris Lattner24793662009-03-05 22:45:59 +0000937 }
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000938
Douglas Gregor10bd3682008-11-17 22:58:34 +0000939 assert((Name || isInstField) && "No identifier for non-field ?");
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000940
Douglas Gregor021c3b32009-03-11 23:00:04 +0000941 if (Init)
Chris Lattnerb28317a2009-03-28 19:18:32 +0000942 AddInitializerToDecl(DeclPtrTy::make(Member), ExprArg(*this, Init), false);
Sebastian Redle2b68332009-04-12 17:16:29 +0000943 if (Deleted) // FIXME: Source location is not very good.
944 SetDeclDeleted(DeclPtrTy::make(Member), D.getSourceRange().getBegin());
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000945
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000946 if (isInstField) {
Douglas Gregor44b43212008-12-11 16:49:14 +0000947 FieldCollector->Add(cast<FieldDecl>(Member));
Chris Lattner682bf922009-03-29 16:50:03 +0000948 return DeclPtrTy();
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000949 }
Chris Lattnerb28317a2009-03-28 19:18:32 +0000950 return DeclPtrTy::make(Member);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000951}
952
Douglas Gregorfe0241e2009-12-31 09:10:24 +0000953/// \brief Find the direct and/or virtual base specifiers that
954/// correspond to the given base type, for use in base initialization
955/// within a constructor.
956static bool FindBaseInitializer(Sema &SemaRef,
957 CXXRecordDecl *ClassDecl,
958 QualType BaseType,
959 const CXXBaseSpecifier *&DirectBaseSpec,
960 const CXXBaseSpecifier *&VirtualBaseSpec) {
961 // First, check for a direct base class.
962 DirectBaseSpec = 0;
963 for (CXXRecordDecl::base_class_const_iterator Base
964 = ClassDecl->bases_begin();
965 Base != ClassDecl->bases_end(); ++Base) {
966 if (SemaRef.Context.hasSameUnqualifiedType(BaseType, Base->getType())) {
967 // We found a direct base of this type. That's what we're
968 // initializing.
969 DirectBaseSpec = &*Base;
970 break;
971 }
972 }
973
974 // Check for a virtual base class.
975 // FIXME: We might be able to short-circuit this if we know in advance that
976 // there are no virtual bases.
977 VirtualBaseSpec = 0;
978 if (!DirectBaseSpec || !DirectBaseSpec->isVirtual()) {
979 // We haven't found a base yet; search the class hierarchy for a
980 // virtual base class.
981 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
982 /*DetectVirtual=*/false);
983 if (SemaRef.IsDerivedFrom(SemaRef.Context.getTypeDeclType(ClassDecl),
984 BaseType, Paths)) {
985 for (CXXBasePaths::paths_iterator Path = Paths.begin();
986 Path != Paths.end(); ++Path) {
987 if (Path->back().Base->isVirtual()) {
988 VirtualBaseSpec = Path->back().Base;
989 break;
990 }
991 }
992 }
993 }
994
995 return DirectBaseSpec || VirtualBaseSpec;
996}
997
Douglas Gregor7ad83902008-11-05 04:29:56 +0000998/// ActOnMemInitializer - Handle a C++ member initializer.
Mike Stump1eb44332009-09-09 15:08:12 +0000999Sema::MemInitResult
Chris Lattnerb28317a2009-03-28 19:18:32 +00001000Sema::ActOnMemInitializer(DeclPtrTy ConstructorD,
Douglas Gregor7ad83902008-11-05 04:29:56 +00001001 Scope *S,
Fariborz Jahanianbcfad542009-06-30 23:26:25 +00001002 const CXXScopeSpec &SS,
Douglas Gregor7ad83902008-11-05 04:29:56 +00001003 IdentifierInfo *MemberOrBase,
Fariborz Jahanian96174332009-07-01 19:21:19 +00001004 TypeTy *TemplateTypeTy,
Douglas Gregor7ad83902008-11-05 04:29:56 +00001005 SourceLocation IdLoc,
1006 SourceLocation LParenLoc,
1007 ExprTy **Args, unsigned NumArgs,
1008 SourceLocation *CommaLocs,
1009 SourceLocation RParenLoc) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +00001010 if (!ConstructorD)
1011 return true;
Mike Stump1eb44332009-09-09 15:08:12 +00001012
Douglas Gregorefd5bda2009-08-24 11:57:43 +00001013 AdjustDeclIfTemplate(ConstructorD);
Mike Stump1eb44332009-09-09 15:08:12 +00001014
1015 CXXConstructorDecl *Constructor
Chris Lattnerb28317a2009-03-28 19:18:32 +00001016 = dyn_cast<CXXConstructorDecl>(ConstructorD.getAs<Decl>());
Douglas Gregor7ad83902008-11-05 04:29:56 +00001017 if (!Constructor) {
1018 // The user wrote a constructor initializer on a function that is
1019 // not a C++ constructor. Ignore the error for now, because we may
1020 // have more member initializers coming; we'll diagnose it just
1021 // once in ActOnMemInitializers.
1022 return true;
1023 }
1024
1025 CXXRecordDecl *ClassDecl = Constructor->getParent();
1026
1027 // C++ [class.base.init]p2:
1028 // Names in a mem-initializer-id are looked up in the scope of the
1029 // constructor’s class and, if not found in that scope, are looked
1030 // up in the scope containing the constructor’s
1031 // definition. [Note: if the constructor’s class contains a member
1032 // with the same name as a direct or virtual base class of the
1033 // class, a mem-initializer-id naming the member or base class and
1034 // composed of a single identifier refers to the class member. A
1035 // mem-initializer-id for the hidden base class may be specified
1036 // using a qualified name. ]
Fariborz Jahanian96174332009-07-01 19:21:19 +00001037 if (!SS.getScopeRep() && !TemplateTypeTy) {
Fariborz Jahanianbcfad542009-06-30 23:26:25 +00001038 // Look for a member, first.
1039 FieldDecl *Member = 0;
Mike Stump1eb44332009-09-09 15:08:12 +00001040 DeclContext::lookup_result Result
Fariborz Jahanianbcfad542009-06-30 23:26:25 +00001041 = ClassDecl->lookup(MemberOrBase);
1042 if (Result.first != Result.second)
1043 Member = dyn_cast<FieldDecl>(*Result.first);
Douglas Gregor7ad83902008-11-05 04:29:56 +00001044
Fariborz Jahanianbcfad542009-06-30 23:26:25 +00001045 // FIXME: Handle members of an anonymous union.
Douglas Gregor7ad83902008-11-05 04:29:56 +00001046
Eli Friedman59c04372009-07-29 19:44:27 +00001047 if (Member)
1048 return BuildMemberInitializer(Member, (Expr**)Args, NumArgs, IdLoc,
Douglas Gregor802ab452009-12-02 22:36:29 +00001049 LParenLoc, RParenLoc);
Douglas Gregor7ad83902008-11-05 04:29:56 +00001050 }
Douglas Gregor7ad83902008-11-05 04:29:56 +00001051 // It didn't name a member, so see if it names a class.
Douglas Gregor802ab452009-12-02 22:36:29 +00001052 QualType BaseType;
John McCalla93c9342009-12-07 02:54:59 +00001053 TypeSourceInfo *TInfo = 0;
John McCall2b194412009-12-21 10:41:20 +00001054
1055 if (TemplateTypeTy) {
John McCalla93c9342009-12-07 02:54:59 +00001056 BaseType = GetTypeFromParser(TemplateTypeTy, &TInfo);
John McCall2b194412009-12-21 10:41:20 +00001057 } else {
1058 LookupResult R(*this, MemberOrBase, IdLoc, LookupOrdinaryName);
1059 LookupParsedName(R, S, &SS);
1060
1061 TypeDecl *TyD = R.getAsSingle<TypeDecl>();
1062 if (!TyD) {
1063 if (R.isAmbiguous()) return true;
1064
Douglas Gregor7a886e12010-01-19 06:46:48 +00001065 if (SS.isSet() && isDependentScopeSpecifier(SS)) {
1066 bool NotUnknownSpecialization = false;
1067 DeclContext *DC = computeDeclContext(SS, false);
1068 if (CXXRecordDecl *Record = dyn_cast_or_null<CXXRecordDecl>(DC))
1069 NotUnknownSpecialization = !Record->hasAnyDependentBases();
1070
1071 if (!NotUnknownSpecialization) {
1072 // When the scope specifier can refer to a member of an unknown
1073 // specialization, we take it as a type name.
1074 BaseType = CheckTypenameType((NestedNameSpecifier *)SS.getScopeRep(),
1075 *MemberOrBase, SS.getRange());
1076 R.clear();
1077 }
1078 }
1079
Douglas Gregorfe0241e2009-12-31 09:10:24 +00001080 // If no results were found, try to correct typos.
Douglas Gregor7a886e12010-01-19 06:46:48 +00001081 if (R.empty() && BaseType.isNull() &&
Douglas Gregorfe0241e2009-12-31 09:10:24 +00001082 CorrectTypo(R, S, &SS, ClassDecl) && R.isSingleResult()) {
1083 if (FieldDecl *Member = R.getAsSingle<FieldDecl>()) {
1084 if (Member->getDeclContext()->getLookupContext()->Equals(ClassDecl)) {
1085 // We have found a non-static data member with a similar
1086 // name to what was typed; complain and initialize that
1087 // member.
1088 Diag(R.getNameLoc(), diag::err_mem_init_not_member_or_class_suggest)
1089 << MemberOrBase << true << R.getLookupName()
1090 << CodeModificationHint::CreateReplacement(R.getNameLoc(),
1091 R.getLookupName().getAsString());
Douglas Gregor67dd1d42010-01-07 00:17:44 +00001092 Diag(Member->getLocation(), diag::note_previous_decl)
1093 << Member->getDeclName();
Douglas Gregorfe0241e2009-12-31 09:10:24 +00001094
1095 return BuildMemberInitializer(Member, (Expr**)Args, NumArgs, IdLoc,
1096 LParenLoc, RParenLoc);
1097 }
1098 } else if (TypeDecl *Type = R.getAsSingle<TypeDecl>()) {
1099 const CXXBaseSpecifier *DirectBaseSpec;
1100 const CXXBaseSpecifier *VirtualBaseSpec;
1101 if (FindBaseInitializer(*this, ClassDecl,
1102 Context.getTypeDeclType(Type),
1103 DirectBaseSpec, VirtualBaseSpec)) {
1104 // We have found a direct or virtual base class with a
1105 // similar name to what was typed; complain and initialize
1106 // that base class.
1107 Diag(R.getNameLoc(), diag::err_mem_init_not_member_or_class_suggest)
1108 << MemberOrBase << false << R.getLookupName()
1109 << CodeModificationHint::CreateReplacement(R.getNameLoc(),
1110 R.getLookupName().getAsString());
Douglas Gregor0d535c82010-01-07 00:26:25 +00001111
1112 const CXXBaseSpecifier *BaseSpec = DirectBaseSpec? DirectBaseSpec
1113 : VirtualBaseSpec;
1114 Diag(BaseSpec->getSourceRange().getBegin(),
1115 diag::note_base_class_specified_here)
1116 << BaseSpec->getType()
1117 << BaseSpec->getSourceRange();
1118
Douglas Gregorfe0241e2009-12-31 09:10:24 +00001119 TyD = Type;
1120 }
1121 }
1122 }
1123
Douglas Gregor7a886e12010-01-19 06:46:48 +00001124 if (!TyD && BaseType.isNull()) {
Douglas Gregorfe0241e2009-12-31 09:10:24 +00001125 Diag(IdLoc, diag::err_mem_init_not_member_or_class)
1126 << MemberOrBase << SourceRange(IdLoc, RParenLoc);
1127 return true;
1128 }
John McCall2b194412009-12-21 10:41:20 +00001129 }
1130
Douglas Gregor7a886e12010-01-19 06:46:48 +00001131 if (BaseType.isNull()) {
1132 BaseType = Context.getTypeDeclType(TyD);
1133 if (SS.isSet()) {
1134 NestedNameSpecifier *Qualifier =
1135 static_cast<NestedNameSpecifier*>(SS.getScopeRep());
John McCall2b194412009-12-21 10:41:20 +00001136
Douglas Gregor7a886e12010-01-19 06:46:48 +00001137 // FIXME: preserve source range information
1138 BaseType = Context.getQualifiedNameType(Qualifier, BaseType);
1139 }
John McCall2b194412009-12-21 10:41:20 +00001140 }
1141 }
Mike Stump1eb44332009-09-09 15:08:12 +00001142
John McCalla93c9342009-12-07 02:54:59 +00001143 if (!TInfo)
1144 TInfo = Context.getTrivialTypeSourceInfo(BaseType, IdLoc);
Douglas Gregor7ad83902008-11-05 04:29:56 +00001145
John McCalla93c9342009-12-07 02:54:59 +00001146 return BuildBaseInitializer(BaseType, TInfo, (Expr **)Args, NumArgs,
Douglas Gregor802ab452009-12-02 22:36:29 +00001147 LParenLoc, RParenLoc, ClassDecl);
Eli Friedman59c04372009-07-29 19:44:27 +00001148}
1149
John McCallb4190042009-11-04 23:02:40 +00001150/// Checks an initializer expression for use of uninitialized fields, such as
1151/// containing the field that is being initialized. Returns true if there is an
1152/// uninitialized field was used an updates the SourceLocation parameter; false
1153/// otherwise.
1154static bool InitExprContainsUninitializedFields(const Stmt* S,
1155 const FieldDecl* LhsField,
1156 SourceLocation* L) {
1157 const MemberExpr* ME = dyn_cast<MemberExpr>(S);
1158 if (ME) {
1159 const NamedDecl* RhsField = ME->getMemberDecl();
1160 if (RhsField == LhsField) {
1161 // Initializing a field with itself. Throw a warning.
1162 // But wait; there are exceptions!
1163 // Exception #1: The field may not belong to this record.
1164 // e.g. Foo(const Foo& rhs) : A(rhs.A) {}
1165 const Expr* base = ME->getBase();
1166 if (base != NULL && !isa<CXXThisExpr>(base->IgnoreParenCasts())) {
1167 // Even though the field matches, it does not belong to this record.
1168 return false;
1169 }
1170 // None of the exceptions triggered; return true to indicate an
1171 // uninitialized field was used.
1172 *L = ME->getMemberLoc();
1173 return true;
1174 }
1175 }
1176 bool found = false;
1177 for (Stmt::const_child_iterator it = S->child_begin();
1178 it != S->child_end() && found == false;
1179 ++it) {
1180 if (isa<CallExpr>(S)) {
1181 // Do not descend into function calls or constructors, as the use
1182 // of an uninitialized field may be valid. One would have to inspect
1183 // the contents of the function/ctor to determine if it is safe or not.
1184 // i.e. Pass-by-value is never safe, but pass-by-reference and pointers
1185 // may be safe, depending on what the function/ctor does.
1186 continue;
1187 }
1188 found = InitExprContainsUninitializedFields(*it, LhsField, L);
1189 }
1190 return found;
1191}
1192
Eli Friedman59c04372009-07-29 19:44:27 +00001193Sema::MemInitResult
1194Sema::BuildMemberInitializer(FieldDecl *Member, Expr **Args,
1195 unsigned NumArgs, SourceLocation IdLoc,
Douglas Gregor802ab452009-12-02 22:36:29 +00001196 SourceLocation LParenLoc,
Eli Friedman59c04372009-07-29 19:44:27 +00001197 SourceLocation RParenLoc) {
Anders Carlssonf8a9a792009-11-13 19:21:49 +00001198 // FIXME: CXXBaseOrMemberInitializer should only contain a single
1199 // subexpression so we can wrap it in a CXXExprWithTemporaries if necessary.
1200 ExprTemporaries.clear();
1201
John McCallb4190042009-11-04 23:02:40 +00001202 // Diagnose value-uses of fields to initialize themselves, e.g.
1203 // foo(foo)
1204 // where foo is not also a parameter to the constructor.
John McCall6aee6212009-11-04 23:13:52 +00001205 // TODO: implement -Wuninitialized and fold this into that framework.
John McCallb4190042009-11-04 23:02:40 +00001206 for (unsigned i = 0; i < NumArgs; ++i) {
1207 SourceLocation L;
1208 if (InitExprContainsUninitializedFields(Args[i], Member, &L)) {
1209 // FIXME: Return true in the case when other fields are used before being
1210 // uninitialized. For example, let this field be the i'th field. When
1211 // initializing the i'th field, throw a warning if any of the >= i'th
1212 // fields are used, as they are not yet initialized.
1213 // Right now we are only handling the case where the i'th field uses
1214 // itself in its initializer.
1215 Diag(L, diag::warn_field_is_uninit);
1216 }
1217 }
1218
Eli Friedman59c04372009-07-29 19:44:27 +00001219 bool HasDependentArg = false;
1220 for (unsigned i = 0; i < NumArgs; i++)
1221 HasDependentArg |= Args[i]->isTypeDependent();
1222
1223 CXXConstructorDecl *C = 0;
1224 QualType FieldType = Member->getType();
1225 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
1226 FieldType = Array->getElementType();
Eli Friedmane6d11b72009-12-25 23:59:21 +00001227 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(*this);
Eli Friedman59c04372009-07-29 19:44:27 +00001228 if (FieldType->isDependentType()) {
1229 // Can't check init for dependent type.
John McCall6aee6212009-11-04 23:13:52 +00001230 } else if (FieldType->isRecordType()) {
1231 // Member is a record (struct/union/class), so pass the initializer
1232 // arguments down to the record's constructor.
Douglas Gregor39da0b82009-09-09 23:08:42 +00001233 if (!HasDependentArg) {
Douglas Gregor39da0b82009-09-09 23:08:42 +00001234 C = PerformInitializationByConstructor(FieldType,
1235 MultiExprArg(*this,
1236 (void**)Args,
1237 NumArgs),
1238 IdLoc,
1239 SourceRange(IdLoc, RParenLoc),
Douglas Gregor20093b42009-12-09 23:02:17 +00001240 Member->getDeclName(),
1241 InitializationKind::CreateDirect(IdLoc, LParenLoc, RParenLoc),
Douglas Gregor39da0b82009-09-09 23:08:42 +00001242 ConstructorArgs);
1243
1244 if (C) {
1245 // Take over the constructor arguments as our own.
1246 NumArgs = ConstructorArgs.size();
1247 Args = (Expr **)ConstructorArgs.take();
1248 }
1249 }
Fariborz Jahanian636a0ff2009-09-02 17:10:17 +00001250 } else if (NumArgs != 1 && NumArgs != 0) {
John McCall6aee6212009-11-04 23:13:52 +00001251 // The member type is not a record type (or an array of record
1252 // types), so it can be only be default- or copy-initialized.
Mike Stump1eb44332009-09-09 15:08:12 +00001253 return Diag(IdLoc, diag::err_mem_initializer_mismatch)
Eli Friedman59c04372009-07-29 19:44:27 +00001254 << Member->getDeclName() << SourceRange(IdLoc, RParenLoc);
1255 } else if (!HasDependentArg) {
Fariborz Jahanian636a0ff2009-09-02 17:10:17 +00001256 Expr *NewExp;
1257 if (NumArgs == 0) {
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001258 if (FieldType->isReferenceType()) {
1259 Diag(IdLoc, diag::err_null_intialized_reference_member)
1260 << Member->getDeclName();
1261 return Diag(Member->getLocation(), diag::note_declared_at);
1262 }
Fariborz Jahanian636a0ff2009-09-02 17:10:17 +00001263 NewExp = new (Context) CXXZeroInitValueExpr(FieldType, IdLoc, RParenLoc);
1264 NumArgs = 1;
1265 }
1266 else
1267 NewExp = (Expr*)Args[0];
Chris Lattner8c3f8902009-12-31 03:10:55 +00001268 if (!Member->isInvalidDecl() &&
1269 PerformCopyInitialization(NewExp, FieldType, AA_Passing))
Eli Friedman59c04372009-07-29 19:44:27 +00001270 return true;
1271 Args[0] = NewExp;
Douglas Gregor7ad83902008-11-05 04:29:56 +00001272 }
Anders Carlssonf8a9a792009-11-13 19:21:49 +00001273
1274 // FIXME: CXXBaseOrMemberInitializer should only contain a single
1275 // subexpression so we can wrap it in a CXXExprWithTemporaries if necessary.
1276 ExprTemporaries.clear();
1277
Eli Friedman59c04372009-07-29 19:44:27 +00001278 // FIXME: Perform direct initialization of the member.
Douglas Gregor802ab452009-12-02 22:36:29 +00001279 return new (Context) CXXBaseOrMemberInitializer(Context, Member, IdLoc,
1280 C, LParenLoc, (Expr **)Args,
1281 NumArgs, RParenLoc);
Eli Friedman59c04372009-07-29 19:44:27 +00001282}
1283
1284Sema::MemInitResult
John McCalla93c9342009-12-07 02:54:59 +00001285Sema::BuildBaseInitializer(QualType BaseType, TypeSourceInfo *BaseTInfo,
Douglas Gregor802ab452009-12-02 22:36:29 +00001286 Expr **Args, unsigned NumArgs,
1287 SourceLocation LParenLoc, SourceLocation RParenLoc,
1288 CXXRecordDecl *ClassDecl) {
Eli Friedman59c04372009-07-29 19:44:27 +00001289 bool HasDependentArg = false;
1290 for (unsigned i = 0; i < NumArgs; i++)
1291 HasDependentArg |= Args[i]->isTypeDependent();
1292
John McCalla93c9342009-12-07 02:54:59 +00001293 SourceLocation BaseLoc = BaseTInfo->getTypeLoc().getSourceRange().getBegin();
Eli Friedman59c04372009-07-29 19:44:27 +00001294 if (!BaseType->isDependentType()) {
1295 if (!BaseType->isRecordType())
Douglas Gregor802ab452009-12-02 22:36:29 +00001296 return Diag(BaseLoc, diag::err_base_init_does_not_name_class)
John McCalla93c9342009-12-07 02:54:59 +00001297 << BaseType << BaseTInfo->getTypeLoc().getSourceRange();
Eli Friedman59c04372009-07-29 19:44:27 +00001298
1299 // C++ [class.base.init]p2:
1300 // [...] Unless the mem-initializer-id names a nonstatic data
1301 // member of the constructor’s class or a direct or virtual base
1302 // of that class, the mem-initializer is ill-formed. A
1303 // mem-initializer-list can initialize a base class using any
1304 // name that denotes that base class type.
Mike Stump1eb44332009-09-09 15:08:12 +00001305
Douglas Gregorfe0241e2009-12-31 09:10:24 +00001306 // Check for direct and virtual base classes.
Eli Friedman59c04372009-07-29 19:44:27 +00001307 const CXXBaseSpecifier *DirectBaseSpec = 0;
Eli Friedman59c04372009-07-29 19:44:27 +00001308 const CXXBaseSpecifier *VirtualBaseSpec = 0;
Douglas Gregorfe0241e2009-12-31 09:10:24 +00001309 FindBaseInitializer(*this, ClassDecl, BaseType, DirectBaseSpec,
1310 VirtualBaseSpec);
Eli Friedman59c04372009-07-29 19:44:27 +00001311
1312 // C++ [base.class.init]p2:
1313 // If a mem-initializer-id is ambiguous because it designates both
1314 // a direct non-virtual base class and an inherited virtual base
1315 // class, the mem-initializer is ill-formed.
1316 if (DirectBaseSpec && VirtualBaseSpec)
Douglas Gregor802ab452009-12-02 22:36:29 +00001317 return Diag(BaseLoc, diag::err_base_init_direct_and_virtual)
John McCalla93c9342009-12-07 02:54:59 +00001318 << BaseType << BaseTInfo->getTypeLoc().getSourceRange();
Eli Friedman59c04372009-07-29 19:44:27 +00001319 // C++ [base.class.init]p2:
1320 // Unless the mem-initializer-id names a nonstatic data membeer of the
1321 // constructor's class ot a direst or virtual base of that class, the
1322 // mem-initializer is ill-formed.
1323 if (!DirectBaseSpec && !VirtualBaseSpec)
Douglas Gregor802ab452009-12-02 22:36:29 +00001324 return Diag(BaseLoc, diag::err_not_direct_base_or_virtual)
1325 << BaseType << ClassDecl->getNameAsCString()
John McCalla93c9342009-12-07 02:54:59 +00001326 << BaseTInfo->getTypeLoc().getSourceRange();
Douglas Gregor7ad83902008-11-05 04:29:56 +00001327 }
1328
Fariborz Jahaniand7b27e12009-07-23 00:42:24 +00001329 CXXConstructorDecl *C = 0;
Eli Friedmane6d11b72009-12-25 23:59:21 +00001330 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(*this);
Eli Friedman59c04372009-07-29 19:44:27 +00001331 if (!BaseType->isDependentType() && !HasDependentArg) {
1332 DeclarationName Name = Context.DeclarationNames.getCXXConstructorName(
Douglas Gregor3eaa9ff2009-11-08 07:12:55 +00001333 Context.getCanonicalType(BaseType).getUnqualifiedType());
Douglas Gregor39da0b82009-09-09 23:08:42 +00001334
1335 C = PerformInitializationByConstructor(BaseType,
1336 MultiExprArg(*this,
1337 (void**)Args, NumArgs),
Douglas Gregor802ab452009-12-02 22:36:29 +00001338 BaseLoc,
1339 SourceRange(BaseLoc, RParenLoc),
Douglas Gregor20093b42009-12-09 23:02:17 +00001340 Name,
1341 InitializationKind::CreateDirect(BaseLoc, LParenLoc, RParenLoc),
Douglas Gregor39da0b82009-09-09 23:08:42 +00001342 ConstructorArgs);
1343 if (C) {
1344 // Take over the constructor arguments as our own.
1345 NumArgs = ConstructorArgs.size();
1346 Args = (Expr **)ConstructorArgs.take();
1347 }
Eli Friedman59c04372009-07-29 19:44:27 +00001348 }
1349
Anders Carlssonf8a9a792009-11-13 19:21:49 +00001350 // FIXME: CXXBaseOrMemberInitializer should only contain a single
1351 // subexpression so we can wrap it in a CXXExprWithTemporaries if necessary.
1352 ExprTemporaries.clear();
1353
John McCalla93c9342009-12-07 02:54:59 +00001354 return new (Context) CXXBaseOrMemberInitializer(Context, BaseTInfo, C,
Douglas Gregor802ab452009-12-02 22:36:29 +00001355 LParenLoc, (Expr **)Args,
1356 NumArgs, RParenLoc);
Douglas Gregor7ad83902008-11-05 04:29:56 +00001357}
1358
Eli Friedman80c30da2009-11-09 19:20:36 +00001359bool
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00001360Sema::SetBaseOrMemberInitializers(CXXConstructorDecl *Constructor,
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001361 CXXBaseOrMemberInitializer **Initializers,
1362 unsigned NumInitializers,
Eli Friedman49c16da2009-11-09 01:05:47 +00001363 bool IsImplicitConstructor) {
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001364 // We need to build the initializer AST according to order of construction
1365 // and not what user specified in the Initializers list.
1366 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Constructor->getDeclContext());
1367 llvm::SmallVector<CXXBaseOrMemberInitializer*, 32> AllToInit;
1368 llvm::DenseMap<const void *, CXXBaseOrMemberInitializer*> AllBaseFields;
1369 bool HasDependentBaseInit = false;
Eli Friedman80c30da2009-11-09 19:20:36 +00001370 bool HadError = false;
Mike Stump1eb44332009-09-09 15:08:12 +00001371
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001372 for (unsigned i = 0; i < NumInitializers; i++) {
1373 CXXBaseOrMemberInitializer *Member = Initializers[i];
1374 if (Member->isBaseInitializer()) {
1375 if (Member->getBaseClass()->isDependentType())
1376 HasDependentBaseInit = true;
1377 AllBaseFields[Member->getBaseClass()->getAs<RecordType>()] = Member;
1378 } else {
1379 AllBaseFields[Member->getMember()] = Member;
1380 }
1381 }
Mike Stump1eb44332009-09-09 15:08:12 +00001382
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001383 if (HasDependentBaseInit) {
1384 // FIXME. This does not preserve the ordering of the initializers.
1385 // Try (with -Wreorder)
1386 // template<class X> struct A {};
Mike Stump1eb44332009-09-09 15:08:12 +00001387 // template<class X> struct B : A<X> {
1388 // B() : x1(10), A<X>() {}
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001389 // int x1;
1390 // };
1391 // B<int> x;
1392 // On seeing one dependent type, we should essentially exit this routine
1393 // while preserving user-declared initializer list. When this routine is
1394 // called during instantiatiation process, this routine will rebuild the
John McCall6aee6212009-11-04 23:13:52 +00001395 // ordered initializer list correctly.
Mike Stump1eb44332009-09-09 15:08:12 +00001396
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001397 // If we have a dependent base initialization, we can't determine the
1398 // association between initializers and bases; just dump the known
1399 // initializers into the list, and don't try to deal with other bases.
1400 for (unsigned i = 0; i < NumInitializers; i++) {
1401 CXXBaseOrMemberInitializer *Member = Initializers[i];
1402 if (Member->isBaseInitializer())
1403 AllToInit.push_back(Member);
1404 }
1405 } else {
1406 // Push virtual bases before others.
1407 for (CXXRecordDecl::base_class_iterator VBase =
1408 ClassDecl->vbases_begin(),
1409 E = ClassDecl->vbases_end(); VBase != E; ++VBase) {
1410 if (VBase->getType()->isDependentType())
1411 continue;
Douglas Gregorc07a4942009-11-15 08:51:10 +00001412 if (CXXBaseOrMemberInitializer *Value
1413 = AllBaseFields.lookup(VBase->getType()->getAs<RecordType>())) {
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001414 AllToInit.push_back(Value);
Fariborz Jahanian9d436202009-09-03 21:32:41 +00001415 }
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001416 else {
Mike Stump1eb44332009-09-09 15:08:12 +00001417 CXXRecordDecl *VBaseDecl =
Douglas Gregor802ab452009-12-02 22:36:29 +00001418 cast<CXXRecordDecl>(VBase->getType()->getAs<RecordType>()->getDecl());
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00001419 assert(VBaseDecl && "SetBaseOrMemberInitializers - VBaseDecl null");
Fariborz Jahanian9d436202009-09-03 21:32:41 +00001420 CXXConstructorDecl *Ctor = VBaseDecl->getDefaultConstructor(Context);
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00001421 if (!Ctor) {
Eli Friedman49c16da2009-11-09 01:05:47 +00001422 Diag(Constructor->getLocation(), diag::err_missing_default_ctor)
1423 << (int)IsImplicitConstructor << Context.getTagDeclType(ClassDecl)
1424 << 0 << VBase->getType();
Douglas Gregor9af2f522009-12-01 16:58:18 +00001425 Diag(VBaseDecl->getLocation(), diag::note_previous_decl)
Eli Friedman49c16da2009-11-09 01:05:47 +00001426 << Context.getTagDeclType(VBaseDecl);
Eli Friedman80c30da2009-11-09 19:20:36 +00001427 HadError = true;
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00001428 continue;
1429 }
Fariborz Jahanian9d436202009-09-03 21:32:41 +00001430
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00001431 ASTOwningVector<&ActionBase::DeleteExpr> CtorArgs(*this);
1432 if (CompleteConstructorCall(Ctor, MultiExprArg(*this, 0, 0),
1433 Constructor->getLocation(), CtorArgs))
1434 continue;
1435
1436 MarkDeclarationReferenced(Constructor->getLocation(), Ctor);
1437
Anders Carlsson8db68da2009-11-13 20:11:49 +00001438 // FIXME: CXXBaseOrMemberInitializer should only contain a single
Douglas Gregor802ab452009-12-02 22:36:29 +00001439 // subexpression so we can wrap it in a CXXExprWithTemporaries if
1440 // necessary.
1441 // FIXME: Is there any better source-location information we can give?
Anders Carlsson8db68da2009-11-13 20:11:49 +00001442 ExprTemporaries.clear();
Mike Stump1eb44332009-09-09 15:08:12 +00001443 CXXBaseOrMemberInitializer *Member =
Douglas Gregor802ab452009-12-02 22:36:29 +00001444 new (Context) CXXBaseOrMemberInitializer(Context,
John McCalla93c9342009-12-07 02:54:59 +00001445 Context.getTrivialTypeSourceInfo(VBase->getType(),
Douglas Gregor802ab452009-12-02 22:36:29 +00001446 SourceLocation()),
1447 Ctor,
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00001448 SourceLocation(),
Douglas Gregor802ab452009-12-02 22:36:29 +00001449 CtorArgs.takeAs<Expr>(),
1450 CtorArgs.size(),
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00001451 SourceLocation());
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001452 AllToInit.push_back(Member);
1453 }
1454 }
Mike Stump1eb44332009-09-09 15:08:12 +00001455
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001456 for (CXXRecordDecl::base_class_iterator Base =
1457 ClassDecl->bases_begin(),
1458 E = ClassDecl->bases_end(); Base != E; ++Base) {
1459 // Virtuals are in the virtual base list and already constructed.
1460 if (Base->isVirtual())
1461 continue;
1462 // Skip dependent types.
1463 if (Base->getType()->isDependentType())
1464 continue;
Douglas Gregorc07a4942009-11-15 08:51:10 +00001465 if (CXXBaseOrMemberInitializer *Value
1466 = AllBaseFields.lookup(Base->getType()->getAs<RecordType>())) {
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001467 AllToInit.push_back(Value);
Fariborz Jahanian9d436202009-09-03 21:32:41 +00001468 }
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001469 else {
Mike Stump1eb44332009-09-09 15:08:12 +00001470 CXXRecordDecl *BaseDecl =
Fariborz Jahanian9d436202009-09-03 21:32:41 +00001471 cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00001472 assert(BaseDecl && "SetBaseOrMemberInitializers - BaseDecl null");
Fariborz Jahanian9d436202009-09-03 21:32:41 +00001473 CXXConstructorDecl *Ctor = BaseDecl->getDefaultConstructor(Context);
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00001474 if (!Ctor) {
Eli Friedman49c16da2009-11-09 01:05:47 +00001475 Diag(Constructor->getLocation(), diag::err_missing_default_ctor)
1476 << (int)IsImplicitConstructor << Context.getTagDeclType(ClassDecl)
1477 << 0 << Base->getType();
Douglas Gregor9af2f522009-12-01 16:58:18 +00001478 Diag(BaseDecl->getLocation(), diag::note_previous_decl)
Eli Friedman49c16da2009-11-09 01:05:47 +00001479 << Context.getTagDeclType(BaseDecl);
Eli Friedman80c30da2009-11-09 19:20:36 +00001480 HadError = true;
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00001481 continue;
1482 }
1483
1484 ASTOwningVector<&ActionBase::DeleteExpr> CtorArgs(*this);
1485 if (CompleteConstructorCall(Ctor, MultiExprArg(*this, 0, 0),
1486 Constructor->getLocation(), CtorArgs))
1487 continue;
1488
1489 MarkDeclarationReferenced(Constructor->getLocation(), Ctor);
Fariborz Jahanian9d436202009-09-03 21:32:41 +00001490
Anders Carlsson8db68da2009-11-13 20:11:49 +00001491 // FIXME: CXXBaseOrMemberInitializer should only contain a single
Douglas Gregor802ab452009-12-02 22:36:29 +00001492 // subexpression so we can wrap it in a CXXExprWithTemporaries if
1493 // necessary.
1494 // FIXME: Is there any better source-location information we can give?
Anders Carlsson8db68da2009-11-13 20:11:49 +00001495 ExprTemporaries.clear();
Mike Stump1eb44332009-09-09 15:08:12 +00001496 CXXBaseOrMemberInitializer *Member =
Douglas Gregor802ab452009-12-02 22:36:29 +00001497 new (Context) CXXBaseOrMemberInitializer(Context,
John McCalla93c9342009-12-07 02:54:59 +00001498 Context.getTrivialTypeSourceInfo(Base->getType(),
Douglas Gregor802ab452009-12-02 22:36:29 +00001499 SourceLocation()),
1500 Ctor,
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00001501 SourceLocation(),
Douglas Gregor802ab452009-12-02 22:36:29 +00001502 CtorArgs.takeAs<Expr>(),
1503 CtorArgs.size(),
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00001504 SourceLocation());
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001505 AllToInit.push_back(Member);
1506 }
1507 }
1508 }
Mike Stump1eb44332009-09-09 15:08:12 +00001509
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001510 // non-static data members.
1511 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
1512 E = ClassDecl->field_end(); Field != E; ++Field) {
1513 if ((*Field)->isAnonymousStructOrUnion()) {
Mike Stump1eb44332009-09-09 15:08:12 +00001514 if (const RecordType *FieldClassType =
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001515 Field->getType()->getAs<RecordType>()) {
1516 CXXRecordDecl *FieldClassDecl
Douglas Gregorafe7ec22009-11-13 18:34:26 +00001517 = cast<CXXRecordDecl>(FieldClassType->getDecl());
Mike Stump1eb44332009-09-09 15:08:12 +00001518 for (RecordDecl::field_iterator FA = FieldClassDecl->field_begin(),
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001519 EA = FieldClassDecl->field_end(); FA != EA; FA++) {
1520 if (CXXBaseOrMemberInitializer *Value = AllBaseFields.lookup(*FA)) {
1521 // 'Member' is the anonymous union field and 'AnonUnionMember' is
1522 // set to the anonymous union data member used in the initializer
1523 // list.
1524 Value->setMember(*Field);
1525 Value->setAnonUnionMember(*FA);
1526 AllToInit.push_back(Value);
1527 break;
1528 }
1529 }
1530 }
1531 continue;
1532 }
1533 if (CXXBaseOrMemberInitializer *Value = AllBaseFields.lookup(*Field)) {
1534 AllToInit.push_back(Value);
1535 continue;
1536 }
Mike Stump1eb44332009-09-09 15:08:12 +00001537
Eli Friedman49c16da2009-11-09 01:05:47 +00001538 if ((*Field)->getType()->isDependentType())
Douglas Gregor1fe6b912009-11-04 17:16:11 +00001539 continue;
Douglas Gregor1fe6b912009-11-04 17:16:11 +00001540
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001541 QualType FT = Context.getBaseElementType((*Field)->getType());
1542 if (const RecordType* RT = FT->getAs<RecordType>()) {
1543 CXXConstructorDecl *Ctor =
1544 cast<CXXRecordDecl>(RT->getDecl())->getDefaultConstructor(Context);
Douglas Gregor1fe6b912009-11-04 17:16:11 +00001545 if (!Ctor) {
Eli Friedman49c16da2009-11-09 01:05:47 +00001546 Diag(Constructor->getLocation(), diag::err_missing_default_ctor)
1547 << (int)IsImplicitConstructor << Context.getTagDeclType(ClassDecl)
1548 << 1 << (*Field)->getDeclName();
1549 Diag(Field->getLocation(), diag::note_field_decl);
Douglas Gregor9af2f522009-12-01 16:58:18 +00001550 Diag(RT->getDecl()->getLocation(), diag::note_previous_decl)
Eli Friedman49c16da2009-11-09 01:05:47 +00001551 << Context.getTagDeclType(RT->getDecl());
Eli Friedman80c30da2009-11-09 19:20:36 +00001552 HadError = true;
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00001553 continue;
1554 }
Eli Friedmane73d3bc2009-11-16 23:07:59 +00001555
1556 if (FT.isConstQualified() && Ctor->isTrivial()) {
1557 Diag(Constructor->getLocation(), diag::err_unintialized_member_in_ctor)
1558 << (int)IsImplicitConstructor << Context.getTagDeclType(ClassDecl)
1559 << 1 << (*Field)->getDeclName();
1560 Diag((*Field)->getLocation(), diag::note_declared_at);
1561 HadError = true;
1562 }
1563
1564 // Don't create initializers for trivial constructors, since they don't
1565 // actually need to be run.
1566 if (Ctor->isTrivial())
1567 continue;
1568
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00001569 ASTOwningVector<&ActionBase::DeleteExpr> CtorArgs(*this);
1570 if (CompleteConstructorCall(Ctor, MultiExprArg(*this, 0, 0),
1571 Constructor->getLocation(), CtorArgs))
1572 continue;
1573
Anders Carlsson8db68da2009-11-13 20:11:49 +00001574 // FIXME: CXXBaseOrMemberInitializer should only contain a single
1575 // subexpression so we can wrap it in a CXXExprWithTemporaries if necessary.
1576 ExprTemporaries.clear();
Mike Stump1eb44332009-09-09 15:08:12 +00001577 CXXBaseOrMemberInitializer *Member =
Douglas Gregor802ab452009-12-02 22:36:29 +00001578 new (Context) CXXBaseOrMemberInitializer(Context,
1579 *Field, SourceLocation(),
1580 Ctor,
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00001581 SourceLocation(),
Douglas Gregor802ab452009-12-02 22:36:29 +00001582 CtorArgs.takeAs<Expr>(),
1583 CtorArgs.size(),
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00001584 SourceLocation());
1585
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001586 AllToInit.push_back(Member);
Eli Friedman49c16da2009-11-09 01:05:47 +00001587 MarkDeclarationReferenced(Constructor->getLocation(), Ctor);
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001588 }
1589 else if (FT->isReferenceType()) {
1590 Diag(Constructor->getLocation(), diag::err_unintialized_member_in_ctor)
Eli Friedman49c16da2009-11-09 01:05:47 +00001591 << (int)IsImplicitConstructor << Context.getTagDeclType(ClassDecl)
1592 << 0 << (*Field)->getDeclName();
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001593 Diag((*Field)->getLocation(), diag::note_declared_at);
Eli Friedman80c30da2009-11-09 19:20:36 +00001594 HadError = true;
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001595 }
1596 else if (FT.isConstQualified()) {
1597 Diag(Constructor->getLocation(), diag::err_unintialized_member_in_ctor)
Eli Friedman49c16da2009-11-09 01:05:47 +00001598 << (int)IsImplicitConstructor << Context.getTagDeclType(ClassDecl)
1599 << 1 << (*Field)->getDeclName();
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001600 Diag((*Field)->getLocation(), diag::note_declared_at);
Eli Friedman80c30da2009-11-09 19:20:36 +00001601 HadError = true;
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001602 }
1603 }
Mike Stump1eb44332009-09-09 15:08:12 +00001604
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001605 NumInitializers = AllToInit.size();
1606 if (NumInitializers > 0) {
1607 Constructor->setNumBaseOrMemberInitializers(NumInitializers);
1608 CXXBaseOrMemberInitializer **baseOrMemberInitializers =
1609 new (Context) CXXBaseOrMemberInitializer*[NumInitializers];
Mike Stump1eb44332009-09-09 15:08:12 +00001610
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001611 Constructor->setBaseOrMemberInitializers(baseOrMemberInitializers);
1612 for (unsigned Idx = 0; Idx < NumInitializers; ++Idx)
1613 baseOrMemberInitializers[Idx] = AllToInit[Idx];
1614 }
Eli Friedman80c30da2009-11-09 19:20:36 +00001615
1616 return HadError;
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001617}
1618
Eli Friedman6347f422009-07-21 19:28:10 +00001619static void *GetKeyForTopLevelField(FieldDecl *Field) {
1620 // For anonymous unions, use the class declaration as the key.
Ted Kremenek6217b802009-07-29 21:53:49 +00001621 if (const RecordType *RT = Field->getType()->getAs<RecordType>()) {
Eli Friedman6347f422009-07-21 19:28:10 +00001622 if (RT->getDecl()->isAnonymousStructOrUnion())
1623 return static_cast<void *>(RT->getDecl());
1624 }
1625 return static_cast<void *>(Field);
1626}
1627
Anders Carlssoncdc83c72009-09-01 06:22:14 +00001628static void *GetKeyForBase(QualType BaseType) {
1629 if (const RecordType *RT = BaseType->getAs<RecordType>())
1630 return (void *)RT;
Mike Stump1eb44332009-09-09 15:08:12 +00001631
Anders Carlssoncdc83c72009-09-01 06:22:14 +00001632 assert(0 && "Unexpected base type!");
1633 return 0;
1634}
1635
Mike Stump1eb44332009-09-09 15:08:12 +00001636static void *GetKeyForMember(CXXBaseOrMemberInitializer *Member,
Anders Carlssoncdc83c72009-09-01 06:22:14 +00001637 bool MemberMaybeAnon = false) {
Eli Friedman6347f422009-07-21 19:28:10 +00001638 // For fields injected into the class via declaration of an anonymous union,
1639 // use its anonymous union class declaration as the unique key.
Anders Carlssoncdc83c72009-09-01 06:22:14 +00001640 if (Member->isMemberInitializer()) {
1641 FieldDecl *Field = Member->getMember();
Mike Stump1eb44332009-09-09 15:08:12 +00001642
Eli Friedman49c16da2009-11-09 01:05:47 +00001643 // After SetBaseOrMemberInitializers call, Field is the anonymous union
Mike Stump1eb44332009-09-09 15:08:12 +00001644 // data member of the class. Data member used in the initializer list is
Fariborz Jahaniane6494122009-08-11 18:49:54 +00001645 // in AnonUnionMember field.
1646 if (MemberMaybeAnon && Field->isAnonymousStructOrUnion())
1647 Field = Member->getAnonUnionMember();
Eli Friedman6347f422009-07-21 19:28:10 +00001648 if (Field->getDeclContext()->isRecord()) {
1649 RecordDecl *RD = cast<RecordDecl>(Field->getDeclContext());
1650 if (RD->isAnonymousStructOrUnion())
1651 return static_cast<void *>(RD);
1652 }
1653 return static_cast<void *>(Field);
1654 }
Mike Stump1eb44332009-09-09 15:08:12 +00001655
Anders Carlssoncdc83c72009-09-01 06:22:14 +00001656 return GetKeyForBase(QualType(Member->getBaseClass(), 0));
Eli Friedman6347f422009-07-21 19:28:10 +00001657}
1658
John McCall6aee6212009-11-04 23:13:52 +00001659/// ActOnMemInitializers - Handle the member initializers for a constructor.
Mike Stump1eb44332009-09-09 15:08:12 +00001660void Sema::ActOnMemInitializers(DeclPtrTy ConstructorDecl,
Anders Carlssona7b35212009-03-25 02:58:17 +00001661 SourceLocation ColonLoc,
1662 MemInitTy **MemInits, unsigned NumMemInits) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +00001663 if (!ConstructorDecl)
1664 return;
Douglas Gregorefd5bda2009-08-24 11:57:43 +00001665
1666 AdjustDeclIfTemplate(ConstructorDecl);
Mike Stump1eb44332009-09-09 15:08:12 +00001667
1668 CXXConstructorDecl *Constructor
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +00001669 = dyn_cast<CXXConstructorDecl>(ConstructorDecl.getAs<Decl>());
Mike Stump1eb44332009-09-09 15:08:12 +00001670
Anders Carlssona7b35212009-03-25 02:58:17 +00001671 if (!Constructor) {
1672 Diag(ColonLoc, diag::err_only_constructors_take_base_inits);
1673 return;
1674 }
Mike Stump1eb44332009-09-09 15:08:12 +00001675
Anders Carlsson8d4c5ea2009-08-27 05:57:30 +00001676 if (!Constructor->isDependentContext()) {
1677 llvm::DenseMap<void*, CXXBaseOrMemberInitializer *>Members;
1678 bool err = false;
1679 for (unsigned i = 0; i < NumMemInits; i++) {
Mike Stump1eb44332009-09-09 15:08:12 +00001680 CXXBaseOrMemberInitializer *Member =
Anders Carlsson8d4c5ea2009-08-27 05:57:30 +00001681 static_cast<CXXBaseOrMemberInitializer*>(MemInits[i]);
1682 void *KeyToMember = GetKeyForMember(Member);
1683 CXXBaseOrMemberInitializer *&PrevMember = Members[KeyToMember];
1684 if (!PrevMember) {
1685 PrevMember = Member;
1686 continue;
1687 }
1688 if (FieldDecl *Field = Member->getMember())
Mike Stump1eb44332009-09-09 15:08:12 +00001689 Diag(Member->getSourceLocation(),
Anders Carlsson8d4c5ea2009-08-27 05:57:30 +00001690 diag::error_multiple_mem_initialization)
Douglas Gregor802ab452009-12-02 22:36:29 +00001691 << Field->getNameAsString()
1692 << Member->getSourceRange();
Anders Carlsson8d4c5ea2009-08-27 05:57:30 +00001693 else {
1694 Type *BaseClass = Member->getBaseClass();
1695 assert(BaseClass && "ActOnMemInitializers - neither field or base");
Mike Stump1eb44332009-09-09 15:08:12 +00001696 Diag(Member->getSourceLocation(),
Anders Carlsson8d4c5ea2009-08-27 05:57:30 +00001697 diag::error_multiple_base_initialization)
Douglas Gregor802ab452009-12-02 22:36:29 +00001698 << QualType(BaseClass, 0)
1699 << Member->getSourceRange();
Anders Carlsson8d4c5ea2009-08-27 05:57:30 +00001700 }
1701 Diag(PrevMember->getSourceLocation(), diag::note_previous_initializer)
1702 << 0;
1703 err = true;
1704 }
Mike Stump1eb44332009-09-09 15:08:12 +00001705
Anders Carlsson8d4c5ea2009-08-27 05:57:30 +00001706 if (err)
1707 return;
1708 }
Mike Stump1eb44332009-09-09 15:08:12 +00001709
Eli Friedman49c16da2009-11-09 01:05:47 +00001710 SetBaseOrMemberInitializers(Constructor,
Mike Stump1eb44332009-09-09 15:08:12 +00001711 reinterpret_cast<CXXBaseOrMemberInitializer **>(MemInits),
Eli Friedman49c16da2009-11-09 01:05:47 +00001712 NumMemInits, false);
Mike Stump1eb44332009-09-09 15:08:12 +00001713
Anders Carlsson8d4c5ea2009-08-27 05:57:30 +00001714 if (Constructor->isDependentContext())
1715 return;
Mike Stump1eb44332009-09-09 15:08:12 +00001716
1717 if (Diags.getDiagnosticLevel(diag::warn_base_initialized) ==
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001718 Diagnostic::Ignored &&
Mike Stump1eb44332009-09-09 15:08:12 +00001719 Diags.getDiagnosticLevel(diag::warn_field_initialized) ==
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001720 Diagnostic::Ignored)
1721 return;
Mike Stump1eb44332009-09-09 15:08:12 +00001722
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001723 // Also issue warning if order of ctor-initializer list does not match order
1724 // of 1) base class declarations and 2) order of non-static data members.
1725 llvm::SmallVector<const void*, 32> AllBaseOrMembers;
Mike Stump1eb44332009-09-09 15:08:12 +00001726
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001727 CXXRecordDecl *ClassDecl
1728 = cast<CXXRecordDecl>(Constructor->getDeclContext());
1729 // Push virtual bases before others.
1730 for (CXXRecordDecl::base_class_iterator VBase =
1731 ClassDecl->vbases_begin(),
1732 E = ClassDecl->vbases_end(); VBase != E; ++VBase)
Anders Carlssoncdc83c72009-09-01 06:22:14 +00001733 AllBaseOrMembers.push_back(GetKeyForBase(VBase->getType()));
Mike Stump1eb44332009-09-09 15:08:12 +00001734
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001735 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
1736 E = ClassDecl->bases_end(); Base != E; ++Base) {
1737 // Virtuals are alread in the virtual base list and are constructed
1738 // first.
1739 if (Base->isVirtual())
1740 continue;
Anders Carlssoncdc83c72009-09-01 06:22:14 +00001741 AllBaseOrMembers.push_back(GetKeyForBase(Base->getType()));
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001742 }
Mike Stump1eb44332009-09-09 15:08:12 +00001743
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001744 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
1745 E = ClassDecl->field_end(); Field != E; ++Field)
1746 AllBaseOrMembers.push_back(GetKeyForTopLevelField(*Field));
Mike Stump1eb44332009-09-09 15:08:12 +00001747
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001748 int Last = AllBaseOrMembers.size();
1749 int curIndex = 0;
1750 CXXBaseOrMemberInitializer *PrevMember = 0;
1751 for (unsigned i = 0; i < NumMemInits; i++) {
Mike Stump1eb44332009-09-09 15:08:12 +00001752 CXXBaseOrMemberInitializer *Member =
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001753 static_cast<CXXBaseOrMemberInitializer*>(MemInits[i]);
1754 void *MemberInCtorList = GetKeyForMember(Member, true);
Eli Friedman6347f422009-07-21 19:28:10 +00001755
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001756 for (; curIndex < Last; curIndex++)
1757 if (MemberInCtorList == AllBaseOrMembers[curIndex])
1758 break;
1759 if (curIndex == Last) {
1760 assert(PrevMember && "Member not in member list?!");
1761 // Initializer as specified in ctor-initializer list is out of order.
1762 // Issue a warning diagnostic.
1763 if (PrevMember->isBaseInitializer()) {
1764 // Diagnostics is for an initialized base class.
1765 Type *BaseClass = PrevMember->getBaseClass();
1766 Diag(PrevMember->getSourceLocation(),
Mike Stump1eb44332009-09-09 15:08:12 +00001767 diag::warn_base_initialized)
John McCallbf1cc052009-09-29 23:03:30 +00001768 << QualType(BaseClass, 0);
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001769 } else {
1770 FieldDecl *Field = PrevMember->getMember();
1771 Diag(PrevMember->getSourceLocation(),
Mike Stump1eb44332009-09-09 15:08:12 +00001772 diag::warn_field_initialized)
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001773 << Field->getNameAsString();
Fariborz Jahanianeb96e122009-07-09 19:59:47 +00001774 }
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001775 // Also the note!
1776 if (FieldDecl *Field = Member->getMember())
Mike Stump1eb44332009-09-09 15:08:12 +00001777 Diag(Member->getSourceLocation(),
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001778 diag::note_fieldorbase_initialized_here) << 0
1779 << Field->getNameAsString();
1780 else {
1781 Type *BaseClass = Member->getBaseClass();
Mike Stump1eb44332009-09-09 15:08:12 +00001782 Diag(Member->getSourceLocation(),
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001783 diag::note_fieldorbase_initialized_here) << 1
John McCallbf1cc052009-09-29 23:03:30 +00001784 << QualType(BaseClass, 0);
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001785 }
1786 for (curIndex = 0; curIndex < Last; curIndex++)
Mike Stump1eb44332009-09-09 15:08:12 +00001787 if (MemberInCtorList == AllBaseOrMembers[curIndex])
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001788 break;
Fariborz Jahanianeb96e122009-07-09 19:59:47 +00001789 }
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001790 PrevMember = Member;
Fariborz Jahanianeb96e122009-07-09 19:59:47 +00001791 }
Anders Carlssona7b35212009-03-25 02:58:17 +00001792}
1793
Fariborz Jahanian34374e62009-09-03 23:18:17 +00001794void
Anders Carlsson9f853df2009-11-17 04:44:12 +00001795Sema::MarkBaseAndMemberDestructorsReferenced(CXXDestructorDecl *Destructor) {
1796 // Ignore dependent destructors.
1797 if (Destructor->isDependentContext())
1798 return;
1799
1800 CXXRecordDecl *ClassDecl = Destructor->getParent();
Mike Stump1eb44332009-09-09 15:08:12 +00001801
Anders Carlsson9f853df2009-11-17 04:44:12 +00001802 // Non-static data members.
1803 for (CXXRecordDecl::field_iterator I = ClassDecl->field_begin(),
1804 E = ClassDecl->field_end(); I != E; ++I) {
1805 FieldDecl *Field = *I;
1806
1807 QualType FieldType = Context.getBaseElementType(Field->getType());
1808
1809 const RecordType* RT = FieldType->getAs<RecordType>();
1810 if (!RT)
1811 continue;
1812
1813 CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl());
1814 if (FieldClassDecl->hasTrivialDestructor())
1815 continue;
1816
1817 const CXXDestructorDecl *Dtor = FieldClassDecl->getDestructor(Context);
1818 MarkDeclarationReferenced(Destructor->getLocation(),
1819 const_cast<CXXDestructorDecl*>(Dtor));
1820 }
1821
1822 // Bases.
1823 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
1824 E = ClassDecl->bases_end(); Base != E; ++Base) {
1825 // Ignore virtual bases.
1826 if (Base->isVirtual())
1827 continue;
1828
1829 // Ignore trivial destructors.
1830 CXXRecordDecl *BaseClassDecl
1831 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
1832 if (BaseClassDecl->hasTrivialDestructor())
1833 continue;
1834
1835 const CXXDestructorDecl *Dtor = BaseClassDecl->getDestructor(Context);
1836 MarkDeclarationReferenced(Destructor->getLocation(),
1837 const_cast<CXXDestructorDecl*>(Dtor));
1838 }
1839
1840 // Virtual bases.
Fariborz Jahanian34374e62009-09-03 23:18:17 +00001841 for (CXXRecordDecl::base_class_iterator VBase = ClassDecl->vbases_begin(),
1842 E = ClassDecl->vbases_end(); VBase != E; ++VBase) {
Anders Carlsson9f853df2009-11-17 04:44:12 +00001843 // Ignore trivial destructors.
Fariborz Jahanian34374e62009-09-03 23:18:17 +00001844 CXXRecordDecl *BaseClassDecl
1845 = cast<CXXRecordDecl>(VBase->getType()->getAs<RecordType>()->getDecl());
1846 if (BaseClassDecl->hasTrivialDestructor())
1847 continue;
Anders Carlsson9f853df2009-11-17 04:44:12 +00001848
1849 const CXXDestructorDecl *Dtor = BaseClassDecl->getDestructor(Context);
1850 MarkDeclarationReferenced(Destructor->getLocation(),
1851 const_cast<CXXDestructorDecl*>(Dtor));
Fariborz Jahanian34374e62009-09-03 23:18:17 +00001852 }
1853}
1854
Fariborz Jahanian393612e2009-07-21 22:36:06 +00001855void Sema::ActOnDefaultCtorInitializers(DeclPtrTy CDtorDecl) {
Fariborz Jahanian560de452009-07-15 22:34:08 +00001856 if (!CDtorDecl)
Fariborz Jahaniand01c9152009-07-14 18:24:21 +00001857 return;
Mike Stump1eb44332009-09-09 15:08:12 +00001858
Douglas Gregorefd5bda2009-08-24 11:57:43 +00001859 AdjustDeclIfTemplate(CDtorDecl);
Mike Stump1eb44332009-09-09 15:08:12 +00001860
1861 if (CXXConstructorDecl *Constructor
Fariborz Jahanian560de452009-07-15 22:34:08 +00001862 = dyn_cast<CXXConstructorDecl>(CDtorDecl.getAs<Decl>()))
Eli Friedman49c16da2009-11-09 01:05:47 +00001863 SetBaseOrMemberInitializers(Constructor, 0, 0, false);
Fariborz Jahaniand01c9152009-07-14 18:24:21 +00001864}
1865
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001866namespace {
1867 /// PureVirtualMethodCollector - traverses a class and its superclasses
1868 /// and determines if it has any pure virtual methods.
Benjamin Kramer85b45212009-11-28 19:45:26 +00001869 class PureVirtualMethodCollector {
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001870 ASTContext &Context;
1871
Sebastian Redldfe292d2009-03-22 21:28:55 +00001872 public:
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001873 typedef llvm::SmallVector<const CXXMethodDecl*, 8> MethodList;
Sebastian Redldfe292d2009-03-22 21:28:55 +00001874
1875 private:
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001876 MethodList Methods;
Mike Stump1eb44332009-09-09 15:08:12 +00001877
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001878 void Collect(const CXXRecordDecl* RD, MethodList& Methods);
Mike Stump1eb44332009-09-09 15:08:12 +00001879
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001880 public:
Mike Stump1eb44332009-09-09 15:08:12 +00001881 PureVirtualMethodCollector(ASTContext &Ctx, const CXXRecordDecl* RD)
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001882 : Context(Ctx) {
Mike Stump1eb44332009-09-09 15:08:12 +00001883
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001884 MethodList List;
1885 Collect(RD, List);
Mike Stump1eb44332009-09-09 15:08:12 +00001886
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001887 // Copy the temporary list to methods, and make sure to ignore any
1888 // null entries.
1889 for (size_t i = 0, e = List.size(); i != e; ++i) {
1890 if (List[i])
1891 Methods.push_back(List[i]);
Mike Stump1eb44332009-09-09 15:08:12 +00001892 }
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001893 }
Mike Stump1eb44332009-09-09 15:08:12 +00001894
Anders Carlsson4681ebd2009-03-22 20:18:17 +00001895 bool empty() const { return Methods.empty(); }
Mike Stump1eb44332009-09-09 15:08:12 +00001896
Anders Carlsson4681ebd2009-03-22 20:18:17 +00001897 MethodList::const_iterator methods_begin() { return Methods.begin(); }
1898 MethodList::const_iterator methods_end() { return Methods.end(); }
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001899 };
Mike Stump1eb44332009-09-09 15:08:12 +00001900
1901 void PureVirtualMethodCollector::Collect(const CXXRecordDecl* RD,
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001902 MethodList& Methods) {
1903 // First, collect the pure virtual methods for the base classes.
1904 for (CXXRecordDecl::base_class_const_iterator Base = RD->bases_begin(),
1905 BaseEnd = RD->bases_end(); Base != BaseEnd; ++Base) {
Ted Kremenek6217b802009-07-29 21:53:49 +00001906 if (const RecordType *RT = Base->getType()->getAs<RecordType>()) {
Chris Lattner64540d72009-03-29 05:01:10 +00001907 const CXXRecordDecl *BaseDecl = cast<CXXRecordDecl>(RT->getDecl());
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001908 if (BaseDecl && BaseDecl->isAbstract())
1909 Collect(BaseDecl, Methods);
1910 }
1911 }
Mike Stump1eb44332009-09-09 15:08:12 +00001912
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001913 // Next, zero out any pure virtual methods that this class overrides.
Anders Carlsson8ff8c222009-05-17 00:00:05 +00001914 typedef llvm::SmallPtrSet<const CXXMethodDecl*, 4> MethodSetTy;
Mike Stump1eb44332009-09-09 15:08:12 +00001915
Anders Carlsson8ff8c222009-05-17 00:00:05 +00001916 MethodSetTy OverriddenMethods;
1917 size_t MethodsSize = Methods.size();
1918
Mike Stump1eb44332009-09-09 15:08:12 +00001919 for (RecordDecl::decl_iterator i = RD->decls_begin(), e = RD->decls_end();
Anders Carlsson8ff8c222009-05-17 00:00:05 +00001920 i != e; ++i) {
1921 // Traverse the record, looking for methods.
1922 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(*i)) {
Sebastian Redl23c7d062009-07-07 20:29:57 +00001923 // If the method is pure virtual, add it to the methods vector.
Anders Carlsson27823022009-10-18 19:34:08 +00001924 if (MD->isPure())
Anders Carlsson8ff8c222009-05-17 00:00:05 +00001925 Methods.push_back(MD);
Mike Stump1eb44332009-09-09 15:08:12 +00001926
Anders Carlsson27823022009-10-18 19:34:08 +00001927 // Record all the overridden methods in our set.
Anders Carlsson8ff8c222009-05-17 00:00:05 +00001928 for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(),
1929 E = MD->end_overridden_methods(); I != E; ++I) {
1930 // Keep track of the overridden methods.
1931 OverriddenMethods.insert(*I);
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001932 }
1933 }
1934 }
Mike Stump1eb44332009-09-09 15:08:12 +00001935
1936 // Now go through the methods and zero out all the ones we know are
Anders Carlsson8ff8c222009-05-17 00:00:05 +00001937 // overridden.
1938 for (size_t i = 0, e = MethodsSize; i != e; ++i) {
1939 if (OverriddenMethods.count(Methods[i]))
1940 Methods[i] = 0;
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001941 }
Mike Stump1eb44332009-09-09 15:08:12 +00001942
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001943 }
1944}
Douglas Gregor7ad83902008-11-05 04:29:56 +00001945
Anders Carlssona6ec7ad2009-08-27 00:13:57 +00001946
Mike Stump1eb44332009-09-09 15:08:12 +00001947bool Sema::RequireNonAbstractType(SourceLocation Loc, QualType T,
Anders Carlssone65a3c82009-03-24 17:23:42 +00001948 unsigned DiagID, AbstractDiagSelID SelID,
1949 const CXXRecordDecl *CurrentRD) {
Anders Carlssona6ec7ad2009-08-27 00:13:57 +00001950 if (SelID == -1)
1951 return RequireNonAbstractType(Loc, T,
1952 PDiag(DiagID), CurrentRD);
1953 else
1954 return RequireNonAbstractType(Loc, T,
1955 PDiag(DiagID) << SelID, CurrentRD);
Mike Stump1eb44332009-09-09 15:08:12 +00001956}
1957
Anders Carlssona6ec7ad2009-08-27 00:13:57 +00001958bool Sema::RequireNonAbstractType(SourceLocation Loc, QualType T,
1959 const PartialDiagnostic &PD,
1960 const CXXRecordDecl *CurrentRD) {
Anders Carlsson4681ebd2009-03-22 20:18:17 +00001961 if (!getLangOptions().CPlusPlus)
1962 return false;
Mike Stump1eb44332009-09-09 15:08:12 +00001963
Anders Carlsson11f21a02009-03-23 19:10:31 +00001964 if (const ArrayType *AT = Context.getAsArrayType(T))
Anders Carlssona6ec7ad2009-08-27 00:13:57 +00001965 return RequireNonAbstractType(Loc, AT->getElementType(), PD,
Anders Carlssone65a3c82009-03-24 17:23:42 +00001966 CurrentRD);
Mike Stump1eb44332009-09-09 15:08:12 +00001967
Ted Kremenek6217b802009-07-29 21:53:49 +00001968 if (const PointerType *PT = T->getAs<PointerType>()) {
Anders Carlsson5eff73c2009-03-24 01:46:45 +00001969 // Find the innermost pointer type.
Ted Kremenek6217b802009-07-29 21:53:49 +00001970 while (const PointerType *T = PT->getPointeeType()->getAs<PointerType>())
Anders Carlsson5eff73c2009-03-24 01:46:45 +00001971 PT = T;
Mike Stump1eb44332009-09-09 15:08:12 +00001972
Anders Carlsson5eff73c2009-03-24 01:46:45 +00001973 if (const ArrayType *AT = Context.getAsArrayType(PT->getPointeeType()))
Anders Carlssona6ec7ad2009-08-27 00:13:57 +00001974 return RequireNonAbstractType(Loc, AT->getElementType(), PD, CurrentRD);
Anders Carlsson5eff73c2009-03-24 01:46:45 +00001975 }
Mike Stump1eb44332009-09-09 15:08:12 +00001976
Ted Kremenek6217b802009-07-29 21:53:49 +00001977 const RecordType *RT = T->getAs<RecordType>();
Anders Carlsson4681ebd2009-03-22 20:18:17 +00001978 if (!RT)
1979 return false;
Mike Stump1eb44332009-09-09 15:08:12 +00001980
Anders Carlsson4681ebd2009-03-22 20:18:17 +00001981 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl());
1982 if (!RD)
1983 return false;
1984
Anders Carlssone65a3c82009-03-24 17:23:42 +00001985 if (CurrentRD && CurrentRD != RD)
1986 return false;
Mike Stump1eb44332009-09-09 15:08:12 +00001987
Anders Carlsson4681ebd2009-03-22 20:18:17 +00001988 if (!RD->isAbstract())
1989 return false;
Mike Stump1eb44332009-09-09 15:08:12 +00001990
Anders Carlssona6ec7ad2009-08-27 00:13:57 +00001991 Diag(Loc, PD) << RD->getDeclName();
Mike Stump1eb44332009-09-09 15:08:12 +00001992
Anders Carlsson4681ebd2009-03-22 20:18:17 +00001993 // Check if we've already emitted the list of pure virtual functions for this
1994 // class.
1995 if (PureVirtualClassDiagSet && PureVirtualClassDiagSet->count(RD))
1996 return true;
Mike Stump1eb44332009-09-09 15:08:12 +00001997
Anders Carlsson4681ebd2009-03-22 20:18:17 +00001998 PureVirtualMethodCollector Collector(Context, RD);
Mike Stump1eb44332009-09-09 15:08:12 +00001999
2000 for (PureVirtualMethodCollector::MethodList::const_iterator I =
Anders Carlsson4681ebd2009-03-22 20:18:17 +00002001 Collector.methods_begin(), E = Collector.methods_end(); I != E; ++I) {
2002 const CXXMethodDecl *MD = *I;
Mike Stump1eb44332009-09-09 15:08:12 +00002003
2004 Diag(MD->getLocation(), diag::note_pure_virtual_function) <<
Anders Carlsson4681ebd2009-03-22 20:18:17 +00002005 MD->getDeclName();
2006 }
2007
2008 if (!PureVirtualClassDiagSet)
2009 PureVirtualClassDiagSet.reset(new RecordDeclSetTy);
2010 PureVirtualClassDiagSet->insert(RD);
Mike Stump1eb44332009-09-09 15:08:12 +00002011
Anders Carlsson4681ebd2009-03-22 20:18:17 +00002012 return true;
2013}
2014
Anders Carlsson8211eff2009-03-24 01:19:16 +00002015namespace {
Benjamin Kramer85b45212009-11-28 19:45:26 +00002016 class AbstractClassUsageDiagnoser
Anders Carlsson8211eff2009-03-24 01:19:16 +00002017 : public DeclVisitor<AbstractClassUsageDiagnoser, bool> {
2018 Sema &SemaRef;
2019 CXXRecordDecl *AbstractClass;
Mike Stump1eb44332009-09-09 15:08:12 +00002020
Anders Carlssone65a3c82009-03-24 17:23:42 +00002021 bool VisitDeclContext(const DeclContext *DC) {
Anders Carlsson8211eff2009-03-24 01:19:16 +00002022 bool Invalid = false;
2023
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002024 for (CXXRecordDecl::decl_iterator I = DC->decls_begin(),
2025 E = DC->decls_end(); I != E; ++I)
Anders Carlsson8211eff2009-03-24 01:19:16 +00002026 Invalid |= Visit(*I);
Anders Carlssone65a3c82009-03-24 17:23:42 +00002027
Anders Carlsson8211eff2009-03-24 01:19:16 +00002028 return Invalid;
2029 }
Mike Stump1eb44332009-09-09 15:08:12 +00002030
Anders Carlssone65a3c82009-03-24 17:23:42 +00002031 public:
2032 AbstractClassUsageDiagnoser(Sema& SemaRef, CXXRecordDecl *ac)
2033 : SemaRef(SemaRef), AbstractClass(ac) {
2034 Visit(SemaRef.Context.getTranslationUnitDecl());
2035 }
Anders Carlsson8211eff2009-03-24 01:19:16 +00002036
Anders Carlssone65a3c82009-03-24 17:23:42 +00002037 bool VisitFunctionDecl(const FunctionDecl *FD) {
2038 if (FD->isThisDeclarationADefinition()) {
2039 // No need to do the check if we're in a definition, because it requires
2040 // that the return/param types are complete.
Mike Stump1eb44332009-09-09 15:08:12 +00002041 // because that requires
Anders Carlssone65a3c82009-03-24 17:23:42 +00002042 return VisitDeclContext(FD);
2043 }
Mike Stump1eb44332009-09-09 15:08:12 +00002044
Anders Carlssone65a3c82009-03-24 17:23:42 +00002045 // Check the return type.
John McCall183700f2009-09-21 23:43:11 +00002046 QualType RTy = FD->getType()->getAs<FunctionType>()->getResultType();
Mike Stump1eb44332009-09-09 15:08:12 +00002047 bool Invalid =
Anders Carlssone65a3c82009-03-24 17:23:42 +00002048 SemaRef.RequireNonAbstractType(FD->getLocation(), RTy,
2049 diag::err_abstract_type_in_decl,
2050 Sema::AbstractReturnType,
2051 AbstractClass);
2052
Mike Stump1eb44332009-09-09 15:08:12 +00002053 for (FunctionDecl::param_const_iterator I = FD->param_begin(),
Anders Carlssone65a3c82009-03-24 17:23:42 +00002054 E = FD->param_end(); I != E; ++I) {
Anders Carlsson8211eff2009-03-24 01:19:16 +00002055 const ParmVarDecl *VD = *I;
Mike Stump1eb44332009-09-09 15:08:12 +00002056 Invalid |=
Anders Carlsson8211eff2009-03-24 01:19:16 +00002057 SemaRef.RequireNonAbstractType(VD->getLocation(),
Mike Stump1eb44332009-09-09 15:08:12 +00002058 VD->getOriginalType(),
2059 diag::err_abstract_type_in_decl,
Anders Carlssone65a3c82009-03-24 17:23:42 +00002060 Sema::AbstractParamType,
2061 AbstractClass);
Anders Carlsson8211eff2009-03-24 01:19:16 +00002062 }
2063
2064 return Invalid;
2065 }
Mike Stump1eb44332009-09-09 15:08:12 +00002066
Anders Carlssone65a3c82009-03-24 17:23:42 +00002067 bool VisitDecl(const Decl* D) {
2068 if (const DeclContext *DC = dyn_cast<DeclContext>(D))
2069 return VisitDeclContext(DC);
Mike Stump1eb44332009-09-09 15:08:12 +00002070
Anders Carlssone65a3c82009-03-24 17:23:42 +00002071 return false;
2072 }
Anders Carlsson8211eff2009-03-24 01:19:16 +00002073 };
2074}
2075
Douglas Gregor1ab537b2009-12-03 18:33:45 +00002076/// \brief Perform semantic checks on a class definition that has been
2077/// completing, introducing implicitly-declared members, checking for
2078/// abstract types, etc.
2079void Sema::CheckCompletedCXXClass(CXXRecordDecl *Record) {
2080 if (!Record || Record->isInvalidDecl())
2081 return;
2082
Eli Friedmanff2d8782009-12-16 20:00:27 +00002083 if (!Record->isDependentType())
2084 AddImplicitlyDeclaredMembersToClass(Record);
Douglas Gregor159ef1e2010-01-06 04:44:19 +00002085
Eli Friedmanff2d8782009-12-16 20:00:27 +00002086 if (Record->isInvalidDecl())
2087 return;
2088
Douglas Gregor1ab537b2009-12-03 18:33:45 +00002089 if (!Record->isAbstract()) {
2090 // Collect all the pure virtual methods and see if this is an abstract
2091 // class after all.
2092 PureVirtualMethodCollector Collector(Context, Record);
2093 if (!Collector.empty())
2094 Record->setAbstract(true);
2095 }
2096
2097 if (Record->isAbstract())
2098 (void)AbstractClassUsageDiagnoser(*this, Record);
Douglas Gregor1ab537b2009-12-03 18:33:45 +00002099}
2100
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002101void Sema::ActOnFinishCXXMemberSpecification(Scope* S, SourceLocation RLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002102 DeclPtrTy TagDecl,
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002103 SourceLocation LBrac,
2104 SourceLocation RBrac) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +00002105 if (!TagDecl)
2106 return;
Mike Stump1eb44332009-09-09 15:08:12 +00002107
Douglas Gregor42af25f2009-05-11 19:58:34 +00002108 AdjustDeclIfTemplate(TagDecl);
Douglas Gregor1ab537b2009-12-03 18:33:45 +00002109
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002110 ActOnFields(S, RLoc, TagDecl,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002111 (DeclPtrTy*)FieldCollector->getCurFields(),
Daniel Dunbar1bfe1c22008-10-03 02:03:53 +00002112 FieldCollector->getCurNumFields(), LBrac, RBrac, 0);
Douglas Gregor2943aed2009-03-03 04:44:36 +00002113
Douglas Gregor1ab537b2009-12-03 18:33:45 +00002114 CheckCompletedCXXClass(
2115 dyn_cast_or_null<CXXRecordDecl>(TagDecl.getAs<Decl>()));
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002116}
2117
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002118/// AddImplicitlyDeclaredMembersToClass - Adds any implicitly-declared
2119/// special functions, such as the default constructor, copy
2120/// constructor, or destructor, to the given C++ class (C++
2121/// [special]p1). This routine can only be executed just before the
2122/// definition of the class is complete.
2123void Sema::AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl) {
Mike Stump1eb44332009-09-09 15:08:12 +00002124 CanQualType ClassType
Douglas Gregor50d62d12009-08-05 05:36:45 +00002125 = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
Douglas Gregor2e1cd422008-11-17 14:58:09 +00002126
Sebastian Redl465226e2009-05-27 22:11:52 +00002127 // FIXME: Implicit declarations have exception specifications, which are
2128 // the union of the specifications of the implicitly called functions.
2129
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002130 if (!ClassDecl->hasUserDeclaredConstructor()) {
2131 // C++ [class.ctor]p5:
2132 // A default constructor for a class X is a constructor of class X
2133 // that can be called without an argument. If there is no
2134 // user-declared constructor for class X, a default constructor is
2135 // implicitly declared. An implicitly-declared default constructor
2136 // is an inline public member of its class.
Mike Stump1eb44332009-09-09 15:08:12 +00002137 DeclarationName Name
Douglas Gregor2e1cd422008-11-17 14:58:09 +00002138 = Context.DeclarationNames.getCXXConstructorName(ClassType);
Mike Stump1eb44332009-09-09 15:08:12 +00002139 CXXConstructorDecl *DefaultCon =
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002140 CXXConstructorDecl::Create(Context, ClassDecl,
Douglas Gregor2e1cd422008-11-17 14:58:09 +00002141 ClassDecl->getLocation(), Name,
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002142 Context.getFunctionType(Context.VoidTy,
2143 0, 0, false, 0),
John McCalla93c9342009-12-07 02:54:59 +00002144 /*TInfo=*/0,
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002145 /*isExplicit=*/false,
2146 /*isInline=*/true,
2147 /*isImplicitlyDeclared=*/true);
2148 DefaultCon->setAccess(AS_public);
Douglas Gregor6b3945f2009-01-07 19:46:03 +00002149 DefaultCon->setImplicit();
Douglas Gregor1f2023a2009-07-22 18:25:24 +00002150 DefaultCon->setTrivial(ClassDecl->hasTrivialConstructor());
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002151 ClassDecl->addDecl(DefaultCon);
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002152 }
2153
2154 if (!ClassDecl->hasUserDeclaredCopyConstructor()) {
2155 // C++ [class.copy]p4:
2156 // If the class definition does not explicitly declare a copy
2157 // constructor, one is declared implicitly.
2158
2159 // C++ [class.copy]p5:
2160 // The implicitly-declared copy constructor for a class X will
2161 // have the form
2162 //
2163 // X::X(const X&)
2164 //
2165 // if
2166 bool HasConstCopyConstructor = true;
2167
2168 // -- each direct or virtual base class B of X has a copy
2169 // constructor whose first parameter is of type const B& or
2170 // const volatile B&, and
2171 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin();
2172 HasConstCopyConstructor && Base != ClassDecl->bases_end(); ++Base) {
2173 const CXXRecordDecl *BaseClassDecl
Ted Kremenek6217b802009-07-29 21:53:49 +00002174 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Mike Stump1eb44332009-09-09 15:08:12 +00002175 HasConstCopyConstructor
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002176 = BaseClassDecl->hasConstCopyConstructor(Context);
2177 }
2178
2179 // -- for all the nonstatic data members of X that are of a
2180 // class type M (or array thereof), each such class type
2181 // has a copy constructor whose first parameter is of type
2182 // const M& or const volatile M&.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002183 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin();
2184 HasConstCopyConstructor && Field != ClassDecl->field_end();
Douglas Gregor6ab35242009-04-09 21:40:53 +00002185 ++Field) {
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002186 QualType FieldType = (*Field)->getType();
2187 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
2188 FieldType = Array->getElementType();
Ted Kremenek6217b802009-07-29 21:53:49 +00002189 if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
Mike Stump1eb44332009-09-09 15:08:12 +00002190 const CXXRecordDecl *FieldClassDecl
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002191 = cast<CXXRecordDecl>(FieldClassType->getDecl());
Mike Stump1eb44332009-09-09 15:08:12 +00002192 HasConstCopyConstructor
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002193 = FieldClassDecl->hasConstCopyConstructor(Context);
2194 }
2195 }
2196
Sebastian Redl64b45f72009-01-05 20:52:13 +00002197 // Otherwise, the implicitly declared copy constructor will have
2198 // the form
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002199 //
2200 // X::X(X&)
Sebastian Redl64b45f72009-01-05 20:52:13 +00002201 QualType ArgType = ClassType;
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002202 if (HasConstCopyConstructor)
2203 ArgType = ArgType.withConst();
Sebastian Redl7c80bd62009-03-16 23:22:08 +00002204 ArgType = Context.getLValueReferenceType(ArgType);
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002205
Sebastian Redl64b45f72009-01-05 20:52:13 +00002206 // An implicitly-declared copy constructor is an inline public
2207 // member of its class.
Mike Stump1eb44332009-09-09 15:08:12 +00002208 DeclarationName Name
Douglas Gregor2e1cd422008-11-17 14:58:09 +00002209 = Context.DeclarationNames.getCXXConstructorName(ClassType);
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002210 CXXConstructorDecl *CopyConstructor
2211 = CXXConstructorDecl::Create(Context, ClassDecl,
Douglas Gregor2e1cd422008-11-17 14:58:09 +00002212 ClassDecl->getLocation(), Name,
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002213 Context.getFunctionType(Context.VoidTy,
2214 &ArgType, 1,
2215 false, 0),
John McCalla93c9342009-12-07 02:54:59 +00002216 /*TInfo=*/0,
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002217 /*isExplicit=*/false,
2218 /*isInline=*/true,
2219 /*isImplicitlyDeclared=*/true);
2220 CopyConstructor->setAccess(AS_public);
Douglas Gregor6b3945f2009-01-07 19:46:03 +00002221 CopyConstructor->setImplicit();
Douglas Gregor1f2023a2009-07-22 18:25:24 +00002222 CopyConstructor->setTrivial(ClassDecl->hasTrivialCopyConstructor());
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002223
2224 // Add the parameter to the constructor.
2225 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyConstructor,
2226 ClassDecl->getLocation(),
2227 /*IdentifierInfo=*/0,
John McCalla93c9342009-12-07 02:54:59 +00002228 ArgType, /*TInfo=*/0,
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +00002229 VarDecl::None, 0);
Ted Kremenekfc767612009-01-14 00:42:25 +00002230 CopyConstructor->setParams(Context, &FromParam, 1);
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002231 ClassDecl->addDecl(CopyConstructor);
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002232 }
2233
Sebastian Redl64b45f72009-01-05 20:52:13 +00002234 if (!ClassDecl->hasUserDeclaredCopyAssignment()) {
2235 // Note: The following rules are largely analoguous to the copy
2236 // constructor rules. Note that virtual bases are not taken into account
2237 // for determining the argument type of the operator. Note also that
2238 // operators taking an object instead of a reference are allowed.
2239 //
2240 // C++ [class.copy]p10:
2241 // If the class definition does not explicitly declare a copy
2242 // assignment operator, one is declared implicitly.
2243 // The implicitly-defined copy assignment operator for a class X
2244 // will have the form
2245 //
2246 // X& X::operator=(const X&)
2247 //
2248 // if
2249 bool HasConstCopyAssignment = true;
2250
2251 // -- each direct base class B of X has a copy assignment operator
2252 // whose parameter is of type const B&, const volatile B& or B,
2253 // and
2254 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin();
2255 HasConstCopyAssignment && Base != ClassDecl->bases_end(); ++Base) {
Sebastian Redl9994a342009-10-25 17:03:50 +00002256 assert(!Base->getType()->isDependentType() &&
2257 "Cannot generate implicit members for class with dependent bases.");
Sebastian Redl64b45f72009-01-05 20:52:13 +00002258 const CXXRecordDecl *BaseClassDecl
Ted Kremenek6217b802009-07-29 21:53:49 +00002259 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Fariborz Jahanian0270b8a2009-08-12 23:34:46 +00002260 const CXXMethodDecl *MD = 0;
Mike Stump1eb44332009-09-09 15:08:12 +00002261 HasConstCopyAssignment = BaseClassDecl->hasConstCopyAssignment(Context,
Fariborz Jahanian0270b8a2009-08-12 23:34:46 +00002262 MD);
Sebastian Redl64b45f72009-01-05 20:52:13 +00002263 }
2264
2265 // -- for all the nonstatic data members of X that are of a class
2266 // type M (or array thereof), each such class type has a copy
2267 // assignment operator whose parameter is of type const M&,
2268 // const volatile M& or M.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002269 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin();
2270 HasConstCopyAssignment && Field != ClassDecl->field_end();
Douglas Gregor6ab35242009-04-09 21:40:53 +00002271 ++Field) {
Sebastian Redl64b45f72009-01-05 20:52:13 +00002272 QualType FieldType = (*Field)->getType();
2273 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
2274 FieldType = Array->getElementType();
Ted Kremenek6217b802009-07-29 21:53:49 +00002275 if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
Sebastian Redl64b45f72009-01-05 20:52:13 +00002276 const CXXRecordDecl *FieldClassDecl
2277 = cast<CXXRecordDecl>(FieldClassType->getDecl());
Fariborz Jahanian0270b8a2009-08-12 23:34:46 +00002278 const CXXMethodDecl *MD = 0;
Sebastian Redl64b45f72009-01-05 20:52:13 +00002279 HasConstCopyAssignment
Fariborz Jahanian0270b8a2009-08-12 23:34:46 +00002280 = FieldClassDecl->hasConstCopyAssignment(Context, MD);
Sebastian Redl64b45f72009-01-05 20:52:13 +00002281 }
2282 }
2283
2284 // Otherwise, the implicitly declared copy assignment operator will
2285 // have the form
2286 //
2287 // X& X::operator=(X&)
2288 QualType ArgType = ClassType;
Sebastian Redl7c80bd62009-03-16 23:22:08 +00002289 QualType RetType = Context.getLValueReferenceType(ArgType);
Sebastian Redl64b45f72009-01-05 20:52:13 +00002290 if (HasConstCopyAssignment)
2291 ArgType = ArgType.withConst();
Sebastian Redl7c80bd62009-03-16 23:22:08 +00002292 ArgType = Context.getLValueReferenceType(ArgType);
Sebastian Redl64b45f72009-01-05 20:52:13 +00002293
2294 // An implicitly-declared copy assignment operator is an inline public
2295 // member of its class.
2296 DeclarationName Name =
2297 Context.DeclarationNames.getCXXOperatorName(OO_Equal);
2298 CXXMethodDecl *CopyAssignment =
2299 CXXMethodDecl::Create(Context, ClassDecl, ClassDecl->getLocation(), Name,
2300 Context.getFunctionType(RetType, &ArgType, 1,
2301 false, 0),
John McCalla93c9342009-12-07 02:54:59 +00002302 /*TInfo=*/0, /*isStatic=*/false, /*isInline=*/true);
Sebastian Redl64b45f72009-01-05 20:52:13 +00002303 CopyAssignment->setAccess(AS_public);
Douglas Gregor6b3945f2009-01-07 19:46:03 +00002304 CopyAssignment->setImplicit();
Douglas Gregor1f2023a2009-07-22 18:25:24 +00002305 CopyAssignment->setTrivial(ClassDecl->hasTrivialCopyAssignment());
Fariborz Jahanian2198ba12009-08-12 21:14:35 +00002306 CopyAssignment->setCopyAssignment(true);
Sebastian Redl64b45f72009-01-05 20:52:13 +00002307
2308 // Add the parameter to the operator.
2309 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyAssignment,
2310 ClassDecl->getLocation(),
2311 /*IdentifierInfo=*/0,
John McCalla93c9342009-12-07 02:54:59 +00002312 ArgType, /*TInfo=*/0,
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +00002313 VarDecl::None, 0);
Ted Kremenekfc767612009-01-14 00:42:25 +00002314 CopyAssignment->setParams(Context, &FromParam, 1);
Sebastian Redl64b45f72009-01-05 20:52:13 +00002315
2316 // Don't call addedAssignmentOperator. There is no way to distinguish an
2317 // implicit from an explicit assignment operator.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002318 ClassDecl->addDecl(CopyAssignment);
Eli Friedmanca6affd2009-12-02 06:59:20 +00002319 AddOverriddenMethods(ClassDecl, CopyAssignment);
Sebastian Redl64b45f72009-01-05 20:52:13 +00002320 }
2321
Douglas Gregor9e7d9de2008-12-15 21:24:18 +00002322 if (!ClassDecl->hasUserDeclaredDestructor()) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00002323 // C++ [class.dtor]p2:
2324 // If a class has no user-declared destructor, a destructor is
2325 // declared implicitly. An implicitly-declared destructor is an
2326 // inline public member of its class.
Mike Stump1eb44332009-09-09 15:08:12 +00002327 DeclarationName Name
Douglas Gregor2e1cd422008-11-17 14:58:09 +00002328 = Context.DeclarationNames.getCXXDestructorName(ClassType);
Mike Stump1eb44332009-09-09 15:08:12 +00002329 CXXDestructorDecl *Destructor
Douglas Gregor42a552f2008-11-05 20:51:48 +00002330 = CXXDestructorDecl::Create(Context, ClassDecl,
Douglas Gregor2e1cd422008-11-17 14:58:09 +00002331 ClassDecl->getLocation(), Name,
Douglas Gregor42a552f2008-11-05 20:51:48 +00002332 Context.getFunctionType(Context.VoidTy,
2333 0, 0, false, 0),
2334 /*isInline=*/true,
2335 /*isImplicitlyDeclared=*/true);
2336 Destructor->setAccess(AS_public);
Douglas Gregor6b3945f2009-01-07 19:46:03 +00002337 Destructor->setImplicit();
Douglas Gregor1f2023a2009-07-22 18:25:24 +00002338 Destructor->setTrivial(ClassDecl->hasTrivialDestructor());
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002339 ClassDecl->addDecl(Destructor);
Anders Carlssond5a942b2009-11-26 21:25:09 +00002340
2341 AddOverriddenMethods(ClassDecl, Destructor);
Douglas Gregor42a552f2008-11-05 20:51:48 +00002342 }
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002343}
2344
Douglas Gregor6569d682009-05-27 23:11:45 +00002345void Sema::ActOnReenterTemplateScope(Scope *S, DeclPtrTy TemplateD) {
Douglas Gregor1cdcc572009-09-10 00:12:48 +00002346 Decl *D = TemplateD.getAs<Decl>();
2347 if (!D)
2348 return;
2349
2350 TemplateParameterList *Params = 0;
2351 if (TemplateDecl *Template = dyn_cast<TemplateDecl>(D))
2352 Params = Template->getTemplateParameters();
2353 else if (ClassTemplatePartialSpecializationDecl *PartialSpec
2354 = dyn_cast<ClassTemplatePartialSpecializationDecl>(D))
2355 Params = PartialSpec->getTemplateParameters();
2356 else
Douglas Gregor6569d682009-05-27 23:11:45 +00002357 return;
2358
Douglas Gregor6569d682009-05-27 23:11:45 +00002359 for (TemplateParameterList::iterator Param = Params->begin(),
2360 ParamEnd = Params->end();
2361 Param != ParamEnd; ++Param) {
2362 NamedDecl *Named = cast<NamedDecl>(*Param);
2363 if (Named->getDeclName()) {
2364 S->AddDecl(DeclPtrTy::make(Named));
2365 IdResolver.AddDecl(Named);
2366 }
2367 }
2368}
2369
John McCall7a1dc562009-12-19 10:49:29 +00002370void Sema::ActOnStartDelayedMemberDeclarations(Scope *S, DeclPtrTy RecordD) {
2371 if (!RecordD) return;
2372 AdjustDeclIfTemplate(RecordD);
2373 CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordD.getAs<Decl>());
2374 PushDeclContext(S, Record);
2375}
2376
2377void Sema::ActOnFinishDelayedMemberDeclarations(Scope *S, DeclPtrTy RecordD) {
2378 if (!RecordD) return;
2379 PopDeclContext();
2380}
2381
Douglas Gregor72b505b2008-12-16 21:30:33 +00002382/// ActOnStartDelayedCXXMethodDeclaration - We have completed
2383/// parsing a top-level (non-nested) C++ class, and we are now
2384/// parsing those parts of the given Method declaration that could
2385/// not be parsed earlier (C++ [class.mem]p2), such as default
2386/// arguments. This action should enter the scope of the given
2387/// Method declaration as if we had just parsed the qualified method
2388/// name. However, it should not bring the parameters into scope;
2389/// that will be performed by ActOnDelayedCXXMethodParameter.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002390void Sema::ActOnStartDelayedCXXMethodDeclaration(Scope *S, DeclPtrTy MethodD) {
Douglas Gregor72b505b2008-12-16 21:30:33 +00002391}
2392
2393/// ActOnDelayedCXXMethodParameter - We've already started a delayed
2394/// C++ method declaration. We're (re-)introducing the given
2395/// function parameter into scope for use in parsing later parts of
2396/// the method declaration. For example, we could see an
2397/// ActOnParamDefaultArgument event for this parameter.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002398void Sema::ActOnDelayedCXXMethodParameter(Scope *S, DeclPtrTy ParamD) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +00002399 if (!ParamD)
2400 return;
Mike Stump1eb44332009-09-09 15:08:12 +00002401
Chris Lattnerb28317a2009-03-28 19:18:32 +00002402 ParmVarDecl *Param = cast<ParmVarDecl>(ParamD.getAs<Decl>());
Douglas Gregor61366e92008-12-24 00:01:03 +00002403
2404 // If this parameter has an unparsed default argument, clear it out
2405 // to make way for the parsed default argument.
2406 if (Param->hasUnparsedDefaultArg())
2407 Param->setDefaultArg(0);
2408
Chris Lattnerb28317a2009-03-28 19:18:32 +00002409 S->AddDecl(DeclPtrTy::make(Param));
Douglas Gregor72b505b2008-12-16 21:30:33 +00002410 if (Param->getDeclName())
2411 IdResolver.AddDecl(Param);
2412}
2413
2414/// ActOnFinishDelayedCXXMethodDeclaration - We have finished
2415/// processing the delayed method declaration for Method. The method
2416/// declaration is now considered finished. There may be a separate
2417/// ActOnStartOfFunctionDef action later (not necessarily
2418/// immediately!) for this method, if it was also defined inside the
2419/// class body.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002420void Sema::ActOnFinishDelayedCXXMethodDeclaration(Scope *S, DeclPtrTy MethodD) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +00002421 if (!MethodD)
2422 return;
Mike Stump1eb44332009-09-09 15:08:12 +00002423
Douglas Gregorefd5bda2009-08-24 11:57:43 +00002424 AdjustDeclIfTemplate(MethodD);
Mike Stump1eb44332009-09-09 15:08:12 +00002425
Chris Lattnerb28317a2009-03-28 19:18:32 +00002426 FunctionDecl *Method = cast<FunctionDecl>(MethodD.getAs<Decl>());
Douglas Gregor72b505b2008-12-16 21:30:33 +00002427
2428 // Now that we have our default arguments, check the constructor
2429 // again. It could produce additional diagnostics or affect whether
2430 // the class has implicitly-declared destructors, among other
2431 // things.
Chris Lattner6e475012009-04-25 08:35:12 +00002432 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Method))
2433 CheckConstructor(Constructor);
Douglas Gregor72b505b2008-12-16 21:30:33 +00002434
2435 // Check the default arguments, which we may have added.
2436 if (!Method->isInvalidDecl())
2437 CheckCXXDefaultArguments(Method);
2438}
2439
Douglas Gregor42a552f2008-11-05 20:51:48 +00002440/// CheckConstructorDeclarator - Called by ActOnDeclarator to check
Douglas Gregor72b505b2008-12-16 21:30:33 +00002441/// the well-formedness of the constructor declarator @p D with type @p
Douglas Gregor42a552f2008-11-05 20:51:48 +00002442/// R. If there are any errors in the declarator, this routine will
Chris Lattner65401802009-04-25 08:28:21 +00002443/// emit diagnostics and set the invalid bit to true. In any case, the type
2444/// will be updated to reflect a well-formed type for the constructor and
2445/// returned.
2446QualType Sema::CheckConstructorDeclarator(Declarator &D, QualType R,
2447 FunctionDecl::StorageClass &SC) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00002448 bool isVirtual = D.getDeclSpec().isVirtualSpecified();
Douglas Gregor42a552f2008-11-05 20:51:48 +00002449
2450 // C++ [class.ctor]p3:
2451 // A constructor shall not be virtual (10.3) or static (9.4). A
2452 // constructor can be invoked for a const, volatile or const
2453 // volatile object. A constructor shall not be declared const,
2454 // volatile, or const volatile (9.3.2).
2455 if (isVirtual) {
Chris Lattner65401802009-04-25 08:28:21 +00002456 if (!D.isInvalidType())
2457 Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
2458 << "virtual" << SourceRange(D.getDeclSpec().getVirtualSpecLoc())
2459 << SourceRange(D.getIdentifierLoc());
2460 D.setInvalidType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00002461 }
2462 if (SC == FunctionDecl::Static) {
Chris Lattner65401802009-04-25 08:28:21 +00002463 if (!D.isInvalidType())
2464 Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
2465 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
2466 << SourceRange(D.getIdentifierLoc());
2467 D.setInvalidType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00002468 SC = FunctionDecl::None;
2469 }
Mike Stump1eb44332009-09-09 15:08:12 +00002470
Chris Lattner65401802009-04-25 08:28:21 +00002471 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
2472 if (FTI.TypeQuals != 0) {
John McCall0953e762009-09-24 19:53:00 +00002473 if (FTI.TypeQuals & Qualifiers::Const)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002474 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
2475 << "const" << SourceRange(D.getIdentifierLoc());
John McCall0953e762009-09-24 19:53:00 +00002476 if (FTI.TypeQuals & Qualifiers::Volatile)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002477 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
2478 << "volatile" << SourceRange(D.getIdentifierLoc());
John McCall0953e762009-09-24 19:53:00 +00002479 if (FTI.TypeQuals & Qualifiers::Restrict)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002480 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
2481 << "restrict" << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00002482 }
Mike Stump1eb44332009-09-09 15:08:12 +00002483
Douglas Gregor42a552f2008-11-05 20:51:48 +00002484 // Rebuild the function type "R" without any type qualifiers (in
2485 // case any of the errors above fired) and with "void" as the
2486 // return type, since constructors don't have return types. We
2487 // *always* have to do this, because GetTypeForDeclarator will
2488 // put in a result type of "int" when none was specified.
John McCall183700f2009-09-21 23:43:11 +00002489 const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
Chris Lattner65401802009-04-25 08:28:21 +00002490 return Context.getFunctionType(Context.VoidTy, Proto->arg_type_begin(),
2491 Proto->getNumArgs(),
2492 Proto->isVariadic(), 0);
Douglas Gregor42a552f2008-11-05 20:51:48 +00002493}
2494
Douglas Gregor72b505b2008-12-16 21:30:33 +00002495/// CheckConstructor - Checks a fully-formed constructor for
2496/// well-formedness, issuing any diagnostics required. Returns true if
2497/// the constructor declarator is invalid.
Chris Lattner6e475012009-04-25 08:35:12 +00002498void Sema::CheckConstructor(CXXConstructorDecl *Constructor) {
Mike Stump1eb44332009-09-09 15:08:12 +00002499 CXXRecordDecl *ClassDecl
Douglas Gregor33297562009-03-27 04:38:56 +00002500 = dyn_cast<CXXRecordDecl>(Constructor->getDeclContext());
2501 if (!ClassDecl)
Chris Lattner6e475012009-04-25 08:35:12 +00002502 return Constructor->setInvalidDecl();
Douglas Gregor72b505b2008-12-16 21:30:33 +00002503
2504 // C++ [class.copy]p3:
2505 // A declaration of a constructor for a class X is ill-formed if
2506 // its first parameter is of type (optionally cv-qualified) X and
2507 // either there are no other parameters or else all other
2508 // parameters have default arguments.
Douglas Gregor33297562009-03-27 04:38:56 +00002509 if (!Constructor->isInvalidDecl() &&
Mike Stump1eb44332009-09-09 15:08:12 +00002510 ((Constructor->getNumParams() == 1) ||
2511 (Constructor->getNumParams() > 1 &&
Douglas Gregor66724ea2009-11-14 01:20:54 +00002512 Constructor->getParamDecl(1)->hasDefaultArg())) &&
2513 Constructor->getTemplateSpecializationKind()
2514 != TSK_ImplicitInstantiation) {
Douglas Gregor72b505b2008-12-16 21:30:33 +00002515 QualType ParamType = Constructor->getParamDecl(0)->getType();
2516 QualType ClassTy = Context.getTagDeclType(ClassDecl);
2517 if (Context.getCanonicalType(ParamType).getUnqualifiedType() == ClassTy) {
Douglas Gregora3a83512009-04-01 23:51:29 +00002518 SourceLocation ParamLoc = Constructor->getParamDecl(0)->getLocation();
2519 Diag(ParamLoc, diag::err_constructor_byvalue_arg)
Douglas Gregor558cb562009-04-02 01:08:08 +00002520 << CodeModificationHint::CreateInsertion(ParamLoc, " const &");
Douglas Gregor66724ea2009-11-14 01:20:54 +00002521
2522 // FIXME: Rather that making the constructor invalid, we should endeavor
2523 // to fix the type.
Chris Lattner6e475012009-04-25 08:35:12 +00002524 Constructor->setInvalidDecl();
Douglas Gregor72b505b2008-12-16 21:30:33 +00002525 }
2526 }
Mike Stump1eb44332009-09-09 15:08:12 +00002527
Douglas Gregor72b505b2008-12-16 21:30:33 +00002528 // Notify the class that we've added a constructor.
2529 ClassDecl->addedConstructor(Context, Constructor);
Douglas Gregor72b505b2008-12-16 21:30:33 +00002530}
2531
Anders Carlsson37909802009-11-30 21:24:50 +00002532/// CheckDestructor - Checks a fully-formed destructor for well-formedness,
2533/// issuing any diagnostics required. Returns true on error.
Anders Carlsson5ec02ae2009-12-02 17:15:43 +00002534bool Sema::CheckDestructor(CXXDestructorDecl *Destructor) {
Anders Carlsson6d701392009-11-15 22:49:34 +00002535 CXXRecordDecl *RD = Destructor->getParent();
2536
2537 if (Destructor->isVirtual()) {
2538 SourceLocation Loc;
2539
2540 if (!Destructor->isImplicit())
2541 Loc = Destructor->getLocation();
2542 else
2543 Loc = RD->getLocation();
2544
2545 // If we have a virtual destructor, look up the deallocation function
2546 FunctionDecl *OperatorDelete = 0;
2547 DeclarationName Name =
2548 Context.DeclarationNames.getCXXOperatorName(OO_Delete);
Anders Carlsson5ec02ae2009-12-02 17:15:43 +00002549 if (FindDeallocationFunction(Loc, RD, Name, OperatorDelete))
Anders Carlsson37909802009-11-30 21:24:50 +00002550 return true;
2551
2552 Destructor->setOperatorDelete(OperatorDelete);
Anders Carlsson6d701392009-11-15 22:49:34 +00002553 }
Anders Carlsson37909802009-11-30 21:24:50 +00002554
2555 return false;
Anders Carlsson6d701392009-11-15 22:49:34 +00002556}
2557
Mike Stump1eb44332009-09-09 15:08:12 +00002558static inline bool
Anders Carlsson7786d1c2009-04-30 23:18:11 +00002559FTIHasSingleVoidArgument(DeclaratorChunk::FunctionTypeInfo &FTI) {
2560 return (FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 &&
2561 FTI.ArgInfo[0].Param &&
2562 FTI.ArgInfo[0].Param.getAs<ParmVarDecl>()->getType()->isVoidType());
2563}
2564
Douglas Gregor42a552f2008-11-05 20:51:48 +00002565/// CheckDestructorDeclarator - Called by ActOnDeclarator to check
2566/// the well-formednes of the destructor declarator @p D with type @p
2567/// R. If there are any errors in the declarator, this routine will
Chris Lattner65401802009-04-25 08:28:21 +00002568/// emit diagnostics and set the declarator to invalid. Even if this happens,
2569/// will be updated to reflect a well-formed type for the destructor and
2570/// returned.
2571QualType Sema::CheckDestructorDeclarator(Declarator &D,
2572 FunctionDecl::StorageClass& SC) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00002573 // C++ [class.dtor]p1:
2574 // [...] A typedef-name that names a class is a class-name
2575 // (7.1.3); however, a typedef-name that names a class shall not
2576 // be used as the identifier in the declarator for a destructor
2577 // declaration.
Douglas Gregor3f9a0562009-11-03 01:35:08 +00002578 QualType DeclaratorType = GetTypeFromParser(D.getName().DestructorName);
Chris Lattner65401802009-04-25 08:28:21 +00002579 if (isa<TypedefType>(DeclaratorType)) {
2580 Diag(D.getIdentifierLoc(), diag::err_destructor_typedef_name)
Douglas Gregor1a51b4a2009-02-09 15:09:02 +00002581 << DeclaratorType;
Chris Lattner65401802009-04-25 08:28:21 +00002582 D.setInvalidType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00002583 }
2584
2585 // C++ [class.dtor]p2:
2586 // A destructor is used to destroy objects of its class type. A
2587 // destructor takes no parameters, and no return type can be
2588 // specified for it (not even void). The address of a destructor
2589 // shall not be taken. A destructor shall not be static. A
2590 // destructor can be invoked for a const, volatile or const
2591 // volatile object. A destructor shall not be declared const,
2592 // volatile or const volatile (9.3.2).
2593 if (SC == FunctionDecl::Static) {
Chris Lattner65401802009-04-25 08:28:21 +00002594 if (!D.isInvalidType())
2595 Diag(D.getIdentifierLoc(), diag::err_destructor_cannot_be)
2596 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
2597 << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00002598 SC = FunctionDecl::None;
Chris Lattner65401802009-04-25 08:28:21 +00002599 D.setInvalidType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00002600 }
Chris Lattner65401802009-04-25 08:28:21 +00002601 if (D.getDeclSpec().hasTypeSpecifier() && !D.isInvalidType()) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00002602 // Destructors don't have return types, but the parser will
2603 // happily parse something like:
2604 //
2605 // class X {
2606 // float ~X();
2607 // };
2608 //
2609 // The return type will be eliminated later.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002610 Diag(D.getIdentifierLoc(), diag::err_destructor_return_type)
2611 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
2612 << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00002613 }
Mike Stump1eb44332009-09-09 15:08:12 +00002614
Chris Lattner65401802009-04-25 08:28:21 +00002615 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
2616 if (FTI.TypeQuals != 0 && !D.isInvalidType()) {
John McCall0953e762009-09-24 19:53:00 +00002617 if (FTI.TypeQuals & Qualifiers::Const)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002618 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
2619 << "const" << SourceRange(D.getIdentifierLoc());
John McCall0953e762009-09-24 19:53:00 +00002620 if (FTI.TypeQuals & Qualifiers::Volatile)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002621 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
2622 << "volatile" << SourceRange(D.getIdentifierLoc());
John McCall0953e762009-09-24 19:53:00 +00002623 if (FTI.TypeQuals & Qualifiers::Restrict)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002624 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
2625 << "restrict" << SourceRange(D.getIdentifierLoc());
Chris Lattner65401802009-04-25 08:28:21 +00002626 D.setInvalidType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00002627 }
2628
2629 // Make sure we don't have any parameters.
Anders Carlsson7786d1c2009-04-30 23:18:11 +00002630 if (FTI.NumArgs > 0 && !FTIHasSingleVoidArgument(FTI)) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00002631 Diag(D.getIdentifierLoc(), diag::err_destructor_with_params);
2632
2633 // Delete the parameters.
Chris Lattner65401802009-04-25 08:28:21 +00002634 FTI.freeArgs();
2635 D.setInvalidType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00002636 }
2637
Mike Stump1eb44332009-09-09 15:08:12 +00002638 // Make sure the destructor isn't variadic.
Chris Lattner65401802009-04-25 08:28:21 +00002639 if (FTI.isVariadic) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00002640 Diag(D.getIdentifierLoc(), diag::err_destructor_variadic);
Chris Lattner65401802009-04-25 08:28:21 +00002641 D.setInvalidType();
2642 }
Douglas Gregor42a552f2008-11-05 20:51:48 +00002643
2644 // Rebuild the function type "R" without any type qualifiers or
2645 // parameters (in case any of the errors above fired) and with
2646 // "void" as the return type, since destructors don't have return
2647 // types. We *always* have to do this, because GetTypeForDeclarator
2648 // will put in a result type of "int" when none was specified.
Chris Lattner65401802009-04-25 08:28:21 +00002649 return Context.getFunctionType(Context.VoidTy, 0, 0, false, 0);
Douglas Gregor42a552f2008-11-05 20:51:48 +00002650}
2651
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002652/// CheckConversionDeclarator - Called by ActOnDeclarator to check the
2653/// well-formednes of the conversion function declarator @p D with
2654/// type @p R. If there are any errors in the declarator, this routine
2655/// will emit diagnostics and return true. Otherwise, it will return
2656/// false. Either way, the type @p R will be updated to reflect a
2657/// well-formed type for the conversion operator.
Chris Lattner6e475012009-04-25 08:35:12 +00002658void Sema::CheckConversionDeclarator(Declarator &D, QualType &R,
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002659 FunctionDecl::StorageClass& SC) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002660 // C++ [class.conv.fct]p1:
2661 // Neither parameter types nor return type can be specified. The
Eli Friedman33a31382009-08-05 19:21:58 +00002662 // type of a conversion function (8.3.5) is "function taking no
Mike Stump1eb44332009-09-09 15:08:12 +00002663 // parameter returning conversion-type-id."
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002664 if (SC == FunctionDecl::Static) {
Chris Lattner6e475012009-04-25 08:35:12 +00002665 if (!D.isInvalidType())
2666 Diag(D.getIdentifierLoc(), diag::err_conv_function_not_member)
2667 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
2668 << SourceRange(D.getIdentifierLoc());
2669 D.setInvalidType();
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002670 SC = FunctionDecl::None;
2671 }
Chris Lattner6e475012009-04-25 08:35:12 +00002672 if (D.getDeclSpec().hasTypeSpecifier() && !D.isInvalidType()) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002673 // Conversion functions don't have return types, but the parser will
2674 // happily parse something like:
2675 //
2676 // class X {
2677 // float operator bool();
2678 // };
2679 //
2680 // The return type will be changed later anyway.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002681 Diag(D.getIdentifierLoc(), diag::err_conv_function_return_type)
2682 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
2683 << SourceRange(D.getIdentifierLoc());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002684 }
2685
2686 // Make sure we don't have any parameters.
John McCall183700f2009-09-21 23:43:11 +00002687 if (R->getAs<FunctionProtoType>()->getNumArgs() > 0) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002688 Diag(D.getIdentifierLoc(), diag::err_conv_function_with_params);
2689
2690 // Delete the parameters.
Chris Lattner1833a832009-01-20 21:06:38 +00002691 D.getTypeObject(0).Fun.freeArgs();
Chris Lattner6e475012009-04-25 08:35:12 +00002692 D.setInvalidType();
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002693 }
2694
Mike Stump1eb44332009-09-09 15:08:12 +00002695 // Make sure the conversion function isn't variadic.
John McCall183700f2009-09-21 23:43:11 +00002696 if (R->getAs<FunctionProtoType>()->isVariadic() && !D.isInvalidType()) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002697 Diag(D.getIdentifierLoc(), diag::err_conv_function_variadic);
Chris Lattner6e475012009-04-25 08:35:12 +00002698 D.setInvalidType();
2699 }
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002700
2701 // C++ [class.conv.fct]p4:
2702 // The conversion-type-id shall not represent a function type nor
2703 // an array type.
Douglas Gregor3f9a0562009-11-03 01:35:08 +00002704 QualType ConvType = GetTypeFromParser(D.getName().ConversionFunctionId);
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002705 if (ConvType->isArrayType()) {
2706 Diag(D.getIdentifierLoc(), diag::err_conv_function_to_array);
2707 ConvType = Context.getPointerType(ConvType);
Chris Lattner6e475012009-04-25 08:35:12 +00002708 D.setInvalidType();
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002709 } else if (ConvType->isFunctionType()) {
2710 Diag(D.getIdentifierLoc(), diag::err_conv_function_to_function);
2711 ConvType = Context.getPointerType(ConvType);
Chris Lattner6e475012009-04-25 08:35:12 +00002712 D.setInvalidType();
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002713 }
2714
2715 // Rebuild the function type "R" without any parameters (in case any
2716 // of the errors above fired) and with the conversion type as the
Mike Stump1eb44332009-09-09 15:08:12 +00002717 // return type.
2718 R = Context.getFunctionType(ConvType, 0, 0, false,
John McCall183700f2009-09-21 23:43:11 +00002719 R->getAs<FunctionProtoType>()->getTypeQuals());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002720
Douglas Gregor09f41cf2009-01-14 15:45:31 +00002721 // C++0x explicit conversion operators.
2722 if (D.getDeclSpec().isExplicitSpecified() && !getLangOptions().CPlusPlus0x)
Mike Stump1eb44332009-09-09 15:08:12 +00002723 Diag(D.getDeclSpec().getExplicitSpecLoc(),
Douglas Gregor09f41cf2009-01-14 15:45:31 +00002724 diag::warn_explicit_conversion_functions)
2725 << SourceRange(D.getDeclSpec().getExplicitSpecLoc());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002726}
2727
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002728/// ActOnConversionDeclarator - Called by ActOnDeclarator to complete
2729/// the declaration of the given C++ conversion function. This routine
2730/// is responsible for recording the conversion function in the C++
2731/// class, if possible.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002732Sema::DeclPtrTy Sema::ActOnConversionDeclarator(CXXConversionDecl *Conversion) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002733 assert(Conversion && "Expected to receive a conversion function declaration");
2734
Douglas Gregor9d350972008-12-12 08:25:50 +00002735 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Conversion->getDeclContext());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002736
2737 // Make sure we aren't redeclaring the conversion function.
2738 QualType ConvType = Context.getCanonicalType(Conversion->getConversionType());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002739
2740 // C++ [class.conv.fct]p1:
2741 // [...] A conversion function is never used to convert a
2742 // (possibly cv-qualified) object to the (possibly cv-qualified)
2743 // same object type (or a reference to it), to a (possibly
2744 // cv-qualified) base class of that type (or a reference to it),
2745 // or to (possibly cv-qualified) void.
Mike Stump390b4cc2009-05-16 07:39:55 +00002746 // FIXME: Suppress this warning if the conversion function ends up being a
2747 // virtual function that overrides a virtual function in a base class.
Mike Stump1eb44332009-09-09 15:08:12 +00002748 QualType ClassType
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002749 = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
Ted Kremenek6217b802009-07-29 21:53:49 +00002750 if (const ReferenceType *ConvTypeRef = ConvType->getAs<ReferenceType>())
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002751 ConvType = ConvTypeRef->getPointeeType();
2752 if (ConvType->isRecordType()) {
2753 ConvType = Context.getCanonicalType(ConvType).getUnqualifiedType();
2754 if (ConvType == ClassType)
Chris Lattner5dc266a2008-11-20 06:13:02 +00002755 Diag(Conversion->getLocation(), diag::warn_conv_to_self_not_used)
Chris Lattnerd1625842008-11-24 06:25:27 +00002756 << ClassType;
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002757 else if (IsDerivedFrom(ClassType, ConvType))
Chris Lattner5dc266a2008-11-20 06:13:02 +00002758 Diag(Conversion->getLocation(), diag::warn_conv_to_base_not_used)
Chris Lattnerd1625842008-11-24 06:25:27 +00002759 << ClassType << ConvType;
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002760 } else if (ConvType->isVoidType()) {
Chris Lattner5dc266a2008-11-20 06:13:02 +00002761 Diag(Conversion->getLocation(), diag::warn_conv_to_void_not_used)
Chris Lattnerd1625842008-11-24 06:25:27 +00002762 << ClassType << ConvType;
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002763 }
2764
Douglas Gregor48026d22010-01-11 18:40:55 +00002765 if (Conversion->getPrimaryTemplate()) {
2766 // ignore specializations
2767 } else if (Conversion->getPreviousDeclaration()) {
Mike Stump1eb44332009-09-09 15:08:12 +00002768 if (FunctionTemplateDecl *ConversionTemplate
Douglas Gregor0c551062010-01-11 18:53:25 +00002769 = Conversion->getDescribedFunctionTemplate()) {
2770 if (ClassDecl->replaceConversion(
2771 ConversionTemplate->getPreviousDeclaration(),
2772 ConversionTemplate))
2773 return DeclPtrTy::make(ConversionTemplate);
2774 } else if (ClassDecl->replaceConversion(Conversion->getPreviousDeclaration(),
2775 Conversion))
John McCallba135432009-11-21 08:51:07 +00002776 return DeclPtrTy::make(Conversion);
Douglas Gregor70316a02008-12-26 15:00:45 +00002777 assert(Conversion->isInvalidDecl() && "Conversion should not get here.");
Mike Stump1eb44332009-09-09 15:08:12 +00002778 } else if (FunctionTemplateDecl *ConversionTemplate
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00002779 = Conversion->getDescribedFunctionTemplate())
Fariborz Jahaniandebc6292009-09-12 19:02:34 +00002780 ClassDecl->addConversionFunction(ConversionTemplate);
Douglas Gregor48026d22010-01-11 18:40:55 +00002781 else
Fariborz Jahaniandebc6292009-09-12 19:02:34 +00002782 ClassDecl->addConversionFunction(Conversion);
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002783
Chris Lattnerb28317a2009-03-28 19:18:32 +00002784 return DeclPtrTy::make(Conversion);
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002785}
2786
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002787//===----------------------------------------------------------------------===//
2788// Namespace Handling
2789//===----------------------------------------------------------------------===//
2790
2791/// ActOnStartNamespaceDef - This is called at the start of a namespace
2792/// definition.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002793Sema::DeclPtrTy Sema::ActOnStartNamespaceDef(Scope *NamespcScope,
2794 SourceLocation IdentLoc,
2795 IdentifierInfo *II,
2796 SourceLocation LBrace) {
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002797 NamespaceDecl *Namespc =
2798 NamespaceDecl::Create(Context, CurContext, IdentLoc, II);
2799 Namespc->setLBracLoc(LBrace);
2800
2801 Scope *DeclRegionScope = NamespcScope->getParent();
2802
2803 if (II) {
2804 // C++ [namespace.def]p2:
2805 // The identifier in an original-namespace-definition shall not have been
2806 // previously defined in the declarative region in which the
2807 // original-namespace-definition appears. The identifier in an
2808 // original-namespace-definition is the name of the namespace. Subsequently
2809 // in that declarative region, it is treated as an original-namespace-name.
2810
John McCallf36e02d2009-10-09 21:13:30 +00002811 NamedDecl *PrevDecl
John McCalla24dc2e2009-11-17 02:14:36 +00002812 = LookupSingleName(DeclRegionScope, II, LookupOrdinaryName,
John McCall7d384dd2009-11-18 07:57:50 +00002813 ForRedeclaration);
Mike Stump1eb44332009-09-09 15:08:12 +00002814
Douglas Gregor44b43212008-12-11 16:49:14 +00002815 if (NamespaceDecl *OrigNS = dyn_cast_or_null<NamespaceDecl>(PrevDecl)) {
2816 // This is an extended namespace definition.
2817 // Attach this namespace decl to the chain of extended namespace
2818 // definitions.
2819 OrigNS->setNextNamespace(Namespc);
2820 Namespc->setOriginalNamespace(OrigNS->getOriginalNamespace());
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002821
Mike Stump1eb44332009-09-09 15:08:12 +00002822 // Remove the previous declaration from the scope.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002823 if (DeclRegionScope->isDeclScope(DeclPtrTy::make(OrigNS))) {
Douglas Gregore267ff32008-12-11 20:41:00 +00002824 IdResolver.RemoveDecl(OrigNS);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002825 DeclRegionScope->RemoveDecl(DeclPtrTy::make(OrigNS));
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002826 }
Douglas Gregor44b43212008-12-11 16:49:14 +00002827 } else if (PrevDecl) {
2828 // This is an invalid name redefinition.
2829 Diag(Namespc->getLocation(), diag::err_redefinition_different_kind)
2830 << Namespc->getDeclName();
2831 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
2832 Namespc->setInvalidDecl();
2833 // Continue on to push Namespc as current DeclContext and return it.
Douglas Gregor7adb10f2009-09-15 22:30:29 +00002834 } else if (II->isStr("std") &&
2835 CurContext->getLookupContext()->isTranslationUnit()) {
2836 // This is the first "real" definition of the namespace "std", so update
2837 // our cache of the "std" namespace to point at this definition.
2838 if (StdNamespace) {
2839 // We had already defined a dummy namespace "std". Link this new
2840 // namespace definition to the dummy namespace "std".
2841 StdNamespace->setNextNamespace(Namespc);
2842 StdNamespace->setLocation(IdentLoc);
2843 Namespc->setOriginalNamespace(StdNamespace->getOriginalNamespace());
2844 }
2845
2846 // Make our StdNamespace cache point at the first real definition of the
2847 // "std" namespace.
2848 StdNamespace = Namespc;
Mike Stump1eb44332009-09-09 15:08:12 +00002849 }
Douglas Gregor44b43212008-12-11 16:49:14 +00002850
2851 PushOnScopeChains(Namespc, DeclRegionScope);
2852 } else {
John McCall9aeed322009-10-01 00:25:31 +00002853 // Anonymous namespaces.
John McCall5fdd7642009-12-16 02:06:49 +00002854 assert(Namespc->isAnonymousNamespace());
2855 CurContext->addDecl(Namespc);
2856
2857 // Link the anonymous namespace into its parent.
2858 NamespaceDecl *PrevDecl;
2859 DeclContext *Parent = CurContext->getLookupContext();
2860 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(Parent)) {
2861 PrevDecl = TU->getAnonymousNamespace();
2862 TU->setAnonymousNamespace(Namespc);
2863 } else {
2864 NamespaceDecl *ND = cast<NamespaceDecl>(Parent);
2865 PrevDecl = ND->getAnonymousNamespace();
2866 ND->setAnonymousNamespace(Namespc);
2867 }
2868
2869 // Link the anonymous namespace with its previous declaration.
2870 if (PrevDecl) {
2871 assert(PrevDecl->isAnonymousNamespace());
2872 assert(!PrevDecl->getNextNamespace());
2873 Namespc->setOriginalNamespace(PrevDecl->getOriginalNamespace());
2874 PrevDecl->setNextNamespace(Namespc);
2875 }
John McCall9aeed322009-10-01 00:25:31 +00002876
2877 // C++ [namespace.unnamed]p1. An unnamed-namespace-definition
2878 // behaves as if it were replaced by
2879 // namespace unique { /* empty body */ }
2880 // using namespace unique;
2881 // namespace unique { namespace-body }
2882 // where all occurrences of 'unique' in a translation unit are
2883 // replaced by the same identifier and this identifier differs
2884 // from all other identifiers in the entire program.
2885
2886 // We just create the namespace with an empty name and then add an
2887 // implicit using declaration, just like the standard suggests.
2888 //
2889 // CodeGen enforces the "universally unique" aspect by giving all
2890 // declarations semantically contained within an anonymous
2891 // namespace internal linkage.
2892
John McCall5fdd7642009-12-16 02:06:49 +00002893 if (!PrevDecl) {
2894 UsingDirectiveDecl* UD
2895 = UsingDirectiveDecl::Create(Context, CurContext,
2896 /* 'using' */ LBrace,
2897 /* 'namespace' */ SourceLocation(),
2898 /* qualifier */ SourceRange(),
2899 /* NNS */ NULL,
2900 /* identifier */ SourceLocation(),
2901 Namespc,
2902 /* Ancestor */ CurContext);
2903 UD->setImplicit();
2904 CurContext->addDecl(UD);
2905 }
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002906 }
2907
2908 // Although we could have an invalid decl (i.e. the namespace name is a
2909 // redefinition), push it as current DeclContext and try to continue parsing.
Mike Stump390b4cc2009-05-16 07:39:55 +00002910 // FIXME: We should be able to push Namespc here, so that the each DeclContext
2911 // for the namespace has the declarations that showed up in that particular
2912 // namespace definition.
Douglas Gregor44b43212008-12-11 16:49:14 +00002913 PushDeclContext(NamespcScope, Namespc);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002914 return DeclPtrTy::make(Namespc);
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002915}
2916
Sebastian Redleb0d8c92009-11-23 15:34:23 +00002917/// getNamespaceDecl - Returns the namespace a decl represents. If the decl
2918/// is a namespace alias, returns the namespace it points to.
2919static inline NamespaceDecl *getNamespaceDecl(NamedDecl *D) {
2920 if (NamespaceAliasDecl *AD = dyn_cast_or_null<NamespaceAliasDecl>(D))
2921 return AD->getNamespace();
2922 return dyn_cast_or_null<NamespaceDecl>(D);
2923}
2924
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002925/// ActOnFinishNamespaceDef - This callback is called after a namespace is
2926/// exited. Decl is the DeclTy returned by ActOnStartNamespaceDef.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002927void Sema::ActOnFinishNamespaceDef(DeclPtrTy D, SourceLocation RBrace) {
2928 Decl *Dcl = D.getAs<Decl>();
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002929 NamespaceDecl *Namespc = dyn_cast_or_null<NamespaceDecl>(Dcl);
2930 assert(Namespc && "Invalid parameter, expected NamespaceDecl");
2931 Namespc->setRBracLoc(RBrace);
2932 PopDeclContext();
2933}
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00002934
Chris Lattnerb28317a2009-03-28 19:18:32 +00002935Sema::DeclPtrTy Sema::ActOnUsingDirective(Scope *S,
2936 SourceLocation UsingLoc,
2937 SourceLocation NamespcLoc,
2938 const CXXScopeSpec &SS,
2939 SourceLocation IdentLoc,
2940 IdentifierInfo *NamespcName,
2941 AttributeList *AttrList) {
Douglas Gregorf780abc2008-12-30 03:27:21 +00002942 assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
2943 assert(NamespcName && "Invalid NamespcName.");
2944 assert(IdentLoc.isValid() && "Invalid NamespceName location.");
Douglas Gregor2a3009a2009-02-03 19:21:40 +00002945 assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
Douglas Gregorf780abc2008-12-30 03:27:21 +00002946
Douglas Gregor2a3009a2009-02-03 19:21:40 +00002947 UsingDirectiveDecl *UDir = 0;
Douglas Gregorf780abc2008-12-30 03:27:21 +00002948
Douglas Gregoreb11cd02009-01-14 22:20:51 +00002949 // Lookup namespace name.
John McCalla24dc2e2009-11-17 02:14:36 +00002950 LookupResult R(*this, NamespcName, IdentLoc, LookupNamespaceName);
2951 LookupParsedName(R, S, &SS);
2952 if (R.isAmbiguous())
Chris Lattnerb28317a2009-03-28 19:18:32 +00002953 return DeclPtrTy();
John McCalla24dc2e2009-11-17 02:14:36 +00002954
John McCallf36e02d2009-10-09 21:13:30 +00002955 if (!R.empty()) {
Sebastian Redleb0d8c92009-11-23 15:34:23 +00002956 NamedDecl *Named = R.getFoundDecl();
2957 assert((isa<NamespaceDecl>(Named) || isa<NamespaceAliasDecl>(Named))
2958 && "expected namespace decl");
Douglas Gregor2a3009a2009-02-03 19:21:40 +00002959 // C++ [namespace.udir]p1:
2960 // A using-directive specifies that the names in the nominated
2961 // namespace can be used in the scope in which the
2962 // using-directive appears after the using-directive. During
2963 // unqualified name lookup (3.4.1), the names appear as if they
2964 // were declared in the nearest enclosing namespace which
2965 // contains both the using-directive and the nominated
Eli Friedman33a31382009-08-05 19:21:58 +00002966 // namespace. [Note: in this context, "contains" means "contains
2967 // directly or indirectly". ]
Douglas Gregor2a3009a2009-02-03 19:21:40 +00002968
2969 // Find enclosing context containing both using-directive and
2970 // nominated namespace.
Sebastian Redleb0d8c92009-11-23 15:34:23 +00002971 NamespaceDecl *NS = getNamespaceDecl(Named);
Douglas Gregor2a3009a2009-02-03 19:21:40 +00002972 DeclContext *CommonAncestor = cast<DeclContext>(NS);
2973 while (CommonAncestor && !CommonAncestor->Encloses(CurContext))
2974 CommonAncestor = CommonAncestor->getParent();
2975
Sebastian Redleb0d8c92009-11-23 15:34:23 +00002976 UDir = UsingDirectiveDecl::Create(Context, CurContext, UsingLoc, NamespcLoc,
Douglas Gregor8419fa32009-05-30 06:31:56 +00002977 SS.getRange(),
2978 (NestedNameSpecifier *)SS.getScopeRep(),
Sebastian Redleb0d8c92009-11-23 15:34:23 +00002979 IdentLoc, Named, CommonAncestor);
Douglas Gregor2a3009a2009-02-03 19:21:40 +00002980 PushUsingDirective(S, UDir);
Douglas Gregorf780abc2008-12-30 03:27:21 +00002981 } else {
Chris Lattneread013e2009-01-06 07:24:29 +00002982 Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
Douglas Gregorf780abc2008-12-30 03:27:21 +00002983 }
2984
Douglas Gregor2a3009a2009-02-03 19:21:40 +00002985 // FIXME: We ignore attributes for now.
Douglas Gregorf780abc2008-12-30 03:27:21 +00002986 delete AttrList;
Chris Lattnerb28317a2009-03-28 19:18:32 +00002987 return DeclPtrTy::make(UDir);
Douglas Gregor2a3009a2009-02-03 19:21:40 +00002988}
2989
2990void Sema::PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir) {
2991 // If scope has associated entity, then using directive is at namespace
2992 // or translation unit scope. We add UsingDirectiveDecls, into
2993 // it's lookup structure.
2994 if (DeclContext *Ctx = static_cast<DeclContext*>(S->getEntity()))
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002995 Ctx->addDecl(UDir);
Douglas Gregor2a3009a2009-02-03 19:21:40 +00002996 else
2997 // Otherwise it is block-sope. using-directives will affect lookup
2998 // only to the end of scope.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002999 S->PushUsingDirective(DeclPtrTy::make(UDir));
Douglas Gregorf780abc2008-12-30 03:27:21 +00003000}
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00003001
Douglas Gregor9cfbe482009-06-20 00:51:54 +00003002
3003Sema::DeclPtrTy Sema::ActOnUsingDeclaration(Scope *S,
Anders Carlsson595adc12009-08-29 19:54:19 +00003004 AccessSpecifier AS,
John McCall60fa3cf2009-12-11 02:10:03 +00003005 bool HasUsingKeyword,
Anders Carlssoncf9f9212009-08-28 03:16:11 +00003006 SourceLocation UsingLoc,
3007 const CXXScopeSpec &SS,
Douglas Gregor12c118a2009-11-04 16:30:06 +00003008 UnqualifiedId &Name,
Anders Carlssoncf9f9212009-08-28 03:16:11 +00003009 AttributeList *AttrList,
John McCall7ba107a2009-11-18 02:36:19 +00003010 bool IsTypeName,
3011 SourceLocation TypenameLoc) {
Douglas Gregor9cfbe482009-06-20 00:51:54 +00003012 assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
Mike Stump1eb44332009-09-09 15:08:12 +00003013
Douglas Gregor12c118a2009-11-04 16:30:06 +00003014 switch (Name.getKind()) {
3015 case UnqualifiedId::IK_Identifier:
3016 case UnqualifiedId::IK_OperatorFunctionId:
Sean Hunt0486d742009-11-28 04:44:28 +00003017 case UnqualifiedId::IK_LiteralOperatorId:
Douglas Gregor12c118a2009-11-04 16:30:06 +00003018 case UnqualifiedId::IK_ConversionFunctionId:
3019 break;
3020
3021 case UnqualifiedId::IK_ConstructorName:
Douglas Gregor0efc2c12010-01-13 17:31:36 +00003022 case UnqualifiedId::IK_ConstructorTemplateId:
John McCall604e7f12009-12-08 07:46:18 +00003023 // C++0x inherited constructors.
3024 if (getLangOptions().CPlusPlus0x) break;
3025
Douglas Gregor12c118a2009-11-04 16:30:06 +00003026 Diag(Name.getSourceRange().getBegin(), diag::err_using_decl_constructor)
3027 << SS.getRange();
3028 return DeclPtrTy();
3029
3030 case UnqualifiedId::IK_DestructorName:
3031 Diag(Name.getSourceRange().getBegin(), diag::err_using_decl_destructor)
3032 << SS.getRange();
3033 return DeclPtrTy();
3034
3035 case UnqualifiedId::IK_TemplateId:
3036 Diag(Name.getSourceRange().getBegin(), diag::err_using_decl_template_id)
3037 << SourceRange(Name.TemplateId->LAngleLoc, Name.TemplateId->RAngleLoc);
3038 return DeclPtrTy();
3039 }
3040
3041 DeclarationName TargetName = GetNameFromUnqualifiedId(Name);
John McCall604e7f12009-12-08 07:46:18 +00003042 if (!TargetName)
3043 return DeclPtrTy();
3044
John McCall60fa3cf2009-12-11 02:10:03 +00003045 // Warn about using declarations.
3046 // TODO: store that the declaration was written without 'using' and
3047 // talk about access decls instead of using decls in the
3048 // diagnostics.
3049 if (!HasUsingKeyword) {
3050 UsingLoc = Name.getSourceRange().getBegin();
3051
3052 Diag(UsingLoc, diag::warn_access_decl_deprecated)
3053 << CodeModificationHint::CreateInsertion(SS.getRange().getBegin(),
3054 "using ");
3055 }
3056
John McCall9488ea12009-11-17 05:59:44 +00003057 NamedDecl *UD = BuildUsingDeclaration(S, AS, UsingLoc, SS,
Douglas Gregor12c118a2009-11-04 16:30:06 +00003058 Name.getSourceRange().getBegin(),
John McCall7ba107a2009-11-18 02:36:19 +00003059 TargetName, AttrList,
3060 /* IsInstantiation */ false,
3061 IsTypeName, TypenameLoc);
John McCalled976492009-12-04 22:46:56 +00003062 if (UD)
3063 PushOnScopeChains(UD, S, /*AddToContext*/ false);
Mike Stump1eb44332009-09-09 15:08:12 +00003064
Anders Carlssonc72160b2009-08-28 05:40:36 +00003065 return DeclPtrTy::make(UD);
3066}
3067
John McCall9f54ad42009-12-10 09:41:52 +00003068/// Determines whether to create a using shadow decl for a particular
3069/// decl, given the set of decls existing prior to this using lookup.
3070bool Sema::CheckUsingShadowDecl(UsingDecl *Using, NamedDecl *Orig,
3071 const LookupResult &Previous) {
3072 // Diagnose finding a decl which is not from a base class of the
3073 // current class. We do this now because there are cases where this
3074 // function will silently decide not to build a shadow decl, which
3075 // will pre-empt further diagnostics.
3076 //
3077 // We don't need to do this in C++0x because we do the check once on
3078 // the qualifier.
3079 //
3080 // FIXME: diagnose the following if we care enough:
3081 // struct A { int foo; };
3082 // struct B : A { using A::foo; };
3083 // template <class T> struct C : A {};
3084 // template <class T> struct D : C<T> { using B::foo; } // <---
3085 // This is invalid (during instantiation) in C++03 because B::foo
3086 // resolves to the using decl in B, which is not a base class of D<T>.
3087 // We can't diagnose it immediately because C<T> is an unknown
3088 // specialization. The UsingShadowDecl in D<T> then points directly
3089 // to A::foo, which will look well-formed when we instantiate.
3090 // The right solution is to not collapse the shadow-decl chain.
3091 if (!getLangOptions().CPlusPlus0x && CurContext->isRecord()) {
3092 DeclContext *OrigDC = Orig->getDeclContext();
3093
3094 // Handle enums and anonymous structs.
3095 if (isa<EnumDecl>(OrigDC)) OrigDC = OrigDC->getParent();
3096 CXXRecordDecl *OrigRec = cast<CXXRecordDecl>(OrigDC);
3097 while (OrigRec->isAnonymousStructOrUnion())
3098 OrigRec = cast<CXXRecordDecl>(OrigRec->getDeclContext());
3099
3100 if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(OrigRec)) {
3101 if (OrigDC == CurContext) {
3102 Diag(Using->getLocation(),
3103 diag::err_using_decl_nested_name_specifier_is_current_class)
3104 << Using->getNestedNameRange();
3105 Diag(Orig->getLocation(), diag::note_using_decl_target);
3106 return true;
3107 }
3108
3109 Diag(Using->getNestedNameRange().getBegin(),
3110 diag::err_using_decl_nested_name_specifier_is_not_base_class)
3111 << Using->getTargetNestedNameDecl()
3112 << cast<CXXRecordDecl>(CurContext)
3113 << Using->getNestedNameRange();
3114 Diag(Orig->getLocation(), diag::note_using_decl_target);
3115 return true;
3116 }
3117 }
3118
3119 if (Previous.empty()) return false;
3120
3121 NamedDecl *Target = Orig;
3122 if (isa<UsingShadowDecl>(Target))
3123 Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
3124
John McCalld7533ec2009-12-11 02:33:26 +00003125 // If the target happens to be one of the previous declarations, we
3126 // don't have a conflict.
3127 //
3128 // FIXME: but we might be increasing its access, in which case we
3129 // should redeclare it.
3130 NamedDecl *NonTag = 0, *Tag = 0;
3131 for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
3132 I != E; ++I) {
3133 NamedDecl *D = (*I)->getUnderlyingDecl();
3134 if (D->getCanonicalDecl() == Target->getCanonicalDecl())
3135 return false;
3136
3137 (isa<TagDecl>(D) ? Tag : NonTag) = D;
3138 }
3139
John McCall9f54ad42009-12-10 09:41:52 +00003140 if (Target->isFunctionOrFunctionTemplate()) {
3141 FunctionDecl *FD;
3142 if (isa<FunctionTemplateDecl>(Target))
3143 FD = cast<FunctionTemplateDecl>(Target)->getTemplatedDecl();
3144 else
3145 FD = cast<FunctionDecl>(Target);
3146
3147 NamedDecl *OldDecl = 0;
3148 switch (CheckOverload(FD, Previous, OldDecl)) {
3149 case Ovl_Overload:
3150 return false;
3151
3152 case Ovl_NonFunction:
John McCall41ce66f2009-12-10 19:51:03 +00003153 Diag(Using->getLocation(), diag::err_using_decl_conflict);
John McCall9f54ad42009-12-10 09:41:52 +00003154 break;
3155
3156 // We found a decl with the exact signature.
3157 case Ovl_Match:
3158 if (isa<UsingShadowDecl>(OldDecl)) {
3159 // Silently ignore the possible conflict.
3160 return false;
3161 }
3162
3163 // If we're in a record, we want to hide the target, so we
3164 // return true (without a diagnostic) to tell the caller not to
3165 // build a shadow decl.
3166 if (CurContext->isRecord())
3167 return true;
3168
3169 // If we're not in a record, this is an error.
John McCall41ce66f2009-12-10 19:51:03 +00003170 Diag(Using->getLocation(), diag::err_using_decl_conflict);
John McCall9f54ad42009-12-10 09:41:52 +00003171 break;
3172 }
3173
3174 Diag(Target->getLocation(), diag::note_using_decl_target);
3175 Diag(OldDecl->getLocation(), diag::note_using_decl_conflict);
3176 return true;
3177 }
3178
3179 // Target is not a function.
3180
John McCall9f54ad42009-12-10 09:41:52 +00003181 if (isa<TagDecl>(Target)) {
3182 // No conflict between a tag and a non-tag.
3183 if (!Tag) return false;
3184
John McCall41ce66f2009-12-10 19:51:03 +00003185 Diag(Using->getLocation(), diag::err_using_decl_conflict);
John McCall9f54ad42009-12-10 09:41:52 +00003186 Diag(Target->getLocation(), diag::note_using_decl_target);
3187 Diag(Tag->getLocation(), diag::note_using_decl_conflict);
3188 return true;
3189 }
3190
3191 // No conflict between a tag and a non-tag.
3192 if (!NonTag) return false;
3193
John McCall41ce66f2009-12-10 19:51:03 +00003194 Diag(Using->getLocation(), diag::err_using_decl_conflict);
John McCall9f54ad42009-12-10 09:41:52 +00003195 Diag(Target->getLocation(), diag::note_using_decl_target);
3196 Diag(NonTag->getLocation(), diag::note_using_decl_conflict);
3197 return true;
3198}
3199
John McCall9488ea12009-11-17 05:59:44 +00003200/// Builds a shadow declaration corresponding to a 'using' declaration.
John McCall604e7f12009-12-08 07:46:18 +00003201UsingShadowDecl *Sema::BuildUsingShadowDecl(Scope *S,
John McCall604e7f12009-12-08 07:46:18 +00003202 UsingDecl *UD,
3203 NamedDecl *Orig) {
John McCall9488ea12009-11-17 05:59:44 +00003204
3205 // If we resolved to another shadow declaration, just coalesce them.
John McCall604e7f12009-12-08 07:46:18 +00003206 NamedDecl *Target = Orig;
3207 if (isa<UsingShadowDecl>(Target)) {
3208 Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
3209 assert(!isa<UsingShadowDecl>(Target) && "nested shadow declaration");
John McCall9488ea12009-11-17 05:59:44 +00003210 }
3211
3212 UsingShadowDecl *Shadow
John McCall604e7f12009-12-08 07:46:18 +00003213 = UsingShadowDecl::Create(Context, CurContext,
3214 UD->getLocation(), UD, Target);
John McCall9488ea12009-11-17 05:59:44 +00003215 UD->addShadowDecl(Shadow);
3216
3217 if (S)
John McCall604e7f12009-12-08 07:46:18 +00003218 PushOnScopeChains(Shadow, S);
John McCall9488ea12009-11-17 05:59:44 +00003219 else
John McCall604e7f12009-12-08 07:46:18 +00003220 CurContext->addDecl(Shadow);
John McCall9f54ad42009-12-10 09:41:52 +00003221 Shadow->setAccess(UD->getAccess());
John McCall9488ea12009-11-17 05:59:44 +00003222
John McCall604e7f12009-12-08 07:46:18 +00003223 if (Orig->isInvalidDecl() || UD->isInvalidDecl())
3224 Shadow->setInvalidDecl();
3225
John McCall9f54ad42009-12-10 09:41:52 +00003226 return Shadow;
3227}
John McCall604e7f12009-12-08 07:46:18 +00003228
John McCall9f54ad42009-12-10 09:41:52 +00003229/// Hides a using shadow declaration. This is required by the current
3230/// using-decl implementation when a resolvable using declaration in a
3231/// class is followed by a declaration which would hide or override
3232/// one or more of the using decl's targets; for example:
3233///
3234/// struct Base { void foo(int); };
3235/// struct Derived : Base {
3236/// using Base::foo;
3237/// void foo(int);
3238/// };
3239///
3240/// The governing language is C++03 [namespace.udecl]p12:
3241///
3242/// When a using-declaration brings names from a base class into a
3243/// derived class scope, member functions in the derived class
3244/// override and/or hide member functions with the same name and
3245/// parameter types in a base class (rather than conflicting).
3246///
3247/// There are two ways to implement this:
3248/// (1) optimistically create shadow decls when they're not hidden
3249/// by existing declarations, or
3250/// (2) don't create any shadow decls (or at least don't make them
3251/// visible) until we've fully parsed/instantiated the class.
3252/// The problem with (1) is that we might have to retroactively remove
3253/// a shadow decl, which requires several O(n) operations because the
3254/// decl structures are (very reasonably) not designed for removal.
3255/// (2) avoids this but is very fiddly and phase-dependent.
3256void Sema::HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow) {
3257 // Remove it from the DeclContext...
3258 Shadow->getDeclContext()->removeDecl(Shadow);
John McCall604e7f12009-12-08 07:46:18 +00003259
John McCall9f54ad42009-12-10 09:41:52 +00003260 // ...and the scope, if applicable...
3261 if (S) {
3262 S->RemoveDecl(DeclPtrTy::make(static_cast<Decl*>(Shadow)));
3263 IdResolver.RemoveDecl(Shadow);
John McCall604e7f12009-12-08 07:46:18 +00003264 }
3265
John McCall9f54ad42009-12-10 09:41:52 +00003266 // ...and the using decl.
3267 Shadow->getUsingDecl()->removeShadowDecl(Shadow);
3268
3269 // TODO: complain somehow if Shadow was used. It shouldn't
3270 // be possible for this to happen, because
John McCall9488ea12009-11-17 05:59:44 +00003271}
3272
John McCall7ba107a2009-11-18 02:36:19 +00003273/// Builds a using declaration.
3274///
3275/// \param IsInstantiation - Whether this call arises from an
3276/// instantiation of an unresolved using declaration. We treat
3277/// the lookup differently for these declarations.
John McCall9488ea12009-11-17 05:59:44 +00003278NamedDecl *Sema::BuildUsingDeclaration(Scope *S, AccessSpecifier AS,
3279 SourceLocation UsingLoc,
Anders Carlssonc72160b2009-08-28 05:40:36 +00003280 const CXXScopeSpec &SS,
3281 SourceLocation IdentLoc,
3282 DeclarationName Name,
3283 AttributeList *AttrList,
John McCall7ba107a2009-11-18 02:36:19 +00003284 bool IsInstantiation,
3285 bool IsTypeName,
3286 SourceLocation TypenameLoc) {
Anders Carlssonc72160b2009-08-28 05:40:36 +00003287 assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
3288 assert(IdentLoc.isValid() && "Invalid TargetName location.");
Eli Friedman2a16a132009-08-27 05:09:36 +00003289
Anders Carlsson550b14b2009-08-28 05:49:21 +00003290 // FIXME: We ignore attributes for now.
3291 delete AttrList;
Mike Stump1eb44332009-09-09 15:08:12 +00003292
Anders Carlssoncf9f9212009-08-28 03:16:11 +00003293 if (SS.isEmpty()) {
3294 Diag(IdentLoc, diag::err_using_requires_qualname);
Anders Carlssonc72160b2009-08-28 05:40:36 +00003295 return 0;
Anders Carlssoncf9f9212009-08-28 03:16:11 +00003296 }
Mike Stump1eb44332009-09-09 15:08:12 +00003297
John McCall9f54ad42009-12-10 09:41:52 +00003298 // Do the redeclaration lookup in the current scope.
3299 LookupResult Previous(*this, Name, IdentLoc, LookupUsingDeclName,
3300 ForRedeclaration);
3301 Previous.setHideTags(false);
3302 if (S) {
3303 LookupName(Previous, S);
3304
3305 // It is really dumb that we have to do this.
3306 LookupResult::Filter F = Previous.makeFilter();
3307 while (F.hasNext()) {
3308 NamedDecl *D = F.next();
3309 if (!isDeclInScope(D, CurContext, S))
3310 F.erase();
3311 }
3312 F.done();
3313 } else {
3314 assert(IsInstantiation && "no scope in non-instantiation");
3315 assert(CurContext->isRecord() && "scope not record in instantiation");
3316 LookupQualifiedName(Previous, CurContext);
3317 }
3318
Mike Stump1eb44332009-09-09 15:08:12 +00003319 NestedNameSpecifier *NNS =
Anders Carlssoncf9f9212009-08-28 03:16:11 +00003320 static_cast<NestedNameSpecifier *>(SS.getScopeRep());
3321
John McCall9f54ad42009-12-10 09:41:52 +00003322 // Check for invalid redeclarations.
3323 if (CheckUsingDeclRedeclaration(UsingLoc, IsTypeName, SS, IdentLoc, Previous))
3324 return 0;
3325
3326 // Check for bad qualifiers.
John McCalled976492009-12-04 22:46:56 +00003327 if (CheckUsingDeclQualifier(UsingLoc, SS, IdentLoc))
3328 return 0;
3329
John McCallaf8e6ed2009-11-12 03:15:40 +00003330 DeclContext *LookupContext = computeDeclContext(SS);
John McCalled976492009-12-04 22:46:56 +00003331 NamedDecl *D;
John McCallaf8e6ed2009-11-12 03:15:40 +00003332 if (!LookupContext) {
John McCall7ba107a2009-11-18 02:36:19 +00003333 if (IsTypeName) {
John McCalled976492009-12-04 22:46:56 +00003334 // FIXME: not all declaration name kinds are legal here
3335 D = UnresolvedUsingTypenameDecl::Create(Context, CurContext,
3336 UsingLoc, TypenameLoc,
3337 SS.getRange(), NNS,
John McCall7ba107a2009-11-18 02:36:19 +00003338 IdentLoc, Name);
John McCalled976492009-12-04 22:46:56 +00003339 } else {
3340 D = UnresolvedUsingValueDecl::Create(Context, CurContext,
3341 UsingLoc, SS.getRange(), NNS,
3342 IdentLoc, Name);
John McCall7ba107a2009-11-18 02:36:19 +00003343 }
John McCalled976492009-12-04 22:46:56 +00003344 } else {
3345 D = UsingDecl::Create(Context, CurContext, IdentLoc,
3346 SS.getRange(), UsingLoc, NNS, Name,
3347 IsTypeName);
Anders Carlsson550b14b2009-08-28 05:49:21 +00003348 }
John McCalled976492009-12-04 22:46:56 +00003349 D->setAccess(AS);
3350 CurContext->addDecl(D);
3351
3352 if (!LookupContext) return D;
3353 UsingDecl *UD = cast<UsingDecl>(D);
Mike Stump1eb44332009-09-09 15:08:12 +00003354
John McCall604e7f12009-12-08 07:46:18 +00003355 if (RequireCompleteDeclContext(SS)) {
3356 UD->setInvalidDecl();
3357 return UD;
Anders Carlssoncf9f9212009-08-28 03:16:11 +00003358 }
3359
John McCall604e7f12009-12-08 07:46:18 +00003360 // Look up the target name.
3361
John McCalla24dc2e2009-11-17 02:14:36 +00003362 LookupResult R(*this, Name, IdentLoc, LookupOrdinaryName);
John McCall7ba107a2009-11-18 02:36:19 +00003363
John McCall604e7f12009-12-08 07:46:18 +00003364 // Unlike most lookups, we don't always want to hide tag
3365 // declarations: tag names are visible through the using declaration
3366 // even if hidden by ordinary names, *except* in a dependent context
3367 // where it's important for the sanity of two-phase lookup.
John McCall7ba107a2009-11-18 02:36:19 +00003368 if (!IsInstantiation)
3369 R.setHideTags(false);
John McCall9488ea12009-11-17 05:59:44 +00003370
John McCalla24dc2e2009-11-17 02:14:36 +00003371 LookupQualifiedName(R, LookupContext);
Mike Stump1eb44332009-09-09 15:08:12 +00003372
John McCallf36e02d2009-10-09 21:13:30 +00003373 if (R.empty()) {
Douglas Gregor3f093272009-10-13 21:16:44 +00003374 Diag(IdentLoc, diag::err_no_member)
3375 << Name << LookupContext << SS.getRange();
John McCalled976492009-12-04 22:46:56 +00003376 UD->setInvalidDecl();
3377 return UD;
Douglas Gregor9cfbe482009-06-20 00:51:54 +00003378 }
3379
John McCalled976492009-12-04 22:46:56 +00003380 if (R.isAmbiguous()) {
3381 UD->setInvalidDecl();
3382 return UD;
3383 }
Mike Stump1eb44332009-09-09 15:08:12 +00003384
John McCall7ba107a2009-11-18 02:36:19 +00003385 if (IsTypeName) {
3386 // If we asked for a typename and got a non-type decl, error out.
John McCalled976492009-12-04 22:46:56 +00003387 if (!R.getAsSingle<TypeDecl>()) {
John McCall7ba107a2009-11-18 02:36:19 +00003388 Diag(IdentLoc, diag::err_using_typename_non_type);
3389 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I)
3390 Diag((*I)->getUnderlyingDecl()->getLocation(),
3391 diag::note_using_decl_target);
John McCalled976492009-12-04 22:46:56 +00003392 UD->setInvalidDecl();
3393 return UD;
John McCall7ba107a2009-11-18 02:36:19 +00003394 }
3395 } else {
3396 // If we asked for a non-typename and we got a type, error out,
3397 // but only if this is an instantiation of an unresolved using
3398 // decl. Otherwise just silently find the type name.
John McCalled976492009-12-04 22:46:56 +00003399 if (IsInstantiation && R.getAsSingle<TypeDecl>()) {
John McCall7ba107a2009-11-18 02:36:19 +00003400 Diag(IdentLoc, diag::err_using_dependent_value_is_type);
3401 Diag(R.getFoundDecl()->getLocation(), diag::note_using_decl_target);
John McCalled976492009-12-04 22:46:56 +00003402 UD->setInvalidDecl();
3403 return UD;
John McCall7ba107a2009-11-18 02:36:19 +00003404 }
Anders Carlssoncf9f9212009-08-28 03:16:11 +00003405 }
3406
Anders Carlsson73b39cf2009-08-28 03:35:18 +00003407 // C++0x N2914 [namespace.udecl]p6:
3408 // A using-declaration shall not name a namespace.
John McCalled976492009-12-04 22:46:56 +00003409 if (R.getAsSingle<NamespaceDecl>()) {
Anders Carlsson73b39cf2009-08-28 03:35:18 +00003410 Diag(IdentLoc, diag::err_using_decl_can_not_refer_to_namespace)
3411 << SS.getRange();
John McCalled976492009-12-04 22:46:56 +00003412 UD->setInvalidDecl();
3413 return UD;
Anders Carlsson73b39cf2009-08-28 03:35:18 +00003414 }
Mike Stump1eb44332009-09-09 15:08:12 +00003415
John McCall9f54ad42009-12-10 09:41:52 +00003416 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {
3417 if (!CheckUsingShadowDecl(UD, *I, Previous))
3418 BuildUsingShadowDecl(S, UD, *I);
3419 }
John McCall9488ea12009-11-17 05:59:44 +00003420
3421 return UD;
Douglas Gregor9cfbe482009-06-20 00:51:54 +00003422}
3423
John McCall9f54ad42009-12-10 09:41:52 +00003424/// Checks that the given using declaration is not an invalid
3425/// redeclaration. Note that this is checking only for the using decl
3426/// itself, not for any ill-formedness among the UsingShadowDecls.
3427bool Sema::CheckUsingDeclRedeclaration(SourceLocation UsingLoc,
3428 bool isTypeName,
3429 const CXXScopeSpec &SS,
3430 SourceLocation NameLoc,
3431 const LookupResult &Prev) {
3432 // C++03 [namespace.udecl]p8:
3433 // C++0x [namespace.udecl]p10:
3434 // A using-declaration is a declaration and can therefore be used
3435 // repeatedly where (and only where) multiple declarations are
3436 // allowed.
3437 // That's only in file contexts.
3438 if (CurContext->getLookupContext()->isFileContext())
3439 return false;
3440
3441 NestedNameSpecifier *Qual
3442 = static_cast<NestedNameSpecifier*>(SS.getScopeRep());
3443
3444 for (LookupResult::iterator I = Prev.begin(), E = Prev.end(); I != E; ++I) {
3445 NamedDecl *D = *I;
3446
3447 bool DTypename;
3448 NestedNameSpecifier *DQual;
3449 if (UsingDecl *UD = dyn_cast<UsingDecl>(D)) {
3450 DTypename = UD->isTypeName();
3451 DQual = UD->getTargetNestedNameDecl();
3452 } else if (UnresolvedUsingValueDecl *UD
3453 = dyn_cast<UnresolvedUsingValueDecl>(D)) {
3454 DTypename = false;
3455 DQual = UD->getTargetNestedNameSpecifier();
3456 } else if (UnresolvedUsingTypenameDecl *UD
3457 = dyn_cast<UnresolvedUsingTypenameDecl>(D)) {
3458 DTypename = true;
3459 DQual = UD->getTargetNestedNameSpecifier();
3460 } else continue;
3461
3462 // using decls differ if one says 'typename' and the other doesn't.
3463 // FIXME: non-dependent using decls?
3464 if (isTypeName != DTypename) continue;
3465
3466 // using decls differ if they name different scopes (but note that
3467 // template instantiation can cause this check to trigger when it
3468 // didn't before instantiation).
3469 if (Context.getCanonicalNestedNameSpecifier(Qual) !=
3470 Context.getCanonicalNestedNameSpecifier(DQual))
3471 continue;
3472
3473 Diag(NameLoc, diag::err_using_decl_redeclaration) << SS.getRange();
John McCall41ce66f2009-12-10 19:51:03 +00003474 Diag(D->getLocation(), diag::note_using_decl) << 1;
John McCall9f54ad42009-12-10 09:41:52 +00003475 return true;
3476 }
3477
3478 return false;
3479}
3480
John McCall604e7f12009-12-08 07:46:18 +00003481
John McCalled976492009-12-04 22:46:56 +00003482/// Checks that the given nested-name qualifier used in a using decl
3483/// in the current context is appropriately related to the current
3484/// scope. If an error is found, diagnoses it and returns true.
3485bool Sema::CheckUsingDeclQualifier(SourceLocation UsingLoc,
3486 const CXXScopeSpec &SS,
3487 SourceLocation NameLoc) {
John McCall604e7f12009-12-08 07:46:18 +00003488 DeclContext *NamedContext = computeDeclContext(SS);
John McCalled976492009-12-04 22:46:56 +00003489
John McCall604e7f12009-12-08 07:46:18 +00003490 if (!CurContext->isRecord()) {
3491 // C++03 [namespace.udecl]p3:
3492 // C++0x [namespace.udecl]p8:
3493 // A using-declaration for a class member shall be a member-declaration.
3494
3495 // If we weren't able to compute a valid scope, it must be a
3496 // dependent class scope.
3497 if (!NamedContext || NamedContext->isRecord()) {
3498 Diag(NameLoc, diag::err_using_decl_can_not_refer_to_class_member)
3499 << SS.getRange();
3500 return true;
3501 }
3502
3503 // Otherwise, everything is known to be fine.
3504 return false;
3505 }
3506
3507 // The current scope is a record.
3508
3509 // If the named context is dependent, we can't decide much.
3510 if (!NamedContext) {
3511 // FIXME: in C++0x, we can diagnose if we can prove that the
3512 // nested-name-specifier does not refer to a base class, which is
3513 // still possible in some cases.
3514
3515 // Otherwise we have to conservatively report that things might be
3516 // okay.
3517 return false;
3518 }
3519
3520 if (!NamedContext->isRecord()) {
3521 // Ideally this would point at the last name in the specifier,
3522 // but we don't have that level of source info.
3523 Diag(SS.getRange().getBegin(),
3524 diag::err_using_decl_nested_name_specifier_is_not_class)
3525 << (NestedNameSpecifier*) SS.getScopeRep() << SS.getRange();
3526 return true;
3527 }
3528
3529 if (getLangOptions().CPlusPlus0x) {
3530 // C++0x [namespace.udecl]p3:
3531 // In a using-declaration used as a member-declaration, the
3532 // nested-name-specifier shall name a base class of the class
3533 // being defined.
3534
3535 if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(
3536 cast<CXXRecordDecl>(NamedContext))) {
3537 if (CurContext == NamedContext) {
3538 Diag(NameLoc,
3539 diag::err_using_decl_nested_name_specifier_is_current_class)
3540 << SS.getRange();
3541 return true;
3542 }
3543
3544 Diag(SS.getRange().getBegin(),
3545 diag::err_using_decl_nested_name_specifier_is_not_base_class)
3546 << (NestedNameSpecifier*) SS.getScopeRep()
3547 << cast<CXXRecordDecl>(CurContext)
3548 << SS.getRange();
3549 return true;
3550 }
3551
3552 return false;
3553 }
3554
3555 // C++03 [namespace.udecl]p4:
3556 // A using-declaration used as a member-declaration shall refer
3557 // to a member of a base class of the class being defined [etc.].
3558
3559 // Salient point: SS doesn't have to name a base class as long as
3560 // lookup only finds members from base classes. Therefore we can
3561 // diagnose here only if we can prove that that can't happen,
3562 // i.e. if the class hierarchies provably don't intersect.
3563
3564 // TODO: it would be nice if "definitely valid" results were cached
3565 // in the UsingDecl and UsingShadowDecl so that these checks didn't
3566 // need to be repeated.
3567
3568 struct UserData {
3569 llvm::DenseSet<const CXXRecordDecl*> Bases;
3570
3571 static bool collect(const CXXRecordDecl *Base, void *OpaqueData) {
3572 UserData *Data = reinterpret_cast<UserData*>(OpaqueData);
3573 Data->Bases.insert(Base);
3574 return true;
3575 }
3576
3577 bool hasDependentBases(const CXXRecordDecl *Class) {
3578 return !Class->forallBases(collect, this);
3579 }
3580
3581 /// Returns true if the base is dependent or is one of the
3582 /// accumulated base classes.
3583 static bool doesNotContain(const CXXRecordDecl *Base, void *OpaqueData) {
3584 UserData *Data = reinterpret_cast<UserData*>(OpaqueData);
3585 return !Data->Bases.count(Base);
3586 }
3587
3588 bool mightShareBases(const CXXRecordDecl *Class) {
3589 return Bases.count(Class) || !Class->forallBases(doesNotContain, this);
3590 }
3591 };
3592
3593 UserData Data;
3594
3595 // Returns false if we find a dependent base.
3596 if (Data.hasDependentBases(cast<CXXRecordDecl>(CurContext)))
3597 return false;
3598
3599 // Returns false if the class has a dependent base or if it or one
3600 // of its bases is present in the base set of the current context.
3601 if (Data.mightShareBases(cast<CXXRecordDecl>(NamedContext)))
3602 return false;
3603
3604 Diag(SS.getRange().getBegin(),
3605 diag::err_using_decl_nested_name_specifier_is_not_base_class)
3606 << (NestedNameSpecifier*) SS.getScopeRep()
3607 << cast<CXXRecordDecl>(CurContext)
3608 << SS.getRange();
3609
3610 return true;
John McCalled976492009-12-04 22:46:56 +00003611}
3612
Mike Stump1eb44332009-09-09 15:08:12 +00003613Sema::DeclPtrTy Sema::ActOnNamespaceAliasDef(Scope *S,
Anders Carlsson03bd5a12009-03-28 22:53:22 +00003614 SourceLocation NamespaceLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00003615 SourceLocation AliasLoc,
3616 IdentifierInfo *Alias,
3617 const CXXScopeSpec &SS,
Anders Carlsson03bd5a12009-03-28 22:53:22 +00003618 SourceLocation IdentLoc,
3619 IdentifierInfo *Ident) {
Mike Stump1eb44332009-09-09 15:08:12 +00003620
Anders Carlsson81c85c42009-03-28 23:53:49 +00003621 // Lookup the namespace name.
John McCalla24dc2e2009-11-17 02:14:36 +00003622 LookupResult R(*this, Ident, IdentLoc, LookupNamespaceName);
3623 LookupParsedName(R, S, &SS);
Anders Carlsson81c85c42009-03-28 23:53:49 +00003624
Anders Carlsson8d7ba402009-03-28 06:23:46 +00003625 // Check if we have a previous declaration with the same name.
John McCallf36e02d2009-10-09 21:13:30 +00003626 if (NamedDecl *PrevDecl
John McCall7d384dd2009-11-18 07:57:50 +00003627 = LookupSingleName(S, Alias, LookupOrdinaryName, ForRedeclaration)) {
Anders Carlsson81c85c42009-03-28 23:53:49 +00003628 if (NamespaceAliasDecl *AD = dyn_cast<NamespaceAliasDecl>(PrevDecl)) {
Mike Stump1eb44332009-09-09 15:08:12 +00003629 // We already have an alias with the same name that points to the same
Anders Carlsson81c85c42009-03-28 23:53:49 +00003630 // namespace, so don't create a new one.
John McCallf36e02d2009-10-09 21:13:30 +00003631 if (!R.isAmbiguous() && !R.empty() &&
3632 AD->getNamespace() == getNamespaceDecl(R.getFoundDecl()))
Anders Carlsson81c85c42009-03-28 23:53:49 +00003633 return DeclPtrTy();
3634 }
Mike Stump1eb44332009-09-09 15:08:12 +00003635
Anders Carlsson8d7ba402009-03-28 06:23:46 +00003636 unsigned DiagID = isa<NamespaceDecl>(PrevDecl) ? diag::err_redefinition :
3637 diag::err_redefinition_different_kind;
3638 Diag(AliasLoc, DiagID) << Alias;
3639 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
Chris Lattnerb28317a2009-03-28 19:18:32 +00003640 return DeclPtrTy();
Anders Carlsson8d7ba402009-03-28 06:23:46 +00003641 }
3642
John McCalla24dc2e2009-11-17 02:14:36 +00003643 if (R.isAmbiguous())
Chris Lattnerb28317a2009-03-28 19:18:32 +00003644 return DeclPtrTy();
Mike Stump1eb44332009-09-09 15:08:12 +00003645
John McCallf36e02d2009-10-09 21:13:30 +00003646 if (R.empty()) {
Anders Carlsson5721c682009-03-28 06:42:02 +00003647 Diag(NamespaceLoc, diag::err_expected_namespace_name) << SS.getRange();
Chris Lattnerb28317a2009-03-28 19:18:32 +00003648 return DeclPtrTy();
Anders Carlsson5721c682009-03-28 06:42:02 +00003649 }
Mike Stump1eb44332009-09-09 15:08:12 +00003650
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00003651 NamespaceAliasDecl *AliasDecl =
Mike Stump1eb44332009-09-09 15:08:12 +00003652 NamespaceAliasDecl::Create(Context, CurContext, NamespaceLoc, AliasLoc,
3653 Alias, SS.getRange(),
Douglas Gregor6c9c9402009-05-30 06:48:27 +00003654 (NestedNameSpecifier *)SS.getScopeRep(),
John McCallf36e02d2009-10-09 21:13:30 +00003655 IdentLoc, R.getFoundDecl());
Mike Stump1eb44332009-09-09 15:08:12 +00003656
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00003657 CurContext->addDecl(AliasDecl);
Anders Carlsson68771c72009-03-28 22:58:02 +00003658 return DeclPtrTy::make(AliasDecl);
Anders Carlssondbb00942009-03-28 05:27:17 +00003659}
3660
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00003661void Sema::DefineImplicitDefaultConstructor(SourceLocation CurrentLocation,
3662 CXXConstructorDecl *Constructor) {
Fariborz Jahanian05a5c452009-06-22 20:37:23 +00003663 assert((Constructor->isImplicit() && Constructor->isDefaultConstructor() &&
3664 !Constructor->isUsed()) &&
3665 "DefineImplicitDefaultConstructor - call it for implicit default ctor");
Mike Stump1eb44332009-09-09 15:08:12 +00003666
Eli Friedman80c30da2009-11-09 19:20:36 +00003667 CXXRecordDecl *ClassDecl
3668 = cast<CXXRecordDecl>(Constructor->getDeclContext());
3669 assert(ClassDecl && "DefineImplicitDefaultConstructor - invalid constructor");
Eli Friedman49c16da2009-11-09 01:05:47 +00003670
Eli Friedman80c30da2009-11-09 19:20:36 +00003671 if (SetBaseOrMemberInitializers(Constructor, 0, 0, true)) {
Anders Carlsson37909802009-11-30 21:24:50 +00003672 Diag(CurrentLocation, diag::note_member_synthesized_at)
3673 << CXXDefaultConstructor << Context.getTagDeclType(ClassDecl);
Eli Friedman80c30da2009-11-09 19:20:36 +00003674 Constructor->setInvalidDecl();
3675 } else {
3676 Constructor->setUsed();
3677 }
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00003678}
3679
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003680void Sema::DefineImplicitDestructor(SourceLocation CurrentLocation,
Douglas Gregor4fe95f92009-09-04 19:04:08 +00003681 CXXDestructorDecl *Destructor) {
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003682 assert((Destructor->isImplicit() && !Destructor->isUsed()) &&
3683 "DefineImplicitDestructor - call it for implicit default dtor");
Anders Carlsson6d701392009-11-15 22:49:34 +00003684 CXXRecordDecl *ClassDecl = Destructor->getParent();
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003685 assert(ClassDecl && "DefineImplicitDestructor - invalid destructor");
3686 // C++ [class.dtor] p5
Mike Stump1eb44332009-09-09 15:08:12 +00003687 // Before the implicitly-declared default destructor for a class is
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003688 // implicitly defined, all the implicitly-declared default destructors
3689 // for its base class and its non-static data members shall have been
3690 // implicitly defined.
Fariborz Jahanian514b7b12009-06-30 16:36:53 +00003691 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
3692 E = ClassDecl->bases_end(); Base != E; ++Base) {
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003693 CXXRecordDecl *BaseClassDecl
Ted Kremenek6217b802009-07-29 21:53:49 +00003694 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003695 if (!BaseClassDecl->hasTrivialDestructor()) {
Mike Stump1eb44332009-09-09 15:08:12 +00003696 if (CXXDestructorDecl *BaseDtor =
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003697 const_cast<CXXDestructorDecl*>(BaseClassDecl->getDestructor(Context)))
3698 MarkDeclarationReferenced(CurrentLocation, BaseDtor);
3699 else
Mike Stump1eb44332009-09-09 15:08:12 +00003700 assert(false &&
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003701 "DefineImplicitDestructor - missing dtor in a base class");
3702 }
3703 }
Mike Stump1eb44332009-09-09 15:08:12 +00003704
Fariborz Jahanian514b7b12009-06-30 16:36:53 +00003705 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
3706 E = ClassDecl->field_end(); Field != E; ++Field) {
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003707 QualType FieldType = Context.getCanonicalType((*Field)->getType());
3708 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
3709 FieldType = Array->getElementType();
Ted Kremenek6217b802009-07-29 21:53:49 +00003710 if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003711 CXXRecordDecl *FieldClassDecl
3712 = cast<CXXRecordDecl>(FieldClassType->getDecl());
3713 if (!FieldClassDecl->hasTrivialDestructor()) {
Mike Stump1eb44332009-09-09 15:08:12 +00003714 if (CXXDestructorDecl *FieldDtor =
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003715 const_cast<CXXDestructorDecl*>(
3716 FieldClassDecl->getDestructor(Context)))
3717 MarkDeclarationReferenced(CurrentLocation, FieldDtor);
3718 else
Mike Stump1eb44332009-09-09 15:08:12 +00003719 assert(false &&
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003720 "DefineImplicitDestructor - missing dtor in class of a data member");
3721 }
3722 }
3723 }
Anders Carlsson37909802009-11-30 21:24:50 +00003724
3725 // FIXME: If CheckDestructor fails, we should emit a note about where the
3726 // implicit destructor was needed.
3727 if (CheckDestructor(Destructor)) {
3728 Diag(CurrentLocation, diag::note_member_synthesized_at)
3729 << CXXDestructor << Context.getTagDeclType(ClassDecl);
3730
3731 Destructor->setInvalidDecl();
3732 return;
3733 }
3734
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003735 Destructor->setUsed();
3736}
3737
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003738void Sema::DefineImplicitOverloadedAssign(SourceLocation CurrentLocation,
3739 CXXMethodDecl *MethodDecl) {
3740 assert((MethodDecl->isImplicit() && MethodDecl->isOverloadedOperator() &&
3741 MethodDecl->getOverloadedOperator() == OO_Equal &&
3742 !MethodDecl->isUsed()) &&
3743 "DefineImplicitOverloadedAssign - call it for implicit assignment op");
Mike Stump1eb44332009-09-09 15:08:12 +00003744
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003745 CXXRecordDecl *ClassDecl
3746 = cast<CXXRecordDecl>(MethodDecl->getDeclContext());
Mike Stump1eb44332009-09-09 15:08:12 +00003747
Fariborz Jahanianc6249b92009-06-26 16:08:57 +00003748 // C++[class.copy] p12
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003749 // Before the implicitly-declared copy assignment operator for a class is
3750 // implicitly defined, all implicitly-declared copy assignment operators
3751 // for its direct base classes and its nonstatic data members shall have
3752 // been implicitly defined.
3753 bool err = false;
Fariborz Jahanian514b7b12009-06-30 16:36:53 +00003754 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
3755 E = ClassDecl->bases_end(); Base != E; ++Base) {
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003756 CXXRecordDecl *BaseClassDecl
Ted Kremenek6217b802009-07-29 21:53:49 +00003757 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Mike Stump1eb44332009-09-09 15:08:12 +00003758 if (CXXMethodDecl *BaseAssignOpMethod =
Anders Carlssonb6cc91b2009-12-09 03:01:51 +00003759 getAssignOperatorMethod(CurrentLocation, MethodDecl->getParamDecl(0),
3760 BaseClassDecl))
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003761 MarkDeclarationReferenced(CurrentLocation, BaseAssignOpMethod);
3762 }
Fariborz Jahanian514b7b12009-06-30 16:36:53 +00003763 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
3764 E = ClassDecl->field_end(); Field != E; ++Field) {
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003765 QualType FieldType = Context.getCanonicalType((*Field)->getType());
3766 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
3767 FieldType = Array->getElementType();
Ted Kremenek6217b802009-07-29 21:53:49 +00003768 if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003769 CXXRecordDecl *FieldClassDecl
3770 = cast<CXXRecordDecl>(FieldClassType->getDecl());
Mike Stump1eb44332009-09-09 15:08:12 +00003771 if (CXXMethodDecl *FieldAssignOpMethod =
Anders Carlssonb6cc91b2009-12-09 03:01:51 +00003772 getAssignOperatorMethod(CurrentLocation, MethodDecl->getParamDecl(0),
3773 FieldClassDecl))
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003774 MarkDeclarationReferenced(CurrentLocation, FieldAssignOpMethod);
Mike Stumpac5fc7c2009-08-04 21:02:39 +00003775 } else if (FieldType->isReferenceType()) {
Mike Stump1eb44332009-09-09 15:08:12 +00003776 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
Anders Carlsson5e09d4c2009-07-09 17:47:25 +00003777 << Context.getTagDeclType(ClassDecl) << 0 << Field->getDeclName();
3778 Diag(Field->getLocation(), diag::note_declared_at);
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003779 Diag(CurrentLocation, diag::note_first_required_here);
3780 err = true;
Mike Stumpac5fc7c2009-08-04 21:02:39 +00003781 } else if (FieldType.isConstQualified()) {
Mike Stump1eb44332009-09-09 15:08:12 +00003782 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
Anders Carlsson5e09d4c2009-07-09 17:47:25 +00003783 << Context.getTagDeclType(ClassDecl) << 1 << Field->getDeclName();
3784 Diag(Field->getLocation(), diag::note_declared_at);
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003785 Diag(CurrentLocation, diag::note_first_required_here);
3786 err = true;
3787 }
3788 }
3789 if (!err)
Mike Stump1eb44332009-09-09 15:08:12 +00003790 MethodDecl->setUsed();
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003791}
3792
3793CXXMethodDecl *
Anders Carlssonb6cc91b2009-12-09 03:01:51 +00003794Sema::getAssignOperatorMethod(SourceLocation CurrentLocation,
3795 ParmVarDecl *ParmDecl,
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003796 CXXRecordDecl *ClassDecl) {
3797 QualType LHSType = Context.getTypeDeclType(ClassDecl);
3798 QualType RHSType(LHSType);
3799 // If class's assignment operator argument is const/volatile qualified,
Mike Stump1eb44332009-09-09 15:08:12 +00003800 // look for operator = (const/volatile B&). Otherwise, look for
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003801 // operator = (B&).
John McCall0953e762009-09-24 19:53:00 +00003802 RHSType = Context.getCVRQualifiedType(RHSType,
3803 ParmDecl->getType().getCVRQualifiers());
Mike Stump1eb44332009-09-09 15:08:12 +00003804 ExprOwningPtr<Expr> LHS(this, new (Context) DeclRefExpr(ParmDecl,
Anders Carlssonb6cc91b2009-12-09 03:01:51 +00003805 LHSType,
3806 SourceLocation()));
Mike Stump1eb44332009-09-09 15:08:12 +00003807 ExprOwningPtr<Expr> RHS(this, new (Context) DeclRefExpr(ParmDecl,
Anders Carlssonb6cc91b2009-12-09 03:01:51 +00003808 RHSType,
3809 CurrentLocation));
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003810 Expr *Args[2] = { &*LHS, &*RHS };
3811 OverloadCandidateSet CandidateSet;
Mike Stump1eb44332009-09-09 15:08:12 +00003812 AddMemberOperatorCandidates(clang::OO_Equal, SourceLocation(), Args, 2,
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003813 CandidateSet);
3814 OverloadCandidateSet::iterator Best;
Anders Carlssonb6cc91b2009-12-09 03:01:51 +00003815 if (BestViableFunction(CandidateSet, CurrentLocation, Best) == OR_Success)
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003816 return cast<CXXMethodDecl>(Best->Function);
3817 assert(false &&
3818 "getAssignOperatorMethod - copy assignment operator method not found");
3819 return 0;
3820}
3821
Fariborz Jahanian485f0872009-06-22 23:34:40 +00003822void Sema::DefineImplicitCopyConstructor(SourceLocation CurrentLocation,
3823 CXXConstructorDecl *CopyConstructor,
3824 unsigned TypeQuals) {
Mike Stump1eb44332009-09-09 15:08:12 +00003825 assert((CopyConstructor->isImplicit() &&
Douglas Gregor9e9199d2009-12-22 00:34:07 +00003826 CopyConstructor->isCopyConstructor(TypeQuals) &&
Fariborz Jahanian485f0872009-06-22 23:34:40 +00003827 !CopyConstructor->isUsed()) &&
3828 "DefineImplicitCopyConstructor - call it for implicit copy ctor");
Mike Stump1eb44332009-09-09 15:08:12 +00003829
Fariborz Jahanian485f0872009-06-22 23:34:40 +00003830 CXXRecordDecl *ClassDecl
3831 = cast<CXXRecordDecl>(CopyConstructor->getDeclContext());
3832 assert(ClassDecl && "DefineImplicitCopyConstructor - invalid constructor");
Fariborz Jahanian220a0f32009-06-23 23:42:10 +00003833 // C++ [class.copy] p209
Mike Stump1eb44332009-09-09 15:08:12 +00003834 // Before the implicitly-declared copy constructor for a class is
Fariborz Jahanian485f0872009-06-22 23:34:40 +00003835 // implicitly defined, all the implicitly-declared copy constructors
3836 // for its base class and its non-static data members shall have been
3837 // implicitly defined.
3838 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin();
3839 Base != ClassDecl->bases_end(); ++Base) {
3840 CXXRecordDecl *BaseClassDecl
Ted Kremenek6217b802009-07-29 21:53:49 +00003841 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Mike Stump1eb44332009-09-09 15:08:12 +00003842 if (CXXConstructorDecl *BaseCopyCtor =
Fariborz Jahanian485f0872009-06-22 23:34:40 +00003843 BaseClassDecl->getCopyConstructor(Context, TypeQuals))
Fariborz Jahanian220a0f32009-06-23 23:42:10 +00003844 MarkDeclarationReferenced(CurrentLocation, BaseCopyCtor);
Fariborz Jahanian485f0872009-06-22 23:34:40 +00003845 }
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00003846 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
3847 FieldEnd = ClassDecl->field_end();
3848 Field != FieldEnd; ++Field) {
Fariborz Jahanian485f0872009-06-22 23:34:40 +00003849 QualType FieldType = Context.getCanonicalType((*Field)->getType());
3850 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
3851 FieldType = Array->getElementType();
Ted Kremenek6217b802009-07-29 21:53:49 +00003852 if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
Fariborz Jahanian485f0872009-06-22 23:34:40 +00003853 CXXRecordDecl *FieldClassDecl
3854 = cast<CXXRecordDecl>(FieldClassType->getDecl());
Mike Stump1eb44332009-09-09 15:08:12 +00003855 if (CXXConstructorDecl *FieldCopyCtor =
Fariborz Jahanian485f0872009-06-22 23:34:40 +00003856 FieldClassDecl->getCopyConstructor(Context, TypeQuals))
Fariborz Jahanian220a0f32009-06-23 23:42:10 +00003857 MarkDeclarationReferenced(CurrentLocation, FieldCopyCtor);
Fariborz Jahanian485f0872009-06-22 23:34:40 +00003858 }
3859 }
3860 CopyConstructor->setUsed();
3861}
3862
Anders Carlssonda3f4e22009-08-25 05:12:04 +00003863Sema::OwningExprResult
Anders Carlssonec8e5ea2009-09-05 07:40:38 +00003864Sema::BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
Mike Stump1eb44332009-09-09 15:08:12 +00003865 CXXConstructorDecl *Constructor,
Douglas Gregor16006c92009-12-16 18:50:27 +00003866 MultiExprArg ExprArgs,
3867 bool RequiresZeroInit) {
Anders Carlsson9abf2ae2009-08-16 05:13:48 +00003868 bool Elidable = false;
Mike Stump1eb44332009-09-09 15:08:12 +00003869
Douglas Gregor39da0b82009-09-09 23:08:42 +00003870 // C++ [class.copy]p15:
3871 // Whenever a temporary class object is copied using a copy constructor, and
3872 // this object and the copy have the same cv-unqualified type, an
3873 // implementation is permitted to treat the original and the copy as two
3874 // different ways of referring to the same object and not perform a copy at
3875 // all, even if the class copy constructor or destructor have side effects.
Mike Stump1eb44332009-09-09 15:08:12 +00003876
Anders Carlsson9abf2ae2009-08-16 05:13:48 +00003877 // FIXME: Is this enough?
Douglas Gregor9e9199d2009-12-22 00:34:07 +00003878 if (Constructor->isCopyConstructor()) {
Anders Carlssonf47511a2009-09-07 22:23:31 +00003879 Expr *E = ((Expr **)ExprArgs.get())[0];
Douglas Gregor18ef5e22009-12-18 05:02:21 +00003880 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
3881 if (ICE->getCastKind() == CastExpr::CK_NoOp)
3882 E = ICE->getSubExpr();
Eli Friedmancb48f8a2009-12-24 23:33:34 +00003883 if (CXXFunctionalCastExpr *FCE = dyn_cast<CXXFunctionalCastExpr>(E))
3884 E = FCE->getSubExpr();
Anders Carlsson9abf2ae2009-08-16 05:13:48 +00003885 while (CXXBindTemporaryExpr *BE = dyn_cast<CXXBindTemporaryExpr>(E))
3886 E = BE->getSubExpr();
Douglas Gregor39da0b82009-09-09 23:08:42 +00003887 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
3888 if (ICE->getCastKind() == CastExpr::CK_NoOp)
3889 E = ICE->getSubExpr();
Eli Friedman03368432009-12-06 09:26:33 +00003890
3891 if (CallExpr *CE = dyn_cast<CallExpr>(E))
3892 Elidable = !CE->getCallReturnType()->isReferenceType();
3893 else if (isa<CXXTemporaryObjectExpr>(E))
Anders Carlsson9abf2ae2009-08-16 05:13:48 +00003894 Elidable = true;
Eli Friedmancb48f8a2009-12-24 23:33:34 +00003895 else if (isa<CXXConstructExpr>(E))
3896 Elidable = true;
Anders Carlsson9abf2ae2009-08-16 05:13:48 +00003897 }
Mike Stump1eb44332009-09-09 15:08:12 +00003898
3899 return BuildCXXConstructExpr(ConstructLoc, DeclInitType, Constructor,
Douglas Gregor16006c92009-12-16 18:50:27 +00003900 Elidable, move(ExprArgs), RequiresZeroInit);
Anders Carlsson9abf2ae2009-08-16 05:13:48 +00003901}
3902
Fariborz Jahanianb2c352e2009-08-05 17:03:54 +00003903/// BuildCXXConstructExpr - Creates a complete call to a constructor,
3904/// including handling of its default argument expressions.
Anders Carlssonda3f4e22009-08-25 05:12:04 +00003905Sema::OwningExprResult
Anders Carlssonec8e5ea2009-09-05 07:40:38 +00003906Sema::BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
3907 CXXConstructorDecl *Constructor, bool Elidable,
Douglas Gregor16006c92009-12-16 18:50:27 +00003908 MultiExprArg ExprArgs,
3909 bool RequiresZeroInit) {
Anders Carlssonf47511a2009-09-07 22:23:31 +00003910 unsigned NumExprs = ExprArgs.size();
3911 Expr **Exprs = (Expr **)ExprArgs.release();
Mike Stump1eb44332009-09-09 15:08:12 +00003912
Douglas Gregor7edfb692009-11-23 12:27:39 +00003913 MarkDeclarationReferenced(ConstructLoc, Constructor);
Douglas Gregor99a2e602009-12-16 01:38:02 +00003914 return Owned(CXXConstructExpr::Create(Context, DeclInitType, ConstructLoc,
Douglas Gregor16006c92009-12-16 18:50:27 +00003915 Constructor, Elidable, Exprs, NumExprs,
3916 RequiresZeroInit));
Fariborz Jahanianb2c352e2009-08-05 17:03:54 +00003917}
3918
Anders Carlssone7624a72009-08-27 05:08:22 +00003919Sema::OwningExprResult
Mike Stump1eb44332009-09-09 15:08:12 +00003920Sema::BuildCXXTemporaryObjectExpr(CXXConstructorDecl *Constructor,
3921 QualType Ty,
3922 SourceLocation TyBeginLoc,
Anders Carlssone7624a72009-08-27 05:08:22 +00003923 MultiExprArg Args,
3924 SourceLocation RParenLoc) {
Douglas Gregor39da0b82009-09-09 23:08:42 +00003925 unsigned NumExprs = Args.size();
3926 Expr **Exprs = (Expr **)Args.release();
Mike Stump1eb44332009-09-09 15:08:12 +00003927
Douglas Gregor7edfb692009-11-23 12:27:39 +00003928 MarkDeclarationReferenced(TyBeginLoc, Constructor);
Douglas Gregor39da0b82009-09-09 23:08:42 +00003929 return Owned(new (Context) CXXTemporaryObjectExpr(Context, Constructor, Ty,
3930 TyBeginLoc, Exprs,
3931 NumExprs, RParenLoc));
Anders Carlssone7624a72009-08-27 05:08:22 +00003932}
3933
3934
Mike Stump1eb44332009-09-09 15:08:12 +00003935bool Sema::InitializeVarWithConstructor(VarDecl *VD,
Fariborz Jahanianb2c352e2009-08-05 17:03:54 +00003936 CXXConstructorDecl *Constructor,
Anders Carlssonf47511a2009-09-07 22:23:31 +00003937 MultiExprArg Exprs) {
Mike Stump1eb44332009-09-09 15:08:12 +00003938 OwningExprResult TempResult =
Fariborz Jahanianc0fcce42009-10-28 18:41:06 +00003939 BuildCXXConstructExpr(VD->getLocation(), VD->getType(), Constructor,
Anders Carlssonf47511a2009-09-07 22:23:31 +00003940 move(Exprs));
Anders Carlssonfe2de492009-08-25 05:18:00 +00003941 if (TempResult.isInvalid())
3942 return true;
Mike Stump1eb44332009-09-09 15:08:12 +00003943
Anders Carlssonda3f4e22009-08-25 05:12:04 +00003944 Expr *Temp = TempResult.takeAs<Expr>();
Douglas Gregord7f37bf2009-06-22 23:06:13 +00003945 MarkDeclarationReferenced(VD->getLocation(), Constructor);
Anders Carlsson0ece4912009-12-15 20:51:39 +00003946 Temp = MaybeCreateCXXExprWithTemporaries(Temp);
Douglas Gregor78d15832009-05-26 18:54:04 +00003947 VD->setInit(Context, Temp);
Mike Stump1eb44332009-09-09 15:08:12 +00003948
Anders Carlssonfe2de492009-08-25 05:18:00 +00003949 return false;
Anders Carlsson930e8d02009-04-16 23:50:50 +00003950}
3951
Mike Stump1eb44332009-09-09 15:08:12 +00003952void Sema::FinalizeVarWithDestructor(VarDecl *VD, QualType DeclInitType) {
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003953 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(
Ted Kremenek6217b802009-07-29 21:53:49 +00003954 DeclInitType->getAs<RecordType>()->getDecl());
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003955 if (!ClassDecl->hasTrivialDestructor())
Mike Stump1eb44332009-09-09 15:08:12 +00003956 if (CXXDestructorDecl *Destructor =
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003957 const_cast<CXXDestructorDecl*>(ClassDecl->getDestructor(Context)))
Fariborz Jahaniana83f7ed2009-08-03 19:13:25 +00003958 MarkDeclarationReferenced(VD->getLocation(), Destructor);
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003959}
3960
Mike Stump1eb44332009-09-09 15:08:12 +00003961/// AddCXXDirectInitializerToDecl - This action is called immediately after
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00003962/// ActOnDeclarator, when a C++ direct initializer is present.
3963/// e.g: "int x(1);"
Chris Lattnerb28317a2009-03-28 19:18:32 +00003964void Sema::AddCXXDirectInitializerToDecl(DeclPtrTy Dcl,
3965 SourceLocation LParenLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +00003966 MultiExprArg Exprs,
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00003967 SourceLocation *CommaLocs,
3968 SourceLocation RParenLoc) {
Daniel Dunbar51846262009-12-24 19:19:26 +00003969 assert(Exprs.size() != 0 && Exprs.get() && "missing expressions");
Chris Lattnerb28317a2009-03-28 19:18:32 +00003970 Decl *RealDecl = Dcl.getAs<Decl>();
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00003971
3972 // If there is no declaration, there was an error parsing it. Just ignore
3973 // the initializer.
Chris Lattnerb28317a2009-03-28 19:18:32 +00003974 if (RealDecl == 0)
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00003975 return;
Mike Stump1eb44332009-09-09 15:08:12 +00003976
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00003977 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
3978 if (!VDecl) {
3979 Diag(RealDecl->getLocation(), diag::err_illegal_initializer);
3980 RealDecl->setInvalidDecl();
3981 return;
3982 }
3983
Douglas Gregor83ddad32009-08-26 21:14:46 +00003984 // We will represent direct-initialization similarly to copy-initialization:
Argyrios Kyrtzidisce8e2922008-10-06 23:08:37 +00003985 // int x(1); -as-> int x = 1;
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00003986 // ClassType x(a,b,c); -as-> ClassType x = ClassType(a,b,c);
3987 //
3988 // Clients that want to distinguish between the two forms, can check for
3989 // direct initializer using VarDecl::hasCXXDirectInitializer().
3990 // A major benefit is that clients that don't particularly care about which
3991 // exactly form was it (like the CodeGen) can handle both cases without
3992 // special case code.
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +00003993
Douglas Gregor83ddad32009-08-26 21:14:46 +00003994 // If either the declaration has a dependent type or if any of the expressions
3995 // is type-dependent, we represent the initialization via a ParenListExpr for
3996 // later use during template instantiation.
3997 if (VDecl->getType()->isDependentType() ||
3998 Expr::hasAnyTypeDependentArguments((Expr **)Exprs.get(), Exprs.size())) {
3999 // Let clients know that initialization was done with a direct initializer.
4000 VDecl->setCXXDirectInitializer(true);
Mike Stump1eb44332009-09-09 15:08:12 +00004001
Douglas Gregor83ddad32009-08-26 21:14:46 +00004002 // Store the initialization expressions as a ParenListExpr.
4003 unsigned NumExprs = Exprs.size();
Mike Stump1eb44332009-09-09 15:08:12 +00004004 VDecl->setInit(Context,
Douglas Gregor83ddad32009-08-26 21:14:46 +00004005 new (Context) ParenListExpr(Context, LParenLoc,
4006 (Expr **)Exprs.release(),
4007 NumExprs, RParenLoc));
4008 return;
4009 }
Mike Stump1eb44332009-09-09 15:08:12 +00004010
Douglas Gregor83ddad32009-08-26 21:14:46 +00004011
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00004012 // C++ 8.5p11:
4013 // The form of initialization (using parentheses or '=') is generally
4014 // insignificant, but does matter when the entity being initialized has a
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +00004015 // class type.
Douglas Gregor18fe5682008-11-03 20:45:27 +00004016 QualType DeclInitType = VDecl->getType();
4017 if (const ArrayType *Array = Context.getAsArrayType(DeclInitType))
Fariborz Jahanian680a3f32009-10-28 19:04:36 +00004018 DeclInitType = Context.getBaseElementType(Array);
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +00004019
Douglas Gregor615c5d42009-03-24 16:43:20 +00004020 if (RequireCompleteType(VDecl->getLocation(), VDecl->getType(),
4021 diag::err_typecheck_decl_incomplete_type)) {
4022 VDecl->setInvalidDecl();
4023 return;
4024 }
4025
Douglas Gregor90f93822009-12-22 22:17:25 +00004026 // The variable can not have an abstract class type.
4027 if (RequireNonAbstractType(VDecl->getLocation(), VDecl->getType(),
4028 diag::err_abstract_type_in_decl,
4029 AbstractVariableType))
4030 VDecl->setInvalidDecl();
4031
4032 const VarDecl *Def = 0;
4033 if (VDecl->getDefinition(Def)) {
4034 Diag(VDecl->getLocation(), diag::err_redefinition)
4035 << VDecl->getDeclName();
4036 Diag(Def->getLocation(), diag::note_previous_definition);
4037 VDecl->setInvalidDecl();
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +00004038 return;
4039 }
Douglas Gregor90f93822009-12-22 22:17:25 +00004040
4041 // Capture the variable that is being initialized and the style of
4042 // initialization.
4043 InitializedEntity Entity = InitializedEntity::InitializeVariable(VDecl);
4044
4045 // FIXME: Poor source location information.
4046 InitializationKind Kind
4047 = InitializationKind::CreateDirect(VDecl->getLocation(),
4048 LParenLoc, RParenLoc);
4049
4050 InitializationSequence InitSeq(*this, Entity, Kind,
4051 (Expr**)Exprs.get(), Exprs.size());
4052 OwningExprResult Result = InitSeq.Perform(*this, Entity, Kind, move(Exprs));
4053 if (Result.isInvalid()) {
4054 VDecl->setInvalidDecl();
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00004055 return;
4056 }
Douglas Gregor90f93822009-12-22 22:17:25 +00004057
4058 Result = MaybeCreateCXXExprWithTemporaries(move(Result));
4059 VDecl->setInit(Context, Result.takeAs<Expr>());
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00004060 VDecl->setCXXDirectInitializer(true);
Argyrios Kyrtzidisce8e2922008-10-06 23:08:37 +00004061
Douglas Gregor90f93822009-12-22 22:17:25 +00004062 if (VDecl->getType()->getAs<RecordType>())
4063 FinalizeVarWithDestructor(VDecl, DeclInitType);
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00004064}
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004065
Douglas Gregor19aeac62009-11-14 03:27:21 +00004066/// \brief Add the applicable constructor candidates for an initialization
4067/// by constructor.
4068static void AddConstructorInitializationCandidates(Sema &SemaRef,
4069 QualType ClassType,
4070 Expr **Args,
4071 unsigned NumArgs,
Douglas Gregor20093b42009-12-09 23:02:17 +00004072 InitializationKind Kind,
Douglas Gregor19aeac62009-11-14 03:27:21 +00004073 OverloadCandidateSet &CandidateSet) {
4074 // C++ [dcl.init]p14:
4075 // If the initialization is direct-initialization, or if it is
4076 // copy-initialization where the cv-unqualified version of the
4077 // source type is the same class as, or a derived class of, the
4078 // class of the destination, constructors are considered. The
4079 // applicable constructors are enumerated (13.3.1.3), and the
4080 // best one is chosen through overload resolution (13.3). The
4081 // constructor so selected is called to initialize the object,
4082 // with the initializer expression(s) as its argument(s). If no
4083 // constructor applies, or the overload resolution is ambiguous,
4084 // the initialization is ill-formed.
4085 const RecordType *ClassRec = ClassType->getAs<RecordType>();
4086 assert(ClassRec && "Can only initialize a class type here");
4087
4088 // FIXME: When we decide not to synthesize the implicitly-declared
4089 // constructors, we'll need to make them appear here.
4090
4091 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(ClassRec->getDecl());
4092 DeclarationName ConstructorName
4093 = SemaRef.Context.DeclarationNames.getCXXConstructorName(
4094 SemaRef.Context.getCanonicalType(ClassType).getUnqualifiedType());
4095 DeclContext::lookup_const_iterator Con, ConEnd;
4096 for (llvm::tie(Con, ConEnd) = ClassDecl->lookup(ConstructorName);
4097 Con != ConEnd; ++Con) {
4098 // Find the constructor (which may be a template).
4099 CXXConstructorDecl *Constructor = 0;
4100 FunctionTemplateDecl *ConstructorTmpl= dyn_cast<FunctionTemplateDecl>(*Con);
4101 if (ConstructorTmpl)
4102 Constructor
4103 = cast<CXXConstructorDecl>(ConstructorTmpl->getTemplatedDecl());
4104 else
4105 Constructor = cast<CXXConstructorDecl>(*Con);
4106
Douglas Gregor20093b42009-12-09 23:02:17 +00004107 if ((Kind.getKind() == InitializationKind::IK_Direct) ||
4108 (Kind.getKind() == InitializationKind::IK_Value) ||
4109 (Kind.getKind() == InitializationKind::IK_Copy &&
Douglas Gregor19aeac62009-11-14 03:27:21 +00004110 Constructor->isConvertingConstructor(/*AllowExplicit=*/false)) ||
Douglas Gregor20093b42009-12-09 23:02:17 +00004111 ((Kind.getKind() == InitializationKind::IK_Default) &&
4112 Constructor->isDefaultConstructor())) {
Douglas Gregor19aeac62009-11-14 03:27:21 +00004113 if (ConstructorTmpl)
John McCalld5532b62009-11-23 01:53:49 +00004114 SemaRef.AddTemplateOverloadCandidate(ConstructorTmpl,
John McCall86820f52010-01-26 01:37:31 +00004115 ConstructorTmpl->getAccess(),
John McCalld5532b62009-11-23 01:53:49 +00004116 /*ExplicitArgs*/ 0,
Douglas Gregor19aeac62009-11-14 03:27:21 +00004117 Args, NumArgs, CandidateSet);
4118 else
John McCall86820f52010-01-26 01:37:31 +00004119 SemaRef.AddOverloadCandidate(Constructor, Constructor->getAccess(),
4120 Args, NumArgs, CandidateSet);
Douglas Gregor19aeac62009-11-14 03:27:21 +00004121 }
4122 }
4123}
4124
4125/// \brief Attempt to perform initialization by constructor
4126/// (C++ [dcl.init]p14), which may occur as part of direct-initialization or
4127/// copy-initialization.
4128///
4129/// This routine determines whether initialization by constructor is possible,
4130/// but it does not emit any diagnostics in the case where the initialization
4131/// is ill-formed.
4132///
4133/// \param ClassType the type of the object being initialized, which must have
4134/// class type.
4135///
4136/// \param Args the arguments provided to initialize the object
4137///
4138/// \param NumArgs the number of arguments provided to initialize the object
4139///
4140/// \param Kind the type of initialization being performed
4141///
4142/// \returns the constructor used to initialize the object, if successful.
4143/// Otherwise, emits a diagnostic and returns NULL.
4144CXXConstructorDecl *
4145Sema::TryInitializationByConstructor(QualType ClassType,
4146 Expr **Args, unsigned NumArgs,
4147 SourceLocation Loc,
4148 InitializationKind Kind) {
4149 // Build the overload candidate set
4150 OverloadCandidateSet CandidateSet;
4151 AddConstructorInitializationCandidates(*this, ClassType, Args, NumArgs, Kind,
4152 CandidateSet);
4153
4154 // Determine whether we found a constructor we can use.
4155 OverloadCandidateSet::iterator Best;
4156 switch (BestViableFunction(CandidateSet, Loc, Best)) {
4157 case OR_Success:
4158 case OR_Deleted:
4159 // We found a constructor. Return it.
4160 return cast<CXXConstructorDecl>(Best->Function);
4161
4162 case OR_No_Viable_Function:
4163 case OR_Ambiguous:
4164 // Overload resolution failed. Return nothing.
4165 return 0;
4166 }
4167
4168 // Silence GCC warning
4169 return 0;
4170}
4171
Douglas Gregor39da0b82009-09-09 23:08:42 +00004172/// \brief Perform initialization by constructor (C++ [dcl.init]p14), which
4173/// may occur as part of direct-initialization or copy-initialization.
4174///
4175/// \param ClassType the type of the object being initialized, which must have
4176/// class type.
4177///
4178/// \param ArgsPtr the arguments provided to initialize the object
4179///
4180/// \param Loc the source location where the initialization occurs
4181///
4182/// \param Range the source range that covers the entire initialization
4183///
4184/// \param InitEntity the name of the entity being initialized, if known
4185///
4186/// \param Kind the type of initialization being performed
4187///
4188/// \param ConvertedArgs a vector that will be filled in with the
4189/// appropriately-converted arguments to the constructor (if initialization
4190/// succeeded).
4191///
4192/// \returns the constructor used to initialize the object, if successful.
4193/// Otherwise, emits a diagnostic and returns NULL.
Douglas Gregor18fe5682008-11-03 20:45:27 +00004194CXXConstructorDecl *
Douglas Gregorf03d7c72008-11-05 15:29:30 +00004195Sema::PerformInitializationByConstructor(QualType ClassType,
Douglas Gregor39da0b82009-09-09 23:08:42 +00004196 MultiExprArg ArgsPtr,
Douglas Gregorf03d7c72008-11-05 15:29:30 +00004197 SourceLocation Loc, SourceRange Range,
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00004198 DeclarationName InitEntity,
Douglas Gregor39da0b82009-09-09 23:08:42 +00004199 InitializationKind Kind,
4200 ASTOwningVector<&ActionBase::DeleteExpr> &ConvertedArgs) {
Douglas Gregor19aeac62009-11-14 03:27:21 +00004201
4202 // Build the overload candidate set
Douglas Gregor39da0b82009-09-09 23:08:42 +00004203 Expr **Args = (Expr **)ArgsPtr.get();
4204 unsigned NumArgs = ArgsPtr.size();
Douglas Gregor18fe5682008-11-03 20:45:27 +00004205 OverloadCandidateSet CandidateSet;
Douglas Gregor19aeac62009-11-14 03:27:21 +00004206 AddConstructorInitializationCandidates(*this, ClassType, Args, NumArgs, Kind,
4207 CandidateSet);
Douglas Gregor9e7d9de2008-12-15 21:24:18 +00004208
Douglas Gregor18fe5682008-11-03 20:45:27 +00004209 OverloadCandidateSet::iterator Best;
Douglas Gregore0762c92009-06-19 23:52:42 +00004210 switch (BestViableFunction(CandidateSet, Loc, Best)) {
Douglas Gregor18fe5682008-11-03 20:45:27 +00004211 case OR_Success:
Douglas Gregor39da0b82009-09-09 23:08:42 +00004212 // We found a constructor. Break out so that we can convert the arguments
4213 // appropriately.
4214 break;
Mike Stump1eb44332009-09-09 15:08:12 +00004215
Douglas Gregor18fe5682008-11-03 20:45:27 +00004216 case OR_No_Viable_Function:
Douglas Gregor87fd7032009-02-02 17:43:21 +00004217 if (InitEntity)
4218 Diag(Loc, diag::err_ovl_no_viable_function_in_init)
Chris Lattner4330d652009-02-17 07:29:20 +00004219 << InitEntity << Range;
Douglas Gregor87fd7032009-02-02 17:43:21 +00004220 else
4221 Diag(Loc, diag::err_ovl_no_viable_function_in_init)
Chris Lattner4330d652009-02-17 07:29:20 +00004222 << ClassType << Range;
John McCallcbce6062010-01-12 07:18:19 +00004223 PrintOverloadCandidates(CandidateSet, OCD_AllCandidates, Args, NumArgs);
Douglas Gregor18fe5682008-11-03 20:45:27 +00004224 return 0;
Mike Stump1eb44332009-09-09 15:08:12 +00004225
Douglas Gregor18fe5682008-11-03 20:45:27 +00004226 case OR_Ambiguous:
Douglas Gregor87fd7032009-02-02 17:43:21 +00004227 if (InitEntity)
4228 Diag(Loc, diag::err_ovl_ambiguous_init) << InitEntity << Range;
4229 else
4230 Diag(Loc, diag::err_ovl_ambiguous_init) << ClassType << Range;
John McCallcbce6062010-01-12 07:18:19 +00004231 PrintOverloadCandidates(CandidateSet, OCD_ViableCandidates, Args, NumArgs);
Douglas Gregor18fe5682008-11-03 20:45:27 +00004232 return 0;
Douglas Gregor48f3bb92009-02-18 21:56:37 +00004233
4234 case OR_Deleted:
4235 if (InitEntity)
4236 Diag(Loc, diag::err_ovl_deleted_init)
4237 << Best->Function->isDeleted()
4238 << InitEntity << Range;
Fariborz Jahanian6a587cb2009-11-25 21:53:11 +00004239 else {
4240 const CXXRecordDecl *RD =
4241 cast<CXXRecordDecl>(ClassType->getAs<RecordType>()->getDecl());
Douglas Gregor48f3bb92009-02-18 21:56:37 +00004242 Diag(Loc, diag::err_ovl_deleted_init)
4243 << Best->Function->isDeleted()
Fariborz Jahanian6a587cb2009-11-25 21:53:11 +00004244 << RD->getDeclName() << Range;
4245 }
John McCallcbce6062010-01-12 07:18:19 +00004246 PrintOverloadCandidates(CandidateSet, OCD_AllCandidates, Args, NumArgs);
Douglas Gregor48f3bb92009-02-18 21:56:37 +00004247 return 0;
Douglas Gregor18fe5682008-11-03 20:45:27 +00004248 }
Mike Stump1eb44332009-09-09 15:08:12 +00004249
Douglas Gregor39da0b82009-09-09 23:08:42 +00004250 // Convert the arguments, fill in default arguments, etc.
4251 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function);
4252 if (CompleteConstructorCall(Constructor, move(ArgsPtr), Loc, ConvertedArgs))
4253 return 0;
4254
4255 return Constructor;
4256}
4257
4258/// \brief Given a constructor and the set of arguments provided for the
4259/// constructor, convert the arguments and add any required default arguments
4260/// to form a proper call to this constructor.
4261///
4262/// \returns true if an error occurred, false otherwise.
4263bool
4264Sema::CompleteConstructorCall(CXXConstructorDecl *Constructor,
4265 MultiExprArg ArgsPtr,
4266 SourceLocation Loc,
4267 ASTOwningVector<&ActionBase::DeleteExpr> &ConvertedArgs) {
4268 // FIXME: This duplicates a lot of code from Sema::ConvertArgumentsForCall.
4269 unsigned NumArgs = ArgsPtr.size();
4270 Expr **Args = (Expr **)ArgsPtr.get();
4271
4272 const FunctionProtoType *Proto
4273 = Constructor->getType()->getAs<FunctionProtoType>();
4274 assert(Proto && "Constructor without a prototype?");
4275 unsigned NumArgsInProto = Proto->getNumArgs();
Douglas Gregor39da0b82009-09-09 23:08:42 +00004276
4277 // If too few arguments are available, we'll fill in the rest with defaults.
Fariborz Jahanian2fe168f2009-11-24 21:37:28 +00004278 if (NumArgs < NumArgsInProto)
Douglas Gregor39da0b82009-09-09 23:08:42 +00004279 ConvertedArgs.reserve(NumArgsInProto);
Fariborz Jahanian2fe168f2009-11-24 21:37:28 +00004280 else
Douglas Gregor39da0b82009-09-09 23:08:42 +00004281 ConvertedArgs.reserve(NumArgs);
Fariborz Jahanian2fe168f2009-11-24 21:37:28 +00004282
4283 VariadicCallType CallType =
4284 Proto->isVariadic() ? VariadicConstructor : VariadicDoesNotApply;
4285 llvm::SmallVector<Expr *, 8> AllArgs;
4286 bool Invalid = GatherArgumentsForCall(Loc, Constructor,
4287 Proto, 0, Args, NumArgs, AllArgs,
4288 CallType);
4289 for (unsigned i =0, size = AllArgs.size(); i < size; i++)
4290 ConvertedArgs.push_back(AllArgs[i]);
4291 return Invalid;
Douglas Gregor18fe5682008-11-03 20:45:27 +00004292}
4293
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004294/// CompareReferenceRelationship - Compare the two types T1 and T2 to
4295/// determine whether they are reference-related,
4296/// reference-compatible, reference-compatible with added
4297/// qualification, or incompatible, for use in C++ initialization by
4298/// reference (C++ [dcl.ref.init]p4). Neither type can be a reference
4299/// type, and the first type (T1) is the pointee type of the reference
4300/// type being initialized.
Mike Stump1eb44332009-09-09 15:08:12 +00004301Sema::ReferenceCompareResult
Chandler Carruth28e318c2009-12-29 07:16:59 +00004302Sema::CompareReferenceRelationship(SourceLocation Loc,
Douglas Gregor393896f2009-11-05 13:06:35 +00004303 QualType OrigT1, QualType OrigT2,
Douglas Gregor15da57e2008-10-29 02:00:59 +00004304 bool& DerivedToBase) {
Douglas Gregor393896f2009-11-05 13:06:35 +00004305 assert(!OrigT1->isReferenceType() &&
Sebastian Redl7c80bd62009-03-16 23:22:08 +00004306 "T1 must be the pointee type of the reference type");
Douglas Gregor393896f2009-11-05 13:06:35 +00004307 assert(!OrigT2->isReferenceType() && "T2 cannot be a reference type");
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004308
Douglas Gregor393896f2009-11-05 13:06:35 +00004309 QualType T1 = Context.getCanonicalType(OrigT1);
4310 QualType T2 = Context.getCanonicalType(OrigT2);
Chandler Carruth28e318c2009-12-29 07:16:59 +00004311 Qualifiers T1Quals, T2Quals;
4312 QualType UnqualT1 = Context.getUnqualifiedArrayType(T1, T1Quals);
4313 QualType UnqualT2 = Context.getUnqualifiedArrayType(T2, T2Quals);
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004314
4315 // C++ [dcl.init.ref]p4:
Eli Friedman33a31382009-08-05 19:21:58 +00004316 // Given types "cv1 T1" and "cv2 T2," "cv1 T1" is
Mike Stump1eb44332009-09-09 15:08:12 +00004317 // reference-related to "cv2 T2" if T1 is the same type as T2, or
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004318 // T1 is a base class of T2.
Douglas Gregor15da57e2008-10-29 02:00:59 +00004319 if (UnqualT1 == UnqualT2)
4320 DerivedToBase = false;
Douglas Gregor393896f2009-11-05 13:06:35 +00004321 else if (!RequireCompleteType(Loc, OrigT1, PDiag()) &&
4322 !RequireCompleteType(Loc, OrigT2, PDiag()) &&
4323 IsDerivedFrom(UnqualT2, UnqualT1))
Douglas Gregor15da57e2008-10-29 02:00:59 +00004324 DerivedToBase = true;
4325 else
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004326 return Ref_Incompatible;
4327
4328 // At this point, we know that T1 and T2 are reference-related (at
4329 // least).
4330
Chandler Carruth28e318c2009-12-29 07:16:59 +00004331 // If the type is an array type, promote the element qualifiers to the type
4332 // for comparison.
4333 if (isa<ArrayType>(T1) && T1Quals)
4334 T1 = Context.getQualifiedType(UnqualT1, T1Quals);
4335 if (isa<ArrayType>(T2) && T2Quals)
4336 T2 = Context.getQualifiedType(UnqualT2, T2Quals);
4337
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004338 // C++ [dcl.init.ref]p4:
Eli Friedman33a31382009-08-05 19:21:58 +00004339 // "cv1 T1" is reference-compatible with "cv2 T2" if T1 is
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004340 // reference-related to T2 and cv1 is the same cv-qualification
4341 // as, or greater cv-qualification than, cv2. For purposes of
4342 // overload resolution, cases for which cv1 is greater
4343 // cv-qualification than cv2 are identified as
4344 // reference-compatible with added qualification (see 13.3.3.2).
Chandler Carruth28e318c2009-12-29 07:16:59 +00004345 if (T1Quals.getCVRQualifiers() == T2Quals.getCVRQualifiers())
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004346 return Ref_Compatible;
4347 else if (T1.isMoreQualifiedThan(T2))
4348 return Ref_Compatible_With_Added_Qualification;
4349 else
4350 return Ref_Related;
4351}
4352
4353/// CheckReferenceInit - Check the initialization of a reference
4354/// variable with the given initializer (C++ [dcl.init.ref]). Init is
4355/// the initializer (either a simple initializer or an initializer
Douglas Gregor3205a782008-10-29 23:31:03 +00004356/// list), and DeclType is the type of the declaration. When ICS is
4357/// non-null, this routine will compute the implicit conversion
4358/// sequence according to C++ [over.ics.ref] and will not produce any
4359/// diagnostics; when ICS is null, it will emit diagnostics when any
4360/// errors are found. Either way, a return value of true indicates
4361/// that there was a failure, a return value of false indicates that
4362/// the reference initialization succeeded.
Douglas Gregor225c41e2008-11-03 19:09:14 +00004363///
4364/// When @p SuppressUserConversions, user-defined conversions are
4365/// suppressed.
Douglas Gregor09f41cf2009-01-14 15:45:31 +00004366/// When @p AllowExplicit, we also permit explicit user-defined
4367/// conversion functions.
Sebastian Redle2b68332009-04-12 17:16:29 +00004368/// When @p ForceRValue, we unconditionally treat the initializer as an rvalue.
Sebastian Redla82e4ae2009-11-14 21:15:49 +00004369/// When @p IgnoreBaseAccess, we don't do access control on to-base conversion.
4370/// This is used when this is called from a C-style cast.
Mike Stump1eb44332009-09-09 15:08:12 +00004371bool
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004372Sema::CheckReferenceInit(Expr *&Init, QualType DeclType,
Douglas Gregor739d8282009-09-23 23:04:10 +00004373 SourceLocation DeclLoc,
Douglas Gregor09f41cf2009-01-14 15:45:31 +00004374 bool SuppressUserConversions,
Anders Carlsson2de3ace2009-08-27 17:30:43 +00004375 bool AllowExplicit, bool ForceRValue,
Sebastian Redla82e4ae2009-11-14 21:15:49 +00004376 ImplicitConversionSequence *ICS,
4377 bool IgnoreBaseAccess) {
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004378 assert(DeclType->isReferenceType() && "Reference init needs a reference");
4379
Ted Kremenek6217b802009-07-29 21:53:49 +00004380 QualType T1 = DeclType->getAs<ReferenceType>()->getPointeeType();
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004381 QualType T2 = Init->getType();
4382
Douglas Gregor904eed32008-11-10 20:40:00 +00004383 // If the initializer is the address of an overloaded function, try
4384 // to resolve the overloaded function. If all goes well, T2 is the
4385 // type of the resulting function.
Douglas Gregor063daf62009-03-13 18:40:31 +00004386 if (Context.getCanonicalType(T2) == Context.OverloadTy) {
Mike Stump1eb44332009-09-09 15:08:12 +00004387 FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Init, DeclType,
Douglas Gregor904eed32008-11-10 20:40:00 +00004388 ICS != 0);
4389 if (Fn) {
4390 // Since we're performing this reference-initialization for
4391 // real, update the initializer with the resulting function.
Douglas Gregor48f3bb92009-02-18 21:56:37 +00004392 if (!ICS) {
Douglas Gregor739d8282009-09-23 23:04:10 +00004393 if (DiagnoseUseOfDecl(Fn, DeclLoc))
Douglas Gregor20093b42009-12-09 23:02:17 +00004394 return true;
Douglas Gregor48f3bb92009-02-18 21:56:37 +00004395
Anders Carlsson96ad5332009-10-21 17:16:23 +00004396 Init = FixOverloadedFunctionReference(Init, Fn);
Douglas Gregor48f3bb92009-02-18 21:56:37 +00004397 }
Douglas Gregor904eed32008-11-10 20:40:00 +00004398
4399 T2 = Fn->getType();
4400 }
4401 }
4402
Douglas Gregor15da57e2008-10-29 02:00:59 +00004403 // Compute some basic properties of the types and the initializer.
Sebastian Redl7c80bd62009-03-16 23:22:08 +00004404 bool isRValRef = DeclType->isRValueReferenceType();
Douglas Gregor15da57e2008-10-29 02:00:59 +00004405 bool DerivedToBase = false;
Sebastian Redle2b68332009-04-12 17:16:29 +00004406 Expr::isLvalueResult InitLvalue = ForceRValue ? Expr::LV_InvalidExpression :
4407 Init->isLvalue(Context);
Mike Stump1eb44332009-09-09 15:08:12 +00004408 ReferenceCompareResult RefRelationship
Douglas Gregor393896f2009-11-05 13:06:35 +00004409 = CompareReferenceRelationship(DeclLoc, T1, T2, DerivedToBase);
Douglas Gregor15da57e2008-10-29 02:00:59 +00004410
4411 // Most paths end in a failed conversion.
John McCalladbb8f82010-01-13 09:16:55 +00004412 if (ICS) {
4413 ICS->setBad();
4414 ICS->Bad.init(BadConversionSequence::no_conversion, Init, DeclType);
4415 }
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004416
4417 // C++ [dcl.init.ref]p5:
Eli Friedman33a31382009-08-05 19:21:58 +00004418 // A reference to type "cv1 T1" is initialized by an expression
4419 // of type "cv2 T2" as follows:
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004420
4421 // -- If the initializer expression
4422
Sebastian Redla9845802009-03-29 15:27:50 +00004423 // Rvalue references cannot bind to lvalues (N2812).
4424 // There is absolutely no situation where they can. In particular, note that
4425 // this is ill-formed, even if B has a user-defined conversion to A&&:
4426 // B b;
4427 // A&& r = b;
4428 if (isRValRef && InitLvalue == Expr::LV_Valid) {
4429 if (!ICS)
Douglas Gregor739d8282009-09-23 23:04:10 +00004430 Diag(DeclLoc, diag::err_lvalue_to_rvalue_ref)
Sebastian Redla9845802009-03-29 15:27:50 +00004431 << Init->getSourceRange();
4432 return true;
4433 }
4434
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004435 bool BindsDirectly = false;
Eli Friedman33a31382009-08-05 19:21:58 +00004436 // -- is an lvalue (but is not a bit-field), and "cv1 T1" is
4437 // reference-compatible with "cv2 T2," or
Douglas Gregor15da57e2008-10-29 02:00:59 +00004438 //
4439 // Note that the bit-field check is skipped if we are just computing
4440 // the implicit conversion sequence (C++ [over.best.ics]p2).
Douglas Gregor33bbbc52009-05-02 02:18:30 +00004441 if (InitLvalue == Expr::LV_Valid && (ICS || !Init->getBitField()) &&
Douglas Gregor15da57e2008-10-29 02:00:59 +00004442 RefRelationship >= Ref_Compatible_With_Added_Qualification) {
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004443 BindsDirectly = true;
4444
Douglas Gregor15da57e2008-10-29 02:00:59 +00004445 if (ICS) {
4446 // C++ [over.ics.ref]p1:
4447 // When a parameter of reference type binds directly (8.5.3)
4448 // to an argument expression, the implicit conversion sequence
4449 // is the identity conversion, unless the argument expression
4450 // has a type that is a derived class of the parameter type,
4451 // in which case the implicit conversion sequence is a
4452 // derived-to-base Conversion (13.3.3.1).
John McCall1d318332010-01-12 00:44:57 +00004453 ICS->setStandard();
Douglas Gregor15da57e2008-10-29 02:00:59 +00004454 ICS->Standard.First = ICK_Identity;
4455 ICS->Standard.Second = DerivedToBase? ICK_Derived_To_Base : ICK_Identity;
4456 ICS->Standard.Third = ICK_Identity;
4457 ICS->Standard.FromTypePtr = T2.getAsOpaquePtr();
Douglas Gregorad323a82010-01-27 03:51:04 +00004458 ICS->Standard.setToType(0, T2);
4459 ICS->Standard.setToType(1, T1);
4460 ICS->Standard.setToType(2, T1);
Douglas Gregorf70bdb92008-10-29 14:50:44 +00004461 ICS->Standard.ReferenceBinding = true;
4462 ICS->Standard.DirectBinding = true;
Sebastian Redla9845802009-03-29 15:27:50 +00004463 ICS->Standard.RRefBinding = false;
Sebastian Redl76458502009-04-17 16:30:52 +00004464 ICS->Standard.CopyConstructor = 0;
Douglas Gregor15da57e2008-10-29 02:00:59 +00004465
4466 // Nothing more to do: the inaccessibility/ambiguity check for
4467 // derived-to-base conversions is suppressed when we're
4468 // computing the implicit conversion sequence (C++
4469 // [over.best.ics]p2).
4470 return false;
4471 } else {
4472 // Perform the conversion.
Douglas Gregor39da0b82009-09-09 23:08:42 +00004473 CastExpr::CastKind CK = CastExpr::CK_NoOp;
4474 if (DerivedToBase)
4475 CK = CastExpr::CK_DerivedToBase;
Sebastian Redl2c7588f2009-10-10 12:04:10 +00004476 else if(CheckExceptionSpecCompatibility(Init, T1))
4477 return true;
Douglas Gregor39da0b82009-09-09 23:08:42 +00004478 ImpCastExprToType(Init, T1, CK, /*isLvalue=*/true);
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004479 }
4480 }
4481
4482 // -- has a class type (i.e., T2 is a class type) and can be
Eli Friedman33a31382009-08-05 19:21:58 +00004483 // implicitly converted to an lvalue of type "cv3 T3,"
4484 // where "cv1 T1" is reference-compatible with "cv3 T3"
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004485 // 92) (this conversion is selected by enumerating the
4486 // applicable conversion functions (13.3.1.6) and choosing
4487 // the best one through overload resolution (13.3)),
Douglas Gregor5842ba92009-08-24 15:23:48 +00004488 if (!isRValRef && !SuppressUserConversions && T2->isRecordType() &&
Douglas Gregor573d9c32009-10-21 23:19:44 +00004489 !RequireCompleteType(DeclLoc, T2, 0)) {
Mike Stump1eb44332009-09-09 15:08:12 +00004490 CXXRecordDecl *T2RecordDecl
Ted Kremenek6217b802009-07-29 21:53:49 +00004491 = dyn_cast<CXXRecordDecl>(T2->getAs<RecordType>()->getDecl());
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004492
Douglas Gregorcb9b9772008-11-10 16:14:15 +00004493 OverloadCandidateSet CandidateSet;
John McCalleec51cf2010-01-20 00:46:10 +00004494 const UnresolvedSetImpl *Conversions
Fariborz Jahanian51bebc82009-09-23 20:55:32 +00004495 = T2RecordDecl->getVisibleConversionFunctions();
John McCalleec51cf2010-01-20 00:46:10 +00004496 for (UnresolvedSetImpl::iterator I = Conversions->begin(),
John McCallba135432009-11-21 08:51:07 +00004497 E = Conversions->end(); I != E; ++I) {
John McCall701c89e2009-12-03 04:06:58 +00004498 NamedDecl *D = *I;
4499 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
4500 if (isa<UsingShadowDecl>(D))
4501 D = cast<UsingShadowDecl>(D)->getTargetDecl();
4502
Mike Stump1eb44332009-09-09 15:08:12 +00004503 FunctionTemplateDecl *ConvTemplate
John McCall701c89e2009-12-03 04:06:58 +00004504 = dyn_cast<FunctionTemplateDecl>(D);
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00004505 CXXConversionDecl *Conv;
4506 if (ConvTemplate)
4507 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
4508 else
John McCall701c89e2009-12-03 04:06:58 +00004509 Conv = cast<CXXConversionDecl>(D);
Fariborz Jahanian51bebc82009-09-23 20:55:32 +00004510
Douglas Gregorcb9b9772008-11-10 16:14:15 +00004511 // If the conversion function doesn't return a reference type,
4512 // it can't be considered for this conversion.
Sebastian Redl7c80bd62009-03-16 23:22:08 +00004513 if (Conv->getConversionType()->isLValueReferenceType() &&
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00004514 (AllowExplicit || !Conv->isExplicit())) {
4515 if (ConvTemplate)
John McCall86820f52010-01-26 01:37:31 +00004516 AddTemplateConversionCandidate(ConvTemplate, I.getAccess(), ActingDC,
John McCall701c89e2009-12-03 04:06:58 +00004517 Init, DeclType, CandidateSet);
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00004518 else
John McCall86820f52010-01-26 01:37:31 +00004519 AddConversionCandidate(Conv, I.getAccess(), ActingDC, Init,
4520 DeclType, CandidateSet);
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00004521 }
Douglas Gregorcb9b9772008-11-10 16:14:15 +00004522 }
4523
4524 OverloadCandidateSet::iterator Best;
Douglas Gregor739d8282009-09-23 23:04:10 +00004525 switch (BestViableFunction(CandidateSet, DeclLoc, Best)) {
Douglas Gregorcb9b9772008-11-10 16:14:15 +00004526 case OR_Success:
4527 // This is a direct binding.
4528 BindsDirectly = true;
4529
4530 if (ICS) {
4531 // C++ [over.ics.ref]p1:
4532 //
4533 // [...] If the parameter binds directly to the result of
4534 // applying a conversion function to the argument
4535 // expression, the implicit conversion sequence is a
4536 // user-defined conversion sequence (13.3.3.1.2), with the
4537 // second standard conversion sequence either an identity
4538 // conversion or, if the conversion function returns an
4539 // entity of a type that is a derived class of the parameter
4540 // type, a derived-to-base Conversion.
John McCall1d318332010-01-12 00:44:57 +00004541 ICS->setUserDefined();
Douglas Gregorcb9b9772008-11-10 16:14:15 +00004542 ICS->UserDefined.Before = Best->Conversions[0].Standard;
4543 ICS->UserDefined.After = Best->FinalConversion;
4544 ICS->UserDefined.ConversionFunction = Best->Function;
Fariborz Jahanian966256a2009-11-06 00:23:08 +00004545 ICS->UserDefined.EllipsisConversion = false;
Douglas Gregorcb9b9772008-11-10 16:14:15 +00004546 assert(ICS->UserDefined.After.ReferenceBinding &&
4547 ICS->UserDefined.After.DirectBinding &&
4548 "Expected a direct reference binding!");
4549 return false;
4550 } else {
Fariborz Jahanian8f489d62009-09-23 22:34:00 +00004551 OwningExprResult InitConversion =
Douglas Gregor739d8282009-09-23 23:04:10 +00004552 BuildCXXCastArgument(DeclLoc, QualType(),
Fariborz Jahanian8f489d62009-09-23 22:34:00 +00004553 CastExpr::CK_UserDefinedConversion,
4554 cast<CXXMethodDecl>(Best->Function),
4555 Owned(Init));
4556 Init = InitConversion.takeAs<Expr>();
Sebastian Redl2c7588f2009-10-10 12:04:10 +00004557
4558 if (CheckExceptionSpecCompatibility(Init, T1))
4559 return true;
Fariborz Jahanian8f489d62009-09-23 22:34:00 +00004560 ImpCastExprToType(Init, T1, CastExpr::CK_UserDefinedConversion,
4561 /*isLvalue=*/true);
Douglas Gregorcb9b9772008-11-10 16:14:15 +00004562 }
4563 break;
4564
4565 case OR_Ambiguous:
Fariborz Jahaniand9290cb2009-10-14 00:52:43 +00004566 if (ICS) {
John McCall1d318332010-01-12 00:44:57 +00004567 ICS->setAmbiguous();
Fariborz Jahaniand9290cb2009-10-14 00:52:43 +00004568 for (OverloadCandidateSet::iterator Cand = CandidateSet.begin();
4569 Cand != CandidateSet.end(); ++Cand)
4570 if (Cand->Viable)
John McCall1d318332010-01-12 00:44:57 +00004571 ICS->Ambiguous.addConversion(Cand->Function);
Fariborz Jahaniand9290cb2009-10-14 00:52:43 +00004572 break;
4573 }
4574 Diag(DeclLoc, diag::err_ref_init_ambiguous) << DeclType << Init->getType()
4575 << Init->getSourceRange();
John McCallcbce6062010-01-12 07:18:19 +00004576 PrintOverloadCandidates(CandidateSet, OCD_ViableCandidates, &Init, 1);
Douglas Gregorcb9b9772008-11-10 16:14:15 +00004577 return true;
Mike Stump1eb44332009-09-09 15:08:12 +00004578
Douglas Gregorcb9b9772008-11-10 16:14:15 +00004579 case OR_No_Viable_Function:
Douglas Gregor48f3bb92009-02-18 21:56:37 +00004580 case OR_Deleted:
4581 // There was no suitable conversion, or we found a deleted
4582 // conversion; continue with other checks.
Douglas Gregorcb9b9772008-11-10 16:14:15 +00004583 break;
4584 }
4585 }
Mike Stump1eb44332009-09-09 15:08:12 +00004586
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004587 if (BindsDirectly) {
4588 // C++ [dcl.init.ref]p4:
4589 // [...] In all cases where the reference-related or
4590 // reference-compatible relationship of two types is used to
4591 // establish the validity of a reference binding, and T1 is a
4592 // base class of T2, a program that necessitates such a binding
4593 // is ill-formed if T1 is an inaccessible (clause 11) or
4594 // ambiguous (10.2) base class of T2.
4595 //
4596 // Note that we only check this condition when we're allowed to
4597 // complain about errors, because we should not be checking for
4598 // ambiguity (or inaccessibility) unless the reference binding
4599 // actually happens.
Mike Stump1eb44332009-09-09 15:08:12 +00004600 if (DerivedToBase)
Douglas Gregor739d8282009-09-23 23:04:10 +00004601 return CheckDerivedToBaseConversion(T2, T1, DeclLoc,
Sebastian Redla82e4ae2009-11-14 21:15:49 +00004602 Init->getSourceRange(),
4603 IgnoreBaseAccess);
Douglas Gregor15da57e2008-10-29 02:00:59 +00004604 else
4605 return false;
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004606 }
4607
4608 // -- Otherwise, the reference shall be to a non-volatile const
Sebastian Redla9845802009-03-29 15:27:50 +00004609 // type (i.e., cv1 shall be const), or the reference shall be an
4610 // rvalue reference and the initializer expression shall be an rvalue.
John McCall0953e762009-09-24 19:53:00 +00004611 if (!isRValRef && T1.getCVRQualifiers() != Qualifiers::Const) {
Douglas Gregor15da57e2008-10-29 02:00:59 +00004612 if (!ICS)
Douglas Gregor739d8282009-09-23 23:04:10 +00004613 Diag(DeclLoc, diag::err_not_reference_to_const_init)
Douglas Gregor5cc07df2009-12-15 16:44:32 +00004614 << T1 << int(InitLvalue != Expr::LV_Valid)
Chris Lattnerd1625842008-11-24 06:25:27 +00004615 << T2 << Init->getSourceRange();
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004616 return true;
4617 }
4618
4619 // -- If the initializer expression is an rvalue, with T2 a
Eli Friedman33a31382009-08-05 19:21:58 +00004620 // class type, and "cv1 T1" is reference-compatible with
4621 // "cv2 T2," the reference is bound in one of the
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004622 // following ways (the choice is implementation-defined):
4623 //
4624 // -- The reference is bound to the object represented by
4625 // the rvalue (see 3.10) or to a sub-object within that
4626 // object.
4627 //
Eli Friedman33a31382009-08-05 19:21:58 +00004628 // -- A temporary of type "cv1 T2" [sic] is created, and
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004629 // a constructor is called to copy the entire rvalue
4630 // object into the temporary. The reference is bound to
4631 // the temporary or to a sub-object within the
4632 // temporary.
4633 //
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004634 // The constructor that would be used to make the copy
4635 // shall be callable whether or not the copy is actually
4636 // done.
4637 //
Sebastian Redla9845802009-03-29 15:27:50 +00004638 // Note that C++0x [dcl.init.ref]p5 takes away this implementation
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004639 // freedom, so we will always take the first option and never build
4640 // a temporary in this case. FIXME: We will, however, have to check
4641 // for the presence of a copy constructor in C++98/03 mode.
4642 if (InitLvalue != Expr::LV_Valid && T2->isRecordType() &&
Douglas Gregor15da57e2008-10-29 02:00:59 +00004643 RefRelationship >= Ref_Compatible_With_Added_Qualification) {
4644 if (ICS) {
John McCall1d318332010-01-12 00:44:57 +00004645 ICS->setStandard();
Douglas Gregor15da57e2008-10-29 02:00:59 +00004646 ICS->Standard.First = ICK_Identity;
4647 ICS->Standard.Second = DerivedToBase? ICK_Derived_To_Base : ICK_Identity;
4648 ICS->Standard.Third = ICK_Identity;
4649 ICS->Standard.FromTypePtr = T2.getAsOpaquePtr();
Douglas Gregorad323a82010-01-27 03:51:04 +00004650 ICS->Standard.setToType(0, T2);
4651 ICS->Standard.setToType(1, T1);
4652 ICS->Standard.setToType(2, T1);
Douglas Gregorf70bdb92008-10-29 14:50:44 +00004653 ICS->Standard.ReferenceBinding = true;
Sebastian Redla9845802009-03-29 15:27:50 +00004654 ICS->Standard.DirectBinding = false;
4655 ICS->Standard.RRefBinding = isRValRef;
Sebastian Redl76458502009-04-17 16:30:52 +00004656 ICS->Standard.CopyConstructor = 0;
Douglas Gregor15da57e2008-10-29 02:00:59 +00004657 } else {
Douglas Gregor39da0b82009-09-09 23:08:42 +00004658 CastExpr::CastKind CK = CastExpr::CK_NoOp;
4659 if (DerivedToBase)
4660 CK = CastExpr::CK_DerivedToBase;
Sebastian Redl2c7588f2009-10-10 12:04:10 +00004661 else if(CheckExceptionSpecCompatibility(Init, T1))
4662 return true;
Douglas Gregor39da0b82009-09-09 23:08:42 +00004663 ImpCastExprToType(Init, T1, CK, /*isLvalue=*/false);
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004664 }
4665 return false;
4666 }
4667
Eli Friedman33a31382009-08-05 19:21:58 +00004668 // -- Otherwise, a temporary of type "cv1 T1" is created and
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004669 // initialized from the initializer expression using the
4670 // rules for a non-reference copy initialization (8.5). The
4671 // reference is then bound to the temporary. If T1 is
4672 // reference-related to T2, cv1 must be the same
4673 // cv-qualification as, or greater cv-qualification than,
4674 // cv2; otherwise, the program is ill-formed.
4675 if (RefRelationship == Ref_Related) {
4676 // If cv1 == cv2 or cv1 is a greater cv-qualified than cv2, then
4677 // we would be reference-compatible or reference-compatible with
4678 // added qualification. But that wasn't the case, so the reference
4679 // initialization fails.
Douglas Gregor15da57e2008-10-29 02:00:59 +00004680 if (!ICS)
Douglas Gregor739d8282009-09-23 23:04:10 +00004681 Diag(DeclLoc, diag::err_reference_init_drops_quals)
Douglas Gregor5cc07df2009-12-15 16:44:32 +00004682 << T1 << int(InitLvalue != Expr::LV_Valid)
Chris Lattnerd1625842008-11-24 06:25:27 +00004683 << T2 << Init->getSourceRange();
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004684 return true;
4685 }
4686
Douglas Gregor734d9862009-01-30 23:27:23 +00004687 // If at least one of the types is a class type, the types are not
4688 // related, and we aren't allowed any user conversions, the
4689 // reference binding fails. This case is important for breaking
4690 // recursion, since TryImplicitConversion below will attempt to
4691 // create a temporary through the use of a copy constructor.
4692 if (SuppressUserConversions && RefRelationship == Ref_Incompatible &&
4693 (T1->isRecordType() || T2->isRecordType())) {
4694 if (!ICS)
Douglas Gregor739d8282009-09-23 23:04:10 +00004695 Diag(DeclLoc, diag::err_typecheck_convert_incompatible)
Douglas Gregor68647482009-12-16 03:45:30 +00004696 << DeclType << Init->getType() << AA_Initializing << Init->getSourceRange();
Douglas Gregor734d9862009-01-30 23:27:23 +00004697 return true;
4698 }
4699
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004700 // Actually try to convert the initializer to T1.
Douglas Gregor15da57e2008-10-29 02:00:59 +00004701 if (ICS) {
Sebastian Redla9845802009-03-29 15:27:50 +00004702 // C++ [over.ics.ref]p2:
Mike Stump1eb44332009-09-09 15:08:12 +00004703 //
Sebastian Redla9845802009-03-29 15:27:50 +00004704 // When a parameter of reference type is not bound directly to
4705 // an argument expression, the conversion sequence is the one
4706 // required to convert the argument expression to the
4707 // underlying type of the reference according to
4708 // 13.3.3.1. Conceptually, this conversion sequence corresponds
4709 // to copy-initializing a temporary of the underlying type with
4710 // the argument expression. Any difference in top-level
4711 // cv-qualification is subsumed by the initialization itself
4712 // and does not constitute a conversion.
Anders Carlssonda7a18b2009-08-27 17:24:15 +00004713 *ICS = TryImplicitConversion(Init, T1, SuppressUserConversions,
4714 /*AllowExplicit=*/false,
Anders Carlsson08972922009-08-28 15:33:32 +00004715 /*ForceRValue=*/false,
4716 /*InOverloadResolution=*/false);
Mike Stump1eb44332009-09-09 15:08:12 +00004717
Sebastian Redla9845802009-03-29 15:27:50 +00004718 // Of course, that's still a reference binding.
John McCall1d318332010-01-12 00:44:57 +00004719 if (ICS->isStandard()) {
Sebastian Redla9845802009-03-29 15:27:50 +00004720 ICS->Standard.ReferenceBinding = true;
4721 ICS->Standard.RRefBinding = isRValRef;
John McCall1d318332010-01-12 00:44:57 +00004722 } else if (ICS->isUserDefined()) {
Sebastian Redla9845802009-03-29 15:27:50 +00004723 ICS->UserDefined.After.ReferenceBinding = true;
4724 ICS->UserDefined.After.RRefBinding = isRValRef;
4725 }
John McCall1d318332010-01-12 00:44:57 +00004726 return ICS->isBad();
Douglas Gregor15da57e2008-10-29 02:00:59 +00004727 } else {
Fariborz Jahanian51bebc82009-09-23 20:55:32 +00004728 ImplicitConversionSequence Conversions;
Douglas Gregor68647482009-12-16 03:45:30 +00004729 bool badConversion = PerformImplicitConversion(Init, T1, AA_Initializing,
Fariborz Jahanian51bebc82009-09-23 20:55:32 +00004730 false, false,
4731 Conversions);
4732 if (badConversion) {
John McCall1d318332010-01-12 00:44:57 +00004733 if (Conversions.isAmbiguous()) {
Fariborz Jahanian7ad2d562009-09-24 00:42:43 +00004734 Diag(DeclLoc,
Fariborz Jahanian51bebc82009-09-23 20:55:32 +00004735 diag::err_lvalue_to_rvalue_ambig_ref) << Init->getSourceRange();
John McCall1d318332010-01-12 00:44:57 +00004736 for (int j = Conversions.Ambiguous.conversions().size()-1;
Fariborz Jahanian51bebc82009-09-23 20:55:32 +00004737 j >= 0; j--) {
John McCall1d318332010-01-12 00:44:57 +00004738 FunctionDecl *Func = Conversions.Ambiguous.conversions()[j];
John McCallb1622a12010-01-06 09:43:14 +00004739 NoteOverloadCandidate(Func);
Fariborz Jahanian51bebc82009-09-23 20:55:32 +00004740 }
4741 }
Fariborz Jahanian893f9552009-09-30 21:23:30 +00004742 else {
4743 if (isRValRef)
4744 Diag(DeclLoc, diag::err_lvalue_to_rvalue_ref)
4745 << Init->getSourceRange();
4746 else
4747 Diag(DeclLoc, diag::err_invalid_initialization)
4748 << DeclType << Init->getType() << Init->getSourceRange();
4749 }
Fariborz Jahanian51bebc82009-09-23 20:55:32 +00004750 }
4751 return badConversion;
Douglas Gregor15da57e2008-10-29 02:00:59 +00004752 }
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004753}
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004754
Anders Carlsson20d45d22009-12-12 00:32:00 +00004755static inline bool
4756CheckOperatorNewDeleteDeclarationScope(Sema &SemaRef,
4757 const FunctionDecl *FnDecl) {
4758 const DeclContext *DC = FnDecl->getDeclContext()->getLookupContext();
4759 if (isa<NamespaceDecl>(DC)) {
4760 return SemaRef.Diag(FnDecl->getLocation(),
4761 diag::err_operator_new_delete_declared_in_namespace)
4762 << FnDecl->getDeclName();
4763 }
4764
4765 if (isa<TranslationUnitDecl>(DC) &&
4766 FnDecl->getStorageClass() == FunctionDecl::Static) {
4767 return SemaRef.Diag(FnDecl->getLocation(),
4768 diag::err_operator_new_delete_declared_static)
4769 << FnDecl->getDeclName();
4770 }
4771
Anders Carlssonfcfdb2b2009-12-12 02:43:16 +00004772 return false;
Anders Carlsson20d45d22009-12-12 00:32:00 +00004773}
4774
Anders Carlsson156c78e2009-12-13 17:53:43 +00004775static inline bool
4776CheckOperatorNewDeleteTypes(Sema &SemaRef, const FunctionDecl *FnDecl,
4777 CanQualType ExpectedResultType,
4778 CanQualType ExpectedFirstParamType,
4779 unsigned DependentParamTypeDiag,
4780 unsigned InvalidParamTypeDiag) {
4781 QualType ResultType =
4782 FnDecl->getType()->getAs<FunctionType>()->getResultType();
4783
4784 // Check that the result type is not dependent.
4785 if (ResultType->isDependentType())
4786 return SemaRef.Diag(FnDecl->getLocation(),
4787 diag::err_operator_new_delete_dependent_result_type)
4788 << FnDecl->getDeclName() << ExpectedResultType;
4789
4790 // Check that the result type is what we expect.
4791 if (SemaRef.Context.getCanonicalType(ResultType) != ExpectedResultType)
4792 return SemaRef.Diag(FnDecl->getLocation(),
4793 diag::err_operator_new_delete_invalid_result_type)
4794 << FnDecl->getDeclName() << ExpectedResultType;
4795
4796 // A function template must have at least 2 parameters.
4797 if (FnDecl->getDescribedFunctionTemplate() && FnDecl->getNumParams() < 2)
4798 return SemaRef.Diag(FnDecl->getLocation(),
4799 diag::err_operator_new_delete_template_too_few_parameters)
4800 << FnDecl->getDeclName();
4801
4802 // The function decl must have at least 1 parameter.
4803 if (FnDecl->getNumParams() == 0)
4804 return SemaRef.Diag(FnDecl->getLocation(),
4805 diag::err_operator_new_delete_too_few_parameters)
4806 << FnDecl->getDeclName();
4807
4808 // Check the the first parameter type is not dependent.
4809 QualType FirstParamType = FnDecl->getParamDecl(0)->getType();
4810 if (FirstParamType->isDependentType())
4811 return SemaRef.Diag(FnDecl->getLocation(), DependentParamTypeDiag)
4812 << FnDecl->getDeclName() << ExpectedFirstParamType;
4813
4814 // Check that the first parameter type is what we expect.
Douglas Gregor6e790ab2009-12-22 23:42:49 +00004815 if (SemaRef.Context.getCanonicalType(FirstParamType).getUnqualifiedType() !=
Anders Carlsson156c78e2009-12-13 17:53:43 +00004816 ExpectedFirstParamType)
4817 return SemaRef.Diag(FnDecl->getLocation(), InvalidParamTypeDiag)
4818 << FnDecl->getDeclName() << ExpectedFirstParamType;
4819
4820 return false;
4821}
4822
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00004823static bool
Anders Carlsson156c78e2009-12-13 17:53:43 +00004824CheckOperatorNewDeclaration(Sema &SemaRef, const FunctionDecl *FnDecl) {
Anders Carlsson20d45d22009-12-12 00:32:00 +00004825 // C++ [basic.stc.dynamic.allocation]p1:
4826 // A program is ill-formed if an allocation function is declared in a
4827 // namespace scope other than global scope or declared static in global
4828 // scope.
4829 if (CheckOperatorNewDeleteDeclarationScope(SemaRef, FnDecl))
4830 return true;
Anders Carlsson156c78e2009-12-13 17:53:43 +00004831
4832 CanQualType SizeTy =
4833 SemaRef.Context.getCanonicalType(SemaRef.Context.getSizeType());
4834
4835 // C++ [basic.stc.dynamic.allocation]p1:
4836 // The return type shall be void*. The first parameter shall have type
4837 // std::size_t.
4838 if (CheckOperatorNewDeleteTypes(SemaRef, FnDecl, SemaRef.Context.VoidPtrTy,
4839 SizeTy,
4840 diag::err_operator_new_dependent_param_type,
4841 diag::err_operator_new_param_type))
4842 return true;
4843
4844 // C++ [basic.stc.dynamic.allocation]p1:
4845 // The first parameter shall not have an associated default argument.
4846 if (FnDecl->getParamDecl(0)->hasDefaultArg())
Anders Carlssona3ccda52009-12-12 00:26:23 +00004847 return SemaRef.Diag(FnDecl->getLocation(),
Anders Carlsson156c78e2009-12-13 17:53:43 +00004848 diag::err_operator_new_default_arg)
4849 << FnDecl->getDeclName() << FnDecl->getParamDecl(0)->getDefaultArgRange();
4850
4851 return false;
Anders Carlssona3ccda52009-12-12 00:26:23 +00004852}
4853
4854static bool
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00004855CheckOperatorDeleteDeclaration(Sema &SemaRef, const FunctionDecl *FnDecl) {
4856 // C++ [basic.stc.dynamic.deallocation]p1:
4857 // A program is ill-formed if deallocation functions are declared in a
4858 // namespace scope other than global scope or declared static in global
4859 // scope.
Anders Carlsson20d45d22009-12-12 00:32:00 +00004860 if (CheckOperatorNewDeleteDeclarationScope(SemaRef, FnDecl))
4861 return true;
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00004862
4863 // C++ [basic.stc.dynamic.deallocation]p2:
4864 // Each deallocation function shall return void and its first parameter
4865 // shall be void*.
Anders Carlsson156c78e2009-12-13 17:53:43 +00004866 if (CheckOperatorNewDeleteTypes(SemaRef, FnDecl, SemaRef.Context.VoidTy,
4867 SemaRef.Context.VoidPtrTy,
4868 diag::err_operator_delete_dependent_param_type,
4869 diag::err_operator_delete_param_type))
4870 return true;
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00004871
Anders Carlsson46991d62009-12-12 00:16:02 +00004872 QualType FirstParamType = FnDecl->getParamDecl(0)->getType();
4873 if (FirstParamType->isDependentType())
4874 return SemaRef.Diag(FnDecl->getLocation(),
4875 diag::err_operator_delete_dependent_param_type)
4876 << FnDecl->getDeclName() << SemaRef.Context.VoidPtrTy;
4877
4878 if (SemaRef.Context.getCanonicalType(FirstParamType) !=
4879 SemaRef.Context.VoidPtrTy)
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00004880 return SemaRef.Diag(FnDecl->getLocation(),
4881 diag::err_operator_delete_param_type)
4882 << FnDecl->getDeclName() << SemaRef.Context.VoidPtrTy;
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00004883
4884 return false;
4885}
4886
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004887/// CheckOverloadedOperatorDeclaration - Check whether the declaration
4888/// of this overloaded operator is well-formed. If so, returns false;
4889/// otherwise, emits appropriate diagnostics and returns true.
4890bool Sema::CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl) {
Douglas Gregor43c7bad2008-11-17 16:14:12 +00004891 assert(FnDecl && FnDecl->isOverloadedOperator() &&
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004892 "Expected an overloaded operator declaration");
4893
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004894 OverloadedOperatorKind Op = FnDecl->getOverloadedOperator();
4895
Mike Stump1eb44332009-09-09 15:08:12 +00004896 // C++ [over.oper]p5:
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004897 // The allocation and deallocation functions, operator new,
4898 // operator new[], operator delete and operator delete[], are
4899 // described completely in 3.7.3. The attributes and restrictions
4900 // found in the rest of this subclause do not apply to them unless
4901 // explicitly stated in 3.7.3.
Anders Carlsson1152c392009-12-11 23:31:21 +00004902 if (Op == OO_Delete || Op == OO_Array_Delete)
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00004903 return CheckOperatorDeleteDeclaration(*this, FnDecl);
Fariborz Jahanianb03bfa52009-11-10 23:47:18 +00004904
Anders Carlssona3ccda52009-12-12 00:26:23 +00004905 if (Op == OO_New || Op == OO_Array_New)
4906 return CheckOperatorNewDeclaration(*this, FnDecl);
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004907
4908 // C++ [over.oper]p6:
4909 // An operator function shall either be a non-static member
4910 // function or be a non-member function and have at least one
4911 // parameter whose type is a class, a reference to a class, an
4912 // enumeration, or a reference to an enumeration.
Douglas Gregor43c7bad2008-11-17 16:14:12 +00004913 if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) {
4914 if (MethodDecl->isStatic())
4915 return Diag(FnDecl->getLocation(),
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00004916 diag::err_operator_overload_static) << FnDecl->getDeclName();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004917 } else {
4918 bool ClassOrEnumParam = false;
Douglas Gregor43c7bad2008-11-17 16:14:12 +00004919 for (FunctionDecl::param_iterator Param = FnDecl->param_begin(),
4920 ParamEnd = FnDecl->param_end();
4921 Param != ParamEnd; ++Param) {
4922 QualType ParamType = (*Param)->getType().getNonReferenceType();
Eli Friedman5d39dee2009-06-27 05:59:59 +00004923 if (ParamType->isDependentType() || ParamType->isRecordType() ||
4924 ParamType->isEnumeralType()) {
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004925 ClassOrEnumParam = true;
4926 break;
4927 }
4928 }
4929
Douglas Gregor43c7bad2008-11-17 16:14:12 +00004930 if (!ClassOrEnumParam)
4931 return Diag(FnDecl->getLocation(),
Chris Lattnerf3a41af2008-11-20 06:38:18 +00004932 diag::err_operator_overload_needs_class_or_enum)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00004933 << FnDecl->getDeclName();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004934 }
4935
4936 // C++ [over.oper]p8:
4937 // An operator function cannot have default arguments (8.3.6),
4938 // except where explicitly stated below.
4939 //
Mike Stump1eb44332009-09-09 15:08:12 +00004940 // Only the function-call operator allows default arguments
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004941 // (C++ [over.call]p1).
4942 if (Op != OO_Call) {
4943 for (FunctionDecl::param_iterator Param = FnDecl->param_begin();
4944 Param != FnDecl->param_end(); ++Param) {
Anders Carlsson156c78e2009-12-13 17:53:43 +00004945 if ((*Param)->hasDefaultArg())
Mike Stump1eb44332009-09-09 15:08:12 +00004946 return Diag((*Param)->getLocation(),
Douglas Gregor61366e92008-12-24 00:01:03 +00004947 diag::err_operator_overload_default_arg)
Anders Carlsson156c78e2009-12-13 17:53:43 +00004948 << FnDecl->getDeclName() << (*Param)->getDefaultArgRange();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004949 }
4950 }
4951
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00004952 static const bool OperatorUses[NUM_OVERLOADED_OPERATORS][3] = {
4953 { false, false, false }
4954#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
4955 , { Unary, Binary, MemberOnly }
4956#include "clang/Basic/OperatorKinds.def"
4957 };
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004958
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00004959 bool CanBeUnaryOperator = OperatorUses[Op][0];
4960 bool CanBeBinaryOperator = OperatorUses[Op][1];
4961 bool MustBeMemberOperator = OperatorUses[Op][2];
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004962
4963 // C++ [over.oper]p8:
4964 // [...] Operator functions cannot have more or fewer parameters
4965 // than the number required for the corresponding operator, as
4966 // described in the rest of this subclause.
Mike Stump1eb44332009-09-09 15:08:12 +00004967 unsigned NumParams = FnDecl->getNumParams()
Douglas Gregor43c7bad2008-11-17 16:14:12 +00004968 + (isa<CXXMethodDecl>(FnDecl)? 1 : 0);
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004969 if (Op != OO_Call &&
4970 ((NumParams == 1 && !CanBeUnaryOperator) ||
4971 (NumParams == 2 && !CanBeBinaryOperator) ||
4972 (NumParams < 1) || (NumParams > 2))) {
4973 // We have the wrong number of parameters.
Chris Lattner416e46f2008-11-21 07:57:12 +00004974 unsigned ErrorKind;
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00004975 if (CanBeUnaryOperator && CanBeBinaryOperator) {
Chris Lattner416e46f2008-11-21 07:57:12 +00004976 ErrorKind = 2; // 2 -> unary or binary.
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00004977 } else if (CanBeUnaryOperator) {
Chris Lattner416e46f2008-11-21 07:57:12 +00004978 ErrorKind = 0; // 0 -> unary
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00004979 } else {
Chris Lattneraf7ae4e2008-11-21 07:50:02 +00004980 assert(CanBeBinaryOperator &&
4981 "All non-call overloaded operators are unary or binary!");
Chris Lattner416e46f2008-11-21 07:57:12 +00004982 ErrorKind = 1; // 1 -> binary
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00004983 }
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004984
Chris Lattner416e46f2008-11-21 07:57:12 +00004985 return Diag(FnDecl->getLocation(), diag::err_operator_overload_must_be)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00004986 << FnDecl->getDeclName() << NumParams << ErrorKind;
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004987 }
Sebastian Redl64b45f72009-01-05 20:52:13 +00004988
Douglas Gregor43c7bad2008-11-17 16:14:12 +00004989 // Overloaded operators other than operator() cannot be variadic.
4990 if (Op != OO_Call &&
John McCall183700f2009-09-21 23:43:11 +00004991 FnDecl->getType()->getAs<FunctionProtoType>()->isVariadic()) {
Chris Lattnerf3a41af2008-11-20 06:38:18 +00004992 return Diag(FnDecl->getLocation(), diag::err_operator_overload_variadic)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00004993 << FnDecl->getDeclName();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004994 }
4995
4996 // Some operators must be non-static member functions.
Douglas Gregor43c7bad2008-11-17 16:14:12 +00004997 if (MustBeMemberOperator && !isa<CXXMethodDecl>(FnDecl)) {
4998 return Diag(FnDecl->getLocation(),
Chris Lattnerf3a41af2008-11-20 06:38:18 +00004999 diag::err_operator_overload_must_be_member)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00005000 << FnDecl->getDeclName();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00005001 }
5002
5003 // C++ [over.inc]p1:
5004 // The user-defined function called operator++ implements the
5005 // prefix and postfix ++ operator. If this function is a member
5006 // function with no parameters, or a non-member function with one
5007 // parameter of class or enumeration type, it defines the prefix
5008 // increment operator ++ for objects of that type. If the function
5009 // is a member function with one parameter (which shall be of type
5010 // int) or a non-member function with two parameters (the second
5011 // of which shall be of type int), it defines the postfix
5012 // increment operator ++ for objects of that type.
5013 if ((Op == OO_PlusPlus || Op == OO_MinusMinus) && NumParams == 2) {
5014 ParmVarDecl *LastParam = FnDecl->getParamDecl(FnDecl->getNumParams() - 1);
5015 bool ParamIsInt = false;
John McCall183700f2009-09-21 23:43:11 +00005016 if (const BuiltinType *BT = LastParam->getType()->getAs<BuiltinType>())
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00005017 ParamIsInt = BT->getKind() == BuiltinType::Int;
5018
Chris Lattneraf7ae4e2008-11-21 07:50:02 +00005019 if (!ParamIsInt)
5020 return Diag(LastParam->getLocation(),
Mike Stump1eb44332009-09-09 15:08:12 +00005021 diag::err_operator_overload_post_incdec_must_be_int)
Chris Lattnerd1625842008-11-24 06:25:27 +00005022 << LastParam->getType() << (Op == OO_MinusMinus);
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00005023 }
5024
Sebastian Redl64b45f72009-01-05 20:52:13 +00005025 // Notify the class if it got an assignment operator.
5026 if (Op == OO_Equal) {
5027 // Would have returned earlier otherwise.
5028 assert(isa<CXXMethodDecl>(FnDecl) &&
5029 "Overloaded = not member, but not filtered.");
5030 CXXMethodDecl *Method = cast<CXXMethodDecl>(FnDecl);
5031 Method->getParent()->addedAssignmentOperator(Context, Method);
5032 }
5033
Douglas Gregor43c7bad2008-11-17 16:14:12 +00005034 return false;
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00005035}
Chris Lattner5a003a42008-12-17 07:09:26 +00005036
Sean Hunta6c058d2010-01-13 09:01:02 +00005037/// CheckLiteralOperatorDeclaration - Check whether the declaration
5038/// of this literal operator function is well-formed. If so, returns
5039/// false; otherwise, emits appropriate diagnostics and returns true.
5040bool Sema::CheckLiteralOperatorDeclaration(FunctionDecl *FnDecl) {
5041 DeclContext *DC = FnDecl->getDeclContext();
5042 Decl::Kind Kind = DC->getDeclKind();
5043 if (Kind != Decl::TranslationUnit && Kind != Decl::Namespace &&
5044 Kind != Decl::LinkageSpec) {
5045 Diag(FnDecl->getLocation(), diag::err_literal_operator_outside_namespace)
5046 << FnDecl->getDeclName();
5047 return true;
5048 }
5049
5050 bool Valid = false;
5051
5052 // FIXME: Check for the one valid template signature
5053 // template <char...> type operator "" name();
5054
5055 if (FunctionDecl::param_iterator Param = FnDecl->param_begin()) {
5056 // Check the first parameter
5057 QualType T = (*Param)->getType();
5058
5059 // unsigned long long int and long double are allowed, but only
5060 // alone.
5061 // We also allow any character type; their omission seems to be a bug
5062 // in n3000
5063 if (Context.hasSameType(T, Context.UnsignedLongLongTy) ||
5064 Context.hasSameType(T, Context.LongDoubleTy) ||
5065 Context.hasSameType(T, Context.CharTy) ||
5066 Context.hasSameType(T, Context.WCharTy) ||
5067 Context.hasSameType(T, Context.Char16Ty) ||
5068 Context.hasSameType(T, Context.Char32Ty)) {
5069 if (++Param == FnDecl->param_end())
5070 Valid = true;
5071 goto FinishedParams;
5072 }
5073
5074 // Otherwise it must be a pointer to const; let's strip those.
5075 const PointerType *PT = T->getAs<PointerType>();
5076 if (!PT)
5077 goto FinishedParams;
5078 T = PT->getPointeeType();
5079 if (!T.isConstQualified())
5080 goto FinishedParams;
5081 T = T.getUnqualifiedType();
5082
5083 // Move on to the second parameter;
5084 ++Param;
5085
5086 // If there is no second parameter, the first must be a const char *
5087 if (Param == FnDecl->param_end()) {
5088 if (Context.hasSameType(T, Context.CharTy))
5089 Valid = true;
5090 goto FinishedParams;
5091 }
5092
5093 // const char *, const wchar_t*, const char16_t*, and const char32_t*
5094 // are allowed as the first parameter to a two-parameter function
5095 if (!(Context.hasSameType(T, Context.CharTy) ||
5096 Context.hasSameType(T, Context.WCharTy) ||
5097 Context.hasSameType(T, Context.Char16Ty) ||
5098 Context.hasSameType(T, Context.Char32Ty)))
5099 goto FinishedParams;
5100
5101 // The second and final parameter must be an std::size_t
5102 T = (*Param)->getType().getUnqualifiedType();
5103 if (Context.hasSameType(T, Context.getSizeType()) &&
5104 ++Param == FnDecl->param_end())
5105 Valid = true;
5106 }
5107
5108 // FIXME: This diagnostic is absolutely terrible.
5109FinishedParams:
5110 if (!Valid) {
5111 Diag(FnDecl->getLocation(), diag::err_literal_operator_params)
5112 << FnDecl->getDeclName();
5113 return true;
5114 }
5115
5116 return false;
5117}
5118
Douglas Gregor074149e2009-01-05 19:45:36 +00005119/// ActOnStartLinkageSpecification - Parsed the beginning of a C++
5120/// linkage specification, including the language and (if present)
5121/// the '{'. ExternLoc is the location of the 'extern', LangLoc is
5122/// the location of the language string literal, which is provided
5123/// by Lang/StrSize. LBraceLoc, if valid, provides the location of
5124/// the '{' brace. Otherwise, this linkage specification does not
5125/// have any braces.
Chris Lattnerb28317a2009-03-28 19:18:32 +00005126Sema::DeclPtrTy Sema::ActOnStartLinkageSpecification(Scope *S,
5127 SourceLocation ExternLoc,
5128 SourceLocation LangLoc,
5129 const char *Lang,
5130 unsigned StrSize,
5131 SourceLocation LBraceLoc) {
Chris Lattnercc98eac2008-12-17 07:13:27 +00005132 LinkageSpecDecl::LanguageIDs Language;
5133 if (strncmp(Lang, "\"C\"", StrSize) == 0)
5134 Language = LinkageSpecDecl::lang_c;
5135 else if (strncmp(Lang, "\"C++\"", StrSize) == 0)
5136 Language = LinkageSpecDecl::lang_cxx;
5137 else {
Douglas Gregor074149e2009-01-05 19:45:36 +00005138 Diag(LangLoc, diag::err_bad_language);
Chris Lattnerb28317a2009-03-28 19:18:32 +00005139 return DeclPtrTy();
Chris Lattnercc98eac2008-12-17 07:13:27 +00005140 }
Mike Stump1eb44332009-09-09 15:08:12 +00005141
Chris Lattnercc98eac2008-12-17 07:13:27 +00005142 // FIXME: Add all the various semantics of linkage specifications
Mike Stump1eb44332009-09-09 15:08:12 +00005143
Douglas Gregor074149e2009-01-05 19:45:36 +00005144 LinkageSpecDecl *D = LinkageSpecDecl::Create(Context, CurContext,
Mike Stump1eb44332009-09-09 15:08:12 +00005145 LangLoc, Language,
Douglas Gregor074149e2009-01-05 19:45:36 +00005146 LBraceLoc.isValid());
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00005147 CurContext->addDecl(D);
Douglas Gregor074149e2009-01-05 19:45:36 +00005148 PushDeclContext(S, D);
Chris Lattnerb28317a2009-03-28 19:18:32 +00005149 return DeclPtrTy::make(D);
Chris Lattnercc98eac2008-12-17 07:13:27 +00005150}
5151
Douglas Gregor074149e2009-01-05 19:45:36 +00005152/// ActOnFinishLinkageSpecification - Completely the definition of
5153/// the C++ linkage specification LinkageSpec. If RBraceLoc is
5154/// valid, it's the position of the closing '}' brace in a linkage
5155/// specification that uses braces.
Chris Lattnerb28317a2009-03-28 19:18:32 +00005156Sema::DeclPtrTy Sema::ActOnFinishLinkageSpecification(Scope *S,
5157 DeclPtrTy LinkageSpec,
5158 SourceLocation RBraceLoc) {
Douglas Gregor074149e2009-01-05 19:45:36 +00005159 if (LinkageSpec)
5160 PopDeclContext();
5161 return LinkageSpec;
Chris Lattner5a003a42008-12-17 07:09:26 +00005162}
5163
Douglas Gregord308e622009-05-18 20:51:54 +00005164/// \brief Perform semantic analysis for the variable declaration that
5165/// occurs within a C++ catch clause, returning the newly-created
5166/// variable.
5167VarDecl *Sema::BuildExceptionDeclaration(Scope *S, QualType ExDeclType,
John McCalla93c9342009-12-07 02:54:59 +00005168 TypeSourceInfo *TInfo,
Douglas Gregord308e622009-05-18 20:51:54 +00005169 IdentifierInfo *Name,
5170 SourceLocation Loc,
5171 SourceRange Range) {
5172 bool Invalid = false;
Sebastian Redl4b07b292008-12-22 19:15:10 +00005173
5174 // Arrays and functions decay.
5175 if (ExDeclType->isArrayType())
5176 ExDeclType = Context.getArrayDecayedType(ExDeclType);
5177 else if (ExDeclType->isFunctionType())
5178 ExDeclType = Context.getPointerType(ExDeclType);
5179
5180 // C++ 15.3p1: The exception-declaration shall not denote an incomplete type.
5181 // The exception-declaration shall not denote a pointer or reference to an
5182 // incomplete type, other than [cv] void*.
Sebastian Redlf2e21e52009-03-22 23:49:27 +00005183 // N2844 forbids rvalue references.
Mike Stump1eb44332009-09-09 15:08:12 +00005184 if (!ExDeclType->isDependentType() && ExDeclType->isRValueReferenceType()) {
Douglas Gregord308e622009-05-18 20:51:54 +00005185 Diag(Loc, diag::err_catch_rvalue_ref) << Range;
Sebastian Redlf2e21e52009-03-22 23:49:27 +00005186 Invalid = true;
5187 }
Douglas Gregord308e622009-05-18 20:51:54 +00005188
Sebastian Redl4b07b292008-12-22 19:15:10 +00005189 QualType BaseType = ExDeclType;
5190 int Mode = 0; // 0 for direct type, 1 for pointer, 2 for reference
Douglas Gregor4ec339f2009-01-19 19:26:10 +00005191 unsigned DK = diag::err_catch_incomplete;
Ted Kremenek6217b802009-07-29 21:53:49 +00005192 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) {
Sebastian Redl4b07b292008-12-22 19:15:10 +00005193 BaseType = Ptr->getPointeeType();
5194 Mode = 1;
Douglas Gregor4ec339f2009-01-19 19:26:10 +00005195 DK = diag::err_catch_incomplete_ptr;
Mike Stump1eb44332009-09-09 15:08:12 +00005196 } else if (const ReferenceType *Ref = BaseType->getAs<ReferenceType>()) {
Sebastian Redlf2e21e52009-03-22 23:49:27 +00005197 // For the purpose of error recovery, we treat rvalue refs like lvalue refs.
Sebastian Redl4b07b292008-12-22 19:15:10 +00005198 BaseType = Ref->getPointeeType();
5199 Mode = 2;
Douglas Gregor4ec339f2009-01-19 19:26:10 +00005200 DK = diag::err_catch_incomplete_ref;
Sebastian Redl4b07b292008-12-22 19:15:10 +00005201 }
Sebastian Redlf2e21e52009-03-22 23:49:27 +00005202 if (!Invalid && (Mode == 0 || !BaseType->isVoidType()) &&
Douglas Gregord308e622009-05-18 20:51:54 +00005203 !BaseType->isDependentType() && RequireCompleteType(Loc, BaseType, DK))
Sebastian Redl4b07b292008-12-22 19:15:10 +00005204 Invalid = true;
Sebastian Redl4b07b292008-12-22 19:15:10 +00005205
Mike Stump1eb44332009-09-09 15:08:12 +00005206 if (!Invalid && !ExDeclType->isDependentType() &&
Douglas Gregord308e622009-05-18 20:51:54 +00005207 RequireNonAbstractType(Loc, ExDeclType,
5208 diag::err_abstract_type_in_decl,
5209 AbstractVariableType))
Sebastian Redlfef9f592009-04-27 21:03:30 +00005210 Invalid = true;
5211
Douglas Gregord308e622009-05-18 20:51:54 +00005212 // FIXME: Need to test for ability to copy-construct and destroy the
5213 // exception variable.
5214
Sebastian Redl8351da02008-12-22 21:35:02 +00005215 // FIXME: Need to check for abstract classes.
5216
Mike Stump1eb44332009-09-09 15:08:12 +00005217 VarDecl *ExDecl = VarDecl::Create(Context, CurContext, Loc,
John McCalla93c9342009-12-07 02:54:59 +00005218 Name, ExDeclType, TInfo, VarDecl::None);
Douglas Gregord308e622009-05-18 20:51:54 +00005219
5220 if (Invalid)
5221 ExDecl->setInvalidDecl();
5222
5223 return ExDecl;
5224}
5225
5226/// ActOnExceptionDeclarator - Parsed the exception-declarator in a C++ catch
5227/// handler.
5228Sema::DeclPtrTy Sema::ActOnExceptionDeclarator(Scope *S, Declarator &D) {
John McCalla93c9342009-12-07 02:54:59 +00005229 TypeSourceInfo *TInfo = 0;
5230 QualType ExDeclType = GetTypeForDeclarator(D, S, &TInfo);
Douglas Gregord308e622009-05-18 20:51:54 +00005231
5232 bool Invalid = D.isInvalidType();
Sebastian Redl4b07b292008-12-22 19:15:10 +00005233 IdentifierInfo *II = D.getIdentifier();
John McCallf36e02d2009-10-09 21:13:30 +00005234 if (NamedDecl *PrevDecl = LookupSingleName(S, II, LookupOrdinaryName)) {
Sebastian Redl4b07b292008-12-22 19:15:10 +00005235 // The scope should be freshly made just for us. There is just no way
5236 // it contains any previous declaration.
Chris Lattnerb28317a2009-03-28 19:18:32 +00005237 assert(!S->isDeclScope(DeclPtrTy::make(PrevDecl)));
Sebastian Redl4b07b292008-12-22 19:15:10 +00005238 if (PrevDecl->isTemplateParameter()) {
5239 // Maybe we will complain about the shadowed template parameter.
5240 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
Sebastian Redl4b07b292008-12-22 19:15:10 +00005241 }
5242 }
5243
Chris Lattnereaaebc72009-04-25 08:06:05 +00005244 if (D.getCXXScopeSpec().isSet() && !Invalid) {
Sebastian Redl4b07b292008-12-22 19:15:10 +00005245 Diag(D.getIdentifierLoc(), diag::err_qualified_catch_declarator)
5246 << D.getCXXScopeSpec().getRange();
Chris Lattnereaaebc72009-04-25 08:06:05 +00005247 Invalid = true;
Sebastian Redl4b07b292008-12-22 19:15:10 +00005248 }
5249
John McCalla93c9342009-12-07 02:54:59 +00005250 VarDecl *ExDecl = BuildExceptionDeclaration(S, ExDeclType, TInfo,
Douglas Gregord308e622009-05-18 20:51:54 +00005251 D.getIdentifier(),
5252 D.getIdentifierLoc(),
5253 D.getDeclSpec().getSourceRange());
5254
Chris Lattnereaaebc72009-04-25 08:06:05 +00005255 if (Invalid)
5256 ExDecl->setInvalidDecl();
Mike Stump1eb44332009-09-09 15:08:12 +00005257
Sebastian Redl4b07b292008-12-22 19:15:10 +00005258 // Add the exception declaration into this scope.
Sebastian Redl4b07b292008-12-22 19:15:10 +00005259 if (II)
Douglas Gregord308e622009-05-18 20:51:54 +00005260 PushOnScopeChains(ExDecl, S);
5261 else
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00005262 CurContext->addDecl(ExDecl);
Sebastian Redl4b07b292008-12-22 19:15:10 +00005263
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00005264 ProcessDeclAttributes(S, ExDecl, D);
Chris Lattnerb28317a2009-03-28 19:18:32 +00005265 return DeclPtrTy::make(ExDecl);
Sebastian Redl4b07b292008-12-22 19:15:10 +00005266}
Anders Carlssonfb311762009-03-14 00:25:26 +00005267
Mike Stump1eb44332009-09-09 15:08:12 +00005268Sema::DeclPtrTy Sema::ActOnStaticAssertDeclaration(SourceLocation AssertLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00005269 ExprArg assertexpr,
5270 ExprArg assertmessageexpr) {
Anders Carlssonfb311762009-03-14 00:25:26 +00005271 Expr *AssertExpr = (Expr *)assertexpr.get();
Mike Stump1eb44332009-09-09 15:08:12 +00005272 StringLiteral *AssertMessage =
Anders Carlssonfb311762009-03-14 00:25:26 +00005273 cast<StringLiteral>((Expr *)assertmessageexpr.get());
5274
Anders Carlssonc3082412009-03-14 00:33:21 +00005275 if (!AssertExpr->isTypeDependent() && !AssertExpr->isValueDependent()) {
5276 llvm::APSInt Value(32);
5277 if (!AssertExpr->isIntegerConstantExpr(Value, Context)) {
5278 Diag(AssertLoc, diag::err_static_assert_expression_is_not_constant) <<
5279 AssertExpr->getSourceRange();
Chris Lattnerb28317a2009-03-28 19:18:32 +00005280 return DeclPtrTy();
Anders Carlssonc3082412009-03-14 00:33:21 +00005281 }
Anders Carlssonfb311762009-03-14 00:25:26 +00005282
Anders Carlssonc3082412009-03-14 00:33:21 +00005283 if (Value == 0) {
Mike Stump1eb44332009-09-09 15:08:12 +00005284 Diag(AssertLoc, diag::err_static_assert_failed)
Benjamin Kramer8d042582009-12-11 13:33:18 +00005285 << AssertMessage->getString() << AssertExpr->getSourceRange();
Anders Carlssonc3082412009-03-14 00:33:21 +00005286 }
5287 }
Mike Stump1eb44332009-09-09 15:08:12 +00005288
Anders Carlsson77d81422009-03-15 17:35:16 +00005289 assertexpr.release();
5290 assertmessageexpr.release();
Mike Stump1eb44332009-09-09 15:08:12 +00005291 Decl *Decl = StaticAssertDecl::Create(Context, CurContext, AssertLoc,
Anders Carlssonfb311762009-03-14 00:25:26 +00005292 AssertExpr, AssertMessage);
Mike Stump1eb44332009-09-09 15:08:12 +00005293
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00005294 CurContext->addDecl(Decl);
Chris Lattnerb28317a2009-03-28 19:18:32 +00005295 return DeclPtrTy::make(Decl);
Anders Carlssonfb311762009-03-14 00:25:26 +00005296}
Sebastian Redl50de12f2009-03-24 22:27:57 +00005297
John McCalldd4a3b02009-09-16 22:47:08 +00005298/// Handle a friend type declaration. This works in tandem with
5299/// ActOnTag.
5300///
5301/// Notes on friend class templates:
5302///
5303/// We generally treat friend class declarations as if they were
5304/// declaring a class. So, for example, the elaborated type specifier
5305/// in a friend declaration is required to obey the restrictions of a
5306/// class-head (i.e. no typedefs in the scope chain), template
5307/// parameters are required to match up with simple template-ids, &c.
5308/// However, unlike when declaring a template specialization, it's
5309/// okay to refer to a template specialization without an empty
5310/// template parameter declaration, e.g.
5311/// friend class A<T>::B<unsigned>;
5312/// We permit this as a special case; if there are any template
5313/// parameters present at all, require proper matching, i.e.
5314/// template <> template <class T> friend class A<int>::B;
Chris Lattnerc7f19042009-10-25 17:47:27 +00005315Sema::DeclPtrTy Sema::ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS,
John McCalldd4a3b02009-09-16 22:47:08 +00005316 MultiTemplateParamsArg TempParams) {
John McCall02cace72009-08-28 07:59:38 +00005317 SourceLocation Loc = DS.getSourceRange().getBegin();
John McCall67d1a672009-08-06 02:15:43 +00005318
5319 assert(DS.isFriendSpecified());
5320 assert(DS.getStorageClassSpec() == DeclSpec::SCS_unspecified);
5321
John McCalldd4a3b02009-09-16 22:47:08 +00005322 // Try to convert the decl specifier to a type. This works for
5323 // friend templates because ActOnTag never produces a ClassTemplateDecl
5324 // for a TUK_Friend.
Chris Lattnerc7f19042009-10-25 17:47:27 +00005325 Declarator TheDeclarator(DS, Declarator::MemberContext);
Chris Lattnerc7f19042009-10-25 17:47:27 +00005326 QualType T = GetTypeForDeclarator(TheDeclarator, S);
5327 if (TheDeclarator.isInvalidType())
5328 return DeclPtrTy();
John McCall67d1a672009-08-06 02:15:43 +00005329
John McCalldd4a3b02009-09-16 22:47:08 +00005330 // This is definitely an error in C++98. It's probably meant to
5331 // be forbidden in C++0x, too, but the specification is just
5332 // poorly written.
5333 //
5334 // The problem is with declarations like the following:
5335 // template <T> friend A<T>::foo;
5336 // where deciding whether a class C is a friend or not now hinges
5337 // on whether there exists an instantiation of A that causes
5338 // 'foo' to equal C. There are restrictions on class-heads
5339 // (which we declare (by fiat) elaborated friend declarations to
5340 // be) that makes this tractable.
5341 //
5342 // FIXME: handle "template <> friend class A<T>;", which
5343 // is possibly well-formed? Who even knows?
5344 if (TempParams.size() && !isa<ElaboratedType>(T)) {
5345 Diag(Loc, diag::err_tagless_friend_type_template)
5346 << DS.getSourceRange();
5347 return DeclPtrTy();
5348 }
5349
John McCall02cace72009-08-28 07:59:38 +00005350 // C++ [class.friend]p2:
5351 // An elaborated-type-specifier shall be used in a friend declaration
5352 // for a class.*
5353 // * The class-key of the elaborated-type-specifier is required.
John McCall6b2becf2009-09-08 17:47:29 +00005354 // This is one of the rare places in Clang where it's legitimate to
5355 // ask about the "spelling" of the type.
5356 if (!getLangOptions().CPlusPlus0x && !isa<ElaboratedType>(T)) {
5357 // If we evaluated the type to a record type, suggest putting
5358 // a tag in front.
John McCall02cace72009-08-28 07:59:38 +00005359 if (const RecordType *RT = T->getAs<RecordType>()) {
John McCall6b2becf2009-09-08 17:47:29 +00005360 RecordDecl *RD = RT->getDecl();
5361
5362 std::string InsertionText = std::string(" ") + RD->getKindName();
5363
John McCalle3af0232009-10-07 23:34:25 +00005364 Diag(DS.getTypeSpecTypeLoc(), diag::err_unelaborated_friend_type)
5365 << (unsigned) RD->getTagKind()
5366 << T
5367 << SourceRange(DS.getFriendSpecLoc())
John McCall6b2becf2009-09-08 17:47:29 +00005368 << CodeModificationHint::CreateInsertion(DS.getTypeSpecTypeLoc(),
5369 InsertionText);
John McCall02cace72009-08-28 07:59:38 +00005370 return DeclPtrTy();
5371 }else {
John McCall6b2becf2009-09-08 17:47:29 +00005372 Diag(DS.getFriendSpecLoc(), diag::err_unexpected_friend)
5373 << DS.getSourceRange();
Mike Stump1eb44332009-09-09 15:08:12 +00005374 return DeclPtrTy();
John McCall02cace72009-08-28 07:59:38 +00005375 }
5376 }
5377
John McCalle3af0232009-10-07 23:34:25 +00005378 // Enum types cannot be friends.
5379 if (T->getAs<EnumType>()) {
5380 Diag(DS.getTypeSpecTypeLoc(), diag::err_enum_friend)
5381 << SourceRange(DS.getFriendSpecLoc());
5382 return DeclPtrTy();
John McCall6b2becf2009-09-08 17:47:29 +00005383 }
John McCall02cace72009-08-28 07:59:38 +00005384
John McCall02cace72009-08-28 07:59:38 +00005385 // C++98 [class.friend]p1: A friend of a class is a function
5386 // or class that is not a member of the class . . .
John McCalla236a552009-12-22 00:59:39 +00005387 // This is fixed in DR77, which just barely didn't make the C++03
5388 // deadline. It's also a very silly restriction that seriously
5389 // affects inner classes and which nobody else seems to implement;
5390 // thus we never diagnose it, not even in -pedantic.
John McCall02cace72009-08-28 07:59:38 +00005391
John McCalldd4a3b02009-09-16 22:47:08 +00005392 Decl *D;
5393 if (TempParams.size())
5394 D = FriendTemplateDecl::Create(Context, CurContext, Loc,
5395 TempParams.size(),
5396 (TemplateParameterList**) TempParams.release(),
5397 T.getTypePtr(),
5398 DS.getFriendSpecLoc());
5399 else
5400 D = FriendDecl::Create(Context, CurContext, Loc, T.getTypePtr(),
5401 DS.getFriendSpecLoc());
5402 D->setAccess(AS_public);
5403 CurContext->addDecl(D);
John McCall02cace72009-08-28 07:59:38 +00005404
John McCalldd4a3b02009-09-16 22:47:08 +00005405 return DeclPtrTy::make(D);
John McCall02cace72009-08-28 07:59:38 +00005406}
5407
John McCallbbbcdd92009-09-11 21:02:39 +00005408Sema::DeclPtrTy
5409Sema::ActOnFriendFunctionDecl(Scope *S,
5410 Declarator &D,
5411 bool IsDefinition,
5412 MultiTemplateParamsArg TemplateParams) {
John McCall02cace72009-08-28 07:59:38 +00005413 const DeclSpec &DS = D.getDeclSpec();
5414
5415 assert(DS.isFriendSpecified());
5416 assert(DS.getStorageClassSpec() == DeclSpec::SCS_unspecified);
5417
5418 SourceLocation Loc = D.getIdentifierLoc();
John McCalla93c9342009-12-07 02:54:59 +00005419 TypeSourceInfo *TInfo = 0;
5420 QualType T = GetTypeForDeclarator(D, S, &TInfo);
John McCall67d1a672009-08-06 02:15:43 +00005421
5422 // C++ [class.friend]p1
5423 // A friend of a class is a function or class....
5424 // Note that this sees through typedefs, which is intended.
John McCall02cace72009-08-28 07:59:38 +00005425 // It *doesn't* see through dependent types, which is correct
5426 // according to [temp.arg.type]p3:
5427 // If a declaration acquires a function type through a
5428 // type dependent on a template-parameter and this causes
5429 // a declaration that does not use the syntactic form of a
5430 // function declarator to have a function type, the program
5431 // is ill-formed.
John McCall67d1a672009-08-06 02:15:43 +00005432 if (!T->isFunctionType()) {
5433 Diag(Loc, diag::err_unexpected_friend);
5434
5435 // It might be worthwhile to try to recover by creating an
5436 // appropriate declaration.
5437 return DeclPtrTy();
5438 }
5439
5440 // C++ [namespace.memdef]p3
5441 // - If a friend declaration in a non-local class first declares a
5442 // class or function, the friend class or function is a member
5443 // of the innermost enclosing namespace.
5444 // - The name of the friend is not found by simple name lookup
5445 // until a matching declaration is provided in that namespace
5446 // scope (either before or after the class declaration granting
5447 // friendship).
5448 // - If a friend function is called, its name may be found by the
5449 // name lookup that considers functions from namespaces and
5450 // classes associated with the types of the function arguments.
5451 // - When looking for a prior declaration of a class or a function
5452 // declared as a friend, scopes outside the innermost enclosing
5453 // namespace scope are not considered.
5454
John McCall02cace72009-08-28 07:59:38 +00005455 CXXScopeSpec &ScopeQual = D.getCXXScopeSpec();
5456 DeclarationName Name = GetNameForDeclarator(D);
John McCall67d1a672009-08-06 02:15:43 +00005457 assert(Name);
5458
John McCall67d1a672009-08-06 02:15:43 +00005459 // The context we found the declaration in, or in which we should
5460 // create the declaration.
5461 DeclContext *DC;
5462
5463 // FIXME: handle local classes
5464
5465 // Recover from invalid scope qualifiers as if they just weren't there.
John McCall68263142009-11-18 22:49:29 +00005466 LookupResult Previous(*this, Name, D.getIdentifierLoc(), LookupOrdinaryName,
5467 ForRedeclaration);
John McCall67d1a672009-08-06 02:15:43 +00005468 if (!ScopeQual.isInvalid() && ScopeQual.isSet()) {
Douglas Gregora735b202009-10-13 14:39:41 +00005469 // FIXME: RequireCompleteDeclContext
John McCall67d1a672009-08-06 02:15:43 +00005470 DC = computeDeclContext(ScopeQual);
5471
5472 // FIXME: handle dependent contexts
5473 if (!DC) return DeclPtrTy();
5474
John McCall68263142009-11-18 22:49:29 +00005475 LookupQualifiedName(Previous, DC);
John McCall67d1a672009-08-06 02:15:43 +00005476
5477 // If searching in that context implicitly found a declaration in
5478 // a different context, treat it like it wasn't found at all.
5479 // TODO: better diagnostics for this case. Suggesting the right
5480 // qualified scope would be nice...
John McCall68263142009-11-18 22:49:29 +00005481 // FIXME: getRepresentativeDecl() is not right here at all
5482 if (Previous.empty() ||
5483 !Previous.getRepresentativeDecl()->getDeclContext()->Equals(DC)) {
John McCall02cace72009-08-28 07:59:38 +00005484 D.setInvalidType();
John McCall67d1a672009-08-06 02:15:43 +00005485 Diag(Loc, diag::err_qualified_friend_not_found) << Name << T;
5486 return DeclPtrTy();
5487 }
5488
5489 // C++ [class.friend]p1: A friend of a class is a function or
5490 // class that is not a member of the class . . .
Douglas Gregor182ddf02009-09-28 00:08:27 +00005491 if (DC->Equals(CurContext))
John McCall67d1a672009-08-06 02:15:43 +00005492 Diag(DS.getFriendSpecLoc(), diag::err_friend_is_member);
5493
John McCall67d1a672009-08-06 02:15:43 +00005494 // Otherwise walk out to the nearest namespace scope looking for matches.
5495 } else {
5496 // TODO: handle local class contexts.
5497
5498 DC = CurContext;
5499 while (true) {
5500 // Skip class contexts. If someone can cite chapter and verse
5501 // for this behavior, that would be nice --- it's what GCC and
5502 // EDG do, and it seems like a reasonable intent, but the spec
5503 // really only says that checks for unqualified existing
5504 // declarations should stop at the nearest enclosing namespace,
5505 // not that they should only consider the nearest enclosing
5506 // namespace.
Douglas Gregor182ddf02009-09-28 00:08:27 +00005507 while (DC->isRecord())
5508 DC = DC->getParent();
John McCall67d1a672009-08-06 02:15:43 +00005509
John McCall68263142009-11-18 22:49:29 +00005510 LookupQualifiedName(Previous, DC);
John McCall67d1a672009-08-06 02:15:43 +00005511
5512 // TODO: decide what we think about using declarations.
John McCall68263142009-11-18 22:49:29 +00005513 if (!Previous.empty())
John McCall67d1a672009-08-06 02:15:43 +00005514 break;
Douglas Gregor182ddf02009-09-28 00:08:27 +00005515
John McCall67d1a672009-08-06 02:15:43 +00005516 if (DC->isFileContext()) break;
5517 DC = DC->getParent();
5518 }
5519
5520 // C++ [class.friend]p1: A friend of a class is a function or
5521 // class that is not a member of the class . . .
John McCall7f27d922009-08-06 20:49:32 +00005522 // C++0x changes this for both friend types and functions.
5523 // Most C++ 98 compilers do seem to give an error here, so
5524 // we do, too.
John McCall68263142009-11-18 22:49:29 +00005525 if (!Previous.empty() && DC->Equals(CurContext)
5526 && !getLangOptions().CPlusPlus0x)
John McCall67d1a672009-08-06 02:15:43 +00005527 Diag(DS.getFriendSpecLoc(), diag::err_friend_is_member);
5528 }
5529
Douglas Gregor182ddf02009-09-28 00:08:27 +00005530 if (DC->isFileContext()) {
John McCall67d1a672009-08-06 02:15:43 +00005531 // This implies that it has to be an operator or function.
Douglas Gregor3f9a0562009-11-03 01:35:08 +00005532 if (D.getName().getKind() == UnqualifiedId::IK_ConstructorName ||
5533 D.getName().getKind() == UnqualifiedId::IK_DestructorName ||
5534 D.getName().getKind() == UnqualifiedId::IK_ConversionFunctionId) {
John McCall67d1a672009-08-06 02:15:43 +00005535 Diag(Loc, diag::err_introducing_special_friend) <<
Douglas Gregor3f9a0562009-11-03 01:35:08 +00005536 (D.getName().getKind() == UnqualifiedId::IK_ConstructorName ? 0 :
5537 D.getName().getKind() == UnqualifiedId::IK_DestructorName ? 1 : 2);
John McCall67d1a672009-08-06 02:15:43 +00005538 return DeclPtrTy();
5539 }
John McCall67d1a672009-08-06 02:15:43 +00005540 }
5541
Douglas Gregor182ddf02009-09-28 00:08:27 +00005542 bool Redeclaration = false;
John McCalla93c9342009-12-07 02:54:59 +00005543 NamedDecl *ND = ActOnFunctionDeclarator(S, D, DC, T, TInfo, Previous,
Douglas Gregora735b202009-10-13 14:39:41 +00005544 move(TemplateParams),
John McCall3f9a8a62009-08-11 06:59:38 +00005545 IsDefinition,
5546 Redeclaration);
John McCall02cace72009-08-28 07:59:38 +00005547 if (!ND) return DeclPtrTy();
John McCallab88d972009-08-31 22:39:49 +00005548
Douglas Gregor182ddf02009-09-28 00:08:27 +00005549 assert(ND->getDeclContext() == DC);
5550 assert(ND->getLexicalDeclContext() == CurContext);
John McCall88232aa2009-08-18 00:00:49 +00005551
John McCallab88d972009-08-31 22:39:49 +00005552 // Add the function declaration to the appropriate lookup tables,
5553 // adjusting the redeclarations list as necessary. We don't
5554 // want to do this yet if the friending class is dependent.
Mike Stump1eb44332009-09-09 15:08:12 +00005555 //
John McCallab88d972009-08-31 22:39:49 +00005556 // Also update the scope-based lookup if the target context's
5557 // lookup context is in lexical scope.
5558 if (!CurContext->isDependentContext()) {
5559 DC = DC->getLookupContext();
Douglas Gregor182ddf02009-09-28 00:08:27 +00005560 DC->makeDeclVisibleInContext(ND, /* Recoverable=*/ false);
John McCallab88d972009-08-31 22:39:49 +00005561 if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
Douglas Gregor182ddf02009-09-28 00:08:27 +00005562 PushOnScopeChains(ND, EnclosingScope, /*AddToContext=*/ false);
John McCallab88d972009-08-31 22:39:49 +00005563 }
John McCall02cace72009-08-28 07:59:38 +00005564
5565 FriendDecl *FrD = FriendDecl::Create(Context, CurContext,
Douglas Gregor182ddf02009-09-28 00:08:27 +00005566 D.getIdentifierLoc(), ND,
John McCall02cace72009-08-28 07:59:38 +00005567 DS.getFriendSpecLoc());
John McCall5fee1102009-08-29 03:50:18 +00005568 FrD->setAccess(AS_public);
John McCall02cace72009-08-28 07:59:38 +00005569 CurContext->addDecl(FrD);
John McCall67d1a672009-08-06 02:15:43 +00005570
Douglas Gregor7557a132009-12-24 20:56:24 +00005571 if (D.getName().getKind() == UnqualifiedId::IK_TemplateId)
5572 FrD->setSpecialization(true);
5573
Douglas Gregor182ddf02009-09-28 00:08:27 +00005574 return DeclPtrTy::make(ND);
Anders Carlsson00338362009-05-11 22:55:49 +00005575}
5576
Chris Lattnerb28317a2009-03-28 19:18:32 +00005577void Sema::SetDeclDeleted(DeclPtrTy dcl, SourceLocation DelLoc) {
Douglas Gregorefd5bda2009-08-24 11:57:43 +00005578 AdjustDeclIfTemplate(dcl);
Mike Stump1eb44332009-09-09 15:08:12 +00005579
Chris Lattnerb28317a2009-03-28 19:18:32 +00005580 Decl *Dcl = dcl.getAs<Decl>();
Sebastian Redl50de12f2009-03-24 22:27:57 +00005581 FunctionDecl *Fn = dyn_cast<FunctionDecl>(Dcl);
5582 if (!Fn) {
5583 Diag(DelLoc, diag::err_deleted_non_function);
5584 return;
5585 }
5586 if (const FunctionDecl *Prev = Fn->getPreviousDeclaration()) {
5587 Diag(DelLoc, diag::err_deleted_decl_not_first);
5588 Diag(Prev->getLocation(), diag::note_previous_declaration);
5589 // If the declaration wasn't the first, we delete the function anyway for
5590 // recovery.
5591 }
5592 Fn->setDeleted();
5593}
Sebastian Redl13e88542009-04-27 21:33:24 +00005594
5595static void SearchForReturnInStmt(Sema &Self, Stmt *S) {
5596 for (Stmt::child_iterator CI = S->child_begin(), E = S->child_end(); CI != E;
5597 ++CI) {
5598 Stmt *SubStmt = *CI;
5599 if (!SubStmt)
5600 continue;
5601 if (isa<ReturnStmt>(SubStmt))
5602 Self.Diag(SubStmt->getSourceRange().getBegin(),
5603 diag::err_return_in_constructor_handler);
5604 if (!isa<Expr>(SubStmt))
5605 SearchForReturnInStmt(Self, SubStmt);
5606 }
5607}
5608
5609void Sema::DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock) {
5610 for (unsigned I = 0, E = TryBlock->getNumHandlers(); I != E; ++I) {
5611 CXXCatchStmt *Handler = TryBlock->getHandler(I);
5612 SearchForReturnInStmt(*this, Handler);
5613 }
5614}
Anders Carlssond7ba27d2009-05-14 01:09:04 +00005615
Mike Stump1eb44332009-09-09 15:08:12 +00005616bool Sema::CheckOverridingFunctionReturnType(const CXXMethodDecl *New,
Anders Carlssond7ba27d2009-05-14 01:09:04 +00005617 const CXXMethodDecl *Old) {
John McCall183700f2009-09-21 23:43:11 +00005618 QualType NewTy = New->getType()->getAs<FunctionType>()->getResultType();
5619 QualType OldTy = Old->getType()->getAs<FunctionType>()->getResultType();
Anders Carlssond7ba27d2009-05-14 01:09:04 +00005620
Anders Carlssonf2a04bf2010-01-22 17:37:20 +00005621 if (Context.hasSameType(NewTy, OldTy))
Anders Carlssond7ba27d2009-05-14 01:09:04 +00005622 return false;
Mike Stump1eb44332009-09-09 15:08:12 +00005623
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005624 // Check if the return types are covariant
5625 QualType NewClassTy, OldClassTy;
Mike Stump1eb44332009-09-09 15:08:12 +00005626
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005627 /// Both types must be pointers or references to classes.
Anders Carlssonf2a04bf2010-01-22 17:37:20 +00005628 if (const PointerType *NewPT = NewTy->getAs<PointerType>()) {
5629 if (const PointerType *OldPT = OldTy->getAs<PointerType>()) {
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005630 NewClassTy = NewPT->getPointeeType();
5631 OldClassTy = OldPT->getPointeeType();
5632 }
Anders Carlssonf2a04bf2010-01-22 17:37:20 +00005633 } else if (const ReferenceType *NewRT = NewTy->getAs<ReferenceType>()) {
5634 if (const ReferenceType *OldRT = OldTy->getAs<ReferenceType>()) {
5635 if (NewRT->getTypeClass() == OldRT->getTypeClass()) {
5636 NewClassTy = NewRT->getPointeeType();
5637 OldClassTy = OldRT->getPointeeType();
5638 }
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005639 }
5640 }
Mike Stump1eb44332009-09-09 15:08:12 +00005641
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005642 // The return types aren't either both pointers or references to a class type.
5643 if (NewClassTy.isNull()) {
Mike Stump1eb44332009-09-09 15:08:12 +00005644 Diag(New->getLocation(),
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005645 diag::err_different_return_type_for_overriding_virtual_function)
5646 << New->getDeclName() << NewTy << OldTy;
5647 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
Mike Stump1eb44332009-09-09 15:08:12 +00005648
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005649 return true;
5650 }
Anders Carlssond7ba27d2009-05-14 01:09:04 +00005651
Anders Carlssonbe2e2052009-12-31 18:34:24 +00005652 // C++ [class.virtual]p6:
5653 // If the return type of D::f differs from the return type of B::f, the
5654 // class type in the return type of D::f shall be complete at the point of
5655 // declaration of D::f or shall be the class type D.
Anders Carlssonac4c9392009-12-31 18:54:35 +00005656 if (const RecordType *RT = NewClassTy->getAs<RecordType>()) {
5657 if (!RT->isBeingDefined() &&
5658 RequireCompleteType(New->getLocation(), NewClassTy,
5659 PDiag(diag::err_covariant_return_incomplete)
5660 << New->getDeclName()))
Anders Carlssonbe2e2052009-12-31 18:34:24 +00005661 return true;
Anders Carlssonac4c9392009-12-31 18:54:35 +00005662 }
Anders Carlssonbe2e2052009-12-31 18:34:24 +00005663
Douglas Gregora4923eb2009-11-16 21:35:15 +00005664 if (!Context.hasSameUnqualifiedType(NewClassTy, OldClassTy)) {
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005665 // Check if the new class derives from the old class.
5666 if (!IsDerivedFrom(NewClassTy, OldClassTy)) {
5667 Diag(New->getLocation(),
5668 diag::err_covariant_return_not_derived)
5669 << New->getDeclName() << NewTy << OldTy;
5670 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
5671 return true;
5672 }
Mike Stump1eb44332009-09-09 15:08:12 +00005673
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005674 // Check if we the conversion from derived to base is valid.
Mike Stump1eb44332009-09-09 15:08:12 +00005675 if (CheckDerivedToBaseConversion(NewClassTy, OldClassTy,
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005676 diag::err_covariant_return_inaccessible_base,
5677 diag::err_covariant_return_ambiguous_derived_to_base_conv,
5678 // FIXME: Should this point to the return type?
5679 New->getLocation(), SourceRange(), New->getDeclName())) {
5680 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
5681 return true;
5682 }
5683 }
Mike Stump1eb44332009-09-09 15:08:12 +00005684
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005685 // The qualifiers of the return types must be the same.
Anders Carlssonf2a04bf2010-01-22 17:37:20 +00005686 if (NewTy.getLocalCVRQualifiers() != OldTy.getLocalCVRQualifiers()) {
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005687 Diag(New->getLocation(),
5688 diag::err_covariant_return_type_different_qualifications)
Anders Carlssond7ba27d2009-05-14 01:09:04 +00005689 << New->getDeclName() << NewTy << OldTy;
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005690 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
5691 return true;
5692 };
Mike Stump1eb44332009-09-09 15:08:12 +00005693
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005694
5695 // The new class type must have the same or less qualifiers as the old type.
5696 if (NewClassTy.isMoreQualifiedThan(OldClassTy)) {
5697 Diag(New->getLocation(),
5698 diag::err_covariant_return_type_class_type_more_qualified)
5699 << New->getDeclName() << NewTy << OldTy;
5700 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
5701 return true;
5702 };
Mike Stump1eb44332009-09-09 15:08:12 +00005703
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005704 return false;
Anders Carlssond7ba27d2009-05-14 01:09:04 +00005705}
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00005706
Sean Huntbbd37c62009-11-21 08:43:09 +00005707bool Sema::CheckOverridingFunctionAttributes(const CXXMethodDecl *New,
5708 const CXXMethodDecl *Old)
5709{
5710 if (Old->hasAttr<FinalAttr>()) {
5711 Diag(New->getLocation(), diag::err_final_function_overridden)
5712 << New->getDeclName();
5713 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
5714 return true;
5715 }
5716
5717 return false;
5718}
5719
Douglas Gregor4ba31362009-12-01 17:24:26 +00005720/// \brief Mark the given method pure.
5721///
5722/// \param Method the method to be marked pure.
5723///
5724/// \param InitRange the source range that covers the "0" initializer.
5725bool Sema::CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange) {
5726 if (Method->isVirtual() || Method->getParent()->isDependentContext()) {
5727 Method->setPure();
5728
5729 // A class is abstract if at least one function is pure virtual.
5730 Method->getParent()->setAbstract(true);
5731 return false;
5732 }
5733
5734 if (!Method->isInvalidDecl())
5735 Diag(Method->getLocation(), diag::err_non_virtual_pure)
5736 << Method->getDeclName() << InitRange;
5737 return true;
5738}
5739
John McCall731ad842009-12-19 09:28:58 +00005740/// ActOnCXXEnterDeclInitializer - Invoked when we are about to parse
5741/// an initializer for the out-of-line declaration 'Dcl'. The scope
5742/// is a fresh scope pushed for just this purpose.
5743///
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00005744/// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
5745/// static data member of class X, names should be looked up in the scope of
5746/// class X.
5747void Sema::ActOnCXXEnterDeclInitializer(Scope *S, DeclPtrTy Dcl) {
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00005748 // If there is no declaration, there was an error parsing it.
John McCall731ad842009-12-19 09:28:58 +00005749 Decl *D = Dcl.getAs<Decl>();
5750 if (D == 0) return;
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00005751
John McCall731ad842009-12-19 09:28:58 +00005752 // We should only get called for declarations with scope specifiers, like:
5753 // int foo::bar;
5754 assert(D->isOutOfLine());
John McCall7a1dc562009-12-19 10:49:29 +00005755 EnterDeclaratorContext(S, D->getDeclContext());
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00005756}
5757
5758/// ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an
John McCall731ad842009-12-19 09:28:58 +00005759/// initializer for the out-of-line declaration 'Dcl'.
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00005760void Sema::ActOnCXXExitDeclInitializer(Scope *S, DeclPtrTy Dcl) {
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00005761 // If there is no declaration, there was an error parsing it.
John McCall731ad842009-12-19 09:28:58 +00005762 Decl *D = Dcl.getAs<Decl>();
5763 if (D == 0) return;
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00005764
John McCall731ad842009-12-19 09:28:58 +00005765 assert(D->isOutOfLine());
John McCall7a1dc562009-12-19 10:49:29 +00005766 ExitDeclaratorContext(S);
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00005767}
Douglas Gregor99e9b4d2009-11-25 00:27:52 +00005768
5769/// ActOnCXXConditionDeclarationExpr - Parsed a condition declaration of a
5770/// C++ if/switch/while/for statement.
5771/// e.g: "if (int x = f()) {...}"
5772Action::DeclResult
5773Sema::ActOnCXXConditionDeclaration(Scope *S, Declarator &D) {
5774 // C++ 6.4p2:
5775 // The declarator shall not specify a function or an array.
5776 // The type-specifier-seq shall not contain typedef and shall not declare a
5777 // new class or enumeration.
5778 assert(D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef &&
5779 "Parser allowed 'typedef' as storage class of condition decl.");
5780
John McCalla93c9342009-12-07 02:54:59 +00005781 TypeSourceInfo *TInfo = 0;
Douglas Gregor99e9b4d2009-11-25 00:27:52 +00005782 TagDecl *OwnedTag = 0;
John McCalla93c9342009-12-07 02:54:59 +00005783 QualType Ty = GetTypeForDeclarator(D, S, &TInfo, &OwnedTag);
Douglas Gregor99e9b4d2009-11-25 00:27:52 +00005784
5785 if (Ty->isFunctionType()) { // The declarator shall not specify a function...
5786 // We exit without creating a CXXConditionDeclExpr because a FunctionDecl
5787 // would be created and CXXConditionDeclExpr wants a VarDecl.
5788 Diag(D.getIdentifierLoc(), diag::err_invalid_use_of_function_type)
5789 << D.getSourceRange();
5790 return DeclResult();
5791 } else if (OwnedTag && OwnedTag->isDefinition()) {
5792 // The type-specifier-seq shall not declare a new class or enumeration.
5793 Diag(OwnedTag->getLocation(), diag::err_type_defined_in_condition);
5794 }
5795
5796 DeclPtrTy Dcl = ActOnDeclarator(S, D);
5797 if (!Dcl)
5798 return DeclResult();
5799
5800 VarDecl *VD = cast<VarDecl>(Dcl.getAs<Decl>());
5801 VD->setDeclaredInCondition(true);
5802 return Dcl;
5803}
Anders Carlsson5ec02ae2009-12-02 17:15:43 +00005804
Anders Carlssond6a637f2009-12-07 08:24:59 +00005805void Sema::MaybeMarkVirtualMembersReferenced(SourceLocation Loc,
5806 CXXMethodDecl *MD) {
Anders Carlsson5ec02ae2009-12-02 17:15:43 +00005807 // Ignore dependent types.
5808 if (MD->isDependentContext())
5809 return;
5810
5811 CXXRecordDecl *RD = MD->getParent();
Anders Carlssonf53df232009-12-07 04:35:11 +00005812
5813 // Ignore classes without a vtable.
5814 if (!RD->isDynamicClass())
5815 return;
5816
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00005817 // Ignore declarations that are not definitions.
5818 if (!MD->isThisDeclarationADefinition())
Anders Carlssond6a637f2009-12-07 08:24:59 +00005819 return;
Douglas Gregor159ef1e2010-01-06 04:44:19 +00005820
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00005821 if (isa<CXXConstructorDecl>(MD)) {
5822 switch (MD->getParent()->getTemplateSpecializationKind()) {
5823 case TSK_Undeclared:
5824 case TSK_ExplicitSpecialization:
5825 // Classes that aren't instantiations of templates don't need their
5826 // virtual methods marked until we see the definition of the key
5827 // function.
5828 return;
5829
5830 case TSK_ImplicitInstantiation:
5831 case TSK_ExplicitInstantiationDeclaration:
5832 case TSK_ExplicitInstantiationDefinition:
5833 // This is a constructor of a class template; mark all of the virtual
5834 // members as referenced to ensure that they get instantiatied.
5835 break;
5836 }
5837 } else if (!MD->isOutOfLine()) {
5838 // Consider only out-of-line definitions of member functions. When we see
5839 // an inline definition, it's too early to compute the key function.
Douglas Gregor159ef1e2010-01-06 04:44:19 +00005840 return;
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00005841 } else if (const CXXMethodDecl *KeyFunction = Context.getKeyFunction(RD)) {
5842 // If this is not the key function, we don't need to mark virtual members.
5843 if (KeyFunction->getCanonicalDecl() != MD->getCanonicalDecl())
5844 return;
5845 } else {
5846 // The class has no key function, so we've already noted that we need to
5847 // mark the virtual members of this class.
5848 return;
5849 }
5850
Douglas Gregor159ef1e2010-01-06 04:44:19 +00005851 // We will need to mark all of the virtual members as referenced to build the
5852 // vtable.
5853 ClassesWithUnmarkedVirtualMembers.push_back(std::make_pair(RD, Loc));
Anders Carlssond6a637f2009-12-07 08:24:59 +00005854}
5855
5856bool Sema::ProcessPendingClassesWithUnmarkedVirtualMembers() {
5857 if (ClassesWithUnmarkedVirtualMembers.empty())
5858 return false;
5859
Douglas Gregor159ef1e2010-01-06 04:44:19 +00005860 while (!ClassesWithUnmarkedVirtualMembers.empty()) {
5861 CXXRecordDecl *RD = ClassesWithUnmarkedVirtualMembers.back().first;
5862 SourceLocation Loc = ClassesWithUnmarkedVirtualMembers.back().second;
5863 ClassesWithUnmarkedVirtualMembers.pop_back();
Anders Carlssond6a637f2009-12-07 08:24:59 +00005864 MarkVirtualMembersReferenced(Loc, RD);
Anders Carlsson5ec02ae2009-12-02 17:15:43 +00005865 }
5866
Anders Carlssond6a637f2009-12-07 08:24:59 +00005867 return true;
Anders Carlsson5ec02ae2009-12-02 17:15:43 +00005868}
Anders Carlssond6a637f2009-12-07 08:24:59 +00005869
5870void Sema::MarkVirtualMembersReferenced(SourceLocation Loc, CXXRecordDecl *RD) {
5871 for (CXXRecordDecl::method_iterator i = RD->method_begin(),
5872 e = RD->method_end(); i != e; ++i) {
5873 CXXMethodDecl *MD = *i;
5874
5875 // C++ [basic.def.odr]p2:
5876 // [...] A virtual member function is used if it is not pure. [...]
5877 if (MD->isVirtual() && !MD->isPure())
5878 MarkDeclarationReferenced(Loc, MD);
5879 }
5880}
5881