blob: afddd9f02cb73511ef8d6c3572cd02c0327e9971 [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 Carlssoned961f92009-08-25 02:29:20 +0000112 QualType ParamType = Param->getType();
113
Anders Carlsson5653ca52009-08-25 13:46:13 +0000114 if (RequireCompleteType(Param->getLocation(), Param->getType(),
115 diag::err_typecheck_decl_incomplete_type)) {
116 Param->setInvalidDecl();
117 return true;
118 }
119
Anders Carlssoned961f92009-08-25 02:29:20 +0000120 Expr *Arg = (Expr *)DefaultArg.get();
Mike Stump1eb44332009-09-09 15:08:12 +0000121
Anders Carlssoned961f92009-08-25 02:29:20 +0000122 // C++ [dcl.fct.default]p5
123 // A default argument expression is implicitly converted (clause
124 // 4) to the parameter type. The default argument expression has
125 // the same semantic constraints as the initializer expression in
126 // a declaration of a variable of the parameter type, using the
127 // copy-initialization semantics (8.5).
Douglas Gregor99a2e602009-12-16 01:38:02 +0000128 InitializedEntity Entity = InitializedEntity::InitializeParameter(Param);
129 InitializationKind Kind = InitializationKind::CreateCopy(Param->getLocation(),
130 EqualLoc);
131 if (CheckInitializerTypes(Arg, ParamType, Entity, Kind))
Anders Carlsson9351c172009-08-25 03:18:48 +0000132 return true;
Anders Carlssoned961f92009-08-25 02:29:20 +0000133
Anders Carlsson0ece4912009-12-15 20:51:39 +0000134 Arg = MaybeCreateCXXExprWithTemporaries(Arg);
Mike Stump1eb44332009-09-09 15:08:12 +0000135
Anders Carlssoned961f92009-08-25 02:29:20 +0000136 // Okay: add the default argument to the parameter
137 Param->setDefaultArg(Arg);
Mike Stump1eb44332009-09-09 15:08:12 +0000138
Anders Carlssoned961f92009-08-25 02:29:20 +0000139 DefaultArg.release();
Mike Stump1eb44332009-09-09 15:08:12 +0000140
Anders Carlsson9351c172009-08-25 03:18:48 +0000141 return false;
Anders Carlssoned961f92009-08-25 02:29:20 +0000142}
143
Chris Lattner8123a952008-04-10 02:22:51 +0000144/// ActOnParamDefaultArgument - Check whether the default argument
145/// provided for a function parameter is well-formed. If so, attach it
146/// to the parameter declaration.
Chris Lattner3d1cee32008-04-08 05:04:30 +0000147void
Mike Stump1eb44332009-09-09 15:08:12 +0000148Sema::ActOnParamDefaultArgument(DeclPtrTy param, SourceLocation EqualLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +0000149 ExprArg defarg) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +0000150 if (!param || !defarg.get())
151 return;
Mike Stump1eb44332009-09-09 15:08:12 +0000152
Chris Lattnerb28317a2009-03-28 19:18:32 +0000153 ParmVarDecl *Param = cast<ParmVarDecl>(param.getAs<Decl>());
Anders Carlsson5e300d12009-06-12 16:51:40 +0000154 UnparsedDefaultArgLocs.erase(Param);
155
Anders Carlssonf1b1d592009-05-01 19:30:39 +0000156 ExprOwningPtr<Expr> DefaultArg(this, defarg.takeAs<Expr>());
Chris Lattner3d1cee32008-04-08 05:04:30 +0000157 QualType ParamType = Param->getType();
158
159 // Default arguments are only permitted in C++
160 if (!getLangOptions().CPlusPlus) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000161 Diag(EqualLoc, diag::err_param_default_argument)
162 << DefaultArg->getSourceRange();
Douglas Gregor72b505b2008-12-16 21:30:33 +0000163 Param->setInvalidDecl();
Chris Lattner3d1cee32008-04-08 05:04:30 +0000164 return;
165 }
166
Anders Carlsson66e30672009-08-25 01:02:06 +0000167 // Check that the default argument is well-formed
168 CheckDefaultArgumentVisitor DefaultArgChecker(DefaultArg.get(), this);
169 if (DefaultArgChecker.Visit(DefaultArg.get())) {
170 Param->setInvalidDecl();
171 return;
172 }
Mike Stump1eb44332009-09-09 15:08:12 +0000173
Anders Carlssoned961f92009-08-25 02:29:20 +0000174 SetParamDefaultArgument(Param, move(DefaultArg), EqualLoc);
Chris Lattner3d1cee32008-04-08 05:04:30 +0000175}
176
Douglas Gregor61366e92008-12-24 00:01:03 +0000177/// ActOnParamUnparsedDefaultArgument - We've seen a default
178/// argument for a function parameter, but we can't parse it yet
179/// because we're inside a class definition. Note that this default
180/// argument will be parsed later.
Mike Stump1eb44332009-09-09 15:08:12 +0000181void Sema::ActOnParamUnparsedDefaultArgument(DeclPtrTy param,
Anders Carlsson5e300d12009-06-12 16:51:40 +0000182 SourceLocation EqualLoc,
183 SourceLocation ArgLoc) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +0000184 if (!param)
185 return;
Mike Stump1eb44332009-09-09 15:08:12 +0000186
Chris Lattnerb28317a2009-03-28 19:18:32 +0000187 ParmVarDecl *Param = cast<ParmVarDecl>(param.getAs<Decl>());
Douglas Gregor61366e92008-12-24 00:01:03 +0000188 if (Param)
189 Param->setUnparsedDefaultArg();
Mike Stump1eb44332009-09-09 15:08:12 +0000190
Anders Carlsson5e300d12009-06-12 16:51:40 +0000191 UnparsedDefaultArgLocs[Param] = ArgLoc;
Douglas Gregor61366e92008-12-24 00:01:03 +0000192}
193
Douglas Gregor72b505b2008-12-16 21:30:33 +0000194/// ActOnParamDefaultArgumentError - Parsing or semantic analysis of
195/// the default argument for the parameter param failed.
Chris Lattnerb28317a2009-03-28 19:18:32 +0000196void Sema::ActOnParamDefaultArgumentError(DeclPtrTy param) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +0000197 if (!param)
198 return;
Mike Stump1eb44332009-09-09 15:08:12 +0000199
Anders Carlsson5e300d12009-06-12 16:51:40 +0000200 ParmVarDecl *Param = cast<ParmVarDecl>(param.getAs<Decl>());
Mike Stump1eb44332009-09-09 15:08:12 +0000201
Anders Carlsson5e300d12009-06-12 16:51:40 +0000202 Param->setInvalidDecl();
Mike Stump1eb44332009-09-09 15:08:12 +0000203
Anders Carlsson5e300d12009-06-12 16:51:40 +0000204 UnparsedDefaultArgLocs.erase(Param);
Douglas Gregor72b505b2008-12-16 21:30:33 +0000205}
206
Douglas Gregor6d6eb572008-05-07 04:49:29 +0000207/// CheckExtraCXXDefaultArguments - Check for any extra default
208/// arguments in the declarator, which is not a function declaration
209/// or definition and therefore is not permitted to have default
210/// arguments. This routine should be invoked for every declarator
211/// that is not a function declaration or definition.
212void Sema::CheckExtraCXXDefaultArguments(Declarator &D) {
213 // C++ [dcl.fct.default]p3
214 // A default argument expression shall be specified only in the
215 // parameter-declaration-clause of a function declaration or in a
216 // template-parameter (14.1). It shall not be specified for a
217 // parameter pack. If it is specified in a
218 // parameter-declaration-clause, it shall not occur within a
219 // declarator or abstract-declarator of a parameter-declaration.
Chris Lattnerb28317a2009-03-28 19:18:32 +0000220 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
Douglas Gregor6d6eb572008-05-07 04:49:29 +0000221 DeclaratorChunk &chunk = D.getTypeObject(i);
222 if (chunk.Kind == DeclaratorChunk::Function) {
Chris Lattnerb28317a2009-03-28 19:18:32 +0000223 for (unsigned argIdx = 0, e = chunk.Fun.NumArgs; argIdx != e; ++argIdx) {
224 ParmVarDecl *Param =
225 cast<ParmVarDecl>(chunk.Fun.ArgInfo[argIdx].Param.getAs<Decl>());
Douglas Gregor61366e92008-12-24 00:01:03 +0000226 if (Param->hasUnparsedDefaultArg()) {
227 CachedTokens *Toks = chunk.Fun.ArgInfo[argIdx].DefaultArgTokens;
Douglas Gregor72b505b2008-12-16 21:30:33 +0000228 Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
229 << SourceRange((*Toks)[1].getLocation(), Toks->back().getLocation());
230 delete Toks;
231 chunk.Fun.ArgInfo[argIdx].DefaultArgTokens = 0;
Douglas Gregor61366e92008-12-24 00:01:03 +0000232 } else if (Param->getDefaultArg()) {
233 Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
234 << Param->getDefaultArg()->getSourceRange();
235 Param->setDefaultArg(0);
Douglas Gregor6d6eb572008-05-07 04:49:29 +0000236 }
237 }
238 }
239 }
240}
241
Chris Lattner3d1cee32008-04-08 05:04:30 +0000242// MergeCXXFunctionDecl - Merge two declarations of the same C++
243// function, once we already know that they have the same
Douglas Gregorcda9c672009-02-16 17:45:42 +0000244// type. Subroutine of MergeFunctionDecl. Returns true if there was an
245// error, false otherwise.
246bool Sema::MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old) {
247 bool Invalid = false;
248
Chris Lattner3d1cee32008-04-08 05:04:30 +0000249 // C++ [dcl.fct.default]p4:
Chris Lattner3d1cee32008-04-08 05:04:30 +0000250 // For non-template functions, default arguments can be added in
251 // later declarations of a function in the same
252 // scope. Declarations in different scopes have completely
253 // distinct sets of default arguments. That is, declarations in
254 // inner scopes do not acquire default arguments from
255 // declarations in outer scopes, and vice versa. In a given
256 // function declaration, all parameters subsequent to a
257 // parameter with a default argument shall have default
258 // arguments supplied in this or previous declarations. A
259 // default argument shall not be redefined by a later
260 // declaration (not even to the same value).
Douglas Gregor6cc15182009-09-11 18:44:32 +0000261 //
262 // C++ [dcl.fct.default]p6:
263 // Except for member functions of class templates, the default arguments
264 // in a member function definition that appears outside of the class
265 // definition are added to the set of default arguments provided by the
266 // member function declaration in the class definition.
Chris Lattner3d1cee32008-04-08 05:04:30 +0000267 for (unsigned p = 0, NumParams = Old->getNumParams(); p < NumParams; ++p) {
268 ParmVarDecl *OldParam = Old->getParamDecl(p);
269 ParmVarDecl *NewParam = New->getParamDecl(p);
270
Douglas Gregor6cc15182009-09-11 18:44:32 +0000271 if (OldParam->hasDefaultArg() && NewParam->hasDefaultArg()) {
Anders Carlssonad26b732009-11-10 03:24:44 +0000272 // FIXME: If the parameter doesn't have an identifier then the location
273 // points to the '=' which means that the fixit hint won't remove any
274 // extra spaces between the type and the '='.
275 SourceLocation Begin = NewParam->getLocation();
Anders Carlsson4881b992009-11-10 03:32:44 +0000276 if (NewParam->getIdentifier())
277 Begin = PP.getLocForEndOfToken(Begin);
Anders Carlssonad26b732009-11-10 03:24:44 +0000278
Mike Stump1eb44332009-09-09 15:08:12 +0000279 Diag(NewParam->getLocation(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000280 diag::err_param_default_argument_redefinition)
Anders Carlssonad26b732009-11-10 03:24:44 +0000281 << NewParam->getDefaultArgRange()
282 << CodeModificationHint::CreateRemoval(SourceRange(Begin,
283 NewParam->getLocEnd()));
Douglas Gregor6cc15182009-09-11 18:44:32 +0000284
285 // Look for the function declaration where the default argument was
286 // actually written, which may be a declaration prior to Old.
287 for (FunctionDecl *Older = Old->getPreviousDeclaration();
288 Older; Older = Older->getPreviousDeclaration()) {
289 if (!Older->getParamDecl(p)->hasDefaultArg())
290 break;
291
292 OldParam = Older->getParamDecl(p);
293 }
294
295 Diag(OldParam->getLocation(), diag::note_previous_definition)
296 << OldParam->getDefaultArgRange();
Douglas Gregorcda9c672009-02-16 17:45:42 +0000297 Invalid = true;
Douglas Gregord85cef52009-09-17 19:51:30 +0000298 } else if (OldParam->hasDefaultArg()) {
Chris Lattner3d1cee32008-04-08 05:04:30 +0000299 // Merge the old default argument into the new parameter
Douglas Gregord85cef52009-09-17 19:51:30 +0000300 if (OldParam->hasUninstantiatedDefaultArg())
301 NewParam->setUninstantiatedDefaultArg(
302 OldParam->getUninstantiatedDefaultArg());
303 else
304 NewParam->setDefaultArg(OldParam->getDefaultArg());
Douglas Gregor6cc15182009-09-11 18:44:32 +0000305 } else if (NewParam->hasDefaultArg()) {
306 if (New->getDescribedFunctionTemplate()) {
307 // Paragraph 4, quoted above, only applies to non-template functions.
308 Diag(NewParam->getLocation(),
309 diag::err_param_default_argument_template_redecl)
310 << NewParam->getDefaultArgRange();
311 Diag(Old->getLocation(), diag::note_template_prev_declaration)
312 << false;
Douglas Gregor096ebfd2009-10-13 17:02:54 +0000313 } else if (New->getTemplateSpecializationKind()
314 != TSK_ImplicitInstantiation &&
315 New->getTemplateSpecializationKind() != TSK_Undeclared) {
316 // C++ [temp.expr.spec]p21:
317 // Default function arguments shall not be specified in a declaration
318 // or a definition for one of the following explicit specializations:
319 // - the explicit specialization of a function template;
Douglas Gregor8c638ab2009-10-13 23:52:38 +0000320 // - the explicit specialization of a member function template;
321 // - the explicit specialization of a member function of a class
Douglas Gregor096ebfd2009-10-13 17:02:54 +0000322 // template where the class template specialization to which the
323 // member function specialization belongs is implicitly
324 // instantiated.
325 Diag(NewParam->getLocation(), diag::err_template_spec_default_arg)
326 << (New->getTemplateSpecializationKind() ==TSK_ExplicitSpecialization)
327 << New->getDeclName()
328 << NewParam->getDefaultArgRange();
Douglas Gregor6cc15182009-09-11 18:44:32 +0000329 } else if (New->getDeclContext()->isDependentContext()) {
330 // C++ [dcl.fct.default]p6 (DR217):
331 // Default arguments for a member function of a class template shall
332 // be specified on the initial declaration of the member function
333 // within the class template.
334 //
335 // Reading the tea leaves a bit in DR217 and its reference to DR205
336 // leads me to the conclusion that one cannot add default function
337 // arguments for an out-of-line definition of a member function of a
338 // dependent type.
339 int WhichKind = 2;
340 if (CXXRecordDecl *Record
341 = dyn_cast<CXXRecordDecl>(New->getDeclContext())) {
342 if (Record->getDescribedClassTemplate())
343 WhichKind = 0;
344 else if (isa<ClassTemplatePartialSpecializationDecl>(Record))
345 WhichKind = 1;
346 else
347 WhichKind = 2;
348 }
349
350 Diag(NewParam->getLocation(),
351 diag::err_param_default_argument_member_template_redecl)
352 << WhichKind
353 << NewParam->getDefaultArgRange();
354 }
Chris Lattner3d1cee32008-04-08 05:04:30 +0000355 }
356 }
357
Sebastian Redl4994d2d2009-07-04 11:39:00 +0000358 if (CheckEquivalentExceptionSpec(
John McCall183700f2009-09-21 23:43:11 +0000359 Old->getType()->getAs<FunctionProtoType>(), Old->getLocation(),
Douglas Gregor5b6d70e2009-11-25 17:50:39 +0000360 New->getType()->getAs<FunctionProtoType>(), New->getLocation()))
Sebastian Redl4994d2d2009-07-04 11:39:00 +0000361 Invalid = true;
Sebastian Redl4994d2d2009-07-04 11:39:00 +0000362
Douglas Gregorcda9c672009-02-16 17:45:42 +0000363 return Invalid;
Chris Lattner3d1cee32008-04-08 05:04:30 +0000364}
365
366/// CheckCXXDefaultArguments - Verify that the default arguments for a
367/// function declaration are well-formed according to C++
368/// [dcl.fct.default].
369void Sema::CheckCXXDefaultArguments(FunctionDecl *FD) {
370 unsigned NumParams = FD->getNumParams();
371 unsigned p;
372
373 // Find first parameter with a default argument
374 for (p = 0; p < NumParams; ++p) {
375 ParmVarDecl *Param = FD->getParamDecl(p);
Anders Carlsson5f49a0c2009-08-25 01:23:32 +0000376 if (Param->hasDefaultArg())
Chris Lattner3d1cee32008-04-08 05:04:30 +0000377 break;
378 }
379
380 // C++ [dcl.fct.default]p4:
381 // In a given function declaration, all parameters
382 // subsequent to a parameter with a default argument shall
383 // have default arguments supplied in this or previous
384 // declarations. A default argument shall not be redefined
385 // by a later declaration (not even to the same value).
386 unsigned LastMissingDefaultArg = 0;
Mike Stump1eb44332009-09-09 15:08:12 +0000387 for (; p < NumParams; ++p) {
Chris Lattner3d1cee32008-04-08 05:04:30 +0000388 ParmVarDecl *Param = FD->getParamDecl(p);
Anders Carlsson5f49a0c2009-08-25 01:23:32 +0000389 if (!Param->hasDefaultArg()) {
Douglas Gregor72b505b2008-12-16 21:30:33 +0000390 if (Param->isInvalidDecl())
391 /* We already complained about this parameter. */;
392 else if (Param->getIdentifier())
Mike Stump1eb44332009-09-09 15:08:12 +0000393 Diag(Param->getLocation(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000394 diag::err_param_default_argument_missing_name)
Chris Lattner43b628c2008-11-19 07:32:16 +0000395 << Param->getIdentifier();
Chris Lattner3d1cee32008-04-08 05:04:30 +0000396 else
Mike Stump1eb44332009-09-09 15:08:12 +0000397 Diag(Param->getLocation(),
Chris Lattner3d1cee32008-04-08 05:04:30 +0000398 diag::err_param_default_argument_missing);
Mike Stump1eb44332009-09-09 15:08:12 +0000399
Chris Lattner3d1cee32008-04-08 05:04:30 +0000400 LastMissingDefaultArg = p;
401 }
402 }
403
404 if (LastMissingDefaultArg > 0) {
405 // Some default arguments were missing. Clear out all of the
406 // default arguments up to (and including) the last missing
407 // default argument, so that we leave the function parameters
408 // in a semantically valid state.
409 for (p = 0; p <= LastMissingDefaultArg; ++p) {
410 ParmVarDecl *Param = FD->getParamDecl(p);
Anders Carlsson5e300d12009-06-12 16:51:40 +0000411 if (Param->hasDefaultArg()) {
Douglas Gregor61366e92008-12-24 00:01:03 +0000412 if (!Param->hasUnparsedDefaultArg())
413 Param->getDefaultArg()->Destroy(Context);
Chris Lattner3d1cee32008-04-08 05:04:30 +0000414 Param->setDefaultArg(0);
415 }
416 }
417 }
418}
Douglas Gregore37ac4f2008-04-13 21:30:24 +0000419
Douglas Gregorb48fe382008-10-31 09:07:45 +0000420/// isCurrentClassName - Determine whether the identifier II is the
421/// name of the class type currently being defined. In the case of
422/// nested classes, this will only return true if II is the name of
423/// the innermost class.
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +0000424bool Sema::isCurrentClassName(const IdentifierInfo &II, Scope *,
425 const CXXScopeSpec *SS) {
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000426 CXXRecordDecl *CurDecl;
Douglas Gregore4e5b052009-03-19 00:18:19 +0000427 if (SS && SS->isSet() && !SS->isInvalid()) {
Douglas Gregorac373c42009-08-21 22:16:40 +0000428 DeclContext *DC = computeDeclContext(*SS, true);
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000429 CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC);
430 } else
431 CurDecl = dyn_cast_or_null<CXXRecordDecl>(CurContext);
432
433 if (CurDecl)
Douglas Gregorb48fe382008-10-31 09:07:45 +0000434 return &II == CurDecl->getIdentifier();
435 else
436 return false;
437}
438
Mike Stump1eb44332009-09-09 15:08:12 +0000439/// \brief Check the validity of a C++ base class specifier.
Douglas Gregor2943aed2009-03-03 04:44:36 +0000440///
441/// \returns a new CXXBaseSpecifier if well-formed, emits diagnostics
442/// and returns NULL otherwise.
443CXXBaseSpecifier *
444Sema::CheckBaseSpecifier(CXXRecordDecl *Class,
445 SourceRange SpecifierRange,
446 bool Virtual, AccessSpecifier Access,
Mike Stump1eb44332009-09-09 15:08:12 +0000447 QualType BaseType,
Douglas Gregor2943aed2009-03-03 04:44:36 +0000448 SourceLocation BaseLoc) {
449 // C++ [class.union]p1:
450 // A union shall not have base classes.
451 if (Class->isUnion()) {
452 Diag(Class->getLocation(), diag::err_base_clause_on_union)
453 << SpecifierRange;
454 return 0;
455 }
456
457 if (BaseType->isDependentType())
Mike Stump1eb44332009-09-09 15:08:12 +0000458 return new (Context) CXXBaseSpecifier(SpecifierRange, Virtual,
Douglas Gregor2943aed2009-03-03 04:44:36 +0000459 Class->getTagKind() == RecordDecl::TK_class,
460 Access, BaseType);
461
462 // Base specifiers must be record types.
463 if (!BaseType->isRecordType()) {
464 Diag(BaseLoc, diag::err_base_must_be_class) << SpecifierRange;
465 return 0;
466 }
467
468 // C++ [class.union]p1:
469 // A union shall not be used as a base class.
470 if (BaseType->isUnionType()) {
471 Diag(BaseLoc, diag::err_union_as_base_class) << SpecifierRange;
472 return 0;
473 }
474
475 // C++ [class.derived]p2:
476 // The class-name in a base-specifier shall not be an incompletely
477 // defined class.
Mike Stump1eb44332009-09-09 15:08:12 +0000478 if (RequireCompleteType(BaseLoc, BaseType,
Anders Carlssonb7906612009-08-26 23:45:07 +0000479 PDiag(diag::err_incomplete_base_class)
480 << SpecifierRange))
Douglas Gregor2943aed2009-03-03 04:44:36 +0000481 return 0;
482
Eli Friedman1d954f62009-08-15 21:55:26 +0000483 // If the base class is polymorphic or isn't empty, the new one is/isn't, too.
Ted Kremenek6217b802009-07-29 21:53:49 +0000484 RecordDecl *BaseDecl = BaseType->getAs<RecordType>()->getDecl();
Douglas Gregor2943aed2009-03-03 04:44:36 +0000485 assert(BaseDecl && "Record type has no declaration");
486 BaseDecl = BaseDecl->getDefinition(Context);
487 assert(BaseDecl && "Base type is not incomplete, but has no definition");
Eli Friedman1d954f62009-08-15 21:55:26 +0000488 CXXRecordDecl * CXXBaseDecl = cast<CXXRecordDecl>(BaseDecl);
489 assert(CXXBaseDecl && "Base type is not a C++ type");
Eli Friedmand0137332009-12-05 23:03:49 +0000490
Sean Huntbbd37c62009-11-21 08:43:09 +0000491 // C++0x CWG Issue #817 indicates that [[final]] classes shouldn't be bases.
492 if (CXXBaseDecl->hasAttr<FinalAttr>()) {
493 Diag(BaseLoc, diag::err_final_base) << BaseType.getAsString();
Douglas Gregor9af2f522009-12-01 16:58:18 +0000494 Diag(CXXBaseDecl->getLocation(), diag::note_previous_decl)
495 << BaseType;
Sean Huntbbd37c62009-11-21 08:43:09 +0000496 return 0;
497 }
Douglas Gregor2943aed2009-03-03 04:44:36 +0000498
Eli Friedmand0137332009-12-05 23:03:49 +0000499 SetClassDeclAttributesFromBase(Class, CXXBaseDecl, Virtual);
Anders Carlsson51f94042009-12-03 17:49:57 +0000500
501 // Create the base specifier.
502 // FIXME: Allocate via ASTContext?
503 return new (Context) CXXBaseSpecifier(SpecifierRange, Virtual,
504 Class->getTagKind() == RecordDecl::TK_class,
505 Access, BaseType);
506}
507
508void Sema::SetClassDeclAttributesFromBase(CXXRecordDecl *Class,
509 const CXXRecordDecl *BaseClass,
510 bool BaseIsVirtual) {
Eli Friedmand0137332009-12-05 23:03:49 +0000511 // A class with a non-empty base class is not empty.
512 // FIXME: Standard ref?
513 if (!BaseClass->isEmpty())
514 Class->setEmpty(false);
515
516 // C++ [class.virtual]p1:
517 // A class that [...] inherits a virtual function is called a polymorphic
518 // class.
519 if (BaseClass->isPolymorphic())
520 Class->setPolymorphic(true);
Anders Carlsson51f94042009-12-03 17:49:57 +0000521
Douglas Gregor2943aed2009-03-03 04:44:36 +0000522 // C++ [dcl.init.aggr]p1:
523 // An aggregate is [...] a class with [...] no base classes [...].
524 Class->setAggregate(false);
Eli Friedmand0137332009-12-05 23:03:49 +0000525
526 // C++ [class]p4:
527 // A POD-struct is an aggregate class...
Douglas Gregor2943aed2009-03-03 04:44:36 +0000528 Class->setPOD(false);
529
Anders Carlsson51f94042009-12-03 17:49:57 +0000530 if (BaseIsVirtual) {
Anders Carlsson347ba892009-04-16 00:08:20 +0000531 // C++ [class.ctor]p5:
532 // A constructor is trivial if its class has no virtual base classes.
533 Class->setHasTrivialConstructor(false);
Douglas Gregor1f2023a2009-07-22 18:25:24 +0000534
535 // C++ [class.copy]p6:
536 // A copy constructor is trivial if its class has no virtual base classes.
537 Class->setHasTrivialCopyConstructor(false);
538
539 // C++ [class.copy]p11:
540 // A copy assignment operator is trivial if its class has no virtual
541 // base classes.
542 Class->setHasTrivialCopyAssignment(false);
Eli Friedman1d954f62009-08-15 21:55:26 +0000543
544 // C++0x [meta.unary.prop] is_empty:
545 // T is a class type, but not a union type, with ... no virtual base
546 // classes
547 Class->setEmpty(false);
Anders Carlsson347ba892009-04-16 00:08:20 +0000548 } else {
549 // C++ [class.ctor]p5:
Mike Stump1eb44332009-09-09 15:08:12 +0000550 // A constructor is trivial if all the direct base classes of its
Anders Carlsson347ba892009-04-16 00:08:20 +0000551 // class have trivial constructors.
Anders Carlsson51f94042009-12-03 17:49:57 +0000552 if (!BaseClass->hasTrivialConstructor())
Douglas Gregor1f2023a2009-07-22 18:25:24 +0000553 Class->setHasTrivialConstructor(false);
554
555 // C++ [class.copy]p6:
556 // A copy constructor is trivial if all the direct base classes of its
557 // class have trivial copy constructors.
Anders Carlsson51f94042009-12-03 17:49:57 +0000558 if (!BaseClass->hasTrivialCopyConstructor())
Douglas Gregor1f2023a2009-07-22 18:25:24 +0000559 Class->setHasTrivialCopyConstructor(false);
560
561 // C++ [class.copy]p11:
562 // A copy assignment operator is trivial if all the direct base classes
563 // of its class have trivial copy assignment operators.
Anders Carlsson51f94042009-12-03 17:49:57 +0000564 if (!BaseClass->hasTrivialCopyAssignment())
Douglas Gregor1f2023a2009-07-22 18:25:24 +0000565 Class->setHasTrivialCopyAssignment(false);
Anders Carlsson347ba892009-04-16 00:08:20 +0000566 }
Anders Carlsson072abef2009-04-17 02:34:54 +0000567
568 // C++ [class.ctor]p3:
569 // A destructor is trivial if all the direct base classes of its class
570 // have trivial destructors.
Anders Carlsson51f94042009-12-03 17:49:57 +0000571 if (!BaseClass->hasTrivialDestructor())
Douglas Gregor1f2023a2009-07-22 18:25:24 +0000572 Class->setHasTrivialDestructor(false);
Douglas Gregor2943aed2009-03-03 04:44:36 +0000573}
574
Douglas Gregore37ac4f2008-04-13 21:30:24 +0000575/// ActOnBaseSpecifier - Parsed a base specifier. A base specifier is
576/// one entry in the base class list of a class specifier, for
Mike Stump1eb44332009-09-09 15:08:12 +0000577/// example:
578/// class foo : public bar, virtual private baz {
Douglas Gregore37ac4f2008-04-13 21:30:24 +0000579/// 'public bar' and 'virtual private baz' are each base-specifiers.
Mike Stump1eb44332009-09-09 15:08:12 +0000580Sema::BaseResult
Chris Lattnerb28317a2009-03-28 19:18:32 +0000581Sema::ActOnBaseSpecifier(DeclPtrTy classdecl, SourceRange SpecifierRange,
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000582 bool Virtual, AccessSpecifier Access,
583 TypeTy *basetype, SourceLocation BaseLoc) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +0000584 if (!classdecl)
585 return true;
586
Douglas Gregor40808ce2009-03-09 23:48:35 +0000587 AdjustDeclIfTemplate(classdecl);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000588 CXXRecordDecl *Class = cast<CXXRecordDecl>(classdecl.getAs<Decl>());
Argyrios Kyrtzidise8661902009-08-19 01:28:28 +0000589 QualType BaseType = GetTypeFromParser(basetype);
Douglas Gregor2943aed2009-03-03 04:44:36 +0000590 if (CXXBaseSpecifier *BaseSpec = CheckBaseSpecifier(Class, SpecifierRange,
591 Virtual, Access,
592 BaseType, BaseLoc))
593 return BaseSpec;
Mike Stump1eb44332009-09-09 15:08:12 +0000594
Douglas Gregor2943aed2009-03-03 04:44:36 +0000595 return true;
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000596}
Douglas Gregore37ac4f2008-04-13 21:30:24 +0000597
Douglas Gregor2943aed2009-03-03 04:44:36 +0000598/// \brief Performs the actual work of attaching the given base class
599/// specifiers to a C++ class.
600bool Sema::AttachBaseSpecifiers(CXXRecordDecl *Class, CXXBaseSpecifier **Bases,
601 unsigned NumBases) {
602 if (NumBases == 0)
603 return false;
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000604
605 // Used to keep track of which base types we have already seen, so
606 // that we can properly diagnose redundant direct base types. Note
Douglas Gregor57c856b2008-10-23 18:13:27 +0000607 // that the key is always the unqualified canonical type of the base
608 // class.
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000609 std::map<QualType, CXXBaseSpecifier*, QualTypeOrdering> KnownBaseTypes;
610
611 // Copy non-redundant base specifiers into permanent storage.
Douglas Gregor57c856b2008-10-23 18:13:27 +0000612 unsigned NumGoodBases = 0;
Douglas Gregor2943aed2009-03-03 04:44:36 +0000613 bool Invalid = false;
Douglas Gregor57c856b2008-10-23 18:13:27 +0000614 for (unsigned idx = 0; idx < NumBases; ++idx) {
Mike Stump1eb44332009-09-09 15:08:12 +0000615 QualType NewBaseType
Douglas Gregor2943aed2009-03-03 04:44:36 +0000616 = Context.getCanonicalType(Bases[idx]->getType());
Douglas Gregora4923eb2009-11-16 21:35:15 +0000617 NewBaseType = NewBaseType.getLocalUnqualifiedType();
Douglas Gregor57c856b2008-10-23 18:13:27 +0000618
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000619 if (KnownBaseTypes[NewBaseType]) {
620 // C++ [class.mi]p3:
621 // A class shall not be specified as a direct base class of a
622 // derived class more than once.
Douglas Gregor2943aed2009-03-03 04:44:36 +0000623 Diag(Bases[idx]->getSourceRange().getBegin(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000624 diag::err_duplicate_base_class)
Chris Lattnerd1625842008-11-24 06:25:27 +0000625 << KnownBaseTypes[NewBaseType]->getType()
Douglas Gregor2943aed2009-03-03 04:44:36 +0000626 << Bases[idx]->getSourceRange();
Douglas Gregor57c856b2008-10-23 18:13:27 +0000627
628 // Delete the duplicate base class specifier; we're going to
629 // overwrite its pointer later.
Douglas Gregor2aef06d2009-07-22 20:55:49 +0000630 Context.Deallocate(Bases[idx]);
Douglas Gregor2943aed2009-03-03 04:44:36 +0000631
632 Invalid = true;
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000633 } else {
634 // Okay, add this new base class.
Douglas Gregor2943aed2009-03-03 04:44:36 +0000635 KnownBaseTypes[NewBaseType] = Bases[idx];
636 Bases[NumGoodBases++] = Bases[idx];
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000637 }
638 }
639
640 // Attach the remaining base class specifiers to the derived class.
Fariborz Jahanian5ffcd7b2009-07-02 18:26:15 +0000641 Class->setBases(Context, Bases, NumGoodBases);
Douglas Gregor57c856b2008-10-23 18:13:27 +0000642
643 // Delete the remaining (good) base class specifiers, since their
644 // data has been copied into the CXXRecordDecl.
645 for (unsigned idx = 0; idx < NumGoodBases; ++idx)
Douglas Gregor2aef06d2009-07-22 20:55:49 +0000646 Context.Deallocate(Bases[idx]);
Douglas Gregor2943aed2009-03-03 04:44:36 +0000647
648 return Invalid;
649}
650
651/// ActOnBaseSpecifiers - Attach the given base specifiers to the
652/// class, after checking whether there are any duplicate base
653/// classes.
Mike Stump1eb44332009-09-09 15:08:12 +0000654void Sema::ActOnBaseSpecifiers(DeclPtrTy ClassDecl, BaseTy **Bases,
Douglas Gregor2943aed2009-03-03 04:44:36 +0000655 unsigned NumBases) {
656 if (!ClassDecl || !Bases || !NumBases)
657 return;
658
659 AdjustDeclIfTemplate(ClassDecl);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000660 AttachBaseSpecifiers(cast<CXXRecordDecl>(ClassDecl.getAs<Decl>()),
Douglas Gregor2943aed2009-03-03 04:44:36 +0000661 (CXXBaseSpecifier**)(Bases), NumBases);
Douglas Gregore37ac4f2008-04-13 21:30:24 +0000662}
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +0000663
Douglas Gregora8f32e02009-10-06 17:59:45 +0000664/// \brief Determine whether the type \p Derived is a C++ class that is
665/// derived from the type \p Base.
666bool Sema::IsDerivedFrom(QualType Derived, QualType Base) {
667 if (!getLangOptions().CPlusPlus)
668 return false;
669
670 const RecordType *DerivedRT = Derived->getAs<RecordType>();
671 if (!DerivedRT)
672 return false;
673
674 const RecordType *BaseRT = Base->getAs<RecordType>();
675 if (!BaseRT)
676 return false;
677
678 CXXRecordDecl *DerivedRD = cast<CXXRecordDecl>(DerivedRT->getDecl());
679 CXXRecordDecl *BaseRD = cast<CXXRecordDecl>(BaseRT->getDecl());
680 return DerivedRD->isDerivedFrom(BaseRD);
681}
682
683/// \brief Determine whether the type \p Derived is a C++ class that is
684/// derived from the type \p Base.
685bool Sema::IsDerivedFrom(QualType Derived, QualType Base, CXXBasePaths &Paths) {
686 if (!getLangOptions().CPlusPlus)
687 return false;
688
689 const RecordType *DerivedRT = Derived->getAs<RecordType>();
690 if (!DerivedRT)
691 return false;
692
693 const RecordType *BaseRT = Base->getAs<RecordType>();
694 if (!BaseRT)
695 return false;
696
697 CXXRecordDecl *DerivedRD = cast<CXXRecordDecl>(DerivedRT->getDecl());
698 CXXRecordDecl *BaseRD = cast<CXXRecordDecl>(BaseRT->getDecl());
699 return DerivedRD->isDerivedFrom(BaseRD, Paths);
700}
701
702/// CheckDerivedToBaseConversion - Check whether the Derived-to-Base
703/// conversion (where Derived and Base are class types) is
704/// well-formed, meaning that the conversion is unambiguous (and
705/// that all of the base classes are accessible). Returns true
706/// and emits a diagnostic if the code is ill-formed, returns false
707/// otherwise. Loc is the location where this routine should point to
708/// if there is an error, and Range is the source range to highlight
709/// if there is an error.
710bool
711Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base,
712 unsigned InaccessibleBaseID,
713 unsigned AmbigiousBaseConvID,
714 SourceLocation Loc, SourceRange Range,
715 DeclarationName Name) {
716 // First, determine whether the path from Derived to Base is
717 // ambiguous. This is slightly more expensive than checking whether
718 // the Derived to Base conversion exists, because here we need to
719 // explore multiple paths to determine if there is an ambiguity.
720 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
721 /*DetectVirtual=*/false);
722 bool DerivationOkay = IsDerivedFrom(Derived, Base, Paths);
723 assert(DerivationOkay &&
724 "Can only be used with a derived-to-base conversion");
725 (void)DerivationOkay;
726
727 if (!Paths.isAmbiguous(Context.getCanonicalType(Base).getUnqualifiedType())) {
Sebastian Redla82e4ae2009-11-14 21:15:49 +0000728 if (InaccessibleBaseID == 0)
729 return false;
Douglas Gregora8f32e02009-10-06 17:59:45 +0000730 // Check that the base class can be accessed.
731 return CheckBaseClassAccess(Derived, Base, InaccessibleBaseID, Paths, Loc,
732 Name);
733 }
734
735 // We know that the derived-to-base conversion is ambiguous, and
736 // we're going to produce a diagnostic. Perform the derived-to-base
737 // search just one more time to compute all of the possible paths so
738 // that we can print them out. This is more expensive than any of
739 // the previous derived-to-base checks we've done, but at this point
740 // performance isn't as much of an issue.
741 Paths.clear();
742 Paths.setRecordingPaths(true);
743 bool StillOkay = IsDerivedFrom(Derived, Base, Paths);
744 assert(StillOkay && "Can only be used with a derived-to-base conversion");
745 (void)StillOkay;
746
747 // Build up a textual representation of the ambiguous paths, e.g.,
748 // D -> B -> A, that will be used to illustrate the ambiguous
749 // conversions in the diagnostic. We only print one of the paths
750 // to each base class subobject.
751 std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
752
753 Diag(Loc, AmbigiousBaseConvID)
754 << Derived << Base << PathDisplayStr << Range << Name;
755 return true;
756}
757
758bool
759Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base,
Sebastian Redla82e4ae2009-11-14 21:15:49 +0000760 SourceLocation Loc, SourceRange Range,
761 bool IgnoreAccess) {
Douglas Gregora8f32e02009-10-06 17:59:45 +0000762 return CheckDerivedToBaseConversion(Derived, Base,
Sebastian Redla82e4ae2009-11-14 21:15:49 +0000763 IgnoreAccess ? 0 :
764 diag::err_conv_to_inaccessible_base,
Douglas Gregora8f32e02009-10-06 17:59:45 +0000765 diag::err_ambiguous_derived_to_base_conv,
766 Loc, Range, DeclarationName());
767}
768
769
770/// @brief Builds a string representing ambiguous paths from a
771/// specific derived class to different subobjects of the same base
772/// class.
773///
774/// This function builds a string that can be used in error messages
775/// to show the different paths that one can take through the
776/// inheritance hierarchy to go from the derived class to different
777/// subobjects of a base class. The result looks something like this:
778/// @code
779/// struct D -> struct B -> struct A
780/// struct D -> struct C -> struct A
781/// @endcode
782std::string Sema::getAmbiguousPathsDisplayString(CXXBasePaths &Paths) {
783 std::string PathDisplayStr;
784 std::set<unsigned> DisplayedPaths;
785 for (CXXBasePaths::paths_iterator Path = Paths.begin();
786 Path != Paths.end(); ++Path) {
787 if (DisplayedPaths.insert(Path->back().SubobjectNumber).second) {
788 // We haven't displayed a path to this particular base
789 // class subobject yet.
790 PathDisplayStr += "\n ";
791 PathDisplayStr += Context.getTypeDeclType(Paths.getOrigin()).getAsString();
792 for (CXXBasePath::const_iterator Element = Path->begin();
793 Element != Path->end(); ++Element)
794 PathDisplayStr += " -> " + Element->Base->getType().getAsString();
795 }
796 }
797
798 return PathDisplayStr;
799}
800
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000801//===----------------------------------------------------------------------===//
802// C++ class member Handling
803//===----------------------------------------------------------------------===//
804
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000805/// ActOnCXXMemberDeclarator - This is invoked when a C++ class member
806/// declarator is parsed. 'AS' is the access specifier, 'BW' specifies the
807/// bitfield width if there is one and 'InitExpr' specifies the initializer if
Chris Lattnerb6688e02009-04-12 22:37:57 +0000808/// any.
Chris Lattnerb28317a2009-03-28 19:18:32 +0000809Sema::DeclPtrTy
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000810Sema::ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS, Declarator &D,
Douglas Gregor37b372b2009-08-20 22:52:58 +0000811 MultiTemplateParamsArg TemplateParameterLists,
Sebastian Redld1a78462009-11-24 23:38:44 +0000812 ExprTy *BW, ExprTy *InitExpr, bool IsDefinition,
813 bool Deleted) {
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000814 const DeclSpec &DS = D.getDeclSpec();
Douglas Gregor10bd3682008-11-17 22:58:34 +0000815 DeclarationName Name = GetNameForDeclarator(D);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000816 Expr *BitWidth = static_cast<Expr*>(BW);
817 Expr *Init = static_cast<Expr*>(InitExpr);
818 SourceLocation Loc = D.getIdentifierLoc();
819
Sebastian Redl669d5d72008-11-14 23:42:31 +0000820 bool isFunc = D.isFunctionDeclarator();
821
John McCall67d1a672009-08-06 02:15:43 +0000822 assert(!DS.isFriendSpecified());
823
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000824 // C++ 9.2p6: A member shall not be declared to have automatic storage
825 // duration (auto, register) or with the extern storage-class-specifier.
Sebastian Redl669d5d72008-11-14 23:42:31 +0000826 // C++ 7.1.1p8: The mutable specifier can be applied only to names of class
827 // data members and cannot be applied to names declared const or static,
828 // and cannot be applied to reference members.
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000829 switch (DS.getStorageClassSpec()) {
830 case DeclSpec::SCS_unspecified:
831 case DeclSpec::SCS_typedef:
832 case DeclSpec::SCS_static:
833 // FALL THROUGH.
834 break;
Sebastian Redl669d5d72008-11-14 23:42:31 +0000835 case DeclSpec::SCS_mutable:
836 if (isFunc) {
837 if (DS.getStorageClassSpecLoc().isValid())
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000838 Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_function);
Sebastian Redl669d5d72008-11-14 23:42:31 +0000839 else
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000840 Diag(DS.getThreadSpecLoc(), diag::err_mutable_function);
Mike Stump1eb44332009-09-09 15:08:12 +0000841
Sebastian Redla11f42f2008-11-17 23:24:37 +0000842 // FIXME: It would be nicer if the keyword was ignored only for this
843 // declarator. Otherwise we could get follow-up errors.
Sebastian Redl669d5d72008-11-14 23:42:31 +0000844 D.getMutableDeclSpec().ClearStorageClassSpecs();
845 } else {
846 QualType T = GetTypeForDeclarator(D, S);
847 diag::kind err = static_cast<diag::kind>(0);
848 if (T->isReferenceType())
849 err = diag::err_mutable_reference;
850 else if (T.isConstQualified())
851 err = diag::err_mutable_const;
852 if (err != 0) {
853 if (DS.getStorageClassSpecLoc().isValid())
854 Diag(DS.getStorageClassSpecLoc(), err);
855 else
856 Diag(DS.getThreadSpecLoc(), err);
Sebastian Redla11f42f2008-11-17 23:24:37 +0000857 // FIXME: It would be nicer if the keyword was ignored only for this
858 // declarator. Otherwise we could get follow-up errors.
Sebastian Redl669d5d72008-11-14 23:42:31 +0000859 D.getMutableDeclSpec().ClearStorageClassSpecs();
860 }
861 }
862 break;
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000863 default:
864 if (DS.getStorageClassSpecLoc().isValid())
865 Diag(DS.getStorageClassSpecLoc(),
866 diag::err_storageclass_invalid_for_member);
867 else
868 Diag(DS.getThreadSpecLoc(), diag::err_storageclass_invalid_for_member);
869 D.getMutableDeclSpec().ClearStorageClassSpecs();
870 }
871
Argyrios Kyrtzidisd6caa9e2008-10-15 20:23:22 +0000872 if (!isFunc &&
Douglas Gregor1a51b4a2009-02-09 15:09:02 +0000873 D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_typename &&
Argyrios Kyrtzidisd6caa9e2008-10-15 20:23:22 +0000874 D.getNumTypeObjects() == 0) {
Argyrios Kyrtzidisde933f02008-10-08 22:20:31 +0000875 // Check also for this case:
876 //
877 // typedef int f();
878 // f a;
879 //
Argyrios Kyrtzidise8661902009-08-19 01:28:28 +0000880 QualType TDType = GetTypeFromParser(DS.getTypeRep());
Douglas Gregor1a51b4a2009-02-09 15:09:02 +0000881 isFunc = TDType->isFunctionType();
Argyrios Kyrtzidisde933f02008-10-08 22:20:31 +0000882 }
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000883
Sebastian Redl669d5d72008-11-14 23:42:31 +0000884 bool isInstField = ((DS.getStorageClassSpec() == DeclSpec::SCS_unspecified ||
885 DS.getStorageClassSpec() == DeclSpec::SCS_mutable) &&
Argyrios Kyrtzidisde933f02008-10-08 22:20:31 +0000886 !isFunc);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000887
888 Decl *Member;
Chris Lattner24793662009-03-05 22:45:59 +0000889 if (isInstField) {
Douglas Gregor37b372b2009-08-20 22:52:58 +0000890 // FIXME: Check for template parameters!
Douglas Gregor4dd55f52009-03-11 20:50:30 +0000891 Member = HandleField(S, cast<CXXRecordDecl>(CurContext), Loc, D, BitWidth,
892 AS);
Chris Lattner6f8ce142009-03-05 23:03:49 +0000893 assert(Member && "HandleField never returns null");
Chris Lattner24793662009-03-05 22:45:59 +0000894 } else {
Sebastian Redld1a78462009-11-24 23:38:44 +0000895 Member = HandleDeclarator(S, D, move(TemplateParameterLists), IsDefinition)
Douglas Gregor37b372b2009-08-20 22:52:58 +0000896 .getAs<Decl>();
Chris Lattner6f8ce142009-03-05 23:03:49 +0000897 if (!Member) {
898 if (BitWidth) DeleteExpr(BitWidth);
Chris Lattner682bf922009-03-29 16:50:03 +0000899 return DeclPtrTy();
Chris Lattner6f8ce142009-03-05 23:03:49 +0000900 }
Chris Lattner8b963ef2009-03-05 23:01:03 +0000901
902 // Non-instance-fields can't have a bitfield.
903 if (BitWidth) {
904 if (Member->isInvalidDecl()) {
905 // don't emit another diagnostic.
Douglas Gregor2d2e9cf2009-03-11 20:22:50 +0000906 } else if (isa<VarDecl>(Member)) {
Chris Lattner8b963ef2009-03-05 23:01:03 +0000907 // C++ 9.6p3: A bit-field shall not be a static member.
908 // "static member 'A' cannot be a bit-field"
909 Diag(Loc, diag::err_static_not_bitfield)
910 << Name << BitWidth->getSourceRange();
911 } else if (isa<TypedefDecl>(Member)) {
912 // "typedef member 'x' cannot be a bit-field"
913 Diag(Loc, diag::err_typedef_not_bitfield)
914 << Name << BitWidth->getSourceRange();
915 } else {
916 // A function typedef ("typedef int f(); f a;").
917 // C++ 9.6p3: A bit-field shall have integral or enumeration type.
918 Diag(Loc, diag::err_not_integral_type_bitfield)
Mike Stump1eb44332009-09-09 15:08:12 +0000919 << Name << cast<ValueDecl>(Member)->getType()
Douglas Gregor3cf538d2009-03-11 18:59:21 +0000920 << BitWidth->getSourceRange();
Chris Lattner8b963ef2009-03-05 23:01:03 +0000921 }
Mike Stump1eb44332009-09-09 15:08:12 +0000922
Chris Lattner8b963ef2009-03-05 23:01:03 +0000923 DeleteExpr(BitWidth);
924 BitWidth = 0;
925 Member->setInvalidDecl();
926 }
Douglas Gregor4dd55f52009-03-11 20:50:30 +0000927
928 Member->setAccess(AS);
Mike Stump1eb44332009-09-09 15:08:12 +0000929
Douglas Gregor37b372b2009-08-20 22:52:58 +0000930 // If we have declared a member function template, set the access of the
931 // templated declaration as well.
932 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Member))
933 FunTmpl->getTemplatedDecl()->setAccess(AS);
Chris Lattner24793662009-03-05 22:45:59 +0000934 }
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000935
Douglas Gregor10bd3682008-11-17 22:58:34 +0000936 assert((Name || isInstField) && "No identifier for non-field ?");
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000937
Douglas Gregor021c3b32009-03-11 23:00:04 +0000938 if (Init)
Chris Lattnerb28317a2009-03-28 19:18:32 +0000939 AddInitializerToDecl(DeclPtrTy::make(Member), ExprArg(*this, Init), false);
Sebastian Redle2b68332009-04-12 17:16:29 +0000940 if (Deleted) // FIXME: Source location is not very good.
941 SetDeclDeleted(DeclPtrTy::make(Member), D.getSourceRange().getBegin());
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000942
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000943 if (isInstField) {
Douglas Gregor44b43212008-12-11 16:49:14 +0000944 FieldCollector->Add(cast<FieldDecl>(Member));
Chris Lattner682bf922009-03-29 16:50:03 +0000945 return DeclPtrTy();
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000946 }
Chris Lattnerb28317a2009-03-28 19:18:32 +0000947 return DeclPtrTy::make(Member);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000948}
949
Douglas Gregor7ad83902008-11-05 04:29:56 +0000950/// ActOnMemInitializer - Handle a C++ member initializer.
Mike Stump1eb44332009-09-09 15:08:12 +0000951Sema::MemInitResult
Chris Lattnerb28317a2009-03-28 19:18:32 +0000952Sema::ActOnMemInitializer(DeclPtrTy ConstructorD,
Douglas Gregor7ad83902008-11-05 04:29:56 +0000953 Scope *S,
Fariborz Jahanianbcfad542009-06-30 23:26:25 +0000954 const CXXScopeSpec &SS,
Douglas Gregor7ad83902008-11-05 04:29:56 +0000955 IdentifierInfo *MemberOrBase,
Fariborz Jahanian96174332009-07-01 19:21:19 +0000956 TypeTy *TemplateTypeTy,
Douglas Gregor7ad83902008-11-05 04:29:56 +0000957 SourceLocation IdLoc,
958 SourceLocation LParenLoc,
959 ExprTy **Args, unsigned NumArgs,
960 SourceLocation *CommaLocs,
961 SourceLocation RParenLoc) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +0000962 if (!ConstructorD)
963 return true;
Mike Stump1eb44332009-09-09 15:08:12 +0000964
Douglas Gregorefd5bda2009-08-24 11:57:43 +0000965 AdjustDeclIfTemplate(ConstructorD);
Mike Stump1eb44332009-09-09 15:08:12 +0000966
967 CXXConstructorDecl *Constructor
Chris Lattnerb28317a2009-03-28 19:18:32 +0000968 = dyn_cast<CXXConstructorDecl>(ConstructorD.getAs<Decl>());
Douglas Gregor7ad83902008-11-05 04:29:56 +0000969 if (!Constructor) {
970 // The user wrote a constructor initializer on a function that is
971 // not a C++ constructor. Ignore the error for now, because we may
972 // have more member initializers coming; we'll diagnose it just
973 // once in ActOnMemInitializers.
974 return true;
975 }
976
977 CXXRecordDecl *ClassDecl = Constructor->getParent();
978
979 // C++ [class.base.init]p2:
980 // Names in a mem-initializer-id are looked up in the scope of the
981 // constructor’s class and, if not found in that scope, are looked
982 // up in the scope containing the constructor’s
983 // definition. [Note: if the constructor’s class contains a member
984 // with the same name as a direct or virtual base class of the
985 // class, a mem-initializer-id naming the member or base class and
986 // composed of a single identifier refers to the class member. A
987 // mem-initializer-id for the hidden base class may be specified
988 // using a qualified name. ]
Fariborz Jahanian96174332009-07-01 19:21:19 +0000989 if (!SS.getScopeRep() && !TemplateTypeTy) {
Fariborz Jahanianbcfad542009-06-30 23:26:25 +0000990 // Look for a member, first.
991 FieldDecl *Member = 0;
Mike Stump1eb44332009-09-09 15:08:12 +0000992 DeclContext::lookup_result Result
Fariborz Jahanianbcfad542009-06-30 23:26:25 +0000993 = ClassDecl->lookup(MemberOrBase);
994 if (Result.first != Result.second)
995 Member = dyn_cast<FieldDecl>(*Result.first);
Douglas Gregor7ad83902008-11-05 04:29:56 +0000996
Fariborz Jahanianbcfad542009-06-30 23:26:25 +0000997 // FIXME: Handle members of an anonymous union.
Douglas Gregor7ad83902008-11-05 04:29:56 +0000998
Eli Friedman59c04372009-07-29 19:44:27 +0000999 if (Member)
1000 return BuildMemberInitializer(Member, (Expr**)Args, NumArgs, IdLoc,
Douglas Gregor802ab452009-12-02 22:36:29 +00001001 LParenLoc, RParenLoc);
Douglas Gregor7ad83902008-11-05 04:29:56 +00001002 }
Douglas Gregor7ad83902008-11-05 04:29:56 +00001003 // It didn't name a member, so see if it names a class.
Douglas Gregor802ab452009-12-02 22:36:29 +00001004 QualType BaseType;
1005
John McCalla93c9342009-12-07 02:54:59 +00001006 TypeSourceInfo *TInfo = 0;
Douglas Gregor802ab452009-12-02 22:36:29 +00001007 if (TemplateTypeTy)
John McCalla93c9342009-12-07 02:54:59 +00001008 BaseType = GetTypeFromParser(TemplateTypeTy, &TInfo);
Douglas Gregor802ab452009-12-02 22:36:29 +00001009 else
1010 BaseType = QualType::getFromOpaquePtr(getTypeName(*MemberOrBase, IdLoc,
1011 S, &SS));
1012 if (BaseType.isNull())
Chris Lattner3c73c412008-11-19 08:23:25 +00001013 return Diag(IdLoc, diag::err_mem_init_not_member_or_class)
1014 << MemberOrBase << SourceRange(IdLoc, RParenLoc);
Mike Stump1eb44332009-09-09 15:08:12 +00001015
John McCalla93c9342009-12-07 02:54:59 +00001016 if (!TInfo)
1017 TInfo = Context.getTrivialTypeSourceInfo(BaseType, IdLoc);
Douglas Gregor7ad83902008-11-05 04:29:56 +00001018
John McCalla93c9342009-12-07 02:54:59 +00001019 return BuildBaseInitializer(BaseType, TInfo, (Expr **)Args, NumArgs,
Douglas Gregor802ab452009-12-02 22:36:29 +00001020 LParenLoc, RParenLoc, ClassDecl);
Eli Friedman59c04372009-07-29 19:44:27 +00001021}
1022
John McCallb4190042009-11-04 23:02:40 +00001023/// Checks an initializer expression for use of uninitialized fields, such as
1024/// containing the field that is being initialized. Returns true if there is an
1025/// uninitialized field was used an updates the SourceLocation parameter; false
1026/// otherwise.
1027static bool InitExprContainsUninitializedFields(const Stmt* S,
1028 const FieldDecl* LhsField,
1029 SourceLocation* L) {
1030 const MemberExpr* ME = dyn_cast<MemberExpr>(S);
1031 if (ME) {
1032 const NamedDecl* RhsField = ME->getMemberDecl();
1033 if (RhsField == LhsField) {
1034 // Initializing a field with itself. Throw a warning.
1035 // But wait; there are exceptions!
1036 // Exception #1: The field may not belong to this record.
1037 // e.g. Foo(const Foo& rhs) : A(rhs.A) {}
1038 const Expr* base = ME->getBase();
1039 if (base != NULL && !isa<CXXThisExpr>(base->IgnoreParenCasts())) {
1040 // Even though the field matches, it does not belong to this record.
1041 return false;
1042 }
1043 // None of the exceptions triggered; return true to indicate an
1044 // uninitialized field was used.
1045 *L = ME->getMemberLoc();
1046 return true;
1047 }
1048 }
1049 bool found = false;
1050 for (Stmt::const_child_iterator it = S->child_begin();
1051 it != S->child_end() && found == false;
1052 ++it) {
1053 if (isa<CallExpr>(S)) {
1054 // Do not descend into function calls or constructors, as the use
1055 // of an uninitialized field may be valid. One would have to inspect
1056 // the contents of the function/ctor to determine if it is safe or not.
1057 // i.e. Pass-by-value is never safe, but pass-by-reference and pointers
1058 // may be safe, depending on what the function/ctor does.
1059 continue;
1060 }
1061 found = InitExprContainsUninitializedFields(*it, LhsField, L);
1062 }
1063 return found;
1064}
1065
Eli Friedman59c04372009-07-29 19:44:27 +00001066Sema::MemInitResult
1067Sema::BuildMemberInitializer(FieldDecl *Member, Expr **Args,
1068 unsigned NumArgs, SourceLocation IdLoc,
Douglas Gregor802ab452009-12-02 22:36:29 +00001069 SourceLocation LParenLoc,
Eli Friedman59c04372009-07-29 19:44:27 +00001070 SourceLocation RParenLoc) {
Anders Carlssonf8a9a792009-11-13 19:21:49 +00001071 // FIXME: CXXBaseOrMemberInitializer should only contain a single
1072 // subexpression so we can wrap it in a CXXExprWithTemporaries if necessary.
1073 ExprTemporaries.clear();
1074
John McCallb4190042009-11-04 23:02:40 +00001075 // Diagnose value-uses of fields to initialize themselves, e.g.
1076 // foo(foo)
1077 // where foo is not also a parameter to the constructor.
John McCall6aee6212009-11-04 23:13:52 +00001078 // TODO: implement -Wuninitialized and fold this into that framework.
John McCallb4190042009-11-04 23:02:40 +00001079 for (unsigned i = 0; i < NumArgs; ++i) {
1080 SourceLocation L;
1081 if (InitExprContainsUninitializedFields(Args[i], Member, &L)) {
1082 // FIXME: Return true in the case when other fields are used before being
1083 // uninitialized. For example, let this field be the i'th field. When
1084 // initializing the i'th field, throw a warning if any of the >= i'th
1085 // fields are used, as they are not yet initialized.
1086 // Right now we are only handling the case where the i'th field uses
1087 // itself in its initializer.
1088 Diag(L, diag::warn_field_is_uninit);
1089 }
1090 }
1091
Eli Friedman59c04372009-07-29 19:44:27 +00001092 bool HasDependentArg = false;
1093 for (unsigned i = 0; i < NumArgs; i++)
1094 HasDependentArg |= Args[i]->isTypeDependent();
1095
1096 CXXConstructorDecl *C = 0;
1097 QualType FieldType = Member->getType();
1098 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
1099 FieldType = Array->getElementType();
1100 if (FieldType->isDependentType()) {
1101 // Can't check init for dependent type.
John McCall6aee6212009-11-04 23:13:52 +00001102 } else if (FieldType->isRecordType()) {
1103 // Member is a record (struct/union/class), so pass the initializer
1104 // arguments down to the record's constructor.
Douglas Gregor39da0b82009-09-09 23:08:42 +00001105 if (!HasDependentArg) {
1106 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(*this);
1107
1108 C = PerformInitializationByConstructor(FieldType,
1109 MultiExprArg(*this,
1110 (void**)Args,
1111 NumArgs),
1112 IdLoc,
1113 SourceRange(IdLoc, RParenLoc),
Douglas Gregor20093b42009-12-09 23:02:17 +00001114 Member->getDeclName(),
1115 InitializationKind::CreateDirect(IdLoc, LParenLoc, RParenLoc),
Douglas Gregor39da0b82009-09-09 23:08:42 +00001116 ConstructorArgs);
1117
1118 if (C) {
1119 // Take over the constructor arguments as our own.
1120 NumArgs = ConstructorArgs.size();
1121 Args = (Expr **)ConstructorArgs.take();
1122 }
1123 }
Fariborz Jahanian636a0ff2009-09-02 17:10:17 +00001124 } else if (NumArgs != 1 && NumArgs != 0) {
John McCall6aee6212009-11-04 23:13:52 +00001125 // The member type is not a record type (or an array of record
1126 // types), so it can be only be default- or copy-initialized.
Mike Stump1eb44332009-09-09 15:08:12 +00001127 return Diag(IdLoc, diag::err_mem_initializer_mismatch)
Eli Friedman59c04372009-07-29 19:44:27 +00001128 << Member->getDeclName() << SourceRange(IdLoc, RParenLoc);
1129 } else if (!HasDependentArg) {
Fariborz Jahanian636a0ff2009-09-02 17:10:17 +00001130 Expr *NewExp;
1131 if (NumArgs == 0) {
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001132 if (FieldType->isReferenceType()) {
1133 Diag(IdLoc, diag::err_null_intialized_reference_member)
1134 << Member->getDeclName();
1135 return Diag(Member->getLocation(), diag::note_declared_at);
1136 }
Fariborz Jahanian636a0ff2009-09-02 17:10:17 +00001137 NewExp = new (Context) CXXZeroInitValueExpr(FieldType, IdLoc, RParenLoc);
1138 NumArgs = 1;
1139 }
1140 else
1141 NewExp = (Expr*)Args[0];
Douglas Gregor68647482009-12-16 03:45:30 +00001142 if (PerformCopyInitialization(NewExp, FieldType, AA_Passing))
Eli Friedman59c04372009-07-29 19:44:27 +00001143 return true;
1144 Args[0] = NewExp;
Douglas Gregor7ad83902008-11-05 04:29:56 +00001145 }
Anders Carlssonf8a9a792009-11-13 19:21:49 +00001146
1147 // FIXME: CXXBaseOrMemberInitializer should only contain a single
1148 // subexpression so we can wrap it in a CXXExprWithTemporaries if necessary.
1149 ExprTemporaries.clear();
1150
Eli Friedman59c04372009-07-29 19:44:27 +00001151 // FIXME: Perform direct initialization of the member.
Douglas Gregor802ab452009-12-02 22:36:29 +00001152 return new (Context) CXXBaseOrMemberInitializer(Context, Member, IdLoc,
1153 C, LParenLoc, (Expr **)Args,
1154 NumArgs, RParenLoc);
Eli Friedman59c04372009-07-29 19:44:27 +00001155}
1156
1157Sema::MemInitResult
John McCalla93c9342009-12-07 02:54:59 +00001158Sema::BuildBaseInitializer(QualType BaseType, TypeSourceInfo *BaseTInfo,
Douglas Gregor802ab452009-12-02 22:36:29 +00001159 Expr **Args, unsigned NumArgs,
1160 SourceLocation LParenLoc, SourceLocation RParenLoc,
1161 CXXRecordDecl *ClassDecl) {
Eli Friedman59c04372009-07-29 19:44:27 +00001162 bool HasDependentArg = false;
1163 for (unsigned i = 0; i < NumArgs; i++)
1164 HasDependentArg |= Args[i]->isTypeDependent();
1165
John McCalla93c9342009-12-07 02:54:59 +00001166 SourceLocation BaseLoc = BaseTInfo->getTypeLoc().getSourceRange().getBegin();
Eli Friedman59c04372009-07-29 19:44:27 +00001167 if (!BaseType->isDependentType()) {
1168 if (!BaseType->isRecordType())
Douglas Gregor802ab452009-12-02 22:36:29 +00001169 return Diag(BaseLoc, diag::err_base_init_does_not_name_class)
John McCalla93c9342009-12-07 02:54:59 +00001170 << BaseType << BaseTInfo->getTypeLoc().getSourceRange();
Eli Friedman59c04372009-07-29 19:44:27 +00001171
1172 // C++ [class.base.init]p2:
1173 // [...] Unless the mem-initializer-id names a nonstatic data
1174 // member of the constructor’s class or a direct or virtual base
1175 // of that class, the mem-initializer is ill-formed. A
1176 // mem-initializer-list can initialize a base class using any
1177 // name that denotes that base class type.
Mike Stump1eb44332009-09-09 15:08:12 +00001178
Eli Friedman59c04372009-07-29 19:44:27 +00001179 // First, check for a direct base class.
1180 const CXXBaseSpecifier *DirectBaseSpec = 0;
1181 for (CXXRecordDecl::base_class_const_iterator Base =
1182 ClassDecl->bases_begin(); Base != ClassDecl->bases_end(); ++Base) {
Douglas Gregora4923eb2009-11-16 21:35:15 +00001183 if (Context.hasSameUnqualifiedType(BaseType, Base->getType())) {
Eli Friedman59c04372009-07-29 19:44:27 +00001184 // We found a direct base of this type. That's what we're
1185 // initializing.
1186 DirectBaseSpec = &*Base;
1187 break;
1188 }
1189 }
Mike Stump1eb44332009-09-09 15:08:12 +00001190
Eli Friedman59c04372009-07-29 19:44:27 +00001191 // Check for a virtual base class.
1192 // FIXME: We might be able to short-circuit this if we know in advance that
1193 // there are no virtual bases.
1194 const CXXBaseSpecifier *VirtualBaseSpec = 0;
1195 if (!DirectBaseSpec || !DirectBaseSpec->isVirtual()) {
1196 // We haven't found a base yet; search the class hierarchy for a
1197 // virtual base class.
Douglas Gregora8f32e02009-10-06 17:59:45 +00001198 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
1199 /*DetectVirtual=*/false);
Eli Friedman59c04372009-07-29 19:44:27 +00001200 if (IsDerivedFrom(Context.getTypeDeclType(ClassDecl), BaseType, Paths)) {
Douglas Gregora8f32e02009-10-06 17:59:45 +00001201 for (CXXBasePaths::paths_iterator Path = Paths.begin();
Eli Friedman59c04372009-07-29 19:44:27 +00001202 Path != Paths.end(); ++Path) {
1203 if (Path->back().Base->isVirtual()) {
1204 VirtualBaseSpec = Path->back().Base;
1205 break;
1206 }
Douglas Gregor7ad83902008-11-05 04:29:56 +00001207 }
1208 }
1209 }
Eli Friedman59c04372009-07-29 19:44:27 +00001210
1211 // C++ [base.class.init]p2:
1212 // If a mem-initializer-id is ambiguous because it designates both
1213 // a direct non-virtual base class and an inherited virtual base
1214 // class, the mem-initializer is ill-formed.
1215 if (DirectBaseSpec && VirtualBaseSpec)
Douglas Gregor802ab452009-12-02 22:36:29 +00001216 return Diag(BaseLoc, diag::err_base_init_direct_and_virtual)
John McCalla93c9342009-12-07 02:54:59 +00001217 << BaseType << BaseTInfo->getTypeLoc().getSourceRange();
Eli Friedman59c04372009-07-29 19:44:27 +00001218 // C++ [base.class.init]p2:
1219 // Unless the mem-initializer-id names a nonstatic data membeer of the
1220 // constructor's class ot a direst or virtual base of that class, the
1221 // mem-initializer is ill-formed.
1222 if (!DirectBaseSpec && !VirtualBaseSpec)
Douglas Gregor802ab452009-12-02 22:36:29 +00001223 return Diag(BaseLoc, diag::err_not_direct_base_or_virtual)
1224 << BaseType << ClassDecl->getNameAsCString()
John McCalla93c9342009-12-07 02:54:59 +00001225 << BaseTInfo->getTypeLoc().getSourceRange();
Douglas Gregor7ad83902008-11-05 04:29:56 +00001226 }
1227
Fariborz Jahaniand7b27e12009-07-23 00:42:24 +00001228 CXXConstructorDecl *C = 0;
Eli Friedman59c04372009-07-29 19:44:27 +00001229 if (!BaseType->isDependentType() && !HasDependentArg) {
1230 DeclarationName Name = Context.DeclarationNames.getCXXConstructorName(
Douglas Gregor3eaa9ff2009-11-08 07:12:55 +00001231 Context.getCanonicalType(BaseType).getUnqualifiedType());
Douglas Gregor39da0b82009-09-09 23:08:42 +00001232 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(*this);
1233
1234 C = PerformInitializationByConstructor(BaseType,
1235 MultiExprArg(*this,
1236 (void**)Args, NumArgs),
Douglas Gregor802ab452009-12-02 22:36:29 +00001237 BaseLoc,
1238 SourceRange(BaseLoc, RParenLoc),
Douglas Gregor20093b42009-12-09 23:02:17 +00001239 Name,
1240 InitializationKind::CreateDirect(BaseLoc, LParenLoc, RParenLoc),
Douglas Gregor39da0b82009-09-09 23:08:42 +00001241 ConstructorArgs);
1242 if (C) {
1243 // Take over the constructor arguments as our own.
1244 NumArgs = ConstructorArgs.size();
1245 Args = (Expr **)ConstructorArgs.take();
1246 }
Eli Friedman59c04372009-07-29 19:44:27 +00001247 }
1248
Anders Carlssonf8a9a792009-11-13 19:21:49 +00001249 // FIXME: CXXBaseOrMemberInitializer should only contain a single
1250 // subexpression so we can wrap it in a CXXExprWithTemporaries if necessary.
1251 ExprTemporaries.clear();
1252
John McCalla93c9342009-12-07 02:54:59 +00001253 return new (Context) CXXBaseOrMemberInitializer(Context, BaseTInfo, C,
Douglas Gregor802ab452009-12-02 22:36:29 +00001254 LParenLoc, (Expr **)Args,
1255 NumArgs, RParenLoc);
Douglas Gregor7ad83902008-11-05 04:29:56 +00001256}
1257
Eli Friedman80c30da2009-11-09 19:20:36 +00001258bool
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00001259Sema::SetBaseOrMemberInitializers(CXXConstructorDecl *Constructor,
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001260 CXXBaseOrMemberInitializer **Initializers,
1261 unsigned NumInitializers,
Eli Friedman49c16da2009-11-09 01:05:47 +00001262 bool IsImplicitConstructor) {
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001263 // We need to build the initializer AST according to order of construction
1264 // and not what user specified in the Initializers list.
1265 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Constructor->getDeclContext());
1266 llvm::SmallVector<CXXBaseOrMemberInitializer*, 32> AllToInit;
1267 llvm::DenseMap<const void *, CXXBaseOrMemberInitializer*> AllBaseFields;
1268 bool HasDependentBaseInit = false;
Eli Friedman80c30da2009-11-09 19:20:36 +00001269 bool HadError = false;
Mike Stump1eb44332009-09-09 15:08:12 +00001270
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001271 for (unsigned i = 0; i < NumInitializers; i++) {
1272 CXXBaseOrMemberInitializer *Member = Initializers[i];
1273 if (Member->isBaseInitializer()) {
1274 if (Member->getBaseClass()->isDependentType())
1275 HasDependentBaseInit = true;
1276 AllBaseFields[Member->getBaseClass()->getAs<RecordType>()] = Member;
1277 } else {
1278 AllBaseFields[Member->getMember()] = Member;
1279 }
1280 }
Mike Stump1eb44332009-09-09 15:08:12 +00001281
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001282 if (HasDependentBaseInit) {
1283 // FIXME. This does not preserve the ordering of the initializers.
1284 // Try (with -Wreorder)
1285 // template<class X> struct A {};
Mike Stump1eb44332009-09-09 15:08:12 +00001286 // template<class X> struct B : A<X> {
1287 // B() : x1(10), A<X>() {}
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001288 // int x1;
1289 // };
1290 // B<int> x;
1291 // On seeing one dependent type, we should essentially exit this routine
1292 // while preserving user-declared initializer list. When this routine is
1293 // called during instantiatiation process, this routine will rebuild the
John McCall6aee6212009-11-04 23:13:52 +00001294 // ordered initializer list correctly.
Mike Stump1eb44332009-09-09 15:08:12 +00001295
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001296 // If we have a dependent base initialization, we can't determine the
1297 // association between initializers and bases; just dump the known
1298 // initializers into the list, and don't try to deal with other bases.
1299 for (unsigned i = 0; i < NumInitializers; i++) {
1300 CXXBaseOrMemberInitializer *Member = Initializers[i];
1301 if (Member->isBaseInitializer())
1302 AllToInit.push_back(Member);
1303 }
1304 } else {
1305 // Push virtual bases before others.
1306 for (CXXRecordDecl::base_class_iterator VBase =
1307 ClassDecl->vbases_begin(),
1308 E = ClassDecl->vbases_end(); VBase != E; ++VBase) {
1309 if (VBase->getType()->isDependentType())
1310 continue;
Douglas Gregorc07a4942009-11-15 08:51:10 +00001311 if (CXXBaseOrMemberInitializer *Value
1312 = AllBaseFields.lookup(VBase->getType()->getAs<RecordType>())) {
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001313 AllToInit.push_back(Value);
Fariborz Jahanian9d436202009-09-03 21:32:41 +00001314 }
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001315 else {
Mike Stump1eb44332009-09-09 15:08:12 +00001316 CXXRecordDecl *VBaseDecl =
Douglas Gregor802ab452009-12-02 22:36:29 +00001317 cast<CXXRecordDecl>(VBase->getType()->getAs<RecordType>()->getDecl());
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00001318 assert(VBaseDecl && "SetBaseOrMemberInitializers - VBaseDecl null");
Fariborz Jahanian9d436202009-09-03 21:32:41 +00001319 CXXConstructorDecl *Ctor = VBaseDecl->getDefaultConstructor(Context);
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00001320 if (!Ctor) {
Eli Friedman49c16da2009-11-09 01:05:47 +00001321 Diag(Constructor->getLocation(), diag::err_missing_default_ctor)
1322 << (int)IsImplicitConstructor << Context.getTagDeclType(ClassDecl)
1323 << 0 << VBase->getType();
Douglas Gregor9af2f522009-12-01 16:58:18 +00001324 Diag(VBaseDecl->getLocation(), diag::note_previous_decl)
Eli Friedman49c16da2009-11-09 01:05:47 +00001325 << Context.getTagDeclType(VBaseDecl);
Eli Friedman80c30da2009-11-09 19:20:36 +00001326 HadError = true;
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00001327 continue;
1328 }
Fariborz Jahanian9d436202009-09-03 21:32:41 +00001329
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00001330 ASTOwningVector<&ActionBase::DeleteExpr> CtorArgs(*this);
1331 if (CompleteConstructorCall(Ctor, MultiExprArg(*this, 0, 0),
1332 Constructor->getLocation(), CtorArgs))
1333 continue;
1334
1335 MarkDeclarationReferenced(Constructor->getLocation(), Ctor);
1336
Anders Carlsson8db68da2009-11-13 20:11:49 +00001337 // FIXME: CXXBaseOrMemberInitializer should only contain a single
Douglas Gregor802ab452009-12-02 22:36:29 +00001338 // subexpression so we can wrap it in a CXXExprWithTemporaries if
1339 // necessary.
1340 // FIXME: Is there any better source-location information we can give?
Anders Carlsson8db68da2009-11-13 20:11:49 +00001341 ExprTemporaries.clear();
Mike Stump1eb44332009-09-09 15:08:12 +00001342 CXXBaseOrMemberInitializer *Member =
Douglas Gregor802ab452009-12-02 22:36:29 +00001343 new (Context) CXXBaseOrMemberInitializer(Context,
John McCalla93c9342009-12-07 02:54:59 +00001344 Context.getTrivialTypeSourceInfo(VBase->getType(),
Douglas Gregor802ab452009-12-02 22:36:29 +00001345 SourceLocation()),
1346 Ctor,
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00001347 SourceLocation(),
Douglas Gregor802ab452009-12-02 22:36:29 +00001348 CtorArgs.takeAs<Expr>(),
1349 CtorArgs.size(),
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00001350 SourceLocation());
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001351 AllToInit.push_back(Member);
1352 }
1353 }
Mike Stump1eb44332009-09-09 15:08:12 +00001354
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001355 for (CXXRecordDecl::base_class_iterator Base =
1356 ClassDecl->bases_begin(),
1357 E = ClassDecl->bases_end(); Base != E; ++Base) {
1358 // Virtuals are in the virtual base list and already constructed.
1359 if (Base->isVirtual())
1360 continue;
1361 // Skip dependent types.
1362 if (Base->getType()->isDependentType())
1363 continue;
Douglas Gregorc07a4942009-11-15 08:51:10 +00001364 if (CXXBaseOrMemberInitializer *Value
1365 = AllBaseFields.lookup(Base->getType()->getAs<RecordType>())) {
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001366 AllToInit.push_back(Value);
Fariborz Jahanian9d436202009-09-03 21:32:41 +00001367 }
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001368 else {
Mike Stump1eb44332009-09-09 15:08:12 +00001369 CXXRecordDecl *BaseDecl =
Fariborz Jahanian9d436202009-09-03 21:32:41 +00001370 cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00001371 assert(BaseDecl && "SetBaseOrMemberInitializers - BaseDecl null");
Fariborz Jahanian9d436202009-09-03 21:32:41 +00001372 CXXConstructorDecl *Ctor = BaseDecl->getDefaultConstructor(Context);
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00001373 if (!Ctor) {
Eli Friedman49c16da2009-11-09 01:05:47 +00001374 Diag(Constructor->getLocation(), diag::err_missing_default_ctor)
1375 << (int)IsImplicitConstructor << Context.getTagDeclType(ClassDecl)
1376 << 0 << Base->getType();
Douglas Gregor9af2f522009-12-01 16:58:18 +00001377 Diag(BaseDecl->getLocation(), diag::note_previous_decl)
Eli Friedman49c16da2009-11-09 01:05:47 +00001378 << Context.getTagDeclType(BaseDecl);
Eli Friedman80c30da2009-11-09 19:20:36 +00001379 HadError = true;
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00001380 continue;
1381 }
1382
1383 ASTOwningVector<&ActionBase::DeleteExpr> CtorArgs(*this);
1384 if (CompleteConstructorCall(Ctor, MultiExprArg(*this, 0, 0),
1385 Constructor->getLocation(), CtorArgs))
1386 continue;
1387
1388 MarkDeclarationReferenced(Constructor->getLocation(), Ctor);
Fariborz Jahanian9d436202009-09-03 21:32:41 +00001389
Anders Carlsson8db68da2009-11-13 20:11:49 +00001390 // FIXME: CXXBaseOrMemberInitializer should only contain a single
Douglas Gregor802ab452009-12-02 22:36:29 +00001391 // subexpression so we can wrap it in a CXXExprWithTemporaries if
1392 // necessary.
1393 // FIXME: Is there any better source-location information we can give?
Anders Carlsson8db68da2009-11-13 20:11:49 +00001394 ExprTemporaries.clear();
Mike Stump1eb44332009-09-09 15:08:12 +00001395 CXXBaseOrMemberInitializer *Member =
Douglas Gregor802ab452009-12-02 22:36:29 +00001396 new (Context) CXXBaseOrMemberInitializer(Context,
John McCalla93c9342009-12-07 02:54:59 +00001397 Context.getTrivialTypeSourceInfo(Base->getType(),
Douglas Gregor802ab452009-12-02 22:36:29 +00001398 SourceLocation()),
1399 Ctor,
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00001400 SourceLocation(),
Douglas Gregor802ab452009-12-02 22:36:29 +00001401 CtorArgs.takeAs<Expr>(),
1402 CtorArgs.size(),
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00001403 SourceLocation());
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001404 AllToInit.push_back(Member);
1405 }
1406 }
1407 }
Mike Stump1eb44332009-09-09 15:08:12 +00001408
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001409 // non-static data members.
1410 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
1411 E = ClassDecl->field_end(); Field != E; ++Field) {
1412 if ((*Field)->isAnonymousStructOrUnion()) {
Mike Stump1eb44332009-09-09 15:08:12 +00001413 if (const RecordType *FieldClassType =
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001414 Field->getType()->getAs<RecordType>()) {
1415 CXXRecordDecl *FieldClassDecl
Douglas Gregorafe7ec22009-11-13 18:34:26 +00001416 = cast<CXXRecordDecl>(FieldClassType->getDecl());
Mike Stump1eb44332009-09-09 15:08:12 +00001417 for (RecordDecl::field_iterator FA = FieldClassDecl->field_begin(),
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001418 EA = FieldClassDecl->field_end(); FA != EA; FA++) {
1419 if (CXXBaseOrMemberInitializer *Value = AllBaseFields.lookup(*FA)) {
1420 // 'Member' is the anonymous union field and 'AnonUnionMember' is
1421 // set to the anonymous union data member used in the initializer
1422 // list.
1423 Value->setMember(*Field);
1424 Value->setAnonUnionMember(*FA);
1425 AllToInit.push_back(Value);
1426 break;
1427 }
1428 }
1429 }
1430 continue;
1431 }
1432 if (CXXBaseOrMemberInitializer *Value = AllBaseFields.lookup(*Field)) {
1433 AllToInit.push_back(Value);
1434 continue;
1435 }
Mike Stump1eb44332009-09-09 15:08:12 +00001436
Eli Friedman49c16da2009-11-09 01:05:47 +00001437 if ((*Field)->getType()->isDependentType())
Douglas Gregor1fe6b912009-11-04 17:16:11 +00001438 continue;
Douglas Gregor1fe6b912009-11-04 17:16:11 +00001439
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001440 QualType FT = Context.getBaseElementType((*Field)->getType());
1441 if (const RecordType* RT = FT->getAs<RecordType>()) {
1442 CXXConstructorDecl *Ctor =
1443 cast<CXXRecordDecl>(RT->getDecl())->getDefaultConstructor(Context);
Douglas Gregor1fe6b912009-11-04 17:16:11 +00001444 if (!Ctor) {
Eli Friedman49c16da2009-11-09 01:05:47 +00001445 Diag(Constructor->getLocation(), diag::err_missing_default_ctor)
1446 << (int)IsImplicitConstructor << Context.getTagDeclType(ClassDecl)
1447 << 1 << (*Field)->getDeclName();
1448 Diag(Field->getLocation(), diag::note_field_decl);
Douglas Gregor9af2f522009-12-01 16:58:18 +00001449 Diag(RT->getDecl()->getLocation(), diag::note_previous_decl)
Eli Friedman49c16da2009-11-09 01:05:47 +00001450 << Context.getTagDeclType(RT->getDecl());
Eli Friedman80c30da2009-11-09 19:20:36 +00001451 HadError = true;
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00001452 continue;
1453 }
Eli Friedmane73d3bc2009-11-16 23:07:59 +00001454
1455 if (FT.isConstQualified() && Ctor->isTrivial()) {
1456 Diag(Constructor->getLocation(), diag::err_unintialized_member_in_ctor)
1457 << (int)IsImplicitConstructor << Context.getTagDeclType(ClassDecl)
1458 << 1 << (*Field)->getDeclName();
1459 Diag((*Field)->getLocation(), diag::note_declared_at);
1460 HadError = true;
1461 }
1462
1463 // Don't create initializers for trivial constructors, since they don't
1464 // actually need to be run.
1465 if (Ctor->isTrivial())
1466 continue;
1467
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00001468 ASTOwningVector<&ActionBase::DeleteExpr> CtorArgs(*this);
1469 if (CompleteConstructorCall(Ctor, MultiExprArg(*this, 0, 0),
1470 Constructor->getLocation(), CtorArgs))
1471 continue;
1472
Anders Carlsson8db68da2009-11-13 20:11:49 +00001473 // FIXME: CXXBaseOrMemberInitializer should only contain a single
1474 // subexpression so we can wrap it in a CXXExprWithTemporaries if necessary.
1475 ExprTemporaries.clear();
Mike Stump1eb44332009-09-09 15:08:12 +00001476 CXXBaseOrMemberInitializer *Member =
Douglas Gregor802ab452009-12-02 22:36:29 +00001477 new (Context) CXXBaseOrMemberInitializer(Context,
1478 *Field, SourceLocation(),
1479 Ctor,
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00001480 SourceLocation(),
Douglas Gregor802ab452009-12-02 22:36:29 +00001481 CtorArgs.takeAs<Expr>(),
1482 CtorArgs.size(),
Anders Carlsson0ebb6d32009-10-29 15:46:07 +00001483 SourceLocation());
1484
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001485 AllToInit.push_back(Member);
Eli Friedman49c16da2009-11-09 01:05:47 +00001486 MarkDeclarationReferenced(Constructor->getLocation(), Ctor);
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001487 }
1488 else if (FT->isReferenceType()) {
1489 Diag(Constructor->getLocation(), diag::err_unintialized_member_in_ctor)
Eli Friedman49c16da2009-11-09 01:05:47 +00001490 << (int)IsImplicitConstructor << Context.getTagDeclType(ClassDecl)
1491 << 0 << (*Field)->getDeclName();
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001492 Diag((*Field)->getLocation(), diag::note_declared_at);
Eli Friedman80c30da2009-11-09 19:20:36 +00001493 HadError = true;
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001494 }
1495 else if (FT.isConstQualified()) {
1496 Diag(Constructor->getLocation(), diag::err_unintialized_member_in_ctor)
Eli Friedman49c16da2009-11-09 01:05:47 +00001497 << (int)IsImplicitConstructor << Context.getTagDeclType(ClassDecl)
1498 << 1 << (*Field)->getDeclName();
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001499 Diag((*Field)->getLocation(), diag::note_declared_at);
Eli Friedman80c30da2009-11-09 19:20:36 +00001500 HadError = true;
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001501 }
1502 }
Mike Stump1eb44332009-09-09 15:08:12 +00001503
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001504 NumInitializers = AllToInit.size();
1505 if (NumInitializers > 0) {
1506 Constructor->setNumBaseOrMemberInitializers(NumInitializers);
1507 CXXBaseOrMemberInitializer **baseOrMemberInitializers =
1508 new (Context) CXXBaseOrMemberInitializer*[NumInitializers];
Mike Stump1eb44332009-09-09 15:08:12 +00001509
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001510 Constructor->setBaseOrMemberInitializers(baseOrMemberInitializers);
1511 for (unsigned Idx = 0; Idx < NumInitializers; ++Idx)
1512 baseOrMemberInitializers[Idx] = AllToInit[Idx];
1513 }
Eli Friedman80c30da2009-11-09 19:20:36 +00001514
1515 return HadError;
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00001516}
1517
Eli Friedman6347f422009-07-21 19:28:10 +00001518static void *GetKeyForTopLevelField(FieldDecl *Field) {
1519 // For anonymous unions, use the class declaration as the key.
Ted Kremenek6217b802009-07-29 21:53:49 +00001520 if (const RecordType *RT = Field->getType()->getAs<RecordType>()) {
Eli Friedman6347f422009-07-21 19:28:10 +00001521 if (RT->getDecl()->isAnonymousStructOrUnion())
1522 return static_cast<void *>(RT->getDecl());
1523 }
1524 return static_cast<void *>(Field);
1525}
1526
Anders Carlssoncdc83c72009-09-01 06:22:14 +00001527static void *GetKeyForBase(QualType BaseType) {
1528 if (const RecordType *RT = BaseType->getAs<RecordType>())
1529 return (void *)RT;
Mike Stump1eb44332009-09-09 15:08:12 +00001530
Anders Carlssoncdc83c72009-09-01 06:22:14 +00001531 assert(0 && "Unexpected base type!");
1532 return 0;
1533}
1534
Mike Stump1eb44332009-09-09 15:08:12 +00001535static void *GetKeyForMember(CXXBaseOrMemberInitializer *Member,
Anders Carlssoncdc83c72009-09-01 06:22:14 +00001536 bool MemberMaybeAnon = false) {
Eli Friedman6347f422009-07-21 19:28:10 +00001537 // For fields injected into the class via declaration of an anonymous union,
1538 // use its anonymous union class declaration as the unique key.
Anders Carlssoncdc83c72009-09-01 06:22:14 +00001539 if (Member->isMemberInitializer()) {
1540 FieldDecl *Field = Member->getMember();
Mike Stump1eb44332009-09-09 15:08:12 +00001541
Eli Friedman49c16da2009-11-09 01:05:47 +00001542 // After SetBaseOrMemberInitializers call, Field is the anonymous union
Mike Stump1eb44332009-09-09 15:08:12 +00001543 // data member of the class. Data member used in the initializer list is
Fariborz Jahaniane6494122009-08-11 18:49:54 +00001544 // in AnonUnionMember field.
1545 if (MemberMaybeAnon && Field->isAnonymousStructOrUnion())
1546 Field = Member->getAnonUnionMember();
Eli Friedman6347f422009-07-21 19:28:10 +00001547 if (Field->getDeclContext()->isRecord()) {
1548 RecordDecl *RD = cast<RecordDecl>(Field->getDeclContext());
1549 if (RD->isAnonymousStructOrUnion())
1550 return static_cast<void *>(RD);
1551 }
1552 return static_cast<void *>(Field);
1553 }
Mike Stump1eb44332009-09-09 15:08:12 +00001554
Anders Carlssoncdc83c72009-09-01 06:22:14 +00001555 return GetKeyForBase(QualType(Member->getBaseClass(), 0));
Eli Friedman6347f422009-07-21 19:28:10 +00001556}
1557
John McCall6aee6212009-11-04 23:13:52 +00001558/// ActOnMemInitializers - Handle the member initializers for a constructor.
Mike Stump1eb44332009-09-09 15:08:12 +00001559void Sema::ActOnMemInitializers(DeclPtrTy ConstructorDecl,
Anders Carlssona7b35212009-03-25 02:58:17 +00001560 SourceLocation ColonLoc,
1561 MemInitTy **MemInits, unsigned NumMemInits) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +00001562 if (!ConstructorDecl)
1563 return;
Douglas Gregorefd5bda2009-08-24 11:57:43 +00001564
1565 AdjustDeclIfTemplate(ConstructorDecl);
Mike Stump1eb44332009-09-09 15:08:12 +00001566
1567 CXXConstructorDecl *Constructor
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +00001568 = dyn_cast<CXXConstructorDecl>(ConstructorDecl.getAs<Decl>());
Mike Stump1eb44332009-09-09 15:08:12 +00001569
Anders Carlssona7b35212009-03-25 02:58:17 +00001570 if (!Constructor) {
1571 Diag(ColonLoc, diag::err_only_constructors_take_base_inits);
1572 return;
1573 }
Mike Stump1eb44332009-09-09 15:08:12 +00001574
Anders Carlsson8d4c5ea2009-08-27 05:57:30 +00001575 if (!Constructor->isDependentContext()) {
1576 llvm::DenseMap<void*, CXXBaseOrMemberInitializer *>Members;
1577 bool err = false;
1578 for (unsigned i = 0; i < NumMemInits; i++) {
Mike Stump1eb44332009-09-09 15:08:12 +00001579 CXXBaseOrMemberInitializer *Member =
Anders Carlsson8d4c5ea2009-08-27 05:57:30 +00001580 static_cast<CXXBaseOrMemberInitializer*>(MemInits[i]);
1581 void *KeyToMember = GetKeyForMember(Member);
1582 CXXBaseOrMemberInitializer *&PrevMember = Members[KeyToMember];
1583 if (!PrevMember) {
1584 PrevMember = Member;
1585 continue;
1586 }
1587 if (FieldDecl *Field = Member->getMember())
Mike Stump1eb44332009-09-09 15:08:12 +00001588 Diag(Member->getSourceLocation(),
Anders Carlsson8d4c5ea2009-08-27 05:57:30 +00001589 diag::error_multiple_mem_initialization)
Douglas Gregor802ab452009-12-02 22:36:29 +00001590 << Field->getNameAsString()
1591 << Member->getSourceRange();
Anders Carlsson8d4c5ea2009-08-27 05:57:30 +00001592 else {
1593 Type *BaseClass = Member->getBaseClass();
1594 assert(BaseClass && "ActOnMemInitializers - neither field or base");
Mike Stump1eb44332009-09-09 15:08:12 +00001595 Diag(Member->getSourceLocation(),
Anders Carlsson8d4c5ea2009-08-27 05:57:30 +00001596 diag::error_multiple_base_initialization)
Douglas Gregor802ab452009-12-02 22:36:29 +00001597 << QualType(BaseClass, 0)
1598 << Member->getSourceRange();
Anders Carlsson8d4c5ea2009-08-27 05:57:30 +00001599 }
1600 Diag(PrevMember->getSourceLocation(), diag::note_previous_initializer)
1601 << 0;
1602 err = true;
1603 }
Mike Stump1eb44332009-09-09 15:08:12 +00001604
Anders Carlsson8d4c5ea2009-08-27 05:57:30 +00001605 if (err)
1606 return;
1607 }
Mike Stump1eb44332009-09-09 15:08:12 +00001608
Eli Friedman49c16da2009-11-09 01:05:47 +00001609 SetBaseOrMemberInitializers(Constructor,
Mike Stump1eb44332009-09-09 15:08:12 +00001610 reinterpret_cast<CXXBaseOrMemberInitializer **>(MemInits),
Eli Friedman49c16da2009-11-09 01:05:47 +00001611 NumMemInits, false);
Mike Stump1eb44332009-09-09 15:08:12 +00001612
Anders Carlsson8d4c5ea2009-08-27 05:57:30 +00001613 if (Constructor->isDependentContext())
1614 return;
Mike Stump1eb44332009-09-09 15:08:12 +00001615
1616 if (Diags.getDiagnosticLevel(diag::warn_base_initialized) ==
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001617 Diagnostic::Ignored &&
Mike Stump1eb44332009-09-09 15:08:12 +00001618 Diags.getDiagnosticLevel(diag::warn_field_initialized) ==
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001619 Diagnostic::Ignored)
1620 return;
Mike Stump1eb44332009-09-09 15:08:12 +00001621
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001622 // Also issue warning if order of ctor-initializer list does not match order
1623 // of 1) base class declarations and 2) order of non-static data members.
1624 llvm::SmallVector<const void*, 32> AllBaseOrMembers;
Mike Stump1eb44332009-09-09 15:08:12 +00001625
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001626 CXXRecordDecl *ClassDecl
1627 = cast<CXXRecordDecl>(Constructor->getDeclContext());
1628 // Push virtual bases before others.
1629 for (CXXRecordDecl::base_class_iterator VBase =
1630 ClassDecl->vbases_begin(),
1631 E = ClassDecl->vbases_end(); VBase != E; ++VBase)
Anders Carlssoncdc83c72009-09-01 06:22:14 +00001632 AllBaseOrMembers.push_back(GetKeyForBase(VBase->getType()));
Mike Stump1eb44332009-09-09 15:08:12 +00001633
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001634 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
1635 E = ClassDecl->bases_end(); Base != E; ++Base) {
1636 // Virtuals are alread in the virtual base list and are constructed
1637 // first.
1638 if (Base->isVirtual())
1639 continue;
Anders Carlssoncdc83c72009-09-01 06:22:14 +00001640 AllBaseOrMembers.push_back(GetKeyForBase(Base->getType()));
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001641 }
Mike Stump1eb44332009-09-09 15:08:12 +00001642
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001643 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
1644 E = ClassDecl->field_end(); Field != E; ++Field)
1645 AllBaseOrMembers.push_back(GetKeyForTopLevelField(*Field));
Mike Stump1eb44332009-09-09 15:08:12 +00001646
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001647 int Last = AllBaseOrMembers.size();
1648 int curIndex = 0;
1649 CXXBaseOrMemberInitializer *PrevMember = 0;
1650 for (unsigned i = 0; i < NumMemInits; i++) {
Mike Stump1eb44332009-09-09 15:08:12 +00001651 CXXBaseOrMemberInitializer *Member =
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001652 static_cast<CXXBaseOrMemberInitializer*>(MemInits[i]);
1653 void *MemberInCtorList = GetKeyForMember(Member, true);
Eli Friedman6347f422009-07-21 19:28:10 +00001654
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001655 for (; curIndex < Last; curIndex++)
1656 if (MemberInCtorList == AllBaseOrMembers[curIndex])
1657 break;
1658 if (curIndex == Last) {
1659 assert(PrevMember && "Member not in member list?!");
1660 // Initializer as specified in ctor-initializer list is out of order.
1661 // Issue a warning diagnostic.
1662 if (PrevMember->isBaseInitializer()) {
1663 // Diagnostics is for an initialized base class.
1664 Type *BaseClass = PrevMember->getBaseClass();
1665 Diag(PrevMember->getSourceLocation(),
Mike Stump1eb44332009-09-09 15:08:12 +00001666 diag::warn_base_initialized)
John McCallbf1cc052009-09-29 23:03:30 +00001667 << QualType(BaseClass, 0);
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001668 } else {
1669 FieldDecl *Field = PrevMember->getMember();
1670 Diag(PrevMember->getSourceLocation(),
Mike Stump1eb44332009-09-09 15:08:12 +00001671 diag::warn_field_initialized)
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001672 << Field->getNameAsString();
Fariborz Jahanianeb96e122009-07-09 19:59:47 +00001673 }
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001674 // Also the note!
1675 if (FieldDecl *Field = Member->getMember())
Mike Stump1eb44332009-09-09 15:08:12 +00001676 Diag(Member->getSourceLocation(),
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001677 diag::note_fieldorbase_initialized_here) << 0
1678 << Field->getNameAsString();
1679 else {
1680 Type *BaseClass = Member->getBaseClass();
Mike Stump1eb44332009-09-09 15:08:12 +00001681 Diag(Member->getSourceLocation(),
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001682 diag::note_fieldorbase_initialized_here) << 1
John McCallbf1cc052009-09-29 23:03:30 +00001683 << QualType(BaseClass, 0);
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001684 }
1685 for (curIndex = 0; curIndex < Last; curIndex++)
Mike Stump1eb44332009-09-09 15:08:12 +00001686 if (MemberInCtorList == AllBaseOrMembers[curIndex])
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001687 break;
Fariborz Jahanianeb96e122009-07-09 19:59:47 +00001688 }
Anders Carlsson5c36fb22009-08-27 05:45:01 +00001689 PrevMember = Member;
Fariborz Jahanianeb96e122009-07-09 19:59:47 +00001690 }
Anders Carlssona7b35212009-03-25 02:58:17 +00001691}
1692
Fariborz Jahanian34374e62009-09-03 23:18:17 +00001693void
Anders Carlsson9f853df2009-11-17 04:44:12 +00001694Sema::MarkBaseAndMemberDestructorsReferenced(CXXDestructorDecl *Destructor) {
1695 // Ignore dependent destructors.
1696 if (Destructor->isDependentContext())
1697 return;
1698
1699 CXXRecordDecl *ClassDecl = Destructor->getParent();
Mike Stump1eb44332009-09-09 15:08:12 +00001700
Anders Carlsson9f853df2009-11-17 04:44:12 +00001701 // Non-static data members.
1702 for (CXXRecordDecl::field_iterator I = ClassDecl->field_begin(),
1703 E = ClassDecl->field_end(); I != E; ++I) {
1704 FieldDecl *Field = *I;
1705
1706 QualType FieldType = Context.getBaseElementType(Field->getType());
1707
1708 const RecordType* RT = FieldType->getAs<RecordType>();
1709 if (!RT)
1710 continue;
1711
1712 CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl());
1713 if (FieldClassDecl->hasTrivialDestructor())
1714 continue;
1715
1716 const CXXDestructorDecl *Dtor = FieldClassDecl->getDestructor(Context);
1717 MarkDeclarationReferenced(Destructor->getLocation(),
1718 const_cast<CXXDestructorDecl*>(Dtor));
1719 }
1720
1721 // Bases.
1722 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
1723 E = ClassDecl->bases_end(); Base != E; ++Base) {
1724 // Ignore virtual bases.
1725 if (Base->isVirtual())
1726 continue;
1727
1728 // Ignore trivial destructors.
1729 CXXRecordDecl *BaseClassDecl
1730 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
1731 if (BaseClassDecl->hasTrivialDestructor())
1732 continue;
1733
1734 const CXXDestructorDecl *Dtor = BaseClassDecl->getDestructor(Context);
1735 MarkDeclarationReferenced(Destructor->getLocation(),
1736 const_cast<CXXDestructorDecl*>(Dtor));
1737 }
1738
1739 // Virtual bases.
Fariborz Jahanian34374e62009-09-03 23:18:17 +00001740 for (CXXRecordDecl::base_class_iterator VBase = ClassDecl->vbases_begin(),
1741 E = ClassDecl->vbases_end(); VBase != E; ++VBase) {
Anders Carlsson9f853df2009-11-17 04:44:12 +00001742 // Ignore trivial destructors.
Fariborz Jahanian34374e62009-09-03 23:18:17 +00001743 CXXRecordDecl *BaseClassDecl
1744 = cast<CXXRecordDecl>(VBase->getType()->getAs<RecordType>()->getDecl());
1745 if (BaseClassDecl->hasTrivialDestructor())
1746 continue;
Anders Carlsson9f853df2009-11-17 04:44:12 +00001747
1748 const CXXDestructorDecl *Dtor = BaseClassDecl->getDestructor(Context);
1749 MarkDeclarationReferenced(Destructor->getLocation(),
1750 const_cast<CXXDestructorDecl*>(Dtor));
Fariborz Jahanian34374e62009-09-03 23:18:17 +00001751 }
1752}
1753
Fariborz Jahanian393612e2009-07-21 22:36:06 +00001754void Sema::ActOnDefaultCtorInitializers(DeclPtrTy CDtorDecl) {
Fariborz Jahanian560de452009-07-15 22:34:08 +00001755 if (!CDtorDecl)
Fariborz Jahaniand01c9152009-07-14 18:24:21 +00001756 return;
Mike Stump1eb44332009-09-09 15:08:12 +00001757
Douglas Gregorefd5bda2009-08-24 11:57:43 +00001758 AdjustDeclIfTemplate(CDtorDecl);
Mike Stump1eb44332009-09-09 15:08:12 +00001759
1760 if (CXXConstructorDecl *Constructor
Fariborz Jahanian560de452009-07-15 22:34:08 +00001761 = dyn_cast<CXXConstructorDecl>(CDtorDecl.getAs<Decl>()))
Eli Friedman49c16da2009-11-09 01:05:47 +00001762 SetBaseOrMemberInitializers(Constructor, 0, 0, false);
Fariborz Jahaniand01c9152009-07-14 18:24:21 +00001763}
1764
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001765namespace {
1766 /// PureVirtualMethodCollector - traverses a class and its superclasses
1767 /// and determines if it has any pure virtual methods.
Benjamin Kramer85b45212009-11-28 19:45:26 +00001768 class PureVirtualMethodCollector {
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001769 ASTContext &Context;
1770
Sebastian Redldfe292d2009-03-22 21:28:55 +00001771 public:
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001772 typedef llvm::SmallVector<const CXXMethodDecl*, 8> MethodList;
Sebastian Redldfe292d2009-03-22 21:28:55 +00001773
1774 private:
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001775 MethodList Methods;
Mike Stump1eb44332009-09-09 15:08:12 +00001776
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001777 void Collect(const CXXRecordDecl* RD, MethodList& Methods);
Mike Stump1eb44332009-09-09 15:08:12 +00001778
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001779 public:
Mike Stump1eb44332009-09-09 15:08:12 +00001780 PureVirtualMethodCollector(ASTContext &Ctx, const CXXRecordDecl* RD)
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001781 : Context(Ctx) {
Mike Stump1eb44332009-09-09 15:08:12 +00001782
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001783 MethodList List;
1784 Collect(RD, List);
Mike Stump1eb44332009-09-09 15:08:12 +00001785
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001786 // Copy the temporary list to methods, and make sure to ignore any
1787 // null entries.
1788 for (size_t i = 0, e = List.size(); i != e; ++i) {
1789 if (List[i])
1790 Methods.push_back(List[i]);
Mike Stump1eb44332009-09-09 15:08:12 +00001791 }
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001792 }
Mike Stump1eb44332009-09-09 15:08:12 +00001793
Anders Carlsson4681ebd2009-03-22 20:18:17 +00001794 bool empty() const { return Methods.empty(); }
Mike Stump1eb44332009-09-09 15:08:12 +00001795
Anders Carlsson4681ebd2009-03-22 20:18:17 +00001796 MethodList::const_iterator methods_begin() { return Methods.begin(); }
1797 MethodList::const_iterator methods_end() { return Methods.end(); }
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001798 };
Mike Stump1eb44332009-09-09 15:08:12 +00001799
1800 void PureVirtualMethodCollector::Collect(const CXXRecordDecl* RD,
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001801 MethodList& Methods) {
1802 // First, collect the pure virtual methods for the base classes.
1803 for (CXXRecordDecl::base_class_const_iterator Base = RD->bases_begin(),
1804 BaseEnd = RD->bases_end(); Base != BaseEnd; ++Base) {
Ted Kremenek6217b802009-07-29 21:53:49 +00001805 if (const RecordType *RT = Base->getType()->getAs<RecordType>()) {
Chris Lattner64540d72009-03-29 05:01:10 +00001806 const CXXRecordDecl *BaseDecl = cast<CXXRecordDecl>(RT->getDecl());
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001807 if (BaseDecl && BaseDecl->isAbstract())
1808 Collect(BaseDecl, Methods);
1809 }
1810 }
Mike Stump1eb44332009-09-09 15:08:12 +00001811
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001812 // Next, zero out any pure virtual methods that this class overrides.
Anders Carlsson8ff8c222009-05-17 00:00:05 +00001813 typedef llvm::SmallPtrSet<const CXXMethodDecl*, 4> MethodSetTy;
Mike Stump1eb44332009-09-09 15:08:12 +00001814
Anders Carlsson8ff8c222009-05-17 00:00:05 +00001815 MethodSetTy OverriddenMethods;
1816 size_t MethodsSize = Methods.size();
1817
Mike Stump1eb44332009-09-09 15:08:12 +00001818 for (RecordDecl::decl_iterator i = RD->decls_begin(), e = RD->decls_end();
Anders Carlsson8ff8c222009-05-17 00:00:05 +00001819 i != e; ++i) {
1820 // Traverse the record, looking for methods.
1821 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(*i)) {
Sebastian Redl23c7d062009-07-07 20:29:57 +00001822 // If the method is pure virtual, add it to the methods vector.
Anders Carlsson27823022009-10-18 19:34:08 +00001823 if (MD->isPure())
Anders Carlsson8ff8c222009-05-17 00:00:05 +00001824 Methods.push_back(MD);
Mike Stump1eb44332009-09-09 15:08:12 +00001825
Anders Carlsson27823022009-10-18 19:34:08 +00001826 // Record all the overridden methods in our set.
Anders Carlsson8ff8c222009-05-17 00:00:05 +00001827 for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(),
1828 E = MD->end_overridden_methods(); I != E; ++I) {
1829 // Keep track of the overridden methods.
1830 OverriddenMethods.insert(*I);
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001831 }
1832 }
1833 }
Mike Stump1eb44332009-09-09 15:08:12 +00001834
1835 // Now go through the methods and zero out all the ones we know are
Anders Carlsson8ff8c222009-05-17 00:00:05 +00001836 // overridden.
1837 for (size_t i = 0, e = MethodsSize; i != e; ++i) {
1838 if (OverriddenMethods.count(Methods[i]))
1839 Methods[i] = 0;
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001840 }
Mike Stump1eb44332009-09-09 15:08:12 +00001841
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001842 }
1843}
Douglas Gregor7ad83902008-11-05 04:29:56 +00001844
Anders Carlssona6ec7ad2009-08-27 00:13:57 +00001845
Mike Stump1eb44332009-09-09 15:08:12 +00001846bool Sema::RequireNonAbstractType(SourceLocation Loc, QualType T,
Anders Carlssone65a3c82009-03-24 17:23:42 +00001847 unsigned DiagID, AbstractDiagSelID SelID,
1848 const CXXRecordDecl *CurrentRD) {
Anders Carlssona6ec7ad2009-08-27 00:13:57 +00001849 if (SelID == -1)
1850 return RequireNonAbstractType(Loc, T,
1851 PDiag(DiagID), CurrentRD);
1852 else
1853 return RequireNonAbstractType(Loc, T,
1854 PDiag(DiagID) << SelID, CurrentRD);
Mike Stump1eb44332009-09-09 15:08:12 +00001855}
1856
Anders Carlssona6ec7ad2009-08-27 00:13:57 +00001857bool Sema::RequireNonAbstractType(SourceLocation Loc, QualType T,
1858 const PartialDiagnostic &PD,
1859 const CXXRecordDecl *CurrentRD) {
Anders Carlsson4681ebd2009-03-22 20:18:17 +00001860 if (!getLangOptions().CPlusPlus)
1861 return false;
Mike Stump1eb44332009-09-09 15:08:12 +00001862
Anders Carlsson11f21a02009-03-23 19:10:31 +00001863 if (const ArrayType *AT = Context.getAsArrayType(T))
Anders Carlssona6ec7ad2009-08-27 00:13:57 +00001864 return RequireNonAbstractType(Loc, AT->getElementType(), PD,
Anders Carlssone65a3c82009-03-24 17:23:42 +00001865 CurrentRD);
Mike Stump1eb44332009-09-09 15:08:12 +00001866
Ted Kremenek6217b802009-07-29 21:53:49 +00001867 if (const PointerType *PT = T->getAs<PointerType>()) {
Anders Carlsson5eff73c2009-03-24 01:46:45 +00001868 // Find the innermost pointer type.
Ted Kremenek6217b802009-07-29 21:53:49 +00001869 while (const PointerType *T = PT->getPointeeType()->getAs<PointerType>())
Anders Carlsson5eff73c2009-03-24 01:46:45 +00001870 PT = T;
Mike Stump1eb44332009-09-09 15:08:12 +00001871
Anders Carlsson5eff73c2009-03-24 01:46:45 +00001872 if (const ArrayType *AT = Context.getAsArrayType(PT->getPointeeType()))
Anders Carlssona6ec7ad2009-08-27 00:13:57 +00001873 return RequireNonAbstractType(Loc, AT->getElementType(), PD, CurrentRD);
Anders Carlsson5eff73c2009-03-24 01:46:45 +00001874 }
Mike Stump1eb44332009-09-09 15:08:12 +00001875
Ted Kremenek6217b802009-07-29 21:53:49 +00001876 const RecordType *RT = T->getAs<RecordType>();
Anders Carlsson4681ebd2009-03-22 20:18:17 +00001877 if (!RT)
1878 return false;
Mike Stump1eb44332009-09-09 15:08:12 +00001879
Anders Carlsson4681ebd2009-03-22 20:18:17 +00001880 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl());
1881 if (!RD)
1882 return false;
1883
Anders Carlssone65a3c82009-03-24 17:23:42 +00001884 if (CurrentRD && CurrentRD != RD)
1885 return false;
Mike Stump1eb44332009-09-09 15:08:12 +00001886
Anders Carlsson4681ebd2009-03-22 20:18:17 +00001887 if (!RD->isAbstract())
1888 return false;
Mike Stump1eb44332009-09-09 15:08:12 +00001889
Anders Carlssona6ec7ad2009-08-27 00:13:57 +00001890 Diag(Loc, PD) << RD->getDeclName();
Mike Stump1eb44332009-09-09 15:08:12 +00001891
Anders Carlsson4681ebd2009-03-22 20:18:17 +00001892 // Check if we've already emitted the list of pure virtual functions for this
1893 // class.
1894 if (PureVirtualClassDiagSet && PureVirtualClassDiagSet->count(RD))
1895 return true;
Mike Stump1eb44332009-09-09 15:08:12 +00001896
Anders Carlsson4681ebd2009-03-22 20:18:17 +00001897 PureVirtualMethodCollector Collector(Context, RD);
Mike Stump1eb44332009-09-09 15:08:12 +00001898
1899 for (PureVirtualMethodCollector::MethodList::const_iterator I =
Anders Carlsson4681ebd2009-03-22 20:18:17 +00001900 Collector.methods_begin(), E = Collector.methods_end(); I != E; ++I) {
1901 const CXXMethodDecl *MD = *I;
Mike Stump1eb44332009-09-09 15:08:12 +00001902
1903 Diag(MD->getLocation(), diag::note_pure_virtual_function) <<
Anders Carlsson4681ebd2009-03-22 20:18:17 +00001904 MD->getDeclName();
1905 }
1906
1907 if (!PureVirtualClassDiagSet)
1908 PureVirtualClassDiagSet.reset(new RecordDeclSetTy);
1909 PureVirtualClassDiagSet->insert(RD);
Mike Stump1eb44332009-09-09 15:08:12 +00001910
Anders Carlsson4681ebd2009-03-22 20:18:17 +00001911 return true;
1912}
1913
Anders Carlsson8211eff2009-03-24 01:19:16 +00001914namespace {
Benjamin Kramer85b45212009-11-28 19:45:26 +00001915 class AbstractClassUsageDiagnoser
Anders Carlsson8211eff2009-03-24 01:19:16 +00001916 : public DeclVisitor<AbstractClassUsageDiagnoser, bool> {
1917 Sema &SemaRef;
1918 CXXRecordDecl *AbstractClass;
Mike Stump1eb44332009-09-09 15:08:12 +00001919
Anders Carlssone65a3c82009-03-24 17:23:42 +00001920 bool VisitDeclContext(const DeclContext *DC) {
Anders Carlsson8211eff2009-03-24 01:19:16 +00001921 bool Invalid = false;
1922
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001923 for (CXXRecordDecl::decl_iterator I = DC->decls_begin(),
1924 E = DC->decls_end(); I != E; ++I)
Anders Carlsson8211eff2009-03-24 01:19:16 +00001925 Invalid |= Visit(*I);
Anders Carlssone65a3c82009-03-24 17:23:42 +00001926
Anders Carlsson8211eff2009-03-24 01:19:16 +00001927 return Invalid;
1928 }
Mike Stump1eb44332009-09-09 15:08:12 +00001929
Anders Carlssone65a3c82009-03-24 17:23:42 +00001930 public:
1931 AbstractClassUsageDiagnoser(Sema& SemaRef, CXXRecordDecl *ac)
1932 : SemaRef(SemaRef), AbstractClass(ac) {
1933 Visit(SemaRef.Context.getTranslationUnitDecl());
1934 }
Anders Carlsson8211eff2009-03-24 01:19:16 +00001935
Anders Carlssone65a3c82009-03-24 17:23:42 +00001936 bool VisitFunctionDecl(const FunctionDecl *FD) {
1937 if (FD->isThisDeclarationADefinition()) {
1938 // No need to do the check if we're in a definition, because it requires
1939 // that the return/param types are complete.
Mike Stump1eb44332009-09-09 15:08:12 +00001940 // because that requires
Anders Carlssone65a3c82009-03-24 17:23:42 +00001941 return VisitDeclContext(FD);
1942 }
Mike Stump1eb44332009-09-09 15:08:12 +00001943
Anders Carlssone65a3c82009-03-24 17:23:42 +00001944 // Check the return type.
John McCall183700f2009-09-21 23:43:11 +00001945 QualType RTy = FD->getType()->getAs<FunctionType>()->getResultType();
Mike Stump1eb44332009-09-09 15:08:12 +00001946 bool Invalid =
Anders Carlssone65a3c82009-03-24 17:23:42 +00001947 SemaRef.RequireNonAbstractType(FD->getLocation(), RTy,
1948 diag::err_abstract_type_in_decl,
1949 Sema::AbstractReturnType,
1950 AbstractClass);
1951
Mike Stump1eb44332009-09-09 15:08:12 +00001952 for (FunctionDecl::param_const_iterator I = FD->param_begin(),
Anders Carlssone65a3c82009-03-24 17:23:42 +00001953 E = FD->param_end(); I != E; ++I) {
Anders Carlsson8211eff2009-03-24 01:19:16 +00001954 const ParmVarDecl *VD = *I;
Mike Stump1eb44332009-09-09 15:08:12 +00001955 Invalid |=
Anders Carlsson8211eff2009-03-24 01:19:16 +00001956 SemaRef.RequireNonAbstractType(VD->getLocation(),
Mike Stump1eb44332009-09-09 15:08:12 +00001957 VD->getOriginalType(),
1958 diag::err_abstract_type_in_decl,
Anders Carlssone65a3c82009-03-24 17:23:42 +00001959 Sema::AbstractParamType,
1960 AbstractClass);
Anders Carlsson8211eff2009-03-24 01:19:16 +00001961 }
1962
1963 return Invalid;
1964 }
Mike Stump1eb44332009-09-09 15:08:12 +00001965
Anders Carlssone65a3c82009-03-24 17:23:42 +00001966 bool VisitDecl(const Decl* D) {
1967 if (const DeclContext *DC = dyn_cast<DeclContext>(D))
1968 return VisitDeclContext(DC);
Mike Stump1eb44332009-09-09 15:08:12 +00001969
Anders Carlssone65a3c82009-03-24 17:23:42 +00001970 return false;
1971 }
Anders Carlsson8211eff2009-03-24 01:19:16 +00001972 };
1973}
1974
Douglas Gregor1ab537b2009-12-03 18:33:45 +00001975/// \brief Perform semantic checks on a class definition that has been
1976/// completing, introducing implicitly-declared members, checking for
1977/// abstract types, etc.
1978void Sema::CheckCompletedCXXClass(CXXRecordDecl *Record) {
1979 if (!Record || Record->isInvalidDecl())
1980 return;
1981
Eli Friedmanff2d8782009-12-16 20:00:27 +00001982 if (!Record->isDependentType())
1983 AddImplicitlyDeclaredMembersToClass(Record);
1984
1985 if (Record->isInvalidDecl())
1986 return;
1987
Douglas Gregor1ab537b2009-12-03 18:33:45 +00001988 if (!Record->isAbstract()) {
1989 // Collect all the pure virtual methods and see if this is an abstract
1990 // class after all.
1991 PureVirtualMethodCollector Collector(Context, Record);
1992 if (!Collector.empty())
1993 Record->setAbstract(true);
1994 }
1995
1996 if (Record->isAbstract())
1997 (void)AbstractClassUsageDiagnoser(*this, Record);
Douglas Gregor1ab537b2009-12-03 18:33:45 +00001998}
1999
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002000void Sema::ActOnFinishCXXMemberSpecification(Scope* S, SourceLocation RLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002001 DeclPtrTy TagDecl,
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002002 SourceLocation LBrac,
2003 SourceLocation RBrac) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +00002004 if (!TagDecl)
2005 return;
Mike Stump1eb44332009-09-09 15:08:12 +00002006
Douglas Gregor42af25f2009-05-11 19:58:34 +00002007 AdjustDeclIfTemplate(TagDecl);
Douglas Gregor1ab537b2009-12-03 18:33:45 +00002008
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002009 ActOnFields(S, RLoc, TagDecl,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002010 (DeclPtrTy*)FieldCollector->getCurFields(),
Daniel Dunbar1bfe1c22008-10-03 02:03:53 +00002011 FieldCollector->getCurNumFields(), LBrac, RBrac, 0);
Douglas Gregor2943aed2009-03-03 04:44:36 +00002012
Douglas Gregor1ab537b2009-12-03 18:33:45 +00002013 CheckCompletedCXXClass(
2014 dyn_cast_or_null<CXXRecordDecl>(TagDecl.getAs<Decl>()));
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002015}
2016
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002017/// AddImplicitlyDeclaredMembersToClass - Adds any implicitly-declared
2018/// special functions, such as the default constructor, copy
2019/// constructor, or destructor, to the given C++ class (C++
2020/// [special]p1). This routine can only be executed just before the
2021/// definition of the class is complete.
2022void Sema::AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl) {
Mike Stump1eb44332009-09-09 15:08:12 +00002023 CanQualType ClassType
Douglas Gregor50d62d12009-08-05 05:36:45 +00002024 = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
Douglas Gregor2e1cd422008-11-17 14:58:09 +00002025
Sebastian Redl465226e2009-05-27 22:11:52 +00002026 // FIXME: Implicit declarations have exception specifications, which are
2027 // the union of the specifications of the implicitly called functions.
2028
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002029 if (!ClassDecl->hasUserDeclaredConstructor()) {
2030 // C++ [class.ctor]p5:
2031 // A default constructor for a class X is a constructor of class X
2032 // that can be called without an argument. If there is no
2033 // user-declared constructor for class X, a default constructor is
2034 // implicitly declared. An implicitly-declared default constructor
2035 // is an inline public member of its class.
Mike Stump1eb44332009-09-09 15:08:12 +00002036 DeclarationName Name
Douglas Gregor2e1cd422008-11-17 14:58:09 +00002037 = Context.DeclarationNames.getCXXConstructorName(ClassType);
Mike Stump1eb44332009-09-09 15:08:12 +00002038 CXXConstructorDecl *DefaultCon =
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002039 CXXConstructorDecl::Create(Context, ClassDecl,
Douglas Gregor2e1cd422008-11-17 14:58:09 +00002040 ClassDecl->getLocation(), Name,
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002041 Context.getFunctionType(Context.VoidTy,
2042 0, 0, false, 0),
John McCalla93c9342009-12-07 02:54:59 +00002043 /*TInfo=*/0,
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002044 /*isExplicit=*/false,
2045 /*isInline=*/true,
2046 /*isImplicitlyDeclared=*/true);
2047 DefaultCon->setAccess(AS_public);
Douglas Gregor6b3945f2009-01-07 19:46:03 +00002048 DefaultCon->setImplicit();
Douglas Gregor1f2023a2009-07-22 18:25:24 +00002049 DefaultCon->setTrivial(ClassDecl->hasTrivialConstructor());
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002050 ClassDecl->addDecl(DefaultCon);
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002051 }
2052
2053 if (!ClassDecl->hasUserDeclaredCopyConstructor()) {
2054 // C++ [class.copy]p4:
2055 // If the class definition does not explicitly declare a copy
2056 // constructor, one is declared implicitly.
2057
2058 // C++ [class.copy]p5:
2059 // The implicitly-declared copy constructor for a class X will
2060 // have the form
2061 //
2062 // X::X(const X&)
2063 //
2064 // if
2065 bool HasConstCopyConstructor = true;
2066
2067 // -- each direct or virtual base class B of X has a copy
2068 // constructor whose first parameter is of type const B& or
2069 // const volatile B&, and
2070 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin();
2071 HasConstCopyConstructor && Base != ClassDecl->bases_end(); ++Base) {
2072 const CXXRecordDecl *BaseClassDecl
Ted Kremenek6217b802009-07-29 21:53:49 +00002073 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Mike Stump1eb44332009-09-09 15:08:12 +00002074 HasConstCopyConstructor
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002075 = BaseClassDecl->hasConstCopyConstructor(Context);
2076 }
2077
2078 // -- for all the nonstatic data members of X that are of a
2079 // class type M (or array thereof), each such class type
2080 // has a copy constructor whose first parameter is of type
2081 // const M& or const volatile M&.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002082 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin();
2083 HasConstCopyConstructor && Field != ClassDecl->field_end();
Douglas Gregor6ab35242009-04-09 21:40:53 +00002084 ++Field) {
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002085 QualType FieldType = (*Field)->getType();
2086 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
2087 FieldType = Array->getElementType();
Ted Kremenek6217b802009-07-29 21:53:49 +00002088 if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
Mike Stump1eb44332009-09-09 15:08:12 +00002089 const CXXRecordDecl *FieldClassDecl
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002090 = cast<CXXRecordDecl>(FieldClassType->getDecl());
Mike Stump1eb44332009-09-09 15:08:12 +00002091 HasConstCopyConstructor
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002092 = FieldClassDecl->hasConstCopyConstructor(Context);
2093 }
2094 }
2095
Sebastian Redl64b45f72009-01-05 20:52:13 +00002096 // Otherwise, the implicitly declared copy constructor will have
2097 // the form
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002098 //
2099 // X::X(X&)
Sebastian Redl64b45f72009-01-05 20:52:13 +00002100 QualType ArgType = ClassType;
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002101 if (HasConstCopyConstructor)
2102 ArgType = ArgType.withConst();
Sebastian Redl7c80bd62009-03-16 23:22:08 +00002103 ArgType = Context.getLValueReferenceType(ArgType);
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002104
Sebastian Redl64b45f72009-01-05 20:52:13 +00002105 // An implicitly-declared copy constructor is an inline public
2106 // member of its class.
Mike Stump1eb44332009-09-09 15:08:12 +00002107 DeclarationName Name
Douglas Gregor2e1cd422008-11-17 14:58:09 +00002108 = Context.DeclarationNames.getCXXConstructorName(ClassType);
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002109 CXXConstructorDecl *CopyConstructor
2110 = CXXConstructorDecl::Create(Context, ClassDecl,
Douglas Gregor2e1cd422008-11-17 14:58:09 +00002111 ClassDecl->getLocation(), Name,
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002112 Context.getFunctionType(Context.VoidTy,
2113 &ArgType, 1,
2114 false, 0),
John McCalla93c9342009-12-07 02:54:59 +00002115 /*TInfo=*/0,
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002116 /*isExplicit=*/false,
2117 /*isInline=*/true,
2118 /*isImplicitlyDeclared=*/true);
2119 CopyConstructor->setAccess(AS_public);
Douglas Gregor6b3945f2009-01-07 19:46:03 +00002120 CopyConstructor->setImplicit();
Douglas Gregor1f2023a2009-07-22 18:25:24 +00002121 CopyConstructor->setTrivial(ClassDecl->hasTrivialCopyConstructor());
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002122
2123 // Add the parameter to the constructor.
2124 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyConstructor,
2125 ClassDecl->getLocation(),
2126 /*IdentifierInfo=*/0,
John McCalla93c9342009-12-07 02:54:59 +00002127 ArgType, /*TInfo=*/0,
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +00002128 VarDecl::None, 0);
Ted Kremenekfc767612009-01-14 00:42:25 +00002129 CopyConstructor->setParams(Context, &FromParam, 1);
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002130 ClassDecl->addDecl(CopyConstructor);
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002131 }
2132
Sebastian Redl64b45f72009-01-05 20:52:13 +00002133 if (!ClassDecl->hasUserDeclaredCopyAssignment()) {
2134 // Note: The following rules are largely analoguous to the copy
2135 // constructor rules. Note that virtual bases are not taken into account
2136 // for determining the argument type of the operator. Note also that
2137 // operators taking an object instead of a reference are allowed.
2138 //
2139 // C++ [class.copy]p10:
2140 // If the class definition does not explicitly declare a copy
2141 // assignment operator, one is declared implicitly.
2142 // The implicitly-defined copy assignment operator for a class X
2143 // will have the form
2144 //
2145 // X& X::operator=(const X&)
2146 //
2147 // if
2148 bool HasConstCopyAssignment = true;
2149
2150 // -- each direct base class B of X has a copy assignment operator
2151 // whose parameter is of type const B&, const volatile B& or B,
2152 // and
2153 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin();
2154 HasConstCopyAssignment && Base != ClassDecl->bases_end(); ++Base) {
Sebastian Redl9994a342009-10-25 17:03:50 +00002155 assert(!Base->getType()->isDependentType() &&
2156 "Cannot generate implicit members for class with dependent bases.");
Sebastian Redl64b45f72009-01-05 20:52:13 +00002157 const CXXRecordDecl *BaseClassDecl
Ted Kremenek6217b802009-07-29 21:53:49 +00002158 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Fariborz Jahanian0270b8a2009-08-12 23:34:46 +00002159 const CXXMethodDecl *MD = 0;
Mike Stump1eb44332009-09-09 15:08:12 +00002160 HasConstCopyAssignment = BaseClassDecl->hasConstCopyAssignment(Context,
Fariborz Jahanian0270b8a2009-08-12 23:34:46 +00002161 MD);
Sebastian Redl64b45f72009-01-05 20:52:13 +00002162 }
2163
2164 // -- for all the nonstatic data members of X that are of a class
2165 // type M (or array thereof), each such class type has a copy
2166 // assignment operator whose parameter is of type const M&,
2167 // const volatile M& or M.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002168 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin();
2169 HasConstCopyAssignment && Field != ClassDecl->field_end();
Douglas Gregor6ab35242009-04-09 21:40:53 +00002170 ++Field) {
Sebastian Redl64b45f72009-01-05 20:52:13 +00002171 QualType FieldType = (*Field)->getType();
2172 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
2173 FieldType = Array->getElementType();
Ted Kremenek6217b802009-07-29 21:53:49 +00002174 if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
Sebastian Redl64b45f72009-01-05 20:52:13 +00002175 const CXXRecordDecl *FieldClassDecl
2176 = cast<CXXRecordDecl>(FieldClassType->getDecl());
Fariborz Jahanian0270b8a2009-08-12 23:34:46 +00002177 const CXXMethodDecl *MD = 0;
Sebastian Redl64b45f72009-01-05 20:52:13 +00002178 HasConstCopyAssignment
Fariborz Jahanian0270b8a2009-08-12 23:34:46 +00002179 = FieldClassDecl->hasConstCopyAssignment(Context, MD);
Sebastian Redl64b45f72009-01-05 20:52:13 +00002180 }
2181 }
2182
2183 // Otherwise, the implicitly declared copy assignment operator will
2184 // have the form
2185 //
2186 // X& X::operator=(X&)
2187 QualType ArgType = ClassType;
Sebastian Redl7c80bd62009-03-16 23:22:08 +00002188 QualType RetType = Context.getLValueReferenceType(ArgType);
Sebastian Redl64b45f72009-01-05 20:52:13 +00002189 if (HasConstCopyAssignment)
2190 ArgType = ArgType.withConst();
Sebastian Redl7c80bd62009-03-16 23:22:08 +00002191 ArgType = Context.getLValueReferenceType(ArgType);
Sebastian Redl64b45f72009-01-05 20:52:13 +00002192
2193 // An implicitly-declared copy assignment operator is an inline public
2194 // member of its class.
2195 DeclarationName Name =
2196 Context.DeclarationNames.getCXXOperatorName(OO_Equal);
2197 CXXMethodDecl *CopyAssignment =
2198 CXXMethodDecl::Create(Context, ClassDecl, ClassDecl->getLocation(), Name,
2199 Context.getFunctionType(RetType, &ArgType, 1,
2200 false, 0),
John McCalla93c9342009-12-07 02:54:59 +00002201 /*TInfo=*/0, /*isStatic=*/false, /*isInline=*/true);
Sebastian Redl64b45f72009-01-05 20:52:13 +00002202 CopyAssignment->setAccess(AS_public);
Douglas Gregor6b3945f2009-01-07 19:46:03 +00002203 CopyAssignment->setImplicit();
Douglas Gregor1f2023a2009-07-22 18:25:24 +00002204 CopyAssignment->setTrivial(ClassDecl->hasTrivialCopyAssignment());
Fariborz Jahanian2198ba12009-08-12 21:14:35 +00002205 CopyAssignment->setCopyAssignment(true);
Sebastian Redl64b45f72009-01-05 20:52:13 +00002206
2207 // Add the parameter to the operator.
2208 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyAssignment,
2209 ClassDecl->getLocation(),
2210 /*IdentifierInfo=*/0,
John McCalla93c9342009-12-07 02:54:59 +00002211 ArgType, /*TInfo=*/0,
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +00002212 VarDecl::None, 0);
Ted Kremenekfc767612009-01-14 00:42:25 +00002213 CopyAssignment->setParams(Context, &FromParam, 1);
Sebastian Redl64b45f72009-01-05 20:52:13 +00002214
2215 // Don't call addedAssignmentOperator. There is no way to distinguish an
2216 // implicit from an explicit assignment operator.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002217 ClassDecl->addDecl(CopyAssignment);
Eli Friedmanca6affd2009-12-02 06:59:20 +00002218 AddOverriddenMethods(ClassDecl, CopyAssignment);
Sebastian Redl64b45f72009-01-05 20:52:13 +00002219 }
2220
Douglas Gregor9e7d9de2008-12-15 21:24:18 +00002221 if (!ClassDecl->hasUserDeclaredDestructor()) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00002222 // C++ [class.dtor]p2:
2223 // If a class has no user-declared destructor, a destructor is
2224 // declared implicitly. An implicitly-declared destructor is an
2225 // inline public member of its class.
Mike Stump1eb44332009-09-09 15:08:12 +00002226 DeclarationName Name
Douglas Gregor2e1cd422008-11-17 14:58:09 +00002227 = Context.DeclarationNames.getCXXDestructorName(ClassType);
Mike Stump1eb44332009-09-09 15:08:12 +00002228 CXXDestructorDecl *Destructor
Douglas Gregor42a552f2008-11-05 20:51:48 +00002229 = CXXDestructorDecl::Create(Context, ClassDecl,
Douglas Gregor2e1cd422008-11-17 14:58:09 +00002230 ClassDecl->getLocation(), Name,
Douglas Gregor42a552f2008-11-05 20:51:48 +00002231 Context.getFunctionType(Context.VoidTy,
2232 0, 0, false, 0),
2233 /*isInline=*/true,
2234 /*isImplicitlyDeclared=*/true);
2235 Destructor->setAccess(AS_public);
Douglas Gregor6b3945f2009-01-07 19:46:03 +00002236 Destructor->setImplicit();
Douglas Gregor1f2023a2009-07-22 18:25:24 +00002237 Destructor->setTrivial(ClassDecl->hasTrivialDestructor());
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002238 ClassDecl->addDecl(Destructor);
Anders Carlssond5a942b2009-11-26 21:25:09 +00002239
2240 AddOverriddenMethods(ClassDecl, Destructor);
Douglas Gregor42a552f2008-11-05 20:51:48 +00002241 }
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002242}
2243
Douglas Gregor6569d682009-05-27 23:11:45 +00002244void Sema::ActOnReenterTemplateScope(Scope *S, DeclPtrTy TemplateD) {
Douglas Gregor1cdcc572009-09-10 00:12:48 +00002245 Decl *D = TemplateD.getAs<Decl>();
2246 if (!D)
2247 return;
2248
2249 TemplateParameterList *Params = 0;
2250 if (TemplateDecl *Template = dyn_cast<TemplateDecl>(D))
2251 Params = Template->getTemplateParameters();
2252 else if (ClassTemplatePartialSpecializationDecl *PartialSpec
2253 = dyn_cast<ClassTemplatePartialSpecializationDecl>(D))
2254 Params = PartialSpec->getTemplateParameters();
2255 else
Douglas Gregor6569d682009-05-27 23:11:45 +00002256 return;
2257
Douglas Gregor6569d682009-05-27 23:11:45 +00002258 for (TemplateParameterList::iterator Param = Params->begin(),
2259 ParamEnd = Params->end();
2260 Param != ParamEnd; ++Param) {
2261 NamedDecl *Named = cast<NamedDecl>(*Param);
2262 if (Named->getDeclName()) {
2263 S->AddDecl(DeclPtrTy::make(Named));
2264 IdResolver.AddDecl(Named);
2265 }
2266 }
2267}
2268
Douglas Gregor72b505b2008-12-16 21:30:33 +00002269/// ActOnStartDelayedCXXMethodDeclaration - We have completed
2270/// parsing a top-level (non-nested) C++ class, and we are now
2271/// parsing those parts of the given Method declaration that could
2272/// not be parsed earlier (C++ [class.mem]p2), such as default
2273/// arguments. This action should enter the scope of the given
2274/// Method declaration as if we had just parsed the qualified method
2275/// name. However, it should not bring the parameters into scope;
2276/// that will be performed by ActOnDelayedCXXMethodParameter.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002277void Sema::ActOnStartDelayedCXXMethodDeclaration(Scope *S, DeclPtrTy MethodD) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +00002278 if (!MethodD)
2279 return;
Mike Stump1eb44332009-09-09 15:08:12 +00002280
Douglas Gregorefd5bda2009-08-24 11:57:43 +00002281 AdjustDeclIfTemplate(MethodD);
Mike Stump1eb44332009-09-09 15:08:12 +00002282
Douglas Gregor72b505b2008-12-16 21:30:33 +00002283 CXXScopeSpec SS;
Chris Lattnerb28317a2009-03-28 19:18:32 +00002284 FunctionDecl *Method = cast<FunctionDecl>(MethodD.getAs<Decl>());
Mike Stump1eb44332009-09-09 15:08:12 +00002285 QualType ClassTy
Douglas Gregorab452ba2009-03-26 23:50:42 +00002286 = Context.getTypeDeclType(cast<RecordDecl>(Method->getDeclContext()));
2287 SS.setScopeRep(
2288 NestedNameSpecifier::Create(Context, 0, false, ClassTy.getTypePtr()));
Douglas Gregor72b505b2008-12-16 21:30:33 +00002289 ActOnCXXEnterDeclaratorScope(S, SS);
2290}
2291
2292/// ActOnDelayedCXXMethodParameter - We've already started a delayed
2293/// C++ method declaration. We're (re-)introducing the given
2294/// function parameter into scope for use in parsing later parts of
2295/// the method declaration. For example, we could see an
2296/// ActOnParamDefaultArgument event for this parameter.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002297void Sema::ActOnDelayedCXXMethodParameter(Scope *S, DeclPtrTy ParamD) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +00002298 if (!ParamD)
2299 return;
Mike Stump1eb44332009-09-09 15:08:12 +00002300
Chris Lattnerb28317a2009-03-28 19:18:32 +00002301 ParmVarDecl *Param = cast<ParmVarDecl>(ParamD.getAs<Decl>());
Douglas Gregor61366e92008-12-24 00:01:03 +00002302
2303 // If this parameter has an unparsed default argument, clear it out
2304 // to make way for the parsed default argument.
2305 if (Param->hasUnparsedDefaultArg())
2306 Param->setDefaultArg(0);
2307
Chris Lattnerb28317a2009-03-28 19:18:32 +00002308 S->AddDecl(DeclPtrTy::make(Param));
Douglas Gregor72b505b2008-12-16 21:30:33 +00002309 if (Param->getDeclName())
2310 IdResolver.AddDecl(Param);
2311}
2312
2313/// ActOnFinishDelayedCXXMethodDeclaration - We have finished
2314/// processing the delayed method declaration for Method. The method
2315/// declaration is now considered finished. There may be a separate
2316/// ActOnStartOfFunctionDef action later (not necessarily
2317/// immediately!) for this method, if it was also defined inside the
2318/// class body.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002319void Sema::ActOnFinishDelayedCXXMethodDeclaration(Scope *S, DeclPtrTy MethodD) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +00002320 if (!MethodD)
2321 return;
Mike Stump1eb44332009-09-09 15:08:12 +00002322
Douglas Gregorefd5bda2009-08-24 11:57:43 +00002323 AdjustDeclIfTemplate(MethodD);
Mike Stump1eb44332009-09-09 15:08:12 +00002324
Chris Lattnerb28317a2009-03-28 19:18:32 +00002325 FunctionDecl *Method = cast<FunctionDecl>(MethodD.getAs<Decl>());
Douglas Gregor72b505b2008-12-16 21:30:33 +00002326 CXXScopeSpec SS;
Mike Stump1eb44332009-09-09 15:08:12 +00002327 QualType ClassTy
Douglas Gregorab452ba2009-03-26 23:50:42 +00002328 = Context.getTypeDeclType(cast<RecordDecl>(Method->getDeclContext()));
2329 SS.setScopeRep(
2330 NestedNameSpecifier::Create(Context, 0, false, ClassTy.getTypePtr()));
Douglas Gregor72b505b2008-12-16 21:30:33 +00002331 ActOnCXXExitDeclaratorScope(S, SS);
2332
2333 // Now that we have our default arguments, check the constructor
2334 // again. It could produce additional diagnostics or affect whether
2335 // the class has implicitly-declared destructors, among other
2336 // things.
Chris Lattner6e475012009-04-25 08:35:12 +00002337 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Method))
2338 CheckConstructor(Constructor);
Douglas Gregor72b505b2008-12-16 21:30:33 +00002339
2340 // Check the default arguments, which we may have added.
2341 if (!Method->isInvalidDecl())
2342 CheckCXXDefaultArguments(Method);
2343}
2344
Douglas Gregor42a552f2008-11-05 20:51:48 +00002345/// CheckConstructorDeclarator - Called by ActOnDeclarator to check
Douglas Gregor72b505b2008-12-16 21:30:33 +00002346/// the well-formedness of the constructor declarator @p D with type @p
Douglas Gregor42a552f2008-11-05 20:51:48 +00002347/// R. If there are any errors in the declarator, this routine will
Chris Lattner65401802009-04-25 08:28:21 +00002348/// emit diagnostics and set the invalid bit to true. In any case, the type
2349/// will be updated to reflect a well-formed type for the constructor and
2350/// returned.
2351QualType Sema::CheckConstructorDeclarator(Declarator &D, QualType R,
2352 FunctionDecl::StorageClass &SC) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00002353 bool isVirtual = D.getDeclSpec().isVirtualSpecified();
Douglas Gregor42a552f2008-11-05 20:51:48 +00002354
2355 // C++ [class.ctor]p3:
2356 // A constructor shall not be virtual (10.3) or static (9.4). A
2357 // constructor can be invoked for a const, volatile or const
2358 // volatile object. A constructor shall not be declared const,
2359 // volatile, or const volatile (9.3.2).
2360 if (isVirtual) {
Chris Lattner65401802009-04-25 08:28:21 +00002361 if (!D.isInvalidType())
2362 Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
2363 << "virtual" << SourceRange(D.getDeclSpec().getVirtualSpecLoc())
2364 << SourceRange(D.getIdentifierLoc());
2365 D.setInvalidType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00002366 }
2367 if (SC == FunctionDecl::Static) {
Chris Lattner65401802009-04-25 08:28:21 +00002368 if (!D.isInvalidType())
2369 Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
2370 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
2371 << SourceRange(D.getIdentifierLoc());
2372 D.setInvalidType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00002373 SC = FunctionDecl::None;
2374 }
Mike Stump1eb44332009-09-09 15:08:12 +00002375
Chris Lattner65401802009-04-25 08:28:21 +00002376 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
2377 if (FTI.TypeQuals != 0) {
John McCall0953e762009-09-24 19:53:00 +00002378 if (FTI.TypeQuals & Qualifiers::Const)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002379 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
2380 << "const" << SourceRange(D.getIdentifierLoc());
John McCall0953e762009-09-24 19:53:00 +00002381 if (FTI.TypeQuals & Qualifiers::Volatile)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002382 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
2383 << "volatile" << SourceRange(D.getIdentifierLoc());
John McCall0953e762009-09-24 19:53:00 +00002384 if (FTI.TypeQuals & Qualifiers::Restrict)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002385 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
2386 << "restrict" << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00002387 }
Mike Stump1eb44332009-09-09 15:08:12 +00002388
Douglas Gregor42a552f2008-11-05 20:51:48 +00002389 // Rebuild the function type "R" without any type qualifiers (in
2390 // case any of the errors above fired) and with "void" as the
2391 // return type, since constructors don't have return types. We
2392 // *always* have to do this, because GetTypeForDeclarator will
2393 // put in a result type of "int" when none was specified.
John McCall183700f2009-09-21 23:43:11 +00002394 const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
Chris Lattner65401802009-04-25 08:28:21 +00002395 return Context.getFunctionType(Context.VoidTy, Proto->arg_type_begin(),
2396 Proto->getNumArgs(),
2397 Proto->isVariadic(), 0);
Douglas Gregor42a552f2008-11-05 20:51:48 +00002398}
2399
Douglas Gregor72b505b2008-12-16 21:30:33 +00002400/// CheckConstructor - Checks a fully-formed constructor for
2401/// well-formedness, issuing any diagnostics required. Returns true if
2402/// the constructor declarator is invalid.
Chris Lattner6e475012009-04-25 08:35:12 +00002403void Sema::CheckConstructor(CXXConstructorDecl *Constructor) {
Mike Stump1eb44332009-09-09 15:08:12 +00002404 CXXRecordDecl *ClassDecl
Douglas Gregor33297562009-03-27 04:38:56 +00002405 = dyn_cast<CXXRecordDecl>(Constructor->getDeclContext());
2406 if (!ClassDecl)
Chris Lattner6e475012009-04-25 08:35:12 +00002407 return Constructor->setInvalidDecl();
Douglas Gregor72b505b2008-12-16 21:30:33 +00002408
2409 // C++ [class.copy]p3:
2410 // A declaration of a constructor for a class X is ill-formed if
2411 // its first parameter is of type (optionally cv-qualified) X and
2412 // either there are no other parameters or else all other
2413 // parameters have default arguments.
Douglas Gregor33297562009-03-27 04:38:56 +00002414 if (!Constructor->isInvalidDecl() &&
Mike Stump1eb44332009-09-09 15:08:12 +00002415 ((Constructor->getNumParams() == 1) ||
2416 (Constructor->getNumParams() > 1 &&
Douglas Gregor66724ea2009-11-14 01:20:54 +00002417 Constructor->getParamDecl(1)->hasDefaultArg())) &&
2418 Constructor->getTemplateSpecializationKind()
2419 != TSK_ImplicitInstantiation) {
Douglas Gregor72b505b2008-12-16 21:30:33 +00002420 QualType ParamType = Constructor->getParamDecl(0)->getType();
2421 QualType ClassTy = Context.getTagDeclType(ClassDecl);
2422 if (Context.getCanonicalType(ParamType).getUnqualifiedType() == ClassTy) {
Douglas Gregora3a83512009-04-01 23:51:29 +00002423 SourceLocation ParamLoc = Constructor->getParamDecl(0)->getLocation();
2424 Diag(ParamLoc, diag::err_constructor_byvalue_arg)
Douglas Gregor558cb562009-04-02 01:08:08 +00002425 << CodeModificationHint::CreateInsertion(ParamLoc, " const &");
Douglas Gregor66724ea2009-11-14 01:20:54 +00002426
2427 // FIXME: Rather that making the constructor invalid, we should endeavor
2428 // to fix the type.
Chris Lattner6e475012009-04-25 08:35:12 +00002429 Constructor->setInvalidDecl();
Douglas Gregor72b505b2008-12-16 21:30:33 +00002430 }
2431 }
Mike Stump1eb44332009-09-09 15:08:12 +00002432
Douglas Gregor72b505b2008-12-16 21:30:33 +00002433 // Notify the class that we've added a constructor.
2434 ClassDecl->addedConstructor(Context, Constructor);
Douglas Gregor72b505b2008-12-16 21:30:33 +00002435}
2436
Anders Carlsson37909802009-11-30 21:24:50 +00002437/// CheckDestructor - Checks a fully-formed destructor for well-formedness,
2438/// issuing any diagnostics required. Returns true on error.
Anders Carlsson5ec02ae2009-12-02 17:15:43 +00002439bool Sema::CheckDestructor(CXXDestructorDecl *Destructor) {
Anders Carlsson6d701392009-11-15 22:49:34 +00002440 CXXRecordDecl *RD = Destructor->getParent();
2441
2442 if (Destructor->isVirtual()) {
2443 SourceLocation Loc;
2444
2445 if (!Destructor->isImplicit())
2446 Loc = Destructor->getLocation();
2447 else
2448 Loc = RD->getLocation();
2449
2450 // If we have a virtual destructor, look up the deallocation function
2451 FunctionDecl *OperatorDelete = 0;
2452 DeclarationName Name =
2453 Context.DeclarationNames.getCXXOperatorName(OO_Delete);
Anders Carlsson5ec02ae2009-12-02 17:15:43 +00002454 if (FindDeallocationFunction(Loc, RD, Name, OperatorDelete))
Anders Carlsson37909802009-11-30 21:24:50 +00002455 return true;
2456
2457 Destructor->setOperatorDelete(OperatorDelete);
Anders Carlsson6d701392009-11-15 22:49:34 +00002458 }
Anders Carlsson37909802009-11-30 21:24:50 +00002459
2460 return false;
Anders Carlsson6d701392009-11-15 22:49:34 +00002461}
2462
Mike Stump1eb44332009-09-09 15:08:12 +00002463static inline bool
Anders Carlsson7786d1c2009-04-30 23:18:11 +00002464FTIHasSingleVoidArgument(DeclaratorChunk::FunctionTypeInfo &FTI) {
2465 return (FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 &&
2466 FTI.ArgInfo[0].Param &&
2467 FTI.ArgInfo[0].Param.getAs<ParmVarDecl>()->getType()->isVoidType());
2468}
2469
Douglas Gregor42a552f2008-11-05 20:51:48 +00002470/// CheckDestructorDeclarator - Called by ActOnDeclarator to check
2471/// the well-formednes of the destructor declarator @p D with type @p
2472/// R. If there are any errors in the declarator, this routine will
Chris Lattner65401802009-04-25 08:28:21 +00002473/// emit diagnostics and set the declarator to invalid. Even if this happens,
2474/// will be updated to reflect a well-formed type for the destructor and
2475/// returned.
2476QualType Sema::CheckDestructorDeclarator(Declarator &D,
2477 FunctionDecl::StorageClass& SC) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00002478 // C++ [class.dtor]p1:
2479 // [...] A typedef-name that names a class is a class-name
2480 // (7.1.3); however, a typedef-name that names a class shall not
2481 // be used as the identifier in the declarator for a destructor
2482 // declaration.
Douglas Gregor3f9a0562009-11-03 01:35:08 +00002483 QualType DeclaratorType = GetTypeFromParser(D.getName().DestructorName);
Chris Lattner65401802009-04-25 08:28:21 +00002484 if (isa<TypedefType>(DeclaratorType)) {
2485 Diag(D.getIdentifierLoc(), diag::err_destructor_typedef_name)
Douglas Gregor1a51b4a2009-02-09 15:09:02 +00002486 << DeclaratorType;
Chris Lattner65401802009-04-25 08:28:21 +00002487 D.setInvalidType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00002488 }
2489
2490 // C++ [class.dtor]p2:
2491 // A destructor is used to destroy objects of its class type. A
2492 // destructor takes no parameters, and no return type can be
2493 // specified for it (not even void). The address of a destructor
2494 // shall not be taken. A destructor shall not be static. A
2495 // destructor can be invoked for a const, volatile or const
2496 // volatile object. A destructor shall not be declared const,
2497 // volatile or const volatile (9.3.2).
2498 if (SC == FunctionDecl::Static) {
Chris Lattner65401802009-04-25 08:28:21 +00002499 if (!D.isInvalidType())
2500 Diag(D.getIdentifierLoc(), diag::err_destructor_cannot_be)
2501 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
2502 << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00002503 SC = FunctionDecl::None;
Chris Lattner65401802009-04-25 08:28:21 +00002504 D.setInvalidType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00002505 }
Chris Lattner65401802009-04-25 08:28:21 +00002506 if (D.getDeclSpec().hasTypeSpecifier() && !D.isInvalidType()) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00002507 // Destructors don't have return types, but the parser will
2508 // happily parse something like:
2509 //
2510 // class X {
2511 // float ~X();
2512 // };
2513 //
2514 // The return type will be eliminated later.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002515 Diag(D.getIdentifierLoc(), diag::err_destructor_return_type)
2516 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
2517 << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00002518 }
Mike Stump1eb44332009-09-09 15:08:12 +00002519
Chris Lattner65401802009-04-25 08:28:21 +00002520 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
2521 if (FTI.TypeQuals != 0 && !D.isInvalidType()) {
John McCall0953e762009-09-24 19:53:00 +00002522 if (FTI.TypeQuals & Qualifiers::Const)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002523 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
2524 << "const" << SourceRange(D.getIdentifierLoc());
John McCall0953e762009-09-24 19:53:00 +00002525 if (FTI.TypeQuals & Qualifiers::Volatile)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002526 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
2527 << "volatile" << SourceRange(D.getIdentifierLoc());
John McCall0953e762009-09-24 19:53:00 +00002528 if (FTI.TypeQuals & Qualifiers::Restrict)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002529 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
2530 << "restrict" << SourceRange(D.getIdentifierLoc());
Chris Lattner65401802009-04-25 08:28:21 +00002531 D.setInvalidType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00002532 }
2533
2534 // Make sure we don't have any parameters.
Anders Carlsson7786d1c2009-04-30 23:18:11 +00002535 if (FTI.NumArgs > 0 && !FTIHasSingleVoidArgument(FTI)) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00002536 Diag(D.getIdentifierLoc(), diag::err_destructor_with_params);
2537
2538 // Delete the parameters.
Chris Lattner65401802009-04-25 08:28:21 +00002539 FTI.freeArgs();
2540 D.setInvalidType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00002541 }
2542
Mike Stump1eb44332009-09-09 15:08:12 +00002543 // Make sure the destructor isn't variadic.
Chris Lattner65401802009-04-25 08:28:21 +00002544 if (FTI.isVariadic) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00002545 Diag(D.getIdentifierLoc(), diag::err_destructor_variadic);
Chris Lattner65401802009-04-25 08:28:21 +00002546 D.setInvalidType();
2547 }
Douglas Gregor42a552f2008-11-05 20:51:48 +00002548
2549 // Rebuild the function type "R" without any type qualifiers or
2550 // parameters (in case any of the errors above fired) and with
2551 // "void" as the return type, since destructors don't have return
2552 // types. We *always* have to do this, because GetTypeForDeclarator
2553 // will put in a result type of "int" when none was specified.
Chris Lattner65401802009-04-25 08:28:21 +00002554 return Context.getFunctionType(Context.VoidTy, 0, 0, false, 0);
Douglas Gregor42a552f2008-11-05 20:51:48 +00002555}
2556
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002557/// CheckConversionDeclarator - Called by ActOnDeclarator to check the
2558/// well-formednes of the conversion function declarator @p D with
2559/// type @p R. If there are any errors in the declarator, this routine
2560/// will emit diagnostics and return true. Otherwise, it will return
2561/// false. Either way, the type @p R will be updated to reflect a
2562/// well-formed type for the conversion operator.
Chris Lattner6e475012009-04-25 08:35:12 +00002563void Sema::CheckConversionDeclarator(Declarator &D, QualType &R,
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002564 FunctionDecl::StorageClass& SC) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002565 // C++ [class.conv.fct]p1:
2566 // Neither parameter types nor return type can be specified. The
Eli Friedman33a31382009-08-05 19:21:58 +00002567 // type of a conversion function (8.3.5) is "function taking no
Mike Stump1eb44332009-09-09 15:08:12 +00002568 // parameter returning conversion-type-id."
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002569 if (SC == FunctionDecl::Static) {
Chris Lattner6e475012009-04-25 08:35:12 +00002570 if (!D.isInvalidType())
2571 Diag(D.getIdentifierLoc(), diag::err_conv_function_not_member)
2572 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
2573 << SourceRange(D.getIdentifierLoc());
2574 D.setInvalidType();
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002575 SC = FunctionDecl::None;
2576 }
Chris Lattner6e475012009-04-25 08:35:12 +00002577 if (D.getDeclSpec().hasTypeSpecifier() && !D.isInvalidType()) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002578 // Conversion functions don't have return types, but the parser will
2579 // happily parse something like:
2580 //
2581 // class X {
2582 // float operator bool();
2583 // };
2584 //
2585 // The return type will be changed later anyway.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002586 Diag(D.getIdentifierLoc(), diag::err_conv_function_return_type)
2587 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
2588 << SourceRange(D.getIdentifierLoc());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002589 }
2590
2591 // Make sure we don't have any parameters.
John McCall183700f2009-09-21 23:43:11 +00002592 if (R->getAs<FunctionProtoType>()->getNumArgs() > 0) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002593 Diag(D.getIdentifierLoc(), diag::err_conv_function_with_params);
2594
2595 // Delete the parameters.
Chris Lattner1833a832009-01-20 21:06:38 +00002596 D.getTypeObject(0).Fun.freeArgs();
Chris Lattner6e475012009-04-25 08:35:12 +00002597 D.setInvalidType();
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002598 }
2599
Mike Stump1eb44332009-09-09 15:08:12 +00002600 // Make sure the conversion function isn't variadic.
John McCall183700f2009-09-21 23:43:11 +00002601 if (R->getAs<FunctionProtoType>()->isVariadic() && !D.isInvalidType()) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002602 Diag(D.getIdentifierLoc(), diag::err_conv_function_variadic);
Chris Lattner6e475012009-04-25 08:35:12 +00002603 D.setInvalidType();
2604 }
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002605
2606 // C++ [class.conv.fct]p4:
2607 // The conversion-type-id shall not represent a function type nor
2608 // an array type.
Douglas Gregor3f9a0562009-11-03 01:35:08 +00002609 QualType ConvType = GetTypeFromParser(D.getName().ConversionFunctionId);
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002610 if (ConvType->isArrayType()) {
2611 Diag(D.getIdentifierLoc(), diag::err_conv_function_to_array);
2612 ConvType = Context.getPointerType(ConvType);
Chris Lattner6e475012009-04-25 08:35:12 +00002613 D.setInvalidType();
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002614 } else if (ConvType->isFunctionType()) {
2615 Diag(D.getIdentifierLoc(), diag::err_conv_function_to_function);
2616 ConvType = Context.getPointerType(ConvType);
Chris Lattner6e475012009-04-25 08:35:12 +00002617 D.setInvalidType();
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002618 }
2619
2620 // Rebuild the function type "R" without any parameters (in case any
2621 // of the errors above fired) and with the conversion type as the
Mike Stump1eb44332009-09-09 15:08:12 +00002622 // return type.
2623 R = Context.getFunctionType(ConvType, 0, 0, false,
John McCall183700f2009-09-21 23:43:11 +00002624 R->getAs<FunctionProtoType>()->getTypeQuals());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002625
Douglas Gregor09f41cf2009-01-14 15:45:31 +00002626 // C++0x explicit conversion operators.
2627 if (D.getDeclSpec().isExplicitSpecified() && !getLangOptions().CPlusPlus0x)
Mike Stump1eb44332009-09-09 15:08:12 +00002628 Diag(D.getDeclSpec().getExplicitSpecLoc(),
Douglas Gregor09f41cf2009-01-14 15:45:31 +00002629 diag::warn_explicit_conversion_functions)
2630 << SourceRange(D.getDeclSpec().getExplicitSpecLoc());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002631}
2632
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002633/// ActOnConversionDeclarator - Called by ActOnDeclarator to complete
2634/// the declaration of the given C++ conversion function. This routine
2635/// is responsible for recording the conversion function in the C++
2636/// class, if possible.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002637Sema::DeclPtrTy Sema::ActOnConversionDeclarator(CXXConversionDecl *Conversion) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002638 assert(Conversion && "Expected to receive a conversion function declaration");
2639
Douglas Gregor9d350972008-12-12 08:25:50 +00002640 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Conversion->getDeclContext());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002641
2642 // Make sure we aren't redeclaring the conversion function.
2643 QualType ConvType = Context.getCanonicalType(Conversion->getConversionType());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002644
2645 // C++ [class.conv.fct]p1:
2646 // [...] A conversion function is never used to convert a
2647 // (possibly cv-qualified) object to the (possibly cv-qualified)
2648 // same object type (or a reference to it), to a (possibly
2649 // cv-qualified) base class of that type (or a reference to it),
2650 // or to (possibly cv-qualified) void.
Mike Stump390b4cc2009-05-16 07:39:55 +00002651 // FIXME: Suppress this warning if the conversion function ends up being a
2652 // virtual function that overrides a virtual function in a base class.
Mike Stump1eb44332009-09-09 15:08:12 +00002653 QualType ClassType
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002654 = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
Ted Kremenek6217b802009-07-29 21:53:49 +00002655 if (const ReferenceType *ConvTypeRef = ConvType->getAs<ReferenceType>())
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002656 ConvType = ConvTypeRef->getPointeeType();
2657 if (ConvType->isRecordType()) {
2658 ConvType = Context.getCanonicalType(ConvType).getUnqualifiedType();
2659 if (ConvType == ClassType)
Chris Lattner5dc266a2008-11-20 06:13:02 +00002660 Diag(Conversion->getLocation(), diag::warn_conv_to_self_not_used)
Chris Lattnerd1625842008-11-24 06:25:27 +00002661 << ClassType;
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002662 else if (IsDerivedFrom(ClassType, ConvType))
Chris Lattner5dc266a2008-11-20 06:13:02 +00002663 Diag(Conversion->getLocation(), diag::warn_conv_to_base_not_used)
Chris Lattnerd1625842008-11-24 06:25:27 +00002664 << ClassType << ConvType;
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002665 } else if (ConvType->isVoidType()) {
Chris Lattner5dc266a2008-11-20 06:13:02 +00002666 Diag(Conversion->getLocation(), diag::warn_conv_to_void_not_used)
Chris Lattnerd1625842008-11-24 06:25:27 +00002667 << ClassType << ConvType;
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002668 }
2669
Douglas Gregor70316a02008-12-26 15:00:45 +00002670 if (Conversion->getPreviousDeclaration()) {
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00002671 const NamedDecl *ExpectedPrevDecl = Conversion->getPreviousDeclaration();
Mike Stump1eb44332009-09-09 15:08:12 +00002672 if (FunctionTemplateDecl *ConversionTemplate
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00002673 = Conversion->getDescribedFunctionTemplate())
2674 ExpectedPrevDecl = ConversionTemplate->getPreviousDeclaration();
John McCallba135432009-11-21 08:51:07 +00002675 if (ClassDecl->replaceConversion(ExpectedPrevDecl, Conversion))
2676 return DeclPtrTy::make(Conversion);
Douglas Gregor70316a02008-12-26 15:00:45 +00002677 assert(Conversion->isInvalidDecl() && "Conversion should not get here.");
Mike Stump1eb44332009-09-09 15:08:12 +00002678 } else if (FunctionTemplateDecl *ConversionTemplate
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00002679 = Conversion->getDescribedFunctionTemplate())
Fariborz Jahaniandebc6292009-09-12 19:02:34 +00002680 ClassDecl->addConversionFunction(ConversionTemplate);
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00002681 else if (!Conversion->getPrimaryTemplate()) // ignore specializations
Fariborz Jahaniandebc6292009-09-12 19:02:34 +00002682 ClassDecl->addConversionFunction(Conversion);
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002683
Chris Lattnerb28317a2009-03-28 19:18:32 +00002684 return DeclPtrTy::make(Conversion);
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002685}
2686
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002687//===----------------------------------------------------------------------===//
2688// Namespace Handling
2689//===----------------------------------------------------------------------===//
2690
2691/// ActOnStartNamespaceDef - This is called at the start of a namespace
2692/// definition.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002693Sema::DeclPtrTy Sema::ActOnStartNamespaceDef(Scope *NamespcScope,
2694 SourceLocation IdentLoc,
2695 IdentifierInfo *II,
2696 SourceLocation LBrace) {
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002697 NamespaceDecl *Namespc =
2698 NamespaceDecl::Create(Context, CurContext, IdentLoc, II);
2699 Namespc->setLBracLoc(LBrace);
2700
2701 Scope *DeclRegionScope = NamespcScope->getParent();
2702
2703 if (II) {
2704 // C++ [namespace.def]p2:
2705 // The identifier in an original-namespace-definition shall not have been
2706 // previously defined in the declarative region in which the
2707 // original-namespace-definition appears. The identifier in an
2708 // original-namespace-definition is the name of the namespace. Subsequently
2709 // in that declarative region, it is treated as an original-namespace-name.
2710
John McCallf36e02d2009-10-09 21:13:30 +00002711 NamedDecl *PrevDecl
John McCalla24dc2e2009-11-17 02:14:36 +00002712 = LookupSingleName(DeclRegionScope, II, LookupOrdinaryName,
John McCall7d384dd2009-11-18 07:57:50 +00002713 ForRedeclaration);
Mike Stump1eb44332009-09-09 15:08:12 +00002714
Douglas Gregor44b43212008-12-11 16:49:14 +00002715 if (NamespaceDecl *OrigNS = dyn_cast_or_null<NamespaceDecl>(PrevDecl)) {
2716 // This is an extended namespace definition.
2717 // Attach this namespace decl to the chain of extended namespace
2718 // definitions.
2719 OrigNS->setNextNamespace(Namespc);
2720 Namespc->setOriginalNamespace(OrigNS->getOriginalNamespace());
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002721
Mike Stump1eb44332009-09-09 15:08:12 +00002722 // Remove the previous declaration from the scope.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002723 if (DeclRegionScope->isDeclScope(DeclPtrTy::make(OrigNS))) {
Douglas Gregore267ff32008-12-11 20:41:00 +00002724 IdResolver.RemoveDecl(OrigNS);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002725 DeclRegionScope->RemoveDecl(DeclPtrTy::make(OrigNS));
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002726 }
Douglas Gregor44b43212008-12-11 16:49:14 +00002727 } else if (PrevDecl) {
2728 // This is an invalid name redefinition.
2729 Diag(Namespc->getLocation(), diag::err_redefinition_different_kind)
2730 << Namespc->getDeclName();
2731 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
2732 Namespc->setInvalidDecl();
2733 // Continue on to push Namespc as current DeclContext and return it.
Douglas Gregor7adb10f2009-09-15 22:30:29 +00002734 } else if (II->isStr("std") &&
2735 CurContext->getLookupContext()->isTranslationUnit()) {
2736 // This is the first "real" definition of the namespace "std", so update
2737 // our cache of the "std" namespace to point at this definition.
2738 if (StdNamespace) {
2739 // We had already defined a dummy namespace "std". Link this new
2740 // namespace definition to the dummy namespace "std".
2741 StdNamespace->setNextNamespace(Namespc);
2742 StdNamespace->setLocation(IdentLoc);
2743 Namespc->setOriginalNamespace(StdNamespace->getOriginalNamespace());
2744 }
2745
2746 // Make our StdNamespace cache point at the first real definition of the
2747 // "std" namespace.
2748 StdNamespace = Namespc;
Mike Stump1eb44332009-09-09 15:08:12 +00002749 }
Douglas Gregor44b43212008-12-11 16:49:14 +00002750
2751 PushOnScopeChains(Namespc, DeclRegionScope);
2752 } else {
John McCall9aeed322009-10-01 00:25:31 +00002753 // Anonymous namespaces.
John McCall5fdd7642009-12-16 02:06:49 +00002754 assert(Namespc->isAnonymousNamespace());
2755 CurContext->addDecl(Namespc);
2756
2757 // Link the anonymous namespace into its parent.
2758 NamespaceDecl *PrevDecl;
2759 DeclContext *Parent = CurContext->getLookupContext();
2760 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(Parent)) {
2761 PrevDecl = TU->getAnonymousNamespace();
2762 TU->setAnonymousNamespace(Namespc);
2763 } else {
2764 NamespaceDecl *ND = cast<NamespaceDecl>(Parent);
2765 PrevDecl = ND->getAnonymousNamespace();
2766 ND->setAnonymousNamespace(Namespc);
2767 }
2768
2769 // Link the anonymous namespace with its previous declaration.
2770 if (PrevDecl) {
2771 assert(PrevDecl->isAnonymousNamespace());
2772 assert(!PrevDecl->getNextNamespace());
2773 Namespc->setOriginalNamespace(PrevDecl->getOriginalNamespace());
2774 PrevDecl->setNextNamespace(Namespc);
2775 }
John McCall9aeed322009-10-01 00:25:31 +00002776
2777 // C++ [namespace.unnamed]p1. An unnamed-namespace-definition
2778 // behaves as if it were replaced by
2779 // namespace unique { /* empty body */ }
2780 // using namespace unique;
2781 // namespace unique { namespace-body }
2782 // where all occurrences of 'unique' in a translation unit are
2783 // replaced by the same identifier and this identifier differs
2784 // from all other identifiers in the entire program.
2785
2786 // We just create the namespace with an empty name and then add an
2787 // implicit using declaration, just like the standard suggests.
2788 //
2789 // CodeGen enforces the "universally unique" aspect by giving all
2790 // declarations semantically contained within an anonymous
2791 // namespace internal linkage.
2792
John McCall5fdd7642009-12-16 02:06:49 +00002793 if (!PrevDecl) {
2794 UsingDirectiveDecl* UD
2795 = UsingDirectiveDecl::Create(Context, CurContext,
2796 /* 'using' */ LBrace,
2797 /* 'namespace' */ SourceLocation(),
2798 /* qualifier */ SourceRange(),
2799 /* NNS */ NULL,
2800 /* identifier */ SourceLocation(),
2801 Namespc,
2802 /* Ancestor */ CurContext);
2803 UD->setImplicit();
2804 CurContext->addDecl(UD);
2805 }
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002806 }
2807
2808 // Although we could have an invalid decl (i.e. the namespace name is a
2809 // redefinition), push it as current DeclContext and try to continue parsing.
Mike Stump390b4cc2009-05-16 07:39:55 +00002810 // FIXME: We should be able to push Namespc here, so that the each DeclContext
2811 // for the namespace has the declarations that showed up in that particular
2812 // namespace definition.
Douglas Gregor44b43212008-12-11 16:49:14 +00002813 PushDeclContext(NamespcScope, Namespc);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002814 return DeclPtrTy::make(Namespc);
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002815}
2816
Sebastian Redleb0d8c92009-11-23 15:34:23 +00002817/// getNamespaceDecl - Returns the namespace a decl represents. If the decl
2818/// is a namespace alias, returns the namespace it points to.
2819static inline NamespaceDecl *getNamespaceDecl(NamedDecl *D) {
2820 if (NamespaceAliasDecl *AD = dyn_cast_or_null<NamespaceAliasDecl>(D))
2821 return AD->getNamespace();
2822 return dyn_cast_or_null<NamespaceDecl>(D);
2823}
2824
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002825/// ActOnFinishNamespaceDef - This callback is called after a namespace is
2826/// exited. Decl is the DeclTy returned by ActOnStartNamespaceDef.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002827void Sema::ActOnFinishNamespaceDef(DeclPtrTy D, SourceLocation RBrace) {
2828 Decl *Dcl = D.getAs<Decl>();
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00002829 NamespaceDecl *Namespc = dyn_cast_or_null<NamespaceDecl>(Dcl);
2830 assert(Namespc && "Invalid parameter, expected NamespaceDecl");
2831 Namespc->setRBracLoc(RBrace);
2832 PopDeclContext();
2833}
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00002834
Chris Lattnerb28317a2009-03-28 19:18:32 +00002835Sema::DeclPtrTy Sema::ActOnUsingDirective(Scope *S,
2836 SourceLocation UsingLoc,
2837 SourceLocation NamespcLoc,
2838 const CXXScopeSpec &SS,
2839 SourceLocation IdentLoc,
2840 IdentifierInfo *NamespcName,
2841 AttributeList *AttrList) {
Douglas Gregorf780abc2008-12-30 03:27:21 +00002842 assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
2843 assert(NamespcName && "Invalid NamespcName.");
2844 assert(IdentLoc.isValid() && "Invalid NamespceName location.");
Douglas Gregor2a3009a2009-02-03 19:21:40 +00002845 assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
Douglas Gregorf780abc2008-12-30 03:27:21 +00002846
Douglas Gregor2a3009a2009-02-03 19:21:40 +00002847 UsingDirectiveDecl *UDir = 0;
Douglas Gregorf780abc2008-12-30 03:27:21 +00002848
Douglas Gregoreb11cd02009-01-14 22:20:51 +00002849 // Lookup namespace name.
John McCalla24dc2e2009-11-17 02:14:36 +00002850 LookupResult R(*this, NamespcName, IdentLoc, LookupNamespaceName);
2851 LookupParsedName(R, S, &SS);
2852 if (R.isAmbiguous())
Chris Lattnerb28317a2009-03-28 19:18:32 +00002853 return DeclPtrTy();
John McCalla24dc2e2009-11-17 02:14:36 +00002854
John McCallf36e02d2009-10-09 21:13:30 +00002855 if (!R.empty()) {
Sebastian Redleb0d8c92009-11-23 15:34:23 +00002856 NamedDecl *Named = R.getFoundDecl();
2857 assert((isa<NamespaceDecl>(Named) || isa<NamespaceAliasDecl>(Named))
2858 && "expected namespace decl");
Douglas Gregor2a3009a2009-02-03 19:21:40 +00002859 // C++ [namespace.udir]p1:
2860 // A using-directive specifies that the names in the nominated
2861 // namespace can be used in the scope in which the
2862 // using-directive appears after the using-directive. During
2863 // unqualified name lookup (3.4.1), the names appear as if they
2864 // were declared in the nearest enclosing namespace which
2865 // contains both the using-directive and the nominated
Eli Friedman33a31382009-08-05 19:21:58 +00002866 // namespace. [Note: in this context, "contains" means "contains
2867 // directly or indirectly". ]
Douglas Gregor2a3009a2009-02-03 19:21:40 +00002868
2869 // Find enclosing context containing both using-directive and
2870 // nominated namespace.
Sebastian Redleb0d8c92009-11-23 15:34:23 +00002871 NamespaceDecl *NS = getNamespaceDecl(Named);
Douglas Gregor2a3009a2009-02-03 19:21:40 +00002872 DeclContext *CommonAncestor = cast<DeclContext>(NS);
2873 while (CommonAncestor && !CommonAncestor->Encloses(CurContext))
2874 CommonAncestor = CommonAncestor->getParent();
2875
Sebastian Redleb0d8c92009-11-23 15:34:23 +00002876 UDir = UsingDirectiveDecl::Create(Context, CurContext, UsingLoc, NamespcLoc,
Douglas Gregor8419fa32009-05-30 06:31:56 +00002877 SS.getRange(),
2878 (NestedNameSpecifier *)SS.getScopeRep(),
Sebastian Redleb0d8c92009-11-23 15:34:23 +00002879 IdentLoc, Named, CommonAncestor);
Douglas Gregor2a3009a2009-02-03 19:21:40 +00002880 PushUsingDirective(S, UDir);
Douglas Gregorf780abc2008-12-30 03:27:21 +00002881 } else {
Chris Lattneread013e2009-01-06 07:24:29 +00002882 Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
Douglas Gregorf780abc2008-12-30 03:27:21 +00002883 }
2884
Douglas Gregor2a3009a2009-02-03 19:21:40 +00002885 // FIXME: We ignore attributes for now.
Douglas Gregorf780abc2008-12-30 03:27:21 +00002886 delete AttrList;
Chris Lattnerb28317a2009-03-28 19:18:32 +00002887 return DeclPtrTy::make(UDir);
Douglas Gregor2a3009a2009-02-03 19:21:40 +00002888}
2889
2890void Sema::PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir) {
2891 // If scope has associated entity, then using directive is at namespace
2892 // or translation unit scope. We add UsingDirectiveDecls, into
2893 // it's lookup structure.
2894 if (DeclContext *Ctx = static_cast<DeclContext*>(S->getEntity()))
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002895 Ctx->addDecl(UDir);
Douglas Gregor2a3009a2009-02-03 19:21:40 +00002896 else
2897 // Otherwise it is block-sope. using-directives will affect lookup
2898 // only to the end of scope.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002899 S->PushUsingDirective(DeclPtrTy::make(UDir));
Douglas Gregorf780abc2008-12-30 03:27:21 +00002900}
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00002901
Douglas Gregor9cfbe482009-06-20 00:51:54 +00002902
2903Sema::DeclPtrTy Sema::ActOnUsingDeclaration(Scope *S,
Anders Carlsson595adc12009-08-29 19:54:19 +00002904 AccessSpecifier AS,
John McCall60fa3cf2009-12-11 02:10:03 +00002905 bool HasUsingKeyword,
Anders Carlssoncf9f9212009-08-28 03:16:11 +00002906 SourceLocation UsingLoc,
2907 const CXXScopeSpec &SS,
Douglas Gregor12c118a2009-11-04 16:30:06 +00002908 UnqualifiedId &Name,
Anders Carlssoncf9f9212009-08-28 03:16:11 +00002909 AttributeList *AttrList,
John McCall7ba107a2009-11-18 02:36:19 +00002910 bool IsTypeName,
2911 SourceLocation TypenameLoc) {
Douglas Gregor9cfbe482009-06-20 00:51:54 +00002912 assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
Mike Stump1eb44332009-09-09 15:08:12 +00002913
Douglas Gregor12c118a2009-11-04 16:30:06 +00002914 switch (Name.getKind()) {
2915 case UnqualifiedId::IK_Identifier:
2916 case UnqualifiedId::IK_OperatorFunctionId:
Sean Hunt0486d742009-11-28 04:44:28 +00002917 case UnqualifiedId::IK_LiteralOperatorId:
Douglas Gregor12c118a2009-11-04 16:30:06 +00002918 case UnqualifiedId::IK_ConversionFunctionId:
2919 break;
2920
2921 case UnqualifiedId::IK_ConstructorName:
John McCall604e7f12009-12-08 07:46:18 +00002922 // C++0x inherited constructors.
2923 if (getLangOptions().CPlusPlus0x) break;
2924
Douglas Gregor12c118a2009-11-04 16:30:06 +00002925 Diag(Name.getSourceRange().getBegin(), diag::err_using_decl_constructor)
2926 << SS.getRange();
2927 return DeclPtrTy();
2928
2929 case UnqualifiedId::IK_DestructorName:
2930 Diag(Name.getSourceRange().getBegin(), diag::err_using_decl_destructor)
2931 << SS.getRange();
2932 return DeclPtrTy();
2933
2934 case UnqualifiedId::IK_TemplateId:
2935 Diag(Name.getSourceRange().getBegin(), diag::err_using_decl_template_id)
2936 << SourceRange(Name.TemplateId->LAngleLoc, Name.TemplateId->RAngleLoc);
2937 return DeclPtrTy();
2938 }
2939
2940 DeclarationName TargetName = GetNameFromUnqualifiedId(Name);
John McCall604e7f12009-12-08 07:46:18 +00002941 if (!TargetName)
2942 return DeclPtrTy();
2943
John McCall60fa3cf2009-12-11 02:10:03 +00002944 // Warn about using declarations.
2945 // TODO: store that the declaration was written without 'using' and
2946 // talk about access decls instead of using decls in the
2947 // diagnostics.
2948 if (!HasUsingKeyword) {
2949 UsingLoc = Name.getSourceRange().getBegin();
2950
2951 Diag(UsingLoc, diag::warn_access_decl_deprecated)
2952 << CodeModificationHint::CreateInsertion(SS.getRange().getBegin(),
2953 "using ");
2954 }
2955
John McCall9488ea12009-11-17 05:59:44 +00002956 NamedDecl *UD = BuildUsingDeclaration(S, AS, UsingLoc, SS,
Douglas Gregor12c118a2009-11-04 16:30:06 +00002957 Name.getSourceRange().getBegin(),
John McCall7ba107a2009-11-18 02:36:19 +00002958 TargetName, AttrList,
2959 /* IsInstantiation */ false,
2960 IsTypeName, TypenameLoc);
John McCalled976492009-12-04 22:46:56 +00002961 if (UD)
2962 PushOnScopeChains(UD, S, /*AddToContext*/ false);
Mike Stump1eb44332009-09-09 15:08:12 +00002963
Anders Carlssonc72160b2009-08-28 05:40:36 +00002964 return DeclPtrTy::make(UD);
2965}
2966
John McCall9f54ad42009-12-10 09:41:52 +00002967/// Determines whether to create a using shadow decl for a particular
2968/// decl, given the set of decls existing prior to this using lookup.
2969bool Sema::CheckUsingShadowDecl(UsingDecl *Using, NamedDecl *Orig,
2970 const LookupResult &Previous) {
2971 // Diagnose finding a decl which is not from a base class of the
2972 // current class. We do this now because there are cases where this
2973 // function will silently decide not to build a shadow decl, which
2974 // will pre-empt further diagnostics.
2975 //
2976 // We don't need to do this in C++0x because we do the check once on
2977 // the qualifier.
2978 //
2979 // FIXME: diagnose the following if we care enough:
2980 // struct A { int foo; };
2981 // struct B : A { using A::foo; };
2982 // template <class T> struct C : A {};
2983 // template <class T> struct D : C<T> { using B::foo; } // <---
2984 // This is invalid (during instantiation) in C++03 because B::foo
2985 // resolves to the using decl in B, which is not a base class of D<T>.
2986 // We can't diagnose it immediately because C<T> is an unknown
2987 // specialization. The UsingShadowDecl in D<T> then points directly
2988 // to A::foo, which will look well-formed when we instantiate.
2989 // The right solution is to not collapse the shadow-decl chain.
2990 if (!getLangOptions().CPlusPlus0x && CurContext->isRecord()) {
2991 DeclContext *OrigDC = Orig->getDeclContext();
2992
2993 // Handle enums and anonymous structs.
2994 if (isa<EnumDecl>(OrigDC)) OrigDC = OrigDC->getParent();
2995 CXXRecordDecl *OrigRec = cast<CXXRecordDecl>(OrigDC);
2996 while (OrigRec->isAnonymousStructOrUnion())
2997 OrigRec = cast<CXXRecordDecl>(OrigRec->getDeclContext());
2998
2999 if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(OrigRec)) {
3000 if (OrigDC == CurContext) {
3001 Diag(Using->getLocation(),
3002 diag::err_using_decl_nested_name_specifier_is_current_class)
3003 << Using->getNestedNameRange();
3004 Diag(Orig->getLocation(), diag::note_using_decl_target);
3005 return true;
3006 }
3007
3008 Diag(Using->getNestedNameRange().getBegin(),
3009 diag::err_using_decl_nested_name_specifier_is_not_base_class)
3010 << Using->getTargetNestedNameDecl()
3011 << cast<CXXRecordDecl>(CurContext)
3012 << Using->getNestedNameRange();
3013 Diag(Orig->getLocation(), diag::note_using_decl_target);
3014 return true;
3015 }
3016 }
3017
3018 if (Previous.empty()) return false;
3019
3020 NamedDecl *Target = Orig;
3021 if (isa<UsingShadowDecl>(Target))
3022 Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
3023
John McCalld7533ec2009-12-11 02:33:26 +00003024 // If the target happens to be one of the previous declarations, we
3025 // don't have a conflict.
3026 //
3027 // FIXME: but we might be increasing its access, in which case we
3028 // should redeclare it.
3029 NamedDecl *NonTag = 0, *Tag = 0;
3030 for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
3031 I != E; ++I) {
3032 NamedDecl *D = (*I)->getUnderlyingDecl();
3033 if (D->getCanonicalDecl() == Target->getCanonicalDecl())
3034 return false;
3035
3036 (isa<TagDecl>(D) ? Tag : NonTag) = D;
3037 }
3038
John McCall9f54ad42009-12-10 09:41:52 +00003039 if (Target->isFunctionOrFunctionTemplate()) {
3040 FunctionDecl *FD;
3041 if (isa<FunctionTemplateDecl>(Target))
3042 FD = cast<FunctionTemplateDecl>(Target)->getTemplatedDecl();
3043 else
3044 FD = cast<FunctionDecl>(Target);
3045
3046 NamedDecl *OldDecl = 0;
3047 switch (CheckOverload(FD, Previous, OldDecl)) {
3048 case Ovl_Overload:
3049 return false;
3050
3051 case Ovl_NonFunction:
John McCall41ce66f2009-12-10 19:51:03 +00003052 Diag(Using->getLocation(), diag::err_using_decl_conflict);
John McCall9f54ad42009-12-10 09:41:52 +00003053 break;
3054
3055 // We found a decl with the exact signature.
3056 case Ovl_Match:
3057 if (isa<UsingShadowDecl>(OldDecl)) {
3058 // Silently ignore the possible conflict.
3059 return false;
3060 }
3061
3062 // If we're in a record, we want to hide the target, so we
3063 // return true (without a diagnostic) to tell the caller not to
3064 // build a shadow decl.
3065 if (CurContext->isRecord())
3066 return true;
3067
3068 // If we're not in a record, this is an error.
John McCall41ce66f2009-12-10 19:51:03 +00003069 Diag(Using->getLocation(), diag::err_using_decl_conflict);
John McCall9f54ad42009-12-10 09:41:52 +00003070 break;
3071 }
3072
3073 Diag(Target->getLocation(), diag::note_using_decl_target);
3074 Diag(OldDecl->getLocation(), diag::note_using_decl_conflict);
3075 return true;
3076 }
3077
3078 // Target is not a function.
3079
John McCall9f54ad42009-12-10 09:41:52 +00003080 if (isa<TagDecl>(Target)) {
3081 // No conflict between a tag and a non-tag.
3082 if (!Tag) return false;
3083
John McCall41ce66f2009-12-10 19:51:03 +00003084 Diag(Using->getLocation(), diag::err_using_decl_conflict);
John McCall9f54ad42009-12-10 09:41:52 +00003085 Diag(Target->getLocation(), diag::note_using_decl_target);
3086 Diag(Tag->getLocation(), diag::note_using_decl_conflict);
3087 return true;
3088 }
3089
3090 // No conflict between a tag and a non-tag.
3091 if (!NonTag) return false;
3092
John McCall41ce66f2009-12-10 19:51:03 +00003093 Diag(Using->getLocation(), diag::err_using_decl_conflict);
John McCall9f54ad42009-12-10 09:41:52 +00003094 Diag(Target->getLocation(), diag::note_using_decl_target);
3095 Diag(NonTag->getLocation(), diag::note_using_decl_conflict);
3096 return true;
3097}
3098
John McCall9488ea12009-11-17 05:59:44 +00003099/// Builds a shadow declaration corresponding to a 'using' declaration.
John McCall604e7f12009-12-08 07:46:18 +00003100UsingShadowDecl *Sema::BuildUsingShadowDecl(Scope *S,
John McCall604e7f12009-12-08 07:46:18 +00003101 UsingDecl *UD,
3102 NamedDecl *Orig) {
John McCall9488ea12009-11-17 05:59:44 +00003103
3104 // If we resolved to another shadow declaration, just coalesce them.
John McCall604e7f12009-12-08 07:46:18 +00003105 NamedDecl *Target = Orig;
3106 if (isa<UsingShadowDecl>(Target)) {
3107 Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
3108 assert(!isa<UsingShadowDecl>(Target) && "nested shadow declaration");
John McCall9488ea12009-11-17 05:59:44 +00003109 }
3110
3111 UsingShadowDecl *Shadow
John McCall604e7f12009-12-08 07:46:18 +00003112 = UsingShadowDecl::Create(Context, CurContext,
3113 UD->getLocation(), UD, Target);
John McCall9488ea12009-11-17 05:59:44 +00003114 UD->addShadowDecl(Shadow);
3115
3116 if (S)
John McCall604e7f12009-12-08 07:46:18 +00003117 PushOnScopeChains(Shadow, S);
John McCall9488ea12009-11-17 05:59:44 +00003118 else
John McCall604e7f12009-12-08 07:46:18 +00003119 CurContext->addDecl(Shadow);
John McCall9f54ad42009-12-10 09:41:52 +00003120 Shadow->setAccess(UD->getAccess());
John McCall9488ea12009-11-17 05:59:44 +00003121
John McCall604e7f12009-12-08 07:46:18 +00003122 if (Orig->isInvalidDecl() || UD->isInvalidDecl())
3123 Shadow->setInvalidDecl();
3124
John McCall9f54ad42009-12-10 09:41:52 +00003125 return Shadow;
3126}
John McCall604e7f12009-12-08 07:46:18 +00003127
John McCall9f54ad42009-12-10 09:41:52 +00003128/// Hides a using shadow declaration. This is required by the current
3129/// using-decl implementation when a resolvable using declaration in a
3130/// class is followed by a declaration which would hide or override
3131/// one or more of the using decl's targets; for example:
3132///
3133/// struct Base { void foo(int); };
3134/// struct Derived : Base {
3135/// using Base::foo;
3136/// void foo(int);
3137/// };
3138///
3139/// The governing language is C++03 [namespace.udecl]p12:
3140///
3141/// When a using-declaration brings names from a base class into a
3142/// derived class scope, member functions in the derived class
3143/// override and/or hide member functions with the same name and
3144/// parameter types in a base class (rather than conflicting).
3145///
3146/// There are two ways to implement this:
3147/// (1) optimistically create shadow decls when they're not hidden
3148/// by existing declarations, or
3149/// (2) don't create any shadow decls (or at least don't make them
3150/// visible) until we've fully parsed/instantiated the class.
3151/// The problem with (1) is that we might have to retroactively remove
3152/// a shadow decl, which requires several O(n) operations because the
3153/// decl structures are (very reasonably) not designed for removal.
3154/// (2) avoids this but is very fiddly and phase-dependent.
3155void Sema::HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow) {
3156 // Remove it from the DeclContext...
3157 Shadow->getDeclContext()->removeDecl(Shadow);
John McCall604e7f12009-12-08 07:46:18 +00003158
John McCall9f54ad42009-12-10 09:41:52 +00003159 // ...and the scope, if applicable...
3160 if (S) {
3161 S->RemoveDecl(DeclPtrTy::make(static_cast<Decl*>(Shadow)));
3162 IdResolver.RemoveDecl(Shadow);
John McCall604e7f12009-12-08 07:46:18 +00003163 }
3164
John McCall9f54ad42009-12-10 09:41:52 +00003165 // ...and the using decl.
3166 Shadow->getUsingDecl()->removeShadowDecl(Shadow);
3167
3168 // TODO: complain somehow if Shadow was used. It shouldn't
3169 // be possible for this to happen, because
John McCall9488ea12009-11-17 05:59:44 +00003170}
3171
John McCall7ba107a2009-11-18 02:36:19 +00003172/// Builds a using declaration.
3173///
3174/// \param IsInstantiation - Whether this call arises from an
3175/// instantiation of an unresolved using declaration. We treat
3176/// the lookup differently for these declarations.
John McCall9488ea12009-11-17 05:59:44 +00003177NamedDecl *Sema::BuildUsingDeclaration(Scope *S, AccessSpecifier AS,
3178 SourceLocation UsingLoc,
Anders Carlssonc72160b2009-08-28 05:40:36 +00003179 const CXXScopeSpec &SS,
3180 SourceLocation IdentLoc,
3181 DeclarationName Name,
3182 AttributeList *AttrList,
John McCall7ba107a2009-11-18 02:36:19 +00003183 bool IsInstantiation,
3184 bool IsTypeName,
3185 SourceLocation TypenameLoc) {
Anders Carlssonc72160b2009-08-28 05:40:36 +00003186 assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
3187 assert(IdentLoc.isValid() && "Invalid TargetName location.");
Eli Friedman2a16a132009-08-27 05:09:36 +00003188
Anders Carlsson550b14b2009-08-28 05:49:21 +00003189 // FIXME: We ignore attributes for now.
3190 delete AttrList;
Mike Stump1eb44332009-09-09 15:08:12 +00003191
Anders Carlssoncf9f9212009-08-28 03:16:11 +00003192 if (SS.isEmpty()) {
3193 Diag(IdentLoc, diag::err_using_requires_qualname);
Anders Carlssonc72160b2009-08-28 05:40:36 +00003194 return 0;
Anders Carlssoncf9f9212009-08-28 03:16:11 +00003195 }
Mike Stump1eb44332009-09-09 15:08:12 +00003196
John McCall9f54ad42009-12-10 09:41:52 +00003197 // Do the redeclaration lookup in the current scope.
3198 LookupResult Previous(*this, Name, IdentLoc, LookupUsingDeclName,
3199 ForRedeclaration);
3200 Previous.setHideTags(false);
3201 if (S) {
3202 LookupName(Previous, S);
3203
3204 // It is really dumb that we have to do this.
3205 LookupResult::Filter F = Previous.makeFilter();
3206 while (F.hasNext()) {
3207 NamedDecl *D = F.next();
3208 if (!isDeclInScope(D, CurContext, S))
3209 F.erase();
3210 }
3211 F.done();
3212 } else {
3213 assert(IsInstantiation && "no scope in non-instantiation");
3214 assert(CurContext->isRecord() && "scope not record in instantiation");
3215 LookupQualifiedName(Previous, CurContext);
3216 }
3217
Mike Stump1eb44332009-09-09 15:08:12 +00003218 NestedNameSpecifier *NNS =
Anders Carlssoncf9f9212009-08-28 03:16:11 +00003219 static_cast<NestedNameSpecifier *>(SS.getScopeRep());
3220
John McCall9f54ad42009-12-10 09:41:52 +00003221 // Check for invalid redeclarations.
3222 if (CheckUsingDeclRedeclaration(UsingLoc, IsTypeName, SS, IdentLoc, Previous))
3223 return 0;
3224
3225 // Check for bad qualifiers.
John McCalled976492009-12-04 22:46:56 +00003226 if (CheckUsingDeclQualifier(UsingLoc, SS, IdentLoc))
3227 return 0;
3228
John McCallaf8e6ed2009-11-12 03:15:40 +00003229 DeclContext *LookupContext = computeDeclContext(SS);
John McCalled976492009-12-04 22:46:56 +00003230 NamedDecl *D;
John McCallaf8e6ed2009-11-12 03:15:40 +00003231 if (!LookupContext) {
John McCall7ba107a2009-11-18 02:36:19 +00003232 if (IsTypeName) {
John McCalled976492009-12-04 22:46:56 +00003233 // FIXME: not all declaration name kinds are legal here
3234 D = UnresolvedUsingTypenameDecl::Create(Context, CurContext,
3235 UsingLoc, TypenameLoc,
3236 SS.getRange(), NNS,
John McCall7ba107a2009-11-18 02:36:19 +00003237 IdentLoc, Name);
John McCalled976492009-12-04 22:46:56 +00003238 } else {
3239 D = UnresolvedUsingValueDecl::Create(Context, CurContext,
3240 UsingLoc, SS.getRange(), NNS,
3241 IdentLoc, Name);
John McCall7ba107a2009-11-18 02:36:19 +00003242 }
John McCalled976492009-12-04 22:46:56 +00003243 } else {
3244 D = UsingDecl::Create(Context, CurContext, IdentLoc,
3245 SS.getRange(), UsingLoc, NNS, Name,
3246 IsTypeName);
Anders Carlsson550b14b2009-08-28 05:49:21 +00003247 }
John McCalled976492009-12-04 22:46:56 +00003248 D->setAccess(AS);
3249 CurContext->addDecl(D);
3250
3251 if (!LookupContext) return D;
3252 UsingDecl *UD = cast<UsingDecl>(D);
Mike Stump1eb44332009-09-09 15:08:12 +00003253
John McCall604e7f12009-12-08 07:46:18 +00003254 if (RequireCompleteDeclContext(SS)) {
3255 UD->setInvalidDecl();
3256 return UD;
Anders Carlssoncf9f9212009-08-28 03:16:11 +00003257 }
3258
John McCall604e7f12009-12-08 07:46:18 +00003259 // Look up the target name.
3260
John McCalla24dc2e2009-11-17 02:14:36 +00003261 LookupResult R(*this, Name, IdentLoc, LookupOrdinaryName);
John McCall7ba107a2009-11-18 02:36:19 +00003262
John McCall604e7f12009-12-08 07:46:18 +00003263 // Unlike most lookups, we don't always want to hide tag
3264 // declarations: tag names are visible through the using declaration
3265 // even if hidden by ordinary names, *except* in a dependent context
3266 // where it's important for the sanity of two-phase lookup.
John McCall7ba107a2009-11-18 02:36:19 +00003267 if (!IsInstantiation)
3268 R.setHideTags(false);
John McCall9488ea12009-11-17 05:59:44 +00003269
John McCalla24dc2e2009-11-17 02:14:36 +00003270 LookupQualifiedName(R, LookupContext);
Mike Stump1eb44332009-09-09 15:08:12 +00003271
John McCallf36e02d2009-10-09 21:13:30 +00003272 if (R.empty()) {
Douglas Gregor3f093272009-10-13 21:16:44 +00003273 Diag(IdentLoc, diag::err_no_member)
3274 << Name << LookupContext << SS.getRange();
John McCalled976492009-12-04 22:46:56 +00003275 UD->setInvalidDecl();
3276 return UD;
Douglas Gregor9cfbe482009-06-20 00:51:54 +00003277 }
3278
John McCalled976492009-12-04 22:46:56 +00003279 if (R.isAmbiguous()) {
3280 UD->setInvalidDecl();
3281 return UD;
3282 }
Mike Stump1eb44332009-09-09 15:08:12 +00003283
John McCall7ba107a2009-11-18 02:36:19 +00003284 if (IsTypeName) {
3285 // If we asked for a typename and got a non-type decl, error out.
John McCalled976492009-12-04 22:46:56 +00003286 if (!R.getAsSingle<TypeDecl>()) {
John McCall7ba107a2009-11-18 02:36:19 +00003287 Diag(IdentLoc, diag::err_using_typename_non_type);
3288 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I)
3289 Diag((*I)->getUnderlyingDecl()->getLocation(),
3290 diag::note_using_decl_target);
John McCalled976492009-12-04 22:46:56 +00003291 UD->setInvalidDecl();
3292 return UD;
John McCall7ba107a2009-11-18 02:36:19 +00003293 }
3294 } else {
3295 // If we asked for a non-typename and we got a type, error out,
3296 // but only if this is an instantiation of an unresolved using
3297 // decl. Otherwise just silently find the type name.
John McCalled976492009-12-04 22:46:56 +00003298 if (IsInstantiation && R.getAsSingle<TypeDecl>()) {
John McCall7ba107a2009-11-18 02:36:19 +00003299 Diag(IdentLoc, diag::err_using_dependent_value_is_type);
3300 Diag(R.getFoundDecl()->getLocation(), diag::note_using_decl_target);
John McCalled976492009-12-04 22:46:56 +00003301 UD->setInvalidDecl();
3302 return UD;
John McCall7ba107a2009-11-18 02:36:19 +00003303 }
Anders Carlssoncf9f9212009-08-28 03:16:11 +00003304 }
3305
Anders Carlsson73b39cf2009-08-28 03:35:18 +00003306 // C++0x N2914 [namespace.udecl]p6:
3307 // A using-declaration shall not name a namespace.
John McCalled976492009-12-04 22:46:56 +00003308 if (R.getAsSingle<NamespaceDecl>()) {
Anders Carlsson73b39cf2009-08-28 03:35:18 +00003309 Diag(IdentLoc, diag::err_using_decl_can_not_refer_to_namespace)
3310 << SS.getRange();
John McCalled976492009-12-04 22:46:56 +00003311 UD->setInvalidDecl();
3312 return UD;
Anders Carlsson73b39cf2009-08-28 03:35:18 +00003313 }
Mike Stump1eb44332009-09-09 15:08:12 +00003314
John McCall9f54ad42009-12-10 09:41:52 +00003315 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {
3316 if (!CheckUsingShadowDecl(UD, *I, Previous))
3317 BuildUsingShadowDecl(S, UD, *I);
3318 }
John McCall9488ea12009-11-17 05:59:44 +00003319
3320 return UD;
Douglas Gregor9cfbe482009-06-20 00:51:54 +00003321}
3322
John McCall9f54ad42009-12-10 09:41:52 +00003323/// Checks that the given using declaration is not an invalid
3324/// redeclaration. Note that this is checking only for the using decl
3325/// itself, not for any ill-formedness among the UsingShadowDecls.
3326bool Sema::CheckUsingDeclRedeclaration(SourceLocation UsingLoc,
3327 bool isTypeName,
3328 const CXXScopeSpec &SS,
3329 SourceLocation NameLoc,
3330 const LookupResult &Prev) {
3331 // C++03 [namespace.udecl]p8:
3332 // C++0x [namespace.udecl]p10:
3333 // A using-declaration is a declaration and can therefore be used
3334 // repeatedly where (and only where) multiple declarations are
3335 // allowed.
3336 // That's only in file contexts.
3337 if (CurContext->getLookupContext()->isFileContext())
3338 return false;
3339
3340 NestedNameSpecifier *Qual
3341 = static_cast<NestedNameSpecifier*>(SS.getScopeRep());
3342
3343 for (LookupResult::iterator I = Prev.begin(), E = Prev.end(); I != E; ++I) {
3344 NamedDecl *D = *I;
3345
3346 bool DTypename;
3347 NestedNameSpecifier *DQual;
3348 if (UsingDecl *UD = dyn_cast<UsingDecl>(D)) {
3349 DTypename = UD->isTypeName();
3350 DQual = UD->getTargetNestedNameDecl();
3351 } else if (UnresolvedUsingValueDecl *UD
3352 = dyn_cast<UnresolvedUsingValueDecl>(D)) {
3353 DTypename = false;
3354 DQual = UD->getTargetNestedNameSpecifier();
3355 } else if (UnresolvedUsingTypenameDecl *UD
3356 = dyn_cast<UnresolvedUsingTypenameDecl>(D)) {
3357 DTypename = true;
3358 DQual = UD->getTargetNestedNameSpecifier();
3359 } else continue;
3360
3361 // using decls differ if one says 'typename' and the other doesn't.
3362 // FIXME: non-dependent using decls?
3363 if (isTypeName != DTypename) continue;
3364
3365 // using decls differ if they name different scopes (but note that
3366 // template instantiation can cause this check to trigger when it
3367 // didn't before instantiation).
3368 if (Context.getCanonicalNestedNameSpecifier(Qual) !=
3369 Context.getCanonicalNestedNameSpecifier(DQual))
3370 continue;
3371
3372 Diag(NameLoc, diag::err_using_decl_redeclaration) << SS.getRange();
John McCall41ce66f2009-12-10 19:51:03 +00003373 Diag(D->getLocation(), diag::note_using_decl) << 1;
John McCall9f54ad42009-12-10 09:41:52 +00003374 return true;
3375 }
3376
3377 return false;
3378}
3379
John McCall604e7f12009-12-08 07:46:18 +00003380
John McCalled976492009-12-04 22:46:56 +00003381/// Checks that the given nested-name qualifier used in a using decl
3382/// in the current context is appropriately related to the current
3383/// scope. If an error is found, diagnoses it and returns true.
3384bool Sema::CheckUsingDeclQualifier(SourceLocation UsingLoc,
3385 const CXXScopeSpec &SS,
3386 SourceLocation NameLoc) {
John McCall604e7f12009-12-08 07:46:18 +00003387 DeclContext *NamedContext = computeDeclContext(SS);
John McCalled976492009-12-04 22:46:56 +00003388
John McCall604e7f12009-12-08 07:46:18 +00003389 if (!CurContext->isRecord()) {
3390 // C++03 [namespace.udecl]p3:
3391 // C++0x [namespace.udecl]p8:
3392 // A using-declaration for a class member shall be a member-declaration.
3393
3394 // If we weren't able to compute a valid scope, it must be a
3395 // dependent class scope.
3396 if (!NamedContext || NamedContext->isRecord()) {
3397 Diag(NameLoc, diag::err_using_decl_can_not_refer_to_class_member)
3398 << SS.getRange();
3399 return true;
3400 }
3401
3402 // Otherwise, everything is known to be fine.
3403 return false;
3404 }
3405
3406 // The current scope is a record.
3407
3408 // If the named context is dependent, we can't decide much.
3409 if (!NamedContext) {
3410 // FIXME: in C++0x, we can diagnose if we can prove that the
3411 // nested-name-specifier does not refer to a base class, which is
3412 // still possible in some cases.
3413
3414 // Otherwise we have to conservatively report that things might be
3415 // okay.
3416 return false;
3417 }
3418
3419 if (!NamedContext->isRecord()) {
3420 // Ideally this would point at the last name in the specifier,
3421 // but we don't have that level of source info.
3422 Diag(SS.getRange().getBegin(),
3423 diag::err_using_decl_nested_name_specifier_is_not_class)
3424 << (NestedNameSpecifier*) SS.getScopeRep() << SS.getRange();
3425 return true;
3426 }
3427
3428 if (getLangOptions().CPlusPlus0x) {
3429 // C++0x [namespace.udecl]p3:
3430 // In a using-declaration used as a member-declaration, the
3431 // nested-name-specifier shall name a base class of the class
3432 // being defined.
3433
3434 if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(
3435 cast<CXXRecordDecl>(NamedContext))) {
3436 if (CurContext == NamedContext) {
3437 Diag(NameLoc,
3438 diag::err_using_decl_nested_name_specifier_is_current_class)
3439 << SS.getRange();
3440 return true;
3441 }
3442
3443 Diag(SS.getRange().getBegin(),
3444 diag::err_using_decl_nested_name_specifier_is_not_base_class)
3445 << (NestedNameSpecifier*) SS.getScopeRep()
3446 << cast<CXXRecordDecl>(CurContext)
3447 << SS.getRange();
3448 return true;
3449 }
3450
3451 return false;
3452 }
3453
3454 // C++03 [namespace.udecl]p4:
3455 // A using-declaration used as a member-declaration shall refer
3456 // to a member of a base class of the class being defined [etc.].
3457
3458 // Salient point: SS doesn't have to name a base class as long as
3459 // lookup only finds members from base classes. Therefore we can
3460 // diagnose here only if we can prove that that can't happen,
3461 // i.e. if the class hierarchies provably don't intersect.
3462
3463 // TODO: it would be nice if "definitely valid" results were cached
3464 // in the UsingDecl and UsingShadowDecl so that these checks didn't
3465 // need to be repeated.
3466
3467 struct UserData {
3468 llvm::DenseSet<const CXXRecordDecl*> Bases;
3469
3470 static bool collect(const CXXRecordDecl *Base, void *OpaqueData) {
3471 UserData *Data = reinterpret_cast<UserData*>(OpaqueData);
3472 Data->Bases.insert(Base);
3473 return true;
3474 }
3475
3476 bool hasDependentBases(const CXXRecordDecl *Class) {
3477 return !Class->forallBases(collect, this);
3478 }
3479
3480 /// Returns true if the base is dependent or is one of the
3481 /// accumulated base classes.
3482 static bool doesNotContain(const CXXRecordDecl *Base, void *OpaqueData) {
3483 UserData *Data = reinterpret_cast<UserData*>(OpaqueData);
3484 return !Data->Bases.count(Base);
3485 }
3486
3487 bool mightShareBases(const CXXRecordDecl *Class) {
3488 return Bases.count(Class) || !Class->forallBases(doesNotContain, this);
3489 }
3490 };
3491
3492 UserData Data;
3493
3494 // Returns false if we find a dependent base.
3495 if (Data.hasDependentBases(cast<CXXRecordDecl>(CurContext)))
3496 return false;
3497
3498 // Returns false if the class has a dependent base or if it or one
3499 // of its bases is present in the base set of the current context.
3500 if (Data.mightShareBases(cast<CXXRecordDecl>(NamedContext)))
3501 return false;
3502
3503 Diag(SS.getRange().getBegin(),
3504 diag::err_using_decl_nested_name_specifier_is_not_base_class)
3505 << (NestedNameSpecifier*) SS.getScopeRep()
3506 << cast<CXXRecordDecl>(CurContext)
3507 << SS.getRange();
3508
3509 return true;
John McCalled976492009-12-04 22:46:56 +00003510}
3511
Mike Stump1eb44332009-09-09 15:08:12 +00003512Sema::DeclPtrTy Sema::ActOnNamespaceAliasDef(Scope *S,
Anders Carlsson03bd5a12009-03-28 22:53:22 +00003513 SourceLocation NamespaceLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00003514 SourceLocation AliasLoc,
3515 IdentifierInfo *Alias,
3516 const CXXScopeSpec &SS,
Anders Carlsson03bd5a12009-03-28 22:53:22 +00003517 SourceLocation IdentLoc,
3518 IdentifierInfo *Ident) {
Mike Stump1eb44332009-09-09 15:08:12 +00003519
Anders Carlsson81c85c42009-03-28 23:53:49 +00003520 // Lookup the namespace name.
John McCalla24dc2e2009-11-17 02:14:36 +00003521 LookupResult R(*this, Ident, IdentLoc, LookupNamespaceName);
3522 LookupParsedName(R, S, &SS);
Anders Carlsson81c85c42009-03-28 23:53:49 +00003523
Anders Carlsson8d7ba402009-03-28 06:23:46 +00003524 // Check if we have a previous declaration with the same name.
John McCallf36e02d2009-10-09 21:13:30 +00003525 if (NamedDecl *PrevDecl
John McCall7d384dd2009-11-18 07:57:50 +00003526 = LookupSingleName(S, Alias, LookupOrdinaryName, ForRedeclaration)) {
Anders Carlsson81c85c42009-03-28 23:53:49 +00003527 if (NamespaceAliasDecl *AD = dyn_cast<NamespaceAliasDecl>(PrevDecl)) {
Mike Stump1eb44332009-09-09 15:08:12 +00003528 // We already have an alias with the same name that points to the same
Anders Carlsson81c85c42009-03-28 23:53:49 +00003529 // namespace, so don't create a new one.
John McCallf36e02d2009-10-09 21:13:30 +00003530 if (!R.isAmbiguous() && !R.empty() &&
3531 AD->getNamespace() == getNamespaceDecl(R.getFoundDecl()))
Anders Carlsson81c85c42009-03-28 23:53:49 +00003532 return DeclPtrTy();
3533 }
Mike Stump1eb44332009-09-09 15:08:12 +00003534
Anders Carlsson8d7ba402009-03-28 06:23:46 +00003535 unsigned DiagID = isa<NamespaceDecl>(PrevDecl) ? diag::err_redefinition :
3536 diag::err_redefinition_different_kind;
3537 Diag(AliasLoc, DiagID) << Alias;
3538 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
Chris Lattnerb28317a2009-03-28 19:18:32 +00003539 return DeclPtrTy();
Anders Carlsson8d7ba402009-03-28 06:23:46 +00003540 }
3541
John McCalla24dc2e2009-11-17 02:14:36 +00003542 if (R.isAmbiguous())
Chris Lattnerb28317a2009-03-28 19:18:32 +00003543 return DeclPtrTy();
Mike Stump1eb44332009-09-09 15:08:12 +00003544
John McCallf36e02d2009-10-09 21:13:30 +00003545 if (R.empty()) {
Anders Carlsson5721c682009-03-28 06:42:02 +00003546 Diag(NamespaceLoc, diag::err_expected_namespace_name) << SS.getRange();
Chris Lattnerb28317a2009-03-28 19:18:32 +00003547 return DeclPtrTy();
Anders Carlsson5721c682009-03-28 06:42:02 +00003548 }
Mike Stump1eb44332009-09-09 15:08:12 +00003549
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00003550 NamespaceAliasDecl *AliasDecl =
Mike Stump1eb44332009-09-09 15:08:12 +00003551 NamespaceAliasDecl::Create(Context, CurContext, NamespaceLoc, AliasLoc,
3552 Alias, SS.getRange(),
Douglas Gregor6c9c9402009-05-30 06:48:27 +00003553 (NestedNameSpecifier *)SS.getScopeRep(),
John McCallf36e02d2009-10-09 21:13:30 +00003554 IdentLoc, R.getFoundDecl());
Mike Stump1eb44332009-09-09 15:08:12 +00003555
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00003556 CurContext->addDecl(AliasDecl);
Anders Carlsson68771c72009-03-28 22:58:02 +00003557 return DeclPtrTy::make(AliasDecl);
Anders Carlssondbb00942009-03-28 05:27:17 +00003558}
3559
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00003560void Sema::DefineImplicitDefaultConstructor(SourceLocation CurrentLocation,
3561 CXXConstructorDecl *Constructor) {
Fariborz Jahanian05a5c452009-06-22 20:37:23 +00003562 assert((Constructor->isImplicit() && Constructor->isDefaultConstructor() &&
3563 !Constructor->isUsed()) &&
3564 "DefineImplicitDefaultConstructor - call it for implicit default ctor");
Mike Stump1eb44332009-09-09 15:08:12 +00003565
Eli Friedman80c30da2009-11-09 19:20:36 +00003566 CXXRecordDecl *ClassDecl
3567 = cast<CXXRecordDecl>(Constructor->getDeclContext());
3568 assert(ClassDecl && "DefineImplicitDefaultConstructor - invalid constructor");
Eli Friedman49c16da2009-11-09 01:05:47 +00003569
Eli Friedman80c30da2009-11-09 19:20:36 +00003570 if (SetBaseOrMemberInitializers(Constructor, 0, 0, true)) {
Anders Carlsson37909802009-11-30 21:24:50 +00003571 Diag(CurrentLocation, diag::note_member_synthesized_at)
3572 << CXXDefaultConstructor << Context.getTagDeclType(ClassDecl);
Eli Friedman80c30da2009-11-09 19:20:36 +00003573 Constructor->setInvalidDecl();
3574 } else {
3575 Constructor->setUsed();
3576 }
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00003577}
3578
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003579void Sema::DefineImplicitDestructor(SourceLocation CurrentLocation,
Douglas Gregor4fe95f92009-09-04 19:04:08 +00003580 CXXDestructorDecl *Destructor) {
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003581 assert((Destructor->isImplicit() && !Destructor->isUsed()) &&
3582 "DefineImplicitDestructor - call it for implicit default dtor");
Anders Carlsson6d701392009-11-15 22:49:34 +00003583 CXXRecordDecl *ClassDecl = Destructor->getParent();
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003584 assert(ClassDecl && "DefineImplicitDestructor - invalid destructor");
3585 // C++ [class.dtor] p5
Mike Stump1eb44332009-09-09 15:08:12 +00003586 // Before the implicitly-declared default destructor for a class is
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003587 // implicitly defined, all the implicitly-declared default destructors
3588 // for its base class and its non-static data members shall have been
3589 // implicitly defined.
Fariborz Jahanian514b7b12009-06-30 16:36:53 +00003590 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
3591 E = ClassDecl->bases_end(); Base != E; ++Base) {
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003592 CXXRecordDecl *BaseClassDecl
Ted Kremenek6217b802009-07-29 21:53:49 +00003593 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003594 if (!BaseClassDecl->hasTrivialDestructor()) {
Mike Stump1eb44332009-09-09 15:08:12 +00003595 if (CXXDestructorDecl *BaseDtor =
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003596 const_cast<CXXDestructorDecl*>(BaseClassDecl->getDestructor(Context)))
3597 MarkDeclarationReferenced(CurrentLocation, BaseDtor);
3598 else
Mike Stump1eb44332009-09-09 15:08:12 +00003599 assert(false &&
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003600 "DefineImplicitDestructor - missing dtor in a base class");
3601 }
3602 }
Mike Stump1eb44332009-09-09 15:08:12 +00003603
Fariborz Jahanian514b7b12009-06-30 16:36:53 +00003604 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
3605 E = ClassDecl->field_end(); Field != E; ++Field) {
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003606 QualType FieldType = Context.getCanonicalType((*Field)->getType());
3607 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
3608 FieldType = Array->getElementType();
Ted Kremenek6217b802009-07-29 21:53:49 +00003609 if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003610 CXXRecordDecl *FieldClassDecl
3611 = cast<CXXRecordDecl>(FieldClassType->getDecl());
3612 if (!FieldClassDecl->hasTrivialDestructor()) {
Mike Stump1eb44332009-09-09 15:08:12 +00003613 if (CXXDestructorDecl *FieldDtor =
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003614 const_cast<CXXDestructorDecl*>(
3615 FieldClassDecl->getDestructor(Context)))
3616 MarkDeclarationReferenced(CurrentLocation, FieldDtor);
3617 else
Mike Stump1eb44332009-09-09 15:08:12 +00003618 assert(false &&
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003619 "DefineImplicitDestructor - missing dtor in class of a data member");
3620 }
3621 }
3622 }
Anders Carlsson37909802009-11-30 21:24:50 +00003623
3624 // FIXME: If CheckDestructor fails, we should emit a note about where the
3625 // implicit destructor was needed.
3626 if (CheckDestructor(Destructor)) {
3627 Diag(CurrentLocation, diag::note_member_synthesized_at)
3628 << CXXDestructor << Context.getTagDeclType(ClassDecl);
3629
3630 Destructor->setInvalidDecl();
3631 return;
3632 }
3633
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003634 Destructor->setUsed();
3635}
3636
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003637void Sema::DefineImplicitOverloadedAssign(SourceLocation CurrentLocation,
3638 CXXMethodDecl *MethodDecl) {
3639 assert((MethodDecl->isImplicit() && MethodDecl->isOverloadedOperator() &&
3640 MethodDecl->getOverloadedOperator() == OO_Equal &&
3641 !MethodDecl->isUsed()) &&
3642 "DefineImplicitOverloadedAssign - call it for implicit assignment op");
Mike Stump1eb44332009-09-09 15:08:12 +00003643
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003644 CXXRecordDecl *ClassDecl
3645 = cast<CXXRecordDecl>(MethodDecl->getDeclContext());
Mike Stump1eb44332009-09-09 15:08:12 +00003646
Fariborz Jahanianc6249b92009-06-26 16:08:57 +00003647 // C++[class.copy] p12
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003648 // Before the implicitly-declared copy assignment operator for a class is
3649 // implicitly defined, all implicitly-declared copy assignment operators
3650 // for its direct base classes and its nonstatic data members shall have
3651 // been implicitly defined.
3652 bool err = false;
Fariborz Jahanian514b7b12009-06-30 16:36:53 +00003653 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
3654 E = ClassDecl->bases_end(); Base != E; ++Base) {
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003655 CXXRecordDecl *BaseClassDecl
Ted Kremenek6217b802009-07-29 21:53:49 +00003656 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Mike Stump1eb44332009-09-09 15:08:12 +00003657 if (CXXMethodDecl *BaseAssignOpMethod =
Anders Carlssonb6cc91b2009-12-09 03:01:51 +00003658 getAssignOperatorMethod(CurrentLocation, MethodDecl->getParamDecl(0),
3659 BaseClassDecl))
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003660 MarkDeclarationReferenced(CurrentLocation, BaseAssignOpMethod);
3661 }
Fariborz Jahanian514b7b12009-06-30 16:36:53 +00003662 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
3663 E = ClassDecl->field_end(); Field != E; ++Field) {
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003664 QualType FieldType = Context.getCanonicalType((*Field)->getType());
3665 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
3666 FieldType = Array->getElementType();
Ted Kremenek6217b802009-07-29 21:53:49 +00003667 if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003668 CXXRecordDecl *FieldClassDecl
3669 = cast<CXXRecordDecl>(FieldClassType->getDecl());
Mike Stump1eb44332009-09-09 15:08:12 +00003670 if (CXXMethodDecl *FieldAssignOpMethod =
Anders Carlssonb6cc91b2009-12-09 03:01:51 +00003671 getAssignOperatorMethod(CurrentLocation, MethodDecl->getParamDecl(0),
3672 FieldClassDecl))
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003673 MarkDeclarationReferenced(CurrentLocation, FieldAssignOpMethod);
Mike Stumpac5fc7c2009-08-04 21:02:39 +00003674 } else if (FieldType->isReferenceType()) {
Mike Stump1eb44332009-09-09 15:08:12 +00003675 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
Anders Carlsson5e09d4c2009-07-09 17:47:25 +00003676 << Context.getTagDeclType(ClassDecl) << 0 << Field->getDeclName();
3677 Diag(Field->getLocation(), diag::note_declared_at);
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003678 Diag(CurrentLocation, diag::note_first_required_here);
3679 err = true;
Mike Stumpac5fc7c2009-08-04 21:02:39 +00003680 } else if (FieldType.isConstQualified()) {
Mike Stump1eb44332009-09-09 15:08:12 +00003681 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
Anders Carlsson5e09d4c2009-07-09 17:47:25 +00003682 << Context.getTagDeclType(ClassDecl) << 1 << Field->getDeclName();
3683 Diag(Field->getLocation(), diag::note_declared_at);
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003684 Diag(CurrentLocation, diag::note_first_required_here);
3685 err = true;
3686 }
3687 }
3688 if (!err)
Mike Stump1eb44332009-09-09 15:08:12 +00003689 MethodDecl->setUsed();
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003690}
3691
3692CXXMethodDecl *
Anders Carlssonb6cc91b2009-12-09 03:01:51 +00003693Sema::getAssignOperatorMethod(SourceLocation CurrentLocation,
3694 ParmVarDecl *ParmDecl,
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003695 CXXRecordDecl *ClassDecl) {
3696 QualType LHSType = Context.getTypeDeclType(ClassDecl);
3697 QualType RHSType(LHSType);
3698 // If class's assignment operator argument is const/volatile qualified,
Mike Stump1eb44332009-09-09 15:08:12 +00003699 // look for operator = (const/volatile B&). Otherwise, look for
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003700 // operator = (B&).
John McCall0953e762009-09-24 19:53:00 +00003701 RHSType = Context.getCVRQualifiedType(RHSType,
3702 ParmDecl->getType().getCVRQualifiers());
Mike Stump1eb44332009-09-09 15:08:12 +00003703 ExprOwningPtr<Expr> LHS(this, new (Context) DeclRefExpr(ParmDecl,
Anders Carlssonb6cc91b2009-12-09 03:01:51 +00003704 LHSType,
3705 SourceLocation()));
Mike Stump1eb44332009-09-09 15:08:12 +00003706 ExprOwningPtr<Expr> RHS(this, new (Context) DeclRefExpr(ParmDecl,
Anders Carlssonb6cc91b2009-12-09 03:01:51 +00003707 RHSType,
3708 CurrentLocation));
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003709 Expr *Args[2] = { &*LHS, &*RHS };
3710 OverloadCandidateSet CandidateSet;
Mike Stump1eb44332009-09-09 15:08:12 +00003711 AddMemberOperatorCandidates(clang::OO_Equal, SourceLocation(), Args, 2,
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003712 CandidateSet);
3713 OverloadCandidateSet::iterator Best;
Anders Carlssonb6cc91b2009-12-09 03:01:51 +00003714 if (BestViableFunction(CandidateSet, CurrentLocation, Best) == OR_Success)
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00003715 return cast<CXXMethodDecl>(Best->Function);
3716 assert(false &&
3717 "getAssignOperatorMethod - copy assignment operator method not found");
3718 return 0;
3719}
3720
Fariborz Jahanian485f0872009-06-22 23:34:40 +00003721void Sema::DefineImplicitCopyConstructor(SourceLocation CurrentLocation,
3722 CXXConstructorDecl *CopyConstructor,
3723 unsigned TypeQuals) {
Mike Stump1eb44332009-09-09 15:08:12 +00003724 assert((CopyConstructor->isImplicit() &&
Fariborz Jahanian485f0872009-06-22 23:34:40 +00003725 CopyConstructor->isCopyConstructor(Context, TypeQuals) &&
3726 !CopyConstructor->isUsed()) &&
3727 "DefineImplicitCopyConstructor - call it for implicit copy ctor");
Mike Stump1eb44332009-09-09 15:08:12 +00003728
Fariborz Jahanian485f0872009-06-22 23:34:40 +00003729 CXXRecordDecl *ClassDecl
3730 = cast<CXXRecordDecl>(CopyConstructor->getDeclContext());
3731 assert(ClassDecl && "DefineImplicitCopyConstructor - invalid constructor");
Fariborz Jahanian220a0f32009-06-23 23:42:10 +00003732 // C++ [class.copy] p209
Mike Stump1eb44332009-09-09 15:08:12 +00003733 // Before the implicitly-declared copy constructor for a class is
Fariborz Jahanian485f0872009-06-22 23:34:40 +00003734 // implicitly defined, all the implicitly-declared copy constructors
3735 // for its base class and its non-static data members shall have been
3736 // implicitly defined.
3737 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin();
3738 Base != ClassDecl->bases_end(); ++Base) {
3739 CXXRecordDecl *BaseClassDecl
Ted Kremenek6217b802009-07-29 21:53:49 +00003740 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Mike Stump1eb44332009-09-09 15:08:12 +00003741 if (CXXConstructorDecl *BaseCopyCtor =
Fariborz Jahanian485f0872009-06-22 23:34:40 +00003742 BaseClassDecl->getCopyConstructor(Context, TypeQuals))
Fariborz Jahanian220a0f32009-06-23 23:42:10 +00003743 MarkDeclarationReferenced(CurrentLocation, BaseCopyCtor);
Fariborz Jahanian485f0872009-06-22 23:34:40 +00003744 }
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00003745 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
3746 FieldEnd = ClassDecl->field_end();
3747 Field != FieldEnd; ++Field) {
Fariborz Jahanian485f0872009-06-22 23:34:40 +00003748 QualType FieldType = Context.getCanonicalType((*Field)->getType());
3749 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
3750 FieldType = Array->getElementType();
Ted Kremenek6217b802009-07-29 21:53:49 +00003751 if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
Fariborz Jahanian485f0872009-06-22 23:34:40 +00003752 CXXRecordDecl *FieldClassDecl
3753 = cast<CXXRecordDecl>(FieldClassType->getDecl());
Mike Stump1eb44332009-09-09 15:08:12 +00003754 if (CXXConstructorDecl *FieldCopyCtor =
Fariborz Jahanian485f0872009-06-22 23:34:40 +00003755 FieldClassDecl->getCopyConstructor(Context, TypeQuals))
Fariborz Jahanian220a0f32009-06-23 23:42:10 +00003756 MarkDeclarationReferenced(CurrentLocation, FieldCopyCtor);
Fariborz Jahanian485f0872009-06-22 23:34:40 +00003757 }
3758 }
3759 CopyConstructor->setUsed();
3760}
3761
Anders Carlssonda3f4e22009-08-25 05:12:04 +00003762Sema::OwningExprResult
Anders Carlssonec8e5ea2009-09-05 07:40:38 +00003763Sema::BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
Mike Stump1eb44332009-09-09 15:08:12 +00003764 CXXConstructorDecl *Constructor,
Douglas Gregor16006c92009-12-16 18:50:27 +00003765 MultiExprArg ExprArgs,
3766 bool RequiresZeroInit) {
Anders Carlsson9abf2ae2009-08-16 05:13:48 +00003767 bool Elidable = false;
Mike Stump1eb44332009-09-09 15:08:12 +00003768
Douglas Gregor39da0b82009-09-09 23:08:42 +00003769 // C++ [class.copy]p15:
3770 // Whenever a temporary class object is copied using a copy constructor, and
3771 // this object and the copy have the same cv-unqualified type, an
3772 // implementation is permitted to treat the original and the copy as two
3773 // different ways of referring to the same object and not perform a copy at
3774 // all, even if the class copy constructor or destructor have side effects.
Mike Stump1eb44332009-09-09 15:08:12 +00003775
Anders Carlsson9abf2ae2009-08-16 05:13:48 +00003776 // FIXME: Is this enough?
Douglas Gregor39da0b82009-09-09 23:08:42 +00003777 if (Constructor->isCopyConstructor(Context)) {
Anders Carlssonf47511a2009-09-07 22:23:31 +00003778 Expr *E = ((Expr **)ExprArgs.get())[0];
Anders Carlsson9abf2ae2009-08-16 05:13:48 +00003779 while (CXXBindTemporaryExpr *BE = dyn_cast<CXXBindTemporaryExpr>(E))
3780 E = BE->getSubExpr();
Douglas Gregor39da0b82009-09-09 23:08:42 +00003781 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
3782 if (ICE->getCastKind() == CastExpr::CK_NoOp)
3783 E = ICE->getSubExpr();
Eli Friedman03368432009-12-06 09:26:33 +00003784
3785 if (CallExpr *CE = dyn_cast<CallExpr>(E))
3786 Elidable = !CE->getCallReturnType()->isReferenceType();
3787 else if (isa<CXXTemporaryObjectExpr>(E))
Anders Carlsson9abf2ae2009-08-16 05:13:48 +00003788 Elidable = true;
3789 }
Mike Stump1eb44332009-09-09 15:08:12 +00003790
3791 return BuildCXXConstructExpr(ConstructLoc, DeclInitType, Constructor,
Douglas Gregor16006c92009-12-16 18:50:27 +00003792 Elidable, move(ExprArgs), RequiresZeroInit);
Anders Carlsson9abf2ae2009-08-16 05:13:48 +00003793}
3794
Fariborz Jahanianb2c352e2009-08-05 17:03:54 +00003795/// BuildCXXConstructExpr - Creates a complete call to a constructor,
3796/// including handling of its default argument expressions.
Anders Carlssonda3f4e22009-08-25 05:12:04 +00003797Sema::OwningExprResult
Anders Carlssonec8e5ea2009-09-05 07:40:38 +00003798Sema::BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
3799 CXXConstructorDecl *Constructor, bool Elidable,
Douglas Gregor16006c92009-12-16 18:50:27 +00003800 MultiExprArg ExprArgs,
3801 bool RequiresZeroInit) {
Anders Carlssonf47511a2009-09-07 22:23:31 +00003802 unsigned NumExprs = ExprArgs.size();
3803 Expr **Exprs = (Expr **)ExprArgs.release();
Mike Stump1eb44332009-09-09 15:08:12 +00003804
Douglas Gregor7edfb692009-11-23 12:27:39 +00003805 MarkDeclarationReferenced(ConstructLoc, Constructor);
Douglas Gregor99a2e602009-12-16 01:38:02 +00003806 return Owned(CXXConstructExpr::Create(Context, DeclInitType, ConstructLoc,
Douglas Gregor16006c92009-12-16 18:50:27 +00003807 Constructor, Elidable, Exprs, NumExprs,
3808 RequiresZeroInit));
Fariborz Jahanianb2c352e2009-08-05 17:03:54 +00003809}
3810
Anders Carlssone7624a72009-08-27 05:08:22 +00003811Sema::OwningExprResult
Mike Stump1eb44332009-09-09 15:08:12 +00003812Sema::BuildCXXTemporaryObjectExpr(CXXConstructorDecl *Constructor,
3813 QualType Ty,
3814 SourceLocation TyBeginLoc,
Anders Carlssone7624a72009-08-27 05:08:22 +00003815 MultiExprArg Args,
3816 SourceLocation RParenLoc) {
Douglas Gregor39da0b82009-09-09 23:08:42 +00003817 unsigned NumExprs = Args.size();
3818 Expr **Exprs = (Expr **)Args.release();
Mike Stump1eb44332009-09-09 15:08:12 +00003819
Douglas Gregor7edfb692009-11-23 12:27:39 +00003820 MarkDeclarationReferenced(TyBeginLoc, Constructor);
Douglas Gregor39da0b82009-09-09 23:08:42 +00003821 return Owned(new (Context) CXXTemporaryObjectExpr(Context, Constructor, Ty,
3822 TyBeginLoc, Exprs,
3823 NumExprs, RParenLoc));
Anders Carlssone7624a72009-08-27 05:08:22 +00003824}
3825
3826
Mike Stump1eb44332009-09-09 15:08:12 +00003827bool Sema::InitializeVarWithConstructor(VarDecl *VD,
Fariborz Jahanianb2c352e2009-08-05 17:03:54 +00003828 CXXConstructorDecl *Constructor,
Anders Carlssonf47511a2009-09-07 22:23:31 +00003829 MultiExprArg Exprs) {
Mike Stump1eb44332009-09-09 15:08:12 +00003830 OwningExprResult TempResult =
Fariborz Jahanianc0fcce42009-10-28 18:41:06 +00003831 BuildCXXConstructExpr(VD->getLocation(), VD->getType(), Constructor,
Anders Carlssonf47511a2009-09-07 22:23:31 +00003832 move(Exprs));
Anders Carlssonfe2de492009-08-25 05:18:00 +00003833 if (TempResult.isInvalid())
3834 return true;
Mike Stump1eb44332009-09-09 15:08:12 +00003835
Anders Carlssonda3f4e22009-08-25 05:12:04 +00003836 Expr *Temp = TempResult.takeAs<Expr>();
Douglas Gregord7f37bf2009-06-22 23:06:13 +00003837 MarkDeclarationReferenced(VD->getLocation(), Constructor);
Anders Carlsson0ece4912009-12-15 20:51:39 +00003838 Temp = MaybeCreateCXXExprWithTemporaries(Temp);
Douglas Gregor78d15832009-05-26 18:54:04 +00003839 VD->setInit(Context, Temp);
Mike Stump1eb44332009-09-09 15:08:12 +00003840
Anders Carlssonfe2de492009-08-25 05:18:00 +00003841 return false;
Anders Carlsson930e8d02009-04-16 23:50:50 +00003842}
3843
Mike Stump1eb44332009-09-09 15:08:12 +00003844void Sema::FinalizeVarWithDestructor(VarDecl *VD, QualType DeclInitType) {
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003845 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(
Ted Kremenek6217b802009-07-29 21:53:49 +00003846 DeclInitType->getAs<RecordType>()->getDecl());
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003847 if (!ClassDecl->hasTrivialDestructor())
Mike Stump1eb44332009-09-09 15:08:12 +00003848 if (CXXDestructorDecl *Destructor =
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003849 const_cast<CXXDestructorDecl*>(ClassDecl->getDestructor(Context)))
Fariborz Jahaniana83f7ed2009-08-03 19:13:25 +00003850 MarkDeclarationReferenced(VD->getLocation(), Destructor);
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00003851}
3852
Mike Stump1eb44332009-09-09 15:08:12 +00003853/// AddCXXDirectInitializerToDecl - This action is called immediately after
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00003854/// ActOnDeclarator, when a C++ direct initializer is present.
3855/// e.g: "int x(1);"
Chris Lattnerb28317a2009-03-28 19:18:32 +00003856void Sema::AddCXXDirectInitializerToDecl(DeclPtrTy Dcl,
3857 SourceLocation LParenLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +00003858 MultiExprArg Exprs,
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00003859 SourceLocation *CommaLocs,
3860 SourceLocation RParenLoc) {
Sebastian Redlf53597f2009-03-15 17:47:39 +00003861 unsigned NumExprs = Exprs.size();
3862 assert(NumExprs != 0 && Exprs.get() && "missing expressions");
Chris Lattnerb28317a2009-03-28 19:18:32 +00003863 Decl *RealDecl = Dcl.getAs<Decl>();
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00003864
3865 // If there is no declaration, there was an error parsing it. Just ignore
3866 // the initializer.
Chris Lattnerb28317a2009-03-28 19:18:32 +00003867 if (RealDecl == 0)
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00003868 return;
Mike Stump1eb44332009-09-09 15:08:12 +00003869
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00003870 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
3871 if (!VDecl) {
3872 Diag(RealDecl->getLocation(), diag::err_illegal_initializer);
3873 RealDecl->setInvalidDecl();
3874 return;
3875 }
3876
Douglas Gregor83ddad32009-08-26 21:14:46 +00003877 // We will represent direct-initialization similarly to copy-initialization:
Argyrios Kyrtzidisce8e2922008-10-06 23:08:37 +00003878 // int x(1); -as-> int x = 1;
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00003879 // ClassType x(a,b,c); -as-> ClassType x = ClassType(a,b,c);
3880 //
3881 // Clients that want to distinguish between the two forms, can check for
3882 // direct initializer using VarDecl::hasCXXDirectInitializer().
3883 // A major benefit is that clients that don't particularly care about which
3884 // exactly form was it (like the CodeGen) can handle both cases without
3885 // special case code.
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +00003886
Douglas Gregor83ddad32009-08-26 21:14:46 +00003887 // If either the declaration has a dependent type or if any of the expressions
3888 // is type-dependent, we represent the initialization via a ParenListExpr for
3889 // later use during template instantiation.
3890 if (VDecl->getType()->isDependentType() ||
3891 Expr::hasAnyTypeDependentArguments((Expr **)Exprs.get(), Exprs.size())) {
3892 // Let clients know that initialization was done with a direct initializer.
3893 VDecl->setCXXDirectInitializer(true);
Mike Stump1eb44332009-09-09 15:08:12 +00003894
Douglas Gregor83ddad32009-08-26 21:14:46 +00003895 // Store the initialization expressions as a ParenListExpr.
3896 unsigned NumExprs = Exprs.size();
Mike Stump1eb44332009-09-09 15:08:12 +00003897 VDecl->setInit(Context,
Douglas Gregor83ddad32009-08-26 21:14:46 +00003898 new (Context) ParenListExpr(Context, LParenLoc,
3899 (Expr **)Exprs.release(),
3900 NumExprs, RParenLoc));
3901 return;
3902 }
Mike Stump1eb44332009-09-09 15:08:12 +00003903
Douglas Gregor83ddad32009-08-26 21:14:46 +00003904
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00003905 // C++ 8.5p11:
3906 // The form of initialization (using parentheses or '=') is generally
3907 // insignificant, but does matter when the entity being initialized has a
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +00003908 // class type.
Douglas Gregor18fe5682008-11-03 20:45:27 +00003909 QualType DeclInitType = VDecl->getType();
3910 if (const ArrayType *Array = Context.getAsArrayType(DeclInitType))
Fariborz Jahanian680a3f32009-10-28 19:04:36 +00003911 DeclInitType = Context.getBaseElementType(Array);
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +00003912
Douglas Gregor615c5d42009-03-24 16:43:20 +00003913 // FIXME: This isn't the right place to complete the type.
3914 if (RequireCompleteType(VDecl->getLocation(), VDecl->getType(),
3915 diag::err_typecheck_decl_incomplete_type)) {
3916 VDecl->setInvalidDecl();
3917 return;
3918 }
3919
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +00003920 if (VDecl->getType()->isRecordType()) {
Douglas Gregor39da0b82009-09-09 23:08:42 +00003921 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(*this);
3922
Douglas Gregor18fe5682008-11-03 20:45:27 +00003923 CXXConstructorDecl *Constructor
Sebastian Redlf53597f2009-03-15 17:47:39 +00003924 = PerformInitializationByConstructor(DeclInitType,
Douglas Gregor39da0b82009-09-09 23:08:42 +00003925 move(Exprs),
Douglas Gregorf03d7c72008-11-05 15:29:30 +00003926 VDecl->getLocation(),
3927 SourceRange(VDecl->getLocation(),
3928 RParenLoc),
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003929 VDecl->getDeclName(),
Douglas Gregor20093b42009-12-09 23:02:17 +00003930 InitializationKind::CreateDirect(VDecl->getLocation(),
3931 LParenLoc,
3932 RParenLoc),
Douglas Gregor39da0b82009-09-09 23:08:42 +00003933 ConstructorArgs);
Sebastian Redlf53597f2009-03-15 17:47:39 +00003934 if (!Constructor)
Douglas Gregor18fe5682008-11-03 20:45:27 +00003935 RealDecl->setInvalidDecl();
Anders Carlssonca29ad92009-04-15 21:48:18 +00003936 else {
Anders Carlssonca29ad92009-04-15 21:48:18 +00003937 VDecl->setCXXDirectInitializer(true);
Fariborz Jahanianc0fcce42009-10-28 18:41:06 +00003938 if (InitializeVarWithConstructor(VDecl, Constructor,
Douglas Gregor39da0b82009-09-09 23:08:42 +00003939 move_arg(ConstructorArgs)))
Anders Carlssonfe2de492009-08-25 05:18:00 +00003940 RealDecl->setInvalidDecl();
Fariborz Jahaniana83f7ed2009-08-03 19:13:25 +00003941 FinalizeVarWithDestructor(VDecl, DeclInitType);
Anders Carlssonca29ad92009-04-15 21:48:18 +00003942 }
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +00003943 return;
3944 }
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00003945
Argyrios Kyrtzidisce8e2922008-10-06 23:08:37 +00003946 if (NumExprs > 1) {
Chris Lattnerdcd5ef12008-11-19 05:27:50 +00003947 Diag(CommaLocs[0], diag::err_builtin_direct_init_more_than_one_arg)
3948 << SourceRange(VDecl->getLocation(), RParenLoc);
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00003949 RealDecl->setInvalidDecl();
3950 return;
3951 }
3952
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00003953 // Let clients know that initialization was done with a direct initializer.
3954 VDecl->setCXXDirectInitializer(true);
Argyrios Kyrtzidisce8e2922008-10-06 23:08:37 +00003955
3956 assert(NumExprs == 1 && "Expected 1 expression");
3957 // Set the init expression, handles conversions.
Sebastian Redlf53597f2009-03-15 17:47:39 +00003958 AddInitializerToDecl(Dcl, ExprArg(*this, Exprs.release()[0]),
3959 /*DirectInit=*/true);
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00003960}
Douglas Gregor27c8dc02008-10-29 00:13:59 +00003961
Douglas Gregor19aeac62009-11-14 03:27:21 +00003962/// \brief Add the applicable constructor candidates for an initialization
3963/// by constructor.
3964static void AddConstructorInitializationCandidates(Sema &SemaRef,
3965 QualType ClassType,
3966 Expr **Args,
3967 unsigned NumArgs,
Douglas Gregor20093b42009-12-09 23:02:17 +00003968 InitializationKind Kind,
Douglas Gregor19aeac62009-11-14 03:27:21 +00003969 OverloadCandidateSet &CandidateSet) {
3970 // C++ [dcl.init]p14:
3971 // If the initialization is direct-initialization, or if it is
3972 // copy-initialization where the cv-unqualified version of the
3973 // source type is the same class as, or a derived class of, the
3974 // class of the destination, constructors are considered. The
3975 // applicable constructors are enumerated (13.3.1.3), and the
3976 // best one is chosen through overload resolution (13.3). The
3977 // constructor so selected is called to initialize the object,
3978 // with the initializer expression(s) as its argument(s). If no
3979 // constructor applies, or the overload resolution is ambiguous,
3980 // the initialization is ill-formed.
3981 const RecordType *ClassRec = ClassType->getAs<RecordType>();
3982 assert(ClassRec && "Can only initialize a class type here");
3983
3984 // FIXME: When we decide not to synthesize the implicitly-declared
3985 // constructors, we'll need to make them appear here.
3986
3987 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(ClassRec->getDecl());
3988 DeclarationName ConstructorName
3989 = SemaRef.Context.DeclarationNames.getCXXConstructorName(
3990 SemaRef.Context.getCanonicalType(ClassType).getUnqualifiedType());
3991 DeclContext::lookup_const_iterator Con, ConEnd;
3992 for (llvm::tie(Con, ConEnd) = ClassDecl->lookup(ConstructorName);
3993 Con != ConEnd; ++Con) {
3994 // Find the constructor (which may be a template).
3995 CXXConstructorDecl *Constructor = 0;
3996 FunctionTemplateDecl *ConstructorTmpl= dyn_cast<FunctionTemplateDecl>(*Con);
3997 if (ConstructorTmpl)
3998 Constructor
3999 = cast<CXXConstructorDecl>(ConstructorTmpl->getTemplatedDecl());
4000 else
4001 Constructor = cast<CXXConstructorDecl>(*Con);
4002
Douglas Gregor20093b42009-12-09 23:02:17 +00004003 if ((Kind.getKind() == InitializationKind::IK_Direct) ||
4004 (Kind.getKind() == InitializationKind::IK_Value) ||
4005 (Kind.getKind() == InitializationKind::IK_Copy &&
Douglas Gregor19aeac62009-11-14 03:27:21 +00004006 Constructor->isConvertingConstructor(/*AllowExplicit=*/false)) ||
Douglas Gregor20093b42009-12-09 23:02:17 +00004007 ((Kind.getKind() == InitializationKind::IK_Default) &&
4008 Constructor->isDefaultConstructor())) {
Douglas Gregor19aeac62009-11-14 03:27:21 +00004009 if (ConstructorTmpl)
John McCalld5532b62009-11-23 01:53:49 +00004010 SemaRef.AddTemplateOverloadCandidate(ConstructorTmpl,
4011 /*ExplicitArgs*/ 0,
Douglas Gregor19aeac62009-11-14 03:27:21 +00004012 Args, NumArgs, CandidateSet);
4013 else
4014 SemaRef.AddOverloadCandidate(Constructor, Args, NumArgs, CandidateSet);
4015 }
4016 }
4017}
4018
4019/// \brief Attempt to perform initialization by constructor
4020/// (C++ [dcl.init]p14), which may occur as part of direct-initialization or
4021/// copy-initialization.
4022///
4023/// This routine determines whether initialization by constructor is possible,
4024/// but it does not emit any diagnostics in the case where the initialization
4025/// is ill-formed.
4026///
4027/// \param ClassType the type of the object being initialized, which must have
4028/// class type.
4029///
4030/// \param Args the arguments provided to initialize the object
4031///
4032/// \param NumArgs the number of arguments provided to initialize the object
4033///
4034/// \param Kind the type of initialization being performed
4035///
4036/// \returns the constructor used to initialize the object, if successful.
4037/// Otherwise, emits a diagnostic and returns NULL.
4038CXXConstructorDecl *
4039Sema::TryInitializationByConstructor(QualType ClassType,
4040 Expr **Args, unsigned NumArgs,
4041 SourceLocation Loc,
4042 InitializationKind Kind) {
4043 // Build the overload candidate set
4044 OverloadCandidateSet CandidateSet;
4045 AddConstructorInitializationCandidates(*this, ClassType, Args, NumArgs, Kind,
4046 CandidateSet);
4047
4048 // Determine whether we found a constructor we can use.
4049 OverloadCandidateSet::iterator Best;
4050 switch (BestViableFunction(CandidateSet, Loc, Best)) {
4051 case OR_Success:
4052 case OR_Deleted:
4053 // We found a constructor. Return it.
4054 return cast<CXXConstructorDecl>(Best->Function);
4055
4056 case OR_No_Viable_Function:
4057 case OR_Ambiguous:
4058 // Overload resolution failed. Return nothing.
4059 return 0;
4060 }
4061
4062 // Silence GCC warning
4063 return 0;
4064}
4065
Douglas Gregor39da0b82009-09-09 23:08:42 +00004066/// \brief Perform initialization by constructor (C++ [dcl.init]p14), which
4067/// may occur as part of direct-initialization or copy-initialization.
4068///
4069/// \param ClassType the type of the object being initialized, which must have
4070/// class type.
4071///
4072/// \param ArgsPtr the arguments provided to initialize the object
4073///
4074/// \param Loc the source location where the initialization occurs
4075///
4076/// \param Range the source range that covers the entire initialization
4077///
4078/// \param InitEntity the name of the entity being initialized, if known
4079///
4080/// \param Kind the type of initialization being performed
4081///
4082/// \param ConvertedArgs a vector that will be filled in with the
4083/// appropriately-converted arguments to the constructor (if initialization
4084/// succeeded).
4085///
4086/// \returns the constructor used to initialize the object, if successful.
4087/// Otherwise, emits a diagnostic and returns NULL.
Douglas Gregor18fe5682008-11-03 20:45:27 +00004088CXXConstructorDecl *
Douglas Gregorf03d7c72008-11-05 15:29:30 +00004089Sema::PerformInitializationByConstructor(QualType ClassType,
Douglas Gregor39da0b82009-09-09 23:08:42 +00004090 MultiExprArg ArgsPtr,
Douglas Gregorf03d7c72008-11-05 15:29:30 +00004091 SourceLocation Loc, SourceRange Range,
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00004092 DeclarationName InitEntity,
Douglas Gregor39da0b82009-09-09 23:08:42 +00004093 InitializationKind Kind,
4094 ASTOwningVector<&ActionBase::DeleteExpr> &ConvertedArgs) {
Douglas Gregor19aeac62009-11-14 03:27:21 +00004095
4096 // Build the overload candidate set
Douglas Gregor39da0b82009-09-09 23:08:42 +00004097 Expr **Args = (Expr **)ArgsPtr.get();
4098 unsigned NumArgs = ArgsPtr.size();
Douglas Gregor18fe5682008-11-03 20:45:27 +00004099 OverloadCandidateSet CandidateSet;
Douglas Gregor19aeac62009-11-14 03:27:21 +00004100 AddConstructorInitializationCandidates(*this, ClassType, Args, NumArgs, Kind,
4101 CandidateSet);
Douglas Gregor9e7d9de2008-12-15 21:24:18 +00004102
Douglas Gregor18fe5682008-11-03 20:45:27 +00004103 OverloadCandidateSet::iterator Best;
Douglas Gregore0762c92009-06-19 23:52:42 +00004104 switch (BestViableFunction(CandidateSet, Loc, Best)) {
Douglas Gregor18fe5682008-11-03 20:45:27 +00004105 case OR_Success:
Douglas Gregor39da0b82009-09-09 23:08:42 +00004106 // We found a constructor. Break out so that we can convert the arguments
4107 // appropriately.
4108 break;
Mike Stump1eb44332009-09-09 15:08:12 +00004109
Douglas Gregor18fe5682008-11-03 20:45:27 +00004110 case OR_No_Viable_Function:
Douglas Gregor87fd7032009-02-02 17:43:21 +00004111 if (InitEntity)
4112 Diag(Loc, diag::err_ovl_no_viable_function_in_init)
Chris Lattner4330d652009-02-17 07:29:20 +00004113 << InitEntity << Range;
Douglas Gregor87fd7032009-02-02 17:43:21 +00004114 else
4115 Diag(Loc, diag::err_ovl_no_viable_function_in_init)
Chris Lattner4330d652009-02-17 07:29:20 +00004116 << ClassType << Range;
Sebastian Redle4c452c2008-11-22 13:44:36 +00004117 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/false);
Douglas Gregor18fe5682008-11-03 20:45:27 +00004118 return 0;
Mike Stump1eb44332009-09-09 15:08:12 +00004119
Douglas Gregor18fe5682008-11-03 20:45:27 +00004120 case OR_Ambiguous:
Douglas Gregor87fd7032009-02-02 17:43:21 +00004121 if (InitEntity)
4122 Diag(Loc, diag::err_ovl_ambiguous_init) << InitEntity << Range;
4123 else
4124 Diag(Loc, diag::err_ovl_ambiguous_init) << ClassType << Range;
Douglas Gregor18fe5682008-11-03 20:45:27 +00004125 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
4126 return 0;
Douglas Gregor48f3bb92009-02-18 21:56:37 +00004127
4128 case OR_Deleted:
4129 if (InitEntity)
4130 Diag(Loc, diag::err_ovl_deleted_init)
4131 << Best->Function->isDeleted()
4132 << InitEntity << Range;
Fariborz Jahanian6a587cb2009-11-25 21:53:11 +00004133 else {
4134 const CXXRecordDecl *RD =
4135 cast<CXXRecordDecl>(ClassType->getAs<RecordType>()->getDecl());
Douglas Gregor48f3bb92009-02-18 21:56:37 +00004136 Diag(Loc, diag::err_ovl_deleted_init)
4137 << Best->Function->isDeleted()
Fariborz Jahanian6a587cb2009-11-25 21:53:11 +00004138 << RD->getDeclName() << Range;
4139 }
Douglas Gregor48f3bb92009-02-18 21:56:37 +00004140 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
4141 return 0;
Douglas Gregor18fe5682008-11-03 20:45:27 +00004142 }
Mike Stump1eb44332009-09-09 15:08:12 +00004143
Douglas Gregor39da0b82009-09-09 23:08:42 +00004144 // Convert the arguments, fill in default arguments, etc.
4145 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function);
4146 if (CompleteConstructorCall(Constructor, move(ArgsPtr), Loc, ConvertedArgs))
4147 return 0;
4148
4149 return Constructor;
4150}
4151
4152/// \brief Given a constructor and the set of arguments provided for the
4153/// constructor, convert the arguments and add any required default arguments
4154/// to form a proper call to this constructor.
4155///
4156/// \returns true if an error occurred, false otherwise.
4157bool
4158Sema::CompleteConstructorCall(CXXConstructorDecl *Constructor,
4159 MultiExprArg ArgsPtr,
4160 SourceLocation Loc,
4161 ASTOwningVector<&ActionBase::DeleteExpr> &ConvertedArgs) {
4162 // FIXME: This duplicates a lot of code from Sema::ConvertArgumentsForCall.
4163 unsigned NumArgs = ArgsPtr.size();
4164 Expr **Args = (Expr **)ArgsPtr.get();
4165
4166 const FunctionProtoType *Proto
4167 = Constructor->getType()->getAs<FunctionProtoType>();
4168 assert(Proto && "Constructor without a prototype?");
4169 unsigned NumArgsInProto = Proto->getNumArgs();
Douglas Gregor39da0b82009-09-09 23:08:42 +00004170
4171 // If too few arguments are available, we'll fill in the rest with defaults.
Fariborz Jahanian2fe168f2009-11-24 21:37:28 +00004172 if (NumArgs < NumArgsInProto)
Douglas Gregor39da0b82009-09-09 23:08:42 +00004173 ConvertedArgs.reserve(NumArgsInProto);
Fariborz Jahanian2fe168f2009-11-24 21:37:28 +00004174 else
Douglas Gregor39da0b82009-09-09 23:08:42 +00004175 ConvertedArgs.reserve(NumArgs);
Fariborz Jahanian2fe168f2009-11-24 21:37:28 +00004176
4177 VariadicCallType CallType =
4178 Proto->isVariadic() ? VariadicConstructor : VariadicDoesNotApply;
4179 llvm::SmallVector<Expr *, 8> AllArgs;
4180 bool Invalid = GatherArgumentsForCall(Loc, Constructor,
4181 Proto, 0, Args, NumArgs, AllArgs,
4182 CallType);
4183 for (unsigned i =0, size = AllArgs.size(); i < size; i++)
4184 ConvertedArgs.push_back(AllArgs[i]);
4185 return Invalid;
Douglas Gregor18fe5682008-11-03 20:45:27 +00004186}
4187
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004188/// CompareReferenceRelationship - Compare the two types T1 and T2 to
4189/// determine whether they are reference-related,
4190/// reference-compatible, reference-compatible with added
4191/// qualification, or incompatible, for use in C++ initialization by
4192/// reference (C++ [dcl.ref.init]p4). Neither type can be a reference
4193/// type, and the first type (T1) is the pointee type of the reference
4194/// type being initialized.
Mike Stump1eb44332009-09-09 15:08:12 +00004195Sema::ReferenceCompareResult
Douglas Gregor393896f2009-11-05 13:06:35 +00004196Sema::CompareReferenceRelationship(SourceLocation Loc,
4197 QualType OrigT1, QualType OrigT2,
Douglas Gregor15da57e2008-10-29 02:00:59 +00004198 bool& DerivedToBase) {
Douglas Gregor393896f2009-11-05 13:06:35 +00004199 assert(!OrigT1->isReferenceType() &&
Sebastian Redl7c80bd62009-03-16 23:22:08 +00004200 "T1 must be the pointee type of the reference type");
Douglas Gregor393896f2009-11-05 13:06:35 +00004201 assert(!OrigT2->isReferenceType() && "T2 cannot be a reference type");
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004202
Douglas Gregor393896f2009-11-05 13:06:35 +00004203 QualType T1 = Context.getCanonicalType(OrigT1);
4204 QualType T2 = Context.getCanonicalType(OrigT2);
Douglas Gregora4923eb2009-11-16 21:35:15 +00004205 QualType UnqualT1 = T1.getLocalUnqualifiedType();
4206 QualType UnqualT2 = T2.getLocalUnqualifiedType();
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004207
4208 // C++ [dcl.init.ref]p4:
Eli Friedman33a31382009-08-05 19:21:58 +00004209 // Given types "cv1 T1" and "cv2 T2," "cv1 T1" is
Mike Stump1eb44332009-09-09 15:08:12 +00004210 // reference-related to "cv2 T2" if T1 is the same type as T2, or
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004211 // T1 is a base class of T2.
Douglas Gregor15da57e2008-10-29 02:00:59 +00004212 if (UnqualT1 == UnqualT2)
4213 DerivedToBase = false;
Douglas Gregor393896f2009-11-05 13:06:35 +00004214 else if (!RequireCompleteType(Loc, OrigT1, PDiag()) &&
4215 !RequireCompleteType(Loc, OrigT2, PDiag()) &&
4216 IsDerivedFrom(UnqualT2, UnqualT1))
Douglas Gregor15da57e2008-10-29 02:00:59 +00004217 DerivedToBase = true;
4218 else
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004219 return Ref_Incompatible;
4220
4221 // At this point, we know that T1 and T2 are reference-related (at
4222 // least).
4223
4224 // C++ [dcl.init.ref]p4:
Eli Friedman33a31382009-08-05 19:21:58 +00004225 // "cv1 T1" is reference-compatible with "cv2 T2" if T1 is
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004226 // reference-related to T2 and cv1 is the same cv-qualification
4227 // as, or greater cv-qualification than, cv2. For purposes of
4228 // overload resolution, cases for which cv1 is greater
4229 // cv-qualification than cv2 are identified as
4230 // reference-compatible with added qualification (see 13.3.3.2).
4231 if (T1.getCVRQualifiers() == T2.getCVRQualifiers())
4232 return Ref_Compatible;
4233 else if (T1.isMoreQualifiedThan(T2))
4234 return Ref_Compatible_With_Added_Qualification;
4235 else
4236 return Ref_Related;
4237}
4238
4239/// CheckReferenceInit - Check the initialization of a reference
4240/// variable with the given initializer (C++ [dcl.init.ref]). Init is
4241/// the initializer (either a simple initializer or an initializer
Douglas Gregor3205a782008-10-29 23:31:03 +00004242/// list), and DeclType is the type of the declaration. When ICS is
4243/// non-null, this routine will compute the implicit conversion
4244/// sequence according to C++ [over.ics.ref] and will not produce any
4245/// diagnostics; when ICS is null, it will emit diagnostics when any
4246/// errors are found. Either way, a return value of true indicates
4247/// that there was a failure, a return value of false indicates that
4248/// the reference initialization succeeded.
Douglas Gregor225c41e2008-11-03 19:09:14 +00004249///
4250/// When @p SuppressUserConversions, user-defined conversions are
4251/// suppressed.
Douglas Gregor09f41cf2009-01-14 15:45:31 +00004252/// When @p AllowExplicit, we also permit explicit user-defined
4253/// conversion functions.
Sebastian Redle2b68332009-04-12 17:16:29 +00004254/// When @p ForceRValue, we unconditionally treat the initializer as an rvalue.
Sebastian Redla82e4ae2009-11-14 21:15:49 +00004255/// When @p IgnoreBaseAccess, we don't do access control on to-base conversion.
4256/// This is used when this is called from a C-style cast.
Mike Stump1eb44332009-09-09 15:08:12 +00004257bool
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004258Sema::CheckReferenceInit(Expr *&Init, QualType DeclType,
Douglas Gregor739d8282009-09-23 23:04:10 +00004259 SourceLocation DeclLoc,
Douglas Gregor09f41cf2009-01-14 15:45:31 +00004260 bool SuppressUserConversions,
Anders Carlsson2de3ace2009-08-27 17:30:43 +00004261 bool AllowExplicit, bool ForceRValue,
Sebastian Redla82e4ae2009-11-14 21:15:49 +00004262 ImplicitConversionSequence *ICS,
4263 bool IgnoreBaseAccess) {
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004264 assert(DeclType->isReferenceType() && "Reference init needs a reference");
4265
Ted Kremenek6217b802009-07-29 21:53:49 +00004266 QualType T1 = DeclType->getAs<ReferenceType>()->getPointeeType();
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004267 QualType T2 = Init->getType();
4268
Douglas Gregor904eed32008-11-10 20:40:00 +00004269 // If the initializer is the address of an overloaded function, try
4270 // to resolve the overloaded function. If all goes well, T2 is the
4271 // type of the resulting function.
Douglas Gregor063daf62009-03-13 18:40:31 +00004272 if (Context.getCanonicalType(T2) == Context.OverloadTy) {
Mike Stump1eb44332009-09-09 15:08:12 +00004273 FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Init, DeclType,
Douglas Gregor904eed32008-11-10 20:40:00 +00004274 ICS != 0);
4275 if (Fn) {
4276 // Since we're performing this reference-initialization for
4277 // real, update the initializer with the resulting function.
Douglas Gregor48f3bb92009-02-18 21:56:37 +00004278 if (!ICS) {
Douglas Gregor739d8282009-09-23 23:04:10 +00004279 if (DiagnoseUseOfDecl(Fn, DeclLoc))
Douglas Gregor20093b42009-12-09 23:02:17 +00004280 return true;
Douglas Gregor48f3bb92009-02-18 21:56:37 +00004281
Anders Carlsson96ad5332009-10-21 17:16:23 +00004282 Init = FixOverloadedFunctionReference(Init, Fn);
Douglas Gregor48f3bb92009-02-18 21:56:37 +00004283 }
Douglas Gregor904eed32008-11-10 20:40:00 +00004284
4285 T2 = Fn->getType();
4286 }
4287 }
4288
Douglas Gregor15da57e2008-10-29 02:00:59 +00004289 // Compute some basic properties of the types and the initializer.
Sebastian Redl7c80bd62009-03-16 23:22:08 +00004290 bool isRValRef = DeclType->isRValueReferenceType();
Douglas Gregor15da57e2008-10-29 02:00:59 +00004291 bool DerivedToBase = false;
Sebastian Redle2b68332009-04-12 17:16:29 +00004292 Expr::isLvalueResult InitLvalue = ForceRValue ? Expr::LV_InvalidExpression :
4293 Init->isLvalue(Context);
Mike Stump1eb44332009-09-09 15:08:12 +00004294 ReferenceCompareResult RefRelationship
Douglas Gregor393896f2009-11-05 13:06:35 +00004295 = CompareReferenceRelationship(DeclLoc, T1, T2, DerivedToBase);
Douglas Gregor15da57e2008-10-29 02:00:59 +00004296
4297 // Most paths end in a failed conversion.
4298 if (ICS)
4299 ICS->ConversionKind = ImplicitConversionSequence::BadConversion;
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004300
4301 // C++ [dcl.init.ref]p5:
Eli Friedman33a31382009-08-05 19:21:58 +00004302 // A reference to type "cv1 T1" is initialized by an expression
4303 // of type "cv2 T2" as follows:
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004304
4305 // -- If the initializer expression
4306
Sebastian Redla9845802009-03-29 15:27:50 +00004307 // Rvalue references cannot bind to lvalues (N2812).
4308 // There is absolutely no situation where they can. In particular, note that
4309 // this is ill-formed, even if B has a user-defined conversion to A&&:
4310 // B b;
4311 // A&& r = b;
4312 if (isRValRef && InitLvalue == Expr::LV_Valid) {
4313 if (!ICS)
Douglas Gregor739d8282009-09-23 23:04:10 +00004314 Diag(DeclLoc, diag::err_lvalue_to_rvalue_ref)
Sebastian Redla9845802009-03-29 15:27:50 +00004315 << Init->getSourceRange();
4316 return true;
4317 }
4318
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004319 bool BindsDirectly = false;
Eli Friedman33a31382009-08-05 19:21:58 +00004320 // -- is an lvalue (but is not a bit-field), and "cv1 T1" is
4321 // reference-compatible with "cv2 T2," or
Douglas Gregor15da57e2008-10-29 02:00:59 +00004322 //
4323 // Note that the bit-field check is skipped if we are just computing
4324 // the implicit conversion sequence (C++ [over.best.ics]p2).
Douglas Gregor33bbbc52009-05-02 02:18:30 +00004325 if (InitLvalue == Expr::LV_Valid && (ICS || !Init->getBitField()) &&
Douglas Gregor15da57e2008-10-29 02:00:59 +00004326 RefRelationship >= Ref_Compatible_With_Added_Qualification) {
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004327 BindsDirectly = true;
4328
Douglas Gregor15da57e2008-10-29 02:00:59 +00004329 if (ICS) {
4330 // C++ [over.ics.ref]p1:
4331 // When a parameter of reference type binds directly (8.5.3)
4332 // to an argument expression, the implicit conversion sequence
4333 // is the identity conversion, unless the argument expression
4334 // has a type that is a derived class of the parameter type,
4335 // in which case the implicit conversion sequence is a
4336 // derived-to-base Conversion (13.3.3.1).
4337 ICS->ConversionKind = ImplicitConversionSequence::StandardConversion;
4338 ICS->Standard.First = ICK_Identity;
4339 ICS->Standard.Second = DerivedToBase? ICK_Derived_To_Base : ICK_Identity;
4340 ICS->Standard.Third = ICK_Identity;
4341 ICS->Standard.FromTypePtr = T2.getAsOpaquePtr();
4342 ICS->Standard.ToTypePtr = T1.getAsOpaquePtr();
Douglas Gregorf70bdb92008-10-29 14:50:44 +00004343 ICS->Standard.ReferenceBinding = true;
4344 ICS->Standard.DirectBinding = true;
Sebastian Redla9845802009-03-29 15:27:50 +00004345 ICS->Standard.RRefBinding = false;
Sebastian Redl76458502009-04-17 16:30:52 +00004346 ICS->Standard.CopyConstructor = 0;
Douglas Gregor15da57e2008-10-29 02:00:59 +00004347
4348 // Nothing more to do: the inaccessibility/ambiguity check for
4349 // derived-to-base conversions is suppressed when we're
4350 // computing the implicit conversion sequence (C++
4351 // [over.best.ics]p2).
4352 return false;
4353 } else {
4354 // Perform the conversion.
Douglas Gregor39da0b82009-09-09 23:08:42 +00004355 CastExpr::CastKind CK = CastExpr::CK_NoOp;
4356 if (DerivedToBase)
4357 CK = CastExpr::CK_DerivedToBase;
Sebastian Redl2c7588f2009-10-10 12:04:10 +00004358 else if(CheckExceptionSpecCompatibility(Init, T1))
4359 return true;
Douglas Gregor39da0b82009-09-09 23:08:42 +00004360 ImpCastExprToType(Init, T1, CK, /*isLvalue=*/true);
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004361 }
4362 }
4363
4364 // -- has a class type (i.e., T2 is a class type) and can be
Eli Friedman33a31382009-08-05 19:21:58 +00004365 // implicitly converted to an lvalue of type "cv3 T3,"
4366 // where "cv1 T1" is reference-compatible with "cv3 T3"
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004367 // 92) (this conversion is selected by enumerating the
4368 // applicable conversion functions (13.3.1.6) and choosing
4369 // the best one through overload resolution (13.3)),
Douglas Gregor5842ba92009-08-24 15:23:48 +00004370 if (!isRValRef && !SuppressUserConversions && T2->isRecordType() &&
Douglas Gregor573d9c32009-10-21 23:19:44 +00004371 !RequireCompleteType(DeclLoc, T2, 0)) {
Mike Stump1eb44332009-09-09 15:08:12 +00004372 CXXRecordDecl *T2RecordDecl
Ted Kremenek6217b802009-07-29 21:53:49 +00004373 = dyn_cast<CXXRecordDecl>(T2->getAs<RecordType>()->getDecl());
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004374
Douglas Gregorcb9b9772008-11-10 16:14:15 +00004375 OverloadCandidateSet CandidateSet;
John McCallba135432009-11-21 08:51:07 +00004376 const UnresolvedSet *Conversions
Fariborz Jahanian51bebc82009-09-23 20:55:32 +00004377 = T2RecordDecl->getVisibleConversionFunctions();
John McCallba135432009-11-21 08:51:07 +00004378 for (UnresolvedSet::iterator I = Conversions->begin(),
4379 E = Conversions->end(); I != E; ++I) {
John McCall701c89e2009-12-03 04:06:58 +00004380 NamedDecl *D = *I;
4381 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
4382 if (isa<UsingShadowDecl>(D))
4383 D = cast<UsingShadowDecl>(D)->getTargetDecl();
4384
Mike Stump1eb44332009-09-09 15:08:12 +00004385 FunctionTemplateDecl *ConvTemplate
John McCall701c89e2009-12-03 04:06:58 +00004386 = dyn_cast<FunctionTemplateDecl>(D);
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00004387 CXXConversionDecl *Conv;
4388 if (ConvTemplate)
4389 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
4390 else
John McCall701c89e2009-12-03 04:06:58 +00004391 Conv = cast<CXXConversionDecl>(D);
Fariborz Jahanian51bebc82009-09-23 20:55:32 +00004392
Douglas Gregorcb9b9772008-11-10 16:14:15 +00004393 // If the conversion function doesn't return a reference type,
4394 // it can't be considered for this conversion.
Sebastian Redl7c80bd62009-03-16 23:22:08 +00004395 if (Conv->getConversionType()->isLValueReferenceType() &&
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00004396 (AllowExplicit || !Conv->isExplicit())) {
4397 if (ConvTemplate)
John McCall701c89e2009-12-03 04:06:58 +00004398 AddTemplateConversionCandidate(ConvTemplate, ActingDC,
4399 Init, DeclType, CandidateSet);
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00004400 else
John McCall701c89e2009-12-03 04:06:58 +00004401 AddConversionCandidate(Conv, ActingDC, Init, DeclType, CandidateSet);
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00004402 }
Douglas Gregorcb9b9772008-11-10 16:14:15 +00004403 }
4404
4405 OverloadCandidateSet::iterator Best;
Douglas Gregor739d8282009-09-23 23:04:10 +00004406 switch (BestViableFunction(CandidateSet, DeclLoc, Best)) {
Douglas Gregorcb9b9772008-11-10 16:14:15 +00004407 case OR_Success:
4408 // This is a direct binding.
4409 BindsDirectly = true;
4410
4411 if (ICS) {
4412 // C++ [over.ics.ref]p1:
4413 //
4414 // [...] If the parameter binds directly to the result of
4415 // applying a conversion function to the argument
4416 // expression, the implicit conversion sequence is a
4417 // user-defined conversion sequence (13.3.3.1.2), with the
4418 // second standard conversion sequence either an identity
4419 // conversion or, if the conversion function returns an
4420 // entity of a type that is a derived class of the parameter
4421 // type, a derived-to-base Conversion.
4422 ICS->ConversionKind = ImplicitConversionSequence::UserDefinedConversion;
4423 ICS->UserDefined.Before = Best->Conversions[0].Standard;
4424 ICS->UserDefined.After = Best->FinalConversion;
4425 ICS->UserDefined.ConversionFunction = Best->Function;
Fariborz Jahanian966256a2009-11-06 00:23:08 +00004426 ICS->UserDefined.EllipsisConversion = false;
Douglas Gregorcb9b9772008-11-10 16:14:15 +00004427 assert(ICS->UserDefined.After.ReferenceBinding &&
4428 ICS->UserDefined.After.DirectBinding &&
4429 "Expected a direct reference binding!");
4430 return false;
4431 } else {
Fariborz Jahanian8f489d62009-09-23 22:34:00 +00004432 OwningExprResult InitConversion =
Douglas Gregor739d8282009-09-23 23:04:10 +00004433 BuildCXXCastArgument(DeclLoc, QualType(),
Fariborz Jahanian8f489d62009-09-23 22:34:00 +00004434 CastExpr::CK_UserDefinedConversion,
4435 cast<CXXMethodDecl>(Best->Function),
4436 Owned(Init));
4437 Init = InitConversion.takeAs<Expr>();
Sebastian Redl2c7588f2009-10-10 12:04:10 +00004438
4439 if (CheckExceptionSpecCompatibility(Init, T1))
4440 return true;
Fariborz Jahanian8f489d62009-09-23 22:34:00 +00004441 ImpCastExprToType(Init, T1, CastExpr::CK_UserDefinedConversion,
4442 /*isLvalue=*/true);
Douglas Gregorcb9b9772008-11-10 16:14:15 +00004443 }
4444 break;
4445
4446 case OR_Ambiguous:
Fariborz Jahaniand9290cb2009-10-14 00:52:43 +00004447 if (ICS) {
4448 for (OverloadCandidateSet::iterator Cand = CandidateSet.begin();
4449 Cand != CandidateSet.end(); ++Cand)
4450 if (Cand->Viable)
4451 ICS->ConversionFunctionSet.push_back(Cand->Function);
4452 break;
4453 }
4454 Diag(DeclLoc, diag::err_ref_init_ambiguous) << DeclType << Init->getType()
4455 << Init->getSourceRange();
4456 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
Douglas Gregorcb9b9772008-11-10 16:14:15 +00004457 return true;
Mike Stump1eb44332009-09-09 15:08:12 +00004458
Douglas Gregorcb9b9772008-11-10 16:14:15 +00004459 case OR_No_Viable_Function:
Douglas Gregor48f3bb92009-02-18 21:56:37 +00004460 case OR_Deleted:
4461 // There was no suitable conversion, or we found a deleted
4462 // conversion; continue with other checks.
Douglas Gregorcb9b9772008-11-10 16:14:15 +00004463 break;
4464 }
4465 }
Mike Stump1eb44332009-09-09 15:08:12 +00004466
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004467 if (BindsDirectly) {
4468 // C++ [dcl.init.ref]p4:
4469 // [...] In all cases where the reference-related or
4470 // reference-compatible relationship of two types is used to
4471 // establish the validity of a reference binding, and T1 is a
4472 // base class of T2, a program that necessitates such a binding
4473 // is ill-formed if T1 is an inaccessible (clause 11) or
4474 // ambiguous (10.2) base class of T2.
4475 //
4476 // Note that we only check this condition when we're allowed to
4477 // complain about errors, because we should not be checking for
4478 // ambiguity (or inaccessibility) unless the reference binding
4479 // actually happens.
Mike Stump1eb44332009-09-09 15:08:12 +00004480 if (DerivedToBase)
Douglas Gregor739d8282009-09-23 23:04:10 +00004481 return CheckDerivedToBaseConversion(T2, T1, DeclLoc,
Sebastian Redla82e4ae2009-11-14 21:15:49 +00004482 Init->getSourceRange(),
4483 IgnoreBaseAccess);
Douglas Gregor15da57e2008-10-29 02:00:59 +00004484 else
4485 return false;
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004486 }
4487
4488 // -- Otherwise, the reference shall be to a non-volatile const
Sebastian Redla9845802009-03-29 15:27:50 +00004489 // type (i.e., cv1 shall be const), or the reference shall be an
4490 // rvalue reference and the initializer expression shall be an rvalue.
John McCall0953e762009-09-24 19:53:00 +00004491 if (!isRValRef && T1.getCVRQualifiers() != Qualifiers::Const) {
Douglas Gregor15da57e2008-10-29 02:00:59 +00004492 if (!ICS)
Douglas Gregor739d8282009-09-23 23:04:10 +00004493 Diag(DeclLoc, diag::err_not_reference_to_const_init)
Douglas Gregor5cc07df2009-12-15 16:44:32 +00004494 << T1 << int(InitLvalue != Expr::LV_Valid)
Chris Lattnerd1625842008-11-24 06:25:27 +00004495 << T2 << Init->getSourceRange();
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004496 return true;
4497 }
4498
4499 // -- If the initializer expression is an rvalue, with T2 a
Eli Friedman33a31382009-08-05 19:21:58 +00004500 // class type, and "cv1 T1" is reference-compatible with
4501 // "cv2 T2," the reference is bound in one of the
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004502 // following ways (the choice is implementation-defined):
4503 //
4504 // -- The reference is bound to the object represented by
4505 // the rvalue (see 3.10) or to a sub-object within that
4506 // object.
4507 //
Eli Friedman33a31382009-08-05 19:21:58 +00004508 // -- A temporary of type "cv1 T2" [sic] is created, and
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004509 // a constructor is called to copy the entire rvalue
4510 // object into the temporary. The reference is bound to
4511 // the temporary or to a sub-object within the
4512 // temporary.
4513 //
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004514 // The constructor that would be used to make the copy
4515 // shall be callable whether or not the copy is actually
4516 // done.
4517 //
Sebastian Redla9845802009-03-29 15:27:50 +00004518 // Note that C++0x [dcl.init.ref]p5 takes away this implementation
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004519 // freedom, so we will always take the first option and never build
4520 // a temporary in this case. FIXME: We will, however, have to check
4521 // for the presence of a copy constructor in C++98/03 mode.
4522 if (InitLvalue != Expr::LV_Valid && T2->isRecordType() &&
Douglas Gregor15da57e2008-10-29 02:00:59 +00004523 RefRelationship >= Ref_Compatible_With_Added_Qualification) {
4524 if (ICS) {
4525 ICS->ConversionKind = ImplicitConversionSequence::StandardConversion;
4526 ICS->Standard.First = ICK_Identity;
4527 ICS->Standard.Second = DerivedToBase? ICK_Derived_To_Base : ICK_Identity;
4528 ICS->Standard.Third = ICK_Identity;
4529 ICS->Standard.FromTypePtr = T2.getAsOpaquePtr();
4530 ICS->Standard.ToTypePtr = T1.getAsOpaquePtr();
Douglas Gregorf70bdb92008-10-29 14:50:44 +00004531 ICS->Standard.ReferenceBinding = true;
Sebastian Redla9845802009-03-29 15:27:50 +00004532 ICS->Standard.DirectBinding = false;
4533 ICS->Standard.RRefBinding = isRValRef;
Sebastian Redl76458502009-04-17 16:30:52 +00004534 ICS->Standard.CopyConstructor = 0;
Douglas Gregor15da57e2008-10-29 02:00:59 +00004535 } else {
Douglas Gregor39da0b82009-09-09 23:08:42 +00004536 CastExpr::CastKind CK = CastExpr::CK_NoOp;
4537 if (DerivedToBase)
4538 CK = CastExpr::CK_DerivedToBase;
Sebastian Redl2c7588f2009-10-10 12:04:10 +00004539 else if(CheckExceptionSpecCompatibility(Init, T1))
4540 return true;
Douglas Gregor39da0b82009-09-09 23:08:42 +00004541 ImpCastExprToType(Init, T1, CK, /*isLvalue=*/false);
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004542 }
4543 return false;
4544 }
4545
Eli Friedman33a31382009-08-05 19:21:58 +00004546 // -- Otherwise, a temporary of type "cv1 T1" is created and
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004547 // initialized from the initializer expression using the
4548 // rules for a non-reference copy initialization (8.5). The
4549 // reference is then bound to the temporary. If T1 is
4550 // reference-related to T2, cv1 must be the same
4551 // cv-qualification as, or greater cv-qualification than,
4552 // cv2; otherwise, the program is ill-formed.
4553 if (RefRelationship == Ref_Related) {
4554 // If cv1 == cv2 or cv1 is a greater cv-qualified than cv2, then
4555 // we would be reference-compatible or reference-compatible with
4556 // added qualification. But that wasn't the case, so the reference
4557 // initialization fails.
Douglas Gregor15da57e2008-10-29 02:00:59 +00004558 if (!ICS)
Douglas Gregor739d8282009-09-23 23:04:10 +00004559 Diag(DeclLoc, diag::err_reference_init_drops_quals)
Douglas Gregor5cc07df2009-12-15 16:44:32 +00004560 << T1 << int(InitLvalue != Expr::LV_Valid)
Chris Lattnerd1625842008-11-24 06:25:27 +00004561 << T2 << Init->getSourceRange();
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004562 return true;
4563 }
4564
Douglas Gregor734d9862009-01-30 23:27:23 +00004565 // If at least one of the types is a class type, the types are not
4566 // related, and we aren't allowed any user conversions, the
4567 // reference binding fails. This case is important for breaking
4568 // recursion, since TryImplicitConversion below will attempt to
4569 // create a temporary through the use of a copy constructor.
4570 if (SuppressUserConversions && RefRelationship == Ref_Incompatible &&
4571 (T1->isRecordType() || T2->isRecordType())) {
4572 if (!ICS)
Douglas Gregor739d8282009-09-23 23:04:10 +00004573 Diag(DeclLoc, diag::err_typecheck_convert_incompatible)
Douglas Gregor68647482009-12-16 03:45:30 +00004574 << DeclType << Init->getType() << AA_Initializing << Init->getSourceRange();
Douglas Gregor734d9862009-01-30 23:27:23 +00004575 return true;
4576 }
4577
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004578 // Actually try to convert the initializer to T1.
Douglas Gregor15da57e2008-10-29 02:00:59 +00004579 if (ICS) {
Sebastian Redla9845802009-03-29 15:27:50 +00004580 // C++ [over.ics.ref]p2:
Mike Stump1eb44332009-09-09 15:08:12 +00004581 //
Sebastian Redla9845802009-03-29 15:27:50 +00004582 // When a parameter of reference type is not bound directly to
4583 // an argument expression, the conversion sequence is the one
4584 // required to convert the argument expression to the
4585 // underlying type of the reference according to
4586 // 13.3.3.1. Conceptually, this conversion sequence corresponds
4587 // to copy-initializing a temporary of the underlying type with
4588 // the argument expression. Any difference in top-level
4589 // cv-qualification is subsumed by the initialization itself
4590 // and does not constitute a conversion.
Anders Carlssonda7a18b2009-08-27 17:24:15 +00004591 *ICS = TryImplicitConversion(Init, T1, SuppressUserConversions,
4592 /*AllowExplicit=*/false,
Anders Carlsson08972922009-08-28 15:33:32 +00004593 /*ForceRValue=*/false,
4594 /*InOverloadResolution=*/false);
Mike Stump1eb44332009-09-09 15:08:12 +00004595
Sebastian Redla9845802009-03-29 15:27:50 +00004596 // Of course, that's still a reference binding.
4597 if (ICS->ConversionKind == ImplicitConversionSequence::StandardConversion) {
4598 ICS->Standard.ReferenceBinding = true;
4599 ICS->Standard.RRefBinding = isRValRef;
Mike Stump1eb44332009-09-09 15:08:12 +00004600 } else if (ICS->ConversionKind ==
Sebastian Redla9845802009-03-29 15:27:50 +00004601 ImplicitConversionSequence::UserDefinedConversion) {
4602 ICS->UserDefined.After.ReferenceBinding = true;
4603 ICS->UserDefined.After.RRefBinding = isRValRef;
4604 }
Douglas Gregor15da57e2008-10-29 02:00:59 +00004605 return ICS->ConversionKind == ImplicitConversionSequence::BadConversion;
4606 } else {
Fariborz Jahanian51bebc82009-09-23 20:55:32 +00004607 ImplicitConversionSequence Conversions;
Douglas Gregor68647482009-12-16 03:45:30 +00004608 bool badConversion = PerformImplicitConversion(Init, T1, AA_Initializing,
Fariborz Jahanian51bebc82009-09-23 20:55:32 +00004609 false, false,
4610 Conversions);
4611 if (badConversion) {
4612 if ((Conversions.ConversionKind ==
4613 ImplicitConversionSequence::BadConversion)
Fariborz Jahanian82ad87b2009-09-28 22:03:07 +00004614 && !Conversions.ConversionFunctionSet.empty()) {
Fariborz Jahanian7ad2d562009-09-24 00:42:43 +00004615 Diag(DeclLoc,
Fariborz Jahanian51bebc82009-09-23 20:55:32 +00004616 diag::err_lvalue_to_rvalue_ambig_ref) << Init->getSourceRange();
4617 for (int j = Conversions.ConversionFunctionSet.size()-1;
4618 j >= 0; j--) {
4619 FunctionDecl *Func = Conversions.ConversionFunctionSet[j];
4620 Diag(Func->getLocation(), diag::err_ovl_candidate);
4621 }
4622 }
Fariborz Jahanian893f9552009-09-30 21:23:30 +00004623 else {
4624 if (isRValRef)
4625 Diag(DeclLoc, diag::err_lvalue_to_rvalue_ref)
4626 << Init->getSourceRange();
4627 else
4628 Diag(DeclLoc, diag::err_invalid_initialization)
4629 << DeclType << Init->getType() << Init->getSourceRange();
4630 }
Fariborz Jahanian51bebc82009-09-23 20:55:32 +00004631 }
4632 return badConversion;
Douglas Gregor15da57e2008-10-29 02:00:59 +00004633 }
Douglas Gregor27c8dc02008-10-29 00:13:59 +00004634}
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004635
Anders Carlsson20d45d22009-12-12 00:32:00 +00004636static inline bool
4637CheckOperatorNewDeleteDeclarationScope(Sema &SemaRef,
4638 const FunctionDecl *FnDecl) {
4639 const DeclContext *DC = FnDecl->getDeclContext()->getLookupContext();
4640 if (isa<NamespaceDecl>(DC)) {
4641 return SemaRef.Diag(FnDecl->getLocation(),
4642 diag::err_operator_new_delete_declared_in_namespace)
4643 << FnDecl->getDeclName();
4644 }
4645
4646 if (isa<TranslationUnitDecl>(DC) &&
4647 FnDecl->getStorageClass() == FunctionDecl::Static) {
4648 return SemaRef.Diag(FnDecl->getLocation(),
4649 diag::err_operator_new_delete_declared_static)
4650 << FnDecl->getDeclName();
4651 }
4652
Anders Carlssonfcfdb2b2009-12-12 02:43:16 +00004653 return false;
Anders Carlsson20d45d22009-12-12 00:32:00 +00004654}
4655
Anders Carlsson156c78e2009-12-13 17:53:43 +00004656static inline bool
4657CheckOperatorNewDeleteTypes(Sema &SemaRef, const FunctionDecl *FnDecl,
4658 CanQualType ExpectedResultType,
4659 CanQualType ExpectedFirstParamType,
4660 unsigned DependentParamTypeDiag,
4661 unsigned InvalidParamTypeDiag) {
4662 QualType ResultType =
4663 FnDecl->getType()->getAs<FunctionType>()->getResultType();
4664
4665 // Check that the result type is not dependent.
4666 if (ResultType->isDependentType())
4667 return SemaRef.Diag(FnDecl->getLocation(),
4668 diag::err_operator_new_delete_dependent_result_type)
4669 << FnDecl->getDeclName() << ExpectedResultType;
4670
4671 // Check that the result type is what we expect.
4672 if (SemaRef.Context.getCanonicalType(ResultType) != ExpectedResultType)
4673 return SemaRef.Diag(FnDecl->getLocation(),
4674 diag::err_operator_new_delete_invalid_result_type)
4675 << FnDecl->getDeclName() << ExpectedResultType;
4676
4677 // A function template must have at least 2 parameters.
4678 if (FnDecl->getDescribedFunctionTemplate() && FnDecl->getNumParams() < 2)
4679 return SemaRef.Diag(FnDecl->getLocation(),
4680 diag::err_operator_new_delete_template_too_few_parameters)
4681 << FnDecl->getDeclName();
4682
4683 // The function decl must have at least 1 parameter.
4684 if (FnDecl->getNumParams() == 0)
4685 return SemaRef.Diag(FnDecl->getLocation(),
4686 diag::err_operator_new_delete_too_few_parameters)
4687 << FnDecl->getDeclName();
4688
4689 // Check the the first parameter type is not dependent.
4690 QualType FirstParamType = FnDecl->getParamDecl(0)->getType();
4691 if (FirstParamType->isDependentType())
4692 return SemaRef.Diag(FnDecl->getLocation(), DependentParamTypeDiag)
4693 << FnDecl->getDeclName() << ExpectedFirstParamType;
4694
4695 // Check that the first parameter type is what we expect.
4696 if (SemaRef.Context.getCanonicalType(FirstParamType) !=
4697 ExpectedFirstParamType)
4698 return SemaRef.Diag(FnDecl->getLocation(), InvalidParamTypeDiag)
4699 << FnDecl->getDeclName() << ExpectedFirstParamType;
4700
4701 return false;
4702}
4703
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00004704static bool
Anders Carlsson156c78e2009-12-13 17:53:43 +00004705CheckOperatorNewDeclaration(Sema &SemaRef, const FunctionDecl *FnDecl) {
Anders Carlsson20d45d22009-12-12 00:32:00 +00004706 // C++ [basic.stc.dynamic.allocation]p1:
4707 // A program is ill-formed if an allocation function is declared in a
4708 // namespace scope other than global scope or declared static in global
4709 // scope.
4710 if (CheckOperatorNewDeleteDeclarationScope(SemaRef, FnDecl))
4711 return true;
Anders Carlsson156c78e2009-12-13 17:53:43 +00004712
4713 CanQualType SizeTy =
4714 SemaRef.Context.getCanonicalType(SemaRef.Context.getSizeType());
4715
4716 // C++ [basic.stc.dynamic.allocation]p1:
4717 // The return type shall be void*. The first parameter shall have type
4718 // std::size_t.
4719 if (CheckOperatorNewDeleteTypes(SemaRef, FnDecl, SemaRef.Context.VoidPtrTy,
4720 SizeTy,
4721 diag::err_operator_new_dependent_param_type,
4722 diag::err_operator_new_param_type))
4723 return true;
4724
4725 // C++ [basic.stc.dynamic.allocation]p1:
4726 // The first parameter shall not have an associated default argument.
4727 if (FnDecl->getParamDecl(0)->hasDefaultArg())
Anders Carlssona3ccda52009-12-12 00:26:23 +00004728 return SemaRef.Diag(FnDecl->getLocation(),
Anders Carlsson156c78e2009-12-13 17:53:43 +00004729 diag::err_operator_new_default_arg)
4730 << FnDecl->getDeclName() << FnDecl->getParamDecl(0)->getDefaultArgRange();
4731
4732 return false;
Anders Carlssona3ccda52009-12-12 00:26:23 +00004733}
4734
4735static bool
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00004736CheckOperatorDeleteDeclaration(Sema &SemaRef, const FunctionDecl *FnDecl) {
4737 // C++ [basic.stc.dynamic.deallocation]p1:
4738 // A program is ill-formed if deallocation functions are declared in a
4739 // namespace scope other than global scope or declared static in global
4740 // scope.
Anders Carlsson20d45d22009-12-12 00:32:00 +00004741 if (CheckOperatorNewDeleteDeclarationScope(SemaRef, FnDecl))
4742 return true;
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00004743
4744 // C++ [basic.stc.dynamic.deallocation]p2:
4745 // Each deallocation function shall return void and its first parameter
4746 // shall be void*.
Anders Carlsson156c78e2009-12-13 17:53:43 +00004747 if (CheckOperatorNewDeleteTypes(SemaRef, FnDecl, SemaRef.Context.VoidTy,
4748 SemaRef.Context.VoidPtrTy,
4749 diag::err_operator_delete_dependent_param_type,
4750 diag::err_operator_delete_param_type))
4751 return true;
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00004752
Anders Carlsson46991d62009-12-12 00:16:02 +00004753 QualType FirstParamType = FnDecl->getParamDecl(0)->getType();
4754 if (FirstParamType->isDependentType())
4755 return SemaRef.Diag(FnDecl->getLocation(),
4756 diag::err_operator_delete_dependent_param_type)
4757 << FnDecl->getDeclName() << SemaRef.Context.VoidPtrTy;
4758
4759 if (SemaRef.Context.getCanonicalType(FirstParamType) !=
4760 SemaRef.Context.VoidPtrTy)
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00004761 return SemaRef.Diag(FnDecl->getLocation(),
4762 diag::err_operator_delete_param_type)
4763 << FnDecl->getDeclName() << SemaRef.Context.VoidPtrTy;
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00004764
4765 return false;
4766}
4767
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004768/// CheckOverloadedOperatorDeclaration - Check whether the declaration
4769/// of this overloaded operator is well-formed. If so, returns false;
4770/// otherwise, emits appropriate diagnostics and returns true.
4771bool Sema::CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl) {
Douglas Gregor43c7bad2008-11-17 16:14:12 +00004772 assert(FnDecl && FnDecl->isOverloadedOperator() &&
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004773 "Expected an overloaded operator declaration");
4774
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004775 OverloadedOperatorKind Op = FnDecl->getOverloadedOperator();
4776
Mike Stump1eb44332009-09-09 15:08:12 +00004777 // C++ [over.oper]p5:
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004778 // The allocation and deallocation functions, operator new,
4779 // operator new[], operator delete and operator delete[], are
4780 // described completely in 3.7.3. The attributes and restrictions
4781 // found in the rest of this subclause do not apply to them unless
4782 // explicitly stated in 3.7.3.
Anders Carlsson1152c392009-12-11 23:31:21 +00004783 if (Op == OO_Delete || Op == OO_Array_Delete)
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00004784 return CheckOperatorDeleteDeclaration(*this, FnDecl);
Fariborz Jahanianb03bfa52009-11-10 23:47:18 +00004785
Anders Carlssona3ccda52009-12-12 00:26:23 +00004786 if (Op == OO_New || Op == OO_Array_New)
4787 return CheckOperatorNewDeclaration(*this, FnDecl);
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004788
4789 // C++ [over.oper]p6:
4790 // An operator function shall either be a non-static member
4791 // function or be a non-member function and have at least one
4792 // parameter whose type is a class, a reference to a class, an
4793 // enumeration, or a reference to an enumeration.
Douglas Gregor43c7bad2008-11-17 16:14:12 +00004794 if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) {
4795 if (MethodDecl->isStatic())
4796 return Diag(FnDecl->getLocation(),
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00004797 diag::err_operator_overload_static) << FnDecl->getDeclName();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004798 } else {
4799 bool ClassOrEnumParam = false;
Douglas Gregor43c7bad2008-11-17 16:14:12 +00004800 for (FunctionDecl::param_iterator Param = FnDecl->param_begin(),
4801 ParamEnd = FnDecl->param_end();
4802 Param != ParamEnd; ++Param) {
4803 QualType ParamType = (*Param)->getType().getNonReferenceType();
Eli Friedman5d39dee2009-06-27 05:59:59 +00004804 if (ParamType->isDependentType() || ParamType->isRecordType() ||
4805 ParamType->isEnumeralType()) {
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004806 ClassOrEnumParam = true;
4807 break;
4808 }
4809 }
4810
Douglas Gregor43c7bad2008-11-17 16:14:12 +00004811 if (!ClassOrEnumParam)
4812 return Diag(FnDecl->getLocation(),
Chris Lattnerf3a41af2008-11-20 06:38:18 +00004813 diag::err_operator_overload_needs_class_or_enum)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00004814 << FnDecl->getDeclName();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004815 }
4816
4817 // C++ [over.oper]p8:
4818 // An operator function cannot have default arguments (8.3.6),
4819 // except where explicitly stated below.
4820 //
Mike Stump1eb44332009-09-09 15:08:12 +00004821 // Only the function-call operator allows default arguments
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004822 // (C++ [over.call]p1).
4823 if (Op != OO_Call) {
4824 for (FunctionDecl::param_iterator Param = FnDecl->param_begin();
4825 Param != FnDecl->param_end(); ++Param) {
Anders Carlsson156c78e2009-12-13 17:53:43 +00004826 if ((*Param)->hasDefaultArg())
Mike Stump1eb44332009-09-09 15:08:12 +00004827 return Diag((*Param)->getLocation(),
Douglas Gregor61366e92008-12-24 00:01:03 +00004828 diag::err_operator_overload_default_arg)
Anders Carlsson156c78e2009-12-13 17:53:43 +00004829 << FnDecl->getDeclName() << (*Param)->getDefaultArgRange();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004830 }
4831 }
4832
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00004833 static const bool OperatorUses[NUM_OVERLOADED_OPERATORS][3] = {
4834 { false, false, false }
4835#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
4836 , { Unary, Binary, MemberOnly }
4837#include "clang/Basic/OperatorKinds.def"
4838 };
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004839
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00004840 bool CanBeUnaryOperator = OperatorUses[Op][0];
4841 bool CanBeBinaryOperator = OperatorUses[Op][1];
4842 bool MustBeMemberOperator = OperatorUses[Op][2];
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004843
4844 // C++ [over.oper]p8:
4845 // [...] Operator functions cannot have more or fewer parameters
4846 // than the number required for the corresponding operator, as
4847 // described in the rest of this subclause.
Mike Stump1eb44332009-09-09 15:08:12 +00004848 unsigned NumParams = FnDecl->getNumParams()
Douglas Gregor43c7bad2008-11-17 16:14:12 +00004849 + (isa<CXXMethodDecl>(FnDecl)? 1 : 0);
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004850 if (Op != OO_Call &&
4851 ((NumParams == 1 && !CanBeUnaryOperator) ||
4852 (NumParams == 2 && !CanBeBinaryOperator) ||
4853 (NumParams < 1) || (NumParams > 2))) {
4854 // We have the wrong number of parameters.
Chris Lattner416e46f2008-11-21 07:57:12 +00004855 unsigned ErrorKind;
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00004856 if (CanBeUnaryOperator && CanBeBinaryOperator) {
Chris Lattner416e46f2008-11-21 07:57:12 +00004857 ErrorKind = 2; // 2 -> unary or binary.
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00004858 } else if (CanBeUnaryOperator) {
Chris Lattner416e46f2008-11-21 07:57:12 +00004859 ErrorKind = 0; // 0 -> unary
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00004860 } else {
Chris Lattneraf7ae4e2008-11-21 07:50:02 +00004861 assert(CanBeBinaryOperator &&
4862 "All non-call overloaded operators are unary or binary!");
Chris Lattner416e46f2008-11-21 07:57:12 +00004863 ErrorKind = 1; // 1 -> binary
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00004864 }
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004865
Chris Lattner416e46f2008-11-21 07:57:12 +00004866 return Diag(FnDecl->getLocation(), diag::err_operator_overload_must_be)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00004867 << FnDecl->getDeclName() << NumParams << ErrorKind;
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004868 }
Sebastian Redl64b45f72009-01-05 20:52:13 +00004869
Douglas Gregor43c7bad2008-11-17 16:14:12 +00004870 // Overloaded operators other than operator() cannot be variadic.
4871 if (Op != OO_Call &&
John McCall183700f2009-09-21 23:43:11 +00004872 FnDecl->getType()->getAs<FunctionProtoType>()->isVariadic()) {
Chris Lattnerf3a41af2008-11-20 06:38:18 +00004873 return Diag(FnDecl->getLocation(), diag::err_operator_overload_variadic)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00004874 << FnDecl->getDeclName();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004875 }
4876
4877 // Some operators must be non-static member functions.
Douglas Gregor43c7bad2008-11-17 16:14:12 +00004878 if (MustBeMemberOperator && !isa<CXXMethodDecl>(FnDecl)) {
4879 return Diag(FnDecl->getLocation(),
Chris Lattnerf3a41af2008-11-20 06:38:18 +00004880 diag::err_operator_overload_must_be_member)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00004881 << FnDecl->getDeclName();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004882 }
4883
4884 // C++ [over.inc]p1:
4885 // The user-defined function called operator++ implements the
4886 // prefix and postfix ++ operator. If this function is a member
4887 // function with no parameters, or a non-member function with one
4888 // parameter of class or enumeration type, it defines the prefix
4889 // increment operator ++ for objects of that type. If the function
4890 // is a member function with one parameter (which shall be of type
4891 // int) or a non-member function with two parameters (the second
4892 // of which shall be of type int), it defines the postfix
4893 // increment operator ++ for objects of that type.
4894 if ((Op == OO_PlusPlus || Op == OO_MinusMinus) && NumParams == 2) {
4895 ParmVarDecl *LastParam = FnDecl->getParamDecl(FnDecl->getNumParams() - 1);
4896 bool ParamIsInt = false;
John McCall183700f2009-09-21 23:43:11 +00004897 if (const BuiltinType *BT = LastParam->getType()->getAs<BuiltinType>())
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004898 ParamIsInt = BT->getKind() == BuiltinType::Int;
4899
Chris Lattneraf7ae4e2008-11-21 07:50:02 +00004900 if (!ParamIsInt)
4901 return Diag(LastParam->getLocation(),
Mike Stump1eb44332009-09-09 15:08:12 +00004902 diag::err_operator_overload_post_incdec_must_be_int)
Chris Lattnerd1625842008-11-24 06:25:27 +00004903 << LastParam->getType() << (Op == OO_MinusMinus);
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004904 }
4905
Sebastian Redl64b45f72009-01-05 20:52:13 +00004906 // Notify the class if it got an assignment operator.
4907 if (Op == OO_Equal) {
4908 // Would have returned earlier otherwise.
4909 assert(isa<CXXMethodDecl>(FnDecl) &&
4910 "Overloaded = not member, but not filtered.");
4911 CXXMethodDecl *Method = cast<CXXMethodDecl>(FnDecl);
4912 Method->getParent()->addedAssignmentOperator(Context, Method);
4913 }
4914
Douglas Gregor43c7bad2008-11-17 16:14:12 +00004915 return false;
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004916}
Chris Lattner5a003a42008-12-17 07:09:26 +00004917
Douglas Gregor074149e2009-01-05 19:45:36 +00004918/// ActOnStartLinkageSpecification - Parsed the beginning of a C++
4919/// linkage specification, including the language and (if present)
4920/// the '{'. ExternLoc is the location of the 'extern', LangLoc is
4921/// the location of the language string literal, which is provided
4922/// by Lang/StrSize. LBraceLoc, if valid, provides the location of
4923/// the '{' brace. Otherwise, this linkage specification does not
4924/// have any braces.
Chris Lattnerb28317a2009-03-28 19:18:32 +00004925Sema::DeclPtrTy Sema::ActOnStartLinkageSpecification(Scope *S,
4926 SourceLocation ExternLoc,
4927 SourceLocation LangLoc,
4928 const char *Lang,
4929 unsigned StrSize,
4930 SourceLocation LBraceLoc) {
Chris Lattnercc98eac2008-12-17 07:13:27 +00004931 LinkageSpecDecl::LanguageIDs Language;
4932 if (strncmp(Lang, "\"C\"", StrSize) == 0)
4933 Language = LinkageSpecDecl::lang_c;
4934 else if (strncmp(Lang, "\"C++\"", StrSize) == 0)
4935 Language = LinkageSpecDecl::lang_cxx;
4936 else {
Douglas Gregor074149e2009-01-05 19:45:36 +00004937 Diag(LangLoc, diag::err_bad_language);
Chris Lattnerb28317a2009-03-28 19:18:32 +00004938 return DeclPtrTy();
Chris Lattnercc98eac2008-12-17 07:13:27 +00004939 }
Mike Stump1eb44332009-09-09 15:08:12 +00004940
Chris Lattnercc98eac2008-12-17 07:13:27 +00004941 // FIXME: Add all the various semantics of linkage specifications
Mike Stump1eb44332009-09-09 15:08:12 +00004942
Douglas Gregor074149e2009-01-05 19:45:36 +00004943 LinkageSpecDecl *D = LinkageSpecDecl::Create(Context, CurContext,
Mike Stump1eb44332009-09-09 15:08:12 +00004944 LangLoc, Language,
Douglas Gregor074149e2009-01-05 19:45:36 +00004945 LBraceLoc.isValid());
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00004946 CurContext->addDecl(D);
Douglas Gregor074149e2009-01-05 19:45:36 +00004947 PushDeclContext(S, D);
Chris Lattnerb28317a2009-03-28 19:18:32 +00004948 return DeclPtrTy::make(D);
Chris Lattnercc98eac2008-12-17 07:13:27 +00004949}
4950
Douglas Gregor074149e2009-01-05 19:45:36 +00004951/// ActOnFinishLinkageSpecification - Completely the definition of
4952/// the C++ linkage specification LinkageSpec. If RBraceLoc is
4953/// valid, it's the position of the closing '}' brace in a linkage
4954/// specification that uses braces.
Chris Lattnerb28317a2009-03-28 19:18:32 +00004955Sema::DeclPtrTy Sema::ActOnFinishLinkageSpecification(Scope *S,
4956 DeclPtrTy LinkageSpec,
4957 SourceLocation RBraceLoc) {
Douglas Gregor074149e2009-01-05 19:45:36 +00004958 if (LinkageSpec)
4959 PopDeclContext();
4960 return LinkageSpec;
Chris Lattner5a003a42008-12-17 07:09:26 +00004961}
4962
Douglas Gregord308e622009-05-18 20:51:54 +00004963/// \brief Perform semantic analysis for the variable declaration that
4964/// occurs within a C++ catch clause, returning the newly-created
4965/// variable.
4966VarDecl *Sema::BuildExceptionDeclaration(Scope *S, QualType ExDeclType,
John McCalla93c9342009-12-07 02:54:59 +00004967 TypeSourceInfo *TInfo,
Douglas Gregord308e622009-05-18 20:51:54 +00004968 IdentifierInfo *Name,
4969 SourceLocation Loc,
4970 SourceRange Range) {
4971 bool Invalid = false;
Sebastian Redl4b07b292008-12-22 19:15:10 +00004972
4973 // Arrays and functions decay.
4974 if (ExDeclType->isArrayType())
4975 ExDeclType = Context.getArrayDecayedType(ExDeclType);
4976 else if (ExDeclType->isFunctionType())
4977 ExDeclType = Context.getPointerType(ExDeclType);
4978
4979 // C++ 15.3p1: The exception-declaration shall not denote an incomplete type.
4980 // The exception-declaration shall not denote a pointer or reference to an
4981 // incomplete type, other than [cv] void*.
Sebastian Redlf2e21e52009-03-22 23:49:27 +00004982 // N2844 forbids rvalue references.
Mike Stump1eb44332009-09-09 15:08:12 +00004983 if (!ExDeclType->isDependentType() && ExDeclType->isRValueReferenceType()) {
Douglas Gregord308e622009-05-18 20:51:54 +00004984 Diag(Loc, diag::err_catch_rvalue_ref) << Range;
Sebastian Redlf2e21e52009-03-22 23:49:27 +00004985 Invalid = true;
4986 }
Douglas Gregord308e622009-05-18 20:51:54 +00004987
Sebastian Redl4b07b292008-12-22 19:15:10 +00004988 QualType BaseType = ExDeclType;
4989 int Mode = 0; // 0 for direct type, 1 for pointer, 2 for reference
Douglas Gregor4ec339f2009-01-19 19:26:10 +00004990 unsigned DK = diag::err_catch_incomplete;
Ted Kremenek6217b802009-07-29 21:53:49 +00004991 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) {
Sebastian Redl4b07b292008-12-22 19:15:10 +00004992 BaseType = Ptr->getPointeeType();
4993 Mode = 1;
Douglas Gregor4ec339f2009-01-19 19:26:10 +00004994 DK = diag::err_catch_incomplete_ptr;
Mike Stump1eb44332009-09-09 15:08:12 +00004995 } else if (const ReferenceType *Ref = BaseType->getAs<ReferenceType>()) {
Sebastian Redlf2e21e52009-03-22 23:49:27 +00004996 // For the purpose of error recovery, we treat rvalue refs like lvalue refs.
Sebastian Redl4b07b292008-12-22 19:15:10 +00004997 BaseType = Ref->getPointeeType();
4998 Mode = 2;
Douglas Gregor4ec339f2009-01-19 19:26:10 +00004999 DK = diag::err_catch_incomplete_ref;
Sebastian Redl4b07b292008-12-22 19:15:10 +00005000 }
Sebastian Redlf2e21e52009-03-22 23:49:27 +00005001 if (!Invalid && (Mode == 0 || !BaseType->isVoidType()) &&
Douglas Gregord308e622009-05-18 20:51:54 +00005002 !BaseType->isDependentType() && RequireCompleteType(Loc, BaseType, DK))
Sebastian Redl4b07b292008-12-22 19:15:10 +00005003 Invalid = true;
Sebastian Redl4b07b292008-12-22 19:15:10 +00005004
Mike Stump1eb44332009-09-09 15:08:12 +00005005 if (!Invalid && !ExDeclType->isDependentType() &&
Douglas Gregord308e622009-05-18 20:51:54 +00005006 RequireNonAbstractType(Loc, ExDeclType,
5007 diag::err_abstract_type_in_decl,
5008 AbstractVariableType))
Sebastian Redlfef9f592009-04-27 21:03:30 +00005009 Invalid = true;
5010
Douglas Gregord308e622009-05-18 20:51:54 +00005011 // FIXME: Need to test for ability to copy-construct and destroy the
5012 // exception variable.
5013
Sebastian Redl8351da02008-12-22 21:35:02 +00005014 // FIXME: Need to check for abstract classes.
5015
Mike Stump1eb44332009-09-09 15:08:12 +00005016 VarDecl *ExDecl = VarDecl::Create(Context, CurContext, Loc,
John McCalla93c9342009-12-07 02:54:59 +00005017 Name, ExDeclType, TInfo, VarDecl::None);
Douglas Gregord308e622009-05-18 20:51:54 +00005018
5019 if (Invalid)
5020 ExDecl->setInvalidDecl();
5021
5022 return ExDecl;
5023}
5024
5025/// ActOnExceptionDeclarator - Parsed the exception-declarator in a C++ catch
5026/// handler.
5027Sema::DeclPtrTy Sema::ActOnExceptionDeclarator(Scope *S, Declarator &D) {
John McCalla93c9342009-12-07 02:54:59 +00005028 TypeSourceInfo *TInfo = 0;
5029 QualType ExDeclType = GetTypeForDeclarator(D, S, &TInfo);
Douglas Gregord308e622009-05-18 20:51:54 +00005030
5031 bool Invalid = D.isInvalidType();
Sebastian Redl4b07b292008-12-22 19:15:10 +00005032 IdentifierInfo *II = D.getIdentifier();
John McCallf36e02d2009-10-09 21:13:30 +00005033 if (NamedDecl *PrevDecl = LookupSingleName(S, II, LookupOrdinaryName)) {
Sebastian Redl4b07b292008-12-22 19:15:10 +00005034 // The scope should be freshly made just for us. There is just no way
5035 // it contains any previous declaration.
Chris Lattnerb28317a2009-03-28 19:18:32 +00005036 assert(!S->isDeclScope(DeclPtrTy::make(PrevDecl)));
Sebastian Redl4b07b292008-12-22 19:15:10 +00005037 if (PrevDecl->isTemplateParameter()) {
5038 // Maybe we will complain about the shadowed template parameter.
5039 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
Sebastian Redl4b07b292008-12-22 19:15:10 +00005040 }
5041 }
5042
Chris Lattnereaaebc72009-04-25 08:06:05 +00005043 if (D.getCXXScopeSpec().isSet() && !Invalid) {
Sebastian Redl4b07b292008-12-22 19:15:10 +00005044 Diag(D.getIdentifierLoc(), diag::err_qualified_catch_declarator)
5045 << D.getCXXScopeSpec().getRange();
Chris Lattnereaaebc72009-04-25 08:06:05 +00005046 Invalid = true;
Sebastian Redl4b07b292008-12-22 19:15:10 +00005047 }
5048
John McCalla93c9342009-12-07 02:54:59 +00005049 VarDecl *ExDecl = BuildExceptionDeclaration(S, ExDeclType, TInfo,
Douglas Gregord308e622009-05-18 20:51:54 +00005050 D.getIdentifier(),
5051 D.getIdentifierLoc(),
5052 D.getDeclSpec().getSourceRange());
5053
Chris Lattnereaaebc72009-04-25 08:06:05 +00005054 if (Invalid)
5055 ExDecl->setInvalidDecl();
Mike Stump1eb44332009-09-09 15:08:12 +00005056
Sebastian Redl4b07b292008-12-22 19:15:10 +00005057 // Add the exception declaration into this scope.
Sebastian Redl4b07b292008-12-22 19:15:10 +00005058 if (II)
Douglas Gregord308e622009-05-18 20:51:54 +00005059 PushOnScopeChains(ExDecl, S);
5060 else
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00005061 CurContext->addDecl(ExDecl);
Sebastian Redl4b07b292008-12-22 19:15:10 +00005062
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00005063 ProcessDeclAttributes(S, ExDecl, D);
Chris Lattnerb28317a2009-03-28 19:18:32 +00005064 return DeclPtrTy::make(ExDecl);
Sebastian Redl4b07b292008-12-22 19:15:10 +00005065}
Anders Carlssonfb311762009-03-14 00:25:26 +00005066
Mike Stump1eb44332009-09-09 15:08:12 +00005067Sema::DeclPtrTy Sema::ActOnStaticAssertDeclaration(SourceLocation AssertLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00005068 ExprArg assertexpr,
5069 ExprArg assertmessageexpr) {
Anders Carlssonfb311762009-03-14 00:25:26 +00005070 Expr *AssertExpr = (Expr *)assertexpr.get();
Mike Stump1eb44332009-09-09 15:08:12 +00005071 StringLiteral *AssertMessage =
Anders Carlssonfb311762009-03-14 00:25:26 +00005072 cast<StringLiteral>((Expr *)assertmessageexpr.get());
5073
Anders Carlssonc3082412009-03-14 00:33:21 +00005074 if (!AssertExpr->isTypeDependent() && !AssertExpr->isValueDependent()) {
5075 llvm::APSInt Value(32);
5076 if (!AssertExpr->isIntegerConstantExpr(Value, Context)) {
5077 Diag(AssertLoc, diag::err_static_assert_expression_is_not_constant) <<
5078 AssertExpr->getSourceRange();
Chris Lattnerb28317a2009-03-28 19:18:32 +00005079 return DeclPtrTy();
Anders Carlssonc3082412009-03-14 00:33:21 +00005080 }
Anders Carlssonfb311762009-03-14 00:25:26 +00005081
Anders Carlssonc3082412009-03-14 00:33:21 +00005082 if (Value == 0) {
Mike Stump1eb44332009-09-09 15:08:12 +00005083 Diag(AssertLoc, diag::err_static_assert_failed)
Benjamin Kramer8d042582009-12-11 13:33:18 +00005084 << AssertMessage->getString() << AssertExpr->getSourceRange();
Anders Carlssonc3082412009-03-14 00:33:21 +00005085 }
5086 }
Mike Stump1eb44332009-09-09 15:08:12 +00005087
Anders Carlsson77d81422009-03-15 17:35:16 +00005088 assertexpr.release();
5089 assertmessageexpr.release();
Mike Stump1eb44332009-09-09 15:08:12 +00005090 Decl *Decl = StaticAssertDecl::Create(Context, CurContext, AssertLoc,
Anders Carlssonfb311762009-03-14 00:25:26 +00005091 AssertExpr, AssertMessage);
Mike Stump1eb44332009-09-09 15:08:12 +00005092
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00005093 CurContext->addDecl(Decl);
Chris Lattnerb28317a2009-03-28 19:18:32 +00005094 return DeclPtrTy::make(Decl);
Anders Carlssonfb311762009-03-14 00:25:26 +00005095}
Sebastian Redl50de12f2009-03-24 22:27:57 +00005096
John McCalldd4a3b02009-09-16 22:47:08 +00005097/// Handle a friend type declaration. This works in tandem with
5098/// ActOnTag.
5099///
5100/// Notes on friend class templates:
5101///
5102/// We generally treat friend class declarations as if they were
5103/// declaring a class. So, for example, the elaborated type specifier
5104/// in a friend declaration is required to obey the restrictions of a
5105/// class-head (i.e. no typedefs in the scope chain), template
5106/// parameters are required to match up with simple template-ids, &c.
5107/// However, unlike when declaring a template specialization, it's
5108/// okay to refer to a template specialization without an empty
5109/// template parameter declaration, e.g.
5110/// friend class A<T>::B<unsigned>;
5111/// We permit this as a special case; if there are any template
5112/// parameters present at all, require proper matching, i.e.
5113/// template <> template <class T> friend class A<int>::B;
Chris Lattnerc7f19042009-10-25 17:47:27 +00005114Sema::DeclPtrTy Sema::ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS,
John McCalldd4a3b02009-09-16 22:47:08 +00005115 MultiTemplateParamsArg TempParams) {
John McCall02cace72009-08-28 07:59:38 +00005116 SourceLocation Loc = DS.getSourceRange().getBegin();
John McCall67d1a672009-08-06 02:15:43 +00005117
5118 assert(DS.isFriendSpecified());
5119 assert(DS.getStorageClassSpec() == DeclSpec::SCS_unspecified);
5120
John McCalldd4a3b02009-09-16 22:47:08 +00005121 // Try to convert the decl specifier to a type. This works for
5122 // friend templates because ActOnTag never produces a ClassTemplateDecl
5123 // for a TUK_Friend.
Chris Lattnerc7f19042009-10-25 17:47:27 +00005124 Declarator TheDeclarator(DS, Declarator::MemberContext);
Chris Lattnerc7f19042009-10-25 17:47:27 +00005125 QualType T = GetTypeForDeclarator(TheDeclarator, S);
5126 if (TheDeclarator.isInvalidType())
5127 return DeclPtrTy();
John McCall67d1a672009-08-06 02:15:43 +00005128
John McCalldd4a3b02009-09-16 22:47:08 +00005129 // This is definitely an error in C++98. It's probably meant to
5130 // be forbidden in C++0x, too, but the specification is just
5131 // poorly written.
5132 //
5133 // The problem is with declarations like the following:
5134 // template <T> friend A<T>::foo;
5135 // where deciding whether a class C is a friend or not now hinges
5136 // on whether there exists an instantiation of A that causes
5137 // 'foo' to equal C. There are restrictions on class-heads
5138 // (which we declare (by fiat) elaborated friend declarations to
5139 // be) that makes this tractable.
5140 //
5141 // FIXME: handle "template <> friend class A<T>;", which
5142 // is possibly well-formed? Who even knows?
5143 if (TempParams.size() && !isa<ElaboratedType>(T)) {
5144 Diag(Loc, diag::err_tagless_friend_type_template)
5145 << DS.getSourceRange();
5146 return DeclPtrTy();
5147 }
5148
John McCall02cace72009-08-28 07:59:38 +00005149 // C++ [class.friend]p2:
5150 // An elaborated-type-specifier shall be used in a friend declaration
5151 // for a class.*
5152 // * The class-key of the elaborated-type-specifier is required.
John McCall6b2becf2009-09-08 17:47:29 +00005153 // This is one of the rare places in Clang where it's legitimate to
5154 // ask about the "spelling" of the type.
5155 if (!getLangOptions().CPlusPlus0x && !isa<ElaboratedType>(T)) {
5156 // If we evaluated the type to a record type, suggest putting
5157 // a tag in front.
John McCall02cace72009-08-28 07:59:38 +00005158 if (const RecordType *RT = T->getAs<RecordType>()) {
John McCall6b2becf2009-09-08 17:47:29 +00005159 RecordDecl *RD = RT->getDecl();
5160
5161 std::string InsertionText = std::string(" ") + RD->getKindName();
5162
John McCalle3af0232009-10-07 23:34:25 +00005163 Diag(DS.getTypeSpecTypeLoc(), diag::err_unelaborated_friend_type)
5164 << (unsigned) RD->getTagKind()
5165 << T
5166 << SourceRange(DS.getFriendSpecLoc())
John McCall6b2becf2009-09-08 17:47:29 +00005167 << CodeModificationHint::CreateInsertion(DS.getTypeSpecTypeLoc(),
5168 InsertionText);
John McCall02cace72009-08-28 07:59:38 +00005169 return DeclPtrTy();
5170 }else {
John McCall6b2becf2009-09-08 17:47:29 +00005171 Diag(DS.getFriendSpecLoc(), diag::err_unexpected_friend)
5172 << DS.getSourceRange();
Mike Stump1eb44332009-09-09 15:08:12 +00005173 return DeclPtrTy();
John McCall02cace72009-08-28 07:59:38 +00005174 }
5175 }
5176
John McCalle3af0232009-10-07 23:34:25 +00005177 // Enum types cannot be friends.
5178 if (T->getAs<EnumType>()) {
5179 Diag(DS.getTypeSpecTypeLoc(), diag::err_enum_friend)
5180 << SourceRange(DS.getFriendSpecLoc());
5181 return DeclPtrTy();
John McCall6b2becf2009-09-08 17:47:29 +00005182 }
John McCall02cace72009-08-28 07:59:38 +00005183
John McCall02cace72009-08-28 07:59:38 +00005184 // C++98 [class.friend]p1: A friend of a class is a function
5185 // or class that is not a member of the class . . .
5186 // But that's a silly restriction which nobody implements for
5187 // inner classes, and C++0x removes it anyway, so we only report
5188 // this (as a warning) if we're being pedantic.
John McCall6b2becf2009-09-08 17:47:29 +00005189 if (!getLangOptions().CPlusPlus0x)
5190 if (const RecordType *RT = T->getAs<RecordType>())
5191 if (RT->getDecl()->getDeclContext() == CurContext)
5192 Diag(DS.getFriendSpecLoc(), diag::ext_friend_inner_class);
John McCall02cace72009-08-28 07:59:38 +00005193
John McCalldd4a3b02009-09-16 22:47:08 +00005194 Decl *D;
5195 if (TempParams.size())
5196 D = FriendTemplateDecl::Create(Context, CurContext, Loc,
5197 TempParams.size(),
5198 (TemplateParameterList**) TempParams.release(),
5199 T.getTypePtr(),
5200 DS.getFriendSpecLoc());
5201 else
5202 D = FriendDecl::Create(Context, CurContext, Loc, T.getTypePtr(),
5203 DS.getFriendSpecLoc());
5204 D->setAccess(AS_public);
5205 CurContext->addDecl(D);
John McCall02cace72009-08-28 07:59:38 +00005206
John McCalldd4a3b02009-09-16 22:47:08 +00005207 return DeclPtrTy::make(D);
John McCall02cace72009-08-28 07:59:38 +00005208}
5209
John McCallbbbcdd92009-09-11 21:02:39 +00005210Sema::DeclPtrTy
5211Sema::ActOnFriendFunctionDecl(Scope *S,
5212 Declarator &D,
5213 bool IsDefinition,
5214 MultiTemplateParamsArg TemplateParams) {
John McCall02cace72009-08-28 07:59:38 +00005215 const DeclSpec &DS = D.getDeclSpec();
5216
5217 assert(DS.isFriendSpecified());
5218 assert(DS.getStorageClassSpec() == DeclSpec::SCS_unspecified);
5219
5220 SourceLocation Loc = D.getIdentifierLoc();
John McCalla93c9342009-12-07 02:54:59 +00005221 TypeSourceInfo *TInfo = 0;
5222 QualType T = GetTypeForDeclarator(D, S, &TInfo);
John McCall67d1a672009-08-06 02:15:43 +00005223
5224 // C++ [class.friend]p1
5225 // A friend of a class is a function or class....
5226 // Note that this sees through typedefs, which is intended.
John McCall02cace72009-08-28 07:59:38 +00005227 // It *doesn't* see through dependent types, which is correct
5228 // according to [temp.arg.type]p3:
5229 // If a declaration acquires a function type through a
5230 // type dependent on a template-parameter and this causes
5231 // a declaration that does not use the syntactic form of a
5232 // function declarator to have a function type, the program
5233 // is ill-formed.
John McCall67d1a672009-08-06 02:15:43 +00005234 if (!T->isFunctionType()) {
5235 Diag(Loc, diag::err_unexpected_friend);
5236
5237 // It might be worthwhile to try to recover by creating an
5238 // appropriate declaration.
5239 return DeclPtrTy();
5240 }
5241
5242 // C++ [namespace.memdef]p3
5243 // - If a friend declaration in a non-local class first declares a
5244 // class or function, the friend class or function is a member
5245 // of the innermost enclosing namespace.
5246 // - The name of the friend is not found by simple name lookup
5247 // until a matching declaration is provided in that namespace
5248 // scope (either before or after the class declaration granting
5249 // friendship).
5250 // - If a friend function is called, its name may be found by the
5251 // name lookup that considers functions from namespaces and
5252 // classes associated with the types of the function arguments.
5253 // - When looking for a prior declaration of a class or a function
5254 // declared as a friend, scopes outside the innermost enclosing
5255 // namespace scope are not considered.
5256
John McCall02cace72009-08-28 07:59:38 +00005257 CXXScopeSpec &ScopeQual = D.getCXXScopeSpec();
5258 DeclarationName Name = GetNameForDeclarator(D);
John McCall67d1a672009-08-06 02:15:43 +00005259 assert(Name);
5260
John McCall67d1a672009-08-06 02:15:43 +00005261 // The context we found the declaration in, or in which we should
5262 // create the declaration.
5263 DeclContext *DC;
5264
5265 // FIXME: handle local classes
5266
5267 // Recover from invalid scope qualifiers as if they just weren't there.
John McCall68263142009-11-18 22:49:29 +00005268 LookupResult Previous(*this, Name, D.getIdentifierLoc(), LookupOrdinaryName,
5269 ForRedeclaration);
John McCall67d1a672009-08-06 02:15:43 +00005270 if (!ScopeQual.isInvalid() && ScopeQual.isSet()) {
Douglas Gregora735b202009-10-13 14:39:41 +00005271 // FIXME: RequireCompleteDeclContext
John McCall67d1a672009-08-06 02:15:43 +00005272 DC = computeDeclContext(ScopeQual);
5273
5274 // FIXME: handle dependent contexts
5275 if (!DC) return DeclPtrTy();
5276
John McCall68263142009-11-18 22:49:29 +00005277 LookupQualifiedName(Previous, DC);
John McCall67d1a672009-08-06 02:15:43 +00005278
5279 // If searching in that context implicitly found a declaration in
5280 // a different context, treat it like it wasn't found at all.
5281 // TODO: better diagnostics for this case. Suggesting the right
5282 // qualified scope would be nice...
John McCall68263142009-11-18 22:49:29 +00005283 // FIXME: getRepresentativeDecl() is not right here at all
5284 if (Previous.empty() ||
5285 !Previous.getRepresentativeDecl()->getDeclContext()->Equals(DC)) {
John McCall02cace72009-08-28 07:59:38 +00005286 D.setInvalidType();
John McCall67d1a672009-08-06 02:15:43 +00005287 Diag(Loc, diag::err_qualified_friend_not_found) << Name << T;
5288 return DeclPtrTy();
5289 }
5290
5291 // C++ [class.friend]p1: A friend of a class is a function or
5292 // class that is not a member of the class . . .
Douglas Gregor182ddf02009-09-28 00:08:27 +00005293 if (DC->Equals(CurContext))
John McCall67d1a672009-08-06 02:15:43 +00005294 Diag(DS.getFriendSpecLoc(), diag::err_friend_is_member);
5295
John McCall67d1a672009-08-06 02:15:43 +00005296 // Otherwise walk out to the nearest namespace scope looking for matches.
5297 } else {
5298 // TODO: handle local class contexts.
5299
5300 DC = CurContext;
5301 while (true) {
5302 // Skip class contexts. If someone can cite chapter and verse
5303 // for this behavior, that would be nice --- it's what GCC and
5304 // EDG do, and it seems like a reasonable intent, but the spec
5305 // really only says that checks for unqualified existing
5306 // declarations should stop at the nearest enclosing namespace,
5307 // not that they should only consider the nearest enclosing
5308 // namespace.
Douglas Gregor182ddf02009-09-28 00:08:27 +00005309 while (DC->isRecord())
5310 DC = DC->getParent();
John McCall67d1a672009-08-06 02:15:43 +00005311
John McCall68263142009-11-18 22:49:29 +00005312 LookupQualifiedName(Previous, DC);
John McCall67d1a672009-08-06 02:15:43 +00005313
5314 // TODO: decide what we think about using declarations.
John McCall68263142009-11-18 22:49:29 +00005315 if (!Previous.empty())
John McCall67d1a672009-08-06 02:15:43 +00005316 break;
Douglas Gregor182ddf02009-09-28 00:08:27 +00005317
John McCall67d1a672009-08-06 02:15:43 +00005318 if (DC->isFileContext()) break;
5319 DC = DC->getParent();
5320 }
5321
5322 // C++ [class.friend]p1: A friend of a class is a function or
5323 // class that is not a member of the class . . .
John McCall7f27d922009-08-06 20:49:32 +00005324 // C++0x changes this for both friend types and functions.
5325 // Most C++ 98 compilers do seem to give an error here, so
5326 // we do, too.
John McCall68263142009-11-18 22:49:29 +00005327 if (!Previous.empty() && DC->Equals(CurContext)
5328 && !getLangOptions().CPlusPlus0x)
John McCall67d1a672009-08-06 02:15:43 +00005329 Diag(DS.getFriendSpecLoc(), diag::err_friend_is_member);
5330 }
5331
Douglas Gregor182ddf02009-09-28 00:08:27 +00005332 if (DC->isFileContext()) {
John McCall67d1a672009-08-06 02:15:43 +00005333 // This implies that it has to be an operator or function.
Douglas Gregor3f9a0562009-11-03 01:35:08 +00005334 if (D.getName().getKind() == UnqualifiedId::IK_ConstructorName ||
5335 D.getName().getKind() == UnqualifiedId::IK_DestructorName ||
5336 D.getName().getKind() == UnqualifiedId::IK_ConversionFunctionId) {
John McCall67d1a672009-08-06 02:15:43 +00005337 Diag(Loc, diag::err_introducing_special_friend) <<
Douglas Gregor3f9a0562009-11-03 01:35:08 +00005338 (D.getName().getKind() == UnqualifiedId::IK_ConstructorName ? 0 :
5339 D.getName().getKind() == UnqualifiedId::IK_DestructorName ? 1 : 2);
John McCall67d1a672009-08-06 02:15:43 +00005340 return DeclPtrTy();
5341 }
John McCall67d1a672009-08-06 02:15:43 +00005342 }
5343
Douglas Gregor182ddf02009-09-28 00:08:27 +00005344 bool Redeclaration = false;
John McCalla93c9342009-12-07 02:54:59 +00005345 NamedDecl *ND = ActOnFunctionDeclarator(S, D, DC, T, TInfo, Previous,
Douglas Gregora735b202009-10-13 14:39:41 +00005346 move(TemplateParams),
John McCall3f9a8a62009-08-11 06:59:38 +00005347 IsDefinition,
5348 Redeclaration);
John McCall02cace72009-08-28 07:59:38 +00005349 if (!ND) return DeclPtrTy();
John McCallab88d972009-08-31 22:39:49 +00005350
Douglas Gregor182ddf02009-09-28 00:08:27 +00005351 assert(ND->getDeclContext() == DC);
5352 assert(ND->getLexicalDeclContext() == CurContext);
John McCall88232aa2009-08-18 00:00:49 +00005353
John McCallab88d972009-08-31 22:39:49 +00005354 // Add the function declaration to the appropriate lookup tables,
5355 // adjusting the redeclarations list as necessary. We don't
5356 // want to do this yet if the friending class is dependent.
Mike Stump1eb44332009-09-09 15:08:12 +00005357 //
John McCallab88d972009-08-31 22:39:49 +00005358 // Also update the scope-based lookup if the target context's
5359 // lookup context is in lexical scope.
5360 if (!CurContext->isDependentContext()) {
5361 DC = DC->getLookupContext();
Douglas Gregor182ddf02009-09-28 00:08:27 +00005362 DC->makeDeclVisibleInContext(ND, /* Recoverable=*/ false);
John McCallab88d972009-08-31 22:39:49 +00005363 if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
Douglas Gregor182ddf02009-09-28 00:08:27 +00005364 PushOnScopeChains(ND, EnclosingScope, /*AddToContext=*/ false);
John McCallab88d972009-08-31 22:39:49 +00005365 }
John McCall02cace72009-08-28 07:59:38 +00005366
5367 FriendDecl *FrD = FriendDecl::Create(Context, CurContext,
Douglas Gregor182ddf02009-09-28 00:08:27 +00005368 D.getIdentifierLoc(), ND,
John McCall02cace72009-08-28 07:59:38 +00005369 DS.getFriendSpecLoc());
John McCall5fee1102009-08-29 03:50:18 +00005370 FrD->setAccess(AS_public);
John McCall02cace72009-08-28 07:59:38 +00005371 CurContext->addDecl(FrD);
John McCall67d1a672009-08-06 02:15:43 +00005372
Douglas Gregor182ddf02009-09-28 00:08:27 +00005373 return DeclPtrTy::make(ND);
Anders Carlsson00338362009-05-11 22:55:49 +00005374}
5375
Chris Lattnerb28317a2009-03-28 19:18:32 +00005376void Sema::SetDeclDeleted(DeclPtrTy dcl, SourceLocation DelLoc) {
Douglas Gregorefd5bda2009-08-24 11:57:43 +00005377 AdjustDeclIfTemplate(dcl);
Mike Stump1eb44332009-09-09 15:08:12 +00005378
Chris Lattnerb28317a2009-03-28 19:18:32 +00005379 Decl *Dcl = dcl.getAs<Decl>();
Sebastian Redl50de12f2009-03-24 22:27:57 +00005380 FunctionDecl *Fn = dyn_cast<FunctionDecl>(Dcl);
5381 if (!Fn) {
5382 Diag(DelLoc, diag::err_deleted_non_function);
5383 return;
5384 }
5385 if (const FunctionDecl *Prev = Fn->getPreviousDeclaration()) {
5386 Diag(DelLoc, diag::err_deleted_decl_not_first);
5387 Diag(Prev->getLocation(), diag::note_previous_declaration);
5388 // If the declaration wasn't the first, we delete the function anyway for
5389 // recovery.
5390 }
5391 Fn->setDeleted();
5392}
Sebastian Redl13e88542009-04-27 21:33:24 +00005393
5394static void SearchForReturnInStmt(Sema &Self, Stmt *S) {
5395 for (Stmt::child_iterator CI = S->child_begin(), E = S->child_end(); CI != E;
5396 ++CI) {
5397 Stmt *SubStmt = *CI;
5398 if (!SubStmt)
5399 continue;
5400 if (isa<ReturnStmt>(SubStmt))
5401 Self.Diag(SubStmt->getSourceRange().getBegin(),
5402 diag::err_return_in_constructor_handler);
5403 if (!isa<Expr>(SubStmt))
5404 SearchForReturnInStmt(Self, SubStmt);
5405 }
5406}
5407
5408void Sema::DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock) {
5409 for (unsigned I = 0, E = TryBlock->getNumHandlers(); I != E; ++I) {
5410 CXXCatchStmt *Handler = TryBlock->getHandler(I);
5411 SearchForReturnInStmt(*this, Handler);
5412 }
5413}
Anders Carlssond7ba27d2009-05-14 01:09:04 +00005414
Mike Stump1eb44332009-09-09 15:08:12 +00005415bool Sema::CheckOverridingFunctionReturnType(const CXXMethodDecl *New,
Anders Carlssond7ba27d2009-05-14 01:09:04 +00005416 const CXXMethodDecl *Old) {
John McCall183700f2009-09-21 23:43:11 +00005417 QualType NewTy = New->getType()->getAs<FunctionType>()->getResultType();
5418 QualType OldTy = Old->getType()->getAs<FunctionType>()->getResultType();
Anders Carlssond7ba27d2009-05-14 01:09:04 +00005419
5420 QualType CNewTy = Context.getCanonicalType(NewTy);
5421 QualType COldTy = Context.getCanonicalType(OldTy);
5422
Mike Stump1eb44332009-09-09 15:08:12 +00005423 if (CNewTy == COldTy &&
Douglas Gregora4923eb2009-11-16 21:35:15 +00005424 CNewTy.getLocalCVRQualifiers() == COldTy.getLocalCVRQualifiers())
Anders Carlssond7ba27d2009-05-14 01:09:04 +00005425 return false;
Mike Stump1eb44332009-09-09 15:08:12 +00005426
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005427 // Check if the return types are covariant
5428 QualType NewClassTy, OldClassTy;
Mike Stump1eb44332009-09-09 15:08:12 +00005429
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005430 /// Both types must be pointers or references to classes.
5431 if (PointerType *NewPT = dyn_cast<PointerType>(NewTy)) {
5432 if (PointerType *OldPT = dyn_cast<PointerType>(OldTy)) {
5433 NewClassTy = NewPT->getPointeeType();
5434 OldClassTy = OldPT->getPointeeType();
5435 }
5436 } else if (ReferenceType *NewRT = dyn_cast<ReferenceType>(NewTy)) {
5437 if (ReferenceType *OldRT = dyn_cast<ReferenceType>(OldTy)) {
5438 NewClassTy = NewRT->getPointeeType();
5439 OldClassTy = OldRT->getPointeeType();
5440 }
5441 }
Mike Stump1eb44332009-09-09 15:08:12 +00005442
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005443 // The return types aren't either both pointers or references to a class type.
5444 if (NewClassTy.isNull()) {
Mike Stump1eb44332009-09-09 15:08:12 +00005445 Diag(New->getLocation(),
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005446 diag::err_different_return_type_for_overriding_virtual_function)
5447 << New->getDeclName() << NewTy << OldTy;
5448 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
Mike Stump1eb44332009-09-09 15:08:12 +00005449
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005450 return true;
5451 }
Anders Carlssond7ba27d2009-05-14 01:09:04 +00005452
Douglas Gregora4923eb2009-11-16 21:35:15 +00005453 if (!Context.hasSameUnqualifiedType(NewClassTy, OldClassTy)) {
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005454 // Check if the new class derives from the old class.
5455 if (!IsDerivedFrom(NewClassTy, OldClassTy)) {
5456 Diag(New->getLocation(),
5457 diag::err_covariant_return_not_derived)
5458 << New->getDeclName() << NewTy << OldTy;
5459 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
5460 return true;
5461 }
Mike Stump1eb44332009-09-09 15:08:12 +00005462
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005463 // Check if we the conversion from derived to base is valid.
Mike Stump1eb44332009-09-09 15:08:12 +00005464 if (CheckDerivedToBaseConversion(NewClassTy, OldClassTy,
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005465 diag::err_covariant_return_inaccessible_base,
5466 diag::err_covariant_return_ambiguous_derived_to_base_conv,
5467 // FIXME: Should this point to the return type?
5468 New->getLocation(), SourceRange(), New->getDeclName())) {
5469 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
5470 return true;
5471 }
5472 }
Mike Stump1eb44332009-09-09 15:08:12 +00005473
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005474 // The qualifiers of the return types must be the same.
Douglas Gregora4923eb2009-11-16 21:35:15 +00005475 if (CNewTy.getLocalCVRQualifiers() != COldTy.getLocalCVRQualifiers()) {
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005476 Diag(New->getLocation(),
5477 diag::err_covariant_return_type_different_qualifications)
Anders Carlssond7ba27d2009-05-14 01:09:04 +00005478 << New->getDeclName() << NewTy << OldTy;
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005479 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
5480 return true;
5481 };
Mike Stump1eb44332009-09-09 15:08:12 +00005482
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005483
5484 // The new class type must have the same or less qualifiers as the old type.
5485 if (NewClassTy.isMoreQualifiedThan(OldClassTy)) {
5486 Diag(New->getLocation(),
5487 diag::err_covariant_return_type_class_type_more_qualified)
5488 << New->getDeclName() << NewTy << OldTy;
5489 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
5490 return true;
5491 };
Mike Stump1eb44332009-09-09 15:08:12 +00005492
Anders Carlssonc3a68b22009-05-14 19:52:19 +00005493 return false;
Anders Carlssond7ba27d2009-05-14 01:09:04 +00005494}
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00005495
Sean Huntbbd37c62009-11-21 08:43:09 +00005496bool Sema::CheckOverridingFunctionAttributes(const CXXMethodDecl *New,
5497 const CXXMethodDecl *Old)
5498{
5499 if (Old->hasAttr<FinalAttr>()) {
5500 Diag(New->getLocation(), diag::err_final_function_overridden)
5501 << New->getDeclName();
5502 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
5503 return true;
5504 }
5505
5506 return false;
5507}
5508
Douglas Gregor4ba31362009-12-01 17:24:26 +00005509/// \brief Mark the given method pure.
5510///
5511/// \param Method the method to be marked pure.
5512///
5513/// \param InitRange the source range that covers the "0" initializer.
5514bool Sema::CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange) {
5515 if (Method->isVirtual() || Method->getParent()->isDependentContext()) {
5516 Method->setPure();
5517
5518 // A class is abstract if at least one function is pure virtual.
5519 Method->getParent()->setAbstract(true);
5520 return false;
5521 }
5522
5523 if (!Method->isInvalidDecl())
5524 Diag(Method->getLocation(), diag::err_non_virtual_pure)
5525 << Method->getDeclName() << InitRange;
5526 return true;
5527}
5528
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00005529/// ActOnCXXEnterDeclInitializer - Invoked when we are about to parse an
5530/// initializer for the declaration 'Dcl'.
5531/// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
5532/// static data member of class X, names should be looked up in the scope of
5533/// class X.
5534void Sema::ActOnCXXEnterDeclInitializer(Scope *S, DeclPtrTy Dcl) {
Douglas Gregorefd5bda2009-08-24 11:57:43 +00005535 AdjustDeclIfTemplate(Dcl);
Mike Stump1eb44332009-09-09 15:08:12 +00005536
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00005537 Decl *D = Dcl.getAs<Decl>();
5538 // If there is no declaration, there was an error parsing it.
5539 if (D == 0)
5540 return;
5541
5542 // Check whether it is a declaration with a nested name specifier like
5543 // int foo::bar;
5544 if (!D->isOutOfLine())
5545 return;
Mike Stump1eb44332009-09-09 15:08:12 +00005546
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00005547 // C++ [basic.lookup.unqual]p13
5548 //
5549 // A name used in the definition of a static data member of class X
5550 // (after the qualified-id of the static member) is looked up as if the name
5551 // was used in a member function of X.
Mike Stump1eb44332009-09-09 15:08:12 +00005552
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00005553 // Change current context into the context of the initializing declaration.
Argyrios Kyrtzidis1d175532009-06-17 23:15:40 +00005554 EnterDeclaratorContext(S, D->getDeclContext());
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00005555}
5556
5557/// ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an
5558/// initializer for the declaration 'Dcl'.
5559void Sema::ActOnCXXExitDeclInitializer(Scope *S, DeclPtrTy Dcl) {
Douglas Gregorefd5bda2009-08-24 11:57:43 +00005560 AdjustDeclIfTemplate(Dcl);
Mike Stump1eb44332009-09-09 15:08:12 +00005561
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00005562 Decl *D = Dcl.getAs<Decl>();
5563 // If there is no declaration, there was an error parsing it.
5564 if (D == 0)
5565 return;
5566
5567 // Check whether it is a declaration with a nested name specifier like
5568 // int foo::bar;
5569 if (!D->isOutOfLine())
5570 return;
5571
5572 assert(S->getEntity() == D->getDeclContext() && "Context imbalance!");
Argyrios Kyrtzidis1d175532009-06-17 23:15:40 +00005573 ExitDeclaratorContext(S);
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00005574}
Douglas Gregor99e9b4d2009-11-25 00:27:52 +00005575
5576/// ActOnCXXConditionDeclarationExpr - Parsed a condition declaration of a
5577/// C++ if/switch/while/for statement.
5578/// e.g: "if (int x = f()) {...}"
5579Action::DeclResult
5580Sema::ActOnCXXConditionDeclaration(Scope *S, Declarator &D) {
5581 // C++ 6.4p2:
5582 // The declarator shall not specify a function or an array.
5583 // The type-specifier-seq shall not contain typedef and shall not declare a
5584 // new class or enumeration.
5585 assert(D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef &&
5586 "Parser allowed 'typedef' as storage class of condition decl.");
5587
John McCalla93c9342009-12-07 02:54:59 +00005588 TypeSourceInfo *TInfo = 0;
Douglas Gregor99e9b4d2009-11-25 00:27:52 +00005589 TagDecl *OwnedTag = 0;
John McCalla93c9342009-12-07 02:54:59 +00005590 QualType Ty = GetTypeForDeclarator(D, S, &TInfo, &OwnedTag);
Douglas Gregor99e9b4d2009-11-25 00:27:52 +00005591
5592 if (Ty->isFunctionType()) { // The declarator shall not specify a function...
5593 // We exit without creating a CXXConditionDeclExpr because a FunctionDecl
5594 // would be created and CXXConditionDeclExpr wants a VarDecl.
5595 Diag(D.getIdentifierLoc(), diag::err_invalid_use_of_function_type)
5596 << D.getSourceRange();
5597 return DeclResult();
5598 } else if (OwnedTag && OwnedTag->isDefinition()) {
5599 // The type-specifier-seq shall not declare a new class or enumeration.
5600 Diag(OwnedTag->getLocation(), diag::err_type_defined_in_condition);
5601 }
5602
5603 DeclPtrTy Dcl = ActOnDeclarator(S, D);
5604 if (!Dcl)
5605 return DeclResult();
5606
5607 VarDecl *VD = cast<VarDecl>(Dcl.getAs<Decl>());
5608 VD->setDeclaredInCondition(true);
5609 return Dcl;
5610}
Anders Carlsson5ec02ae2009-12-02 17:15:43 +00005611
Anders Carlssond6a637f2009-12-07 08:24:59 +00005612void Sema::MaybeMarkVirtualMembersReferenced(SourceLocation Loc,
5613 CXXMethodDecl *MD) {
Anders Carlsson5ec02ae2009-12-02 17:15:43 +00005614 // Ignore dependent types.
5615 if (MD->isDependentContext())
5616 return;
5617
5618 CXXRecordDecl *RD = MD->getParent();
Anders Carlssonf53df232009-12-07 04:35:11 +00005619
5620 // Ignore classes without a vtable.
5621 if (!RD->isDynamicClass())
5622 return;
5623
Anders Carlssond6a637f2009-12-07 08:24:59 +00005624 if (!MD->isOutOfLine()) {
5625 // The only inline functions we care about are constructors. We also defer
5626 // marking the virtual members as referenced until we've reached the end
5627 // of the translation unit. We do this because we need to know the key
5628 // function of the class in order to determine the key function.
5629 if (isa<CXXConstructorDecl>(MD))
5630 ClassesWithUnmarkedVirtualMembers.insert(std::make_pair(RD, Loc));
5631 return;
5632 }
5633
Anders Carlssonf53df232009-12-07 04:35:11 +00005634 const CXXMethodDecl *KeyFunction = Context.getKeyFunction(RD);
Anders Carlsson5ec02ae2009-12-02 17:15:43 +00005635
5636 if (!KeyFunction) {
5637 // This record does not have a key function, so we assume that the vtable
5638 // will be emitted when it's used by the constructor.
5639 if (!isa<CXXConstructorDecl>(MD))
5640 return;
5641 } else if (KeyFunction->getCanonicalDecl() != MD->getCanonicalDecl()) {
5642 // We don't have the right key function.
5643 return;
5644 }
5645
Anders Carlssond6a637f2009-12-07 08:24:59 +00005646 // Mark the members as referenced.
5647 MarkVirtualMembersReferenced(Loc, RD);
5648 ClassesWithUnmarkedVirtualMembers.erase(RD);
5649}
5650
5651bool Sema::ProcessPendingClassesWithUnmarkedVirtualMembers() {
5652 if (ClassesWithUnmarkedVirtualMembers.empty())
5653 return false;
5654
5655 for (std::map<CXXRecordDecl *, SourceLocation>::iterator i =
5656 ClassesWithUnmarkedVirtualMembers.begin(),
5657 e = ClassesWithUnmarkedVirtualMembers.end(); i != e; ++i) {
5658 CXXRecordDecl *RD = i->first;
5659
5660 const CXXMethodDecl *KeyFunction = Context.getKeyFunction(RD);
5661 if (KeyFunction) {
5662 // We know that the class has a key function. If the key function was
5663 // declared in this translation unit, then it the class decl would not
5664 // have been in the ClassesWithUnmarkedVirtualMembers map.
5665 continue;
5666 }
5667
5668 SourceLocation Loc = i->second;
5669 MarkVirtualMembersReferenced(Loc, RD);
Anders Carlsson5ec02ae2009-12-02 17:15:43 +00005670 }
5671
Anders Carlssond6a637f2009-12-07 08:24:59 +00005672 ClassesWithUnmarkedVirtualMembers.clear();
5673 return true;
Anders Carlsson5ec02ae2009-12-02 17:15:43 +00005674}
Anders Carlssond6a637f2009-12-07 08:24:59 +00005675
5676void Sema::MarkVirtualMembersReferenced(SourceLocation Loc, CXXRecordDecl *RD) {
5677 for (CXXRecordDecl::method_iterator i = RD->method_begin(),
5678 e = RD->method_end(); i != e; ++i) {
5679 CXXMethodDecl *MD = *i;
5680
5681 // C++ [basic.def.odr]p2:
5682 // [...] A virtual member function is used if it is not pure. [...]
5683 if (MD->isVirtual() && !MD->isPure())
5684 MarkDeclarationReferenced(Loc, MD);
5685 }
5686}
5687