blob: 566e915bc0115fd8740acde7ad1c75ee6b30ec10 [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
John McCall233a6412010-01-28 07:38:46 +00002089 // Set access bits correctly on the directly-declared conversions.
2090 UnresolvedSetImpl *Convs = Record->getConversionFunctions();
2091 for (UnresolvedSetIterator I = Convs->begin(), E = Convs->end(); I != E; ++I)
2092 Convs->setAccess(I, (*I)->getAccess());
2093
Douglas Gregor1ab537b2009-12-03 18:33:45 +00002094 if (!Record->isAbstract()) {
2095 // Collect all the pure virtual methods and see if this is an abstract
2096 // class after all.
2097 PureVirtualMethodCollector Collector(Context, Record);
2098 if (!Collector.empty())
2099 Record->setAbstract(true);
2100 }
2101
2102 if (Record->isAbstract())
2103 (void)AbstractClassUsageDiagnoser(*this, Record);
Douglas Gregor1ab537b2009-12-03 18:33:45 +00002104}
2105
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002106void Sema::ActOnFinishCXXMemberSpecification(Scope* S, SourceLocation RLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002107 DeclPtrTy TagDecl,
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002108 SourceLocation LBrac,
2109 SourceLocation RBrac) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +00002110 if (!TagDecl)
2111 return;
Mike Stump1eb44332009-09-09 15:08:12 +00002112
Douglas Gregor42af25f2009-05-11 19:58:34 +00002113 AdjustDeclIfTemplate(TagDecl);
Douglas Gregor1ab537b2009-12-03 18:33:45 +00002114
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002115 ActOnFields(S, RLoc, TagDecl,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002116 (DeclPtrTy*)FieldCollector->getCurFields(),
Daniel Dunbar1bfe1c22008-10-03 02:03:53 +00002117 FieldCollector->getCurNumFields(), LBrac, RBrac, 0);
Douglas Gregor2943aed2009-03-03 04:44:36 +00002118
Douglas Gregor1ab537b2009-12-03 18:33:45 +00002119 CheckCompletedCXXClass(
2120 dyn_cast_or_null<CXXRecordDecl>(TagDecl.getAs<Decl>()));
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002121}
2122
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002123/// AddImplicitlyDeclaredMembersToClass - Adds any implicitly-declared
2124/// special functions, such as the default constructor, copy
2125/// constructor, or destructor, to the given C++ class (C++
2126/// [special]p1). This routine can only be executed just before the
2127/// definition of the class is complete.
2128void Sema::AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl) {
Mike Stump1eb44332009-09-09 15:08:12 +00002129 CanQualType ClassType
Douglas Gregor50d62d12009-08-05 05:36:45 +00002130 = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
Douglas Gregor2e1cd422008-11-17 14:58:09 +00002131
Sebastian Redl465226e2009-05-27 22:11:52 +00002132 // FIXME: Implicit declarations have exception specifications, which are
2133 // the union of the specifications of the implicitly called functions.
2134
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002135 if (!ClassDecl->hasUserDeclaredConstructor()) {
2136 // C++ [class.ctor]p5:
2137 // A default constructor for a class X is a constructor of class X
2138 // that can be called without an argument. If there is no
2139 // user-declared constructor for class X, a default constructor is
2140 // implicitly declared. An implicitly-declared default constructor
2141 // is an inline public member of its class.
Mike Stump1eb44332009-09-09 15:08:12 +00002142 DeclarationName Name
Douglas Gregor2e1cd422008-11-17 14:58:09 +00002143 = Context.DeclarationNames.getCXXConstructorName(ClassType);
Mike Stump1eb44332009-09-09 15:08:12 +00002144 CXXConstructorDecl *DefaultCon =
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002145 CXXConstructorDecl::Create(Context, ClassDecl,
Douglas Gregor2e1cd422008-11-17 14:58:09 +00002146 ClassDecl->getLocation(), Name,
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002147 Context.getFunctionType(Context.VoidTy,
2148 0, 0, false, 0),
John McCalla93c9342009-12-07 02:54:59 +00002149 /*TInfo=*/0,
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002150 /*isExplicit=*/false,
2151 /*isInline=*/true,
2152 /*isImplicitlyDeclared=*/true);
2153 DefaultCon->setAccess(AS_public);
Douglas Gregor6b3945f2009-01-07 19:46:03 +00002154 DefaultCon->setImplicit();
Douglas Gregor1f2023a2009-07-22 18:25:24 +00002155 DefaultCon->setTrivial(ClassDecl->hasTrivialConstructor());
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002156 ClassDecl->addDecl(DefaultCon);
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002157 }
2158
2159 if (!ClassDecl->hasUserDeclaredCopyConstructor()) {
2160 // C++ [class.copy]p4:
2161 // If the class definition does not explicitly declare a copy
2162 // constructor, one is declared implicitly.
2163
2164 // C++ [class.copy]p5:
2165 // The implicitly-declared copy constructor for a class X will
2166 // have the form
2167 //
2168 // X::X(const X&)
2169 //
2170 // if
2171 bool HasConstCopyConstructor = true;
2172
2173 // -- each direct or virtual base class B of X has a copy
2174 // constructor whose first parameter is of type const B& or
2175 // const volatile B&, and
2176 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin();
2177 HasConstCopyConstructor && Base != ClassDecl->bases_end(); ++Base) {
2178 const CXXRecordDecl *BaseClassDecl
Ted Kremenek6217b802009-07-29 21:53:49 +00002179 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Mike Stump1eb44332009-09-09 15:08:12 +00002180 HasConstCopyConstructor
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002181 = BaseClassDecl->hasConstCopyConstructor(Context);
2182 }
2183
2184 // -- for all the nonstatic data members of X that are of a
2185 // class type M (or array thereof), each such class type
2186 // has a copy constructor whose first parameter is of type
2187 // const M& or const volatile M&.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002188 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin();
2189 HasConstCopyConstructor && Field != ClassDecl->field_end();
Douglas Gregor6ab35242009-04-09 21:40:53 +00002190 ++Field) {
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002191 QualType FieldType = (*Field)->getType();
2192 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
2193 FieldType = Array->getElementType();
Ted Kremenek6217b802009-07-29 21:53:49 +00002194 if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
Mike Stump1eb44332009-09-09 15:08:12 +00002195 const CXXRecordDecl *FieldClassDecl
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002196 = cast<CXXRecordDecl>(FieldClassType->getDecl());
Mike Stump1eb44332009-09-09 15:08:12 +00002197 HasConstCopyConstructor
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002198 = FieldClassDecl->hasConstCopyConstructor(Context);
2199 }
2200 }
2201
Sebastian Redl64b45f72009-01-05 20:52:13 +00002202 // Otherwise, the implicitly declared copy constructor will have
2203 // the form
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002204 //
2205 // X::X(X&)
Sebastian Redl64b45f72009-01-05 20:52:13 +00002206 QualType ArgType = ClassType;
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002207 if (HasConstCopyConstructor)
2208 ArgType = ArgType.withConst();
Sebastian Redl7c80bd62009-03-16 23:22:08 +00002209 ArgType = Context.getLValueReferenceType(ArgType);
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002210
Sebastian Redl64b45f72009-01-05 20:52:13 +00002211 // An implicitly-declared copy constructor is an inline public
2212 // member of its class.
Mike Stump1eb44332009-09-09 15:08:12 +00002213 DeclarationName Name
Douglas Gregor2e1cd422008-11-17 14:58:09 +00002214 = Context.DeclarationNames.getCXXConstructorName(ClassType);
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002215 CXXConstructorDecl *CopyConstructor
2216 = CXXConstructorDecl::Create(Context, ClassDecl,
Douglas Gregor2e1cd422008-11-17 14:58:09 +00002217 ClassDecl->getLocation(), Name,
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002218 Context.getFunctionType(Context.VoidTy,
2219 &ArgType, 1,
2220 false, 0),
John McCalla93c9342009-12-07 02:54:59 +00002221 /*TInfo=*/0,
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002222 /*isExplicit=*/false,
2223 /*isInline=*/true,
2224 /*isImplicitlyDeclared=*/true);
2225 CopyConstructor->setAccess(AS_public);
Douglas Gregor6b3945f2009-01-07 19:46:03 +00002226 CopyConstructor->setImplicit();
Douglas Gregor1f2023a2009-07-22 18:25:24 +00002227 CopyConstructor->setTrivial(ClassDecl->hasTrivialCopyConstructor());
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002228
2229 // Add the parameter to the constructor.
2230 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyConstructor,
2231 ClassDecl->getLocation(),
2232 /*IdentifierInfo=*/0,
John McCalla93c9342009-12-07 02:54:59 +00002233 ArgType, /*TInfo=*/0,
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +00002234 VarDecl::None, 0);
Ted Kremenekfc767612009-01-14 00:42:25 +00002235 CopyConstructor->setParams(Context, &FromParam, 1);
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002236 ClassDecl->addDecl(CopyConstructor);
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002237 }
2238
Sebastian Redl64b45f72009-01-05 20:52:13 +00002239 if (!ClassDecl->hasUserDeclaredCopyAssignment()) {
2240 // Note: The following rules are largely analoguous to the copy
2241 // constructor rules. Note that virtual bases are not taken into account
2242 // for determining the argument type of the operator. Note also that
2243 // operators taking an object instead of a reference are allowed.
2244 //
2245 // C++ [class.copy]p10:
2246 // If the class definition does not explicitly declare a copy
2247 // assignment operator, one is declared implicitly.
2248 // The implicitly-defined copy assignment operator for a class X
2249 // will have the form
2250 //
2251 // X& X::operator=(const X&)
2252 //
2253 // if
2254 bool HasConstCopyAssignment = true;
2255
2256 // -- each direct base class B of X has a copy assignment operator
2257 // whose parameter is of type const B&, const volatile B& or B,
2258 // and
2259 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin();
2260 HasConstCopyAssignment && Base != ClassDecl->bases_end(); ++Base) {
Sebastian Redl9994a342009-10-25 17:03:50 +00002261 assert(!Base->getType()->isDependentType() &&
2262 "Cannot generate implicit members for class with dependent bases.");
Sebastian Redl64b45f72009-01-05 20:52:13 +00002263 const CXXRecordDecl *BaseClassDecl
Ted Kremenek6217b802009-07-29 21:53:49 +00002264 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Fariborz Jahanian0270b8a2009-08-12 23:34:46 +00002265 const CXXMethodDecl *MD = 0;
Mike Stump1eb44332009-09-09 15:08:12 +00002266 HasConstCopyAssignment = BaseClassDecl->hasConstCopyAssignment(Context,
Fariborz Jahanian0270b8a2009-08-12 23:34:46 +00002267 MD);
Sebastian Redl64b45f72009-01-05 20:52:13 +00002268 }
2269
2270 // -- for all the nonstatic data members of X that are of a class
2271 // type M (or array thereof), each such class type has a copy
2272 // assignment operator whose parameter is of type const M&,
2273 // const volatile M& or M.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002274 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin();
2275 HasConstCopyAssignment && Field != ClassDecl->field_end();
Douglas Gregor6ab35242009-04-09 21:40:53 +00002276 ++Field) {
Sebastian Redl64b45f72009-01-05 20:52:13 +00002277 QualType FieldType = (*Field)->getType();
2278 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
2279 FieldType = Array->getElementType();
Ted Kremenek6217b802009-07-29 21:53:49 +00002280 if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
Sebastian Redl64b45f72009-01-05 20:52:13 +00002281 const CXXRecordDecl *FieldClassDecl
2282 = cast<CXXRecordDecl>(FieldClassType->getDecl());
Fariborz Jahanian0270b8a2009-08-12 23:34:46 +00002283 const CXXMethodDecl *MD = 0;
Sebastian Redl64b45f72009-01-05 20:52:13 +00002284 HasConstCopyAssignment
Fariborz Jahanian0270b8a2009-08-12 23:34:46 +00002285 = FieldClassDecl->hasConstCopyAssignment(Context, MD);
Sebastian Redl64b45f72009-01-05 20:52:13 +00002286 }
2287 }
2288
2289 // Otherwise, the implicitly declared copy assignment operator will
2290 // have the form
2291 //
2292 // X& X::operator=(X&)
2293 QualType ArgType = ClassType;
Sebastian Redl7c80bd62009-03-16 23:22:08 +00002294 QualType RetType = Context.getLValueReferenceType(ArgType);
Sebastian Redl64b45f72009-01-05 20:52:13 +00002295 if (HasConstCopyAssignment)
2296 ArgType = ArgType.withConst();
Sebastian Redl7c80bd62009-03-16 23:22:08 +00002297 ArgType = Context.getLValueReferenceType(ArgType);
Sebastian Redl64b45f72009-01-05 20:52:13 +00002298
2299 // An implicitly-declared copy assignment operator is an inline public
2300 // member of its class.
2301 DeclarationName Name =
2302 Context.DeclarationNames.getCXXOperatorName(OO_Equal);
2303 CXXMethodDecl *CopyAssignment =
2304 CXXMethodDecl::Create(Context, ClassDecl, ClassDecl->getLocation(), Name,
2305 Context.getFunctionType(RetType, &ArgType, 1,
2306 false, 0),
John McCalla93c9342009-12-07 02:54:59 +00002307 /*TInfo=*/0, /*isStatic=*/false, /*isInline=*/true);
Sebastian Redl64b45f72009-01-05 20:52:13 +00002308 CopyAssignment->setAccess(AS_public);
Douglas Gregor6b3945f2009-01-07 19:46:03 +00002309 CopyAssignment->setImplicit();
Douglas Gregor1f2023a2009-07-22 18:25:24 +00002310 CopyAssignment->setTrivial(ClassDecl->hasTrivialCopyAssignment());
Fariborz Jahanian2198ba12009-08-12 21:14:35 +00002311 CopyAssignment->setCopyAssignment(true);
Sebastian Redl64b45f72009-01-05 20:52:13 +00002312
2313 // Add the parameter to the operator.
2314 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyAssignment,
2315 ClassDecl->getLocation(),
2316 /*IdentifierInfo=*/0,
John McCalla93c9342009-12-07 02:54:59 +00002317 ArgType, /*TInfo=*/0,
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +00002318 VarDecl::None, 0);
Ted Kremenekfc767612009-01-14 00:42:25 +00002319 CopyAssignment->setParams(Context, &FromParam, 1);
Sebastian Redl64b45f72009-01-05 20:52:13 +00002320
2321 // Don't call addedAssignmentOperator. There is no way to distinguish an
2322 // implicit from an explicit assignment operator.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002323 ClassDecl->addDecl(CopyAssignment);
Eli Friedmanca6affd2009-12-02 06:59:20 +00002324 AddOverriddenMethods(ClassDecl, CopyAssignment);
Sebastian Redl64b45f72009-01-05 20:52:13 +00002325 }
2326
Douglas Gregor9e7d9de2008-12-15 21:24:18 +00002327 if (!ClassDecl->hasUserDeclaredDestructor()) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00002328 // C++ [class.dtor]p2:
2329 // If a class has no user-declared destructor, a destructor is
2330 // declared implicitly. An implicitly-declared destructor is an
2331 // inline public member of its class.
Mike Stump1eb44332009-09-09 15:08:12 +00002332 DeclarationName Name
Douglas Gregor2e1cd422008-11-17 14:58:09 +00002333 = Context.DeclarationNames.getCXXDestructorName(ClassType);
Mike Stump1eb44332009-09-09 15:08:12 +00002334 CXXDestructorDecl *Destructor
Douglas Gregor42a552f2008-11-05 20:51:48 +00002335 = CXXDestructorDecl::Create(Context, ClassDecl,
Douglas Gregor2e1cd422008-11-17 14:58:09 +00002336 ClassDecl->getLocation(), Name,
Douglas Gregor42a552f2008-11-05 20:51:48 +00002337 Context.getFunctionType(Context.VoidTy,
2338 0, 0, false, 0),
2339 /*isInline=*/true,
2340 /*isImplicitlyDeclared=*/true);
2341 Destructor->setAccess(AS_public);
Douglas Gregor6b3945f2009-01-07 19:46:03 +00002342 Destructor->setImplicit();
Douglas Gregor1f2023a2009-07-22 18:25:24 +00002343 Destructor->setTrivial(ClassDecl->hasTrivialDestructor());
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002344 ClassDecl->addDecl(Destructor);
Anders Carlssond5a942b2009-11-26 21:25:09 +00002345
2346 AddOverriddenMethods(ClassDecl, Destructor);
Douglas Gregor42a552f2008-11-05 20:51:48 +00002347 }
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002348}
2349
Douglas Gregor6569d682009-05-27 23:11:45 +00002350void Sema::ActOnReenterTemplateScope(Scope *S, DeclPtrTy TemplateD) {
Douglas Gregor1cdcc572009-09-10 00:12:48 +00002351 Decl *D = TemplateD.getAs<Decl>();
2352 if (!D)
2353 return;
2354
2355 TemplateParameterList *Params = 0;
2356 if (TemplateDecl *Template = dyn_cast<TemplateDecl>(D))
2357 Params = Template->getTemplateParameters();
2358 else if (ClassTemplatePartialSpecializationDecl *PartialSpec
2359 = dyn_cast<ClassTemplatePartialSpecializationDecl>(D))
2360 Params = PartialSpec->getTemplateParameters();
2361 else
Douglas Gregor6569d682009-05-27 23:11:45 +00002362 return;
2363
Douglas Gregor6569d682009-05-27 23:11:45 +00002364 for (TemplateParameterList::iterator Param = Params->begin(),
2365 ParamEnd = Params->end();
2366 Param != ParamEnd; ++Param) {
2367 NamedDecl *Named = cast<NamedDecl>(*Param);
2368 if (Named->getDeclName()) {
2369 S->AddDecl(DeclPtrTy::make(Named));
2370 IdResolver.AddDecl(Named);
2371 }
2372 }
2373}
2374
John McCall7a1dc562009-12-19 10:49:29 +00002375void Sema::ActOnStartDelayedMemberDeclarations(Scope *S, DeclPtrTy RecordD) {
2376 if (!RecordD) return;
2377 AdjustDeclIfTemplate(RecordD);
2378 CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordD.getAs<Decl>());
2379 PushDeclContext(S, Record);
2380}
2381
2382void Sema::ActOnFinishDelayedMemberDeclarations(Scope *S, DeclPtrTy RecordD) {
2383 if (!RecordD) return;
2384 PopDeclContext();
2385}
2386
Douglas Gregor72b505b2008-12-16 21:30:33 +00002387/// ActOnStartDelayedCXXMethodDeclaration - We have completed
2388/// parsing a top-level (non-nested) C++ class, and we are now
2389/// parsing those parts of the given Method declaration that could
2390/// not be parsed earlier (C++ [class.mem]p2), such as default
2391/// arguments. This action should enter the scope of the given
2392/// Method declaration as if we had just parsed the qualified method
2393/// name. However, it should not bring the parameters into scope;
2394/// that will be performed by ActOnDelayedCXXMethodParameter.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002395void Sema::ActOnStartDelayedCXXMethodDeclaration(Scope *S, DeclPtrTy MethodD) {
Douglas Gregor72b505b2008-12-16 21:30:33 +00002396}
2397
2398/// ActOnDelayedCXXMethodParameter - We've already started a delayed
2399/// C++ method declaration. We're (re-)introducing the given
2400/// function parameter into scope for use in parsing later parts of
2401/// the method declaration. For example, we could see an
2402/// ActOnParamDefaultArgument event for this parameter.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002403void Sema::ActOnDelayedCXXMethodParameter(Scope *S, DeclPtrTy ParamD) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +00002404 if (!ParamD)
2405 return;
Mike Stump1eb44332009-09-09 15:08:12 +00002406
Chris Lattnerb28317a2009-03-28 19:18:32 +00002407 ParmVarDecl *Param = cast<ParmVarDecl>(ParamD.getAs<Decl>());
Douglas Gregor61366e92008-12-24 00:01:03 +00002408
2409 // If this parameter has an unparsed default argument, clear it out
2410 // to make way for the parsed default argument.
2411 if (Param->hasUnparsedDefaultArg())
2412 Param->setDefaultArg(0);
2413
Chris Lattnerb28317a2009-03-28 19:18:32 +00002414 S->AddDecl(DeclPtrTy::make(Param));
Douglas Gregor72b505b2008-12-16 21:30:33 +00002415 if (Param->getDeclName())
2416 IdResolver.AddDecl(Param);
2417}
2418
2419/// ActOnFinishDelayedCXXMethodDeclaration - We have finished
2420/// processing the delayed method declaration for Method. The method
2421/// declaration is now considered finished. There may be a separate
2422/// ActOnStartOfFunctionDef action later (not necessarily
2423/// immediately!) for this method, if it was also defined inside the
2424/// class body.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002425void Sema::ActOnFinishDelayedCXXMethodDeclaration(Scope *S, DeclPtrTy MethodD) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +00002426 if (!MethodD)
2427 return;
Mike Stump1eb44332009-09-09 15:08:12 +00002428
Douglas Gregorefd5bda2009-08-24 11:57:43 +00002429 AdjustDeclIfTemplate(MethodD);
Mike Stump1eb44332009-09-09 15:08:12 +00002430
Chris Lattnerb28317a2009-03-28 19:18:32 +00002431 FunctionDecl *Method = cast<FunctionDecl>(MethodD.getAs<Decl>());
Douglas Gregor72b505b2008-12-16 21:30:33 +00002432
2433 // Now that we have our default arguments, check the constructor
2434 // again. It could produce additional diagnostics or affect whether
2435 // the class has implicitly-declared destructors, among other
2436 // things.
Chris Lattner6e475012009-04-25 08:35:12 +00002437 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Method))
2438 CheckConstructor(Constructor);
Douglas Gregor72b505b2008-12-16 21:30:33 +00002439
2440 // Check the default arguments, which we may have added.
2441 if (!Method->isInvalidDecl())
2442 CheckCXXDefaultArguments(Method);
2443}
2444
Douglas Gregor42a552f2008-11-05 20:51:48 +00002445/// CheckConstructorDeclarator - Called by ActOnDeclarator to check
Douglas Gregor72b505b2008-12-16 21:30:33 +00002446/// the well-formedness of the constructor declarator @p D with type @p
Douglas Gregor42a552f2008-11-05 20:51:48 +00002447/// R. If there are any errors in the declarator, this routine will
Chris Lattner65401802009-04-25 08:28:21 +00002448/// emit diagnostics and set the invalid bit to true. In any case, the type
2449/// will be updated to reflect a well-formed type for the constructor and
2450/// returned.
2451QualType Sema::CheckConstructorDeclarator(Declarator &D, QualType R,
2452 FunctionDecl::StorageClass &SC) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00002453 bool isVirtual = D.getDeclSpec().isVirtualSpecified();
Douglas Gregor42a552f2008-11-05 20:51:48 +00002454
2455 // C++ [class.ctor]p3:
2456 // A constructor shall not be virtual (10.3) or static (9.4). A
2457 // constructor can be invoked for a const, volatile or const
2458 // volatile object. A constructor shall not be declared const,
2459 // volatile, or const volatile (9.3.2).
2460 if (isVirtual) {
Chris Lattner65401802009-04-25 08:28:21 +00002461 if (!D.isInvalidType())
2462 Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
2463 << "virtual" << SourceRange(D.getDeclSpec().getVirtualSpecLoc())
2464 << SourceRange(D.getIdentifierLoc());
2465 D.setInvalidType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00002466 }
2467 if (SC == FunctionDecl::Static) {
Chris Lattner65401802009-04-25 08:28:21 +00002468 if (!D.isInvalidType())
2469 Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
2470 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
2471 << SourceRange(D.getIdentifierLoc());
2472 D.setInvalidType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00002473 SC = FunctionDecl::None;
2474 }
Mike Stump1eb44332009-09-09 15:08:12 +00002475
Chris Lattner65401802009-04-25 08:28:21 +00002476 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
2477 if (FTI.TypeQuals != 0) {
John McCall0953e762009-09-24 19:53:00 +00002478 if (FTI.TypeQuals & Qualifiers::Const)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002479 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
2480 << "const" << SourceRange(D.getIdentifierLoc());
John McCall0953e762009-09-24 19:53:00 +00002481 if (FTI.TypeQuals & Qualifiers::Volatile)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002482 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
2483 << "volatile" << SourceRange(D.getIdentifierLoc());
John McCall0953e762009-09-24 19:53:00 +00002484 if (FTI.TypeQuals & Qualifiers::Restrict)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002485 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
2486 << "restrict" << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00002487 }
Mike Stump1eb44332009-09-09 15:08:12 +00002488
Douglas Gregor42a552f2008-11-05 20:51:48 +00002489 // Rebuild the function type "R" without any type qualifiers (in
2490 // case any of the errors above fired) and with "void" as the
2491 // return type, since constructors don't have return types. We
2492 // *always* have to do this, because GetTypeForDeclarator will
2493 // put in a result type of "int" when none was specified.
John McCall183700f2009-09-21 23:43:11 +00002494 const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
Chris Lattner65401802009-04-25 08:28:21 +00002495 return Context.getFunctionType(Context.VoidTy, Proto->arg_type_begin(),
2496 Proto->getNumArgs(),
2497 Proto->isVariadic(), 0);
Douglas Gregor42a552f2008-11-05 20:51:48 +00002498}
2499
Douglas Gregor72b505b2008-12-16 21:30:33 +00002500/// CheckConstructor - Checks a fully-formed constructor for
2501/// well-formedness, issuing any diagnostics required. Returns true if
2502/// the constructor declarator is invalid.
Chris Lattner6e475012009-04-25 08:35:12 +00002503void Sema::CheckConstructor(CXXConstructorDecl *Constructor) {
Mike Stump1eb44332009-09-09 15:08:12 +00002504 CXXRecordDecl *ClassDecl
Douglas Gregor33297562009-03-27 04:38:56 +00002505 = dyn_cast<CXXRecordDecl>(Constructor->getDeclContext());
2506 if (!ClassDecl)
Chris Lattner6e475012009-04-25 08:35:12 +00002507 return Constructor->setInvalidDecl();
Douglas Gregor72b505b2008-12-16 21:30:33 +00002508
2509 // C++ [class.copy]p3:
2510 // A declaration of a constructor for a class X is ill-formed if
2511 // its first parameter is of type (optionally cv-qualified) X and
2512 // either there are no other parameters or else all other
2513 // parameters have default arguments.
Douglas Gregor33297562009-03-27 04:38:56 +00002514 if (!Constructor->isInvalidDecl() &&
Mike Stump1eb44332009-09-09 15:08:12 +00002515 ((Constructor->getNumParams() == 1) ||
2516 (Constructor->getNumParams() > 1 &&
Douglas Gregor66724ea2009-11-14 01:20:54 +00002517 Constructor->getParamDecl(1)->hasDefaultArg())) &&
2518 Constructor->getTemplateSpecializationKind()
2519 != TSK_ImplicitInstantiation) {
Douglas Gregor72b505b2008-12-16 21:30:33 +00002520 QualType ParamType = Constructor->getParamDecl(0)->getType();
2521 QualType ClassTy = Context.getTagDeclType(ClassDecl);
2522 if (Context.getCanonicalType(ParamType).getUnqualifiedType() == ClassTy) {
Douglas Gregora3a83512009-04-01 23:51:29 +00002523 SourceLocation ParamLoc = Constructor->getParamDecl(0)->getLocation();
2524 Diag(ParamLoc, diag::err_constructor_byvalue_arg)
Douglas Gregor558cb562009-04-02 01:08:08 +00002525 << CodeModificationHint::CreateInsertion(ParamLoc, " const &");
Douglas Gregor66724ea2009-11-14 01:20:54 +00002526
2527 // FIXME: Rather that making the constructor invalid, we should endeavor
2528 // to fix the type.
Chris Lattner6e475012009-04-25 08:35:12 +00002529 Constructor->setInvalidDecl();
Douglas Gregor72b505b2008-12-16 21:30:33 +00002530 }
2531 }
Mike Stump1eb44332009-09-09 15:08:12 +00002532
Douglas Gregor72b505b2008-12-16 21:30:33 +00002533 // Notify the class that we've added a constructor.
2534 ClassDecl->addedConstructor(Context, Constructor);
Douglas Gregor72b505b2008-12-16 21:30:33 +00002535}
2536
Anders Carlsson37909802009-11-30 21:24:50 +00002537/// CheckDestructor - Checks a fully-formed destructor for well-formedness,
2538/// issuing any diagnostics required. Returns true on error.
Anders Carlsson5ec02ae2009-12-02 17:15:43 +00002539bool Sema::CheckDestructor(CXXDestructorDecl *Destructor) {
Anders Carlsson6d701392009-11-15 22:49:34 +00002540 CXXRecordDecl *RD = Destructor->getParent();
2541
2542 if (Destructor->isVirtual()) {
2543 SourceLocation Loc;
2544
2545 if (!Destructor->isImplicit())
2546 Loc = Destructor->getLocation();
2547 else
2548 Loc = RD->getLocation();
2549
2550 // If we have a virtual destructor, look up the deallocation function
2551 FunctionDecl *OperatorDelete = 0;
2552 DeclarationName Name =
2553 Context.DeclarationNames.getCXXOperatorName(OO_Delete);
Anders Carlsson5ec02ae2009-12-02 17:15:43 +00002554 if (FindDeallocationFunction(Loc, RD, Name, OperatorDelete))
Anders Carlsson37909802009-11-30 21:24:50 +00002555 return true;
2556
2557 Destructor->setOperatorDelete(OperatorDelete);
Anders Carlsson6d701392009-11-15 22:49:34 +00002558 }
Anders Carlsson37909802009-11-30 21:24:50 +00002559
2560 return false;
Anders Carlsson6d701392009-11-15 22:49:34 +00002561}
2562
Mike Stump1eb44332009-09-09 15:08:12 +00002563static inline bool
Anders Carlsson7786d1c2009-04-30 23:18:11 +00002564FTIHasSingleVoidArgument(DeclaratorChunk::FunctionTypeInfo &FTI) {
2565 return (FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 &&
2566 FTI.ArgInfo[0].Param &&
2567 FTI.ArgInfo[0].Param.getAs<ParmVarDecl>()->getType()->isVoidType());
2568}
2569
Douglas Gregor42a552f2008-11-05 20:51:48 +00002570/// CheckDestructorDeclarator - Called by ActOnDeclarator to check
2571/// the well-formednes of the destructor declarator @p D with type @p
2572/// R. If there are any errors in the declarator, this routine will
Chris Lattner65401802009-04-25 08:28:21 +00002573/// emit diagnostics and set the declarator to invalid. Even if this happens,
2574/// will be updated to reflect a well-formed type for the destructor and
2575/// returned.
2576QualType Sema::CheckDestructorDeclarator(Declarator &D,
2577 FunctionDecl::StorageClass& SC) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00002578 // C++ [class.dtor]p1:
2579 // [...] A typedef-name that names a class is a class-name
2580 // (7.1.3); however, a typedef-name that names a class shall not
2581 // be used as the identifier in the declarator for a destructor
2582 // declaration.
Douglas Gregor3f9a0562009-11-03 01:35:08 +00002583 QualType DeclaratorType = GetTypeFromParser(D.getName().DestructorName);
Chris Lattner65401802009-04-25 08:28:21 +00002584 if (isa<TypedefType>(DeclaratorType)) {
2585 Diag(D.getIdentifierLoc(), diag::err_destructor_typedef_name)
Douglas Gregor1a51b4a2009-02-09 15:09:02 +00002586 << DeclaratorType;
Chris Lattner65401802009-04-25 08:28:21 +00002587 D.setInvalidType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00002588 }
2589
2590 // C++ [class.dtor]p2:
2591 // A destructor is used to destroy objects of its class type. A
2592 // destructor takes no parameters, and no return type can be
2593 // specified for it (not even void). The address of a destructor
2594 // shall not be taken. A destructor shall not be static. A
2595 // destructor can be invoked for a const, volatile or const
2596 // volatile object. A destructor shall not be declared const,
2597 // volatile or const volatile (9.3.2).
2598 if (SC == FunctionDecl::Static) {
Chris Lattner65401802009-04-25 08:28:21 +00002599 if (!D.isInvalidType())
2600 Diag(D.getIdentifierLoc(), diag::err_destructor_cannot_be)
2601 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
2602 << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00002603 SC = FunctionDecl::None;
Chris Lattner65401802009-04-25 08:28:21 +00002604 D.setInvalidType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00002605 }
Chris Lattner65401802009-04-25 08:28:21 +00002606 if (D.getDeclSpec().hasTypeSpecifier() && !D.isInvalidType()) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00002607 // Destructors don't have return types, but the parser will
2608 // happily parse something like:
2609 //
2610 // class X {
2611 // float ~X();
2612 // };
2613 //
2614 // The return type will be eliminated later.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002615 Diag(D.getIdentifierLoc(), diag::err_destructor_return_type)
2616 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
2617 << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00002618 }
Mike Stump1eb44332009-09-09 15:08:12 +00002619
Chris Lattner65401802009-04-25 08:28:21 +00002620 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
2621 if (FTI.TypeQuals != 0 && !D.isInvalidType()) {
John McCall0953e762009-09-24 19:53:00 +00002622 if (FTI.TypeQuals & Qualifiers::Const)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002623 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
2624 << "const" << SourceRange(D.getIdentifierLoc());
John McCall0953e762009-09-24 19:53:00 +00002625 if (FTI.TypeQuals & Qualifiers::Volatile)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002626 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
2627 << "volatile" << SourceRange(D.getIdentifierLoc());
John McCall0953e762009-09-24 19:53:00 +00002628 if (FTI.TypeQuals & Qualifiers::Restrict)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002629 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
2630 << "restrict" << SourceRange(D.getIdentifierLoc());
Chris Lattner65401802009-04-25 08:28:21 +00002631 D.setInvalidType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00002632 }
2633
2634 // Make sure we don't have any parameters.
Anders Carlsson7786d1c2009-04-30 23:18:11 +00002635 if (FTI.NumArgs > 0 && !FTIHasSingleVoidArgument(FTI)) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00002636 Diag(D.getIdentifierLoc(), diag::err_destructor_with_params);
2637
2638 // Delete the parameters.
Chris Lattner65401802009-04-25 08:28:21 +00002639 FTI.freeArgs();
2640 D.setInvalidType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00002641 }
2642
Mike Stump1eb44332009-09-09 15:08:12 +00002643 // Make sure the destructor isn't variadic.
Chris Lattner65401802009-04-25 08:28:21 +00002644 if (FTI.isVariadic) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00002645 Diag(D.getIdentifierLoc(), diag::err_destructor_variadic);
Chris Lattner65401802009-04-25 08:28:21 +00002646 D.setInvalidType();
2647 }
Douglas Gregor42a552f2008-11-05 20:51:48 +00002648
2649 // Rebuild the function type "R" without any type qualifiers or
2650 // parameters (in case any of the errors above fired) and with
2651 // "void" as the return type, since destructors don't have return
2652 // types. We *always* have to do this, because GetTypeForDeclarator
2653 // will put in a result type of "int" when none was specified.
Chris Lattner65401802009-04-25 08:28:21 +00002654 return Context.getFunctionType(Context.VoidTy, 0, 0, false, 0);
Douglas Gregor42a552f2008-11-05 20:51:48 +00002655}
2656
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002657/// CheckConversionDeclarator - Called by ActOnDeclarator to check the
2658/// well-formednes of the conversion function declarator @p D with
2659/// type @p R. If there are any errors in the declarator, this routine
2660/// will emit diagnostics and return true. Otherwise, it will return
2661/// false. Either way, the type @p R will be updated to reflect a
2662/// well-formed type for the conversion operator.
Chris Lattner6e475012009-04-25 08:35:12 +00002663void Sema::CheckConversionDeclarator(Declarator &D, QualType &R,
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002664 FunctionDecl::StorageClass& SC) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002665 // C++ [class.conv.fct]p1:
2666 // Neither parameter types nor return type can be specified. The
Eli Friedman33a31382009-08-05 19:21:58 +00002667 // type of a conversion function (8.3.5) is "function taking no
Mike Stump1eb44332009-09-09 15:08:12 +00002668 // parameter returning conversion-type-id."
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002669 if (SC == FunctionDecl::Static) {
Chris Lattner6e475012009-04-25 08:35:12 +00002670 if (!D.isInvalidType())
2671 Diag(D.getIdentifierLoc(), diag::err_conv_function_not_member)
2672 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
2673 << SourceRange(D.getIdentifierLoc());
2674 D.setInvalidType();
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002675 SC = FunctionDecl::None;
2676 }
Chris Lattner6e475012009-04-25 08:35:12 +00002677 if (D.getDeclSpec().hasTypeSpecifier() && !D.isInvalidType()) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002678 // Conversion functions don't have return types, but the parser will
2679 // happily parse something like:
2680 //
2681 // class X {
2682 // float operator bool();
2683 // };
2684 //
2685 // The return type will be changed later anyway.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002686 Diag(D.getIdentifierLoc(), diag::err_conv_function_return_type)
2687 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
2688 << SourceRange(D.getIdentifierLoc());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002689 }
2690
2691 // Make sure we don't have any parameters.
John McCall183700f2009-09-21 23:43:11 +00002692 if (R->getAs<FunctionProtoType>()->getNumArgs() > 0) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002693 Diag(D.getIdentifierLoc(), diag::err_conv_function_with_params);
2694
2695 // Delete the parameters.
Chris Lattner1833a832009-01-20 21:06:38 +00002696 D.getTypeObject(0).Fun.freeArgs();
Chris Lattner6e475012009-04-25 08:35:12 +00002697 D.setInvalidType();
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002698 }
2699
Mike Stump1eb44332009-09-09 15:08:12 +00002700 // Make sure the conversion function isn't variadic.
John McCall183700f2009-09-21 23:43:11 +00002701 if (R->getAs<FunctionProtoType>()->isVariadic() && !D.isInvalidType()) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002702 Diag(D.getIdentifierLoc(), diag::err_conv_function_variadic);
Chris Lattner6e475012009-04-25 08:35:12 +00002703 D.setInvalidType();
2704 }
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002705
2706 // C++ [class.conv.fct]p4:
2707 // The conversion-type-id shall not represent a function type nor
2708 // an array type.
Douglas Gregor3f9a0562009-11-03 01:35:08 +00002709 QualType ConvType = GetTypeFromParser(D.getName().ConversionFunctionId);
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002710 if (ConvType->isArrayType()) {
2711 Diag(D.getIdentifierLoc(), diag::err_conv_function_to_array);
2712 ConvType = Context.getPointerType(ConvType);
Chris Lattner6e475012009-04-25 08:35:12 +00002713 D.setInvalidType();
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002714 } else if (ConvType->isFunctionType()) {
2715 Diag(D.getIdentifierLoc(), diag::err_conv_function_to_function);
2716 ConvType = Context.getPointerType(ConvType);
Chris Lattner6e475012009-04-25 08:35:12 +00002717 D.setInvalidType();
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002718 }
2719
2720 // Rebuild the function type "R" without any parameters (in case any
2721 // of the errors above fired) and with the conversion type as the
Mike Stump1eb44332009-09-09 15:08:12 +00002722 // return type.
2723 R = Context.getFunctionType(ConvType, 0, 0, false,
John McCall183700f2009-09-21 23:43:11 +00002724 R->getAs<FunctionProtoType>()->getTypeQuals());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002725
Douglas Gregor09f41cf2009-01-14 15:45:31 +00002726 // C++0x explicit conversion operators.
2727 if (D.getDeclSpec().isExplicitSpecified() && !getLangOptions().CPlusPlus0x)
Mike Stump1eb44332009-09-09 15:08:12 +00002728 Diag(D.getDeclSpec().getExplicitSpecLoc(),
Douglas Gregor09f41cf2009-01-14 15:45:31 +00002729 diag::warn_explicit_conversion_functions)
2730 << SourceRange(D.getDeclSpec().getExplicitSpecLoc());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002731}
2732
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002733/// ActOnConversionDeclarator - Called by ActOnDeclarator to complete
2734/// the declaration of the given C++ conversion function. This routine
2735/// is responsible for recording the conversion function in the C++
2736/// class, if possible.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002737Sema::DeclPtrTy Sema::ActOnConversionDeclarator(CXXConversionDecl *Conversion) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002738 assert(Conversion && "Expected to receive a conversion function declaration");
2739
Douglas Gregor9d350972008-12-12 08:25:50 +00002740 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Conversion->getDeclContext());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002741
2742 // Make sure we aren't redeclaring the conversion function.
2743 QualType ConvType = Context.getCanonicalType(Conversion->getConversionType());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002744
2745 // C++ [class.conv.fct]p1:
2746 // [...] A conversion function is never used to convert a
2747 // (possibly cv-qualified) object to the (possibly cv-qualified)
2748 // same object type (or a reference to it), to a (possibly
2749 // cv-qualified) base class of that type (or a reference to it),
2750 // or to (possibly cv-qualified) void.
Mike Stump390b4cc2009-05-16 07:39:55 +00002751 // FIXME: Suppress this warning if the conversion function ends up being a
2752 // virtual function that overrides a virtual function in a base class.
Mike Stump1eb44332009-09-09 15:08:12 +00002753 QualType ClassType
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002754 = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
Ted Kremenek6217b802009-07-29 21:53:49 +00002755 if (const ReferenceType *ConvTypeRef = ConvType->getAs<ReferenceType>())
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002756 ConvType = ConvTypeRef->getPointeeType();
2757 if (ConvType->isRecordType()) {
2758 ConvType = Context.getCanonicalType(ConvType).getUnqualifiedType();
2759 if (ConvType == ClassType)
Chris Lattner5dc266a2008-11-20 06:13:02 +00002760 Diag(Conversion->getLocation(), diag::warn_conv_to_self_not_used)
Chris Lattnerd1625842008-11-24 06:25:27 +00002761 << ClassType;
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002762 else if (IsDerivedFrom(ClassType, ConvType))
Chris Lattner5dc266a2008-11-20 06:13:02 +00002763 Diag(Conversion->getLocation(), diag::warn_conv_to_base_not_used)
Chris Lattnerd1625842008-11-24 06:25:27 +00002764 << ClassType << ConvType;
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002765 } else if (ConvType->isVoidType()) {
Chris Lattner5dc266a2008-11-20 06:13:02 +00002766 Diag(Conversion->getLocation(), diag::warn_conv_to_void_not_used)
Chris Lattnerd1625842008-11-24 06:25:27 +00002767 << ClassType << ConvType;
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002768 }
2769
Douglas Gregor48026d22010-01-11 18:40:55 +00002770 if (Conversion->getPrimaryTemplate()) {
2771 // ignore specializations
2772 } else if (Conversion->getPreviousDeclaration()) {
Mike Stump1eb44332009-09-09 15:08:12 +00002773 if (FunctionTemplateDecl *ConversionTemplate
Douglas Gregor0c551062010-01-11 18:53:25 +00002774 = Conversion->getDescribedFunctionTemplate()) {
2775 if (ClassDecl->replaceConversion(
2776 ConversionTemplate->getPreviousDeclaration(),
2777 ConversionTemplate))
2778 return DeclPtrTy::make(ConversionTemplate);
2779 } else if (ClassDecl->replaceConversion(Conversion->getPreviousDeclaration(),
2780 Conversion))
John McCallba135432009-11-21 08:51:07 +00002781 return DeclPtrTy::make(Conversion);
Douglas Gregor70316a02008-12-26 15:00:45 +00002782 assert(Conversion->isInvalidDecl() && "Conversion should not get here.");
Mike Stump1eb44332009-09-09 15:08:12 +00002783 } else if (FunctionTemplateDecl *ConversionTemplate
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00002784 = Conversion->getDescribedFunctionTemplate())
Fariborz Jahaniandebc6292009-09-12 19:02:34 +00002785 ClassDecl->addConversionFunction(ConversionTemplate);
Douglas Gregor48026d22010-01-11 18:40:55 +00002786 else
Fariborz Jahaniandebc6292009-09-12 19:02:34 +00002787 ClassDecl->addConversionFunction(Conversion);
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002788
Chris Lattnerb28317a2009-03-28 19:18:32 +00002789 return DeclPtrTy::make(Conversion);
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002790}
2791
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002792//===----------------------------------------------------------------------===//
2793// Namespace Handling
2794//===----------------------------------------------------------------------===//
2795
2796/// ActOnStartNamespaceDef - This is called at the start of a namespace
2797/// definition.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002798Sema::DeclPtrTy Sema::ActOnStartNamespaceDef(Scope *NamespcScope,
2799 SourceLocation IdentLoc,
2800 IdentifierInfo *II,
2801 SourceLocation LBrace) {
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002802 NamespaceDecl *Namespc =
2803 NamespaceDecl::Create(Context, CurContext, IdentLoc, II);
2804 Namespc->setLBracLoc(LBrace);
2805
2806 Scope *DeclRegionScope = NamespcScope->getParent();
2807
2808 if (II) {
2809 // C++ [namespace.def]p2:
2810 // The identifier in an original-namespace-definition shall not have been
2811 // previously defined in the declarative region in which the
2812 // original-namespace-definition appears. The identifier in an
2813 // original-namespace-definition is the name of the namespace. Subsequently
2814 // in that declarative region, it is treated as an original-namespace-name.
2815
John McCallf36e02d2009-10-09 21:13:30 +00002816 NamedDecl *PrevDecl
John McCalla24dc2e2009-11-17 02:14:36 +00002817 = LookupSingleName(DeclRegionScope, II, LookupOrdinaryName,
John McCall7d384dd2009-11-18 07:57:50 +00002818 ForRedeclaration);
Mike Stump1eb44332009-09-09 15:08:12 +00002819
Douglas Gregor44b43212008-12-11 16:49:14 +00002820 if (NamespaceDecl *OrigNS = dyn_cast_or_null<NamespaceDecl>(PrevDecl)) {
2821 // This is an extended namespace definition.
2822 // Attach this namespace decl to the chain of extended namespace
2823 // definitions.
2824 OrigNS->setNextNamespace(Namespc);
2825 Namespc->setOriginalNamespace(OrigNS->getOriginalNamespace());
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002826
Mike Stump1eb44332009-09-09 15:08:12 +00002827 // Remove the previous declaration from the scope.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002828 if (DeclRegionScope->isDeclScope(DeclPtrTy::make(OrigNS))) {
Douglas Gregore267ff32008-12-11 20:41:00 +00002829 IdResolver.RemoveDecl(OrigNS);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002830 DeclRegionScope->RemoveDecl(DeclPtrTy::make(OrigNS));
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002831 }
Douglas Gregor44b43212008-12-11 16:49:14 +00002832 } else if (PrevDecl) {
2833 // This is an invalid name redefinition.
2834 Diag(Namespc->getLocation(), diag::err_redefinition_different_kind)
2835 << Namespc->getDeclName();
2836 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
2837 Namespc->setInvalidDecl();
2838 // Continue on to push Namespc as current DeclContext and return it.
Douglas Gregor7adb10f2009-09-15 22:30:29 +00002839 } else if (II->isStr("std") &&
2840 CurContext->getLookupContext()->isTranslationUnit()) {
2841 // This is the first "real" definition of the namespace "std", so update
2842 // our cache of the "std" namespace to point at this definition.
2843 if (StdNamespace) {
2844 // We had already defined a dummy namespace "std". Link this new
2845 // namespace definition to the dummy namespace "std".
2846 StdNamespace->setNextNamespace(Namespc);
2847 StdNamespace->setLocation(IdentLoc);
2848 Namespc->setOriginalNamespace(StdNamespace->getOriginalNamespace());
2849 }
2850
2851 // Make our StdNamespace cache point at the first real definition of the
2852 // "std" namespace.
2853 StdNamespace = Namespc;
Mike Stump1eb44332009-09-09 15:08:12 +00002854 }
Douglas Gregor44b43212008-12-11 16:49:14 +00002855
2856 PushOnScopeChains(Namespc, DeclRegionScope);
2857 } else {
John McCall9aeed322009-10-01 00:25:31 +00002858 // Anonymous namespaces.
John McCall5fdd7642009-12-16 02:06:49 +00002859 assert(Namespc->isAnonymousNamespace());
2860 CurContext->addDecl(Namespc);
2861
2862 // Link the anonymous namespace into its parent.
2863 NamespaceDecl *PrevDecl;
2864 DeclContext *Parent = CurContext->getLookupContext();
2865 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(Parent)) {
2866 PrevDecl = TU->getAnonymousNamespace();
2867 TU->setAnonymousNamespace(Namespc);
2868 } else {
2869 NamespaceDecl *ND = cast<NamespaceDecl>(Parent);
2870 PrevDecl = ND->getAnonymousNamespace();
2871 ND->setAnonymousNamespace(Namespc);
2872 }
2873
2874 // Link the anonymous namespace with its previous declaration.
2875 if (PrevDecl) {
2876 assert(PrevDecl->isAnonymousNamespace());
2877 assert(!PrevDecl->getNextNamespace());
2878 Namespc->setOriginalNamespace(PrevDecl->getOriginalNamespace());
2879 PrevDecl->setNextNamespace(Namespc);
2880 }
John McCall9aeed322009-10-01 00:25:31 +00002881
2882 // C++ [namespace.unnamed]p1. An unnamed-namespace-definition
2883 // behaves as if it were replaced by
2884 // namespace unique { /* empty body */ }
2885 // using namespace unique;
2886 // namespace unique { namespace-body }
2887 // where all occurrences of 'unique' in a translation unit are
2888 // replaced by the same identifier and this identifier differs
2889 // from all other identifiers in the entire program.
2890
2891 // We just create the namespace with an empty name and then add an
2892 // implicit using declaration, just like the standard suggests.
2893 //
2894 // CodeGen enforces the "universally unique" aspect by giving all
2895 // declarations semantically contained within an anonymous
2896 // namespace internal linkage.
2897
John McCall5fdd7642009-12-16 02:06:49 +00002898 if (!PrevDecl) {
2899 UsingDirectiveDecl* UD
2900 = UsingDirectiveDecl::Create(Context, CurContext,
2901 /* 'using' */ LBrace,
2902 /* 'namespace' */ SourceLocation(),
2903 /* qualifier */ SourceRange(),
2904 /* NNS */ NULL,
2905 /* identifier */ SourceLocation(),
2906 Namespc,
2907 /* Ancestor */ CurContext);
2908 UD->setImplicit();
2909 CurContext->addDecl(UD);
2910 }
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002911 }
2912
2913 // Although we could have an invalid decl (i.e. the namespace name is a
2914 // redefinition), push it as current DeclContext and try to continue parsing.
Mike Stump390b4cc2009-05-16 07:39:55 +00002915 // FIXME: We should be able to push Namespc here, so that the each DeclContext
2916 // for the namespace has the declarations that showed up in that particular
2917 // namespace definition.
Douglas Gregor44b43212008-12-11 16:49:14 +00002918 PushDeclContext(NamespcScope, Namespc);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002919 return DeclPtrTy::make(Namespc);
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002920}
2921
Sebastian Redleb0d8c92009-11-23 15:34:23 +00002922/// getNamespaceDecl - Returns the namespace a decl represents. If the decl
2923/// is a namespace alias, returns the namespace it points to.
2924static inline NamespaceDecl *getNamespaceDecl(NamedDecl *D) {
2925 if (NamespaceAliasDecl *AD = dyn_cast_or_null<NamespaceAliasDecl>(D))
2926 return AD->getNamespace();
2927 return dyn_cast_or_null<NamespaceDecl>(D);
2928}
2929
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002930/// ActOnFinishNamespaceDef - This callback is called after a namespace is
2931/// exited. Decl is the DeclTy returned by ActOnStartNamespaceDef.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002932void Sema::ActOnFinishNamespaceDef(DeclPtrTy D, SourceLocation RBrace) {
2933 Decl *Dcl = D.getAs<Decl>();
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002934 NamespaceDecl *Namespc = dyn_cast_or_null<NamespaceDecl>(Dcl);
2935 assert(Namespc && "Invalid parameter, expected NamespaceDecl");
2936 Namespc->setRBracLoc(RBrace);
2937 PopDeclContext();
2938}
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00002939
Chris Lattnerb28317a2009-03-28 19:18:32 +00002940Sema::DeclPtrTy Sema::ActOnUsingDirective(Scope *S,
2941 SourceLocation UsingLoc,
2942 SourceLocation NamespcLoc,
2943 const CXXScopeSpec &SS,
2944 SourceLocation IdentLoc,
2945 IdentifierInfo *NamespcName,
2946 AttributeList *AttrList) {
Douglas Gregorf780abc2008-12-30 03:27:21 +00002947 assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
2948 assert(NamespcName && "Invalid NamespcName.");
2949 assert(IdentLoc.isValid() && "Invalid NamespceName location.");
Douglas Gregor2a3009a2009-02-03 19:21:40 +00002950 assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
Douglas Gregorf780abc2008-12-30 03:27:21 +00002951
Douglas Gregor2a3009a2009-02-03 19:21:40 +00002952 UsingDirectiveDecl *UDir = 0;
Douglas Gregorf780abc2008-12-30 03:27:21 +00002953
Douglas Gregoreb11cd02009-01-14 22:20:51 +00002954 // Lookup namespace name.
John McCalla24dc2e2009-11-17 02:14:36 +00002955 LookupResult R(*this, NamespcName, IdentLoc, LookupNamespaceName);
2956 LookupParsedName(R, S, &SS);
2957 if (R.isAmbiguous())
Chris Lattnerb28317a2009-03-28 19:18:32 +00002958 return DeclPtrTy();
John McCalla24dc2e2009-11-17 02:14:36 +00002959
John McCallf36e02d2009-10-09 21:13:30 +00002960 if (!R.empty()) {
Sebastian Redleb0d8c92009-11-23 15:34:23 +00002961 NamedDecl *Named = R.getFoundDecl();
2962 assert((isa<NamespaceDecl>(Named) || isa<NamespaceAliasDecl>(Named))
2963 && "expected namespace decl");
Douglas Gregor2a3009a2009-02-03 19:21:40 +00002964 // C++ [namespace.udir]p1:
2965 // A using-directive specifies that the names in the nominated
2966 // namespace can be used in the scope in which the
2967 // using-directive appears after the using-directive. During
2968 // unqualified name lookup (3.4.1), the names appear as if they
2969 // were declared in the nearest enclosing namespace which
2970 // contains both the using-directive and the nominated
Eli Friedman33a31382009-08-05 19:21:58 +00002971 // namespace. [Note: in this context, "contains" means "contains
2972 // directly or indirectly". ]
Douglas Gregor2a3009a2009-02-03 19:21:40 +00002973
2974 // Find enclosing context containing both using-directive and
2975 // nominated namespace.
Sebastian Redleb0d8c92009-11-23 15:34:23 +00002976 NamespaceDecl *NS = getNamespaceDecl(Named);
Douglas Gregor2a3009a2009-02-03 19:21:40 +00002977 DeclContext *CommonAncestor = cast<DeclContext>(NS);
2978 while (CommonAncestor && !CommonAncestor->Encloses(CurContext))
2979 CommonAncestor = CommonAncestor->getParent();
2980
Sebastian Redleb0d8c92009-11-23 15:34:23 +00002981 UDir = UsingDirectiveDecl::Create(Context, CurContext, UsingLoc, NamespcLoc,
Douglas Gregor8419fa32009-05-30 06:31:56 +00002982 SS.getRange(),
2983 (NestedNameSpecifier *)SS.getScopeRep(),
Sebastian Redleb0d8c92009-11-23 15:34:23 +00002984 IdentLoc, Named, CommonAncestor);
Douglas Gregor2a3009a2009-02-03 19:21:40 +00002985 PushUsingDirective(S, UDir);
Douglas Gregorf780abc2008-12-30 03:27:21 +00002986 } else {
Chris Lattneread013e2009-01-06 07:24:29 +00002987 Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
Douglas Gregorf780abc2008-12-30 03:27:21 +00002988 }
2989
Douglas Gregor2a3009a2009-02-03 19:21:40 +00002990 // FIXME: We ignore attributes for now.
Douglas Gregorf780abc2008-12-30 03:27:21 +00002991 delete AttrList;
Chris Lattnerb28317a2009-03-28 19:18:32 +00002992 return DeclPtrTy::make(UDir);
Douglas Gregor2a3009a2009-02-03 19:21:40 +00002993}
2994
2995void Sema::PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir) {
2996 // If scope has associated entity, then using directive is at namespace
2997 // or translation unit scope. We add UsingDirectiveDecls, into
2998 // it's lookup structure.
2999 if (DeclContext *Ctx = static_cast<DeclContext*>(S->getEntity()))
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00003000 Ctx->addDecl(UDir);
Douglas Gregor2a3009a2009-02-03 19:21:40 +00003001 else
3002 // Otherwise it is block-sope. using-directives will affect lookup
3003 // only to the end of scope.
Chris Lattnerb28317a2009-03-28 19:18:32 +00003004 S->PushUsingDirective(DeclPtrTy::make(UDir));
Douglas Gregorf780abc2008-12-30 03:27:21 +00003005}
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00003006
Douglas Gregor9cfbe482009-06-20 00:51:54 +00003007
3008Sema::DeclPtrTy Sema::ActOnUsingDeclaration(Scope *S,
Anders Carlsson595adc12009-08-29 19:54:19 +00003009 AccessSpecifier AS,
John McCall60fa3cf2009-12-11 02:10:03 +00003010 bool HasUsingKeyword,
Anders Carlssoncf9f9212009-08-28 03:16:11 +00003011 SourceLocation UsingLoc,
3012 const CXXScopeSpec &SS,
Douglas Gregor12c118a2009-11-04 16:30:06 +00003013 UnqualifiedId &Name,
Anders Carlssoncf9f9212009-08-28 03:16:11 +00003014 AttributeList *AttrList,
John McCall7ba107a2009-11-18 02:36:19 +00003015 bool IsTypeName,
3016 SourceLocation TypenameLoc) {
Douglas Gregor9cfbe482009-06-20 00:51:54 +00003017 assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
Mike Stump1eb44332009-09-09 15:08:12 +00003018
Douglas Gregor12c118a2009-11-04 16:30:06 +00003019 switch (Name.getKind()) {
3020 case UnqualifiedId::IK_Identifier:
3021 case UnqualifiedId::IK_OperatorFunctionId:
Sean Hunt0486d742009-11-28 04:44:28 +00003022 case UnqualifiedId::IK_LiteralOperatorId:
Douglas Gregor12c118a2009-11-04 16:30:06 +00003023 case UnqualifiedId::IK_ConversionFunctionId:
3024 break;
3025
3026 case UnqualifiedId::IK_ConstructorName:
Douglas Gregor0efc2c12010-01-13 17:31:36 +00003027 case UnqualifiedId::IK_ConstructorTemplateId:
John McCall604e7f12009-12-08 07:46:18 +00003028 // C++0x inherited constructors.
3029 if (getLangOptions().CPlusPlus0x) break;
3030
Douglas Gregor12c118a2009-11-04 16:30:06 +00003031 Diag(Name.getSourceRange().getBegin(), diag::err_using_decl_constructor)
3032 << SS.getRange();
3033 return DeclPtrTy();
3034
3035 case UnqualifiedId::IK_DestructorName:
3036 Diag(Name.getSourceRange().getBegin(), diag::err_using_decl_destructor)
3037 << SS.getRange();
3038 return DeclPtrTy();
3039
3040 case UnqualifiedId::IK_TemplateId:
3041 Diag(Name.getSourceRange().getBegin(), diag::err_using_decl_template_id)
3042 << SourceRange(Name.TemplateId->LAngleLoc, Name.TemplateId->RAngleLoc);
3043 return DeclPtrTy();
3044 }
3045
3046 DeclarationName TargetName = GetNameFromUnqualifiedId(Name);
John McCall604e7f12009-12-08 07:46:18 +00003047 if (!TargetName)
3048 return DeclPtrTy();
3049
John McCall60fa3cf2009-12-11 02:10:03 +00003050 // Warn about using declarations.
3051 // TODO: store that the declaration was written without 'using' and
3052 // talk about access decls instead of using decls in the
3053 // diagnostics.
3054 if (!HasUsingKeyword) {
3055 UsingLoc = Name.getSourceRange().getBegin();
3056
3057 Diag(UsingLoc, diag::warn_access_decl_deprecated)
3058 << CodeModificationHint::CreateInsertion(SS.getRange().getBegin(),
3059 "using ");
3060 }
3061
John McCall9488ea12009-11-17 05:59:44 +00003062 NamedDecl *UD = BuildUsingDeclaration(S, AS, UsingLoc, SS,
Douglas Gregor12c118a2009-11-04 16:30:06 +00003063 Name.getSourceRange().getBegin(),
John McCall7ba107a2009-11-18 02:36:19 +00003064 TargetName, AttrList,
3065 /* IsInstantiation */ false,
3066 IsTypeName, TypenameLoc);
John McCalled976492009-12-04 22:46:56 +00003067 if (UD)
3068 PushOnScopeChains(UD, S, /*AddToContext*/ false);
Mike Stump1eb44332009-09-09 15:08:12 +00003069
Anders Carlssonc72160b2009-08-28 05:40:36 +00003070 return DeclPtrTy::make(UD);
3071}
3072
John McCall9f54ad42009-12-10 09:41:52 +00003073/// Determines whether to create a using shadow decl for a particular
3074/// decl, given the set of decls existing prior to this using lookup.
3075bool Sema::CheckUsingShadowDecl(UsingDecl *Using, NamedDecl *Orig,
3076 const LookupResult &Previous) {
3077 // Diagnose finding a decl which is not from a base class of the
3078 // current class. We do this now because there are cases where this
3079 // function will silently decide not to build a shadow decl, which
3080 // will pre-empt further diagnostics.
3081 //
3082 // We don't need to do this in C++0x because we do the check once on
3083 // the qualifier.
3084 //
3085 // FIXME: diagnose the following if we care enough:
3086 // struct A { int foo; };
3087 // struct B : A { using A::foo; };
3088 // template <class T> struct C : A {};
3089 // template <class T> struct D : C<T> { using B::foo; } // <---
3090 // This is invalid (during instantiation) in C++03 because B::foo
3091 // resolves to the using decl in B, which is not a base class of D<T>.
3092 // We can't diagnose it immediately because C<T> is an unknown
3093 // specialization. The UsingShadowDecl in D<T> then points directly
3094 // to A::foo, which will look well-formed when we instantiate.
3095 // The right solution is to not collapse the shadow-decl chain.
3096 if (!getLangOptions().CPlusPlus0x && CurContext->isRecord()) {
3097 DeclContext *OrigDC = Orig->getDeclContext();
3098
3099 // Handle enums and anonymous structs.
3100 if (isa<EnumDecl>(OrigDC)) OrigDC = OrigDC->getParent();
3101 CXXRecordDecl *OrigRec = cast<CXXRecordDecl>(OrigDC);
3102 while (OrigRec->isAnonymousStructOrUnion())
3103 OrigRec = cast<CXXRecordDecl>(OrigRec->getDeclContext());
3104
3105 if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(OrigRec)) {
3106 if (OrigDC == CurContext) {
3107 Diag(Using->getLocation(),
3108 diag::err_using_decl_nested_name_specifier_is_current_class)
3109 << Using->getNestedNameRange();
3110 Diag(Orig->getLocation(), diag::note_using_decl_target);
3111 return true;
3112 }
3113
3114 Diag(Using->getNestedNameRange().getBegin(),
3115 diag::err_using_decl_nested_name_specifier_is_not_base_class)
3116 << Using->getTargetNestedNameDecl()
3117 << cast<CXXRecordDecl>(CurContext)
3118 << Using->getNestedNameRange();
3119 Diag(Orig->getLocation(), diag::note_using_decl_target);
3120 return true;
3121 }
3122 }
3123
3124 if (Previous.empty()) return false;
3125
3126 NamedDecl *Target = Orig;
3127 if (isa<UsingShadowDecl>(Target))
3128 Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
3129
John McCalld7533ec2009-12-11 02:33:26 +00003130 // If the target happens to be one of the previous declarations, we
3131 // don't have a conflict.
3132 //
3133 // FIXME: but we might be increasing its access, in which case we
3134 // should redeclare it.
3135 NamedDecl *NonTag = 0, *Tag = 0;
3136 for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
3137 I != E; ++I) {
3138 NamedDecl *D = (*I)->getUnderlyingDecl();
3139 if (D->getCanonicalDecl() == Target->getCanonicalDecl())
3140 return false;
3141
3142 (isa<TagDecl>(D) ? Tag : NonTag) = D;
3143 }
3144
John McCall9f54ad42009-12-10 09:41:52 +00003145 if (Target->isFunctionOrFunctionTemplate()) {
3146 FunctionDecl *FD;
3147 if (isa<FunctionTemplateDecl>(Target))
3148 FD = cast<FunctionTemplateDecl>(Target)->getTemplatedDecl();
3149 else
3150 FD = cast<FunctionDecl>(Target);
3151
3152 NamedDecl *OldDecl = 0;
3153 switch (CheckOverload(FD, Previous, OldDecl)) {
3154 case Ovl_Overload:
3155 return false;
3156
3157 case Ovl_NonFunction:
John McCall41ce66f2009-12-10 19:51:03 +00003158 Diag(Using->getLocation(), diag::err_using_decl_conflict);
John McCall9f54ad42009-12-10 09:41:52 +00003159 break;
3160
3161 // We found a decl with the exact signature.
3162 case Ovl_Match:
3163 if (isa<UsingShadowDecl>(OldDecl)) {
3164 // Silently ignore the possible conflict.
3165 return false;
3166 }
3167
3168 // If we're in a record, we want to hide the target, so we
3169 // return true (without a diagnostic) to tell the caller not to
3170 // build a shadow decl.
3171 if (CurContext->isRecord())
3172 return true;
3173
3174 // If we're not in a record, this is an error.
John McCall41ce66f2009-12-10 19:51:03 +00003175 Diag(Using->getLocation(), diag::err_using_decl_conflict);
John McCall9f54ad42009-12-10 09:41:52 +00003176 break;
3177 }
3178
3179 Diag(Target->getLocation(), diag::note_using_decl_target);
3180 Diag(OldDecl->getLocation(), diag::note_using_decl_conflict);
3181 return true;
3182 }
3183
3184 // Target is not a function.
3185
John McCall9f54ad42009-12-10 09:41:52 +00003186 if (isa<TagDecl>(Target)) {
3187 // No conflict between a tag and a non-tag.
3188 if (!Tag) return false;
3189
John McCall41ce66f2009-12-10 19:51:03 +00003190 Diag(Using->getLocation(), diag::err_using_decl_conflict);
John McCall9f54ad42009-12-10 09:41:52 +00003191 Diag(Target->getLocation(), diag::note_using_decl_target);
3192 Diag(Tag->getLocation(), diag::note_using_decl_conflict);
3193 return true;
3194 }
3195
3196 // No conflict between a tag and a non-tag.
3197 if (!NonTag) return false;
3198
John McCall41ce66f2009-12-10 19:51:03 +00003199 Diag(Using->getLocation(), diag::err_using_decl_conflict);
John McCall9f54ad42009-12-10 09:41:52 +00003200 Diag(Target->getLocation(), diag::note_using_decl_target);
3201 Diag(NonTag->getLocation(), diag::note_using_decl_conflict);
3202 return true;
3203}
3204
John McCall9488ea12009-11-17 05:59:44 +00003205/// Builds a shadow declaration corresponding to a 'using' declaration.
John McCall604e7f12009-12-08 07:46:18 +00003206UsingShadowDecl *Sema::BuildUsingShadowDecl(Scope *S,
John McCall604e7f12009-12-08 07:46:18 +00003207 UsingDecl *UD,
3208 NamedDecl *Orig) {
John McCall9488ea12009-11-17 05:59:44 +00003209
3210 // If we resolved to another shadow declaration, just coalesce them.
John McCall604e7f12009-12-08 07:46:18 +00003211 NamedDecl *Target = Orig;
3212 if (isa<UsingShadowDecl>(Target)) {
3213 Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
3214 assert(!isa<UsingShadowDecl>(Target) && "nested shadow declaration");
John McCall9488ea12009-11-17 05:59:44 +00003215 }
3216
3217 UsingShadowDecl *Shadow
John McCall604e7f12009-12-08 07:46:18 +00003218 = UsingShadowDecl::Create(Context, CurContext,
3219 UD->getLocation(), UD, Target);
John McCall9488ea12009-11-17 05:59:44 +00003220 UD->addShadowDecl(Shadow);
3221
3222 if (S)
John McCall604e7f12009-12-08 07:46:18 +00003223 PushOnScopeChains(Shadow, S);
John McCall9488ea12009-11-17 05:59:44 +00003224 else
John McCall604e7f12009-12-08 07:46:18 +00003225 CurContext->addDecl(Shadow);
John McCall9f54ad42009-12-10 09:41:52 +00003226 Shadow->setAccess(UD->getAccess());
John McCall9488ea12009-11-17 05:59:44 +00003227
John McCall604e7f12009-12-08 07:46:18 +00003228 if (Orig->isInvalidDecl() || UD->isInvalidDecl())
3229 Shadow->setInvalidDecl();
3230
John McCall9f54ad42009-12-10 09:41:52 +00003231 return Shadow;
3232}
John McCall604e7f12009-12-08 07:46:18 +00003233
John McCall9f54ad42009-12-10 09:41:52 +00003234/// Hides a using shadow declaration. This is required by the current
3235/// using-decl implementation when a resolvable using declaration in a
3236/// class is followed by a declaration which would hide or override
3237/// one or more of the using decl's targets; for example:
3238///
3239/// struct Base { void foo(int); };
3240/// struct Derived : Base {
3241/// using Base::foo;
3242/// void foo(int);
3243/// };
3244///
3245/// The governing language is C++03 [namespace.udecl]p12:
3246///
3247/// When a using-declaration brings names from a base class into a
3248/// derived class scope, member functions in the derived class
3249/// override and/or hide member functions with the same name and
3250/// parameter types in a base class (rather than conflicting).
3251///
3252/// There are two ways to implement this:
3253/// (1) optimistically create shadow decls when they're not hidden
3254/// by existing declarations, or
3255/// (2) don't create any shadow decls (or at least don't make them
3256/// visible) until we've fully parsed/instantiated the class.
3257/// The problem with (1) is that we might have to retroactively remove
3258/// a shadow decl, which requires several O(n) operations because the
3259/// decl structures are (very reasonably) not designed for removal.
3260/// (2) avoids this but is very fiddly and phase-dependent.
3261void Sema::HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow) {
3262 // Remove it from the DeclContext...
3263 Shadow->getDeclContext()->removeDecl(Shadow);
John McCall604e7f12009-12-08 07:46:18 +00003264
John McCall9f54ad42009-12-10 09:41:52 +00003265 // ...and the scope, if applicable...
3266 if (S) {
3267 S->RemoveDecl(DeclPtrTy::make(static_cast<Decl*>(Shadow)));
3268 IdResolver.RemoveDecl(Shadow);
John McCall604e7f12009-12-08 07:46:18 +00003269 }
3270
John McCall9f54ad42009-12-10 09:41:52 +00003271 // ...and the using decl.
3272 Shadow->getUsingDecl()->removeShadowDecl(Shadow);
3273
3274 // TODO: complain somehow if Shadow was used. It shouldn't
3275 // be possible for this to happen, because
John McCall9488ea12009-11-17 05:59:44 +00003276}
3277
John McCall7ba107a2009-11-18 02:36:19 +00003278/// Builds a using declaration.
3279///
3280/// \param IsInstantiation - Whether this call arises from an
3281/// instantiation of an unresolved using declaration. We treat
3282/// the lookup differently for these declarations.
John McCall9488ea12009-11-17 05:59:44 +00003283NamedDecl *Sema::BuildUsingDeclaration(Scope *S, AccessSpecifier AS,
3284 SourceLocation UsingLoc,
Anders Carlssonc72160b2009-08-28 05:40:36 +00003285 const CXXScopeSpec &SS,
3286 SourceLocation IdentLoc,
3287 DeclarationName Name,
3288 AttributeList *AttrList,
John McCall7ba107a2009-11-18 02:36:19 +00003289 bool IsInstantiation,
3290 bool IsTypeName,
3291 SourceLocation TypenameLoc) {
Anders Carlssonc72160b2009-08-28 05:40:36 +00003292 assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
3293 assert(IdentLoc.isValid() && "Invalid TargetName location.");
Eli Friedman2a16a132009-08-27 05:09:36 +00003294
Anders Carlsson550b14b2009-08-28 05:49:21 +00003295 // FIXME: We ignore attributes for now.
3296 delete AttrList;
Mike Stump1eb44332009-09-09 15:08:12 +00003297
Anders Carlssoncf9f9212009-08-28 03:16:11 +00003298 if (SS.isEmpty()) {
3299 Diag(IdentLoc, diag::err_using_requires_qualname);
Anders Carlssonc72160b2009-08-28 05:40:36 +00003300 return 0;
Anders Carlssoncf9f9212009-08-28 03:16:11 +00003301 }
Mike Stump1eb44332009-09-09 15:08:12 +00003302
John McCall9f54ad42009-12-10 09:41:52 +00003303 // Do the redeclaration lookup in the current scope.
3304 LookupResult Previous(*this, Name, IdentLoc, LookupUsingDeclName,
3305 ForRedeclaration);
3306 Previous.setHideTags(false);
3307 if (S) {
3308 LookupName(Previous, S);
3309
3310 // It is really dumb that we have to do this.
3311 LookupResult::Filter F = Previous.makeFilter();
3312 while (F.hasNext()) {
3313 NamedDecl *D = F.next();
3314 if (!isDeclInScope(D, CurContext, S))
3315 F.erase();
3316 }
3317 F.done();
3318 } else {
3319 assert(IsInstantiation && "no scope in non-instantiation");
3320 assert(CurContext->isRecord() && "scope not record in instantiation");
3321 LookupQualifiedName(Previous, CurContext);
3322 }
3323
Mike Stump1eb44332009-09-09 15:08:12 +00003324 NestedNameSpecifier *NNS =
Anders Carlssoncf9f9212009-08-28 03:16:11 +00003325 static_cast<NestedNameSpecifier *>(SS.getScopeRep());
3326
John McCall9f54ad42009-12-10 09:41:52 +00003327 // Check for invalid redeclarations.
3328 if (CheckUsingDeclRedeclaration(UsingLoc, IsTypeName, SS, IdentLoc, Previous))
3329 return 0;
3330
3331 // Check for bad qualifiers.
John McCalled976492009-12-04 22:46:56 +00003332 if (CheckUsingDeclQualifier(UsingLoc, SS, IdentLoc))
3333 return 0;
3334
John McCallaf8e6ed2009-11-12 03:15:40 +00003335 DeclContext *LookupContext = computeDeclContext(SS);
John McCalled976492009-12-04 22:46:56 +00003336 NamedDecl *D;
John McCallaf8e6ed2009-11-12 03:15:40 +00003337 if (!LookupContext) {
John McCall7ba107a2009-11-18 02:36:19 +00003338 if (IsTypeName) {
John McCalled976492009-12-04 22:46:56 +00003339 // FIXME: not all declaration name kinds are legal here
3340 D = UnresolvedUsingTypenameDecl::Create(Context, CurContext,
3341 UsingLoc, TypenameLoc,
3342 SS.getRange(), NNS,
John McCall7ba107a2009-11-18 02:36:19 +00003343 IdentLoc, Name);
John McCalled976492009-12-04 22:46:56 +00003344 } else {
3345 D = UnresolvedUsingValueDecl::Create(Context, CurContext,
3346 UsingLoc, SS.getRange(), NNS,
3347 IdentLoc, Name);
John McCall7ba107a2009-11-18 02:36:19 +00003348 }
John McCalled976492009-12-04 22:46:56 +00003349 } else {
3350 D = UsingDecl::Create(Context, CurContext, IdentLoc,
3351 SS.getRange(), UsingLoc, NNS, Name,
3352 IsTypeName);
Anders Carlsson550b14b2009-08-28 05:49:21 +00003353 }
John McCalled976492009-12-04 22:46:56 +00003354 D->setAccess(AS);
3355 CurContext->addDecl(D);
3356
3357 if (!LookupContext) return D;
3358 UsingDecl *UD = cast<UsingDecl>(D);
Mike Stump1eb44332009-09-09 15:08:12 +00003359
John McCall604e7f12009-12-08 07:46:18 +00003360 if (RequireCompleteDeclContext(SS)) {
3361 UD->setInvalidDecl();
3362 return UD;
Anders Carlssoncf9f9212009-08-28 03:16:11 +00003363 }
3364
John McCall604e7f12009-12-08 07:46:18 +00003365 // Look up the target name.
3366
John McCalla24dc2e2009-11-17 02:14:36 +00003367 LookupResult R(*this, Name, IdentLoc, LookupOrdinaryName);
John McCall7ba107a2009-11-18 02:36:19 +00003368
John McCall604e7f12009-12-08 07:46:18 +00003369 // Unlike most lookups, we don't always want to hide tag
3370 // declarations: tag names are visible through the using declaration
3371 // even if hidden by ordinary names, *except* in a dependent context
3372 // where it's important for the sanity of two-phase lookup.
John McCall7ba107a2009-11-18 02:36:19 +00003373 if (!IsInstantiation)
3374 R.setHideTags(false);
John McCall9488ea12009-11-17 05:59:44 +00003375
John McCalla24dc2e2009-11-17 02:14:36 +00003376 LookupQualifiedName(R, LookupContext);
Mike Stump1eb44332009-09-09 15:08:12 +00003377
John McCallf36e02d2009-10-09 21:13:30 +00003378 if (R.empty()) {
Douglas Gregor3f093272009-10-13 21:16:44 +00003379 Diag(IdentLoc, diag::err_no_member)
3380 << Name << LookupContext << SS.getRange();
John McCalled976492009-12-04 22:46:56 +00003381 UD->setInvalidDecl();
3382 return UD;
Douglas Gregor9cfbe482009-06-20 00:51:54 +00003383 }
3384
John McCalled976492009-12-04 22:46:56 +00003385 if (R.isAmbiguous()) {
3386 UD->setInvalidDecl();
3387 return UD;
3388 }
Mike Stump1eb44332009-09-09 15:08:12 +00003389
John McCall7ba107a2009-11-18 02:36:19 +00003390 if (IsTypeName) {
3391 // If we asked for a typename and got a non-type decl, error out.
John McCalled976492009-12-04 22:46:56 +00003392 if (!R.getAsSingle<TypeDecl>()) {
John McCall7ba107a2009-11-18 02:36:19 +00003393 Diag(IdentLoc, diag::err_using_typename_non_type);
3394 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I)
3395 Diag((*I)->getUnderlyingDecl()->getLocation(),
3396 diag::note_using_decl_target);
John McCalled976492009-12-04 22:46:56 +00003397 UD->setInvalidDecl();
3398 return UD;
John McCall7ba107a2009-11-18 02:36:19 +00003399 }
3400 } else {
3401 // If we asked for a non-typename and we got a type, error out,
3402 // but only if this is an instantiation of an unresolved using
3403 // decl. Otherwise just silently find the type name.
John McCalled976492009-12-04 22:46:56 +00003404 if (IsInstantiation && R.getAsSingle<TypeDecl>()) {
John McCall7ba107a2009-11-18 02:36:19 +00003405 Diag(IdentLoc, diag::err_using_dependent_value_is_type);
3406 Diag(R.getFoundDecl()->getLocation(), diag::note_using_decl_target);
John McCalled976492009-12-04 22:46:56 +00003407 UD->setInvalidDecl();
3408 return UD;
John McCall7ba107a2009-11-18 02:36:19 +00003409 }
Anders Carlssoncf9f9212009-08-28 03:16:11 +00003410 }
3411
Anders Carlsson73b39cf2009-08-28 03:35:18 +00003412 // C++0x N2914 [namespace.udecl]p6:
3413 // A using-declaration shall not name a namespace.
John McCalled976492009-12-04 22:46:56 +00003414 if (R.getAsSingle<NamespaceDecl>()) {
Anders Carlsson73b39cf2009-08-28 03:35:18 +00003415 Diag(IdentLoc, diag::err_using_decl_can_not_refer_to_namespace)
3416 << SS.getRange();
John McCalled976492009-12-04 22:46:56 +00003417 UD->setInvalidDecl();
3418 return UD;
Anders Carlsson73b39cf2009-08-28 03:35:18 +00003419 }
Mike Stump1eb44332009-09-09 15:08:12 +00003420
John McCall9f54ad42009-12-10 09:41:52 +00003421 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {
3422 if (!CheckUsingShadowDecl(UD, *I, Previous))
3423 BuildUsingShadowDecl(S, UD, *I);
3424 }
John McCall9488ea12009-11-17 05:59:44 +00003425
3426 return UD;
Douglas Gregor9cfbe482009-06-20 00:51:54 +00003427}
3428
John McCall9f54ad42009-12-10 09:41:52 +00003429/// Checks that the given using declaration is not an invalid
3430/// redeclaration. Note that this is checking only for the using decl
3431/// itself, not for any ill-formedness among the UsingShadowDecls.
3432bool Sema::CheckUsingDeclRedeclaration(SourceLocation UsingLoc,
3433 bool isTypeName,
3434 const CXXScopeSpec &SS,
3435 SourceLocation NameLoc,
3436 const LookupResult &Prev) {
3437 // C++03 [namespace.udecl]p8:
3438 // C++0x [namespace.udecl]p10:
3439 // A using-declaration is a declaration and can therefore be used
3440 // repeatedly where (and only where) multiple declarations are
3441 // allowed.
3442 // That's only in file contexts.
3443 if (CurContext->getLookupContext()->isFileContext())
3444 return false;
3445
3446 NestedNameSpecifier *Qual
3447 = static_cast<NestedNameSpecifier*>(SS.getScopeRep());
3448
3449 for (LookupResult::iterator I = Prev.begin(), E = Prev.end(); I != E; ++I) {
3450 NamedDecl *D = *I;
3451
3452 bool DTypename;
3453 NestedNameSpecifier *DQual;
3454 if (UsingDecl *UD = dyn_cast<UsingDecl>(D)) {
3455 DTypename = UD->isTypeName();
3456 DQual = UD->getTargetNestedNameDecl();
3457 } else if (UnresolvedUsingValueDecl *UD
3458 = dyn_cast<UnresolvedUsingValueDecl>(D)) {
3459 DTypename = false;
3460 DQual = UD->getTargetNestedNameSpecifier();
3461 } else if (UnresolvedUsingTypenameDecl *UD
3462 = dyn_cast<UnresolvedUsingTypenameDecl>(D)) {
3463 DTypename = true;
3464 DQual = UD->getTargetNestedNameSpecifier();
3465 } else continue;
3466
3467 // using decls differ if one says 'typename' and the other doesn't.
3468 // FIXME: non-dependent using decls?
3469 if (isTypeName != DTypename) continue;
3470
3471 // using decls differ if they name different scopes (but note that
3472 // template instantiation can cause this check to trigger when it
3473 // didn't before instantiation).
3474 if (Context.getCanonicalNestedNameSpecifier(Qual) !=
3475 Context.getCanonicalNestedNameSpecifier(DQual))
3476 continue;
3477
3478 Diag(NameLoc, diag::err_using_decl_redeclaration) << SS.getRange();
John McCall41ce66f2009-12-10 19:51:03 +00003479 Diag(D->getLocation(), diag::note_using_decl) << 1;
John McCall9f54ad42009-12-10 09:41:52 +00003480 return true;
3481 }
3482
3483 return false;
3484}
3485
John McCall604e7f12009-12-08 07:46:18 +00003486
John McCalled976492009-12-04 22:46:56 +00003487/// Checks that the given nested-name qualifier used in a using decl
3488/// in the current context is appropriately related to the current
3489/// scope. If an error is found, diagnoses it and returns true.
3490bool Sema::CheckUsingDeclQualifier(SourceLocation UsingLoc,
3491 const CXXScopeSpec &SS,
3492 SourceLocation NameLoc) {
John McCall604e7f12009-12-08 07:46:18 +00003493 DeclContext *NamedContext = computeDeclContext(SS);
John McCalled976492009-12-04 22:46:56 +00003494
John McCall604e7f12009-12-08 07:46:18 +00003495 if (!CurContext->isRecord()) {
3496 // C++03 [namespace.udecl]p3:
3497 // C++0x [namespace.udecl]p8:
3498 // A using-declaration for a class member shall be a member-declaration.
3499
3500 // If we weren't able to compute a valid scope, it must be a
3501 // dependent class scope.
3502 if (!NamedContext || NamedContext->isRecord()) {
3503 Diag(NameLoc, diag::err_using_decl_can_not_refer_to_class_member)
3504 << SS.getRange();
3505 return true;
3506 }
3507
3508 // Otherwise, everything is known to be fine.
3509 return false;
3510 }
3511
3512 // The current scope is a record.
3513
3514 // If the named context is dependent, we can't decide much.
3515 if (!NamedContext) {
3516 // FIXME: in C++0x, we can diagnose if we can prove that the
3517 // nested-name-specifier does not refer to a base class, which is
3518 // still possible in some cases.
3519
3520 // Otherwise we have to conservatively report that things might be
3521 // okay.
3522 return false;
3523 }
3524
3525 if (!NamedContext->isRecord()) {
3526 // Ideally this would point at the last name in the specifier,
3527 // but we don't have that level of source info.
3528 Diag(SS.getRange().getBegin(),
3529 diag::err_using_decl_nested_name_specifier_is_not_class)
3530 << (NestedNameSpecifier*) SS.getScopeRep() << SS.getRange();
3531 return true;
3532 }
3533
3534 if (getLangOptions().CPlusPlus0x) {
3535 // C++0x [namespace.udecl]p3:
3536 // In a using-declaration used as a member-declaration, the
3537 // nested-name-specifier shall name a base class of the class
3538 // being defined.
3539
3540 if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(
3541 cast<CXXRecordDecl>(NamedContext))) {
3542 if (CurContext == NamedContext) {
3543 Diag(NameLoc,
3544 diag::err_using_decl_nested_name_specifier_is_current_class)
3545 << SS.getRange();
3546 return true;
3547 }
3548
3549 Diag(SS.getRange().getBegin(),
3550 diag::err_using_decl_nested_name_specifier_is_not_base_class)
3551 << (NestedNameSpecifier*) SS.getScopeRep()
3552 << cast<CXXRecordDecl>(CurContext)
3553 << SS.getRange();
3554 return true;
3555 }
3556
3557 return false;
3558 }
3559
3560 // C++03 [namespace.udecl]p4:
3561 // A using-declaration used as a member-declaration shall refer
3562 // to a member of a base class of the class being defined [etc.].
3563
3564 // Salient point: SS doesn't have to name a base class as long as
3565 // lookup only finds members from base classes. Therefore we can
3566 // diagnose here only if we can prove that that can't happen,
3567 // i.e. if the class hierarchies provably don't intersect.
3568
3569 // TODO: it would be nice if "definitely valid" results were cached
3570 // in the UsingDecl and UsingShadowDecl so that these checks didn't
3571 // need to be repeated.
3572
3573 struct UserData {
3574 llvm::DenseSet<const CXXRecordDecl*> Bases;
3575
3576 static bool collect(const CXXRecordDecl *Base, void *OpaqueData) {
3577 UserData *Data = reinterpret_cast<UserData*>(OpaqueData);
3578 Data->Bases.insert(Base);
3579 return true;
3580 }
3581
3582 bool hasDependentBases(const CXXRecordDecl *Class) {
3583 return !Class->forallBases(collect, this);
3584 }
3585
3586 /// Returns true if the base is dependent or is one of the
3587 /// accumulated base classes.
3588 static bool doesNotContain(const CXXRecordDecl *Base, void *OpaqueData) {
3589 UserData *Data = reinterpret_cast<UserData*>(OpaqueData);
3590 return !Data->Bases.count(Base);
3591 }
3592
3593 bool mightShareBases(const CXXRecordDecl *Class) {
3594 return Bases.count(Class) || !Class->forallBases(doesNotContain, this);
3595 }
3596 };
3597
3598 UserData Data;
3599
3600 // Returns false if we find a dependent base.
3601 if (Data.hasDependentBases(cast<CXXRecordDecl>(CurContext)))
3602 return false;
3603
3604 // Returns false if the class has a dependent base or if it or one
3605 // of its bases is present in the base set of the current context.
3606 if (Data.mightShareBases(cast<CXXRecordDecl>(NamedContext)))
3607 return false;
3608
3609 Diag(SS.getRange().getBegin(),
3610 diag::err_using_decl_nested_name_specifier_is_not_base_class)
3611 << (NestedNameSpecifier*) SS.getScopeRep()
3612 << cast<CXXRecordDecl>(CurContext)
3613 << SS.getRange();
3614
3615 return true;
John McCalled976492009-12-04 22:46:56 +00003616}
3617
Mike Stump1eb44332009-09-09 15:08:12 +00003618Sema::DeclPtrTy Sema::ActOnNamespaceAliasDef(Scope *S,
Anders Carlsson03bd5a12009-03-28 22:53:22 +00003619 SourceLocation NamespaceLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00003620 SourceLocation AliasLoc,
3621 IdentifierInfo *Alias,
3622 const CXXScopeSpec &SS,
Anders Carlsson03bd5a12009-03-28 22:53:22 +00003623 SourceLocation IdentLoc,
3624 IdentifierInfo *Ident) {
Mike Stump1eb44332009-09-09 15:08:12 +00003625
Anders Carlsson81c85c42009-03-28 23:53:49 +00003626 // Lookup the namespace name.
John McCalla24dc2e2009-11-17 02:14:36 +00003627 LookupResult R(*this, Ident, IdentLoc, LookupNamespaceName);
3628 LookupParsedName(R, S, &SS);
Anders Carlsson81c85c42009-03-28 23:53:49 +00003629
Anders Carlsson8d7ba402009-03-28 06:23:46 +00003630 // Check if we have a previous declaration with the same name.
John McCallf36e02d2009-10-09 21:13:30 +00003631 if (NamedDecl *PrevDecl
John McCall7d384dd2009-11-18 07:57:50 +00003632 = LookupSingleName(S, Alias, LookupOrdinaryName, ForRedeclaration)) {
Anders Carlsson81c85c42009-03-28 23:53:49 +00003633 if (NamespaceAliasDecl *AD = dyn_cast<NamespaceAliasDecl>(PrevDecl)) {
Mike Stump1eb44332009-09-09 15:08:12 +00003634 // We already have an alias with the same name that points to the same
Anders Carlsson81c85c42009-03-28 23:53:49 +00003635 // namespace, so don't create a new one.
John McCallf36e02d2009-10-09 21:13:30 +00003636 if (!R.isAmbiguous() && !R.empty() &&
3637 AD->getNamespace() == getNamespaceDecl(R.getFoundDecl()))
Anders Carlsson81c85c42009-03-28 23:53:49 +00003638 return DeclPtrTy();
3639 }
Mike Stump1eb44332009-09-09 15:08:12 +00003640
Anders Carlsson8d7ba402009-03-28 06:23:46 +00003641 unsigned DiagID = isa<NamespaceDecl>(PrevDecl) ? diag::err_redefinition :
3642 diag::err_redefinition_different_kind;
3643 Diag(AliasLoc, DiagID) << Alias;
3644 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
Chris Lattnerb28317a2009-03-28 19:18:32 +00003645 return DeclPtrTy();
Anders Carlsson8d7ba402009-03-28 06:23:46 +00003646 }
3647
John McCalla24dc2e2009-11-17 02:14:36 +00003648 if (R.isAmbiguous())
Chris Lattnerb28317a2009-03-28 19:18:32 +00003649 return DeclPtrTy();
Mike Stump1eb44332009-09-09 15:08:12 +00003650
John McCallf36e02d2009-10-09 21:13:30 +00003651 if (R.empty()) {
Anders Carlsson5721c682009-03-28 06:42:02 +00003652 Diag(NamespaceLoc, diag::err_expected_namespace_name) << SS.getRange();
Chris Lattnerb28317a2009-03-28 19:18:32 +00003653 return DeclPtrTy();
Anders Carlsson5721c682009-03-28 06:42:02 +00003654 }
Mike Stump1eb44332009-09-09 15:08:12 +00003655
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00003656 NamespaceAliasDecl *AliasDecl =
Mike Stump1eb44332009-09-09 15:08:12 +00003657 NamespaceAliasDecl::Create(Context, CurContext, NamespaceLoc, AliasLoc,
3658 Alias, SS.getRange(),
Douglas Gregor6c9c9402009-05-30 06:48:27 +00003659 (NestedNameSpecifier *)SS.getScopeRep(),
John McCallf36e02d2009-10-09 21:13:30 +00003660 IdentLoc, R.getFoundDecl());
Mike Stump1eb44332009-09-09 15:08:12 +00003661
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00003662 CurContext->addDecl(AliasDecl);
Anders Carlsson68771c72009-03-28 22:58:02 +00003663 return DeclPtrTy::make(AliasDecl);
Anders Carlssondbb00942009-03-28 05:27:17 +00003664}
3665
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00003666void Sema::DefineImplicitDefaultConstructor(SourceLocation CurrentLocation,
3667 CXXConstructorDecl *Constructor) {
Fariborz Jahanian05a5c452009-06-22 20:37:23 +00003668 assert((Constructor->isImplicit() && Constructor->isDefaultConstructor() &&
3669 !Constructor->isUsed()) &&
3670 "DefineImplicitDefaultConstructor - call it for implicit default ctor");
Mike Stump1eb44332009-09-09 15:08:12 +00003671
Eli Friedman80c30da2009-11-09 19:20:36 +00003672 CXXRecordDecl *ClassDecl
3673 = cast<CXXRecordDecl>(Constructor->getDeclContext());
3674 assert(ClassDecl && "DefineImplicitDefaultConstructor - invalid constructor");
Eli Friedman49c16da2009-11-09 01:05:47 +00003675
Eli Friedman80c30da2009-11-09 19:20:36 +00003676 if (SetBaseOrMemberInitializers(Constructor, 0, 0, true)) {
Anders Carlsson37909802009-11-30 21:24:50 +00003677 Diag(CurrentLocation, diag::note_member_synthesized_at)
3678 << CXXDefaultConstructor << Context.getTagDeclType(ClassDecl);
Eli Friedman80c30da2009-11-09 19:20:36 +00003679 Constructor->setInvalidDecl();
3680 } else {
3681 Constructor->setUsed();
3682 }
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00003683}
3684
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003685void Sema::DefineImplicitDestructor(SourceLocation CurrentLocation,
Douglas Gregor4fe95f92009-09-04 19:04:08 +00003686 CXXDestructorDecl *Destructor) {
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003687 assert((Destructor->isImplicit() && !Destructor->isUsed()) &&
3688 "DefineImplicitDestructor - call it for implicit default dtor");
Anders Carlsson6d701392009-11-15 22:49:34 +00003689 CXXRecordDecl *ClassDecl = Destructor->getParent();
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003690 assert(ClassDecl && "DefineImplicitDestructor - invalid destructor");
3691 // C++ [class.dtor] p5
Mike Stump1eb44332009-09-09 15:08:12 +00003692 // Before the implicitly-declared default destructor for a class is
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003693 // implicitly defined, all the implicitly-declared default destructors
3694 // for its base class and its non-static data members shall have been
3695 // implicitly defined.
Fariborz Jahanian514b7b12009-06-30 16:36:53 +00003696 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
3697 E = ClassDecl->bases_end(); Base != E; ++Base) {
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003698 CXXRecordDecl *BaseClassDecl
Ted Kremenek6217b802009-07-29 21:53:49 +00003699 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003700 if (!BaseClassDecl->hasTrivialDestructor()) {
Mike Stump1eb44332009-09-09 15:08:12 +00003701 if (CXXDestructorDecl *BaseDtor =
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003702 const_cast<CXXDestructorDecl*>(BaseClassDecl->getDestructor(Context)))
3703 MarkDeclarationReferenced(CurrentLocation, BaseDtor);
3704 else
Mike Stump1eb44332009-09-09 15:08:12 +00003705 assert(false &&
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003706 "DefineImplicitDestructor - missing dtor in a base class");
3707 }
3708 }
Mike Stump1eb44332009-09-09 15:08:12 +00003709
Fariborz Jahanian514b7b12009-06-30 16:36:53 +00003710 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
3711 E = ClassDecl->field_end(); Field != E; ++Field) {
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003712 QualType FieldType = Context.getCanonicalType((*Field)->getType());
3713 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
3714 FieldType = Array->getElementType();
Ted Kremenek6217b802009-07-29 21:53:49 +00003715 if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003716 CXXRecordDecl *FieldClassDecl
3717 = cast<CXXRecordDecl>(FieldClassType->getDecl());
3718 if (!FieldClassDecl->hasTrivialDestructor()) {
Mike Stump1eb44332009-09-09 15:08:12 +00003719 if (CXXDestructorDecl *FieldDtor =
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003720 const_cast<CXXDestructorDecl*>(
3721 FieldClassDecl->getDestructor(Context)))
3722 MarkDeclarationReferenced(CurrentLocation, FieldDtor);
3723 else
Mike Stump1eb44332009-09-09 15:08:12 +00003724 assert(false &&
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003725 "DefineImplicitDestructor - missing dtor in class of a data member");
3726 }
3727 }
3728 }
Anders Carlsson37909802009-11-30 21:24:50 +00003729
3730 // FIXME: If CheckDestructor fails, we should emit a note about where the
3731 // implicit destructor was needed.
3732 if (CheckDestructor(Destructor)) {
3733 Diag(CurrentLocation, diag::note_member_synthesized_at)
3734 << CXXDestructor << Context.getTagDeclType(ClassDecl);
3735
3736 Destructor->setInvalidDecl();
3737 return;
3738 }
3739
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003740 Destructor->setUsed();
3741}
3742
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003743void Sema::DefineImplicitOverloadedAssign(SourceLocation CurrentLocation,
3744 CXXMethodDecl *MethodDecl) {
3745 assert((MethodDecl->isImplicit() && MethodDecl->isOverloadedOperator() &&
3746 MethodDecl->getOverloadedOperator() == OO_Equal &&
3747 !MethodDecl->isUsed()) &&
3748 "DefineImplicitOverloadedAssign - call it for implicit assignment op");
Mike Stump1eb44332009-09-09 15:08:12 +00003749
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003750 CXXRecordDecl *ClassDecl
3751 = cast<CXXRecordDecl>(MethodDecl->getDeclContext());
Mike Stump1eb44332009-09-09 15:08:12 +00003752
Fariborz Jahanianc6249b92009-06-26 16:08:57 +00003753 // C++[class.copy] p12
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003754 // Before the implicitly-declared copy assignment operator for a class is
3755 // implicitly defined, all implicitly-declared copy assignment operators
3756 // for its direct base classes and its nonstatic data members shall have
3757 // been implicitly defined.
3758 bool err = false;
Fariborz Jahanian514b7b12009-06-30 16:36:53 +00003759 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
3760 E = ClassDecl->bases_end(); Base != E; ++Base) {
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003761 CXXRecordDecl *BaseClassDecl
Ted Kremenek6217b802009-07-29 21:53:49 +00003762 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Mike Stump1eb44332009-09-09 15:08:12 +00003763 if (CXXMethodDecl *BaseAssignOpMethod =
Anders Carlssonb6cc91b2009-12-09 03:01:51 +00003764 getAssignOperatorMethod(CurrentLocation, MethodDecl->getParamDecl(0),
3765 BaseClassDecl))
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003766 MarkDeclarationReferenced(CurrentLocation, BaseAssignOpMethod);
3767 }
Fariborz Jahanian514b7b12009-06-30 16:36:53 +00003768 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
3769 E = ClassDecl->field_end(); Field != E; ++Field) {
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003770 QualType FieldType = Context.getCanonicalType((*Field)->getType());
3771 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
3772 FieldType = Array->getElementType();
Ted Kremenek6217b802009-07-29 21:53:49 +00003773 if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003774 CXXRecordDecl *FieldClassDecl
3775 = cast<CXXRecordDecl>(FieldClassType->getDecl());
Mike Stump1eb44332009-09-09 15:08:12 +00003776 if (CXXMethodDecl *FieldAssignOpMethod =
Anders Carlssonb6cc91b2009-12-09 03:01:51 +00003777 getAssignOperatorMethod(CurrentLocation, MethodDecl->getParamDecl(0),
3778 FieldClassDecl))
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003779 MarkDeclarationReferenced(CurrentLocation, FieldAssignOpMethod);
Mike Stumpac5fc7c2009-08-04 21:02:39 +00003780 } else if (FieldType->isReferenceType()) {
Mike Stump1eb44332009-09-09 15:08:12 +00003781 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
Anders Carlsson5e09d4c2009-07-09 17:47:25 +00003782 << Context.getTagDeclType(ClassDecl) << 0 << Field->getDeclName();
3783 Diag(Field->getLocation(), diag::note_declared_at);
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003784 Diag(CurrentLocation, diag::note_first_required_here);
3785 err = true;
Mike Stumpac5fc7c2009-08-04 21:02:39 +00003786 } else if (FieldType.isConstQualified()) {
Mike Stump1eb44332009-09-09 15:08:12 +00003787 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
Anders Carlsson5e09d4c2009-07-09 17:47:25 +00003788 << Context.getTagDeclType(ClassDecl) << 1 << Field->getDeclName();
3789 Diag(Field->getLocation(), diag::note_declared_at);
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003790 Diag(CurrentLocation, diag::note_first_required_here);
3791 err = true;
3792 }
3793 }
3794 if (!err)
Mike Stump1eb44332009-09-09 15:08:12 +00003795 MethodDecl->setUsed();
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003796}
3797
3798CXXMethodDecl *
Anders Carlssonb6cc91b2009-12-09 03:01:51 +00003799Sema::getAssignOperatorMethod(SourceLocation CurrentLocation,
3800 ParmVarDecl *ParmDecl,
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003801 CXXRecordDecl *ClassDecl) {
3802 QualType LHSType = Context.getTypeDeclType(ClassDecl);
3803 QualType RHSType(LHSType);
3804 // If class's assignment operator argument is const/volatile qualified,
Mike Stump1eb44332009-09-09 15:08:12 +00003805 // look for operator = (const/volatile B&). Otherwise, look for
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003806 // operator = (B&).
John McCall0953e762009-09-24 19:53:00 +00003807 RHSType = Context.getCVRQualifiedType(RHSType,
3808 ParmDecl->getType().getCVRQualifiers());
Mike Stump1eb44332009-09-09 15:08:12 +00003809 ExprOwningPtr<Expr> LHS(this, new (Context) DeclRefExpr(ParmDecl,
Anders Carlssonb6cc91b2009-12-09 03:01:51 +00003810 LHSType,
3811 SourceLocation()));
Mike Stump1eb44332009-09-09 15:08:12 +00003812 ExprOwningPtr<Expr> RHS(this, new (Context) DeclRefExpr(ParmDecl,
Anders Carlssonb6cc91b2009-12-09 03:01:51 +00003813 RHSType,
3814 CurrentLocation));
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003815 Expr *Args[2] = { &*LHS, &*RHS };
3816 OverloadCandidateSet CandidateSet;
Mike Stump1eb44332009-09-09 15:08:12 +00003817 AddMemberOperatorCandidates(clang::OO_Equal, SourceLocation(), Args, 2,
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003818 CandidateSet);
3819 OverloadCandidateSet::iterator Best;
Anders Carlssonb6cc91b2009-12-09 03:01:51 +00003820 if (BestViableFunction(CandidateSet, CurrentLocation, Best) == OR_Success)
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003821 return cast<CXXMethodDecl>(Best->Function);
3822 assert(false &&
3823 "getAssignOperatorMethod - copy assignment operator method not found");
3824 return 0;
3825}
3826
Fariborz Jahanian485f0872009-06-22 23:34:40 +00003827void Sema::DefineImplicitCopyConstructor(SourceLocation CurrentLocation,
3828 CXXConstructorDecl *CopyConstructor,
3829 unsigned TypeQuals) {
Mike Stump1eb44332009-09-09 15:08:12 +00003830 assert((CopyConstructor->isImplicit() &&
Douglas Gregor9e9199d2009-12-22 00:34:07 +00003831 CopyConstructor->isCopyConstructor(TypeQuals) &&
Fariborz Jahanian485f0872009-06-22 23:34:40 +00003832 !CopyConstructor->isUsed()) &&
3833 "DefineImplicitCopyConstructor - call it for implicit copy ctor");
Mike Stump1eb44332009-09-09 15:08:12 +00003834
Fariborz Jahanian485f0872009-06-22 23:34:40 +00003835 CXXRecordDecl *ClassDecl
3836 = cast<CXXRecordDecl>(CopyConstructor->getDeclContext());
3837 assert(ClassDecl && "DefineImplicitCopyConstructor - invalid constructor");
Fariborz Jahanian220a0f32009-06-23 23:42:10 +00003838 // C++ [class.copy] p209
Mike Stump1eb44332009-09-09 15:08:12 +00003839 // Before the implicitly-declared copy constructor for a class is
Fariborz Jahanian485f0872009-06-22 23:34:40 +00003840 // implicitly defined, all the implicitly-declared copy constructors
3841 // for its base class and its non-static data members shall have been
3842 // implicitly defined.
3843 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin();
3844 Base != ClassDecl->bases_end(); ++Base) {
3845 CXXRecordDecl *BaseClassDecl
Ted Kremenek6217b802009-07-29 21:53:49 +00003846 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Mike Stump1eb44332009-09-09 15:08:12 +00003847 if (CXXConstructorDecl *BaseCopyCtor =
Fariborz Jahanian485f0872009-06-22 23:34:40 +00003848 BaseClassDecl->getCopyConstructor(Context, TypeQuals))
Fariborz Jahanian220a0f32009-06-23 23:42:10 +00003849 MarkDeclarationReferenced(CurrentLocation, BaseCopyCtor);
Fariborz Jahanian485f0872009-06-22 23:34:40 +00003850 }
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00003851 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
3852 FieldEnd = ClassDecl->field_end();
3853 Field != FieldEnd; ++Field) {
Fariborz Jahanian485f0872009-06-22 23:34:40 +00003854 QualType FieldType = Context.getCanonicalType((*Field)->getType());
3855 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
3856 FieldType = Array->getElementType();
Ted Kremenek6217b802009-07-29 21:53:49 +00003857 if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
Fariborz Jahanian485f0872009-06-22 23:34:40 +00003858 CXXRecordDecl *FieldClassDecl
3859 = cast<CXXRecordDecl>(FieldClassType->getDecl());
Mike Stump1eb44332009-09-09 15:08:12 +00003860 if (CXXConstructorDecl *FieldCopyCtor =
Fariborz Jahanian485f0872009-06-22 23:34:40 +00003861 FieldClassDecl->getCopyConstructor(Context, TypeQuals))
Fariborz Jahanian220a0f32009-06-23 23:42:10 +00003862 MarkDeclarationReferenced(CurrentLocation, FieldCopyCtor);
Fariborz Jahanian485f0872009-06-22 23:34:40 +00003863 }
3864 }
3865 CopyConstructor->setUsed();
3866}
3867
Anders Carlssonda3f4e22009-08-25 05:12:04 +00003868Sema::OwningExprResult
Anders Carlssonec8e5ea2009-09-05 07:40:38 +00003869Sema::BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
Mike Stump1eb44332009-09-09 15:08:12 +00003870 CXXConstructorDecl *Constructor,
Douglas Gregor16006c92009-12-16 18:50:27 +00003871 MultiExprArg ExprArgs,
3872 bool RequiresZeroInit) {
Anders Carlsson9abf2ae2009-08-16 05:13:48 +00003873 bool Elidable = false;
Mike Stump1eb44332009-09-09 15:08:12 +00003874
Douglas Gregor39da0b82009-09-09 23:08:42 +00003875 // C++ [class.copy]p15:
3876 // Whenever a temporary class object is copied using a copy constructor, and
3877 // this object and the copy have the same cv-unqualified type, an
3878 // implementation is permitted to treat the original and the copy as two
3879 // different ways of referring to the same object and not perform a copy at
3880 // all, even if the class copy constructor or destructor have side effects.
Mike Stump1eb44332009-09-09 15:08:12 +00003881
Anders Carlsson9abf2ae2009-08-16 05:13:48 +00003882 // FIXME: Is this enough?
Douglas Gregor9e9199d2009-12-22 00:34:07 +00003883 if (Constructor->isCopyConstructor()) {
Anders Carlssonf47511a2009-09-07 22:23:31 +00003884 Expr *E = ((Expr **)ExprArgs.get())[0];
Douglas Gregor18ef5e22009-12-18 05:02:21 +00003885 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
3886 if (ICE->getCastKind() == CastExpr::CK_NoOp)
3887 E = ICE->getSubExpr();
Eli Friedmancb48f8a2009-12-24 23:33:34 +00003888 if (CXXFunctionalCastExpr *FCE = dyn_cast<CXXFunctionalCastExpr>(E))
3889 E = FCE->getSubExpr();
Anders Carlsson9abf2ae2009-08-16 05:13:48 +00003890 while (CXXBindTemporaryExpr *BE = dyn_cast<CXXBindTemporaryExpr>(E))
3891 E = BE->getSubExpr();
Douglas Gregor39da0b82009-09-09 23:08:42 +00003892 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
3893 if (ICE->getCastKind() == CastExpr::CK_NoOp)
3894 E = ICE->getSubExpr();
Eli Friedman03368432009-12-06 09:26:33 +00003895
3896 if (CallExpr *CE = dyn_cast<CallExpr>(E))
3897 Elidable = !CE->getCallReturnType()->isReferenceType();
3898 else if (isa<CXXTemporaryObjectExpr>(E))
Anders Carlsson9abf2ae2009-08-16 05:13:48 +00003899 Elidable = true;
Eli Friedmancb48f8a2009-12-24 23:33:34 +00003900 else if (isa<CXXConstructExpr>(E))
3901 Elidable = true;
Anders Carlsson9abf2ae2009-08-16 05:13:48 +00003902 }
Mike Stump1eb44332009-09-09 15:08:12 +00003903
3904 return BuildCXXConstructExpr(ConstructLoc, DeclInitType, Constructor,
Douglas Gregor16006c92009-12-16 18:50:27 +00003905 Elidable, move(ExprArgs), RequiresZeroInit);
Anders Carlsson9abf2ae2009-08-16 05:13:48 +00003906}
3907
Fariborz Jahanianb2c352e2009-08-05 17:03:54 +00003908/// BuildCXXConstructExpr - Creates a complete call to a constructor,
3909/// including handling of its default argument expressions.
Anders Carlssonda3f4e22009-08-25 05:12:04 +00003910Sema::OwningExprResult
Anders Carlssonec8e5ea2009-09-05 07:40:38 +00003911Sema::BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
3912 CXXConstructorDecl *Constructor, bool Elidable,
Douglas Gregor16006c92009-12-16 18:50:27 +00003913 MultiExprArg ExprArgs,
3914 bool RequiresZeroInit) {
Anders Carlssonf47511a2009-09-07 22:23:31 +00003915 unsigned NumExprs = ExprArgs.size();
3916 Expr **Exprs = (Expr **)ExprArgs.release();
Mike Stump1eb44332009-09-09 15:08:12 +00003917
Douglas Gregor7edfb692009-11-23 12:27:39 +00003918 MarkDeclarationReferenced(ConstructLoc, Constructor);
Douglas Gregor99a2e602009-12-16 01:38:02 +00003919 return Owned(CXXConstructExpr::Create(Context, DeclInitType, ConstructLoc,
Douglas Gregor16006c92009-12-16 18:50:27 +00003920 Constructor, Elidable, Exprs, NumExprs,
3921 RequiresZeroInit));
Fariborz Jahanianb2c352e2009-08-05 17:03:54 +00003922}
3923
Anders Carlssone7624a72009-08-27 05:08:22 +00003924Sema::OwningExprResult
Mike Stump1eb44332009-09-09 15:08:12 +00003925Sema::BuildCXXTemporaryObjectExpr(CXXConstructorDecl *Constructor,
3926 QualType Ty,
3927 SourceLocation TyBeginLoc,
Anders Carlssone7624a72009-08-27 05:08:22 +00003928 MultiExprArg Args,
3929 SourceLocation RParenLoc) {
Douglas Gregor39da0b82009-09-09 23:08:42 +00003930 unsigned NumExprs = Args.size();
3931 Expr **Exprs = (Expr **)Args.release();
Mike Stump1eb44332009-09-09 15:08:12 +00003932
Douglas Gregor7edfb692009-11-23 12:27:39 +00003933 MarkDeclarationReferenced(TyBeginLoc, Constructor);
Douglas Gregor39da0b82009-09-09 23:08:42 +00003934 return Owned(new (Context) CXXTemporaryObjectExpr(Context, Constructor, Ty,
3935 TyBeginLoc, Exprs,
3936 NumExprs, RParenLoc));
Anders Carlssone7624a72009-08-27 05:08:22 +00003937}
3938
3939
Mike Stump1eb44332009-09-09 15:08:12 +00003940bool Sema::InitializeVarWithConstructor(VarDecl *VD,
Fariborz Jahanianb2c352e2009-08-05 17:03:54 +00003941 CXXConstructorDecl *Constructor,
Anders Carlssonf47511a2009-09-07 22:23:31 +00003942 MultiExprArg Exprs) {
Mike Stump1eb44332009-09-09 15:08:12 +00003943 OwningExprResult TempResult =
Fariborz Jahanianc0fcce42009-10-28 18:41:06 +00003944 BuildCXXConstructExpr(VD->getLocation(), VD->getType(), Constructor,
Anders Carlssonf47511a2009-09-07 22:23:31 +00003945 move(Exprs));
Anders Carlssonfe2de492009-08-25 05:18:00 +00003946 if (TempResult.isInvalid())
3947 return true;
Mike Stump1eb44332009-09-09 15:08:12 +00003948
Anders Carlssonda3f4e22009-08-25 05:12:04 +00003949 Expr *Temp = TempResult.takeAs<Expr>();
Douglas Gregord7f37bf2009-06-22 23:06:13 +00003950 MarkDeclarationReferenced(VD->getLocation(), Constructor);
Anders Carlsson0ece4912009-12-15 20:51:39 +00003951 Temp = MaybeCreateCXXExprWithTemporaries(Temp);
Douglas Gregor78d15832009-05-26 18:54:04 +00003952 VD->setInit(Context, Temp);
Mike Stump1eb44332009-09-09 15:08:12 +00003953
Anders Carlssonfe2de492009-08-25 05:18:00 +00003954 return false;
Anders Carlsson930e8d02009-04-16 23:50:50 +00003955}
3956
Mike Stump1eb44332009-09-09 15:08:12 +00003957void Sema::FinalizeVarWithDestructor(VarDecl *VD, QualType DeclInitType) {
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003958 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(
Ted Kremenek6217b802009-07-29 21:53:49 +00003959 DeclInitType->getAs<RecordType>()->getDecl());
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003960 if (!ClassDecl->hasTrivialDestructor())
Mike Stump1eb44332009-09-09 15:08:12 +00003961 if (CXXDestructorDecl *Destructor =
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003962 const_cast<CXXDestructorDecl*>(ClassDecl->getDestructor(Context)))
Fariborz Jahaniana83f7ed2009-08-03 19:13:25 +00003963 MarkDeclarationReferenced(VD->getLocation(), Destructor);
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003964}
3965
Mike Stump1eb44332009-09-09 15:08:12 +00003966/// AddCXXDirectInitializerToDecl - This action is called immediately after
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00003967/// ActOnDeclarator, when a C++ direct initializer is present.
3968/// e.g: "int x(1);"
Chris Lattnerb28317a2009-03-28 19:18:32 +00003969void Sema::AddCXXDirectInitializerToDecl(DeclPtrTy Dcl,
3970 SourceLocation LParenLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +00003971 MultiExprArg Exprs,
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00003972 SourceLocation *CommaLocs,
3973 SourceLocation RParenLoc) {
Daniel Dunbar51846262009-12-24 19:19:26 +00003974 assert(Exprs.size() != 0 && Exprs.get() && "missing expressions");
Chris Lattnerb28317a2009-03-28 19:18:32 +00003975 Decl *RealDecl = Dcl.getAs<Decl>();
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00003976
3977 // If there is no declaration, there was an error parsing it. Just ignore
3978 // the initializer.
Chris Lattnerb28317a2009-03-28 19:18:32 +00003979 if (RealDecl == 0)
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00003980 return;
Mike Stump1eb44332009-09-09 15:08:12 +00003981
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00003982 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
3983 if (!VDecl) {
3984 Diag(RealDecl->getLocation(), diag::err_illegal_initializer);
3985 RealDecl->setInvalidDecl();
3986 return;
3987 }
3988
Douglas Gregor83ddad32009-08-26 21:14:46 +00003989 // We will represent direct-initialization similarly to copy-initialization:
Argyrios Kyrtzidisce8e2922008-10-06 23:08:37 +00003990 // int x(1); -as-> int x = 1;
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00003991 // ClassType x(a,b,c); -as-> ClassType x = ClassType(a,b,c);
3992 //
3993 // Clients that want to distinguish between the two forms, can check for
3994 // direct initializer using VarDecl::hasCXXDirectInitializer().
3995 // A major benefit is that clients that don't particularly care about which
3996 // exactly form was it (like the CodeGen) can handle both cases without
3997 // special case code.
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +00003998
Douglas Gregor83ddad32009-08-26 21:14:46 +00003999 // If either the declaration has a dependent type or if any of the expressions
4000 // is type-dependent, we represent the initialization via a ParenListExpr for
4001 // later use during template instantiation.
4002 if (VDecl->getType()->isDependentType() ||
4003 Expr::hasAnyTypeDependentArguments((Expr **)Exprs.get(), Exprs.size())) {
4004 // Let clients know that initialization was done with a direct initializer.
4005 VDecl->setCXXDirectInitializer(true);
Mike Stump1eb44332009-09-09 15:08:12 +00004006
Douglas Gregor83ddad32009-08-26 21:14:46 +00004007 // Store the initialization expressions as a ParenListExpr.
4008 unsigned NumExprs = Exprs.size();
Mike Stump1eb44332009-09-09 15:08:12 +00004009 VDecl->setInit(Context,
Douglas Gregor83ddad32009-08-26 21:14:46 +00004010 new (Context) ParenListExpr(Context, LParenLoc,
4011 (Expr **)Exprs.release(),
4012 NumExprs, RParenLoc));
4013 return;
4014 }
Mike Stump1eb44332009-09-09 15:08:12 +00004015
Douglas Gregor83ddad32009-08-26 21:14:46 +00004016
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00004017 // C++ 8.5p11:
4018 // The form of initialization (using parentheses or '=') is generally
4019 // insignificant, but does matter when the entity being initialized has a
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +00004020 // class type.
Douglas Gregor18fe5682008-11-03 20:45:27 +00004021 QualType DeclInitType = VDecl->getType();
4022 if (const ArrayType *Array = Context.getAsArrayType(DeclInitType))
Fariborz Jahanian680a3f32009-10-28 19:04:36 +00004023 DeclInitType = Context.getBaseElementType(Array);
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +00004024
Douglas Gregor615c5d42009-03-24 16:43:20 +00004025 if (RequireCompleteType(VDecl->getLocation(), VDecl->getType(),
4026 diag::err_typecheck_decl_incomplete_type)) {
4027 VDecl->setInvalidDecl();
4028 return;
4029 }
4030
Douglas Gregor90f93822009-12-22 22:17:25 +00004031 // The variable can not have an abstract class type.
4032 if (RequireNonAbstractType(VDecl->getLocation(), VDecl->getType(),
4033 diag::err_abstract_type_in_decl,
4034 AbstractVariableType))
4035 VDecl->setInvalidDecl();
4036
4037 const VarDecl *Def = 0;
4038 if (VDecl->getDefinition(Def)) {
4039 Diag(VDecl->getLocation(), diag::err_redefinition)
4040 << VDecl->getDeclName();
4041 Diag(Def->getLocation(), diag::note_previous_definition);
4042 VDecl->setInvalidDecl();
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +00004043 return;
4044 }
Douglas Gregor90f93822009-12-22 22:17:25 +00004045
4046 // Capture the variable that is being initialized and the style of
4047 // initialization.
4048 InitializedEntity Entity = InitializedEntity::InitializeVariable(VDecl);
4049
4050 // FIXME: Poor source location information.
4051 InitializationKind Kind
4052 = InitializationKind::CreateDirect(VDecl->getLocation(),
4053 LParenLoc, RParenLoc);
4054
4055 InitializationSequence InitSeq(*this, Entity, Kind,
4056 (Expr**)Exprs.get(), Exprs.size());
4057 OwningExprResult Result = InitSeq.Perform(*this, Entity, Kind, move(Exprs));
4058 if (Result.isInvalid()) {
4059 VDecl->setInvalidDecl();
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00004060 return;
4061 }
Douglas Gregor90f93822009-12-22 22:17:25 +00004062
4063 Result = MaybeCreateCXXExprWithTemporaries(move(Result));
4064 VDecl->setInit(Context, Result.takeAs<Expr>());
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00004065 VDecl->setCXXDirectInitializer(true);
Argyrios Kyrtzidisce8e2922008-10-06 23:08:37 +00004066
Douglas Gregor90f93822009-12-22 22:17:25 +00004067 if (VDecl->getType()->getAs<RecordType>())
4068 FinalizeVarWithDestructor(VDecl, DeclInitType);
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00004069}
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004070
Douglas Gregor19aeac62009-11-14 03:27:21 +00004071/// \brief Add the applicable constructor candidates for an initialization
4072/// by constructor.
4073static void AddConstructorInitializationCandidates(Sema &SemaRef,
4074 QualType ClassType,
4075 Expr **Args,
4076 unsigned NumArgs,
Douglas Gregor20093b42009-12-09 23:02:17 +00004077 InitializationKind Kind,
Douglas Gregor19aeac62009-11-14 03:27:21 +00004078 OverloadCandidateSet &CandidateSet) {
4079 // C++ [dcl.init]p14:
4080 // If the initialization is direct-initialization, or if it is
4081 // copy-initialization where the cv-unqualified version of the
4082 // source type is the same class as, or a derived class of, the
4083 // class of the destination, constructors are considered. The
4084 // applicable constructors are enumerated (13.3.1.3), and the
4085 // best one is chosen through overload resolution (13.3). The
4086 // constructor so selected is called to initialize the object,
4087 // with the initializer expression(s) as its argument(s). If no
4088 // constructor applies, or the overload resolution is ambiguous,
4089 // the initialization is ill-formed.
4090 const RecordType *ClassRec = ClassType->getAs<RecordType>();
4091 assert(ClassRec && "Can only initialize a class type here");
4092
4093 // FIXME: When we decide not to synthesize the implicitly-declared
4094 // constructors, we'll need to make them appear here.
4095
4096 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(ClassRec->getDecl());
4097 DeclarationName ConstructorName
4098 = SemaRef.Context.DeclarationNames.getCXXConstructorName(
4099 SemaRef.Context.getCanonicalType(ClassType).getUnqualifiedType());
4100 DeclContext::lookup_const_iterator Con, ConEnd;
4101 for (llvm::tie(Con, ConEnd) = ClassDecl->lookup(ConstructorName);
4102 Con != ConEnd; ++Con) {
4103 // Find the constructor (which may be a template).
4104 CXXConstructorDecl *Constructor = 0;
4105 FunctionTemplateDecl *ConstructorTmpl= dyn_cast<FunctionTemplateDecl>(*Con);
4106 if (ConstructorTmpl)
4107 Constructor
4108 = cast<CXXConstructorDecl>(ConstructorTmpl->getTemplatedDecl());
4109 else
4110 Constructor = cast<CXXConstructorDecl>(*Con);
4111
Douglas Gregor20093b42009-12-09 23:02:17 +00004112 if ((Kind.getKind() == InitializationKind::IK_Direct) ||
4113 (Kind.getKind() == InitializationKind::IK_Value) ||
4114 (Kind.getKind() == InitializationKind::IK_Copy &&
Douglas Gregor19aeac62009-11-14 03:27:21 +00004115 Constructor->isConvertingConstructor(/*AllowExplicit=*/false)) ||
Douglas Gregor20093b42009-12-09 23:02:17 +00004116 ((Kind.getKind() == InitializationKind::IK_Default) &&
4117 Constructor->isDefaultConstructor())) {
Douglas Gregor19aeac62009-11-14 03:27:21 +00004118 if (ConstructorTmpl)
John McCalld5532b62009-11-23 01:53:49 +00004119 SemaRef.AddTemplateOverloadCandidate(ConstructorTmpl,
John McCall86820f52010-01-26 01:37:31 +00004120 ConstructorTmpl->getAccess(),
John McCalld5532b62009-11-23 01:53:49 +00004121 /*ExplicitArgs*/ 0,
Douglas Gregor19aeac62009-11-14 03:27:21 +00004122 Args, NumArgs, CandidateSet);
4123 else
John McCall86820f52010-01-26 01:37:31 +00004124 SemaRef.AddOverloadCandidate(Constructor, Constructor->getAccess(),
4125 Args, NumArgs, CandidateSet);
Douglas Gregor19aeac62009-11-14 03:27:21 +00004126 }
4127 }
4128}
4129
4130/// \brief Attempt to perform initialization by constructor
4131/// (C++ [dcl.init]p14), which may occur as part of direct-initialization or
4132/// copy-initialization.
4133///
4134/// This routine determines whether initialization by constructor is possible,
4135/// but it does not emit any diagnostics in the case where the initialization
4136/// is ill-formed.
4137///
4138/// \param ClassType the type of the object being initialized, which must have
4139/// class type.
4140///
4141/// \param Args the arguments provided to initialize the object
4142///
4143/// \param NumArgs the number of arguments provided to initialize the object
4144///
4145/// \param Kind the type of initialization being performed
4146///
4147/// \returns the constructor used to initialize the object, if successful.
4148/// Otherwise, emits a diagnostic and returns NULL.
4149CXXConstructorDecl *
4150Sema::TryInitializationByConstructor(QualType ClassType,
4151 Expr **Args, unsigned NumArgs,
4152 SourceLocation Loc,
4153 InitializationKind Kind) {
4154 // Build the overload candidate set
4155 OverloadCandidateSet CandidateSet;
4156 AddConstructorInitializationCandidates(*this, ClassType, Args, NumArgs, Kind,
4157 CandidateSet);
4158
4159 // Determine whether we found a constructor we can use.
4160 OverloadCandidateSet::iterator Best;
4161 switch (BestViableFunction(CandidateSet, Loc, Best)) {
4162 case OR_Success:
4163 case OR_Deleted:
4164 // We found a constructor. Return it.
4165 return cast<CXXConstructorDecl>(Best->Function);
4166
4167 case OR_No_Viable_Function:
4168 case OR_Ambiguous:
4169 // Overload resolution failed. Return nothing.
4170 return 0;
4171 }
4172
4173 // Silence GCC warning
4174 return 0;
4175}
4176
Douglas Gregor39da0b82009-09-09 23:08:42 +00004177/// \brief Perform initialization by constructor (C++ [dcl.init]p14), which
4178/// may occur as part of direct-initialization or copy-initialization.
4179///
4180/// \param ClassType the type of the object being initialized, which must have
4181/// class type.
4182///
4183/// \param ArgsPtr the arguments provided to initialize the object
4184///
4185/// \param Loc the source location where the initialization occurs
4186///
4187/// \param Range the source range that covers the entire initialization
4188///
4189/// \param InitEntity the name of the entity being initialized, if known
4190///
4191/// \param Kind the type of initialization being performed
4192///
4193/// \param ConvertedArgs a vector that will be filled in with the
4194/// appropriately-converted arguments to the constructor (if initialization
4195/// succeeded).
4196///
4197/// \returns the constructor used to initialize the object, if successful.
4198/// Otherwise, emits a diagnostic and returns NULL.
Douglas Gregor18fe5682008-11-03 20:45:27 +00004199CXXConstructorDecl *
Douglas Gregorf03d7c72008-11-05 15:29:30 +00004200Sema::PerformInitializationByConstructor(QualType ClassType,
Douglas Gregor39da0b82009-09-09 23:08:42 +00004201 MultiExprArg ArgsPtr,
Douglas Gregorf03d7c72008-11-05 15:29:30 +00004202 SourceLocation Loc, SourceRange Range,
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00004203 DeclarationName InitEntity,
Douglas Gregor39da0b82009-09-09 23:08:42 +00004204 InitializationKind Kind,
4205 ASTOwningVector<&ActionBase::DeleteExpr> &ConvertedArgs) {
Douglas Gregor19aeac62009-11-14 03:27:21 +00004206
4207 // Build the overload candidate set
Douglas Gregor39da0b82009-09-09 23:08:42 +00004208 Expr **Args = (Expr **)ArgsPtr.get();
4209 unsigned NumArgs = ArgsPtr.size();
Douglas Gregor18fe5682008-11-03 20:45:27 +00004210 OverloadCandidateSet CandidateSet;
Douglas Gregor19aeac62009-11-14 03:27:21 +00004211 AddConstructorInitializationCandidates(*this, ClassType, Args, NumArgs, Kind,
4212 CandidateSet);
Douglas Gregor9e7d9de2008-12-15 21:24:18 +00004213
Douglas Gregor18fe5682008-11-03 20:45:27 +00004214 OverloadCandidateSet::iterator Best;
Douglas Gregore0762c92009-06-19 23:52:42 +00004215 switch (BestViableFunction(CandidateSet, Loc, Best)) {
Douglas Gregor18fe5682008-11-03 20:45:27 +00004216 case OR_Success:
Douglas Gregor39da0b82009-09-09 23:08:42 +00004217 // We found a constructor. Break out so that we can convert the arguments
4218 // appropriately.
4219 break;
Mike Stump1eb44332009-09-09 15:08:12 +00004220
Douglas Gregor18fe5682008-11-03 20:45:27 +00004221 case OR_No_Viable_Function:
Douglas Gregor87fd7032009-02-02 17:43:21 +00004222 if (InitEntity)
4223 Diag(Loc, diag::err_ovl_no_viable_function_in_init)
Chris Lattner4330d652009-02-17 07:29:20 +00004224 << InitEntity << Range;
Douglas Gregor87fd7032009-02-02 17:43:21 +00004225 else
4226 Diag(Loc, diag::err_ovl_no_viable_function_in_init)
Chris Lattner4330d652009-02-17 07:29:20 +00004227 << ClassType << Range;
John McCallcbce6062010-01-12 07:18:19 +00004228 PrintOverloadCandidates(CandidateSet, OCD_AllCandidates, Args, NumArgs);
Douglas Gregor18fe5682008-11-03 20:45:27 +00004229 return 0;
Mike Stump1eb44332009-09-09 15:08:12 +00004230
Douglas Gregor18fe5682008-11-03 20:45:27 +00004231 case OR_Ambiguous:
Douglas Gregor87fd7032009-02-02 17:43:21 +00004232 if (InitEntity)
4233 Diag(Loc, diag::err_ovl_ambiguous_init) << InitEntity << Range;
4234 else
4235 Diag(Loc, diag::err_ovl_ambiguous_init) << ClassType << Range;
John McCallcbce6062010-01-12 07:18:19 +00004236 PrintOverloadCandidates(CandidateSet, OCD_ViableCandidates, Args, NumArgs);
Douglas Gregor18fe5682008-11-03 20:45:27 +00004237 return 0;
Douglas Gregor48f3bb92009-02-18 21:56:37 +00004238
4239 case OR_Deleted:
4240 if (InitEntity)
4241 Diag(Loc, diag::err_ovl_deleted_init)
4242 << Best->Function->isDeleted()
4243 << InitEntity << Range;
Fariborz Jahanian6a587cb2009-11-25 21:53:11 +00004244 else {
4245 const CXXRecordDecl *RD =
4246 cast<CXXRecordDecl>(ClassType->getAs<RecordType>()->getDecl());
Douglas Gregor48f3bb92009-02-18 21:56:37 +00004247 Diag(Loc, diag::err_ovl_deleted_init)
4248 << Best->Function->isDeleted()
Fariborz Jahanian6a587cb2009-11-25 21:53:11 +00004249 << RD->getDeclName() << Range;
4250 }
John McCallcbce6062010-01-12 07:18:19 +00004251 PrintOverloadCandidates(CandidateSet, OCD_AllCandidates, Args, NumArgs);
Douglas Gregor48f3bb92009-02-18 21:56:37 +00004252 return 0;
Douglas Gregor18fe5682008-11-03 20:45:27 +00004253 }
Mike Stump1eb44332009-09-09 15:08:12 +00004254
Douglas Gregor39da0b82009-09-09 23:08:42 +00004255 // Convert the arguments, fill in default arguments, etc.
4256 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function);
4257 if (CompleteConstructorCall(Constructor, move(ArgsPtr), Loc, ConvertedArgs))
4258 return 0;
4259
4260 return Constructor;
4261}
4262
4263/// \brief Given a constructor and the set of arguments provided for the
4264/// constructor, convert the arguments and add any required default arguments
4265/// to form a proper call to this constructor.
4266///
4267/// \returns true if an error occurred, false otherwise.
4268bool
4269Sema::CompleteConstructorCall(CXXConstructorDecl *Constructor,
4270 MultiExprArg ArgsPtr,
4271 SourceLocation Loc,
4272 ASTOwningVector<&ActionBase::DeleteExpr> &ConvertedArgs) {
4273 // FIXME: This duplicates a lot of code from Sema::ConvertArgumentsForCall.
4274 unsigned NumArgs = ArgsPtr.size();
4275 Expr **Args = (Expr **)ArgsPtr.get();
4276
4277 const FunctionProtoType *Proto
4278 = Constructor->getType()->getAs<FunctionProtoType>();
4279 assert(Proto && "Constructor without a prototype?");
4280 unsigned NumArgsInProto = Proto->getNumArgs();
Douglas Gregor39da0b82009-09-09 23:08:42 +00004281
4282 // If too few arguments are available, we'll fill in the rest with defaults.
Fariborz Jahanian2fe168f2009-11-24 21:37:28 +00004283 if (NumArgs < NumArgsInProto)
Douglas Gregor39da0b82009-09-09 23:08:42 +00004284 ConvertedArgs.reserve(NumArgsInProto);
Fariborz Jahanian2fe168f2009-11-24 21:37:28 +00004285 else
Douglas Gregor39da0b82009-09-09 23:08:42 +00004286 ConvertedArgs.reserve(NumArgs);
Fariborz Jahanian2fe168f2009-11-24 21:37:28 +00004287
4288 VariadicCallType CallType =
4289 Proto->isVariadic() ? VariadicConstructor : VariadicDoesNotApply;
4290 llvm::SmallVector<Expr *, 8> AllArgs;
4291 bool Invalid = GatherArgumentsForCall(Loc, Constructor,
4292 Proto, 0, Args, NumArgs, AllArgs,
4293 CallType);
4294 for (unsigned i =0, size = AllArgs.size(); i < size; i++)
4295 ConvertedArgs.push_back(AllArgs[i]);
4296 return Invalid;
Douglas Gregor18fe5682008-11-03 20:45:27 +00004297}
4298
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004299/// CompareReferenceRelationship - Compare the two types T1 and T2 to
4300/// determine whether they are reference-related,
4301/// reference-compatible, reference-compatible with added
4302/// qualification, or incompatible, for use in C++ initialization by
4303/// reference (C++ [dcl.ref.init]p4). Neither type can be a reference
4304/// type, and the first type (T1) is the pointee type of the reference
4305/// type being initialized.
Mike Stump1eb44332009-09-09 15:08:12 +00004306Sema::ReferenceCompareResult
Chandler Carruth28e318c2009-12-29 07:16:59 +00004307Sema::CompareReferenceRelationship(SourceLocation Loc,
Douglas Gregor393896f2009-11-05 13:06:35 +00004308 QualType OrigT1, QualType OrigT2,
Douglas Gregor15da57e2008-10-29 02:00:59 +00004309 bool& DerivedToBase) {
Douglas Gregor393896f2009-11-05 13:06:35 +00004310 assert(!OrigT1->isReferenceType() &&
Sebastian Redl7c80bd62009-03-16 23:22:08 +00004311 "T1 must be the pointee type of the reference type");
Douglas Gregor393896f2009-11-05 13:06:35 +00004312 assert(!OrigT2->isReferenceType() && "T2 cannot be a reference type");
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004313
Douglas Gregor393896f2009-11-05 13:06:35 +00004314 QualType T1 = Context.getCanonicalType(OrigT1);
4315 QualType T2 = Context.getCanonicalType(OrigT2);
Chandler Carruth28e318c2009-12-29 07:16:59 +00004316 Qualifiers T1Quals, T2Quals;
4317 QualType UnqualT1 = Context.getUnqualifiedArrayType(T1, T1Quals);
4318 QualType UnqualT2 = Context.getUnqualifiedArrayType(T2, T2Quals);
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004319
4320 // C++ [dcl.init.ref]p4:
Eli Friedman33a31382009-08-05 19:21:58 +00004321 // Given types "cv1 T1" and "cv2 T2," "cv1 T1" is
Mike Stump1eb44332009-09-09 15:08:12 +00004322 // reference-related to "cv2 T2" if T1 is the same type as T2, or
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004323 // T1 is a base class of T2.
Douglas Gregor15da57e2008-10-29 02:00:59 +00004324 if (UnqualT1 == UnqualT2)
4325 DerivedToBase = false;
Douglas Gregor393896f2009-11-05 13:06:35 +00004326 else if (!RequireCompleteType(Loc, OrigT1, PDiag()) &&
4327 !RequireCompleteType(Loc, OrigT2, PDiag()) &&
4328 IsDerivedFrom(UnqualT2, UnqualT1))
Douglas Gregor15da57e2008-10-29 02:00:59 +00004329 DerivedToBase = true;
4330 else
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004331 return Ref_Incompatible;
4332
4333 // At this point, we know that T1 and T2 are reference-related (at
4334 // least).
4335
Chandler Carruth28e318c2009-12-29 07:16:59 +00004336 // If the type is an array type, promote the element qualifiers to the type
4337 // for comparison.
4338 if (isa<ArrayType>(T1) && T1Quals)
4339 T1 = Context.getQualifiedType(UnqualT1, T1Quals);
4340 if (isa<ArrayType>(T2) && T2Quals)
4341 T2 = Context.getQualifiedType(UnqualT2, T2Quals);
4342
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004343 // C++ [dcl.init.ref]p4:
Eli Friedman33a31382009-08-05 19:21:58 +00004344 // "cv1 T1" is reference-compatible with "cv2 T2" if T1 is
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004345 // reference-related to T2 and cv1 is the same cv-qualification
4346 // as, or greater cv-qualification than, cv2. For purposes of
4347 // overload resolution, cases for which cv1 is greater
4348 // cv-qualification than cv2 are identified as
4349 // reference-compatible with added qualification (see 13.3.3.2).
Chandler Carruth28e318c2009-12-29 07:16:59 +00004350 if (T1Quals.getCVRQualifiers() == T2Quals.getCVRQualifiers())
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004351 return Ref_Compatible;
4352 else if (T1.isMoreQualifiedThan(T2))
4353 return Ref_Compatible_With_Added_Qualification;
4354 else
4355 return Ref_Related;
4356}
4357
4358/// CheckReferenceInit - Check the initialization of a reference
4359/// variable with the given initializer (C++ [dcl.init.ref]). Init is
4360/// the initializer (either a simple initializer or an initializer
Douglas Gregor3205a782008-10-29 23:31:03 +00004361/// list), and DeclType is the type of the declaration. When ICS is
4362/// non-null, this routine will compute the implicit conversion
4363/// sequence according to C++ [over.ics.ref] and will not produce any
4364/// diagnostics; when ICS is null, it will emit diagnostics when any
4365/// errors are found. Either way, a return value of true indicates
4366/// that there was a failure, a return value of false indicates that
4367/// the reference initialization succeeded.
Douglas Gregor225c41e2008-11-03 19:09:14 +00004368///
4369/// When @p SuppressUserConversions, user-defined conversions are
4370/// suppressed.
Douglas Gregor09f41cf2009-01-14 15:45:31 +00004371/// When @p AllowExplicit, we also permit explicit user-defined
4372/// conversion functions.
Sebastian Redle2b68332009-04-12 17:16:29 +00004373/// When @p ForceRValue, we unconditionally treat the initializer as an rvalue.
Sebastian Redla82e4ae2009-11-14 21:15:49 +00004374/// When @p IgnoreBaseAccess, we don't do access control on to-base conversion.
4375/// This is used when this is called from a C-style cast.
Mike Stump1eb44332009-09-09 15:08:12 +00004376bool
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004377Sema::CheckReferenceInit(Expr *&Init, QualType DeclType,
Douglas Gregor739d8282009-09-23 23:04:10 +00004378 SourceLocation DeclLoc,
Douglas Gregor09f41cf2009-01-14 15:45:31 +00004379 bool SuppressUserConversions,
Anders Carlsson2de3ace2009-08-27 17:30:43 +00004380 bool AllowExplicit, bool ForceRValue,
Sebastian Redla82e4ae2009-11-14 21:15:49 +00004381 ImplicitConversionSequence *ICS,
4382 bool IgnoreBaseAccess) {
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004383 assert(DeclType->isReferenceType() && "Reference init needs a reference");
4384
Ted Kremenek6217b802009-07-29 21:53:49 +00004385 QualType T1 = DeclType->getAs<ReferenceType>()->getPointeeType();
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004386 QualType T2 = Init->getType();
4387
Douglas Gregor904eed32008-11-10 20:40:00 +00004388 // If the initializer is the address of an overloaded function, try
4389 // to resolve the overloaded function. If all goes well, T2 is the
4390 // type of the resulting function.
Douglas Gregor063daf62009-03-13 18:40:31 +00004391 if (Context.getCanonicalType(T2) == Context.OverloadTy) {
Mike Stump1eb44332009-09-09 15:08:12 +00004392 FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Init, DeclType,
Douglas Gregor904eed32008-11-10 20:40:00 +00004393 ICS != 0);
4394 if (Fn) {
4395 // Since we're performing this reference-initialization for
4396 // real, update the initializer with the resulting function.
Douglas Gregor48f3bb92009-02-18 21:56:37 +00004397 if (!ICS) {
Douglas Gregor739d8282009-09-23 23:04:10 +00004398 if (DiagnoseUseOfDecl(Fn, DeclLoc))
Douglas Gregor20093b42009-12-09 23:02:17 +00004399 return true;
Douglas Gregor48f3bb92009-02-18 21:56:37 +00004400
Anders Carlsson96ad5332009-10-21 17:16:23 +00004401 Init = FixOverloadedFunctionReference(Init, Fn);
Douglas Gregor48f3bb92009-02-18 21:56:37 +00004402 }
Douglas Gregor904eed32008-11-10 20:40:00 +00004403
4404 T2 = Fn->getType();
4405 }
4406 }
4407
Douglas Gregor15da57e2008-10-29 02:00:59 +00004408 // Compute some basic properties of the types and the initializer.
Sebastian Redl7c80bd62009-03-16 23:22:08 +00004409 bool isRValRef = DeclType->isRValueReferenceType();
Douglas Gregor15da57e2008-10-29 02:00:59 +00004410 bool DerivedToBase = false;
Sebastian Redle2b68332009-04-12 17:16:29 +00004411 Expr::isLvalueResult InitLvalue = ForceRValue ? Expr::LV_InvalidExpression :
4412 Init->isLvalue(Context);
Mike Stump1eb44332009-09-09 15:08:12 +00004413 ReferenceCompareResult RefRelationship
Douglas Gregor393896f2009-11-05 13:06:35 +00004414 = CompareReferenceRelationship(DeclLoc, T1, T2, DerivedToBase);
Douglas Gregor15da57e2008-10-29 02:00:59 +00004415
4416 // Most paths end in a failed conversion.
John McCalladbb8f82010-01-13 09:16:55 +00004417 if (ICS) {
4418 ICS->setBad();
4419 ICS->Bad.init(BadConversionSequence::no_conversion, Init, DeclType);
4420 }
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004421
4422 // C++ [dcl.init.ref]p5:
Eli Friedman33a31382009-08-05 19:21:58 +00004423 // A reference to type "cv1 T1" is initialized by an expression
4424 // of type "cv2 T2" as follows:
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004425
4426 // -- If the initializer expression
4427
Sebastian Redla9845802009-03-29 15:27:50 +00004428 // Rvalue references cannot bind to lvalues (N2812).
4429 // There is absolutely no situation where they can. In particular, note that
4430 // this is ill-formed, even if B has a user-defined conversion to A&&:
4431 // B b;
4432 // A&& r = b;
4433 if (isRValRef && InitLvalue == Expr::LV_Valid) {
4434 if (!ICS)
Douglas Gregor739d8282009-09-23 23:04:10 +00004435 Diag(DeclLoc, diag::err_lvalue_to_rvalue_ref)
Sebastian Redla9845802009-03-29 15:27:50 +00004436 << Init->getSourceRange();
4437 return true;
4438 }
4439
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004440 bool BindsDirectly = false;
Eli Friedman33a31382009-08-05 19:21:58 +00004441 // -- is an lvalue (but is not a bit-field), and "cv1 T1" is
4442 // reference-compatible with "cv2 T2," or
Douglas Gregor15da57e2008-10-29 02:00:59 +00004443 //
4444 // Note that the bit-field check is skipped if we are just computing
4445 // the implicit conversion sequence (C++ [over.best.ics]p2).
Douglas Gregor33bbbc52009-05-02 02:18:30 +00004446 if (InitLvalue == Expr::LV_Valid && (ICS || !Init->getBitField()) &&
Douglas Gregor15da57e2008-10-29 02:00:59 +00004447 RefRelationship >= Ref_Compatible_With_Added_Qualification) {
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004448 BindsDirectly = true;
4449
Douglas Gregor15da57e2008-10-29 02:00:59 +00004450 if (ICS) {
4451 // C++ [over.ics.ref]p1:
4452 // When a parameter of reference type binds directly (8.5.3)
4453 // to an argument expression, the implicit conversion sequence
4454 // is the identity conversion, unless the argument expression
4455 // has a type that is a derived class of the parameter type,
4456 // in which case the implicit conversion sequence is a
4457 // derived-to-base Conversion (13.3.3.1).
John McCall1d318332010-01-12 00:44:57 +00004458 ICS->setStandard();
Douglas Gregor15da57e2008-10-29 02:00:59 +00004459 ICS->Standard.First = ICK_Identity;
4460 ICS->Standard.Second = DerivedToBase? ICK_Derived_To_Base : ICK_Identity;
4461 ICS->Standard.Third = ICK_Identity;
4462 ICS->Standard.FromTypePtr = T2.getAsOpaquePtr();
Douglas Gregorad323a82010-01-27 03:51:04 +00004463 ICS->Standard.setToType(0, T2);
4464 ICS->Standard.setToType(1, T1);
4465 ICS->Standard.setToType(2, T1);
Douglas Gregorf70bdb92008-10-29 14:50:44 +00004466 ICS->Standard.ReferenceBinding = true;
4467 ICS->Standard.DirectBinding = true;
Sebastian Redla9845802009-03-29 15:27:50 +00004468 ICS->Standard.RRefBinding = false;
Sebastian Redl76458502009-04-17 16:30:52 +00004469 ICS->Standard.CopyConstructor = 0;
Douglas Gregor15da57e2008-10-29 02:00:59 +00004470
4471 // Nothing more to do: the inaccessibility/ambiguity check for
4472 // derived-to-base conversions is suppressed when we're
4473 // computing the implicit conversion sequence (C++
4474 // [over.best.ics]p2).
4475 return false;
4476 } else {
4477 // Perform the conversion.
Douglas Gregor39da0b82009-09-09 23:08:42 +00004478 CastExpr::CastKind CK = CastExpr::CK_NoOp;
4479 if (DerivedToBase)
4480 CK = CastExpr::CK_DerivedToBase;
Sebastian Redl2c7588f2009-10-10 12:04:10 +00004481 else if(CheckExceptionSpecCompatibility(Init, T1))
4482 return true;
Douglas Gregor39da0b82009-09-09 23:08:42 +00004483 ImpCastExprToType(Init, T1, CK, /*isLvalue=*/true);
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004484 }
4485 }
4486
4487 // -- has a class type (i.e., T2 is a class type) and can be
Eli Friedman33a31382009-08-05 19:21:58 +00004488 // implicitly converted to an lvalue of type "cv3 T3,"
4489 // where "cv1 T1" is reference-compatible with "cv3 T3"
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004490 // 92) (this conversion is selected by enumerating the
4491 // applicable conversion functions (13.3.1.6) and choosing
4492 // the best one through overload resolution (13.3)),
Douglas Gregor5842ba92009-08-24 15:23:48 +00004493 if (!isRValRef && !SuppressUserConversions && T2->isRecordType() &&
Douglas Gregor573d9c32009-10-21 23:19:44 +00004494 !RequireCompleteType(DeclLoc, T2, 0)) {
Mike Stump1eb44332009-09-09 15:08:12 +00004495 CXXRecordDecl *T2RecordDecl
Ted Kremenek6217b802009-07-29 21:53:49 +00004496 = dyn_cast<CXXRecordDecl>(T2->getAs<RecordType>()->getDecl());
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004497
Douglas Gregorcb9b9772008-11-10 16:14:15 +00004498 OverloadCandidateSet CandidateSet;
John McCalleec51cf2010-01-20 00:46:10 +00004499 const UnresolvedSetImpl *Conversions
Fariborz Jahanian51bebc82009-09-23 20:55:32 +00004500 = T2RecordDecl->getVisibleConversionFunctions();
John McCalleec51cf2010-01-20 00:46:10 +00004501 for (UnresolvedSetImpl::iterator I = Conversions->begin(),
John McCallba135432009-11-21 08:51:07 +00004502 E = Conversions->end(); I != E; ++I) {
John McCall701c89e2009-12-03 04:06:58 +00004503 NamedDecl *D = *I;
4504 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
4505 if (isa<UsingShadowDecl>(D))
4506 D = cast<UsingShadowDecl>(D)->getTargetDecl();
4507
Mike Stump1eb44332009-09-09 15:08:12 +00004508 FunctionTemplateDecl *ConvTemplate
John McCall701c89e2009-12-03 04:06:58 +00004509 = dyn_cast<FunctionTemplateDecl>(D);
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00004510 CXXConversionDecl *Conv;
4511 if (ConvTemplate)
4512 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
4513 else
John McCall701c89e2009-12-03 04:06:58 +00004514 Conv = cast<CXXConversionDecl>(D);
Fariborz Jahanian51bebc82009-09-23 20:55:32 +00004515
Douglas Gregorcb9b9772008-11-10 16:14:15 +00004516 // If the conversion function doesn't return a reference type,
4517 // it can't be considered for this conversion.
Sebastian Redl7c80bd62009-03-16 23:22:08 +00004518 if (Conv->getConversionType()->isLValueReferenceType() &&
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00004519 (AllowExplicit || !Conv->isExplicit())) {
4520 if (ConvTemplate)
John McCall86820f52010-01-26 01:37:31 +00004521 AddTemplateConversionCandidate(ConvTemplate, I.getAccess(), ActingDC,
John McCall701c89e2009-12-03 04:06:58 +00004522 Init, DeclType, CandidateSet);
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00004523 else
John McCall86820f52010-01-26 01:37:31 +00004524 AddConversionCandidate(Conv, I.getAccess(), ActingDC, Init,
4525 DeclType, CandidateSet);
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00004526 }
Douglas Gregorcb9b9772008-11-10 16:14:15 +00004527 }
4528
4529 OverloadCandidateSet::iterator Best;
Douglas Gregor739d8282009-09-23 23:04:10 +00004530 switch (BestViableFunction(CandidateSet, DeclLoc, Best)) {
Douglas Gregorcb9b9772008-11-10 16:14:15 +00004531 case OR_Success:
4532 // This is a direct binding.
4533 BindsDirectly = true;
4534
4535 if (ICS) {
4536 // C++ [over.ics.ref]p1:
4537 //
4538 // [...] If the parameter binds directly to the result of
4539 // applying a conversion function to the argument
4540 // expression, the implicit conversion sequence is a
4541 // user-defined conversion sequence (13.3.3.1.2), with the
4542 // second standard conversion sequence either an identity
4543 // conversion or, if the conversion function returns an
4544 // entity of a type that is a derived class of the parameter
4545 // type, a derived-to-base Conversion.
John McCall1d318332010-01-12 00:44:57 +00004546 ICS->setUserDefined();
Douglas Gregorcb9b9772008-11-10 16:14:15 +00004547 ICS->UserDefined.Before = Best->Conversions[0].Standard;
4548 ICS->UserDefined.After = Best->FinalConversion;
4549 ICS->UserDefined.ConversionFunction = Best->Function;
Fariborz Jahanian966256a2009-11-06 00:23:08 +00004550 ICS->UserDefined.EllipsisConversion = false;
Douglas Gregorcb9b9772008-11-10 16:14:15 +00004551 assert(ICS->UserDefined.After.ReferenceBinding &&
4552 ICS->UserDefined.After.DirectBinding &&
4553 "Expected a direct reference binding!");
4554 return false;
4555 } else {
Fariborz Jahanian8f489d62009-09-23 22:34:00 +00004556 OwningExprResult InitConversion =
Douglas Gregor739d8282009-09-23 23:04:10 +00004557 BuildCXXCastArgument(DeclLoc, QualType(),
Fariborz Jahanian8f489d62009-09-23 22:34:00 +00004558 CastExpr::CK_UserDefinedConversion,
4559 cast<CXXMethodDecl>(Best->Function),
4560 Owned(Init));
4561 Init = InitConversion.takeAs<Expr>();
Sebastian Redl2c7588f2009-10-10 12:04:10 +00004562
4563 if (CheckExceptionSpecCompatibility(Init, T1))
4564 return true;
Fariborz Jahanian8f489d62009-09-23 22:34:00 +00004565 ImpCastExprToType(Init, T1, CastExpr::CK_UserDefinedConversion,
4566 /*isLvalue=*/true);
Douglas Gregorcb9b9772008-11-10 16:14:15 +00004567 }
4568 break;
4569
4570 case OR_Ambiguous:
Fariborz Jahaniand9290cb2009-10-14 00:52:43 +00004571 if (ICS) {
John McCall1d318332010-01-12 00:44:57 +00004572 ICS->setAmbiguous();
Fariborz Jahaniand9290cb2009-10-14 00:52:43 +00004573 for (OverloadCandidateSet::iterator Cand = CandidateSet.begin();
4574 Cand != CandidateSet.end(); ++Cand)
4575 if (Cand->Viable)
John McCall1d318332010-01-12 00:44:57 +00004576 ICS->Ambiguous.addConversion(Cand->Function);
Fariborz Jahaniand9290cb2009-10-14 00:52:43 +00004577 break;
4578 }
4579 Diag(DeclLoc, diag::err_ref_init_ambiguous) << DeclType << Init->getType()
4580 << Init->getSourceRange();
John McCallcbce6062010-01-12 07:18:19 +00004581 PrintOverloadCandidates(CandidateSet, OCD_ViableCandidates, &Init, 1);
Douglas Gregorcb9b9772008-11-10 16:14:15 +00004582 return true;
Mike Stump1eb44332009-09-09 15:08:12 +00004583
Douglas Gregorcb9b9772008-11-10 16:14:15 +00004584 case OR_No_Viable_Function:
Douglas Gregor48f3bb92009-02-18 21:56:37 +00004585 case OR_Deleted:
4586 // There was no suitable conversion, or we found a deleted
4587 // conversion; continue with other checks.
Douglas Gregorcb9b9772008-11-10 16:14:15 +00004588 break;
4589 }
4590 }
Mike Stump1eb44332009-09-09 15:08:12 +00004591
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004592 if (BindsDirectly) {
4593 // C++ [dcl.init.ref]p4:
4594 // [...] In all cases where the reference-related or
4595 // reference-compatible relationship of two types is used to
4596 // establish the validity of a reference binding, and T1 is a
4597 // base class of T2, a program that necessitates such a binding
4598 // is ill-formed if T1 is an inaccessible (clause 11) or
4599 // ambiguous (10.2) base class of T2.
4600 //
4601 // Note that we only check this condition when we're allowed to
4602 // complain about errors, because we should not be checking for
4603 // ambiguity (or inaccessibility) unless the reference binding
4604 // actually happens.
Mike Stump1eb44332009-09-09 15:08:12 +00004605 if (DerivedToBase)
Douglas Gregor739d8282009-09-23 23:04:10 +00004606 return CheckDerivedToBaseConversion(T2, T1, DeclLoc,
Sebastian Redla82e4ae2009-11-14 21:15:49 +00004607 Init->getSourceRange(),
4608 IgnoreBaseAccess);
Douglas Gregor15da57e2008-10-29 02:00:59 +00004609 else
4610 return false;
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004611 }
4612
4613 // -- Otherwise, the reference shall be to a non-volatile const
Sebastian Redla9845802009-03-29 15:27:50 +00004614 // type (i.e., cv1 shall be const), or the reference shall be an
4615 // rvalue reference and the initializer expression shall be an rvalue.
John McCall0953e762009-09-24 19:53:00 +00004616 if (!isRValRef && T1.getCVRQualifiers() != Qualifiers::Const) {
Douglas Gregor15da57e2008-10-29 02:00:59 +00004617 if (!ICS)
Douglas Gregor739d8282009-09-23 23:04:10 +00004618 Diag(DeclLoc, diag::err_not_reference_to_const_init)
Douglas Gregor5cc07df2009-12-15 16:44:32 +00004619 << T1 << int(InitLvalue != Expr::LV_Valid)
Chris Lattnerd1625842008-11-24 06:25:27 +00004620 << T2 << Init->getSourceRange();
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004621 return true;
4622 }
4623
4624 // -- If the initializer expression is an rvalue, with T2 a
Eli Friedman33a31382009-08-05 19:21:58 +00004625 // class type, and "cv1 T1" is reference-compatible with
4626 // "cv2 T2," the reference is bound in one of the
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004627 // following ways (the choice is implementation-defined):
4628 //
4629 // -- The reference is bound to the object represented by
4630 // the rvalue (see 3.10) or to a sub-object within that
4631 // object.
4632 //
Eli Friedman33a31382009-08-05 19:21:58 +00004633 // -- A temporary of type "cv1 T2" [sic] is created, and
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004634 // a constructor is called to copy the entire rvalue
4635 // object into the temporary. The reference is bound to
4636 // the temporary or to a sub-object within the
4637 // temporary.
4638 //
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004639 // The constructor that would be used to make the copy
4640 // shall be callable whether or not the copy is actually
4641 // done.
4642 //
Sebastian Redla9845802009-03-29 15:27:50 +00004643 // Note that C++0x [dcl.init.ref]p5 takes away this implementation
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004644 // freedom, so we will always take the first option and never build
4645 // a temporary in this case. FIXME: We will, however, have to check
4646 // for the presence of a copy constructor in C++98/03 mode.
4647 if (InitLvalue != Expr::LV_Valid && T2->isRecordType() &&
Douglas Gregor15da57e2008-10-29 02:00:59 +00004648 RefRelationship >= Ref_Compatible_With_Added_Qualification) {
4649 if (ICS) {
John McCall1d318332010-01-12 00:44:57 +00004650 ICS->setStandard();
Douglas Gregor15da57e2008-10-29 02:00:59 +00004651 ICS->Standard.First = ICK_Identity;
4652 ICS->Standard.Second = DerivedToBase? ICK_Derived_To_Base : ICK_Identity;
4653 ICS->Standard.Third = ICK_Identity;
4654 ICS->Standard.FromTypePtr = T2.getAsOpaquePtr();
Douglas Gregorad323a82010-01-27 03:51:04 +00004655 ICS->Standard.setToType(0, T2);
4656 ICS->Standard.setToType(1, T1);
4657 ICS->Standard.setToType(2, T1);
Douglas Gregorf70bdb92008-10-29 14:50:44 +00004658 ICS->Standard.ReferenceBinding = true;
Sebastian Redla9845802009-03-29 15:27:50 +00004659 ICS->Standard.DirectBinding = false;
4660 ICS->Standard.RRefBinding = isRValRef;
Sebastian Redl76458502009-04-17 16:30:52 +00004661 ICS->Standard.CopyConstructor = 0;
Douglas Gregor15da57e2008-10-29 02:00:59 +00004662 } else {
Douglas Gregor39da0b82009-09-09 23:08:42 +00004663 CastExpr::CastKind CK = CastExpr::CK_NoOp;
4664 if (DerivedToBase)
4665 CK = CastExpr::CK_DerivedToBase;
Sebastian Redl2c7588f2009-10-10 12:04:10 +00004666 else if(CheckExceptionSpecCompatibility(Init, T1))
4667 return true;
Douglas Gregor39da0b82009-09-09 23:08:42 +00004668 ImpCastExprToType(Init, T1, CK, /*isLvalue=*/false);
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004669 }
4670 return false;
4671 }
4672
Eli Friedman33a31382009-08-05 19:21:58 +00004673 // -- Otherwise, a temporary of type "cv1 T1" is created and
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004674 // initialized from the initializer expression using the
4675 // rules for a non-reference copy initialization (8.5). The
4676 // reference is then bound to the temporary. If T1 is
4677 // reference-related to T2, cv1 must be the same
4678 // cv-qualification as, or greater cv-qualification than,
4679 // cv2; otherwise, the program is ill-formed.
4680 if (RefRelationship == Ref_Related) {
4681 // If cv1 == cv2 or cv1 is a greater cv-qualified than cv2, then
4682 // we would be reference-compatible or reference-compatible with
4683 // added qualification. But that wasn't the case, so the reference
4684 // initialization fails.
Douglas Gregor15da57e2008-10-29 02:00:59 +00004685 if (!ICS)
Douglas Gregor739d8282009-09-23 23:04:10 +00004686 Diag(DeclLoc, diag::err_reference_init_drops_quals)
Douglas Gregor5cc07df2009-12-15 16:44:32 +00004687 << T1 << int(InitLvalue != Expr::LV_Valid)
Chris Lattnerd1625842008-11-24 06:25:27 +00004688 << T2 << Init->getSourceRange();
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004689 return true;
4690 }
4691
Douglas Gregor734d9862009-01-30 23:27:23 +00004692 // If at least one of the types is a class type, the types are not
4693 // related, and we aren't allowed any user conversions, the
4694 // reference binding fails. This case is important for breaking
4695 // recursion, since TryImplicitConversion below will attempt to
4696 // create a temporary through the use of a copy constructor.
4697 if (SuppressUserConversions && RefRelationship == Ref_Incompatible &&
4698 (T1->isRecordType() || T2->isRecordType())) {
4699 if (!ICS)
Douglas Gregor739d8282009-09-23 23:04:10 +00004700 Diag(DeclLoc, diag::err_typecheck_convert_incompatible)
Douglas Gregor68647482009-12-16 03:45:30 +00004701 << DeclType << Init->getType() << AA_Initializing << Init->getSourceRange();
Douglas Gregor734d9862009-01-30 23:27:23 +00004702 return true;
4703 }
4704
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004705 // Actually try to convert the initializer to T1.
Douglas Gregor15da57e2008-10-29 02:00:59 +00004706 if (ICS) {
Sebastian Redla9845802009-03-29 15:27:50 +00004707 // C++ [over.ics.ref]p2:
Mike Stump1eb44332009-09-09 15:08:12 +00004708 //
Sebastian Redla9845802009-03-29 15:27:50 +00004709 // When a parameter of reference type is not bound directly to
4710 // an argument expression, the conversion sequence is the one
4711 // required to convert the argument expression to the
4712 // underlying type of the reference according to
4713 // 13.3.3.1. Conceptually, this conversion sequence corresponds
4714 // to copy-initializing a temporary of the underlying type with
4715 // the argument expression. Any difference in top-level
4716 // cv-qualification is subsumed by the initialization itself
4717 // and does not constitute a conversion.
Anders Carlssonda7a18b2009-08-27 17:24:15 +00004718 *ICS = TryImplicitConversion(Init, T1, SuppressUserConversions,
4719 /*AllowExplicit=*/false,
Anders Carlsson08972922009-08-28 15:33:32 +00004720 /*ForceRValue=*/false,
4721 /*InOverloadResolution=*/false);
Mike Stump1eb44332009-09-09 15:08:12 +00004722
Sebastian Redla9845802009-03-29 15:27:50 +00004723 // Of course, that's still a reference binding.
John McCall1d318332010-01-12 00:44:57 +00004724 if (ICS->isStandard()) {
Sebastian Redla9845802009-03-29 15:27:50 +00004725 ICS->Standard.ReferenceBinding = true;
4726 ICS->Standard.RRefBinding = isRValRef;
John McCall1d318332010-01-12 00:44:57 +00004727 } else if (ICS->isUserDefined()) {
Sebastian Redla9845802009-03-29 15:27:50 +00004728 ICS->UserDefined.After.ReferenceBinding = true;
4729 ICS->UserDefined.After.RRefBinding = isRValRef;
4730 }
John McCall1d318332010-01-12 00:44:57 +00004731 return ICS->isBad();
Douglas Gregor15da57e2008-10-29 02:00:59 +00004732 } else {
Fariborz Jahanian51bebc82009-09-23 20:55:32 +00004733 ImplicitConversionSequence Conversions;
Douglas Gregor68647482009-12-16 03:45:30 +00004734 bool badConversion = PerformImplicitConversion(Init, T1, AA_Initializing,
Fariborz Jahanian51bebc82009-09-23 20:55:32 +00004735 false, false,
4736 Conversions);
4737 if (badConversion) {
John McCall1d318332010-01-12 00:44:57 +00004738 if (Conversions.isAmbiguous()) {
Fariborz Jahanian7ad2d562009-09-24 00:42:43 +00004739 Diag(DeclLoc,
Fariborz Jahanian51bebc82009-09-23 20:55:32 +00004740 diag::err_lvalue_to_rvalue_ambig_ref) << Init->getSourceRange();
John McCall1d318332010-01-12 00:44:57 +00004741 for (int j = Conversions.Ambiguous.conversions().size()-1;
Fariborz Jahanian51bebc82009-09-23 20:55:32 +00004742 j >= 0; j--) {
John McCall1d318332010-01-12 00:44:57 +00004743 FunctionDecl *Func = Conversions.Ambiguous.conversions()[j];
John McCallb1622a12010-01-06 09:43:14 +00004744 NoteOverloadCandidate(Func);
Fariborz Jahanian51bebc82009-09-23 20:55:32 +00004745 }
4746 }
Fariborz Jahanian893f9552009-09-30 21:23:30 +00004747 else {
4748 if (isRValRef)
4749 Diag(DeclLoc, diag::err_lvalue_to_rvalue_ref)
4750 << Init->getSourceRange();
4751 else
4752 Diag(DeclLoc, diag::err_invalid_initialization)
4753 << DeclType << Init->getType() << Init->getSourceRange();
4754 }
Fariborz Jahanian51bebc82009-09-23 20:55:32 +00004755 }
4756 return badConversion;
Douglas Gregor15da57e2008-10-29 02:00:59 +00004757 }
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004758}
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004759
Anders Carlsson20d45d22009-12-12 00:32:00 +00004760static inline bool
4761CheckOperatorNewDeleteDeclarationScope(Sema &SemaRef,
4762 const FunctionDecl *FnDecl) {
4763 const DeclContext *DC = FnDecl->getDeclContext()->getLookupContext();
4764 if (isa<NamespaceDecl>(DC)) {
4765 return SemaRef.Diag(FnDecl->getLocation(),
4766 diag::err_operator_new_delete_declared_in_namespace)
4767 << FnDecl->getDeclName();
4768 }
4769
4770 if (isa<TranslationUnitDecl>(DC) &&
4771 FnDecl->getStorageClass() == FunctionDecl::Static) {
4772 return SemaRef.Diag(FnDecl->getLocation(),
4773 diag::err_operator_new_delete_declared_static)
4774 << FnDecl->getDeclName();
4775 }
4776
Anders Carlssonfcfdb2b2009-12-12 02:43:16 +00004777 return false;
Anders Carlsson20d45d22009-12-12 00:32:00 +00004778}
4779
Anders Carlsson156c78e2009-12-13 17:53:43 +00004780static inline bool
4781CheckOperatorNewDeleteTypes(Sema &SemaRef, const FunctionDecl *FnDecl,
4782 CanQualType ExpectedResultType,
4783 CanQualType ExpectedFirstParamType,
4784 unsigned DependentParamTypeDiag,
4785 unsigned InvalidParamTypeDiag) {
4786 QualType ResultType =
4787 FnDecl->getType()->getAs<FunctionType>()->getResultType();
4788
4789 // Check that the result type is not dependent.
4790 if (ResultType->isDependentType())
4791 return SemaRef.Diag(FnDecl->getLocation(),
4792 diag::err_operator_new_delete_dependent_result_type)
4793 << FnDecl->getDeclName() << ExpectedResultType;
4794
4795 // Check that the result type is what we expect.
4796 if (SemaRef.Context.getCanonicalType(ResultType) != ExpectedResultType)
4797 return SemaRef.Diag(FnDecl->getLocation(),
4798 diag::err_operator_new_delete_invalid_result_type)
4799 << FnDecl->getDeclName() << ExpectedResultType;
4800
4801 // A function template must have at least 2 parameters.
4802 if (FnDecl->getDescribedFunctionTemplate() && FnDecl->getNumParams() < 2)
4803 return SemaRef.Diag(FnDecl->getLocation(),
4804 diag::err_operator_new_delete_template_too_few_parameters)
4805 << FnDecl->getDeclName();
4806
4807 // The function decl must have at least 1 parameter.
4808 if (FnDecl->getNumParams() == 0)
4809 return SemaRef.Diag(FnDecl->getLocation(),
4810 diag::err_operator_new_delete_too_few_parameters)
4811 << FnDecl->getDeclName();
4812
4813 // Check the the first parameter type is not dependent.
4814 QualType FirstParamType = FnDecl->getParamDecl(0)->getType();
4815 if (FirstParamType->isDependentType())
4816 return SemaRef.Diag(FnDecl->getLocation(), DependentParamTypeDiag)
4817 << FnDecl->getDeclName() << ExpectedFirstParamType;
4818
4819 // Check that the first parameter type is what we expect.
Douglas Gregor6e790ab2009-12-22 23:42:49 +00004820 if (SemaRef.Context.getCanonicalType(FirstParamType).getUnqualifiedType() !=
Anders Carlsson156c78e2009-12-13 17:53:43 +00004821 ExpectedFirstParamType)
4822 return SemaRef.Diag(FnDecl->getLocation(), InvalidParamTypeDiag)
4823 << FnDecl->getDeclName() << ExpectedFirstParamType;
4824
4825 return false;
4826}
4827
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00004828static bool
Anders Carlsson156c78e2009-12-13 17:53:43 +00004829CheckOperatorNewDeclaration(Sema &SemaRef, const FunctionDecl *FnDecl) {
Anders Carlsson20d45d22009-12-12 00:32:00 +00004830 // C++ [basic.stc.dynamic.allocation]p1:
4831 // A program is ill-formed if an allocation function is declared in a
4832 // namespace scope other than global scope or declared static in global
4833 // scope.
4834 if (CheckOperatorNewDeleteDeclarationScope(SemaRef, FnDecl))
4835 return true;
Anders Carlsson156c78e2009-12-13 17:53:43 +00004836
4837 CanQualType SizeTy =
4838 SemaRef.Context.getCanonicalType(SemaRef.Context.getSizeType());
4839
4840 // C++ [basic.stc.dynamic.allocation]p1:
4841 // The return type shall be void*. The first parameter shall have type
4842 // std::size_t.
4843 if (CheckOperatorNewDeleteTypes(SemaRef, FnDecl, SemaRef.Context.VoidPtrTy,
4844 SizeTy,
4845 diag::err_operator_new_dependent_param_type,
4846 diag::err_operator_new_param_type))
4847 return true;
4848
4849 // C++ [basic.stc.dynamic.allocation]p1:
4850 // The first parameter shall not have an associated default argument.
4851 if (FnDecl->getParamDecl(0)->hasDefaultArg())
Anders Carlssona3ccda52009-12-12 00:26:23 +00004852 return SemaRef.Diag(FnDecl->getLocation(),
Anders Carlsson156c78e2009-12-13 17:53:43 +00004853 diag::err_operator_new_default_arg)
4854 << FnDecl->getDeclName() << FnDecl->getParamDecl(0)->getDefaultArgRange();
4855
4856 return false;
Anders Carlssona3ccda52009-12-12 00:26:23 +00004857}
4858
4859static bool
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00004860CheckOperatorDeleteDeclaration(Sema &SemaRef, const FunctionDecl *FnDecl) {
4861 // C++ [basic.stc.dynamic.deallocation]p1:
4862 // A program is ill-formed if deallocation functions are declared in a
4863 // namespace scope other than global scope or declared static in global
4864 // scope.
Anders Carlsson20d45d22009-12-12 00:32:00 +00004865 if (CheckOperatorNewDeleteDeclarationScope(SemaRef, FnDecl))
4866 return true;
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00004867
4868 // C++ [basic.stc.dynamic.deallocation]p2:
4869 // Each deallocation function shall return void and its first parameter
4870 // shall be void*.
Anders Carlsson156c78e2009-12-13 17:53:43 +00004871 if (CheckOperatorNewDeleteTypes(SemaRef, FnDecl, SemaRef.Context.VoidTy,
4872 SemaRef.Context.VoidPtrTy,
4873 diag::err_operator_delete_dependent_param_type,
4874 diag::err_operator_delete_param_type))
4875 return true;
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00004876
Anders Carlsson46991d62009-12-12 00:16:02 +00004877 QualType FirstParamType = FnDecl->getParamDecl(0)->getType();
4878 if (FirstParamType->isDependentType())
4879 return SemaRef.Diag(FnDecl->getLocation(),
4880 diag::err_operator_delete_dependent_param_type)
4881 << FnDecl->getDeclName() << SemaRef.Context.VoidPtrTy;
4882
4883 if (SemaRef.Context.getCanonicalType(FirstParamType) !=
4884 SemaRef.Context.VoidPtrTy)
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00004885 return SemaRef.Diag(FnDecl->getLocation(),
4886 diag::err_operator_delete_param_type)
4887 << FnDecl->getDeclName() << SemaRef.Context.VoidPtrTy;
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00004888
4889 return false;
4890}
4891
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004892/// CheckOverloadedOperatorDeclaration - Check whether the declaration
4893/// of this overloaded operator is well-formed. If so, returns false;
4894/// otherwise, emits appropriate diagnostics and returns true.
4895bool Sema::CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl) {
Douglas Gregor43c7bad2008-11-17 16:14:12 +00004896 assert(FnDecl && FnDecl->isOverloadedOperator() &&
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004897 "Expected an overloaded operator declaration");
4898
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004899 OverloadedOperatorKind Op = FnDecl->getOverloadedOperator();
4900
Mike Stump1eb44332009-09-09 15:08:12 +00004901 // C++ [over.oper]p5:
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004902 // The allocation and deallocation functions, operator new,
4903 // operator new[], operator delete and operator delete[], are
4904 // described completely in 3.7.3. The attributes and restrictions
4905 // found in the rest of this subclause do not apply to them unless
4906 // explicitly stated in 3.7.3.
Anders Carlsson1152c392009-12-11 23:31:21 +00004907 if (Op == OO_Delete || Op == OO_Array_Delete)
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00004908 return CheckOperatorDeleteDeclaration(*this, FnDecl);
Fariborz Jahanianb03bfa52009-11-10 23:47:18 +00004909
Anders Carlssona3ccda52009-12-12 00:26:23 +00004910 if (Op == OO_New || Op == OO_Array_New)
4911 return CheckOperatorNewDeclaration(*this, FnDecl);
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004912
4913 // C++ [over.oper]p6:
4914 // An operator function shall either be a non-static member
4915 // function or be a non-member function and have at least one
4916 // parameter whose type is a class, a reference to a class, an
4917 // enumeration, or a reference to an enumeration.
Douglas Gregor43c7bad2008-11-17 16:14:12 +00004918 if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) {
4919 if (MethodDecl->isStatic())
4920 return Diag(FnDecl->getLocation(),
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00004921 diag::err_operator_overload_static) << FnDecl->getDeclName();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004922 } else {
4923 bool ClassOrEnumParam = false;
Douglas Gregor43c7bad2008-11-17 16:14:12 +00004924 for (FunctionDecl::param_iterator Param = FnDecl->param_begin(),
4925 ParamEnd = FnDecl->param_end();
4926 Param != ParamEnd; ++Param) {
4927 QualType ParamType = (*Param)->getType().getNonReferenceType();
Eli Friedman5d39dee2009-06-27 05:59:59 +00004928 if (ParamType->isDependentType() || ParamType->isRecordType() ||
4929 ParamType->isEnumeralType()) {
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004930 ClassOrEnumParam = true;
4931 break;
4932 }
4933 }
4934
Douglas Gregor43c7bad2008-11-17 16:14:12 +00004935 if (!ClassOrEnumParam)
4936 return Diag(FnDecl->getLocation(),
Chris Lattnerf3a41af2008-11-20 06:38:18 +00004937 diag::err_operator_overload_needs_class_or_enum)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00004938 << FnDecl->getDeclName();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004939 }
4940
4941 // C++ [over.oper]p8:
4942 // An operator function cannot have default arguments (8.3.6),
4943 // except where explicitly stated below.
4944 //
Mike Stump1eb44332009-09-09 15:08:12 +00004945 // Only the function-call operator allows default arguments
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004946 // (C++ [over.call]p1).
4947 if (Op != OO_Call) {
4948 for (FunctionDecl::param_iterator Param = FnDecl->param_begin();
4949 Param != FnDecl->param_end(); ++Param) {
Anders Carlsson156c78e2009-12-13 17:53:43 +00004950 if ((*Param)->hasDefaultArg())
Mike Stump1eb44332009-09-09 15:08:12 +00004951 return Diag((*Param)->getLocation(),
Douglas Gregor61366e92008-12-24 00:01:03 +00004952 diag::err_operator_overload_default_arg)
Anders Carlsson156c78e2009-12-13 17:53:43 +00004953 << FnDecl->getDeclName() << (*Param)->getDefaultArgRange();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004954 }
4955 }
4956
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00004957 static const bool OperatorUses[NUM_OVERLOADED_OPERATORS][3] = {
4958 { false, false, false }
4959#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
4960 , { Unary, Binary, MemberOnly }
4961#include "clang/Basic/OperatorKinds.def"
4962 };
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004963
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00004964 bool CanBeUnaryOperator = OperatorUses[Op][0];
4965 bool CanBeBinaryOperator = OperatorUses[Op][1];
4966 bool MustBeMemberOperator = OperatorUses[Op][2];
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004967
4968 // C++ [over.oper]p8:
4969 // [...] Operator functions cannot have more or fewer parameters
4970 // than the number required for the corresponding operator, as
4971 // described in the rest of this subclause.
Mike Stump1eb44332009-09-09 15:08:12 +00004972 unsigned NumParams = FnDecl->getNumParams()
Douglas Gregor43c7bad2008-11-17 16:14:12 +00004973 + (isa<CXXMethodDecl>(FnDecl)? 1 : 0);
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004974 if (Op != OO_Call &&
4975 ((NumParams == 1 && !CanBeUnaryOperator) ||
4976 (NumParams == 2 && !CanBeBinaryOperator) ||
4977 (NumParams < 1) || (NumParams > 2))) {
4978 // We have the wrong number of parameters.
Chris Lattner416e46f2008-11-21 07:57:12 +00004979 unsigned ErrorKind;
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00004980 if (CanBeUnaryOperator && CanBeBinaryOperator) {
Chris Lattner416e46f2008-11-21 07:57:12 +00004981 ErrorKind = 2; // 2 -> unary or binary.
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00004982 } else if (CanBeUnaryOperator) {
Chris Lattner416e46f2008-11-21 07:57:12 +00004983 ErrorKind = 0; // 0 -> unary
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00004984 } else {
Chris Lattneraf7ae4e2008-11-21 07:50:02 +00004985 assert(CanBeBinaryOperator &&
4986 "All non-call overloaded operators are unary or binary!");
Chris Lattner416e46f2008-11-21 07:57:12 +00004987 ErrorKind = 1; // 1 -> binary
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00004988 }
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004989
Chris Lattner416e46f2008-11-21 07:57:12 +00004990 return Diag(FnDecl->getLocation(), diag::err_operator_overload_must_be)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00004991 << FnDecl->getDeclName() << NumParams << ErrorKind;
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004992 }
Sebastian Redl64b45f72009-01-05 20:52:13 +00004993
Douglas Gregor43c7bad2008-11-17 16:14:12 +00004994 // Overloaded operators other than operator() cannot be variadic.
4995 if (Op != OO_Call &&
John McCall183700f2009-09-21 23:43:11 +00004996 FnDecl->getType()->getAs<FunctionProtoType>()->isVariadic()) {
Chris Lattnerf3a41af2008-11-20 06:38:18 +00004997 return Diag(FnDecl->getLocation(), diag::err_operator_overload_variadic)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00004998 << FnDecl->getDeclName();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004999 }
5000
5001 // Some operators must be non-static member functions.
Douglas Gregor43c7bad2008-11-17 16:14:12 +00005002 if (MustBeMemberOperator && !isa<CXXMethodDecl>(FnDecl)) {
5003 return Diag(FnDecl->getLocation(),
Chris Lattnerf3a41af2008-11-20 06:38:18 +00005004 diag::err_operator_overload_must_be_member)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00005005 << FnDecl->getDeclName();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00005006 }
5007
5008 // C++ [over.inc]p1:
5009 // The user-defined function called operator++ implements the
5010 // prefix and postfix ++ operator. If this function is a member
5011 // function with no parameters, or a non-member function with one
5012 // parameter of class or enumeration type, it defines the prefix
5013 // increment operator ++ for objects of that type. If the function
5014 // is a member function with one parameter (which shall be of type
5015 // int) or a non-member function with two parameters (the second
5016 // of which shall be of type int), it defines the postfix
5017 // increment operator ++ for objects of that type.
5018 if ((Op == OO_PlusPlus || Op == OO_MinusMinus) && NumParams == 2) {
5019 ParmVarDecl *LastParam = FnDecl->getParamDecl(FnDecl->getNumParams() - 1);
5020 bool ParamIsInt = false;
John McCall183700f2009-09-21 23:43:11 +00005021 if (const BuiltinType *BT = LastParam->getType()->getAs<BuiltinType>())
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00005022 ParamIsInt = BT->getKind() == BuiltinType::Int;
5023
Chris Lattneraf7ae4e2008-11-21 07:50:02 +00005024 if (!ParamIsInt)
5025 return Diag(LastParam->getLocation(),
Mike Stump1eb44332009-09-09 15:08:12 +00005026 diag::err_operator_overload_post_incdec_must_be_int)
Chris Lattnerd1625842008-11-24 06:25:27 +00005027 << LastParam->getType() << (Op == OO_MinusMinus);
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00005028 }
5029
Sebastian Redl64b45f72009-01-05 20:52:13 +00005030 // Notify the class if it got an assignment operator.
5031 if (Op == OO_Equal) {
5032 // Would have returned earlier otherwise.
5033 assert(isa<CXXMethodDecl>(FnDecl) &&
5034 "Overloaded = not member, but not filtered.");
5035 CXXMethodDecl *Method = cast<CXXMethodDecl>(FnDecl);
5036 Method->getParent()->addedAssignmentOperator(Context, Method);
5037 }
5038
Douglas Gregor43c7bad2008-11-17 16:14:12 +00005039 return false;
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00005040}
Chris Lattner5a003a42008-12-17 07:09:26 +00005041
Sean Hunta6c058d2010-01-13 09:01:02 +00005042/// CheckLiteralOperatorDeclaration - Check whether the declaration
5043/// of this literal operator function is well-formed. If so, returns
5044/// false; otherwise, emits appropriate diagnostics and returns true.
5045bool Sema::CheckLiteralOperatorDeclaration(FunctionDecl *FnDecl) {
5046 DeclContext *DC = FnDecl->getDeclContext();
5047 Decl::Kind Kind = DC->getDeclKind();
5048 if (Kind != Decl::TranslationUnit && Kind != Decl::Namespace &&
5049 Kind != Decl::LinkageSpec) {
5050 Diag(FnDecl->getLocation(), diag::err_literal_operator_outside_namespace)
5051 << FnDecl->getDeclName();
5052 return true;
5053 }
5054
5055 bool Valid = false;
5056
5057 // FIXME: Check for the one valid template signature
5058 // template <char...> type operator "" name();
5059
5060 if (FunctionDecl::param_iterator Param = FnDecl->param_begin()) {
5061 // Check the first parameter
5062 QualType T = (*Param)->getType();
5063
5064 // unsigned long long int and long double are allowed, but only
5065 // alone.
5066 // We also allow any character type; their omission seems to be a bug
5067 // in n3000
5068 if (Context.hasSameType(T, Context.UnsignedLongLongTy) ||
5069 Context.hasSameType(T, Context.LongDoubleTy) ||
5070 Context.hasSameType(T, Context.CharTy) ||
5071 Context.hasSameType(T, Context.WCharTy) ||
5072 Context.hasSameType(T, Context.Char16Ty) ||
5073 Context.hasSameType(T, Context.Char32Ty)) {
5074 if (++Param == FnDecl->param_end())
5075 Valid = true;
5076 goto FinishedParams;
5077 }
5078
5079 // Otherwise it must be a pointer to const; let's strip those.
5080 const PointerType *PT = T->getAs<PointerType>();
5081 if (!PT)
5082 goto FinishedParams;
5083 T = PT->getPointeeType();
5084 if (!T.isConstQualified())
5085 goto FinishedParams;
5086 T = T.getUnqualifiedType();
5087
5088 // Move on to the second parameter;
5089 ++Param;
5090
5091 // If there is no second parameter, the first must be a const char *
5092 if (Param == FnDecl->param_end()) {
5093 if (Context.hasSameType(T, Context.CharTy))
5094 Valid = true;
5095 goto FinishedParams;
5096 }
5097
5098 // const char *, const wchar_t*, const char16_t*, and const char32_t*
5099 // are allowed as the first parameter to a two-parameter function
5100 if (!(Context.hasSameType(T, Context.CharTy) ||
5101 Context.hasSameType(T, Context.WCharTy) ||
5102 Context.hasSameType(T, Context.Char16Ty) ||
5103 Context.hasSameType(T, Context.Char32Ty)))
5104 goto FinishedParams;
5105
5106 // The second and final parameter must be an std::size_t
5107 T = (*Param)->getType().getUnqualifiedType();
5108 if (Context.hasSameType(T, Context.getSizeType()) &&
5109 ++Param == FnDecl->param_end())
5110 Valid = true;
5111 }
5112
5113 // FIXME: This diagnostic is absolutely terrible.
5114FinishedParams:
5115 if (!Valid) {
5116 Diag(FnDecl->getLocation(), diag::err_literal_operator_params)
5117 << FnDecl->getDeclName();
5118 return true;
5119 }
5120
5121 return false;
5122}
5123
Douglas Gregor074149e2009-01-05 19:45:36 +00005124/// ActOnStartLinkageSpecification - Parsed the beginning of a C++
5125/// linkage specification, including the language and (if present)
5126/// the '{'. ExternLoc is the location of the 'extern', LangLoc is
5127/// the location of the language string literal, which is provided
5128/// by Lang/StrSize. LBraceLoc, if valid, provides the location of
5129/// the '{' brace. Otherwise, this linkage specification does not
5130/// have any braces.
Chris Lattnerb28317a2009-03-28 19:18:32 +00005131Sema::DeclPtrTy Sema::ActOnStartLinkageSpecification(Scope *S,
5132 SourceLocation ExternLoc,
5133 SourceLocation LangLoc,
5134 const char *Lang,
5135 unsigned StrSize,
5136 SourceLocation LBraceLoc) {
Chris Lattnercc98eac2008-12-17 07:13:27 +00005137 LinkageSpecDecl::LanguageIDs Language;
5138 if (strncmp(Lang, "\"C\"", StrSize) == 0)
5139 Language = LinkageSpecDecl::lang_c;
5140 else if (strncmp(Lang, "\"C++\"", StrSize) == 0)
5141 Language = LinkageSpecDecl::lang_cxx;
5142 else {
Douglas Gregor074149e2009-01-05 19:45:36 +00005143 Diag(LangLoc, diag::err_bad_language);
Chris Lattnerb28317a2009-03-28 19:18:32 +00005144 return DeclPtrTy();
Chris Lattnercc98eac2008-12-17 07:13:27 +00005145 }
Mike Stump1eb44332009-09-09 15:08:12 +00005146
Chris Lattnercc98eac2008-12-17 07:13:27 +00005147 // FIXME: Add all the various semantics of linkage specifications
Mike Stump1eb44332009-09-09 15:08:12 +00005148
Douglas Gregor074149e2009-01-05 19:45:36 +00005149 LinkageSpecDecl *D = LinkageSpecDecl::Create(Context, CurContext,
Mike Stump1eb44332009-09-09 15:08:12 +00005150 LangLoc, Language,
Douglas Gregor074149e2009-01-05 19:45:36 +00005151 LBraceLoc.isValid());
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00005152 CurContext->addDecl(D);
Douglas Gregor074149e2009-01-05 19:45:36 +00005153 PushDeclContext(S, D);
Chris Lattnerb28317a2009-03-28 19:18:32 +00005154 return DeclPtrTy::make(D);
Chris Lattnercc98eac2008-12-17 07:13:27 +00005155}
5156
Douglas Gregor074149e2009-01-05 19:45:36 +00005157/// ActOnFinishLinkageSpecification - Completely the definition of
5158/// the C++ linkage specification LinkageSpec. If RBraceLoc is
5159/// valid, it's the position of the closing '}' brace in a linkage
5160/// specification that uses braces.
Chris Lattnerb28317a2009-03-28 19:18:32 +00005161Sema::DeclPtrTy Sema::ActOnFinishLinkageSpecification(Scope *S,
5162 DeclPtrTy LinkageSpec,
5163 SourceLocation RBraceLoc) {
Douglas Gregor074149e2009-01-05 19:45:36 +00005164 if (LinkageSpec)
5165 PopDeclContext();
5166 return LinkageSpec;
Chris Lattner5a003a42008-12-17 07:09:26 +00005167}
5168
Douglas Gregord308e622009-05-18 20:51:54 +00005169/// \brief Perform semantic analysis for the variable declaration that
5170/// occurs within a C++ catch clause, returning the newly-created
5171/// variable.
5172VarDecl *Sema::BuildExceptionDeclaration(Scope *S, QualType ExDeclType,
John McCalla93c9342009-12-07 02:54:59 +00005173 TypeSourceInfo *TInfo,
Douglas Gregord308e622009-05-18 20:51:54 +00005174 IdentifierInfo *Name,
5175 SourceLocation Loc,
5176 SourceRange Range) {
5177 bool Invalid = false;
Sebastian Redl4b07b292008-12-22 19:15:10 +00005178
5179 // Arrays and functions decay.
5180 if (ExDeclType->isArrayType())
5181 ExDeclType = Context.getArrayDecayedType(ExDeclType);
5182 else if (ExDeclType->isFunctionType())
5183 ExDeclType = Context.getPointerType(ExDeclType);
5184
5185 // C++ 15.3p1: The exception-declaration shall not denote an incomplete type.
5186 // The exception-declaration shall not denote a pointer or reference to an
5187 // incomplete type, other than [cv] void*.
Sebastian Redlf2e21e52009-03-22 23:49:27 +00005188 // N2844 forbids rvalue references.
Mike Stump1eb44332009-09-09 15:08:12 +00005189 if (!ExDeclType->isDependentType() && ExDeclType->isRValueReferenceType()) {
Douglas Gregord308e622009-05-18 20:51:54 +00005190 Diag(Loc, diag::err_catch_rvalue_ref) << Range;
Sebastian Redlf2e21e52009-03-22 23:49:27 +00005191 Invalid = true;
5192 }
Douglas Gregord308e622009-05-18 20:51:54 +00005193
Sebastian Redl4b07b292008-12-22 19:15:10 +00005194 QualType BaseType = ExDeclType;
5195 int Mode = 0; // 0 for direct type, 1 for pointer, 2 for reference
Douglas Gregor4ec339f2009-01-19 19:26:10 +00005196 unsigned DK = diag::err_catch_incomplete;
Ted Kremenek6217b802009-07-29 21:53:49 +00005197 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) {
Sebastian Redl4b07b292008-12-22 19:15:10 +00005198 BaseType = Ptr->getPointeeType();
5199 Mode = 1;
Douglas Gregor4ec339f2009-01-19 19:26:10 +00005200 DK = diag::err_catch_incomplete_ptr;
Mike Stump1eb44332009-09-09 15:08:12 +00005201 } else if (const ReferenceType *Ref = BaseType->getAs<ReferenceType>()) {
Sebastian Redlf2e21e52009-03-22 23:49:27 +00005202 // For the purpose of error recovery, we treat rvalue refs like lvalue refs.
Sebastian Redl4b07b292008-12-22 19:15:10 +00005203 BaseType = Ref->getPointeeType();
5204 Mode = 2;
Douglas Gregor4ec339f2009-01-19 19:26:10 +00005205 DK = diag::err_catch_incomplete_ref;
Sebastian Redl4b07b292008-12-22 19:15:10 +00005206 }
Sebastian Redlf2e21e52009-03-22 23:49:27 +00005207 if (!Invalid && (Mode == 0 || !BaseType->isVoidType()) &&
Douglas Gregord308e622009-05-18 20:51:54 +00005208 !BaseType->isDependentType() && RequireCompleteType(Loc, BaseType, DK))
Sebastian Redl4b07b292008-12-22 19:15:10 +00005209 Invalid = true;
Sebastian Redl4b07b292008-12-22 19:15:10 +00005210
Mike Stump1eb44332009-09-09 15:08:12 +00005211 if (!Invalid && !ExDeclType->isDependentType() &&
Douglas Gregord308e622009-05-18 20:51:54 +00005212 RequireNonAbstractType(Loc, ExDeclType,
5213 diag::err_abstract_type_in_decl,
5214 AbstractVariableType))
Sebastian Redlfef9f592009-04-27 21:03:30 +00005215 Invalid = true;
5216
Douglas Gregord308e622009-05-18 20:51:54 +00005217 // FIXME: Need to test for ability to copy-construct and destroy the
5218 // exception variable.
5219
Sebastian Redl8351da02008-12-22 21:35:02 +00005220 // FIXME: Need to check for abstract classes.
5221
Mike Stump1eb44332009-09-09 15:08:12 +00005222 VarDecl *ExDecl = VarDecl::Create(Context, CurContext, Loc,
John McCalla93c9342009-12-07 02:54:59 +00005223 Name, ExDeclType, TInfo, VarDecl::None);
Douglas Gregord308e622009-05-18 20:51:54 +00005224
5225 if (Invalid)
5226 ExDecl->setInvalidDecl();
5227
5228 return ExDecl;
5229}
5230
5231/// ActOnExceptionDeclarator - Parsed the exception-declarator in a C++ catch
5232/// handler.
5233Sema::DeclPtrTy Sema::ActOnExceptionDeclarator(Scope *S, Declarator &D) {
John McCalla93c9342009-12-07 02:54:59 +00005234 TypeSourceInfo *TInfo = 0;
5235 QualType ExDeclType = GetTypeForDeclarator(D, S, &TInfo);
Douglas Gregord308e622009-05-18 20:51:54 +00005236
5237 bool Invalid = D.isInvalidType();
Sebastian Redl4b07b292008-12-22 19:15:10 +00005238 IdentifierInfo *II = D.getIdentifier();
John McCallf36e02d2009-10-09 21:13:30 +00005239 if (NamedDecl *PrevDecl = LookupSingleName(S, II, LookupOrdinaryName)) {
Sebastian Redl4b07b292008-12-22 19:15:10 +00005240 // The scope should be freshly made just for us. There is just no way
5241 // it contains any previous declaration.
Chris Lattnerb28317a2009-03-28 19:18:32 +00005242 assert(!S->isDeclScope(DeclPtrTy::make(PrevDecl)));
Sebastian Redl4b07b292008-12-22 19:15:10 +00005243 if (PrevDecl->isTemplateParameter()) {
5244 // Maybe we will complain about the shadowed template parameter.
5245 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
Sebastian Redl4b07b292008-12-22 19:15:10 +00005246 }
5247 }
5248
Chris Lattnereaaebc72009-04-25 08:06:05 +00005249 if (D.getCXXScopeSpec().isSet() && !Invalid) {
Sebastian Redl4b07b292008-12-22 19:15:10 +00005250 Diag(D.getIdentifierLoc(), diag::err_qualified_catch_declarator)
5251 << D.getCXXScopeSpec().getRange();
Chris Lattnereaaebc72009-04-25 08:06:05 +00005252 Invalid = true;
Sebastian Redl4b07b292008-12-22 19:15:10 +00005253 }
5254
John McCalla93c9342009-12-07 02:54:59 +00005255 VarDecl *ExDecl = BuildExceptionDeclaration(S, ExDeclType, TInfo,
Douglas Gregord308e622009-05-18 20:51:54 +00005256 D.getIdentifier(),
5257 D.getIdentifierLoc(),
5258 D.getDeclSpec().getSourceRange());
5259
Chris Lattnereaaebc72009-04-25 08:06:05 +00005260 if (Invalid)
5261 ExDecl->setInvalidDecl();
Mike Stump1eb44332009-09-09 15:08:12 +00005262
Sebastian Redl4b07b292008-12-22 19:15:10 +00005263 // Add the exception declaration into this scope.
Sebastian Redl4b07b292008-12-22 19:15:10 +00005264 if (II)
Douglas Gregord308e622009-05-18 20:51:54 +00005265 PushOnScopeChains(ExDecl, S);
5266 else
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00005267 CurContext->addDecl(ExDecl);
Sebastian Redl4b07b292008-12-22 19:15:10 +00005268
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00005269 ProcessDeclAttributes(S, ExDecl, D);
Chris Lattnerb28317a2009-03-28 19:18:32 +00005270 return DeclPtrTy::make(ExDecl);
Sebastian Redl4b07b292008-12-22 19:15:10 +00005271}
Anders Carlssonfb311762009-03-14 00:25:26 +00005272
Mike Stump1eb44332009-09-09 15:08:12 +00005273Sema::DeclPtrTy Sema::ActOnStaticAssertDeclaration(SourceLocation AssertLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00005274 ExprArg assertexpr,
5275 ExprArg assertmessageexpr) {
Anders Carlssonfb311762009-03-14 00:25:26 +00005276 Expr *AssertExpr = (Expr *)assertexpr.get();
Mike Stump1eb44332009-09-09 15:08:12 +00005277 StringLiteral *AssertMessage =
Anders Carlssonfb311762009-03-14 00:25:26 +00005278 cast<StringLiteral>((Expr *)assertmessageexpr.get());
5279
Anders Carlssonc3082412009-03-14 00:33:21 +00005280 if (!AssertExpr->isTypeDependent() && !AssertExpr->isValueDependent()) {
5281 llvm::APSInt Value(32);
5282 if (!AssertExpr->isIntegerConstantExpr(Value, Context)) {
5283 Diag(AssertLoc, diag::err_static_assert_expression_is_not_constant) <<
5284 AssertExpr->getSourceRange();
Chris Lattnerb28317a2009-03-28 19:18:32 +00005285 return DeclPtrTy();
Anders Carlssonc3082412009-03-14 00:33:21 +00005286 }
Anders Carlssonfb311762009-03-14 00:25:26 +00005287
Anders Carlssonc3082412009-03-14 00:33:21 +00005288 if (Value == 0) {
Mike Stump1eb44332009-09-09 15:08:12 +00005289 Diag(AssertLoc, diag::err_static_assert_failed)
Benjamin Kramer8d042582009-12-11 13:33:18 +00005290 << AssertMessage->getString() << AssertExpr->getSourceRange();
Anders Carlssonc3082412009-03-14 00:33:21 +00005291 }
5292 }
Mike Stump1eb44332009-09-09 15:08:12 +00005293
Anders Carlsson77d81422009-03-15 17:35:16 +00005294 assertexpr.release();
5295 assertmessageexpr.release();
Mike Stump1eb44332009-09-09 15:08:12 +00005296 Decl *Decl = StaticAssertDecl::Create(Context, CurContext, AssertLoc,
Anders Carlssonfb311762009-03-14 00:25:26 +00005297 AssertExpr, AssertMessage);
Mike Stump1eb44332009-09-09 15:08:12 +00005298
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00005299 CurContext->addDecl(Decl);
Chris Lattnerb28317a2009-03-28 19:18:32 +00005300 return DeclPtrTy::make(Decl);
Anders Carlssonfb311762009-03-14 00:25:26 +00005301}
Sebastian Redl50de12f2009-03-24 22:27:57 +00005302
John McCalldd4a3b02009-09-16 22:47:08 +00005303/// Handle a friend type declaration. This works in tandem with
5304/// ActOnTag.
5305///
5306/// Notes on friend class templates:
5307///
5308/// We generally treat friend class declarations as if they were
5309/// declaring a class. So, for example, the elaborated type specifier
5310/// in a friend declaration is required to obey the restrictions of a
5311/// class-head (i.e. no typedefs in the scope chain), template
5312/// parameters are required to match up with simple template-ids, &c.
5313/// However, unlike when declaring a template specialization, it's
5314/// okay to refer to a template specialization without an empty
5315/// template parameter declaration, e.g.
5316/// friend class A<T>::B<unsigned>;
5317/// We permit this as a special case; if there are any template
5318/// parameters present at all, require proper matching, i.e.
5319/// template <> template <class T> friend class A<int>::B;
Chris Lattnerc7f19042009-10-25 17:47:27 +00005320Sema::DeclPtrTy Sema::ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS,
John McCalldd4a3b02009-09-16 22:47:08 +00005321 MultiTemplateParamsArg TempParams) {
John McCall02cace72009-08-28 07:59:38 +00005322 SourceLocation Loc = DS.getSourceRange().getBegin();
John McCall67d1a672009-08-06 02:15:43 +00005323
5324 assert(DS.isFriendSpecified());
5325 assert(DS.getStorageClassSpec() == DeclSpec::SCS_unspecified);
5326
John McCalldd4a3b02009-09-16 22:47:08 +00005327 // Try to convert the decl specifier to a type. This works for
5328 // friend templates because ActOnTag never produces a ClassTemplateDecl
5329 // for a TUK_Friend.
Chris Lattnerc7f19042009-10-25 17:47:27 +00005330 Declarator TheDeclarator(DS, Declarator::MemberContext);
Chris Lattnerc7f19042009-10-25 17:47:27 +00005331 QualType T = GetTypeForDeclarator(TheDeclarator, S);
5332 if (TheDeclarator.isInvalidType())
5333 return DeclPtrTy();
John McCall67d1a672009-08-06 02:15:43 +00005334
John McCalldd4a3b02009-09-16 22:47:08 +00005335 // This is definitely an error in C++98. It's probably meant to
5336 // be forbidden in C++0x, too, but the specification is just
5337 // poorly written.
5338 //
5339 // The problem is with declarations like the following:
5340 // template <T> friend A<T>::foo;
5341 // where deciding whether a class C is a friend or not now hinges
5342 // on whether there exists an instantiation of A that causes
5343 // 'foo' to equal C. There are restrictions on class-heads
5344 // (which we declare (by fiat) elaborated friend declarations to
5345 // be) that makes this tractable.
5346 //
5347 // FIXME: handle "template <> friend class A<T>;", which
5348 // is possibly well-formed? Who even knows?
5349 if (TempParams.size() && !isa<ElaboratedType>(T)) {
5350 Diag(Loc, diag::err_tagless_friend_type_template)
5351 << DS.getSourceRange();
5352 return DeclPtrTy();
5353 }
5354
John McCall02cace72009-08-28 07:59:38 +00005355 // C++ [class.friend]p2:
5356 // An elaborated-type-specifier shall be used in a friend declaration
5357 // for a class.*
5358 // * The class-key of the elaborated-type-specifier is required.
John McCall6b2becf2009-09-08 17:47:29 +00005359 // This is one of the rare places in Clang where it's legitimate to
5360 // ask about the "spelling" of the type.
5361 if (!getLangOptions().CPlusPlus0x && !isa<ElaboratedType>(T)) {
5362 // If we evaluated the type to a record type, suggest putting
5363 // a tag in front.
John McCall02cace72009-08-28 07:59:38 +00005364 if (const RecordType *RT = T->getAs<RecordType>()) {
John McCall6b2becf2009-09-08 17:47:29 +00005365 RecordDecl *RD = RT->getDecl();
5366
5367 std::string InsertionText = std::string(" ") + RD->getKindName();
5368
John McCalle3af0232009-10-07 23:34:25 +00005369 Diag(DS.getTypeSpecTypeLoc(), diag::err_unelaborated_friend_type)
5370 << (unsigned) RD->getTagKind()
5371 << T
5372 << SourceRange(DS.getFriendSpecLoc())
John McCall6b2becf2009-09-08 17:47:29 +00005373 << CodeModificationHint::CreateInsertion(DS.getTypeSpecTypeLoc(),
5374 InsertionText);
John McCall02cace72009-08-28 07:59:38 +00005375 return DeclPtrTy();
5376 }else {
John McCall6b2becf2009-09-08 17:47:29 +00005377 Diag(DS.getFriendSpecLoc(), diag::err_unexpected_friend)
5378 << DS.getSourceRange();
Mike Stump1eb44332009-09-09 15:08:12 +00005379 return DeclPtrTy();
John McCall02cace72009-08-28 07:59:38 +00005380 }
5381 }
5382
John McCalle3af0232009-10-07 23:34:25 +00005383 // Enum types cannot be friends.
5384 if (T->getAs<EnumType>()) {
5385 Diag(DS.getTypeSpecTypeLoc(), diag::err_enum_friend)
5386 << SourceRange(DS.getFriendSpecLoc());
5387 return DeclPtrTy();
John McCall6b2becf2009-09-08 17:47:29 +00005388 }
John McCall02cace72009-08-28 07:59:38 +00005389
John McCall02cace72009-08-28 07:59:38 +00005390 // C++98 [class.friend]p1: A friend of a class is a function
5391 // or class that is not a member of the class . . .
John McCalla236a552009-12-22 00:59:39 +00005392 // This is fixed in DR77, which just barely didn't make the C++03
5393 // deadline. It's also a very silly restriction that seriously
5394 // affects inner classes and which nobody else seems to implement;
5395 // thus we never diagnose it, not even in -pedantic.
John McCall02cace72009-08-28 07:59:38 +00005396
John McCalldd4a3b02009-09-16 22:47:08 +00005397 Decl *D;
5398 if (TempParams.size())
5399 D = FriendTemplateDecl::Create(Context, CurContext, Loc,
5400 TempParams.size(),
5401 (TemplateParameterList**) TempParams.release(),
5402 T.getTypePtr(),
5403 DS.getFriendSpecLoc());
5404 else
5405 D = FriendDecl::Create(Context, CurContext, Loc, T.getTypePtr(),
5406 DS.getFriendSpecLoc());
5407 D->setAccess(AS_public);
5408 CurContext->addDecl(D);
John McCall02cace72009-08-28 07:59:38 +00005409
John McCalldd4a3b02009-09-16 22:47:08 +00005410 return DeclPtrTy::make(D);
John McCall02cace72009-08-28 07:59:38 +00005411}
5412
John McCallbbbcdd92009-09-11 21:02:39 +00005413Sema::DeclPtrTy
5414Sema::ActOnFriendFunctionDecl(Scope *S,
5415 Declarator &D,
5416 bool IsDefinition,
5417 MultiTemplateParamsArg TemplateParams) {
John McCall02cace72009-08-28 07:59:38 +00005418 const DeclSpec &DS = D.getDeclSpec();
5419
5420 assert(DS.isFriendSpecified());
5421 assert(DS.getStorageClassSpec() == DeclSpec::SCS_unspecified);
5422
5423 SourceLocation Loc = D.getIdentifierLoc();
John McCalla93c9342009-12-07 02:54:59 +00005424 TypeSourceInfo *TInfo = 0;
5425 QualType T = GetTypeForDeclarator(D, S, &TInfo);
John McCall67d1a672009-08-06 02:15:43 +00005426
5427 // C++ [class.friend]p1
5428 // A friend of a class is a function or class....
5429 // Note that this sees through typedefs, which is intended.
John McCall02cace72009-08-28 07:59:38 +00005430 // It *doesn't* see through dependent types, which is correct
5431 // according to [temp.arg.type]p3:
5432 // If a declaration acquires a function type through a
5433 // type dependent on a template-parameter and this causes
5434 // a declaration that does not use the syntactic form of a
5435 // function declarator to have a function type, the program
5436 // is ill-formed.
John McCall67d1a672009-08-06 02:15:43 +00005437 if (!T->isFunctionType()) {
5438 Diag(Loc, diag::err_unexpected_friend);
5439
5440 // It might be worthwhile to try to recover by creating an
5441 // appropriate declaration.
5442 return DeclPtrTy();
5443 }
5444
5445 // C++ [namespace.memdef]p3
5446 // - If a friend declaration in a non-local class first declares a
5447 // class or function, the friend class or function is a member
5448 // of the innermost enclosing namespace.
5449 // - The name of the friend is not found by simple name lookup
5450 // until a matching declaration is provided in that namespace
5451 // scope (either before or after the class declaration granting
5452 // friendship).
5453 // - If a friend function is called, its name may be found by the
5454 // name lookup that considers functions from namespaces and
5455 // classes associated with the types of the function arguments.
5456 // - When looking for a prior declaration of a class or a function
5457 // declared as a friend, scopes outside the innermost enclosing
5458 // namespace scope are not considered.
5459
John McCall02cace72009-08-28 07:59:38 +00005460 CXXScopeSpec &ScopeQual = D.getCXXScopeSpec();
5461 DeclarationName Name = GetNameForDeclarator(D);
John McCall67d1a672009-08-06 02:15:43 +00005462 assert(Name);
5463
John McCall67d1a672009-08-06 02:15:43 +00005464 // The context we found the declaration in, or in which we should
5465 // create the declaration.
5466 DeclContext *DC;
5467
5468 // FIXME: handle local classes
5469
5470 // Recover from invalid scope qualifiers as if they just weren't there.
John McCall68263142009-11-18 22:49:29 +00005471 LookupResult Previous(*this, Name, D.getIdentifierLoc(), LookupOrdinaryName,
5472 ForRedeclaration);
John McCall67d1a672009-08-06 02:15:43 +00005473 if (!ScopeQual.isInvalid() && ScopeQual.isSet()) {
Douglas Gregora735b202009-10-13 14:39:41 +00005474 // FIXME: RequireCompleteDeclContext
John McCall67d1a672009-08-06 02:15:43 +00005475 DC = computeDeclContext(ScopeQual);
5476
5477 // FIXME: handle dependent contexts
5478 if (!DC) return DeclPtrTy();
5479
John McCall68263142009-11-18 22:49:29 +00005480 LookupQualifiedName(Previous, DC);
John McCall67d1a672009-08-06 02:15:43 +00005481
5482 // If searching in that context implicitly found a declaration in
5483 // a different context, treat it like it wasn't found at all.
5484 // TODO: better diagnostics for this case. Suggesting the right
5485 // qualified scope would be nice...
John McCall68263142009-11-18 22:49:29 +00005486 // FIXME: getRepresentativeDecl() is not right here at all
5487 if (Previous.empty() ||
5488 !Previous.getRepresentativeDecl()->getDeclContext()->Equals(DC)) {
John McCall02cace72009-08-28 07:59:38 +00005489 D.setInvalidType();
John McCall67d1a672009-08-06 02:15:43 +00005490 Diag(Loc, diag::err_qualified_friend_not_found) << Name << T;
5491 return DeclPtrTy();
5492 }
5493
5494 // C++ [class.friend]p1: A friend of a class is a function or
5495 // class that is not a member of the class . . .
Douglas Gregor182ddf02009-09-28 00:08:27 +00005496 if (DC->Equals(CurContext))
John McCall67d1a672009-08-06 02:15:43 +00005497 Diag(DS.getFriendSpecLoc(), diag::err_friend_is_member);
5498
John McCall67d1a672009-08-06 02:15:43 +00005499 // Otherwise walk out to the nearest namespace scope looking for matches.
5500 } else {
5501 // TODO: handle local class contexts.
5502
5503 DC = CurContext;
5504 while (true) {
5505 // Skip class contexts. If someone can cite chapter and verse
5506 // for this behavior, that would be nice --- it's what GCC and
5507 // EDG do, and it seems like a reasonable intent, but the spec
5508 // really only says that checks for unqualified existing
5509 // declarations should stop at the nearest enclosing namespace,
5510 // not that they should only consider the nearest enclosing
5511 // namespace.
Douglas Gregor182ddf02009-09-28 00:08:27 +00005512 while (DC->isRecord())
5513 DC = DC->getParent();
John McCall67d1a672009-08-06 02:15:43 +00005514
John McCall68263142009-11-18 22:49:29 +00005515 LookupQualifiedName(Previous, DC);
John McCall67d1a672009-08-06 02:15:43 +00005516
5517 // TODO: decide what we think about using declarations.
John McCall68263142009-11-18 22:49:29 +00005518 if (!Previous.empty())
John McCall67d1a672009-08-06 02:15:43 +00005519 break;
Douglas Gregor182ddf02009-09-28 00:08:27 +00005520
John McCall67d1a672009-08-06 02:15:43 +00005521 if (DC->isFileContext()) break;
5522 DC = DC->getParent();
5523 }
5524
5525 // C++ [class.friend]p1: A friend of a class is a function or
5526 // class that is not a member of the class . . .
John McCall7f27d922009-08-06 20:49:32 +00005527 // C++0x changes this for both friend types and functions.
5528 // Most C++ 98 compilers do seem to give an error here, so
5529 // we do, too.
John McCall68263142009-11-18 22:49:29 +00005530 if (!Previous.empty() && DC->Equals(CurContext)
5531 && !getLangOptions().CPlusPlus0x)
John McCall67d1a672009-08-06 02:15:43 +00005532 Diag(DS.getFriendSpecLoc(), diag::err_friend_is_member);
5533 }
5534
Douglas Gregor182ddf02009-09-28 00:08:27 +00005535 if (DC->isFileContext()) {
John McCall67d1a672009-08-06 02:15:43 +00005536 // This implies that it has to be an operator or function.
Douglas Gregor3f9a0562009-11-03 01:35:08 +00005537 if (D.getName().getKind() == UnqualifiedId::IK_ConstructorName ||
5538 D.getName().getKind() == UnqualifiedId::IK_DestructorName ||
5539 D.getName().getKind() == UnqualifiedId::IK_ConversionFunctionId) {
John McCall67d1a672009-08-06 02:15:43 +00005540 Diag(Loc, diag::err_introducing_special_friend) <<
Douglas Gregor3f9a0562009-11-03 01:35:08 +00005541 (D.getName().getKind() == UnqualifiedId::IK_ConstructorName ? 0 :
5542 D.getName().getKind() == UnqualifiedId::IK_DestructorName ? 1 : 2);
John McCall67d1a672009-08-06 02:15:43 +00005543 return DeclPtrTy();
5544 }
John McCall67d1a672009-08-06 02:15:43 +00005545 }
5546
Douglas Gregor182ddf02009-09-28 00:08:27 +00005547 bool Redeclaration = false;
John McCalla93c9342009-12-07 02:54:59 +00005548 NamedDecl *ND = ActOnFunctionDeclarator(S, D, DC, T, TInfo, Previous,
Douglas Gregora735b202009-10-13 14:39:41 +00005549 move(TemplateParams),
John McCall3f9a8a62009-08-11 06:59:38 +00005550 IsDefinition,
5551 Redeclaration);
John McCall02cace72009-08-28 07:59:38 +00005552 if (!ND) return DeclPtrTy();
John McCallab88d972009-08-31 22:39:49 +00005553
Douglas Gregor182ddf02009-09-28 00:08:27 +00005554 assert(ND->getDeclContext() == DC);
5555 assert(ND->getLexicalDeclContext() == CurContext);
John McCall88232aa2009-08-18 00:00:49 +00005556
John McCallab88d972009-08-31 22:39:49 +00005557 // Add the function declaration to the appropriate lookup tables,
5558 // adjusting the redeclarations list as necessary. We don't
5559 // want to do this yet if the friending class is dependent.
Mike Stump1eb44332009-09-09 15:08:12 +00005560 //
John McCallab88d972009-08-31 22:39:49 +00005561 // Also update the scope-based lookup if the target context's
5562 // lookup context is in lexical scope.
5563 if (!CurContext->isDependentContext()) {
5564 DC = DC->getLookupContext();
Douglas Gregor182ddf02009-09-28 00:08:27 +00005565 DC->makeDeclVisibleInContext(ND, /* Recoverable=*/ false);
John McCallab88d972009-08-31 22:39:49 +00005566 if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
Douglas Gregor182ddf02009-09-28 00:08:27 +00005567 PushOnScopeChains(ND, EnclosingScope, /*AddToContext=*/ false);
John McCallab88d972009-08-31 22:39:49 +00005568 }
John McCall02cace72009-08-28 07:59:38 +00005569
5570 FriendDecl *FrD = FriendDecl::Create(Context, CurContext,
Douglas Gregor182ddf02009-09-28 00:08:27 +00005571 D.getIdentifierLoc(), ND,
John McCall02cace72009-08-28 07:59:38 +00005572 DS.getFriendSpecLoc());
John McCall5fee1102009-08-29 03:50:18 +00005573 FrD->setAccess(AS_public);
John McCall02cace72009-08-28 07:59:38 +00005574 CurContext->addDecl(FrD);
John McCall67d1a672009-08-06 02:15:43 +00005575
Douglas Gregor7557a132009-12-24 20:56:24 +00005576 if (D.getName().getKind() == UnqualifiedId::IK_TemplateId)
5577 FrD->setSpecialization(true);
5578
Douglas Gregor182ddf02009-09-28 00:08:27 +00005579 return DeclPtrTy::make(ND);
Anders Carlsson00338362009-05-11 22:55:49 +00005580}
5581
Chris Lattnerb28317a2009-03-28 19:18:32 +00005582void Sema::SetDeclDeleted(DeclPtrTy dcl, SourceLocation DelLoc) {
Douglas Gregorefd5bda2009-08-24 11:57:43 +00005583 AdjustDeclIfTemplate(dcl);
Mike Stump1eb44332009-09-09 15:08:12 +00005584
Chris Lattnerb28317a2009-03-28 19:18:32 +00005585 Decl *Dcl = dcl.getAs<Decl>();
Sebastian Redl50de12f2009-03-24 22:27:57 +00005586 FunctionDecl *Fn = dyn_cast<FunctionDecl>(Dcl);
5587 if (!Fn) {
5588 Diag(DelLoc, diag::err_deleted_non_function);
5589 return;
5590 }
5591 if (const FunctionDecl *Prev = Fn->getPreviousDeclaration()) {
5592 Diag(DelLoc, diag::err_deleted_decl_not_first);
5593 Diag(Prev->getLocation(), diag::note_previous_declaration);
5594 // If the declaration wasn't the first, we delete the function anyway for
5595 // recovery.
5596 }
5597 Fn->setDeleted();
5598}
Sebastian Redl13e88542009-04-27 21:33:24 +00005599
5600static void SearchForReturnInStmt(Sema &Self, Stmt *S) {
5601 for (Stmt::child_iterator CI = S->child_begin(), E = S->child_end(); CI != E;
5602 ++CI) {
5603 Stmt *SubStmt = *CI;
5604 if (!SubStmt)
5605 continue;
5606 if (isa<ReturnStmt>(SubStmt))
5607 Self.Diag(SubStmt->getSourceRange().getBegin(),
5608 diag::err_return_in_constructor_handler);
5609 if (!isa<Expr>(SubStmt))
5610 SearchForReturnInStmt(Self, SubStmt);
5611 }
5612}
5613
5614void Sema::DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock) {
5615 for (unsigned I = 0, E = TryBlock->getNumHandlers(); I != E; ++I) {
5616 CXXCatchStmt *Handler = TryBlock->getHandler(I);
5617 SearchForReturnInStmt(*this, Handler);
5618 }
5619}
Anders Carlssond7ba27d2009-05-14 01:09:04 +00005620
Mike Stump1eb44332009-09-09 15:08:12 +00005621bool Sema::CheckOverridingFunctionReturnType(const CXXMethodDecl *New,
Anders Carlssond7ba27d2009-05-14 01:09:04 +00005622 const CXXMethodDecl *Old) {
John McCall183700f2009-09-21 23:43:11 +00005623 QualType NewTy = New->getType()->getAs<FunctionType>()->getResultType();
5624 QualType OldTy = Old->getType()->getAs<FunctionType>()->getResultType();
Anders Carlssond7ba27d2009-05-14 01:09:04 +00005625
Anders Carlssonf2a04bf2010-01-22 17:37:20 +00005626 if (Context.hasSameType(NewTy, OldTy))
Anders Carlssond7ba27d2009-05-14 01:09:04 +00005627 return false;
Mike Stump1eb44332009-09-09 15:08:12 +00005628
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005629 // Check if the return types are covariant
5630 QualType NewClassTy, OldClassTy;
Mike Stump1eb44332009-09-09 15:08:12 +00005631
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005632 /// Both types must be pointers or references to classes.
Anders Carlssonf2a04bf2010-01-22 17:37:20 +00005633 if (const PointerType *NewPT = NewTy->getAs<PointerType>()) {
5634 if (const PointerType *OldPT = OldTy->getAs<PointerType>()) {
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005635 NewClassTy = NewPT->getPointeeType();
5636 OldClassTy = OldPT->getPointeeType();
5637 }
Anders Carlssonf2a04bf2010-01-22 17:37:20 +00005638 } else if (const ReferenceType *NewRT = NewTy->getAs<ReferenceType>()) {
5639 if (const ReferenceType *OldRT = OldTy->getAs<ReferenceType>()) {
5640 if (NewRT->getTypeClass() == OldRT->getTypeClass()) {
5641 NewClassTy = NewRT->getPointeeType();
5642 OldClassTy = OldRT->getPointeeType();
5643 }
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005644 }
5645 }
Mike Stump1eb44332009-09-09 15:08:12 +00005646
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005647 // The return types aren't either both pointers or references to a class type.
5648 if (NewClassTy.isNull()) {
Mike Stump1eb44332009-09-09 15:08:12 +00005649 Diag(New->getLocation(),
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005650 diag::err_different_return_type_for_overriding_virtual_function)
5651 << New->getDeclName() << NewTy << OldTy;
5652 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
Mike Stump1eb44332009-09-09 15:08:12 +00005653
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005654 return true;
5655 }
Anders Carlssond7ba27d2009-05-14 01:09:04 +00005656
Anders Carlssonbe2e2052009-12-31 18:34:24 +00005657 // C++ [class.virtual]p6:
5658 // If the return type of D::f differs from the return type of B::f, the
5659 // class type in the return type of D::f shall be complete at the point of
5660 // declaration of D::f or shall be the class type D.
Anders Carlssonac4c9392009-12-31 18:54:35 +00005661 if (const RecordType *RT = NewClassTy->getAs<RecordType>()) {
5662 if (!RT->isBeingDefined() &&
5663 RequireCompleteType(New->getLocation(), NewClassTy,
5664 PDiag(diag::err_covariant_return_incomplete)
5665 << New->getDeclName()))
Anders Carlssonbe2e2052009-12-31 18:34:24 +00005666 return true;
Anders Carlssonac4c9392009-12-31 18:54:35 +00005667 }
Anders Carlssonbe2e2052009-12-31 18:34:24 +00005668
Douglas Gregora4923eb2009-11-16 21:35:15 +00005669 if (!Context.hasSameUnqualifiedType(NewClassTy, OldClassTy)) {
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005670 // Check if the new class derives from the old class.
5671 if (!IsDerivedFrom(NewClassTy, OldClassTy)) {
5672 Diag(New->getLocation(),
5673 diag::err_covariant_return_not_derived)
5674 << New->getDeclName() << NewTy << OldTy;
5675 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
5676 return true;
5677 }
Mike Stump1eb44332009-09-09 15:08:12 +00005678
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005679 // Check if we the conversion from derived to base is valid.
Mike Stump1eb44332009-09-09 15:08:12 +00005680 if (CheckDerivedToBaseConversion(NewClassTy, OldClassTy,
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005681 diag::err_covariant_return_inaccessible_base,
5682 diag::err_covariant_return_ambiguous_derived_to_base_conv,
5683 // FIXME: Should this point to the return type?
5684 New->getLocation(), SourceRange(), New->getDeclName())) {
5685 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
5686 return true;
5687 }
5688 }
Mike Stump1eb44332009-09-09 15:08:12 +00005689
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005690 // The qualifiers of the return types must be the same.
Anders Carlssonf2a04bf2010-01-22 17:37:20 +00005691 if (NewTy.getLocalCVRQualifiers() != OldTy.getLocalCVRQualifiers()) {
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005692 Diag(New->getLocation(),
5693 diag::err_covariant_return_type_different_qualifications)
Anders Carlssond7ba27d2009-05-14 01:09:04 +00005694 << New->getDeclName() << NewTy << OldTy;
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005695 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
5696 return true;
5697 };
Mike Stump1eb44332009-09-09 15:08:12 +00005698
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005699
5700 // The new class type must have the same or less qualifiers as the old type.
5701 if (NewClassTy.isMoreQualifiedThan(OldClassTy)) {
5702 Diag(New->getLocation(),
5703 diag::err_covariant_return_type_class_type_more_qualified)
5704 << New->getDeclName() << NewTy << OldTy;
5705 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
5706 return true;
5707 };
Mike Stump1eb44332009-09-09 15:08:12 +00005708
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005709 return false;
Anders Carlssond7ba27d2009-05-14 01:09:04 +00005710}
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00005711
Sean Huntbbd37c62009-11-21 08:43:09 +00005712bool Sema::CheckOverridingFunctionAttributes(const CXXMethodDecl *New,
5713 const CXXMethodDecl *Old)
5714{
5715 if (Old->hasAttr<FinalAttr>()) {
5716 Diag(New->getLocation(), diag::err_final_function_overridden)
5717 << New->getDeclName();
5718 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
5719 return true;
5720 }
5721
5722 return false;
5723}
5724
Douglas Gregor4ba31362009-12-01 17:24:26 +00005725/// \brief Mark the given method pure.
5726///
5727/// \param Method the method to be marked pure.
5728///
5729/// \param InitRange the source range that covers the "0" initializer.
5730bool Sema::CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange) {
5731 if (Method->isVirtual() || Method->getParent()->isDependentContext()) {
5732 Method->setPure();
5733
5734 // A class is abstract if at least one function is pure virtual.
5735 Method->getParent()->setAbstract(true);
5736 return false;
5737 }
5738
5739 if (!Method->isInvalidDecl())
5740 Diag(Method->getLocation(), diag::err_non_virtual_pure)
5741 << Method->getDeclName() << InitRange;
5742 return true;
5743}
5744
John McCall731ad842009-12-19 09:28:58 +00005745/// ActOnCXXEnterDeclInitializer - Invoked when we are about to parse
5746/// an initializer for the out-of-line declaration 'Dcl'. The scope
5747/// is a fresh scope pushed for just this purpose.
5748///
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00005749/// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
5750/// static data member of class X, names should be looked up in the scope of
5751/// class X.
5752void Sema::ActOnCXXEnterDeclInitializer(Scope *S, DeclPtrTy Dcl) {
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00005753 // If there is no declaration, there was an error parsing it.
John McCall731ad842009-12-19 09:28:58 +00005754 Decl *D = Dcl.getAs<Decl>();
5755 if (D == 0) return;
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00005756
John McCall731ad842009-12-19 09:28:58 +00005757 // We should only get called for declarations with scope specifiers, like:
5758 // int foo::bar;
5759 assert(D->isOutOfLine());
John McCall7a1dc562009-12-19 10:49:29 +00005760 EnterDeclaratorContext(S, D->getDeclContext());
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00005761}
5762
5763/// ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an
John McCall731ad842009-12-19 09:28:58 +00005764/// initializer for the out-of-line declaration 'Dcl'.
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00005765void Sema::ActOnCXXExitDeclInitializer(Scope *S, DeclPtrTy Dcl) {
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00005766 // If there is no declaration, there was an error parsing it.
John McCall731ad842009-12-19 09:28:58 +00005767 Decl *D = Dcl.getAs<Decl>();
5768 if (D == 0) return;
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00005769
John McCall731ad842009-12-19 09:28:58 +00005770 assert(D->isOutOfLine());
John McCall7a1dc562009-12-19 10:49:29 +00005771 ExitDeclaratorContext(S);
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00005772}
Douglas Gregor99e9b4d2009-11-25 00:27:52 +00005773
5774/// ActOnCXXConditionDeclarationExpr - Parsed a condition declaration of a
5775/// C++ if/switch/while/for statement.
5776/// e.g: "if (int x = f()) {...}"
5777Action::DeclResult
5778Sema::ActOnCXXConditionDeclaration(Scope *S, Declarator &D) {
5779 // C++ 6.4p2:
5780 // The declarator shall not specify a function or an array.
5781 // The type-specifier-seq shall not contain typedef and shall not declare a
5782 // new class or enumeration.
5783 assert(D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef &&
5784 "Parser allowed 'typedef' as storage class of condition decl.");
5785
John McCalla93c9342009-12-07 02:54:59 +00005786 TypeSourceInfo *TInfo = 0;
Douglas Gregor99e9b4d2009-11-25 00:27:52 +00005787 TagDecl *OwnedTag = 0;
John McCalla93c9342009-12-07 02:54:59 +00005788 QualType Ty = GetTypeForDeclarator(D, S, &TInfo, &OwnedTag);
Douglas Gregor99e9b4d2009-11-25 00:27:52 +00005789
5790 if (Ty->isFunctionType()) { // The declarator shall not specify a function...
5791 // We exit without creating a CXXConditionDeclExpr because a FunctionDecl
5792 // would be created and CXXConditionDeclExpr wants a VarDecl.
5793 Diag(D.getIdentifierLoc(), diag::err_invalid_use_of_function_type)
5794 << D.getSourceRange();
5795 return DeclResult();
5796 } else if (OwnedTag && OwnedTag->isDefinition()) {
5797 // The type-specifier-seq shall not declare a new class or enumeration.
5798 Diag(OwnedTag->getLocation(), diag::err_type_defined_in_condition);
5799 }
5800
5801 DeclPtrTy Dcl = ActOnDeclarator(S, D);
5802 if (!Dcl)
5803 return DeclResult();
5804
5805 VarDecl *VD = cast<VarDecl>(Dcl.getAs<Decl>());
5806 VD->setDeclaredInCondition(true);
5807 return Dcl;
5808}
Anders Carlsson5ec02ae2009-12-02 17:15:43 +00005809
Anders Carlssond6a637f2009-12-07 08:24:59 +00005810void Sema::MaybeMarkVirtualMembersReferenced(SourceLocation Loc,
5811 CXXMethodDecl *MD) {
Anders Carlsson5ec02ae2009-12-02 17:15:43 +00005812 // Ignore dependent types.
5813 if (MD->isDependentContext())
5814 return;
5815
5816 CXXRecordDecl *RD = MD->getParent();
Anders Carlssonf53df232009-12-07 04:35:11 +00005817
5818 // Ignore classes without a vtable.
5819 if (!RD->isDynamicClass())
5820 return;
5821
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00005822 // Ignore declarations that are not definitions.
5823 if (!MD->isThisDeclarationADefinition())
Anders Carlssond6a637f2009-12-07 08:24:59 +00005824 return;
Douglas Gregor159ef1e2010-01-06 04:44:19 +00005825
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00005826 if (isa<CXXConstructorDecl>(MD)) {
5827 switch (MD->getParent()->getTemplateSpecializationKind()) {
5828 case TSK_Undeclared:
5829 case TSK_ExplicitSpecialization:
5830 // Classes that aren't instantiations of templates don't need their
5831 // virtual methods marked until we see the definition of the key
5832 // function.
5833 return;
5834
5835 case TSK_ImplicitInstantiation:
5836 case TSK_ExplicitInstantiationDeclaration:
5837 case TSK_ExplicitInstantiationDefinition:
5838 // This is a constructor of a class template; mark all of the virtual
5839 // members as referenced to ensure that they get instantiatied.
5840 break;
5841 }
5842 } else if (!MD->isOutOfLine()) {
5843 // Consider only out-of-line definitions of member functions. When we see
5844 // an inline definition, it's too early to compute the key function.
Douglas Gregor159ef1e2010-01-06 04:44:19 +00005845 return;
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00005846 } else if (const CXXMethodDecl *KeyFunction = Context.getKeyFunction(RD)) {
5847 // If this is not the key function, we don't need to mark virtual members.
5848 if (KeyFunction->getCanonicalDecl() != MD->getCanonicalDecl())
5849 return;
5850 } else {
5851 // The class has no key function, so we've already noted that we need to
5852 // mark the virtual members of this class.
5853 return;
5854 }
5855
Douglas Gregor159ef1e2010-01-06 04:44:19 +00005856 // We will need to mark all of the virtual members as referenced to build the
5857 // vtable.
5858 ClassesWithUnmarkedVirtualMembers.push_back(std::make_pair(RD, Loc));
Anders Carlssond6a637f2009-12-07 08:24:59 +00005859}
5860
5861bool Sema::ProcessPendingClassesWithUnmarkedVirtualMembers() {
5862 if (ClassesWithUnmarkedVirtualMembers.empty())
5863 return false;
5864
Douglas Gregor159ef1e2010-01-06 04:44:19 +00005865 while (!ClassesWithUnmarkedVirtualMembers.empty()) {
5866 CXXRecordDecl *RD = ClassesWithUnmarkedVirtualMembers.back().first;
5867 SourceLocation Loc = ClassesWithUnmarkedVirtualMembers.back().second;
5868 ClassesWithUnmarkedVirtualMembers.pop_back();
Anders Carlssond6a637f2009-12-07 08:24:59 +00005869 MarkVirtualMembersReferenced(Loc, RD);
Anders Carlsson5ec02ae2009-12-02 17:15:43 +00005870 }
5871
Anders Carlssond6a637f2009-12-07 08:24:59 +00005872 return true;
Anders Carlsson5ec02ae2009-12-02 17:15:43 +00005873}
Anders Carlssond6a637f2009-12-07 08:24:59 +00005874
5875void Sema::MarkVirtualMembersReferenced(SourceLocation Loc, CXXRecordDecl *RD) {
5876 for (CXXRecordDecl::method_iterator i = RD->method_begin(),
5877 e = RD->method_end(); i != e; ++i) {
5878 CXXMethodDecl *MD = *i;
5879
5880 // C++ [basic.def.odr]p2:
5881 // [...] A virtual member function is used if it is not pure. [...]
5882 if (MD->isVirtual() && !MD->isPure())
5883 MarkDeclarationReferenced(Loc, MD);
5884 }
5885}
5886