blob: feff707e1568743d0681af7ca9ad002d89f1c49d [file] [log] [blame]
Chris Lattner3d1cee32008-04-08 05:04:30 +00001//===------ SemaDeclCXX.cpp - Semantic Analysis for C++ Declarations ------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements semantic analysis for C++ declarations.
11//
12//===----------------------------------------------------------------------===//
13
14#include "Sema.h"
Douglas Gregor7ad83902008-11-05 04:29:56 +000015#include "SemaInherit.h"
Argyrios Kyrtzidisa4755c62008-08-09 00:58:37 +000016#include "clang/AST/ASTConsumer.h"
Douglas Gregore37ac4f2008-04-13 21:30:24 +000017#include "clang/AST/ASTContext.h"
Anders Carlsson8211eff2009-03-24 01:19:16 +000018#include "clang/AST/DeclVisitor.h"
Douglas Gregor02189362008-10-22 21:13:31 +000019#include "clang/AST/TypeOrdering.h"
Chris Lattner8123a952008-04-10 02:22:51 +000020#include "clang/AST/StmtVisitor.h"
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +000021#include "clang/Lex/Preprocessor.h"
Daniel Dunbar12bc6922008-08-11 03:27:53 +000022#include "clang/Parse/DeclSpec.h"
Douglas Gregor3fc749d2008-12-23 00:26:44 +000023#include "llvm/ADT/STLExtras.h"
Chris Lattner8123a952008-04-10 02:22:51 +000024#include "llvm/Support/Compiler.h"
Douglas Gregor8e9bebd2008-10-21 16:13:35 +000025#include <algorithm> // for std::equal
Douglas Gregorf8268ae2008-10-22 17:49:05 +000026#include <map>
Chris Lattner3d1cee32008-04-08 05:04:30 +000027
28using namespace clang;
29
Chris Lattner8123a952008-04-10 02:22:51 +000030//===----------------------------------------------------------------------===//
31// CheckDefaultArgumentVisitor
32//===----------------------------------------------------------------------===//
33
Chris Lattner9e979552008-04-12 23:52:44 +000034namespace {
35 /// CheckDefaultArgumentVisitor - C++ [dcl.fct.default] Traverses
36 /// the default argument of a parameter to determine whether it
37 /// contains any ill-formed subexpressions. For example, this will
38 /// diagnose the use of local variables or parameters within the
39 /// default argument expression.
40 class VISIBILITY_HIDDEN CheckDefaultArgumentVisitor
Chris Lattnerb77792e2008-07-26 22:17:49 +000041 : public StmtVisitor<CheckDefaultArgumentVisitor, bool> {
Chris Lattner9e979552008-04-12 23:52:44 +000042 Expr *DefaultArg;
43 Sema *S;
Chris Lattner8123a952008-04-10 02:22:51 +000044
Chris Lattner9e979552008-04-12 23:52:44 +000045 public:
46 CheckDefaultArgumentVisitor(Expr *defarg, Sema *s)
47 : DefaultArg(defarg), S(s) {}
Chris Lattner8123a952008-04-10 02:22:51 +000048
Chris Lattner9e979552008-04-12 23:52:44 +000049 bool VisitExpr(Expr *Node);
50 bool VisitDeclRefExpr(DeclRefExpr *DRE);
Douglas Gregor796da182008-11-04 14:32:21 +000051 bool VisitCXXThisExpr(CXXThisExpr *ThisE);
Chris Lattner9e979552008-04-12 23:52:44 +000052 };
Chris Lattner8123a952008-04-10 02:22:51 +000053
Chris Lattner9e979552008-04-12 23:52:44 +000054 /// VisitExpr - Visit all of the children of this expression.
55 bool CheckDefaultArgumentVisitor::VisitExpr(Expr *Node) {
56 bool IsInvalid = false;
Chris Lattnerb77792e2008-07-26 22:17:49 +000057 for (Stmt::child_iterator I = Node->child_begin(),
58 E = Node->child_end(); I != E; ++I)
59 IsInvalid |= Visit(*I);
Chris Lattner9e979552008-04-12 23:52:44 +000060 return IsInvalid;
Chris Lattner8123a952008-04-10 02:22:51 +000061 }
62
Chris Lattner9e979552008-04-12 23:52:44 +000063 /// VisitDeclRefExpr - Visit a reference to a declaration, to
64 /// determine whether this declaration can be used in the default
65 /// argument expression.
66 bool CheckDefaultArgumentVisitor::VisitDeclRefExpr(DeclRefExpr *DRE) {
Douglas Gregor8e9bebd2008-10-21 16:13:35 +000067 NamedDecl *Decl = DRE->getDecl();
Chris Lattner9e979552008-04-12 23:52:44 +000068 if (ParmVarDecl *Param = dyn_cast<ParmVarDecl>(Decl)) {
69 // C++ [dcl.fct.default]p9
70 // Default arguments are evaluated each time the function is
71 // called. The order of evaluation of function arguments is
72 // unspecified. Consequently, parameters of a function shall not
73 // be used in default argument expressions, even if they are not
74 // evaluated. Parameters of a function declared before a default
75 // argument expression are in scope and can hide namespace and
76 // class member names.
77 return S->Diag(DRE->getSourceRange().getBegin(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +000078 diag::err_param_default_argument_references_param)
Chris Lattner08631c52008-11-23 21:45:46 +000079 << Param->getDeclName() << DefaultArg->getSourceRange();
Steve Naroff248a7532008-04-15 22:42:06 +000080 } else if (VarDecl *VDecl = dyn_cast<VarDecl>(Decl)) {
Chris Lattner9e979552008-04-12 23:52:44 +000081 // C++ [dcl.fct.default]p7
82 // Local variables shall not be used in default argument
83 // expressions.
Steve Naroff248a7532008-04-15 22:42:06 +000084 if (VDecl->isBlockVarDecl())
85 return S->Diag(DRE->getSourceRange().getBegin(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +000086 diag::err_param_default_argument_references_local)
Chris Lattner08631c52008-11-23 21:45:46 +000087 << VDecl->getDeclName() << DefaultArg->getSourceRange();
Chris Lattner9e979552008-04-12 23:52:44 +000088 }
Chris Lattner8123a952008-04-10 02:22:51 +000089
Douglas Gregor3996f232008-11-04 13:41:56 +000090 return false;
91 }
Chris Lattner9e979552008-04-12 23:52:44 +000092
Douglas Gregor796da182008-11-04 14:32:21 +000093 /// VisitCXXThisExpr - Visit a C++ "this" expression.
94 bool CheckDefaultArgumentVisitor::VisitCXXThisExpr(CXXThisExpr *ThisE) {
95 // C++ [dcl.fct.default]p8:
96 // The keyword this shall not be used in a default argument of a
97 // member function.
98 return S->Diag(ThisE->getSourceRange().getBegin(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +000099 diag::err_param_default_argument_references_this)
100 << ThisE->getSourceRange();
Chris Lattner9e979552008-04-12 23:52:44 +0000101 }
Chris Lattner8123a952008-04-10 02:22:51 +0000102}
103
104/// ActOnParamDefaultArgument - Check whether the default argument
105/// provided for a function parameter is well-formed. If so, attach it
106/// to the parameter declaration.
Chris Lattner3d1cee32008-04-08 05:04:30 +0000107void
Chris Lattnerb28317a2009-03-28 19:18:32 +0000108Sema::ActOnParamDefaultArgument(DeclPtrTy param, SourceLocation EqualLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +0000109 ExprArg defarg) {
Chris Lattnerb28317a2009-03-28 19:18:32 +0000110 ParmVarDecl *Param = cast<ParmVarDecl>(param.getAs<Decl>());
Sebastian Redlf53597f2009-03-15 17:47:39 +0000111 ExprOwningPtr<Expr> DefaultArg(this, (Expr *)defarg.release());
Chris Lattner3d1cee32008-04-08 05:04:30 +0000112 QualType ParamType = Param->getType();
113
114 // Default arguments are only permitted in C++
115 if (!getLangOptions().CPlusPlus) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000116 Diag(EqualLoc, diag::err_param_default_argument)
117 << DefaultArg->getSourceRange();
Douglas Gregor72b505b2008-12-16 21:30:33 +0000118 Param->setInvalidDecl();
Chris Lattner3d1cee32008-04-08 05:04:30 +0000119 return;
120 }
121
122 // C++ [dcl.fct.default]p5
123 // A default argument expression is implicitly converted (clause
124 // 4) to the parameter type. The default argument expression has
125 // the same semantic constraints as the initializer expression in
126 // a declaration of a variable of the parameter type, using the
127 // copy-initialization semantics (8.5).
Chris Lattner3d1cee32008-04-08 05:04:30 +0000128 Expr *DefaultArgPtr = DefaultArg.get();
Douglas Gregor61366e92008-12-24 00:01:03 +0000129 bool DefaultInitFailed = CheckInitializerTypes(DefaultArgPtr, ParamType,
130 EqualLoc,
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000131 Param->getDeclName(),
132 /*DirectInit=*/false);
Chris Lattner3d1cee32008-04-08 05:04:30 +0000133 if (DefaultArgPtr != DefaultArg.get()) {
134 DefaultArg.take();
135 DefaultArg.reset(DefaultArgPtr);
136 }
Douglas Gregoreb704f22008-11-04 13:57:51 +0000137 if (DefaultInitFailed) {
Chris Lattner3d1cee32008-04-08 05:04:30 +0000138 return;
139 }
140
Chris Lattner8123a952008-04-10 02:22:51 +0000141 // Check that the default argument is well-formed
Chris Lattner9e979552008-04-12 23:52:44 +0000142 CheckDefaultArgumentVisitor DefaultArgChecker(DefaultArg.get(), this);
Douglas Gregor72b505b2008-12-16 21:30:33 +0000143 if (DefaultArgChecker.Visit(DefaultArg.get())) {
144 Param->setInvalidDecl();
Chris Lattner8123a952008-04-10 02:22:51 +0000145 return;
Douglas Gregor72b505b2008-12-16 21:30:33 +0000146 }
Chris Lattner8123a952008-04-10 02:22:51 +0000147
Chris Lattner3d1cee32008-04-08 05:04:30 +0000148 // Okay: add the default argument to the parameter
149 Param->setDefaultArg(DefaultArg.take());
150}
151
Douglas Gregor61366e92008-12-24 00:01:03 +0000152/// ActOnParamUnparsedDefaultArgument - We've seen a default
153/// argument for a function parameter, but we can't parse it yet
154/// because we're inside a class definition. Note that this default
155/// argument will be parsed later.
Chris Lattnerb28317a2009-03-28 19:18:32 +0000156void Sema::ActOnParamUnparsedDefaultArgument(DeclPtrTy param,
Douglas Gregor61366e92008-12-24 00:01:03 +0000157 SourceLocation EqualLoc) {
Chris Lattnerb28317a2009-03-28 19:18:32 +0000158 ParmVarDecl *Param = cast<ParmVarDecl>(param.getAs<Decl>());
Douglas Gregor61366e92008-12-24 00:01:03 +0000159 if (Param)
160 Param->setUnparsedDefaultArg();
161}
162
Douglas Gregor72b505b2008-12-16 21:30:33 +0000163/// ActOnParamDefaultArgumentError - Parsing or semantic analysis of
164/// the default argument for the parameter param failed.
Chris Lattnerb28317a2009-03-28 19:18:32 +0000165void Sema::ActOnParamDefaultArgumentError(DeclPtrTy param) {
166 cast<ParmVarDecl>(param.getAs<Decl>())->setInvalidDecl();
Douglas Gregor72b505b2008-12-16 21:30:33 +0000167}
168
Douglas Gregor6d6eb572008-05-07 04:49:29 +0000169/// CheckExtraCXXDefaultArguments - Check for any extra default
170/// arguments in the declarator, which is not a function declaration
171/// or definition and therefore is not permitted to have default
172/// arguments. This routine should be invoked for every declarator
173/// that is not a function declaration or definition.
174void Sema::CheckExtraCXXDefaultArguments(Declarator &D) {
175 // C++ [dcl.fct.default]p3
176 // A default argument expression shall be specified only in the
177 // parameter-declaration-clause of a function declaration or in a
178 // template-parameter (14.1). It shall not be specified for a
179 // parameter pack. If it is specified in a
180 // parameter-declaration-clause, it shall not occur within a
181 // declarator or abstract-declarator of a parameter-declaration.
Chris Lattnerb28317a2009-03-28 19:18:32 +0000182 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
Douglas Gregor6d6eb572008-05-07 04:49:29 +0000183 DeclaratorChunk &chunk = D.getTypeObject(i);
184 if (chunk.Kind == DeclaratorChunk::Function) {
Chris Lattnerb28317a2009-03-28 19:18:32 +0000185 for (unsigned argIdx = 0, e = chunk.Fun.NumArgs; argIdx != e; ++argIdx) {
186 ParmVarDecl *Param =
187 cast<ParmVarDecl>(chunk.Fun.ArgInfo[argIdx].Param.getAs<Decl>());
Douglas Gregor61366e92008-12-24 00:01:03 +0000188 if (Param->hasUnparsedDefaultArg()) {
189 CachedTokens *Toks = chunk.Fun.ArgInfo[argIdx].DefaultArgTokens;
Douglas Gregor72b505b2008-12-16 21:30:33 +0000190 Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
191 << SourceRange((*Toks)[1].getLocation(), Toks->back().getLocation());
192 delete Toks;
193 chunk.Fun.ArgInfo[argIdx].DefaultArgTokens = 0;
Douglas Gregor61366e92008-12-24 00:01:03 +0000194 } else if (Param->getDefaultArg()) {
195 Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
196 << Param->getDefaultArg()->getSourceRange();
197 Param->setDefaultArg(0);
Douglas Gregor6d6eb572008-05-07 04:49:29 +0000198 }
199 }
200 }
201 }
202}
203
Chris Lattner3d1cee32008-04-08 05:04:30 +0000204// MergeCXXFunctionDecl - Merge two declarations of the same C++
205// function, once we already know that they have the same
Douglas Gregorcda9c672009-02-16 17:45:42 +0000206// type. Subroutine of MergeFunctionDecl. Returns true if there was an
207// error, false otherwise.
208bool Sema::MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old) {
209 bool Invalid = false;
210
Chris Lattner3d1cee32008-04-08 05:04:30 +0000211 // C++ [dcl.fct.default]p4:
212 //
213 // For non-template functions, default arguments can be added in
214 // later declarations of a function in the same
215 // scope. Declarations in different scopes have completely
216 // distinct sets of default arguments. That is, declarations in
217 // inner scopes do not acquire default arguments from
218 // declarations in outer scopes, and vice versa. In a given
219 // function declaration, all parameters subsequent to a
220 // parameter with a default argument shall have default
221 // arguments supplied in this or previous declarations. A
222 // default argument shall not be redefined by a later
223 // declaration (not even to the same value).
224 for (unsigned p = 0, NumParams = Old->getNumParams(); p < NumParams; ++p) {
225 ParmVarDecl *OldParam = Old->getParamDecl(p);
226 ParmVarDecl *NewParam = New->getParamDecl(p);
227
228 if(OldParam->getDefaultArg() && NewParam->getDefaultArg()) {
229 Diag(NewParam->getLocation(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000230 diag::err_param_default_argument_redefinition)
231 << NewParam->getDefaultArg()->getSourceRange();
Chris Lattner5f4a6822008-11-23 23:12:31 +0000232 Diag(OldParam->getLocation(), diag::note_previous_definition);
Douglas Gregorcda9c672009-02-16 17:45:42 +0000233 Invalid = true;
Chris Lattner3d1cee32008-04-08 05:04:30 +0000234 } else if (OldParam->getDefaultArg()) {
235 // Merge the old default argument into the new parameter
236 NewParam->setDefaultArg(OldParam->getDefaultArg());
237 }
238 }
239
Douglas Gregorcda9c672009-02-16 17:45:42 +0000240 return Invalid;
Chris Lattner3d1cee32008-04-08 05:04:30 +0000241}
242
243/// CheckCXXDefaultArguments - Verify that the default arguments for a
244/// function declaration are well-formed according to C++
245/// [dcl.fct.default].
246void Sema::CheckCXXDefaultArguments(FunctionDecl *FD) {
247 unsigned NumParams = FD->getNumParams();
248 unsigned p;
249
250 // Find first parameter with a default argument
251 for (p = 0; p < NumParams; ++p) {
252 ParmVarDecl *Param = FD->getParamDecl(p);
253 if (Param->getDefaultArg())
254 break;
255 }
256
257 // C++ [dcl.fct.default]p4:
258 // In a given function declaration, all parameters
259 // subsequent to a parameter with a default argument shall
260 // have default arguments supplied in this or previous
261 // declarations. A default argument shall not be redefined
262 // by a later declaration (not even to the same value).
263 unsigned LastMissingDefaultArg = 0;
264 for(; p < NumParams; ++p) {
265 ParmVarDecl *Param = FD->getParamDecl(p);
266 if (!Param->getDefaultArg()) {
Douglas Gregor72b505b2008-12-16 21:30:33 +0000267 if (Param->isInvalidDecl())
268 /* We already complained about this parameter. */;
269 else if (Param->getIdentifier())
Chris Lattner3d1cee32008-04-08 05:04:30 +0000270 Diag(Param->getLocation(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000271 diag::err_param_default_argument_missing_name)
Chris Lattner43b628c2008-11-19 07:32:16 +0000272 << Param->getIdentifier();
Chris Lattner3d1cee32008-04-08 05:04:30 +0000273 else
274 Diag(Param->getLocation(),
275 diag::err_param_default_argument_missing);
276
277 LastMissingDefaultArg = p;
278 }
279 }
280
281 if (LastMissingDefaultArg > 0) {
282 // Some default arguments were missing. Clear out all of the
283 // default arguments up to (and including) the last missing
284 // default argument, so that we leave the function parameters
285 // in a semantically valid state.
286 for (p = 0; p <= LastMissingDefaultArg; ++p) {
287 ParmVarDecl *Param = FD->getParamDecl(p);
288 if (Param->getDefaultArg()) {
Douglas Gregor61366e92008-12-24 00:01:03 +0000289 if (!Param->hasUnparsedDefaultArg())
290 Param->getDefaultArg()->Destroy(Context);
Chris Lattner3d1cee32008-04-08 05:04:30 +0000291 Param->setDefaultArg(0);
292 }
293 }
294 }
295}
Douglas Gregore37ac4f2008-04-13 21:30:24 +0000296
Douglas Gregorb48fe382008-10-31 09:07:45 +0000297/// isCurrentClassName - Determine whether the identifier II is the
298/// name of the class type currently being defined. In the case of
299/// nested classes, this will only return true if II is the name of
300/// the innermost class.
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +0000301bool Sema::isCurrentClassName(const IdentifierInfo &II, Scope *,
302 const CXXScopeSpec *SS) {
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000303 CXXRecordDecl *CurDecl;
Douglas Gregore4e5b052009-03-19 00:18:19 +0000304 if (SS && SS->isSet() && !SS->isInvalid()) {
305 DeclContext *DC = computeDeclContext(*SS);
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000306 CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC);
307 } else
308 CurDecl = dyn_cast_or_null<CXXRecordDecl>(CurContext);
309
310 if (CurDecl)
Douglas Gregorb48fe382008-10-31 09:07:45 +0000311 return &II == CurDecl->getIdentifier();
312 else
313 return false;
314}
315
Douglas Gregor2943aed2009-03-03 04:44:36 +0000316/// \brief Check the validity of a C++ base class specifier.
317///
318/// \returns a new CXXBaseSpecifier if well-formed, emits diagnostics
319/// and returns NULL otherwise.
320CXXBaseSpecifier *
321Sema::CheckBaseSpecifier(CXXRecordDecl *Class,
322 SourceRange SpecifierRange,
323 bool Virtual, AccessSpecifier Access,
324 QualType BaseType,
325 SourceLocation BaseLoc) {
326 // C++ [class.union]p1:
327 // A union shall not have base classes.
328 if (Class->isUnion()) {
329 Diag(Class->getLocation(), diag::err_base_clause_on_union)
330 << SpecifierRange;
331 return 0;
332 }
333
334 if (BaseType->isDependentType())
335 return new CXXBaseSpecifier(SpecifierRange, Virtual,
336 Class->getTagKind() == RecordDecl::TK_class,
337 Access, BaseType);
338
339 // Base specifiers must be record types.
340 if (!BaseType->isRecordType()) {
341 Diag(BaseLoc, diag::err_base_must_be_class) << SpecifierRange;
342 return 0;
343 }
344
345 // C++ [class.union]p1:
346 // A union shall not be used as a base class.
347 if (BaseType->isUnionType()) {
348 Diag(BaseLoc, diag::err_union_as_base_class) << SpecifierRange;
349 return 0;
350 }
351
352 // C++ [class.derived]p2:
353 // The class-name in a base-specifier shall not be an incompletely
354 // defined class.
Douglas Gregor86447ec2009-03-09 16:13:40 +0000355 if (RequireCompleteType(BaseLoc, BaseType, diag::err_incomplete_base_class,
Douglas Gregor26dce442009-03-10 00:06:19 +0000356 SpecifierRange))
Douglas Gregor2943aed2009-03-03 04:44:36 +0000357 return 0;
358
359 // If the base class is polymorphic, the new one is, too.
360 RecordDecl *BaseDecl = BaseType->getAsRecordType()->getDecl();
361 assert(BaseDecl && "Record type has no declaration");
362 BaseDecl = BaseDecl->getDefinition(Context);
363 assert(BaseDecl && "Base type is not incomplete, but has no definition");
364 if (cast<CXXRecordDecl>(BaseDecl)->isPolymorphic())
365 Class->setPolymorphic(true);
366
367 // C++ [dcl.init.aggr]p1:
368 // An aggregate is [...] a class with [...] no base classes [...].
369 Class->setAggregate(false);
370 Class->setPOD(false);
371
372 // Create the base specifier.
373 // FIXME: Allocate via ASTContext?
374 return new CXXBaseSpecifier(SpecifierRange, Virtual,
375 Class->getTagKind() == RecordDecl::TK_class,
376 Access, BaseType);
377}
378
Douglas Gregore37ac4f2008-04-13 21:30:24 +0000379/// ActOnBaseSpecifier - Parsed a base specifier. A base specifier is
380/// one entry in the base class list of a class specifier, for
381/// example:
382/// class foo : public bar, virtual private baz {
383/// 'public bar' and 'virtual private baz' are each base-specifiers.
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000384Sema::BaseResult
Chris Lattnerb28317a2009-03-28 19:18:32 +0000385Sema::ActOnBaseSpecifier(DeclPtrTy classdecl, SourceRange SpecifierRange,
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000386 bool Virtual, AccessSpecifier Access,
387 TypeTy *basetype, SourceLocation BaseLoc) {
Douglas Gregor40808ce2009-03-09 23:48:35 +0000388 AdjustDeclIfTemplate(classdecl);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000389 CXXRecordDecl *Class = cast<CXXRecordDecl>(classdecl.getAs<Decl>());
Douglas Gregor1a51b4a2009-02-09 15:09:02 +0000390 QualType BaseType = QualType::getFromOpaquePtr(basetype);
Douglas Gregor2943aed2009-03-03 04:44:36 +0000391 if (CXXBaseSpecifier *BaseSpec = CheckBaseSpecifier(Class, SpecifierRange,
392 Virtual, Access,
393 BaseType, BaseLoc))
394 return BaseSpec;
395
396 return true;
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000397}
Douglas Gregore37ac4f2008-04-13 21:30:24 +0000398
Douglas Gregor2943aed2009-03-03 04:44:36 +0000399/// \brief Performs the actual work of attaching the given base class
400/// specifiers to a C++ class.
401bool Sema::AttachBaseSpecifiers(CXXRecordDecl *Class, CXXBaseSpecifier **Bases,
402 unsigned NumBases) {
403 if (NumBases == 0)
404 return false;
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000405
406 // Used to keep track of which base types we have already seen, so
407 // that we can properly diagnose redundant direct base types. Note
Douglas Gregor57c856b2008-10-23 18:13:27 +0000408 // that the key is always the unqualified canonical type of the base
409 // class.
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000410 std::map<QualType, CXXBaseSpecifier*, QualTypeOrdering> KnownBaseTypes;
411
412 // Copy non-redundant base specifiers into permanent storage.
Douglas Gregor57c856b2008-10-23 18:13:27 +0000413 unsigned NumGoodBases = 0;
Douglas Gregor2943aed2009-03-03 04:44:36 +0000414 bool Invalid = false;
Douglas Gregor57c856b2008-10-23 18:13:27 +0000415 for (unsigned idx = 0; idx < NumBases; ++idx) {
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000416 QualType NewBaseType
Douglas Gregor2943aed2009-03-03 04:44:36 +0000417 = Context.getCanonicalType(Bases[idx]->getType());
Douglas Gregor57c856b2008-10-23 18:13:27 +0000418 NewBaseType = NewBaseType.getUnqualifiedType();
419
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000420 if (KnownBaseTypes[NewBaseType]) {
421 // C++ [class.mi]p3:
422 // A class shall not be specified as a direct base class of a
423 // derived class more than once.
Douglas Gregor2943aed2009-03-03 04:44:36 +0000424 Diag(Bases[idx]->getSourceRange().getBegin(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000425 diag::err_duplicate_base_class)
Chris Lattnerd1625842008-11-24 06:25:27 +0000426 << KnownBaseTypes[NewBaseType]->getType()
Douglas Gregor2943aed2009-03-03 04:44:36 +0000427 << Bases[idx]->getSourceRange();
Douglas Gregor57c856b2008-10-23 18:13:27 +0000428
429 // Delete the duplicate base class specifier; we're going to
430 // overwrite its pointer later.
Douglas Gregor2943aed2009-03-03 04:44:36 +0000431 delete Bases[idx];
432
433 Invalid = true;
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000434 } else {
435 // Okay, add this new base class.
Douglas Gregor2943aed2009-03-03 04:44:36 +0000436 KnownBaseTypes[NewBaseType] = Bases[idx];
437 Bases[NumGoodBases++] = Bases[idx];
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000438 }
439 }
440
441 // Attach the remaining base class specifiers to the derived class.
Douglas Gregor2943aed2009-03-03 04:44:36 +0000442 Class->setBases(Bases, NumGoodBases);
Douglas Gregor57c856b2008-10-23 18:13:27 +0000443
444 // Delete the remaining (good) base class specifiers, since their
445 // data has been copied into the CXXRecordDecl.
446 for (unsigned idx = 0; idx < NumGoodBases; ++idx)
Douglas Gregor2943aed2009-03-03 04:44:36 +0000447 delete Bases[idx];
448
449 return Invalid;
450}
451
452/// ActOnBaseSpecifiers - Attach the given base specifiers to the
453/// class, after checking whether there are any duplicate base
454/// classes.
Chris Lattnerb28317a2009-03-28 19:18:32 +0000455void Sema::ActOnBaseSpecifiers(DeclPtrTy ClassDecl, BaseTy **Bases,
Douglas Gregor2943aed2009-03-03 04:44:36 +0000456 unsigned NumBases) {
457 if (!ClassDecl || !Bases || !NumBases)
458 return;
459
460 AdjustDeclIfTemplate(ClassDecl);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000461 AttachBaseSpecifiers(cast<CXXRecordDecl>(ClassDecl.getAs<Decl>()),
Douglas Gregor2943aed2009-03-03 04:44:36 +0000462 (CXXBaseSpecifier**)(Bases), NumBases);
Douglas Gregore37ac4f2008-04-13 21:30:24 +0000463}
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +0000464
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000465//===----------------------------------------------------------------------===//
466// C++ class member Handling
467//===----------------------------------------------------------------------===//
468
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000469/// ActOnCXXMemberDeclarator - This is invoked when a C++ class member
470/// declarator is parsed. 'AS' is the access specifier, 'BW' specifies the
471/// bitfield width if there is one and 'InitExpr' specifies the initializer if
472/// any. 'LastInGroup' is non-null for cases where one declspec has multiple
473/// declarators on it.
Chris Lattnerb28317a2009-03-28 19:18:32 +0000474Sema::DeclPtrTy
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000475Sema::ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS, Declarator &D,
Chris Lattner682bf922009-03-29 16:50:03 +0000476 ExprTy *BW, ExprTy *InitExpr) {
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000477 const DeclSpec &DS = D.getDeclSpec();
Douglas Gregor10bd3682008-11-17 22:58:34 +0000478 DeclarationName Name = GetNameForDeclarator(D);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000479 Expr *BitWidth = static_cast<Expr*>(BW);
480 Expr *Init = static_cast<Expr*>(InitExpr);
481 SourceLocation Loc = D.getIdentifierLoc();
482
Sebastian Redl669d5d72008-11-14 23:42:31 +0000483 bool isFunc = D.isFunctionDeclarator();
484
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000485 // C++ 9.2p6: A member shall not be declared to have automatic storage
486 // duration (auto, register) or with the extern storage-class-specifier.
Sebastian Redl669d5d72008-11-14 23:42:31 +0000487 // C++ 7.1.1p8: The mutable specifier can be applied only to names of class
488 // data members and cannot be applied to names declared const or static,
489 // and cannot be applied to reference members.
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000490 switch (DS.getStorageClassSpec()) {
491 case DeclSpec::SCS_unspecified:
492 case DeclSpec::SCS_typedef:
493 case DeclSpec::SCS_static:
494 // FALL THROUGH.
495 break;
Sebastian Redl669d5d72008-11-14 23:42:31 +0000496 case DeclSpec::SCS_mutable:
497 if (isFunc) {
498 if (DS.getStorageClassSpecLoc().isValid())
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000499 Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_function);
Sebastian Redl669d5d72008-11-14 23:42:31 +0000500 else
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000501 Diag(DS.getThreadSpecLoc(), diag::err_mutable_function);
502
Sebastian Redla11f42f2008-11-17 23:24:37 +0000503 // FIXME: It would be nicer if the keyword was ignored only for this
504 // declarator. Otherwise we could get follow-up errors.
Sebastian Redl669d5d72008-11-14 23:42:31 +0000505 D.getMutableDeclSpec().ClearStorageClassSpecs();
506 } else {
507 QualType T = GetTypeForDeclarator(D, S);
508 diag::kind err = static_cast<diag::kind>(0);
509 if (T->isReferenceType())
510 err = diag::err_mutable_reference;
511 else if (T.isConstQualified())
512 err = diag::err_mutable_const;
513 if (err != 0) {
514 if (DS.getStorageClassSpecLoc().isValid())
515 Diag(DS.getStorageClassSpecLoc(), err);
516 else
517 Diag(DS.getThreadSpecLoc(), err);
Sebastian Redla11f42f2008-11-17 23:24:37 +0000518 // FIXME: It would be nicer if the keyword was ignored only for this
519 // declarator. Otherwise we could get follow-up errors.
Sebastian Redl669d5d72008-11-14 23:42:31 +0000520 D.getMutableDeclSpec().ClearStorageClassSpecs();
521 }
522 }
523 break;
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000524 default:
525 if (DS.getStorageClassSpecLoc().isValid())
526 Diag(DS.getStorageClassSpecLoc(),
527 diag::err_storageclass_invalid_for_member);
528 else
529 Diag(DS.getThreadSpecLoc(), diag::err_storageclass_invalid_for_member);
530 D.getMutableDeclSpec().ClearStorageClassSpecs();
531 }
532
Argyrios Kyrtzidisd6caa9e2008-10-15 20:23:22 +0000533 if (!isFunc &&
Douglas Gregor1a51b4a2009-02-09 15:09:02 +0000534 D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_typename &&
Argyrios Kyrtzidisd6caa9e2008-10-15 20:23:22 +0000535 D.getNumTypeObjects() == 0) {
Argyrios Kyrtzidisde933f02008-10-08 22:20:31 +0000536 // Check also for this case:
537 //
538 // typedef int f();
539 // f a;
540 //
Douglas Gregor1a51b4a2009-02-09 15:09:02 +0000541 QualType TDType = QualType::getFromOpaquePtr(DS.getTypeRep());
542 isFunc = TDType->isFunctionType();
Argyrios Kyrtzidisde933f02008-10-08 22:20:31 +0000543 }
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000544
Sebastian Redl669d5d72008-11-14 23:42:31 +0000545 bool isInstField = ((DS.getStorageClassSpec() == DeclSpec::SCS_unspecified ||
546 DS.getStorageClassSpec() == DeclSpec::SCS_mutable) &&
Argyrios Kyrtzidisde933f02008-10-08 22:20:31 +0000547 !isFunc);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000548
549 Decl *Member;
Chris Lattner24793662009-03-05 22:45:59 +0000550 if (isInstField) {
Douglas Gregor4dd55f52009-03-11 20:50:30 +0000551 Member = HandleField(S, cast<CXXRecordDecl>(CurContext), Loc, D, BitWidth,
552 AS);
Chris Lattner6f8ce142009-03-05 23:03:49 +0000553 assert(Member && "HandleField never returns null");
Chris Lattner24793662009-03-05 22:45:59 +0000554 } else {
Chris Lattner682bf922009-03-29 16:50:03 +0000555 Member = ActOnDeclarator(S, D).getAs<Decl>();
Chris Lattner6f8ce142009-03-05 23:03:49 +0000556 if (!Member) {
557 if (BitWidth) DeleteExpr(BitWidth);
Chris Lattner682bf922009-03-29 16:50:03 +0000558 return DeclPtrTy();
Chris Lattner6f8ce142009-03-05 23:03:49 +0000559 }
Chris Lattner8b963ef2009-03-05 23:01:03 +0000560
561 // Non-instance-fields can't have a bitfield.
562 if (BitWidth) {
563 if (Member->isInvalidDecl()) {
564 // don't emit another diagnostic.
Douglas Gregor2d2e9cf2009-03-11 20:22:50 +0000565 } else if (isa<VarDecl>(Member)) {
Chris Lattner8b963ef2009-03-05 23:01:03 +0000566 // C++ 9.6p3: A bit-field shall not be a static member.
567 // "static member 'A' cannot be a bit-field"
568 Diag(Loc, diag::err_static_not_bitfield)
569 << Name << BitWidth->getSourceRange();
570 } else if (isa<TypedefDecl>(Member)) {
571 // "typedef member 'x' cannot be a bit-field"
572 Diag(Loc, diag::err_typedef_not_bitfield)
573 << Name << BitWidth->getSourceRange();
574 } else {
575 // A function typedef ("typedef int f(); f a;").
576 // C++ 9.6p3: A bit-field shall have integral or enumeration type.
577 Diag(Loc, diag::err_not_integral_type_bitfield)
Douglas Gregor3cf538d2009-03-11 18:59:21 +0000578 << Name << cast<ValueDecl>(Member)->getType()
579 << BitWidth->getSourceRange();
Chris Lattner8b963ef2009-03-05 23:01:03 +0000580 }
581
582 DeleteExpr(BitWidth);
583 BitWidth = 0;
584 Member->setInvalidDecl();
585 }
Douglas Gregor4dd55f52009-03-11 20:50:30 +0000586
587 Member->setAccess(AS);
Chris Lattner24793662009-03-05 22:45:59 +0000588 }
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000589
Douglas Gregor10bd3682008-11-17 22:58:34 +0000590 assert((Name || isInstField) && "No identifier for non-field ?");
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000591
Douglas Gregor021c3b32009-03-11 23:00:04 +0000592 if (Init)
Chris Lattnerb28317a2009-03-28 19:18:32 +0000593 AddInitializerToDecl(DeclPtrTy::make(Member), ExprArg(*this, Init), false);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000594
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000595 if (isInstField) {
Douglas Gregor44b43212008-12-11 16:49:14 +0000596 FieldCollector->Add(cast<FieldDecl>(Member));
Chris Lattner682bf922009-03-29 16:50:03 +0000597 return DeclPtrTy();
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000598 }
Chris Lattnerb28317a2009-03-28 19:18:32 +0000599 return DeclPtrTy::make(Member);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000600}
601
Douglas Gregor7ad83902008-11-05 04:29:56 +0000602/// ActOnMemInitializer - Handle a C++ member initializer.
603Sema::MemInitResult
Chris Lattnerb28317a2009-03-28 19:18:32 +0000604Sema::ActOnMemInitializer(DeclPtrTy ConstructorD,
Douglas Gregor7ad83902008-11-05 04:29:56 +0000605 Scope *S,
606 IdentifierInfo *MemberOrBase,
607 SourceLocation IdLoc,
608 SourceLocation LParenLoc,
609 ExprTy **Args, unsigned NumArgs,
610 SourceLocation *CommaLocs,
611 SourceLocation RParenLoc) {
612 CXXConstructorDecl *Constructor
Chris Lattnerb28317a2009-03-28 19:18:32 +0000613 = dyn_cast<CXXConstructorDecl>(ConstructorD.getAs<Decl>());
Douglas Gregor7ad83902008-11-05 04:29:56 +0000614 if (!Constructor) {
615 // The user wrote a constructor initializer on a function that is
616 // not a C++ constructor. Ignore the error for now, because we may
617 // have more member initializers coming; we'll diagnose it just
618 // once in ActOnMemInitializers.
619 return true;
620 }
621
622 CXXRecordDecl *ClassDecl = Constructor->getParent();
623
624 // C++ [class.base.init]p2:
625 // Names in a mem-initializer-id are looked up in the scope of the
626 // constructor’s class and, if not found in that scope, are looked
627 // up in the scope containing the constructor’s
628 // definition. [Note: if the constructor’s class contains a member
629 // with the same name as a direct or virtual base class of the
630 // class, a mem-initializer-id naming the member or base class and
631 // composed of a single identifier refers to the class member. A
632 // mem-initializer-id for the hidden base class may be specified
633 // using a qualified name. ]
634 // Look for a member, first.
Douglas Gregor44b43212008-12-11 16:49:14 +0000635 FieldDecl *Member = 0;
Douglas Gregor6ab35242009-04-09 21:40:53 +0000636 DeclContext::lookup_result Result
637 = ClassDecl->lookup(Context, MemberOrBase);
Douglas Gregor44b43212008-12-11 16:49:14 +0000638 if (Result.first != Result.second)
639 Member = dyn_cast<FieldDecl>(*Result.first);
Douglas Gregor7ad83902008-11-05 04:29:56 +0000640
641 // FIXME: Handle members of an anonymous union.
642
643 if (Member) {
644 // FIXME: Perform direct initialization of the member.
645 return new CXXBaseOrMemberInitializer(Member, (Expr **)Args, NumArgs);
646 }
647
648 // It didn't name a member, so see if it names a class.
Douglas Gregorb696ea32009-02-04 17:00:24 +0000649 TypeTy *BaseTy = getTypeName(*MemberOrBase, IdLoc, S, 0/*SS*/);
Douglas Gregor7ad83902008-11-05 04:29:56 +0000650 if (!BaseTy)
Chris Lattner3c73c412008-11-19 08:23:25 +0000651 return Diag(IdLoc, diag::err_mem_init_not_member_or_class)
652 << MemberOrBase << SourceRange(IdLoc, RParenLoc);
Douglas Gregor7ad83902008-11-05 04:29:56 +0000653
Douglas Gregor1a51b4a2009-02-09 15:09:02 +0000654 QualType BaseType = QualType::getFromOpaquePtr(BaseTy);
Douglas Gregor7ad83902008-11-05 04:29:56 +0000655 if (!BaseType->isRecordType())
Chris Lattner3c73c412008-11-19 08:23:25 +0000656 return Diag(IdLoc, diag::err_base_init_does_not_name_class)
Chris Lattner08631c52008-11-23 21:45:46 +0000657 << BaseType << SourceRange(IdLoc, RParenLoc);
Douglas Gregor7ad83902008-11-05 04:29:56 +0000658
659 // C++ [class.base.init]p2:
660 // [...] Unless the mem-initializer-id names a nonstatic data
661 // member of the constructor’s class or a direct or virtual base
662 // of that class, the mem-initializer is ill-formed. A
663 // mem-initializer-list can initialize a base class using any
664 // name that denotes that base class type.
665
666 // First, check for a direct base class.
667 const CXXBaseSpecifier *DirectBaseSpec = 0;
668 for (CXXRecordDecl::base_class_const_iterator Base = ClassDecl->bases_begin();
669 Base != ClassDecl->bases_end(); ++Base) {
670 if (Context.getCanonicalType(BaseType).getUnqualifiedType() ==
671 Context.getCanonicalType(Base->getType()).getUnqualifiedType()) {
672 // We found a direct base of this type. That's what we're
673 // initializing.
674 DirectBaseSpec = &*Base;
675 break;
676 }
677 }
678
679 // Check for a virtual base class.
680 // FIXME: We might be able to short-circuit this if we know in
681 // advance that there are no virtual bases.
682 const CXXBaseSpecifier *VirtualBaseSpec = 0;
683 if (!DirectBaseSpec || !DirectBaseSpec->isVirtual()) {
684 // We haven't found a base yet; search the class hierarchy for a
685 // virtual base class.
686 BasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
687 /*DetectVirtual=*/false);
688 if (IsDerivedFrom(Context.getTypeDeclType(ClassDecl), BaseType, Paths)) {
689 for (BasePaths::paths_iterator Path = Paths.begin();
690 Path != Paths.end(); ++Path) {
691 if (Path->back().Base->isVirtual()) {
692 VirtualBaseSpec = Path->back().Base;
693 break;
694 }
695 }
696 }
697 }
698
699 // C++ [base.class.init]p2:
700 // If a mem-initializer-id is ambiguous because it designates both
701 // a direct non-virtual base class and an inherited virtual base
702 // class, the mem-initializer is ill-formed.
703 if (DirectBaseSpec && VirtualBaseSpec)
Chris Lattner3c73c412008-11-19 08:23:25 +0000704 return Diag(IdLoc, diag::err_base_init_direct_and_virtual)
705 << MemberOrBase << SourceRange(IdLoc, RParenLoc);
Douglas Gregor7ad83902008-11-05 04:29:56 +0000706
707 return new CXXBaseOrMemberInitializer(BaseType, (Expr **)Args, NumArgs);
708}
709
Chris Lattnerb28317a2009-03-28 19:18:32 +0000710void Sema::ActOnMemInitializers(DeclPtrTy ConstructorDecl,
Anders Carlssona7b35212009-03-25 02:58:17 +0000711 SourceLocation ColonLoc,
712 MemInitTy **MemInits, unsigned NumMemInits) {
713 CXXConstructorDecl *Constructor =
Chris Lattnerb28317a2009-03-28 19:18:32 +0000714 dyn_cast<CXXConstructorDecl>(ConstructorDecl.getAs<Decl>());
Anders Carlssona7b35212009-03-25 02:58:17 +0000715
716 if (!Constructor) {
717 Diag(ColonLoc, diag::err_only_constructors_take_base_inits);
718 return;
719 }
720}
721
Anders Carlsson67e4dd22009-03-22 01:52:17 +0000722namespace {
723 /// PureVirtualMethodCollector - traverses a class and its superclasses
724 /// and determines if it has any pure virtual methods.
725 class VISIBILITY_HIDDEN PureVirtualMethodCollector {
726 ASTContext &Context;
727
Sebastian Redldfe292d2009-03-22 21:28:55 +0000728 public:
Anders Carlsson67e4dd22009-03-22 01:52:17 +0000729 typedef llvm::SmallVector<const CXXMethodDecl*, 8> MethodList;
Sebastian Redldfe292d2009-03-22 21:28:55 +0000730
731 private:
Anders Carlsson67e4dd22009-03-22 01:52:17 +0000732 MethodList Methods;
733
734 void Collect(const CXXRecordDecl* RD, MethodList& Methods);
735
736 public:
737 PureVirtualMethodCollector(ASTContext &Ctx, const CXXRecordDecl* RD)
738 : Context(Ctx) {
739
740 MethodList List;
741 Collect(RD, List);
742
743 // Copy the temporary list to methods, and make sure to ignore any
744 // null entries.
745 for (size_t i = 0, e = List.size(); i != e; ++i) {
746 if (List[i])
747 Methods.push_back(List[i]);
748 }
749 }
750
Anders Carlsson4681ebd2009-03-22 20:18:17 +0000751 bool empty() const { return Methods.empty(); }
752
753 MethodList::const_iterator methods_begin() { return Methods.begin(); }
754 MethodList::const_iterator methods_end() { return Methods.end(); }
Anders Carlsson67e4dd22009-03-22 01:52:17 +0000755 };
756
757 void PureVirtualMethodCollector::Collect(const CXXRecordDecl* RD,
758 MethodList& Methods) {
759 // First, collect the pure virtual methods for the base classes.
760 for (CXXRecordDecl::base_class_const_iterator Base = RD->bases_begin(),
761 BaseEnd = RD->bases_end(); Base != BaseEnd; ++Base) {
762 if (const RecordType *RT = Base->getType()->getAsRecordType()) {
Chris Lattner64540d72009-03-29 05:01:10 +0000763 const CXXRecordDecl *BaseDecl = cast<CXXRecordDecl>(RT->getDecl());
Anders Carlsson67e4dd22009-03-22 01:52:17 +0000764 if (BaseDecl && BaseDecl->isAbstract())
765 Collect(BaseDecl, Methods);
766 }
767 }
768
769 // Next, zero out any pure virtual methods that this class overrides.
770 for (size_t i = 0, e = Methods.size(); i != e; ++i) {
771 const CXXMethodDecl *VMD = dyn_cast_or_null<CXXMethodDecl>(Methods[i]);
772 if (!VMD)
773 continue;
774
775 DeclContext::lookup_const_iterator I, E;
Douglas Gregor6ab35242009-04-09 21:40:53 +0000776 for (llvm::tie(I, E) = RD->lookup(Context, VMD->getDeclName());
777 I != E; ++I) {
Anders Carlsson67e4dd22009-03-22 01:52:17 +0000778 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(*I)) {
779 if (Context.getCanonicalType(MD->getType()) ==
780 Context.getCanonicalType(VMD->getType())) {
781 // We did find a matching method, which means that this is not a
782 // pure virtual method in the current class. Zero it out.
783 Methods[i] = 0;
784 }
785 }
786 }
787 }
788
789 // Finally, add pure virtual methods from this class.
Douglas Gregor6ab35242009-04-09 21:40:53 +0000790 for (RecordDecl::decl_iterator i = RD->decls_begin(Context),
791 e = RD->decls_end(Context);
Anders Carlsson67e4dd22009-03-22 01:52:17 +0000792 i != e; ++i) {
793 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(*i)) {
794 if (MD->isPure())
795 Methods.push_back(MD);
796 }
797 }
798 }
799}
Douglas Gregor7ad83902008-11-05 04:29:56 +0000800
Anders Carlsson4681ebd2009-03-22 20:18:17 +0000801bool Sema::RequireNonAbstractType(SourceLocation Loc, QualType T,
Anders Carlssone65a3c82009-03-24 17:23:42 +0000802 unsigned DiagID, AbstractDiagSelID SelID,
803 const CXXRecordDecl *CurrentRD) {
Anders Carlsson4681ebd2009-03-22 20:18:17 +0000804
805 if (!getLangOptions().CPlusPlus)
806 return false;
Anders Carlsson11f21a02009-03-23 19:10:31 +0000807
808 if (const ArrayType *AT = Context.getAsArrayType(T))
Anders Carlssone65a3c82009-03-24 17:23:42 +0000809 return RequireNonAbstractType(Loc, AT->getElementType(), DiagID, SelID,
810 CurrentRD);
Anders Carlsson5eff73c2009-03-24 01:46:45 +0000811
812 if (const PointerType *PT = T->getAsPointerType()) {
813 // Find the innermost pointer type.
814 while (const PointerType *T = PT->getPointeeType()->getAsPointerType())
815 PT = T;
Anders Carlsson4681ebd2009-03-22 20:18:17 +0000816
Anders Carlsson5eff73c2009-03-24 01:46:45 +0000817 if (const ArrayType *AT = Context.getAsArrayType(PT->getPointeeType()))
Anders Carlssone65a3c82009-03-24 17:23:42 +0000818 return RequireNonAbstractType(Loc, AT->getElementType(), DiagID, SelID,
819 CurrentRD);
Anders Carlsson5eff73c2009-03-24 01:46:45 +0000820 }
821
Anders Carlsson4681ebd2009-03-22 20:18:17 +0000822 const RecordType *RT = T->getAsRecordType();
823 if (!RT)
824 return false;
825
826 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl());
827 if (!RD)
828 return false;
829
Anders Carlssone65a3c82009-03-24 17:23:42 +0000830 if (CurrentRD && CurrentRD != RD)
831 return false;
832
Anders Carlsson4681ebd2009-03-22 20:18:17 +0000833 if (!RD->isAbstract())
834 return false;
835
Anders Carlssonb9bbe492009-03-23 17:49:10 +0000836 Diag(Loc, DiagID) << RD->getDeclName() << SelID;
Anders Carlsson4681ebd2009-03-22 20:18:17 +0000837
838 // Check if we've already emitted the list of pure virtual functions for this
839 // class.
840 if (PureVirtualClassDiagSet && PureVirtualClassDiagSet->count(RD))
841 return true;
842
843 PureVirtualMethodCollector Collector(Context, RD);
844
845 for (PureVirtualMethodCollector::MethodList::const_iterator I =
846 Collector.methods_begin(), E = Collector.methods_end(); I != E; ++I) {
847 const CXXMethodDecl *MD = *I;
848
849 Diag(MD->getLocation(), diag::note_pure_virtual_function) <<
850 MD->getDeclName();
851 }
852
853 if (!PureVirtualClassDiagSet)
854 PureVirtualClassDiagSet.reset(new RecordDeclSetTy);
855 PureVirtualClassDiagSet->insert(RD);
856
857 return true;
858}
859
Anders Carlsson8211eff2009-03-24 01:19:16 +0000860namespace {
861 class VISIBILITY_HIDDEN AbstractClassUsageDiagnoser
862 : public DeclVisitor<AbstractClassUsageDiagnoser, bool> {
863 Sema &SemaRef;
864 CXXRecordDecl *AbstractClass;
865
Anders Carlssone65a3c82009-03-24 17:23:42 +0000866 bool VisitDeclContext(const DeclContext *DC) {
Anders Carlsson8211eff2009-03-24 01:19:16 +0000867 bool Invalid = false;
868
Douglas Gregor6ab35242009-04-09 21:40:53 +0000869 for (CXXRecordDecl::decl_iterator I = DC->decls_begin(SemaRef.Context),
870 E = DC->decls_end(SemaRef.Context); I != E; ++I)
Anders Carlsson8211eff2009-03-24 01:19:16 +0000871 Invalid |= Visit(*I);
Anders Carlssone65a3c82009-03-24 17:23:42 +0000872
Anders Carlsson8211eff2009-03-24 01:19:16 +0000873 return Invalid;
874 }
Anders Carlssone65a3c82009-03-24 17:23:42 +0000875
876 public:
877 AbstractClassUsageDiagnoser(Sema& SemaRef, CXXRecordDecl *ac)
878 : SemaRef(SemaRef), AbstractClass(ac) {
879 Visit(SemaRef.Context.getTranslationUnitDecl());
880 }
Anders Carlsson8211eff2009-03-24 01:19:16 +0000881
Anders Carlssone65a3c82009-03-24 17:23:42 +0000882 bool VisitFunctionDecl(const FunctionDecl *FD) {
883 if (FD->isThisDeclarationADefinition()) {
884 // No need to do the check if we're in a definition, because it requires
885 // that the return/param types are complete.
886 // because that requires
887 return VisitDeclContext(FD);
888 }
889
890 // Check the return type.
891 QualType RTy = FD->getType()->getAsFunctionType()->getResultType();
892 bool Invalid =
893 SemaRef.RequireNonAbstractType(FD->getLocation(), RTy,
894 diag::err_abstract_type_in_decl,
895 Sema::AbstractReturnType,
896 AbstractClass);
897
898 for (FunctionDecl::param_const_iterator I = FD->param_begin(),
899 E = FD->param_end(); I != E; ++I) {
Anders Carlsson8211eff2009-03-24 01:19:16 +0000900 const ParmVarDecl *VD = *I;
901 Invalid |=
902 SemaRef.RequireNonAbstractType(VD->getLocation(),
903 VD->getOriginalType(),
904 diag::err_abstract_type_in_decl,
Anders Carlssone65a3c82009-03-24 17:23:42 +0000905 Sema::AbstractParamType,
906 AbstractClass);
Anders Carlsson8211eff2009-03-24 01:19:16 +0000907 }
908
909 return Invalid;
910 }
Anders Carlssone65a3c82009-03-24 17:23:42 +0000911
912 bool VisitDecl(const Decl* D) {
913 if (const DeclContext *DC = dyn_cast<DeclContext>(D))
914 return VisitDeclContext(DC);
915
916 return false;
917 }
Anders Carlsson8211eff2009-03-24 01:19:16 +0000918 };
919}
920
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000921void Sema::ActOnFinishCXXMemberSpecification(Scope* S, SourceLocation RLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +0000922 DeclPtrTy TagDecl,
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000923 SourceLocation LBrac,
924 SourceLocation RBrac) {
Douglas Gregor2943aed2009-03-03 04:44:36 +0000925 TemplateDecl *Template = AdjustDeclIfTemplate(TagDecl);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000926 ActOnFields(S, RLoc, TagDecl,
Chris Lattnerb28317a2009-03-28 19:18:32 +0000927 (DeclPtrTy*)FieldCollector->getCurFields(),
Daniel Dunbar1bfe1c22008-10-03 02:03:53 +0000928 FieldCollector->getCurNumFields(), LBrac, RBrac, 0);
Douglas Gregor2943aed2009-03-03 04:44:36 +0000929
Chris Lattnerb28317a2009-03-28 19:18:32 +0000930 CXXRecordDecl *RD = cast<CXXRecordDecl>(TagDecl.getAs<Decl>());
Anders Carlsson67e4dd22009-03-22 01:52:17 +0000931 if (!RD->isAbstract()) {
932 // Collect all the pure virtual methods and see if this is an abstract
933 // class after all.
934 PureVirtualMethodCollector Collector(Context, RD);
935 if (!Collector.empty())
936 RD->setAbstract(true);
937 }
938
Anders Carlssone65a3c82009-03-24 17:23:42 +0000939 if (RD->isAbstract())
940 AbstractClassUsageDiagnoser(*this, RD);
Anders Carlsson8211eff2009-03-24 01:19:16 +0000941
Douglas Gregor2943aed2009-03-03 04:44:36 +0000942 if (!Template)
Anders Carlsson67e4dd22009-03-22 01:52:17 +0000943 AddImplicitlyDeclaredMembersToClass(RD);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000944}
945
Douglas Gregor396b7cd2008-11-03 17:51:48 +0000946/// AddImplicitlyDeclaredMembersToClass - Adds any implicitly-declared
947/// special functions, such as the default constructor, copy
948/// constructor, or destructor, to the given C++ class (C++
949/// [special]p1). This routine can only be executed just before the
950/// definition of the class is complete.
951void Sema::AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl) {
Douglas Gregor2e1cd422008-11-17 14:58:09 +0000952 QualType ClassType = Context.getTypeDeclType(ClassDecl);
953 ClassType = Context.getCanonicalType(ClassType);
954
Douglas Gregor396b7cd2008-11-03 17:51:48 +0000955 if (!ClassDecl->hasUserDeclaredConstructor()) {
956 // C++ [class.ctor]p5:
957 // A default constructor for a class X is a constructor of class X
958 // that can be called without an argument. If there is no
959 // user-declared constructor for class X, a default constructor is
960 // implicitly declared. An implicitly-declared default constructor
961 // is an inline public member of its class.
Douglas Gregor2e1cd422008-11-17 14:58:09 +0000962 DeclarationName Name
963 = Context.DeclarationNames.getCXXConstructorName(ClassType);
Douglas Gregor396b7cd2008-11-03 17:51:48 +0000964 CXXConstructorDecl *DefaultCon =
965 CXXConstructorDecl::Create(Context, ClassDecl,
Douglas Gregor2e1cd422008-11-17 14:58:09 +0000966 ClassDecl->getLocation(), Name,
Douglas Gregor396b7cd2008-11-03 17:51:48 +0000967 Context.getFunctionType(Context.VoidTy,
968 0, 0, false, 0),
969 /*isExplicit=*/false,
970 /*isInline=*/true,
971 /*isImplicitlyDeclared=*/true);
972 DefaultCon->setAccess(AS_public);
Douglas Gregor6b3945f2009-01-07 19:46:03 +0000973 DefaultCon->setImplicit();
Douglas Gregor6ab35242009-04-09 21:40:53 +0000974 ClassDecl->addDecl(Context, DefaultCon);
Douglas Gregor9e7d9de2008-12-15 21:24:18 +0000975
976 // Notify the class that we've added a constructor.
977 ClassDecl->addedConstructor(Context, DefaultCon);
Douglas Gregor396b7cd2008-11-03 17:51:48 +0000978 }
979
980 if (!ClassDecl->hasUserDeclaredCopyConstructor()) {
981 // C++ [class.copy]p4:
982 // If the class definition does not explicitly declare a copy
983 // constructor, one is declared implicitly.
984
985 // C++ [class.copy]p5:
986 // The implicitly-declared copy constructor for a class X will
987 // have the form
988 //
989 // X::X(const X&)
990 //
991 // if
992 bool HasConstCopyConstructor = true;
993
994 // -- each direct or virtual base class B of X has a copy
995 // constructor whose first parameter is of type const B& or
996 // const volatile B&, and
997 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin();
998 HasConstCopyConstructor && Base != ClassDecl->bases_end(); ++Base) {
999 const CXXRecordDecl *BaseClassDecl
1000 = cast<CXXRecordDecl>(Base->getType()->getAsRecordType()->getDecl());
1001 HasConstCopyConstructor
1002 = BaseClassDecl->hasConstCopyConstructor(Context);
1003 }
1004
1005 // -- for all the nonstatic data members of X that are of a
1006 // class type M (or array thereof), each such class type
1007 // has a copy constructor whose first parameter is of type
1008 // const M& or const volatile M&.
Douglas Gregor6ab35242009-04-09 21:40:53 +00001009 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(Context);
1010 HasConstCopyConstructor && Field != ClassDecl->field_end(Context);
1011 ++Field) {
Douglas Gregor396b7cd2008-11-03 17:51:48 +00001012 QualType FieldType = (*Field)->getType();
1013 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
1014 FieldType = Array->getElementType();
1015 if (const RecordType *FieldClassType = FieldType->getAsRecordType()) {
1016 const CXXRecordDecl *FieldClassDecl
1017 = cast<CXXRecordDecl>(FieldClassType->getDecl());
1018 HasConstCopyConstructor
1019 = FieldClassDecl->hasConstCopyConstructor(Context);
1020 }
1021 }
1022
Sebastian Redl64b45f72009-01-05 20:52:13 +00001023 // Otherwise, the implicitly declared copy constructor will have
1024 // the form
Douglas Gregor396b7cd2008-11-03 17:51:48 +00001025 //
1026 // X::X(X&)
Sebastian Redl64b45f72009-01-05 20:52:13 +00001027 QualType ArgType = ClassType;
Douglas Gregor396b7cd2008-11-03 17:51:48 +00001028 if (HasConstCopyConstructor)
1029 ArgType = ArgType.withConst();
Sebastian Redl7c80bd62009-03-16 23:22:08 +00001030 ArgType = Context.getLValueReferenceType(ArgType);
Douglas Gregor396b7cd2008-11-03 17:51:48 +00001031
Sebastian Redl64b45f72009-01-05 20:52:13 +00001032 // An implicitly-declared copy constructor is an inline public
1033 // member of its class.
Douglas Gregor2e1cd422008-11-17 14:58:09 +00001034 DeclarationName Name
1035 = Context.DeclarationNames.getCXXConstructorName(ClassType);
Douglas Gregor396b7cd2008-11-03 17:51:48 +00001036 CXXConstructorDecl *CopyConstructor
1037 = CXXConstructorDecl::Create(Context, ClassDecl,
Douglas Gregor2e1cd422008-11-17 14:58:09 +00001038 ClassDecl->getLocation(), Name,
Douglas Gregor396b7cd2008-11-03 17:51:48 +00001039 Context.getFunctionType(Context.VoidTy,
1040 &ArgType, 1,
1041 false, 0),
1042 /*isExplicit=*/false,
1043 /*isInline=*/true,
1044 /*isImplicitlyDeclared=*/true);
1045 CopyConstructor->setAccess(AS_public);
Douglas Gregor6b3945f2009-01-07 19:46:03 +00001046 CopyConstructor->setImplicit();
Douglas Gregor396b7cd2008-11-03 17:51:48 +00001047
1048 // Add the parameter to the constructor.
1049 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyConstructor,
1050 ClassDecl->getLocation(),
1051 /*IdentifierInfo=*/0,
Douglas Gregor4afa39d2009-01-20 01:17:11 +00001052 ArgType, VarDecl::None, 0);
Ted Kremenekfc767612009-01-14 00:42:25 +00001053 CopyConstructor->setParams(Context, &FromParam, 1);
Douglas Gregor396b7cd2008-11-03 17:51:48 +00001054
Douglas Gregor9e7d9de2008-12-15 21:24:18 +00001055 ClassDecl->addedConstructor(Context, CopyConstructor);
Douglas Gregor6ab35242009-04-09 21:40:53 +00001056 ClassDecl->addDecl(Context, CopyConstructor);
Douglas Gregor396b7cd2008-11-03 17:51:48 +00001057 }
1058
Sebastian Redl64b45f72009-01-05 20:52:13 +00001059 if (!ClassDecl->hasUserDeclaredCopyAssignment()) {
1060 // Note: The following rules are largely analoguous to the copy
1061 // constructor rules. Note that virtual bases are not taken into account
1062 // for determining the argument type of the operator. Note also that
1063 // operators taking an object instead of a reference are allowed.
1064 //
1065 // C++ [class.copy]p10:
1066 // If the class definition does not explicitly declare a copy
1067 // assignment operator, one is declared implicitly.
1068 // The implicitly-defined copy assignment operator for a class X
1069 // will have the form
1070 //
1071 // X& X::operator=(const X&)
1072 //
1073 // if
1074 bool HasConstCopyAssignment = true;
1075
1076 // -- each direct base class B of X has a copy assignment operator
1077 // whose parameter is of type const B&, const volatile B& or B,
1078 // and
1079 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin();
1080 HasConstCopyAssignment && Base != ClassDecl->bases_end(); ++Base) {
1081 const CXXRecordDecl *BaseClassDecl
1082 = cast<CXXRecordDecl>(Base->getType()->getAsRecordType()->getDecl());
1083 HasConstCopyAssignment = BaseClassDecl->hasConstCopyAssignment(Context);
1084 }
1085
1086 // -- for all the nonstatic data members of X that are of a class
1087 // type M (or array thereof), each such class type has a copy
1088 // assignment operator whose parameter is of type const M&,
1089 // const volatile M& or M.
Douglas Gregor6ab35242009-04-09 21:40:53 +00001090 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(Context);
1091 HasConstCopyAssignment && Field != ClassDecl->field_end(Context);
1092 ++Field) {
Sebastian Redl64b45f72009-01-05 20:52:13 +00001093 QualType FieldType = (*Field)->getType();
1094 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
1095 FieldType = Array->getElementType();
1096 if (const RecordType *FieldClassType = FieldType->getAsRecordType()) {
1097 const CXXRecordDecl *FieldClassDecl
1098 = cast<CXXRecordDecl>(FieldClassType->getDecl());
1099 HasConstCopyAssignment
1100 = FieldClassDecl->hasConstCopyAssignment(Context);
1101 }
1102 }
1103
1104 // Otherwise, the implicitly declared copy assignment operator will
1105 // have the form
1106 //
1107 // X& X::operator=(X&)
1108 QualType ArgType = ClassType;
Sebastian Redl7c80bd62009-03-16 23:22:08 +00001109 QualType RetType = Context.getLValueReferenceType(ArgType);
Sebastian Redl64b45f72009-01-05 20:52:13 +00001110 if (HasConstCopyAssignment)
1111 ArgType = ArgType.withConst();
Sebastian Redl7c80bd62009-03-16 23:22:08 +00001112 ArgType = Context.getLValueReferenceType(ArgType);
Sebastian Redl64b45f72009-01-05 20:52:13 +00001113
1114 // An implicitly-declared copy assignment operator is an inline public
1115 // member of its class.
1116 DeclarationName Name =
1117 Context.DeclarationNames.getCXXOperatorName(OO_Equal);
1118 CXXMethodDecl *CopyAssignment =
1119 CXXMethodDecl::Create(Context, ClassDecl, ClassDecl->getLocation(), Name,
1120 Context.getFunctionType(RetType, &ArgType, 1,
1121 false, 0),
Douglas Gregor4afa39d2009-01-20 01:17:11 +00001122 /*isStatic=*/false, /*isInline=*/true);
Sebastian Redl64b45f72009-01-05 20:52:13 +00001123 CopyAssignment->setAccess(AS_public);
Douglas Gregor6b3945f2009-01-07 19:46:03 +00001124 CopyAssignment->setImplicit();
Sebastian Redl64b45f72009-01-05 20:52:13 +00001125
1126 // Add the parameter to the operator.
1127 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyAssignment,
1128 ClassDecl->getLocation(),
1129 /*IdentifierInfo=*/0,
Douglas Gregor4afa39d2009-01-20 01:17:11 +00001130 ArgType, VarDecl::None, 0);
Ted Kremenekfc767612009-01-14 00:42:25 +00001131 CopyAssignment->setParams(Context, &FromParam, 1);
Sebastian Redl64b45f72009-01-05 20:52:13 +00001132
1133 // Don't call addedAssignmentOperator. There is no way to distinguish an
1134 // implicit from an explicit assignment operator.
Douglas Gregor6ab35242009-04-09 21:40:53 +00001135 ClassDecl->addDecl(Context, CopyAssignment);
Sebastian Redl64b45f72009-01-05 20:52:13 +00001136 }
1137
Douglas Gregor9e7d9de2008-12-15 21:24:18 +00001138 if (!ClassDecl->hasUserDeclaredDestructor()) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00001139 // C++ [class.dtor]p2:
1140 // If a class has no user-declared destructor, a destructor is
1141 // declared implicitly. An implicitly-declared destructor is an
1142 // inline public member of its class.
Douglas Gregor2e1cd422008-11-17 14:58:09 +00001143 DeclarationName Name
1144 = Context.DeclarationNames.getCXXDestructorName(ClassType);
Douglas Gregor42a552f2008-11-05 20:51:48 +00001145 CXXDestructorDecl *Destructor
1146 = CXXDestructorDecl::Create(Context, ClassDecl,
Douglas Gregor2e1cd422008-11-17 14:58:09 +00001147 ClassDecl->getLocation(), Name,
Douglas Gregor42a552f2008-11-05 20:51:48 +00001148 Context.getFunctionType(Context.VoidTy,
1149 0, 0, false, 0),
1150 /*isInline=*/true,
1151 /*isImplicitlyDeclared=*/true);
1152 Destructor->setAccess(AS_public);
Douglas Gregor6b3945f2009-01-07 19:46:03 +00001153 Destructor->setImplicit();
Douglas Gregor6ab35242009-04-09 21:40:53 +00001154 ClassDecl->addDecl(Context, Destructor);
Douglas Gregor42a552f2008-11-05 20:51:48 +00001155 }
Douglas Gregor396b7cd2008-11-03 17:51:48 +00001156}
1157
Douglas Gregor72b505b2008-12-16 21:30:33 +00001158/// ActOnStartDelayedCXXMethodDeclaration - We have completed
1159/// parsing a top-level (non-nested) C++ class, and we are now
1160/// parsing those parts of the given Method declaration that could
1161/// not be parsed earlier (C++ [class.mem]p2), such as default
1162/// arguments. This action should enter the scope of the given
1163/// Method declaration as if we had just parsed the qualified method
1164/// name. However, it should not bring the parameters into scope;
1165/// that will be performed by ActOnDelayedCXXMethodParameter.
Chris Lattnerb28317a2009-03-28 19:18:32 +00001166void Sema::ActOnStartDelayedCXXMethodDeclaration(Scope *S, DeclPtrTy MethodD) {
Douglas Gregor72b505b2008-12-16 21:30:33 +00001167 CXXScopeSpec SS;
Chris Lattnerb28317a2009-03-28 19:18:32 +00001168 FunctionDecl *Method = cast<FunctionDecl>(MethodD.getAs<Decl>());
Douglas Gregorab452ba2009-03-26 23:50:42 +00001169 QualType ClassTy
1170 = Context.getTypeDeclType(cast<RecordDecl>(Method->getDeclContext()));
1171 SS.setScopeRep(
1172 NestedNameSpecifier::Create(Context, 0, false, ClassTy.getTypePtr()));
Douglas Gregor72b505b2008-12-16 21:30:33 +00001173 ActOnCXXEnterDeclaratorScope(S, SS);
1174}
1175
1176/// ActOnDelayedCXXMethodParameter - We've already started a delayed
1177/// C++ method declaration. We're (re-)introducing the given
1178/// function parameter into scope for use in parsing later parts of
1179/// the method declaration. For example, we could see an
1180/// ActOnParamDefaultArgument event for this parameter.
Chris Lattnerb28317a2009-03-28 19:18:32 +00001181void Sema::ActOnDelayedCXXMethodParameter(Scope *S, DeclPtrTy ParamD) {
1182 ParmVarDecl *Param = cast<ParmVarDecl>(ParamD.getAs<Decl>());
Douglas Gregor61366e92008-12-24 00:01:03 +00001183
1184 // If this parameter has an unparsed default argument, clear it out
1185 // to make way for the parsed default argument.
1186 if (Param->hasUnparsedDefaultArg())
1187 Param->setDefaultArg(0);
1188
Chris Lattnerb28317a2009-03-28 19:18:32 +00001189 S->AddDecl(DeclPtrTy::make(Param));
Douglas Gregor72b505b2008-12-16 21:30:33 +00001190 if (Param->getDeclName())
1191 IdResolver.AddDecl(Param);
1192}
1193
1194/// ActOnFinishDelayedCXXMethodDeclaration - We have finished
1195/// processing the delayed method declaration for Method. The method
1196/// declaration is now considered finished. There may be a separate
1197/// ActOnStartOfFunctionDef action later (not necessarily
1198/// immediately!) for this method, if it was also defined inside the
1199/// class body.
Chris Lattnerb28317a2009-03-28 19:18:32 +00001200void Sema::ActOnFinishDelayedCXXMethodDeclaration(Scope *S, DeclPtrTy MethodD) {
1201 FunctionDecl *Method = cast<FunctionDecl>(MethodD.getAs<Decl>());
Douglas Gregor72b505b2008-12-16 21:30:33 +00001202 CXXScopeSpec SS;
Douglas Gregorab452ba2009-03-26 23:50:42 +00001203 QualType ClassTy
1204 = Context.getTypeDeclType(cast<RecordDecl>(Method->getDeclContext()));
1205 SS.setScopeRep(
1206 NestedNameSpecifier::Create(Context, 0, false, ClassTy.getTypePtr()));
Douglas Gregor72b505b2008-12-16 21:30:33 +00001207 ActOnCXXExitDeclaratorScope(S, SS);
1208
1209 // Now that we have our default arguments, check the constructor
1210 // again. It could produce additional diagnostics or affect whether
1211 // the class has implicitly-declared destructors, among other
1212 // things.
1213 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Method)) {
1214 if (CheckConstructor(Constructor))
1215 Constructor->setInvalidDecl();
1216 }
1217
1218 // Check the default arguments, which we may have added.
1219 if (!Method->isInvalidDecl())
1220 CheckCXXDefaultArguments(Method);
1221}
1222
Douglas Gregor42a552f2008-11-05 20:51:48 +00001223/// CheckConstructorDeclarator - Called by ActOnDeclarator to check
Douglas Gregor72b505b2008-12-16 21:30:33 +00001224/// the well-formedness of the constructor declarator @p D with type @p
Douglas Gregor42a552f2008-11-05 20:51:48 +00001225/// R. If there are any errors in the declarator, this routine will
1226/// emit diagnostics and return true. Otherwise, it will return
1227/// false. Either way, the type @p R will be updated to reflect a
1228/// well-formed type for the constructor.
1229bool Sema::CheckConstructorDeclarator(Declarator &D, QualType &R,
1230 FunctionDecl::StorageClass& SC) {
1231 bool isVirtual = D.getDeclSpec().isVirtualSpecified();
1232 bool isInvalid = false;
1233
1234 // C++ [class.ctor]p3:
1235 // A constructor shall not be virtual (10.3) or static (9.4). A
1236 // constructor can be invoked for a const, volatile or const
1237 // volatile object. A constructor shall not be declared const,
1238 // volatile, or const volatile (9.3.2).
1239 if (isVirtual) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001240 Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
1241 << "virtual" << SourceRange(D.getDeclSpec().getVirtualSpecLoc())
1242 << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00001243 isInvalid = true;
1244 }
1245 if (SC == FunctionDecl::Static) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001246 Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
1247 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
1248 << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00001249 isInvalid = true;
1250 SC = FunctionDecl::None;
1251 }
1252 if (D.getDeclSpec().hasTypeSpecifier()) {
1253 // Constructors don't have return types, but the parser will
1254 // happily parse something like:
1255 //
1256 // class X {
1257 // float X(float);
1258 // };
1259 //
1260 // The return type will be eliminated later.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001261 Diag(D.getIdentifierLoc(), diag::err_constructor_return_type)
1262 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
1263 << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00001264 }
Douglas Gregor72564e72009-02-26 23:50:07 +00001265 if (R->getAsFunctionProtoType()->getTypeQuals() != 0) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00001266 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
1267 if (FTI.TypeQuals & QualType::Const)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001268 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
1269 << "const" << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00001270 if (FTI.TypeQuals & QualType::Volatile)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001271 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
1272 << "volatile" << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00001273 if (FTI.TypeQuals & QualType::Restrict)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001274 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
1275 << "restrict" << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00001276 }
1277
1278 // Rebuild the function type "R" without any type qualifiers (in
1279 // case any of the errors above fired) and with "void" as the
1280 // return type, since constructors don't have return types. We
1281 // *always* have to do this, because GetTypeForDeclarator will
1282 // put in a result type of "int" when none was specified.
Douglas Gregor72564e72009-02-26 23:50:07 +00001283 const FunctionProtoType *Proto = R->getAsFunctionProtoType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00001284 R = Context.getFunctionType(Context.VoidTy, Proto->arg_type_begin(),
1285 Proto->getNumArgs(),
1286 Proto->isVariadic(),
1287 0);
1288
1289 return isInvalid;
1290}
1291
Douglas Gregor72b505b2008-12-16 21:30:33 +00001292/// CheckConstructor - Checks a fully-formed constructor for
1293/// well-formedness, issuing any diagnostics required. Returns true if
1294/// the constructor declarator is invalid.
1295bool Sema::CheckConstructor(CXXConstructorDecl *Constructor) {
Douglas Gregor33297562009-03-27 04:38:56 +00001296 CXXRecordDecl *ClassDecl
1297 = dyn_cast<CXXRecordDecl>(Constructor->getDeclContext());
1298 if (!ClassDecl)
Douglas Gregor72b505b2008-12-16 21:30:33 +00001299 return true;
1300
Douglas Gregor33297562009-03-27 04:38:56 +00001301 bool Invalid = Constructor->isInvalidDecl();
Douglas Gregor72b505b2008-12-16 21:30:33 +00001302
1303 // C++ [class.copy]p3:
1304 // A declaration of a constructor for a class X is ill-formed if
1305 // its first parameter is of type (optionally cv-qualified) X and
1306 // either there are no other parameters or else all other
1307 // parameters have default arguments.
Douglas Gregor33297562009-03-27 04:38:56 +00001308 if (!Constructor->isInvalidDecl() &&
1309 ((Constructor->getNumParams() == 1) ||
1310 (Constructor->getNumParams() > 1 &&
1311 Constructor->getParamDecl(1)->getDefaultArg() != 0))) {
Douglas Gregor72b505b2008-12-16 21:30:33 +00001312 QualType ParamType = Constructor->getParamDecl(0)->getType();
1313 QualType ClassTy = Context.getTagDeclType(ClassDecl);
1314 if (Context.getCanonicalType(ParamType).getUnqualifiedType() == ClassTy) {
Douglas Gregora3a83512009-04-01 23:51:29 +00001315 SourceLocation ParamLoc = Constructor->getParamDecl(0)->getLocation();
1316 Diag(ParamLoc, diag::err_constructor_byvalue_arg)
Douglas Gregor558cb562009-04-02 01:08:08 +00001317 << CodeModificationHint::CreateInsertion(ParamLoc, " const &");
Douglas Gregor72b505b2008-12-16 21:30:33 +00001318 Invalid = true;
1319 }
1320 }
1321
1322 // Notify the class that we've added a constructor.
1323 ClassDecl->addedConstructor(Context, Constructor);
1324
1325 return Invalid;
1326}
1327
Douglas Gregor42a552f2008-11-05 20:51:48 +00001328/// CheckDestructorDeclarator - Called by ActOnDeclarator to check
1329/// the well-formednes of the destructor declarator @p D with type @p
1330/// R. If there are any errors in the declarator, this routine will
1331/// emit diagnostics and return true. Otherwise, it will return
1332/// false. Either way, the type @p R will be updated to reflect a
1333/// well-formed type for the destructor.
1334bool Sema::CheckDestructorDeclarator(Declarator &D, QualType &R,
1335 FunctionDecl::StorageClass& SC) {
1336 bool isInvalid = false;
1337
1338 // C++ [class.dtor]p1:
1339 // [...] A typedef-name that names a class is a class-name
1340 // (7.1.3); however, a typedef-name that names a class shall not
1341 // be used as the identifier in the declarator for a destructor
1342 // declaration.
Douglas Gregor1a51b4a2009-02-09 15:09:02 +00001343 QualType DeclaratorType = QualType::getFromOpaquePtr(D.getDeclaratorIdType());
1344 if (DeclaratorType->getAsTypedefType()) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001345 Diag(D.getIdentifierLoc(), diag::err_destructor_typedef_name)
Douglas Gregor1a51b4a2009-02-09 15:09:02 +00001346 << DeclaratorType;
Douglas Gregor55c60952008-11-10 14:41:22 +00001347 isInvalid = true;
Douglas Gregor42a552f2008-11-05 20:51:48 +00001348 }
1349
1350 // C++ [class.dtor]p2:
1351 // A destructor is used to destroy objects of its class type. A
1352 // destructor takes no parameters, and no return type can be
1353 // specified for it (not even void). The address of a destructor
1354 // shall not be taken. A destructor shall not be static. A
1355 // destructor can be invoked for a const, volatile or const
1356 // volatile object. A destructor shall not be declared const,
1357 // volatile or const volatile (9.3.2).
1358 if (SC == FunctionDecl::Static) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001359 Diag(D.getIdentifierLoc(), diag::err_destructor_cannot_be)
1360 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
1361 << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00001362 isInvalid = true;
1363 SC = FunctionDecl::None;
1364 }
1365 if (D.getDeclSpec().hasTypeSpecifier()) {
1366 // Destructors don't have return types, but the parser will
1367 // happily parse something like:
1368 //
1369 // class X {
1370 // float ~X();
1371 // };
1372 //
1373 // The return type will be eliminated later.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001374 Diag(D.getIdentifierLoc(), diag::err_destructor_return_type)
1375 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
1376 << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00001377 }
Douglas Gregor72564e72009-02-26 23:50:07 +00001378 if (R->getAsFunctionProtoType()->getTypeQuals() != 0) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00001379 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
1380 if (FTI.TypeQuals & QualType::Const)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001381 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
1382 << "const" << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00001383 if (FTI.TypeQuals & QualType::Volatile)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001384 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
1385 << "volatile" << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00001386 if (FTI.TypeQuals & QualType::Restrict)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001387 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
1388 << "restrict" << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00001389 }
1390
1391 // Make sure we don't have any parameters.
Douglas Gregor72564e72009-02-26 23:50:07 +00001392 if (R->getAsFunctionProtoType()->getNumArgs() > 0) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00001393 Diag(D.getIdentifierLoc(), diag::err_destructor_with_params);
1394
1395 // Delete the parameters.
Chris Lattner1833a832009-01-20 21:06:38 +00001396 D.getTypeObject(0).Fun.freeArgs();
Douglas Gregor42a552f2008-11-05 20:51:48 +00001397 }
1398
1399 // Make sure the destructor isn't variadic.
Douglas Gregor72564e72009-02-26 23:50:07 +00001400 if (R->getAsFunctionProtoType()->isVariadic())
Douglas Gregor42a552f2008-11-05 20:51:48 +00001401 Diag(D.getIdentifierLoc(), diag::err_destructor_variadic);
1402
1403 // Rebuild the function type "R" without any type qualifiers or
1404 // parameters (in case any of the errors above fired) and with
1405 // "void" as the return type, since destructors don't have return
1406 // types. We *always* have to do this, because GetTypeForDeclarator
1407 // will put in a result type of "int" when none was specified.
1408 R = Context.getFunctionType(Context.VoidTy, 0, 0, false, 0);
1409
1410 return isInvalid;
1411}
1412
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001413/// CheckConversionDeclarator - Called by ActOnDeclarator to check the
1414/// well-formednes of the conversion function declarator @p D with
1415/// type @p R. If there are any errors in the declarator, this routine
1416/// will emit diagnostics and return true. Otherwise, it will return
1417/// false. Either way, the type @p R will be updated to reflect a
1418/// well-formed type for the conversion operator.
1419bool Sema::CheckConversionDeclarator(Declarator &D, QualType &R,
1420 FunctionDecl::StorageClass& SC) {
1421 bool isInvalid = false;
1422
1423 // C++ [class.conv.fct]p1:
1424 // Neither parameter types nor return type can be specified. The
1425 // type of a conversion function (8.3.5) is “function taking no
1426 // parameter returning conversion-type-id.”
1427 if (SC == FunctionDecl::Static) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001428 Diag(D.getIdentifierLoc(), diag::err_conv_function_not_member)
1429 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
1430 << SourceRange(D.getIdentifierLoc());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001431 isInvalid = true;
1432 SC = FunctionDecl::None;
1433 }
1434 if (D.getDeclSpec().hasTypeSpecifier()) {
1435 // Conversion functions don't have return types, but the parser will
1436 // happily parse something like:
1437 //
1438 // class X {
1439 // float operator bool();
1440 // };
1441 //
1442 // The return type will be changed later anyway.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001443 Diag(D.getIdentifierLoc(), diag::err_conv_function_return_type)
1444 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
1445 << SourceRange(D.getIdentifierLoc());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001446 }
1447
1448 // Make sure we don't have any parameters.
Douglas Gregor72564e72009-02-26 23:50:07 +00001449 if (R->getAsFunctionProtoType()->getNumArgs() > 0) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001450 Diag(D.getIdentifierLoc(), diag::err_conv_function_with_params);
1451
1452 // Delete the parameters.
Chris Lattner1833a832009-01-20 21:06:38 +00001453 D.getTypeObject(0).Fun.freeArgs();
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001454 }
1455
1456 // Make sure the conversion function isn't variadic.
Douglas Gregor72564e72009-02-26 23:50:07 +00001457 if (R->getAsFunctionProtoType()->isVariadic())
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001458 Diag(D.getIdentifierLoc(), diag::err_conv_function_variadic);
1459
1460 // C++ [class.conv.fct]p4:
1461 // The conversion-type-id shall not represent a function type nor
1462 // an array type.
1463 QualType ConvType = QualType::getFromOpaquePtr(D.getDeclaratorIdType());
1464 if (ConvType->isArrayType()) {
1465 Diag(D.getIdentifierLoc(), diag::err_conv_function_to_array);
1466 ConvType = Context.getPointerType(ConvType);
1467 } else if (ConvType->isFunctionType()) {
1468 Diag(D.getIdentifierLoc(), diag::err_conv_function_to_function);
1469 ConvType = Context.getPointerType(ConvType);
1470 }
1471
1472 // Rebuild the function type "R" without any parameters (in case any
1473 // of the errors above fired) and with the conversion type as the
1474 // return type.
1475 R = Context.getFunctionType(ConvType, 0, 0, false,
Douglas Gregor72564e72009-02-26 23:50:07 +00001476 R->getAsFunctionProtoType()->getTypeQuals());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001477
Douglas Gregor09f41cf2009-01-14 15:45:31 +00001478 // C++0x explicit conversion operators.
1479 if (D.getDeclSpec().isExplicitSpecified() && !getLangOptions().CPlusPlus0x)
1480 Diag(D.getDeclSpec().getExplicitSpecLoc(),
1481 diag::warn_explicit_conversion_functions)
1482 << SourceRange(D.getDeclSpec().getExplicitSpecLoc());
1483
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001484 return isInvalid;
1485}
1486
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001487/// ActOnConversionDeclarator - Called by ActOnDeclarator to complete
1488/// the declaration of the given C++ conversion function. This routine
1489/// is responsible for recording the conversion function in the C++
1490/// class, if possible.
Chris Lattnerb28317a2009-03-28 19:18:32 +00001491Sema::DeclPtrTy Sema::ActOnConversionDeclarator(CXXConversionDecl *Conversion) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001492 assert(Conversion && "Expected to receive a conversion function declaration");
1493
Douglas Gregor9d350972008-12-12 08:25:50 +00001494 // Set the lexical context of this conversion function
1495 Conversion->setLexicalDeclContext(CurContext);
1496
1497 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Conversion->getDeclContext());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001498
1499 // Make sure we aren't redeclaring the conversion function.
1500 QualType ConvType = Context.getCanonicalType(Conversion->getConversionType());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001501
1502 // C++ [class.conv.fct]p1:
1503 // [...] A conversion function is never used to convert a
1504 // (possibly cv-qualified) object to the (possibly cv-qualified)
1505 // same object type (or a reference to it), to a (possibly
1506 // cv-qualified) base class of that type (or a reference to it),
1507 // or to (possibly cv-qualified) void.
1508 // FIXME: Suppress this warning if the conversion function ends up
1509 // being a virtual function that overrides a virtual function in a
1510 // base class.
1511 QualType ClassType
1512 = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
1513 if (const ReferenceType *ConvTypeRef = ConvType->getAsReferenceType())
1514 ConvType = ConvTypeRef->getPointeeType();
1515 if (ConvType->isRecordType()) {
1516 ConvType = Context.getCanonicalType(ConvType).getUnqualifiedType();
1517 if (ConvType == ClassType)
Chris Lattner5dc266a2008-11-20 06:13:02 +00001518 Diag(Conversion->getLocation(), diag::warn_conv_to_self_not_used)
Chris Lattnerd1625842008-11-24 06:25:27 +00001519 << ClassType;
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001520 else if (IsDerivedFrom(ClassType, ConvType))
Chris Lattner5dc266a2008-11-20 06:13:02 +00001521 Diag(Conversion->getLocation(), diag::warn_conv_to_base_not_used)
Chris Lattnerd1625842008-11-24 06:25:27 +00001522 << ClassType << ConvType;
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001523 } else if (ConvType->isVoidType()) {
Chris Lattner5dc266a2008-11-20 06:13:02 +00001524 Diag(Conversion->getLocation(), diag::warn_conv_to_void_not_used)
Chris Lattnerd1625842008-11-24 06:25:27 +00001525 << ClassType << ConvType;
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001526 }
1527
Douglas Gregor70316a02008-12-26 15:00:45 +00001528 if (Conversion->getPreviousDeclaration()) {
1529 OverloadedFunctionDecl *Conversions = ClassDecl->getConversionFunctions();
1530 for (OverloadedFunctionDecl::function_iterator
1531 Conv = Conversions->function_begin(),
1532 ConvEnd = Conversions->function_end();
1533 Conv != ConvEnd; ++Conv) {
1534 if (*Conv == Conversion->getPreviousDeclaration()) {
1535 *Conv = Conversion;
Chris Lattnerb28317a2009-03-28 19:18:32 +00001536 return DeclPtrTy::make(Conversion);
Douglas Gregor70316a02008-12-26 15:00:45 +00001537 }
1538 }
1539 assert(Conversion->isInvalidDecl() && "Conversion should not get here.");
1540 } else
1541 ClassDecl->addConversionFunction(Context, Conversion);
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001542
Chris Lattnerb28317a2009-03-28 19:18:32 +00001543 return DeclPtrTy::make(Conversion);
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001544}
1545
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001546//===----------------------------------------------------------------------===//
1547// Namespace Handling
1548//===----------------------------------------------------------------------===//
1549
1550/// ActOnStartNamespaceDef - This is called at the start of a namespace
1551/// definition.
Chris Lattnerb28317a2009-03-28 19:18:32 +00001552Sema::DeclPtrTy Sema::ActOnStartNamespaceDef(Scope *NamespcScope,
1553 SourceLocation IdentLoc,
1554 IdentifierInfo *II,
1555 SourceLocation LBrace) {
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001556 NamespaceDecl *Namespc =
1557 NamespaceDecl::Create(Context, CurContext, IdentLoc, II);
1558 Namespc->setLBracLoc(LBrace);
1559
1560 Scope *DeclRegionScope = NamespcScope->getParent();
1561
1562 if (II) {
1563 // C++ [namespace.def]p2:
1564 // The identifier in an original-namespace-definition shall not have been
1565 // previously defined in the declarative region in which the
1566 // original-namespace-definition appears. The identifier in an
1567 // original-namespace-definition is the name of the namespace. Subsequently
1568 // in that declarative region, it is treated as an original-namespace-name.
1569
Douglas Gregor47b9a1c2009-02-04 17:27:36 +00001570 NamedDecl *PrevDecl = LookupName(DeclRegionScope, II, LookupOrdinaryName,
1571 true);
Douglas Gregor44b43212008-12-11 16:49:14 +00001572
1573 if (NamespaceDecl *OrigNS = dyn_cast_or_null<NamespaceDecl>(PrevDecl)) {
1574 // This is an extended namespace definition.
1575 // Attach this namespace decl to the chain of extended namespace
1576 // definitions.
1577 OrigNS->setNextNamespace(Namespc);
1578 Namespc->setOriginalNamespace(OrigNS->getOriginalNamespace());
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001579
Douglas Gregor44b43212008-12-11 16:49:14 +00001580 // Remove the previous declaration from the scope.
Chris Lattnerb28317a2009-03-28 19:18:32 +00001581 if (DeclRegionScope->isDeclScope(DeclPtrTy::make(OrigNS))) {
Douglas Gregore267ff32008-12-11 20:41:00 +00001582 IdResolver.RemoveDecl(OrigNS);
Chris Lattnerb28317a2009-03-28 19:18:32 +00001583 DeclRegionScope->RemoveDecl(DeclPtrTy::make(OrigNS));
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001584 }
Douglas Gregor44b43212008-12-11 16:49:14 +00001585 } else if (PrevDecl) {
1586 // This is an invalid name redefinition.
1587 Diag(Namespc->getLocation(), diag::err_redefinition_different_kind)
1588 << Namespc->getDeclName();
1589 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
1590 Namespc->setInvalidDecl();
1591 // Continue on to push Namespc as current DeclContext and return it.
1592 }
1593
1594 PushOnScopeChains(Namespc, DeclRegionScope);
1595 } else {
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001596 // FIXME: Handle anonymous namespaces
1597 }
1598
1599 // Although we could have an invalid decl (i.e. the namespace name is a
1600 // redefinition), push it as current DeclContext and try to continue parsing.
Douglas Gregor44b43212008-12-11 16:49:14 +00001601 // FIXME: We should be able to push Namespc here, so that the
1602 // each DeclContext for the namespace has the declarations
1603 // that showed up in that particular namespace definition.
1604 PushDeclContext(NamespcScope, Namespc);
Chris Lattnerb28317a2009-03-28 19:18:32 +00001605 return DeclPtrTy::make(Namespc);
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001606}
1607
1608/// ActOnFinishNamespaceDef - This callback is called after a namespace is
1609/// exited. Decl is the DeclTy returned by ActOnStartNamespaceDef.
Chris Lattnerb28317a2009-03-28 19:18:32 +00001610void Sema::ActOnFinishNamespaceDef(DeclPtrTy D, SourceLocation RBrace) {
1611 Decl *Dcl = D.getAs<Decl>();
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001612 NamespaceDecl *Namespc = dyn_cast_or_null<NamespaceDecl>(Dcl);
1613 assert(Namespc && "Invalid parameter, expected NamespaceDecl");
1614 Namespc->setRBracLoc(RBrace);
1615 PopDeclContext();
1616}
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001617
Chris Lattnerb28317a2009-03-28 19:18:32 +00001618Sema::DeclPtrTy Sema::ActOnUsingDirective(Scope *S,
1619 SourceLocation UsingLoc,
1620 SourceLocation NamespcLoc,
1621 const CXXScopeSpec &SS,
1622 SourceLocation IdentLoc,
1623 IdentifierInfo *NamespcName,
1624 AttributeList *AttrList) {
Douglas Gregorf780abc2008-12-30 03:27:21 +00001625 assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
1626 assert(NamespcName && "Invalid NamespcName.");
1627 assert(IdentLoc.isValid() && "Invalid NamespceName location.");
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001628 assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
Douglas Gregorf780abc2008-12-30 03:27:21 +00001629
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001630 UsingDirectiveDecl *UDir = 0;
Douglas Gregorf780abc2008-12-30 03:27:21 +00001631
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001632 // Lookup namespace name.
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001633 LookupResult R = LookupParsedName(S, &SS, NamespcName,
1634 LookupNamespaceName, false);
1635 if (R.isAmbiguous()) {
1636 DiagnoseAmbiguousLookup(R, NamespcName, IdentLoc);
Chris Lattnerb28317a2009-03-28 19:18:32 +00001637 return DeclPtrTy();
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001638 }
Douglas Gregor47b9a1c2009-02-04 17:27:36 +00001639 if (NamedDecl *NS = R) {
Douglas Gregorf780abc2008-12-30 03:27:21 +00001640 assert(isa<NamespaceDecl>(NS) && "expected namespace decl");
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001641 // C++ [namespace.udir]p1:
1642 // A using-directive specifies that the names in the nominated
1643 // namespace can be used in the scope in which the
1644 // using-directive appears after the using-directive. During
1645 // unqualified name lookup (3.4.1), the names appear as if they
1646 // were declared in the nearest enclosing namespace which
1647 // contains both the using-directive and the nominated
1648 // namespace. [Note: in this context, “contains” means “contains
1649 // directly or indirectly”. ]
1650
1651 // Find enclosing context containing both using-directive and
1652 // nominated namespace.
1653 DeclContext *CommonAncestor = cast<DeclContext>(NS);
1654 while (CommonAncestor && !CommonAncestor->Encloses(CurContext))
1655 CommonAncestor = CommonAncestor->getParent();
1656
1657 UDir = UsingDirectiveDecl::Create(Context, CurContext, UsingLoc,
1658 NamespcLoc, IdentLoc,
1659 cast<NamespaceDecl>(NS),
1660 CommonAncestor);
1661 PushUsingDirective(S, UDir);
Douglas Gregorf780abc2008-12-30 03:27:21 +00001662 } else {
Chris Lattneread013e2009-01-06 07:24:29 +00001663 Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
Douglas Gregorf780abc2008-12-30 03:27:21 +00001664 }
1665
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001666 // FIXME: We ignore attributes for now.
Douglas Gregorf780abc2008-12-30 03:27:21 +00001667 delete AttrList;
Chris Lattnerb28317a2009-03-28 19:18:32 +00001668 return DeclPtrTy::make(UDir);
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001669}
1670
1671void Sema::PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir) {
1672 // If scope has associated entity, then using directive is at namespace
1673 // or translation unit scope. We add UsingDirectiveDecls, into
1674 // it's lookup structure.
1675 if (DeclContext *Ctx = static_cast<DeclContext*>(S->getEntity()))
Douglas Gregor6ab35242009-04-09 21:40:53 +00001676 Ctx->addDecl(Context, UDir);
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001677 else
1678 // Otherwise it is block-sope. using-directives will affect lookup
1679 // only to the end of scope.
Chris Lattnerb28317a2009-03-28 19:18:32 +00001680 S->PushUsingDirective(DeclPtrTy::make(UDir));
Douglas Gregorf780abc2008-12-30 03:27:21 +00001681}
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001682
Anders Carlsson81c85c42009-03-28 23:53:49 +00001683/// getNamespaceDecl - Returns the namespace a decl represents. If the decl
1684/// is a namespace alias, returns the namespace it points to.
1685static inline NamespaceDecl *getNamespaceDecl(NamedDecl *D) {
1686 if (NamespaceAliasDecl *AD = dyn_cast_or_null<NamespaceAliasDecl>(D))
1687 return AD->getNamespace();
1688 return dyn_cast_or_null<NamespaceDecl>(D);
1689}
1690
Chris Lattnerb28317a2009-03-28 19:18:32 +00001691Sema::DeclPtrTy Sema::ActOnNamespaceAliasDef(Scope *S,
Anders Carlsson03bd5a12009-03-28 22:53:22 +00001692 SourceLocation NamespaceLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001693 SourceLocation AliasLoc,
1694 IdentifierInfo *Alias,
1695 const CXXScopeSpec &SS,
Anders Carlsson03bd5a12009-03-28 22:53:22 +00001696 SourceLocation IdentLoc,
1697 IdentifierInfo *Ident) {
Anders Carlsson8d7ba402009-03-28 06:23:46 +00001698
Anders Carlsson81c85c42009-03-28 23:53:49 +00001699 // Lookup the namespace name.
1700 LookupResult R = LookupParsedName(S, &SS, Ident, LookupNamespaceName, false);
1701
Anders Carlsson8d7ba402009-03-28 06:23:46 +00001702 // Check if we have a previous declaration with the same name.
Anders Carlssondd729fc2009-03-28 23:49:35 +00001703 if (NamedDecl *PrevDecl = LookupName(S, Alias, LookupOrdinaryName, true)) {
Anders Carlsson81c85c42009-03-28 23:53:49 +00001704 if (NamespaceAliasDecl *AD = dyn_cast<NamespaceAliasDecl>(PrevDecl)) {
1705 // We already have an alias with the same name that points to the same
1706 // namespace, so don't create a new one.
1707 if (!R.isAmbiguous() && AD->getNamespace() == getNamespaceDecl(R))
1708 return DeclPtrTy();
1709 }
1710
Anders Carlsson8d7ba402009-03-28 06:23:46 +00001711 unsigned DiagID = isa<NamespaceDecl>(PrevDecl) ? diag::err_redefinition :
1712 diag::err_redefinition_different_kind;
1713 Diag(AliasLoc, DiagID) << Alias;
1714 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
Chris Lattnerb28317a2009-03-28 19:18:32 +00001715 return DeclPtrTy();
Anders Carlsson8d7ba402009-03-28 06:23:46 +00001716 }
1717
Anders Carlsson5721c682009-03-28 06:42:02 +00001718 if (R.isAmbiguous()) {
Anders Carlsson03bd5a12009-03-28 22:53:22 +00001719 DiagnoseAmbiguousLookup(R, Ident, IdentLoc);
Chris Lattnerb28317a2009-03-28 19:18:32 +00001720 return DeclPtrTy();
Anders Carlsson5721c682009-03-28 06:42:02 +00001721 }
1722
1723 if (!R) {
1724 Diag(NamespaceLoc, diag::err_expected_namespace_name) << SS.getRange();
Chris Lattnerb28317a2009-03-28 19:18:32 +00001725 return DeclPtrTy();
Anders Carlsson5721c682009-03-28 06:42:02 +00001726 }
1727
Anders Carlsson68771c72009-03-28 22:58:02 +00001728 NamespaceAliasDecl *AliasDecl =
1729 NamespaceAliasDecl::Create(Context, CurContext, NamespaceLoc, AliasLoc, Alias,
1730 IdentLoc, R);
1731
Douglas Gregor6ab35242009-04-09 21:40:53 +00001732 CurContext->addDecl(Context, AliasDecl);
Anders Carlsson68771c72009-03-28 22:58:02 +00001733 return DeclPtrTy::make(AliasDecl);
Anders Carlssondbb00942009-03-28 05:27:17 +00001734}
1735
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001736/// AddCXXDirectInitializerToDecl - This action is called immediately after
1737/// ActOnDeclarator, when a C++ direct initializer is present.
1738/// e.g: "int x(1);"
Chris Lattnerb28317a2009-03-28 19:18:32 +00001739void Sema::AddCXXDirectInitializerToDecl(DeclPtrTy Dcl,
1740 SourceLocation LParenLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +00001741 MultiExprArg Exprs,
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001742 SourceLocation *CommaLocs,
1743 SourceLocation RParenLoc) {
Sebastian Redlf53597f2009-03-15 17:47:39 +00001744 unsigned NumExprs = Exprs.size();
1745 assert(NumExprs != 0 && Exprs.get() && "missing expressions");
Chris Lattnerb28317a2009-03-28 19:18:32 +00001746 Decl *RealDecl = Dcl.getAs<Decl>();
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001747
1748 // If there is no declaration, there was an error parsing it. Just ignore
1749 // the initializer.
Chris Lattnerb28317a2009-03-28 19:18:32 +00001750 if (RealDecl == 0)
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001751 return;
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001752
1753 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
1754 if (!VDecl) {
1755 Diag(RealDecl->getLocation(), diag::err_illegal_initializer);
1756 RealDecl->setInvalidDecl();
1757 return;
1758 }
1759
Douglas Gregor615c5d42009-03-24 16:43:20 +00001760 // FIXME: Need to handle dependent types and expressions here.
1761
Argyrios Kyrtzidisce8e2922008-10-06 23:08:37 +00001762 // We will treat direct-initialization as a copy-initialization:
1763 // int x(1); -as-> int x = 1;
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001764 // ClassType x(a,b,c); -as-> ClassType x = ClassType(a,b,c);
1765 //
1766 // Clients that want to distinguish between the two forms, can check for
1767 // direct initializer using VarDecl::hasCXXDirectInitializer().
1768 // A major benefit is that clients that don't particularly care about which
1769 // exactly form was it (like the CodeGen) can handle both cases without
1770 // special case code.
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +00001771
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001772 // C++ 8.5p11:
1773 // The form of initialization (using parentheses or '=') is generally
1774 // insignificant, but does matter when the entity being initialized has a
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +00001775 // class type.
Douglas Gregor18fe5682008-11-03 20:45:27 +00001776 QualType DeclInitType = VDecl->getType();
1777 if (const ArrayType *Array = Context.getAsArrayType(DeclInitType))
1778 DeclInitType = Array->getElementType();
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +00001779
Douglas Gregor615c5d42009-03-24 16:43:20 +00001780 // FIXME: This isn't the right place to complete the type.
1781 if (RequireCompleteType(VDecl->getLocation(), VDecl->getType(),
1782 diag::err_typecheck_decl_incomplete_type)) {
1783 VDecl->setInvalidDecl();
1784 return;
1785 }
1786
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +00001787 if (VDecl->getType()->isRecordType()) {
Douglas Gregor18fe5682008-11-03 20:45:27 +00001788 CXXConstructorDecl *Constructor
Sebastian Redlf53597f2009-03-15 17:47:39 +00001789 = PerformInitializationByConstructor(DeclInitType,
1790 (Expr **)Exprs.get(), NumExprs,
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001791 VDecl->getLocation(),
1792 SourceRange(VDecl->getLocation(),
1793 RParenLoc),
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001794 VDecl->getDeclName(),
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001795 IK_Direct);
Sebastian Redlf53597f2009-03-15 17:47:39 +00001796 if (!Constructor)
Douglas Gregor18fe5682008-11-03 20:45:27 +00001797 RealDecl->setInvalidDecl();
Sebastian Redlf53597f2009-03-15 17:47:39 +00001798 else
1799 Exprs.release();
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001800
1801 // Let clients know that initialization was done with a direct
1802 // initializer.
1803 VDecl->setCXXDirectInitializer(true);
1804
1805 // FIXME: Add ExprTys and Constructor to the RealDecl as part of
1806 // the initializer.
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +00001807 return;
1808 }
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001809
Argyrios Kyrtzidisce8e2922008-10-06 23:08:37 +00001810 if (NumExprs > 1) {
Chris Lattnerdcd5ef12008-11-19 05:27:50 +00001811 Diag(CommaLocs[0], diag::err_builtin_direct_init_more_than_one_arg)
1812 << SourceRange(VDecl->getLocation(), RParenLoc);
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001813 RealDecl->setInvalidDecl();
1814 return;
1815 }
1816
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001817 // Let clients know that initialization was done with a direct initializer.
1818 VDecl->setCXXDirectInitializer(true);
Argyrios Kyrtzidisce8e2922008-10-06 23:08:37 +00001819
1820 assert(NumExprs == 1 && "Expected 1 expression");
1821 // Set the init expression, handles conversions.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001822 AddInitializerToDecl(Dcl, ExprArg(*this, Exprs.release()[0]),
1823 /*DirectInit=*/true);
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001824}
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001825
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001826/// PerformInitializationByConstructor - Perform initialization by
1827/// constructor (C++ [dcl.init]p14), which may occur as part of
1828/// direct-initialization or copy-initialization. We are initializing
1829/// an object of type @p ClassType with the given arguments @p
1830/// Args. @p Loc is the location in the source code where the
1831/// initializer occurs (e.g., a declaration, member initializer,
1832/// functional cast, etc.) while @p Range covers the whole
1833/// initialization. @p InitEntity is the entity being initialized,
1834/// which may by the name of a declaration or a type. @p Kind is the
1835/// kind of initialization we're performing, which affects whether
1836/// explicit constructors will be considered. When successful, returns
Douglas Gregor18fe5682008-11-03 20:45:27 +00001837/// the constructor that will be used to perform the initialization;
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001838/// when the initialization fails, emits a diagnostic and returns
1839/// null.
Douglas Gregor18fe5682008-11-03 20:45:27 +00001840CXXConstructorDecl *
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001841Sema::PerformInitializationByConstructor(QualType ClassType,
1842 Expr **Args, unsigned NumArgs,
1843 SourceLocation Loc, SourceRange Range,
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001844 DeclarationName InitEntity,
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001845 InitializationKind Kind) {
Douglas Gregor18fe5682008-11-03 20:45:27 +00001846 const RecordType *ClassRec = ClassType->getAsRecordType();
1847 assert(ClassRec && "Can only initialize a class type here");
1848
1849 // C++ [dcl.init]p14:
1850 //
1851 // If the initialization is direct-initialization, or if it is
1852 // copy-initialization where the cv-unqualified version of the
1853 // source type is the same class as, or a derived class of, the
1854 // class of the destination, constructors are considered. The
1855 // applicable constructors are enumerated (13.3.1.3), and the
1856 // best one is chosen through overload resolution (13.3). The
1857 // constructor so selected is called to initialize the object,
1858 // with the initializer expression(s) as its argument(s). If no
1859 // constructor applies, or the overload resolution is ambiguous,
1860 // the initialization is ill-formed.
Douglas Gregor18fe5682008-11-03 20:45:27 +00001861 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(ClassRec->getDecl());
1862 OverloadCandidateSet CandidateSet;
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001863
1864 // Add constructors to the overload set.
Douglas Gregor9e7d9de2008-12-15 21:24:18 +00001865 DeclarationName ConstructorName
1866 = Context.DeclarationNames.getCXXConstructorName(
1867 Context.getCanonicalType(ClassType.getUnqualifiedType()));
Douglas Gregor3fc749d2008-12-23 00:26:44 +00001868 DeclContext::lookup_const_iterator Con, ConEnd;
Douglas Gregor6ab35242009-04-09 21:40:53 +00001869 for (llvm::tie(Con, ConEnd) = ClassDecl->lookup(Context, ConstructorName);
Douglas Gregor3fc749d2008-12-23 00:26:44 +00001870 Con != ConEnd; ++Con) {
1871 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(*Con);
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001872 if ((Kind == IK_Direct) ||
1873 (Kind == IK_Copy && Constructor->isConvertingConstructor()) ||
1874 (Kind == IK_Default && Constructor->isDefaultConstructor()))
1875 AddOverloadCandidate(Constructor, Args, NumArgs, CandidateSet);
1876 }
1877
Douglas Gregor9e7d9de2008-12-15 21:24:18 +00001878 // FIXME: When we decide not to synthesize the implicitly-declared
1879 // constructors, we'll need to make them appear here.
1880
Douglas Gregor18fe5682008-11-03 20:45:27 +00001881 OverloadCandidateSet::iterator Best;
Douglas Gregor18fe5682008-11-03 20:45:27 +00001882 switch (BestViableFunction(CandidateSet, Best)) {
1883 case OR_Success:
1884 // We found a constructor. Return it.
1885 return cast<CXXConstructorDecl>(Best->Function);
1886
1887 case OR_No_Viable_Function:
Douglas Gregor87fd7032009-02-02 17:43:21 +00001888 if (InitEntity)
1889 Diag(Loc, diag::err_ovl_no_viable_function_in_init)
Chris Lattner4330d652009-02-17 07:29:20 +00001890 << InitEntity << Range;
Douglas Gregor87fd7032009-02-02 17:43:21 +00001891 else
1892 Diag(Loc, diag::err_ovl_no_viable_function_in_init)
Chris Lattner4330d652009-02-17 07:29:20 +00001893 << ClassType << Range;
Sebastian Redle4c452c2008-11-22 13:44:36 +00001894 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/false);
Douglas Gregor18fe5682008-11-03 20:45:27 +00001895 return 0;
1896
1897 case OR_Ambiguous:
Douglas Gregor87fd7032009-02-02 17:43:21 +00001898 if (InitEntity)
1899 Diag(Loc, diag::err_ovl_ambiguous_init) << InitEntity << Range;
1900 else
1901 Diag(Loc, diag::err_ovl_ambiguous_init) << ClassType << Range;
Douglas Gregor18fe5682008-11-03 20:45:27 +00001902 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
1903 return 0;
Douglas Gregor48f3bb92009-02-18 21:56:37 +00001904
1905 case OR_Deleted:
1906 if (InitEntity)
1907 Diag(Loc, diag::err_ovl_deleted_init)
1908 << Best->Function->isDeleted()
1909 << InitEntity << Range;
1910 else
1911 Diag(Loc, diag::err_ovl_deleted_init)
1912 << Best->Function->isDeleted()
1913 << InitEntity << Range;
1914 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
1915 return 0;
Douglas Gregor18fe5682008-11-03 20:45:27 +00001916 }
1917
1918 return 0;
1919}
1920
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001921/// CompareReferenceRelationship - Compare the two types T1 and T2 to
1922/// determine whether they are reference-related,
1923/// reference-compatible, reference-compatible with added
1924/// qualification, or incompatible, for use in C++ initialization by
1925/// reference (C++ [dcl.ref.init]p4). Neither type can be a reference
1926/// type, and the first type (T1) is the pointee type of the reference
1927/// type being initialized.
1928Sema::ReferenceCompareResult
Douglas Gregor15da57e2008-10-29 02:00:59 +00001929Sema::CompareReferenceRelationship(QualType T1, QualType T2,
1930 bool& DerivedToBase) {
Sebastian Redl7c80bd62009-03-16 23:22:08 +00001931 assert(!T1->isReferenceType() &&
1932 "T1 must be the pointee type of the reference type");
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001933 assert(!T2->isReferenceType() && "T2 cannot be a reference type");
1934
1935 T1 = Context.getCanonicalType(T1);
1936 T2 = Context.getCanonicalType(T2);
1937 QualType UnqualT1 = T1.getUnqualifiedType();
1938 QualType UnqualT2 = T2.getUnqualifiedType();
1939
1940 // C++ [dcl.init.ref]p4:
1941 // Given types “cv1 T1” and “cv2 T2,” “cv1 T1” is
1942 // reference-related to “cv2 T2” if T1 is the same type as T2, or
1943 // T1 is a base class of T2.
Douglas Gregor15da57e2008-10-29 02:00:59 +00001944 if (UnqualT1 == UnqualT2)
1945 DerivedToBase = false;
1946 else if (IsDerivedFrom(UnqualT2, UnqualT1))
1947 DerivedToBase = true;
1948 else
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001949 return Ref_Incompatible;
1950
1951 // At this point, we know that T1 and T2 are reference-related (at
1952 // least).
1953
1954 // C++ [dcl.init.ref]p4:
1955 // "cv1 T1” is reference-compatible with “cv2 T2” if T1 is
1956 // reference-related to T2 and cv1 is the same cv-qualification
1957 // as, or greater cv-qualification than, cv2. For purposes of
1958 // overload resolution, cases for which cv1 is greater
1959 // cv-qualification than cv2 are identified as
1960 // reference-compatible with added qualification (see 13.3.3.2).
1961 if (T1.getCVRQualifiers() == T2.getCVRQualifiers())
1962 return Ref_Compatible;
1963 else if (T1.isMoreQualifiedThan(T2))
1964 return Ref_Compatible_With_Added_Qualification;
1965 else
1966 return Ref_Related;
1967}
1968
1969/// CheckReferenceInit - Check the initialization of a reference
1970/// variable with the given initializer (C++ [dcl.init.ref]). Init is
1971/// the initializer (either a simple initializer or an initializer
Douglas Gregor3205a782008-10-29 23:31:03 +00001972/// list), and DeclType is the type of the declaration. When ICS is
1973/// non-null, this routine will compute the implicit conversion
1974/// sequence according to C++ [over.ics.ref] and will not produce any
1975/// diagnostics; when ICS is null, it will emit diagnostics when any
1976/// errors are found. Either way, a return value of true indicates
1977/// that there was a failure, a return value of false indicates that
1978/// the reference initialization succeeded.
Douglas Gregor225c41e2008-11-03 19:09:14 +00001979///
1980/// When @p SuppressUserConversions, user-defined conversions are
1981/// suppressed.
Douglas Gregor09f41cf2009-01-14 15:45:31 +00001982/// When @p AllowExplicit, we also permit explicit user-defined
1983/// conversion functions.
Douglas Gregor15da57e2008-10-29 02:00:59 +00001984bool
1985Sema::CheckReferenceInit(Expr *&Init, QualType &DeclType,
Douglas Gregor225c41e2008-11-03 19:09:14 +00001986 ImplicitConversionSequence *ICS,
Douglas Gregor09f41cf2009-01-14 15:45:31 +00001987 bool SuppressUserConversions,
1988 bool AllowExplicit) {
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001989 assert(DeclType->isReferenceType() && "Reference init needs a reference");
1990
1991 QualType T1 = DeclType->getAsReferenceType()->getPointeeType();
1992 QualType T2 = Init->getType();
1993
Douglas Gregor904eed32008-11-10 20:40:00 +00001994 // If the initializer is the address of an overloaded function, try
1995 // to resolve the overloaded function. If all goes well, T2 is the
1996 // type of the resulting function.
Douglas Gregor063daf62009-03-13 18:40:31 +00001997 if (Context.getCanonicalType(T2) == Context.OverloadTy) {
Douglas Gregor904eed32008-11-10 20:40:00 +00001998 FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Init, DeclType,
1999 ICS != 0);
2000 if (Fn) {
2001 // Since we're performing this reference-initialization for
2002 // real, update the initializer with the resulting function.
Douglas Gregor48f3bb92009-02-18 21:56:37 +00002003 if (!ICS) {
2004 if (DiagnoseUseOfDecl(Fn, Init->getSourceRange().getBegin()))
2005 return true;
2006
Douglas Gregor904eed32008-11-10 20:40:00 +00002007 FixOverloadedFunctionReference(Init, Fn);
Douglas Gregor48f3bb92009-02-18 21:56:37 +00002008 }
Douglas Gregor904eed32008-11-10 20:40:00 +00002009
2010 T2 = Fn->getType();
2011 }
2012 }
2013
Douglas Gregor15da57e2008-10-29 02:00:59 +00002014 // Compute some basic properties of the types and the initializer.
Sebastian Redl7c80bd62009-03-16 23:22:08 +00002015 bool isRValRef = DeclType->isRValueReferenceType();
Douglas Gregor15da57e2008-10-29 02:00:59 +00002016 bool DerivedToBase = false;
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002017 Expr::isLvalueResult InitLvalue = Init->isLvalue(Context);
Douglas Gregor15da57e2008-10-29 02:00:59 +00002018 ReferenceCompareResult RefRelationship
2019 = CompareReferenceRelationship(T1, T2, DerivedToBase);
2020
2021 // Most paths end in a failed conversion.
2022 if (ICS)
2023 ICS->ConversionKind = ImplicitConversionSequence::BadConversion;
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002024
2025 // C++ [dcl.init.ref]p5:
2026 // A reference to type “cv1 T1” is initialized by an expression
2027 // of type “cv2 T2” as follows:
2028
2029 // -- If the initializer expression
2030
Sebastian Redla9845802009-03-29 15:27:50 +00002031 // Rvalue references cannot bind to lvalues (N2812).
2032 // There is absolutely no situation where they can. In particular, note that
2033 // this is ill-formed, even if B has a user-defined conversion to A&&:
2034 // B b;
2035 // A&& r = b;
2036 if (isRValRef && InitLvalue == Expr::LV_Valid) {
2037 if (!ICS)
2038 Diag(Init->getSourceRange().getBegin(), diag::err_lvalue_to_rvalue_ref)
2039 << Init->getSourceRange();
2040 return true;
2041 }
2042
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002043 bool BindsDirectly = false;
2044 // -- is an lvalue (but is not a bit-field), and “cv1 T1” is
2045 // reference-compatible with “cv2 T2,” or
Douglas Gregor15da57e2008-10-29 02:00:59 +00002046 //
2047 // Note that the bit-field check is skipped if we are just computing
2048 // the implicit conversion sequence (C++ [over.best.ics]p2).
2049 if (InitLvalue == Expr::LV_Valid && (ICS || !Init->isBitField()) &&
2050 RefRelationship >= Ref_Compatible_With_Added_Qualification) {
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002051 BindsDirectly = true;
2052
Douglas Gregor15da57e2008-10-29 02:00:59 +00002053 if (ICS) {
2054 // C++ [over.ics.ref]p1:
2055 // When a parameter of reference type binds directly (8.5.3)
2056 // to an argument expression, the implicit conversion sequence
2057 // is the identity conversion, unless the argument expression
2058 // has a type that is a derived class of the parameter type,
2059 // in which case the implicit conversion sequence is a
2060 // derived-to-base Conversion (13.3.3.1).
2061 ICS->ConversionKind = ImplicitConversionSequence::StandardConversion;
2062 ICS->Standard.First = ICK_Identity;
2063 ICS->Standard.Second = DerivedToBase? ICK_Derived_To_Base : ICK_Identity;
2064 ICS->Standard.Third = ICK_Identity;
2065 ICS->Standard.FromTypePtr = T2.getAsOpaquePtr();
2066 ICS->Standard.ToTypePtr = T1.getAsOpaquePtr();
Douglas Gregorf70bdb92008-10-29 14:50:44 +00002067 ICS->Standard.ReferenceBinding = true;
2068 ICS->Standard.DirectBinding = true;
Sebastian Redla9845802009-03-29 15:27:50 +00002069 ICS->Standard.RRefBinding = false;
Douglas Gregor15da57e2008-10-29 02:00:59 +00002070
2071 // Nothing more to do: the inaccessibility/ambiguity check for
2072 // derived-to-base conversions is suppressed when we're
2073 // computing the implicit conversion sequence (C++
2074 // [over.best.ics]p2).
2075 return false;
2076 } else {
2077 // Perform the conversion.
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002078 // FIXME: Binding to a subobject of the lvalue is going to require
2079 // more AST annotation than this.
Douglas Gregoreb8f3062008-11-12 17:17:38 +00002080 ImpCastExprToType(Init, T1, /*isLvalue=*/true);
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002081 }
2082 }
2083
2084 // -- has a class type (i.e., T2 is a class type) and can be
2085 // implicitly converted to an lvalue of type “cv3 T3,”
2086 // where “cv1 T1” is reference-compatible with “cv3 T3”
2087 // 92) (this conversion is selected by enumerating the
2088 // applicable conversion functions (13.3.1.6) and choosing
2089 // the best one through overload resolution (13.3)),
Sebastian Redl7c80bd62009-03-16 23:22:08 +00002090 if (!isRValRef && !SuppressUserConversions && T2->isRecordType()) {
Douglas Gregorcb9b9772008-11-10 16:14:15 +00002091 // FIXME: Look for conversions in base classes!
2092 CXXRecordDecl *T2RecordDecl
2093 = dyn_cast<CXXRecordDecl>(T2->getAsRecordType()->getDecl());
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002094
Douglas Gregorcb9b9772008-11-10 16:14:15 +00002095 OverloadCandidateSet CandidateSet;
2096 OverloadedFunctionDecl *Conversions
2097 = T2RecordDecl->getConversionFunctions();
2098 for (OverloadedFunctionDecl::function_iterator Func
2099 = Conversions->function_begin();
2100 Func != Conversions->function_end(); ++Func) {
2101 CXXConversionDecl *Conv = cast<CXXConversionDecl>(*Func);
Sebastian Redldfe292d2009-03-22 21:28:55 +00002102
Douglas Gregorcb9b9772008-11-10 16:14:15 +00002103 // If the conversion function doesn't return a reference type,
2104 // it can't be considered for this conversion.
Sebastian Redl7c80bd62009-03-16 23:22:08 +00002105 if (Conv->getConversionType()->isLValueReferenceType() &&
Douglas Gregor09f41cf2009-01-14 15:45:31 +00002106 (AllowExplicit || !Conv->isExplicit()))
Douglas Gregorcb9b9772008-11-10 16:14:15 +00002107 AddConversionCandidate(Conv, Init, DeclType, CandidateSet);
2108 }
2109
2110 OverloadCandidateSet::iterator Best;
2111 switch (BestViableFunction(CandidateSet, Best)) {
2112 case OR_Success:
2113 // This is a direct binding.
2114 BindsDirectly = true;
2115
2116 if (ICS) {
2117 // C++ [over.ics.ref]p1:
2118 //
2119 // [...] If the parameter binds directly to the result of
2120 // applying a conversion function to the argument
2121 // expression, the implicit conversion sequence is a
2122 // user-defined conversion sequence (13.3.3.1.2), with the
2123 // second standard conversion sequence either an identity
2124 // conversion or, if the conversion function returns an
2125 // entity of a type that is a derived class of the parameter
2126 // type, a derived-to-base Conversion.
2127 ICS->ConversionKind = ImplicitConversionSequence::UserDefinedConversion;
2128 ICS->UserDefined.Before = Best->Conversions[0].Standard;
2129 ICS->UserDefined.After = Best->FinalConversion;
2130 ICS->UserDefined.ConversionFunction = Best->Function;
2131 assert(ICS->UserDefined.After.ReferenceBinding &&
2132 ICS->UserDefined.After.DirectBinding &&
2133 "Expected a direct reference binding!");
2134 return false;
2135 } else {
2136 // Perform the conversion.
2137 // FIXME: Binding to a subobject of the lvalue is going to require
2138 // more AST annotation than this.
Douglas Gregoreb8f3062008-11-12 17:17:38 +00002139 ImpCastExprToType(Init, T1, /*isLvalue=*/true);
Douglas Gregorcb9b9772008-11-10 16:14:15 +00002140 }
2141 break;
2142
2143 case OR_Ambiguous:
2144 assert(false && "Ambiguous reference binding conversions not implemented.");
2145 return true;
2146
2147 case OR_No_Viable_Function:
Douglas Gregor48f3bb92009-02-18 21:56:37 +00002148 case OR_Deleted:
2149 // There was no suitable conversion, or we found a deleted
2150 // conversion; continue with other checks.
Douglas Gregorcb9b9772008-11-10 16:14:15 +00002151 break;
2152 }
2153 }
2154
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002155 if (BindsDirectly) {
2156 // C++ [dcl.init.ref]p4:
2157 // [...] In all cases where the reference-related or
2158 // reference-compatible relationship of two types is used to
2159 // establish the validity of a reference binding, and T1 is a
2160 // base class of T2, a program that necessitates such a binding
2161 // is ill-formed if T1 is an inaccessible (clause 11) or
2162 // ambiguous (10.2) base class of T2.
2163 //
2164 // Note that we only check this condition when we're allowed to
2165 // complain about errors, because we should not be checking for
2166 // ambiguity (or inaccessibility) unless the reference binding
2167 // actually happens.
Douglas Gregor15da57e2008-10-29 02:00:59 +00002168 if (DerivedToBase)
2169 return CheckDerivedToBaseConversion(T2, T1,
2170 Init->getSourceRange().getBegin(),
2171 Init->getSourceRange());
2172 else
2173 return false;
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002174 }
2175
2176 // -- Otherwise, the reference shall be to a non-volatile const
Sebastian Redla9845802009-03-29 15:27:50 +00002177 // type (i.e., cv1 shall be const), or the reference shall be an
2178 // rvalue reference and the initializer expression shall be an rvalue.
Sebastian Redl7c80bd62009-03-16 23:22:08 +00002179 if (!isRValRef && T1.getCVRQualifiers() != QualType::Const) {
Douglas Gregor15da57e2008-10-29 02:00:59 +00002180 if (!ICS)
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002181 Diag(Init->getSourceRange().getBegin(),
Chris Lattnerc9c7c4e2008-11-18 22:52:51 +00002182 diag::err_not_reference_to_const_init)
Chris Lattnerd1625842008-11-24 06:25:27 +00002183 << T1 << (InitLvalue != Expr::LV_Valid? "temporary" : "value")
2184 << T2 << Init->getSourceRange();
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002185 return true;
2186 }
2187
2188 // -- If the initializer expression is an rvalue, with T2 a
2189 // class type, and “cv1 T1” is reference-compatible with
2190 // “cv2 T2,” the reference is bound in one of the
2191 // following ways (the choice is implementation-defined):
2192 //
2193 // -- The reference is bound to the object represented by
2194 // the rvalue (see 3.10) or to a sub-object within that
2195 // object.
2196 //
2197 // -- A temporary of type “cv1 T2” [sic] is created, and
2198 // a constructor is called to copy the entire rvalue
2199 // object into the temporary. The reference is bound to
2200 // the temporary or to a sub-object within the
2201 // temporary.
2202 //
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002203 // The constructor that would be used to make the copy
2204 // shall be callable whether or not the copy is actually
2205 // done.
2206 //
Sebastian Redla9845802009-03-29 15:27:50 +00002207 // Note that C++0x [dcl.init.ref]p5 takes away this implementation
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002208 // freedom, so we will always take the first option and never build
2209 // a temporary in this case. FIXME: We will, however, have to check
2210 // for the presence of a copy constructor in C++98/03 mode.
2211 if (InitLvalue != Expr::LV_Valid && T2->isRecordType() &&
Douglas Gregor15da57e2008-10-29 02:00:59 +00002212 RefRelationship >= Ref_Compatible_With_Added_Qualification) {
2213 if (ICS) {
2214 ICS->ConversionKind = ImplicitConversionSequence::StandardConversion;
2215 ICS->Standard.First = ICK_Identity;
2216 ICS->Standard.Second = DerivedToBase? ICK_Derived_To_Base : ICK_Identity;
2217 ICS->Standard.Third = ICK_Identity;
2218 ICS->Standard.FromTypePtr = T2.getAsOpaquePtr();
2219 ICS->Standard.ToTypePtr = T1.getAsOpaquePtr();
Douglas Gregorf70bdb92008-10-29 14:50:44 +00002220 ICS->Standard.ReferenceBinding = true;
Sebastian Redla9845802009-03-29 15:27:50 +00002221 ICS->Standard.DirectBinding = false;
2222 ICS->Standard.RRefBinding = isRValRef;
Douglas Gregor15da57e2008-10-29 02:00:59 +00002223 } else {
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002224 // FIXME: Binding to a subobject of the rvalue is going to require
2225 // more AST annotation than this.
Douglas Gregoreb8f3062008-11-12 17:17:38 +00002226 ImpCastExprToType(Init, T1, /*isLvalue=*/true);
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002227 }
2228 return false;
2229 }
2230
2231 // -- Otherwise, a temporary of type “cv1 T1” is created and
2232 // initialized from the initializer expression using the
2233 // rules for a non-reference copy initialization (8.5). The
2234 // reference is then bound to the temporary. If T1 is
2235 // reference-related to T2, cv1 must be the same
2236 // cv-qualification as, or greater cv-qualification than,
2237 // cv2; otherwise, the program is ill-formed.
2238 if (RefRelationship == Ref_Related) {
2239 // If cv1 == cv2 or cv1 is a greater cv-qualified than cv2, then
2240 // we would be reference-compatible or reference-compatible with
2241 // added qualification. But that wasn't the case, so the reference
2242 // initialization fails.
Douglas Gregor15da57e2008-10-29 02:00:59 +00002243 if (!ICS)
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002244 Diag(Init->getSourceRange().getBegin(),
Chris Lattnerc9c7c4e2008-11-18 22:52:51 +00002245 diag::err_reference_init_drops_quals)
Chris Lattnerd1625842008-11-24 06:25:27 +00002246 << T1 << (InitLvalue != Expr::LV_Valid? "temporary" : "value")
2247 << T2 << Init->getSourceRange();
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002248 return true;
2249 }
2250
Douglas Gregor734d9862009-01-30 23:27:23 +00002251 // If at least one of the types is a class type, the types are not
2252 // related, and we aren't allowed any user conversions, the
2253 // reference binding fails. This case is important for breaking
2254 // recursion, since TryImplicitConversion below will attempt to
2255 // create a temporary through the use of a copy constructor.
2256 if (SuppressUserConversions && RefRelationship == Ref_Incompatible &&
2257 (T1->isRecordType() || T2->isRecordType())) {
2258 if (!ICS)
2259 Diag(Init->getSourceRange().getBegin(),
2260 diag::err_typecheck_convert_incompatible)
2261 << DeclType << Init->getType() << "initializing" << Init->getSourceRange();
2262 return true;
2263 }
2264
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002265 // Actually try to convert the initializer to T1.
Douglas Gregor15da57e2008-10-29 02:00:59 +00002266 if (ICS) {
Sebastian Redla9845802009-03-29 15:27:50 +00002267 // C++ [over.ics.ref]p2:
2268 //
2269 // When a parameter of reference type is not bound directly to
2270 // an argument expression, the conversion sequence is the one
2271 // required to convert the argument expression to the
2272 // underlying type of the reference according to
2273 // 13.3.3.1. Conceptually, this conversion sequence corresponds
2274 // to copy-initializing a temporary of the underlying type with
2275 // the argument expression. Any difference in top-level
2276 // cv-qualification is subsumed by the initialization itself
2277 // and does not constitute a conversion.
Douglas Gregor225c41e2008-11-03 19:09:14 +00002278 *ICS = TryImplicitConversion(Init, T1, SuppressUserConversions);
Sebastian Redla9845802009-03-29 15:27:50 +00002279 // Of course, that's still a reference binding.
2280 if (ICS->ConversionKind == ImplicitConversionSequence::StandardConversion) {
2281 ICS->Standard.ReferenceBinding = true;
2282 ICS->Standard.RRefBinding = isRValRef;
2283 } else if(ICS->ConversionKind ==
2284 ImplicitConversionSequence::UserDefinedConversion) {
2285 ICS->UserDefined.After.ReferenceBinding = true;
2286 ICS->UserDefined.After.RRefBinding = isRValRef;
2287 }
Douglas Gregor15da57e2008-10-29 02:00:59 +00002288 return ICS->ConversionKind == ImplicitConversionSequence::BadConversion;
2289 } else {
Douglas Gregor45920e82008-12-19 17:40:08 +00002290 return PerformImplicitConversion(Init, T1, "initializing");
Douglas Gregor15da57e2008-10-29 02:00:59 +00002291 }
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002292}
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002293
2294/// CheckOverloadedOperatorDeclaration - Check whether the declaration
2295/// of this overloaded operator is well-formed. If so, returns false;
2296/// otherwise, emits appropriate diagnostics and returns true.
2297bool Sema::CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl) {
Douglas Gregor43c7bad2008-11-17 16:14:12 +00002298 assert(FnDecl && FnDecl->isOverloadedOperator() &&
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002299 "Expected an overloaded operator declaration");
2300
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002301 OverloadedOperatorKind Op = FnDecl->getOverloadedOperator();
2302
2303 // C++ [over.oper]p5:
2304 // The allocation and deallocation functions, operator new,
2305 // operator new[], operator delete and operator delete[], are
2306 // described completely in 3.7.3. The attributes and restrictions
2307 // found in the rest of this subclause do not apply to them unless
2308 // explicitly stated in 3.7.3.
2309 // FIXME: Write a separate routine for checking this. For now, just
2310 // allow it.
2311 if (Op == OO_New || Op == OO_Array_New ||
2312 Op == OO_Delete || Op == OO_Array_Delete)
2313 return false;
2314
2315 // C++ [over.oper]p6:
2316 // An operator function shall either be a non-static member
2317 // function or be a non-member function and have at least one
2318 // parameter whose type is a class, a reference to a class, an
2319 // enumeration, or a reference to an enumeration.
Douglas Gregor43c7bad2008-11-17 16:14:12 +00002320 if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) {
2321 if (MethodDecl->isStatic())
2322 return Diag(FnDecl->getLocation(),
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002323 diag::err_operator_overload_static) << FnDecl->getDeclName();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002324 } else {
2325 bool ClassOrEnumParam = false;
Douglas Gregor43c7bad2008-11-17 16:14:12 +00002326 for (FunctionDecl::param_iterator Param = FnDecl->param_begin(),
2327 ParamEnd = FnDecl->param_end();
2328 Param != ParamEnd; ++Param) {
2329 QualType ParamType = (*Param)->getType().getNonReferenceType();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002330 if (ParamType->isRecordType() || ParamType->isEnumeralType()) {
2331 ClassOrEnumParam = true;
2332 break;
2333 }
2334 }
2335
Douglas Gregor43c7bad2008-11-17 16:14:12 +00002336 if (!ClassOrEnumParam)
2337 return Diag(FnDecl->getLocation(),
Chris Lattnerf3a41af2008-11-20 06:38:18 +00002338 diag::err_operator_overload_needs_class_or_enum)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002339 << FnDecl->getDeclName();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002340 }
2341
2342 // C++ [over.oper]p8:
2343 // An operator function cannot have default arguments (8.3.6),
2344 // except where explicitly stated below.
2345 //
2346 // Only the function-call operator allows default arguments
2347 // (C++ [over.call]p1).
2348 if (Op != OO_Call) {
2349 for (FunctionDecl::param_iterator Param = FnDecl->param_begin();
2350 Param != FnDecl->param_end(); ++Param) {
Douglas Gregor61366e92008-12-24 00:01:03 +00002351 if ((*Param)->hasUnparsedDefaultArg())
2352 return Diag((*Param)->getLocation(),
2353 diag::err_operator_overload_default_arg)
2354 << FnDecl->getDeclName();
2355 else if (Expr *DefArg = (*Param)->getDefaultArg())
Douglas Gregor43c7bad2008-11-17 16:14:12 +00002356 return Diag((*Param)->getLocation(),
Chris Lattnerd3a94e22008-11-20 06:06:08 +00002357 diag::err_operator_overload_default_arg)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002358 << FnDecl->getDeclName() << DefArg->getSourceRange();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002359 }
2360 }
2361
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00002362 static const bool OperatorUses[NUM_OVERLOADED_OPERATORS][3] = {
2363 { false, false, false }
2364#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
2365 , { Unary, Binary, MemberOnly }
2366#include "clang/Basic/OperatorKinds.def"
2367 };
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002368
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00002369 bool CanBeUnaryOperator = OperatorUses[Op][0];
2370 bool CanBeBinaryOperator = OperatorUses[Op][1];
2371 bool MustBeMemberOperator = OperatorUses[Op][2];
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002372
2373 // C++ [over.oper]p8:
2374 // [...] Operator functions cannot have more or fewer parameters
2375 // than the number required for the corresponding operator, as
2376 // described in the rest of this subclause.
Douglas Gregor43c7bad2008-11-17 16:14:12 +00002377 unsigned NumParams = FnDecl->getNumParams()
2378 + (isa<CXXMethodDecl>(FnDecl)? 1 : 0);
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002379 if (Op != OO_Call &&
2380 ((NumParams == 1 && !CanBeUnaryOperator) ||
2381 (NumParams == 2 && !CanBeBinaryOperator) ||
2382 (NumParams < 1) || (NumParams > 2))) {
2383 // We have the wrong number of parameters.
Chris Lattner416e46f2008-11-21 07:57:12 +00002384 unsigned ErrorKind;
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00002385 if (CanBeUnaryOperator && CanBeBinaryOperator) {
Chris Lattner416e46f2008-11-21 07:57:12 +00002386 ErrorKind = 2; // 2 -> unary or binary.
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00002387 } else if (CanBeUnaryOperator) {
Chris Lattner416e46f2008-11-21 07:57:12 +00002388 ErrorKind = 0; // 0 -> unary
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00002389 } else {
Chris Lattneraf7ae4e2008-11-21 07:50:02 +00002390 assert(CanBeBinaryOperator &&
2391 "All non-call overloaded operators are unary or binary!");
Chris Lattner416e46f2008-11-21 07:57:12 +00002392 ErrorKind = 1; // 1 -> binary
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00002393 }
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002394
Chris Lattner416e46f2008-11-21 07:57:12 +00002395 return Diag(FnDecl->getLocation(), diag::err_operator_overload_must_be)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002396 << FnDecl->getDeclName() << NumParams << ErrorKind;
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002397 }
Sebastian Redl64b45f72009-01-05 20:52:13 +00002398
Douglas Gregor43c7bad2008-11-17 16:14:12 +00002399 // Overloaded operators other than operator() cannot be variadic.
2400 if (Op != OO_Call &&
Douglas Gregor72564e72009-02-26 23:50:07 +00002401 FnDecl->getType()->getAsFunctionProtoType()->isVariadic()) {
Chris Lattnerf3a41af2008-11-20 06:38:18 +00002402 return Diag(FnDecl->getLocation(), diag::err_operator_overload_variadic)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002403 << FnDecl->getDeclName();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002404 }
2405
2406 // Some operators must be non-static member functions.
Douglas Gregor43c7bad2008-11-17 16:14:12 +00002407 if (MustBeMemberOperator && !isa<CXXMethodDecl>(FnDecl)) {
2408 return Diag(FnDecl->getLocation(),
Chris Lattnerf3a41af2008-11-20 06:38:18 +00002409 diag::err_operator_overload_must_be_member)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002410 << FnDecl->getDeclName();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002411 }
2412
2413 // C++ [over.inc]p1:
2414 // The user-defined function called operator++ implements the
2415 // prefix and postfix ++ operator. If this function is a member
2416 // function with no parameters, or a non-member function with one
2417 // parameter of class or enumeration type, it defines the prefix
2418 // increment operator ++ for objects of that type. If the function
2419 // is a member function with one parameter (which shall be of type
2420 // int) or a non-member function with two parameters (the second
2421 // of which shall be of type int), it defines the postfix
2422 // increment operator ++ for objects of that type.
2423 if ((Op == OO_PlusPlus || Op == OO_MinusMinus) && NumParams == 2) {
2424 ParmVarDecl *LastParam = FnDecl->getParamDecl(FnDecl->getNumParams() - 1);
2425 bool ParamIsInt = false;
2426 if (const BuiltinType *BT = LastParam->getType()->getAsBuiltinType())
2427 ParamIsInt = BT->getKind() == BuiltinType::Int;
2428
Chris Lattneraf7ae4e2008-11-21 07:50:02 +00002429 if (!ParamIsInt)
2430 return Diag(LastParam->getLocation(),
2431 diag::err_operator_overload_post_incdec_must_be_int)
Chris Lattnerd1625842008-11-24 06:25:27 +00002432 << LastParam->getType() << (Op == OO_MinusMinus);
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002433 }
2434
Sebastian Redl64b45f72009-01-05 20:52:13 +00002435 // Notify the class if it got an assignment operator.
2436 if (Op == OO_Equal) {
2437 // Would have returned earlier otherwise.
2438 assert(isa<CXXMethodDecl>(FnDecl) &&
2439 "Overloaded = not member, but not filtered.");
2440 CXXMethodDecl *Method = cast<CXXMethodDecl>(FnDecl);
2441 Method->getParent()->addedAssignmentOperator(Context, Method);
2442 }
2443
Douglas Gregor43c7bad2008-11-17 16:14:12 +00002444 return false;
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002445}
Chris Lattner5a003a42008-12-17 07:09:26 +00002446
Douglas Gregor074149e2009-01-05 19:45:36 +00002447/// ActOnStartLinkageSpecification - Parsed the beginning of a C++
2448/// linkage specification, including the language and (if present)
2449/// the '{'. ExternLoc is the location of the 'extern', LangLoc is
2450/// the location of the language string literal, which is provided
2451/// by Lang/StrSize. LBraceLoc, if valid, provides the location of
2452/// the '{' brace. Otherwise, this linkage specification does not
2453/// have any braces.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002454Sema::DeclPtrTy Sema::ActOnStartLinkageSpecification(Scope *S,
2455 SourceLocation ExternLoc,
2456 SourceLocation LangLoc,
2457 const char *Lang,
2458 unsigned StrSize,
2459 SourceLocation LBraceLoc) {
Chris Lattnercc98eac2008-12-17 07:13:27 +00002460 LinkageSpecDecl::LanguageIDs Language;
2461 if (strncmp(Lang, "\"C\"", StrSize) == 0)
2462 Language = LinkageSpecDecl::lang_c;
2463 else if (strncmp(Lang, "\"C++\"", StrSize) == 0)
2464 Language = LinkageSpecDecl::lang_cxx;
2465 else {
Douglas Gregor074149e2009-01-05 19:45:36 +00002466 Diag(LangLoc, diag::err_bad_language);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002467 return DeclPtrTy();
Chris Lattnercc98eac2008-12-17 07:13:27 +00002468 }
2469
2470 // FIXME: Add all the various semantics of linkage specifications
2471
Douglas Gregor074149e2009-01-05 19:45:36 +00002472 LinkageSpecDecl *D = LinkageSpecDecl::Create(Context, CurContext,
2473 LangLoc, Language,
2474 LBraceLoc.isValid());
Douglas Gregor6ab35242009-04-09 21:40:53 +00002475 CurContext->addDecl(Context, D);
Douglas Gregor074149e2009-01-05 19:45:36 +00002476 PushDeclContext(S, D);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002477 return DeclPtrTy::make(D);
Chris Lattnercc98eac2008-12-17 07:13:27 +00002478}
2479
Douglas Gregor074149e2009-01-05 19:45:36 +00002480/// ActOnFinishLinkageSpecification - Completely the definition of
2481/// the C++ linkage specification LinkageSpec. If RBraceLoc is
2482/// valid, it's the position of the closing '}' brace in a linkage
2483/// specification that uses braces.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002484Sema::DeclPtrTy Sema::ActOnFinishLinkageSpecification(Scope *S,
2485 DeclPtrTy LinkageSpec,
2486 SourceLocation RBraceLoc) {
Douglas Gregor074149e2009-01-05 19:45:36 +00002487 if (LinkageSpec)
2488 PopDeclContext();
2489 return LinkageSpec;
Chris Lattner5a003a42008-12-17 07:09:26 +00002490}
2491
Sebastian Redl4b07b292008-12-22 19:15:10 +00002492/// ActOnExceptionDeclarator - Parsed the exception-declarator in a C++ catch
2493/// handler.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002494Sema::DeclPtrTy Sema::ActOnExceptionDeclarator(Scope *S, Declarator &D) {
Sebastian Redl4b07b292008-12-22 19:15:10 +00002495 QualType ExDeclType = GetTypeForDeclarator(D, S);
2496 SourceLocation Begin = D.getDeclSpec().getSourceRange().getBegin();
2497
2498 bool Invalid = false;
2499
2500 // Arrays and functions decay.
2501 if (ExDeclType->isArrayType())
2502 ExDeclType = Context.getArrayDecayedType(ExDeclType);
2503 else if (ExDeclType->isFunctionType())
2504 ExDeclType = Context.getPointerType(ExDeclType);
2505
2506 // C++ 15.3p1: The exception-declaration shall not denote an incomplete type.
2507 // The exception-declaration shall not denote a pointer or reference to an
2508 // incomplete type, other than [cv] void*.
Sebastian Redlf2e21e52009-03-22 23:49:27 +00002509 // N2844 forbids rvalue references.
2510 if(ExDeclType->isRValueReferenceType()) {
2511 Diag(Begin, diag::err_catch_rvalue_ref) << D.getSourceRange();
2512 Invalid = true;
2513 }
Sebastian Redl4b07b292008-12-22 19:15:10 +00002514 QualType BaseType = ExDeclType;
2515 int Mode = 0; // 0 for direct type, 1 for pointer, 2 for reference
Douglas Gregor4ec339f2009-01-19 19:26:10 +00002516 unsigned DK = diag::err_catch_incomplete;
Sebastian Redl4b07b292008-12-22 19:15:10 +00002517 if (const PointerType *Ptr = BaseType->getAsPointerType()) {
2518 BaseType = Ptr->getPointeeType();
2519 Mode = 1;
Douglas Gregor4ec339f2009-01-19 19:26:10 +00002520 DK = diag::err_catch_incomplete_ptr;
Sebastian Redl4b07b292008-12-22 19:15:10 +00002521 } else if(const ReferenceType *Ref = BaseType->getAsReferenceType()) {
Sebastian Redlf2e21e52009-03-22 23:49:27 +00002522 // For the purpose of error recovery, we treat rvalue refs like lvalue refs.
Sebastian Redl4b07b292008-12-22 19:15:10 +00002523 BaseType = Ref->getPointeeType();
2524 Mode = 2;
Douglas Gregor4ec339f2009-01-19 19:26:10 +00002525 DK = diag::err_catch_incomplete_ref;
Sebastian Redl4b07b292008-12-22 19:15:10 +00002526 }
Sebastian Redlf2e21e52009-03-22 23:49:27 +00002527 if (!Invalid && (Mode == 0 || !BaseType->isVoidType()) &&
Douglas Gregor86447ec2009-03-09 16:13:40 +00002528 RequireCompleteType(Begin, BaseType, DK))
Sebastian Redl4b07b292008-12-22 19:15:10 +00002529 Invalid = true;
Sebastian Redl4b07b292008-12-22 19:15:10 +00002530
Sebastian Redl8351da02008-12-22 21:35:02 +00002531 // FIXME: Need to test for ability to copy-construct and destroy the
2532 // exception variable.
2533 // FIXME: Need to check for abstract classes.
2534
Sebastian Redl4b07b292008-12-22 19:15:10 +00002535 IdentifierInfo *II = D.getIdentifier();
Douglas Gregor47b9a1c2009-02-04 17:27:36 +00002536 if (NamedDecl *PrevDecl = LookupName(S, II, LookupOrdinaryName)) {
Sebastian Redl4b07b292008-12-22 19:15:10 +00002537 // The scope should be freshly made just for us. There is just no way
2538 // it contains any previous declaration.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002539 assert(!S->isDeclScope(DeclPtrTy::make(PrevDecl)));
Sebastian Redl4b07b292008-12-22 19:15:10 +00002540 if (PrevDecl->isTemplateParameter()) {
2541 // Maybe we will complain about the shadowed template parameter.
2542 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
Sebastian Redl4b07b292008-12-22 19:15:10 +00002543 }
2544 }
2545
2546 VarDecl *ExDecl = VarDecl::Create(Context, CurContext, D.getIdentifierLoc(),
Douglas Gregor4afa39d2009-01-20 01:17:11 +00002547 II, ExDeclType, VarDecl::None, Begin);
Sebastian Redl4b07b292008-12-22 19:15:10 +00002548 if (D.getInvalidType() || Invalid)
2549 ExDecl->setInvalidDecl();
2550
2551 if (D.getCXXScopeSpec().isSet()) {
2552 Diag(D.getIdentifierLoc(), diag::err_qualified_catch_declarator)
2553 << D.getCXXScopeSpec().getRange();
2554 ExDecl->setInvalidDecl();
2555 }
2556
2557 // Add the exception declaration into this scope.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002558 S->AddDecl(DeclPtrTy::make(ExDecl));
Sebastian Redl4b07b292008-12-22 19:15:10 +00002559 if (II)
2560 IdResolver.AddDecl(ExDecl);
2561
2562 ProcessDeclAttributes(ExDecl, D);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002563 return DeclPtrTy::make(ExDecl);
Sebastian Redl4b07b292008-12-22 19:15:10 +00002564}
Anders Carlssonfb311762009-03-14 00:25:26 +00002565
Chris Lattnerb28317a2009-03-28 19:18:32 +00002566Sema::DeclPtrTy Sema::ActOnStaticAssertDeclaration(SourceLocation AssertLoc,
2567 ExprArg assertexpr,
2568 ExprArg assertmessageexpr) {
Anders Carlssonfb311762009-03-14 00:25:26 +00002569 Expr *AssertExpr = (Expr *)assertexpr.get();
2570 StringLiteral *AssertMessage =
2571 cast<StringLiteral>((Expr *)assertmessageexpr.get());
2572
Anders Carlssonc3082412009-03-14 00:33:21 +00002573 if (!AssertExpr->isTypeDependent() && !AssertExpr->isValueDependent()) {
2574 llvm::APSInt Value(32);
2575 if (!AssertExpr->isIntegerConstantExpr(Value, Context)) {
2576 Diag(AssertLoc, diag::err_static_assert_expression_is_not_constant) <<
2577 AssertExpr->getSourceRange();
Chris Lattnerb28317a2009-03-28 19:18:32 +00002578 return DeclPtrTy();
Anders Carlssonc3082412009-03-14 00:33:21 +00002579 }
Anders Carlssonfb311762009-03-14 00:25:26 +00002580
Anders Carlssonc3082412009-03-14 00:33:21 +00002581 if (Value == 0) {
2582 std::string str(AssertMessage->getStrData(),
2583 AssertMessage->getByteLength());
Anders Carlsson94b15fb2009-03-15 18:44:04 +00002584 Diag(AssertLoc, diag::err_static_assert_failed)
2585 << str << AssertExpr->getSourceRange();
Anders Carlssonc3082412009-03-14 00:33:21 +00002586 }
2587 }
2588
Anders Carlsson77d81422009-03-15 17:35:16 +00002589 assertexpr.release();
2590 assertmessageexpr.release();
Anders Carlssonfb311762009-03-14 00:25:26 +00002591 Decl *Decl = StaticAssertDecl::Create(Context, CurContext, AssertLoc,
2592 AssertExpr, AssertMessage);
Anders Carlssonfb311762009-03-14 00:25:26 +00002593
Douglas Gregor6ab35242009-04-09 21:40:53 +00002594 CurContext->addDecl(Context, Decl);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002595 return DeclPtrTy::make(Decl);
Anders Carlssonfb311762009-03-14 00:25:26 +00002596}
Sebastian Redl50de12f2009-03-24 22:27:57 +00002597
Chris Lattnerb28317a2009-03-28 19:18:32 +00002598void Sema::SetDeclDeleted(DeclPtrTy dcl, SourceLocation DelLoc) {
2599 Decl *Dcl = dcl.getAs<Decl>();
Sebastian Redl50de12f2009-03-24 22:27:57 +00002600 FunctionDecl *Fn = dyn_cast<FunctionDecl>(Dcl);
2601 if (!Fn) {
2602 Diag(DelLoc, diag::err_deleted_non_function);
2603 return;
2604 }
2605 if (const FunctionDecl *Prev = Fn->getPreviousDeclaration()) {
2606 Diag(DelLoc, diag::err_deleted_decl_not_first);
2607 Diag(Prev->getLocation(), diag::note_previous_declaration);
2608 // If the declaration wasn't the first, we delete the function anyway for
2609 // recovery.
2610 }
2611 Fn->setDeleted();
2612}