blob: 1dcac3fc9ec92dd441b0895d0df2bdf7035badd8 [file] [log] [blame]
Chris Lattner3d1cee32008-04-08 05:04:30 +00001//===------ SemaDeclCXX.cpp - Semantic Analysis for C++ Declarations ------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements semantic analysis for C++ declarations.
11//
12//===----------------------------------------------------------------------===//
13
14#include "Sema.h"
Douglas Gregor7ad83902008-11-05 04:29:56 +000015#include "SemaInherit.h"
Argyrios Kyrtzidisa4755c62008-08-09 00:58:37 +000016#include "clang/AST/ASTConsumer.h"
Douglas Gregore37ac4f2008-04-13 21:30:24 +000017#include "clang/AST/ASTContext.h"
Anders Carlsson8211eff2009-03-24 01:19:16 +000018#include "clang/AST/DeclVisitor.h"
Douglas Gregor02189362008-10-22 21:13:31 +000019#include "clang/AST/TypeOrdering.h"
Chris Lattner8123a952008-04-10 02:22:51 +000020#include "clang/AST/StmtVisitor.h"
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +000021#include "clang/Lex/Preprocessor.h"
Daniel Dunbar12bc6922008-08-11 03:27:53 +000022#include "clang/Parse/DeclSpec.h"
Douglas Gregor3fc749d2008-12-23 00:26:44 +000023#include "llvm/ADT/STLExtras.h"
Chris Lattner8123a952008-04-10 02:22:51 +000024#include "llvm/Support/Compiler.h"
Douglas Gregor8e9bebd2008-10-21 16:13:35 +000025#include <algorithm> // for std::equal
Douglas Gregorf8268ae2008-10-22 17:49:05 +000026#include <map>
Chris Lattner3d1cee32008-04-08 05:04:30 +000027
28using namespace clang;
29
Chris Lattner8123a952008-04-10 02:22:51 +000030//===----------------------------------------------------------------------===//
31// CheckDefaultArgumentVisitor
32//===----------------------------------------------------------------------===//
33
Chris Lattner9e979552008-04-12 23:52:44 +000034namespace {
35 /// CheckDefaultArgumentVisitor - C++ [dcl.fct.default] Traverses
36 /// the default argument of a parameter to determine whether it
37 /// contains any ill-formed subexpressions. For example, this will
38 /// diagnose the use of local variables or parameters within the
39 /// default argument expression.
40 class VISIBILITY_HIDDEN CheckDefaultArgumentVisitor
Chris Lattnerb77792e2008-07-26 22:17:49 +000041 : public StmtVisitor<CheckDefaultArgumentVisitor, bool> {
Chris Lattner9e979552008-04-12 23:52:44 +000042 Expr *DefaultArg;
43 Sema *S;
Chris Lattner8123a952008-04-10 02:22:51 +000044
Chris Lattner9e979552008-04-12 23:52:44 +000045 public:
46 CheckDefaultArgumentVisitor(Expr *defarg, Sema *s)
47 : DefaultArg(defarg), S(s) {}
Chris Lattner8123a952008-04-10 02:22:51 +000048
Chris Lattner9e979552008-04-12 23:52:44 +000049 bool VisitExpr(Expr *Node);
50 bool VisitDeclRefExpr(DeclRefExpr *DRE);
Douglas Gregor796da182008-11-04 14:32:21 +000051 bool VisitCXXThisExpr(CXXThisExpr *ThisE);
Chris Lattner9e979552008-04-12 23:52:44 +000052 };
Chris Lattner8123a952008-04-10 02:22:51 +000053
Chris Lattner9e979552008-04-12 23:52:44 +000054 /// VisitExpr - Visit all of the children of this expression.
55 bool CheckDefaultArgumentVisitor::VisitExpr(Expr *Node) {
56 bool IsInvalid = false;
Chris Lattnerb77792e2008-07-26 22:17:49 +000057 for (Stmt::child_iterator I = Node->child_begin(),
58 E = Node->child_end(); I != E; ++I)
59 IsInvalid |= Visit(*I);
Chris Lattner9e979552008-04-12 23:52:44 +000060 return IsInvalid;
Chris Lattner8123a952008-04-10 02:22:51 +000061 }
62
Chris Lattner9e979552008-04-12 23:52:44 +000063 /// VisitDeclRefExpr - Visit a reference to a declaration, to
64 /// determine whether this declaration can be used in the default
65 /// argument expression.
66 bool CheckDefaultArgumentVisitor::VisitDeclRefExpr(DeclRefExpr *DRE) {
Douglas Gregor8e9bebd2008-10-21 16:13:35 +000067 NamedDecl *Decl = DRE->getDecl();
Chris Lattner9e979552008-04-12 23:52:44 +000068 if (ParmVarDecl *Param = dyn_cast<ParmVarDecl>(Decl)) {
69 // C++ [dcl.fct.default]p9
70 // Default arguments are evaluated each time the function is
71 // called. The order of evaluation of function arguments is
72 // unspecified. Consequently, parameters of a function shall not
73 // be used in default argument expressions, even if they are not
74 // evaluated. Parameters of a function declared before a default
75 // argument expression are in scope and can hide namespace and
76 // class member names.
77 return S->Diag(DRE->getSourceRange().getBegin(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +000078 diag::err_param_default_argument_references_param)
Chris Lattner08631c52008-11-23 21:45:46 +000079 << Param->getDeclName() << DefaultArg->getSourceRange();
Steve Naroff248a7532008-04-15 22:42:06 +000080 } else if (VarDecl *VDecl = dyn_cast<VarDecl>(Decl)) {
Chris Lattner9e979552008-04-12 23:52:44 +000081 // C++ [dcl.fct.default]p7
82 // Local variables shall not be used in default argument
83 // expressions.
Steve Naroff248a7532008-04-15 22:42:06 +000084 if (VDecl->isBlockVarDecl())
85 return S->Diag(DRE->getSourceRange().getBegin(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +000086 diag::err_param_default_argument_references_local)
Chris Lattner08631c52008-11-23 21:45:46 +000087 << VDecl->getDeclName() << DefaultArg->getSourceRange();
Chris Lattner9e979552008-04-12 23:52:44 +000088 }
Chris Lattner8123a952008-04-10 02:22:51 +000089
Douglas Gregor3996f232008-11-04 13:41:56 +000090 return false;
91 }
Chris Lattner9e979552008-04-12 23:52:44 +000092
Douglas Gregor796da182008-11-04 14:32:21 +000093 /// VisitCXXThisExpr - Visit a C++ "this" expression.
94 bool CheckDefaultArgumentVisitor::VisitCXXThisExpr(CXXThisExpr *ThisE) {
95 // C++ [dcl.fct.default]p8:
96 // The keyword this shall not be used in a default argument of a
97 // member function.
98 return S->Diag(ThisE->getSourceRange().getBegin(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +000099 diag::err_param_default_argument_references_this)
100 << ThisE->getSourceRange();
Chris Lattner9e979552008-04-12 23:52:44 +0000101 }
Chris Lattner8123a952008-04-10 02:22:51 +0000102}
103
104/// ActOnParamDefaultArgument - Check whether the default argument
105/// provided for a function parameter is well-formed. If so, attach it
106/// to the parameter declaration.
Chris Lattner3d1cee32008-04-08 05:04:30 +0000107void
Chris Lattnerb28317a2009-03-28 19:18:32 +0000108Sema::ActOnParamDefaultArgument(DeclPtrTy param, SourceLocation EqualLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +0000109 ExprArg defarg) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +0000110 if (!param || !defarg.get())
111 return;
112
Chris Lattnerb28317a2009-03-28 19:18:32 +0000113 ParmVarDecl *Param = cast<ParmVarDecl>(param.getAs<Decl>());
Anders Carlsson5e300d12009-06-12 16:51:40 +0000114 UnparsedDefaultArgLocs.erase(Param);
115
Anders Carlssonf1b1d592009-05-01 19:30:39 +0000116 ExprOwningPtr<Expr> DefaultArg(this, defarg.takeAs<Expr>());
Chris Lattner3d1cee32008-04-08 05:04:30 +0000117 QualType ParamType = Param->getType();
118
119 // Default arguments are only permitted in C++
120 if (!getLangOptions().CPlusPlus) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000121 Diag(EqualLoc, diag::err_param_default_argument)
122 << DefaultArg->getSourceRange();
Douglas Gregor72b505b2008-12-16 21:30:33 +0000123 Param->setInvalidDecl();
Chris Lattner3d1cee32008-04-08 05:04:30 +0000124 return;
125 }
126
127 // C++ [dcl.fct.default]p5
128 // A default argument expression is implicitly converted (clause
129 // 4) to the parameter type. The default argument expression has
130 // the same semantic constraints as the initializer expression in
131 // a declaration of a variable of the parameter type, using the
132 // copy-initialization semantics (8.5).
Chris Lattner3d1cee32008-04-08 05:04:30 +0000133 Expr *DefaultArgPtr = DefaultArg.get();
Douglas Gregor61366e92008-12-24 00:01:03 +0000134 bool DefaultInitFailed = CheckInitializerTypes(DefaultArgPtr, ParamType,
135 EqualLoc,
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000136 Param->getDeclName(),
137 /*DirectInit=*/false);
Chris Lattner3d1cee32008-04-08 05:04:30 +0000138 if (DefaultArgPtr != DefaultArg.get()) {
139 DefaultArg.take();
140 DefaultArg.reset(DefaultArgPtr);
141 }
Douglas Gregoreb704f22008-11-04 13:57:51 +0000142 if (DefaultInitFailed) {
Chris Lattner3d1cee32008-04-08 05:04:30 +0000143 return;
144 }
145
Chris Lattner8123a952008-04-10 02:22:51 +0000146 // Check that the default argument is well-formed
Chris Lattner9e979552008-04-12 23:52:44 +0000147 CheckDefaultArgumentVisitor DefaultArgChecker(DefaultArg.get(), this);
Douglas Gregor72b505b2008-12-16 21:30:33 +0000148 if (DefaultArgChecker.Visit(DefaultArg.get())) {
149 Param->setInvalidDecl();
Chris Lattner8123a952008-04-10 02:22:51 +0000150 return;
Douglas Gregor72b505b2008-12-16 21:30:33 +0000151 }
Chris Lattner8123a952008-04-10 02:22:51 +0000152
Anders Carlssonf54741e2009-06-16 03:37:31 +0000153 DefaultArgPtr = MaybeCreateCXXExprWithTemporaries(DefaultArg.take(),
154 /*DestroyTemps=*/false);
155
Chris Lattner3d1cee32008-04-08 05:04:30 +0000156 // Okay: add the default argument to the parameter
Anders Carlssonf54741e2009-06-16 03:37:31 +0000157 Param->setDefaultArg(DefaultArgPtr);
Chris Lattner3d1cee32008-04-08 05:04:30 +0000158}
159
Douglas Gregor61366e92008-12-24 00:01:03 +0000160/// ActOnParamUnparsedDefaultArgument - We've seen a default
161/// argument for a function parameter, but we can't parse it yet
162/// because we're inside a class definition. Note that this default
163/// argument will be parsed later.
Chris Lattnerb28317a2009-03-28 19:18:32 +0000164void Sema::ActOnParamUnparsedDefaultArgument(DeclPtrTy param,
Anders Carlsson5e300d12009-06-12 16:51:40 +0000165 SourceLocation EqualLoc,
166 SourceLocation ArgLoc) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +0000167 if (!param)
168 return;
169
Chris Lattnerb28317a2009-03-28 19:18:32 +0000170 ParmVarDecl *Param = cast<ParmVarDecl>(param.getAs<Decl>());
Douglas Gregor61366e92008-12-24 00:01:03 +0000171 if (Param)
172 Param->setUnparsedDefaultArg();
Anders Carlsson5e300d12009-06-12 16:51:40 +0000173
174 UnparsedDefaultArgLocs[Param] = ArgLoc;
Douglas Gregor61366e92008-12-24 00:01:03 +0000175}
176
Douglas Gregor72b505b2008-12-16 21:30:33 +0000177/// ActOnParamDefaultArgumentError - Parsing or semantic analysis of
178/// the default argument for the parameter param failed.
Chris Lattnerb28317a2009-03-28 19:18:32 +0000179void Sema::ActOnParamDefaultArgumentError(DeclPtrTy param) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +0000180 if (!param)
181 return;
182
Anders Carlsson5e300d12009-06-12 16:51:40 +0000183 ParmVarDecl *Param = cast<ParmVarDecl>(param.getAs<Decl>());
184
185 Param->setInvalidDecl();
186
187 UnparsedDefaultArgLocs.erase(Param);
Douglas Gregor72b505b2008-12-16 21:30:33 +0000188}
189
Douglas Gregor6d6eb572008-05-07 04:49:29 +0000190/// CheckExtraCXXDefaultArguments - Check for any extra default
191/// arguments in the declarator, which is not a function declaration
192/// or definition and therefore is not permitted to have default
193/// arguments. This routine should be invoked for every declarator
194/// that is not a function declaration or definition.
195void Sema::CheckExtraCXXDefaultArguments(Declarator &D) {
196 // C++ [dcl.fct.default]p3
197 // A default argument expression shall be specified only in the
198 // parameter-declaration-clause of a function declaration or in a
199 // template-parameter (14.1). It shall not be specified for a
200 // parameter pack. If it is specified in a
201 // parameter-declaration-clause, it shall not occur within a
202 // declarator or abstract-declarator of a parameter-declaration.
Chris Lattnerb28317a2009-03-28 19:18:32 +0000203 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
Douglas Gregor6d6eb572008-05-07 04:49:29 +0000204 DeclaratorChunk &chunk = D.getTypeObject(i);
205 if (chunk.Kind == DeclaratorChunk::Function) {
Chris Lattnerb28317a2009-03-28 19:18:32 +0000206 for (unsigned argIdx = 0, e = chunk.Fun.NumArgs; argIdx != e; ++argIdx) {
207 ParmVarDecl *Param =
208 cast<ParmVarDecl>(chunk.Fun.ArgInfo[argIdx].Param.getAs<Decl>());
Douglas Gregor61366e92008-12-24 00:01:03 +0000209 if (Param->hasUnparsedDefaultArg()) {
210 CachedTokens *Toks = chunk.Fun.ArgInfo[argIdx].DefaultArgTokens;
Douglas Gregor72b505b2008-12-16 21:30:33 +0000211 Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
212 << SourceRange((*Toks)[1].getLocation(), Toks->back().getLocation());
213 delete Toks;
214 chunk.Fun.ArgInfo[argIdx].DefaultArgTokens = 0;
Douglas Gregor61366e92008-12-24 00:01:03 +0000215 } else if (Param->getDefaultArg()) {
216 Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
217 << Param->getDefaultArg()->getSourceRange();
218 Param->setDefaultArg(0);
Douglas Gregor6d6eb572008-05-07 04:49:29 +0000219 }
220 }
221 }
222 }
223}
224
Chris Lattner3d1cee32008-04-08 05:04:30 +0000225// MergeCXXFunctionDecl - Merge two declarations of the same C++
226// function, once we already know that they have the same
Douglas Gregorcda9c672009-02-16 17:45:42 +0000227// type. Subroutine of MergeFunctionDecl. Returns true if there was an
228// error, false otherwise.
229bool Sema::MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old) {
230 bool Invalid = false;
231
Chris Lattner3d1cee32008-04-08 05:04:30 +0000232 // C++ [dcl.fct.default]p4:
233 //
234 // For non-template functions, default arguments can be added in
235 // later declarations of a function in the same
236 // scope. Declarations in different scopes have completely
237 // distinct sets of default arguments. That is, declarations in
238 // inner scopes do not acquire default arguments from
239 // declarations in outer scopes, and vice versa. In a given
240 // function declaration, all parameters subsequent to a
241 // parameter with a default argument shall have default
242 // arguments supplied in this or previous declarations. A
243 // default argument shall not be redefined by a later
244 // declaration (not even to the same value).
245 for (unsigned p = 0, NumParams = Old->getNumParams(); p < NumParams; ++p) {
246 ParmVarDecl *OldParam = Old->getParamDecl(p);
247 ParmVarDecl *NewParam = New->getParamDecl(p);
248
249 if(OldParam->getDefaultArg() && NewParam->getDefaultArg()) {
250 Diag(NewParam->getLocation(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000251 diag::err_param_default_argument_redefinition)
252 << NewParam->getDefaultArg()->getSourceRange();
Chris Lattner5f4a6822008-11-23 23:12:31 +0000253 Diag(OldParam->getLocation(), diag::note_previous_definition);
Douglas Gregorcda9c672009-02-16 17:45:42 +0000254 Invalid = true;
Chris Lattner3d1cee32008-04-08 05:04:30 +0000255 } else if (OldParam->getDefaultArg()) {
256 // Merge the old default argument into the new parameter
257 NewParam->setDefaultArg(OldParam->getDefaultArg());
258 }
259 }
260
Sebastian Redl4994d2d2009-07-04 11:39:00 +0000261 if (CheckEquivalentExceptionSpec(
262 Old->getType()->getAsFunctionProtoType(), Old->getLocation(),
263 New->getType()->getAsFunctionProtoType(), New->getLocation())) {
264 Invalid = true;
265 }
266
Douglas Gregorcda9c672009-02-16 17:45:42 +0000267 return Invalid;
Chris Lattner3d1cee32008-04-08 05:04:30 +0000268}
269
270/// CheckCXXDefaultArguments - Verify that the default arguments for a
271/// function declaration are well-formed according to C++
272/// [dcl.fct.default].
273void Sema::CheckCXXDefaultArguments(FunctionDecl *FD) {
274 unsigned NumParams = FD->getNumParams();
275 unsigned p;
276
277 // Find first parameter with a default argument
278 for (p = 0; p < NumParams; ++p) {
279 ParmVarDecl *Param = FD->getParamDecl(p);
280 if (Param->getDefaultArg())
281 break;
282 }
283
284 // C++ [dcl.fct.default]p4:
285 // In a given function declaration, all parameters
286 // subsequent to a parameter with a default argument shall
287 // have default arguments supplied in this or previous
288 // declarations. A default argument shall not be redefined
289 // by a later declaration (not even to the same value).
290 unsigned LastMissingDefaultArg = 0;
291 for(; p < NumParams; ++p) {
292 ParmVarDecl *Param = FD->getParamDecl(p);
293 if (!Param->getDefaultArg()) {
Douglas Gregor72b505b2008-12-16 21:30:33 +0000294 if (Param->isInvalidDecl())
295 /* We already complained about this parameter. */;
296 else if (Param->getIdentifier())
Chris Lattner3d1cee32008-04-08 05:04:30 +0000297 Diag(Param->getLocation(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000298 diag::err_param_default_argument_missing_name)
Chris Lattner43b628c2008-11-19 07:32:16 +0000299 << Param->getIdentifier();
Chris Lattner3d1cee32008-04-08 05:04:30 +0000300 else
301 Diag(Param->getLocation(),
302 diag::err_param_default_argument_missing);
303
304 LastMissingDefaultArg = p;
305 }
306 }
307
308 if (LastMissingDefaultArg > 0) {
309 // Some default arguments were missing. Clear out all of the
310 // default arguments up to (and including) the last missing
311 // default argument, so that we leave the function parameters
312 // in a semantically valid state.
313 for (p = 0; p <= LastMissingDefaultArg; ++p) {
314 ParmVarDecl *Param = FD->getParamDecl(p);
Anders Carlsson5e300d12009-06-12 16:51:40 +0000315 if (Param->hasDefaultArg()) {
Douglas Gregor61366e92008-12-24 00:01:03 +0000316 if (!Param->hasUnparsedDefaultArg())
317 Param->getDefaultArg()->Destroy(Context);
Chris Lattner3d1cee32008-04-08 05:04:30 +0000318 Param->setDefaultArg(0);
319 }
320 }
321 }
322}
Douglas Gregore37ac4f2008-04-13 21:30:24 +0000323
Douglas Gregorb48fe382008-10-31 09:07:45 +0000324/// isCurrentClassName - Determine whether the identifier II is the
325/// name of the class type currently being defined. In the case of
326/// nested classes, this will only return true if II is the name of
327/// the innermost class.
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +0000328bool Sema::isCurrentClassName(const IdentifierInfo &II, Scope *,
329 const CXXScopeSpec *SS) {
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000330 CXXRecordDecl *CurDecl;
Douglas Gregore4e5b052009-03-19 00:18:19 +0000331 if (SS && SS->isSet() && !SS->isInvalid()) {
332 DeclContext *DC = computeDeclContext(*SS);
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000333 CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC);
334 } else
335 CurDecl = dyn_cast_or_null<CXXRecordDecl>(CurContext);
336
337 if (CurDecl)
Douglas Gregorb48fe382008-10-31 09:07:45 +0000338 return &II == CurDecl->getIdentifier();
339 else
340 return false;
341}
342
Douglas Gregor2943aed2009-03-03 04:44:36 +0000343/// \brief Check the validity of a C++ base class specifier.
344///
345/// \returns a new CXXBaseSpecifier if well-formed, emits diagnostics
346/// and returns NULL otherwise.
347CXXBaseSpecifier *
348Sema::CheckBaseSpecifier(CXXRecordDecl *Class,
349 SourceRange SpecifierRange,
350 bool Virtual, AccessSpecifier Access,
351 QualType BaseType,
352 SourceLocation BaseLoc) {
353 // C++ [class.union]p1:
354 // A union shall not have base classes.
355 if (Class->isUnion()) {
356 Diag(Class->getLocation(), diag::err_base_clause_on_union)
357 << SpecifierRange;
358 return 0;
359 }
360
361 if (BaseType->isDependentType())
362 return new CXXBaseSpecifier(SpecifierRange, Virtual,
363 Class->getTagKind() == RecordDecl::TK_class,
364 Access, BaseType);
365
366 // Base specifiers must be record types.
367 if (!BaseType->isRecordType()) {
368 Diag(BaseLoc, diag::err_base_must_be_class) << SpecifierRange;
369 return 0;
370 }
371
372 // C++ [class.union]p1:
373 // A union shall not be used as a base class.
374 if (BaseType->isUnionType()) {
375 Diag(BaseLoc, diag::err_union_as_base_class) << SpecifierRange;
376 return 0;
377 }
378
379 // C++ [class.derived]p2:
380 // The class-name in a base-specifier shall not be an incompletely
381 // defined class.
Douglas Gregor86447ec2009-03-09 16:13:40 +0000382 if (RequireCompleteType(BaseLoc, BaseType, diag::err_incomplete_base_class,
Douglas Gregor26dce442009-03-10 00:06:19 +0000383 SpecifierRange))
Douglas Gregor2943aed2009-03-03 04:44:36 +0000384 return 0;
385
386 // If the base class is polymorphic, the new one is, too.
Ted Kremenek35366a62009-07-17 17:50:17 +0000387 RecordDecl *BaseDecl = BaseType->getAsRecordType()->getDecl();
Douglas Gregor2943aed2009-03-03 04:44:36 +0000388 assert(BaseDecl && "Record type has no declaration");
389 BaseDecl = BaseDecl->getDefinition(Context);
390 assert(BaseDecl && "Base type is not incomplete, but has no definition");
391 if (cast<CXXRecordDecl>(BaseDecl)->isPolymorphic())
392 Class->setPolymorphic(true);
393
394 // C++ [dcl.init.aggr]p1:
395 // An aggregate is [...] a class with [...] no base classes [...].
396 Class->setAggregate(false);
397 Class->setPOD(false);
398
Anders Carlsson347ba892009-04-16 00:08:20 +0000399 if (Virtual) {
400 // C++ [class.ctor]p5:
401 // A constructor is trivial if its class has no virtual base classes.
402 Class->setHasTrivialConstructor(false);
403 } else {
404 // C++ [class.ctor]p5:
405 // A constructor is trivial if all the direct base classes of its
406 // class have trivial constructors.
407 Class->setHasTrivialConstructor(cast<CXXRecordDecl>(BaseDecl)->
408 hasTrivialConstructor());
409 }
Anders Carlsson072abef2009-04-17 02:34:54 +0000410
411 // C++ [class.ctor]p3:
412 // A destructor is trivial if all the direct base classes of its class
413 // have trivial destructors.
414 Class->setHasTrivialDestructor(cast<CXXRecordDecl>(BaseDecl)->
415 hasTrivialDestructor());
Anders Carlsson347ba892009-04-16 00:08:20 +0000416
Douglas Gregor2943aed2009-03-03 04:44:36 +0000417 // Create the base specifier.
418 // FIXME: Allocate via ASTContext?
419 return new CXXBaseSpecifier(SpecifierRange, Virtual,
420 Class->getTagKind() == RecordDecl::TK_class,
421 Access, BaseType);
422}
423
Douglas Gregore37ac4f2008-04-13 21:30:24 +0000424/// ActOnBaseSpecifier - Parsed a base specifier. A base specifier is
425/// one entry in the base class list of a class specifier, for
426/// example:
427/// class foo : public bar, virtual private baz {
428/// 'public bar' and 'virtual private baz' are each base-specifiers.
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000429Sema::BaseResult
Chris Lattnerb28317a2009-03-28 19:18:32 +0000430Sema::ActOnBaseSpecifier(DeclPtrTy classdecl, SourceRange SpecifierRange,
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000431 bool Virtual, AccessSpecifier Access,
432 TypeTy *basetype, SourceLocation BaseLoc) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +0000433 if (!classdecl)
434 return true;
435
Douglas Gregor40808ce2009-03-09 23:48:35 +0000436 AdjustDeclIfTemplate(classdecl);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000437 CXXRecordDecl *Class = cast<CXXRecordDecl>(classdecl.getAs<Decl>());
Douglas Gregor1a51b4a2009-02-09 15:09:02 +0000438 QualType BaseType = QualType::getFromOpaquePtr(basetype);
Douglas Gregor2943aed2009-03-03 04:44:36 +0000439 if (CXXBaseSpecifier *BaseSpec = CheckBaseSpecifier(Class, SpecifierRange,
440 Virtual, Access,
441 BaseType, BaseLoc))
442 return BaseSpec;
443
444 return true;
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000445}
Douglas Gregore37ac4f2008-04-13 21:30:24 +0000446
Douglas Gregor2943aed2009-03-03 04:44:36 +0000447/// \brief Performs the actual work of attaching the given base class
448/// specifiers to a C++ class.
449bool Sema::AttachBaseSpecifiers(CXXRecordDecl *Class, CXXBaseSpecifier **Bases,
450 unsigned NumBases) {
451 if (NumBases == 0)
452 return false;
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000453
454 // Used to keep track of which base types we have already seen, so
455 // that we can properly diagnose redundant direct base types. Note
Douglas Gregor57c856b2008-10-23 18:13:27 +0000456 // that the key is always the unqualified canonical type of the base
457 // class.
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000458 std::map<QualType, CXXBaseSpecifier*, QualTypeOrdering> KnownBaseTypes;
459
460 // Copy non-redundant base specifiers into permanent storage.
Douglas Gregor57c856b2008-10-23 18:13:27 +0000461 unsigned NumGoodBases = 0;
Douglas Gregor2943aed2009-03-03 04:44:36 +0000462 bool Invalid = false;
Douglas Gregor57c856b2008-10-23 18:13:27 +0000463 for (unsigned idx = 0; idx < NumBases; ++idx) {
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000464 QualType NewBaseType
Douglas Gregor2943aed2009-03-03 04:44:36 +0000465 = Context.getCanonicalType(Bases[idx]->getType());
Douglas Gregor57c856b2008-10-23 18:13:27 +0000466 NewBaseType = NewBaseType.getUnqualifiedType();
467
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000468 if (KnownBaseTypes[NewBaseType]) {
469 // C++ [class.mi]p3:
470 // A class shall not be specified as a direct base class of a
471 // derived class more than once.
Douglas Gregor2943aed2009-03-03 04:44:36 +0000472 Diag(Bases[idx]->getSourceRange().getBegin(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000473 diag::err_duplicate_base_class)
Chris Lattnerd1625842008-11-24 06:25:27 +0000474 << KnownBaseTypes[NewBaseType]->getType()
Douglas Gregor2943aed2009-03-03 04:44:36 +0000475 << Bases[idx]->getSourceRange();
Douglas Gregor57c856b2008-10-23 18:13:27 +0000476
477 // Delete the duplicate base class specifier; we're going to
478 // overwrite its pointer later.
Douglas Gregor2943aed2009-03-03 04:44:36 +0000479 delete Bases[idx];
480
481 Invalid = true;
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000482 } else {
483 // Okay, add this new base class.
Douglas Gregor2943aed2009-03-03 04:44:36 +0000484 KnownBaseTypes[NewBaseType] = Bases[idx];
485 Bases[NumGoodBases++] = Bases[idx];
Douglas Gregorf8268ae2008-10-22 17:49:05 +0000486 }
487 }
488
489 // Attach the remaining base class specifiers to the derived class.
Fariborz Jahanian5ffcd7b2009-07-02 18:26:15 +0000490 Class->setBases(Context, Bases, NumGoodBases);
Douglas Gregor57c856b2008-10-23 18:13:27 +0000491
492 // Delete the remaining (good) base class specifiers, since their
493 // data has been copied into the CXXRecordDecl.
494 for (unsigned idx = 0; idx < NumGoodBases; ++idx)
Douglas Gregor2943aed2009-03-03 04:44:36 +0000495 delete Bases[idx];
496
497 return Invalid;
498}
499
500/// ActOnBaseSpecifiers - Attach the given base specifiers to the
501/// class, after checking whether there are any duplicate base
502/// classes.
Chris Lattnerb28317a2009-03-28 19:18:32 +0000503void Sema::ActOnBaseSpecifiers(DeclPtrTy ClassDecl, BaseTy **Bases,
Douglas Gregor2943aed2009-03-03 04:44:36 +0000504 unsigned NumBases) {
505 if (!ClassDecl || !Bases || !NumBases)
506 return;
507
508 AdjustDeclIfTemplate(ClassDecl);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000509 AttachBaseSpecifiers(cast<CXXRecordDecl>(ClassDecl.getAs<Decl>()),
Douglas Gregor2943aed2009-03-03 04:44:36 +0000510 (CXXBaseSpecifier**)(Bases), NumBases);
Douglas Gregore37ac4f2008-04-13 21:30:24 +0000511}
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +0000512
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000513//===----------------------------------------------------------------------===//
514// C++ class member Handling
515//===----------------------------------------------------------------------===//
516
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000517/// ActOnCXXMemberDeclarator - This is invoked when a C++ class member
518/// declarator is parsed. 'AS' is the access specifier, 'BW' specifies the
519/// bitfield width if there is one and 'InitExpr' specifies the initializer if
Chris Lattnerb6688e02009-04-12 22:37:57 +0000520/// any.
Chris Lattnerb28317a2009-03-28 19:18:32 +0000521Sema::DeclPtrTy
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000522Sema::ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS, Declarator &D,
Sebastian Redle2b68332009-04-12 17:16:29 +0000523 ExprTy *BW, ExprTy *InitExpr, bool Deleted) {
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000524 const DeclSpec &DS = D.getDeclSpec();
Douglas Gregor10bd3682008-11-17 22:58:34 +0000525 DeclarationName Name = GetNameForDeclarator(D);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000526 Expr *BitWidth = static_cast<Expr*>(BW);
527 Expr *Init = static_cast<Expr*>(InitExpr);
528 SourceLocation Loc = D.getIdentifierLoc();
529
Sebastian Redl669d5d72008-11-14 23:42:31 +0000530 bool isFunc = D.isFunctionDeclarator();
531
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000532 // C++ 9.2p6: A member shall not be declared to have automatic storage
533 // duration (auto, register) or with the extern storage-class-specifier.
Sebastian Redl669d5d72008-11-14 23:42:31 +0000534 // C++ 7.1.1p8: The mutable specifier can be applied only to names of class
535 // data members and cannot be applied to names declared const or static,
536 // and cannot be applied to reference members.
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000537 switch (DS.getStorageClassSpec()) {
538 case DeclSpec::SCS_unspecified:
539 case DeclSpec::SCS_typedef:
540 case DeclSpec::SCS_static:
541 // FALL THROUGH.
542 break;
Sebastian Redl669d5d72008-11-14 23:42:31 +0000543 case DeclSpec::SCS_mutable:
544 if (isFunc) {
545 if (DS.getStorageClassSpecLoc().isValid())
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000546 Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_function);
Sebastian Redl669d5d72008-11-14 23:42:31 +0000547 else
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000548 Diag(DS.getThreadSpecLoc(), diag::err_mutable_function);
549
Sebastian Redla11f42f2008-11-17 23:24:37 +0000550 // FIXME: It would be nicer if the keyword was ignored only for this
551 // declarator. Otherwise we could get follow-up errors.
Sebastian Redl669d5d72008-11-14 23:42:31 +0000552 D.getMutableDeclSpec().ClearStorageClassSpecs();
553 } else {
554 QualType T = GetTypeForDeclarator(D, S);
555 diag::kind err = static_cast<diag::kind>(0);
556 if (T->isReferenceType())
557 err = diag::err_mutable_reference;
558 else if (T.isConstQualified())
559 err = diag::err_mutable_const;
560 if (err != 0) {
561 if (DS.getStorageClassSpecLoc().isValid())
562 Diag(DS.getStorageClassSpecLoc(), err);
563 else
564 Diag(DS.getThreadSpecLoc(), err);
Sebastian Redla11f42f2008-11-17 23:24:37 +0000565 // FIXME: It would be nicer if the keyword was ignored only for this
566 // declarator. Otherwise we could get follow-up errors.
Sebastian Redl669d5d72008-11-14 23:42:31 +0000567 D.getMutableDeclSpec().ClearStorageClassSpecs();
568 }
569 }
570 break;
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000571 default:
572 if (DS.getStorageClassSpecLoc().isValid())
573 Diag(DS.getStorageClassSpecLoc(),
574 diag::err_storageclass_invalid_for_member);
575 else
576 Diag(DS.getThreadSpecLoc(), diag::err_storageclass_invalid_for_member);
577 D.getMutableDeclSpec().ClearStorageClassSpecs();
578 }
579
Argyrios Kyrtzidisd6caa9e2008-10-15 20:23:22 +0000580 if (!isFunc &&
Douglas Gregor1a51b4a2009-02-09 15:09:02 +0000581 D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_typename &&
Argyrios Kyrtzidisd6caa9e2008-10-15 20:23:22 +0000582 D.getNumTypeObjects() == 0) {
Argyrios Kyrtzidisde933f02008-10-08 22:20:31 +0000583 // Check also for this case:
584 //
585 // typedef int f();
586 // f a;
587 //
Douglas Gregor1a51b4a2009-02-09 15:09:02 +0000588 QualType TDType = QualType::getFromOpaquePtr(DS.getTypeRep());
589 isFunc = TDType->isFunctionType();
Argyrios Kyrtzidisde933f02008-10-08 22:20:31 +0000590 }
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000591
Sebastian Redl669d5d72008-11-14 23:42:31 +0000592 bool isInstField = ((DS.getStorageClassSpec() == DeclSpec::SCS_unspecified ||
593 DS.getStorageClassSpec() == DeclSpec::SCS_mutable) &&
Argyrios Kyrtzidisde933f02008-10-08 22:20:31 +0000594 !isFunc);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000595
596 Decl *Member;
Chris Lattner24793662009-03-05 22:45:59 +0000597 if (isInstField) {
Douglas Gregor4dd55f52009-03-11 20:50:30 +0000598 Member = HandleField(S, cast<CXXRecordDecl>(CurContext), Loc, D, BitWidth,
599 AS);
Chris Lattner6f8ce142009-03-05 23:03:49 +0000600 assert(Member && "HandleField never returns null");
Chris Lattner24793662009-03-05 22:45:59 +0000601 } else {
Chris Lattner682bf922009-03-29 16:50:03 +0000602 Member = ActOnDeclarator(S, D).getAs<Decl>();
Chris Lattner6f8ce142009-03-05 23:03:49 +0000603 if (!Member) {
604 if (BitWidth) DeleteExpr(BitWidth);
Chris Lattner682bf922009-03-29 16:50:03 +0000605 return DeclPtrTy();
Chris Lattner6f8ce142009-03-05 23:03:49 +0000606 }
Chris Lattner8b963ef2009-03-05 23:01:03 +0000607
608 // Non-instance-fields can't have a bitfield.
609 if (BitWidth) {
610 if (Member->isInvalidDecl()) {
611 // don't emit another diagnostic.
Douglas Gregor2d2e9cf2009-03-11 20:22:50 +0000612 } else if (isa<VarDecl>(Member)) {
Chris Lattner8b963ef2009-03-05 23:01:03 +0000613 // C++ 9.6p3: A bit-field shall not be a static member.
614 // "static member 'A' cannot be a bit-field"
615 Diag(Loc, diag::err_static_not_bitfield)
616 << Name << BitWidth->getSourceRange();
617 } else if (isa<TypedefDecl>(Member)) {
618 // "typedef member 'x' cannot be a bit-field"
619 Diag(Loc, diag::err_typedef_not_bitfield)
620 << Name << BitWidth->getSourceRange();
621 } else {
622 // A function typedef ("typedef int f(); f a;").
623 // C++ 9.6p3: A bit-field shall have integral or enumeration type.
624 Diag(Loc, diag::err_not_integral_type_bitfield)
Douglas Gregor3cf538d2009-03-11 18:59:21 +0000625 << Name << cast<ValueDecl>(Member)->getType()
626 << BitWidth->getSourceRange();
Chris Lattner8b963ef2009-03-05 23:01:03 +0000627 }
628
629 DeleteExpr(BitWidth);
630 BitWidth = 0;
631 Member->setInvalidDecl();
632 }
Douglas Gregor4dd55f52009-03-11 20:50:30 +0000633
634 Member->setAccess(AS);
Chris Lattner24793662009-03-05 22:45:59 +0000635 }
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000636
Douglas Gregor10bd3682008-11-17 22:58:34 +0000637 assert((Name || isInstField) && "No identifier for non-field ?");
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000638
Douglas Gregor021c3b32009-03-11 23:00:04 +0000639 if (Init)
Chris Lattnerb28317a2009-03-28 19:18:32 +0000640 AddInitializerToDecl(DeclPtrTy::make(Member), ExprArg(*this, Init), false);
Sebastian Redle2b68332009-04-12 17:16:29 +0000641 if (Deleted) // FIXME: Source location is not very good.
642 SetDeclDeleted(DeclPtrTy::make(Member), D.getSourceRange().getBegin());
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000643
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000644 if (isInstField) {
Douglas Gregor44b43212008-12-11 16:49:14 +0000645 FieldCollector->Add(cast<FieldDecl>(Member));
Chris Lattner682bf922009-03-29 16:50:03 +0000646 return DeclPtrTy();
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000647 }
Chris Lattnerb28317a2009-03-28 19:18:32 +0000648 return DeclPtrTy::make(Member);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000649}
650
Douglas Gregor7ad83902008-11-05 04:29:56 +0000651/// ActOnMemInitializer - Handle a C++ member initializer.
652Sema::MemInitResult
Chris Lattnerb28317a2009-03-28 19:18:32 +0000653Sema::ActOnMemInitializer(DeclPtrTy ConstructorD,
Douglas Gregor7ad83902008-11-05 04:29:56 +0000654 Scope *S,
Fariborz Jahanianbcfad542009-06-30 23:26:25 +0000655 const CXXScopeSpec &SS,
Douglas Gregor7ad83902008-11-05 04:29:56 +0000656 IdentifierInfo *MemberOrBase,
Fariborz Jahanian96174332009-07-01 19:21:19 +0000657 TypeTy *TemplateTypeTy,
Douglas Gregor7ad83902008-11-05 04:29:56 +0000658 SourceLocation IdLoc,
659 SourceLocation LParenLoc,
660 ExprTy **Args, unsigned NumArgs,
661 SourceLocation *CommaLocs,
662 SourceLocation RParenLoc) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +0000663 if (!ConstructorD)
664 return true;
665
Douglas Gregor7ad83902008-11-05 04:29:56 +0000666 CXXConstructorDecl *Constructor
Chris Lattnerb28317a2009-03-28 19:18:32 +0000667 = dyn_cast<CXXConstructorDecl>(ConstructorD.getAs<Decl>());
Douglas Gregor7ad83902008-11-05 04:29:56 +0000668 if (!Constructor) {
669 // The user wrote a constructor initializer on a function that is
670 // not a C++ constructor. Ignore the error for now, because we may
671 // have more member initializers coming; we'll diagnose it just
672 // once in ActOnMemInitializers.
673 return true;
674 }
675
676 CXXRecordDecl *ClassDecl = Constructor->getParent();
677
678 // C++ [class.base.init]p2:
679 // Names in a mem-initializer-id are looked up in the scope of the
680 // constructor’s class and, if not found in that scope, are looked
681 // up in the scope containing the constructor’s
682 // definition. [Note: if the constructor’s class contains a member
683 // with the same name as a direct or virtual base class of the
684 // class, a mem-initializer-id naming the member or base class and
685 // composed of a single identifier refers to the class member. A
686 // mem-initializer-id for the hidden base class may be specified
687 // using a qualified name. ]
Fariborz Jahanian96174332009-07-01 19:21:19 +0000688 if (!SS.getScopeRep() && !TemplateTypeTy) {
Fariborz Jahanianbcfad542009-06-30 23:26:25 +0000689 // Look for a member, first.
690 FieldDecl *Member = 0;
691 DeclContext::lookup_result Result
692 = ClassDecl->lookup(MemberOrBase);
693 if (Result.first != Result.second)
694 Member = dyn_cast<FieldDecl>(*Result.first);
Douglas Gregor7ad83902008-11-05 04:29:56 +0000695
Fariborz Jahanianbcfad542009-06-30 23:26:25 +0000696 // FIXME: Handle members of an anonymous union.
Douglas Gregor7ad83902008-11-05 04:29:56 +0000697
Fariborz Jahanianbcfad542009-06-30 23:26:25 +0000698 if (Member) {
699 // FIXME: Perform direct initialization of the member.
700 return new CXXBaseOrMemberInitializer(Member, (Expr **)Args, NumArgs,
701 IdLoc);
702 }
Douglas Gregor7ad83902008-11-05 04:29:56 +0000703 }
Douglas Gregor7ad83902008-11-05 04:29:56 +0000704 // It didn't name a member, so see if it names a class.
Fariborz Jahanian96174332009-07-01 19:21:19 +0000705 TypeTy *BaseTy = TemplateTypeTy ? TemplateTypeTy
706 : getTypeName(*MemberOrBase, IdLoc, S, &SS);
Douglas Gregor7ad83902008-11-05 04:29:56 +0000707 if (!BaseTy)
Chris Lattner3c73c412008-11-19 08:23:25 +0000708 return Diag(IdLoc, diag::err_mem_init_not_member_or_class)
709 << MemberOrBase << SourceRange(IdLoc, RParenLoc);
Douglas Gregor7ad83902008-11-05 04:29:56 +0000710
Douglas Gregor1a51b4a2009-02-09 15:09:02 +0000711 QualType BaseType = QualType::getFromOpaquePtr(BaseTy);
Fariborz Jahanian96174332009-07-01 19:21:19 +0000712 if (!BaseType->isRecordType() && !BaseType->isDependentType())
Chris Lattner3c73c412008-11-19 08:23:25 +0000713 return Diag(IdLoc, diag::err_base_init_does_not_name_class)
Chris Lattner08631c52008-11-23 21:45:46 +0000714 << BaseType << SourceRange(IdLoc, RParenLoc);
Douglas Gregor7ad83902008-11-05 04:29:56 +0000715
716 // C++ [class.base.init]p2:
717 // [...] Unless the mem-initializer-id names a nonstatic data
718 // member of the constructor’s class or a direct or virtual base
719 // of that class, the mem-initializer is ill-formed. A
720 // mem-initializer-list can initialize a base class using any
721 // name that denotes that base class type.
722
723 // First, check for a direct base class.
724 const CXXBaseSpecifier *DirectBaseSpec = 0;
725 for (CXXRecordDecl::base_class_const_iterator Base = ClassDecl->bases_begin();
726 Base != ClassDecl->bases_end(); ++Base) {
727 if (Context.getCanonicalType(BaseType).getUnqualifiedType() ==
728 Context.getCanonicalType(Base->getType()).getUnqualifiedType()) {
729 // We found a direct base of this type. That's what we're
730 // initializing.
731 DirectBaseSpec = &*Base;
732 break;
733 }
734 }
735
736 // Check for a virtual base class.
Mike Stump390b4cc2009-05-16 07:39:55 +0000737 // FIXME: We might be able to short-circuit this if we know in advance that
738 // there are no virtual bases.
Douglas Gregor7ad83902008-11-05 04:29:56 +0000739 const CXXBaseSpecifier *VirtualBaseSpec = 0;
740 if (!DirectBaseSpec || !DirectBaseSpec->isVirtual()) {
741 // We haven't found a base yet; search the class hierarchy for a
742 // virtual base class.
743 BasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
744 /*DetectVirtual=*/false);
745 if (IsDerivedFrom(Context.getTypeDeclType(ClassDecl), BaseType, Paths)) {
746 for (BasePaths::paths_iterator Path = Paths.begin();
747 Path != Paths.end(); ++Path) {
748 if (Path->back().Base->isVirtual()) {
749 VirtualBaseSpec = Path->back().Base;
750 break;
751 }
752 }
753 }
754 }
755
756 // C++ [base.class.init]p2:
757 // If a mem-initializer-id is ambiguous because it designates both
758 // a direct non-virtual base class and an inherited virtual base
759 // class, the mem-initializer is ill-formed.
760 if (DirectBaseSpec && VirtualBaseSpec)
Chris Lattner3c73c412008-11-19 08:23:25 +0000761 return Diag(IdLoc, diag::err_base_init_direct_and_virtual)
762 << MemberOrBase << SourceRange(IdLoc, RParenLoc);
Fariborz Jahanian9da72012009-06-30 17:34:52 +0000763 // C++ [base.class.init]p2:
764 // Unless the mem-initializer-id names a nonstatic data membeer of the
765 // constructor's class ot a direst or virtual base of that class, the
766 // mem-initializer is ill-formed.
767 if (!DirectBaseSpec && !VirtualBaseSpec)
768 return Diag(IdLoc, diag::err_not_direct_base_or_virtual)
769 << BaseType << ClassDecl->getNameAsCString()
770 << SourceRange(IdLoc, RParenLoc);
771
Douglas Gregor7ad83902008-11-05 04:29:56 +0000772
Fariborz Jahanian47deacf2009-06-30 00:02:17 +0000773 return new CXXBaseOrMemberInitializer(BaseType, (Expr **)Args, NumArgs,
774 IdLoc);
Douglas Gregor7ad83902008-11-05 04:29:56 +0000775}
776
Eli Friedman6347f422009-07-21 19:28:10 +0000777static void *GetKeyForTopLevelField(FieldDecl *Field) {
778 // For anonymous unions, use the class declaration as the key.
779 if (const RecordType *RT = Field->getType()->getAsRecordType()) {
780 if (RT->getDecl()->isAnonymousStructOrUnion())
781 return static_cast<void *>(RT->getDecl());
782 }
783 return static_cast<void *>(Field);
784}
785
786static void *GetKeyForMember(CXXBaseOrMemberInitializer *Member) {
787 // For fields injected into the class via declaration of an anonymous union,
788 // use its anonymous union class declaration as the unique key.
789 if (FieldDecl *Field = Member->getMember()) {
790 if (Field->getDeclContext()->isRecord()) {
791 RecordDecl *RD = cast<RecordDecl>(Field->getDeclContext());
792 if (RD->isAnonymousStructOrUnion())
793 return static_cast<void *>(RD);
794 }
795 return static_cast<void *>(Field);
796 }
797 return static_cast<RecordType *>(Member->getBaseClass());
798}
799
Chris Lattnerb28317a2009-03-28 19:18:32 +0000800void Sema::ActOnMemInitializers(DeclPtrTy ConstructorDecl,
Anders Carlssona7b35212009-03-25 02:58:17 +0000801 SourceLocation ColonLoc,
802 MemInitTy **MemInits, unsigned NumMemInits) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +0000803 if (!ConstructorDecl)
804 return;
805
806 CXXConstructorDecl *Constructor
807 = dyn_cast<CXXConstructorDecl>(ConstructorDecl.getAs<Decl>());
Anders Carlssona7b35212009-03-25 02:58:17 +0000808
809 if (!Constructor) {
810 Diag(ColonLoc, diag::err_only_constructors_take_base_inits);
811 return;
812 }
Fariborz Jahanian16dbdce2009-06-30 00:17:27 +0000813 llvm::DenseMap<void*, CXXBaseOrMemberInitializer *>Members;
Fariborz Jahanian73b85f32009-07-01 23:35:25 +0000814 bool err = false;
Fariborz Jahanian7881a052009-06-29 22:33:26 +0000815 for (unsigned i = 0; i < NumMemInits; i++) {
816 CXXBaseOrMemberInitializer *Member =
817 static_cast<CXXBaseOrMemberInitializer*>(MemInits[i]);
Eli Friedman6347f422009-07-21 19:28:10 +0000818 void *KeyToMember = GetKeyForMember(Member);
Fariborz Jahanian5ac3dfc2009-06-30 21:52:59 +0000819 CXXBaseOrMemberInitializer *&PrevMember = Members[KeyToMember];
Fariborz Jahanian16dbdce2009-06-30 00:17:27 +0000820 if (!PrevMember) {
Fariborz Jahanian47deacf2009-06-30 00:02:17 +0000821 PrevMember = Member;
Fariborz Jahanian16dbdce2009-06-30 00:17:27 +0000822 continue;
Fariborz Jahanian7881a052009-06-29 22:33:26 +0000823 }
Fariborz Jahanian16dbdce2009-06-30 00:17:27 +0000824 if (FieldDecl *Field = Member->getMember())
825 Diag(Member->getSourceLocation(),
826 diag::error_multiple_mem_initialization)
827 << Field->getNameAsString();
828 else {
829 Type *BaseClass = Member->getBaseClass();
830 assert(BaseClass && "ActOnMemInitializers - neither field or base");
831 Diag(Member->getSourceLocation(),
832 diag::error_multiple_base_initialization)
833 << BaseClass->getDesugaredType(true);
834 }
835 Diag(PrevMember->getSourceLocation(), diag::note_previous_initializer)
836 << 0;
Fariborz Jahanian73b85f32009-07-01 23:35:25 +0000837 err = true;
Fariborz Jahanian7881a052009-06-29 22:33:26 +0000838 }
Fariborz Jahanianeb96e122009-07-09 19:59:47 +0000839 if (!err) {
Fariborz Jahanian73b85f32009-07-01 23:35:25 +0000840 Constructor->setBaseOrMemberInitializers(Context,
841 reinterpret_cast<CXXBaseOrMemberInitializer **>(MemInits),
842 NumMemInits);
Eli Friedman6347f422009-07-21 19:28:10 +0000843 }
844 if (!err && (Diags.getDiagnosticLevel(diag::warn_base_initialized)
845 != Diagnostic::Ignored ||
846 Diags.getDiagnosticLevel(diag::warn_field_initialized)
847 != Diagnostic::Ignored)) {
Fariborz Jahanianeb96e122009-07-09 19:59:47 +0000848 // Also issue warning if order of ctor-initializer list does not match order
849 // of 1) base class declarations and 2) order of non-static data members.
Fariborz Jahanianeb96e122009-07-09 19:59:47 +0000850 llvm::SmallVector<const void*, 32> AllBaseOrMembers;
851
852 CXXRecordDecl *ClassDecl
853 = cast<CXXRecordDecl>(Constructor->getDeclContext());
Fariborz Jahanian40c072f2009-07-10 20:13:23 +0000854 // Push virtual bases before others.
855 for (CXXRecordDecl::base_class_iterator VBase =
856 ClassDecl->vbases_begin(),
857 E = ClassDecl->vbases_end(); VBase != E; ++VBase)
Ted Kremenek35366a62009-07-17 17:50:17 +0000858 AllBaseOrMembers.push_back(VBase->getType()->getAsRecordType());
Fariborz Jahanian40c072f2009-07-10 20:13:23 +0000859
Fariborz Jahanianeb96e122009-07-09 19:59:47 +0000860 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
Fariborz Jahanian40c072f2009-07-10 20:13:23 +0000861 E = ClassDecl->bases_end(); Base != E; ++Base) {
862 // Virtuals are alread in the virtual base list and are constructed
863 // first.
864 if (Base->isVirtual())
865 continue;
Ted Kremenek35366a62009-07-17 17:50:17 +0000866 AllBaseOrMembers.push_back(Base->getType()->getAsRecordType());
Fariborz Jahanian40c072f2009-07-10 20:13:23 +0000867 }
Fariborz Jahanianeb96e122009-07-09 19:59:47 +0000868
869 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
870 E = ClassDecl->field_end(); Field != E; ++Field)
Eli Friedman6347f422009-07-21 19:28:10 +0000871 AllBaseOrMembers.push_back(GetKeyForTopLevelField(*Field));
Fariborz Jahanianeb96e122009-07-09 19:59:47 +0000872
873 int Last = AllBaseOrMembers.size();
874 int curIndex = 0;
875 CXXBaseOrMemberInitializer *PrevMember = 0;
876 for (unsigned i = 0; i < NumMemInits; i++) {
877 CXXBaseOrMemberInitializer *Member =
878 static_cast<CXXBaseOrMemberInitializer*>(MemInits[i]);
Eli Friedman6347f422009-07-21 19:28:10 +0000879 void *MemberInCtorList = GetKeyForMember(Member);
880
881 for (; curIndex < Last; curIndex++)
882 if (MemberInCtorList == AllBaseOrMembers[curIndex])
Fariborz Jahanianeb96e122009-07-09 19:59:47 +0000883 break;
Eli Friedman6347f422009-07-21 19:28:10 +0000884 if (curIndex == Last) {
885 assert(PrevMember && "Member not in member list?!");
Fariborz Jahanianeb96e122009-07-09 19:59:47 +0000886 // Initializer as specified in ctor-initializer list is out of order.
887 // Issue a warning diagnostic.
888 if (PrevMember->isBaseInitializer()) {
889 // Diagnostics is for an initialized base class.
890 Type *BaseClass = PrevMember->getBaseClass();
891 Diag(PrevMember->getSourceLocation(),
892 diag::warn_base_initialized)
893 << BaseClass->getDesugaredType(true);
894 }
895 else {
896 FieldDecl *Field = PrevMember->getMember();
897 Diag(PrevMember->getSourceLocation(),
898 diag::warn_field_initialized)
899 << Field->getNameAsString();
900 }
901 // Also the note!
902 if (FieldDecl *Field = Member->getMember())
903 Diag(Member->getSourceLocation(),
904 diag::note_fieldorbase_initialized_here) << 0
905 << Field->getNameAsString();
906 else {
907 Type *BaseClass = Member->getBaseClass();
908 Diag(Member->getSourceLocation(),
909 diag::note_fieldorbase_initialized_here) << 1
910 << BaseClass->getDesugaredType(true);
911 }
Eli Friedman6347f422009-07-21 19:28:10 +0000912 for (curIndex = 0; curIndex < Last; curIndex++)
913 if (MemberInCtorList == AllBaseOrMembers[curIndex])
914 break;
Fariborz Jahanianeb96e122009-07-09 19:59:47 +0000915 }
916 PrevMember = Member;
Fariborz Jahanianeb96e122009-07-09 19:59:47 +0000917 }
918 }
Anders Carlssona7b35212009-03-25 02:58:17 +0000919}
920
Fariborz Jahanian393612e2009-07-21 22:36:06 +0000921void Sema::ActOnDefaultCtorInitializers(DeclPtrTy CDtorDecl) {
Fariborz Jahanian560de452009-07-15 22:34:08 +0000922 if (!CDtorDecl)
Fariborz Jahaniand01c9152009-07-14 18:24:21 +0000923 return;
924
925 if (CXXConstructorDecl *Constructor
Fariborz Jahanian560de452009-07-15 22:34:08 +0000926 = dyn_cast<CXXConstructorDecl>(CDtorDecl.getAs<Decl>()))
Fariborz Jahaniand01c9152009-07-14 18:24:21 +0000927 Constructor->setBaseOrMemberInitializers(Context,
928 (CXXBaseOrMemberInitializer **)0, 0);
Fariborz Jahaniand01c9152009-07-14 18:24:21 +0000929}
930
Anders Carlsson67e4dd22009-03-22 01:52:17 +0000931namespace {
932 /// PureVirtualMethodCollector - traverses a class and its superclasses
933 /// and determines if it has any pure virtual methods.
934 class VISIBILITY_HIDDEN PureVirtualMethodCollector {
935 ASTContext &Context;
936
Sebastian Redldfe292d2009-03-22 21:28:55 +0000937 public:
Anders Carlsson67e4dd22009-03-22 01:52:17 +0000938 typedef llvm::SmallVector<const CXXMethodDecl*, 8> MethodList;
Sebastian Redldfe292d2009-03-22 21:28:55 +0000939
940 private:
Anders Carlsson67e4dd22009-03-22 01:52:17 +0000941 MethodList Methods;
942
943 void Collect(const CXXRecordDecl* RD, MethodList& Methods);
944
945 public:
946 PureVirtualMethodCollector(ASTContext &Ctx, const CXXRecordDecl* RD)
947 : Context(Ctx) {
948
949 MethodList List;
950 Collect(RD, List);
951
952 // Copy the temporary list to methods, and make sure to ignore any
953 // null entries.
954 for (size_t i = 0, e = List.size(); i != e; ++i) {
955 if (List[i])
956 Methods.push_back(List[i]);
957 }
958 }
959
Anders Carlsson4681ebd2009-03-22 20:18:17 +0000960 bool empty() const { return Methods.empty(); }
961
962 MethodList::const_iterator methods_begin() { return Methods.begin(); }
963 MethodList::const_iterator methods_end() { return Methods.end(); }
Anders Carlsson67e4dd22009-03-22 01:52:17 +0000964 };
965
966 void PureVirtualMethodCollector::Collect(const CXXRecordDecl* RD,
967 MethodList& Methods) {
968 // First, collect the pure virtual methods for the base classes.
969 for (CXXRecordDecl::base_class_const_iterator Base = RD->bases_begin(),
970 BaseEnd = RD->bases_end(); Base != BaseEnd; ++Base) {
Ted Kremenek35366a62009-07-17 17:50:17 +0000971 if (const RecordType *RT = Base->getType()->getAsRecordType()) {
Chris Lattner64540d72009-03-29 05:01:10 +0000972 const CXXRecordDecl *BaseDecl = cast<CXXRecordDecl>(RT->getDecl());
Anders Carlsson67e4dd22009-03-22 01:52:17 +0000973 if (BaseDecl && BaseDecl->isAbstract())
974 Collect(BaseDecl, Methods);
975 }
976 }
977
978 // Next, zero out any pure virtual methods that this class overrides.
Anders Carlsson8ff8c222009-05-17 00:00:05 +0000979 typedef llvm::SmallPtrSet<const CXXMethodDecl*, 4> MethodSetTy;
980
981 MethodSetTy OverriddenMethods;
982 size_t MethodsSize = Methods.size();
983
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000984 for (RecordDecl::decl_iterator i = RD->decls_begin(), e = RD->decls_end();
Anders Carlsson8ff8c222009-05-17 00:00:05 +0000985 i != e; ++i) {
986 // Traverse the record, looking for methods.
987 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(*i)) {
Sebastian Redl23c7d062009-07-07 20:29:57 +0000988 // If the method is pure virtual, add it to the methods vector.
Anders Carlsson8ff8c222009-05-17 00:00:05 +0000989 if (MD->isPure()) {
990 Methods.push_back(MD);
991 continue;
992 }
993
994 // Otherwise, record all the overridden methods in our set.
995 for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(),
996 E = MD->end_overridden_methods(); I != E; ++I) {
997 // Keep track of the overridden methods.
998 OverriddenMethods.insert(*I);
Anders Carlsson67e4dd22009-03-22 01:52:17 +0000999 }
1000 }
1001 }
1002
Anders Carlsson8ff8c222009-05-17 00:00:05 +00001003 // Now go through the methods and zero out all the ones we know are
1004 // overridden.
1005 for (size_t i = 0, e = MethodsSize; i != e; ++i) {
1006 if (OverriddenMethods.count(Methods[i]))
1007 Methods[i] = 0;
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001008 }
Anders Carlsson8ff8c222009-05-17 00:00:05 +00001009
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001010 }
1011}
Douglas Gregor7ad83902008-11-05 04:29:56 +00001012
Anders Carlsson4681ebd2009-03-22 20:18:17 +00001013bool Sema::RequireNonAbstractType(SourceLocation Loc, QualType T,
Anders Carlssone65a3c82009-03-24 17:23:42 +00001014 unsigned DiagID, AbstractDiagSelID SelID,
1015 const CXXRecordDecl *CurrentRD) {
Anders Carlsson4681ebd2009-03-22 20:18:17 +00001016
1017 if (!getLangOptions().CPlusPlus)
1018 return false;
Anders Carlsson11f21a02009-03-23 19:10:31 +00001019
1020 if (const ArrayType *AT = Context.getAsArrayType(T))
Anders Carlssone65a3c82009-03-24 17:23:42 +00001021 return RequireNonAbstractType(Loc, AT->getElementType(), DiagID, SelID,
1022 CurrentRD);
Anders Carlsson5eff73c2009-03-24 01:46:45 +00001023
Ted Kremenek35366a62009-07-17 17:50:17 +00001024 if (const PointerType *PT = T->getAsPointerType()) {
Anders Carlsson5eff73c2009-03-24 01:46:45 +00001025 // Find the innermost pointer type.
Ted Kremenek35366a62009-07-17 17:50:17 +00001026 while (const PointerType *T = PT->getPointeeType()->getAsPointerType())
Anders Carlsson5eff73c2009-03-24 01:46:45 +00001027 PT = T;
Anders Carlsson4681ebd2009-03-22 20:18:17 +00001028
Anders Carlsson5eff73c2009-03-24 01:46:45 +00001029 if (const ArrayType *AT = Context.getAsArrayType(PT->getPointeeType()))
Anders Carlssone65a3c82009-03-24 17:23:42 +00001030 return RequireNonAbstractType(Loc, AT->getElementType(), DiagID, SelID,
1031 CurrentRD);
Anders Carlsson5eff73c2009-03-24 01:46:45 +00001032 }
1033
Ted Kremenek35366a62009-07-17 17:50:17 +00001034 const RecordType *RT = T->getAsRecordType();
Anders Carlsson4681ebd2009-03-22 20:18:17 +00001035 if (!RT)
1036 return false;
1037
1038 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl());
1039 if (!RD)
1040 return false;
1041
Anders Carlssone65a3c82009-03-24 17:23:42 +00001042 if (CurrentRD && CurrentRD != RD)
1043 return false;
1044
Anders Carlsson4681ebd2009-03-22 20:18:17 +00001045 if (!RD->isAbstract())
1046 return false;
1047
Anders Carlssonb9bbe492009-03-23 17:49:10 +00001048 Diag(Loc, DiagID) << RD->getDeclName() << SelID;
Anders Carlsson4681ebd2009-03-22 20:18:17 +00001049
1050 // Check if we've already emitted the list of pure virtual functions for this
1051 // class.
1052 if (PureVirtualClassDiagSet && PureVirtualClassDiagSet->count(RD))
1053 return true;
1054
1055 PureVirtualMethodCollector Collector(Context, RD);
1056
1057 for (PureVirtualMethodCollector::MethodList::const_iterator I =
1058 Collector.methods_begin(), E = Collector.methods_end(); I != E; ++I) {
1059 const CXXMethodDecl *MD = *I;
1060
1061 Diag(MD->getLocation(), diag::note_pure_virtual_function) <<
1062 MD->getDeclName();
1063 }
1064
1065 if (!PureVirtualClassDiagSet)
1066 PureVirtualClassDiagSet.reset(new RecordDeclSetTy);
1067 PureVirtualClassDiagSet->insert(RD);
1068
1069 return true;
1070}
1071
Anders Carlsson8211eff2009-03-24 01:19:16 +00001072namespace {
1073 class VISIBILITY_HIDDEN AbstractClassUsageDiagnoser
1074 : public DeclVisitor<AbstractClassUsageDiagnoser, bool> {
1075 Sema &SemaRef;
1076 CXXRecordDecl *AbstractClass;
1077
Anders Carlssone65a3c82009-03-24 17:23:42 +00001078 bool VisitDeclContext(const DeclContext *DC) {
Anders Carlsson8211eff2009-03-24 01:19:16 +00001079 bool Invalid = false;
1080
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001081 for (CXXRecordDecl::decl_iterator I = DC->decls_begin(),
1082 E = DC->decls_end(); I != E; ++I)
Anders Carlsson8211eff2009-03-24 01:19:16 +00001083 Invalid |= Visit(*I);
Anders Carlssone65a3c82009-03-24 17:23:42 +00001084
Anders Carlsson8211eff2009-03-24 01:19:16 +00001085 return Invalid;
1086 }
Anders Carlssone65a3c82009-03-24 17:23:42 +00001087
1088 public:
1089 AbstractClassUsageDiagnoser(Sema& SemaRef, CXXRecordDecl *ac)
1090 : SemaRef(SemaRef), AbstractClass(ac) {
1091 Visit(SemaRef.Context.getTranslationUnitDecl());
1092 }
Anders Carlsson8211eff2009-03-24 01:19:16 +00001093
Anders Carlssone65a3c82009-03-24 17:23:42 +00001094 bool VisitFunctionDecl(const FunctionDecl *FD) {
1095 if (FD->isThisDeclarationADefinition()) {
1096 // No need to do the check if we're in a definition, because it requires
1097 // that the return/param types are complete.
1098 // because that requires
1099 return VisitDeclContext(FD);
1100 }
1101
1102 // Check the return type.
1103 QualType RTy = FD->getType()->getAsFunctionType()->getResultType();
1104 bool Invalid =
1105 SemaRef.RequireNonAbstractType(FD->getLocation(), RTy,
1106 diag::err_abstract_type_in_decl,
1107 Sema::AbstractReturnType,
1108 AbstractClass);
1109
1110 for (FunctionDecl::param_const_iterator I = FD->param_begin(),
1111 E = FD->param_end(); I != E; ++I) {
Anders Carlsson8211eff2009-03-24 01:19:16 +00001112 const ParmVarDecl *VD = *I;
1113 Invalid |=
1114 SemaRef.RequireNonAbstractType(VD->getLocation(),
1115 VD->getOriginalType(),
1116 diag::err_abstract_type_in_decl,
Anders Carlssone65a3c82009-03-24 17:23:42 +00001117 Sema::AbstractParamType,
1118 AbstractClass);
Anders Carlsson8211eff2009-03-24 01:19:16 +00001119 }
1120
1121 return Invalid;
1122 }
Anders Carlssone65a3c82009-03-24 17:23:42 +00001123
1124 bool VisitDecl(const Decl* D) {
1125 if (const DeclContext *DC = dyn_cast<DeclContext>(D))
1126 return VisitDeclContext(DC);
1127
1128 return false;
1129 }
Anders Carlsson8211eff2009-03-24 01:19:16 +00001130 };
1131}
1132
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001133void Sema::ActOnFinishCXXMemberSpecification(Scope* S, SourceLocation RLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001134 DeclPtrTy TagDecl,
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001135 SourceLocation LBrac,
1136 SourceLocation RBrac) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +00001137 if (!TagDecl)
1138 return;
1139
Douglas Gregor42af25f2009-05-11 19:58:34 +00001140 AdjustDeclIfTemplate(TagDecl);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001141 ActOnFields(S, RLoc, TagDecl,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001142 (DeclPtrTy*)FieldCollector->getCurFields(),
Daniel Dunbar1bfe1c22008-10-03 02:03:53 +00001143 FieldCollector->getCurNumFields(), LBrac, RBrac, 0);
Douglas Gregor2943aed2009-03-03 04:44:36 +00001144
Chris Lattnerb28317a2009-03-28 19:18:32 +00001145 CXXRecordDecl *RD = cast<CXXRecordDecl>(TagDecl.getAs<Decl>());
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001146 if (!RD->isAbstract()) {
1147 // Collect all the pure virtual methods and see if this is an abstract
1148 // class after all.
1149 PureVirtualMethodCollector Collector(Context, RD);
1150 if (!Collector.empty())
1151 RD->setAbstract(true);
1152 }
1153
Anders Carlssone65a3c82009-03-24 17:23:42 +00001154 if (RD->isAbstract())
1155 AbstractClassUsageDiagnoser(*this, RD);
Anders Carlsson8211eff2009-03-24 01:19:16 +00001156
Anders Carlsson072abef2009-04-17 02:34:54 +00001157 if (RD->hasTrivialConstructor() || RD->hasTrivialDestructor()) {
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001158 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
1159 i != e; ++i) {
Anders Carlsson347ba892009-04-16 00:08:20 +00001160 // All the nonstatic data members must have trivial constructors.
1161 QualType FTy = i->getType();
1162 while (const ArrayType *AT = Context.getAsArrayType(FTy))
1163 FTy = AT->getElementType();
1164
Ted Kremenek35366a62009-07-17 17:50:17 +00001165 if (const RecordType *RT = FTy->getAsRecordType()) {
Anders Carlsson347ba892009-04-16 00:08:20 +00001166 CXXRecordDecl *FieldRD = cast<CXXRecordDecl>(RT->getDecl());
Anders Carlsson072abef2009-04-17 02:34:54 +00001167
1168 if (!FieldRD->hasTrivialConstructor())
Anders Carlsson347ba892009-04-16 00:08:20 +00001169 RD->setHasTrivialConstructor(false);
Anders Carlsson072abef2009-04-17 02:34:54 +00001170 if (!FieldRD->hasTrivialDestructor())
1171 RD->setHasTrivialDestructor(false);
1172
1173 // If RD has neither a trivial constructor nor a trivial destructor
1174 // we don't need to continue checking.
1175 if (!RD->hasTrivialConstructor() && !RD->hasTrivialDestructor())
Anders Carlsson347ba892009-04-16 00:08:20 +00001176 break;
Anders Carlsson347ba892009-04-16 00:08:20 +00001177 }
1178 }
1179 }
1180
Douglas Gregor42af25f2009-05-11 19:58:34 +00001181 if (!RD->isDependentType())
Anders Carlsson67e4dd22009-03-22 01:52:17 +00001182 AddImplicitlyDeclaredMembersToClass(RD);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001183}
1184
Douglas Gregor396b7cd2008-11-03 17:51:48 +00001185/// AddImplicitlyDeclaredMembersToClass - Adds any implicitly-declared
1186/// special functions, such as the default constructor, copy
1187/// constructor, or destructor, to the given C++ class (C++
1188/// [special]p1). This routine can only be executed just before the
1189/// definition of the class is complete.
1190void Sema::AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl) {
Douglas Gregor2e1cd422008-11-17 14:58:09 +00001191 QualType ClassType = Context.getTypeDeclType(ClassDecl);
1192 ClassType = Context.getCanonicalType(ClassType);
1193
Sebastian Redl465226e2009-05-27 22:11:52 +00001194 // FIXME: Implicit declarations have exception specifications, which are
1195 // the union of the specifications of the implicitly called functions.
1196
Douglas Gregor396b7cd2008-11-03 17:51:48 +00001197 if (!ClassDecl->hasUserDeclaredConstructor()) {
1198 // C++ [class.ctor]p5:
1199 // A default constructor for a class X is a constructor of class X
1200 // that can be called without an argument. If there is no
1201 // user-declared constructor for class X, a default constructor is
1202 // implicitly declared. An implicitly-declared default constructor
1203 // is an inline public member of its class.
Douglas Gregor2e1cd422008-11-17 14:58:09 +00001204 DeclarationName Name
1205 = Context.DeclarationNames.getCXXConstructorName(ClassType);
Douglas Gregor396b7cd2008-11-03 17:51:48 +00001206 CXXConstructorDecl *DefaultCon =
1207 CXXConstructorDecl::Create(Context, ClassDecl,
Douglas Gregor2e1cd422008-11-17 14:58:09 +00001208 ClassDecl->getLocation(), Name,
Douglas Gregor396b7cd2008-11-03 17:51:48 +00001209 Context.getFunctionType(Context.VoidTy,
1210 0, 0, false, 0),
1211 /*isExplicit=*/false,
1212 /*isInline=*/true,
1213 /*isImplicitlyDeclared=*/true);
1214 DefaultCon->setAccess(AS_public);
Douglas Gregor6b3945f2009-01-07 19:46:03 +00001215 DefaultCon->setImplicit();
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001216 ClassDecl->addDecl(DefaultCon);
Douglas Gregor396b7cd2008-11-03 17:51:48 +00001217 }
1218
1219 if (!ClassDecl->hasUserDeclaredCopyConstructor()) {
1220 // C++ [class.copy]p4:
1221 // If the class definition does not explicitly declare a copy
1222 // constructor, one is declared implicitly.
1223
1224 // C++ [class.copy]p5:
1225 // The implicitly-declared copy constructor for a class X will
1226 // have the form
1227 //
1228 // X::X(const X&)
1229 //
1230 // if
1231 bool HasConstCopyConstructor = true;
1232
1233 // -- each direct or virtual base class B of X has a copy
1234 // constructor whose first parameter is of type const B& or
1235 // const volatile B&, and
1236 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin();
1237 HasConstCopyConstructor && Base != ClassDecl->bases_end(); ++Base) {
1238 const CXXRecordDecl *BaseClassDecl
Ted Kremenek35366a62009-07-17 17:50:17 +00001239 = cast<CXXRecordDecl>(Base->getType()->getAsRecordType()->getDecl());
Douglas Gregor396b7cd2008-11-03 17:51:48 +00001240 HasConstCopyConstructor
1241 = BaseClassDecl->hasConstCopyConstructor(Context);
1242 }
1243
1244 // -- for all the nonstatic data members of X that are of a
1245 // class type M (or array thereof), each such class type
1246 // has a copy constructor whose first parameter is of type
1247 // const M& or const volatile M&.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001248 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin();
1249 HasConstCopyConstructor && Field != ClassDecl->field_end();
Douglas Gregor6ab35242009-04-09 21:40:53 +00001250 ++Field) {
Douglas Gregor396b7cd2008-11-03 17:51:48 +00001251 QualType FieldType = (*Field)->getType();
1252 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
1253 FieldType = Array->getElementType();
Ted Kremenek35366a62009-07-17 17:50:17 +00001254 if (const RecordType *FieldClassType = FieldType->getAsRecordType()) {
Douglas Gregor396b7cd2008-11-03 17:51:48 +00001255 const CXXRecordDecl *FieldClassDecl
1256 = cast<CXXRecordDecl>(FieldClassType->getDecl());
1257 HasConstCopyConstructor
1258 = FieldClassDecl->hasConstCopyConstructor(Context);
1259 }
1260 }
1261
Sebastian Redl64b45f72009-01-05 20:52:13 +00001262 // Otherwise, the implicitly declared copy constructor will have
1263 // the form
Douglas Gregor396b7cd2008-11-03 17:51:48 +00001264 //
1265 // X::X(X&)
Sebastian Redl64b45f72009-01-05 20:52:13 +00001266 QualType ArgType = ClassType;
Douglas Gregor396b7cd2008-11-03 17:51:48 +00001267 if (HasConstCopyConstructor)
1268 ArgType = ArgType.withConst();
Sebastian Redl7c80bd62009-03-16 23:22:08 +00001269 ArgType = Context.getLValueReferenceType(ArgType);
Douglas Gregor396b7cd2008-11-03 17:51:48 +00001270
Sebastian Redl64b45f72009-01-05 20:52:13 +00001271 // An implicitly-declared copy constructor is an inline public
1272 // member of its class.
Douglas Gregor2e1cd422008-11-17 14:58:09 +00001273 DeclarationName Name
1274 = Context.DeclarationNames.getCXXConstructorName(ClassType);
Douglas Gregor396b7cd2008-11-03 17:51:48 +00001275 CXXConstructorDecl *CopyConstructor
1276 = CXXConstructorDecl::Create(Context, ClassDecl,
Douglas Gregor2e1cd422008-11-17 14:58:09 +00001277 ClassDecl->getLocation(), Name,
Douglas Gregor396b7cd2008-11-03 17:51:48 +00001278 Context.getFunctionType(Context.VoidTy,
1279 &ArgType, 1,
1280 false, 0),
1281 /*isExplicit=*/false,
1282 /*isInline=*/true,
1283 /*isImplicitlyDeclared=*/true);
1284 CopyConstructor->setAccess(AS_public);
Douglas Gregor6b3945f2009-01-07 19:46:03 +00001285 CopyConstructor->setImplicit();
Douglas Gregor396b7cd2008-11-03 17:51:48 +00001286
1287 // Add the parameter to the constructor.
1288 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyConstructor,
1289 ClassDecl->getLocation(),
1290 /*IdentifierInfo=*/0,
Douglas Gregor4afa39d2009-01-20 01:17:11 +00001291 ArgType, VarDecl::None, 0);
Ted Kremenekfc767612009-01-14 00:42:25 +00001292 CopyConstructor->setParams(Context, &FromParam, 1);
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001293 ClassDecl->addDecl(CopyConstructor);
Douglas Gregor396b7cd2008-11-03 17:51:48 +00001294 }
1295
Sebastian Redl64b45f72009-01-05 20:52:13 +00001296 if (!ClassDecl->hasUserDeclaredCopyAssignment()) {
1297 // Note: The following rules are largely analoguous to the copy
1298 // constructor rules. Note that virtual bases are not taken into account
1299 // for determining the argument type of the operator. Note also that
1300 // operators taking an object instead of a reference are allowed.
1301 //
1302 // C++ [class.copy]p10:
1303 // If the class definition does not explicitly declare a copy
1304 // assignment operator, one is declared implicitly.
1305 // The implicitly-defined copy assignment operator for a class X
1306 // will have the form
1307 //
1308 // X& X::operator=(const X&)
1309 //
1310 // if
1311 bool HasConstCopyAssignment = true;
1312
1313 // -- each direct base class B of X has a copy assignment operator
1314 // whose parameter is of type const B&, const volatile B& or B,
1315 // and
1316 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin();
1317 HasConstCopyAssignment && Base != ClassDecl->bases_end(); ++Base) {
1318 const CXXRecordDecl *BaseClassDecl
Ted Kremenek35366a62009-07-17 17:50:17 +00001319 = cast<CXXRecordDecl>(Base->getType()->getAsRecordType()->getDecl());
Sebastian Redl64b45f72009-01-05 20:52:13 +00001320 HasConstCopyAssignment = BaseClassDecl->hasConstCopyAssignment(Context);
1321 }
1322
1323 // -- for all the nonstatic data members of X that are of a class
1324 // type M (or array thereof), each such class type has a copy
1325 // assignment operator whose parameter is of type const M&,
1326 // const volatile M& or M.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001327 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin();
1328 HasConstCopyAssignment && Field != ClassDecl->field_end();
Douglas Gregor6ab35242009-04-09 21:40:53 +00001329 ++Field) {
Sebastian Redl64b45f72009-01-05 20:52:13 +00001330 QualType FieldType = (*Field)->getType();
1331 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
1332 FieldType = Array->getElementType();
Ted Kremenek35366a62009-07-17 17:50:17 +00001333 if (const RecordType *FieldClassType = FieldType->getAsRecordType()) {
Sebastian Redl64b45f72009-01-05 20:52:13 +00001334 const CXXRecordDecl *FieldClassDecl
1335 = cast<CXXRecordDecl>(FieldClassType->getDecl());
1336 HasConstCopyAssignment
1337 = FieldClassDecl->hasConstCopyAssignment(Context);
1338 }
1339 }
1340
1341 // Otherwise, the implicitly declared copy assignment operator will
1342 // have the form
1343 //
1344 // X& X::operator=(X&)
1345 QualType ArgType = ClassType;
Sebastian Redl7c80bd62009-03-16 23:22:08 +00001346 QualType RetType = Context.getLValueReferenceType(ArgType);
Sebastian Redl64b45f72009-01-05 20:52:13 +00001347 if (HasConstCopyAssignment)
1348 ArgType = ArgType.withConst();
Sebastian Redl7c80bd62009-03-16 23:22:08 +00001349 ArgType = Context.getLValueReferenceType(ArgType);
Sebastian Redl64b45f72009-01-05 20:52:13 +00001350
1351 // An implicitly-declared copy assignment operator is an inline public
1352 // member of its class.
1353 DeclarationName Name =
1354 Context.DeclarationNames.getCXXOperatorName(OO_Equal);
1355 CXXMethodDecl *CopyAssignment =
1356 CXXMethodDecl::Create(Context, ClassDecl, ClassDecl->getLocation(), Name,
1357 Context.getFunctionType(RetType, &ArgType, 1,
1358 false, 0),
Douglas Gregor4afa39d2009-01-20 01:17:11 +00001359 /*isStatic=*/false, /*isInline=*/true);
Sebastian Redl64b45f72009-01-05 20:52:13 +00001360 CopyAssignment->setAccess(AS_public);
Douglas Gregor6b3945f2009-01-07 19:46:03 +00001361 CopyAssignment->setImplicit();
Sebastian Redl64b45f72009-01-05 20:52:13 +00001362
1363 // Add the parameter to the operator.
1364 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyAssignment,
1365 ClassDecl->getLocation(),
1366 /*IdentifierInfo=*/0,
Douglas Gregor4afa39d2009-01-20 01:17:11 +00001367 ArgType, VarDecl::None, 0);
Ted Kremenekfc767612009-01-14 00:42:25 +00001368 CopyAssignment->setParams(Context, &FromParam, 1);
Sebastian Redl64b45f72009-01-05 20:52:13 +00001369
1370 // Don't call addedAssignmentOperator. There is no way to distinguish an
1371 // implicit from an explicit assignment operator.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001372 ClassDecl->addDecl(CopyAssignment);
Sebastian Redl64b45f72009-01-05 20:52:13 +00001373 }
1374
Douglas Gregor9e7d9de2008-12-15 21:24:18 +00001375 if (!ClassDecl->hasUserDeclaredDestructor()) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00001376 // C++ [class.dtor]p2:
1377 // If a class has no user-declared destructor, a destructor is
1378 // declared implicitly. An implicitly-declared destructor is an
1379 // inline public member of its class.
Douglas Gregor2e1cd422008-11-17 14:58:09 +00001380 DeclarationName Name
1381 = Context.DeclarationNames.getCXXDestructorName(ClassType);
Douglas Gregor42a552f2008-11-05 20:51:48 +00001382 CXXDestructorDecl *Destructor
1383 = CXXDestructorDecl::Create(Context, ClassDecl,
Douglas Gregor2e1cd422008-11-17 14:58:09 +00001384 ClassDecl->getLocation(), Name,
Douglas Gregor42a552f2008-11-05 20:51:48 +00001385 Context.getFunctionType(Context.VoidTy,
1386 0, 0, false, 0),
1387 /*isInline=*/true,
1388 /*isImplicitlyDeclared=*/true);
1389 Destructor->setAccess(AS_public);
Douglas Gregor6b3945f2009-01-07 19:46:03 +00001390 Destructor->setImplicit();
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001391 ClassDecl->addDecl(Destructor);
Douglas Gregor42a552f2008-11-05 20:51:48 +00001392 }
Douglas Gregor396b7cd2008-11-03 17:51:48 +00001393}
1394
Douglas Gregor6569d682009-05-27 23:11:45 +00001395void Sema::ActOnReenterTemplateScope(Scope *S, DeclPtrTy TemplateD) {
1396 TemplateDecl *Template = TemplateD.getAs<TemplateDecl>();
1397 if (!Template)
1398 return;
1399
1400 TemplateParameterList *Params = Template->getTemplateParameters();
1401 for (TemplateParameterList::iterator Param = Params->begin(),
1402 ParamEnd = Params->end();
1403 Param != ParamEnd; ++Param) {
1404 NamedDecl *Named = cast<NamedDecl>(*Param);
1405 if (Named->getDeclName()) {
1406 S->AddDecl(DeclPtrTy::make(Named));
1407 IdResolver.AddDecl(Named);
1408 }
1409 }
1410}
1411
Douglas Gregor72b505b2008-12-16 21:30:33 +00001412/// ActOnStartDelayedCXXMethodDeclaration - We have completed
1413/// parsing a top-level (non-nested) C++ class, and we are now
1414/// parsing those parts of the given Method declaration that could
1415/// not be parsed earlier (C++ [class.mem]p2), such as default
1416/// arguments. This action should enter the scope of the given
1417/// Method declaration as if we had just parsed the qualified method
1418/// name. However, it should not bring the parameters into scope;
1419/// that will be performed by ActOnDelayedCXXMethodParameter.
Chris Lattnerb28317a2009-03-28 19:18:32 +00001420void Sema::ActOnStartDelayedCXXMethodDeclaration(Scope *S, DeclPtrTy MethodD) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +00001421 if (!MethodD)
1422 return;
1423
Douglas Gregor72b505b2008-12-16 21:30:33 +00001424 CXXScopeSpec SS;
Chris Lattnerb28317a2009-03-28 19:18:32 +00001425 FunctionDecl *Method = cast<FunctionDecl>(MethodD.getAs<Decl>());
Douglas Gregorab452ba2009-03-26 23:50:42 +00001426 QualType ClassTy
1427 = Context.getTypeDeclType(cast<RecordDecl>(Method->getDeclContext()));
1428 SS.setScopeRep(
1429 NestedNameSpecifier::Create(Context, 0, false, ClassTy.getTypePtr()));
Douglas Gregor72b505b2008-12-16 21:30:33 +00001430 ActOnCXXEnterDeclaratorScope(S, SS);
1431}
1432
1433/// ActOnDelayedCXXMethodParameter - We've already started a delayed
1434/// C++ method declaration. We're (re-)introducing the given
1435/// function parameter into scope for use in parsing later parts of
1436/// the method declaration. For example, we could see an
1437/// ActOnParamDefaultArgument event for this parameter.
Chris Lattnerb28317a2009-03-28 19:18:32 +00001438void Sema::ActOnDelayedCXXMethodParameter(Scope *S, DeclPtrTy ParamD) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +00001439 if (!ParamD)
1440 return;
1441
Chris Lattnerb28317a2009-03-28 19:18:32 +00001442 ParmVarDecl *Param = cast<ParmVarDecl>(ParamD.getAs<Decl>());
Douglas Gregor61366e92008-12-24 00:01:03 +00001443
1444 // If this parameter has an unparsed default argument, clear it out
1445 // to make way for the parsed default argument.
1446 if (Param->hasUnparsedDefaultArg())
1447 Param->setDefaultArg(0);
1448
Chris Lattnerb28317a2009-03-28 19:18:32 +00001449 S->AddDecl(DeclPtrTy::make(Param));
Douglas Gregor72b505b2008-12-16 21:30:33 +00001450 if (Param->getDeclName())
1451 IdResolver.AddDecl(Param);
1452}
1453
1454/// ActOnFinishDelayedCXXMethodDeclaration - We have finished
1455/// processing the delayed method declaration for Method. The method
1456/// declaration is now considered finished. There may be a separate
1457/// ActOnStartOfFunctionDef action later (not necessarily
1458/// immediately!) for this method, if it was also defined inside the
1459/// class body.
Chris Lattnerb28317a2009-03-28 19:18:32 +00001460void Sema::ActOnFinishDelayedCXXMethodDeclaration(Scope *S, DeclPtrTy MethodD) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +00001461 if (!MethodD)
1462 return;
1463
Chris Lattnerb28317a2009-03-28 19:18:32 +00001464 FunctionDecl *Method = cast<FunctionDecl>(MethodD.getAs<Decl>());
Douglas Gregor72b505b2008-12-16 21:30:33 +00001465 CXXScopeSpec SS;
Douglas Gregorab452ba2009-03-26 23:50:42 +00001466 QualType ClassTy
1467 = Context.getTypeDeclType(cast<RecordDecl>(Method->getDeclContext()));
1468 SS.setScopeRep(
1469 NestedNameSpecifier::Create(Context, 0, false, ClassTy.getTypePtr()));
Douglas Gregor72b505b2008-12-16 21:30:33 +00001470 ActOnCXXExitDeclaratorScope(S, SS);
1471
1472 // Now that we have our default arguments, check the constructor
1473 // again. It could produce additional diagnostics or affect whether
1474 // the class has implicitly-declared destructors, among other
1475 // things.
Chris Lattner6e475012009-04-25 08:35:12 +00001476 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Method))
1477 CheckConstructor(Constructor);
Douglas Gregor72b505b2008-12-16 21:30:33 +00001478
1479 // Check the default arguments, which we may have added.
1480 if (!Method->isInvalidDecl())
1481 CheckCXXDefaultArguments(Method);
1482}
1483
Douglas Gregor42a552f2008-11-05 20:51:48 +00001484/// CheckConstructorDeclarator - Called by ActOnDeclarator to check
Douglas Gregor72b505b2008-12-16 21:30:33 +00001485/// the well-formedness of the constructor declarator @p D with type @p
Douglas Gregor42a552f2008-11-05 20:51:48 +00001486/// R. If there are any errors in the declarator, this routine will
Chris Lattner65401802009-04-25 08:28:21 +00001487/// emit diagnostics and set the invalid bit to true. In any case, the type
1488/// will be updated to reflect a well-formed type for the constructor and
1489/// returned.
1490QualType Sema::CheckConstructorDeclarator(Declarator &D, QualType R,
1491 FunctionDecl::StorageClass &SC) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00001492 bool isVirtual = D.getDeclSpec().isVirtualSpecified();
Douglas Gregor42a552f2008-11-05 20:51:48 +00001493
1494 // C++ [class.ctor]p3:
1495 // A constructor shall not be virtual (10.3) or static (9.4). A
1496 // constructor can be invoked for a const, volatile or const
1497 // volatile object. A constructor shall not be declared const,
1498 // volatile, or const volatile (9.3.2).
1499 if (isVirtual) {
Chris Lattner65401802009-04-25 08:28:21 +00001500 if (!D.isInvalidType())
1501 Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
1502 << "virtual" << SourceRange(D.getDeclSpec().getVirtualSpecLoc())
1503 << SourceRange(D.getIdentifierLoc());
1504 D.setInvalidType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00001505 }
1506 if (SC == FunctionDecl::Static) {
Chris Lattner65401802009-04-25 08:28:21 +00001507 if (!D.isInvalidType())
1508 Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
1509 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
1510 << SourceRange(D.getIdentifierLoc());
1511 D.setInvalidType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00001512 SC = FunctionDecl::None;
1513 }
Chris Lattner65401802009-04-25 08:28:21 +00001514
1515 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
1516 if (FTI.TypeQuals != 0) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00001517 if (FTI.TypeQuals & QualType::Const)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001518 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
1519 << "const" << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00001520 if (FTI.TypeQuals & QualType::Volatile)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001521 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
1522 << "volatile" << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00001523 if (FTI.TypeQuals & QualType::Restrict)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001524 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
1525 << "restrict" << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00001526 }
1527
1528 // Rebuild the function type "R" without any type qualifiers (in
1529 // case any of the errors above fired) and with "void" as the
1530 // return type, since constructors don't have return types. We
1531 // *always* have to do this, because GetTypeForDeclarator will
1532 // put in a result type of "int" when none was specified.
Douglas Gregor72564e72009-02-26 23:50:07 +00001533 const FunctionProtoType *Proto = R->getAsFunctionProtoType();
Chris Lattner65401802009-04-25 08:28:21 +00001534 return Context.getFunctionType(Context.VoidTy, Proto->arg_type_begin(),
1535 Proto->getNumArgs(),
1536 Proto->isVariadic(), 0);
Douglas Gregor42a552f2008-11-05 20:51:48 +00001537}
1538
Douglas Gregor72b505b2008-12-16 21:30:33 +00001539/// CheckConstructor - Checks a fully-formed constructor for
1540/// well-formedness, issuing any diagnostics required. Returns true if
1541/// the constructor declarator is invalid.
Chris Lattner6e475012009-04-25 08:35:12 +00001542void Sema::CheckConstructor(CXXConstructorDecl *Constructor) {
Douglas Gregor33297562009-03-27 04:38:56 +00001543 CXXRecordDecl *ClassDecl
1544 = dyn_cast<CXXRecordDecl>(Constructor->getDeclContext());
1545 if (!ClassDecl)
Chris Lattner6e475012009-04-25 08:35:12 +00001546 return Constructor->setInvalidDecl();
Douglas Gregor72b505b2008-12-16 21:30:33 +00001547
1548 // C++ [class.copy]p3:
1549 // A declaration of a constructor for a class X is ill-formed if
1550 // its first parameter is of type (optionally cv-qualified) X and
1551 // either there are no other parameters or else all other
1552 // parameters have default arguments.
Douglas Gregor33297562009-03-27 04:38:56 +00001553 if (!Constructor->isInvalidDecl() &&
1554 ((Constructor->getNumParams() == 1) ||
1555 (Constructor->getNumParams() > 1 &&
Anders Carlssonae0b4e72009-06-06 04:14:07 +00001556 Constructor->getParamDecl(1)->hasDefaultArg()))) {
Douglas Gregor72b505b2008-12-16 21:30:33 +00001557 QualType ParamType = Constructor->getParamDecl(0)->getType();
1558 QualType ClassTy = Context.getTagDeclType(ClassDecl);
1559 if (Context.getCanonicalType(ParamType).getUnqualifiedType() == ClassTy) {
Douglas Gregora3a83512009-04-01 23:51:29 +00001560 SourceLocation ParamLoc = Constructor->getParamDecl(0)->getLocation();
1561 Diag(ParamLoc, diag::err_constructor_byvalue_arg)
Douglas Gregor558cb562009-04-02 01:08:08 +00001562 << CodeModificationHint::CreateInsertion(ParamLoc, " const &");
Chris Lattner6e475012009-04-25 08:35:12 +00001563 Constructor->setInvalidDecl();
Douglas Gregor72b505b2008-12-16 21:30:33 +00001564 }
1565 }
1566
1567 // Notify the class that we've added a constructor.
1568 ClassDecl->addedConstructor(Context, Constructor);
Douglas Gregor72b505b2008-12-16 21:30:33 +00001569}
1570
Anders Carlsson7786d1c2009-04-30 23:18:11 +00001571static inline bool
1572FTIHasSingleVoidArgument(DeclaratorChunk::FunctionTypeInfo &FTI) {
1573 return (FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 &&
1574 FTI.ArgInfo[0].Param &&
1575 FTI.ArgInfo[0].Param.getAs<ParmVarDecl>()->getType()->isVoidType());
1576}
1577
Douglas Gregor42a552f2008-11-05 20:51:48 +00001578/// CheckDestructorDeclarator - Called by ActOnDeclarator to check
1579/// the well-formednes of the destructor declarator @p D with type @p
1580/// R. If there are any errors in the declarator, this routine will
Chris Lattner65401802009-04-25 08:28:21 +00001581/// emit diagnostics and set the declarator to invalid. Even if this happens,
1582/// will be updated to reflect a well-formed type for the destructor and
1583/// returned.
1584QualType Sema::CheckDestructorDeclarator(Declarator &D,
1585 FunctionDecl::StorageClass& SC) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00001586 // C++ [class.dtor]p1:
1587 // [...] A typedef-name that names a class is a class-name
1588 // (7.1.3); however, a typedef-name that names a class shall not
1589 // be used as the identifier in the declarator for a destructor
1590 // declaration.
Douglas Gregor1a51b4a2009-02-09 15:09:02 +00001591 QualType DeclaratorType = QualType::getFromOpaquePtr(D.getDeclaratorIdType());
Chris Lattner65401802009-04-25 08:28:21 +00001592 if (isa<TypedefType>(DeclaratorType)) {
1593 Diag(D.getIdentifierLoc(), diag::err_destructor_typedef_name)
Douglas Gregor1a51b4a2009-02-09 15:09:02 +00001594 << DeclaratorType;
Chris Lattner65401802009-04-25 08:28:21 +00001595 D.setInvalidType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00001596 }
1597
1598 // C++ [class.dtor]p2:
1599 // A destructor is used to destroy objects of its class type. A
1600 // destructor takes no parameters, and no return type can be
1601 // specified for it (not even void). The address of a destructor
1602 // shall not be taken. A destructor shall not be static. A
1603 // destructor can be invoked for a const, volatile or const
1604 // volatile object. A destructor shall not be declared const,
1605 // volatile or const volatile (9.3.2).
1606 if (SC == FunctionDecl::Static) {
Chris Lattner65401802009-04-25 08:28:21 +00001607 if (!D.isInvalidType())
1608 Diag(D.getIdentifierLoc(), diag::err_destructor_cannot_be)
1609 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
1610 << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00001611 SC = FunctionDecl::None;
Chris Lattner65401802009-04-25 08:28:21 +00001612 D.setInvalidType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00001613 }
Chris Lattner65401802009-04-25 08:28:21 +00001614 if (D.getDeclSpec().hasTypeSpecifier() && !D.isInvalidType()) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00001615 // Destructors don't have return types, but the parser will
1616 // happily parse something like:
1617 //
1618 // class X {
1619 // float ~X();
1620 // };
1621 //
1622 // The return type will be eliminated later.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001623 Diag(D.getIdentifierLoc(), diag::err_destructor_return_type)
1624 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
1625 << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00001626 }
Chris Lattner65401802009-04-25 08:28:21 +00001627
1628 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
1629 if (FTI.TypeQuals != 0 && !D.isInvalidType()) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00001630 if (FTI.TypeQuals & QualType::Const)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001631 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
1632 << "const" << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00001633 if (FTI.TypeQuals & QualType::Volatile)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001634 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
1635 << "volatile" << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00001636 if (FTI.TypeQuals & QualType::Restrict)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001637 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
1638 << "restrict" << SourceRange(D.getIdentifierLoc());
Chris Lattner65401802009-04-25 08:28:21 +00001639 D.setInvalidType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00001640 }
1641
1642 // Make sure we don't have any parameters.
Anders Carlsson7786d1c2009-04-30 23:18:11 +00001643 if (FTI.NumArgs > 0 && !FTIHasSingleVoidArgument(FTI)) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00001644 Diag(D.getIdentifierLoc(), diag::err_destructor_with_params);
1645
1646 // Delete the parameters.
Chris Lattner65401802009-04-25 08:28:21 +00001647 FTI.freeArgs();
1648 D.setInvalidType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00001649 }
1650
1651 // Make sure the destructor isn't variadic.
Chris Lattner65401802009-04-25 08:28:21 +00001652 if (FTI.isVariadic) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00001653 Diag(D.getIdentifierLoc(), diag::err_destructor_variadic);
Chris Lattner65401802009-04-25 08:28:21 +00001654 D.setInvalidType();
1655 }
Douglas Gregor42a552f2008-11-05 20:51:48 +00001656
1657 // Rebuild the function type "R" without any type qualifiers or
1658 // parameters (in case any of the errors above fired) and with
1659 // "void" as the return type, since destructors don't have return
1660 // types. We *always* have to do this, because GetTypeForDeclarator
1661 // will put in a result type of "int" when none was specified.
Chris Lattner65401802009-04-25 08:28:21 +00001662 return Context.getFunctionType(Context.VoidTy, 0, 0, false, 0);
Douglas Gregor42a552f2008-11-05 20:51:48 +00001663}
1664
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001665/// CheckConversionDeclarator - Called by ActOnDeclarator to check the
1666/// well-formednes of the conversion function declarator @p D with
1667/// type @p R. If there are any errors in the declarator, this routine
1668/// will emit diagnostics and return true. Otherwise, it will return
1669/// false. Either way, the type @p R will be updated to reflect a
1670/// well-formed type for the conversion operator.
Chris Lattner6e475012009-04-25 08:35:12 +00001671void Sema::CheckConversionDeclarator(Declarator &D, QualType &R,
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001672 FunctionDecl::StorageClass& SC) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001673 // C++ [class.conv.fct]p1:
1674 // Neither parameter types nor return type can be specified. The
1675 // type of a conversion function (8.3.5) is “function taking no
1676 // parameter returning conversion-type-id.”
1677 if (SC == FunctionDecl::Static) {
Chris Lattner6e475012009-04-25 08:35:12 +00001678 if (!D.isInvalidType())
1679 Diag(D.getIdentifierLoc(), diag::err_conv_function_not_member)
1680 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
1681 << SourceRange(D.getIdentifierLoc());
1682 D.setInvalidType();
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001683 SC = FunctionDecl::None;
1684 }
Chris Lattner6e475012009-04-25 08:35:12 +00001685 if (D.getDeclSpec().hasTypeSpecifier() && !D.isInvalidType()) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001686 // Conversion functions don't have return types, but the parser will
1687 // happily parse something like:
1688 //
1689 // class X {
1690 // float operator bool();
1691 // };
1692 //
1693 // The return type will be changed later anyway.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001694 Diag(D.getIdentifierLoc(), diag::err_conv_function_return_type)
1695 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
1696 << SourceRange(D.getIdentifierLoc());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001697 }
1698
1699 // Make sure we don't have any parameters.
Douglas Gregor72564e72009-02-26 23:50:07 +00001700 if (R->getAsFunctionProtoType()->getNumArgs() > 0) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001701 Diag(D.getIdentifierLoc(), diag::err_conv_function_with_params);
1702
1703 // Delete the parameters.
Chris Lattner1833a832009-01-20 21:06:38 +00001704 D.getTypeObject(0).Fun.freeArgs();
Chris Lattner6e475012009-04-25 08:35:12 +00001705 D.setInvalidType();
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001706 }
1707
1708 // Make sure the conversion function isn't variadic.
Chris Lattner6e475012009-04-25 08:35:12 +00001709 if (R->getAsFunctionProtoType()->isVariadic() && !D.isInvalidType()) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001710 Diag(D.getIdentifierLoc(), diag::err_conv_function_variadic);
Chris Lattner6e475012009-04-25 08:35:12 +00001711 D.setInvalidType();
1712 }
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001713
1714 // C++ [class.conv.fct]p4:
1715 // The conversion-type-id shall not represent a function type nor
1716 // an array type.
1717 QualType ConvType = QualType::getFromOpaquePtr(D.getDeclaratorIdType());
1718 if (ConvType->isArrayType()) {
1719 Diag(D.getIdentifierLoc(), diag::err_conv_function_to_array);
1720 ConvType = Context.getPointerType(ConvType);
Chris Lattner6e475012009-04-25 08:35:12 +00001721 D.setInvalidType();
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001722 } else if (ConvType->isFunctionType()) {
1723 Diag(D.getIdentifierLoc(), diag::err_conv_function_to_function);
1724 ConvType = Context.getPointerType(ConvType);
Chris Lattner6e475012009-04-25 08:35:12 +00001725 D.setInvalidType();
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001726 }
1727
1728 // Rebuild the function type "R" without any parameters (in case any
1729 // of the errors above fired) and with the conversion type as the
1730 // return type.
1731 R = Context.getFunctionType(ConvType, 0, 0, false,
Douglas Gregor72564e72009-02-26 23:50:07 +00001732 R->getAsFunctionProtoType()->getTypeQuals());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001733
Douglas Gregor09f41cf2009-01-14 15:45:31 +00001734 // C++0x explicit conversion operators.
1735 if (D.getDeclSpec().isExplicitSpecified() && !getLangOptions().CPlusPlus0x)
1736 Diag(D.getDeclSpec().getExplicitSpecLoc(),
1737 diag::warn_explicit_conversion_functions)
1738 << SourceRange(D.getDeclSpec().getExplicitSpecLoc());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001739}
1740
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001741/// ActOnConversionDeclarator - Called by ActOnDeclarator to complete
1742/// the declaration of the given C++ conversion function. This routine
1743/// is responsible for recording the conversion function in the C++
1744/// class, if possible.
Chris Lattnerb28317a2009-03-28 19:18:32 +00001745Sema::DeclPtrTy Sema::ActOnConversionDeclarator(CXXConversionDecl *Conversion) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001746 assert(Conversion && "Expected to receive a conversion function declaration");
1747
Douglas Gregor9d350972008-12-12 08:25:50 +00001748 // Set the lexical context of this conversion function
1749 Conversion->setLexicalDeclContext(CurContext);
1750
1751 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Conversion->getDeclContext());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001752
1753 // Make sure we aren't redeclaring the conversion function.
1754 QualType ConvType = Context.getCanonicalType(Conversion->getConversionType());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001755
1756 // C++ [class.conv.fct]p1:
1757 // [...] A conversion function is never used to convert a
1758 // (possibly cv-qualified) object to the (possibly cv-qualified)
1759 // same object type (or a reference to it), to a (possibly
1760 // cv-qualified) base class of that type (or a reference to it),
1761 // or to (possibly cv-qualified) void.
Mike Stump390b4cc2009-05-16 07:39:55 +00001762 // FIXME: Suppress this warning if the conversion function ends up being a
1763 // virtual function that overrides a virtual function in a base class.
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001764 QualType ClassType
1765 = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
Ted Kremenek35366a62009-07-17 17:50:17 +00001766 if (const ReferenceType *ConvTypeRef = ConvType->getAsReferenceType())
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001767 ConvType = ConvTypeRef->getPointeeType();
1768 if (ConvType->isRecordType()) {
1769 ConvType = Context.getCanonicalType(ConvType).getUnqualifiedType();
1770 if (ConvType == ClassType)
Chris Lattner5dc266a2008-11-20 06:13:02 +00001771 Diag(Conversion->getLocation(), diag::warn_conv_to_self_not_used)
Chris Lattnerd1625842008-11-24 06:25:27 +00001772 << ClassType;
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001773 else if (IsDerivedFrom(ClassType, ConvType))
Chris Lattner5dc266a2008-11-20 06:13:02 +00001774 Diag(Conversion->getLocation(), diag::warn_conv_to_base_not_used)
Chris Lattnerd1625842008-11-24 06:25:27 +00001775 << ClassType << ConvType;
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001776 } else if (ConvType->isVoidType()) {
Chris Lattner5dc266a2008-11-20 06:13:02 +00001777 Diag(Conversion->getLocation(), diag::warn_conv_to_void_not_used)
Chris Lattnerd1625842008-11-24 06:25:27 +00001778 << ClassType << ConvType;
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001779 }
1780
Douglas Gregor70316a02008-12-26 15:00:45 +00001781 if (Conversion->getPreviousDeclaration()) {
1782 OverloadedFunctionDecl *Conversions = ClassDecl->getConversionFunctions();
1783 for (OverloadedFunctionDecl::function_iterator
1784 Conv = Conversions->function_begin(),
1785 ConvEnd = Conversions->function_end();
1786 Conv != ConvEnd; ++Conv) {
Douglas Gregore53060f2009-06-25 22:08:12 +00001787 if (*Conv
1788 == cast_or_null<NamedDecl>(Conversion->getPreviousDeclaration())) {
Douglas Gregor70316a02008-12-26 15:00:45 +00001789 *Conv = Conversion;
Chris Lattnerb28317a2009-03-28 19:18:32 +00001790 return DeclPtrTy::make(Conversion);
Douglas Gregor70316a02008-12-26 15:00:45 +00001791 }
1792 }
1793 assert(Conversion->isInvalidDecl() && "Conversion should not get here.");
1794 } else
1795 ClassDecl->addConversionFunction(Context, Conversion);
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001796
Chris Lattnerb28317a2009-03-28 19:18:32 +00001797 return DeclPtrTy::make(Conversion);
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001798}
1799
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001800//===----------------------------------------------------------------------===//
1801// Namespace Handling
1802//===----------------------------------------------------------------------===//
1803
1804/// ActOnStartNamespaceDef - This is called at the start of a namespace
1805/// definition.
Chris Lattnerb28317a2009-03-28 19:18:32 +00001806Sema::DeclPtrTy Sema::ActOnStartNamespaceDef(Scope *NamespcScope,
1807 SourceLocation IdentLoc,
1808 IdentifierInfo *II,
1809 SourceLocation LBrace) {
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001810 NamespaceDecl *Namespc =
1811 NamespaceDecl::Create(Context, CurContext, IdentLoc, II);
1812 Namespc->setLBracLoc(LBrace);
1813
1814 Scope *DeclRegionScope = NamespcScope->getParent();
1815
1816 if (II) {
1817 // C++ [namespace.def]p2:
1818 // The identifier in an original-namespace-definition shall not have been
1819 // previously defined in the declarative region in which the
1820 // original-namespace-definition appears. The identifier in an
1821 // original-namespace-definition is the name of the namespace. Subsequently
1822 // in that declarative region, it is treated as an original-namespace-name.
1823
Douglas Gregor47b9a1c2009-02-04 17:27:36 +00001824 NamedDecl *PrevDecl = LookupName(DeclRegionScope, II, LookupOrdinaryName,
1825 true);
Douglas Gregor44b43212008-12-11 16:49:14 +00001826
1827 if (NamespaceDecl *OrigNS = dyn_cast_or_null<NamespaceDecl>(PrevDecl)) {
1828 // This is an extended namespace definition.
1829 // Attach this namespace decl to the chain of extended namespace
1830 // definitions.
1831 OrigNS->setNextNamespace(Namespc);
1832 Namespc->setOriginalNamespace(OrigNS->getOriginalNamespace());
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001833
Douglas Gregor44b43212008-12-11 16:49:14 +00001834 // Remove the previous declaration from the scope.
Chris Lattnerb28317a2009-03-28 19:18:32 +00001835 if (DeclRegionScope->isDeclScope(DeclPtrTy::make(OrigNS))) {
Douglas Gregore267ff32008-12-11 20:41:00 +00001836 IdResolver.RemoveDecl(OrigNS);
Chris Lattnerb28317a2009-03-28 19:18:32 +00001837 DeclRegionScope->RemoveDecl(DeclPtrTy::make(OrigNS));
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001838 }
Douglas Gregor44b43212008-12-11 16:49:14 +00001839 } else if (PrevDecl) {
1840 // This is an invalid name redefinition.
1841 Diag(Namespc->getLocation(), diag::err_redefinition_different_kind)
1842 << Namespc->getDeclName();
1843 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
1844 Namespc->setInvalidDecl();
1845 // Continue on to push Namespc as current DeclContext and return it.
1846 }
1847
1848 PushOnScopeChains(Namespc, DeclRegionScope);
1849 } else {
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001850 // FIXME: Handle anonymous namespaces
1851 }
1852
1853 // Although we could have an invalid decl (i.e. the namespace name is a
1854 // redefinition), push it as current DeclContext and try to continue parsing.
Mike Stump390b4cc2009-05-16 07:39:55 +00001855 // FIXME: We should be able to push Namespc here, so that the each DeclContext
1856 // for the namespace has the declarations that showed up in that particular
1857 // namespace definition.
Douglas Gregor44b43212008-12-11 16:49:14 +00001858 PushDeclContext(NamespcScope, Namespc);
Chris Lattnerb28317a2009-03-28 19:18:32 +00001859 return DeclPtrTy::make(Namespc);
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001860}
1861
1862/// ActOnFinishNamespaceDef - This callback is called after a namespace is
1863/// exited. Decl is the DeclTy returned by ActOnStartNamespaceDef.
Chris Lattnerb28317a2009-03-28 19:18:32 +00001864void Sema::ActOnFinishNamespaceDef(DeclPtrTy D, SourceLocation RBrace) {
1865 Decl *Dcl = D.getAs<Decl>();
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001866 NamespaceDecl *Namespc = dyn_cast_or_null<NamespaceDecl>(Dcl);
1867 assert(Namespc && "Invalid parameter, expected NamespaceDecl");
1868 Namespc->setRBracLoc(RBrace);
1869 PopDeclContext();
1870}
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001871
Chris Lattnerb28317a2009-03-28 19:18:32 +00001872Sema::DeclPtrTy Sema::ActOnUsingDirective(Scope *S,
1873 SourceLocation UsingLoc,
1874 SourceLocation NamespcLoc,
1875 const CXXScopeSpec &SS,
1876 SourceLocation IdentLoc,
1877 IdentifierInfo *NamespcName,
1878 AttributeList *AttrList) {
Douglas Gregorf780abc2008-12-30 03:27:21 +00001879 assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
1880 assert(NamespcName && "Invalid NamespcName.");
1881 assert(IdentLoc.isValid() && "Invalid NamespceName location.");
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001882 assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
Douglas Gregorf780abc2008-12-30 03:27:21 +00001883
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001884 UsingDirectiveDecl *UDir = 0;
Douglas Gregorf780abc2008-12-30 03:27:21 +00001885
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001886 // Lookup namespace name.
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001887 LookupResult R = LookupParsedName(S, &SS, NamespcName,
1888 LookupNamespaceName, false);
1889 if (R.isAmbiguous()) {
1890 DiagnoseAmbiguousLookup(R, NamespcName, IdentLoc);
Chris Lattnerb28317a2009-03-28 19:18:32 +00001891 return DeclPtrTy();
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001892 }
Douglas Gregor47b9a1c2009-02-04 17:27:36 +00001893 if (NamedDecl *NS = R) {
Douglas Gregorf780abc2008-12-30 03:27:21 +00001894 assert(isa<NamespaceDecl>(NS) && "expected namespace decl");
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001895 // C++ [namespace.udir]p1:
1896 // A using-directive specifies that the names in the nominated
1897 // namespace can be used in the scope in which the
1898 // using-directive appears after the using-directive. During
1899 // unqualified name lookup (3.4.1), the names appear as if they
1900 // were declared in the nearest enclosing namespace which
1901 // contains both the using-directive and the nominated
1902 // namespace. [Note: in this context, “contains” means “contains
1903 // directly or indirectly”. ]
1904
1905 // Find enclosing context containing both using-directive and
1906 // nominated namespace.
1907 DeclContext *CommonAncestor = cast<DeclContext>(NS);
1908 while (CommonAncestor && !CommonAncestor->Encloses(CurContext))
1909 CommonAncestor = CommonAncestor->getParent();
1910
Douglas Gregor8419fa32009-05-30 06:31:56 +00001911 UDir = UsingDirectiveDecl::Create(Context,
1912 CurContext, UsingLoc,
1913 NamespcLoc,
1914 SS.getRange(),
1915 (NestedNameSpecifier *)SS.getScopeRep(),
1916 IdentLoc,
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001917 cast<NamespaceDecl>(NS),
1918 CommonAncestor);
1919 PushUsingDirective(S, UDir);
Douglas Gregorf780abc2008-12-30 03:27:21 +00001920 } else {
Chris Lattneread013e2009-01-06 07:24:29 +00001921 Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
Douglas Gregorf780abc2008-12-30 03:27:21 +00001922 }
1923
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001924 // FIXME: We ignore attributes for now.
Douglas Gregorf780abc2008-12-30 03:27:21 +00001925 delete AttrList;
Chris Lattnerb28317a2009-03-28 19:18:32 +00001926 return DeclPtrTy::make(UDir);
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001927}
1928
1929void Sema::PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir) {
1930 // If scope has associated entity, then using directive is at namespace
1931 // or translation unit scope. We add UsingDirectiveDecls, into
1932 // it's lookup structure.
1933 if (DeclContext *Ctx = static_cast<DeclContext*>(S->getEntity()))
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001934 Ctx->addDecl(UDir);
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001935 else
1936 // Otherwise it is block-sope. using-directives will affect lookup
1937 // only to the end of scope.
Chris Lattnerb28317a2009-03-28 19:18:32 +00001938 S->PushUsingDirective(DeclPtrTy::make(UDir));
Douglas Gregorf780abc2008-12-30 03:27:21 +00001939}
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001940
Douglas Gregor9cfbe482009-06-20 00:51:54 +00001941
1942Sema::DeclPtrTy Sema::ActOnUsingDeclaration(Scope *S,
1943 SourceLocation UsingLoc,
1944 const CXXScopeSpec &SS,
1945 SourceLocation IdentLoc,
1946 IdentifierInfo *TargetName,
Anders Carlsson0c6139d2009-06-27 00:27:47 +00001947 OverloadedOperatorKind Op,
Douglas Gregor9cfbe482009-06-20 00:51:54 +00001948 AttributeList *AttrList,
1949 bool IsTypeName) {
1950 assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
Eli Friedman5d39dee2009-06-27 05:59:59 +00001951 assert((TargetName || Op) && "Invalid TargetName.");
Douglas Gregor9cfbe482009-06-20 00:51:54 +00001952 assert(IdentLoc.isValid() && "Invalid TargetName location.");
1953 assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
1954
1955 UsingDecl *UsingAlias = 0;
1956
Anders Carlsson0c6139d2009-06-27 00:27:47 +00001957 DeclarationName Name;
1958 if (TargetName)
1959 Name = TargetName;
1960 else
1961 Name = Context.DeclarationNames.getCXXOperatorName(Op);
1962
Douglas Gregor9cfbe482009-06-20 00:51:54 +00001963 // Lookup target name.
Anders Carlsson0c6139d2009-06-27 00:27:47 +00001964 LookupResult R = LookupParsedName(S, &SS, Name, LookupOrdinaryName, false);
Douglas Gregor9cfbe482009-06-20 00:51:54 +00001965
1966 if (NamedDecl *NS = R) {
1967 if (IsTypeName && !isa<TypeDecl>(NS)) {
1968 Diag(IdentLoc, diag::err_using_typename_non_type);
1969 }
1970 UsingAlias = UsingDecl::Create(Context, CurContext, IdentLoc, SS.getRange(),
1971 NS->getLocation(), UsingLoc, NS,
1972 static_cast<NestedNameSpecifier *>(SS.getScopeRep()),
1973 IsTypeName);
1974 PushOnScopeChains(UsingAlias, S);
1975 } else {
1976 Diag(IdentLoc, diag::err_using_requires_qualname) << SS.getRange();
1977 }
1978
1979 // FIXME: We ignore attributes for now.
1980 delete AttrList;
1981 return DeclPtrTy::make(UsingAlias);
1982}
1983
Anders Carlsson81c85c42009-03-28 23:53:49 +00001984/// getNamespaceDecl - Returns the namespace a decl represents. If the decl
1985/// is a namespace alias, returns the namespace it points to.
1986static inline NamespaceDecl *getNamespaceDecl(NamedDecl *D) {
1987 if (NamespaceAliasDecl *AD = dyn_cast_or_null<NamespaceAliasDecl>(D))
1988 return AD->getNamespace();
1989 return dyn_cast_or_null<NamespaceDecl>(D);
1990}
1991
Chris Lattnerb28317a2009-03-28 19:18:32 +00001992Sema::DeclPtrTy Sema::ActOnNamespaceAliasDef(Scope *S,
Anders Carlsson03bd5a12009-03-28 22:53:22 +00001993 SourceLocation NamespaceLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001994 SourceLocation AliasLoc,
1995 IdentifierInfo *Alias,
1996 const CXXScopeSpec &SS,
Anders Carlsson03bd5a12009-03-28 22:53:22 +00001997 SourceLocation IdentLoc,
1998 IdentifierInfo *Ident) {
Anders Carlsson8d7ba402009-03-28 06:23:46 +00001999
Anders Carlsson81c85c42009-03-28 23:53:49 +00002000 // Lookup the namespace name.
2001 LookupResult R = LookupParsedName(S, &SS, Ident, LookupNamespaceName, false);
2002
Anders Carlsson8d7ba402009-03-28 06:23:46 +00002003 // Check if we have a previous declaration with the same name.
Anders Carlssondd729fc2009-03-28 23:49:35 +00002004 if (NamedDecl *PrevDecl = LookupName(S, Alias, LookupOrdinaryName, true)) {
Anders Carlsson81c85c42009-03-28 23:53:49 +00002005 if (NamespaceAliasDecl *AD = dyn_cast<NamespaceAliasDecl>(PrevDecl)) {
2006 // We already have an alias with the same name that points to the same
2007 // namespace, so don't create a new one.
2008 if (!R.isAmbiguous() && AD->getNamespace() == getNamespaceDecl(R))
2009 return DeclPtrTy();
2010 }
2011
Anders Carlsson8d7ba402009-03-28 06:23:46 +00002012 unsigned DiagID = isa<NamespaceDecl>(PrevDecl) ? diag::err_redefinition :
2013 diag::err_redefinition_different_kind;
2014 Diag(AliasLoc, DiagID) << Alias;
2015 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002016 return DeclPtrTy();
Anders Carlsson8d7ba402009-03-28 06:23:46 +00002017 }
2018
Anders Carlsson5721c682009-03-28 06:42:02 +00002019 if (R.isAmbiguous()) {
Anders Carlsson03bd5a12009-03-28 22:53:22 +00002020 DiagnoseAmbiguousLookup(R, Ident, IdentLoc);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002021 return DeclPtrTy();
Anders Carlsson5721c682009-03-28 06:42:02 +00002022 }
2023
2024 if (!R) {
2025 Diag(NamespaceLoc, diag::err_expected_namespace_name) << SS.getRange();
Chris Lattnerb28317a2009-03-28 19:18:32 +00002026 return DeclPtrTy();
Anders Carlsson5721c682009-03-28 06:42:02 +00002027 }
2028
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00002029 NamespaceAliasDecl *AliasDecl =
Douglas Gregor6c9c9402009-05-30 06:48:27 +00002030 NamespaceAliasDecl::Create(Context, CurContext, NamespaceLoc, AliasLoc,
2031 Alias, SS.getRange(),
2032 (NestedNameSpecifier *)SS.getScopeRep(),
Anders Carlsson68771c72009-03-28 22:58:02 +00002033 IdentLoc, R);
2034
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002035 CurContext->addDecl(AliasDecl);
Anders Carlsson68771c72009-03-28 22:58:02 +00002036 return DeclPtrTy::make(AliasDecl);
Anders Carlssondbb00942009-03-28 05:27:17 +00002037}
2038
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00002039void Sema::DefineImplicitDefaultConstructor(SourceLocation CurrentLocation,
2040 CXXConstructorDecl *Constructor) {
Fariborz Jahanian05a5c452009-06-22 20:37:23 +00002041 assert((Constructor->isImplicit() && Constructor->isDefaultConstructor() &&
2042 !Constructor->isUsed()) &&
2043 "DefineImplicitDefaultConstructor - call it for implicit default ctor");
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00002044
2045 CXXRecordDecl *ClassDecl
2046 = cast<CXXRecordDecl>(Constructor->getDeclContext());
Fariborz Jahanian485f0872009-06-22 23:34:40 +00002047 assert(ClassDecl && "DefineImplicitDefaultConstructor - invalid constructor");
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00002048 // Before the implicitly-declared default constructor for a class is
2049 // implicitly defined, all the implicitly-declared default constructors
2050 // for its base class and its non-static data members shall have been
2051 // implicitly defined.
2052 bool err = false;
Fariborz Jahanian514b7b12009-06-30 16:36:53 +00002053 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
2054 E = ClassDecl->bases_end(); Base != E; ++Base) {
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00002055 CXXRecordDecl *BaseClassDecl
Ted Kremenek35366a62009-07-17 17:50:17 +00002056 = cast<CXXRecordDecl>(Base->getType()->getAsRecordType()->getDecl());
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00002057 if (!BaseClassDecl->hasTrivialConstructor()) {
2058 if (CXXConstructorDecl *BaseCtor =
Fariborz Jahanian220a0f32009-06-23 23:42:10 +00002059 BaseClassDecl->getDefaultConstructor(Context))
2060 MarkDeclarationReferenced(CurrentLocation, BaseCtor);
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00002061 else {
2062 Diag(CurrentLocation, diag::err_defining_default_ctor)
Fariborz Jahanian3da83eb2009-06-20 20:23:38 +00002063 << Context.getTagDeclType(ClassDecl) << 1
2064 << Context.getTagDeclType(BaseClassDecl);
2065 Diag(BaseClassDecl->getLocation(), diag::note_previous_class_decl)
2066 << Context.getTagDeclType(BaseClassDecl);
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00002067 err = true;
2068 }
2069 }
2070 }
Fariborz Jahanian514b7b12009-06-30 16:36:53 +00002071 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
2072 E = ClassDecl->field_end(); Field != E; ++Field) {
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00002073 QualType FieldType = Context.getCanonicalType((*Field)->getType());
2074 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
2075 FieldType = Array->getElementType();
Ted Kremenek35366a62009-07-17 17:50:17 +00002076 if (const RecordType *FieldClassType = FieldType->getAsRecordType()) {
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00002077 CXXRecordDecl *FieldClassDecl
2078 = cast<CXXRecordDecl>(FieldClassType->getDecl());
Duncan Sands6887e632009-06-25 09:03:06 +00002079 if (!FieldClassDecl->hasTrivialConstructor()) {
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00002080 if (CXXConstructorDecl *FieldCtor =
Fariborz Jahanian220a0f32009-06-23 23:42:10 +00002081 FieldClassDecl->getDefaultConstructor(Context))
2082 MarkDeclarationReferenced(CurrentLocation, FieldCtor);
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00002083 else {
2084 Diag(CurrentLocation, diag::err_defining_default_ctor)
Fariborz Jahanian3da83eb2009-06-20 20:23:38 +00002085 << Context.getTagDeclType(ClassDecl) << 0 <<
2086 Context.getTagDeclType(FieldClassDecl);
2087 Diag(FieldClassDecl->getLocation(), diag::note_previous_class_decl)
2088 << Context.getTagDeclType(FieldClassDecl);
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00002089 err = true;
2090 }
2091 }
Duncan Sands6887e632009-06-25 09:03:06 +00002092 }
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00002093 else if (FieldType->isReferenceType()) {
2094 Diag(CurrentLocation, diag::err_unintialized_member)
Anders Carlsson5eda8162009-07-09 17:37:12 +00002095 << Context.getTagDeclType(ClassDecl) << 0 << Field->getDeclName();
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00002096 Diag((*Field)->getLocation(), diag::note_declared_at);
2097 err = true;
2098 }
2099 else if (FieldType.isConstQualified()) {
2100 Diag(CurrentLocation, diag::err_unintialized_member)
Anders Carlsson5eda8162009-07-09 17:37:12 +00002101 << Context.getTagDeclType(ClassDecl) << 1 << Field->getDeclName();
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00002102 Diag((*Field)->getLocation(), diag::note_declared_at);
2103 err = true;
2104 }
2105 }
2106 if (!err)
Fariborz Jahanianc6249b92009-06-26 16:08:57 +00002107 Constructor->setUsed();
2108 else
2109 Constructor->setInvalidDecl();
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00002110}
2111
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00002112void Sema::DefineImplicitDestructor(SourceLocation CurrentLocation,
2113 CXXDestructorDecl *Destructor) {
2114 assert((Destructor->isImplicit() && !Destructor->isUsed()) &&
2115 "DefineImplicitDestructor - call it for implicit default dtor");
2116
2117 CXXRecordDecl *ClassDecl
2118 = cast<CXXRecordDecl>(Destructor->getDeclContext());
2119 assert(ClassDecl && "DefineImplicitDestructor - invalid destructor");
2120 // C++ [class.dtor] p5
2121 // Before the implicitly-declared default destructor for a class is
2122 // implicitly defined, all the implicitly-declared default destructors
2123 // for its base class and its non-static data members shall have been
2124 // implicitly defined.
Fariborz Jahanian514b7b12009-06-30 16:36:53 +00002125 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
2126 E = ClassDecl->bases_end(); Base != E; ++Base) {
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00002127 CXXRecordDecl *BaseClassDecl
Ted Kremenek35366a62009-07-17 17:50:17 +00002128 = cast<CXXRecordDecl>(Base->getType()->getAsRecordType()->getDecl());
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00002129 if (!BaseClassDecl->hasTrivialDestructor()) {
2130 if (CXXDestructorDecl *BaseDtor =
2131 const_cast<CXXDestructorDecl*>(BaseClassDecl->getDestructor(Context)))
2132 MarkDeclarationReferenced(CurrentLocation, BaseDtor);
2133 else
2134 assert(false &&
2135 "DefineImplicitDestructor - missing dtor in a base class");
2136 }
2137 }
2138
Fariborz Jahanian514b7b12009-06-30 16:36:53 +00002139 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
2140 E = ClassDecl->field_end(); Field != E; ++Field) {
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00002141 QualType FieldType = Context.getCanonicalType((*Field)->getType());
2142 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
2143 FieldType = Array->getElementType();
Ted Kremenek35366a62009-07-17 17:50:17 +00002144 if (const RecordType *FieldClassType = FieldType->getAsRecordType()) {
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00002145 CXXRecordDecl *FieldClassDecl
2146 = cast<CXXRecordDecl>(FieldClassType->getDecl());
2147 if (!FieldClassDecl->hasTrivialDestructor()) {
2148 if (CXXDestructorDecl *FieldDtor =
2149 const_cast<CXXDestructorDecl*>(
2150 FieldClassDecl->getDestructor(Context)))
2151 MarkDeclarationReferenced(CurrentLocation, FieldDtor);
2152 else
2153 assert(false &&
2154 "DefineImplicitDestructor - missing dtor in class of a data member");
2155 }
2156 }
2157 }
2158 Destructor->setUsed();
2159}
2160
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00002161void Sema::DefineImplicitOverloadedAssign(SourceLocation CurrentLocation,
2162 CXXMethodDecl *MethodDecl) {
2163 assert((MethodDecl->isImplicit() && MethodDecl->isOverloadedOperator() &&
2164 MethodDecl->getOverloadedOperator() == OO_Equal &&
2165 !MethodDecl->isUsed()) &&
2166 "DefineImplicitOverloadedAssign - call it for implicit assignment op");
2167
2168 CXXRecordDecl *ClassDecl
2169 = cast<CXXRecordDecl>(MethodDecl->getDeclContext());
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00002170
Fariborz Jahanianc6249b92009-06-26 16:08:57 +00002171 // C++[class.copy] p12
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00002172 // Before the implicitly-declared copy assignment operator for a class is
2173 // implicitly defined, all implicitly-declared copy assignment operators
2174 // for its direct base classes and its nonstatic data members shall have
2175 // been implicitly defined.
2176 bool err = false;
Fariborz Jahanian514b7b12009-06-30 16:36:53 +00002177 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
2178 E = ClassDecl->bases_end(); Base != E; ++Base) {
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00002179 CXXRecordDecl *BaseClassDecl
Ted Kremenek35366a62009-07-17 17:50:17 +00002180 = cast<CXXRecordDecl>(Base->getType()->getAsRecordType()->getDecl());
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00002181 if (CXXMethodDecl *BaseAssignOpMethod =
2182 getAssignOperatorMethod(MethodDecl->getParamDecl(0), BaseClassDecl))
2183 MarkDeclarationReferenced(CurrentLocation, BaseAssignOpMethod);
2184 }
Fariborz Jahanian514b7b12009-06-30 16:36:53 +00002185 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
2186 E = ClassDecl->field_end(); Field != E; ++Field) {
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00002187 QualType FieldType = Context.getCanonicalType((*Field)->getType());
2188 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
2189 FieldType = Array->getElementType();
Ted Kremenek35366a62009-07-17 17:50:17 +00002190 if (const RecordType *FieldClassType = FieldType->getAsRecordType()) {
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00002191 CXXRecordDecl *FieldClassDecl
2192 = cast<CXXRecordDecl>(FieldClassType->getDecl());
2193 if (CXXMethodDecl *FieldAssignOpMethod =
2194 getAssignOperatorMethod(MethodDecl->getParamDecl(0), FieldClassDecl))
2195 MarkDeclarationReferenced(CurrentLocation, FieldAssignOpMethod);
2196 }
2197 else if (FieldType->isReferenceType()) {
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00002198 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
Anders Carlsson5e09d4c2009-07-09 17:47:25 +00002199 << Context.getTagDeclType(ClassDecl) << 0 << Field->getDeclName();
2200 Diag(Field->getLocation(), diag::note_declared_at);
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00002201 Diag(CurrentLocation, diag::note_first_required_here);
2202 err = true;
2203 }
2204 else if (FieldType.isConstQualified()) {
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00002205 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
Anders Carlsson5e09d4c2009-07-09 17:47:25 +00002206 << Context.getTagDeclType(ClassDecl) << 1 << Field->getDeclName();
2207 Diag(Field->getLocation(), diag::note_declared_at);
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00002208 Diag(CurrentLocation, diag::note_first_required_here);
2209 err = true;
2210 }
2211 }
2212 if (!err)
2213 MethodDecl->setUsed();
2214}
2215
2216CXXMethodDecl *
2217Sema::getAssignOperatorMethod(ParmVarDecl *ParmDecl,
2218 CXXRecordDecl *ClassDecl) {
2219 QualType LHSType = Context.getTypeDeclType(ClassDecl);
2220 QualType RHSType(LHSType);
2221 // If class's assignment operator argument is const/volatile qualified,
2222 // look for operator = (const/volatile B&). Otherwise, look for
2223 // operator = (B&).
2224 if (ParmDecl->getType().isConstQualified())
2225 RHSType.addConst();
2226 if (ParmDecl->getType().isVolatileQualified())
2227 RHSType.addVolatile();
2228 ExprOwningPtr<Expr> LHS(this, new (Context) DeclRefExpr(ParmDecl,
2229 LHSType,
2230 SourceLocation()));
2231 ExprOwningPtr<Expr> RHS(this, new (Context) DeclRefExpr(ParmDecl,
2232 RHSType,
2233 SourceLocation()));
2234 Expr *Args[2] = { &*LHS, &*RHS };
2235 OverloadCandidateSet CandidateSet;
2236 AddMemberOperatorCandidates(clang::OO_Equal, SourceLocation(), Args, 2,
2237 CandidateSet);
2238 OverloadCandidateSet::iterator Best;
2239 if (BestViableFunction(CandidateSet,
2240 ClassDecl->getLocation(), Best) == OR_Success)
2241 return cast<CXXMethodDecl>(Best->Function);
2242 assert(false &&
2243 "getAssignOperatorMethod - copy assignment operator method not found");
2244 return 0;
2245}
2246
Fariborz Jahanian485f0872009-06-22 23:34:40 +00002247void Sema::DefineImplicitCopyConstructor(SourceLocation CurrentLocation,
2248 CXXConstructorDecl *CopyConstructor,
2249 unsigned TypeQuals) {
2250 assert((CopyConstructor->isImplicit() &&
2251 CopyConstructor->isCopyConstructor(Context, TypeQuals) &&
2252 !CopyConstructor->isUsed()) &&
2253 "DefineImplicitCopyConstructor - call it for implicit copy ctor");
2254
2255 CXXRecordDecl *ClassDecl
2256 = cast<CXXRecordDecl>(CopyConstructor->getDeclContext());
2257 assert(ClassDecl && "DefineImplicitCopyConstructor - invalid constructor");
Fariborz Jahanian220a0f32009-06-23 23:42:10 +00002258 // C++ [class.copy] p209
Fariborz Jahanian485f0872009-06-22 23:34:40 +00002259 // Before the implicitly-declared copy constructor for a class is
2260 // implicitly defined, all the implicitly-declared copy constructors
2261 // for its base class and its non-static data members shall have been
2262 // implicitly defined.
2263 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin();
2264 Base != ClassDecl->bases_end(); ++Base) {
2265 CXXRecordDecl *BaseClassDecl
Ted Kremenek35366a62009-07-17 17:50:17 +00002266 = cast<CXXRecordDecl>(Base->getType()->getAsRecordType()->getDecl());
Fariborz Jahanian485f0872009-06-22 23:34:40 +00002267 if (CXXConstructorDecl *BaseCopyCtor =
2268 BaseClassDecl->getCopyConstructor(Context, TypeQuals))
Fariborz Jahanian220a0f32009-06-23 23:42:10 +00002269 MarkDeclarationReferenced(CurrentLocation, BaseCopyCtor);
Fariborz Jahanian485f0872009-06-22 23:34:40 +00002270 }
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002271 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
2272 FieldEnd = ClassDecl->field_end();
2273 Field != FieldEnd; ++Field) {
Fariborz Jahanian485f0872009-06-22 23:34:40 +00002274 QualType FieldType = Context.getCanonicalType((*Field)->getType());
2275 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
2276 FieldType = Array->getElementType();
Ted Kremenek35366a62009-07-17 17:50:17 +00002277 if (const RecordType *FieldClassType = FieldType->getAsRecordType()) {
Fariborz Jahanian485f0872009-06-22 23:34:40 +00002278 CXXRecordDecl *FieldClassDecl
2279 = cast<CXXRecordDecl>(FieldClassType->getDecl());
2280 if (CXXConstructorDecl *FieldCopyCtor =
2281 FieldClassDecl->getCopyConstructor(Context, TypeQuals))
Fariborz Jahanian220a0f32009-06-23 23:42:10 +00002282 MarkDeclarationReferenced(CurrentLocation, FieldCopyCtor);
Fariborz Jahanian485f0872009-06-22 23:34:40 +00002283 }
2284 }
2285 CopyConstructor->setUsed();
2286}
2287
Anders Carlsson930e8d02009-04-16 23:50:50 +00002288void Sema::InitializeVarWithConstructor(VarDecl *VD,
2289 CXXConstructorDecl *Constructor,
2290 QualType DeclInitType,
2291 Expr **Exprs, unsigned NumExprs) {
Anders Carlsson8e587a12009-05-30 20:56:46 +00002292 Expr *Temp = CXXConstructExpr::Create(Context, DeclInitType, Constructor,
Anders Carlsson49d44012009-04-24 05:16:06 +00002293 false, Exprs, NumExprs);
Douglas Gregord7f37bf2009-06-22 23:06:13 +00002294 MarkDeclarationReferenced(VD->getLocation(), Constructor);
Douglas Gregor78d15832009-05-26 18:54:04 +00002295 VD->setInit(Context, Temp);
Anders Carlsson930e8d02009-04-16 23:50:50 +00002296}
2297
Fariborz Jahanianf8d736c2009-06-27 15:05:11 +00002298void Sema::MarkDestructorReferenced(SourceLocation Loc, QualType DeclInitType)
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00002299{
2300 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(
Ted Kremenek35366a62009-07-17 17:50:17 +00002301 DeclInitType->getAsRecordType()->getDecl());
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00002302 if (!ClassDecl->hasTrivialDestructor())
2303 if (CXXDestructorDecl *Destructor =
2304 const_cast<CXXDestructorDecl*>(ClassDecl->getDestructor(Context)))
2305 MarkDeclarationReferenced(Loc, Destructor);
2306}
2307
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00002308/// AddCXXDirectInitializerToDecl - This action is called immediately after
2309/// ActOnDeclarator, when a C++ direct initializer is present.
2310/// e.g: "int x(1);"
Chris Lattnerb28317a2009-03-28 19:18:32 +00002311void Sema::AddCXXDirectInitializerToDecl(DeclPtrTy Dcl,
2312 SourceLocation LParenLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +00002313 MultiExprArg Exprs,
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00002314 SourceLocation *CommaLocs,
2315 SourceLocation RParenLoc) {
Sebastian Redlf53597f2009-03-15 17:47:39 +00002316 unsigned NumExprs = Exprs.size();
2317 assert(NumExprs != 0 && Exprs.get() && "missing expressions");
Chris Lattnerb28317a2009-03-28 19:18:32 +00002318 Decl *RealDecl = Dcl.getAs<Decl>();
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00002319
2320 // If there is no declaration, there was an error parsing it. Just ignore
2321 // the initializer.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002322 if (RealDecl == 0)
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00002323 return;
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00002324
2325 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
2326 if (!VDecl) {
2327 Diag(RealDecl->getLocation(), diag::err_illegal_initializer);
2328 RealDecl->setInvalidDecl();
2329 return;
2330 }
2331
Douglas Gregor615c5d42009-03-24 16:43:20 +00002332 // FIXME: Need to handle dependent types and expressions here.
2333
Argyrios Kyrtzidisce8e2922008-10-06 23:08:37 +00002334 // We will treat direct-initialization as a copy-initialization:
2335 // int x(1); -as-> int x = 1;
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00002336 // ClassType x(a,b,c); -as-> ClassType x = ClassType(a,b,c);
2337 //
2338 // Clients that want to distinguish between the two forms, can check for
2339 // direct initializer using VarDecl::hasCXXDirectInitializer().
2340 // A major benefit is that clients that don't particularly care about which
2341 // exactly form was it (like the CodeGen) can handle both cases without
2342 // special case code.
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +00002343
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00002344 // C++ 8.5p11:
2345 // The form of initialization (using parentheses or '=') is generally
2346 // insignificant, but does matter when the entity being initialized has a
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +00002347 // class type.
Douglas Gregor18fe5682008-11-03 20:45:27 +00002348 QualType DeclInitType = VDecl->getType();
2349 if (const ArrayType *Array = Context.getAsArrayType(DeclInitType))
2350 DeclInitType = Array->getElementType();
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +00002351
Douglas Gregor615c5d42009-03-24 16:43:20 +00002352 // FIXME: This isn't the right place to complete the type.
2353 if (RequireCompleteType(VDecl->getLocation(), VDecl->getType(),
2354 diag::err_typecheck_decl_incomplete_type)) {
2355 VDecl->setInvalidDecl();
2356 return;
2357 }
2358
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +00002359 if (VDecl->getType()->isRecordType()) {
Douglas Gregor18fe5682008-11-03 20:45:27 +00002360 CXXConstructorDecl *Constructor
Sebastian Redlf53597f2009-03-15 17:47:39 +00002361 = PerformInitializationByConstructor(DeclInitType,
2362 (Expr **)Exprs.get(), NumExprs,
Douglas Gregorf03d7c72008-11-05 15:29:30 +00002363 VDecl->getLocation(),
2364 SourceRange(VDecl->getLocation(),
2365 RParenLoc),
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002366 VDecl->getDeclName(),
Douglas Gregorf03d7c72008-11-05 15:29:30 +00002367 IK_Direct);
Sebastian Redlf53597f2009-03-15 17:47:39 +00002368 if (!Constructor)
Douglas Gregor18fe5682008-11-03 20:45:27 +00002369 RealDecl->setInvalidDecl();
Anders Carlssonca29ad92009-04-15 21:48:18 +00002370 else {
Anders Carlssonca29ad92009-04-15 21:48:18 +00002371 VDecl->setCXXDirectInitializer(true);
Anders Carlsson930e8d02009-04-16 23:50:50 +00002372 InitializeVarWithConstructor(VDecl, Constructor, DeclInitType,
2373 (Expr**)Exprs.release(), NumExprs);
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00002374 // FIXME. Must do all that is needed to destroy the object
2375 // on scope exit. For now, just mark the destructor as used.
Fariborz Jahanianf8d736c2009-06-27 15:05:11 +00002376 MarkDestructorReferenced(VDecl->getLocation(), DeclInitType);
Anders Carlssonca29ad92009-04-15 21:48:18 +00002377 }
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +00002378 return;
2379 }
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00002380
Argyrios Kyrtzidisce8e2922008-10-06 23:08:37 +00002381 if (NumExprs > 1) {
Chris Lattnerdcd5ef12008-11-19 05:27:50 +00002382 Diag(CommaLocs[0], diag::err_builtin_direct_init_more_than_one_arg)
2383 << SourceRange(VDecl->getLocation(), RParenLoc);
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00002384 RealDecl->setInvalidDecl();
2385 return;
2386 }
2387
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00002388 // Let clients know that initialization was done with a direct initializer.
2389 VDecl->setCXXDirectInitializer(true);
Argyrios Kyrtzidisce8e2922008-10-06 23:08:37 +00002390
2391 assert(NumExprs == 1 && "Expected 1 expression");
2392 // Set the init expression, handles conversions.
Sebastian Redlf53597f2009-03-15 17:47:39 +00002393 AddInitializerToDecl(Dcl, ExprArg(*this, Exprs.release()[0]),
2394 /*DirectInit=*/true);
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00002395}
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002396
Douglas Gregorf03d7c72008-11-05 15:29:30 +00002397/// PerformInitializationByConstructor - Perform initialization by
2398/// constructor (C++ [dcl.init]p14), which may occur as part of
2399/// direct-initialization or copy-initialization. We are initializing
2400/// an object of type @p ClassType with the given arguments @p
2401/// Args. @p Loc is the location in the source code where the
2402/// initializer occurs (e.g., a declaration, member initializer,
2403/// functional cast, etc.) while @p Range covers the whole
2404/// initialization. @p InitEntity is the entity being initialized,
2405/// which may by the name of a declaration or a type. @p Kind is the
2406/// kind of initialization we're performing, which affects whether
2407/// explicit constructors will be considered. When successful, returns
Douglas Gregor18fe5682008-11-03 20:45:27 +00002408/// the constructor that will be used to perform the initialization;
Douglas Gregorf03d7c72008-11-05 15:29:30 +00002409/// when the initialization fails, emits a diagnostic and returns
2410/// null.
Douglas Gregor18fe5682008-11-03 20:45:27 +00002411CXXConstructorDecl *
Douglas Gregorf03d7c72008-11-05 15:29:30 +00002412Sema::PerformInitializationByConstructor(QualType ClassType,
2413 Expr **Args, unsigned NumArgs,
2414 SourceLocation Loc, SourceRange Range,
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002415 DeclarationName InitEntity,
Douglas Gregorf03d7c72008-11-05 15:29:30 +00002416 InitializationKind Kind) {
Ted Kremenek35366a62009-07-17 17:50:17 +00002417 const RecordType *ClassRec = ClassType->getAsRecordType();
Douglas Gregor18fe5682008-11-03 20:45:27 +00002418 assert(ClassRec && "Can only initialize a class type here");
2419
2420 // C++ [dcl.init]p14:
2421 //
2422 // If the initialization is direct-initialization, or if it is
2423 // copy-initialization where the cv-unqualified version of the
2424 // source type is the same class as, or a derived class of, the
2425 // class of the destination, constructors are considered. The
2426 // applicable constructors are enumerated (13.3.1.3), and the
2427 // best one is chosen through overload resolution (13.3). The
2428 // constructor so selected is called to initialize the object,
2429 // with the initializer expression(s) as its argument(s). If no
2430 // constructor applies, or the overload resolution is ambiguous,
2431 // the initialization is ill-formed.
Douglas Gregor18fe5682008-11-03 20:45:27 +00002432 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(ClassRec->getDecl());
2433 OverloadCandidateSet CandidateSet;
Douglas Gregorf03d7c72008-11-05 15:29:30 +00002434
2435 // Add constructors to the overload set.
Douglas Gregor9e7d9de2008-12-15 21:24:18 +00002436 DeclarationName ConstructorName
2437 = Context.DeclarationNames.getCXXConstructorName(
2438 Context.getCanonicalType(ClassType.getUnqualifiedType()));
Douglas Gregor3fc749d2008-12-23 00:26:44 +00002439 DeclContext::lookup_const_iterator Con, ConEnd;
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002440 for (llvm::tie(Con, ConEnd) = ClassDecl->lookup(ConstructorName);
Douglas Gregor3fc749d2008-12-23 00:26:44 +00002441 Con != ConEnd; ++Con) {
2442 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(*Con);
Douglas Gregorf03d7c72008-11-05 15:29:30 +00002443 if ((Kind == IK_Direct) ||
2444 (Kind == IK_Copy && Constructor->isConvertingConstructor()) ||
2445 (Kind == IK_Default && Constructor->isDefaultConstructor()))
2446 AddOverloadCandidate(Constructor, Args, NumArgs, CandidateSet);
2447 }
2448
Douglas Gregor9e7d9de2008-12-15 21:24:18 +00002449 // FIXME: When we decide not to synthesize the implicitly-declared
2450 // constructors, we'll need to make them appear here.
2451
Douglas Gregor18fe5682008-11-03 20:45:27 +00002452 OverloadCandidateSet::iterator Best;
Douglas Gregore0762c92009-06-19 23:52:42 +00002453 switch (BestViableFunction(CandidateSet, Loc, Best)) {
Douglas Gregor18fe5682008-11-03 20:45:27 +00002454 case OR_Success:
2455 // We found a constructor. Return it.
2456 return cast<CXXConstructorDecl>(Best->Function);
2457
2458 case OR_No_Viable_Function:
Douglas Gregor87fd7032009-02-02 17:43:21 +00002459 if (InitEntity)
2460 Diag(Loc, diag::err_ovl_no_viable_function_in_init)
Chris Lattner4330d652009-02-17 07:29:20 +00002461 << InitEntity << Range;
Douglas Gregor87fd7032009-02-02 17:43:21 +00002462 else
2463 Diag(Loc, diag::err_ovl_no_viable_function_in_init)
Chris Lattner4330d652009-02-17 07:29:20 +00002464 << ClassType << Range;
Sebastian Redle4c452c2008-11-22 13:44:36 +00002465 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/false);
Douglas Gregor18fe5682008-11-03 20:45:27 +00002466 return 0;
2467
2468 case OR_Ambiguous:
Douglas Gregor87fd7032009-02-02 17:43:21 +00002469 if (InitEntity)
2470 Diag(Loc, diag::err_ovl_ambiguous_init) << InitEntity << Range;
2471 else
2472 Diag(Loc, diag::err_ovl_ambiguous_init) << ClassType << Range;
Douglas Gregor18fe5682008-11-03 20:45:27 +00002473 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
2474 return 0;
Douglas Gregor48f3bb92009-02-18 21:56:37 +00002475
2476 case OR_Deleted:
2477 if (InitEntity)
2478 Diag(Loc, diag::err_ovl_deleted_init)
2479 << Best->Function->isDeleted()
2480 << InitEntity << Range;
2481 else
2482 Diag(Loc, diag::err_ovl_deleted_init)
2483 << Best->Function->isDeleted()
2484 << InitEntity << Range;
2485 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
2486 return 0;
Douglas Gregor18fe5682008-11-03 20:45:27 +00002487 }
2488
2489 return 0;
2490}
2491
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002492/// CompareReferenceRelationship - Compare the two types T1 and T2 to
2493/// determine whether they are reference-related,
2494/// reference-compatible, reference-compatible with added
2495/// qualification, or incompatible, for use in C++ initialization by
2496/// reference (C++ [dcl.ref.init]p4). Neither type can be a reference
2497/// type, and the first type (T1) is the pointee type of the reference
2498/// type being initialized.
2499Sema::ReferenceCompareResult
Douglas Gregor15da57e2008-10-29 02:00:59 +00002500Sema::CompareReferenceRelationship(QualType T1, QualType T2,
2501 bool& DerivedToBase) {
Sebastian Redl7c80bd62009-03-16 23:22:08 +00002502 assert(!T1->isReferenceType() &&
2503 "T1 must be the pointee type of the reference type");
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002504 assert(!T2->isReferenceType() && "T2 cannot be a reference type");
2505
2506 T1 = Context.getCanonicalType(T1);
2507 T2 = Context.getCanonicalType(T2);
2508 QualType UnqualT1 = T1.getUnqualifiedType();
2509 QualType UnqualT2 = T2.getUnqualifiedType();
2510
2511 // C++ [dcl.init.ref]p4:
2512 // Given types “cv1 T1” and “cv2 T2,” “cv1 T1” is
2513 // reference-related to “cv2 T2” if T1 is the same type as T2, or
2514 // T1 is a base class of T2.
Douglas Gregor15da57e2008-10-29 02:00:59 +00002515 if (UnqualT1 == UnqualT2)
2516 DerivedToBase = false;
2517 else if (IsDerivedFrom(UnqualT2, UnqualT1))
2518 DerivedToBase = true;
2519 else
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002520 return Ref_Incompatible;
2521
2522 // At this point, we know that T1 and T2 are reference-related (at
2523 // least).
2524
2525 // C++ [dcl.init.ref]p4:
2526 // "cv1 T1” is reference-compatible with “cv2 T2” if T1 is
2527 // reference-related to T2 and cv1 is the same cv-qualification
2528 // as, or greater cv-qualification than, cv2. For purposes of
2529 // overload resolution, cases for which cv1 is greater
2530 // cv-qualification than cv2 are identified as
2531 // reference-compatible with added qualification (see 13.3.3.2).
2532 if (T1.getCVRQualifiers() == T2.getCVRQualifiers())
2533 return Ref_Compatible;
2534 else if (T1.isMoreQualifiedThan(T2))
2535 return Ref_Compatible_With_Added_Qualification;
2536 else
2537 return Ref_Related;
2538}
2539
2540/// CheckReferenceInit - Check the initialization of a reference
2541/// variable with the given initializer (C++ [dcl.init.ref]). Init is
2542/// the initializer (either a simple initializer or an initializer
Douglas Gregor3205a782008-10-29 23:31:03 +00002543/// list), and DeclType is the type of the declaration. When ICS is
2544/// non-null, this routine will compute the implicit conversion
2545/// sequence according to C++ [over.ics.ref] and will not produce any
2546/// diagnostics; when ICS is null, it will emit diagnostics when any
2547/// errors are found. Either way, a return value of true indicates
2548/// that there was a failure, a return value of false indicates that
2549/// the reference initialization succeeded.
Douglas Gregor225c41e2008-11-03 19:09:14 +00002550///
2551/// When @p SuppressUserConversions, user-defined conversions are
2552/// suppressed.
Douglas Gregor09f41cf2009-01-14 15:45:31 +00002553/// When @p AllowExplicit, we also permit explicit user-defined
2554/// conversion functions.
Sebastian Redle2b68332009-04-12 17:16:29 +00002555/// When @p ForceRValue, we unconditionally treat the initializer as an rvalue.
Douglas Gregor15da57e2008-10-29 02:00:59 +00002556bool
Sebastian Redl3201f6b2009-04-16 17:51:27 +00002557Sema::CheckReferenceInit(Expr *&Init, QualType DeclType,
Douglas Gregor225c41e2008-11-03 19:09:14 +00002558 ImplicitConversionSequence *ICS,
Douglas Gregor09f41cf2009-01-14 15:45:31 +00002559 bool SuppressUserConversions,
Sebastian Redle2b68332009-04-12 17:16:29 +00002560 bool AllowExplicit, bool ForceRValue) {
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002561 assert(DeclType->isReferenceType() && "Reference init needs a reference");
2562
Ted Kremenek35366a62009-07-17 17:50:17 +00002563 QualType T1 = DeclType->getAsReferenceType()->getPointeeType();
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002564 QualType T2 = Init->getType();
2565
Douglas Gregor904eed32008-11-10 20:40:00 +00002566 // If the initializer is the address of an overloaded function, try
2567 // to resolve the overloaded function. If all goes well, T2 is the
2568 // type of the resulting function.
Douglas Gregor063daf62009-03-13 18:40:31 +00002569 if (Context.getCanonicalType(T2) == Context.OverloadTy) {
Douglas Gregor904eed32008-11-10 20:40:00 +00002570 FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Init, DeclType,
2571 ICS != 0);
2572 if (Fn) {
2573 // Since we're performing this reference-initialization for
2574 // real, update the initializer with the resulting function.
Douglas Gregor48f3bb92009-02-18 21:56:37 +00002575 if (!ICS) {
2576 if (DiagnoseUseOfDecl(Fn, Init->getSourceRange().getBegin()))
2577 return true;
2578
Douglas Gregor904eed32008-11-10 20:40:00 +00002579 FixOverloadedFunctionReference(Init, Fn);
Douglas Gregor48f3bb92009-02-18 21:56:37 +00002580 }
Douglas Gregor904eed32008-11-10 20:40:00 +00002581
2582 T2 = Fn->getType();
2583 }
2584 }
2585
Douglas Gregor15da57e2008-10-29 02:00:59 +00002586 // Compute some basic properties of the types and the initializer.
Sebastian Redl7c80bd62009-03-16 23:22:08 +00002587 bool isRValRef = DeclType->isRValueReferenceType();
Douglas Gregor15da57e2008-10-29 02:00:59 +00002588 bool DerivedToBase = false;
Sebastian Redle2b68332009-04-12 17:16:29 +00002589 Expr::isLvalueResult InitLvalue = ForceRValue ? Expr::LV_InvalidExpression :
2590 Init->isLvalue(Context);
Douglas Gregor15da57e2008-10-29 02:00:59 +00002591 ReferenceCompareResult RefRelationship
2592 = CompareReferenceRelationship(T1, T2, DerivedToBase);
2593
2594 // Most paths end in a failed conversion.
2595 if (ICS)
2596 ICS->ConversionKind = ImplicitConversionSequence::BadConversion;
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002597
2598 // C++ [dcl.init.ref]p5:
2599 // A reference to type “cv1 T1” is initialized by an expression
2600 // of type “cv2 T2” as follows:
2601
2602 // -- If the initializer expression
2603
Sebastian Redla9845802009-03-29 15:27:50 +00002604 // Rvalue references cannot bind to lvalues (N2812).
2605 // There is absolutely no situation where they can. In particular, note that
2606 // this is ill-formed, even if B has a user-defined conversion to A&&:
2607 // B b;
2608 // A&& r = b;
2609 if (isRValRef && InitLvalue == Expr::LV_Valid) {
2610 if (!ICS)
2611 Diag(Init->getSourceRange().getBegin(), diag::err_lvalue_to_rvalue_ref)
2612 << Init->getSourceRange();
2613 return true;
2614 }
2615
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002616 bool BindsDirectly = false;
2617 // -- is an lvalue (but is not a bit-field), and “cv1 T1” is
2618 // reference-compatible with “cv2 T2,” or
Douglas Gregor15da57e2008-10-29 02:00:59 +00002619 //
2620 // Note that the bit-field check is skipped if we are just computing
2621 // the implicit conversion sequence (C++ [over.best.ics]p2).
Douglas Gregor33bbbc52009-05-02 02:18:30 +00002622 if (InitLvalue == Expr::LV_Valid && (ICS || !Init->getBitField()) &&
Douglas Gregor15da57e2008-10-29 02:00:59 +00002623 RefRelationship >= Ref_Compatible_With_Added_Qualification) {
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002624 BindsDirectly = true;
2625
Douglas Gregor15da57e2008-10-29 02:00:59 +00002626 if (ICS) {
2627 // C++ [over.ics.ref]p1:
2628 // When a parameter of reference type binds directly (8.5.3)
2629 // to an argument expression, the implicit conversion sequence
2630 // is the identity conversion, unless the argument expression
2631 // has a type that is a derived class of the parameter type,
2632 // in which case the implicit conversion sequence is a
2633 // derived-to-base Conversion (13.3.3.1).
2634 ICS->ConversionKind = ImplicitConversionSequence::StandardConversion;
2635 ICS->Standard.First = ICK_Identity;
2636 ICS->Standard.Second = DerivedToBase? ICK_Derived_To_Base : ICK_Identity;
2637 ICS->Standard.Third = ICK_Identity;
2638 ICS->Standard.FromTypePtr = T2.getAsOpaquePtr();
2639 ICS->Standard.ToTypePtr = T1.getAsOpaquePtr();
Douglas Gregorf70bdb92008-10-29 14:50:44 +00002640 ICS->Standard.ReferenceBinding = true;
2641 ICS->Standard.DirectBinding = true;
Sebastian Redla9845802009-03-29 15:27:50 +00002642 ICS->Standard.RRefBinding = false;
Sebastian Redl76458502009-04-17 16:30:52 +00002643 ICS->Standard.CopyConstructor = 0;
Douglas Gregor15da57e2008-10-29 02:00:59 +00002644
2645 // Nothing more to do: the inaccessibility/ambiguity check for
2646 // derived-to-base conversions is suppressed when we're
2647 // computing the implicit conversion sequence (C++
2648 // [over.best.ics]p2).
2649 return false;
2650 } else {
2651 // Perform the conversion.
Mike Stump390b4cc2009-05-16 07:39:55 +00002652 // FIXME: Binding to a subobject of the lvalue is going to require more
2653 // AST annotation than this.
Douglas Gregoreb8f3062008-11-12 17:17:38 +00002654 ImpCastExprToType(Init, T1, /*isLvalue=*/true);
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002655 }
2656 }
2657
2658 // -- has a class type (i.e., T2 is a class type) and can be
2659 // implicitly converted to an lvalue of type “cv3 T3,”
2660 // where “cv1 T1” is reference-compatible with “cv3 T3”
2661 // 92) (this conversion is selected by enumerating the
2662 // applicable conversion functions (13.3.1.6) and choosing
2663 // the best one through overload resolution (13.3)),
Sebastian Redl7c80bd62009-03-16 23:22:08 +00002664 if (!isRValRef && !SuppressUserConversions && T2->isRecordType()) {
Douglas Gregorcb9b9772008-11-10 16:14:15 +00002665 // FIXME: Look for conversions in base classes!
2666 CXXRecordDecl *T2RecordDecl
Ted Kremenek35366a62009-07-17 17:50:17 +00002667 = dyn_cast<CXXRecordDecl>(T2->getAsRecordType()->getDecl());
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002668
Douglas Gregorcb9b9772008-11-10 16:14:15 +00002669 OverloadCandidateSet CandidateSet;
2670 OverloadedFunctionDecl *Conversions
2671 = T2RecordDecl->getConversionFunctions();
2672 for (OverloadedFunctionDecl::function_iterator Func
2673 = Conversions->function_begin();
2674 Func != Conversions->function_end(); ++Func) {
2675 CXXConversionDecl *Conv = cast<CXXConversionDecl>(*Func);
Sebastian Redldfe292d2009-03-22 21:28:55 +00002676
Douglas Gregorcb9b9772008-11-10 16:14:15 +00002677 // If the conversion function doesn't return a reference type,
2678 // it can't be considered for this conversion.
Sebastian Redl7c80bd62009-03-16 23:22:08 +00002679 if (Conv->getConversionType()->isLValueReferenceType() &&
Douglas Gregor09f41cf2009-01-14 15:45:31 +00002680 (AllowExplicit || !Conv->isExplicit()))
Douglas Gregorcb9b9772008-11-10 16:14:15 +00002681 AddConversionCandidate(Conv, Init, DeclType, CandidateSet);
2682 }
2683
2684 OverloadCandidateSet::iterator Best;
Douglas Gregore0762c92009-06-19 23:52:42 +00002685 switch (BestViableFunction(CandidateSet, Init->getLocStart(), Best)) {
Douglas Gregorcb9b9772008-11-10 16:14:15 +00002686 case OR_Success:
2687 // This is a direct binding.
2688 BindsDirectly = true;
2689
2690 if (ICS) {
2691 // C++ [over.ics.ref]p1:
2692 //
2693 // [...] If the parameter binds directly to the result of
2694 // applying a conversion function to the argument
2695 // expression, the implicit conversion sequence is a
2696 // user-defined conversion sequence (13.3.3.1.2), with the
2697 // second standard conversion sequence either an identity
2698 // conversion or, if the conversion function returns an
2699 // entity of a type that is a derived class of the parameter
2700 // type, a derived-to-base Conversion.
2701 ICS->ConversionKind = ImplicitConversionSequence::UserDefinedConversion;
2702 ICS->UserDefined.Before = Best->Conversions[0].Standard;
2703 ICS->UserDefined.After = Best->FinalConversion;
2704 ICS->UserDefined.ConversionFunction = Best->Function;
2705 assert(ICS->UserDefined.After.ReferenceBinding &&
2706 ICS->UserDefined.After.DirectBinding &&
2707 "Expected a direct reference binding!");
2708 return false;
2709 } else {
2710 // Perform the conversion.
Mike Stump390b4cc2009-05-16 07:39:55 +00002711 // FIXME: Binding to a subobject of the lvalue is going to require more
2712 // AST annotation than this.
Douglas Gregoreb8f3062008-11-12 17:17:38 +00002713 ImpCastExprToType(Init, T1, /*isLvalue=*/true);
Douglas Gregorcb9b9772008-11-10 16:14:15 +00002714 }
2715 break;
2716
2717 case OR_Ambiguous:
2718 assert(false && "Ambiguous reference binding conversions not implemented.");
2719 return true;
2720
2721 case OR_No_Viable_Function:
Douglas Gregor48f3bb92009-02-18 21:56:37 +00002722 case OR_Deleted:
2723 // There was no suitable conversion, or we found a deleted
2724 // conversion; continue with other checks.
Douglas Gregorcb9b9772008-11-10 16:14:15 +00002725 break;
2726 }
2727 }
2728
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002729 if (BindsDirectly) {
2730 // C++ [dcl.init.ref]p4:
2731 // [...] In all cases where the reference-related or
2732 // reference-compatible relationship of two types is used to
2733 // establish the validity of a reference binding, and T1 is a
2734 // base class of T2, a program that necessitates such a binding
2735 // is ill-formed if T1 is an inaccessible (clause 11) or
2736 // ambiguous (10.2) base class of T2.
2737 //
2738 // Note that we only check this condition when we're allowed to
2739 // complain about errors, because we should not be checking for
2740 // ambiguity (or inaccessibility) unless the reference binding
2741 // actually happens.
Douglas Gregor15da57e2008-10-29 02:00:59 +00002742 if (DerivedToBase)
2743 return CheckDerivedToBaseConversion(T2, T1,
2744 Init->getSourceRange().getBegin(),
2745 Init->getSourceRange());
2746 else
2747 return false;
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002748 }
2749
2750 // -- Otherwise, the reference shall be to a non-volatile const
Sebastian Redla9845802009-03-29 15:27:50 +00002751 // type (i.e., cv1 shall be const), or the reference shall be an
2752 // rvalue reference and the initializer expression shall be an rvalue.
Sebastian Redl7c80bd62009-03-16 23:22:08 +00002753 if (!isRValRef && T1.getCVRQualifiers() != QualType::Const) {
Douglas Gregor15da57e2008-10-29 02:00:59 +00002754 if (!ICS)
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002755 Diag(Init->getSourceRange().getBegin(),
Chris Lattnerc9c7c4e2008-11-18 22:52:51 +00002756 diag::err_not_reference_to_const_init)
Chris Lattnerd1625842008-11-24 06:25:27 +00002757 << T1 << (InitLvalue != Expr::LV_Valid? "temporary" : "value")
2758 << T2 << Init->getSourceRange();
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002759 return true;
2760 }
2761
2762 // -- If the initializer expression is an rvalue, with T2 a
2763 // class type, and “cv1 T1” is reference-compatible with
2764 // “cv2 T2,” the reference is bound in one of the
2765 // following ways (the choice is implementation-defined):
2766 //
2767 // -- The reference is bound to the object represented by
2768 // the rvalue (see 3.10) or to a sub-object within that
2769 // object.
2770 //
2771 // -- A temporary of type “cv1 T2” [sic] is created, and
2772 // a constructor is called to copy the entire rvalue
2773 // object into the temporary. The reference is bound to
2774 // the temporary or to a sub-object within the
2775 // temporary.
2776 //
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002777 // The constructor that would be used to make the copy
2778 // shall be callable whether or not the copy is actually
2779 // done.
2780 //
Sebastian Redla9845802009-03-29 15:27:50 +00002781 // Note that C++0x [dcl.init.ref]p5 takes away this implementation
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002782 // freedom, so we will always take the first option and never build
2783 // a temporary in this case. FIXME: We will, however, have to check
2784 // for the presence of a copy constructor in C++98/03 mode.
2785 if (InitLvalue != Expr::LV_Valid && T2->isRecordType() &&
Douglas Gregor15da57e2008-10-29 02:00:59 +00002786 RefRelationship >= Ref_Compatible_With_Added_Qualification) {
2787 if (ICS) {
2788 ICS->ConversionKind = ImplicitConversionSequence::StandardConversion;
2789 ICS->Standard.First = ICK_Identity;
2790 ICS->Standard.Second = DerivedToBase? ICK_Derived_To_Base : ICK_Identity;
2791 ICS->Standard.Third = ICK_Identity;
2792 ICS->Standard.FromTypePtr = T2.getAsOpaquePtr();
2793 ICS->Standard.ToTypePtr = T1.getAsOpaquePtr();
Douglas Gregorf70bdb92008-10-29 14:50:44 +00002794 ICS->Standard.ReferenceBinding = true;
Sebastian Redla9845802009-03-29 15:27:50 +00002795 ICS->Standard.DirectBinding = false;
2796 ICS->Standard.RRefBinding = isRValRef;
Sebastian Redl76458502009-04-17 16:30:52 +00002797 ICS->Standard.CopyConstructor = 0;
Douglas Gregor15da57e2008-10-29 02:00:59 +00002798 } else {
Mike Stump390b4cc2009-05-16 07:39:55 +00002799 // FIXME: Binding to a subobject of the rvalue is going to require more
2800 // AST annotation than this.
Anders Carlsson68654802009-05-19 00:38:24 +00002801 ImpCastExprToType(Init, T1, /*isLvalue=*/false);
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002802 }
2803 return false;
2804 }
2805
2806 // -- Otherwise, a temporary of type “cv1 T1” is created and
2807 // initialized from the initializer expression using the
2808 // rules for a non-reference copy initialization (8.5). The
2809 // reference is then bound to the temporary. If T1 is
2810 // reference-related to T2, cv1 must be the same
2811 // cv-qualification as, or greater cv-qualification than,
2812 // cv2; otherwise, the program is ill-formed.
2813 if (RefRelationship == Ref_Related) {
2814 // If cv1 == cv2 or cv1 is a greater cv-qualified than cv2, then
2815 // we would be reference-compatible or reference-compatible with
2816 // added qualification. But that wasn't the case, so the reference
2817 // initialization fails.
Douglas Gregor15da57e2008-10-29 02:00:59 +00002818 if (!ICS)
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002819 Diag(Init->getSourceRange().getBegin(),
Chris Lattnerc9c7c4e2008-11-18 22:52:51 +00002820 diag::err_reference_init_drops_quals)
Chris Lattnerd1625842008-11-24 06:25:27 +00002821 << T1 << (InitLvalue != Expr::LV_Valid? "temporary" : "value")
2822 << T2 << Init->getSourceRange();
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002823 return true;
2824 }
2825
Douglas Gregor734d9862009-01-30 23:27:23 +00002826 // If at least one of the types is a class type, the types are not
2827 // related, and we aren't allowed any user conversions, the
2828 // reference binding fails. This case is important for breaking
2829 // recursion, since TryImplicitConversion below will attempt to
2830 // create a temporary through the use of a copy constructor.
2831 if (SuppressUserConversions && RefRelationship == Ref_Incompatible &&
2832 (T1->isRecordType() || T2->isRecordType())) {
2833 if (!ICS)
2834 Diag(Init->getSourceRange().getBegin(),
2835 diag::err_typecheck_convert_incompatible)
2836 << DeclType << Init->getType() << "initializing" << Init->getSourceRange();
2837 return true;
2838 }
2839
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002840 // Actually try to convert the initializer to T1.
Douglas Gregor15da57e2008-10-29 02:00:59 +00002841 if (ICS) {
Sebastian Redla9845802009-03-29 15:27:50 +00002842 // C++ [over.ics.ref]p2:
2843 //
2844 // When a parameter of reference type is not bound directly to
2845 // an argument expression, the conversion sequence is the one
2846 // required to convert the argument expression to the
2847 // underlying type of the reference according to
2848 // 13.3.3.1. Conceptually, this conversion sequence corresponds
2849 // to copy-initializing a temporary of the underlying type with
2850 // the argument expression. Any difference in top-level
2851 // cv-qualification is subsumed by the initialization itself
2852 // and does not constitute a conversion.
Douglas Gregor225c41e2008-11-03 19:09:14 +00002853 *ICS = TryImplicitConversion(Init, T1, SuppressUserConversions);
Sebastian Redla9845802009-03-29 15:27:50 +00002854 // Of course, that's still a reference binding.
2855 if (ICS->ConversionKind == ImplicitConversionSequence::StandardConversion) {
2856 ICS->Standard.ReferenceBinding = true;
2857 ICS->Standard.RRefBinding = isRValRef;
2858 } else if(ICS->ConversionKind ==
2859 ImplicitConversionSequence::UserDefinedConversion) {
2860 ICS->UserDefined.After.ReferenceBinding = true;
2861 ICS->UserDefined.After.RRefBinding = isRValRef;
2862 }
Douglas Gregor15da57e2008-10-29 02:00:59 +00002863 return ICS->ConversionKind == ImplicitConversionSequence::BadConversion;
2864 } else {
Douglas Gregor45920e82008-12-19 17:40:08 +00002865 return PerformImplicitConversion(Init, T1, "initializing");
Douglas Gregor15da57e2008-10-29 02:00:59 +00002866 }
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002867}
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002868
2869/// CheckOverloadedOperatorDeclaration - Check whether the declaration
2870/// of this overloaded operator is well-formed. If so, returns false;
2871/// otherwise, emits appropriate diagnostics and returns true.
2872bool Sema::CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl) {
Douglas Gregor43c7bad2008-11-17 16:14:12 +00002873 assert(FnDecl && FnDecl->isOverloadedOperator() &&
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002874 "Expected an overloaded operator declaration");
2875
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002876 OverloadedOperatorKind Op = FnDecl->getOverloadedOperator();
2877
2878 // C++ [over.oper]p5:
2879 // The allocation and deallocation functions, operator new,
2880 // operator new[], operator delete and operator delete[], are
2881 // described completely in 3.7.3. The attributes and restrictions
2882 // found in the rest of this subclause do not apply to them unless
2883 // explicitly stated in 3.7.3.
Mike Stump390b4cc2009-05-16 07:39:55 +00002884 // FIXME: Write a separate routine for checking this. For now, just allow it.
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002885 if (Op == OO_New || Op == OO_Array_New ||
2886 Op == OO_Delete || Op == OO_Array_Delete)
2887 return false;
2888
2889 // C++ [over.oper]p6:
2890 // An operator function shall either be a non-static member
2891 // function or be a non-member function and have at least one
2892 // parameter whose type is a class, a reference to a class, an
2893 // enumeration, or a reference to an enumeration.
Douglas Gregor43c7bad2008-11-17 16:14:12 +00002894 if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) {
2895 if (MethodDecl->isStatic())
2896 return Diag(FnDecl->getLocation(),
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002897 diag::err_operator_overload_static) << FnDecl->getDeclName();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002898 } else {
2899 bool ClassOrEnumParam = false;
Douglas Gregor43c7bad2008-11-17 16:14:12 +00002900 for (FunctionDecl::param_iterator Param = FnDecl->param_begin(),
2901 ParamEnd = FnDecl->param_end();
2902 Param != ParamEnd; ++Param) {
2903 QualType ParamType = (*Param)->getType().getNonReferenceType();
Eli Friedman5d39dee2009-06-27 05:59:59 +00002904 if (ParamType->isDependentType() || ParamType->isRecordType() ||
2905 ParamType->isEnumeralType()) {
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002906 ClassOrEnumParam = true;
2907 break;
2908 }
2909 }
2910
Douglas Gregor43c7bad2008-11-17 16:14:12 +00002911 if (!ClassOrEnumParam)
2912 return Diag(FnDecl->getLocation(),
Chris Lattnerf3a41af2008-11-20 06:38:18 +00002913 diag::err_operator_overload_needs_class_or_enum)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002914 << FnDecl->getDeclName();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002915 }
2916
2917 // C++ [over.oper]p8:
2918 // An operator function cannot have default arguments (8.3.6),
2919 // except where explicitly stated below.
2920 //
2921 // Only the function-call operator allows default arguments
2922 // (C++ [over.call]p1).
2923 if (Op != OO_Call) {
2924 for (FunctionDecl::param_iterator Param = FnDecl->param_begin();
2925 Param != FnDecl->param_end(); ++Param) {
Douglas Gregor61366e92008-12-24 00:01:03 +00002926 if ((*Param)->hasUnparsedDefaultArg())
2927 return Diag((*Param)->getLocation(),
2928 diag::err_operator_overload_default_arg)
2929 << FnDecl->getDeclName();
2930 else if (Expr *DefArg = (*Param)->getDefaultArg())
Douglas Gregor43c7bad2008-11-17 16:14:12 +00002931 return Diag((*Param)->getLocation(),
Chris Lattnerd3a94e22008-11-20 06:06:08 +00002932 diag::err_operator_overload_default_arg)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002933 << FnDecl->getDeclName() << DefArg->getSourceRange();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002934 }
2935 }
2936
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00002937 static const bool OperatorUses[NUM_OVERLOADED_OPERATORS][3] = {
2938 { false, false, false }
2939#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
2940 , { Unary, Binary, MemberOnly }
2941#include "clang/Basic/OperatorKinds.def"
2942 };
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002943
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00002944 bool CanBeUnaryOperator = OperatorUses[Op][0];
2945 bool CanBeBinaryOperator = OperatorUses[Op][1];
2946 bool MustBeMemberOperator = OperatorUses[Op][2];
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002947
2948 // C++ [over.oper]p8:
2949 // [...] Operator functions cannot have more or fewer parameters
2950 // than the number required for the corresponding operator, as
2951 // described in the rest of this subclause.
Douglas Gregor43c7bad2008-11-17 16:14:12 +00002952 unsigned NumParams = FnDecl->getNumParams()
2953 + (isa<CXXMethodDecl>(FnDecl)? 1 : 0);
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002954 if (Op != OO_Call &&
2955 ((NumParams == 1 && !CanBeUnaryOperator) ||
2956 (NumParams == 2 && !CanBeBinaryOperator) ||
2957 (NumParams < 1) || (NumParams > 2))) {
2958 // We have the wrong number of parameters.
Chris Lattner416e46f2008-11-21 07:57:12 +00002959 unsigned ErrorKind;
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00002960 if (CanBeUnaryOperator && CanBeBinaryOperator) {
Chris Lattner416e46f2008-11-21 07:57:12 +00002961 ErrorKind = 2; // 2 -> unary or binary.
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00002962 } else if (CanBeUnaryOperator) {
Chris Lattner416e46f2008-11-21 07:57:12 +00002963 ErrorKind = 0; // 0 -> unary
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00002964 } else {
Chris Lattneraf7ae4e2008-11-21 07:50:02 +00002965 assert(CanBeBinaryOperator &&
2966 "All non-call overloaded operators are unary or binary!");
Chris Lattner416e46f2008-11-21 07:57:12 +00002967 ErrorKind = 1; // 1 -> binary
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00002968 }
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002969
Chris Lattner416e46f2008-11-21 07:57:12 +00002970 return Diag(FnDecl->getLocation(), diag::err_operator_overload_must_be)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002971 << FnDecl->getDeclName() << NumParams << ErrorKind;
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002972 }
Sebastian Redl64b45f72009-01-05 20:52:13 +00002973
Douglas Gregor43c7bad2008-11-17 16:14:12 +00002974 // Overloaded operators other than operator() cannot be variadic.
2975 if (Op != OO_Call &&
Douglas Gregor72564e72009-02-26 23:50:07 +00002976 FnDecl->getType()->getAsFunctionProtoType()->isVariadic()) {
Chris Lattnerf3a41af2008-11-20 06:38:18 +00002977 return Diag(FnDecl->getLocation(), diag::err_operator_overload_variadic)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002978 << FnDecl->getDeclName();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002979 }
2980
2981 // Some operators must be non-static member functions.
Douglas Gregor43c7bad2008-11-17 16:14:12 +00002982 if (MustBeMemberOperator && !isa<CXXMethodDecl>(FnDecl)) {
2983 return Diag(FnDecl->getLocation(),
Chris Lattnerf3a41af2008-11-20 06:38:18 +00002984 diag::err_operator_overload_must_be_member)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002985 << FnDecl->getDeclName();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002986 }
2987
2988 // C++ [over.inc]p1:
2989 // The user-defined function called operator++ implements the
2990 // prefix and postfix ++ operator. If this function is a member
2991 // function with no parameters, or a non-member function with one
2992 // parameter of class or enumeration type, it defines the prefix
2993 // increment operator ++ for objects of that type. If the function
2994 // is a member function with one parameter (which shall be of type
2995 // int) or a non-member function with two parameters (the second
2996 // of which shall be of type int), it defines the postfix
2997 // increment operator ++ for objects of that type.
2998 if ((Op == OO_PlusPlus || Op == OO_MinusMinus) && NumParams == 2) {
2999 ParmVarDecl *LastParam = FnDecl->getParamDecl(FnDecl->getNumParams() - 1);
3000 bool ParamIsInt = false;
3001 if (const BuiltinType *BT = LastParam->getType()->getAsBuiltinType())
3002 ParamIsInt = BT->getKind() == BuiltinType::Int;
3003
Chris Lattneraf7ae4e2008-11-21 07:50:02 +00003004 if (!ParamIsInt)
3005 return Diag(LastParam->getLocation(),
3006 diag::err_operator_overload_post_incdec_must_be_int)
Chris Lattnerd1625842008-11-24 06:25:27 +00003007 << LastParam->getType() << (Op == OO_MinusMinus);
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00003008 }
3009
Sebastian Redl64b45f72009-01-05 20:52:13 +00003010 // Notify the class if it got an assignment operator.
3011 if (Op == OO_Equal) {
3012 // Would have returned earlier otherwise.
3013 assert(isa<CXXMethodDecl>(FnDecl) &&
3014 "Overloaded = not member, but not filtered.");
3015 CXXMethodDecl *Method = cast<CXXMethodDecl>(FnDecl);
3016 Method->getParent()->addedAssignmentOperator(Context, Method);
3017 }
3018
Douglas Gregor43c7bad2008-11-17 16:14:12 +00003019 return false;
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00003020}
Chris Lattner5a003a42008-12-17 07:09:26 +00003021
Douglas Gregor074149e2009-01-05 19:45:36 +00003022/// ActOnStartLinkageSpecification - Parsed the beginning of a C++
3023/// linkage specification, including the language and (if present)
3024/// the '{'. ExternLoc is the location of the 'extern', LangLoc is
3025/// the location of the language string literal, which is provided
3026/// by Lang/StrSize. LBraceLoc, if valid, provides the location of
3027/// the '{' brace. Otherwise, this linkage specification does not
3028/// have any braces.
Chris Lattnerb28317a2009-03-28 19:18:32 +00003029Sema::DeclPtrTy Sema::ActOnStartLinkageSpecification(Scope *S,
3030 SourceLocation ExternLoc,
3031 SourceLocation LangLoc,
3032 const char *Lang,
3033 unsigned StrSize,
3034 SourceLocation LBraceLoc) {
Chris Lattnercc98eac2008-12-17 07:13:27 +00003035 LinkageSpecDecl::LanguageIDs Language;
3036 if (strncmp(Lang, "\"C\"", StrSize) == 0)
3037 Language = LinkageSpecDecl::lang_c;
3038 else if (strncmp(Lang, "\"C++\"", StrSize) == 0)
3039 Language = LinkageSpecDecl::lang_cxx;
3040 else {
Douglas Gregor074149e2009-01-05 19:45:36 +00003041 Diag(LangLoc, diag::err_bad_language);
Chris Lattnerb28317a2009-03-28 19:18:32 +00003042 return DeclPtrTy();
Chris Lattnercc98eac2008-12-17 07:13:27 +00003043 }
3044
3045 // FIXME: Add all the various semantics of linkage specifications
3046
Douglas Gregor074149e2009-01-05 19:45:36 +00003047 LinkageSpecDecl *D = LinkageSpecDecl::Create(Context, CurContext,
3048 LangLoc, Language,
3049 LBraceLoc.isValid());
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00003050 CurContext->addDecl(D);
Douglas Gregor074149e2009-01-05 19:45:36 +00003051 PushDeclContext(S, D);
Chris Lattnerb28317a2009-03-28 19:18:32 +00003052 return DeclPtrTy::make(D);
Chris Lattnercc98eac2008-12-17 07:13:27 +00003053}
3054
Douglas Gregor074149e2009-01-05 19:45:36 +00003055/// ActOnFinishLinkageSpecification - Completely the definition of
3056/// the C++ linkage specification LinkageSpec. If RBraceLoc is
3057/// valid, it's the position of the closing '}' brace in a linkage
3058/// specification that uses braces.
Chris Lattnerb28317a2009-03-28 19:18:32 +00003059Sema::DeclPtrTy Sema::ActOnFinishLinkageSpecification(Scope *S,
3060 DeclPtrTy LinkageSpec,
3061 SourceLocation RBraceLoc) {
Douglas Gregor074149e2009-01-05 19:45:36 +00003062 if (LinkageSpec)
3063 PopDeclContext();
3064 return LinkageSpec;
Chris Lattner5a003a42008-12-17 07:09:26 +00003065}
3066
Douglas Gregord308e622009-05-18 20:51:54 +00003067/// \brief Perform semantic analysis for the variable declaration that
3068/// occurs within a C++ catch clause, returning the newly-created
3069/// variable.
3070VarDecl *Sema::BuildExceptionDeclaration(Scope *S, QualType ExDeclType,
3071 IdentifierInfo *Name,
3072 SourceLocation Loc,
3073 SourceRange Range) {
3074 bool Invalid = false;
Sebastian Redl4b07b292008-12-22 19:15:10 +00003075
3076 // Arrays and functions decay.
3077 if (ExDeclType->isArrayType())
3078 ExDeclType = Context.getArrayDecayedType(ExDeclType);
3079 else if (ExDeclType->isFunctionType())
3080 ExDeclType = Context.getPointerType(ExDeclType);
3081
3082 // C++ 15.3p1: The exception-declaration shall not denote an incomplete type.
3083 // The exception-declaration shall not denote a pointer or reference to an
3084 // incomplete type, other than [cv] void*.
Sebastian Redlf2e21e52009-03-22 23:49:27 +00003085 // N2844 forbids rvalue references.
Douglas Gregor2f2433f2009-05-18 21:08:14 +00003086 if(!ExDeclType->isDependentType() && ExDeclType->isRValueReferenceType()) {
Douglas Gregord308e622009-05-18 20:51:54 +00003087 Diag(Loc, diag::err_catch_rvalue_ref) << Range;
Sebastian Redlf2e21e52009-03-22 23:49:27 +00003088 Invalid = true;
3089 }
Douglas Gregord308e622009-05-18 20:51:54 +00003090
Sebastian Redl4b07b292008-12-22 19:15:10 +00003091 QualType BaseType = ExDeclType;
3092 int Mode = 0; // 0 for direct type, 1 for pointer, 2 for reference
Douglas Gregor4ec339f2009-01-19 19:26:10 +00003093 unsigned DK = diag::err_catch_incomplete;
Ted Kremenek35366a62009-07-17 17:50:17 +00003094 if (const PointerType *Ptr = BaseType->getAsPointerType()) {
Sebastian Redl4b07b292008-12-22 19:15:10 +00003095 BaseType = Ptr->getPointeeType();
3096 Mode = 1;
Douglas Gregor4ec339f2009-01-19 19:26:10 +00003097 DK = diag::err_catch_incomplete_ptr;
Ted Kremenek35366a62009-07-17 17:50:17 +00003098 } else if(const ReferenceType *Ref = BaseType->getAsReferenceType()) {
Sebastian Redlf2e21e52009-03-22 23:49:27 +00003099 // For the purpose of error recovery, we treat rvalue refs like lvalue refs.
Sebastian Redl4b07b292008-12-22 19:15:10 +00003100 BaseType = Ref->getPointeeType();
3101 Mode = 2;
Douglas Gregor4ec339f2009-01-19 19:26:10 +00003102 DK = diag::err_catch_incomplete_ref;
Sebastian Redl4b07b292008-12-22 19:15:10 +00003103 }
Sebastian Redlf2e21e52009-03-22 23:49:27 +00003104 if (!Invalid && (Mode == 0 || !BaseType->isVoidType()) &&
Douglas Gregord308e622009-05-18 20:51:54 +00003105 !BaseType->isDependentType() && RequireCompleteType(Loc, BaseType, DK))
Sebastian Redl4b07b292008-12-22 19:15:10 +00003106 Invalid = true;
Sebastian Redl4b07b292008-12-22 19:15:10 +00003107
Douglas Gregord308e622009-05-18 20:51:54 +00003108 if (!Invalid && !ExDeclType->isDependentType() &&
3109 RequireNonAbstractType(Loc, ExDeclType,
3110 diag::err_abstract_type_in_decl,
3111 AbstractVariableType))
Sebastian Redlfef9f592009-04-27 21:03:30 +00003112 Invalid = true;
3113
Douglas Gregord308e622009-05-18 20:51:54 +00003114 // FIXME: Need to test for ability to copy-construct and destroy the
3115 // exception variable.
3116
Sebastian Redl8351da02008-12-22 21:35:02 +00003117 // FIXME: Need to check for abstract classes.
3118
Douglas Gregord308e622009-05-18 20:51:54 +00003119 VarDecl *ExDecl = VarDecl::Create(Context, CurContext, Loc,
3120 Name, ExDeclType, VarDecl::None,
3121 Range.getBegin());
3122
3123 if (Invalid)
3124 ExDecl->setInvalidDecl();
3125
3126 return ExDecl;
3127}
3128
3129/// ActOnExceptionDeclarator - Parsed the exception-declarator in a C++ catch
3130/// handler.
3131Sema::DeclPtrTy Sema::ActOnExceptionDeclarator(Scope *S, Declarator &D) {
3132 QualType ExDeclType = GetTypeForDeclarator(D, S);
3133
3134 bool Invalid = D.isInvalidType();
Sebastian Redl4b07b292008-12-22 19:15:10 +00003135 IdentifierInfo *II = D.getIdentifier();
Douglas Gregor47b9a1c2009-02-04 17:27:36 +00003136 if (NamedDecl *PrevDecl = LookupName(S, II, LookupOrdinaryName)) {
Sebastian Redl4b07b292008-12-22 19:15:10 +00003137 // The scope should be freshly made just for us. There is just no way
3138 // it contains any previous declaration.
Chris Lattnerb28317a2009-03-28 19:18:32 +00003139 assert(!S->isDeclScope(DeclPtrTy::make(PrevDecl)));
Sebastian Redl4b07b292008-12-22 19:15:10 +00003140 if (PrevDecl->isTemplateParameter()) {
3141 // Maybe we will complain about the shadowed template parameter.
3142 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
Sebastian Redl4b07b292008-12-22 19:15:10 +00003143 }
3144 }
3145
Chris Lattnereaaebc72009-04-25 08:06:05 +00003146 if (D.getCXXScopeSpec().isSet() && !Invalid) {
Sebastian Redl4b07b292008-12-22 19:15:10 +00003147 Diag(D.getIdentifierLoc(), diag::err_qualified_catch_declarator)
3148 << D.getCXXScopeSpec().getRange();
Chris Lattnereaaebc72009-04-25 08:06:05 +00003149 Invalid = true;
Sebastian Redl4b07b292008-12-22 19:15:10 +00003150 }
3151
Douglas Gregord308e622009-05-18 20:51:54 +00003152 VarDecl *ExDecl = BuildExceptionDeclaration(S, ExDeclType,
3153 D.getIdentifier(),
3154 D.getIdentifierLoc(),
3155 D.getDeclSpec().getSourceRange());
3156
Chris Lattnereaaebc72009-04-25 08:06:05 +00003157 if (Invalid)
3158 ExDecl->setInvalidDecl();
3159
Sebastian Redl4b07b292008-12-22 19:15:10 +00003160 // Add the exception declaration into this scope.
Sebastian Redl4b07b292008-12-22 19:15:10 +00003161 if (II)
Douglas Gregord308e622009-05-18 20:51:54 +00003162 PushOnScopeChains(ExDecl, S);
3163 else
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00003164 CurContext->addDecl(ExDecl);
Sebastian Redl4b07b292008-12-22 19:15:10 +00003165
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00003166 ProcessDeclAttributes(S, ExDecl, D);
Chris Lattnerb28317a2009-03-28 19:18:32 +00003167 return DeclPtrTy::make(ExDecl);
Sebastian Redl4b07b292008-12-22 19:15:10 +00003168}
Anders Carlssonfb311762009-03-14 00:25:26 +00003169
Chris Lattnerb28317a2009-03-28 19:18:32 +00003170Sema::DeclPtrTy Sema::ActOnStaticAssertDeclaration(SourceLocation AssertLoc,
3171 ExprArg assertexpr,
3172 ExprArg assertmessageexpr) {
Anders Carlssonfb311762009-03-14 00:25:26 +00003173 Expr *AssertExpr = (Expr *)assertexpr.get();
3174 StringLiteral *AssertMessage =
3175 cast<StringLiteral>((Expr *)assertmessageexpr.get());
3176
Anders Carlssonc3082412009-03-14 00:33:21 +00003177 if (!AssertExpr->isTypeDependent() && !AssertExpr->isValueDependent()) {
3178 llvm::APSInt Value(32);
3179 if (!AssertExpr->isIntegerConstantExpr(Value, Context)) {
3180 Diag(AssertLoc, diag::err_static_assert_expression_is_not_constant) <<
3181 AssertExpr->getSourceRange();
Chris Lattnerb28317a2009-03-28 19:18:32 +00003182 return DeclPtrTy();
Anders Carlssonc3082412009-03-14 00:33:21 +00003183 }
Anders Carlssonfb311762009-03-14 00:25:26 +00003184
Anders Carlssonc3082412009-03-14 00:33:21 +00003185 if (Value == 0) {
3186 std::string str(AssertMessage->getStrData(),
3187 AssertMessage->getByteLength());
Anders Carlsson94b15fb2009-03-15 18:44:04 +00003188 Diag(AssertLoc, diag::err_static_assert_failed)
3189 << str << AssertExpr->getSourceRange();
Anders Carlssonc3082412009-03-14 00:33:21 +00003190 }
3191 }
3192
Anders Carlsson77d81422009-03-15 17:35:16 +00003193 assertexpr.release();
3194 assertmessageexpr.release();
Anders Carlssonfb311762009-03-14 00:25:26 +00003195 Decl *Decl = StaticAssertDecl::Create(Context, CurContext, AssertLoc,
3196 AssertExpr, AssertMessage);
Anders Carlssonfb311762009-03-14 00:25:26 +00003197
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00003198 CurContext->addDecl(Decl);
Chris Lattnerb28317a2009-03-28 19:18:32 +00003199 return DeclPtrTy::make(Decl);
Anders Carlssonfb311762009-03-14 00:25:26 +00003200}
Sebastian Redl50de12f2009-03-24 22:27:57 +00003201
Anders Carlsson00338362009-05-11 22:55:49 +00003202bool Sema::ActOnFriendDecl(Scope *S, SourceLocation FriendLoc, DeclPtrTy Dcl) {
3203 if (!(S->getFlags() & Scope::ClassScope)) {
3204 Diag(FriendLoc, diag::err_friend_decl_outside_class);
3205 return true;
3206 }
3207
3208 return false;
3209}
3210
Chris Lattnerb28317a2009-03-28 19:18:32 +00003211void Sema::SetDeclDeleted(DeclPtrTy dcl, SourceLocation DelLoc) {
3212 Decl *Dcl = dcl.getAs<Decl>();
Sebastian Redl50de12f2009-03-24 22:27:57 +00003213 FunctionDecl *Fn = dyn_cast<FunctionDecl>(Dcl);
3214 if (!Fn) {
3215 Diag(DelLoc, diag::err_deleted_non_function);
3216 return;
3217 }
3218 if (const FunctionDecl *Prev = Fn->getPreviousDeclaration()) {
3219 Diag(DelLoc, diag::err_deleted_decl_not_first);
3220 Diag(Prev->getLocation(), diag::note_previous_declaration);
3221 // If the declaration wasn't the first, we delete the function anyway for
3222 // recovery.
3223 }
3224 Fn->setDeleted();
3225}
Sebastian Redl13e88542009-04-27 21:33:24 +00003226
3227static void SearchForReturnInStmt(Sema &Self, Stmt *S) {
3228 for (Stmt::child_iterator CI = S->child_begin(), E = S->child_end(); CI != E;
3229 ++CI) {
3230 Stmt *SubStmt = *CI;
3231 if (!SubStmt)
3232 continue;
3233 if (isa<ReturnStmt>(SubStmt))
3234 Self.Diag(SubStmt->getSourceRange().getBegin(),
3235 diag::err_return_in_constructor_handler);
3236 if (!isa<Expr>(SubStmt))
3237 SearchForReturnInStmt(Self, SubStmt);
3238 }
3239}
3240
3241void Sema::DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock) {
3242 for (unsigned I = 0, E = TryBlock->getNumHandlers(); I != E; ++I) {
3243 CXXCatchStmt *Handler = TryBlock->getHandler(I);
3244 SearchForReturnInStmt(*this, Handler);
3245 }
3246}
Anders Carlssond7ba27d2009-05-14 01:09:04 +00003247
3248bool Sema::CheckOverridingFunctionReturnType(const CXXMethodDecl *New,
3249 const CXXMethodDecl *Old) {
3250 QualType NewTy = New->getType()->getAsFunctionType()->getResultType();
3251 QualType OldTy = Old->getType()->getAsFunctionType()->getResultType();
3252
3253 QualType CNewTy = Context.getCanonicalType(NewTy);
3254 QualType COldTy = Context.getCanonicalType(OldTy);
3255
3256 if (CNewTy == COldTy &&
3257 CNewTy.getCVRQualifiers() == COldTy.getCVRQualifiers())
3258 return false;
3259
Anders Carlssonc3a68b22009-05-14 19:52:19 +00003260 // Check if the return types are covariant
3261 QualType NewClassTy, OldClassTy;
3262
3263 /// Both types must be pointers or references to classes.
3264 if (PointerType *NewPT = dyn_cast<PointerType>(NewTy)) {
3265 if (PointerType *OldPT = dyn_cast<PointerType>(OldTy)) {
3266 NewClassTy = NewPT->getPointeeType();
3267 OldClassTy = OldPT->getPointeeType();
3268 }
3269 } else if (ReferenceType *NewRT = dyn_cast<ReferenceType>(NewTy)) {
3270 if (ReferenceType *OldRT = dyn_cast<ReferenceType>(OldTy)) {
3271 NewClassTy = NewRT->getPointeeType();
3272 OldClassTy = OldRT->getPointeeType();
3273 }
3274 }
3275
3276 // The return types aren't either both pointers or references to a class type.
3277 if (NewClassTy.isNull()) {
3278 Diag(New->getLocation(),
3279 diag::err_different_return_type_for_overriding_virtual_function)
3280 << New->getDeclName() << NewTy << OldTy;
3281 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
3282
3283 return true;
3284 }
Anders Carlssond7ba27d2009-05-14 01:09:04 +00003285
Anders Carlssonc3a68b22009-05-14 19:52:19 +00003286 if (NewClassTy.getUnqualifiedType() != OldClassTy.getUnqualifiedType()) {
3287 // Check if the new class derives from the old class.
3288 if (!IsDerivedFrom(NewClassTy, OldClassTy)) {
3289 Diag(New->getLocation(),
3290 diag::err_covariant_return_not_derived)
3291 << New->getDeclName() << NewTy << OldTy;
3292 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
3293 return true;
3294 }
3295
3296 // Check if we the conversion from derived to base is valid.
3297 if (CheckDerivedToBaseConversion(NewClassTy, OldClassTy,
3298 diag::err_covariant_return_inaccessible_base,
3299 diag::err_covariant_return_ambiguous_derived_to_base_conv,
3300 // FIXME: Should this point to the return type?
3301 New->getLocation(), SourceRange(), New->getDeclName())) {
3302 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
3303 return true;
3304 }
3305 }
3306
3307 // The qualifiers of the return types must be the same.
3308 if (CNewTy.getCVRQualifiers() != COldTy.getCVRQualifiers()) {
3309 Diag(New->getLocation(),
3310 diag::err_covariant_return_type_different_qualifications)
Anders Carlssond7ba27d2009-05-14 01:09:04 +00003311 << New->getDeclName() << NewTy << OldTy;
Anders Carlssonc3a68b22009-05-14 19:52:19 +00003312 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
3313 return true;
3314 };
3315
3316
3317 // The new class type must have the same or less qualifiers as the old type.
3318 if (NewClassTy.isMoreQualifiedThan(OldClassTy)) {
3319 Diag(New->getLocation(),
3320 diag::err_covariant_return_type_class_type_more_qualified)
3321 << New->getDeclName() << NewTy << OldTy;
3322 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
3323 return true;
3324 };
3325
3326 return false;
Anders Carlssond7ba27d2009-05-14 01:09:04 +00003327}
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00003328
Sebastian Redl23c7d062009-07-07 20:29:57 +00003329bool Sema::CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New,
3330 const CXXMethodDecl *Old)
3331{
3332 return CheckExceptionSpecSubset(diag::err_override_exception_spec,
3333 diag::note_overridden_virtual_function,
3334 Old->getType()->getAsFunctionProtoType(),
3335 Old->getLocation(),
3336 New->getType()->getAsFunctionProtoType(),
3337 New->getLocation());
3338}
3339
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00003340/// ActOnCXXEnterDeclInitializer - Invoked when we are about to parse an
3341/// initializer for the declaration 'Dcl'.
3342/// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
3343/// static data member of class X, names should be looked up in the scope of
3344/// class X.
3345void Sema::ActOnCXXEnterDeclInitializer(Scope *S, DeclPtrTy Dcl) {
3346 Decl *D = Dcl.getAs<Decl>();
3347 // If there is no declaration, there was an error parsing it.
3348 if (D == 0)
3349 return;
3350
3351 // Check whether it is a declaration with a nested name specifier like
3352 // int foo::bar;
3353 if (!D->isOutOfLine())
3354 return;
3355
3356 // C++ [basic.lookup.unqual]p13
3357 //
3358 // A name used in the definition of a static data member of class X
3359 // (after the qualified-id of the static member) is looked up as if the name
3360 // was used in a member function of X.
3361
3362 // Change current context into the context of the initializing declaration.
Argyrios Kyrtzidis1d175532009-06-17 23:15:40 +00003363 EnterDeclaratorContext(S, D->getDeclContext());
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00003364}
3365
3366/// ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an
3367/// initializer for the declaration 'Dcl'.
3368void Sema::ActOnCXXExitDeclInitializer(Scope *S, DeclPtrTy Dcl) {
3369 Decl *D = Dcl.getAs<Decl>();
3370 // If there is no declaration, there was an error parsing it.
3371 if (D == 0)
3372 return;
3373
3374 // Check whether it is a declaration with a nested name specifier like
3375 // int foo::bar;
3376 if (!D->isOutOfLine())
3377 return;
3378
3379 assert(S->getEntity() == D->getDeclContext() && "Context imbalance!");
Argyrios Kyrtzidis1d175532009-06-17 23:15:40 +00003380 ExitDeclaratorContext(S);
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00003381}