blob: 3ff9144cc21c6f18a77ca6c8a18895817c7e7a58 [file] [log] [blame]
Chris Lattner199abbc2008-04-08 05:04:30 +00001//===------ SemaDeclCXX.cpp - Semantic Analysis for C++ Declarations ------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements semantic analysis for C++ declarations.
11//
12//===----------------------------------------------------------------------===//
13
14#include "Sema.h"
John McCall5cebab12009-11-18 07:57:50 +000015#include "Lookup.h"
Argyrios Kyrtzidis2f67f372008-08-09 00:58:37 +000016#include "clang/AST/ASTConsumer.h"
Douglas Gregor556877c2008-04-13 21:30:24 +000017#include "clang/AST/ASTContext.h"
Douglas Gregor36d1b142009-10-06 17:59:45 +000018#include "clang/AST/CXXInheritance.h"
Anders Carlssonb5a27b42009-03-24 01:19:16 +000019#include "clang/AST/DeclVisitor.h"
Douglas Gregordff6a8e2008-10-22 21:13:31 +000020#include "clang/AST/TypeOrdering.h"
Chris Lattner58258242008-04-10 02:22:51 +000021#include "clang/AST/StmtVisitor.h"
Douglas Gregorb53edfb2009-11-10 19:49:08 +000022#include "clang/Parse/DeclSpec.h"
23#include "clang/Parse/Template.h"
Anders Carlssond624e162009-08-26 23:45:07 +000024#include "clang/Basic/PartialDiagnostic.h"
Argyrios Kyrtzidis153d9672008-10-06 18:37:09 +000025#include "clang/Lex/Preprocessor.h"
Douglas Gregor55297ac2008-12-23 00:26:44 +000026#include "llvm/ADT/STLExtras.h"
Chris Lattner58258242008-04-10 02:22:51 +000027#include "llvm/Support/Compiler.h"
Douglas Gregor5251f1b2008-10-21 16:13:35 +000028#include <algorithm> // for std::equal
Douglas Gregor29a92472008-10-22 17:49:05 +000029#include <map>
Douglas Gregor36d1b142009-10-06 17:59:45 +000030#include <set>
Chris Lattner199abbc2008-04-08 05:04:30 +000031
32using namespace clang;
33
Chris Lattner58258242008-04-10 02:22:51 +000034//===----------------------------------------------------------------------===//
35// CheckDefaultArgumentVisitor
36//===----------------------------------------------------------------------===//
37
Chris Lattnerb0d38442008-04-12 23:52:44 +000038namespace {
39 /// CheckDefaultArgumentVisitor - C++ [dcl.fct.default] Traverses
40 /// the default argument of a parameter to determine whether it
41 /// contains any ill-formed subexpressions. For example, this will
42 /// diagnose the use of local variables or parameters within the
43 /// default argument expression.
Mike Stump11289f42009-09-09 15:08:12 +000044 class VISIBILITY_HIDDEN CheckDefaultArgumentVisitor
Chris Lattner574dee62008-07-26 22:17:49 +000045 : public StmtVisitor<CheckDefaultArgumentVisitor, bool> {
Chris Lattnerb0d38442008-04-12 23:52:44 +000046 Expr *DefaultArg;
47 Sema *S;
Chris Lattner58258242008-04-10 02:22:51 +000048
Chris Lattnerb0d38442008-04-12 23:52:44 +000049 public:
Mike Stump11289f42009-09-09 15:08:12 +000050 CheckDefaultArgumentVisitor(Expr *defarg, Sema *s)
Chris Lattnerb0d38442008-04-12 23:52:44 +000051 : DefaultArg(defarg), S(s) {}
Chris Lattner58258242008-04-10 02:22:51 +000052
Chris Lattnerb0d38442008-04-12 23:52:44 +000053 bool VisitExpr(Expr *Node);
54 bool VisitDeclRefExpr(DeclRefExpr *DRE);
Douglas Gregor97a9c812008-11-04 14:32:21 +000055 bool VisitCXXThisExpr(CXXThisExpr *ThisE);
Chris Lattnerb0d38442008-04-12 23:52:44 +000056 };
Chris Lattner58258242008-04-10 02:22:51 +000057
Chris Lattnerb0d38442008-04-12 23:52:44 +000058 /// VisitExpr - Visit all of the children of this expression.
59 bool CheckDefaultArgumentVisitor::VisitExpr(Expr *Node) {
60 bool IsInvalid = false;
Mike Stump11289f42009-09-09 15:08:12 +000061 for (Stmt::child_iterator I = Node->child_begin(),
Chris Lattner574dee62008-07-26 22:17:49 +000062 E = Node->child_end(); I != E; ++I)
63 IsInvalid |= Visit(*I);
Chris Lattnerb0d38442008-04-12 23:52:44 +000064 return IsInvalid;
Chris Lattner58258242008-04-10 02:22:51 +000065 }
66
Chris Lattnerb0d38442008-04-12 23:52:44 +000067 /// VisitDeclRefExpr - Visit a reference to a declaration, to
68 /// determine whether this declaration can be used in the default
69 /// argument expression.
70 bool CheckDefaultArgumentVisitor::VisitDeclRefExpr(DeclRefExpr *DRE) {
Douglas Gregor5251f1b2008-10-21 16:13:35 +000071 NamedDecl *Decl = DRE->getDecl();
Chris Lattnerb0d38442008-04-12 23:52:44 +000072 if (ParmVarDecl *Param = dyn_cast<ParmVarDecl>(Decl)) {
73 // C++ [dcl.fct.default]p9
74 // Default arguments are evaluated each time the function is
75 // called. The order of evaluation of function arguments is
76 // unspecified. Consequently, parameters of a function shall not
77 // be used in default argument expressions, even if they are not
78 // evaluated. Parameters of a function declared before a default
79 // argument expression are in scope and can hide namespace and
80 // class member names.
Mike Stump11289f42009-09-09 15:08:12 +000081 return S->Diag(DRE->getSourceRange().getBegin(),
Chris Lattner3b054132008-11-19 05:08:23 +000082 diag::err_param_default_argument_references_param)
Chris Lattnere3d20d92008-11-23 21:45:46 +000083 << Param->getDeclName() << DefaultArg->getSourceRange();
Steve Naroff08899ff2008-04-15 22:42:06 +000084 } else if (VarDecl *VDecl = dyn_cast<VarDecl>(Decl)) {
Chris Lattnerb0d38442008-04-12 23:52:44 +000085 // C++ [dcl.fct.default]p7
86 // Local variables shall not be used in default argument
87 // expressions.
Steve Naroff08899ff2008-04-15 22:42:06 +000088 if (VDecl->isBlockVarDecl())
Mike Stump11289f42009-09-09 15:08:12 +000089 return S->Diag(DRE->getSourceRange().getBegin(),
Chris Lattner3b054132008-11-19 05:08:23 +000090 diag::err_param_default_argument_references_local)
Chris Lattnere3d20d92008-11-23 21:45:46 +000091 << VDecl->getDeclName() << DefaultArg->getSourceRange();
Chris Lattnerb0d38442008-04-12 23:52:44 +000092 }
Chris Lattner58258242008-04-10 02:22:51 +000093
Douglas Gregor8e12c382008-11-04 13:41:56 +000094 return false;
95 }
Chris Lattnerb0d38442008-04-12 23:52:44 +000096
Douglas Gregor97a9c812008-11-04 14:32:21 +000097 /// VisitCXXThisExpr - Visit a C++ "this" expression.
98 bool CheckDefaultArgumentVisitor::VisitCXXThisExpr(CXXThisExpr *ThisE) {
99 // C++ [dcl.fct.default]p8:
100 // The keyword this shall not be used in a default argument of a
101 // member function.
102 return S->Diag(ThisE->getSourceRange().getBegin(),
Chris Lattner3b054132008-11-19 05:08:23 +0000103 diag::err_param_default_argument_references_this)
104 << ThisE->getSourceRange();
Chris Lattnerb0d38442008-04-12 23:52:44 +0000105 }
Chris Lattner58258242008-04-10 02:22:51 +0000106}
107
Anders Carlssonc80a1272009-08-25 02:29:20 +0000108bool
109Sema::SetParamDefaultArgument(ParmVarDecl *Param, ExprArg DefaultArg,
Mike Stump11289f42009-09-09 15:08:12 +0000110 SourceLocation EqualLoc) {
Anders Carlssonc80a1272009-08-25 02:29:20 +0000111 QualType ParamType = Param->getType();
112
Anders Carlsson114056f2009-08-25 13:46:13 +0000113 if (RequireCompleteType(Param->getLocation(), Param->getType(),
114 diag::err_typecheck_decl_incomplete_type)) {
115 Param->setInvalidDecl();
116 return true;
117 }
118
Anders Carlssonc80a1272009-08-25 02:29:20 +0000119 Expr *Arg = (Expr *)DefaultArg.get();
Mike Stump11289f42009-09-09 15:08:12 +0000120
Anders Carlssonc80a1272009-08-25 02:29:20 +0000121 // C++ [dcl.fct.default]p5
122 // A default argument expression is implicitly converted (clause
123 // 4) to the parameter type. The default argument expression has
124 // the same semantic constraints as the initializer expression in
125 // a declaration of a variable of the parameter type, using the
126 // copy-initialization semantics (8.5).
Mike Stump11289f42009-09-09 15:08:12 +0000127 if (CheckInitializerTypes(Arg, ParamType, EqualLoc,
Anders Carlssonc80a1272009-08-25 02:29:20 +0000128 Param->getDeclName(), /*DirectInit=*/false))
Anders Carlsson4562f1f2009-08-25 03:18:48 +0000129 return true;
Anders Carlssonc80a1272009-08-25 02:29:20 +0000130
131 Arg = MaybeCreateCXXExprWithTemporaries(Arg, /*DestroyTemps=*/false);
Mike Stump11289f42009-09-09 15:08:12 +0000132
Anders Carlssonc80a1272009-08-25 02:29:20 +0000133 // Okay: add the default argument to the parameter
134 Param->setDefaultArg(Arg);
Mike Stump11289f42009-09-09 15:08:12 +0000135
Anders Carlssonc80a1272009-08-25 02:29:20 +0000136 DefaultArg.release();
Mike Stump11289f42009-09-09 15:08:12 +0000137
Anders Carlsson4562f1f2009-08-25 03:18:48 +0000138 return false;
Anders Carlssonc80a1272009-08-25 02:29:20 +0000139}
140
Chris Lattner58258242008-04-10 02:22:51 +0000141/// ActOnParamDefaultArgument - Check whether the default argument
142/// provided for a function parameter is well-formed. If so, attach it
143/// to the parameter declaration.
Chris Lattner199abbc2008-04-08 05:04:30 +0000144void
Mike Stump11289f42009-09-09 15:08:12 +0000145Sema::ActOnParamDefaultArgument(DeclPtrTy param, SourceLocation EqualLoc,
Sebastian Redl6d4256c2009-03-15 17:47:39 +0000146 ExprArg defarg) {
Douglas Gregor71a57182009-06-22 23:20:33 +0000147 if (!param || !defarg.get())
148 return;
Mike Stump11289f42009-09-09 15:08:12 +0000149
Chris Lattner83f095c2009-03-28 19:18:32 +0000150 ParmVarDecl *Param = cast<ParmVarDecl>(param.getAs<Decl>());
Anders Carlsson84613c42009-06-12 16:51:40 +0000151 UnparsedDefaultArgLocs.erase(Param);
152
Anders Carlsson3cbc8592009-05-01 19:30:39 +0000153 ExprOwningPtr<Expr> DefaultArg(this, defarg.takeAs<Expr>());
Chris Lattner199abbc2008-04-08 05:04:30 +0000154 QualType ParamType = Param->getType();
155
156 // Default arguments are only permitted in C++
157 if (!getLangOptions().CPlusPlus) {
Chris Lattner3b054132008-11-19 05:08:23 +0000158 Diag(EqualLoc, diag::err_param_default_argument)
159 << DefaultArg->getSourceRange();
Douglas Gregor4d87df52008-12-16 21:30:33 +0000160 Param->setInvalidDecl();
Chris Lattner199abbc2008-04-08 05:04:30 +0000161 return;
162 }
163
Anders Carlssonf1c26952009-08-25 01:02:06 +0000164 // Check that the default argument is well-formed
165 CheckDefaultArgumentVisitor DefaultArgChecker(DefaultArg.get(), this);
166 if (DefaultArgChecker.Visit(DefaultArg.get())) {
167 Param->setInvalidDecl();
168 return;
169 }
Mike Stump11289f42009-09-09 15:08:12 +0000170
Anders Carlssonc80a1272009-08-25 02:29:20 +0000171 SetParamDefaultArgument(Param, move(DefaultArg), EqualLoc);
Chris Lattner199abbc2008-04-08 05:04:30 +0000172}
173
Douglas Gregor58354032008-12-24 00:01:03 +0000174/// ActOnParamUnparsedDefaultArgument - We've seen a default
175/// argument for a function parameter, but we can't parse it yet
176/// because we're inside a class definition. Note that this default
177/// argument will be parsed later.
Mike Stump11289f42009-09-09 15:08:12 +0000178void Sema::ActOnParamUnparsedDefaultArgument(DeclPtrTy param,
Anders Carlsson84613c42009-06-12 16:51:40 +0000179 SourceLocation EqualLoc,
180 SourceLocation ArgLoc) {
Douglas Gregor71a57182009-06-22 23:20:33 +0000181 if (!param)
182 return;
Mike Stump11289f42009-09-09 15:08:12 +0000183
Chris Lattner83f095c2009-03-28 19:18:32 +0000184 ParmVarDecl *Param = cast<ParmVarDecl>(param.getAs<Decl>());
Douglas Gregor58354032008-12-24 00:01:03 +0000185 if (Param)
186 Param->setUnparsedDefaultArg();
Mike Stump11289f42009-09-09 15:08:12 +0000187
Anders Carlsson84613c42009-06-12 16:51:40 +0000188 UnparsedDefaultArgLocs[Param] = ArgLoc;
Douglas Gregor58354032008-12-24 00:01:03 +0000189}
190
Douglas Gregor4d87df52008-12-16 21:30:33 +0000191/// ActOnParamDefaultArgumentError - Parsing or semantic analysis of
192/// the default argument for the parameter param failed.
Chris Lattner83f095c2009-03-28 19:18:32 +0000193void Sema::ActOnParamDefaultArgumentError(DeclPtrTy param) {
Douglas Gregor71a57182009-06-22 23:20:33 +0000194 if (!param)
195 return;
Mike Stump11289f42009-09-09 15:08:12 +0000196
Anders Carlsson84613c42009-06-12 16:51:40 +0000197 ParmVarDecl *Param = cast<ParmVarDecl>(param.getAs<Decl>());
Mike Stump11289f42009-09-09 15:08:12 +0000198
Anders Carlsson84613c42009-06-12 16:51:40 +0000199 Param->setInvalidDecl();
Mike Stump11289f42009-09-09 15:08:12 +0000200
Anders Carlsson84613c42009-06-12 16:51:40 +0000201 UnparsedDefaultArgLocs.erase(Param);
Douglas Gregor4d87df52008-12-16 21:30:33 +0000202}
203
Douglas Gregorcaa8ace2008-05-07 04:49:29 +0000204/// CheckExtraCXXDefaultArguments - Check for any extra default
205/// arguments in the declarator, which is not a function declaration
206/// or definition and therefore is not permitted to have default
207/// arguments. This routine should be invoked for every declarator
208/// that is not a function declaration or definition.
209void Sema::CheckExtraCXXDefaultArguments(Declarator &D) {
210 // C++ [dcl.fct.default]p3
211 // A default argument expression shall be specified only in the
212 // parameter-declaration-clause of a function declaration or in a
213 // template-parameter (14.1). It shall not be specified for a
214 // parameter pack. If it is specified in a
215 // parameter-declaration-clause, it shall not occur within a
216 // declarator or abstract-declarator of a parameter-declaration.
Chris Lattner83f095c2009-03-28 19:18:32 +0000217 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
Douglas Gregorcaa8ace2008-05-07 04:49:29 +0000218 DeclaratorChunk &chunk = D.getTypeObject(i);
219 if (chunk.Kind == DeclaratorChunk::Function) {
Chris Lattner83f095c2009-03-28 19:18:32 +0000220 for (unsigned argIdx = 0, e = chunk.Fun.NumArgs; argIdx != e; ++argIdx) {
221 ParmVarDecl *Param =
222 cast<ParmVarDecl>(chunk.Fun.ArgInfo[argIdx].Param.getAs<Decl>());
Douglas Gregor58354032008-12-24 00:01:03 +0000223 if (Param->hasUnparsedDefaultArg()) {
224 CachedTokens *Toks = chunk.Fun.ArgInfo[argIdx].DefaultArgTokens;
Douglas Gregor4d87df52008-12-16 21:30:33 +0000225 Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
226 << SourceRange((*Toks)[1].getLocation(), Toks->back().getLocation());
227 delete Toks;
228 chunk.Fun.ArgInfo[argIdx].DefaultArgTokens = 0;
Douglas Gregor58354032008-12-24 00:01:03 +0000229 } else if (Param->getDefaultArg()) {
230 Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
231 << Param->getDefaultArg()->getSourceRange();
232 Param->setDefaultArg(0);
Douglas Gregorcaa8ace2008-05-07 04:49:29 +0000233 }
234 }
235 }
236 }
237}
238
Chris Lattner199abbc2008-04-08 05:04:30 +0000239// MergeCXXFunctionDecl - Merge two declarations of the same C++
240// function, once we already know that they have the same
Douglas Gregor75a45ba2009-02-16 17:45:42 +0000241// type. Subroutine of MergeFunctionDecl. Returns true if there was an
242// error, false otherwise.
243bool Sema::MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old) {
244 bool Invalid = false;
245
Chris Lattner199abbc2008-04-08 05:04:30 +0000246 // C++ [dcl.fct.default]p4:
Chris Lattner199abbc2008-04-08 05:04:30 +0000247 // For non-template functions, default arguments can be added in
248 // later declarations of a function in the same
249 // scope. Declarations in different scopes have completely
250 // distinct sets of default arguments. That is, declarations in
251 // inner scopes do not acquire default arguments from
252 // declarations in outer scopes, and vice versa. In a given
253 // function declaration, all parameters subsequent to a
254 // parameter with a default argument shall have default
255 // arguments supplied in this or previous declarations. A
256 // default argument shall not be redefined by a later
257 // declaration (not even to the same value).
Douglas Gregorc732aba2009-09-11 18:44:32 +0000258 //
259 // C++ [dcl.fct.default]p6:
260 // Except for member functions of class templates, the default arguments
261 // in a member function definition that appears outside of the class
262 // definition are added to the set of default arguments provided by the
263 // member function declaration in the class definition.
Chris Lattner199abbc2008-04-08 05:04:30 +0000264 for (unsigned p = 0, NumParams = Old->getNumParams(); p < NumParams; ++p) {
265 ParmVarDecl *OldParam = Old->getParamDecl(p);
266 ParmVarDecl *NewParam = New->getParamDecl(p);
267
Douglas Gregorc732aba2009-09-11 18:44:32 +0000268 if (OldParam->hasDefaultArg() && NewParam->hasDefaultArg()) {
Anders Carlsson0b8ea552009-11-10 03:24:44 +0000269 // FIXME: If the parameter doesn't have an identifier then the location
270 // points to the '=' which means that the fixit hint won't remove any
271 // extra spaces between the type and the '='.
272 SourceLocation Begin = NewParam->getLocation();
Anders Carlsson1566eb52009-11-10 03:32:44 +0000273 if (NewParam->getIdentifier())
274 Begin = PP.getLocForEndOfToken(Begin);
Anders Carlsson0b8ea552009-11-10 03:24:44 +0000275
Mike Stump11289f42009-09-09 15:08:12 +0000276 Diag(NewParam->getLocation(),
Chris Lattner3b054132008-11-19 05:08:23 +0000277 diag::err_param_default_argument_redefinition)
Anders Carlsson0b8ea552009-11-10 03:24:44 +0000278 << NewParam->getDefaultArgRange()
279 << CodeModificationHint::CreateRemoval(SourceRange(Begin,
280 NewParam->getLocEnd()));
Douglas Gregorc732aba2009-09-11 18:44:32 +0000281
282 // Look for the function declaration where the default argument was
283 // actually written, which may be a declaration prior to Old.
284 for (FunctionDecl *Older = Old->getPreviousDeclaration();
285 Older; Older = Older->getPreviousDeclaration()) {
286 if (!Older->getParamDecl(p)->hasDefaultArg())
287 break;
288
289 OldParam = Older->getParamDecl(p);
290 }
291
292 Diag(OldParam->getLocation(), diag::note_previous_definition)
293 << OldParam->getDefaultArgRange();
Douglas Gregor75a45ba2009-02-16 17:45:42 +0000294 Invalid = true;
Douglas Gregor4f15f4d2009-09-17 19:51:30 +0000295 } else if (OldParam->hasDefaultArg()) {
Chris Lattner199abbc2008-04-08 05:04:30 +0000296 // Merge the old default argument into the new parameter
Douglas Gregor4f15f4d2009-09-17 19:51:30 +0000297 if (OldParam->hasUninstantiatedDefaultArg())
298 NewParam->setUninstantiatedDefaultArg(
299 OldParam->getUninstantiatedDefaultArg());
300 else
301 NewParam->setDefaultArg(OldParam->getDefaultArg());
Douglas Gregorc732aba2009-09-11 18:44:32 +0000302 } else if (NewParam->hasDefaultArg()) {
303 if (New->getDescribedFunctionTemplate()) {
304 // Paragraph 4, quoted above, only applies to non-template functions.
305 Diag(NewParam->getLocation(),
306 diag::err_param_default_argument_template_redecl)
307 << NewParam->getDefaultArgRange();
308 Diag(Old->getLocation(), diag::note_template_prev_declaration)
309 << false;
Douglas Gregor62e10f02009-10-13 17:02:54 +0000310 } else if (New->getTemplateSpecializationKind()
311 != TSK_ImplicitInstantiation &&
312 New->getTemplateSpecializationKind() != TSK_Undeclared) {
313 // C++ [temp.expr.spec]p21:
314 // Default function arguments shall not be specified in a declaration
315 // or a definition for one of the following explicit specializations:
316 // - the explicit specialization of a function template;
Douglas Gregor3362bde2009-10-13 23:52:38 +0000317 // - the explicit specialization of a member function template;
318 // - the explicit specialization of a member function of a class
Douglas Gregor62e10f02009-10-13 17:02:54 +0000319 // template where the class template specialization to which the
320 // member function specialization belongs is implicitly
321 // instantiated.
322 Diag(NewParam->getLocation(), diag::err_template_spec_default_arg)
323 << (New->getTemplateSpecializationKind() ==TSK_ExplicitSpecialization)
324 << New->getDeclName()
325 << NewParam->getDefaultArgRange();
Douglas Gregorc732aba2009-09-11 18:44:32 +0000326 } else if (New->getDeclContext()->isDependentContext()) {
327 // C++ [dcl.fct.default]p6 (DR217):
328 // Default arguments for a member function of a class template shall
329 // be specified on the initial declaration of the member function
330 // within the class template.
331 //
332 // Reading the tea leaves a bit in DR217 and its reference to DR205
333 // leads me to the conclusion that one cannot add default function
334 // arguments for an out-of-line definition of a member function of a
335 // dependent type.
336 int WhichKind = 2;
337 if (CXXRecordDecl *Record
338 = dyn_cast<CXXRecordDecl>(New->getDeclContext())) {
339 if (Record->getDescribedClassTemplate())
340 WhichKind = 0;
341 else if (isa<ClassTemplatePartialSpecializationDecl>(Record))
342 WhichKind = 1;
343 else
344 WhichKind = 2;
345 }
346
347 Diag(NewParam->getLocation(),
348 diag::err_param_default_argument_member_template_redecl)
349 << WhichKind
350 << NewParam->getDefaultArgRange();
351 }
Chris Lattner199abbc2008-04-08 05:04:30 +0000352 }
353 }
354
Sebastian Redl4f4d7b52009-07-04 11:39:00 +0000355 if (CheckEquivalentExceptionSpec(
John McCall9dd450b2009-09-21 23:43:11 +0000356 Old->getType()->getAs<FunctionProtoType>(), Old->getLocation(),
357 New->getType()->getAs<FunctionProtoType>(), New->getLocation())) {
Sebastian Redl4f4d7b52009-07-04 11:39:00 +0000358 Invalid = true;
359 }
360
Douglas Gregor75a45ba2009-02-16 17:45:42 +0000361 return Invalid;
Chris Lattner199abbc2008-04-08 05:04:30 +0000362}
363
364/// CheckCXXDefaultArguments - Verify that the default arguments for a
365/// function declaration are well-formed according to C++
366/// [dcl.fct.default].
367void Sema::CheckCXXDefaultArguments(FunctionDecl *FD) {
368 unsigned NumParams = FD->getNumParams();
369 unsigned p;
370
371 // Find first parameter with a default argument
372 for (p = 0; p < NumParams; ++p) {
373 ParmVarDecl *Param = FD->getParamDecl(p);
Anders Carlsson5a532382009-08-25 01:23:32 +0000374 if (Param->hasDefaultArg())
Chris Lattner199abbc2008-04-08 05:04:30 +0000375 break;
376 }
377
378 // C++ [dcl.fct.default]p4:
379 // In a given function declaration, all parameters
380 // subsequent to a parameter with a default argument shall
381 // have default arguments supplied in this or previous
382 // declarations. A default argument shall not be redefined
383 // by a later declaration (not even to the same value).
384 unsigned LastMissingDefaultArg = 0;
Mike Stump11289f42009-09-09 15:08:12 +0000385 for (; p < NumParams; ++p) {
Chris Lattner199abbc2008-04-08 05:04:30 +0000386 ParmVarDecl *Param = FD->getParamDecl(p);
Anders Carlsson5a532382009-08-25 01:23:32 +0000387 if (!Param->hasDefaultArg()) {
Douglas Gregor4d87df52008-12-16 21:30:33 +0000388 if (Param->isInvalidDecl())
389 /* We already complained about this parameter. */;
390 else if (Param->getIdentifier())
Mike Stump11289f42009-09-09 15:08:12 +0000391 Diag(Param->getLocation(),
Chris Lattner3b054132008-11-19 05:08:23 +0000392 diag::err_param_default_argument_missing_name)
Chris Lattnerb91fd172008-11-19 07:32:16 +0000393 << Param->getIdentifier();
Chris Lattner199abbc2008-04-08 05:04:30 +0000394 else
Mike Stump11289f42009-09-09 15:08:12 +0000395 Diag(Param->getLocation(),
Chris Lattner199abbc2008-04-08 05:04:30 +0000396 diag::err_param_default_argument_missing);
Mike Stump11289f42009-09-09 15:08:12 +0000397
Chris Lattner199abbc2008-04-08 05:04:30 +0000398 LastMissingDefaultArg = p;
399 }
400 }
401
402 if (LastMissingDefaultArg > 0) {
403 // Some default arguments were missing. Clear out all of the
404 // default arguments up to (and including) the last missing
405 // default argument, so that we leave the function parameters
406 // in a semantically valid state.
407 for (p = 0; p <= LastMissingDefaultArg; ++p) {
408 ParmVarDecl *Param = FD->getParamDecl(p);
Anders Carlsson84613c42009-06-12 16:51:40 +0000409 if (Param->hasDefaultArg()) {
Douglas Gregor58354032008-12-24 00:01:03 +0000410 if (!Param->hasUnparsedDefaultArg())
411 Param->getDefaultArg()->Destroy(Context);
Chris Lattner199abbc2008-04-08 05:04:30 +0000412 Param->setDefaultArg(0);
413 }
414 }
415 }
416}
Douglas Gregor556877c2008-04-13 21:30:24 +0000417
Douglas Gregor61956c42008-10-31 09:07:45 +0000418/// isCurrentClassName - Determine whether the identifier II is the
419/// name of the class type currently being defined. In the case of
420/// nested classes, this will only return true if II is the name of
421/// the innermost class.
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +0000422bool Sema::isCurrentClassName(const IdentifierInfo &II, Scope *,
423 const CXXScopeSpec *SS) {
Argyrios Kyrtzidis16ac9be2008-11-08 17:17:31 +0000424 CXXRecordDecl *CurDecl;
Douglas Gregor52537682009-03-19 00:18:19 +0000425 if (SS && SS->isSet() && !SS->isInvalid()) {
Douglas Gregore5bbb7d2009-08-21 22:16:40 +0000426 DeclContext *DC = computeDeclContext(*SS, true);
Argyrios Kyrtzidis16ac9be2008-11-08 17:17:31 +0000427 CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC);
428 } else
429 CurDecl = dyn_cast_or_null<CXXRecordDecl>(CurContext);
430
431 if (CurDecl)
Douglas Gregor61956c42008-10-31 09:07:45 +0000432 return &II == CurDecl->getIdentifier();
433 else
434 return false;
435}
436
Mike Stump11289f42009-09-09 15:08:12 +0000437/// \brief Check the validity of a C++ base class specifier.
Douglas Gregor463421d2009-03-03 04:44:36 +0000438///
439/// \returns a new CXXBaseSpecifier if well-formed, emits diagnostics
440/// and returns NULL otherwise.
441CXXBaseSpecifier *
442Sema::CheckBaseSpecifier(CXXRecordDecl *Class,
443 SourceRange SpecifierRange,
444 bool Virtual, AccessSpecifier Access,
Mike Stump11289f42009-09-09 15:08:12 +0000445 QualType BaseType,
Douglas Gregor463421d2009-03-03 04:44:36 +0000446 SourceLocation BaseLoc) {
447 // C++ [class.union]p1:
448 // A union shall not have base classes.
449 if (Class->isUnion()) {
450 Diag(Class->getLocation(), diag::err_base_clause_on_union)
451 << SpecifierRange;
452 return 0;
453 }
454
455 if (BaseType->isDependentType())
Mike Stump11289f42009-09-09 15:08:12 +0000456 return new (Context) CXXBaseSpecifier(SpecifierRange, Virtual,
Douglas Gregor463421d2009-03-03 04:44:36 +0000457 Class->getTagKind() == RecordDecl::TK_class,
458 Access, BaseType);
459
460 // Base specifiers must be record types.
461 if (!BaseType->isRecordType()) {
462 Diag(BaseLoc, diag::err_base_must_be_class) << SpecifierRange;
463 return 0;
464 }
465
466 // C++ [class.union]p1:
467 // A union shall not be used as a base class.
468 if (BaseType->isUnionType()) {
469 Diag(BaseLoc, diag::err_union_as_base_class) << SpecifierRange;
470 return 0;
471 }
472
473 // C++ [class.derived]p2:
474 // The class-name in a base-specifier shall not be an incompletely
475 // defined class.
Mike Stump11289f42009-09-09 15:08:12 +0000476 if (RequireCompleteType(BaseLoc, BaseType,
Anders Carlssond624e162009-08-26 23:45:07 +0000477 PDiag(diag::err_incomplete_base_class)
478 << SpecifierRange))
Douglas Gregor463421d2009-03-03 04:44:36 +0000479 return 0;
480
Eli Friedmanc96d4962009-08-15 21:55:26 +0000481 // If the base class is polymorphic or isn't empty, the new one is/isn't, too.
Ted Kremenekc23c7e62009-07-29 21:53:49 +0000482 RecordDecl *BaseDecl = BaseType->getAs<RecordType>()->getDecl();
Douglas Gregor463421d2009-03-03 04:44:36 +0000483 assert(BaseDecl && "Record type has no declaration");
484 BaseDecl = BaseDecl->getDefinition(Context);
485 assert(BaseDecl && "Base type is not incomplete, but has no definition");
Eli Friedmanc96d4962009-08-15 21:55:26 +0000486 CXXRecordDecl * CXXBaseDecl = cast<CXXRecordDecl>(BaseDecl);
487 assert(CXXBaseDecl && "Base type is not a C++ type");
488 if (!CXXBaseDecl->isEmpty())
489 Class->setEmpty(false);
490 if (CXXBaseDecl->isPolymorphic())
Douglas Gregor463421d2009-03-03 04:44:36 +0000491 Class->setPolymorphic(true);
Alexis Hunt96d5c762009-11-21 08:43:09 +0000492 // C++0x CWG Issue #817 indicates that [[final]] classes shouldn't be bases.
493 if (CXXBaseDecl->hasAttr<FinalAttr>()) {
494 Diag(BaseLoc, diag::err_final_base) << BaseType.getAsString();
495 Diag(CXXBaseDecl->getLocation(), diag::note_previous_class_decl)
496 << BaseType.getAsString();
497 return 0;
498 }
Douglas Gregor463421d2009-03-03 04:44:36 +0000499
500 // C++ [dcl.init.aggr]p1:
501 // An aggregate is [...] a class with [...] no base classes [...].
502 Class->setAggregate(false);
503 Class->setPOD(false);
504
Anders Carlssonfe63dc52009-04-16 00:08:20 +0000505 if (Virtual) {
506 // C++ [class.ctor]p5:
507 // A constructor is trivial if its class has no virtual base classes.
508 Class->setHasTrivialConstructor(false);
Douglas Gregor8a273912009-07-22 18:25:24 +0000509
510 // C++ [class.copy]p6:
511 // A copy constructor is trivial if its class has no virtual base classes.
512 Class->setHasTrivialCopyConstructor(false);
513
514 // C++ [class.copy]p11:
515 // A copy assignment operator is trivial if its class has no virtual
516 // base classes.
517 Class->setHasTrivialCopyAssignment(false);
Eli Friedmanc96d4962009-08-15 21:55:26 +0000518
519 // C++0x [meta.unary.prop] is_empty:
520 // T is a class type, but not a union type, with ... no virtual base
521 // classes
522 Class->setEmpty(false);
Anders Carlssonfe63dc52009-04-16 00:08:20 +0000523 } else {
524 // C++ [class.ctor]p5:
Mike Stump11289f42009-09-09 15:08:12 +0000525 // A constructor is trivial if all the direct base classes of its
Anders Carlssonfe63dc52009-04-16 00:08:20 +0000526 // class have trivial constructors.
Douglas Gregor8a273912009-07-22 18:25:24 +0000527 if (!cast<CXXRecordDecl>(BaseDecl)->hasTrivialConstructor())
528 Class->setHasTrivialConstructor(false);
529
530 // C++ [class.copy]p6:
531 // A copy constructor is trivial if all the direct base classes of its
532 // class have trivial copy constructors.
533 if (!cast<CXXRecordDecl>(BaseDecl)->hasTrivialCopyConstructor())
534 Class->setHasTrivialCopyConstructor(false);
535
536 // C++ [class.copy]p11:
537 // A copy assignment operator is trivial if all the direct base classes
538 // of its class have trivial copy assignment operators.
539 if (!cast<CXXRecordDecl>(BaseDecl)->hasTrivialCopyAssignment())
540 Class->setHasTrivialCopyAssignment(false);
Anders Carlssonfe63dc52009-04-16 00:08:20 +0000541 }
Anders Carlsson6dc35752009-04-17 02:34:54 +0000542
543 // C++ [class.ctor]p3:
544 // A destructor is trivial if all the direct base classes of its class
545 // have trivial destructors.
Douglas Gregor8a273912009-07-22 18:25:24 +0000546 if (!cast<CXXRecordDecl>(BaseDecl)->hasTrivialDestructor())
547 Class->setHasTrivialDestructor(false);
Mike Stump11289f42009-09-09 15:08:12 +0000548
Douglas Gregor463421d2009-03-03 04:44:36 +0000549 // Create the base specifier.
550 // FIXME: Allocate via ASTContext?
Mike Stump11289f42009-09-09 15:08:12 +0000551 return new (Context) CXXBaseSpecifier(SpecifierRange, Virtual,
552 Class->getTagKind() == RecordDecl::TK_class,
Douglas Gregor463421d2009-03-03 04:44:36 +0000553 Access, BaseType);
554}
555
Douglas Gregor556877c2008-04-13 21:30:24 +0000556/// ActOnBaseSpecifier - Parsed a base specifier. A base specifier is
557/// one entry in the base class list of a class specifier, for
Mike Stump11289f42009-09-09 15:08:12 +0000558/// example:
559/// class foo : public bar, virtual private baz {
Douglas Gregor556877c2008-04-13 21:30:24 +0000560/// 'public bar' and 'virtual private baz' are each base-specifiers.
Mike Stump11289f42009-09-09 15:08:12 +0000561Sema::BaseResult
Chris Lattner83f095c2009-03-28 19:18:32 +0000562Sema::ActOnBaseSpecifier(DeclPtrTy classdecl, SourceRange SpecifierRange,
Douglas Gregor29a92472008-10-22 17:49:05 +0000563 bool Virtual, AccessSpecifier Access,
564 TypeTy *basetype, SourceLocation BaseLoc) {
Douglas Gregor71a57182009-06-22 23:20:33 +0000565 if (!classdecl)
566 return true;
567
Douglas Gregorc40290e2009-03-09 23:48:35 +0000568 AdjustDeclIfTemplate(classdecl);
Chris Lattner83f095c2009-03-28 19:18:32 +0000569 CXXRecordDecl *Class = cast<CXXRecordDecl>(classdecl.getAs<Decl>());
Argyrios Kyrtzidisc7148c92009-08-19 01:28:28 +0000570 QualType BaseType = GetTypeFromParser(basetype);
Douglas Gregor463421d2009-03-03 04:44:36 +0000571 if (CXXBaseSpecifier *BaseSpec = CheckBaseSpecifier(Class, SpecifierRange,
572 Virtual, Access,
573 BaseType, BaseLoc))
574 return BaseSpec;
Mike Stump11289f42009-09-09 15:08:12 +0000575
Douglas Gregor463421d2009-03-03 04:44:36 +0000576 return true;
Douglas Gregor29a92472008-10-22 17:49:05 +0000577}
Douglas Gregor556877c2008-04-13 21:30:24 +0000578
Douglas Gregor463421d2009-03-03 04:44:36 +0000579/// \brief Performs the actual work of attaching the given base class
580/// specifiers to a C++ class.
581bool Sema::AttachBaseSpecifiers(CXXRecordDecl *Class, CXXBaseSpecifier **Bases,
582 unsigned NumBases) {
583 if (NumBases == 0)
584 return false;
Douglas Gregor29a92472008-10-22 17:49:05 +0000585
586 // Used to keep track of which base types we have already seen, so
587 // that we can properly diagnose redundant direct base types. Note
Douglas Gregor9d6290b2008-10-23 18:13:27 +0000588 // that the key is always the unqualified canonical type of the base
589 // class.
Douglas Gregor29a92472008-10-22 17:49:05 +0000590 std::map<QualType, CXXBaseSpecifier*, QualTypeOrdering> KnownBaseTypes;
591
592 // Copy non-redundant base specifiers into permanent storage.
Douglas Gregor9d6290b2008-10-23 18:13:27 +0000593 unsigned NumGoodBases = 0;
Douglas Gregor463421d2009-03-03 04:44:36 +0000594 bool Invalid = false;
Douglas Gregor9d6290b2008-10-23 18:13:27 +0000595 for (unsigned idx = 0; idx < NumBases; ++idx) {
Mike Stump11289f42009-09-09 15:08:12 +0000596 QualType NewBaseType
Douglas Gregor463421d2009-03-03 04:44:36 +0000597 = Context.getCanonicalType(Bases[idx]->getType());
Douglas Gregor1b8fe5b72009-11-16 21:35:15 +0000598 NewBaseType = NewBaseType.getLocalUnqualifiedType();
Douglas Gregor9d6290b2008-10-23 18:13:27 +0000599
Douglas Gregor29a92472008-10-22 17:49:05 +0000600 if (KnownBaseTypes[NewBaseType]) {
601 // C++ [class.mi]p3:
602 // A class shall not be specified as a direct base class of a
603 // derived class more than once.
Douglas Gregor463421d2009-03-03 04:44:36 +0000604 Diag(Bases[idx]->getSourceRange().getBegin(),
Chris Lattner3b054132008-11-19 05:08:23 +0000605 diag::err_duplicate_base_class)
Chris Lattner1e5665e2008-11-24 06:25:27 +0000606 << KnownBaseTypes[NewBaseType]->getType()
Douglas Gregor463421d2009-03-03 04:44:36 +0000607 << Bases[idx]->getSourceRange();
Douglas Gregor9d6290b2008-10-23 18:13:27 +0000608
609 // Delete the duplicate base class specifier; we're going to
610 // overwrite its pointer later.
Douglas Gregorb77af8f2009-07-22 20:55:49 +0000611 Context.Deallocate(Bases[idx]);
Douglas Gregor463421d2009-03-03 04:44:36 +0000612
613 Invalid = true;
Douglas Gregor29a92472008-10-22 17:49:05 +0000614 } else {
615 // Okay, add this new base class.
Douglas Gregor463421d2009-03-03 04:44:36 +0000616 KnownBaseTypes[NewBaseType] = Bases[idx];
617 Bases[NumGoodBases++] = Bases[idx];
Douglas Gregor29a92472008-10-22 17:49:05 +0000618 }
619 }
620
621 // Attach the remaining base class specifiers to the derived class.
Fariborz Jahanian9fa077c2009-07-02 18:26:15 +0000622 Class->setBases(Context, Bases, NumGoodBases);
Douglas Gregor9d6290b2008-10-23 18:13:27 +0000623
624 // Delete the remaining (good) base class specifiers, since their
625 // data has been copied into the CXXRecordDecl.
626 for (unsigned idx = 0; idx < NumGoodBases; ++idx)
Douglas Gregorb77af8f2009-07-22 20:55:49 +0000627 Context.Deallocate(Bases[idx]);
Douglas Gregor463421d2009-03-03 04:44:36 +0000628
629 return Invalid;
630}
631
632/// ActOnBaseSpecifiers - Attach the given base specifiers to the
633/// class, after checking whether there are any duplicate base
634/// classes.
Mike Stump11289f42009-09-09 15:08:12 +0000635void Sema::ActOnBaseSpecifiers(DeclPtrTy ClassDecl, BaseTy **Bases,
Douglas Gregor463421d2009-03-03 04:44:36 +0000636 unsigned NumBases) {
637 if (!ClassDecl || !Bases || !NumBases)
638 return;
639
640 AdjustDeclIfTemplate(ClassDecl);
Chris Lattner83f095c2009-03-28 19:18:32 +0000641 AttachBaseSpecifiers(cast<CXXRecordDecl>(ClassDecl.getAs<Decl>()),
Douglas Gregor463421d2009-03-03 04:44:36 +0000642 (CXXBaseSpecifier**)(Bases), NumBases);
Douglas Gregor556877c2008-04-13 21:30:24 +0000643}
Argyrios Kyrtzidis08114892008-04-27 13:50:30 +0000644
Douglas Gregor36d1b142009-10-06 17:59:45 +0000645/// \brief Determine whether the type \p Derived is a C++ class that is
646/// derived from the type \p Base.
647bool Sema::IsDerivedFrom(QualType Derived, QualType Base) {
648 if (!getLangOptions().CPlusPlus)
649 return false;
650
651 const RecordType *DerivedRT = Derived->getAs<RecordType>();
652 if (!DerivedRT)
653 return false;
654
655 const RecordType *BaseRT = Base->getAs<RecordType>();
656 if (!BaseRT)
657 return false;
658
659 CXXRecordDecl *DerivedRD = cast<CXXRecordDecl>(DerivedRT->getDecl());
660 CXXRecordDecl *BaseRD = cast<CXXRecordDecl>(BaseRT->getDecl());
661 return DerivedRD->isDerivedFrom(BaseRD);
662}
663
664/// \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, CXXBasePaths &Paths) {
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, Paths);
681}
682
683/// CheckDerivedToBaseConversion - Check whether the Derived-to-Base
684/// conversion (where Derived and Base are class types) is
685/// well-formed, meaning that the conversion is unambiguous (and
686/// that all of the base classes are accessible). Returns true
687/// and emits a diagnostic if the code is ill-formed, returns false
688/// otherwise. Loc is the location where this routine should point to
689/// if there is an error, and Range is the source range to highlight
690/// if there is an error.
691bool
692Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base,
693 unsigned InaccessibleBaseID,
694 unsigned AmbigiousBaseConvID,
695 SourceLocation Loc, SourceRange Range,
696 DeclarationName Name) {
697 // First, determine whether the path from Derived to Base is
698 // ambiguous. This is slightly more expensive than checking whether
699 // the Derived to Base conversion exists, because here we need to
700 // explore multiple paths to determine if there is an ambiguity.
701 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
702 /*DetectVirtual=*/false);
703 bool DerivationOkay = IsDerivedFrom(Derived, Base, Paths);
704 assert(DerivationOkay &&
705 "Can only be used with a derived-to-base conversion");
706 (void)DerivationOkay;
707
708 if (!Paths.isAmbiguous(Context.getCanonicalType(Base).getUnqualifiedType())) {
Sebastian Redl7c353682009-11-14 21:15:49 +0000709 if (InaccessibleBaseID == 0)
710 return false;
Douglas Gregor36d1b142009-10-06 17:59:45 +0000711 // Check that the base class can be accessed.
712 return CheckBaseClassAccess(Derived, Base, InaccessibleBaseID, Paths, Loc,
713 Name);
714 }
715
716 // We know that the derived-to-base conversion is ambiguous, and
717 // we're going to produce a diagnostic. Perform the derived-to-base
718 // search just one more time to compute all of the possible paths so
719 // that we can print them out. This is more expensive than any of
720 // the previous derived-to-base checks we've done, but at this point
721 // performance isn't as much of an issue.
722 Paths.clear();
723 Paths.setRecordingPaths(true);
724 bool StillOkay = IsDerivedFrom(Derived, Base, Paths);
725 assert(StillOkay && "Can only be used with a derived-to-base conversion");
726 (void)StillOkay;
727
728 // Build up a textual representation of the ambiguous paths, e.g.,
729 // D -> B -> A, that will be used to illustrate the ambiguous
730 // conversions in the diagnostic. We only print one of the paths
731 // to each base class subobject.
732 std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
733
734 Diag(Loc, AmbigiousBaseConvID)
735 << Derived << Base << PathDisplayStr << Range << Name;
736 return true;
737}
738
739bool
740Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base,
Sebastian Redl7c353682009-11-14 21:15:49 +0000741 SourceLocation Loc, SourceRange Range,
742 bool IgnoreAccess) {
Douglas Gregor36d1b142009-10-06 17:59:45 +0000743 return CheckDerivedToBaseConversion(Derived, Base,
Sebastian Redl7c353682009-11-14 21:15:49 +0000744 IgnoreAccess ? 0 :
745 diag::err_conv_to_inaccessible_base,
Douglas Gregor36d1b142009-10-06 17:59:45 +0000746 diag::err_ambiguous_derived_to_base_conv,
747 Loc, Range, DeclarationName());
748}
749
750
751/// @brief Builds a string representing ambiguous paths from a
752/// specific derived class to different subobjects of the same base
753/// class.
754///
755/// This function builds a string that can be used in error messages
756/// to show the different paths that one can take through the
757/// inheritance hierarchy to go from the derived class to different
758/// subobjects of a base class. The result looks something like this:
759/// @code
760/// struct D -> struct B -> struct A
761/// struct D -> struct C -> struct A
762/// @endcode
763std::string Sema::getAmbiguousPathsDisplayString(CXXBasePaths &Paths) {
764 std::string PathDisplayStr;
765 std::set<unsigned> DisplayedPaths;
766 for (CXXBasePaths::paths_iterator Path = Paths.begin();
767 Path != Paths.end(); ++Path) {
768 if (DisplayedPaths.insert(Path->back().SubobjectNumber).second) {
769 // We haven't displayed a path to this particular base
770 // class subobject yet.
771 PathDisplayStr += "\n ";
772 PathDisplayStr += Context.getTypeDeclType(Paths.getOrigin()).getAsString();
773 for (CXXBasePath::const_iterator Element = Path->begin();
774 Element != Path->end(); ++Element)
775 PathDisplayStr += " -> " + Element->Base->getType().getAsString();
776 }
777 }
778
779 return PathDisplayStr;
780}
781
Argyrios Kyrtzidised983422008-07-01 10:37:29 +0000782//===----------------------------------------------------------------------===//
783// C++ class member Handling
784//===----------------------------------------------------------------------===//
785
Argyrios Kyrtzidised983422008-07-01 10:37:29 +0000786/// ActOnCXXMemberDeclarator - This is invoked when a C++ class member
787/// declarator is parsed. 'AS' is the access specifier, 'BW' specifies the
788/// bitfield width if there is one and 'InitExpr' specifies the initializer if
Chris Lattnereb4373d2009-04-12 22:37:57 +0000789/// any.
Chris Lattner83f095c2009-03-28 19:18:32 +0000790Sema::DeclPtrTy
Argyrios Kyrtzidised983422008-07-01 10:37:29 +0000791Sema::ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS, Declarator &D,
Douglas Gregor3447e762009-08-20 22:52:58 +0000792 MultiTemplateParamsArg TemplateParameterLists,
Sebastian Redl42e92c42009-04-12 17:16:29 +0000793 ExprTy *BW, ExprTy *InitExpr, bool Deleted) {
Argyrios Kyrtzidised983422008-07-01 10:37:29 +0000794 const DeclSpec &DS = D.getDeclSpec();
Douglas Gregor92751d42008-11-17 22:58:34 +0000795 DeclarationName Name = GetNameForDeclarator(D);
Argyrios Kyrtzidised983422008-07-01 10:37:29 +0000796 Expr *BitWidth = static_cast<Expr*>(BW);
797 Expr *Init = static_cast<Expr*>(InitExpr);
798 SourceLocation Loc = D.getIdentifierLoc();
799
Sebastian Redlccdfaba2008-11-14 23:42:31 +0000800 bool isFunc = D.isFunctionDeclarator();
801
John McCall07e91c02009-08-06 02:15:43 +0000802 assert(!DS.isFriendSpecified());
803
Argyrios Kyrtzidised983422008-07-01 10:37:29 +0000804 // C++ 9.2p6: A member shall not be declared to have automatic storage
805 // duration (auto, register) or with the extern storage-class-specifier.
Sebastian Redlccdfaba2008-11-14 23:42:31 +0000806 // C++ 7.1.1p8: The mutable specifier can be applied only to names of class
807 // data members and cannot be applied to names declared const or static,
808 // and cannot be applied to reference members.
Argyrios Kyrtzidised983422008-07-01 10:37:29 +0000809 switch (DS.getStorageClassSpec()) {
810 case DeclSpec::SCS_unspecified:
811 case DeclSpec::SCS_typedef:
812 case DeclSpec::SCS_static:
813 // FALL THROUGH.
814 break;
Sebastian Redlccdfaba2008-11-14 23:42:31 +0000815 case DeclSpec::SCS_mutable:
816 if (isFunc) {
817 if (DS.getStorageClassSpecLoc().isValid())
Chris Lattner3b054132008-11-19 05:08:23 +0000818 Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_function);
Sebastian Redlccdfaba2008-11-14 23:42:31 +0000819 else
Chris Lattner3b054132008-11-19 05:08:23 +0000820 Diag(DS.getThreadSpecLoc(), diag::err_mutable_function);
Mike Stump11289f42009-09-09 15:08:12 +0000821
Sebastian Redl8071edb2008-11-17 23:24:37 +0000822 // FIXME: It would be nicer if the keyword was ignored only for this
823 // declarator. Otherwise we could get follow-up errors.
Sebastian Redlccdfaba2008-11-14 23:42:31 +0000824 D.getMutableDeclSpec().ClearStorageClassSpecs();
825 } else {
826 QualType T = GetTypeForDeclarator(D, S);
827 diag::kind err = static_cast<diag::kind>(0);
828 if (T->isReferenceType())
829 err = diag::err_mutable_reference;
830 else if (T.isConstQualified())
831 err = diag::err_mutable_const;
832 if (err != 0) {
833 if (DS.getStorageClassSpecLoc().isValid())
834 Diag(DS.getStorageClassSpecLoc(), err);
835 else
836 Diag(DS.getThreadSpecLoc(), err);
Sebastian Redl8071edb2008-11-17 23:24:37 +0000837 // FIXME: It would be nicer if the keyword was ignored only for this
838 // declarator. Otherwise we could get follow-up errors.
Sebastian Redlccdfaba2008-11-14 23:42:31 +0000839 D.getMutableDeclSpec().ClearStorageClassSpecs();
840 }
841 }
842 break;
Argyrios Kyrtzidised983422008-07-01 10:37:29 +0000843 default:
844 if (DS.getStorageClassSpecLoc().isValid())
845 Diag(DS.getStorageClassSpecLoc(),
846 diag::err_storageclass_invalid_for_member);
847 else
848 Diag(DS.getThreadSpecLoc(), diag::err_storageclass_invalid_for_member);
849 D.getMutableDeclSpec().ClearStorageClassSpecs();
850 }
851
Argyrios Kyrtzidis2e3e7562008-10-15 20:23:22 +0000852 if (!isFunc &&
Douglas Gregor9817f4a2009-02-09 15:09:02 +0000853 D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_typename &&
Argyrios Kyrtzidis2e3e7562008-10-15 20:23:22 +0000854 D.getNumTypeObjects() == 0) {
Argyrios Kyrtzidis1207d312008-10-08 22:20:31 +0000855 // Check also for this case:
856 //
857 // typedef int f();
858 // f a;
859 //
Argyrios Kyrtzidisc7148c92009-08-19 01:28:28 +0000860 QualType TDType = GetTypeFromParser(DS.getTypeRep());
Douglas Gregor9817f4a2009-02-09 15:09:02 +0000861 isFunc = TDType->isFunctionType();
Argyrios Kyrtzidis1207d312008-10-08 22:20:31 +0000862 }
Argyrios Kyrtzidised983422008-07-01 10:37:29 +0000863
Sebastian Redlccdfaba2008-11-14 23:42:31 +0000864 bool isInstField = ((DS.getStorageClassSpec() == DeclSpec::SCS_unspecified ||
865 DS.getStorageClassSpec() == DeclSpec::SCS_mutable) &&
Argyrios Kyrtzidis1207d312008-10-08 22:20:31 +0000866 !isFunc);
Argyrios Kyrtzidised983422008-07-01 10:37:29 +0000867
868 Decl *Member;
Chris Lattner73bf7b42009-03-05 22:45:59 +0000869 if (isInstField) {
Douglas Gregor3447e762009-08-20 22:52:58 +0000870 // FIXME: Check for template parameters!
Douglas Gregor4261e4c2009-03-11 20:50:30 +0000871 Member = HandleField(S, cast<CXXRecordDecl>(CurContext), Loc, D, BitWidth,
872 AS);
Chris Lattner97e277e2009-03-05 23:03:49 +0000873 assert(Member && "HandleField never returns null");
Chris Lattner73bf7b42009-03-05 22:45:59 +0000874 } else {
Douglas Gregor3447e762009-08-20 22:52:58 +0000875 Member = HandleDeclarator(S, D, move(TemplateParameterLists), false)
876 .getAs<Decl>();
Chris Lattner97e277e2009-03-05 23:03:49 +0000877 if (!Member) {
878 if (BitWidth) DeleteExpr(BitWidth);
Chris Lattner5bbb3c82009-03-29 16:50:03 +0000879 return DeclPtrTy();
Chris Lattner97e277e2009-03-05 23:03:49 +0000880 }
Chris Lattnerd26760a2009-03-05 23:01:03 +0000881
882 // Non-instance-fields can't have a bitfield.
883 if (BitWidth) {
884 if (Member->isInvalidDecl()) {
885 // don't emit another diagnostic.
Douglas Gregor212cab32009-03-11 20:22:50 +0000886 } else if (isa<VarDecl>(Member)) {
Chris Lattnerd26760a2009-03-05 23:01:03 +0000887 // C++ 9.6p3: A bit-field shall not be a static member.
888 // "static member 'A' cannot be a bit-field"
889 Diag(Loc, diag::err_static_not_bitfield)
890 << Name << BitWidth->getSourceRange();
891 } else if (isa<TypedefDecl>(Member)) {
892 // "typedef member 'x' cannot be a bit-field"
893 Diag(Loc, diag::err_typedef_not_bitfield)
894 << Name << BitWidth->getSourceRange();
895 } else {
896 // A function typedef ("typedef int f(); f a;").
897 // C++ 9.6p3: A bit-field shall have integral or enumeration type.
898 Diag(Loc, diag::err_not_integral_type_bitfield)
Mike Stump11289f42009-09-09 15:08:12 +0000899 << Name << cast<ValueDecl>(Member)->getType()
Douglas Gregor1efa4372009-03-11 18:59:21 +0000900 << BitWidth->getSourceRange();
Chris Lattnerd26760a2009-03-05 23:01:03 +0000901 }
Mike Stump11289f42009-09-09 15:08:12 +0000902
Chris Lattnerd26760a2009-03-05 23:01:03 +0000903 DeleteExpr(BitWidth);
904 BitWidth = 0;
905 Member->setInvalidDecl();
906 }
Douglas Gregor4261e4c2009-03-11 20:50:30 +0000907
908 Member->setAccess(AS);
Mike Stump11289f42009-09-09 15:08:12 +0000909
Douglas Gregor3447e762009-08-20 22:52:58 +0000910 // If we have declared a member function template, set the access of the
911 // templated declaration as well.
912 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Member))
913 FunTmpl->getTemplatedDecl()->setAccess(AS);
Chris Lattner73bf7b42009-03-05 22:45:59 +0000914 }
Argyrios Kyrtzidised983422008-07-01 10:37:29 +0000915
Douglas Gregor92751d42008-11-17 22:58:34 +0000916 assert((Name || isInstField) && "No identifier for non-field ?");
Argyrios Kyrtzidised983422008-07-01 10:37:29 +0000917
Douglas Gregor0c880302009-03-11 23:00:04 +0000918 if (Init)
Chris Lattner83f095c2009-03-28 19:18:32 +0000919 AddInitializerToDecl(DeclPtrTy::make(Member), ExprArg(*this, Init), false);
Sebastian Redl42e92c42009-04-12 17:16:29 +0000920 if (Deleted) // FIXME: Source location is not very good.
921 SetDeclDeleted(DeclPtrTy::make(Member), D.getSourceRange().getBegin());
Argyrios Kyrtzidised983422008-07-01 10:37:29 +0000922
Argyrios Kyrtzidised983422008-07-01 10:37:29 +0000923 if (isInstField) {
Douglas Gregor91f84212008-12-11 16:49:14 +0000924 FieldCollector->Add(cast<FieldDecl>(Member));
Chris Lattner5bbb3c82009-03-29 16:50:03 +0000925 return DeclPtrTy();
Argyrios Kyrtzidised983422008-07-01 10:37:29 +0000926 }
Chris Lattner83f095c2009-03-28 19:18:32 +0000927 return DeclPtrTy::make(Member);
Argyrios Kyrtzidised983422008-07-01 10:37:29 +0000928}
929
Douglas Gregore8381c02008-11-05 04:29:56 +0000930/// ActOnMemInitializer - Handle a C++ member initializer.
Mike Stump11289f42009-09-09 15:08:12 +0000931Sema::MemInitResult
Chris Lattner83f095c2009-03-28 19:18:32 +0000932Sema::ActOnMemInitializer(DeclPtrTy ConstructorD,
Douglas Gregore8381c02008-11-05 04:29:56 +0000933 Scope *S,
Fariborz Jahanian302bb662009-06-30 23:26:25 +0000934 const CXXScopeSpec &SS,
Douglas Gregore8381c02008-11-05 04:29:56 +0000935 IdentifierInfo *MemberOrBase,
Fariborz Jahanianc1fc3ec2009-07-01 19:21:19 +0000936 TypeTy *TemplateTypeTy,
Douglas Gregore8381c02008-11-05 04:29:56 +0000937 SourceLocation IdLoc,
938 SourceLocation LParenLoc,
939 ExprTy **Args, unsigned NumArgs,
940 SourceLocation *CommaLocs,
941 SourceLocation RParenLoc) {
Douglas Gregor71a57182009-06-22 23:20:33 +0000942 if (!ConstructorD)
943 return true;
Mike Stump11289f42009-09-09 15:08:12 +0000944
Douglas Gregorc8c277a2009-08-24 11:57:43 +0000945 AdjustDeclIfTemplate(ConstructorD);
Mike Stump11289f42009-09-09 15:08:12 +0000946
947 CXXConstructorDecl *Constructor
Chris Lattner83f095c2009-03-28 19:18:32 +0000948 = dyn_cast<CXXConstructorDecl>(ConstructorD.getAs<Decl>());
Douglas Gregore8381c02008-11-05 04:29:56 +0000949 if (!Constructor) {
950 // The user wrote a constructor initializer on a function that is
951 // not a C++ constructor. Ignore the error for now, because we may
952 // have more member initializers coming; we'll diagnose it just
953 // once in ActOnMemInitializers.
954 return true;
955 }
956
957 CXXRecordDecl *ClassDecl = Constructor->getParent();
958
959 // C++ [class.base.init]p2:
960 // Names in a mem-initializer-id are looked up in the scope of the
961 // constructor’s class and, if not found in that scope, are looked
962 // up in the scope containing the constructor’s
963 // definition. [Note: if the constructor’s class contains a member
964 // with the same name as a direct or virtual base class of the
965 // class, a mem-initializer-id naming the member or base class and
966 // composed of a single identifier refers to the class member. A
967 // mem-initializer-id for the hidden base class may be specified
968 // using a qualified name. ]
Fariborz Jahanianc1fc3ec2009-07-01 19:21:19 +0000969 if (!SS.getScopeRep() && !TemplateTypeTy) {
Fariborz Jahanian302bb662009-06-30 23:26:25 +0000970 // Look for a member, first.
971 FieldDecl *Member = 0;
Mike Stump11289f42009-09-09 15:08:12 +0000972 DeclContext::lookup_result Result
Fariborz Jahanian302bb662009-06-30 23:26:25 +0000973 = ClassDecl->lookup(MemberOrBase);
974 if (Result.first != Result.second)
975 Member = dyn_cast<FieldDecl>(*Result.first);
Douglas Gregore8381c02008-11-05 04:29:56 +0000976
Fariborz Jahanian302bb662009-06-30 23:26:25 +0000977 // FIXME: Handle members of an anonymous union.
Douglas Gregore8381c02008-11-05 04:29:56 +0000978
Eli Friedman8e1433b2009-07-29 19:44:27 +0000979 if (Member)
980 return BuildMemberInitializer(Member, (Expr**)Args, NumArgs, IdLoc,
981 RParenLoc);
Douglas Gregore8381c02008-11-05 04:29:56 +0000982 }
Douglas Gregore8381c02008-11-05 04:29:56 +0000983 // It didn't name a member, so see if it names a class.
Mike Stump11289f42009-09-09 15:08:12 +0000984 TypeTy *BaseTy = TemplateTypeTy ? TemplateTypeTy
Fariborz Jahanianc1fc3ec2009-07-01 19:21:19 +0000985 : getTypeName(*MemberOrBase, IdLoc, S, &SS);
Douglas Gregore8381c02008-11-05 04:29:56 +0000986 if (!BaseTy)
Chris Lattner4bd8dd82008-11-19 08:23:25 +0000987 return Diag(IdLoc, diag::err_mem_init_not_member_or_class)
988 << MemberOrBase << SourceRange(IdLoc, RParenLoc);
Mike Stump11289f42009-09-09 15:08:12 +0000989
Argyrios Kyrtzidisc7148c92009-08-19 01:28:28 +0000990 QualType BaseType = GetTypeFromParser(BaseTy);
Douglas Gregore8381c02008-11-05 04:29:56 +0000991
Eli Friedman8e1433b2009-07-29 19:44:27 +0000992 return BuildBaseInitializer(BaseType, (Expr **)Args, NumArgs, IdLoc,
993 RParenLoc, ClassDecl);
994}
995
John McCalle22a04a2009-11-04 23:02:40 +0000996/// Checks an initializer expression for use of uninitialized fields, such as
997/// containing the field that is being initialized. Returns true if there is an
998/// uninitialized field was used an updates the SourceLocation parameter; false
999/// otherwise.
1000static bool InitExprContainsUninitializedFields(const Stmt* S,
1001 const FieldDecl* LhsField,
1002 SourceLocation* L) {
1003 const MemberExpr* ME = dyn_cast<MemberExpr>(S);
1004 if (ME) {
1005 const NamedDecl* RhsField = ME->getMemberDecl();
1006 if (RhsField == LhsField) {
1007 // Initializing a field with itself. Throw a warning.
1008 // But wait; there are exceptions!
1009 // Exception #1: The field may not belong to this record.
1010 // e.g. Foo(const Foo& rhs) : A(rhs.A) {}
1011 const Expr* base = ME->getBase();
1012 if (base != NULL && !isa<CXXThisExpr>(base->IgnoreParenCasts())) {
1013 // Even though the field matches, it does not belong to this record.
1014 return false;
1015 }
1016 // None of the exceptions triggered; return true to indicate an
1017 // uninitialized field was used.
1018 *L = ME->getMemberLoc();
1019 return true;
1020 }
1021 }
1022 bool found = false;
1023 for (Stmt::const_child_iterator it = S->child_begin();
1024 it != S->child_end() && found == false;
1025 ++it) {
1026 if (isa<CallExpr>(S)) {
1027 // Do not descend into function calls or constructors, as the use
1028 // of an uninitialized field may be valid. One would have to inspect
1029 // the contents of the function/ctor to determine if it is safe or not.
1030 // i.e. Pass-by-value is never safe, but pass-by-reference and pointers
1031 // may be safe, depending on what the function/ctor does.
1032 continue;
1033 }
1034 found = InitExprContainsUninitializedFields(*it, LhsField, L);
1035 }
1036 return found;
1037}
1038
Eli Friedman8e1433b2009-07-29 19:44:27 +00001039Sema::MemInitResult
1040Sema::BuildMemberInitializer(FieldDecl *Member, Expr **Args,
1041 unsigned NumArgs, SourceLocation IdLoc,
1042 SourceLocation RParenLoc) {
Anders Carlsson1fe64cb2009-11-13 19:21:49 +00001043 // FIXME: CXXBaseOrMemberInitializer should only contain a single
1044 // subexpression so we can wrap it in a CXXExprWithTemporaries if necessary.
1045 ExprTemporaries.clear();
1046
John McCalle22a04a2009-11-04 23:02:40 +00001047 // Diagnose value-uses of fields to initialize themselves, e.g.
1048 // foo(foo)
1049 // where foo is not also a parameter to the constructor.
John McCallc90f6d72009-11-04 23:13:52 +00001050 // TODO: implement -Wuninitialized and fold this into that framework.
John McCalle22a04a2009-11-04 23:02:40 +00001051 for (unsigned i = 0; i < NumArgs; ++i) {
1052 SourceLocation L;
1053 if (InitExprContainsUninitializedFields(Args[i], Member, &L)) {
1054 // FIXME: Return true in the case when other fields are used before being
1055 // uninitialized. For example, let this field be the i'th field. When
1056 // initializing the i'th field, throw a warning if any of the >= i'th
1057 // fields are used, as they are not yet initialized.
1058 // Right now we are only handling the case where the i'th field uses
1059 // itself in its initializer.
1060 Diag(L, diag::warn_field_is_uninit);
1061 }
1062 }
1063
Eli Friedman8e1433b2009-07-29 19:44:27 +00001064 bool HasDependentArg = false;
1065 for (unsigned i = 0; i < NumArgs; i++)
1066 HasDependentArg |= Args[i]->isTypeDependent();
1067
1068 CXXConstructorDecl *C = 0;
1069 QualType FieldType = Member->getType();
1070 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
1071 FieldType = Array->getElementType();
1072 if (FieldType->isDependentType()) {
1073 // Can't check init for dependent type.
John McCallc90f6d72009-11-04 23:13:52 +00001074 } else if (FieldType->isRecordType()) {
1075 // Member is a record (struct/union/class), so pass the initializer
1076 // arguments down to the record's constructor.
Douglas Gregor5d3507d2009-09-09 23:08:42 +00001077 if (!HasDependentArg) {
1078 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(*this);
1079
1080 C = PerformInitializationByConstructor(FieldType,
1081 MultiExprArg(*this,
1082 (void**)Args,
1083 NumArgs),
1084 IdLoc,
1085 SourceRange(IdLoc, RParenLoc),
1086 Member->getDeclName(), IK_Direct,
1087 ConstructorArgs);
1088
1089 if (C) {
1090 // Take over the constructor arguments as our own.
1091 NumArgs = ConstructorArgs.size();
1092 Args = (Expr **)ConstructorArgs.take();
1093 }
1094 }
Fariborz Jahanianfc60ca82009-09-02 17:10:17 +00001095 } else if (NumArgs != 1 && NumArgs != 0) {
John McCallc90f6d72009-11-04 23:13:52 +00001096 // The member type is not a record type (or an array of record
1097 // types), so it can be only be default- or copy-initialized.
Mike Stump11289f42009-09-09 15:08:12 +00001098 return Diag(IdLoc, diag::err_mem_initializer_mismatch)
Eli Friedman8e1433b2009-07-29 19:44:27 +00001099 << Member->getDeclName() << SourceRange(IdLoc, RParenLoc);
1100 } else if (!HasDependentArg) {
Fariborz Jahanianfc60ca82009-09-02 17:10:17 +00001101 Expr *NewExp;
1102 if (NumArgs == 0) {
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00001103 if (FieldType->isReferenceType()) {
1104 Diag(IdLoc, diag::err_null_intialized_reference_member)
1105 << Member->getDeclName();
1106 return Diag(Member->getLocation(), diag::note_declared_at);
1107 }
Fariborz Jahanianfc60ca82009-09-02 17:10:17 +00001108 NewExp = new (Context) CXXZeroInitValueExpr(FieldType, IdLoc, RParenLoc);
1109 NumArgs = 1;
1110 }
1111 else
1112 NewExp = (Expr*)Args[0];
Eli Friedman8e1433b2009-07-29 19:44:27 +00001113 if (PerformCopyInitialization(NewExp, FieldType, "passing"))
1114 return true;
1115 Args[0] = NewExp;
Douglas Gregore8381c02008-11-05 04:29:56 +00001116 }
Anders Carlsson1fe64cb2009-11-13 19:21:49 +00001117
1118 // FIXME: CXXBaseOrMemberInitializer should only contain a single
1119 // subexpression so we can wrap it in a CXXExprWithTemporaries if necessary.
1120 ExprTemporaries.clear();
1121
Eli Friedman8e1433b2009-07-29 19:44:27 +00001122 // FIXME: Perform direct initialization of the member.
Mike Stump11289f42009-09-09 15:08:12 +00001123 return new (Context) CXXBaseOrMemberInitializer(Member, (Expr **)Args,
Anders Carlsson1e172e02009-08-29 01:31:33 +00001124 NumArgs, C, IdLoc, RParenLoc);
Eli Friedman8e1433b2009-07-29 19:44:27 +00001125}
1126
1127Sema::MemInitResult
1128Sema::BuildBaseInitializer(QualType BaseType, Expr **Args,
1129 unsigned NumArgs, SourceLocation IdLoc,
1130 SourceLocation RParenLoc, CXXRecordDecl *ClassDecl) {
1131 bool HasDependentArg = false;
1132 for (unsigned i = 0; i < NumArgs; i++)
1133 HasDependentArg |= Args[i]->isTypeDependent();
1134
1135 if (!BaseType->isDependentType()) {
1136 if (!BaseType->isRecordType())
1137 return Diag(IdLoc, diag::err_base_init_does_not_name_class)
1138 << BaseType << SourceRange(IdLoc, RParenLoc);
1139
1140 // C++ [class.base.init]p2:
1141 // [...] Unless the mem-initializer-id names a nonstatic data
1142 // member of the constructor’s class or a direct or virtual base
1143 // of that class, the mem-initializer is ill-formed. A
1144 // mem-initializer-list can initialize a base class using any
1145 // name that denotes that base class type.
Mike Stump11289f42009-09-09 15:08:12 +00001146
Eli Friedman8e1433b2009-07-29 19:44:27 +00001147 // First, check for a direct base class.
1148 const CXXBaseSpecifier *DirectBaseSpec = 0;
1149 for (CXXRecordDecl::base_class_const_iterator Base =
1150 ClassDecl->bases_begin(); Base != ClassDecl->bases_end(); ++Base) {
Douglas Gregor1b8fe5b72009-11-16 21:35:15 +00001151 if (Context.hasSameUnqualifiedType(BaseType, Base->getType())) {
Eli Friedman8e1433b2009-07-29 19:44:27 +00001152 // We found a direct base of this type. That's what we're
1153 // initializing.
1154 DirectBaseSpec = &*Base;
1155 break;
1156 }
1157 }
Mike Stump11289f42009-09-09 15:08:12 +00001158
Eli Friedman8e1433b2009-07-29 19:44:27 +00001159 // Check for a virtual base class.
1160 // FIXME: We might be able to short-circuit this if we know in advance that
1161 // there are no virtual bases.
1162 const CXXBaseSpecifier *VirtualBaseSpec = 0;
1163 if (!DirectBaseSpec || !DirectBaseSpec->isVirtual()) {
1164 // We haven't found a base yet; search the class hierarchy for a
1165 // virtual base class.
Douglas Gregor36d1b142009-10-06 17:59:45 +00001166 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
1167 /*DetectVirtual=*/false);
Eli Friedman8e1433b2009-07-29 19:44:27 +00001168 if (IsDerivedFrom(Context.getTypeDeclType(ClassDecl), BaseType, Paths)) {
Douglas Gregor36d1b142009-10-06 17:59:45 +00001169 for (CXXBasePaths::paths_iterator Path = Paths.begin();
Eli Friedman8e1433b2009-07-29 19:44:27 +00001170 Path != Paths.end(); ++Path) {
1171 if (Path->back().Base->isVirtual()) {
1172 VirtualBaseSpec = Path->back().Base;
1173 break;
1174 }
Douglas Gregore8381c02008-11-05 04:29:56 +00001175 }
1176 }
1177 }
Eli Friedman8e1433b2009-07-29 19:44:27 +00001178
1179 // C++ [base.class.init]p2:
1180 // If a mem-initializer-id is ambiguous because it designates both
1181 // a direct non-virtual base class and an inherited virtual base
1182 // class, the mem-initializer is ill-formed.
1183 if (DirectBaseSpec && VirtualBaseSpec)
1184 return Diag(IdLoc, diag::err_base_init_direct_and_virtual)
1185 << BaseType << SourceRange(IdLoc, RParenLoc);
1186 // C++ [base.class.init]p2:
1187 // Unless the mem-initializer-id names a nonstatic data membeer of the
1188 // constructor's class ot a direst or virtual base of that class, the
1189 // mem-initializer is ill-formed.
1190 if (!DirectBaseSpec && !VirtualBaseSpec)
1191 return Diag(IdLoc, diag::err_not_direct_base_or_virtual)
1192 << BaseType << ClassDecl->getNameAsCString()
1193 << SourceRange(IdLoc, RParenLoc);
Douglas Gregore8381c02008-11-05 04:29:56 +00001194 }
1195
Fariborz Jahanian0228bc12009-07-23 00:42:24 +00001196 CXXConstructorDecl *C = 0;
Eli Friedman8e1433b2009-07-29 19:44:27 +00001197 if (!BaseType->isDependentType() && !HasDependentArg) {
1198 DeclarationName Name = Context.DeclarationNames.getCXXConstructorName(
Douglas Gregor4100db62009-11-08 07:12:55 +00001199 Context.getCanonicalType(BaseType).getUnqualifiedType());
Douglas Gregor5d3507d2009-09-09 23:08:42 +00001200 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(*this);
1201
1202 C = PerformInitializationByConstructor(BaseType,
1203 MultiExprArg(*this,
1204 (void**)Args, NumArgs),
Mike Stump11289f42009-09-09 15:08:12 +00001205 IdLoc, SourceRange(IdLoc, RParenLoc),
Douglas Gregor5d3507d2009-09-09 23:08:42 +00001206 Name, IK_Direct,
1207 ConstructorArgs);
1208 if (C) {
1209 // Take over the constructor arguments as our own.
1210 NumArgs = ConstructorArgs.size();
1211 Args = (Expr **)ConstructorArgs.take();
1212 }
Eli Friedman8e1433b2009-07-29 19:44:27 +00001213 }
1214
Anders Carlsson1fe64cb2009-11-13 19:21:49 +00001215 // FIXME: CXXBaseOrMemberInitializer should only contain a single
1216 // subexpression so we can wrap it in a CXXExprWithTemporaries if necessary.
1217 ExprTemporaries.clear();
1218
Mike Stump11289f42009-09-09 15:08:12 +00001219 return new (Context) CXXBaseOrMemberInitializer(BaseType, (Expr **)Args,
Anders Carlsson1e172e02009-08-29 01:31:33 +00001220 NumArgs, C, IdLoc, RParenLoc);
Douglas Gregore8381c02008-11-05 04:29:56 +00001221}
1222
Eli Friedman9cf6b592009-11-09 19:20:36 +00001223bool
Anders Carlsson561f7932009-10-29 15:46:07 +00001224Sema::SetBaseOrMemberInitializers(CXXConstructorDecl *Constructor,
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00001225 CXXBaseOrMemberInitializer **Initializers,
1226 unsigned NumInitializers,
Eli Friedmand7686ef2009-11-09 01:05:47 +00001227 bool IsImplicitConstructor) {
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00001228 // We need to build the initializer AST according to order of construction
1229 // and not what user specified in the Initializers list.
1230 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Constructor->getDeclContext());
1231 llvm::SmallVector<CXXBaseOrMemberInitializer*, 32> AllToInit;
1232 llvm::DenseMap<const void *, CXXBaseOrMemberInitializer*> AllBaseFields;
1233 bool HasDependentBaseInit = false;
Eli Friedman9cf6b592009-11-09 19:20:36 +00001234 bool HadError = false;
Mike Stump11289f42009-09-09 15:08:12 +00001235
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00001236 for (unsigned i = 0; i < NumInitializers; i++) {
1237 CXXBaseOrMemberInitializer *Member = Initializers[i];
1238 if (Member->isBaseInitializer()) {
1239 if (Member->getBaseClass()->isDependentType())
1240 HasDependentBaseInit = true;
1241 AllBaseFields[Member->getBaseClass()->getAs<RecordType>()] = Member;
1242 } else {
1243 AllBaseFields[Member->getMember()] = Member;
1244 }
1245 }
Mike Stump11289f42009-09-09 15:08:12 +00001246
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00001247 if (HasDependentBaseInit) {
1248 // FIXME. This does not preserve the ordering of the initializers.
1249 // Try (with -Wreorder)
1250 // template<class X> struct A {};
Mike Stump11289f42009-09-09 15:08:12 +00001251 // template<class X> struct B : A<X> {
1252 // B() : x1(10), A<X>() {}
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00001253 // int x1;
1254 // };
1255 // B<int> x;
1256 // On seeing one dependent type, we should essentially exit this routine
1257 // while preserving user-declared initializer list. When this routine is
1258 // called during instantiatiation process, this routine will rebuild the
John McCallc90f6d72009-11-04 23:13:52 +00001259 // ordered initializer list correctly.
Mike Stump11289f42009-09-09 15:08:12 +00001260
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00001261 // If we have a dependent base initialization, we can't determine the
1262 // association between initializers and bases; just dump the known
1263 // initializers into the list, and don't try to deal with other bases.
1264 for (unsigned i = 0; i < NumInitializers; i++) {
1265 CXXBaseOrMemberInitializer *Member = Initializers[i];
1266 if (Member->isBaseInitializer())
1267 AllToInit.push_back(Member);
1268 }
1269 } else {
1270 // Push virtual bases before others.
1271 for (CXXRecordDecl::base_class_iterator VBase =
1272 ClassDecl->vbases_begin(),
1273 E = ClassDecl->vbases_end(); VBase != E; ++VBase) {
1274 if (VBase->getType()->isDependentType())
1275 continue;
Douglas Gregor598caee2009-11-15 08:51:10 +00001276 if (CXXBaseOrMemberInitializer *Value
1277 = AllBaseFields.lookup(VBase->getType()->getAs<RecordType>())) {
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00001278 AllToInit.push_back(Value);
Fariborz Jahanian59a1cd42009-09-03 21:32:41 +00001279 }
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00001280 else {
Mike Stump11289f42009-09-09 15:08:12 +00001281 CXXRecordDecl *VBaseDecl =
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00001282 cast<CXXRecordDecl>(VBase->getType()->getAs<RecordType>()->getDecl());
Anders Carlsson561f7932009-10-29 15:46:07 +00001283 assert(VBaseDecl && "SetBaseOrMemberInitializers - VBaseDecl null");
Fariborz Jahanian59a1cd42009-09-03 21:32:41 +00001284 CXXConstructorDecl *Ctor = VBaseDecl->getDefaultConstructor(Context);
Anders Carlsson561f7932009-10-29 15:46:07 +00001285 if (!Ctor) {
Eli Friedmand7686ef2009-11-09 01:05:47 +00001286 Diag(Constructor->getLocation(), diag::err_missing_default_ctor)
1287 << (int)IsImplicitConstructor << Context.getTagDeclType(ClassDecl)
1288 << 0 << VBase->getType();
1289 Diag(VBaseDecl->getLocation(), diag::note_previous_class_decl)
1290 << Context.getTagDeclType(VBaseDecl);
Eli Friedman9cf6b592009-11-09 19:20:36 +00001291 HadError = true;
Anders Carlsson561f7932009-10-29 15:46:07 +00001292 continue;
1293 }
Fariborz Jahanian59a1cd42009-09-03 21:32:41 +00001294
Anders Carlsson561f7932009-10-29 15:46:07 +00001295 ASTOwningVector<&ActionBase::DeleteExpr> CtorArgs(*this);
1296 if (CompleteConstructorCall(Ctor, MultiExprArg(*this, 0, 0),
1297 Constructor->getLocation(), CtorArgs))
1298 continue;
1299
1300 MarkDeclarationReferenced(Constructor->getLocation(), Ctor);
1301
Anders Carlssonbdd12402009-11-13 20:11:49 +00001302 // FIXME: CXXBaseOrMemberInitializer should only contain a single
1303 // subexpression so we can wrap it in a CXXExprWithTemporaries if necessary.
1304 ExprTemporaries.clear();
Mike Stump11289f42009-09-09 15:08:12 +00001305 CXXBaseOrMemberInitializer *Member =
Anders Carlsson561f7932009-10-29 15:46:07 +00001306 new (Context) CXXBaseOrMemberInitializer(VBase->getType(),
1307 CtorArgs.takeAs<Expr>(),
1308 CtorArgs.size(), Ctor,
1309 SourceLocation(),
1310 SourceLocation());
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00001311 AllToInit.push_back(Member);
1312 }
1313 }
Mike Stump11289f42009-09-09 15:08:12 +00001314
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00001315 for (CXXRecordDecl::base_class_iterator Base =
1316 ClassDecl->bases_begin(),
1317 E = ClassDecl->bases_end(); Base != E; ++Base) {
1318 // Virtuals are in the virtual base list and already constructed.
1319 if (Base->isVirtual())
1320 continue;
1321 // Skip dependent types.
1322 if (Base->getType()->isDependentType())
1323 continue;
Douglas Gregor598caee2009-11-15 08:51:10 +00001324 if (CXXBaseOrMemberInitializer *Value
1325 = AllBaseFields.lookup(Base->getType()->getAs<RecordType>())) {
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00001326 AllToInit.push_back(Value);
Fariborz Jahanian59a1cd42009-09-03 21:32:41 +00001327 }
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00001328 else {
Mike Stump11289f42009-09-09 15:08:12 +00001329 CXXRecordDecl *BaseDecl =
Fariborz Jahanian59a1cd42009-09-03 21:32:41 +00001330 cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Anders Carlsson561f7932009-10-29 15:46:07 +00001331 assert(BaseDecl && "SetBaseOrMemberInitializers - BaseDecl null");
Fariborz Jahanian59a1cd42009-09-03 21:32:41 +00001332 CXXConstructorDecl *Ctor = BaseDecl->getDefaultConstructor(Context);
Anders Carlsson561f7932009-10-29 15:46:07 +00001333 if (!Ctor) {
Eli Friedmand7686ef2009-11-09 01:05:47 +00001334 Diag(Constructor->getLocation(), diag::err_missing_default_ctor)
1335 << (int)IsImplicitConstructor << Context.getTagDeclType(ClassDecl)
1336 << 0 << Base->getType();
1337 Diag(BaseDecl->getLocation(), diag::note_previous_class_decl)
1338 << Context.getTagDeclType(BaseDecl);
Eli Friedman9cf6b592009-11-09 19:20:36 +00001339 HadError = true;
Anders Carlsson561f7932009-10-29 15:46:07 +00001340 continue;
1341 }
1342
1343 ASTOwningVector<&ActionBase::DeleteExpr> CtorArgs(*this);
1344 if (CompleteConstructorCall(Ctor, MultiExprArg(*this, 0, 0),
1345 Constructor->getLocation(), CtorArgs))
1346 continue;
1347
1348 MarkDeclarationReferenced(Constructor->getLocation(), Ctor);
Fariborz Jahanian59a1cd42009-09-03 21:32:41 +00001349
Anders Carlssonbdd12402009-11-13 20:11:49 +00001350 // FIXME: CXXBaseOrMemberInitializer should only contain a single
1351 // subexpression so we can wrap it in a CXXExprWithTemporaries if necessary.
1352 ExprTemporaries.clear();
Mike Stump11289f42009-09-09 15:08:12 +00001353 CXXBaseOrMemberInitializer *Member =
Anders Carlsson561f7932009-10-29 15:46:07 +00001354 new (Context) CXXBaseOrMemberInitializer(Base->getType(),
1355 CtorArgs.takeAs<Expr>(),
1356 CtorArgs.size(), Ctor,
1357 SourceLocation(),
1358 SourceLocation());
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00001359 AllToInit.push_back(Member);
1360 }
1361 }
1362 }
Mike Stump11289f42009-09-09 15:08:12 +00001363
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00001364 // non-static data members.
1365 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
1366 E = ClassDecl->field_end(); Field != E; ++Field) {
1367 if ((*Field)->isAnonymousStructOrUnion()) {
Mike Stump11289f42009-09-09 15:08:12 +00001368 if (const RecordType *FieldClassType =
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00001369 Field->getType()->getAs<RecordType>()) {
1370 CXXRecordDecl *FieldClassDecl
Douglas Gregor07eae022009-11-13 18:34:26 +00001371 = cast<CXXRecordDecl>(FieldClassType->getDecl());
Mike Stump11289f42009-09-09 15:08:12 +00001372 for (RecordDecl::field_iterator FA = FieldClassDecl->field_begin(),
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00001373 EA = FieldClassDecl->field_end(); FA != EA; FA++) {
1374 if (CXXBaseOrMemberInitializer *Value = AllBaseFields.lookup(*FA)) {
1375 // 'Member' is the anonymous union field and 'AnonUnionMember' is
1376 // set to the anonymous union data member used in the initializer
1377 // list.
1378 Value->setMember(*Field);
1379 Value->setAnonUnionMember(*FA);
1380 AllToInit.push_back(Value);
1381 break;
1382 }
1383 }
1384 }
1385 continue;
1386 }
1387 if (CXXBaseOrMemberInitializer *Value = AllBaseFields.lookup(*Field)) {
1388 AllToInit.push_back(Value);
1389 continue;
1390 }
Mike Stump11289f42009-09-09 15:08:12 +00001391
Eli Friedmand7686ef2009-11-09 01:05:47 +00001392 if ((*Field)->getType()->isDependentType())
Douglas Gregor2de8f412009-11-04 17:16:11 +00001393 continue;
Douglas Gregor2de8f412009-11-04 17:16:11 +00001394
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00001395 QualType FT = Context.getBaseElementType((*Field)->getType());
1396 if (const RecordType* RT = FT->getAs<RecordType>()) {
1397 CXXConstructorDecl *Ctor =
1398 cast<CXXRecordDecl>(RT->getDecl())->getDefaultConstructor(Context);
Douglas Gregor2de8f412009-11-04 17:16:11 +00001399 if (!Ctor) {
Eli Friedmand7686ef2009-11-09 01:05:47 +00001400 Diag(Constructor->getLocation(), diag::err_missing_default_ctor)
1401 << (int)IsImplicitConstructor << Context.getTagDeclType(ClassDecl)
1402 << 1 << (*Field)->getDeclName();
1403 Diag(Field->getLocation(), diag::note_field_decl);
1404 Diag(RT->getDecl()->getLocation(), diag::note_previous_class_decl)
1405 << Context.getTagDeclType(RT->getDecl());
Eli Friedman9cf6b592009-11-09 19:20:36 +00001406 HadError = true;
Anders Carlsson561f7932009-10-29 15:46:07 +00001407 continue;
1408 }
Eli Friedman22683fe2009-11-16 23:07:59 +00001409
1410 if (FT.isConstQualified() && Ctor->isTrivial()) {
1411 Diag(Constructor->getLocation(), diag::err_unintialized_member_in_ctor)
1412 << (int)IsImplicitConstructor << Context.getTagDeclType(ClassDecl)
1413 << 1 << (*Field)->getDeclName();
1414 Diag((*Field)->getLocation(), diag::note_declared_at);
1415 HadError = true;
1416 }
1417
1418 // Don't create initializers for trivial constructors, since they don't
1419 // actually need to be run.
1420 if (Ctor->isTrivial())
1421 continue;
1422
Anders Carlsson561f7932009-10-29 15:46:07 +00001423 ASTOwningVector<&ActionBase::DeleteExpr> CtorArgs(*this);
1424 if (CompleteConstructorCall(Ctor, MultiExprArg(*this, 0, 0),
1425 Constructor->getLocation(), CtorArgs))
1426 continue;
1427
Anders Carlssonbdd12402009-11-13 20:11:49 +00001428 // FIXME: CXXBaseOrMemberInitializer should only contain a single
1429 // subexpression so we can wrap it in a CXXExprWithTemporaries if necessary.
1430 ExprTemporaries.clear();
Mike Stump11289f42009-09-09 15:08:12 +00001431 CXXBaseOrMemberInitializer *Member =
Anders Carlsson561f7932009-10-29 15:46:07 +00001432 new (Context) CXXBaseOrMemberInitializer(*Field,CtorArgs.takeAs<Expr>(),
1433 CtorArgs.size(), Ctor,
1434 SourceLocation(),
1435 SourceLocation());
1436
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00001437 AllToInit.push_back(Member);
Eli Friedmand7686ef2009-11-09 01:05:47 +00001438 MarkDeclarationReferenced(Constructor->getLocation(), Ctor);
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00001439 }
1440 else if (FT->isReferenceType()) {
1441 Diag(Constructor->getLocation(), diag::err_unintialized_member_in_ctor)
Eli Friedmand7686ef2009-11-09 01:05:47 +00001442 << (int)IsImplicitConstructor << Context.getTagDeclType(ClassDecl)
1443 << 0 << (*Field)->getDeclName();
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00001444 Diag((*Field)->getLocation(), diag::note_declared_at);
Eli Friedman9cf6b592009-11-09 19:20:36 +00001445 HadError = true;
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00001446 }
1447 else if (FT.isConstQualified()) {
1448 Diag(Constructor->getLocation(), diag::err_unintialized_member_in_ctor)
Eli Friedmand7686ef2009-11-09 01:05:47 +00001449 << (int)IsImplicitConstructor << Context.getTagDeclType(ClassDecl)
1450 << 1 << (*Field)->getDeclName();
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00001451 Diag((*Field)->getLocation(), diag::note_declared_at);
Eli Friedman9cf6b592009-11-09 19:20:36 +00001452 HadError = true;
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00001453 }
1454 }
Mike Stump11289f42009-09-09 15:08:12 +00001455
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00001456 NumInitializers = AllToInit.size();
1457 if (NumInitializers > 0) {
1458 Constructor->setNumBaseOrMemberInitializers(NumInitializers);
1459 CXXBaseOrMemberInitializer **baseOrMemberInitializers =
1460 new (Context) CXXBaseOrMemberInitializer*[NumInitializers];
Mike Stump11289f42009-09-09 15:08:12 +00001461
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00001462 Constructor->setBaseOrMemberInitializers(baseOrMemberInitializers);
1463 for (unsigned Idx = 0; Idx < NumInitializers; ++Idx)
1464 baseOrMemberInitializers[Idx] = AllToInit[Idx];
1465 }
Eli Friedman9cf6b592009-11-09 19:20:36 +00001466
1467 return HadError;
Fariborz Jahanian3501bce2009-09-03 19:36:46 +00001468}
1469
Eli Friedman952c15d2009-07-21 19:28:10 +00001470static void *GetKeyForTopLevelField(FieldDecl *Field) {
1471 // For anonymous unions, use the class declaration as the key.
Ted Kremenekc23c7e62009-07-29 21:53:49 +00001472 if (const RecordType *RT = Field->getType()->getAs<RecordType>()) {
Eli Friedman952c15d2009-07-21 19:28:10 +00001473 if (RT->getDecl()->isAnonymousStructOrUnion())
1474 return static_cast<void *>(RT->getDecl());
1475 }
1476 return static_cast<void *>(Field);
1477}
1478
Anders Carlssonbcec05c2009-09-01 06:22:14 +00001479static void *GetKeyForBase(QualType BaseType) {
1480 if (const RecordType *RT = BaseType->getAs<RecordType>())
1481 return (void *)RT;
Mike Stump11289f42009-09-09 15:08:12 +00001482
Anders Carlssonbcec05c2009-09-01 06:22:14 +00001483 assert(0 && "Unexpected base type!");
1484 return 0;
1485}
1486
Mike Stump11289f42009-09-09 15:08:12 +00001487static void *GetKeyForMember(CXXBaseOrMemberInitializer *Member,
Anders Carlssonbcec05c2009-09-01 06:22:14 +00001488 bool MemberMaybeAnon = false) {
Eli Friedman952c15d2009-07-21 19:28:10 +00001489 // For fields injected into the class via declaration of an anonymous union,
1490 // use its anonymous union class declaration as the unique key.
Anders Carlssonbcec05c2009-09-01 06:22:14 +00001491 if (Member->isMemberInitializer()) {
1492 FieldDecl *Field = Member->getMember();
Mike Stump11289f42009-09-09 15:08:12 +00001493
Eli Friedmand7686ef2009-11-09 01:05:47 +00001494 // After SetBaseOrMemberInitializers call, Field is the anonymous union
Mike Stump11289f42009-09-09 15:08:12 +00001495 // data member of the class. Data member used in the initializer list is
Fariborz Jahanianb2197042009-08-11 18:49:54 +00001496 // in AnonUnionMember field.
1497 if (MemberMaybeAnon && Field->isAnonymousStructOrUnion())
1498 Field = Member->getAnonUnionMember();
Eli Friedman952c15d2009-07-21 19:28:10 +00001499 if (Field->getDeclContext()->isRecord()) {
1500 RecordDecl *RD = cast<RecordDecl>(Field->getDeclContext());
1501 if (RD->isAnonymousStructOrUnion())
1502 return static_cast<void *>(RD);
1503 }
1504 return static_cast<void *>(Field);
1505 }
Mike Stump11289f42009-09-09 15:08:12 +00001506
Anders Carlssonbcec05c2009-09-01 06:22:14 +00001507 return GetKeyForBase(QualType(Member->getBaseClass(), 0));
Eli Friedman952c15d2009-07-21 19:28:10 +00001508}
1509
John McCallc90f6d72009-11-04 23:13:52 +00001510/// ActOnMemInitializers - Handle the member initializers for a constructor.
Mike Stump11289f42009-09-09 15:08:12 +00001511void Sema::ActOnMemInitializers(DeclPtrTy ConstructorDecl,
Anders Carlsson75fdaa42009-03-25 02:58:17 +00001512 SourceLocation ColonLoc,
1513 MemInitTy **MemInits, unsigned NumMemInits) {
Douglas Gregor71a57182009-06-22 23:20:33 +00001514 if (!ConstructorDecl)
1515 return;
Douglas Gregorc8c277a2009-08-24 11:57:43 +00001516
1517 AdjustDeclIfTemplate(ConstructorDecl);
Mike Stump11289f42009-09-09 15:08:12 +00001518
1519 CXXConstructorDecl *Constructor
Douglas Gregor71a57182009-06-22 23:20:33 +00001520 = dyn_cast<CXXConstructorDecl>(ConstructorDecl.getAs<Decl>());
Mike Stump11289f42009-09-09 15:08:12 +00001521
Anders Carlsson75fdaa42009-03-25 02:58:17 +00001522 if (!Constructor) {
1523 Diag(ColonLoc, diag::err_only_constructors_take_base_inits);
1524 return;
1525 }
Mike Stump11289f42009-09-09 15:08:12 +00001526
Anders Carlsson35d6e3e2009-08-27 05:57:30 +00001527 if (!Constructor->isDependentContext()) {
1528 llvm::DenseMap<void*, CXXBaseOrMemberInitializer *>Members;
1529 bool err = false;
1530 for (unsigned i = 0; i < NumMemInits; i++) {
Mike Stump11289f42009-09-09 15:08:12 +00001531 CXXBaseOrMemberInitializer *Member =
Anders Carlsson35d6e3e2009-08-27 05:57:30 +00001532 static_cast<CXXBaseOrMemberInitializer*>(MemInits[i]);
1533 void *KeyToMember = GetKeyForMember(Member);
1534 CXXBaseOrMemberInitializer *&PrevMember = Members[KeyToMember];
1535 if (!PrevMember) {
1536 PrevMember = Member;
1537 continue;
1538 }
1539 if (FieldDecl *Field = Member->getMember())
Mike Stump11289f42009-09-09 15:08:12 +00001540 Diag(Member->getSourceLocation(),
Anders Carlsson35d6e3e2009-08-27 05:57:30 +00001541 diag::error_multiple_mem_initialization)
1542 << Field->getNameAsString();
1543 else {
1544 Type *BaseClass = Member->getBaseClass();
1545 assert(BaseClass && "ActOnMemInitializers - neither field or base");
Mike Stump11289f42009-09-09 15:08:12 +00001546 Diag(Member->getSourceLocation(),
Anders Carlsson35d6e3e2009-08-27 05:57:30 +00001547 diag::error_multiple_base_initialization)
John McCalla1925362009-09-29 23:03:30 +00001548 << QualType(BaseClass, 0);
Anders Carlsson35d6e3e2009-08-27 05:57:30 +00001549 }
1550 Diag(PrevMember->getSourceLocation(), diag::note_previous_initializer)
1551 << 0;
1552 err = true;
1553 }
Mike Stump11289f42009-09-09 15:08:12 +00001554
Anders Carlsson35d6e3e2009-08-27 05:57:30 +00001555 if (err)
1556 return;
1557 }
Mike Stump11289f42009-09-09 15:08:12 +00001558
Eli Friedmand7686ef2009-11-09 01:05:47 +00001559 SetBaseOrMemberInitializers(Constructor,
Mike Stump11289f42009-09-09 15:08:12 +00001560 reinterpret_cast<CXXBaseOrMemberInitializer **>(MemInits),
Eli Friedmand7686ef2009-11-09 01:05:47 +00001561 NumMemInits, false);
Mike Stump11289f42009-09-09 15:08:12 +00001562
Anders Carlsson35d6e3e2009-08-27 05:57:30 +00001563 if (Constructor->isDependentContext())
1564 return;
Mike Stump11289f42009-09-09 15:08:12 +00001565
1566 if (Diags.getDiagnosticLevel(diag::warn_base_initialized) ==
Anders Carlssone0eebb32009-08-27 05:45:01 +00001567 Diagnostic::Ignored &&
Mike Stump11289f42009-09-09 15:08:12 +00001568 Diags.getDiagnosticLevel(diag::warn_field_initialized) ==
Anders Carlssone0eebb32009-08-27 05:45:01 +00001569 Diagnostic::Ignored)
1570 return;
Mike Stump11289f42009-09-09 15:08:12 +00001571
Anders Carlssone0eebb32009-08-27 05:45:01 +00001572 // Also issue warning if order of ctor-initializer list does not match order
1573 // of 1) base class declarations and 2) order of non-static data members.
1574 llvm::SmallVector<const void*, 32> AllBaseOrMembers;
Mike Stump11289f42009-09-09 15:08:12 +00001575
Anders Carlssone0eebb32009-08-27 05:45:01 +00001576 CXXRecordDecl *ClassDecl
1577 = cast<CXXRecordDecl>(Constructor->getDeclContext());
1578 // Push virtual bases before others.
1579 for (CXXRecordDecl::base_class_iterator VBase =
1580 ClassDecl->vbases_begin(),
1581 E = ClassDecl->vbases_end(); VBase != E; ++VBase)
Anders Carlssonbcec05c2009-09-01 06:22:14 +00001582 AllBaseOrMembers.push_back(GetKeyForBase(VBase->getType()));
Mike Stump11289f42009-09-09 15:08:12 +00001583
Anders Carlssone0eebb32009-08-27 05:45:01 +00001584 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
1585 E = ClassDecl->bases_end(); Base != E; ++Base) {
1586 // Virtuals are alread in the virtual base list and are constructed
1587 // first.
1588 if (Base->isVirtual())
1589 continue;
Anders Carlssonbcec05c2009-09-01 06:22:14 +00001590 AllBaseOrMembers.push_back(GetKeyForBase(Base->getType()));
Anders Carlssone0eebb32009-08-27 05:45:01 +00001591 }
Mike Stump11289f42009-09-09 15:08:12 +00001592
Anders Carlssone0eebb32009-08-27 05:45:01 +00001593 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
1594 E = ClassDecl->field_end(); Field != E; ++Field)
1595 AllBaseOrMembers.push_back(GetKeyForTopLevelField(*Field));
Mike Stump11289f42009-09-09 15:08:12 +00001596
Anders Carlssone0eebb32009-08-27 05:45:01 +00001597 int Last = AllBaseOrMembers.size();
1598 int curIndex = 0;
1599 CXXBaseOrMemberInitializer *PrevMember = 0;
1600 for (unsigned i = 0; i < NumMemInits; i++) {
Mike Stump11289f42009-09-09 15:08:12 +00001601 CXXBaseOrMemberInitializer *Member =
Anders Carlssone0eebb32009-08-27 05:45:01 +00001602 static_cast<CXXBaseOrMemberInitializer*>(MemInits[i]);
1603 void *MemberInCtorList = GetKeyForMember(Member, true);
Eli Friedman952c15d2009-07-21 19:28:10 +00001604
Anders Carlssone0eebb32009-08-27 05:45:01 +00001605 for (; curIndex < Last; curIndex++)
1606 if (MemberInCtorList == AllBaseOrMembers[curIndex])
1607 break;
1608 if (curIndex == Last) {
1609 assert(PrevMember && "Member not in member list?!");
1610 // Initializer as specified in ctor-initializer list is out of order.
1611 // Issue a warning diagnostic.
1612 if (PrevMember->isBaseInitializer()) {
1613 // Diagnostics is for an initialized base class.
1614 Type *BaseClass = PrevMember->getBaseClass();
1615 Diag(PrevMember->getSourceLocation(),
Mike Stump11289f42009-09-09 15:08:12 +00001616 diag::warn_base_initialized)
John McCalla1925362009-09-29 23:03:30 +00001617 << QualType(BaseClass, 0);
Anders Carlssone0eebb32009-08-27 05:45:01 +00001618 } else {
1619 FieldDecl *Field = PrevMember->getMember();
1620 Diag(PrevMember->getSourceLocation(),
Mike Stump11289f42009-09-09 15:08:12 +00001621 diag::warn_field_initialized)
Anders Carlssone0eebb32009-08-27 05:45:01 +00001622 << Field->getNameAsString();
Fariborz Jahanian341583c2009-07-09 19:59:47 +00001623 }
Anders Carlssone0eebb32009-08-27 05:45:01 +00001624 // Also the note!
1625 if (FieldDecl *Field = Member->getMember())
Mike Stump11289f42009-09-09 15:08:12 +00001626 Diag(Member->getSourceLocation(),
Anders Carlssone0eebb32009-08-27 05:45:01 +00001627 diag::note_fieldorbase_initialized_here) << 0
1628 << Field->getNameAsString();
1629 else {
1630 Type *BaseClass = Member->getBaseClass();
Mike Stump11289f42009-09-09 15:08:12 +00001631 Diag(Member->getSourceLocation(),
Anders Carlssone0eebb32009-08-27 05:45:01 +00001632 diag::note_fieldorbase_initialized_here) << 1
John McCalla1925362009-09-29 23:03:30 +00001633 << QualType(BaseClass, 0);
Anders Carlssone0eebb32009-08-27 05:45:01 +00001634 }
1635 for (curIndex = 0; curIndex < Last; curIndex++)
Mike Stump11289f42009-09-09 15:08:12 +00001636 if (MemberInCtorList == AllBaseOrMembers[curIndex])
Anders Carlssone0eebb32009-08-27 05:45:01 +00001637 break;
Fariborz Jahanian341583c2009-07-09 19:59:47 +00001638 }
Anders Carlssone0eebb32009-08-27 05:45:01 +00001639 PrevMember = Member;
Fariborz Jahanian341583c2009-07-09 19:59:47 +00001640 }
Anders Carlsson75fdaa42009-03-25 02:58:17 +00001641}
1642
Fariborz Jahanian37d06562009-09-03 23:18:17 +00001643void
Anders Carlssondee9a302009-11-17 04:44:12 +00001644Sema::MarkBaseAndMemberDestructorsReferenced(CXXDestructorDecl *Destructor) {
1645 // Ignore dependent destructors.
1646 if (Destructor->isDependentContext())
1647 return;
1648
1649 CXXRecordDecl *ClassDecl = Destructor->getParent();
Mike Stump11289f42009-09-09 15:08:12 +00001650
Anders Carlssondee9a302009-11-17 04:44:12 +00001651 // Non-static data members.
1652 for (CXXRecordDecl::field_iterator I = ClassDecl->field_begin(),
1653 E = ClassDecl->field_end(); I != E; ++I) {
1654 FieldDecl *Field = *I;
1655
1656 QualType FieldType = Context.getBaseElementType(Field->getType());
1657
1658 const RecordType* RT = FieldType->getAs<RecordType>();
1659 if (!RT)
1660 continue;
1661
1662 CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl());
1663 if (FieldClassDecl->hasTrivialDestructor())
1664 continue;
1665
1666 const CXXDestructorDecl *Dtor = FieldClassDecl->getDestructor(Context);
1667 MarkDeclarationReferenced(Destructor->getLocation(),
1668 const_cast<CXXDestructorDecl*>(Dtor));
1669 }
1670
1671 // Bases.
1672 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
1673 E = ClassDecl->bases_end(); Base != E; ++Base) {
1674 // Ignore virtual bases.
1675 if (Base->isVirtual())
1676 continue;
1677
1678 // Ignore trivial destructors.
1679 CXXRecordDecl *BaseClassDecl
1680 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
1681 if (BaseClassDecl->hasTrivialDestructor())
1682 continue;
1683
1684 const CXXDestructorDecl *Dtor = BaseClassDecl->getDestructor(Context);
1685 MarkDeclarationReferenced(Destructor->getLocation(),
1686 const_cast<CXXDestructorDecl*>(Dtor));
1687 }
1688
1689 // Virtual bases.
Fariborz Jahanian37d06562009-09-03 23:18:17 +00001690 for (CXXRecordDecl::base_class_iterator VBase = ClassDecl->vbases_begin(),
1691 E = ClassDecl->vbases_end(); VBase != E; ++VBase) {
Anders Carlssondee9a302009-11-17 04:44:12 +00001692 // Ignore trivial destructors.
Fariborz Jahanian37d06562009-09-03 23:18:17 +00001693 CXXRecordDecl *BaseClassDecl
1694 = cast<CXXRecordDecl>(VBase->getType()->getAs<RecordType>()->getDecl());
1695 if (BaseClassDecl->hasTrivialDestructor())
1696 continue;
Anders Carlssondee9a302009-11-17 04:44:12 +00001697
1698 const CXXDestructorDecl *Dtor = BaseClassDecl->getDestructor(Context);
1699 MarkDeclarationReferenced(Destructor->getLocation(),
1700 const_cast<CXXDestructorDecl*>(Dtor));
Fariborz Jahanian37d06562009-09-03 23:18:17 +00001701 }
1702}
1703
Fariborz Jahanianaee31ac2009-07-21 22:36:06 +00001704void Sema::ActOnDefaultCtorInitializers(DeclPtrTy CDtorDecl) {
Fariborz Jahanian16094c22009-07-15 22:34:08 +00001705 if (!CDtorDecl)
Fariborz Jahanian49c81792009-07-14 18:24:21 +00001706 return;
Mike Stump11289f42009-09-09 15:08:12 +00001707
Douglas Gregorc8c277a2009-08-24 11:57:43 +00001708 AdjustDeclIfTemplate(CDtorDecl);
Mike Stump11289f42009-09-09 15:08:12 +00001709
1710 if (CXXConstructorDecl *Constructor
Fariborz Jahanian16094c22009-07-15 22:34:08 +00001711 = dyn_cast<CXXConstructorDecl>(CDtorDecl.getAs<Decl>()))
Eli Friedmand7686ef2009-11-09 01:05:47 +00001712 SetBaseOrMemberInitializers(Constructor, 0, 0, false);
Fariborz Jahanian49c81792009-07-14 18:24:21 +00001713}
1714
Anders Carlsson7cbd8fb2009-03-22 01:52:17 +00001715namespace {
1716 /// PureVirtualMethodCollector - traverses a class and its superclasses
1717 /// and determines if it has any pure virtual methods.
1718 class VISIBILITY_HIDDEN PureVirtualMethodCollector {
1719 ASTContext &Context;
1720
Sebastian Redlb7d64912009-03-22 21:28:55 +00001721 public:
Anders Carlsson7cbd8fb2009-03-22 01:52:17 +00001722 typedef llvm::SmallVector<const CXXMethodDecl*, 8> MethodList;
Sebastian Redlb7d64912009-03-22 21:28:55 +00001723
1724 private:
Anders Carlsson7cbd8fb2009-03-22 01:52:17 +00001725 MethodList Methods;
Mike Stump11289f42009-09-09 15:08:12 +00001726
Anders Carlsson7cbd8fb2009-03-22 01:52:17 +00001727 void Collect(const CXXRecordDecl* RD, MethodList& Methods);
Mike Stump11289f42009-09-09 15:08:12 +00001728
Anders Carlsson7cbd8fb2009-03-22 01:52:17 +00001729 public:
Mike Stump11289f42009-09-09 15:08:12 +00001730 PureVirtualMethodCollector(ASTContext &Ctx, const CXXRecordDecl* RD)
Anders Carlsson7cbd8fb2009-03-22 01:52:17 +00001731 : Context(Ctx) {
Mike Stump11289f42009-09-09 15:08:12 +00001732
Anders Carlsson7cbd8fb2009-03-22 01:52:17 +00001733 MethodList List;
1734 Collect(RD, List);
Mike Stump11289f42009-09-09 15:08:12 +00001735
Anders Carlsson7cbd8fb2009-03-22 01:52:17 +00001736 // Copy the temporary list to methods, and make sure to ignore any
1737 // null entries.
1738 for (size_t i = 0, e = List.size(); i != e; ++i) {
1739 if (List[i])
1740 Methods.push_back(List[i]);
Mike Stump11289f42009-09-09 15:08:12 +00001741 }
Anders Carlsson7cbd8fb2009-03-22 01:52:17 +00001742 }
Mike Stump11289f42009-09-09 15:08:12 +00001743
Anders Carlsson576cc6f2009-03-22 20:18:17 +00001744 bool empty() const { return Methods.empty(); }
Mike Stump11289f42009-09-09 15:08:12 +00001745
Anders Carlsson576cc6f2009-03-22 20:18:17 +00001746 MethodList::const_iterator methods_begin() { return Methods.begin(); }
1747 MethodList::const_iterator methods_end() { return Methods.end(); }
Anders Carlsson7cbd8fb2009-03-22 01:52:17 +00001748 };
Mike Stump11289f42009-09-09 15:08:12 +00001749
1750 void PureVirtualMethodCollector::Collect(const CXXRecordDecl* RD,
Anders Carlsson7cbd8fb2009-03-22 01:52:17 +00001751 MethodList& Methods) {
1752 // First, collect the pure virtual methods for the base classes.
1753 for (CXXRecordDecl::base_class_const_iterator Base = RD->bases_begin(),
1754 BaseEnd = RD->bases_end(); Base != BaseEnd; ++Base) {
Ted Kremenekc23c7e62009-07-29 21:53:49 +00001755 if (const RecordType *RT = Base->getType()->getAs<RecordType>()) {
Chris Lattner85e2e142009-03-29 05:01:10 +00001756 const CXXRecordDecl *BaseDecl = cast<CXXRecordDecl>(RT->getDecl());
Anders Carlsson7cbd8fb2009-03-22 01:52:17 +00001757 if (BaseDecl && BaseDecl->isAbstract())
1758 Collect(BaseDecl, Methods);
1759 }
1760 }
Mike Stump11289f42009-09-09 15:08:12 +00001761
Anders Carlsson7cbd8fb2009-03-22 01:52:17 +00001762 // Next, zero out any pure virtual methods that this class overrides.
Anders Carlsson3c012712009-05-17 00:00:05 +00001763 typedef llvm::SmallPtrSet<const CXXMethodDecl*, 4> MethodSetTy;
Mike Stump11289f42009-09-09 15:08:12 +00001764
Anders Carlsson3c012712009-05-17 00:00:05 +00001765 MethodSetTy OverriddenMethods;
1766 size_t MethodsSize = Methods.size();
1767
Mike Stump11289f42009-09-09 15:08:12 +00001768 for (RecordDecl::decl_iterator i = RD->decls_begin(), e = RD->decls_end();
Anders Carlsson3c012712009-05-17 00:00:05 +00001769 i != e; ++i) {
1770 // Traverse the record, looking for methods.
1771 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(*i)) {
Sebastian Redl86be8542009-07-07 20:29:57 +00001772 // If the method is pure virtual, add it to the methods vector.
Anders Carlsson700179432009-10-18 19:34:08 +00001773 if (MD->isPure())
Anders Carlsson3c012712009-05-17 00:00:05 +00001774 Methods.push_back(MD);
Mike Stump11289f42009-09-09 15:08:12 +00001775
Anders Carlsson700179432009-10-18 19:34:08 +00001776 // Record all the overridden methods in our set.
Anders Carlsson3c012712009-05-17 00:00:05 +00001777 for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(),
1778 E = MD->end_overridden_methods(); I != E; ++I) {
1779 // Keep track of the overridden methods.
1780 OverriddenMethods.insert(*I);
Anders Carlsson7cbd8fb2009-03-22 01:52:17 +00001781 }
1782 }
1783 }
Mike Stump11289f42009-09-09 15:08:12 +00001784
1785 // Now go through the methods and zero out all the ones we know are
Anders Carlsson3c012712009-05-17 00:00:05 +00001786 // overridden.
1787 for (size_t i = 0, e = MethodsSize; i != e; ++i) {
1788 if (OverriddenMethods.count(Methods[i]))
1789 Methods[i] = 0;
Anders Carlsson7cbd8fb2009-03-22 01:52:17 +00001790 }
Mike Stump11289f42009-09-09 15:08:12 +00001791
Anders Carlsson7cbd8fb2009-03-22 01:52:17 +00001792 }
1793}
Douglas Gregore8381c02008-11-05 04:29:56 +00001794
Anders Carlssoneabf7702009-08-27 00:13:57 +00001795
Mike Stump11289f42009-09-09 15:08:12 +00001796bool Sema::RequireNonAbstractType(SourceLocation Loc, QualType T,
Anders Carlssonb57738b2009-03-24 17:23:42 +00001797 unsigned DiagID, AbstractDiagSelID SelID,
1798 const CXXRecordDecl *CurrentRD) {
Anders Carlssoneabf7702009-08-27 00:13:57 +00001799 if (SelID == -1)
1800 return RequireNonAbstractType(Loc, T,
1801 PDiag(DiagID), CurrentRD);
1802 else
1803 return RequireNonAbstractType(Loc, T,
1804 PDiag(DiagID) << SelID, CurrentRD);
Mike Stump11289f42009-09-09 15:08:12 +00001805}
1806
Anders Carlssoneabf7702009-08-27 00:13:57 +00001807bool Sema::RequireNonAbstractType(SourceLocation Loc, QualType T,
1808 const PartialDiagnostic &PD,
1809 const CXXRecordDecl *CurrentRD) {
Anders Carlsson576cc6f2009-03-22 20:18:17 +00001810 if (!getLangOptions().CPlusPlus)
1811 return false;
Mike Stump11289f42009-09-09 15:08:12 +00001812
Anders Carlssoneb0c5322009-03-23 19:10:31 +00001813 if (const ArrayType *AT = Context.getAsArrayType(T))
Anders Carlssoneabf7702009-08-27 00:13:57 +00001814 return RequireNonAbstractType(Loc, AT->getElementType(), PD,
Anders Carlssonb57738b2009-03-24 17:23:42 +00001815 CurrentRD);
Mike Stump11289f42009-09-09 15:08:12 +00001816
Ted Kremenekc23c7e62009-07-29 21:53:49 +00001817 if (const PointerType *PT = T->getAs<PointerType>()) {
Anders Carlsson8f0d2182009-03-24 01:46:45 +00001818 // Find the innermost pointer type.
Ted Kremenekc23c7e62009-07-29 21:53:49 +00001819 while (const PointerType *T = PT->getPointeeType()->getAs<PointerType>())
Anders Carlsson8f0d2182009-03-24 01:46:45 +00001820 PT = T;
Mike Stump11289f42009-09-09 15:08:12 +00001821
Anders Carlsson8f0d2182009-03-24 01:46:45 +00001822 if (const ArrayType *AT = Context.getAsArrayType(PT->getPointeeType()))
Anders Carlssoneabf7702009-08-27 00:13:57 +00001823 return RequireNonAbstractType(Loc, AT->getElementType(), PD, CurrentRD);
Anders Carlsson8f0d2182009-03-24 01:46:45 +00001824 }
Mike Stump11289f42009-09-09 15:08:12 +00001825
Ted Kremenekc23c7e62009-07-29 21:53:49 +00001826 const RecordType *RT = T->getAs<RecordType>();
Anders Carlsson576cc6f2009-03-22 20:18:17 +00001827 if (!RT)
1828 return false;
Mike Stump11289f42009-09-09 15:08:12 +00001829
Anders Carlsson576cc6f2009-03-22 20:18:17 +00001830 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl());
1831 if (!RD)
1832 return false;
1833
Anders Carlssonb57738b2009-03-24 17:23:42 +00001834 if (CurrentRD && CurrentRD != RD)
1835 return false;
Mike Stump11289f42009-09-09 15:08:12 +00001836
Anders Carlsson576cc6f2009-03-22 20:18:17 +00001837 if (!RD->isAbstract())
1838 return false;
Mike Stump11289f42009-09-09 15:08:12 +00001839
Anders Carlssoneabf7702009-08-27 00:13:57 +00001840 Diag(Loc, PD) << RD->getDeclName();
Mike Stump11289f42009-09-09 15:08:12 +00001841
Anders Carlsson576cc6f2009-03-22 20:18:17 +00001842 // Check if we've already emitted the list of pure virtual functions for this
1843 // class.
1844 if (PureVirtualClassDiagSet && PureVirtualClassDiagSet->count(RD))
1845 return true;
Mike Stump11289f42009-09-09 15:08:12 +00001846
Anders Carlsson576cc6f2009-03-22 20:18:17 +00001847 PureVirtualMethodCollector Collector(Context, RD);
Mike Stump11289f42009-09-09 15:08:12 +00001848
1849 for (PureVirtualMethodCollector::MethodList::const_iterator I =
Anders Carlsson576cc6f2009-03-22 20:18:17 +00001850 Collector.methods_begin(), E = Collector.methods_end(); I != E; ++I) {
1851 const CXXMethodDecl *MD = *I;
Mike Stump11289f42009-09-09 15:08:12 +00001852
1853 Diag(MD->getLocation(), diag::note_pure_virtual_function) <<
Anders Carlsson576cc6f2009-03-22 20:18:17 +00001854 MD->getDeclName();
1855 }
1856
1857 if (!PureVirtualClassDiagSet)
1858 PureVirtualClassDiagSet.reset(new RecordDeclSetTy);
1859 PureVirtualClassDiagSet->insert(RD);
Mike Stump11289f42009-09-09 15:08:12 +00001860
Anders Carlsson576cc6f2009-03-22 20:18:17 +00001861 return true;
1862}
1863
Anders Carlssonb5a27b42009-03-24 01:19:16 +00001864namespace {
Mike Stump11289f42009-09-09 15:08:12 +00001865 class VISIBILITY_HIDDEN AbstractClassUsageDiagnoser
Anders Carlssonb5a27b42009-03-24 01:19:16 +00001866 : public DeclVisitor<AbstractClassUsageDiagnoser, bool> {
1867 Sema &SemaRef;
1868 CXXRecordDecl *AbstractClass;
Mike Stump11289f42009-09-09 15:08:12 +00001869
Anders Carlssonb57738b2009-03-24 17:23:42 +00001870 bool VisitDeclContext(const DeclContext *DC) {
Anders Carlssonb5a27b42009-03-24 01:19:16 +00001871 bool Invalid = false;
1872
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00001873 for (CXXRecordDecl::decl_iterator I = DC->decls_begin(),
1874 E = DC->decls_end(); I != E; ++I)
Anders Carlssonb5a27b42009-03-24 01:19:16 +00001875 Invalid |= Visit(*I);
Anders Carlssonb57738b2009-03-24 17:23:42 +00001876
Anders Carlssonb5a27b42009-03-24 01:19:16 +00001877 return Invalid;
1878 }
Mike Stump11289f42009-09-09 15:08:12 +00001879
Anders Carlssonb57738b2009-03-24 17:23:42 +00001880 public:
1881 AbstractClassUsageDiagnoser(Sema& SemaRef, CXXRecordDecl *ac)
1882 : SemaRef(SemaRef), AbstractClass(ac) {
1883 Visit(SemaRef.Context.getTranslationUnitDecl());
1884 }
Anders Carlssonb5a27b42009-03-24 01:19:16 +00001885
Anders Carlssonb57738b2009-03-24 17:23:42 +00001886 bool VisitFunctionDecl(const FunctionDecl *FD) {
1887 if (FD->isThisDeclarationADefinition()) {
1888 // No need to do the check if we're in a definition, because it requires
1889 // that the return/param types are complete.
Mike Stump11289f42009-09-09 15:08:12 +00001890 // because that requires
Anders Carlssonb57738b2009-03-24 17:23:42 +00001891 return VisitDeclContext(FD);
1892 }
Mike Stump11289f42009-09-09 15:08:12 +00001893
Anders Carlssonb57738b2009-03-24 17:23:42 +00001894 // Check the return type.
John McCall9dd450b2009-09-21 23:43:11 +00001895 QualType RTy = FD->getType()->getAs<FunctionType>()->getResultType();
Mike Stump11289f42009-09-09 15:08:12 +00001896 bool Invalid =
Anders Carlssonb57738b2009-03-24 17:23:42 +00001897 SemaRef.RequireNonAbstractType(FD->getLocation(), RTy,
1898 diag::err_abstract_type_in_decl,
1899 Sema::AbstractReturnType,
1900 AbstractClass);
1901
Mike Stump11289f42009-09-09 15:08:12 +00001902 for (FunctionDecl::param_const_iterator I = FD->param_begin(),
Anders Carlssonb57738b2009-03-24 17:23:42 +00001903 E = FD->param_end(); I != E; ++I) {
Anders Carlssonb5a27b42009-03-24 01:19:16 +00001904 const ParmVarDecl *VD = *I;
Mike Stump11289f42009-09-09 15:08:12 +00001905 Invalid |=
Anders Carlssonb5a27b42009-03-24 01:19:16 +00001906 SemaRef.RequireNonAbstractType(VD->getLocation(),
Mike Stump11289f42009-09-09 15:08:12 +00001907 VD->getOriginalType(),
1908 diag::err_abstract_type_in_decl,
Anders Carlssonb57738b2009-03-24 17:23:42 +00001909 Sema::AbstractParamType,
1910 AbstractClass);
Anders Carlssonb5a27b42009-03-24 01:19:16 +00001911 }
1912
1913 return Invalid;
1914 }
Mike Stump11289f42009-09-09 15:08:12 +00001915
Anders Carlssonb57738b2009-03-24 17:23:42 +00001916 bool VisitDecl(const Decl* D) {
1917 if (const DeclContext *DC = dyn_cast<DeclContext>(D))
1918 return VisitDeclContext(DC);
Mike Stump11289f42009-09-09 15:08:12 +00001919
Anders Carlssonb57738b2009-03-24 17:23:42 +00001920 return false;
1921 }
Anders Carlssonb5a27b42009-03-24 01:19:16 +00001922 };
1923}
1924
Argyrios Kyrtzidised983422008-07-01 10:37:29 +00001925void Sema::ActOnFinishCXXMemberSpecification(Scope* S, SourceLocation RLoc,
Chris Lattner83f095c2009-03-28 19:18:32 +00001926 DeclPtrTy TagDecl,
Argyrios Kyrtzidised983422008-07-01 10:37:29 +00001927 SourceLocation LBrac,
1928 SourceLocation RBrac) {
Douglas Gregor71a57182009-06-22 23:20:33 +00001929 if (!TagDecl)
1930 return;
Mike Stump11289f42009-09-09 15:08:12 +00001931
Douglas Gregorc9f9b862009-05-11 19:58:34 +00001932 AdjustDeclIfTemplate(TagDecl);
Argyrios Kyrtzidised983422008-07-01 10:37:29 +00001933 ActOnFields(S, RLoc, TagDecl,
Chris Lattner83f095c2009-03-28 19:18:32 +00001934 (DeclPtrTy*)FieldCollector->getCurFields(),
Daniel Dunbar15619c72008-10-03 02:03:53 +00001935 FieldCollector->getCurNumFields(), LBrac, RBrac, 0);
Douglas Gregor463421d2009-03-03 04:44:36 +00001936
Chris Lattner83f095c2009-03-28 19:18:32 +00001937 CXXRecordDecl *RD = cast<CXXRecordDecl>(TagDecl.getAs<Decl>());
Anders Carlsson7cbd8fb2009-03-22 01:52:17 +00001938 if (!RD->isAbstract()) {
1939 // Collect all the pure virtual methods and see if this is an abstract
1940 // class after all.
1941 PureVirtualMethodCollector Collector(Context, RD);
Mike Stump11289f42009-09-09 15:08:12 +00001942 if (!Collector.empty())
Anders Carlsson7cbd8fb2009-03-22 01:52:17 +00001943 RD->setAbstract(true);
1944 }
Mike Stump11289f42009-09-09 15:08:12 +00001945
1946 if (RD->isAbstract())
Douglas Gregor120f6a62009-11-17 06:14:37 +00001947 (void)AbstractClassUsageDiagnoser(*this, RD);
Mike Stump11289f42009-09-09 15:08:12 +00001948
Douglas Gregor3c74d412009-10-14 20:14:33 +00001949 if (!RD->isDependentType() && !RD->isInvalidDecl())
Anders Carlsson7cbd8fb2009-03-22 01:52:17 +00001950 AddImplicitlyDeclaredMembersToClass(RD);
Argyrios Kyrtzidised983422008-07-01 10:37:29 +00001951}
1952
Douglas Gregor05379422008-11-03 17:51:48 +00001953/// AddImplicitlyDeclaredMembersToClass - Adds any implicitly-declared
1954/// special functions, such as the default constructor, copy
1955/// constructor, or destructor, to the given C++ class (C++
1956/// [special]p1). This routine can only be executed just before the
1957/// definition of the class is complete.
1958void Sema::AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl) {
Mike Stump11289f42009-09-09 15:08:12 +00001959 CanQualType ClassType
Douglas Gregor2211d342009-08-05 05:36:45 +00001960 = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
Douglas Gregor77324f32008-11-17 14:58:09 +00001961
Sebastian Redl5068f77ac2009-05-27 22:11:52 +00001962 // FIXME: Implicit declarations have exception specifications, which are
1963 // the union of the specifications of the implicitly called functions.
1964
Douglas Gregor05379422008-11-03 17:51:48 +00001965 if (!ClassDecl->hasUserDeclaredConstructor()) {
1966 // C++ [class.ctor]p5:
1967 // A default constructor for a class X is a constructor of class X
1968 // that can be called without an argument. If there is no
1969 // user-declared constructor for class X, a default constructor is
1970 // implicitly declared. An implicitly-declared default constructor
1971 // is an inline public member of its class.
Mike Stump11289f42009-09-09 15:08:12 +00001972 DeclarationName Name
Douglas Gregor77324f32008-11-17 14:58:09 +00001973 = Context.DeclarationNames.getCXXConstructorName(ClassType);
Mike Stump11289f42009-09-09 15:08:12 +00001974 CXXConstructorDecl *DefaultCon =
Douglas Gregor05379422008-11-03 17:51:48 +00001975 CXXConstructorDecl::Create(Context, ClassDecl,
Douglas Gregor77324f32008-11-17 14:58:09 +00001976 ClassDecl->getLocation(), Name,
Douglas Gregor05379422008-11-03 17:51:48 +00001977 Context.getFunctionType(Context.VoidTy,
1978 0, 0, false, 0),
Argyrios Kyrtzidis60ed5602009-08-19 01:27:57 +00001979 /*DInfo=*/0,
Douglas Gregor05379422008-11-03 17:51:48 +00001980 /*isExplicit=*/false,
1981 /*isInline=*/true,
1982 /*isImplicitlyDeclared=*/true);
1983 DefaultCon->setAccess(AS_public);
Douglas Gregorf4d33272009-01-07 19:46:03 +00001984 DefaultCon->setImplicit();
Douglas Gregor8a273912009-07-22 18:25:24 +00001985 DefaultCon->setTrivial(ClassDecl->hasTrivialConstructor());
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00001986 ClassDecl->addDecl(DefaultCon);
Douglas Gregor05379422008-11-03 17:51:48 +00001987 }
1988
1989 if (!ClassDecl->hasUserDeclaredCopyConstructor()) {
1990 // C++ [class.copy]p4:
1991 // If the class definition does not explicitly declare a copy
1992 // constructor, one is declared implicitly.
1993
1994 // C++ [class.copy]p5:
1995 // The implicitly-declared copy constructor for a class X will
1996 // have the form
1997 //
1998 // X::X(const X&)
1999 //
2000 // if
2001 bool HasConstCopyConstructor = true;
2002
2003 // -- each direct or virtual base class B of X has a copy
2004 // constructor whose first parameter is of type const B& or
2005 // const volatile B&, and
2006 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin();
2007 HasConstCopyConstructor && Base != ClassDecl->bases_end(); ++Base) {
2008 const CXXRecordDecl *BaseClassDecl
Ted Kremenekc23c7e62009-07-29 21:53:49 +00002009 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Mike Stump11289f42009-09-09 15:08:12 +00002010 HasConstCopyConstructor
Douglas Gregor05379422008-11-03 17:51:48 +00002011 = BaseClassDecl->hasConstCopyConstructor(Context);
2012 }
2013
2014 // -- for all the nonstatic data members of X that are of a
2015 // class type M (or array thereof), each such class type
2016 // has a copy constructor whose first parameter is of type
2017 // const M& or const volatile M&.
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00002018 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin();
2019 HasConstCopyConstructor && Field != ClassDecl->field_end();
Douglas Gregorbcced4e2009-04-09 21:40:53 +00002020 ++Field) {
Douglas Gregor05379422008-11-03 17:51:48 +00002021 QualType FieldType = (*Field)->getType();
2022 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
2023 FieldType = Array->getElementType();
Ted Kremenekc23c7e62009-07-29 21:53:49 +00002024 if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
Mike Stump11289f42009-09-09 15:08:12 +00002025 const CXXRecordDecl *FieldClassDecl
Douglas Gregor05379422008-11-03 17:51:48 +00002026 = cast<CXXRecordDecl>(FieldClassType->getDecl());
Mike Stump11289f42009-09-09 15:08:12 +00002027 HasConstCopyConstructor
Douglas Gregor05379422008-11-03 17:51:48 +00002028 = FieldClassDecl->hasConstCopyConstructor(Context);
2029 }
2030 }
2031
Sebastian Redlbaad4e72009-01-05 20:52:13 +00002032 // Otherwise, the implicitly declared copy constructor will have
2033 // the form
Douglas Gregor05379422008-11-03 17:51:48 +00002034 //
2035 // X::X(X&)
Sebastian Redlbaad4e72009-01-05 20:52:13 +00002036 QualType ArgType = ClassType;
Douglas Gregor05379422008-11-03 17:51:48 +00002037 if (HasConstCopyConstructor)
2038 ArgType = ArgType.withConst();
Sebastian Redl0f8b23f2009-03-16 23:22:08 +00002039 ArgType = Context.getLValueReferenceType(ArgType);
Douglas Gregor05379422008-11-03 17:51:48 +00002040
Sebastian Redlbaad4e72009-01-05 20:52:13 +00002041 // An implicitly-declared copy constructor is an inline public
2042 // member of its class.
Mike Stump11289f42009-09-09 15:08:12 +00002043 DeclarationName Name
Douglas Gregor77324f32008-11-17 14:58:09 +00002044 = Context.DeclarationNames.getCXXConstructorName(ClassType);
Douglas Gregor05379422008-11-03 17:51:48 +00002045 CXXConstructorDecl *CopyConstructor
2046 = CXXConstructorDecl::Create(Context, ClassDecl,
Douglas Gregor77324f32008-11-17 14:58:09 +00002047 ClassDecl->getLocation(), Name,
Douglas Gregor05379422008-11-03 17:51:48 +00002048 Context.getFunctionType(Context.VoidTy,
2049 &ArgType, 1,
2050 false, 0),
Argyrios Kyrtzidis60ed5602009-08-19 01:27:57 +00002051 /*DInfo=*/0,
Douglas Gregor05379422008-11-03 17:51:48 +00002052 /*isExplicit=*/false,
2053 /*isInline=*/true,
2054 /*isImplicitlyDeclared=*/true);
2055 CopyConstructor->setAccess(AS_public);
Douglas Gregorf4d33272009-01-07 19:46:03 +00002056 CopyConstructor->setImplicit();
Douglas Gregor8a273912009-07-22 18:25:24 +00002057 CopyConstructor->setTrivial(ClassDecl->hasTrivialCopyConstructor());
Douglas Gregor05379422008-11-03 17:51:48 +00002058
2059 // Add the parameter to the constructor.
2060 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyConstructor,
2061 ClassDecl->getLocation(),
2062 /*IdentifierInfo=*/0,
Argyrios Kyrtzidis60ed5602009-08-19 01:27:57 +00002063 ArgType, /*DInfo=*/0,
2064 VarDecl::None, 0);
Ted Kremenek4ba36fc2009-01-14 00:42:25 +00002065 CopyConstructor->setParams(Context, &FromParam, 1);
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00002066 ClassDecl->addDecl(CopyConstructor);
Douglas Gregor05379422008-11-03 17:51:48 +00002067 }
2068
Sebastian Redlbaad4e72009-01-05 20:52:13 +00002069 if (!ClassDecl->hasUserDeclaredCopyAssignment()) {
2070 // Note: The following rules are largely analoguous to the copy
2071 // constructor rules. Note that virtual bases are not taken into account
2072 // for determining the argument type of the operator. Note also that
2073 // operators taking an object instead of a reference are allowed.
2074 //
2075 // C++ [class.copy]p10:
2076 // If the class definition does not explicitly declare a copy
2077 // assignment operator, one is declared implicitly.
2078 // The implicitly-defined copy assignment operator for a class X
2079 // will have the form
2080 //
2081 // X& X::operator=(const X&)
2082 //
2083 // if
2084 bool HasConstCopyAssignment = true;
2085
2086 // -- each direct base class B of X has a copy assignment operator
2087 // whose parameter is of type const B&, const volatile B& or B,
2088 // and
2089 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin();
2090 HasConstCopyAssignment && Base != ClassDecl->bases_end(); ++Base) {
Sebastian Redl1054fae2009-10-25 17:03:50 +00002091 assert(!Base->getType()->isDependentType() &&
2092 "Cannot generate implicit members for class with dependent bases.");
Sebastian Redlbaad4e72009-01-05 20:52:13 +00002093 const CXXRecordDecl *BaseClassDecl
Ted Kremenekc23c7e62009-07-29 21:53:49 +00002094 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Fariborz Jahanianbbd5e8c2009-08-12 23:34:46 +00002095 const CXXMethodDecl *MD = 0;
Mike Stump11289f42009-09-09 15:08:12 +00002096 HasConstCopyAssignment = BaseClassDecl->hasConstCopyAssignment(Context,
Fariborz Jahanianbbd5e8c2009-08-12 23:34:46 +00002097 MD);
Sebastian Redlbaad4e72009-01-05 20:52:13 +00002098 }
2099
2100 // -- for all the nonstatic data members of X that are of a class
2101 // type M (or array thereof), each such class type has a copy
2102 // assignment operator whose parameter is of type const M&,
2103 // const volatile M& or M.
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00002104 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin();
2105 HasConstCopyAssignment && Field != ClassDecl->field_end();
Douglas Gregorbcced4e2009-04-09 21:40:53 +00002106 ++Field) {
Sebastian Redlbaad4e72009-01-05 20:52:13 +00002107 QualType FieldType = (*Field)->getType();
2108 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
2109 FieldType = Array->getElementType();
Ted Kremenekc23c7e62009-07-29 21:53:49 +00002110 if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
Sebastian Redlbaad4e72009-01-05 20:52:13 +00002111 const CXXRecordDecl *FieldClassDecl
2112 = cast<CXXRecordDecl>(FieldClassType->getDecl());
Fariborz Jahanianbbd5e8c2009-08-12 23:34:46 +00002113 const CXXMethodDecl *MD = 0;
Sebastian Redlbaad4e72009-01-05 20:52:13 +00002114 HasConstCopyAssignment
Fariborz Jahanianbbd5e8c2009-08-12 23:34:46 +00002115 = FieldClassDecl->hasConstCopyAssignment(Context, MD);
Sebastian Redlbaad4e72009-01-05 20:52:13 +00002116 }
2117 }
2118
2119 // Otherwise, the implicitly declared copy assignment operator will
2120 // have the form
2121 //
2122 // X& X::operator=(X&)
2123 QualType ArgType = ClassType;
Sebastian Redl0f8b23f2009-03-16 23:22:08 +00002124 QualType RetType = Context.getLValueReferenceType(ArgType);
Sebastian Redlbaad4e72009-01-05 20:52:13 +00002125 if (HasConstCopyAssignment)
2126 ArgType = ArgType.withConst();
Sebastian Redl0f8b23f2009-03-16 23:22:08 +00002127 ArgType = Context.getLValueReferenceType(ArgType);
Sebastian Redlbaad4e72009-01-05 20:52:13 +00002128
2129 // An implicitly-declared copy assignment operator is an inline public
2130 // member of its class.
2131 DeclarationName Name =
2132 Context.DeclarationNames.getCXXOperatorName(OO_Equal);
2133 CXXMethodDecl *CopyAssignment =
2134 CXXMethodDecl::Create(Context, ClassDecl, ClassDecl->getLocation(), Name,
2135 Context.getFunctionType(RetType, &ArgType, 1,
2136 false, 0),
Argyrios Kyrtzidis60ed5602009-08-19 01:27:57 +00002137 /*DInfo=*/0, /*isStatic=*/false, /*isInline=*/true);
Sebastian Redlbaad4e72009-01-05 20:52:13 +00002138 CopyAssignment->setAccess(AS_public);
Douglas Gregorf4d33272009-01-07 19:46:03 +00002139 CopyAssignment->setImplicit();
Douglas Gregor8a273912009-07-22 18:25:24 +00002140 CopyAssignment->setTrivial(ClassDecl->hasTrivialCopyAssignment());
Fariborz Jahaniande7d4c22009-08-12 21:14:35 +00002141 CopyAssignment->setCopyAssignment(true);
Sebastian Redlbaad4e72009-01-05 20:52:13 +00002142
2143 // Add the parameter to the operator.
2144 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyAssignment,
2145 ClassDecl->getLocation(),
2146 /*IdentifierInfo=*/0,
Argyrios Kyrtzidis60ed5602009-08-19 01:27:57 +00002147 ArgType, /*DInfo=*/0,
2148 VarDecl::None, 0);
Ted Kremenek4ba36fc2009-01-14 00:42:25 +00002149 CopyAssignment->setParams(Context, &FromParam, 1);
Sebastian Redlbaad4e72009-01-05 20:52:13 +00002150
2151 // Don't call addedAssignmentOperator. There is no way to distinguish an
2152 // implicit from an explicit assignment operator.
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00002153 ClassDecl->addDecl(CopyAssignment);
Sebastian Redlbaad4e72009-01-05 20:52:13 +00002154 }
2155
Douglas Gregor1349b452008-12-15 21:24:18 +00002156 if (!ClassDecl->hasUserDeclaredDestructor()) {
Douglas Gregor831c93f2008-11-05 20:51:48 +00002157 // C++ [class.dtor]p2:
2158 // If a class has no user-declared destructor, a destructor is
2159 // declared implicitly. An implicitly-declared destructor is an
2160 // inline public member of its class.
Mike Stump11289f42009-09-09 15:08:12 +00002161 DeclarationName Name
Douglas Gregor77324f32008-11-17 14:58:09 +00002162 = Context.DeclarationNames.getCXXDestructorName(ClassType);
Mike Stump11289f42009-09-09 15:08:12 +00002163 CXXDestructorDecl *Destructor
Douglas Gregor831c93f2008-11-05 20:51:48 +00002164 = CXXDestructorDecl::Create(Context, ClassDecl,
Douglas Gregor77324f32008-11-17 14:58:09 +00002165 ClassDecl->getLocation(), Name,
Douglas Gregor831c93f2008-11-05 20:51:48 +00002166 Context.getFunctionType(Context.VoidTy,
2167 0, 0, false, 0),
2168 /*isInline=*/true,
2169 /*isImplicitlyDeclared=*/true);
2170 Destructor->setAccess(AS_public);
Douglas Gregorf4d33272009-01-07 19:46:03 +00002171 Destructor->setImplicit();
Douglas Gregor8a273912009-07-22 18:25:24 +00002172 Destructor->setTrivial(ClassDecl->hasTrivialDestructor());
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00002173 ClassDecl->addDecl(Destructor);
Douglas Gregor831c93f2008-11-05 20:51:48 +00002174 }
Douglas Gregor05379422008-11-03 17:51:48 +00002175}
2176
Douglas Gregore44a2ad2009-05-27 23:11:45 +00002177void Sema::ActOnReenterTemplateScope(Scope *S, DeclPtrTy TemplateD) {
Douglas Gregore61ef622009-09-10 00:12:48 +00002178 Decl *D = TemplateD.getAs<Decl>();
2179 if (!D)
2180 return;
2181
2182 TemplateParameterList *Params = 0;
2183 if (TemplateDecl *Template = dyn_cast<TemplateDecl>(D))
2184 Params = Template->getTemplateParameters();
2185 else if (ClassTemplatePartialSpecializationDecl *PartialSpec
2186 = dyn_cast<ClassTemplatePartialSpecializationDecl>(D))
2187 Params = PartialSpec->getTemplateParameters();
2188 else
Douglas Gregore44a2ad2009-05-27 23:11:45 +00002189 return;
2190
Douglas Gregore44a2ad2009-05-27 23:11:45 +00002191 for (TemplateParameterList::iterator Param = Params->begin(),
2192 ParamEnd = Params->end();
2193 Param != ParamEnd; ++Param) {
2194 NamedDecl *Named = cast<NamedDecl>(*Param);
2195 if (Named->getDeclName()) {
2196 S->AddDecl(DeclPtrTy::make(Named));
2197 IdResolver.AddDecl(Named);
2198 }
2199 }
2200}
2201
Douglas Gregor4d87df52008-12-16 21:30:33 +00002202/// ActOnStartDelayedCXXMethodDeclaration - We have completed
2203/// parsing a top-level (non-nested) C++ class, and we are now
2204/// parsing those parts of the given Method declaration that could
2205/// not be parsed earlier (C++ [class.mem]p2), such as default
2206/// arguments. This action should enter the scope of the given
2207/// Method declaration as if we had just parsed the qualified method
2208/// name. However, it should not bring the parameters into scope;
2209/// that will be performed by ActOnDelayedCXXMethodParameter.
Chris Lattner83f095c2009-03-28 19:18:32 +00002210void Sema::ActOnStartDelayedCXXMethodDeclaration(Scope *S, DeclPtrTy MethodD) {
Douglas Gregor71a57182009-06-22 23:20:33 +00002211 if (!MethodD)
2212 return;
Mike Stump11289f42009-09-09 15:08:12 +00002213
Douglas Gregorc8c277a2009-08-24 11:57:43 +00002214 AdjustDeclIfTemplate(MethodD);
Mike Stump11289f42009-09-09 15:08:12 +00002215
Douglas Gregor4d87df52008-12-16 21:30:33 +00002216 CXXScopeSpec SS;
Chris Lattner83f095c2009-03-28 19:18:32 +00002217 FunctionDecl *Method = cast<FunctionDecl>(MethodD.getAs<Decl>());
Mike Stump11289f42009-09-09 15:08:12 +00002218 QualType ClassTy
Douglas Gregorf21eb492009-03-26 23:50:42 +00002219 = Context.getTypeDeclType(cast<RecordDecl>(Method->getDeclContext()));
2220 SS.setScopeRep(
2221 NestedNameSpecifier::Create(Context, 0, false, ClassTy.getTypePtr()));
Douglas Gregor4d87df52008-12-16 21:30:33 +00002222 ActOnCXXEnterDeclaratorScope(S, SS);
2223}
2224
2225/// ActOnDelayedCXXMethodParameter - We've already started a delayed
2226/// C++ method declaration. We're (re-)introducing the given
2227/// function parameter into scope for use in parsing later parts of
2228/// the method declaration. For example, we could see an
2229/// ActOnParamDefaultArgument event for this parameter.
Chris Lattner83f095c2009-03-28 19:18:32 +00002230void Sema::ActOnDelayedCXXMethodParameter(Scope *S, DeclPtrTy ParamD) {
Douglas Gregor71a57182009-06-22 23:20:33 +00002231 if (!ParamD)
2232 return;
Mike Stump11289f42009-09-09 15:08:12 +00002233
Chris Lattner83f095c2009-03-28 19:18:32 +00002234 ParmVarDecl *Param = cast<ParmVarDecl>(ParamD.getAs<Decl>());
Douglas Gregor58354032008-12-24 00:01:03 +00002235
2236 // If this parameter has an unparsed default argument, clear it out
2237 // to make way for the parsed default argument.
2238 if (Param->hasUnparsedDefaultArg())
2239 Param->setDefaultArg(0);
2240
Chris Lattner83f095c2009-03-28 19:18:32 +00002241 S->AddDecl(DeclPtrTy::make(Param));
Douglas Gregor4d87df52008-12-16 21:30:33 +00002242 if (Param->getDeclName())
2243 IdResolver.AddDecl(Param);
2244}
2245
2246/// ActOnFinishDelayedCXXMethodDeclaration - We have finished
2247/// processing the delayed method declaration for Method. The method
2248/// declaration is now considered finished. There may be a separate
2249/// ActOnStartOfFunctionDef action later (not necessarily
2250/// immediately!) for this method, if it was also defined inside the
2251/// class body.
Chris Lattner83f095c2009-03-28 19:18:32 +00002252void Sema::ActOnFinishDelayedCXXMethodDeclaration(Scope *S, DeclPtrTy MethodD) {
Douglas Gregor71a57182009-06-22 23:20:33 +00002253 if (!MethodD)
2254 return;
Mike Stump11289f42009-09-09 15:08:12 +00002255
Douglas Gregorc8c277a2009-08-24 11:57:43 +00002256 AdjustDeclIfTemplate(MethodD);
Mike Stump11289f42009-09-09 15:08:12 +00002257
Chris Lattner83f095c2009-03-28 19:18:32 +00002258 FunctionDecl *Method = cast<FunctionDecl>(MethodD.getAs<Decl>());
Douglas Gregor4d87df52008-12-16 21:30:33 +00002259 CXXScopeSpec SS;
Mike Stump11289f42009-09-09 15:08:12 +00002260 QualType ClassTy
Douglas Gregorf21eb492009-03-26 23:50:42 +00002261 = Context.getTypeDeclType(cast<RecordDecl>(Method->getDeclContext()));
2262 SS.setScopeRep(
2263 NestedNameSpecifier::Create(Context, 0, false, ClassTy.getTypePtr()));
Douglas Gregor4d87df52008-12-16 21:30:33 +00002264 ActOnCXXExitDeclaratorScope(S, SS);
2265
2266 // Now that we have our default arguments, check the constructor
2267 // again. It could produce additional diagnostics or affect whether
2268 // the class has implicitly-declared destructors, among other
2269 // things.
Chris Lattnerb41df4f2009-04-25 08:35:12 +00002270 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Method))
2271 CheckConstructor(Constructor);
Douglas Gregor4d87df52008-12-16 21:30:33 +00002272
2273 // Check the default arguments, which we may have added.
2274 if (!Method->isInvalidDecl())
2275 CheckCXXDefaultArguments(Method);
2276}
2277
Douglas Gregor831c93f2008-11-05 20:51:48 +00002278/// CheckConstructorDeclarator - Called by ActOnDeclarator to check
Douglas Gregor4d87df52008-12-16 21:30:33 +00002279/// the well-formedness of the constructor declarator @p D with type @p
Douglas Gregor831c93f2008-11-05 20:51:48 +00002280/// R. If there are any errors in the declarator, this routine will
Chris Lattner38378bf2009-04-25 08:28:21 +00002281/// emit diagnostics and set the invalid bit to true. In any case, the type
2282/// will be updated to reflect a well-formed type for the constructor and
2283/// returned.
2284QualType Sema::CheckConstructorDeclarator(Declarator &D, QualType R,
2285 FunctionDecl::StorageClass &SC) {
Douglas Gregor831c93f2008-11-05 20:51:48 +00002286 bool isVirtual = D.getDeclSpec().isVirtualSpecified();
Douglas Gregor831c93f2008-11-05 20:51:48 +00002287
2288 // C++ [class.ctor]p3:
2289 // A constructor shall not be virtual (10.3) or static (9.4). A
2290 // constructor can be invoked for a const, volatile or const
2291 // volatile object. A constructor shall not be declared const,
2292 // volatile, or const volatile (9.3.2).
2293 if (isVirtual) {
Chris Lattner38378bf2009-04-25 08:28:21 +00002294 if (!D.isInvalidType())
2295 Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
2296 << "virtual" << SourceRange(D.getDeclSpec().getVirtualSpecLoc())
2297 << SourceRange(D.getIdentifierLoc());
2298 D.setInvalidType();
Douglas Gregor831c93f2008-11-05 20:51:48 +00002299 }
2300 if (SC == FunctionDecl::Static) {
Chris Lattner38378bf2009-04-25 08:28:21 +00002301 if (!D.isInvalidType())
2302 Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
2303 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
2304 << SourceRange(D.getIdentifierLoc());
2305 D.setInvalidType();
Douglas Gregor831c93f2008-11-05 20:51:48 +00002306 SC = FunctionDecl::None;
2307 }
Mike Stump11289f42009-09-09 15:08:12 +00002308
Chris Lattner38378bf2009-04-25 08:28:21 +00002309 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
2310 if (FTI.TypeQuals != 0) {
John McCall8ccfcb52009-09-24 19:53:00 +00002311 if (FTI.TypeQuals & Qualifiers::Const)
Chris Lattner3b054132008-11-19 05:08:23 +00002312 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
2313 << "const" << SourceRange(D.getIdentifierLoc());
John McCall8ccfcb52009-09-24 19:53:00 +00002314 if (FTI.TypeQuals & Qualifiers::Volatile)
Chris Lattner3b054132008-11-19 05:08:23 +00002315 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
2316 << "volatile" << SourceRange(D.getIdentifierLoc());
John McCall8ccfcb52009-09-24 19:53:00 +00002317 if (FTI.TypeQuals & Qualifiers::Restrict)
Chris Lattner3b054132008-11-19 05:08:23 +00002318 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
2319 << "restrict" << SourceRange(D.getIdentifierLoc());
Douglas Gregor831c93f2008-11-05 20:51:48 +00002320 }
Mike Stump11289f42009-09-09 15:08:12 +00002321
Douglas Gregor831c93f2008-11-05 20:51:48 +00002322 // Rebuild the function type "R" without any type qualifiers (in
2323 // case any of the errors above fired) and with "void" as the
2324 // return type, since constructors don't have return types. We
2325 // *always* have to do this, because GetTypeForDeclarator will
2326 // put in a result type of "int" when none was specified.
John McCall9dd450b2009-09-21 23:43:11 +00002327 const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
Chris Lattner38378bf2009-04-25 08:28:21 +00002328 return Context.getFunctionType(Context.VoidTy, Proto->arg_type_begin(),
2329 Proto->getNumArgs(),
2330 Proto->isVariadic(), 0);
Douglas Gregor831c93f2008-11-05 20:51:48 +00002331}
2332
Douglas Gregor4d87df52008-12-16 21:30:33 +00002333/// CheckConstructor - Checks a fully-formed constructor for
2334/// well-formedness, issuing any diagnostics required. Returns true if
2335/// the constructor declarator is invalid.
Chris Lattnerb41df4f2009-04-25 08:35:12 +00002336void Sema::CheckConstructor(CXXConstructorDecl *Constructor) {
Mike Stump11289f42009-09-09 15:08:12 +00002337 CXXRecordDecl *ClassDecl
Douglas Gregorf4d17c42009-03-27 04:38:56 +00002338 = dyn_cast<CXXRecordDecl>(Constructor->getDeclContext());
2339 if (!ClassDecl)
Chris Lattnerb41df4f2009-04-25 08:35:12 +00002340 return Constructor->setInvalidDecl();
Douglas Gregor4d87df52008-12-16 21:30:33 +00002341
2342 // C++ [class.copy]p3:
2343 // A declaration of a constructor for a class X is ill-formed if
2344 // its first parameter is of type (optionally cv-qualified) X and
2345 // either there are no other parameters or else all other
2346 // parameters have default arguments.
Douglas Gregorf4d17c42009-03-27 04:38:56 +00002347 if (!Constructor->isInvalidDecl() &&
Mike Stump11289f42009-09-09 15:08:12 +00002348 ((Constructor->getNumParams() == 1) ||
2349 (Constructor->getNumParams() > 1 &&
Douglas Gregorffe14e32009-11-14 01:20:54 +00002350 Constructor->getParamDecl(1)->hasDefaultArg())) &&
2351 Constructor->getTemplateSpecializationKind()
2352 != TSK_ImplicitInstantiation) {
Douglas Gregor4d87df52008-12-16 21:30:33 +00002353 QualType ParamType = Constructor->getParamDecl(0)->getType();
2354 QualType ClassTy = Context.getTagDeclType(ClassDecl);
2355 if (Context.getCanonicalType(ParamType).getUnqualifiedType() == ClassTy) {
Douglas Gregor170512f2009-04-01 23:51:29 +00002356 SourceLocation ParamLoc = Constructor->getParamDecl(0)->getLocation();
2357 Diag(ParamLoc, diag::err_constructor_byvalue_arg)
Douglas Gregor578dae52009-04-02 01:08:08 +00002358 << CodeModificationHint::CreateInsertion(ParamLoc, " const &");
Douglas Gregorffe14e32009-11-14 01:20:54 +00002359
2360 // FIXME: Rather that making the constructor invalid, we should endeavor
2361 // to fix the type.
Chris Lattnerb41df4f2009-04-25 08:35:12 +00002362 Constructor->setInvalidDecl();
Douglas Gregor4d87df52008-12-16 21:30:33 +00002363 }
2364 }
Mike Stump11289f42009-09-09 15:08:12 +00002365
Douglas Gregor4d87df52008-12-16 21:30:33 +00002366 // Notify the class that we've added a constructor.
2367 ClassDecl->addedConstructor(Context, Constructor);
Douglas Gregor4d87df52008-12-16 21:30:33 +00002368}
2369
Anders Carlsson2a50e952009-11-15 22:49:34 +00002370/// CheckDestructor - Checks a fully-formed destructor for
2371/// well-formedness, issuing any diagnostics required.
2372void Sema::CheckDestructor(CXXDestructorDecl *Destructor) {
2373 CXXRecordDecl *RD = Destructor->getParent();
2374
2375 if (Destructor->isVirtual()) {
2376 SourceLocation Loc;
2377
2378 if (!Destructor->isImplicit())
2379 Loc = Destructor->getLocation();
2380 else
2381 Loc = RD->getLocation();
2382
2383 // If we have a virtual destructor, look up the deallocation function
2384 FunctionDecl *OperatorDelete = 0;
2385 DeclarationName Name =
2386 Context.DeclarationNames.getCXXOperatorName(OO_Delete);
2387 if (!FindDeallocationFunction(Loc, RD, Name, OperatorDelete))
2388 Destructor->setOperatorDelete(OperatorDelete);
2389 }
2390}
2391
Mike Stump11289f42009-09-09 15:08:12 +00002392static inline bool
Anders Carlsson5e965472009-04-30 23:18:11 +00002393FTIHasSingleVoidArgument(DeclaratorChunk::FunctionTypeInfo &FTI) {
2394 return (FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 &&
2395 FTI.ArgInfo[0].Param &&
2396 FTI.ArgInfo[0].Param.getAs<ParmVarDecl>()->getType()->isVoidType());
2397}
2398
Douglas Gregor831c93f2008-11-05 20:51:48 +00002399/// CheckDestructorDeclarator - Called by ActOnDeclarator to check
2400/// the well-formednes of the destructor declarator @p D with type @p
2401/// R. If there are any errors in the declarator, this routine will
Chris Lattner38378bf2009-04-25 08:28:21 +00002402/// emit diagnostics and set the declarator to invalid. Even if this happens,
2403/// will be updated to reflect a well-formed type for the destructor and
2404/// returned.
2405QualType Sema::CheckDestructorDeclarator(Declarator &D,
2406 FunctionDecl::StorageClass& SC) {
Douglas Gregor831c93f2008-11-05 20:51:48 +00002407 // C++ [class.dtor]p1:
2408 // [...] A typedef-name that names a class is a class-name
2409 // (7.1.3); however, a typedef-name that names a class shall not
2410 // be used as the identifier in the declarator for a destructor
2411 // declaration.
Douglas Gregor7861a802009-11-03 01:35:08 +00002412 QualType DeclaratorType = GetTypeFromParser(D.getName().DestructorName);
Chris Lattner38378bf2009-04-25 08:28:21 +00002413 if (isa<TypedefType>(DeclaratorType)) {
2414 Diag(D.getIdentifierLoc(), diag::err_destructor_typedef_name)
Douglas Gregor9817f4a2009-02-09 15:09:02 +00002415 << DeclaratorType;
Chris Lattner38378bf2009-04-25 08:28:21 +00002416 D.setInvalidType();
Douglas Gregor831c93f2008-11-05 20:51:48 +00002417 }
2418
2419 // C++ [class.dtor]p2:
2420 // A destructor is used to destroy objects of its class type. A
2421 // destructor takes no parameters, and no return type can be
2422 // specified for it (not even void). The address of a destructor
2423 // shall not be taken. A destructor shall not be static. A
2424 // destructor can be invoked for a const, volatile or const
2425 // volatile object. A destructor shall not be declared const,
2426 // volatile or const volatile (9.3.2).
2427 if (SC == FunctionDecl::Static) {
Chris Lattner38378bf2009-04-25 08:28:21 +00002428 if (!D.isInvalidType())
2429 Diag(D.getIdentifierLoc(), diag::err_destructor_cannot_be)
2430 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
2431 << SourceRange(D.getIdentifierLoc());
Douglas Gregor831c93f2008-11-05 20:51:48 +00002432 SC = FunctionDecl::None;
Chris Lattner38378bf2009-04-25 08:28:21 +00002433 D.setInvalidType();
Douglas Gregor831c93f2008-11-05 20:51:48 +00002434 }
Chris Lattner38378bf2009-04-25 08:28:21 +00002435 if (D.getDeclSpec().hasTypeSpecifier() && !D.isInvalidType()) {
Douglas Gregor831c93f2008-11-05 20:51:48 +00002436 // Destructors don't have return types, but the parser will
2437 // happily parse something like:
2438 //
2439 // class X {
2440 // float ~X();
2441 // };
2442 //
2443 // The return type will be eliminated later.
Chris Lattner3b054132008-11-19 05:08:23 +00002444 Diag(D.getIdentifierLoc(), diag::err_destructor_return_type)
2445 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
2446 << SourceRange(D.getIdentifierLoc());
Douglas Gregor831c93f2008-11-05 20:51:48 +00002447 }
Mike Stump11289f42009-09-09 15:08:12 +00002448
Chris Lattner38378bf2009-04-25 08:28:21 +00002449 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
2450 if (FTI.TypeQuals != 0 && !D.isInvalidType()) {
John McCall8ccfcb52009-09-24 19:53:00 +00002451 if (FTI.TypeQuals & Qualifiers::Const)
Chris Lattner3b054132008-11-19 05:08:23 +00002452 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
2453 << "const" << SourceRange(D.getIdentifierLoc());
John McCall8ccfcb52009-09-24 19:53:00 +00002454 if (FTI.TypeQuals & Qualifiers::Volatile)
Chris Lattner3b054132008-11-19 05:08:23 +00002455 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
2456 << "volatile" << SourceRange(D.getIdentifierLoc());
John McCall8ccfcb52009-09-24 19:53:00 +00002457 if (FTI.TypeQuals & Qualifiers::Restrict)
Chris Lattner3b054132008-11-19 05:08:23 +00002458 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
2459 << "restrict" << SourceRange(D.getIdentifierLoc());
Chris Lattner38378bf2009-04-25 08:28:21 +00002460 D.setInvalidType();
Douglas Gregor831c93f2008-11-05 20:51:48 +00002461 }
2462
2463 // Make sure we don't have any parameters.
Anders Carlsson5e965472009-04-30 23:18:11 +00002464 if (FTI.NumArgs > 0 && !FTIHasSingleVoidArgument(FTI)) {
Douglas Gregor831c93f2008-11-05 20:51:48 +00002465 Diag(D.getIdentifierLoc(), diag::err_destructor_with_params);
2466
2467 // Delete the parameters.
Chris Lattner38378bf2009-04-25 08:28:21 +00002468 FTI.freeArgs();
2469 D.setInvalidType();
Douglas Gregor831c93f2008-11-05 20:51:48 +00002470 }
2471
Mike Stump11289f42009-09-09 15:08:12 +00002472 // Make sure the destructor isn't variadic.
Chris Lattner38378bf2009-04-25 08:28:21 +00002473 if (FTI.isVariadic) {
Douglas Gregor831c93f2008-11-05 20:51:48 +00002474 Diag(D.getIdentifierLoc(), diag::err_destructor_variadic);
Chris Lattner38378bf2009-04-25 08:28:21 +00002475 D.setInvalidType();
2476 }
Douglas Gregor831c93f2008-11-05 20:51:48 +00002477
2478 // Rebuild the function type "R" without any type qualifiers or
2479 // parameters (in case any of the errors above fired) and with
2480 // "void" as the return type, since destructors don't have return
2481 // types. We *always* have to do this, because GetTypeForDeclarator
2482 // will put in a result type of "int" when none was specified.
Chris Lattner38378bf2009-04-25 08:28:21 +00002483 return Context.getFunctionType(Context.VoidTy, 0, 0, false, 0);
Douglas Gregor831c93f2008-11-05 20:51:48 +00002484}
2485
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002486/// CheckConversionDeclarator - Called by ActOnDeclarator to check the
2487/// well-formednes of the conversion function declarator @p D with
2488/// type @p R. If there are any errors in the declarator, this routine
2489/// will emit diagnostics and return true. Otherwise, it will return
2490/// false. Either way, the type @p R will be updated to reflect a
2491/// well-formed type for the conversion operator.
Chris Lattnerb41df4f2009-04-25 08:35:12 +00002492void Sema::CheckConversionDeclarator(Declarator &D, QualType &R,
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002493 FunctionDecl::StorageClass& SC) {
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002494 // C++ [class.conv.fct]p1:
2495 // Neither parameter types nor return type can be specified. The
Eli Friedman44b83ee2009-08-05 19:21:58 +00002496 // type of a conversion function (8.3.5) is "function taking no
Mike Stump11289f42009-09-09 15:08:12 +00002497 // parameter returning conversion-type-id."
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002498 if (SC == FunctionDecl::Static) {
Chris Lattnerb41df4f2009-04-25 08:35:12 +00002499 if (!D.isInvalidType())
2500 Diag(D.getIdentifierLoc(), diag::err_conv_function_not_member)
2501 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
2502 << SourceRange(D.getIdentifierLoc());
2503 D.setInvalidType();
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002504 SC = FunctionDecl::None;
2505 }
Chris Lattnerb41df4f2009-04-25 08:35:12 +00002506 if (D.getDeclSpec().hasTypeSpecifier() && !D.isInvalidType()) {
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002507 // Conversion functions don't have return types, but the parser will
2508 // happily parse something like:
2509 //
2510 // class X {
2511 // float operator bool();
2512 // };
2513 //
2514 // The return type will be changed later anyway.
Chris Lattner3b054132008-11-19 05:08:23 +00002515 Diag(D.getIdentifierLoc(), diag::err_conv_function_return_type)
2516 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
2517 << SourceRange(D.getIdentifierLoc());
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002518 }
2519
2520 // Make sure we don't have any parameters.
John McCall9dd450b2009-09-21 23:43:11 +00002521 if (R->getAs<FunctionProtoType>()->getNumArgs() > 0) {
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002522 Diag(D.getIdentifierLoc(), diag::err_conv_function_with_params);
2523
2524 // Delete the parameters.
Chris Lattner5742c1e2009-01-20 21:06:38 +00002525 D.getTypeObject(0).Fun.freeArgs();
Chris Lattnerb41df4f2009-04-25 08:35:12 +00002526 D.setInvalidType();
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002527 }
2528
Mike Stump11289f42009-09-09 15:08:12 +00002529 // Make sure the conversion function isn't variadic.
John McCall9dd450b2009-09-21 23:43:11 +00002530 if (R->getAs<FunctionProtoType>()->isVariadic() && !D.isInvalidType()) {
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002531 Diag(D.getIdentifierLoc(), diag::err_conv_function_variadic);
Chris Lattnerb41df4f2009-04-25 08:35:12 +00002532 D.setInvalidType();
2533 }
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002534
2535 // C++ [class.conv.fct]p4:
2536 // The conversion-type-id shall not represent a function type nor
2537 // an array type.
Douglas Gregor7861a802009-11-03 01:35:08 +00002538 QualType ConvType = GetTypeFromParser(D.getName().ConversionFunctionId);
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002539 if (ConvType->isArrayType()) {
2540 Diag(D.getIdentifierLoc(), diag::err_conv_function_to_array);
2541 ConvType = Context.getPointerType(ConvType);
Chris Lattnerb41df4f2009-04-25 08:35:12 +00002542 D.setInvalidType();
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002543 } else if (ConvType->isFunctionType()) {
2544 Diag(D.getIdentifierLoc(), diag::err_conv_function_to_function);
2545 ConvType = Context.getPointerType(ConvType);
Chris Lattnerb41df4f2009-04-25 08:35:12 +00002546 D.setInvalidType();
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002547 }
2548
2549 // Rebuild the function type "R" without any parameters (in case any
2550 // of the errors above fired) and with the conversion type as the
Mike Stump11289f42009-09-09 15:08:12 +00002551 // return type.
2552 R = Context.getFunctionType(ConvType, 0, 0, false,
John McCall9dd450b2009-09-21 23:43:11 +00002553 R->getAs<FunctionProtoType>()->getTypeQuals());
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002554
Douglas Gregor5fb53972009-01-14 15:45:31 +00002555 // C++0x explicit conversion operators.
2556 if (D.getDeclSpec().isExplicitSpecified() && !getLangOptions().CPlusPlus0x)
Mike Stump11289f42009-09-09 15:08:12 +00002557 Diag(D.getDeclSpec().getExplicitSpecLoc(),
Douglas Gregor5fb53972009-01-14 15:45:31 +00002558 diag::warn_explicit_conversion_functions)
2559 << SourceRange(D.getDeclSpec().getExplicitSpecLoc());
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002560}
2561
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002562/// ActOnConversionDeclarator - Called by ActOnDeclarator to complete
2563/// the declaration of the given C++ conversion function. This routine
2564/// is responsible for recording the conversion function in the C++
2565/// class, if possible.
Chris Lattner83f095c2009-03-28 19:18:32 +00002566Sema::DeclPtrTy Sema::ActOnConversionDeclarator(CXXConversionDecl *Conversion) {
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002567 assert(Conversion && "Expected to receive a conversion function declaration");
2568
Douglas Gregor4287b372008-12-12 08:25:50 +00002569 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Conversion->getDeclContext());
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002570
2571 // Make sure we aren't redeclaring the conversion function.
2572 QualType ConvType = Context.getCanonicalType(Conversion->getConversionType());
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002573
2574 // C++ [class.conv.fct]p1:
2575 // [...] A conversion function is never used to convert a
2576 // (possibly cv-qualified) object to the (possibly cv-qualified)
2577 // same object type (or a reference to it), to a (possibly
2578 // cv-qualified) base class of that type (or a reference to it),
2579 // or to (possibly cv-qualified) void.
Mike Stump87c57ac2009-05-16 07:39:55 +00002580 // FIXME: Suppress this warning if the conversion function ends up being a
2581 // virtual function that overrides a virtual function in a base class.
Mike Stump11289f42009-09-09 15:08:12 +00002582 QualType ClassType
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002583 = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
Ted Kremenekc23c7e62009-07-29 21:53:49 +00002584 if (const ReferenceType *ConvTypeRef = ConvType->getAs<ReferenceType>())
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002585 ConvType = ConvTypeRef->getPointeeType();
2586 if (ConvType->isRecordType()) {
2587 ConvType = Context.getCanonicalType(ConvType).getUnqualifiedType();
2588 if (ConvType == ClassType)
Chris Lattnerf7e3f6d2008-11-20 06:13:02 +00002589 Diag(Conversion->getLocation(), diag::warn_conv_to_self_not_used)
Chris Lattner1e5665e2008-11-24 06:25:27 +00002590 << ClassType;
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002591 else if (IsDerivedFrom(ClassType, ConvType))
Chris Lattnerf7e3f6d2008-11-20 06:13:02 +00002592 Diag(Conversion->getLocation(), diag::warn_conv_to_base_not_used)
Chris Lattner1e5665e2008-11-24 06:25:27 +00002593 << ClassType << ConvType;
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002594 } else if (ConvType->isVoidType()) {
Chris Lattnerf7e3f6d2008-11-20 06:13:02 +00002595 Diag(Conversion->getLocation(), diag::warn_conv_to_void_not_used)
Chris Lattner1e5665e2008-11-24 06:25:27 +00002596 << ClassType << ConvType;
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002597 }
2598
Douglas Gregor1dc98262008-12-26 15:00:45 +00002599 if (Conversion->getPreviousDeclaration()) {
Douglas Gregor05155d82009-08-21 23:19:43 +00002600 const NamedDecl *ExpectedPrevDecl = Conversion->getPreviousDeclaration();
Mike Stump11289f42009-09-09 15:08:12 +00002601 if (FunctionTemplateDecl *ConversionTemplate
Douglas Gregor05155d82009-08-21 23:19:43 +00002602 = Conversion->getDescribedFunctionTemplate())
2603 ExpectedPrevDecl = ConversionTemplate->getPreviousDeclaration();
John McCalld14a8642009-11-21 08:51:07 +00002604 if (ClassDecl->replaceConversion(ExpectedPrevDecl, Conversion))
2605 return DeclPtrTy::make(Conversion);
Douglas Gregor1dc98262008-12-26 15:00:45 +00002606 assert(Conversion->isInvalidDecl() && "Conversion should not get here.");
Mike Stump11289f42009-09-09 15:08:12 +00002607 } else if (FunctionTemplateDecl *ConversionTemplate
Douglas Gregor05155d82009-08-21 23:19:43 +00002608 = Conversion->getDescribedFunctionTemplate())
Fariborz Jahanianedca0bc2009-09-12 19:02:34 +00002609 ClassDecl->addConversionFunction(ConversionTemplate);
Douglas Gregor05155d82009-08-21 23:19:43 +00002610 else if (!Conversion->getPrimaryTemplate()) // ignore specializations
Fariborz Jahanianedca0bc2009-09-12 19:02:34 +00002611 ClassDecl->addConversionFunction(Conversion);
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002612
Chris Lattner83f095c2009-03-28 19:18:32 +00002613 return DeclPtrTy::make(Conversion);
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002614}
2615
Argyrios Kyrtzidis08114892008-04-27 13:50:30 +00002616//===----------------------------------------------------------------------===//
2617// Namespace Handling
2618//===----------------------------------------------------------------------===//
2619
2620/// ActOnStartNamespaceDef - This is called at the start of a namespace
2621/// definition.
Chris Lattner83f095c2009-03-28 19:18:32 +00002622Sema::DeclPtrTy Sema::ActOnStartNamespaceDef(Scope *NamespcScope,
2623 SourceLocation IdentLoc,
2624 IdentifierInfo *II,
2625 SourceLocation LBrace) {
Argyrios Kyrtzidis08114892008-04-27 13:50:30 +00002626 NamespaceDecl *Namespc =
2627 NamespaceDecl::Create(Context, CurContext, IdentLoc, II);
2628 Namespc->setLBracLoc(LBrace);
2629
2630 Scope *DeclRegionScope = NamespcScope->getParent();
2631
2632 if (II) {
2633 // C++ [namespace.def]p2:
2634 // The identifier in an original-namespace-definition shall not have been
2635 // previously defined in the declarative region in which the
2636 // original-namespace-definition appears. The identifier in an
2637 // original-namespace-definition is the name of the namespace. Subsequently
2638 // in that declarative region, it is treated as an original-namespace-name.
2639
John McCall9f3059a2009-10-09 21:13:30 +00002640 NamedDecl *PrevDecl
John McCall27b18f82009-11-17 02:14:36 +00002641 = LookupSingleName(DeclRegionScope, II, LookupOrdinaryName,
John McCall5cebab12009-11-18 07:57:50 +00002642 ForRedeclaration);
Mike Stump11289f42009-09-09 15:08:12 +00002643
Douglas Gregor91f84212008-12-11 16:49:14 +00002644 if (NamespaceDecl *OrigNS = dyn_cast_or_null<NamespaceDecl>(PrevDecl)) {
2645 // This is an extended namespace definition.
2646 // Attach this namespace decl to the chain of extended namespace
2647 // definitions.
2648 OrigNS->setNextNamespace(Namespc);
2649 Namespc->setOriginalNamespace(OrigNS->getOriginalNamespace());
Argyrios Kyrtzidis08114892008-04-27 13:50:30 +00002650
Mike Stump11289f42009-09-09 15:08:12 +00002651 // Remove the previous declaration from the scope.
Chris Lattner83f095c2009-03-28 19:18:32 +00002652 if (DeclRegionScope->isDeclScope(DeclPtrTy::make(OrigNS))) {
Douglas Gregor7a4fad12008-12-11 20:41:00 +00002653 IdResolver.RemoveDecl(OrigNS);
Chris Lattner83f095c2009-03-28 19:18:32 +00002654 DeclRegionScope->RemoveDecl(DeclPtrTy::make(OrigNS));
Argyrios Kyrtzidis08114892008-04-27 13:50:30 +00002655 }
Douglas Gregor91f84212008-12-11 16:49:14 +00002656 } else if (PrevDecl) {
2657 // This is an invalid name redefinition.
2658 Diag(Namespc->getLocation(), diag::err_redefinition_different_kind)
2659 << Namespc->getDeclName();
2660 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
2661 Namespc->setInvalidDecl();
2662 // Continue on to push Namespc as current DeclContext and return it.
Douglas Gregor87f54062009-09-15 22:30:29 +00002663 } else if (II->isStr("std") &&
2664 CurContext->getLookupContext()->isTranslationUnit()) {
2665 // This is the first "real" definition of the namespace "std", so update
2666 // our cache of the "std" namespace to point at this definition.
2667 if (StdNamespace) {
2668 // We had already defined a dummy namespace "std". Link this new
2669 // namespace definition to the dummy namespace "std".
2670 StdNamespace->setNextNamespace(Namespc);
2671 StdNamespace->setLocation(IdentLoc);
2672 Namespc->setOriginalNamespace(StdNamespace->getOriginalNamespace());
2673 }
2674
2675 // Make our StdNamespace cache point at the first real definition of the
2676 // "std" namespace.
2677 StdNamespace = Namespc;
Mike Stump11289f42009-09-09 15:08:12 +00002678 }
Douglas Gregor91f84212008-12-11 16:49:14 +00002679
2680 PushOnScopeChains(Namespc, DeclRegionScope);
2681 } else {
John McCall4fa53422009-10-01 00:25:31 +00002682 // Anonymous namespaces.
2683
2684 // C++ [namespace.unnamed]p1. An unnamed-namespace-definition
2685 // behaves as if it were replaced by
2686 // namespace unique { /* empty body */ }
2687 // using namespace unique;
2688 // namespace unique { namespace-body }
2689 // where all occurrences of 'unique' in a translation unit are
2690 // replaced by the same identifier and this identifier differs
2691 // from all other identifiers in the entire program.
2692
2693 // We just create the namespace with an empty name and then add an
2694 // implicit using declaration, just like the standard suggests.
2695 //
2696 // CodeGen enforces the "universally unique" aspect by giving all
2697 // declarations semantically contained within an anonymous
2698 // namespace internal linkage.
2699
2700 assert(Namespc->isAnonymousNamespace());
2701 CurContext->addDecl(Namespc);
2702
2703 UsingDirectiveDecl* UD
2704 = UsingDirectiveDecl::Create(Context, CurContext,
2705 /* 'using' */ LBrace,
2706 /* 'namespace' */ SourceLocation(),
2707 /* qualifier */ SourceRange(),
2708 /* NNS */ NULL,
2709 /* identifier */ SourceLocation(),
2710 Namespc,
2711 /* Ancestor */ CurContext);
2712 UD->setImplicit();
2713 CurContext->addDecl(UD);
Argyrios Kyrtzidis08114892008-04-27 13:50:30 +00002714 }
2715
2716 // Although we could have an invalid decl (i.e. the namespace name is a
2717 // redefinition), push it as current DeclContext and try to continue parsing.
Mike Stump87c57ac2009-05-16 07:39:55 +00002718 // FIXME: We should be able to push Namespc here, so that the each DeclContext
2719 // for the namespace has the declarations that showed up in that particular
2720 // namespace definition.
Douglas Gregor91f84212008-12-11 16:49:14 +00002721 PushDeclContext(NamespcScope, Namespc);
Chris Lattner83f095c2009-03-28 19:18:32 +00002722 return DeclPtrTy::make(Namespc);
Argyrios Kyrtzidis08114892008-04-27 13:50:30 +00002723}
2724
2725/// ActOnFinishNamespaceDef - This callback is called after a namespace is
2726/// exited. Decl is the DeclTy returned by ActOnStartNamespaceDef.
Chris Lattner83f095c2009-03-28 19:18:32 +00002727void Sema::ActOnFinishNamespaceDef(DeclPtrTy D, SourceLocation RBrace) {
2728 Decl *Dcl = D.getAs<Decl>();
Argyrios Kyrtzidis08114892008-04-27 13:50:30 +00002729 NamespaceDecl *Namespc = dyn_cast_or_null<NamespaceDecl>(Dcl);
2730 assert(Namespc && "Invalid parameter, expected NamespaceDecl");
2731 Namespc->setRBracLoc(RBrace);
2732 PopDeclContext();
2733}
Argyrios Kyrtzidis9a1191c2008-10-06 17:10:33 +00002734
Chris Lattner83f095c2009-03-28 19:18:32 +00002735Sema::DeclPtrTy Sema::ActOnUsingDirective(Scope *S,
2736 SourceLocation UsingLoc,
2737 SourceLocation NamespcLoc,
2738 const CXXScopeSpec &SS,
2739 SourceLocation IdentLoc,
2740 IdentifierInfo *NamespcName,
2741 AttributeList *AttrList) {
Douglas Gregord7c4d982008-12-30 03:27:21 +00002742 assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
2743 assert(NamespcName && "Invalid NamespcName.");
2744 assert(IdentLoc.isValid() && "Invalid NamespceName location.");
Douglas Gregor889ceb72009-02-03 19:21:40 +00002745 assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
Douglas Gregord7c4d982008-12-30 03:27:21 +00002746
Douglas Gregor889ceb72009-02-03 19:21:40 +00002747 UsingDirectiveDecl *UDir = 0;
Douglas Gregord7c4d982008-12-30 03:27:21 +00002748
Douglas Gregor34074322009-01-14 22:20:51 +00002749 // Lookup namespace name.
John McCall27b18f82009-11-17 02:14:36 +00002750 LookupResult R(*this, NamespcName, IdentLoc, LookupNamespaceName);
2751 LookupParsedName(R, S, &SS);
2752 if (R.isAmbiguous())
Chris Lattner83f095c2009-03-28 19:18:32 +00002753 return DeclPtrTy();
John McCall27b18f82009-11-17 02:14:36 +00002754
John McCall9f3059a2009-10-09 21:13:30 +00002755 if (!R.empty()) {
2756 NamedDecl *NS = R.getFoundDecl();
Douglas Gregorbf3f3222009-11-14 03:27:21 +00002757 // FIXME: Namespace aliases!
Douglas Gregord7c4d982008-12-30 03:27:21 +00002758 assert(isa<NamespaceDecl>(NS) && "expected namespace decl");
Douglas Gregor889ceb72009-02-03 19:21:40 +00002759 // C++ [namespace.udir]p1:
2760 // A using-directive specifies that the names in the nominated
2761 // namespace can be used in the scope in which the
2762 // using-directive appears after the using-directive. During
2763 // unqualified name lookup (3.4.1), the names appear as if they
2764 // were declared in the nearest enclosing namespace which
2765 // contains both the using-directive and the nominated
Eli Friedman44b83ee2009-08-05 19:21:58 +00002766 // namespace. [Note: in this context, "contains" means "contains
2767 // directly or indirectly". ]
Douglas Gregor889ceb72009-02-03 19:21:40 +00002768
2769 // Find enclosing context containing both using-directive and
2770 // nominated namespace.
2771 DeclContext *CommonAncestor = cast<DeclContext>(NS);
2772 while (CommonAncestor && !CommonAncestor->Encloses(CurContext))
2773 CommonAncestor = CommonAncestor->getParent();
2774
Mike Stump11289f42009-09-09 15:08:12 +00002775 UDir = UsingDirectiveDecl::Create(Context,
Douglas Gregor3bc6e4c2009-05-30 06:31:56 +00002776 CurContext, UsingLoc,
Mike Stump11289f42009-09-09 15:08:12 +00002777 NamespcLoc,
Douglas Gregor3bc6e4c2009-05-30 06:31:56 +00002778 SS.getRange(),
2779 (NestedNameSpecifier *)SS.getScopeRep(),
2780 IdentLoc,
Douglas Gregor889ceb72009-02-03 19:21:40 +00002781 cast<NamespaceDecl>(NS),
2782 CommonAncestor);
2783 PushUsingDirective(S, UDir);
Douglas Gregord7c4d982008-12-30 03:27:21 +00002784 } else {
Chris Lattner8dca2e92009-01-06 07:24:29 +00002785 Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
Douglas Gregord7c4d982008-12-30 03:27:21 +00002786 }
2787
Douglas Gregor889ceb72009-02-03 19:21:40 +00002788 // FIXME: We ignore attributes for now.
Douglas Gregord7c4d982008-12-30 03:27:21 +00002789 delete AttrList;
Chris Lattner83f095c2009-03-28 19:18:32 +00002790 return DeclPtrTy::make(UDir);
Douglas Gregor889ceb72009-02-03 19:21:40 +00002791}
2792
2793void Sema::PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir) {
2794 // If scope has associated entity, then using directive is at namespace
2795 // or translation unit scope. We add UsingDirectiveDecls, into
2796 // it's lookup structure.
2797 if (DeclContext *Ctx = static_cast<DeclContext*>(S->getEntity()))
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00002798 Ctx->addDecl(UDir);
Douglas Gregor889ceb72009-02-03 19:21:40 +00002799 else
2800 // Otherwise it is block-sope. using-directives will affect lookup
2801 // only to the end of scope.
Chris Lattner83f095c2009-03-28 19:18:32 +00002802 S->PushUsingDirective(DeclPtrTy::make(UDir));
Douglas Gregord7c4d982008-12-30 03:27:21 +00002803}
Argyrios Kyrtzidis9a1191c2008-10-06 17:10:33 +00002804
Douglas Gregorfec52632009-06-20 00:51:54 +00002805
2806Sema::DeclPtrTy Sema::ActOnUsingDeclaration(Scope *S,
Anders Carlsson7b194b72009-08-29 19:54:19 +00002807 AccessSpecifier AS,
Anders Carlsson59140b32009-08-28 03:16:11 +00002808 SourceLocation UsingLoc,
2809 const CXXScopeSpec &SS,
Douglas Gregor220f4272009-11-04 16:30:06 +00002810 UnqualifiedId &Name,
Anders Carlsson59140b32009-08-28 03:16:11 +00002811 AttributeList *AttrList,
John McCalle61f2ba2009-11-18 02:36:19 +00002812 bool IsTypeName,
2813 SourceLocation TypenameLoc) {
Douglas Gregorfec52632009-06-20 00:51:54 +00002814 assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
Mike Stump11289f42009-09-09 15:08:12 +00002815
Douglas Gregor220f4272009-11-04 16:30:06 +00002816 switch (Name.getKind()) {
2817 case UnqualifiedId::IK_Identifier:
2818 case UnqualifiedId::IK_OperatorFunctionId:
2819 case UnqualifiedId::IK_ConversionFunctionId:
2820 break;
2821
2822 case UnqualifiedId::IK_ConstructorName:
2823 Diag(Name.getSourceRange().getBegin(), diag::err_using_decl_constructor)
2824 << SS.getRange();
2825 return DeclPtrTy();
2826
2827 case UnqualifiedId::IK_DestructorName:
2828 Diag(Name.getSourceRange().getBegin(), diag::err_using_decl_destructor)
2829 << SS.getRange();
2830 return DeclPtrTy();
2831
2832 case UnqualifiedId::IK_TemplateId:
2833 Diag(Name.getSourceRange().getBegin(), diag::err_using_decl_template_id)
2834 << SourceRange(Name.TemplateId->LAngleLoc, Name.TemplateId->RAngleLoc);
2835 return DeclPtrTy();
2836 }
2837
2838 DeclarationName TargetName = GetNameFromUnqualifiedId(Name);
John McCall3f746822009-11-17 05:59:44 +00002839 NamedDecl *UD = BuildUsingDeclaration(S, AS, UsingLoc, SS,
Douglas Gregor220f4272009-11-04 16:30:06 +00002840 Name.getSourceRange().getBegin(),
John McCalle61f2ba2009-11-18 02:36:19 +00002841 TargetName, AttrList,
2842 /* IsInstantiation */ false,
2843 IsTypeName, TypenameLoc);
Anders Carlsson7b194b72009-08-29 19:54:19 +00002844 if (UD) {
Anders Carlsson696a3f12009-08-28 05:40:36 +00002845 PushOnScopeChains(UD, S);
Anders Carlsson7b194b72009-08-29 19:54:19 +00002846 UD->setAccess(AS);
2847 }
Mike Stump11289f42009-09-09 15:08:12 +00002848
Anders Carlsson696a3f12009-08-28 05:40:36 +00002849 return DeclPtrTy::make(UD);
2850}
2851
John McCall3f746822009-11-17 05:59:44 +00002852/// Builds a shadow declaration corresponding to a 'using' declaration.
2853static UsingShadowDecl *BuildUsingShadowDecl(Sema &SemaRef, Scope *S,
2854 AccessSpecifier AS,
2855 UsingDecl *UD, NamedDecl *Orig) {
2856 // FIXME: diagnose hiding, collisions
2857
2858 // If we resolved to another shadow declaration, just coalesce them.
2859 if (isa<UsingShadowDecl>(Orig)) {
2860 Orig = cast<UsingShadowDecl>(Orig)->getTargetDecl();
2861 assert(!isa<UsingShadowDecl>(Orig) && "nested shadow declaration");
2862 }
2863
2864 UsingShadowDecl *Shadow
2865 = UsingShadowDecl::Create(SemaRef.Context, SemaRef.CurContext,
2866 UD->getLocation(), UD, Orig);
2867 UD->addShadowDecl(Shadow);
2868
2869 if (S)
2870 SemaRef.PushOnScopeChains(Shadow, S);
2871 else
2872 SemaRef.CurContext->addDecl(Shadow);
2873 Shadow->setAccess(AS);
2874
2875 return Shadow;
2876}
2877
John McCalle61f2ba2009-11-18 02:36:19 +00002878/// Builds a using declaration.
2879///
2880/// \param IsInstantiation - Whether this call arises from an
2881/// instantiation of an unresolved using declaration. We treat
2882/// the lookup differently for these declarations.
John McCall3f746822009-11-17 05:59:44 +00002883NamedDecl *Sema::BuildUsingDeclaration(Scope *S, AccessSpecifier AS,
2884 SourceLocation UsingLoc,
Anders Carlsson696a3f12009-08-28 05:40:36 +00002885 const CXXScopeSpec &SS,
2886 SourceLocation IdentLoc,
2887 DeclarationName Name,
2888 AttributeList *AttrList,
John McCalle61f2ba2009-11-18 02:36:19 +00002889 bool IsInstantiation,
2890 bool IsTypeName,
2891 SourceLocation TypenameLoc) {
Anders Carlsson696a3f12009-08-28 05:40:36 +00002892 assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
2893 assert(IdentLoc.isValid() && "Invalid TargetName location.");
Eli Friedman561154d2009-08-27 05:09:36 +00002894
Anders Carlssonf038fc22009-08-28 05:49:21 +00002895 // FIXME: We ignore attributes for now.
2896 delete AttrList;
Mike Stump11289f42009-09-09 15:08:12 +00002897
Anders Carlsson59140b32009-08-28 03:16:11 +00002898 if (SS.isEmpty()) {
2899 Diag(IdentLoc, diag::err_using_requires_qualname);
Anders Carlsson696a3f12009-08-28 05:40:36 +00002900 return 0;
Anders Carlsson59140b32009-08-28 03:16:11 +00002901 }
Mike Stump11289f42009-09-09 15:08:12 +00002902
2903 NestedNameSpecifier *NNS =
Anders Carlsson59140b32009-08-28 03:16:11 +00002904 static_cast<NestedNameSpecifier *>(SS.getScopeRep());
2905
John McCall84c16cf2009-11-12 03:15:40 +00002906 DeclContext *LookupContext = computeDeclContext(SS);
2907 if (!LookupContext) {
John McCalle61f2ba2009-11-18 02:36:19 +00002908 if (IsTypeName) {
2909 return UnresolvedUsingTypenameDecl::Create(Context, CurContext,
2910 UsingLoc, TypenameLoc,
2911 SS.getRange(), NNS,
2912 IdentLoc, Name);
2913 } else {
2914 return UnresolvedUsingValueDecl::Create(Context, CurContext,
2915 UsingLoc, SS.getRange(), NNS,
2916 IdentLoc, Name);
2917 }
Anders Carlssonf038fc22009-08-28 05:49:21 +00002918 }
Mike Stump11289f42009-09-09 15:08:12 +00002919
Anders Carlsson59140b32009-08-28 03:16:11 +00002920 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(CurContext)) {
2921 // C++0x N2914 [namespace.udecl]p3:
2922 // A using-declaration used as a member-declaration shall refer to a member
2923 // of a base class of the class being defined, shall refer to a member of an
2924 // anonymous union that is a member of a base class of the class being
Mike Stump11289f42009-09-09 15:08:12 +00002925 // defined, or shall refer to an enumerator for an enumeration type that is
Anders Carlsson59140b32009-08-28 03:16:11 +00002926 // a member of a base class of the class being defined.
John McCall3f746822009-11-17 05:59:44 +00002927
John McCall84c16cf2009-11-12 03:15:40 +00002928 CXXRecordDecl *LookupRD = dyn_cast<CXXRecordDecl>(LookupContext);
2929 if (!LookupRD || !RD->isDerivedFrom(LookupRD)) {
Anders Carlsson59140b32009-08-28 03:16:11 +00002930 Diag(SS.getRange().getBegin(),
2931 diag::err_using_decl_nested_name_specifier_is_not_a_base_class)
2932 << NNS << RD->getDeclName();
Anders Carlsson696a3f12009-08-28 05:40:36 +00002933 return 0;
Anders Carlsson59140b32009-08-28 03:16:11 +00002934 }
Anders Carlsson59140b32009-08-28 03:16:11 +00002935 } else {
2936 // C++0x N2914 [namespace.udecl]p8:
2937 // A using-declaration for a class member shall be a member-declaration.
John McCall84c16cf2009-11-12 03:15:40 +00002938 if (isa<CXXRecordDecl>(LookupContext)) {
Anders Carlsson5a9c5ac2009-08-28 03:35:18 +00002939 Diag(IdentLoc, diag::err_using_decl_can_not_refer_to_class_member)
Anders Carlsson59140b32009-08-28 03:16:11 +00002940 << SS.getRange();
Anders Carlsson696a3f12009-08-28 05:40:36 +00002941 return 0;
Anders Carlsson59140b32009-08-28 03:16:11 +00002942 }
Anders Carlsson59140b32009-08-28 03:16:11 +00002943 }
2944
John McCall3f746822009-11-17 05:59:44 +00002945 // Look up the target name. Unlike most lookups, we do not want to
2946 // hide tag declarations: tag names are visible through the using
2947 // declaration even if hidden by ordinary names.
John McCall27b18f82009-11-17 02:14:36 +00002948 LookupResult R(*this, Name, IdentLoc, LookupOrdinaryName);
John McCalle61f2ba2009-11-18 02:36:19 +00002949
2950 // We don't hide tags behind ordinary decls if we're in a
2951 // non-dependent context, but in a dependent context, this is
2952 // important for the stability of two-phase lookup.
2953 if (!IsInstantiation)
2954 R.setHideTags(false);
John McCall3f746822009-11-17 05:59:44 +00002955
John McCall27b18f82009-11-17 02:14:36 +00002956 LookupQualifiedName(R, LookupContext);
Mike Stump11289f42009-09-09 15:08:12 +00002957
John McCall9f3059a2009-10-09 21:13:30 +00002958 if (R.empty()) {
Douglas Gregore40876a2009-10-13 21:16:44 +00002959 Diag(IdentLoc, diag::err_no_member)
2960 << Name << LookupContext << SS.getRange();
Anders Carlsson696a3f12009-08-28 05:40:36 +00002961 return 0;
Douglas Gregorfec52632009-06-20 00:51:54 +00002962 }
2963
John McCall3f746822009-11-17 05:59:44 +00002964 if (R.isAmbiguous())
2965 return 0;
Mike Stump11289f42009-09-09 15:08:12 +00002966
John McCalle61f2ba2009-11-18 02:36:19 +00002967 if (IsTypeName) {
2968 // If we asked for a typename and got a non-type decl, error out.
2969 if (R.getResultKind() != LookupResult::Found
2970 || !isa<TypeDecl>(R.getFoundDecl())) {
2971 Diag(IdentLoc, diag::err_using_typename_non_type);
2972 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I)
2973 Diag((*I)->getUnderlyingDecl()->getLocation(),
2974 diag::note_using_decl_target);
2975 return 0;
2976 }
2977 } else {
2978 // If we asked for a non-typename and we got a type, error out,
2979 // but only if this is an instantiation of an unresolved using
2980 // decl. Otherwise just silently find the type name.
2981 if (IsInstantiation &&
2982 R.getResultKind() == LookupResult::Found &&
2983 isa<TypeDecl>(R.getFoundDecl())) {
2984 Diag(IdentLoc, diag::err_using_dependent_value_is_type);
2985 Diag(R.getFoundDecl()->getLocation(), diag::note_using_decl_target);
2986 return 0;
2987 }
Anders Carlsson59140b32009-08-28 03:16:11 +00002988 }
2989
Anders Carlsson5a9c5ac2009-08-28 03:35:18 +00002990 // C++0x N2914 [namespace.udecl]p6:
2991 // A using-declaration shall not name a namespace.
John McCall3f746822009-11-17 05:59:44 +00002992 if (R.getResultKind() == LookupResult::Found
2993 && isa<NamespaceDecl>(R.getFoundDecl())) {
Anders Carlsson5a9c5ac2009-08-28 03:35:18 +00002994 Diag(IdentLoc, diag::err_using_decl_can_not_refer_to_namespace)
2995 << SS.getRange();
Anders Carlsson696a3f12009-08-28 05:40:36 +00002996 return 0;
Anders Carlsson5a9c5ac2009-08-28 03:35:18 +00002997 }
Mike Stump11289f42009-09-09 15:08:12 +00002998
John McCall3f746822009-11-17 05:59:44 +00002999 UsingDecl *UD = UsingDecl::Create(Context, CurContext, IdentLoc,
3000 SS.getRange(), UsingLoc, NNS, Name,
3001 IsTypeName);
3002
3003 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I)
3004 BuildUsingShadowDecl(*this, S, AS, UD, *I);
3005
3006 return UD;
Douglas Gregorfec52632009-06-20 00:51:54 +00003007}
3008
Anders Carlssonbb1e4722009-03-28 23:53:49 +00003009/// getNamespaceDecl - Returns the namespace a decl represents. If the decl
3010/// is a namespace alias, returns the namespace it points to.
3011static inline NamespaceDecl *getNamespaceDecl(NamedDecl *D) {
3012 if (NamespaceAliasDecl *AD = dyn_cast_or_null<NamespaceAliasDecl>(D))
3013 return AD->getNamespace();
3014 return dyn_cast_or_null<NamespaceDecl>(D);
3015}
3016
Mike Stump11289f42009-09-09 15:08:12 +00003017Sema::DeclPtrTy Sema::ActOnNamespaceAliasDef(Scope *S,
Anders Carlsson47952ae2009-03-28 22:53:22 +00003018 SourceLocation NamespaceLoc,
Chris Lattner83f095c2009-03-28 19:18:32 +00003019 SourceLocation AliasLoc,
3020 IdentifierInfo *Alias,
3021 const CXXScopeSpec &SS,
Anders Carlsson47952ae2009-03-28 22:53:22 +00003022 SourceLocation IdentLoc,
3023 IdentifierInfo *Ident) {
Mike Stump11289f42009-09-09 15:08:12 +00003024
Anders Carlssonbb1e4722009-03-28 23:53:49 +00003025 // Lookup the namespace name.
John McCall27b18f82009-11-17 02:14:36 +00003026 LookupResult R(*this, Ident, IdentLoc, LookupNamespaceName);
3027 LookupParsedName(R, S, &SS);
Anders Carlssonbb1e4722009-03-28 23:53:49 +00003028
Anders Carlssondca83c42009-03-28 06:23:46 +00003029 // Check if we have a previous declaration with the same name.
John McCall9f3059a2009-10-09 21:13:30 +00003030 if (NamedDecl *PrevDecl
John McCall5cebab12009-11-18 07:57:50 +00003031 = LookupSingleName(S, Alias, LookupOrdinaryName, ForRedeclaration)) {
Anders Carlssonbb1e4722009-03-28 23:53:49 +00003032 if (NamespaceAliasDecl *AD = dyn_cast<NamespaceAliasDecl>(PrevDecl)) {
Mike Stump11289f42009-09-09 15:08:12 +00003033 // We already have an alias with the same name that points to the same
Anders Carlssonbb1e4722009-03-28 23:53:49 +00003034 // namespace, so don't create a new one.
John McCall9f3059a2009-10-09 21:13:30 +00003035 if (!R.isAmbiguous() && !R.empty() &&
3036 AD->getNamespace() == getNamespaceDecl(R.getFoundDecl()))
Anders Carlssonbb1e4722009-03-28 23:53:49 +00003037 return DeclPtrTy();
3038 }
Mike Stump11289f42009-09-09 15:08:12 +00003039
Anders Carlssondca83c42009-03-28 06:23:46 +00003040 unsigned DiagID = isa<NamespaceDecl>(PrevDecl) ? diag::err_redefinition :
3041 diag::err_redefinition_different_kind;
3042 Diag(AliasLoc, DiagID) << Alias;
3043 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
Chris Lattner83f095c2009-03-28 19:18:32 +00003044 return DeclPtrTy();
Anders Carlssondca83c42009-03-28 06:23:46 +00003045 }
3046
John McCall27b18f82009-11-17 02:14:36 +00003047 if (R.isAmbiguous())
Chris Lattner83f095c2009-03-28 19:18:32 +00003048 return DeclPtrTy();
Mike Stump11289f42009-09-09 15:08:12 +00003049
John McCall9f3059a2009-10-09 21:13:30 +00003050 if (R.empty()) {
Anders Carlssonac2c9652009-03-28 06:42:02 +00003051 Diag(NamespaceLoc, diag::err_expected_namespace_name) << SS.getRange();
Chris Lattner83f095c2009-03-28 19:18:32 +00003052 return DeclPtrTy();
Anders Carlssonac2c9652009-03-28 06:42:02 +00003053 }
Mike Stump11289f42009-09-09 15:08:12 +00003054
Fariborz Jahanian423a81f2009-06-19 19:55:27 +00003055 NamespaceAliasDecl *AliasDecl =
Mike Stump11289f42009-09-09 15:08:12 +00003056 NamespaceAliasDecl::Create(Context, CurContext, NamespaceLoc, AliasLoc,
3057 Alias, SS.getRange(),
Douglas Gregor18231932009-05-30 06:48:27 +00003058 (NestedNameSpecifier *)SS.getScopeRep(),
John McCall9f3059a2009-10-09 21:13:30 +00003059 IdentLoc, R.getFoundDecl());
Mike Stump11289f42009-09-09 15:08:12 +00003060
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00003061 CurContext->addDecl(AliasDecl);
Anders Carlssonff25fdf2009-03-28 22:58:02 +00003062 return DeclPtrTy::make(AliasDecl);
Anders Carlsson9205d552009-03-28 05:27:17 +00003063}
3064
Fariborz Jahanian423a81f2009-06-19 19:55:27 +00003065void Sema::DefineImplicitDefaultConstructor(SourceLocation CurrentLocation,
3066 CXXConstructorDecl *Constructor) {
Fariborz Jahanian18eb69a2009-06-22 20:37:23 +00003067 assert((Constructor->isImplicit() && Constructor->isDefaultConstructor() &&
3068 !Constructor->isUsed()) &&
3069 "DefineImplicitDefaultConstructor - call it for implicit default ctor");
Mike Stump11289f42009-09-09 15:08:12 +00003070
Eli Friedman9cf6b592009-11-09 19:20:36 +00003071 CXXRecordDecl *ClassDecl
3072 = cast<CXXRecordDecl>(Constructor->getDeclContext());
3073 assert(ClassDecl && "DefineImplicitDefaultConstructor - invalid constructor");
Eli Friedmand7686ef2009-11-09 01:05:47 +00003074
Eli Friedman9cf6b592009-11-09 19:20:36 +00003075 if (SetBaseOrMemberInitializers(Constructor, 0, 0, true)) {
3076 Diag(CurrentLocation, diag::note_ctor_synthesized_at)
3077 << Context.getTagDeclType(ClassDecl);
3078 Constructor->setInvalidDecl();
3079 } else {
3080 Constructor->setUsed();
3081 }
Eli Friedmand7686ef2009-11-09 01:05:47 +00003082 return;
Fariborz Jahanian423a81f2009-06-19 19:55:27 +00003083}
3084
Fariborz Jahanian24a175b2009-06-26 23:49:16 +00003085void Sema::DefineImplicitDestructor(SourceLocation CurrentLocation,
Douglas Gregord94105a2009-09-04 19:04:08 +00003086 CXXDestructorDecl *Destructor) {
Fariborz Jahanian24a175b2009-06-26 23:49:16 +00003087 assert((Destructor->isImplicit() && !Destructor->isUsed()) &&
3088 "DefineImplicitDestructor - call it for implicit default dtor");
Anders Carlsson2a50e952009-11-15 22:49:34 +00003089 CXXRecordDecl *ClassDecl = Destructor->getParent();
Fariborz Jahanian24a175b2009-06-26 23:49:16 +00003090 assert(ClassDecl && "DefineImplicitDestructor - invalid destructor");
3091 // C++ [class.dtor] p5
Mike Stump11289f42009-09-09 15:08:12 +00003092 // Before the implicitly-declared default destructor for a class is
Fariborz Jahanian24a175b2009-06-26 23:49:16 +00003093 // implicitly defined, all the implicitly-declared default destructors
3094 // for its base class and its non-static data members shall have been
3095 // implicitly defined.
Fariborz Jahanian5f12b532009-06-30 16:36:53 +00003096 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
3097 E = ClassDecl->bases_end(); Base != E; ++Base) {
Fariborz Jahanian24a175b2009-06-26 23:49:16 +00003098 CXXRecordDecl *BaseClassDecl
Ted Kremenekc23c7e62009-07-29 21:53:49 +00003099 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Fariborz Jahanian24a175b2009-06-26 23:49:16 +00003100 if (!BaseClassDecl->hasTrivialDestructor()) {
Mike Stump11289f42009-09-09 15:08:12 +00003101 if (CXXDestructorDecl *BaseDtor =
Fariborz Jahanian24a175b2009-06-26 23:49:16 +00003102 const_cast<CXXDestructorDecl*>(BaseClassDecl->getDestructor(Context)))
3103 MarkDeclarationReferenced(CurrentLocation, BaseDtor);
3104 else
Mike Stump11289f42009-09-09 15:08:12 +00003105 assert(false &&
Fariborz Jahanian24a175b2009-06-26 23:49:16 +00003106 "DefineImplicitDestructor - missing dtor in a base class");
3107 }
3108 }
Mike Stump11289f42009-09-09 15:08:12 +00003109
Fariborz Jahanian5f12b532009-06-30 16:36:53 +00003110 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
3111 E = ClassDecl->field_end(); Field != E; ++Field) {
Fariborz Jahanian24a175b2009-06-26 23:49:16 +00003112 QualType FieldType = Context.getCanonicalType((*Field)->getType());
3113 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
3114 FieldType = Array->getElementType();
Ted Kremenekc23c7e62009-07-29 21:53:49 +00003115 if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
Fariborz Jahanian24a175b2009-06-26 23:49:16 +00003116 CXXRecordDecl *FieldClassDecl
3117 = cast<CXXRecordDecl>(FieldClassType->getDecl());
3118 if (!FieldClassDecl->hasTrivialDestructor()) {
Mike Stump11289f42009-09-09 15:08:12 +00003119 if (CXXDestructorDecl *FieldDtor =
Fariborz Jahanian24a175b2009-06-26 23:49:16 +00003120 const_cast<CXXDestructorDecl*>(
3121 FieldClassDecl->getDestructor(Context)))
3122 MarkDeclarationReferenced(CurrentLocation, FieldDtor);
3123 else
Mike Stump11289f42009-09-09 15:08:12 +00003124 assert(false &&
Fariborz Jahanian24a175b2009-06-26 23:49:16 +00003125 "DefineImplicitDestructor - missing dtor in class of a data member");
3126 }
3127 }
3128 }
3129 Destructor->setUsed();
3130}
3131
Fariborz Jahanian41f79272009-06-25 21:45:19 +00003132void Sema::DefineImplicitOverloadedAssign(SourceLocation CurrentLocation,
3133 CXXMethodDecl *MethodDecl) {
3134 assert((MethodDecl->isImplicit() && MethodDecl->isOverloadedOperator() &&
3135 MethodDecl->getOverloadedOperator() == OO_Equal &&
3136 !MethodDecl->isUsed()) &&
3137 "DefineImplicitOverloadedAssign - call it for implicit assignment op");
Mike Stump11289f42009-09-09 15:08:12 +00003138
Fariborz Jahanian41f79272009-06-25 21:45:19 +00003139 CXXRecordDecl *ClassDecl
3140 = cast<CXXRecordDecl>(MethodDecl->getDeclContext());
Mike Stump11289f42009-09-09 15:08:12 +00003141
Fariborz Jahanianebe772e2009-06-26 16:08:57 +00003142 // C++[class.copy] p12
Fariborz Jahanian41f79272009-06-25 21:45:19 +00003143 // Before the implicitly-declared copy assignment operator for a class is
3144 // implicitly defined, all implicitly-declared copy assignment operators
3145 // for its direct base classes and its nonstatic data members shall have
3146 // been implicitly defined.
3147 bool err = false;
Fariborz Jahanian5f12b532009-06-30 16:36:53 +00003148 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
3149 E = ClassDecl->bases_end(); Base != E; ++Base) {
Fariborz Jahanian41f79272009-06-25 21:45:19 +00003150 CXXRecordDecl *BaseClassDecl
Ted Kremenekc23c7e62009-07-29 21:53:49 +00003151 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Mike Stump11289f42009-09-09 15:08:12 +00003152 if (CXXMethodDecl *BaseAssignOpMethod =
Fariborz Jahanian41f79272009-06-25 21:45:19 +00003153 getAssignOperatorMethod(MethodDecl->getParamDecl(0), BaseClassDecl))
3154 MarkDeclarationReferenced(CurrentLocation, BaseAssignOpMethod);
3155 }
Fariborz Jahanian5f12b532009-06-30 16:36:53 +00003156 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
3157 E = ClassDecl->field_end(); Field != E; ++Field) {
Fariborz Jahanian41f79272009-06-25 21:45:19 +00003158 QualType FieldType = Context.getCanonicalType((*Field)->getType());
3159 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
3160 FieldType = Array->getElementType();
Ted Kremenekc23c7e62009-07-29 21:53:49 +00003161 if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
Fariborz Jahanian41f79272009-06-25 21:45:19 +00003162 CXXRecordDecl *FieldClassDecl
3163 = cast<CXXRecordDecl>(FieldClassType->getDecl());
Mike Stump11289f42009-09-09 15:08:12 +00003164 if (CXXMethodDecl *FieldAssignOpMethod =
Fariborz Jahanian41f79272009-06-25 21:45:19 +00003165 getAssignOperatorMethod(MethodDecl->getParamDecl(0), FieldClassDecl))
3166 MarkDeclarationReferenced(CurrentLocation, FieldAssignOpMethod);
Mike Stump12b8ce12009-08-04 21:02:39 +00003167 } else if (FieldType->isReferenceType()) {
Mike Stump11289f42009-09-09 15:08:12 +00003168 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
Anders Carlsson17973e62009-07-09 17:47:25 +00003169 << Context.getTagDeclType(ClassDecl) << 0 << Field->getDeclName();
3170 Diag(Field->getLocation(), diag::note_declared_at);
Fariborz Jahanian41f79272009-06-25 21:45:19 +00003171 Diag(CurrentLocation, diag::note_first_required_here);
3172 err = true;
Mike Stump12b8ce12009-08-04 21:02:39 +00003173 } else if (FieldType.isConstQualified()) {
Mike Stump11289f42009-09-09 15:08:12 +00003174 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
Anders Carlsson17973e62009-07-09 17:47:25 +00003175 << Context.getTagDeclType(ClassDecl) << 1 << Field->getDeclName();
3176 Diag(Field->getLocation(), diag::note_declared_at);
Fariborz Jahanian41f79272009-06-25 21:45:19 +00003177 Diag(CurrentLocation, diag::note_first_required_here);
3178 err = true;
3179 }
3180 }
3181 if (!err)
Mike Stump11289f42009-09-09 15:08:12 +00003182 MethodDecl->setUsed();
Fariborz Jahanian41f79272009-06-25 21:45:19 +00003183}
3184
3185CXXMethodDecl *
3186Sema::getAssignOperatorMethod(ParmVarDecl *ParmDecl,
3187 CXXRecordDecl *ClassDecl) {
3188 QualType LHSType = Context.getTypeDeclType(ClassDecl);
3189 QualType RHSType(LHSType);
3190 // If class's assignment operator argument is const/volatile qualified,
Mike Stump11289f42009-09-09 15:08:12 +00003191 // look for operator = (const/volatile B&). Otherwise, look for
Fariborz Jahanian41f79272009-06-25 21:45:19 +00003192 // operator = (B&).
John McCall8ccfcb52009-09-24 19:53:00 +00003193 RHSType = Context.getCVRQualifiedType(RHSType,
3194 ParmDecl->getType().getCVRQualifiers());
Mike Stump11289f42009-09-09 15:08:12 +00003195 ExprOwningPtr<Expr> LHS(this, new (Context) DeclRefExpr(ParmDecl,
3196 LHSType,
Fariborz Jahanian41f79272009-06-25 21:45:19 +00003197 SourceLocation()));
Mike Stump11289f42009-09-09 15:08:12 +00003198 ExprOwningPtr<Expr> RHS(this, new (Context) DeclRefExpr(ParmDecl,
3199 RHSType,
Fariborz Jahanian41f79272009-06-25 21:45:19 +00003200 SourceLocation()));
3201 Expr *Args[2] = { &*LHS, &*RHS };
3202 OverloadCandidateSet CandidateSet;
Mike Stump11289f42009-09-09 15:08:12 +00003203 AddMemberOperatorCandidates(clang::OO_Equal, SourceLocation(), Args, 2,
Fariborz Jahanian41f79272009-06-25 21:45:19 +00003204 CandidateSet);
3205 OverloadCandidateSet::iterator Best;
Mike Stump11289f42009-09-09 15:08:12 +00003206 if (BestViableFunction(CandidateSet,
Fariborz Jahanian41f79272009-06-25 21:45:19 +00003207 ClassDecl->getLocation(), Best) == OR_Success)
3208 return cast<CXXMethodDecl>(Best->Function);
3209 assert(false &&
3210 "getAssignOperatorMethod - copy assignment operator method not found");
3211 return 0;
3212}
3213
Fariborz Jahanian477d2422009-06-22 23:34:40 +00003214void Sema::DefineImplicitCopyConstructor(SourceLocation CurrentLocation,
3215 CXXConstructorDecl *CopyConstructor,
3216 unsigned TypeQuals) {
Mike Stump11289f42009-09-09 15:08:12 +00003217 assert((CopyConstructor->isImplicit() &&
Fariborz Jahanian477d2422009-06-22 23:34:40 +00003218 CopyConstructor->isCopyConstructor(Context, TypeQuals) &&
3219 !CopyConstructor->isUsed()) &&
3220 "DefineImplicitCopyConstructor - call it for implicit copy ctor");
Mike Stump11289f42009-09-09 15:08:12 +00003221
Fariborz Jahanian477d2422009-06-22 23:34:40 +00003222 CXXRecordDecl *ClassDecl
3223 = cast<CXXRecordDecl>(CopyConstructor->getDeclContext());
3224 assert(ClassDecl && "DefineImplicitCopyConstructor - invalid constructor");
Fariborz Jahaniana83edb02009-06-23 23:42:10 +00003225 // C++ [class.copy] p209
Mike Stump11289f42009-09-09 15:08:12 +00003226 // Before the implicitly-declared copy constructor for a class is
Fariborz Jahanian477d2422009-06-22 23:34:40 +00003227 // implicitly defined, all the implicitly-declared copy constructors
3228 // for its base class and its non-static data members shall have been
3229 // implicitly defined.
3230 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin();
3231 Base != ClassDecl->bases_end(); ++Base) {
3232 CXXRecordDecl *BaseClassDecl
Ted Kremenekc23c7e62009-07-29 21:53:49 +00003233 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Mike Stump11289f42009-09-09 15:08:12 +00003234 if (CXXConstructorDecl *BaseCopyCtor =
Fariborz Jahanian477d2422009-06-22 23:34:40 +00003235 BaseClassDecl->getCopyConstructor(Context, TypeQuals))
Fariborz Jahaniana83edb02009-06-23 23:42:10 +00003236 MarkDeclarationReferenced(CurrentLocation, BaseCopyCtor);
Fariborz Jahanian477d2422009-06-22 23:34:40 +00003237 }
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00003238 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
3239 FieldEnd = ClassDecl->field_end();
3240 Field != FieldEnd; ++Field) {
Fariborz Jahanian477d2422009-06-22 23:34:40 +00003241 QualType FieldType = Context.getCanonicalType((*Field)->getType());
3242 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
3243 FieldType = Array->getElementType();
Ted Kremenekc23c7e62009-07-29 21:53:49 +00003244 if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
Fariborz Jahanian477d2422009-06-22 23:34:40 +00003245 CXXRecordDecl *FieldClassDecl
3246 = cast<CXXRecordDecl>(FieldClassType->getDecl());
Mike Stump11289f42009-09-09 15:08:12 +00003247 if (CXXConstructorDecl *FieldCopyCtor =
Fariborz Jahanian477d2422009-06-22 23:34:40 +00003248 FieldClassDecl->getCopyConstructor(Context, TypeQuals))
Fariborz Jahaniana83edb02009-06-23 23:42:10 +00003249 MarkDeclarationReferenced(CurrentLocation, FieldCopyCtor);
Fariborz Jahanian477d2422009-06-22 23:34:40 +00003250 }
3251 }
3252 CopyConstructor->setUsed();
3253}
3254
Anders Carlsson6eb55572009-08-25 05:12:04 +00003255Sema::OwningExprResult
Anders Carlsson1b4ebfa2009-09-05 07:40:38 +00003256Sema::BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
Mike Stump11289f42009-09-09 15:08:12 +00003257 CXXConstructorDecl *Constructor,
Anders Carlsson5995a3e2009-09-07 22:23:31 +00003258 MultiExprArg ExprArgs) {
Anders Carlsson250aada2009-08-16 05:13:48 +00003259 bool Elidable = false;
Mike Stump11289f42009-09-09 15:08:12 +00003260
Douglas Gregor5d3507d2009-09-09 23:08:42 +00003261 // C++ [class.copy]p15:
3262 // Whenever a temporary class object is copied using a copy constructor, and
3263 // this object and the copy have the same cv-unqualified type, an
3264 // implementation is permitted to treat the original and the copy as two
3265 // different ways of referring to the same object and not perform a copy at
3266 // all, even if the class copy constructor or destructor have side effects.
Mike Stump11289f42009-09-09 15:08:12 +00003267
Anders Carlsson250aada2009-08-16 05:13:48 +00003268 // FIXME: Is this enough?
Douglas Gregor5d3507d2009-09-09 23:08:42 +00003269 if (Constructor->isCopyConstructor(Context)) {
Anders Carlsson5995a3e2009-09-07 22:23:31 +00003270 Expr *E = ((Expr **)ExprArgs.get())[0];
Anders Carlsson250aada2009-08-16 05:13:48 +00003271 while (CXXBindTemporaryExpr *BE = dyn_cast<CXXBindTemporaryExpr>(E))
3272 E = BE->getSubExpr();
Douglas Gregor5d3507d2009-09-09 23:08:42 +00003273 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
3274 if (ICE->getCastKind() == CastExpr::CK_NoOp)
3275 E = ICE->getSubExpr();
3276
Anders Carlsson250aada2009-08-16 05:13:48 +00003277 if (isa<CallExpr>(E) || isa<CXXTemporaryObjectExpr>(E))
3278 Elidable = true;
3279 }
Mike Stump11289f42009-09-09 15:08:12 +00003280
3281 return BuildCXXConstructExpr(ConstructLoc, DeclInitType, Constructor,
Anders Carlsson5995a3e2009-09-07 22:23:31 +00003282 Elidable, move(ExprArgs));
Anders Carlsson250aada2009-08-16 05:13:48 +00003283}
3284
Fariborz Jahanianaa890bf2009-08-05 17:03:54 +00003285/// BuildCXXConstructExpr - Creates a complete call to a constructor,
3286/// including handling of its default argument expressions.
Anders Carlsson6eb55572009-08-25 05:12:04 +00003287Sema::OwningExprResult
Anders Carlsson1b4ebfa2009-09-05 07:40:38 +00003288Sema::BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
3289 CXXConstructorDecl *Constructor, bool Elidable,
Anders Carlsson5995a3e2009-09-07 22:23:31 +00003290 MultiExprArg ExprArgs) {
3291 unsigned NumExprs = ExprArgs.size();
3292 Expr **Exprs = (Expr **)ExprArgs.release();
Mike Stump11289f42009-09-09 15:08:12 +00003293
Douglas Gregor27381f32009-11-23 12:27:39 +00003294 MarkDeclarationReferenced(ConstructLoc, Constructor);
Douglas Gregor5d3507d2009-09-09 23:08:42 +00003295 return Owned(CXXConstructExpr::Create(Context, DeclInitType, Constructor,
3296 Elidable, Exprs, NumExprs));
Fariborz Jahanianaa890bf2009-08-05 17:03:54 +00003297}
3298
Anders Carlsson574315a2009-08-27 05:08:22 +00003299Sema::OwningExprResult
Mike Stump11289f42009-09-09 15:08:12 +00003300Sema::BuildCXXTemporaryObjectExpr(CXXConstructorDecl *Constructor,
3301 QualType Ty,
3302 SourceLocation TyBeginLoc,
Anders Carlsson574315a2009-08-27 05:08:22 +00003303 MultiExprArg Args,
3304 SourceLocation RParenLoc) {
Douglas Gregor5d3507d2009-09-09 23:08:42 +00003305 unsigned NumExprs = Args.size();
3306 Expr **Exprs = (Expr **)Args.release();
Mike Stump11289f42009-09-09 15:08:12 +00003307
Douglas Gregor27381f32009-11-23 12:27:39 +00003308 MarkDeclarationReferenced(TyBeginLoc, Constructor);
Douglas Gregor5d3507d2009-09-09 23:08:42 +00003309 return Owned(new (Context) CXXTemporaryObjectExpr(Context, Constructor, Ty,
3310 TyBeginLoc, Exprs,
3311 NumExprs, RParenLoc));
Anders Carlsson574315a2009-08-27 05:08:22 +00003312}
3313
3314
Mike Stump11289f42009-09-09 15:08:12 +00003315bool Sema::InitializeVarWithConstructor(VarDecl *VD,
Fariborz Jahanianaa890bf2009-08-05 17:03:54 +00003316 CXXConstructorDecl *Constructor,
Anders Carlsson5995a3e2009-09-07 22:23:31 +00003317 MultiExprArg Exprs) {
Mike Stump11289f42009-09-09 15:08:12 +00003318 OwningExprResult TempResult =
Fariborz Jahanian57277c52009-10-28 18:41:06 +00003319 BuildCXXConstructExpr(VD->getLocation(), VD->getType(), Constructor,
Anders Carlsson5995a3e2009-09-07 22:23:31 +00003320 move(Exprs));
Anders Carlssonc1eb79b2009-08-25 05:18:00 +00003321 if (TempResult.isInvalid())
3322 return true;
Mike Stump11289f42009-09-09 15:08:12 +00003323
Anders Carlsson6eb55572009-08-25 05:12:04 +00003324 Expr *Temp = TempResult.takeAs<Expr>();
Douglas Gregor77b50e12009-06-22 23:06:13 +00003325 MarkDeclarationReferenced(VD->getLocation(), Constructor);
Fariborz Jahaniand460cb42009-08-05 18:17:32 +00003326 Temp = MaybeCreateCXXExprWithTemporaries(Temp, /*DestroyTemps=*/true);
Douglas Gregor31cf12c2009-05-26 18:54:04 +00003327 VD->setInit(Context, Temp);
Mike Stump11289f42009-09-09 15:08:12 +00003328
Anders Carlssonc1eb79b2009-08-25 05:18:00 +00003329 return false;
Anders Carlssone6840d82009-04-16 23:50:50 +00003330}
3331
Mike Stump11289f42009-09-09 15:08:12 +00003332void Sema::FinalizeVarWithDestructor(VarDecl *VD, QualType DeclInitType) {
Fariborz Jahanian24a175b2009-06-26 23:49:16 +00003333 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(
Ted Kremenekc23c7e62009-07-29 21:53:49 +00003334 DeclInitType->getAs<RecordType>()->getDecl());
Fariborz Jahanian24a175b2009-06-26 23:49:16 +00003335 if (!ClassDecl->hasTrivialDestructor())
Mike Stump11289f42009-09-09 15:08:12 +00003336 if (CXXDestructorDecl *Destructor =
Fariborz Jahanian24a175b2009-06-26 23:49:16 +00003337 const_cast<CXXDestructorDecl*>(ClassDecl->getDestructor(Context)))
Fariborz Jahanian67828442009-08-03 19:13:25 +00003338 MarkDeclarationReferenced(VD->getLocation(), Destructor);
Fariborz Jahanian24a175b2009-06-26 23:49:16 +00003339}
3340
Mike Stump11289f42009-09-09 15:08:12 +00003341/// AddCXXDirectInitializerToDecl - This action is called immediately after
Argyrios Kyrtzidis9a1191c2008-10-06 17:10:33 +00003342/// ActOnDeclarator, when a C++ direct initializer is present.
3343/// e.g: "int x(1);"
Chris Lattner83f095c2009-03-28 19:18:32 +00003344void Sema::AddCXXDirectInitializerToDecl(DeclPtrTy Dcl,
3345 SourceLocation LParenLoc,
Sebastian Redl6d4256c2009-03-15 17:47:39 +00003346 MultiExprArg Exprs,
Argyrios Kyrtzidis9a1191c2008-10-06 17:10:33 +00003347 SourceLocation *CommaLocs,
3348 SourceLocation RParenLoc) {
Sebastian Redl6d4256c2009-03-15 17:47:39 +00003349 unsigned NumExprs = Exprs.size();
3350 assert(NumExprs != 0 && Exprs.get() && "missing expressions");
Chris Lattner83f095c2009-03-28 19:18:32 +00003351 Decl *RealDecl = Dcl.getAs<Decl>();
Argyrios Kyrtzidis9a1191c2008-10-06 17:10:33 +00003352
3353 // If there is no declaration, there was an error parsing it. Just ignore
3354 // the initializer.
Chris Lattner83f095c2009-03-28 19:18:32 +00003355 if (RealDecl == 0)
Argyrios Kyrtzidis9a1191c2008-10-06 17:10:33 +00003356 return;
Mike Stump11289f42009-09-09 15:08:12 +00003357
Argyrios Kyrtzidis9a1191c2008-10-06 17:10:33 +00003358 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
3359 if (!VDecl) {
3360 Diag(RealDecl->getLocation(), diag::err_illegal_initializer);
3361 RealDecl->setInvalidDecl();
3362 return;
3363 }
3364
Douglas Gregor402250f2009-08-26 21:14:46 +00003365 // We will represent direct-initialization similarly to copy-initialization:
Argyrios Kyrtzidis997d00d2008-10-06 23:08:37 +00003366 // int x(1); -as-> int x = 1;
Argyrios Kyrtzidis9a1191c2008-10-06 17:10:33 +00003367 // ClassType x(a,b,c); -as-> ClassType x = ClassType(a,b,c);
3368 //
3369 // Clients that want to distinguish between the two forms, can check for
3370 // direct initializer using VarDecl::hasCXXDirectInitializer().
3371 // A major benefit is that clients that don't particularly care about which
3372 // exactly form was it (like the CodeGen) can handle both cases without
3373 // special case code.
Argyrios Kyrtzidis153d9672008-10-06 18:37:09 +00003374
Douglas Gregor402250f2009-08-26 21:14:46 +00003375 // If either the declaration has a dependent type or if any of the expressions
3376 // is type-dependent, we represent the initialization via a ParenListExpr for
3377 // later use during template instantiation.
3378 if (VDecl->getType()->isDependentType() ||
3379 Expr::hasAnyTypeDependentArguments((Expr **)Exprs.get(), Exprs.size())) {
3380 // Let clients know that initialization was done with a direct initializer.
3381 VDecl->setCXXDirectInitializer(true);
Mike Stump11289f42009-09-09 15:08:12 +00003382
Douglas Gregor402250f2009-08-26 21:14:46 +00003383 // Store the initialization expressions as a ParenListExpr.
3384 unsigned NumExprs = Exprs.size();
Mike Stump11289f42009-09-09 15:08:12 +00003385 VDecl->setInit(Context,
Douglas Gregor402250f2009-08-26 21:14:46 +00003386 new (Context) ParenListExpr(Context, LParenLoc,
3387 (Expr **)Exprs.release(),
3388 NumExprs, RParenLoc));
3389 return;
3390 }
Mike Stump11289f42009-09-09 15:08:12 +00003391
Douglas Gregor402250f2009-08-26 21:14:46 +00003392
Argyrios Kyrtzidis9a1191c2008-10-06 17:10:33 +00003393 // C++ 8.5p11:
3394 // The form of initialization (using parentheses or '=') is generally
3395 // insignificant, but does matter when the entity being initialized has a
Argyrios Kyrtzidis153d9672008-10-06 18:37:09 +00003396 // class type.
Douglas Gregorc28b57d2008-11-03 20:45:27 +00003397 QualType DeclInitType = VDecl->getType();
3398 if (const ArrayType *Array = Context.getAsArrayType(DeclInitType))
Fariborz Jahaniand264ee02009-10-28 19:04:36 +00003399 DeclInitType = Context.getBaseElementType(Array);
Argyrios Kyrtzidis153d9672008-10-06 18:37:09 +00003400
Douglas Gregor4044d992009-03-24 16:43:20 +00003401 // FIXME: This isn't the right place to complete the type.
3402 if (RequireCompleteType(VDecl->getLocation(), VDecl->getType(),
3403 diag::err_typecheck_decl_incomplete_type)) {
3404 VDecl->setInvalidDecl();
3405 return;
3406 }
3407
Argyrios Kyrtzidis153d9672008-10-06 18:37:09 +00003408 if (VDecl->getType()->isRecordType()) {
Douglas Gregor5d3507d2009-09-09 23:08:42 +00003409 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(*this);
3410
Douglas Gregorc28b57d2008-11-03 20:45:27 +00003411 CXXConstructorDecl *Constructor
Sebastian Redl6d4256c2009-03-15 17:47:39 +00003412 = PerformInitializationByConstructor(DeclInitType,
Douglas Gregor5d3507d2009-09-09 23:08:42 +00003413 move(Exprs),
Douglas Gregor6f543152008-11-05 15:29:30 +00003414 VDecl->getLocation(),
3415 SourceRange(VDecl->getLocation(),
3416 RParenLoc),
Chris Lattnerf3d3fae2008-11-24 05:29:24 +00003417 VDecl->getDeclName(),
Douglas Gregor5d3507d2009-09-09 23:08:42 +00003418 IK_Direct,
3419 ConstructorArgs);
Sebastian Redl6d4256c2009-03-15 17:47:39 +00003420 if (!Constructor)
Douglas Gregorc28b57d2008-11-03 20:45:27 +00003421 RealDecl->setInvalidDecl();
Anders Carlsson332ef552009-04-15 21:48:18 +00003422 else {
Anders Carlsson332ef552009-04-15 21:48:18 +00003423 VDecl->setCXXDirectInitializer(true);
Fariborz Jahanian57277c52009-10-28 18:41:06 +00003424 if (InitializeVarWithConstructor(VDecl, Constructor,
Douglas Gregor5d3507d2009-09-09 23:08:42 +00003425 move_arg(ConstructorArgs)))
Anders Carlssonc1eb79b2009-08-25 05:18:00 +00003426 RealDecl->setInvalidDecl();
Fariborz Jahanian67828442009-08-03 19:13:25 +00003427 FinalizeVarWithDestructor(VDecl, DeclInitType);
Anders Carlsson332ef552009-04-15 21:48:18 +00003428 }
Argyrios Kyrtzidis153d9672008-10-06 18:37:09 +00003429 return;
3430 }
Argyrios Kyrtzidis9a1191c2008-10-06 17:10:33 +00003431
Argyrios Kyrtzidis997d00d2008-10-06 23:08:37 +00003432 if (NumExprs > 1) {
Chris Lattnerf490e152008-11-19 05:27:50 +00003433 Diag(CommaLocs[0], diag::err_builtin_direct_init_more_than_one_arg)
3434 << SourceRange(VDecl->getLocation(), RParenLoc);
Argyrios Kyrtzidis9a1191c2008-10-06 17:10:33 +00003435 RealDecl->setInvalidDecl();
3436 return;
3437 }
3438
Argyrios Kyrtzidis9a1191c2008-10-06 17:10:33 +00003439 // Let clients know that initialization was done with a direct initializer.
3440 VDecl->setCXXDirectInitializer(true);
Argyrios Kyrtzidis997d00d2008-10-06 23:08:37 +00003441
3442 assert(NumExprs == 1 && "Expected 1 expression");
3443 // Set the init expression, handles conversions.
Sebastian Redl6d4256c2009-03-15 17:47:39 +00003444 AddInitializerToDecl(Dcl, ExprArg(*this, Exprs.release()[0]),
3445 /*DirectInit=*/true);
Argyrios Kyrtzidis9a1191c2008-10-06 17:10:33 +00003446}
Douglas Gregor8e1cf602008-10-29 00:13:59 +00003447
Douglas Gregorbf3f3222009-11-14 03:27:21 +00003448/// \brief Add the applicable constructor candidates for an initialization
3449/// by constructor.
3450static void AddConstructorInitializationCandidates(Sema &SemaRef,
3451 QualType ClassType,
3452 Expr **Args,
3453 unsigned NumArgs,
3454 Sema::InitializationKind Kind,
3455 OverloadCandidateSet &CandidateSet) {
3456 // C++ [dcl.init]p14:
3457 // If the initialization is direct-initialization, or if it is
3458 // copy-initialization where the cv-unqualified version of the
3459 // source type is the same class as, or a derived class of, the
3460 // class of the destination, constructors are considered. The
3461 // applicable constructors are enumerated (13.3.1.3), and the
3462 // best one is chosen through overload resolution (13.3). The
3463 // constructor so selected is called to initialize the object,
3464 // with the initializer expression(s) as its argument(s). If no
3465 // constructor applies, or the overload resolution is ambiguous,
3466 // the initialization is ill-formed.
3467 const RecordType *ClassRec = ClassType->getAs<RecordType>();
3468 assert(ClassRec && "Can only initialize a class type here");
3469
3470 // FIXME: When we decide not to synthesize the implicitly-declared
3471 // constructors, we'll need to make them appear here.
3472
3473 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(ClassRec->getDecl());
3474 DeclarationName ConstructorName
3475 = SemaRef.Context.DeclarationNames.getCXXConstructorName(
3476 SemaRef.Context.getCanonicalType(ClassType).getUnqualifiedType());
3477 DeclContext::lookup_const_iterator Con, ConEnd;
3478 for (llvm::tie(Con, ConEnd) = ClassDecl->lookup(ConstructorName);
3479 Con != ConEnd; ++Con) {
3480 // Find the constructor (which may be a template).
3481 CXXConstructorDecl *Constructor = 0;
3482 FunctionTemplateDecl *ConstructorTmpl= dyn_cast<FunctionTemplateDecl>(*Con);
3483 if (ConstructorTmpl)
3484 Constructor
3485 = cast<CXXConstructorDecl>(ConstructorTmpl->getTemplatedDecl());
3486 else
3487 Constructor = cast<CXXConstructorDecl>(*Con);
3488
3489 if ((Kind == Sema::IK_Direct) ||
3490 (Kind == Sema::IK_Copy &&
3491 Constructor->isConvertingConstructor(/*AllowExplicit=*/false)) ||
3492 (Kind == Sema::IK_Default && Constructor->isDefaultConstructor())) {
3493 if (ConstructorTmpl)
John McCall6b51f282009-11-23 01:53:49 +00003494 SemaRef.AddTemplateOverloadCandidate(ConstructorTmpl,
3495 /*ExplicitArgs*/ 0,
Douglas Gregorbf3f3222009-11-14 03:27:21 +00003496 Args, NumArgs, CandidateSet);
3497 else
3498 SemaRef.AddOverloadCandidate(Constructor, Args, NumArgs, CandidateSet);
3499 }
3500 }
3501}
3502
3503/// \brief Attempt to perform initialization by constructor
3504/// (C++ [dcl.init]p14), which may occur as part of direct-initialization or
3505/// copy-initialization.
3506///
3507/// This routine determines whether initialization by constructor is possible,
3508/// but it does not emit any diagnostics in the case where the initialization
3509/// is ill-formed.
3510///
3511/// \param ClassType the type of the object being initialized, which must have
3512/// class type.
3513///
3514/// \param Args the arguments provided to initialize the object
3515///
3516/// \param NumArgs the number of arguments provided to initialize the object
3517///
3518/// \param Kind the type of initialization being performed
3519///
3520/// \returns the constructor used to initialize the object, if successful.
3521/// Otherwise, emits a diagnostic and returns NULL.
3522CXXConstructorDecl *
3523Sema::TryInitializationByConstructor(QualType ClassType,
3524 Expr **Args, unsigned NumArgs,
3525 SourceLocation Loc,
3526 InitializationKind Kind) {
3527 // Build the overload candidate set
3528 OverloadCandidateSet CandidateSet;
3529 AddConstructorInitializationCandidates(*this, ClassType, Args, NumArgs, Kind,
3530 CandidateSet);
3531
3532 // Determine whether we found a constructor we can use.
3533 OverloadCandidateSet::iterator Best;
3534 switch (BestViableFunction(CandidateSet, Loc, Best)) {
3535 case OR_Success:
3536 case OR_Deleted:
3537 // We found a constructor. Return it.
3538 return cast<CXXConstructorDecl>(Best->Function);
3539
3540 case OR_No_Viable_Function:
3541 case OR_Ambiguous:
3542 // Overload resolution failed. Return nothing.
3543 return 0;
3544 }
3545
3546 // Silence GCC warning
3547 return 0;
3548}
3549
Douglas Gregor5d3507d2009-09-09 23:08:42 +00003550/// \brief Perform initialization by constructor (C++ [dcl.init]p14), which
3551/// may occur as part of direct-initialization or copy-initialization.
3552///
3553/// \param ClassType the type of the object being initialized, which must have
3554/// class type.
3555///
3556/// \param ArgsPtr the arguments provided to initialize the object
3557///
3558/// \param Loc the source location where the initialization occurs
3559///
3560/// \param Range the source range that covers the entire initialization
3561///
3562/// \param InitEntity the name of the entity being initialized, if known
3563///
3564/// \param Kind the type of initialization being performed
3565///
3566/// \param ConvertedArgs a vector that will be filled in with the
3567/// appropriately-converted arguments to the constructor (if initialization
3568/// succeeded).
3569///
3570/// \returns the constructor used to initialize the object, if successful.
3571/// Otherwise, emits a diagnostic and returns NULL.
Douglas Gregorc28b57d2008-11-03 20:45:27 +00003572CXXConstructorDecl *
Douglas Gregor6f543152008-11-05 15:29:30 +00003573Sema::PerformInitializationByConstructor(QualType ClassType,
Douglas Gregor5d3507d2009-09-09 23:08:42 +00003574 MultiExprArg ArgsPtr,
Douglas Gregor6f543152008-11-05 15:29:30 +00003575 SourceLocation Loc, SourceRange Range,
Chris Lattnerf3d3fae2008-11-24 05:29:24 +00003576 DeclarationName InitEntity,
Douglas Gregor5d3507d2009-09-09 23:08:42 +00003577 InitializationKind Kind,
3578 ASTOwningVector<&ActionBase::DeleteExpr> &ConvertedArgs) {
Douglas Gregorbf3f3222009-11-14 03:27:21 +00003579
3580 // Build the overload candidate set
Douglas Gregor5d3507d2009-09-09 23:08:42 +00003581 Expr **Args = (Expr **)ArgsPtr.get();
3582 unsigned NumArgs = ArgsPtr.size();
Douglas Gregorc28b57d2008-11-03 20:45:27 +00003583 OverloadCandidateSet CandidateSet;
Douglas Gregorbf3f3222009-11-14 03:27:21 +00003584 AddConstructorInitializationCandidates(*this, ClassType, Args, NumArgs, Kind,
3585 CandidateSet);
Douglas Gregor1349b452008-12-15 21:24:18 +00003586
Douglas Gregorc28b57d2008-11-03 20:45:27 +00003587 OverloadCandidateSet::iterator Best;
Douglas Gregorc9c02ed2009-06-19 23:52:42 +00003588 switch (BestViableFunction(CandidateSet, Loc, Best)) {
Douglas Gregorc28b57d2008-11-03 20:45:27 +00003589 case OR_Success:
Douglas Gregor5d3507d2009-09-09 23:08:42 +00003590 // We found a constructor. Break out so that we can convert the arguments
3591 // appropriately.
3592 break;
Mike Stump11289f42009-09-09 15:08:12 +00003593
Douglas Gregorc28b57d2008-11-03 20:45:27 +00003594 case OR_No_Viable_Function:
Douglas Gregora5c9e1a2009-02-02 17:43:21 +00003595 if (InitEntity)
3596 Diag(Loc, diag::err_ovl_no_viable_function_in_init)
Chris Lattner45d9d602009-02-17 07:29:20 +00003597 << InitEntity << Range;
Douglas Gregora5c9e1a2009-02-02 17:43:21 +00003598 else
3599 Diag(Loc, diag::err_ovl_no_viable_function_in_init)
Chris Lattner45d9d602009-02-17 07:29:20 +00003600 << ClassType << Range;
Sebastian Redl15b02d22008-11-22 13:44:36 +00003601 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/false);
Douglas Gregorc28b57d2008-11-03 20:45:27 +00003602 return 0;
Mike Stump11289f42009-09-09 15:08:12 +00003603
Douglas Gregorc28b57d2008-11-03 20:45:27 +00003604 case OR_Ambiguous:
Douglas Gregora5c9e1a2009-02-02 17:43:21 +00003605 if (InitEntity)
3606 Diag(Loc, diag::err_ovl_ambiguous_init) << InitEntity << Range;
3607 else
3608 Diag(Loc, diag::err_ovl_ambiguous_init) << ClassType << Range;
Douglas Gregorc28b57d2008-11-03 20:45:27 +00003609 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
3610 return 0;
Douglas Gregor171c45a2009-02-18 21:56:37 +00003611
3612 case OR_Deleted:
3613 if (InitEntity)
3614 Diag(Loc, diag::err_ovl_deleted_init)
3615 << Best->Function->isDeleted()
3616 << InitEntity << Range;
3617 else
3618 Diag(Loc, diag::err_ovl_deleted_init)
3619 << Best->Function->isDeleted()
3620 << InitEntity << Range;
3621 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
3622 return 0;
Douglas Gregorc28b57d2008-11-03 20:45:27 +00003623 }
Mike Stump11289f42009-09-09 15:08:12 +00003624
Douglas Gregor5d3507d2009-09-09 23:08:42 +00003625 // Convert the arguments, fill in default arguments, etc.
3626 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function);
3627 if (CompleteConstructorCall(Constructor, move(ArgsPtr), Loc, ConvertedArgs))
3628 return 0;
3629
3630 return Constructor;
3631}
3632
3633/// \brief Given a constructor and the set of arguments provided for the
3634/// constructor, convert the arguments and add any required default arguments
3635/// to form a proper call to this constructor.
3636///
3637/// \returns true if an error occurred, false otherwise.
3638bool
3639Sema::CompleteConstructorCall(CXXConstructorDecl *Constructor,
3640 MultiExprArg ArgsPtr,
3641 SourceLocation Loc,
3642 ASTOwningVector<&ActionBase::DeleteExpr> &ConvertedArgs) {
3643 // FIXME: This duplicates a lot of code from Sema::ConvertArgumentsForCall.
3644 unsigned NumArgs = ArgsPtr.size();
3645 Expr **Args = (Expr **)ArgsPtr.get();
3646
3647 const FunctionProtoType *Proto
3648 = Constructor->getType()->getAs<FunctionProtoType>();
3649 assert(Proto && "Constructor without a prototype?");
3650 unsigned NumArgsInProto = Proto->getNumArgs();
3651 unsigned NumArgsToCheck = NumArgs;
3652
3653 // If too few arguments are available, we'll fill in the rest with defaults.
3654 if (NumArgs < NumArgsInProto) {
3655 NumArgsToCheck = NumArgsInProto;
3656 ConvertedArgs.reserve(NumArgsInProto);
3657 } else {
3658 ConvertedArgs.reserve(NumArgs);
3659 if (NumArgs > NumArgsInProto)
3660 NumArgsToCheck = NumArgsInProto;
3661 }
3662
3663 // Convert arguments
3664 for (unsigned i = 0; i != NumArgsToCheck; i++) {
3665 QualType ProtoArgType = Proto->getArgType(i);
3666
3667 Expr *Arg;
3668 if (i < NumArgs) {
3669 Arg = Args[i];
Anders Carlssonc8bfc462009-09-15 21:14:33 +00003670
3671 // Pass the argument.
3672 if (PerformCopyInitialization(Arg, ProtoArgType, "passing"))
3673 return true;
3674
3675 Args[i] = 0;
Douglas Gregor5d3507d2009-09-09 23:08:42 +00003676 } else {
3677 ParmVarDecl *Param = Constructor->getParamDecl(i);
3678
3679 OwningExprResult DefArg = BuildCXXDefaultArgExpr(Loc, Constructor, Param);
3680 if (DefArg.isInvalid())
3681 return true;
3682
3683 Arg = DefArg.takeAs<Expr>();
3684 }
3685
3686 ConvertedArgs.push_back(Arg);
3687 }
3688
3689 // If this is a variadic call, handle args passed through "...".
3690 if (Proto->isVariadic()) {
3691 // Promote the arguments (C99 6.5.2.2p7).
3692 for (unsigned i = NumArgsInProto; i != NumArgs; i++) {
3693 Expr *Arg = Args[i];
3694 if (DefaultVariadicArgumentPromotion(Arg, VariadicConstructor))
3695 return true;
3696
3697 ConvertedArgs.push_back(Arg);
3698 Args[i] = 0;
3699 }
3700 }
3701
3702 return false;
Douglas Gregorc28b57d2008-11-03 20:45:27 +00003703}
3704
Douglas Gregor8e1cf602008-10-29 00:13:59 +00003705/// CompareReferenceRelationship - Compare the two types T1 and T2 to
3706/// determine whether they are reference-related,
3707/// reference-compatible, reference-compatible with added
3708/// qualification, or incompatible, for use in C++ initialization by
3709/// reference (C++ [dcl.ref.init]p4). Neither type can be a reference
3710/// type, and the first type (T1) is the pointee type of the reference
3711/// type being initialized.
Mike Stump11289f42009-09-09 15:08:12 +00003712Sema::ReferenceCompareResult
Douglas Gregor3ec1bf22009-11-05 13:06:35 +00003713Sema::CompareReferenceRelationship(SourceLocation Loc,
3714 QualType OrigT1, QualType OrigT2,
Douglas Gregor786ab212008-10-29 02:00:59 +00003715 bool& DerivedToBase) {
Douglas Gregor3ec1bf22009-11-05 13:06:35 +00003716 assert(!OrigT1->isReferenceType() &&
Sebastian Redl0f8b23f2009-03-16 23:22:08 +00003717 "T1 must be the pointee type of the reference type");
Douglas Gregor3ec1bf22009-11-05 13:06:35 +00003718 assert(!OrigT2->isReferenceType() && "T2 cannot be a reference type");
Douglas Gregor8e1cf602008-10-29 00:13:59 +00003719
Douglas Gregor3ec1bf22009-11-05 13:06:35 +00003720 QualType T1 = Context.getCanonicalType(OrigT1);
3721 QualType T2 = Context.getCanonicalType(OrigT2);
Douglas Gregor1b8fe5b72009-11-16 21:35:15 +00003722 QualType UnqualT1 = T1.getLocalUnqualifiedType();
3723 QualType UnqualT2 = T2.getLocalUnqualifiedType();
Douglas Gregor8e1cf602008-10-29 00:13:59 +00003724
3725 // C++ [dcl.init.ref]p4:
Eli Friedman44b83ee2009-08-05 19:21:58 +00003726 // Given types "cv1 T1" and "cv2 T2," "cv1 T1" is
Mike Stump11289f42009-09-09 15:08:12 +00003727 // reference-related to "cv2 T2" if T1 is the same type as T2, or
Douglas Gregor8e1cf602008-10-29 00:13:59 +00003728 // T1 is a base class of T2.
Douglas Gregor786ab212008-10-29 02:00:59 +00003729 if (UnqualT1 == UnqualT2)
3730 DerivedToBase = false;
Douglas Gregor3ec1bf22009-11-05 13:06:35 +00003731 else if (!RequireCompleteType(Loc, OrigT1, PDiag()) &&
3732 !RequireCompleteType(Loc, OrigT2, PDiag()) &&
3733 IsDerivedFrom(UnqualT2, UnqualT1))
Douglas Gregor786ab212008-10-29 02:00:59 +00003734 DerivedToBase = true;
3735 else
Douglas Gregor8e1cf602008-10-29 00:13:59 +00003736 return Ref_Incompatible;
3737
3738 // At this point, we know that T1 and T2 are reference-related (at
3739 // least).
3740
3741 // C++ [dcl.init.ref]p4:
Eli Friedman44b83ee2009-08-05 19:21:58 +00003742 // "cv1 T1" is reference-compatible with "cv2 T2" if T1 is
Douglas Gregor8e1cf602008-10-29 00:13:59 +00003743 // reference-related to T2 and cv1 is the same cv-qualification
3744 // as, or greater cv-qualification than, cv2. For purposes of
3745 // overload resolution, cases for which cv1 is greater
3746 // cv-qualification than cv2 are identified as
3747 // reference-compatible with added qualification (see 13.3.3.2).
3748 if (T1.getCVRQualifiers() == T2.getCVRQualifiers())
3749 return Ref_Compatible;
3750 else if (T1.isMoreQualifiedThan(T2))
3751 return Ref_Compatible_With_Added_Qualification;
3752 else
3753 return Ref_Related;
3754}
3755
3756/// CheckReferenceInit - Check the initialization of a reference
3757/// variable with the given initializer (C++ [dcl.init.ref]). Init is
3758/// the initializer (either a simple initializer or an initializer
Douglas Gregor23a1f192008-10-29 23:31:03 +00003759/// list), and DeclType is the type of the declaration. When ICS is
3760/// non-null, this routine will compute the implicit conversion
3761/// sequence according to C++ [over.ics.ref] and will not produce any
3762/// diagnostics; when ICS is null, it will emit diagnostics when any
3763/// errors are found. Either way, a return value of true indicates
3764/// that there was a failure, a return value of false indicates that
3765/// the reference initialization succeeded.
Douglas Gregor2fe98832008-11-03 19:09:14 +00003766///
3767/// When @p SuppressUserConversions, user-defined conversions are
3768/// suppressed.
Douglas Gregor5fb53972009-01-14 15:45:31 +00003769/// When @p AllowExplicit, we also permit explicit user-defined
3770/// conversion functions.
Sebastian Redl42e92c42009-04-12 17:16:29 +00003771/// When @p ForceRValue, we unconditionally treat the initializer as an rvalue.
Sebastian Redl7c353682009-11-14 21:15:49 +00003772/// When @p IgnoreBaseAccess, we don't do access control on to-base conversion.
3773/// This is used when this is called from a C-style cast.
Mike Stump11289f42009-09-09 15:08:12 +00003774bool
Sebastian Redl1a99f442009-04-16 17:51:27 +00003775Sema::CheckReferenceInit(Expr *&Init, QualType DeclType,
Douglas Gregorc809cc22009-09-23 23:04:10 +00003776 SourceLocation DeclLoc,
Douglas Gregor5fb53972009-01-14 15:45:31 +00003777 bool SuppressUserConversions,
Anders Carlsson271e3a42009-08-27 17:30:43 +00003778 bool AllowExplicit, bool ForceRValue,
Sebastian Redl7c353682009-11-14 21:15:49 +00003779 ImplicitConversionSequence *ICS,
3780 bool IgnoreBaseAccess) {
Douglas Gregor8e1cf602008-10-29 00:13:59 +00003781 assert(DeclType->isReferenceType() && "Reference init needs a reference");
3782
Ted Kremenekc23c7e62009-07-29 21:53:49 +00003783 QualType T1 = DeclType->getAs<ReferenceType>()->getPointeeType();
Douglas Gregor8e1cf602008-10-29 00:13:59 +00003784 QualType T2 = Init->getType();
3785
Douglas Gregorcd695e52008-11-10 20:40:00 +00003786 // If the initializer is the address of an overloaded function, try
3787 // to resolve the overloaded function. If all goes well, T2 is the
3788 // type of the resulting function.
Douglas Gregor1baf54e2009-03-13 18:40:31 +00003789 if (Context.getCanonicalType(T2) == Context.OverloadTy) {
Mike Stump11289f42009-09-09 15:08:12 +00003790 FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Init, DeclType,
Douglas Gregorcd695e52008-11-10 20:40:00 +00003791 ICS != 0);
3792 if (Fn) {
3793 // Since we're performing this reference-initialization for
3794 // real, update the initializer with the resulting function.
Douglas Gregor171c45a2009-02-18 21:56:37 +00003795 if (!ICS) {
Douglas Gregorc809cc22009-09-23 23:04:10 +00003796 if (DiagnoseUseOfDecl(Fn, DeclLoc))
Douglas Gregor171c45a2009-02-18 21:56:37 +00003797 return true;
3798
Anders Carlssonfcb4ab42009-10-21 17:16:23 +00003799 Init = FixOverloadedFunctionReference(Init, Fn);
Douglas Gregor171c45a2009-02-18 21:56:37 +00003800 }
Douglas Gregorcd695e52008-11-10 20:40:00 +00003801
3802 T2 = Fn->getType();
3803 }
3804 }
3805
Douglas Gregor786ab212008-10-29 02:00:59 +00003806 // Compute some basic properties of the types and the initializer.
Sebastian Redl0f8b23f2009-03-16 23:22:08 +00003807 bool isRValRef = DeclType->isRValueReferenceType();
Douglas Gregor786ab212008-10-29 02:00:59 +00003808 bool DerivedToBase = false;
Sebastian Redl42e92c42009-04-12 17:16:29 +00003809 Expr::isLvalueResult InitLvalue = ForceRValue ? Expr::LV_InvalidExpression :
3810 Init->isLvalue(Context);
Mike Stump11289f42009-09-09 15:08:12 +00003811 ReferenceCompareResult RefRelationship
Douglas Gregor3ec1bf22009-11-05 13:06:35 +00003812 = CompareReferenceRelationship(DeclLoc, T1, T2, DerivedToBase);
Douglas Gregor786ab212008-10-29 02:00:59 +00003813
3814 // Most paths end in a failed conversion.
3815 if (ICS)
3816 ICS->ConversionKind = ImplicitConversionSequence::BadConversion;
Douglas Gregor8e1cf602008-10-29 00:13:59 +00003817
3818 // C++ [dcl.init.ref]p5:
Eli Friedman44b83ee2009-08-05 19:21:58 +00003819 // A reference to type "cv1 T1" is initialized by an expression
3820 // of type "cv2 T2" as follows:
Douglas Gregor8e1cf602008-10-29 00:13:59 +00003821
3822 // -- If the initializer expression
3823
Sebastian Redl4c0cd852009-03-29 15:27:50 +00003824 // Rvalue references cannot bind to lvalues (N2812).
3825 // There is absolutely no situation where they can. In particular, note that
3826 // this is ill-formed, even if B has a user-defined conversion to A&&:
3827 // B b;
3828 // A&& r = b;
3829 if (isRValRef && InitLvalue == Expr::LV_Valid) {
3830 if (!ICS)
Douglas Gregorc809cc22009-09-23 23:04:10 +00003831 Diag(DeclLoc, diag::err_lvalue_to_rvalue_ref)
Sebastian Redl4c0cd852009-03-29 15:27:50 +00003832 << Init->getSourceRange();
3833 return true;
3834 }
3835
Douglas Gregor8e1cf602008-10-29 00:13:59 +00003836 bool BindsDirectly = false;
Eli Friedman44b83ee2009-08-05 19:21:58 +00003837 // -- is an lvalue (but is not a bit-field), and "cv1 T1" is
3838 // reference-compatible with "cv2 T2," or
Douglas Gregor786ab212008-10-29 02:00:59 +00003839 //
3840 // Note that the bit-field check is skipped if we are just computing
3841 // the implicit conversion sequence (C++ [over.best.ics]p2).
Douglas Gregor71235ec2009-05-02 02:18:30 +00003842 if (InitLvalue == Expr::LV_Valid && (ICS || !Init->getBitField()) &&
Douglas Gregor786ab212008-10-29 02:00:59 +00003843 RefRelationship >= Ref_Compatible_With_Added_Qualification) {
Douglas Gregor8e1cf602008-10-29 00:13:59 +00003844 BindsDirectly = true;
3845
Douglas Gregor786ab212008-10-29 02:00:59 +00003846 if (ICS) {
3847 // C++ [over.ics.ref]p1:
3848 // When a parameter of reference type binds directly (8.5.3)
3849 // to an argument expression, the implicit conversion sequence
3850 // is the identity conversion, unless the argument expression
3851 // has a type that is a derived class of the parameter type,
3852 // in which case the implicit conversion sequence is a
3853 // derived-to-base Conversion (13.3.3.1).
3854 ICS->ConversionKind = ImplicitConversionSequence::StandardConversion;
3855 ICS->Standard.First = ICK_Identity;
3856 ICS->Standard.Second = DerivedToBase? ICK_Derived_To_Base : ICK_Identity;
3857 ICS->Standard.Third = ICK_Identity;
3858 ICS->Standard.FromTypePtr = T2.getAsOpaquePtr();
3859 ICS->Standard.ToTypePtr = T1.getAsOpaquePtr();
Douglas Gregoref30a5f2008-10-29 14:50:44 +00003860 ICS->Standard.ReferenceBinding = true;
3861 ICS->Standard.DirectBinding = true;
Sebastian Redl4c0cd852009-03-29 15:27:50 +00003862 ICS->Standard.RRefBinding = false;
Sebastian Redl5775af1a2009-04-17 16:30:52 +00003863 ICS->Standard.CopyConstructor = 0;
Douglas Gregor786ab212008-10-29 02:00:59 +00003864
3865 // Nothing more to do: the inaccessibility/ambiguity check for
3866 // derived-to-base conversions is suppressed when we're
3867 // computing the implicit conversion sequence (C++
3868 // [over.best.ics]p2).
3869 return false;
3870 } else {
3871 // Perform the conversion.
Douglas Gregor5d3507d2009-09-09 23:08:42 +00003872 CastExpr::CastKind CK = CastExpr::CK_NoOp;
3873 if (DerivedToBase)
3874 CK = CastExpr::CK_DerivedToBase;
Sebastian Redl5d431642009-10-10 12:04:10 +00003875 else if(CheckExceptionSpecCompatibility(Init, T1))
3876 return true;
Douglas Gregor5d3507d2009-09-09 23:08:42 +00003877 ImpCastExprToType(Init, T1, CK, /*isLvalue=*/true);
Douglas Gregor8e1cf602008-10-29 00:13:59 +00003878 }
3879 }
3880
3881 // -- has a class type (i.e., T2 is a class type) and can be
Eli Friedman44b83ee2009-08-05 19:21:58 +00003882 // implicitly converted to an lvalue of type "cv3 T3,"
3883 // where "cv1 T1" is reference-compatible with "cv3 T3"
Douglas Gregor8e1cf602008-10-29 00:13:59 +00003884 // 92) (this conversion is selected by enumerating the
3885 // applicable conversion functions (13.3.1.6) and choosing
3886 // the best one through overload resolution (13.3)),
Douglas Gregor8a2e6012009-08-24 15:23:48 +00003887 if (!isRValRef && !SuppressUserConversions && T2->isRecordType() &&
Douglas Gregorc02cfe22009-10-21 23:19:44 +00003888 !RequireCompleteType(DeclLoc, T2, 0)) {
Mike Stump11289f42009-09-09 15:08:12 +00003889 CXXRecordDecl *T2RecordDecl
Ted Kremenekc23c7e62009-07-29 21:53:49 +00003890 = dyn_cast<CXXRecordDecl>(T2->getAs<RecordType>()->getDecl());
Douglas Gregor8e1cf602008-10-29 00:13:59 +00003891
Douglas Gregorf52cdd02008-11-10 16:14:15 +00003892 OverloadCandidateSet CandidateSet;
John McCalld14a8642009-11-21 08:51:07 +00003893 const UnresolvedSet *Conversions
Fariborz Jahanianaf0262d2009-09-23 20:55:32 +00003894 = T2RecordDecl->getVisibleConversionFunctions();
John McCalld14a8642009-11-21 08:51:07 +00003895 for (UnresolvedSet::iterator I = Conversions->begin(),
3896 E = Conversions->end(); I != E; ++I) {
Mike Stump11289f42009-09-09 15:08:12 +00003897 FunctionTemplateDecl *ConvTemplate
John McCalld14a8642009-11-21 08:51:07 +00003898 = dyn_cast<FunctionTemplateDecl>(*I);
Douglas Gregor05155d82009-08-21 23:19:43 +00003899 CXXConversionDecl *Conv;
3900 if (ConvTemplate)
3901 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
3902 else
John McCalld14a8642009-11-21 08:51:07 +00003903 Conv = cast<CXXConversionDecl>(*I);
Fariborz Jahanianaf0262d2009-09-23 20:55:32 +00003904
Douglas Gregorf52cdd02008-11-10 16:14:15 +00003905 // If the conversion function doesn't return a reference type,
3906 // it can't be considered for this conversion.
Sebastian Redl0f8b23f2009-03-16 23:22:08 +00003907 if (Conv->getConversionType()->isLValueReferenceType() &&
Douglas Gregor05155d82009-08-21 23:19:43 +00003908 (AllowExplicit || !Conv->isExplicit())) {
3909 if (ConvTemplate)
Mike Stump11289f42009-09-09 15:08:12 +00003910 AddTemplateConversionCandidate(ConvTemplate, Init, DeclType,
Douglas Gregor05155d82009-08-21 23:19:43 +00003911 CandidateSet);
3912 else
3913 AddConversionCandidate(Conv, Init, DeclType, CandidateSet);
3914 }
Douglas Gregorf52cdd02008-11-10 16:14:15 +00003915 }
3916
3917 OverloadCandidateSet::iterator Best;
Douglas Gregorc809cc22009-09-23 23:04:10 +00003918 switch (BestViableFunction(CandidateSet, DeclLoc, Best)) {
Douglas Gregorf52cdd02008-11-10 16:14:15 +00003919 case OR_Success:
3920 // This is a direct binding.
3921 BindsDirectly = true;
3922
3923 if (ICS) {
3924 // C++ [over.ics.ref]p1:
3925 //
3926 // [...] If the parameter binds directly to the result of
3927 // applying a conversion function to the argument
3928 // expression, the implicit conversion sequence is a
3929 // user-defined conversion sequence (13.3.3.1.2), with the
3930 // second standard conversion sequence either an identity
3931 // conversion or, if the conversion function returns an
3932 // entity of a type that is a derived class of the parameter
3933 // type, a derived-to-base Conversion.
3934 ICS->ConversionKind = ImplicitConversionSequence::UserDefinedConversion;
3935 ICS->UserDefined.Before = Best->Conversions[0].Standard;
3936 ICS->UserDefined.After = Best->FinalConversion;
3937 ICS->UserDefined.ConversionFunction = Best->Function;
Fariborz Jahanian55824512009-11-06 00:23:08 +00003938 ICS->UserDefined.EllipsisConversion = false;
Douglas Gregorf52cdd02008-11-10 16:14:15 +00003939 assert(ICS->UserDefined.After.ReferenceBinding &&
3940 ICS->UserDefined.After.DirectBinding &&
3941 "Expected a direct reference binding!");
3942 return false;
3943 } else {
Fariborz Jahanian9ce90d12009-09-23 22:34:00 +00003944 OwningExprResult InitConversion =
Douglas Gregorc809cc22009-09-23 23:04:10 +00003945 BuildCXXCastArgument(DeclLoc, QualType(),
Fariborz Jahanian9ce90d12009-09-23 22:34:00 +00003946 CastExpr::CK_UserDefinedConversion,
3947 cast<CXXMethodDecl>(Best->Function),
3948 Owned(Init));
3949 Init = InitConversion.takeAs<Expr>();
Sebastian Redl5d431642009-10-10 12:04:10 +00003950
3951 if (CheckExceptionSpecCompatibility(Init, T1))
3952 return true;
Fariborz Jahanian9ce90d12009-09-23 22:34:00 +00003953 ImpCastExprToType(Init, T1, CastExpr::CK_UserDefinedConversion,
3954 /*isLvalue=*/true);
Douglas Gregorf52cdd02008-11-10 16:14:15 +00003955 }
3956 break;
3957
3958 case OR_Ambiguous:
Fariborz Jahanian31481d82009-10-14 00:52:43 +00003959 if (ICS) {
3960 for (OverloadCandidateSet::iterator Cand = CandidateSet.begin();
3961 Cand != CandidateSet.end(); ++Cand)
3962 if (Cand->Viable)
3963 ICS->ConversionFunctionSet.push_back(Cand->Function);
3964 break;
3965 }
3966 Diag(DeclLoc, diag::err_ref_init_ambiguous) << DeclType << Init->getType()
3967 << Init->getSourceRange();
3968 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
Douglas Gregorf52cdd02008-11-10 16:14:15 +00003969 return true;
Mike Stump11289f42009-09-09 15:08:12 +00003970
Douglas Gregorf52cdd02008-11-10 16:14:15 +00003971 case OR_No_Viable_Function:
Douglas Gregor171c45a2009-02-18 21:56:37 +00003972 case OR_Deleted:
3973 // There was no suitable conversion, or we found a deleted
3974 // conversion; continue with other checks.
Douglas Gregorf52cdd02008-11-10 16:14:15 +00003975 break;
3976 }
3977 }
Mike Stump11289f42009-09-09 15:08:12 +00003978
Douglas Gregor8e1cf602008-10-29 00:13:59 +00003979 if (BindsDirectly) {
3980 // C++ [dcl.init.ref]p4:
3981 // [...] In all cases where the reference-related or
3982 // reference-compatible relationship of two types is used to
3983 // establish the validity of a reference binding, and T1 is a
3984 // base class of T2, a program that necessitates such a binding
3985 // is ill-formed if T1 is an inaccessible (clause 11) or
3986 // ambiguous (10.2) base class of T2.
3987 //
3988 // Note that we only check this condition when we're allowed to
3989 // complain about errors, because we should not be checking for
3990 // ambiguity (or inaccessibility) unless the reference binding
3991 // actually happens.
Mike Stump11289f42009-09-09 15:08:12 +00003992 if (DerivedToBase)
Douglas Gregorc809cc22009-09-23 23:04:10 +00003993 return CheckDerivedToBaseConversion(T2, T1, DeclLoc,
Sebastian Redl7c353682009-11-14 21:15:49 +00003994 Init->getSourceRange(),
3995 IgnoreBaseAccess);
Douglas Gregor786ab212008-10-29 02:00:59 +00003996 else
3997 return false;
Douglas Gregor8e1cf602008-10-29 00:13:59 +00003998 }
3999
4000 // -- Otherwise, the reference shall be to a non-volatile const
Sebastian Redl4c0cd852009-03-29 15:27:50 +00004001 // type (i.e., cv1 shall be const), or the reference shall be an
4002 // rvalue reference and the initializer expression shall be an rvalue.
John McCall8ccfcb52009-09-24 19:53:00 +00004003 if (!isRValRef && T1.getCVRQualifiers() != Qualifiers::Const) {
Douglas Gregor786ab212008-10-29 02:00:59 +00004004 if (!ICS)
Douglas Gregorc809cc22009-09-23 23:04:10 +00004005 Diag(DeclLoc, diag::err_not_reference_to_const_init)
Chris Lattner1e5665e2008-11-24 06:25:27 +00004006 << T1 << (InitLvalue != Expr::LV_Valid? "temporary" : "value")
4007 << T2 << Init->getSourceRange();
Douglas Gregor8e1cf602008-10-29 00:13:59 +00004008 return true;
4009 }
4010
4011 // -- If the initializer expression is an rvalue, with T2 a
Eli Friedman44b83ee2009-08-05 19:21:58 +00004012 // class type, and "cv1 T1" is reference-compatible with
4013 // "cv2 T2," the reference is bound in one of the
Douglas Gregor8e1cf602008-10-29 00:13:59 +00004014 // following ways (the choice is implementation-defined):
4015 //
4016 // -- The reference is bound to the object represented by
4017 // the rvalue (see 3.10) or to a sub-object within that
4018 // object.
4019 //
Eli Friedman44b83ee2009-08-05 19:21:58 +00004020 // -- A temporary of type "cv1 T2" [sic] is created, and
Douglas Gregor8e1cf602008-10-29 00:13:59 +00004021 // a constructor is called to copy the entire rvalue
4022 // object into the temporary. The reference is bound to
4023 // the temporary or to a sub-object within the
4024 // temporary.
4025 //
Douglas Gregor8e1cf602008-10-29 00:13:59 +00004026 // The constructor that would be used to make the copy
4027 // shall be callable whether or not the copy is actually
4028 // done.
4029 //
Sebastian Redl4c0cd852009-03-29 15:27:50 +00004030 // Note that C++0x [dcl.init.ref]p5 takes away this implementation
Douglas Gregor8e1cf602008-10-29 00:13:59 +00004031 // freedom, so we will always take the first option and never build
4032 // a temporary in this case. FIXME: We will, however, have to check
4033 // for the presence of a copy constructor in C++98/03 mode.
4034 if (InitLvalue != Expr::LV_Valid && T2->isRecordType() &&
Douglas Gregor786ab212008-10-29 02:00:59 +00004035 RefRelationship >= Ref_Compatible_With_Added_Qualification) {
4036 if (ICS) {
4037 ICS->ConversionKind = ImplicitConversionSequence::StandardConversion;
4038 ICS->Standard.First = ICK_Identity;
4039 ICS->Standard.Second = DerivedToBase? ICK_Derived_To_Base : ICK_Identity;
4040 ICS->Standard.Third = ICK_Identity;
4041 ICS->Standard.FromTypePtr = T2.getAsOpaquePtr();
4042 ICS->Standard.ToTypePtr = T1.getAsOpaquePtr();
Douglas Gregoref30a5f2008-10-29 14:50:44 +00004043 ICS->Standard.ReferenceBinding = true;
Sebastian Redl4c0cd852009-03-29 15:27:50 +00004044 ICS->Standard.DirectBinding = false;
4045 ICS->Standard.RRefBinding = isRValRef;
Sebastian Redl5775af1a2009-04-17 16:30:52 +00004046 ICS->Standard.CopyConstructor = 0;
Douglas Gregor786ab212008-10-29 02:00:59 +00004047 } else {
Douglas Gregor5d3507d2009-09-09 23:08:42 +00004048 CastExpr::CastKind CK = CastExpr::CK_NoOp;
4049 if (DerivedToBase)
4050 CK = CastExpr::CK_DerivedToBase;
Sebastian Redl5d431642009-10-10 12:04:10 +00004051 else if(CheckExceptionSpecCompatibility(Init, T1))
4052 return true;
Douglas Gregor5d3507d2009-09-09 23:08:42 +00004053 ImpCastExprToType(Init, T1, CK, /*isLvalue=*/false);
Douglas Gregor8e1cf602008-10-29 00:13:59 +00004054 }
4055 return false;
4056 }
4057
Eli Friedman44b83ee2009-08-05 19:21:58 +00004058 // -- Otherwise, a temporary of type "cv1 T1" is created and
Douglas Gregor8e1cf602008-10-29 00:13:59 +00004059 // initialized from the initializer expression using the
4060 // rules for a non-reference copy initialization (8.5). The
4061 // reference is then bound to the temporary. If T1 is
4062 // reference-related to T2, cv1 must be the same
4063 // cv-qualification as, or greater cv-qualification than,
4064 // cv2; otherwise, the program is ill-formed.
4065 if (RefRelationship == Ref_Related) {
4066 // If cv1 == cv2 or cv1 is a greater cv-qualified than cv2, then
4067 // we would be reference-compatible or reference-compatible with
4068 // added qualification. But that wasn't the case, so the reference
4069 // initialization fails.
Douglas Gregor786ab212008-10-29 02:00:59 +00004070 if (!ICS)
Douglas Gregorc809cc22009-09-23 23:04:10 +00004071 Diag(DeclLoc, diag::err_reference_init_drops_quals)
Chris Lattner1e5665e2008-11-24 06:25:27 +00004072 << T1 << (InitLvalue != Expr::LV_Valid? "temporary" : "value")
4073 << T2 << Init->getSourceRange();
Douglas Gregor8e1cf602008-10-29 00:13:59 +00004074 return true;
4075 }
4076
Douglas Gregor576e98c2009-01-30 23:27:23 +00004077 // If at least one of the types is a class type, the types are not
4078 // related, and we aren't allowed any user conversions, the
4079 // reference binding fails. This case is important for breaking
4080 // recursion, since TryImplicitConversion below will attempt to
4081 // create a temporary through the use of a copy constructor.
4082 if (SuppressUserConversions && RefRelationship == Ref_Incompatible &&
4083 (T1->isRecordType() || T2->isRecordType())) {
4084 if (!ICS)
Douglas Gregorc809cc22009-09-23 23:04:10 +00004085 Diag(DeclLoc, diag::err_typecheck_convert_incompatible)
Douglas Gregor576e98c2009-01-30 23:27:23 +00004086 << DeclType << Init->getType() << "initializing" << Init->getSourceRange();
4087 return true;
4088 }
4089
Douglas Gregor8e1cf602008-10-29 00:13:59 +00004090 // Actually try to convert the initializer to T1.
Douglas Gregor786ab212008-10-29 02:00:59 +00004091 if (ICS) {
Sebastian Redl4c0cd852009-03-29 15:27:50 +00004092 // C++ [over.ics.ref]p2:
Mike Stump11289f42009-09-09 15:08:12 +00004093 //
Sebastian Redl4c0cd852009-03-29 15:27:50 +00004094 // When a parameter of reference type is not bound directly to
4095 // an argument expression, the conversion sequence is the one
4096 // required to convert the argument expression to the
4097 // underlying type of the reference according to
4098 // 13.3.3.1. Conceptually, this conversion sequence corresponds
4099 // to copy-initializing a temporary of the underlying type with
4100 // the argument expression. Any difference in top-level
4101 // cv-qualification is subsumed by the initialization itself
4102 // and does not constitute a conversion.
Anders Carlssonef4c7212009-08-27 17:24:15 +00004103 *ICS = TryImplicitConversion(Init, T1, SuppressUserConversions,
4104 /*AllowExplicit=*/false,
Anders Carlsson228eea32009-08-28 15:33:32 +00004105 /*ForceRValue=*/false,
4106 /*InOverloadResolution=*/false);
Mike Stump11289f42009-09-09 15:08:12 +00004107
Sebastian Redl4c0cd852009-03-29 15:27:50 +00004108 // Of course, that's still a reference binding.
4109 if (ICS->ConversionKind == ImplicitConversionSequence::StandardConversion) {
4110 ICS->Standard.ReferenceBinding = true;
4111 ICS->Standard.RRefBinding = isRValRef;
Mike Stump11289f42009-09-09 15:08:12 +00004112 } else if (ICS->ConversionKind ==
Sebastian Redl4c0cd852009-03-29 15:27:50 +00004113 ImplicitConversionSequence::UserDefinedConversion) {
4114 ICS->UserDefined.After.ReferenceBinding = true;
4115 ICS->UserDefined.After.RRefBinding = isRValRef;
4116 }
Douglas Gregor786ab212008-10-29 02:00:59 +00004117 return ICS->ConversionKind == ImplicitConversionSequence::BadConversion;
4118 } else {
Fariborz Jahanianaf0262d2009-09-23 20:55:32 +00004119 ImplicitConversionSequence Conversions;
4120 bool badConversion = PerformImplicitConversion(Init, T1, "initializing",
4121 false, false,
4122 Conversions);
4123 if (badConversion) {
4124 if ((Conversions.ConversionKind ==
4125 ImplicitConversionSequence::BadConversion)
Fariborz Jahanian9021fc72009-09-28 22:03:07 +00004126 && !Conversions.ConversionFunctionSet.empty()) {
Fariborz Jahanian20327b02009-09-24 00:42:43 +00004127 Diag(DeclLoc,
Fariborz Jahanianaf0262d2009-09-23 20:55:32 +00004128 diag::err_lvalue_to_rvalue_ambig_ref) << Init->getSourceRange();
4129 for (int j = Conversions.ConversionFunctionSet.size()-1;
4130 j >= 0; j--) {
4131 FunctionDecl *Func = Conversions.ConversionFunctionSet[j];
4132 Diag(Func->getLocation(), diag::err_ovl_candidate);
4133 }
4134 }
Fariborz Jahaniandb823082009-09-30 21:23:30 +00004135 else {
4136 if (isRValRef)
4137 Diag(DeclLoc, diag::err_lvalue_to_rvalue_ref)
4138 << Init->getSourceRange();
4139 else
4140 Diag(DeclLoc, diag::err_invalid_initialization)
4141 << DeclType << Init->getType() << Init->getSourceRange();
4142 }
Fariborz Jahanianaf0262d2009-09-23 20:55:32 +00004143 }
4144 return badConversion;
Douglas Gregor786ab212008-10-29 02:00:59 +00004145 }
Douglas Gregor8e1cf602008-10-29 00:13:59 +00004146}
Douglas Gregor11d0c4c2008-11-06 22:13:31 +00004147
4148/// CheckOverloadedOperatorDeclaration - Check whether the declaration
4149/// of this overloaded operator is well-formed. If so, returns false;
4150/// otherwise, emits appropriate diagnostics and returns true.
4151bool Sema::CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl) {
Douglas Gregord69246b2008-11-17 16:14:12 +00004152 assert(FnDecl && FnDecl->isOverloadedOperator() &&
Douglas Gregor11d0c4c2008-11-06 22:13:31 +00004153 "Expected an overloaded operator declaration");
4154
Douglas Gregor11d0c4c2008-11-06 22:13:31 +00004155 OverloadedOperatorKind Op = FnDecl->getOverloadedOperator();
4156
Mike Stump11289f42009-09-09 15:08:12 +00004157 // C++ [over.oper]p5:
Douglas Gregor11d0c4c2008-11-06 22:13:31 +00004158 // The allocation and deallocation functions, operator new,
4159 // operator new[], operator delete and operator delete[], are
4160 // described completely in 3.7.3. The attributes and restrictions
4161 // found in the rest of this subclause do not apply to them unless
4162 // explicitly stated in 3.7.3.
Mike Stump87c57ac2009-05-16 07:39:55 +00004163 // FIXME: Write a separate routine for checking this. For now, just allow it.
Fariborz Jahanian4e088942009-11-10 23:47:18 +00004164 if (Op == OO_Delete || Op == OO_Array_Delete)
Douglas Gregor11d0c4c2008-11-06 22:13:31 +00004165 return false;
Fariborz Jahanian4e088942009-11-10 23:47:18 +00004166
4167 if (Op == OO_New || Op == OO_Array_New) {
4168 bool ret = false;
4169 if (FunctionDecl::param_iterator Param = FnDecl->param_begin()) {
4170 QualType SizeTy = Context.getCanonicalType(Context.getSizeType());
4171 QualType T = Context.getCanonicalType((*Param)->getType());
4172 if (!T->isDependentType() && SizeTy != T) {
4173 Diag(FnDecl->getLocation(),
4174 diag::err_operator_new_param_type) << FnDecl->getDeclName()
4175 << SizeTy;
4176 ret = true;
4177 }
4178 }
4179 QualType ResultTy = Context.getCanonicalType(FnDecl->getResultType());
4180 if (!ResultTy->isDependentType() && ResultTy != Context.VoidPtrTy)
4181 return Diag(FnDecl->getLocation(),
4182 diag::err_operator_new_result_type) << FnDecl->getDeclName()
Douglas Gregor6051c8d2009-11-12 16:49:45 +00004183 << static_cast<QualType>(Context.VoidPtrTy);
Fariborz Jahanian4e088942009-11-10 23:47:18 +00004184 return ret;
4185 }
Douglas Gregor11d0c4c2008-11-06 22:13:31 +00004186
4187 // C++ [over.oper]p6:
4188 // An operator function shall either be a non-static member
4189 // function or be a non-member function and have at least one
4190 // parameter whose type is a class, a reference to a class, an
4191 // enumeration, or a reference to an enumeration.
Douglas Gregord69246b2008-11-17 16:14:12 +00004192 if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) {
4193 if (MethodDecl->isStatic())
4194 return Diag(FnDecl->getLocation(),
Chris Lattnerf3d3fae2008-11-24 05:29:24 +00004195 diag::err_operator_overload_static) << FnDecl->getDeclName();
Douglas Gregor11d0c4c2008-11-06 22:13:31 +00004196 } else {
4197 bool ClassOrEnumParam = false;
Douglas Gregord69246b2008-11-17 16:14:12 +00004198 for (FunctionDecl::param_iterator Param = FnDecl->param_begin(),
4199 ParamEnd = FnDecl->param_end();
4200 Param != ParamEnd; ++Param) {
4201 QualType ParamType = (*Param)->getType().getNonReferenceType();
Eli Friedman173e0b7a2009-06-27 05:59:59 +00004202 if (ParamType->isDependentType() || ParamType->isRecordType() ||
4203 ParamType->isEnumeralType()) {
Douglas Gregor11d0c4c2008-11-06 22:13:31 +00004204 ClassOrEnumParam = true;
4205 break;
4206 }
4207 }
4208
Douglas Gregord69246b2008-11-17 16:14:12 +00004209 if (!ClassOrEnumParam)
4210 return Diag(FnDecl->getLocation(),
Chris Lattner651d42d2008-11-20 06:38:18 +00004211 diag::err_operator_overload_needs_class_or_enum)
Chris Lattnerf3d3fae2008-11-24 05:29:24 +00004212 << FnDecl->getDeclName();
Douglas Gregor11d0c4c2008-11-06 22:13:31 +00004213 }
4214
4215 // C++ [over.oper]p8:
4216 // An operator function cannot have default arguments (8.3.6),
4217 // except where explicitly stated below.
4218 //
Mike Stump11289f42009-09-09 15:08:12 +00004219 // Only the function-call operator allows default arguments
Douglas Gregor11d0c4c2008-11-06 22:13:31 +00004220 // (C++ [over.call]p1).
4221 if (Op != OO_Call) {
4222 for (FunctionDecl::param_iterator Param = FnDecl->param_begin();
4223 Param != FnDecl->param_end(); ++Param) {
Douglas Gregor58354032008-12-24 00:01:03 +00004224 if ((*Param)->hasUnparsedDefaultArg())
Mike Stump11289f42009-09-09 15:08:12 +00004225 return Diag((*Param)->getLocation(),
Douglas Gregor58354032008-12-24 00:01:03 +00004226 diag::err_operator_overload_default_arg)
4227 << FnDecl->getDeclName();
4228 else if (Expr *DefArg = (*Param)->getDefaultArg())
Douglas Gregord69246b2008-11-17 16:14:12 +00004229 return Diag((*Param)->getLocation(),
Chris Lattner29e812b2008-11-20 06:06:08 +00004230 diag::err_operator_overload_default_arg)
Chris Lattnerf3d3fae2008-11-24 05:29:24 +00004231 << FnDecl->getDeclName() << DefArg->getSourceRange();
Douglas Gregor11d0c4c2008-11-06 22:13:31 +00004232 }
4233 }
4234
Douglas Gregor6cf08062008-11-10 13:38:07 +00004235 static const bool OperatorUses[NUM_OVERLOADED_OPERATORS][3] = {
4236 { false, false, false }
4237#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
4238 , { Unary, Binary, MemberOnly }
4239#include "clang/Basic/OperatorKinds.def"
4240 };
Douglas Gregor11d0c4c2008-11-06 22:13:31 +00004241
Douglas Gregor6cf08062008-11-10 13:38:07 +00004242 bool CanBeUnaryOperator = OperatorUses[Op][0];
4243 bool CanBeBinaryOperator = OperatorUses[Op][1];
4244 bool MustBeMemberOperator = OperatorUses[Op][2];
Douglas Gregor11d0c4c2008-11-06 22:13:31 +00004245
4246 // C++ [over.oper]p8:
4247 // [...] Operator functions cannot have more or fewer parameters
4248 // than the number required for the corresponding operator, as
4249 // described in the rest of this subclause.
Mike Stump11289f42009-09-09 15:08:12 +00004250 unsigned NumParams = FnDecl->getNumParams()
Douglas Gregord69246b2008-11-17 16:14:12 +00004251 + (isa<CXXMethodDecl>(FnDecl)? 1 : 0);
Douglas Gregor11d0c4c2008-11-06 22:13:31 +00004252 if (Op != OO_Call &&
4253 ((NumParams == 1 && !CanBeUnaryOperator) ||
4254 (NumParams == 2 && !CanBeBinaryOperator) ||
4255 (NumParams < 1) || (NumParams > 2))) {
4256 // We have the wrong number of parameters.
Chris Lattnerc5bab9f2008-11-21 07:57:12 +00004257 unsigned ErrorKind;
Douglas Gregor6cf08062008-11-10 13:38:07 +00004258 if (CanBeUnaryOperator && CanBeBinaryOperator) {
Chris Lattnerc5bab9f2008-11-21 07:57:12 +00004259 ErrorKind = 2; // 2 -> unary or binary.
Douglas Gregor6cf08062008-11-10 13:38:07 +00004260 } else if (CanBeUnaryOperator) {
Chris Lattnerc5bab9f2008-11-21 07:57:12 +00004261 ErrorKind = 0; // 0 -> unary
Douglas Gregor6cf08062008-11-10 13:38:07 +00004262 } else {
Chris Lattner2b786902008-11-21 07:50:02 +00004263 assert(CanBeBinaryOperator &&
4264 "All non-call overloaded operators are unary or binary!");
Chris Lattnerc5bab9f2008-11-21 07:57:12 +00004265 ErrorKind = 1; // 1 -> binary
Douglas Gregor6cf08062008-11-10 13:38:07 +00004266 }
Douglas Gregor11d0c4c2008-11-06 22:13:31 +00004267
Chris Lattnerc5bab9f2008-11-21 07:57:12 +00004268 return Diag(FnDecl->getLocation(), diag::err_operator_overload_must_be)
Chris Lattnerf3d3fae2008-11-24 05:29:24 +00004269 << FnDecl->getDeclName() << NumParams << ErrorKind;
Douglas Gregor11d0c4c2008-11-06 22:13:31 +00004270 }
Sebastian Redlbaad4e72009-01-05 20:52:13 +00004271
Douglas Gregord69246b2008-11-17 16:14:12 +00004272 // Overloaded operators other than operator() cannot be variadic.
4273 if (Op != OO_Call &&
John McCall9dd450b2009-09-21 23:43:11 +00004274 FnDecl->getType()->getAs<FunctionProtoType>()->isVariadic()) {
Chris Lattner651d42d2008-11-20 06:38:18 +00004275 return Diag(FnDecl->getLocation(), diag::err_operator_overload_variadic)
Chris Lattnerf3d3fae2008-11-24 05:29:24 +00004276 << FnDecl->getDeclName();
Douglas Gregor11d0c4c2008-11-06 22:13:31 +00004277 }
4278
4279 // Some operators must be non-static member functions.
Douglas Gregord69246b2008-11-17 16:14:12 +00004280 if (MustBeMemberOperator && !isa<CXXMethodDecl>(FnDecl)) {
4281 return Diag(FnDecl->getLocation(),
Chris Lattner651d42d2008-11-20 06:38:18 +00004282 diag::err_operator_overload_must_be_member)
Chris Lattnerf3d3fae2008-11-24 05:29:24 +00004283 << FnDecl->getDeclName();
Douglas Gregor11d0c4c2008-11-06 22:13:31 +00004284 }
4285
4286 // C++ [over.inc]p1:
4287 // The user-defined function called operator++ implements the
4288 // prefix and postfix ++ operator. If this function is a member
4289 // function with no parameters, or a non-member function with one
4290 // parameter of class or enumeration type, it defines the prefix
4291 // increment operator ++ for objects of that type. If the function
4292 // is a member function with one parameter (which shall be of type
4293 // int) or a non-member function with two parameters (the second
4294 // of which shall be of type int), it defines the postfix
4295 // increment operator ++ for objects of that type.
4296 if ((Op == OO_PlusPlus || Op == OO_MinusMinus) && NumParams == 2) {
4297 ParmVarDecl *LastParam = FnDecl->getParamDecl(FnDecl->getNumParams() - 1);
4298 bool ParamIsInt = false;
John McCall9dd450b2009-09-21 23:43:11 +00004299 if (const BuiltinType *BT = LastParam->getType()->getAs<BuiltinType>())
Douglas Gregor11d0c4c2008-11-06 22:13:31 +00004300 ParamIsInt = BT->getKind() == BuiltinType::Int;
4301
Chris Lattner2b786902008-11-21 07:50:02 +00004302 if (!ParamIsInt)
4303 return Diag(LastParam->getLocation(),
Mike Stump11289f42009-09-09 15:08:12 +00004304 diag::err_operator_overload_post_incdec_must_be_int)
Chris Lattner1e5665e2008-11-24 06:25:27 +00004305 << LastParam->getType() << (Op == OO_MinusMinus);
Douglas Gregor11d0c4c2008-11-06 22:13:31 +00004306 }
4307
Sebastian Redlbaad4e72009-01-05 20:52:13 +00004308 // Notify the class if it got an assignment operator.
4309 if (Op == OO_Equal) {
4310 // Would have returned earlier otherwise.
4311 assert(isa<CXXMethodDecl>(FnDecl) &&
4312 "Overloaded = not member, but not filtered.");
4313 CXXMethodDecl *Method = cast<CXXMethodDecl>(FnDecl);
4314 Method->getParent()->addedAssignmentOperator(Context, Method);
4315 }
4316
Douglas Gregord69246b2008-11-17 16:14:12 +00004317 return false;
Douglas Gregor11d0c4c2008-11-06 22:13:31 +00004318}
Chris Lattner3b024a32008-12-17 07:09:26 +00004319
Douglas Gregor07665a62009-01-05 19:45:36 +00004320/// ActOnStartLinkageSpecification - Parsed the beginning of a C++
4321/// linkage specification, including the language and (if present)
4322/// the '{'. ExternLoc is the location of the 'extern', LangLoc is
4323/// the location of the language string literal, which is provided
4324/// by Lang/StrSize. LBraceLoc, if valid, provides the location of
4325/// the '{' brace. Otherwise, this linkage specification does not
4326/// have any braces.
Chris Lattner83f095c2009-03-28 19:18:32 +00004327Sema::DeclPtrTy Sema::ActOnStartLinkageSpecification(Scope *S,
4328 SourceLocation ExternLoc,
4329 SourceLocation LangLoc,
4330 const char *Lang,
4331 unsigned StrSize,
4332 SourceLocation LBraceLoc) {
Chris Lattner438e5012008-12-17 07:13:27 +00004333 LinkageSpecDecl::LanguageIDs Language;
4334 if (strncmp(Lang, "\"C\"", StrSize) == 0)
4335 Language = LinkageSpecDecl::lang_c;
4336 else if (strncmp(Lang, "\"C++\"", StrSize) == 0)
4337 Language = LinkageSpecDecl::lang_cxx;
4338 else {
Douglas Gregor07665a62009-01-05 19:45:36 +00004339 Diag(LangLoc, diag::err_bad_language);
Chris Lattner83f095c2009-03-28 19:18:32 +00004340 return DeclPtrTy();
Chris Lattner438e5012008-12-17 07:13:27 +00004341 }
Mike Stump11289f42009-09-09 15:08:12 +00004342
Chris Lattner438e5012008-12-17 07:13:27 +00004343 // FIXME: Add all the various semantics of linkage specifications
Mike Stump11289f42009-09-09 15:08:12 +00004344
Douglas Gregor07665a62009-01-05 19:45:36 +00004345 LinkageSpecDecl *D = LinkageSpecDecl::Create(Context, CurContext,
Mike Stump11289f42009-09-09 15:08:12 +00004346 LangLoc, Language,
Douglas Gregor07665a62009-01-05 19:45:36 +00004347 LBraceLoc.isValid());
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00004348 CurContext->addDecl(D);
Douglas Gregor07665a62009-01-05 19:45:36 +00004349 PushDeclContext(S, D);
Chris Lattner83f095c2009-03-28 19:18:32 +00004350 return DeclPtrTy::make(D);
Chris Lattner438e5012008-12-17 07:13:27 +00004351}
4352
Douglas Gregor07665a62009-01-05 19:45:36 +00004353/// ActOnFinishLinkageSpecification - Completely the definition of
4354/// the C++ linkage specification LinkageSpec. If RBraceLoc is
4355/// valid, it's the position of the closing '}' brace in a linkage
4356/// specification that uses braces.
Chris Lattner83f095c2009-03-28 19:18:32 +00004357Sema::DeclPtrTy Sema::ActOnFinishLinkageSpecification(Scope *S,
4358 DeclPtrTy LinkageSpec,
4359 SourceLocation RBraceLoc) {
Douglas Gregor07665a62009-01-05 19:45:36 +00004360 if (LinkageSpec)
4361 PopDeclContext();
4362 return LinkageSpec;
Chris Lattner3b024a32008-12-17 07:09:26 +00004363}
4364
Douglas Gregor5e16fbe2009-05-18 20:51:54 +00004365/// \brief Perform semantic analysis for the variable declaration that
4366/// occurs within a C++ catch clause, returning the newly-created
4367/// variable.
4368VarDecl *Sema::BuildExceptionDeclaration(Scope *S, QualType ExDeclType,
Argyrios Kyrtzidis60ed5602009-08-19 01:27:57 +00004369 DeclaratorInfo *DInfo,
Douglas Gregor5e16fbe2009-05-18 20:51:54 +00004370 IdentifierInfo *Name,
4371 SourceLocation Loc,
4372 SourceRange Range) {
4373 bool Invalid = false;
Sebastian Redl54c04d42008-12-22 19:15:10 +00004374
4375 // Arrays and functions decay.
4376 if (ExDeclType->isArrayType())
4377 ExDeclType = Context.getArrayDecayedType(ExDeclType);
4378 else if (ExDeclType->isFunctionType())
4379 ExDeclType = Context.getPointerType(ExDeclType);
4380
4381 // C++ 15.3p1: The exception-declaration shall not denote an incomplete type.
4382 // The exception-declaration shall not denote a pointer or reference to an
4383 // incomplete type, other than [cv] void*.
Sebastian Redlb28b4072009-03-22 23:49:27 +00004384 // N2844 forbids rvalue references.
Mike Stump11289f42009-09-09 15:08:12 +00004385 if (!ExDeclType->isDependentType() && ExDeclType->isRValueReferenceType()) {
Douglas Gregor5e16fbe2009-05-18 20:51:54 +00004386 Diag(Loc, diag::err_catch_rvalue_ref) << Range;
Sebastian Redlb28b4072009-03-22 23:49:27 +00004387 Invalid = true;
4388 }
Douglas Gregor5e16fbe2009-05-18 20:51:54 +00004389
Sebastian Redl54c04d42008-12-22 19:15:10 +00004390 QualType BaseType = ExDeclType;
4391 int Mode = 0; // 0 for direct type, 1 for pointer, 2 for reference
Douglas Gregordd430f72009-01-19 19:26:10 +00004392 unsigned DK = diag::err_catch_incomplete;
Ted Kremenekc23c7e62009-07-29 21:53:49 +00004393 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) {
Sebastian Redl54c04d42008-12-22 19:15:10 +00004394 BaseType = Ptr->getPointeeType();
4395 Mode = 1;
Douglas Gregordd430f72009-01-19 19:26:10 +00004396 DK = diag::err_catch_incomplete_ptr;
Mike Stump11289f42009-09-09 15:08:12 +00004397 } else if (const ReferenceType *Ref = BaseType->getAs<ReferenceType>()) {
Sebastian Redlb28b4072009-03-22 23:49:27 +00004398 // For the purpose of error recovery, we treat rvalue refs like lvalue refs.
Sebastian Redl54c04d42008-12-22 19:15:10 +00004399 BaseType = Ref->getPointeeType();
4400 Mode = 2;
Douglas Gregordd430f72009-01-19 19:26:10 +00004401 DK = diag::err_catch_incomplete_ref;
Sebastian Redl54c04d42008-12-22 19:15:10 +00004402 }
Sebastian Redlb28b4072009-03-22 23:49:27 +00004403 if (!Invalid && (Mode == 0 || !BaseType->isVoidType()) &&
Douglas Gregor5e16fbe2009-05-18 20:51:54 +00004404 !BaseType->isDependentType() && RequireCompleteType(Loc, BaseType, DK))
Sebastian Redl54c04d42008-12-22 19:15:10 +00004405 Invalid = true;
Sebastian Redl54c04d42008-12-22 19:15:10 +00004406
Mike Stump11289f42009-09-09 15:08:12 +00004407 if (!Invalid && !ExDeclType->isDependentType() &&
Douglas Gregor5e16fbe2009-05-18 20:51:54 +00004408 RequireNonAbstractType(Loc, ExDeclType,
4409 diag::err_abstract_type_in_decl,
4410 AbstractVariableType))
Sebastian Redl2f38ba52009-04-27 21:03:30 +00004411 Invalid = true;
4412
Douglas Gregor5e16fbe2009-05-18 20:51:54 +00004413 // FIXME: Need to test for ability to copy-construct and destroy the
4414 // exception variable.
4415
Sebastian Redl9b244a82008-12-22 21:35:02 +00004416 // FIXME: Need to check for abstract classes.
4417
Mike Stump11289f42009-09-09 15:08:12 +00004418 VarDecl *ExDecl = VarDecl::Create(Context, CurContext, Loc,
Argyrios Kyrtzidis6032ef12009-08-21 00:31:54 +00004419 Name, ExDeclType, DInfo, VarDecl::None);
Douglas Gregor5e16fbe2009-05-18 20:51:54 +00004420
4421 if (Invalid)
4422 ExDecl->setInvalidDecl();
4423
4424 return ExDecl;
4425}
4426
4427/// ActOnExceptionDeclarator - Parsed the exception-declarator in a C++ catch
4428/// handler.
4429Sema::DeclPtrTy Sema::ActOnExceptionDeclarator(Scope *S, Declarator &D) {
Argyrios Kyrtzidis60ed5602009-08-19 01:27:57 +00004430 DeclaratorInfo *DInfo = 0;
4431 QualType ExDeclType = GetTypeForDeclarator(D, S, &DInfo);
Douglas Gregor5e16fbe2009-05-18 20:51:54 +00004432
4433 bool Invalid = D.isInvalidType();
Sebastian Redl54c04d42008-12-22 19:15:10 +00004434 IdentifierInfo *II = D.getIdentifier();
John McCall9f3059a2009-10-09 21:13:30 +00004435 if (NamedDecl *PrevDecl = LookupSingleName(S, II, LookupOrdinaryName)) {
Sebastian Redl54c04d42008-12-22 19:15:10 +00004436 // The scope should be freshly made just for us. There is just no way
4437 // it contains any previous declaration.
Chris Lattner83f095c2009-03-28 19:18:32 +00004438 assert(!S->isDeclScope(DeclPtrTy::make(PrevDecl)));
Sebastian Redl54c04d42008-12-22 19:15:10 +00004439 if (PrevDecl->isTemplateParameter()) {
4440 // Maybe we will complain about the shadowed template parameter.
4441 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
Sebastian Redl54c04d42008-12-22 19:15:10 +00004442 }
4443 }
4444
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00004445 if (D.getCXXScopeSpec().isSet() && !Invalid) {
Sebastian Redl54c04d42008-12-22 19:15:10 +00004446 Diag(D.getIdentifierLoc(), diag::err_qualified_catch_declarator)
4447 << D.getCXXScopeSpec().getRange();
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00004448 Invalid = true;
Sebastian Redl54c04d42008-12-22 19:15:10 +00004449 }
4450
Argyrios Kyrtzidis60ed5602009-08-19 01:27:57 +00004451 VarDecl *ExDecl = BuildExceptionDeclaration(S, ExDeclType, DInfo,
Douglas Gregor5e16fbe2009-05-18 20:51:54 +00004452 D.getIdentifier(),
4453 D.getIdentifierLoc(),
4454 D.getDeclSpec().getSourceRange());
4455
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00004456 if (Invalid)
4457 ExDecl->setInvalidDecl();
Mike Stump11289f42009-09-09 15:08:12 +00004458
Sebastian Redl54c04d42008-12-22 19:15:10 +00004459 // Add the exception declaration into this scope.
Sebastian Redl54c04d42008-12-22 19:15:10 +00004460 if (II)
Douglas Gregor5e16fbe2009-05-18 20:51:54 +00004461 PushOnScopeChains(ExDecl, S);
4462 else
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00004463 CurContext->addDecl(ExDecl);
Sebastian Redl54c04d42008-12-22 19:15:10 +00004464
Douglas Gregor758a8692009-06-17 21:51:59 +00004465 ProcessDeclAttributes(S, ExDecl, D);
Chris Lattner83f095c2009-03-28 19:18:32 +00004466 return DeclPtrTy::make(ExDecl);
Sebastian Redl54c04d42008-12-22 19:15:10 +00004467}
Anders Carlsson5bbe1d72009-03-14 00:25:26 +00004468
Mike Stump11289f42009-09-09 15:08:12 +00004469Sema::DeclPtrTy Sema::ActOnStaticAssertDeclaration(SourceLocation AssertLoc,
Chris Lattner83f095c2009-03-28 19:18:32 +00004470 ExprArg assertexpr,
4471 ExprArg assertmessageexpr) {
Anders Carlsson5bbe1d72009-03-14 00:25:26 +00004472 Expr *AssertExpr = (Expr *)assertexpr.get();
Mike Stump11289f42009-09-09 15:08:12 +00004473 StringLiteral *AssertMessage =
Anders Carlsson5bbe1d72009-03-14 00:25:26 +00004474 cast<StringLiteral>((Expr *)assertmessageexpr.get());
4475
Anders Carlsson54b26982009-03-14 00:33:21 +00004476 if (!AssertExpr->isTypeDependent() && !AssertExpr->isValueDependent()) {
4477 llvm::APSInt Value(32);
4478 if (!AssertExpr->isIntegerConstantExpr(Value, Context)) {
4479 Diag(AssertLoc, diag::err_static_assert_expression_is_not_constant) <<
4480 AssertExpr->getSourceRange();
Chris Lattner83f095c2009-03-28 19:18:32 +00004481 return DeclPtrTy();
Anders Carlsson54b26982009-03-14 00:33:21 +00004482 }
Anders Carlsson5bbe1d72009-03-14 00:25:26 +00004483
Anders Carlsson54b26982009-03-14 00:33:21 +00004484 if (Value == 0) {
Mike Stump11289f42009-09-09 15:08:12 +00004485 std::string str(AssertMessage->getStrData(),
Anders Carlsson54b26982009-03-14 00:33:21 +00004486 AssertMessage->getByteLength());
Mike Stump11289f42009-09-09 15:08:12 +00004487 Diag(AssertLoc, diag::err_static_assert_failed)
Anders Carlsson27de6a52009-03-15 18:44:04 +00004488 << str << AssertExpr->getSourceRange();
Anders Carlsson54b26982009-03-14 00:33:21 +00004489 }
4490 }
Mike Stump11289f42009-09-09 15:08:12 +00004491
Anders Carlsson78e2bc02009-03-15 17:35:16 +00004492 assertexpr.release();
4493 assertmessageexpr.release();
Mike Stump11289f42009-09-09 15:08:12 +00004494 Decl *Decl = StaticAssertDecl::Create(Context, CurContext, AssertLoc,
Anders Carlsson5bbe1d72009-03-14 00:25:26 +00004495 AssertExpr, AssertMessage);
Mike Stump11289f42009-09-09 15:08:12 +00004496
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00004497 CurContext->addDecl(Decl);
Chris Lattner83f095c2009-03-28 19:18:32 +00004498 return DeclPtrTy::make(Decl);
Anders Carlsson5bbe1d72009-03-14 00:25:26 +00004499}
Sebastian Redlf769df52009-03-24 22:27:57 +00004500
John McCall11083da2009-09-16 22:47:08 +00004501/// Handle a friend type declaration. This works in tandem with
4502/// ActOnTag.
4503///
4504/// Notes on friend class templates:
4505///
4506/// We generally treat friend class declarations as if they were
4507/// declaring a class. So, for example, the elaborated type specifier
4508/// in a friend declaration is required to obey the restrictions of a
4509/// class-head (i.e. no typedefs in the scope chain), template
4510/// parameters are required to match up with simple template-ids, &c.
4511/// However, unlike when declaring a template specialization, it's
4512/// okay to refer to a template specialization without an empty
4513/// template parameter declaration, e.g.
4514/// friend class A<T>::B<unsigned>;
4515/// We permit this as a special case; if there are any template
4516/// parameters present at all, require proper matching, i.e.
4517/// template <> template <class T> friend class A<int>::B;
Chris Lattner1fb66f42009-10-25 17:47:27 +00004518Sema::DeclPtrTy Sema::ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS,
John McCall11083da2009-09-16 22:47:08 +00004519 MultiTemplateParamsArg TempParams) {
John McCallaa74a0c2009-08-28 07:59:38 +00004520 SourceLocation Loc = DS.getSourceRange().getBegin();
John McCall07e91c02009-08-06 02:15:43 +00004521
4522 assert(DS.isFriendSpecified());
4523 assert(DS.getStorageClassSpec() == DeclSpec::SCS_unspecified);
4524
John McCall11083da2009-09-16 22:47:08 +00004525 // Try to convert the decl specifier to a type. This works for
4526 // friend templates because ActOnTag never produces a ClassTemplateDecl
4527 // for a TUK_Friend.
Chris Lattner1fb66f42009-10-25 17:47:27 +00004528 Declarator TheDeclarator(DS, Declarator::MemberContext);
Chris Lattner1fb66f42009-10-25 17:47:27 +00004529 QualType T = GetTypeForDeclarator(TheDeclarator, S);
4530 if (TheDeclarator.isInvalidType())
4531 return DeclPtrTy();
John McCall07e91c02009-08-06 02:15:43 +00004532
John McCall11083da2009-09-16 22:47:08 +00004533 // This is definitely an error in C++98. It's probably meant to
4534 // be forbidden in C++0x, too, but the specification is just
4535 // poorly written.
4536 //
4537 // The problem is with declarations like the following:
4538 // template <T> friend A<T>::foo;
4539 // where deciding whether a class C is a friend or not now hinges
4540 // on whether there exists an instantiation of A that causes
4541 // 'foo' to equal C. There are restrictions on class-heads
4542 // (which we declare (by fiat) elaborated friend declarations to
4543 // be) that makes this tractable.
4544 //
4545 // FIXME: handle "template <> friend class A<T>;", which
4546 // is possibly well-formed? Who even knows?
4547 if (TempParams.size() && !isa<ElaboratedType>(T)) {
4548 Diag(Loc, diag::err_tagless_friend_type_template)
4549 << DS.getSourceRange();
4550 return DeclPtrTy();
4551 }
4552
John McCallaa74a0c2009-08-28 07:59:38 +00004553 // C++ [class.friend]p2:
4554 // An elaborated-type-specifier shall be used in a friend declaration
4555 // for a class.*
4556 // * The class-key of the elaborated-type-specifier is required.
John McCalld8fe9af2009-09-08 17:47:29 +00004557 // This is one of the rare places in Clang where it's legitimate to
4558 // ask about the "spelling" of the type.
4559 if (!getLangOptions().CPlusPlus0x && !isa<ElaboratedType>(T)) {
4560 // If we evaluated the type to a record type, suggest putting
4561 // a tag in front.
John McCallaa74a0c2009-08-28 07:59:38 +00004562 if (const RecordType *RT = T->getAs<RecordType>()) {
John McCalld8fe9af2009-09-08 17:47:29 +00004563 RecordDecl *RD = RT->getDecl();
4564
4565 std::string InsertionText = std::string(" ") + RD->getKindName();
4566
John McCallc3987482009-10-07 23:34:25 +00004567 Diag(DS.getTypeSpecTypeLoc(), diag::err_unelaborated_friend_type)
4568 << (unsigned) RD->getTagKind()
4569 << T
4570 << SourceRange(DS.getFriendSpecLoc())
John McCalld8fe9af2009-09-08 17:47:29 +00004571 << CodeModificationHint::CreateInsertion(DS.getTypeSpecTypeLoc(),
4572 InsertionText);
John McCallaa74a0c2009-08-28 07:59:38 +00004573 return DeclPtrTy();
4574 }else {
John McCalld8fe9af2009-09-08 17:47:29 +00004575 Diag(DS.getFriendSpecLoc(), diag::err_unexpected_friend)
4576 << DS.getSourceRange();
Mike Stump11289f42009-09-09 15:08:12 +00004577 return DeclPtrTy();
John McCallaa74a0c2009-08-28 07:59:38 +00004578 }
4579 }
4580
John McCallc3987482009-10-07 23:34:25 +00004581 // Enum types cannot be friends.
4582 if (T->getAs<EnumType>()) {
4583 Diag(DS.getTypeSpecTypeLoc(), diag::err_enum_friend)
4584 << SourceRange(DS.getFriendSpecLoc());
4585 return DeclPtrTy();
John McCalld8fe9af2009-09-08 17:47:29 +00004586 }
John McCallaa74a0c2009-08-28 07:59:38 +00004587
John McCallaa74a0c2009-08-28 07:59:38 +00004588 // C++98 [class.friend]p1: A friend of a class is a function
4589 // or class that is not a member of the class . . .
4590 // But that's a silly restriction which nobody implements for
4591 // inner classes, and C++0x removes it anyway, so we only report
4592 // this (as a warning) if we're being pedantic.
John McCalld8fe9af2009-09-08 17:47:29 +00004593 if (!getLangOptions().CPlusPlus0x)
4594 if (const RecordType *RT = T->getAs<RecordType>())
4595 if (RT->getDecl()->getDeclContext() == CurContext)
4596 Diag(DS.getFriendSpecLoc(), diag::ext_friend_inner_class);
John McCallaa74a0c2009-08-28 07:59:38 +00004597
John McCall11083da2009-09-16 22:47:08 +00004598 Decl *D;
4599 if (TempParams.size())
4600 D = FriendTemplateDecl::Create(Context, CurContext, Loc,
4601 TempParams.size(),
4602 (TemplateParameterList**) TempParams.release(),
4603 T.getTypePtr(),
4604 DS.getFriendSpecLoc());
4605 else
4606 D = FriendDecl::Create(Context, CurContext, Loc, T.getTypePtr(),
4607 DS.getFriendSpecLoc());
4608 D->setAccess(AS_public);
4609 CurContext->addDecl(D);
John McCallaa74a0c2009-08-28 07:59:38 +00004610
John McCall11083da2009-09-16 22:47:08 +00004611 return DeclPtrTy::make(D);
John McCallaa74a0c2009-08-28 07:59:38 +00004612}
4613
John McCall2f212b32009-09-11 21:02:39 +00004614Sema::DeclPtrTy
4615Sema::ActOnFriendFunctionDecl(Scope *S,
4616 Declarator &D,
4617 bool IsDefinition,
4618 MultiTemplateParamsArg TemplateParams) {
John McCallaa74a0c2009-08-28 07:59:38 +00004619 const DeclSpec &DS = D.getDeclSpec();
4620
4621 assert(DS.isFriendSpecified());
4622 assert(DS.getStorageClassSpec() == DeclSpec::SCS_unspecified);
4623
4624 SourceLocation Loc = D.getIdentifierLoc();
Argyrios Kyrtzidis60ed5602009-08-19 01:27:57 +00004625 DeclaratorInfo *DInfo = 0;
John McCallaa74a0c2009-08-28 07:59:38 +00004626 QualType T = GetTypeForDeclarator(D, S, &DInfo);
John McCall07e91c02009-08-06 02:15:43 +00004627
4628 // C++ [class.friend]p1
4629 // A friend of a class is a function or class....
4630 // Note that this sees through typedefs, which is intended.
John McCallaa74a0c2009-08-28 07:59:38 +00004631 // It *doesn't* see through dependent types, which is correct
4632 // according to [temp.arg.type]p3:
4633 // If a declaration acquires a function type through a
4634 // type dependent on a template-parameter and this causes
4635 // a declaration that does not use the syntactic form of a
4636 // function declarator to have a function type, the program
4637 // is ill-formed.
John McCall07e91c02009-08-06 02:15:43 +00004638 if (!T->isFunctionType()) {
4639 Diag(Loc, diag::err_unexpected_friend);
4640
4641 // It might be worthwhile to try to recover by creating an
4642 // appropriate declaration.
4643 return DeclPtrTy();
4644 }
4645
4646 // C++ [namespace.memdef]p3
4647 // - If a friend declaration in a non-local class first declares a
4648 // class or function, the friend class or function is a member
4649 // of the innermost enclosing namespace.
4650 // - The name of the friend is not found by simple name lookup
4651 // until a matching declaration is provided in that namespace
4652 // scope (either before or after the class declaration granting
4653 // friendship).
4654 // - If a friend function is called, its name may be found by the
4655 // name lookup that considers functions from namespaces and
4656 // classes associated with the types of the function arguments.
4657 // - When looking for a prior declaration of a class or a function
4658 // declared as a friend, scopes outside the innermost enclosing
4659 // namespace scope are not considered.
4660
John McCallaa74a0c2009-08-28 07:59:38 +00004661 CXXScopeSpec &ScopeQual = D.getCXXScopeSpec();
4662 DeclarationName Name = GetNameForDeclarator(D);
John McCall07e91c02009-08-06 02:15:43 +00004663 assert(Name);
4664
John McCall07e91c02009-08-06 02:15:43 +00004665 // The context we found the declaration in, or in which we should
4666 // create the declaration.
4667 DeclContext *DC;
4668
4669 // FIXME: handle local classes
4670
4671 // Recover from invalid scope qualifiers as if they just weren't there.
John McCall1f82f242009-11-18 22:49:29 +00004672 LookupResult Previous(*this, Name, D.getIdentifierLoc(), LookupOrdinaryName,
4673 ForRedeclaration);
John McCall07e91c02009-08-06 02:15:43 +00004674 if (!ScopeQual.isInvalid() && ScopeQual.isSet()) {
Douglas Gregor3a88c1d2009-10-13 14:39:41 +00004675 // FIXME: RequireCompleteDeclContext
John McCall07e91c02009-08-06 02:15:43 +00004676 DC = computeDeclContext(ScopeQual);
4677
4678 // FIXME: handle dependent contexts
4679 if (!DC) return DeclPtrTy();
4680
John McCall1f82f242009-11-18 22:49:29 +00004681 LookupQualifiedName(Previous, DC);
John McCall07e91c02009-08-06 02:15:43 +00004682
4683 // If searching in that context implicitly found a declaration in
4684 // a different context, treat it like it wasn't found at all.
4685 // TODO: better diagnostics for this case. Suggesting the right
4686 // qualified scope would be nice...
John McCall1f82f242009-11-18 22:49:29 +00004687 // FIXME: getRepresentativeDecl() is not right here at all
4688 if (Previous.empty() ||
4689 !Previous.getRepresentativeDecl()->getDeclContext()->Equals(DC)) {
John McCallaa74a0c2009-08-28 07:59:38 +00004690 D.setInvalidType();
John McCall07e91c02009-08-06 02:15:43 +00004691 Diag(Loc, diag::err_qualified_friend_not_found) << Name << T;
4692 return DeclPtrTy();
4693 }
4694
4695 // C++ [class.friend]p1: A friend of a class is a function or
4696 // class that is not a member of the class . . .
Douglas Gregora29a3ff2009-09-28 00:08:27 +00004697 if (DC->Equals(CurContext))
John McCall07e91c02009-08-06 02:15:43 +00004698 Diag(DS.getFriendSpecLoc(), diag::err_friend_is_member);
4699
John McCall07e91c02009-08-06 02:15:43 +00004700 // Otherwise walk out to the nearest namespace scope looking for matches.
4701 } else {
4702 // TODO: handle local class contexts.
4703
4704 DC = CurContext;
4705 while (true) {
4706 // Skip class contexts. If someone can cite chapter and verse
4707 // for this behavior, that would be nice --- it's what GCC and
4708 // EDG do, and it seems like a reasonable intent, but the spec
4709 // really only says that checks for unqualified existing
4710 // declarations should stop at the nearest enclosing namespace,
4711 // not that they should only consider the nearest enclosing
4712 // namespace.
Douglas Gregora29a3ff2009-09-28 00:08:27 +00004713 while (DC->isRecord())
4714 DC = DC->getParent();
John McCall07e91c02009-08-06 02:15:43 +00004715
John McCall1f82f242009-11-18 22:49:29 +00004716 LookupQualifiedName(Previous, DC);
John McCall07e91c02009-08-06 02:15:43 +00004717
4718 // TODO: decide what we think about using declarations.
John McCall1f82f242009-11-18 22:49:29 +00004719 if (!Previous.empty())
John McCall07e91c02009-08-06 02:15:43 +00004720 break;
Douglas Gregora29a3ff2009-09-28 00:08:27 +00004721
John McCall07e91c02009-08-06 02:15:43 +00004722 if (DC->isFileContext()) break;
4723 DC = DC->getParent();
4724 }
4725
4726 // C++ [class.friend]p1: A friend of a class is a function or
4727 // class that is not a member of the class . . .
John McCall93343b92009-08-06 20:49:32 +00004728 // C++0x changes this for both friend types and functions.
4729 // Most C++ 98 compilers do seem to give an error here, so
4730 // we do, too.
John McCall1f82f242009-11-18 22:49:29 +00004731 if (!Previous.empty() && DC->Equals(CurContext)
4732 && !getLangOptions().CPlusPlus0x)
John McCall07e91c02009-08-06 02:15:43 +00004733 Diag(DS.getFriendSpecLoc(), diag::err_friend_is_member);
4734 }
4735
Douglas Gregora29a3ff2009-09-28 00:08:27 +00004736 if (DC->isFileContext()) {
John McCall07e91c02009-08-06 02:15:43 +00004737 // This implies that it has to be an operator or function.
Douglas Gregor7861a802009-11-03 01:35:08 +00004738 if (D.getName().getKind() == UnqualifiedId::IK_ConstructorName ||
4739 D.getName().getKind() == UnqualifiedId::IK_DestructorName ||
4740 D.getName().getKind() == UnqualifiedId::IK_ConversionFunctionId) {
John McCall07e91c02009-08-06 02:15:43 +00004741 Diag(Loc, diag::err_introducing_special_friend) <<
Douglas Gregor7861a802009-11-03 01:35:08 +00004742 (D.getName().getKind() == UnqualifiedId::IK_ConstructorName ? 0 :
4743 D.getName().getKind() == UnqualifiedId::IK_DestructorName ? 1 : 2);
John McCall07e91c02009-08-06 02:15:43 +00004744 return DeclPtrTy();
4745 }
John McCall07e91c02009-08-06 02:15:43 +00004746 }
4747
Douglas Gregora29a3ff2009-09-28 00:08:27 +00004748 bool Redeclaration = false;
John McCall1f82f242009-11-18 22:49:29 +00004749 NamedDecl *ND = ActOnFunctionDeclarator(S, D, DC, T, DInfo, Previous,
Douglas Gregor3a88c1d2009-10-13 14:39:41 +00004750 move(TemplateParams),
John McCalld1e9d832009-08-11 06:59:38 +00004751 IsDefinition,
4752 Redeclaration);
John McCallaa74a0c2009-08-28 07:59:38 +00004753 if (!ND) return DeclPtrTy();
John McCall759e32b2009-08-31 22:39:49 +00004754
Douglas Gregora29a3ff2009-09-28 00:08:27 +00004755 assert(ND->getDeclContext() == DC);
4756 assert(ND->getLexicalDeclContext() == CurContext);
John McCall5ed6e8f2009-08-18 00:00:49 +00004757
John McCall759e32b2009-08-31 22:39:49 +00004758 // Add the function declaration to the appropriate lookup tables,
4759 // adjusting the redeclarations list as necessary. We don't
4760 // want to do this yet if the friending class is dependent.
Mike Stump11289f42009-09-09 15:08:12 +00004761 //
John McCall759e32b2009-08-31 22:39:49 +00004762 // Also update the scope-based lookup if the target context's
4763 // lookup context is in lexical scope.
4764 if (!CurContext->isDependentContext()) {
4765 DC = DC->getLookupContext();
Douglas Gregora29a3ff2009-09-28 00:08:27 +00004766 DC->makeDeclVisibleInContext(ND, /* Recoverable=*/ false);
John McCall759e32b2009-08-31 22:39:49 +00004767 if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
Douglas Gregora29a3ff2009-09-28 00:08:27 +00004768 PushOnScopeChains(ND, EnclosingScope, /*AddToContext=*/ false);
John McCall759e32b2009-08-31 22:39:49 +00004769 }
John McCallaa74a0c2009-08-28 07:59:38 +00004770
4771 FriendDecl *FrD = FriendDecl::Create(Context, CurContext,
Douglas Gregora29a3ff2009-09-28 00:08:27 +00004772 D.getIdentifierLoc(), ND,
John McCallaa74a0c2009-08-28 07:59:38 +00004773 DS.getFriendSpecLoc());
John McCall75c03bb2009-08-29 03:50:18 +00004774 FrD->setAccess(AS_public);
John McCallaa74a0c2009-08-28 07:59:38 +00004775 CurContext->addDecl(FrD);
John McCall07e91c02009-08-06 02:15:43 +00004776
Douglas Gregora29a3ff2009-09-28 00:08:27 +00004777 return DeclPtrTy::make(ND);
Anders Carlsson38811702009-05-11 22:55:49 +00004778}
4779
Chris Lattner83f095c2009-03-28 19:18:32 +00004780void Sema::SetDeclDeleted(DeclPtrTy dcl, SourceLocation DelLoc) {
Douglas Gregorc8c277a2009-08-24 11:57:43 +00004781 AdjustDeclIfTemplate(dcl);
Mike Stump11289f42009-09-09 15:08:12 +00004782
Chris Lattner83f095c2009-03-28 19:18:32 +00004783 Decl *Dcl = dcl.getAs<Decl>();
Sebastian Redlf769df52009-03-24 22:27:57 +00004784 FunctionDecl *Fn = dyn_cast<FunctionDecl>(Dcl);
4785 if (!Fn) {
4786 Diag(DelLoc, diag::err_deleted_non_function);
4787 return;
4788 }
4789 if (const FunctionDecl *Prev = Fn->getPreviousDeclaration()) {
4790 Diag(DelLoc, diag::err_deleted_decl_not_first);
4791 Diag(Prev->getLocation(), diag::note_previous_declaration);
4792 // If the declaration wasn't the first, we delete the function anyway for
4793 // recovery.
4794 }
4795 Fn->setDeleted();
4796}
Sebastian Redl4c018662009-04-27 21:33:24 +00004797
4798static void SearchForReturnInStmt(Sema &Self, Stmt *S) {
4799 for (Stmt::child_iterator CI = S->child_begin(), E = S->child_end(); CI != E;
4800 ++CI) {
4801 Stmt *SubStmt = *CI;
4802 if (!SubStmt)
4803 continue;
4804 if (isa<ReturnStmt>(SubStmt))
4805 Self.Diag(SubStmt->getSourceRange().getBegin(),
4806 diag::err_return_in_constructor_handler);
4807 if (!isa<Expr>(SubStmt))
4808 SearchForReturnInStmt(Self, SubStmt);
4809 }
4810}
4811
4812void Sema::DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock) {
4813 for (unsigned I = 0, E = TryBlock->getNumHandlers(); I != E; ++I) {
4814 CXXCatchStmt *Handler = TryBlock->getHandler(I);
4815 SearchForReturnInStmt(*this, Handler);
4816 }
4817}
Anders Carlssonf2a2e332009-05-14 01:09:04 +00004818
Mike Stump11289f42009-09-09 15:08:12 +00004819bool Sema::CheckOverridingFunctionReturnType(const CXXMethodDecl *New,
Anders Carlssonf2a2e332009-05-14 01:09:04 +00004820 const CXXMethodDecl *Old) {
John McCall9dd450b2009-09-21 23:43:11 +00004821 QualType NewTy = New->getType()->getAs<FunctionType>()->getResultType();
4822 QualType OldTy = Old->getType()->getAs<FunctionType>()->getResultType();
Anders Carlssonf2a2e332009-05-14 01:09:04 +00004823
4824 QualType CNewTy = Context.getCanonicalType(NewTy);
4825 QualType COldTy = Context.getCanonicalType(OldTy);
4826
Mike Stump11289f42009-09-09 15:08:12 +00004827 if (CNewTy == COldTy &&
Douglas Gregor1b8fe5b72009-11-16 21:35:15 +00004828 CNewTy.getLocalCVRQualifiers() == COldTy.getLocalCVRQualifiers())
Anders Carlssonf2a2e332009-05-14 01:09:04 +00004829 return false;
Mike Stump11289f42009-09-09 15:08:12 +00004830
Anders Carlsson8fb0b8a2009-05-14 19:52:19 +00004831 // Check if the return types are covariant
4832 QualType NewClassTy, OldClassTy;
Mike Stump11289f42009-09-09 15:08:12 +00004833
Anders Carlsson8fb0b8a2009-05-14 19:52:19 +00004834 /// Both types must be pointers or references to classes.
4835 if (PointerType *NewPT = dyn_cast<PointerType>(NewTy)) {
4836 if (PointerType *OldPT = dyn_cast<PointerType>(OldTy)) {
4837 NewClassTy = NewPT->getPointeeType();
4838 OldClassTy = OldPT->getPointeeType();
4839 }
4840 } else if (ReferenceType *NewRT = dyn_cast<ReferenceType>(NewTy)) {
4841 if (ReferenceType *OldRT = dyn_cast<ReferenceType>(OldTy)) {
4842 NewClassTy = NewRT->getPointeeType();
4843 OldClassTy = OldRT->getPointeeType();
4844 }
4845 }
Mike Stump11289f42009-09-09 15:08:12 +00004846
Anders Carlsson8fb0b8a2009-05-14 19:52:19 +00004847 // The return types aren't either both pointers or references to a class type.
4848 if (NewClassTy.isNull()) {
Mike Stump11289f42009-09-09 15:08:12 +00004849 Diag(New->getLocation(),
Anders Carlsson8fb0b8a2009-05-14 19:52:19 +00004850 diag::err_different_return_type_for_overriding_virtual_function)
4851 << New->getDeclName() << NewTy << OldTy;
4852 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
Mike Stump11289f42009-09-09 15:08:12 +00004853
Anders Carlsson8fb0b8a2009-05-14 19:52:19 +00004854 return true;
4855 }
Anders Carlssonf2a2e332009-05-14 01:09:04 +00004856
Douglas Gregor1b8fe5b72009-11-16 21:35:15 +00004857 if (!Context.hasSameUnqualifiedType(NewClassTy, OldClassTy)) {
Anders Carlsson8fb0b8a2009-05-14 19:52:19 +00004858 // Check if the new class derives from the old class.
4859 if (!IsDerivedFrom(NewClassTy, OldClassTy)) {
4860 Diag(New->getLocation(),
4861 diag::err_covariant_return_not_derived)
4862 << New->getDeclName() << NewTy << OldTy;
4863 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
4864 return true;
4865 }
Mike Stump11289f42009-09-09 15:08:12 +00004866
Anders Carlsson8fb0b8a2009-05-14 19:52:19 +00004867 // Check if we the conversion from derived to base is valid.
Mike Stump11289f42009-09-09 15:08:12 +00004868 if (CheckDerivedToBaseConversion(NewClassTy, OldClassTy,
Anders Carlsson8fb0b8a2009-05-14 19:52:19 +00004869 diag::err_covariant_return_inaccessible_base,
4870 diag::err_covariant_return_ambiguous_derived_to_base_conv,
4871 // FIXME: Should this point to the return type?
4872 New->getLocation(), SourceRange(), New->getDeclName())) {
4873 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
4874 return true;
4875 }
4876 }
Mike Stump11289f42009-09-09 15:08:12 +00004877
Anders Carlsson8fb0b8a2009-05-14 19:52:19 +00004878 // The qualifiers of the return types must be the same.
Douglas Gregor1b8fe5b72009-11-16 21:35:15 +00004879 if (CNewTy.getLocalCVRQualifiers() != COldTy.getLocalCVRQualifiers()) {
Anders Carlsson8fb0b8a2009-05-14 19:52:19 +00004880 Diag(New->getLocation(),
4881 diag::err_covariant_return_type_different_qualifications)
Anders Carlssonf2a2e332009-05-14 01:09:04 +00004882 << New->getDeclName() << NewTy << OldTy;
Anders Carlsson8fb0b8a2009-05-14 19:52:19 +00004883 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
4884 return true;
4885 };
Mike Stump11289f42009-09-09 15:08:12 +00004886
Anders Carlsson8fb0b8a2009-05-14 19:52:19 +00004887
4888 // The new class type must have the same or less qualifiers as the old type.
4889 if (NewClassTy.isMoreQualifiedThan(OldClassTy)) {
4890 Diag(New->getLocation(),
4891 diag::err_covariant_return_type_class_type_more_qualified)
4892 << New->getDeclName() << NewTy << OldTy;
4893 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
4894 return true;
4895 };
Mike Stump11289f42009-09-09 15:08:12 +00004896
Anders Carlsson8fb0b8a2009-05-14 19:52:19 +00004897 return false;
Anders Carlssonf2a2e332009-05-14 01:09:04 +00004898}
Argyrios Kyrtzidis3df19782009-06-17 22:50:06 +00004899
Alexis Hunt96d5c762009-11-21 08:43:09 +00004900bool Sema::CheckOverridingFunctionAttributes(const CXXMethodDecl *New,
4901 const CXXMethodDecl *Old)
4902{
4903 if (Old->hasAttr<FinalAttr>()) {
4904 Diag(New->getLocation(), diag::err_final_function_overridden)
4905 << New->getDeclName();
4906 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
4907 return true;
4908 }
4909
4910 return false;
4911}
4912
Argyrios Kyrtzidis3df19782009-06-17 22:50:06 +00004913/// ActOnCXXEnterDeclInitializer - Invoked when we are about to parse an
4914/// initializer for the declaration 'Dcl'.
4915/// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
4916/// static data member of class X, names should be looked up in the scope of
4917/// class X.
4918void Sema::ActOnCXXEnterDeclInitializer(Scope *S, DeclPtrTy Dcl) {
Douglas Gregorc8c277a2009-08-24 11:57:43 +00004919 AdjustDeclIfTemplate(Dcl);
Mike Stump11289f42009-09-09 15:08:12 +00004920
Argyrios Kyrtzidis3df19782009-06-17 22:50:06 +00004921 Decl *D = Dcl.getAs<Decl>();
4922 // If there is no declaration, there was an error parsing it.
4923 if (D == 0)
4924 return;
4925
4926 // Check whether it is a declaration with a nested name specifier like
4927 // int foo::bar;
4928 if (!D->isOutOfLine())
4929 return;
Mike Stump11289f42009-09-09 15:08:12 +00004930
Argyrios Kyrtzidis3df19782009-06-17 22:50:06 +00004931 // C++ [basic.lookup.unqual]p13
4932 //
4933 // A name used in the definition of a static data member of class X
4934 // (after the qualified-id of the static member) is looked up as if the name
4935 // was used in a member function of X.
Mike Stump11289f42009-09-09 15:08:12 +00004936
Argyrios Kyrtzidis3df19782009-06-17 22:50:06 +00004937 // Change current context into the context of the initializing declaration.
Argyrios Kyrtzidis7bcce492009-06-17 23:15:40 +00004938 EnterDeclaratorContext(S, D->getDeclContext());
Argyrios Kyrtzidis3df19782009-06-17 22:50:06 +00004939}
4940
4941/// ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an
4942/// initializer for the declaration 'Dcl'.
4943void Sema::ActOnCXXExitDeclInitializer(Scope *S, DeclPtrTy Dcl) {
Douglas Gregorc8c277a2009-08-24 11:57:43 +00004944 AdjustDeclIfTemplate(Dcl);
Mike Stump11289f42009-09-09 15:08:12 +00004945
Argyrios Kyrtzidis3df19782009-06-17 22:50:06 +00004946 Decl *D = Dcl.getAs<Decl>();
4947 // If there is no declaration, there was an error parsing it.
4948 if (D == 0)
4949 return;
4950
4951 // Check whether it is a declaration with a nested name specifier like
4952 // int foo::bar;
4953 if (!D->isOutOfLine())
4954 return;
4955
4956 assert(S->getEntity() == D->getDeclContext() && "Context imbalance!");
Argyrios Kyrtzidis7bcce492009-06-17 23:15:40 +00004957 ExitDeclaratorContext(S);
Argyrios Kyrtzidis3df19782009-06-17 22:50:06 +00004958}