blob: dea3688bdbfb720b4ef18c20ff684b67c61ace8b [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"
Douglas Gregor02189362008-10-22 21:13:31 +000018#include "clang/AST/TypeOrdering.h"
Chris Lattner8123a952008-04-10 02:22:51 +000019#include "clang/AST/StmtVisitor.h"
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +000020#include "clang/Lex/Preprocessor.h"
Daniel Dunbar12bc6922008-08-11 03:27:53 +000021#include "clang/Basic/Diagnostic.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
108Sema::ActOnParamDefaultArgument(DeclTy *param, SourceLocation EqualLoc,
109 ExprTy *defarg) {
110 ParmVarDecl *Param = (ParmVarDecl *)param;
111 llvm::OwningPtr<Expr> DefaultArg((Expr *)defarg);
112 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,
131 Param->getDeclName());
Chris Lattner3d1cee32008-04-08 05:04:30 +0000132 if (DefaultArgPtr != DefaultArg.get()) {
133 DefaultArg.take();
134 DefaultArg.reset(DefaultArgPtr);
135 }
Douglas Gregoreb704f22008-11-04 13:57:51 +0000136 if (DefaultInitFailed) {
Chris Lattner3d1cee32008-04-08 05:04:30 +0000137 return;
138 }
139
Chris Lattner8123a952008-04-10 02:22:51 +0000140 // Check that the default argument is well-formed
Chris Lattner9e979552008-04-12 23:52:44 +0000141 CheckDefaultArgumentVisitor DefaultArgChecker(DefaultArg.get(), this);
Douglas Gregor72b505b2008-12-16 21:30:33 +0000142 if (DefaultArgChecker.Visit(DefaultArg.get())) {
143 Param->setInvalidDecl();
Chris Lattner8123a952008-04-10 02:22:51 +0000144 return;
Douglas Gregor72b505b2008-12-16 21:30:33 +0000145 }
Chris Lattner8123a952008-04-10 02:22:51 +0000146
Chris Lattner3d1cee32008-04-08 05:04:30 +0000147 // Okay: add the default argument to the parameter
148 Param->setDefaultArg(DefaultArg.take());
149}
150
Douglas Gregor61366e92008-12-24 00:01:03 +0000151/// ActOnParamUnparsedDefaultArgument - We've seen a default
152/// argument for a function parameter, but we can't parse it yet
153/// because we're inside a class definition. Note that this default
154/// argument will be parsed later.
155void Sema::ActOnParamUnparsedDefaultArgument(DeclTy *param,
156 SourceLocation EqualLoc) {
157 ParmVarDecl *Param = (ParmVarDecl*)param;
158 if (Param)
159 Param->setUnparsedDefaultArg();
160}
161
Douglas Gregor72b505b2008-12-16 21:30:33 +0000162/// ActOnParamDefaultArgumentError - Parsing or semantic analysis of
163/// the default argument for the parameter param failed.
164void Sema::ActOnParamDefaultArgumentError(DeclTy *param) {
165 ((ParmVarDecl*)param)->setInvalidDecl();
166}
167
Douglas Gregor6d6eb572008-05-07 04:49:29 +0000168/// CheckExtraCXXDefaultArguments - Check for any extra default
169/// arguments in the declarator, which is not a function declaration
170/// or definition and therefore is not permitted to have default
171/// arguments. This routine should be invoked for every declarator
172/// that is not a function declaration or definition.
173void Sema::CheckExtraCXXDefaultArguments(Declarator &D) {
174 // C++ [dcl.fct.default]p3
175 // A default argument expression shall be specified only in the
176 // parameter-declaration-clause of a function declaration or in a
177 // template-parameter (14.1). It shall not be specified for a
178 // parameter pack. If it is specified in a
179 // parameter-declaration-clause, it shall not occur within a
180 // declarator or abstract-declarator of a parameter-declaration.
181 for (unsigned i = 0; i < D.getNumTypeObjects(); ++i) {
182 DeclaratorChunk &chunk = D.getTypeObject(i);
183 if (chunk.Kind == DeclaratorChunk::Function) {
184 for (unsigned argIdx = 0; argIdx < chunk.Fun.NumArgs; ++argIdx) {
185 ParmVarDecl *Param = (ParmVarDecl *)chunk.Fun.ArgInfo[argIdx].Param;
Douglas Gregor61366e92008-12-24 00:01:03 +0000186 if (Param->hasUnparsedDefaultArg()) {
187 CachedTokens *Toks = chunk.Fun.ArgInfo[argIdx].DefaultArgTokens;
Douglas Gregor72b505b2008-12-16 21:30:33 +0000188 Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
189 << SourceRange((*Toks)[1].getLocation(), Toks->back().getLocation());
190 delete Toks;
191 chunk.Fun.ArgInfo[argIdx].DefaultArgTokens = 0;
Douglas Gregor61366e92008-12-24 00:01:03 +0000192 } else if (Param->getDefaultArg()) {
193 Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
194 << Param->getDefaultArg()->getSourceRange();
195 Param->setDefaultArg(0);
Douglas Gregor6d6eb572008-05-07 04:49:29 +0000196 }
197 }
198 }
199 }
200}
201
Chris Lattner3d1cee32008-04-08 05:04:30 +0000202// MergeCXXFunctionDecl - Merge two declarations of the same C++
203// function, once we already know that they have the same
204// type. Subroutine of MergeFunctionDecl.
205FunctionDecl *
206Sema::MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old) {
207 // C++ [dcl.fct.default]p4:
208 //
209 // For non-template functions, default arguments can be added in
210 // later declarations of a function in the same
211 // scope. Declarations in different scopes have completely
212 // distinct sets of default arguments. That is, declarations in
213 // inner scopes do not acquire default arguments from
214 // declarations in outer scopes, and vice versa. In a given
215 // function declaration, all parameters subsequent to a
216 // parameter with a default argument shall have default
217 // arguments supplied in this or previous declarations. A
218 // default argument shall not be redefined by a later
219 // declaration (not even to the same value).
220 for (unsigned p = 0, NumParams = Old->getNumParams(); p < NumParams; ++p) {
221 ParmVarDecl *OldParam = Old->getParamDecl(p);
222 ParmVarDecl *NewParam = New->getParamDecl(p);
223
224 if(OldParam->getDefaultArg() && NewParam->getDefaultArg()) {
225 Diag(NewParam->getLocation(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000226 diag::err_param_default_argument_redefinition)
227 << NewParam->getDefaultArg()->getSourceRange();
Chris Lattner5f4a6822008-11-23 23:12:31 +0000228 Diag(OldParam->getLocation(), diag::note_previous_definition);
Chris Lattner3d1cee32008-04-08 05:04:30 +0000229 } else if (OldParam->getDefaultArg()) {
230 // Merge the old default argument into the new parameter
231 NewParam->setDefaultArg(OldParam->getDefaultArg());
232 }
233 }
234
235 return New;
236}
237
238/// CheckCXXDefaultArguments - Verify that the default arguments for a
239/// function declaration are well-formed according to C++
240/// [dcl.fct.default].
241void Sema::CheckCXXDefaultArguments(FunctionDecl *FD) {
242 unsigned NumParams = FD->getNumParams();
243 unsigned p;
244
245 // Find first parameter with a default argument
246 for (p = 0; p < NumParams; ++p) {
247 ParmVarDecl *Param = FD->getParamDecl(p);
248 if (Param->getDefaultArg())
249 break;
250 }
251
252 // C++ [dcl.fct.default]p4:
253 // In a given function declaration, all parameters
254 // subsequent to a parameter with a default argument shall
255 // have default arguments supplied in this or previous
256 // declarations. A default argument shall not be redefined
257 // by a later declaration (not even to the same value).
258 unsigned LastMissingDefaultArg = 0;
259 for(; p < NumParams; ++p) {
260 ParmVarDecl *Param = FD->getParamDecl(p);
261 if (!Param->getDefaultArg()) {
Douglas Gregor72b505b2008-12-16 21:30:33 +0000262 if (Param->isInvalidDecl())
263 /* We already complained about this parameter. */;
264 else if (Param->getIdentifier())
Chris Lattner3d1cee32008-04-08 05:04:30 +0000265 Diag(Param->getLocation(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000266 diag::err_param_default_argument_missing_name)
Chris Lattner43b628c2008-11-19 07:32:16 +0000267 << Param->getIdentifier();
Chris Lattner3d1cee32008-04-08 05:04:30 +0000268 else
269 Diag(Param->getLocation(),
270 diag::err_param_default_argument_missing);
271
272 LastMissingDefaultArg = p;
273 }
274 }
275
276 if (LastMissingDefaultArg > 0) {
277 // Some default arguments were missing. Clear out all of the
278 // default arguments up to (and including) the last missing
279 // default argument, so that we leave the function parameters
280 // in a semantically valid state.
281 for (p = 0; p <= LastMissingDefaultArg; ++p) {
282 ParmVarDecl *Param = FD->getParamDecl(p);
283 if (Param->getDefaultArg()) {
Douglas Gregor61366e92008-12-24 00:01:03 +0000284 if (!Param->hasUnparsedDefaultArg())
285 Param->getDefaultArg()->Destroy(Context);
Chris Lattner3d1cee32008-04-08 05:04:30 +0000286 Param->setDefaultArg(0);
287 }
288 }
289 }
290}
Douglas Gregore37ac4f2008-04-13 21:30:24 +0000291
Douglas Gregorb48fe382008-10-31 09:07:45 +0000292/// isCurrentClassName - Determine whether the identifier II is the
293/// name of the class type currently being defined. In the case of
294/// nested classes, this will only return true if II is the name of
295/// the innermost class.
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +0000296bool Sema::isCurrentClassName(const IdentifierInfo &II, Scope *,
297 const CXXScopeSpec *SS) {
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000298 CXXRecordDecl *CurDecl;
299 if (SS) {
300 DeclContext *DC = static_cast<DeclContext*>(SS->getScopeRep());
301 CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC);
302 } else
303 CurDecl = dyn_cast_or_null<CXXRecordDecl>(CurContext);
304
305 if (CurDecl)
Douglas Gregorb48fe382008-10-31 09:07:45 +0000306 return &II == CurDecl->getIdentifier();
307 else
308 return false;
309}
310
Douglas Gregore37ac4f2008-04-13 21:30:24 +0000311/// ActOnBaseSpecifier - Parsed a base specifier. A base specifier is
312/// one entry in the base class list of a class specifier, for
313/// example:
314/// class foo : public bar, virtual private baz {
315/// 'public bar' and 'virtual private baz' are each base-specifiers.
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000316Sema::BaseResult
317Sema::ActOnBaseSpecifier(DeclTy *classdecl, SourceRange SpecifierRange,
318 bool Virtual, AccessSpecifier Access,
319 TypeTy *basetype, SourceLocation BaseLoc) {
Sebastian Redl64b45f72009-01-05 20:52:13 +0000320 CXXRecordDecl *Decl = (CXXRecordDecl*)classdecl;
Douglas Gregore37ac4f2008-04-13 21:30:24 +0000321 QualType BaseType = Context.getTypeDeclType((TypeDecl*)basetype);
322
323 // Base specifiers must be record types.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000324 if (!BaseType->isRecordType())
325 return Diag(BaseLoc, diag::err_base_must_be_class) << SpecifierRange;
Douglas Gregore37ac4f2008-04-13 21:30:24 +0000326
327 // C++ [class.union]p1:
328 // A union shall not be used as a base class.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000329 if (BaseType->isUnionType())
330 return Diag(BaseLoc, diag::err_union_as_base_class) << SpecifierRange;
Douglas Gregore37ac4f2008-04-13 21:30:24 +0000331
332 // C++ [class.union]p1:
333 // A union shall not have base classes.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000334 if (Decl->isUnion())
335 return Diag(Decl->getLocation(), diag::err_base_clause_on_union)
336 << SpecifierRange;
Douglas Gregore37ac4f2008-04-13 21:30:24 +0000337
338 // C++ [class.derived]p2:
339 // The class-name in a base-specifier shall not be an incompletely
340 // defined class.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000341 if (BaseType->isIncompleteType())
342 return Diag(BaseLoc, diag::err_incomplete_base_class) << SpecifierRange;
Douglas Gregore37ac4f2008-04-13 21:30:24 +0000343
Sebastian Redld93f0dd2008-11-06 15:59:35 +0000344 // If the base class is polymorphic, the new one is, too.
345 RecordDecl *BaseDecl = BaseType->getAsRecordType()->getDecl();
346 assert(BaseDecl && "Record type has no declaration");
347 BaseDecl = BaseDecl->getDefinition(Context);
348 assert(BaseDecl && "Base type is not incomplete, but has no definition");
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000349 if (cast<CXXRecordDecl>(BaseDecl)->isPolymorphic())
Sebastian Redl64b45f72009-01-05 20:52:13 +0000350 Decl->setPolymorphic(true);
351
352 // C++ [dcl.init.aggr]p1:
353 // An aggregate is [...] a class with [...] no base classes [...].
354 Decl->setAggregate(false);
355 Decl->setPOD(false);
Sebastian Redld93f0dd2008-11-06 15:59:35 +0000356
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000357 // Create the base specifier.
Douglas Gregor57c856b2008-10-23 18:13:27 +0000358 return new CXXBaseSpecifier(SpecifierRange, Virtual,
359 BaseType->isClassType(), Access, BaseType);
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000360}
Douglas Gregore37ac4f2008-04-13 21:30:24 +0000361
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000362/// ActOnBaseSpecifiers - Attach the given base specifiers to the
363/// class, after checking whether there are any duplicate base
364/// classes.
365void Sema::ActOnBaseSpecifiers(DeclTy *ClassDecl, BaseTy **Bases,
366 unsigned NumBases) {
367 if (NumBases == 0)
368 return;
369
370 // Used to keep track of which base types we have already seen, so
371 // that we can properly diagnose redundant direct base types. Note
Douglas Gregor57c856b2008-10-23 18:13:27 +0000372 // that the key is always the unqualified canonical type of the base
373 // class.
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000374 std::map<QualType, CXXBaseSpecifier*, QualTypeOrdering> KnownBaseTypes;
375
376 // Copy non-redundant base specifiers into permanent storage.
Douglas Gregor57c856b2008-10-23 18:13:27 +0000377 CXXBaseSpecifier **BaseSpecs = (CXXBaseSpecifier **)Bases;
378 unsigned NumGoodBases = 0;
379 for (unsigned idx = 0; idx < NumBases; ++idx) {
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000380 QualType NewBaseType
Douglas Gregor57c856b2008-10-23 18:13:27 +0000381 = Context.getCanonicalType(BaseSpecs[idx]->getType());
382 NewBaseType = NewBaseType.getUnqualifiedType();
383
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000384 if (KnownBaseTypes[NewBaseType]) {
385 // C++ [class.mi]p3:
386 // A class shall not be specified as a direct base class of a
387 // derived class more than once.
Douglas Gregor57c856b2008-10-23 18:13:27 +0000388 Diag(BaseSpecs[idx]->getSourceRange().getBegin(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000389 diag::err_duplicate_base_class)
Chris Lattnerd1625842008-11-24 06:25:27 +0000390 << KnownBaseTypes[NewBaseType]->getType()
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000391 << BaseSpecs[idx]->getSourceRange();
Douglas Gregor57c856b2008-10-23 18:13:27 +0000392
393 // Delete the duplicate base class specifier; we're going to
394 // overwrite its pointer later.
395 delete BaseSpecs[idx];
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000396 } else {
397 // Okay, add this new base class.
Douglas Gregor57c856b2008-10-23 18:13:27 +0000398 KnownBaseTypes[NewBaseType] = BaseSpecs[idx];
399 BaseSpecs[NumGoodBases++] = BaseSpecs[idx];
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000400 }
401 }
402
403 // Attach the remaining base class specifiers to the derived class.
404 CXXRecordDecl *Decl = (CXXRecordDecl*)ClassDecl;
Douglas Gregor57c856b2008-10-23 18:13:27 +0000405 Decl->setBases(BaseSpecs, NumGoodBases);
406
407 // Delete the remaining (good) base class specifiers, since their
408 // data has been copied into the CXXRecordDecl.
409 for (unsigned idx = 0; idx < NumGoodBases; ++idx)
410 delete BaseSpecs[idx];
Douglas Gregore37ac4f2008-04-13 21:30:24 +0000411}
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +0000412
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000413//===----------------------------------------------------------------------===//
414// C++ class member Handling
415//===----------------------------------------------------------------------===//
416
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000417/// ActOnCXXMemberDeclarator - This is invoked when a C++ class member
418/// declarator is parsed. 'AS' is the access specifier, 'BW' specifies the
419/// bitfield width if there is one and 'InitExpr' specifies the initializer if
420/// any. 'LastInGroup' is non-null for cases where one declspec has multiple
421/// declarators on it.
422///
Douglas Gregor72b505b2008-12-16 21:30:33 +0000423/// FIXME: The note below is out-of-date.
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000424/// NOTE: Because of CXXFieldDecl's inability to be chained like ScopedDecls, if
425/// an instance field is declared, a new CXXFieldDecl is created but the method
426/// does *not* return it; it returns LastInGroup instead. The other C++ members
427/// (which are all ScopedDecls) are returned after appending them to
428/// LastInGroup.
429Sema::DeclTy *
430Sema::ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS, Declarator &D,
431 ExprTy *BW, ExprTy *InitExpr,
432 DeclTy *LastInGroup) {
433 const DeclSpec &DS = D.getDeclSpec();
Douglas Gregor10bd3682008-11-17 22:58:34 +0000434 DeclarationName Name = GetNameForDeclarator(D);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000435 Expr *BitWidth = static_cast<Expr*>(BW);
436 Expr *Init = static_cast<Expr*>(InitExpr);
437 SourceLocation Loc = D.getIdentifierLoc();
438
Sebastian Redl669d5d72008-11-14 23:42:31 +0000439 bool isFunc = D.isFunctionDeclarator();
440
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000441 // C++ 9.2p6: A member shall not be declared to have automatic storage
442 // duration (auto, register) or with the extern storage-class-specifier.
Sebastian Redl669d5d72008-11-14 23:42:31 +0000443 // C++ 7.1.1p8: The mutable specifier can be applied only to names of class
444 // data members and cannot be applied to names declared const or static,
445 // and cannot be applied to reference members.
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000446 switch (DS.getStorageClassSpec()) {
447 case DeclSpec::SCS_unspecified:
448 case DeclSpec::SCS_typedef:
449 case DeclSpec::SCS_static:
450 // FALL THROUGH.
451 break;
Sebastian Redl669d5d72008-11-14 23:42:31 +0000452 case DeclSpec::SCS_mutable:
453 if (isFunc) {
454 if (DS.getStorageClassSpecLoc().isValid())
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000455 Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_function);
Sebastian Redl669d5d72008-11-14 23:42:31 +0000456 else
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000457 Diag(DS.getThreadSpecLoc(), diag::err_mutable_function);
458
Sebastian Redla11f42f2008-11-17 23:24:37 +0000459 // FIXME: It would be nicer if the keyword was ignored only for this
460 // declarator. Otherwise we could get follow-up errors.
Sebastian Redl669d5d72008-11-14 23:42:31 +0000461 D.getMutableDeclSpec().ClearStorageClassSpecs();
462 } else {
463 QualType T = GetTypeForDeclarator(D, S);
464 diag::kind err = static_cast<diag::kind>(0);
465 if (T->isReferenceType())
466 err = diag::err_mutable_reference;
467 else if (T.isConstQualified())
468 err = diag::err_mutable_const;
469 if (err != 0) {
470 if (DS.getStorageClassSpecLoc().isValid())
471 Diag(DS.getStorageClassSpecLoc(), err);
472 else
473 Diag(DS.getThreadSpecLoc(), err);
Sebastian Redla11f42f2008-11-17 23:24:37 +0000474 // FIXME: It would be nicer if the keyword was ignored only for this
475 // declarator. Otherwise we could get follow-up errors.
Sebastian Redl669d5d72008-11-14 23:42:31 +0000476 D.getMutableDeclSpec().ClearStorageClassSpecs();
477 }
478 }
479 break;
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000480 default:
481 if (DS.getStorageClassSpecLoc().isValid())
482 Diag(DS.getStorageClassSpecLoc(),
483 diag::err_storageclass_invalid_for_member);
484 else
485 Diag(DS.getThreadSpecLoc(), diag::err_storageclass_invalid_for_member);
486 D.getMutableDeclSpec().ClearStorageClassSpecs();
487 }
488
Argyrios Kyrtzidisd6caa9e2008-10-15 20:23:22 +0000489 if (!isFunc &&
490 D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_typedef &&
491 D.getNumTypeObjects() == 0) {
Argyrios Kyrtzidisde933f02008-10-08 22:20:31 +0000492 // Check also for this case:
493 //
494 // typedef int f();
495 // f a;
496 //
497 Decl *TD = static_cast<Decl *>(DS.getTypeRep());
498 isFunc = Context.getTypeDeclType(cast<TypeDecl>(TD))->isFunctionType();
499 }
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000500
Sebastian Redl669d5d72008-11-14 23:42:31 +0000501 bool isInstField = ((DS.getStorageClassSpec() == DeclSpec::SCS_unspecified ||
502 DS.getStorageClassSpec() == DeclSpec::SCS_mutable) &&
Argyrios Kyrtzidisde933f02008-10-08 22:20:31 +0000503 !isFunc);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000504
505 Decl *Member;
506 bool InvalidDecl = false;
507
508 if (isInstField)
Douglas Gregor44b43212008-12-11 16:49:14 +0000509 Member = static_cast<Decl*>(ActOnField(S, cast<CXXRecordDecl>(CurContext),
510 Loc, D, BitWidth));
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000511 else
Daniel Dunbar914701e2008-08-05 16:28:08 +0000512 Member = static_cast<Decl*>(ActOnDeclarator(S, D, LastInGroup));
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000513
514 if (!Member) return LastInGroup;
515
Douglas Gregor10bd3682008-11-17 22:58:34 +0000516 assert((Name || isInstField) && "No identifier for non-field ?");
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000517
518 // set/getAccess is not part of Decl's interface to avoid bloating it with C++
519 // specific methods. Use a wrapper class that can be used with all C++ class
520 // member decls.
521 CXXClassMemberWrapper(Member).setAccess(AS);
522
Douglas Gregor64bffa92008-11-05 16:20:31 +0000523 // C++ [dcl.init.aggr]p1:
524 // An aggregate is an array or a class (clause 9) with [...] no
525 // private or protected non-static data members (clause 11).
Sebastian Redl64b45f72009-01-05 20:52:13 +0000526 // A POD must be an aggregate.
527 if (isInstField && (AS == AS_private || AS == AS_protected)) {
528 CXXRecordDecl *Record = cast<CXXRecordDecl>(CurContext);
529 Record->setAggregate(false);
530 Record->setPOD(false);
531 }
Douglas Gregor64bffa92008-11-05 16:20:31 +0000532
Sebastian Redld93f0dd2008-11-06 15:59:35 +0000533 if (DS.isVirtualSpecified()) {
534 if (!isFunc || DS.getStorageClassSpec() == DeclSpec::SCS_static) {
535 Diag(DS.getVirtualSpecLoc(), diag::err_virtual_non_function);
536 InvalidDecl = true;
537 } else {
538 CXXRecordDecl *CurClass = cast<CXXRecordDecl>(CurContext);
539 CurClass->setAggregate(false);
Sebastian Redl64b45f72009-01-05 20:52:13 +0000540 CurClass->setPOD(false);
Sebastian Redld93f0dd2008-11-06 15:59:35 +0000541 CurClass->setPolymorphic(true);
542 }
543 }
Douglas Gregor64bffa92008-11-05 16:20:31 +0000544
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000545 if (BitWidth) {
546 // C++ 9.6p2: Only when declaring an unnamed bit-field may the
547 // constant-expression be a value equal to zero.
548 // FIXME: Check this.
549
550 if (D.isFunctionDeclarator()) {
551 // FIXME: Emit diagnostic about only constructors taking base initializers
552 // or something similar, when constructor support is in place.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000553 Diag(Loc, diag::err_not_bitfield_type)
Anders Carlssona75023d2008-12-06 20:05:35 +0000554 << Name << BitWidth->getSourceRange();
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000555 InvalidDecl = true;
556
Argyrios Kyrtzidisde933f02008-10-08 22:20:31 +0000557 } else if (isInstField) {
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000558 // C++ 9.6p3: A bit-field shall have integral or enumeration type.
Argyrios Kyrtzidisde933f02008-10-08 22:20:31 +0000559 if (!cast<FieldDecl>(Member)->getType()->isIntegralType()) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000560 Diag(Loc, diag::err_not_integral_type_bitfield)
Anders Carlssona75023d2008-12-06 20:05:35 +0000561 << Name << BitWidth->getSourceRange();
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000562 InvalidDecl = true;
563 }
564
Argyrios Kyrtzidisde933f02008-10-08 22:20:31 +0000565 } else if (isa<FunctionDecl>(Member)) {
566 // A function typedef ("typedef int f(); f a;").
567 // C++ 9.6p3: A bit-field shall have integral or enumeration type.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000568 Diag(Loc, diag::err_not_integral_type_bitfield)
Anders Carlssona75023d2008-12-06 20:05:35 +0000569 << Name << BitWidth->getSourceRange();
Argyrios Kyrtzidisde933f02008-10-08 22:20:31 +0000570 InvalidDecl = true;
571
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000572 } else if (isa<TypedefDecl>(Member)) {
573 // "cannot declare 'A' to be a bit-field type"
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000574 Diag(Loc, diag::err_not_bitfield_type)
Anders Carlssona75023d2008-12-06 20:05:35 +0000575 << Name << BitWidth->getSourceRange();
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000576 InvalidDecl = true;
577
578 } else {
579 assert(isa<CXXClassVarDecl>(Member) &&
580 "Didn't we cover all member kinds?");
581 // C++ 9.6p3: A bit-field shall not be a static member.
582 // "static member 'A' cannot be a bit-field"
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000583 Diag(Loc, diag::err_static_not_bitfield)
Anders Carlssona75023d2008-12-06 20:05:35 +0000584 << Name << BitWidth->getSourceRange();
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000585 InvalidDecl = true;
586 }
587 }
588
589 if (Init) {
590 // C++ 9.2p4: A member-declarator can contain a constant-initializer only
591 // if it declares a static member of const integral or const enumeration
592 // type.
Chris Lattnerb77792e2008-07-26 22:17:49 +0000593 if (CXXClassVarDecl *CVD = dyn_cast<CXXClassVarDecl>(Member)) {
594 // ...static member of...
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000595 CVD->setInit(Init);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000596 // ...const integral or const enumeration type.
Chris Lattnerb77792e2008-07-26 22:17:49 +0000597 if (Context.getCanonicalType(CVD->getType()).isConstQualified() &&
598 CVD->getType()->isIntegralType()) {
599 // constant-initializer
600 if (CheckForConstantInitializer(Init, CVD->getType()))
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000601 InvalidDecl = true;
602
603 } else {
604 // not const integral.
Chris Lattnerd3a94e22008-11-20 06:06:08 +0000605 Diag(Loc, diag::err_member_initialization)
Anders Carlssona75023d2008-12-06 20:05:35 +0000606 << Name << Init->getSourceRange();
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000607 InvalidDecl = true;
608 }
609
610 } else {
611 // not static member.
Chris Lattnerd3a94e22008-11-20 06:06:08 +0000612 Diag(Loc, diag::err_member_initialization)
Anders Carlssona75023d2008-12-06 20:05:35 +0000613 << Name << Init->getSourceRange();
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000614 InvalidDecl = true;
615 }
616 }
617
618 if (InvalidDecl)
619 Member->setInvalidDecl();
620
621 if (isInstField) {
Douglas Gregor44b43212008-12-11 16:49:14 +0000622 FieldCollector->Add(cast<FieldDecl>(Member));
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000623 return LastInGroup;
624 }
625 return Member;
626}
627
Douglas Gregor7ad83902008-11-05 04:29:56 +0000628/// ActOnMemInitializer - Handle a C++ member initializer.
629Sema::MemInitResult
630Sema::ActOnMemInitializer(DeclTy *ConstructorD,
631 Scope *S,
632 IdentifierInfo *MemberOrBase,
633 SourceLocation IdLoc,
634 SourceLocation LParenLoc,
635 ExprTy **Args, unsigned NumArgs,
636 SourceLocation *CommaLocs,
637 SourceLocation RParenLoc) {
638 CXXConstructorDecl *Constructor
639 = dyn_cast<CXXConstructorDecl>((Decl*)ConstructorD);
640 if (!Constructor) {
641 // The user wrote a constructor initializer on a function that is
642 // not a C++ constructor. Ignore the error for now, because we may
643 // have more member initializers coming; we'll diagnose it just
644 // once in ActOnMemInitializers.
645 return true;
646 }
647
648 CXXRecordDecl *ClassDecl = Constructor->getParent();
649
650 // C++ [class.base.init]p2:
651 // Names in a mem-initializer-id are looked up in the scope of the
652 // constructor’s class and, if not found in that scope, are looked
653 // up in the scope containing the constructor’s
654 // definition. [Note: if the constructor’s class contains a member
655 // with the same name as a direct or virtual base class of the
656 // class, a mem-initializer-id naming the member or base class and
657 // composed of a single identifier refers to the class member. A
658 // mem-initializer-id for the hidden base class may be specified
659 // using a qualified name. ]
660 // Look for a member, first.
Douglas Gregor44b43212008-12-11 16:49:14 +0000661 FieldDecl *Member = 0;
Steve Naroff0701bbb2009-01-08 17:28:14 +0000662 DeclContext::lookup_result Result = ClassDecl->lookup(MemberOrBase);
Douglas Gregor44b43212008-12-11 16:49:14 +0000663 if (Result.first != Result.second)
664 Member = dyn_cast<FieldDecl>(*Result.first);
Douglas Gregor7ad83902008-11-05 04:29:56 +0000665
666 // FIXME: Handle members of an anonymous union.
667
668 if (Member) {
669 // FIXME: Perform direct initialization of the member.
670 return new CXXBaseOrMemberInitializer(Member, (Expr **)Args, NumArgs);
671 }
672
673 // It didn't name a member, so see if it names a class.
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +0000674 TypeTy *BaseTy = isTypeName(*MemberOrBase, S, 0/*SS*/);
Douglas Gregor7ad83902008-11-05 04:29:56 +0000675 if (!BaseTy)
Chris Lattner3c73c412008-11-19 08:23:25 +0000676 return Diag(IdLoc, diag::err_mem_init_not_member_or_class)
677 << MemberOrBase << SourceRange(IdLoc, RParenLoc);
Douglas Gregor7ad83902008-11-05 04:29:56 +0000678
679 QualType BaseType = Context.getTypeDeclType((TypeDecl *)BaseTy);
680 if (!BaseType->isRecordType())
Chris Lattner3c73c412008-11-19 08:23:25 +0000681 return Diag(IdLoc, diag::err_base_init_does_not_name_class)
Chris Lattner08631c52008-11-23 21:45:46 +0000682 << BaseType << SourceRange(IdLoc, RParenLoc);
Douglas Gregor7ad83902008-11-05 04:29:56 +0000683
684 // C++ [class.base.init]p2:
685 // [...] Unless the mem-initializer-id names a nonstatic data
686 // member of the constructor’s class or a direct or virtual base
687 // of that class, the mem-initializer is ill-formed. A
688 // mem-initializer-list can initialize a base class using any
689 // name that denotes that base class type.
690
691 // First, check for a direct base class.
692 const CXXBaseSpecifier *DirectBaseSpec = 0;
693 for (CXXRecordDecl::base_class_const_iterator Base = ClassDecl->bases_begin();
694 Base != ClassDecl->bases_end(); ++Base) {
695 if (Context.getCanonicalType(BaseType).getUnqualifiedType() ==
696 Context.getCanonicalType(Base->getType()).getUnqualifiedType()) {
697 // We found a direct base of this type. That's what we're
698 // initializing.
699 DirectBaseSpec = &*Base;
700 break;
701 }
702 }
703
704 // Check for a virtual base class.
705 // FIXME: We might be able to short-circuit this if we know in
706 // advance that there are no virtual bases.
707 const CXXBaseSpecifier *VirtualBaseSpec = 0;
708 if (!DirectBaseSpec || !DirectBaseSpec->isVirtual()) {
709 // We haven't found a base yet; search the class hierarchy for a
710 // virtual base class.
711 BasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
712 /*DetectVirtual=*/false);
713 if (IsDerivedFrom(Context.getTypeDeclType(ClassDecl), BaseType, Paths)) {
714 for (BasePaths::paths_iterator Path = Paths.begin();
715 Path != Paths.end(); ++Path) {
716 if (Path->back().Base->isVirtual()) {
717 VirtualBaseSpec = Path->back().Base;
718 break;
719 }
720 }
721 }
722 }
723
724 // C++ [base.class.init]p2:
725 // If a mem-initializer-id is ambiguous because it designates both
726 // a direct non-virtual base class and an inherited virtual base
727 // class, the mem-initializer is ill-formed.
728 if (DirectBaseSpec && VirtualBaseSpec)
Chris Lattner3c73c412008-11-19 08:23:25 +0000729 return Diag(IdLoc, diag::err_base_init_direct_and_virtual)
730 << MemberOrBase << SourceRange(IdLoc, RParenLoc);
Douglas Gregor7ad83902008-11-05 04:29:56 +0000731
732 return new CXXBaseOrMemberInitializer(BaseType, (Expr **)Args, NumArgs);
733}
734
735
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000736void Sema::ActOnFinishCXXMemberSpecification(Scope* S, SourceLocation RLoc,
737 DeclTy *TagDecl,
738 SourceLocation LBrac,
739 SourceLocation RBrac) {
740 ActOnFields(S, RLoc, TagDecl,
741 (DeclTy**)FieldCollector->getCurFields(),
Daniel Dunbar1bfe1c22008-10-03 02:03:53 +0000742 FieldCollector->getCurNumFields(), LBrac, RBrac, 0);
Douglas Gregor61366e92008-12-24 00:01:03 +0000743 AddImplicitlyDeclaredMembersToClass(cast<CXXRecordDecl>((Decl*)TagDecl));
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000744}
745
Douglas Gregor396b7cd2008-11-03 17:51:48 +0000746/// AddImplicitlyDeclaredMembersToClass - Adds any implicitly-declared
747/// special functions, such as the default constructor, copy
748/// constructor, or destructor, to the given C++ class (C++
749/// [special]p1). This routine can only be executed just before the
750/// definition of the class is complete.
751void Sema::AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl) {
Douglas Gregor2e1cd422008-11-17 14:58:09 +0000752 QualType ClassType = Context.getTypeDeclType(ClassDecl);
753 ClassType = Context.getCanonicalType(ClassType);
754
Douglas Gregor396b7cd2008-11-03 17:51:48 +0000755 if (!ClassDecl->hasUserDeclaredConstructor()) {
756 // C++ [class.ctor]p5:
757 // A default constructor for a class X is a constructor of class X
758 // that can be called without an argument. If there is no
759 // user-declared constructor for class X, a default constructor is
760 // implicitly declared. An implicitly-declared default constructor
761 // is an inline public member of its class.
Douglas Gregor2e1cd422008-11-17 14:58:09 +0000762 DeclarationName Name
763 = Context.DeclarationNames.getCXXConstructorName(ClassType);
Douglas Gregor396b7cd2008-11-03 17:51:48 +0000764 CXXConstructorDecl *DefaultCon =
765 CXXConstructorDecl::Create(Context, ClassDecl,
Douglas Gregor2e1cd422008-11-17 14:58:09 +0000766 ClassDecl->getLocation(), Name,
Douglas Gregor396b7cd2008-11-03 17:51:48 +0000767 Context.getFunctionType(Context.VoidTy,
768 0, 0, false, 0),
769 /*isExplicit=*/false,
770 /*isInline=*/true,
771 /*isImplicitlyDeclared=*/true);
772 DefaultCon->setAccess(AS_public);
Douglas Gregor6b3945f2009-01-07 19:46:03 +0000773 DefaultCon->setImplicit();
Douglas Gregor9e7d9de2008-12-15 21:24:18 +0000774 ClassDecl->addDecl(Context, DefaultCon);
775
776 // Notify the class that we've added a constructor.
777 ClassDecl->addedConstructor(Context, DefaultCon);
Douglas Gregor396b7cd2008-11-03 17:51:48 +0000778 }
779
780 if (!ClassDecl->hasUserDeclaredCopyConstructor()) {
781 // C++ [class.copy]p4:
782 // If the class definition does not explicitly declare a copy
783 // constructor, one is declared implicitly.
784
785 // C++ [class.copy]p5:
786 // The implicitly-declared copy constructor for a class X will
787 // have the form
788 //
789 // X::X(const X&)
790 //
791 // if
792 bool HasConstCopyConstructor = true;
793
794 // -- each direct or virtual base class B of X has a copy
795 // constructor whose first parameter is of type const B& or
796 // const volatile B&, and
797 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin();
798 HasConstCopyConstructor && Base != ClassDecl->bases_end(); ++Base) {
799 const CXXRecordDecl *BaseClassDecl
800 = cast<CXXRecordDecl>(Base->getType()->getAsRecordType()->getDecl());
801 HasConstCopyConstructor
802 = BaseClassDecl->hasConstCopyConstructor(Context);
803 }
804
805 // -- for all the nonstatic data members of X that are of a
806 // class type M (or array thereof), each such class type
807 // has a copy constructor whose first parameter is of type
808 // const M& or const volatile M&.
809 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin();
810 HasConstCopyConstructor && Field != ClassDecl->field_end(); ++Field) {
811 QualType FieldType = (*Field)->getType();
812 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
813 FieldType = Array->getElementType();
814 if (const RecordType *FieldClassType = FieldType->getAsRecordType()) {
815 const CXXRecordDecl *FieldClassDecl
816 = cast<CXXRecordDecl>(FieldClassType->getDecl());
817 HasConstCopyConstructor
818 = FieldClassDecl->hasConstCopyConstructor(Context);
819 }
820 }
821
Sebastian Redl64b45f72009-01-05 20:52:13 +0000822 // Otherwise, the implicitly declared copy constructor will have
823 // the form
Douglas Gregor396b7cd2008-11-03 17:51:48 +0000824 //
825 // X::X(X&)
Sebastian Redl64b45f72009-01-05 20:52:13 +0000826 QualType ArgType = ClassType;
Douglas Gregor396b7cd2008-11-03 17:51:48 +0000827 if (HasConstCopyConstructor)
828 ArgType = ArgType.withConst();
829 ArgType = Context.getReferenceType(ArgType);
830
Sebastian Redl64b45f72009-01-05 20:52:13 +0000831 // An implicitly-declared copy constructor is an inline public
832 // member of its class.
Douglas Gregor2e1cd422008-11-17 14:58:09 +0000833 DeclarationName Name
834 = Context.DeclarationNames.getCXXConstructorName(ClassType);
Douglas Gregor396b7cd2008-11-03 17:51:48 +0000835 CXXConstructorDecl *CopyConstructor
836 = CXXConstructorDecl::Create(Context, ClassDecl,
Douglas Gregor2e1cd422008-11-17 14:58:09 +0000837 ClassDecl->getLocation(), Name,
Douglas Gregor396b7cd2008-11-03 17:51:48 +0000838 Context.getFunctionType(Context.VoidTy,
839 &ArgType, 1,
840 false, 0),
841 /*isExplicit=*/false,
842 /*isInline=*/true,
843 /*isImplicitlyDeclared=*/true);
844 CopyConstructor->setAccess(AS_public);
Douglas Gregor6b3945f2009-01-07 19:46:03 +0000845 CopyConstructor->setImplicit();
Douglas Gregor396b7cd2008-11-03 17:51:48 +0000846
847 // Add the parameter to the constructor.
848 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyConstructor,
849 ClassDecl->getLocation(),
850 /*IdentifierInfo=*/0,
851 ArgType, VarDecl::None, 0, 0);
852 CopyConstructor->setParams(&FromParam, 1);
853
Douglas Gregor9e7d9de2008-12-15 21:24:18 +0000854 ClassDecl->addedConstructor(Context, CopyConstructor);
Douglas Gregor3fc749d2008-12-23 00:26:44 +0000855 ClassDecl->addDecl(Context, CopyConstructor);
Douglas Gregor396b7cd2008-11-03 17:51:48 +0000856 }
857
Sebastian Redl64b45f72009-01-05 20:52:13 +0000858 if (!ClassDecl->hasUserDeclaredCopyAssignment()) {
859 // Note: The following rules are largely analoguous to the copy
860 // constructor rules. Note that virtual bases are not taken into account
861 // for determining the argument type of the operator. Note also that
862 // operators taking an object instead of a reference are allowed.
863 //
864 // C++ [class.copy]p10:
865 // If the class definition does not explicitly declare a copy
866 // assignment operator, one is declared implicitly.
867 // The implicitly-defined copy assignment operator for a class X
868 // will have the form
869 //
870 // X& X::operator=(const X&)
871 //
872 // if
873 bool HasConstCopyAssignment = true;
874
875 // -- each direct base class B of X has a copy assignment operator
876 // whose parameter is of type const B&, const volatile B& or B,
877 // and
878 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin();
879 HasConstCopyAssignment && Base != ClassDecl->bases_end(); ++Base) {
880 const CXXRecordDecl *BaseClassDecl
881 = cast<CXXRecordDecl>(Base->getType()->getAsRecordType()->getDecl());
882 HasConstCopyAssignment = BaseClassDecl->hasConstCopyAssignment(Context);
883 }
884
885 // -- for all the nonstatic data members of X that are of a class
886 // type M (or array thereof), each such class type has a copy
887 // assignment operator whose parameter is of type const M&,
888 // const volatile M& or M.
889 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin();
890 HasConstCopyAssignment && Field != ClassDecl->field_end(); ++Field) {
891 QualType FieldType = (*Field)->getType();
892 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
893 FieldType = Array->getElementType();
894 if (const RecordType *FieldClassType = FieldType->getAsRecordType()) {
895 const CXXRecordDecl *FieldClassDecl
896 = cast<CXXRecordDecl>(FieldClassType->getDecl());
897 HasConstCopyAssignment
898 = FieldClassDecl->hasConstCopyAssignment(Context);
899 }
900 }
901
902 // Otherwise, the implicitly declared copy assignment operator will
903 // have the form
904 //
905 // X& X::operator=(X&)
906 QualType ArgType = ClassType;
907 QualType RetType = Context.getReferenceType(ArgType);
908 if (HasConstCopyAssignment)
909 ArgType = ArgType.withConst();
910 ArgType = Context.getReferenceType(ArgType);
911
912 // An implicitly-declared copy assignment operator is an inline public
913 // member of its class.
914 DeclarationName Name =
915 Context.DeclarationNames.getCXXOperatorName(OO_Equal);
916 CXXMethodDecl *CopyAssignment =
917 CXXMethodDecl::Create(Context, ClassDecl, ClassDecl->getLocation(), Name,
918 Context.getFunctionType(RetType, &ArgType, 1,
919 false, 0),
920 /*isStatic=*/false, /*isInline=*/true, 0);
921 CopyAssignment->setAccess(AS_public);
Douglas Gregor6b3945f2009-01-07 19:46:03 +0000922 CopyAssignment->setImplicit();
Sebastian Redl64b45f72009-01-05 20:52:13 +0000923
924 // Add the parameter to the operator.
925 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyAssignment,
926 ClassDecl->getLocation(),
927 /*IdentifierInfo=*/0,
928 ArgType, VarDecl::None, 0, 0);
929 CopyAssignment->setParams(&FromParam, 1);
930
931 // Don't call addedAssignmentOperator. There is no way to distinguish an
932 // implicit from an explicit assignment operator.
933 ClassDecl->addDecl(Context, CopyAssignment);
934 }
935
Douglas Gregor9e7d9de2008-12-15 21:24:18 +0000936 if (!ClassDecl->hasUserDeclaredDestructor()) {
Douglas Gregor42a552f2008-11-05 20:51:48 +0000937 // C++ [class.dtor]p2:
938 // If a class has no user-declared destructor, a destructor is
939 // declared implicitly. An implicitly-declared destructor is an
940 // inline public member of its class.
Douglas Gregor2e1cd422008-11-17 14:58:09 +0000941 DeclarationName Name
942 = Context.DeclarationNames.getCXXDestructorName(ClassType);
Douglas Gregor42a552f2008-11-05 20:51:48 +0000943 CXXDestructorDecl *Destructor
944 = CXXDestructorDecl::Create(Context, ClassDecl,
Douglas Gregor2e1cd422008-11-17 14:58:09 +0000945 ClassDecl->getLocation(), Name,
Douglas Gregor42a552f2008-11-05 20:51:48 +0000946 Context.getFunctionType(Context.VoidTy,
947 0, 0, false, 0),
948 /*isInline=*/true,
949 /*isImplicitlyDeclared=*/true);
950 Destructor->setAccess(AS_public);
Douglas Gregor6b3945f2009-01-07 19:46:03 +0000951 Destructor->setImplicit();
Douglas Gregor9e7d9de2008-12-15 21:24:18 +0000952 ClassDecl->addDecl(Context, Destructor);
Douglas Gregor42a552f2008-11-05 20:51:48 +0000953 }
Douglas Gregor396b7cd2008-11-03 17:51:48 +0000954}
955
Douglas Gregor72b505b2008-12-16 21:30:33 +0000956/// ActOnStartDelayedCXXMethodDeclaration - We have completed
957/// parsing a top-level (non-nested) C++ class, and we are now
958/// parsing those parts of the given Method declaration that could
959/// not be parsed earlier (C++ [class.mem]p2), such as default
960/// arguments. This action should enter the scope of the given
961/// Method declaration as if we had just parsed the qualified method
962/// name. However, it should not bring the parameters into scope;
963/// that will be performed by ActOnDelayedCXXMethodParameter.
964void Sema::ActOnStartDelayedCXXMethodDeclaration(Scope *S, DeclTy *Method) {
965 CXXScopeSpec SS;
966 SS.setScopeRep(((FunctionDecl*)Method)->getDeclContext());
967 ActOnCXXEnterDeclaratorScope(S, SS);
968}
969
970/// ActOnDelayedCXXMethodParameter - We've already started a delayed
971/// C++ method declaration. We're (re-)introducing the given
972/// function parameter into scope for use in parsing later parts of
973/// the method declaration. For example, we could see an
974/// ActOnParamDefaultArgument event for this parameter.
975void Sema::ActOnDelayedCXXMethodParameter(Scope *S, DeclTy *ParamD) {
976 ParmVarDecl *Param = (ParmVarDecl*)ParamD;
Douglas Gregor61366e92008-12-24 00:01:03 +0000977
978 // If this parameter has an unparsed default argument, clear it out
979 // to make way for the parsed default argument.
980 if (Param->hasUnparsedDefaultArg())
981 Param->setDefaultArg(0);
982
Douglas Gregor72b505b2008-12-16 21:30:33 +0000983 S->AddDecl(Param);
984 if (Param->getDeclName())
985 IdResolver.AddDecl(Param);
986}
987
988/// ActOnFinishDelayedCXXMethodDeclaration - We have finished
989/// processing the delayed method declaration for Method. The method
990/// declaration is now considered finished. There may be a separate
991/// ActOnStartOfFunctionDef action later (not necessarily
992/// immediately!) for this method, if it was also defined inside the
993/// class body.
994void Sema::ActOnFinishDelayedCXXMethodDeclaration(Scope *S, DeclTy *MethodD) {
995 FunctionDecl *Method = (FunctionDecl*)MethodD;
996 CXXScopeSpec SS;
997 SS.setScopeRep(Method->getDeclContext());
998 ActOnCXXExitDeclaratorScope(S, SS);
999
1000 // Now that we have our default arguments, check the constructor
1001 // again. It could produce additional diagnostics or affect whether
1002 // the class has implicitly-declared destructors, among other
1003 // things.
1004 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Method)) {
1005 if (CheckConstructor(Constructor))
1006 Constructor->setInvalidDecl();
1007 }
1008
1009 // Check the default arguments, which we may have added.
1010 if (!Method->isInvalidDecl())
1011 CheckCXXDefaultArguments(Method);
1012}
1013
Douglas Gregor42a552f2008-11-05 20:51:48 +00001014/// CheckConstructorDeclarator - Called by ActOnDeclarator to check
Douglas Gregor72b505b2008-12-16 21:30:33 +00001015/// the well-formedness of the constructor declarator @p D with type @p
Douglas Gregor42a552f2008-11-05 20:51:48 +00001016/// R. If there are any errors in the declarator, this routine will
1017/// emit diagnostics and return true. Otherwise, it will return
1018/// false. Either way, the type @p R will be updated to reflect a
1019/// well-formed type for the constructor.
1020bool Sema::CheckConstructorDeclarator(Declarator &D, QualType &R,
1021 FunctionDecl::StorageClass& SC) {
1022 bool isVirtual = D.getDeclSpec().isVirtualSpecified();
1023 bool isInvalid = false;
1024
1025 // C++ [class.ctor]p3:
1026 // A constructor shall not be virtual (10.3) or static (9.4). A
1027 // constructor can be invoked for a const, volatile or const
1028 // volatile object. A constructor shall not be declared const,
1029 // volatile, or const volatile (9.3.2).
1030 if (isVirtual) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001031 Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
1032 << "virtual" << SourceRange(D.getDeclSpec().getVirtualSpecLoc())
1033 << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00001034 isInvalid = true;
1035 }
1036 if (SC == FunctionDecl::Static) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001037 Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
1038 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
1039 << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00001040 isInvalid = true;
1041 SC = FunctionDecl::None;
1042 }
1043 if (D.getDeclSpec().hasTypeSpecifier()) {
1044 // Constructors don't have return types, but the parser will
1045 // happily parse something like:
1046 //
1047 // class X {
1048 // float X(float);
1049 // };
1050 //
1051 // The return type will be eliminated later.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001052 Diag(D.getIdentifierLoc(), diag::err_constructor_return_type)
1053 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
1054 << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00001055 }
1056 if (R->getAsFunctionTypeProto()->getTypeQuals() != 0) {
1057 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
1058 if (FTI.TypeQuals & QualType::Const)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001059 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
1060 << "const" << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00001061 if (FTI.TypeQuals & QualType::Volatile)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001062 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
1063 << "volatile" << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00001064 if (FTI.TypeQuals & QualType::Restrict)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001065 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
1066 << "restrict" << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00001067 }
1068
1069 // Rebuild the function type "R" without any type qualifiers (in
1070 // case any of the errors above fired) and with "void" as the
1071 // return type, since constructors don't have return types. We
1072 // *always* have to do this, because GetTypeForDeclarator will
1073 // put in a result type of "int" when none was specified.
1074 const FunctionTypeProto *Proto = R->getAsFunctionTypeProto();
1075 R = Context.getFunctionType(Context.VoidTy, Proto->arg_type_begin(),
1076 Proto->getNumArgs(),
1077 Proto->isVariadic(),
1078 0);
1079
1080 return isInvalid;
1081}
1082
Douglas Gregor72b505b2008-12-16 21:30:33 +00001083/// CheckConstructor - Checks a fully-formed constructor for
1084/// well-formedness, issuing any diagnostics required. Returns true if
1085/// the constructor declarator is invalid.
1086bool Sema::CheckConstructor(CXXConstructorDecl *Constructor) {
1087 if (Constructor->isInvalidDecl())
1088 return true;
1089
1090 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Constructor->getDeclContext());
1091 bool Invalid = false;
1092
1093 // C++ [class.copy]p3:
1094 // A declaration of a constructor for a class X is ill-formed if
1095 // its first parameter is of type (optionally cv-qualified) X and
1096 // either there are no other parameters or else all other
1097 // parameters have default arguments.
1098 if ((Constructor->getNumParams() == 1) ||
1099 (Constructor->getNumParams() > 1 &&
1100 Constructor->getParamDecl(1)->getDefaultArg() != 0)) {
1101 QualType ParamType = Constructor->getParamDecl(0)->getType();
1102 QualType ClassTy = Context.getTagDeclType(ClassDecl);
1103 if (Context.getCanonicalType(ParamType).getUnqualifiedType() == ClassTy) {
1104 Diag(Constructor->getLocation(), diag::err_constructor_byvalue_arg)
1105 << SourceRange(Constructor->getParamDecl(0)->getLocation());
1106 Invalid = true;
1107 }
1108 }
1109
1110 // Notify the class that we've added a constructor.
1111 ClassDecl->addedConstructor(Context, Constructor);
1112
1113 return Invalid;
1114}
1115
Douglas Gregor42a552f2008-11-05 20:51:48 +00001116/// CheckDestructorDeclarator - Called by ActOnDeclarator to check
1117/// the well-formednes of the destructor declarator @p D with type @p
1118/// R. If there are any errors in the declarator, this routine will
1119/// emit diagnostics and return true. Otherwise, it will return
1120/// false. Either way, the type @p R will be updated to reflect a
1121/// well-formed type for the destructor.
1122bool Sema::CheckDestructorDeclarator(Declarator &D, QualType &R,
1123 FunctionDecl::StorageClass& SC) {
1124 bool isInvalid = false;
1125
1126 // C++ [class.dtor]p1:
1127 // [...] A typedef-name that names a class is a class-name
1128 // (7.1.3); however, a typedef-name that names a class shall not
1129 // be used as the identifier in the declarator for a destructor
1130 // declaration.
1131 TypeDecl *DeclaratorTypeD = (TypeDecl *)D.getDeclaratorIdType();
1132 if (const TypedefDecl *TypedefD = dyn_cast<TypedefDecl>(DeclaratorTypeD)) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001133 Diag(D.getIdentifierLoc(), diag::err_destructor_typedef_name)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001134 << TypedefD->getDeclName();
Douglas Gregor55c60952008-11-10 14:41:22 +00001135 isInvalid = true;
Douglas Gregor42a552f2008-11-05 20:51:48 +00001136 }
1137
1138 // C++ [class.dtor]p2:
1139 // A destructor is used to destroy objects of its class type. A
1140 // destructor takes no parameters, and no return type can be
1141 // specified for it (not even void). The address of a destructor
1142 // shall not be taken. A destructor shall not be static. A
1143 // destructor can be invoked for a const, volatile or const
1144 // volatile object. A destructor shall not be declared const,
1145 // volatile or const volatile (9.3.2).
1146 if (SC == FunctionDecl::Static) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001147 Diag(D.getIdentifierLoc(), diag::err_destructor_cannot_be)
1148 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
1149 << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00001150 isInvalid = true;
1151 SC = FunctionDecl::None;
1152 }
1153 if (D.getDeclSpec().hasTypeSpecifier()) {
1154 // Destructors don't have return types, but the parser will
1155 // happily parse something like:
1156 //
1157 // class X {
1158 // float ~X();
1159 // };
1160 //
1161 // The return type will be eliminated later.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001162 Diag(D.getIdentifierLoc(), diag::err_destructor_return_type)
1163 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
1164 << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00001165 }
1166 if (R->getAsFunctionTypeProto()->getTypeQuals() != 0) {
1167 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
1168 if (FTI.TypeQuals & QualType::Const)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001169 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
1170 << "const" << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00001171 if (FTI.TypeQuals & QualType::Volatile)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001172 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
1173 << "volatile" << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00001174 if (FTI.TypeQuals & QualType::Restrict)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001175 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
1176 << "restrict" << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00001177 }
1178
1179 // Make sure we don't have any parameters.
1180 if (R->getAsFunctionTypeProto()->getNumArgs() > 0) {
1181 Diag(D.getIdentifierLoc(), diag::err_destructor_with_params);
1182
1183 // Delete the parameters.
1184 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
1185 if (FTI.NumArgs) {
1186 delete [] FTI.ArgInfo;
1187 FTI.NumArgs = 0;
1188 FTI.ArgInfo = 0;
1189 }
1190 }
1191
1192 // Make sure the destructor isn't variadic.
1193 if (R->getAsFunctionTypeProto()->isVariadic())
1194 Diag(D.getIdentifierLoc(), diag::err_destructor_variadic);
1195
1196 // Rebuild the function type "R" without any type qualifiers or
1197 // parameters (in case any of the errors above fired) and with
1198 // "void" as the return type, since destructors don't have return
1199 // types. We *always* have to do this, because GetTypeForDeclarator
1200 // will put in a result type of "int" when none was specified.
1201 R = Context.getFunctionType(Context.VoidTy, 0, 0, false, 0);
1202
1203 return isInvalid;
1204}
1205
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001206/// CheckConversionDeclarator - Called by ActOnDeclarator to check the
1207/// well-formednes of the conversion function declarator @p D with
1208/// type @p R. If there are any errors in the declarator, this routine
1209/// will emit diagnostics and return true. Otherwise, it will return
1210/// false. Either way, the type @p R will be updated to reflect a
1211/// well-formed type for the conversion operator.
1212bool Sema::CheckConversionDeclarator(Declarator &D, QualType &R,
1213 FunctionDecl::StorageClass& SC) {
1214 bool isInvalid = false;
1215
1216 // C++ [class.conv.fct]p1:
1217 // Neither parameter types nor return type can be specified. The
1218 // type of a conversion function (8.3.5) is “function taking no
1219 // parameter returning conversion-type-id.”
1220 if (SC == FunctionDecl::Static) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001221 Diag(D.getIdentifierLoc(), diag::err_conv_function_not_member)
1222 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
1223 << SourceRange(D.getIdentifierLoc());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001224 isInvalid = true;
1225 SC = FunctionDecl::None;
1226 }
1227 if (D.getDeclSpec().hasTypeSpecifier()) {
1228 // Conversion functions don't have return types, but the parser will
1229 // happily parse something like:
1230 //
1231 // class X {
1232 // float operator bool();
1233 // };
1234 //
1235 // The return type will be changed later anyway.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001236 Diag(D.getIdentifierLoc(), diag::err_conv_function_return_type)
1237 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
1238 << SourceRange(D.getIdentifierLoc());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001239 }
1240
1241 // Make sure we don't have any parameters.
1242 if (R->getAsFunctionTypeProto()->getNumArgs() > 0) {
1243 Diag(D.getIdentifierLoc(), diag::err_conv_function_with_params);
1244
1245 // Delete the parameters.
1246 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
1247 if (FTI.NumArgs) {
1248 delete [] FTI.ArgInfo;
1249 FTI.NumArgs = 0;
1250 FTI.ArgInfo = 0;
1251 }
1252 }
1253
1254 // Make sure the conversion function isn't variadic.
1255 if (R->getAsFunctionTypeProto()->isVariadic())
1256 Diag(D.getIdentifierLoc(), diag::err_conv_function_variadic);
1257
1258 // C++ [class.conv.fct]p4:
1259 // The conversion-type-id shall not represent a function type nor
1260 // an array type.
1261 QualType ConvType = QualType::getFromOpaquePtr(D.getDeclaratorIdType());
1262 if (ConvType->isArrayType()) {
1263 Diag(D.getIdentifierLoc(), diag::err_conv_function_to_array);
1264 ConvType = Context.getPointerType(ConvType);
1265 } else if (ConvType->isFunctionType()) {
1266 Diag(D.getIdentifierLoc(), diag::err_conv_function_to_function);
1267 ConvType = Context.getPointerType(ConvType);
1268 }
1269
1270 // Rebuild the function type "R" without any parameters (in case any
1271 // of the errors above fired) and with the conversion type as the
1272 // return type.
1273 R = Context.getFunctionType(ConvType, 0, 0, false,
1274 R->getAsFunctionTypeProto()->getTypeQuals());
1275
1276 return isInvalid;
1277}
1278
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001279/// ActOnConversionDeclarator - Called by ActOnDeclarator to complete
1280/// the declaration of the given C++ conversion function. This routine
1281/// is responsible for recording the conversion function in the C++
1282/// class, if possible.
1283Sema::DeclTy *Sema::ActOnConversionDeclarator(CXXConversionDecl *Conversion) {
1284 assert(Conversion && "Expected to receive a conversion function declaration");
1285
Douglas Gregor9d350972008-12-12 08:25:50 +00001286 // Set the lexical context of this conversion function
1287 Conversion->setLexicalDeclContext(CurContext);
1288
1289 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Conversion->getDeclContext());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001290
1291 // Make sure we aren't redeclaring the conversion function.
1292 QualType ConvType = Context.getCanonicalType(Conversion->getConversionType());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001293
1294 // C++ [class.conv.fct]p1:
1295 // [...] A conversion function is never used to convert a
1296 // (possibly cv-qualified) object to the (possibly cv-qualified)
1297 // same object type (or a reference to it), to a (possibly
1298 // cv-qualified) base class of that type (or a reference to it),
1299 // or to (possibly cv-qualified) void.
1300 // FIXME: Suppress this warning if the conversion function ends up
1301 // being a virtual function that overrides a virtual function in a
1302 // base class.
1303 QualType ClassType
1304 = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
1305 if (const ReferenceType *ConvTypeRef = ConvType->getAsReferenceType())
1306 ConvType = ConvTypeRef->getPointeeType();
1307 if (ConvType->isRecordType()) {
1308 ConvType = Context.getCanonicalType(ConvType).getUnqualifiedType();
1309 if (ConvType == ClassType)
Chris Lattner5dc266a2008-11-20 06:13:02 +00001310 Diag(Conversion->getLocation(), diag::warn_conv_to_self_not_used)
Chris Lattnerd1625842008-11-24 06:25:27 +00001311 << ClassType;
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001312 else if (IsDerivedFrom(ClassType, ConvType))
Chris Lattner5dc266a2008-11-20 06:13:02 +00001313 Diag(Conversion->getLocation(), diag::warn_conv_to_base_not_used)
Chris Lattnerd1625842008-11-24 06:25:27 +00001314 << ClassType << ConvType;
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001315 } else if (ConvType->isVoidType()) {
Chris Lattner5dc266a2008-11-20 06:13:02 +00001316 Diag(Conversion->getLocation(), diag::warn_conv_to_void_not_used)
Chris Lattnerd1625842008-11-24 06:25:27 +00001317 << ClassType << ConvType;
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001318 }
1319
Douglas Gregor70316a02008-12-26 15:00:45 +00001320 if (Conversion->getPreviousDeclaration()) {
1321 OverloadedFunctionDecl *Conversions = ClassDecl->getConversionFunctions();
1322 for (OverloadedFunctionDecl::function_iterator
1323 Conv = Conversions->function_begin(),
1324 ConvEnd = Conversions->function_end();
1325 Conv != ConvEnd; ++Conv) {
1326 if (*Conv == Conversion->getPreviousDeclaration()) {
1327 *Conv = Conversion;
1328 return (DeclTy *)Conversion;
1329 }
1330 }
1331 assert(Conversion->isInvalidDecl() && "Conversion should not get here.");
1332 } else
1333 ClassDecl->addConversionFunction(Context, Conversion);
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001334
1335 return (DeclTy *)Conversion;
1336}
1337
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001338//===----------------------------------------------------------------------===//
1339// Namespace Handling
1340//===----------------------------------------------------------------------===//
1341
1342/// ActOnStartNamespaceDef - This is called at the start of a namespace
1343/// definition.
1344Sema::DeclTy *Sema::ActOnStartNamespaceDef(Scope *NamespcScope,
1345 SourceLocation IdentLoc,
1346 IdentifierInfo *II,
1347 SourceLocation LBrace) {
1348 NamespaceDecl *Namespc =
1349 NamespaceDecl::Create(Context, CurContext, IdentLoc, II);
1350 Namespc->setLBracLoc(LBrace);
1351
1352 Scope *DeclRegionScope = NamespcScope->getParent();
1353
1354 if (II) {
1355 // C++ [namespace.def]p2:
1356 // The identifier in an original-namespace-definition shall not have been
1357 // previously defined in the declarative region in which the
1358 // original-namespace-definition appears. The identifier in an
1359 // original-namespace-definition is the name of the namespace. Subsequently
1360 // in that declarative region, it is treated as an original-namespace-name.
1361
1362 Decl *PrevDecl =
Douglas Gregor44b43212008-12-11 16:49:14 +00001363 LookupDecl(II, Decl::IDNS_Tag | Decl::IDNS_Ordinary, DeclRegionScope, 0,
1364 /*enableLazyBuiltinCreation=*/false,
1365 /*LookupInParent=*/false);
1366
1367 if (NamespaceDecl *OrigNS = dyn_cast_or_null<NamespaceDecl>(PrevDecl)) {
1368 // This is an extended namespace definition.
1369 // Attach this namespace decl to the chain of extended namespace
1370 // definitions.
1371 OrigNS->setNextNamespace(Namespc);
1372 Namespc->setOriginalNamespace(OrigNS->getOriginalNamespace());
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001373
Douglas Gregor44b43212008-12-11 16:49:14 +00001374 // Remove the previous declaration from the scope.
1375 if (DeclRegionScope->isDeclScope(OrigNS)) {
Douglas Gregore267ff32008-12-11 20:41:00 +00001376 IdResolver.RemoveDecl(OrigNS);
1377 DeclRegionScope->RemoveDecl(OrigNS);
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001378 }
Douglas Gregor44b43212008-12-11 16:49:14 +00001379 } else if (PrevDecl) {
1380 // This is an invalid name redefinition.
1381 Diag(Namespc->getLocation(), diag::err_redefinition_different_kind)
1382 << Namespc->getDeclName();
1383 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
1384 Namespc->setInvalidDecl();
1385 // Continue on to push Namespc as current DeclContext and return it.
1386 }
1387
1388 PushOnScopeChains(Namespc, DeclRegionScope);
1389 } else {
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001390 // FIXME: Handle anonymous namespaces
1391 }
1392
1393 // Although we could have an invalid decl (i.e. the namespace name is a
1394 // redefinition), push it as current DeclContext and try to continue parsing.
Douglas Gregor44b43212008-12-11 16:49:14 +00001395 // FIXME: We should be able to push Namespc here, so that the
1396 // each DeclContext for the namespace has the declarations
1397 // that showed up in that particular namespace definition.
1398 PushDeclContext(NamespcScope, Namespc);
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001399 return Namespc;
1400}
1401
1402/// ActOnFinishNamespaceDef - This callback is called after a namespace is
1403/// exited. Decl is the DeclTy returned by ActOnStartNamespaceDef.
1404void Sema::ActOnFinishNamespaceDef(DeclTy *D, SourceLocation RBrace) {
1405 Decl *Dcl = static_cast<Decl *>(D);
1406 NamespaceDecl *Namespc = dyn_cast_or_null<NamespaceDecl>(Dcl);
1407 assert(Namespc && "Invalid parameter, expected NamespaceDecl");
1408 Namespc->setRBracLoc(RBrace);
1409 PopDeclContext();
1410}
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001411
Douglas Gregorf780abc2008-12-30 03:27:21 +00001412Sema::DeclTy *Sema::ActOnUsingDirective(Scope *S,
1413 SourceLocation UsingLoc,
1414 SourceLocation NamespcLoc,
1415 const CXXScopeSpec &SS,
1416 SourceLocation IdentLoc,
1417 IdentifierInfo *NamespcName,
1418 AttributeList *AttrList) {
1419 assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
1420 assert(NamespcName && "Invalid NamespcName.");
1421 assert(IdentLoc.isValid() && "Invalid NamespceName location.");
1422
1423 // FIXME: This still requires lot more checks, and AST support.
1424 // Lookup namespace name.
1425 DeclContext *DC = static_cast<DeclContext*>(SS.getScopeRep());
Douglas Gregorf780abc2008-12-30 03:27:21 +00001426
Chris Lattneread013e2009-01-06 07:24:29 +00001427 if (Decl *NS = LookupNamespaceName(NamespcName, S, DC)) {
Douglas Gregorf780abc2008-12-30 03:27:21 +00001428 assert(isa<NamespaceDecl>(NS) && "expected namespace decl");
1429 } else {
Chris Lattneread013e2009-01-06 07:24:29 +00001430 Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
Douglas Gregorf780abc2008-12-30 03:27:21 +00001431 }
1432
1433 // FIXME: We ignore AttrList for now, and delete it to avoid leak.
1434 delete AttrList;
1435 return 0;
1436}
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001437
1438/// AddCXXDirectInitializerToDecl - This action is called immediately after
1439/// ActOnDeclarator, when a C++ direct initializer is present.
1440/// e.g: "int x(1);"
1441void Sema::AddCXXDirectInitializerToDecl(DeclTy *Dcl, SourceLocation LParenLoc,
1442 ExprTy **ExprTys, unsigned NumExprs,
1443 SourceLocation *CommaLocs,
1444 SourceLocation RParenLoc) {
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001445 assert(NumExprs != 0 && ExprTys && "missing expressions");
Argyrios Kyrtzidisce8e2922008-10-06 23:08:37 +00001446 Decl *RealDecl = static_cast<Decl *>(Dcl);
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001447
1448 // If there is no declaration, there was an error parsing it. Just ignore
1449 // the initializer.
1450 if (RealDecl == 0) {
Ted Kremenek15f61392008-10-06 20:35:04 +00001451 for (unsigned i = 0; i != NumExprs; ++i)
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001452 delete static_cast<Expr *>(ExprTys[i]);
1453 return;
1454 }
1455
1456 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
1457 if (!VDecl) {
1458 Diag(RealDecl->getLocation(), diag::err_illegal_initializer);
1459 RealDecl->setInvalidDecl();
1460 return;
1461 }
1462
Argyrios Kyrtzidisce8e2922008-10-06 23:08:37 +00001463 // We will treat direct-initialization as a copy-initialization:
1464 // int x(1); -as-> int x = 1;
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001465 // ClassType x(a,b,c); -as-> ClassType x = ClassType(a,b,c);
1466 //
1467 // Clients that want to distinguish between the two forms, can check for
1468 // direct initializer using VarDecl::hasCXXDirectInitializer().
1469 // A major benefit is that clients that don't particularly care about which
1470 // exactly form was it (like the CodeGen) can handle both cases without
1471 // special case code.
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +00001472
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001473 // C++ 8.5p11:
1474 // The form of initialization (using parentheses or '=') is generally
1475 // insignificant, but does matter when the entity being initialized has a
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +00001476 // class type.
Douglas Gregor18fe5682008-11-03 20:45:27 +00001477 QualType DeclInitType = VDecl->getType();
1478 if (const ArrayType *Array = Context.getAsArrayType(DeclInitType))
1479 DeclInitType = Array->getElementType();
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +00001480
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +00001481 if (VDecl->getType()->isRecordType()) {
Douglas Gregor18fe5682008-11-03 20:45:27 +00001482 CXXConstructorDecl *Constructor
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001483 = PerformInitializationByConstructor(DeclInitType,
1484 (Expr **)ExprTys, NumExprs,
1485 VDecl->getLocation(),
1486 SourceRange(VDecl->getLocation(),
1487 RParenLoc),
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001488 VDecl->getDeclName(),
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001489 IK_Direct);
Douglas Gregor18fe5682008-11-03 20:45:27 +00001490 if (!Constructor) {
1491 RealDecl->setInvalidDecl();
1492 }
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001493
1494 // Let clients know that initialization was done with a direct
1495 // initializer.
1496 VDecl->setCXXDirectInitializer(true);
1497
1498 // FIXME: Add ExprTys and Constructor to the RealDecl as part of
1499 // the initializer.
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +00001500 return;
1501 }
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001502
Argyrios Kyrtzidisce8e2922008-10-06 23:08:37 +00001503 if (NumExprs > 1) {
Chris Lattnerdcd5ef12008-11-19 05:27:50 +00001504 Diag(CommaLocs[0], diag::err_builtin_direct_init_more_than_one_arg)
1505 << SourceRange(VDecl->getLocation(), RParenLoc);
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001506 RealDecl->setInvalidDecl();
1507 return;
1508 }
1509
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001510 // Let clients know that initialization was done with a direct initializer.
1511 VDecl->setCXXDirectInitializer(true);
Argyrios Kyrtzidisce8e2922008-10-06 23:08:37 +00001512
1513 assert(NumExprs == 1 && "Expected 1 expression");
1514 // Set the init expression, handles conversions.
Sebastian Redl798d1192008-12-13 16:23:55 +00001515 AddInitializerToDecl(Dcl, ExprArg(*this, ExprTys[0]));
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001516}
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001517
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001518/// PerformInitializationByConstructor - Perform initialization by
1519/// constructor (C++ [dcl.init]p14), which may occur as part of
1520/// direct-initialization or copy-initialization. We are initializing
1521/// an object of type @p ClassType with the given arguments @p
1522/// Args. @p Loc is the location in the source code where the
1523/// initializer occurs (e.g., a declaration, member initializer,
1524/// functional cast, etc.) while @p Range covers the whole
1525/// initialization. @p InitEntity is the entity being initialized,
1526/// which may by the name of a declaration or a type. @p Kind is the
1527/// kind of initialization we're performing, which affects whether
1528/// explicit constructors will be considered. When successful, returns
Douglas Gregor18fe5682008-11-03 20:45:27 +00001529/// the constructor that will be used to perform the initialization;
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001530/// when the initialization fails, emits a diagnostic and returns
1531/// null.
Douglas Gregor18fe5682008-11-03 20:45:27 +00001532CXXConstructorDecl *
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001533Sema::PerformInitializationByConstructor(QualType ClassType,
1534 Expr **Args, unsigned NumArgs,
1535 SourceLocation Loc, SourceRange Range,
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001536 DeclarationName InitEntity,
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001537 InitializationKind Kind) {
Douglas Gregor18fe5682008-11-03 20:45:27 +00001538 const RecordType *ClassRec = ClassType->getAsRecordType();
1539 assert(ClassRec && "Can only initialize a class type here");
1540
1541 // C++ [dcl.init]p14:
1542 //
1543 // If the initialization is direct-initialization, or if it is
1544 // copy-initialization where the cv-unqualified version of the
1545 // source type is the same class as, or a derived class of, the
1546 // class of the destination, constructors are considered. The
1547 // applicable constructors are enumerated (13.3.1.3), and the
1548 // best one is chosen through overload resolution (13.3). The
1549 // constructor so selected is called to initialize the object,
1550 // with the initializer expression(s) as its argument(s). If no
1551 // constructor applies, or the overload resolution is ambiguous,
1552 // the initialization is ill-formed.
Douglas Gregor18fe5682008-11-03 20:45:27 +00001553 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(ClassRec->getDecl());
1554 OverloadCandidateSet CandidateSet;
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001555
1556 // Add constructors to the overload set.
Douglas Gregor9e7d9de2008-12-15 21:24:18 +00001557 DeclarationName ConstructorName
1558 = Context.DeclarationNames.getCXXConstructorName(
1559 Context.getCanonicalType(ClassType.getUnqualifiedType()));
Douglas Gregor3fc749d2008-12-23 00:26:44 +00001560 DeclContext::lookup_const_iterator Con, ConEnd;
Steve Naroff0701bbb2009-01-08 17:28:14 +00001561 for (llvm::tie(Con, ConEnd) = ClassDecl->lookup(ConstructorName);
Douglas Gregor3fc749d2008-12-23 00:26:44 +00001562 Con != ConEnd; ++Con) {
1563 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(*Con);
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001564 if ((Kind == IK_Direct) ||
1565 (Kind == IK_Copy && Constructor->isConvertingConstructor()) ||
1566 (Kind == IK_Default && Constructor->isDefaultConstructor()))
1567 AddOverloadCandidate(Constructor, Args, NumArgs, CandidateSet);
1568 }
1569
Douglas Gregor9e7d9de2008-12-15 21:24:18 +00001570 // FIXME: When we decide not to synthesize the implicitly-declared
1571 // constructors, we'll need to make them appear here.
1572
Douglas Gregor18fe5682008-11-03 20:45:27 +00001573 OverloadCandidateSet::iterator Best;
Douglas Gregor18fe5682008-11-03 20:45:27 +00001574 switch (BestViableFunction(CandidateSet, Best)) {
1575 case OR_Success:
1576 // We found a constructor. Return it.
1577 return cast<CXXConstructorDecl>(Best->Function);
1578
1579 case OR_No_Viable_Function:
Sebastian Redle4c452c2008-11-22 13:44:36 +00001580 Diag(Loc, diag::err_ovl_no_viable_function_in_init)
1581 << InitEntity << (unsigned)CandidateSet.size() << Range;
1582 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/false);
Douglas Gregor18fe5682008-11-03 20:45:27 +00001583 return 0;
1584
1585 case OR_Ambiguous:
Chris Lattnerd3a94e22008-11-20 06:06:08 +00001586 Diag(Loc, diag::err_ovl_ambiguous_init) << InitEntity << Range;
Douglas Gregor18fe5682008-11-03 20:45:27 +00001587 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
1588 return 0;
1589 }
1590
1591 return 0;
1592}
1593
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001594/// CompareReferenceRelationship - Compare the two types T1 and T2 to
1595/// determine whether they are reference-related,
1596/// reference-compatible, reference-compatible with added
1597/// qualification, or incompatible, for use in C++ initialization by
1598/// reference (C++ [dcl.ref.init]p4). Neither type can be a reference
1599/// type, and the first type (T1) is the pointee type of the reference
1600/// type being initialized.
1601Sema::ReferenceCompareResult
Douglas Gregor15da57e2008-10-29 02:00:59 +00001602Sema::CompareReferenceRelationship(QualType T1, QualType T2,
1603 bool& DerivedToBase) {
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001604 assert(!T1->isReferenceType() && "T1 must be the pointee type of the reference type");
1605 assert(!T2->isReferenceType() && "T2 cannot be a reference type");
1606
1607 T1 = Context.getCanonicalType(T1);
1608 T2 = Context.getCanonicalType(T2);
1609 QualType UnqualT1 = T1.getUnqualifiedType();
1610 QualType UnqualT2 = T2.getUnqualifiedType();
1611
1612 // C++ [dcl.init.ref]p4:
1613 // Given types “cv1 T1” and “cv2 T2,” “cv1 T1” is
1614 // reference-related to “cv2 T2” if T1 is the same type as T2, or
1615 // T1 is a base class of T2.
Douglas Gregor15da57e2008-10-29 02:00:59 +00001616 if (UnqualT1 == UnqualT2)
1617 DerivedToBase = false;
1618 else if (IsDerivedFrom(UnqualT2, UnqualT1))
1619 DerivedToBase = true;
1620 else
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001621 return Ref_Incompatible;
1622
1623 // At this point, we know that T1 and T2 are reference-related (at
1624 // least).
1625
1626 // C++ [dcl.init.ref]p4:
1627 // "cv1 T1” is reference-compatible with “cv2 T2” if T1 is
1628 // reference-related to T2 and cv1 is the same cv-qualification
1629 // as, or greater cv-qualification than, cv2. For purposes of
1630 // overload resolution, cases for which cv1 is greater
1631 // cv-qualification than cv2 are identified as
1632 // reference-compatible with added qualification (see 13.3.3.2).
1633 if (T1.getCVRQualifiers() == T2.getCVRQualifiers())
1634 return Ref_Compatible;
1635 else if (T1.isMoreQualifiedThan(T2))
1636 return Ref_Compatible_With_Added_Qualification;
1637 else
1638 return Ref_Related;
1639}
1640
1641/// CheckReferenceInit - Check the initialization of a reference
1642/// variable with the given initializer (C++ [dcl.init.ref]). Init is
1643/// the initializer (either a simple initializer or an initializer
Douglas Gregor3205a782008-10-29 23:31:03 +00001644/// list), and DeclType is the type of the declaration. When ICS is
1645/// non-null, this routine will compute the implicit conversion
1646/// sequence according to C++ [over.ics.ref] and will not produce any
1647/// diagnostics; when ICS is null, it will emit diagnostics when any
1648/// errors are found. Either way, a return value of true indicates
1649/// that there was a failure, a return value of false indicates that
1650/// the reference initialization succeeded.
Douglas Gregor225c41e2008-11-03 19:09:14 +00001651///
1652/// When @p SuppressUserConversions, user-defined conversions are
1653/// suppressed.
Douglas Gregor15da57e2008-10-29 02:00:59 +00001654bool
1655Sema::CheckReferenceInit(Expr *&Init, QualType &DeclType,
Douglas Gregor225c41e2008-11-03 19:09:14 +00001656 ImplicitConversionSequence *ICS,
1657 bool SuppressUserConversions) {
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001658 assert(DeclType->isReferenceType() && "Reference init needs a reference");
1659
1660 QualType T1 = DeclType->getAsReferenceType()->getPointeeType();
1661 QualType T2 = Init->getType();
1662
Douglas Gregor904eed32008-11-10 20:40:00 +00001663 // If the initializer is the address of an overloaded function, try
1664 // to resolve the overloaded function. If all goes well, T2 is the
1665 // type of the resulting function.
1666 if (T2->isOverloadType()) {
1667 FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Init, DeclType,
1668 ICS != 0);
1669 if (Fn) {
1670 // Since we're performing this reference-initialization for
1671 // real, update the initializer with the resulting function.
1672 if (!ICS)
1673 FixOverloadedFunctionReference(Init, Fn);
1674
1675 T2 = Fn->getType();
1676 }
1677 }
1678
Douglas Gregor15da57e2008-10-29 02:00:59 +00001679 // Compute some basic properties of the types and the initializer.
1680 bool DerivedToBase = false;
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001681 Expr::isLvalueResult InitLvalue = Init->isLvalue(Context);
Douglas Gregor15da57e2008-10-29 02:00:59 +00001682 ReferenceCompareResult RefRelationship
1683 = CompareReferenceRelationship(T1, T2, DerivedToBase);
1684
1685 // Most paths end in a failed conversion.
1686 if (ICS)
1687 ICS->ConversionKind = ImplicitConversionSequence::BadConversion;
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001688
1689 // C++ [dcl.init.ref]p5:
1690 // A reference to type “cv1 T1” is initialized by an expression
1691 // of type “cv2 T2” as follows:
1692
1693 // -- If the initializer expression
1694
1695 bool BindsDirectly = false;
1696 // -- is an lvalue (but is not a bit-field), and “cv1 T1” is
1697 // reference-compatible with “cv2 T2,” or
Douglas Gregor15da57e2008-10-29 02:00:59 +00001698 //
1699 // Note that the bit-field check is skipped if we are just computing
1700 // the implicit conversion sequence (C++ [over.best.ics]p2).
1701 if (InitLvalue == Expr::LV_Valid && (ICS || !Init->isBitField()) &&
1702 RefRelationship >= Ref_Compatible_With_Added_Qualification) {
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001703 BindsDirectly = true;
1704
Douglas Gregor15da57e2008-10-29 02:00:59 +00001705 if (ICS) {
1706 // C++ [over.ics.ref]p1:
1707 // When a parameter of reference type binds directly (8.5.3)
1708 // to an argument expression, the implicit conversion sequence
1709 // is the identity conversion, unless the argument expression
1710 // has a type that is a derived class of the parameter type,
1711 // in which case the implicit conversion sequence is a
1712 // derived-to-base Conversion (13.3.3.1).
1713 ICS->ConversionKind = ImplicitConversionSequence::StandardConversion;
1714 ICS->Standard.First = ICK_Identity;
1715 ICS->Standard.Second = DerivedToBase? ICK_Derived_To_Base : ICK_Identity;
1716 ICS->Standard.Third = ICK_Identity;
1717 ICS->Standard.FromTypePtr = T2.getAsOpaquePtr();
1718 ICS->Standard.ToTypePtr = T1.getAsOpaquePtr();
Douglas Gregorf70bdb92008-10-29 14:50:44 +00001719 ICS->Standard.ReferenceBinding = true;
1720 ICS->Standard.DirectBinding = true;
Douglas Gregor15da57e2008-10-29 02:00:59 +00001721
1722 // Nothing more to do: the inaccessibility/ambiguity check for
1723 // derived-to-base conversions is suppressed when we're
1724 // computing the implicit conversion sequence (C++
1725 // [over.best.ics]p2).
1726 return false;
1727 } else {
1728 // Perform the conversion.
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001729 // FIXME: Binding to a subobject of the lvalue is going to require
1730 // more AST annotation than this.
Douglas Gregoreb8f3062008-11-12 17:17:38 +00001731 ImpCastExprToType(Init, T1, /*isLvalue=*/true);
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001732 }
1733 }
1734
1735 // -- has a class type (i.e., T2 is a class type) and can be
1736 // implicitly converted to an lvalue of type “cv3 T3,”
1737 // where “cv1 T1” is reference-compatible with “cv3 T3”
1738 // 92) (this conversion is selected by enumerating the
1739 // applicable conversion functions (13.3.1.6) and choosing
1740 // the best one through overload resolution (13.3)),
Douglas Gregorcb9b9772008-11-10 16:14:15 +00001741 if (!SuppressUserConversions && T2->isRecordType()) {
1742 // FIXME: Look for conversions in base classes!
1743 CXXRecordDecl *T2RecordDecl
1744 = dyn_cast<CXXRecordDecl>(T2->getAsRecordType()->getDecl());
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001745
Douglas Gregorcb9b9772008-11-10 16:14:15 +00001746 OverloadCandidateSet CandidateSet;
1747 OverloadedFunctionDecl *Conversions
1748 = T2RecordDecl->getConversionFunctions();
1749 for (OverloadedFunctionDecl::function_iterator Func
1750 = Conversions->function_begin();
1751 Func != Conversions->function_end(); ++Func) {
1752 CXXConversionDecl *Conv = cast<CXXConversionDecl>(*Func);
1753
1754 // If the conversion function doesn't return a reference type,
1755 // it can't be considered for this conversion.
1756 // FIXME: This will change when we support rvalue references.
1757 if (Conv->getConversionType()->isReferenceType())
1758 AddConversionCandidate(Conv, Init, DeclType, CandidateSet);
1759 }
1760
1761 OverloadCandidateSet::iterator Best;
1762 switch (BestViableFunction(CandidateSet, Best)) {
1763 case OR_Success:
1764 // This is a direct binding.
1765 BindsDirectly = true;
1766
1767 if (ICS) {
1768 // C++ [over.ics.ref]p1:
1769 //
1770 // [...] If the parameter binds directly to the result of
1771 // applying a conversion function to the argument
1772 // expression, the implicit conversion sequence is a
1773 // user-defined conversion sequence (13.3.3.1.2), with the
1774 // second standard conversion sequence either an identity
1775 // conversion or, if the conversion function returns an
1776 // entity of a type that is a derived class of the parameter
1777 // type, a derived-to-base Conversion.
1778 ICS->ConversionKind = ImplicitConversionSequence::UserDefinedConversion;
1779 ICS->UserDefined.Before = Best->Conversions[0].Standard;
1780 ICS->UserDefined.After = Best->FinalConversion;
1781 ICS->UserDefined.ConversionFunction = Best->Function;
1782 assert(ICS->UserDefined.After.ReferenceBinding &&
1783 ICS->UserDefined.After.DirectBinding &&
1784 "Expected a direct reference binding!");
1785 return false;
1786 } else {
1787 // Perform the conversion.
1788 // FIXME: Binding to a subobject of the lvalue is going to require
1789 // more AST annotation than this.
Douglas Gregoreb8f3062008-11-12 17:17:38 +00001790 ImpCastExprToType(Init, T1, /*isLvalue=*/true);
Douglas Gregorcb9b9772008-11-10 16:14:15 +00001791 }
1792 break;
1793
1794 case OR_Ambiguous:
1795 assert(false && "Ambiguous reference binding conversions not implemented.");
1796 return true;
1797
1798 case OR_No_Viable_Function:
1799 // There was no suitable conversion; continue with other checks.
1800 break;
1801 }
1802 }
1803
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001804 if (BindsDirectly) {
1805 // C++ [dcl.init.ref]p4:
1806 // [...] In all cases where the reference-related or
1807 // reference-compatible relationship of two types is used to
1808 // establish the validity of a reference binding, and T1 is a
1809 // base class of T2, a program that necessitates such a binding
1810 // is ill-formed if T1 is an inaccessible (clause 11) or
1811 // ambiguous (10.2) base class of T2.
1812 //
1813 // Note that we only check this condition when we're allowed to
1814 // complain about errors, because we should not be checking for
1815 // ambiguity (or inaccessibility) unless the reference binding
1816 // actually happens.
Douglas Gregor15da57e2008-10-29 02:00:59 +00001817 if (DerivedToBase)
1818 return CheckDerivedToBaseConversion(T2, T1,
1819 Init->getSourceRange().getBegin(),
1820 Init->getSourceRange());
1821 else
1822 return false;
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001823 }
1824
1825 // -- Otherwise, the reference shall be to a non-volatile const
1826 // type (i.e., cv1 shall be const).
1827 if (T1.getCVRQualifiers() != QualType::Const) {
Douglas Gregor15da57e2008-10-29 02:00:59 +00001828 if (!ICS)
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001829 Diag(Init->getSourceRange().getBegin(),
Chris Lattnerc9c7c4e2008-11-18 22:52:51 +00001830 diag::err_not_reference_to_const_init)
Chris Lattnerd1625842008-11-24 06:25:27 +00001831 << T1 << (InitLvalue != Expr::LV_Valid? "temporary" : "value")
1832 << T2 << Init->getSourceRange();
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001833 return true;
1834 }
1835
1836 // -- If the initializer expression is an rvalue, with T2 a
1837 // class type, and “cv1 T1” is reference-compatible with
1838 // “cv2 T2,” the reference is bound in one of the
1839 // following ways (the choice is implementation-defined):
1840 //
1841 // -- The reference is bound to the object represented by
1842 // the rvalue (see 3.10) or to a sub-object within that
1843 // object.
1844 //
1845 // -- A temporary of type “cv1 T2” [sic] is created, and
1846 // a constructor is called to copy the entire rvalue
1847 // object into the temporary. The reference is bound to
1848 // the temporary or to a sub-object within the
1849 // temporary.
1850 //
1851 //
1852 // The constructor that would be used to make the copy
1853 // shall be callable whether or not the copy is actually
1854 // done.
1855 //
1856 // Note that C++0x [dcl.ref.init]p5 takes away this implementation
1857 // freedom, so we will always take the first option and never build
1858 // a temporary in this case. FIXME: We will, however, have to check
1859 // for the presence of a copy constructor in C++98/03 mode.
1860 if (InitLvalue != Expr::LV_Valid && T2->isRecordType() &&
Douglas Gregor15da57e2008-10-29 02:00:59 +00001861 RefRelationship >= Ref_Compatible_With_Added_Qualification) {
1862 if (ICS) {
1863 ICS->ConversionKind = ImplicitConversionSequence::StandardConversion;
1864 ICS->Standard.First = ICK_Identity;
1865 ICS->Standard.Second = DerivedToBase? ICK_Derived_To_Base : ICK_Identity;
1866 ICS->Standard.Third = ICK_Identity;
1867 ICS->Standard.FromTypePtr = T2.getAsOpaquePtr();
1868 ICS->Standard.ToTypePtr = T1.getAsOpaquePtr();
Douglas Gregorf70bdb92008-10-29 14:50:44 +00001869 ICS->Standard.ReferenceBinding = true;
1870 ICS->Standard.DirectBinding = false;
Douglas Gregor15da57e2008-10-29 02:00:59 +00001871 } else {
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001872 // FIXME: Binding to a subobject of the rvalue is going to require
1873 // more AST annotation than this.
Douglas Gregoreb8f3062008-11-12 17:17:38 +00001874 ImpCastExprToType(Init, T1, /*isLvalue=*/true);
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001875 }
1876 return false;
1877 }
1878
1879 // -- Otherwise, a temporary of type “cv1 T1” is created and
1880 // initialized from the initializer expression using the
1881 // rules for a non-reference copy initialization (8.5). The
1882 // reference is then bound to the temporary. If T1 is
1883 // reference-related to T2, cv1 must be the same
1884 // cv-qualification as, or greater cv-qualification than,
1885 // cv2; otherwise, the program is ill-formed.
1886 if (RefRelationship == Ref_Related) {
1887 // If cv1 == cv2 or cv1 is a greater cv-qualified than cv2, then
1888 // we would be reference-compatible or reference-compatible with
1889 // added qualification. But that wasn't the case, so the reference
1890 // initialization fails.
Douglas Gregor15da57e2008-10-29 02:00:59 +00001891 if (!ICS)
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001892 Diag(Init->getSourceRange().getBegin(),
Chris Lattnerc9c7c4e2008-11-18 22:52:51 +00001893 diag::err_reference_init_drops_quals)
Chris Lattnerd1625842008-11-24 06:25:27 +00001894 << T1 << (InitLvalue != Expr::LV_Valid? "temporary" : "value")
1895 << T2 << Init->getSourceRange();
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001896 return true;
1897 }
1898
1899 // Actually try to convert the initializer to T1.
Douglas Gregor15da57e2008-10-29 02:00:59 +00001900 if (ICS) {
1901 /// C++ [over.ics.ref]p2:
1902 ///
1903 /// When a parameter of reference type is not bound directly to
1904 /// an argument expression, the conversion sequence is the one
1905 /// required to convert the argument expression to the
1906 /// underlying type of the reference according to
1907 /// 13.3.3.1. Conceptually, this conversion sequence corresponds
1908 /// to copy-initializing a temporary of the underlying type with
1909 /// the argument expression. Any difference in top-level
1910 /// cv-qualification is subsumed by the initialization itself
1911 /// and does not constitute a conversion.
Douglas Gregor225c41e2008-11-03 19:09:14 +00001912 *ICS = TryImplicitConversion(Init, T1, SuppressUserConversions);
Douglas Gregor15da57e2008-10-29 02:00:59 +00001913 return ICS->ConversionKind == ImplicitConversionSequence::BadConversion;
1914 } else {
Douglas Gregor45920e82008-12-19 17:40:08 +00001915 return PerformImplicitConversion(Init, T1, "initializing");
Douglas Gregor15da57e2008-10-29 02:00:59 +00001916 }
Douglas Gregor27c8dc02008-10-29 00:13:59 +00001917}
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00001918
1919/// CheckOverloadedOperatorDeclaration - Check whether the declaration
1920/// of this overloaded operator is well-formed. If so, returns false;
1921/// otherwise, emits appropriate diagnostics and returns true.
1922bool Sema::CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl) {
Douglas Gregor43c7bad2008-11-17 16:14:12 +00001923 assert(FnDecl && FnDecl->isOverloadedOperator() &&
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00001924 "Expected an overloaded operator declaration");
1925
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00001926 OverloadedOperatorKind Op = FnDecl->getOverloadedOperator();
1927
1928 // C++ [over.oper]p5:
1929 // The allocation and deallocation functions, operator new,
1930 // operator new[], operator delete and operator delete[], are
1931 // described completely in 3.7.3. The attributes and restrictions
1932 // found in the rest of this subclause do not apply to them unless
1933 // explicitly stated in 3.7.3.
1934 // FIXME: Write a separate routine for checking this. For now, just
1935 // allow it.
1936 if (Op == OO_New || Op == OO_Array_New ||
1937 Op == OO_Delete || Op == OO_Array_Delete)
1938 return false;
1939
1940 // C++ [over.oper]p6:
1941 // An operator function shall either be a non-static member
1942 // function or be a non-member function and have at least one
1943 // parameter whose type is a class, a reference to a class, an
1944 // enumeration, or a reference to an enumeration.
Douglas Gregor43c7bad2008-11-17 16:14:12 +00001945 if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) {
1946 if (MethodDecl->isStatic())
1947 return Diag(FnDecl->getLocation(),
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001948 diag::err_operator_overload_static) << FnDecl->getDeclName();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00001949 } else {
1950 bool ClassOrEnumParam = false;
Douglas Gregor43c7bad2008-11-17 16:14:12 +00001951 for (FunctionDecl::param_iterator Param = FnDecl->param_begin(),
1952 ParamEnd = FnDecl->param_end();
1953 Param != ParamEnd; ++Param) {
1954 QualType ParamType = (*Param)->getType().getNonReferenceType();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00001955 if (ParamType->isRecordType() || ParamType->isEnumeralType()) {
1956 ClassOrEnumParam = true;
1957 break;
1958 }
1959 }
1960
Douglas Gregor43c7bad2008-11-17 16:14:12 +00001961 if (!ClassOrEnumParam)
1962 return Diag(FnDecl->getLocation(),
Chris Lattnerf3a41af2008-11-20 06:38:18 +00001963 diag::err_operator_overload_needs_class_or_enum)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001964 << FnDecl->getDeclName();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00001965 }
1966
1967 // C++ [over.oper]p8:
1968 // An operator function cannot have default arguments (8.3.6),
1969 // except where explicitly stated below.
1970 //
1971 // Only the function-call operator allows default arguments
1972 // (C++ [over.call]p1).
1973 if (Op != OO_Call) {
1974 for (FunctionDecl::param_iterator Param = FnDecl->param_begin();
1975 Param != FnDecl->param_end(); ++Param) {
Douglas Gregor61366e92008-12-24 00:01:03 +00001976 if ((*Param)->hasUnparsedDefaultArg())
1977 return Diag((*Param)->getLocation(),
1978 diag::err_operator_overload_default_arg)
1979 << FnDecl->getDeclName();
1980 else if (Expr *DefArg = (*Param)->getDefaultArg())
Douglas Gregor43c7bad2008-11-17 16:14:12 +00001981 return Diag((*Param)->getLocation(),
Chris Lattnerd3a94e22008-11-20 06:06:08 +00001982 diag::err_operator_overload_default_arg)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001983 << FnDecl->getDeclName() << DefArg->getSourceRange();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00001984 }
1985 }
1986
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00001987 static const bool OperatorUses[NUM_OVERLOADED_OPERATORS][3] = {
1988 { false, false, false }
1989#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
1990 , { Unary, Binary, MemberOnly }
1991#include "clang/Basic/OperatorKinds.def"
1992 };
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00001993
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00001994 bool CanBeUnaryOperator = OperatorUses[Op][0];
1995 bool CanBeBinaryOperator = OperatorUses[Op][1];
1996 bool MustBeMemberOperator = OperatorUses[Op][2];
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00001997
1998 // C++ [over.oper]p8:
1999 // [...] Operator functions cannot have more or fewer parameters
2000 // than the number required for the corresponding operator, as
2001 // described in the rest of this subclause.
Douglas Gregor43c7bad2008-11-17 16:14:12 +00002002 unsigned NumParams = FnDecl->getNumParams()
2003 + (isa<CXXMethodDecl>(FnDecl)? 1 : 0);
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002004 if (Op != OO_Call &&
2005 ((NumParams == 1 && !CanBeUnaryOperator) ||
2006 (NumParams == 2 && !CanBeBinaryOperator) ||
2007 (NumParams < 1) || (NumParams > 2))) {
2008 // We have the wrong number of parameters.
Chris Lattner416e46f2008-11-21 07:57:12 +00002009 unsigned ErrorKind;
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00002010 if (CanBeUnaryOperator && CanBeBinaryOperator) {
Chris Lattner416e46f2008-11-21 07:57:12 +00002011 ErrorKind = 2; // 2 -> unary or binary.
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00002012 } else if (CanBeUnaryOperator) {
Chris Lattner416e46f2008-11-21 07:57:12 +00002013 ErrorKind = 0; // 0 -> unary
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00002014 } else {
Chris Lattneraf7ae4e2008-11-21 07:50:02 +00002015 assert(CanBeBinaryOperator &&
2016 "All non-call overloaded operators are unary or binary!");
Chris Lattner416e46f2008-11-21 07:57:12 +00002017 ErrorKind = 1; // 1 -> binary
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00002018 }
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002019
Chris Lattner416e46f2008-11-21 07:57:12 +00002020 return Diag(FnDecl->getLocation(), diag::err_operator_overload_must_be)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002021 << FnDecl->getDeclName() << NumParams << ErrorKind;
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002022 }
Sebastian Redl64b45f72009-01-05 20:52:13 +00002023
Douglas Gregor43c7bad2008-11-17 16:14:12 +00002024 // Overloaded operators other than operator() cannot be variadic.
2025 if (Op != OO_Call &&
2026 FnDecl->getType()->getAsFunctionTypeProto()->isVariadic()) {
Chris Lattnerf3a41af2008-11-20 06:38:18 +00002027 return Diag(FnDecl->getLocation(), diag::err_operator_overload_variadic)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002028 << FnDecl->getDeclName();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002029 }
2030
2031 // Some operators must be non-static member functions.
Douglas Gregor43c7bad2008-11-17 16:14:12 +00002032 if (MustBeMemberOperator && !isa<CXXMethodDecl>(FnDecl)) {
2033 return Diag(FnDecl->getLocation(),
Chris Lattnerf3a41af2008-11-20 06:38:18 +00002034 diag::err_operator_overload_must_be_member)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002035 << FnDecl->getDeclName();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002036 }
2037
2038 // C++ [over.inc]p1:
2039 // The user-defined function called operator++ implements the
2040 // prefix and postfix ++ operator. If this function is a member
2041 // function with no parameters, or a non-member function with one
2042 // parameter of class or enumeration type, it defines the prefix
2043 // increment operator ++ for objects of that type. If the function
2044 // is a member function with one parameter (which shall be of type
2045 // int) or a non-member function with two parameters (the second
2046 // of which shall be of type int), it defines the postfix
2047 // increment operator ++ for objects of that type.
2048 if ((Op == OO_PlusPlus || Op == OO_MinusMinus) && NumParams == 2) {
2049 ParmVarDecl *LastParam = FnDecl->getParamDecl(FnDecl->getNumParams() - 1);
2050 bool ParamIsInt = false;
2051 if (const BuiltinType *BT = LastParam->getType()->getAsBuiltinType())
2052 ParamIsInt = BT->getKind() == BuiltinType::Int;
2053
Chris Lattneraf7ae4e2008-11-21 07:50:02 +00002054 if (!ParamIsInt)
2055 return Diag(LastParam->getLocation(),
2056 diag::err_operator_overload_post_incdec_must_be_int)
Chris Lattnerd1625842008-11-24 06:25:27 +00002057 << LastParam->getType() << (Op == OO_MinusMinus);
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002058 }
2059
Sebastian Redl64b45f72009-01-05 20:52:13 +00002060 // Notify the class if it got an assignment operator.
2061 if (Op == OO_Equal) {
2062 // Would have returned earlier otherwise.
2063 assert(isa<CXXMethodDecl>(FnDecl) &&
2064 "Overloaded = not member, but not filtered.");
2065 CXXMethodDecl *Method = cast<CXXMethodDecl>(FnDecl);
2066 Method->getParent()->addedAssignmentOperator(Context, Method);
2067 }
2068
Douglas Gregor43c7bad2008-11-17 16:14:12 +00002069 return false;
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002070}
Chris Lattner5a003a42008-12-17 07:09:26 +00002071
Douglas Gregor074149e2009-01-05 19:45:36 +00002072/// ActOnStartLinkageSpecification - Parsed the beginning of a C++
2073/// linkage specification, including the language and (if present)
2074/// the '{'. ExternLoc is the location of the 'extern', LangLoc is
2075/// the location of the language string literal, which is provided
2076/// by Lang/StrSize. LBraceLoc, if valid, provides the location of
2077/// the '{' brace. Otherwise, this linkage specification does not
2078/// have any braces.
2079Sema::DeclTy *Sema::ActOnStartLinkageSpecification(Scope *S,
2080 SourceLocation ExternLoc,
2081 SourceLocation LangLoc,
2082 const char *Lang,
2083 unsigned StrSize,
2084 SourceLocation LBraceLoc) {
Chris Lattnercc98eac2008-12-17 07:13:27 +00002085 LinkageSpecDecl::LanguageIDs Language;
2086 if (strncmp(Lang, "\"C\"", StrSize) == 0)
2087 Language = LinkageSpecDecl::lang_c;
2088 else if (strncmp(Lang, "\"C++\"", StrSize) == 0)
2089 Language = LinkageSpecDecl::lang_cxx;
2090 else {
Douglas Gregor074149e2009-01-05 19:45:36 +00002091 Diag(LangLoc, diag::err_bad_language);
Chris Lattnercc98eac2008-12-17 07:13:27 +00002092 return 0;
2093 }
2094
2095 // FIXME: Add all the various semantics of linkage specifications
2096
Douglas Gregor074149e2009-01-05 19:45:36 +00002097 LinkageSpecDecl *D = LinkageSpecDecl::Create(Context, CurContext,
2098 LangLoc, Language,
2099 LBraceLoc.isValid());
2100 CurContext->addDecl(Context, D);
2101 PushDeclContext(S, D);
2102 return D;
Chris Lattnercc98eac2008-12-17 07:13:27 +00002103}
2104
Douglas Gregor074149e2009-01-05 19:45:36 +00002105/// ActOnFinishLinkageSpecification - Completely the definition of
2106/// the C++ linkage specification LinkageSpec. If RBraceLoc is
2107/// valid, it's the position of the closing '}' brace in a linkage
2108/// specification that uses braces.
2109Sema::DeclTy *Sema::ActOnFinishLinkageSpecification(Scope *S,
2110 DeclTy *LinkageSpec,
2111 SourceLocation RBraceLoc) {
2112 if (LinkageSpec)
2113 PopDeclContext();
2114 return LinkageSpec;
Chris Lattner5a003a42008-12-17 07:09:26 +00002115}
2116
Sebastian Redl4b07b292008-12-22 19:15:10 +00002117/// ActOnExceptionDeclarator - Parsed the exception-declarator in a C++ catch
2118/// handler.
2119Sema::DeclTy *Sema::ActOnExceptionDeclarator(Scope *S, Declarator &D)
2120{
2121 QualType ExDeclType = GetTypeForDeclarator(D, S);
2122 SourceLocation Begin = D.getDeclSpec().getSourceRange().getBegin();
2123
2124 bool Invalid = false;
2125
2126 // Arrays and functions decay.
2127 if (ExDeclType->isArrayType())
2128 ExDeclType = Context.getArrayDecayedType(ExDeclType);
2129 else if (ExDeclType->isFunctionType())
2130 ExDeclType = Context.getPointerType(ExDeclType);
2131
2132 // C++ 15.3p1: The exception-declaration shall not denote an incomplete type.
2133 // The exception-declaration shall not denote a pointer or reference to an
2134 // incomplete type, other than [cv] void*.
2135 QualType BaseType = ExDeclType;
2136 int Mode = 0; // 0 for direct type, 1 for pointer, 2 for reference
2137 if (const PointerType *Ptr = BaseType->getAsPointerType()) {
2138 BaseType = Ptr->getPointeeType();
2139 Mode = 1;
2140 } else if(const ReferenceType *Ref = BaseType->getAsReferenceType()) {
2141 BaseType = Ref->getPointeeType();
2142 Mode = 2;
2143 }
2144 if ((Mode == 0 || !BaseType->isVoidType()) && BaseType->isIncompleteType()) {
2145 Invalid = true;
2146 Diag(Begin, diag::err_catch_incomplete) << BaseType << Mode;
2147 }
2148
Sebastian Redl8351da02008-12-22 21:35:02 +00002149 // FIXME: Need to test for ability to copy-construct and destroy the
2150 // exception variable.
2151 // FIXME: Need to check for abstract classes.
2152
Sebastian Redl4b07b292008-12-22 19:15:10 +00002153 IdentifierInfo *II = D.getIdentifier();
2154 if (Decl *PrevDecl = LookupDecl(II, Decl::IDNS_Ordinary, S)) {
2155 // The scope should be freshly made just for us. There is just no way
2156 // it contains any previous declaration.
2157 assert(!S->isDeclScope(PrevDecl));
2158 if (PrevDecl->isTemplateParameter()) {
2159 // Maybe we will complain about the shadowed template parameter.
2160 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
2161
2162 }
2163 }
2164
2165 VarDecl *ExDecl = VarDecl::Create(Context, CurContext, D.getIdentifierLoc(),
2166 II, ExDeclType, VarDecl::None, 0, Begin);
2167 if (D.getInvalidType() || Invalid)
2168 ExDecl->setInvalidDecl();
2169
2170 if (D.getCXXScopeSpec().isSet()) {
2171 Diag(D.getIdentifierLoc(), diag::err_qualified_catch_declarator)
2172 << D.getCXXScopeSpec().getRange();
2173 ExDecl->setInvalidDecl();
2174 }
2175
2176 // Add the exception declaration into this scope.
2177 S->AddDecl(ExDecl);
2178 if (II)
2179 IdResolver.AddDecl(ExDecl);
2180
2181 ProcessDeclAttributes(ExDecl, D);
2182 return ExDecl;
2183}