1//===------ 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"
15#include "SemaInherit.h"
16#include "clang/AST/ASTConsumer.h"
17#include "clang/AST/ASTContext.h"
18#include "clang/AST/DeclVisitor.h"
19#include "clang/AST/TypeOrdering.h"
20#include "clang/AST/StmtVisitor.h"
21#include "clang/Lex/Preprocessor.h"
22#include "clang/Parse/DeclSpec.h"
23#include "llvm/ADT/STLExtras.h"
24#include "llvm/Support/Compiler.h"
25#include <algorithm> // for std::equal
26#include <map>
27
28using namespace clang;
29
30//===----------------------------------------------------------------------===//
31// CheckDefaultArgumentVisitor
32//===----------------------------------------------------------------------===//
33
34namespace {
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
41 : public StmtVisitor<CheckDefaultArgumentVisitor, bool> {
42 Expr *DefaultArg;
43 Sema *S;
44
45 public:
46 CheckDefaultArgumentVisitor(Expr *defarg, Sema *s)
47 : DefaultArg(defarg), S(s) {}
48
49 bool VisitExpr(Expr *Node);
50 bool VisitDeclRefExpr(DeclRefExpr *DRE);
51 bool VisitCXXThisExpr(CXXThisExpr *ThisE);
52 };
53
54 /// VisitExpr - Visit all of the children of this expression.
55 bool CheckDefaultArgumentVisitor::VisitExpr(Expr *Node) {
56 bool IsInvalid = false;
57 for (Stmt::child_iterator I = Node->child_begin(),
58 E = Node->child_end(); I != E; ++I)
59 IsInvalid |= Visit(*I);
60 return IsInvalid;
61 }
62
63 /// 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) {
67 NamedDecl *Decl = DRE->getDecl();
68 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(),
78 diag::err_param_default_argument_references_param)
79 << Param->getDeclName() << DefaultArg->getSourceRange();
80 } else if (VarDecl *VDecl = dyn_cast<VarDecl>(Decl)) {
81 // C++ [dcl.fct.default]p7
82 // Local variables shall not be used in default argument
83 // expressions.
84 if (VDecl->isBlockVarDecl())
85 return S->Diag(DRE->getSourceRange().getBegin(),
86 diag::err_param_default_argument_references_local)
87 << VDecl->getDeclName() << DefaultArg->getSourceRange();
88 }
89
90 return false;
91 }
92
93 /// 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(),
99 diag::err_param_default_argument_references_this)
100 << ThisE->getSourceRange();
101 }
102}
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.
107void
108Sema::ActOnParamDefaultArgument(DeclPtrTy param, SourceLocation EqualLoc,
109 ExprArg defarg) {
110 if (!param || !defarg.get())
111 return;
112
113 ParmVarDecl *Param = cast<ParmVarDecl>(param.getAs<Decl>());
114 UnparsedDefaultArgLocs.erase(Param);
115
116 ExprOwningPtr<Expr> DefaultArg(this, defarg.takeAs<Expr>());
117 QualType ParamType = Param->getType();
118
119 // Default arguments are only permitted in C++
120 if (!getLangOptions().CPlusPlus) {
121 Diag(EqualLoc, diag::err_param_default_argument)
122 << DefaultArg->getSourceRange();
123 Param->setInvalidDecl();
124 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).
133 Expr *DefaultArgPtr = DefaultArg.get();
134 bool DefaultInitFailed = CheckInitializerTypes(DefaultArgPtr, ParamType,
135 EqualLoc,
136 Param->getDeclName(),
137 /*DirectInit=*/false);
138 if (DefaultArgPtr != DefaultArg.get()) {
139 DefaultArg.take();
140 DefaultArg.reset(DefaultArgPtr);
141 }
142 if (DefaultInitFailed) {
143 return;
144 }
145
146 // Check that the default argument is well-formed
147 CheckDefaultArgumentVisitor DefaultArgChecker(DefaultArg.get(), this);
148 if (DefaultArgChecker.Visit(DefaultArg.get())) {
149 Param->setInvalidDecl();
150 return;
151 }
152
153 DefaultArgPtr = MaybeCreateCXXExprWithTemporaries(DefaultArg.take(),
154 /*DestroyTemps=*/false);
155
156 // Okay: add the default argument to the parameter
157 Param->setDefaultArg(DefaultArgPtr);
158}
159
160/// 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.
164void Sema::ActOnParamUnparsedDefaultArgument(DeclPtrTy param,
165 SourceLocation EqualLoc,
166 SourceLocation ArgLoc) {
167 if (!param)
168 return;
169
170 ParmVarDecl *Param = cast<ParmVarDecl>(param.getAs<Decl>());
171 if (Param)
172 Param->setUnparsedDefaultArg();
173
174 UnparsedDefaultArgLocs[Param] = ArgLoc;
175}
176
177/// ActOnParamDefaultArgumentError - Parsing or semantic analysis of
178/// the default argument for the parameter param failed.
179void Sema::ActOnParamDefaultArgumentError(DeclPtrTy param) {
180 if (!param)
181 return;
182
183 ParmVarDecl *Param = cast<ParmVarDecl>(param.getAs<Decl>());
184
185 Param->setInvalidDecl();
186
187 UnparsedDefaultArgLocs.erase(Param);
188}
189
190/// 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.
203 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
204 DeclaratorChunk &chunk = D.getTypeObject(i);
205 if (chunk.Kind == DeclaratorChunk::Function) {
206 for (unsigned argIdx = 0, e = chunk.Fun.NumArgs; argIdx != e; ++argIdx) {
207 ParmVarDecl *Param =
208 cast<ParmVarDecl>(chunk.Fun.ArgInfo[argIdx].Param.getAs<Decl>());
209 if (Param->hasUnparsedDefaultArg()) {
210 CachedTokens *Toks = chunk.Fun.ArgInfo[argIdx].DefaultArgTokens;
211 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;
215 } else if (Param->getDefaultArg()) {
216 Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
217 << Param->getDefaultArg()->getSourceRange();
218 Param->setDefaultArg(0);
219 }
220 }
221 }
222 }
223}
224
225// MergeCXXFunctionDecl - Merge two declarations of the same C++
226// function, once we already know that they have the same
227// 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
232 // 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(),
251 diag::err_param_default_argument_redefinition)
252 << NewParam->getDefaultArg()->getSourceRange();
253 Diag(OldParam->getLocation(), diag::note_previous_definition);
254 Invalid = true;
255 } else if (OldParam->getDefaultArg()) {
256 // Merge the old default argument into the new parameter
257 NewParam->setDefaultArg(OldParam->getDefaultArg());
258 }
259 }
260
261 if (CheckEquivalentExceptionSpec(
262 Old->getType()->getAsFunctionProtoType(), Old->getLocation(),
263 New->getType()->getAsFunctionProtoType(), New->getLocation())) {
264 Invalid = true;
265 }
266
267 return Invalid;
268}
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()) {
294 if (Param->isInvalidDecl())
295 /* We already complained about this parameter. */;
296 else if (Param->getIdentifier())
297 Diag(Param->getLocation(),
298 diag::err_param_default_argument_missing_name)
299 << Param->getIdentifier();
300 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);
315 if (Param->hasDefaultArg()) {
316 if (!Param->hasUnparsedDefaultArg())
317 Param->getDefaultArg()->Destroy(Context);
318 Param->setDefaultArg(0);
319 }
320 }
321 }
322}
323
324/// 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.
328bool Sema::isCurrentClassName(const IdentifierInfo &II, Scope *,
329 const CXXScopeSpec *SS) {
330 CXXRecordDecl *CurDecl;
331 if (SS && SS->isSet() && !SS->isInvalid()) {
332 DeclContext *DC = computeDeclContext(*SS);
333 CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC);
334 } else
335 CurDecl = dyn_cast_or_null<CXXRecordDecl>(CurContext);
336
337 if (CurDecl)
338 return &II == CurDecl->getIdentifier();
339 else
340 return false;
341}
342
343/// \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.
382 if (RequireCompleteType(BaseLoc, BaseType, diag::err_incomplete_base_class,
383 SpecifierRange))
384 return 0;
385
386 // If the base class is polymorphic, the new one is, too.
387 RecordDecl *BaseDecl = BaseType->getAsRecordType()->getDecl();
388 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
399 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 }
410
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());
416
417 // 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
424/// 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.
429Sema::BaseResult
430Sema::ActOnBaseSpecifier(DeclPtrTy classdecl, SourceRange SpecifierRange,
431 bool Virtual, AccessSpecifier Access,
432 TypeTy *basetype, SourceLocation BaseLoc) {
433 if (!classdecl)
434 return true;
435
436 AdjustDeclIfTemplate(classdecl);
437 CXXRecordDecl *Class = cast<CXXRecordDecl>(classdecl.getAs<Decl>());
438 QualType BaseType = QualType::getFromOpaquePtr(basetype);
439 if (CXXBaseSpecifier *BaseSpec = CheckBaseSpecifier(Class, SpecifierRange,
440 Virtual, Access,
441 BaseType, BaseLoc))
442 return BaseSpec;
443
444 return true;
445}
446
447/// \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;
453
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
456 // that the key is always the unqualified canonical type of the base
457 // class.
458 std::map<QualType, CXXBaseSpecifier*, QualTypeOrdering> KnownBaseTypes;
459
460 // Copy non-redundant base specifiers into permanent storage.
461 unsigned NumGoodBases = 0;
462 bool Invalid = false;
463 for (unsigned idx = 0; idx < NumBases; ++idx) {
464 QualType NewBaseType
465 = Context.getCanonicalType(Bases[idx]->getType());
466 NewBaseType = NewBaseType.getUnqualifiedType();
467
468 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.
472 Diag(Bases[idx]->getSourceRange().getBegin(),
473 diag::err_duplicate_base_class)
474 << KnownBaseTypes[NewBaseType]->getType()
475 << Bases[idx]->getSourceRange();
476
477 // Delete the duplicate base class specifier; we're going to
478 // overwrite its pointer later.
479 delete Bases[idx];
480
481 Invalid = true;
482 } else {
483 // Okay, add this new base class.
484 KnownBaseTypes[NewBaseType] = Bases[idx];
485 Bases[NumGoodBases++] = Bases[idx];
486 }
487 }
488
489 // Attach the remaining base class specifiers to the derived class.
490 Class->setBases(Context, Bases, NumGoodBases);
491
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)
495 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.
503void Sema::ActOnBaseSpecifiers(DeclPtrTy ClassDecl, BaseTy **Bases,
504 unsigned NumBases) {
505 if (!ClassDecl || !Bases || !NumBases)
506 return;
507
508 AdjustDeclIfTemplate(ClassDecl);
509 AttachBaseSpecifiers(cast<CXXRecordDecl>(ClassDecl.getAs<Decl>()),
510 (CXXBaseSpecifier**)(Bases), NumBases);
511}
512
513//===----------------------------------------------------------------------===//
514// C++ class member Handling
515//===----------------------------------------------------------------------===//
516
517/// 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
520/// any.
521Sema::DeclPtrTy
522Sema::ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS, Declarator &D,
523 ExprTy *BW, ExprTy *InitExpr, bool Deleted) {
524 const DeclSpec &DS = D.getDeclSpec();
525 DeclarationName Name = GetNameForDeclarator(D);
526 Expr *BitWidth = static_cast<Expr*>(BW);
527 Expr *Init = static_cast<Expr*>(InitExpr);
528 SourceLocation Loc = D.getIdentifierLoc();
529
530 bool isFunc = D.isFunctionDeclarator();
531
532 // C++ 9.2p6: A member shall not be declared to have automatic storage
533 // duration (auto, register) or with the extern storage-class-specifier.
534 // 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.
537 switch (DS.getStorageClassSpec()) {
538 case DeclSpec::SCS_unspecified:
539 case DeclSpec::SCS_typedef:
540 case DeclSpec::SCS_static:
541 // FALL THROUGH.
542 break;
543 case DeclSpec::SCS_mutable:
544 if (isFunc) {
545 if (DS.getStorageClassSpecLoc().isValid())
546 Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_function);
547 else
548 Diag(DS.getThreadSpecLoc(), diag::err_mutable_function);
549
550 // FIXME: It would be nicer if the keyword was ignored only for this
551 // declarator. Otherwise we could get follow-up errors.
552 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);
565 // FIXME: It would be nicer if the keyword was ignored only for this
566 // declarator. Otherwise we could get follow-up errors.
567 D.getMutableDeclSpec().ClearStorageClassSpecs();
568 }
569 }
570 break;
571 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
580 if (!isFunc &&
581 D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_typename &&
582 D.getNumTypeObjects() == 0) {
583 // Check also for this case:
584 //
585 // typedef int f();
586 // f a;
587 //
588 QualType TDType = QualType::getFromOpaquePtr(DS.getTypeRep());
589 isFunc = TDType->isFunctionType();
590 }
591
592 bool isInstField = ((DS.getStorageClassSpec() == DeclSpec::SCS_unspecified ||
593 DS.getStorageClassSpec() == DeclSpec::SCS_mutable) &&
594 !isFunc);
595
596 Decl *Member;
597 if (isInstField) {
598 Member = HandleField(S, cast<CXXRecordDecl>(CurContext), Loc, D, BitWidth,
599 AS);
600 assert(Member && "HandleField never returns null");
601 } else {
602 Member = ActOnDeclarator(S, D).getAs<Decl>();
603 if (!Member) {
604 if (BitWidth) DeleteExpr(BitWidth);
605 return DeclPtrTy();
606 }
607
608 // Non-instance-fields can't have a bitfield.
609 if (BitWidth) {
610 if (Member->isInvalidDecl()) {
611 // don't emit another diagnostic.
612 } else if (isa<VarDecl>(Member)) {
613 // 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)
625 << Name << cast<ValueDecl>(Member)->getType()
626 << BitWidth->getSourceRange();
627 }
628
629 DeleteExpr(BitWidth);
630 BitWidth = 0;
631 Member->setInvalidDecl();
632 }
633
634 Member->setAccess(AS);
635 }
636
637 assert((Name || isInstField) && "No identifier for non-field ?");
638
639 if (Init)
640 AddInitializerToDecl(DeclPtrTy::make(Member), ExprArg(*this, Init), false);
641 if (Deleted) // FIXME: Source location is not very good.
642 SetDeclDeleted(DeclPtrTy::make(Member), D.getSourceRange().getBegin());
643
644 if (isInstField) {
645 FieldCollector->Add(cast<FieldDecl>(Member));
646 return DeclPtrTy();
647 }
648 return DeclPtrTy::make(Member);
649}
650
651/// ActOnMemInitializer - Handle a C++ member initializer.
652Sema::MemInitResult
653Sema::ActOnMemInitializer(DeclPtrTy ConstructorD,
654 Scope *S,
655 const CXXScopeSpec &SS,
656 IdentifierInfo *MemberOrBase,
657 TypeTy *TemplateTypeTy,
658 SourceLocation IdLoc,
659 SourceLocation LParenLoc,
660 ExprTy **Args, unsigned NumArgs,
661 SourceLocation *CommaLocs,
662 SourceLocation RParenLoc) {
663 if (!ConstructorD)
664 return true;
665
666 CXXConstructorDecl *Constructor
667 = dyn_cast<CXXConstructorDecl>(ConstructorD.getAs<Decl>());
668 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. ]
688 if (!SS.getScopeRep() && !TemplateTypeTy) {
689 // 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);
695
696 // FIXME: Handle members of an anonymous union.
697
698 if (Member) {
699 // FIXME: Perform direct initialization of the member.
700 return new CXXBaseOrMemberInitializer(Member, (Expr **)Args, NumArgs,
701 IdLoc);
702 }
703 }
704 // It didn't name a member, so see if it names a class.
705 TypeTy *BaseTy = TemplateTypeTy ? TemplateTypeTy
706 : getTypeName(*MemberOrBase, IdLoc, S, &SS);
707 if (!BaseTy)
708 return Diag(IdLoc, diag::err_mem_init_not_member_or_class)
709 << MemberOrBase << SourceRange(IdLoc, RParenLoc);
710
711 QualType BaseType = QualType::getFromOpaquePtr(BaseTy);
712 if (!BaseType->isRecordType() && !BaseType->isDependentType())
713 return Diag(IdLoc, diag::err_base_init_does_not_name_class)
714 << BaseType << SourceRange(IdLoc, RParenLoc);
715
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.
737 // FIXME: We might be able to short-circuit this if we know in advance that
738 // there are no virtual bases.
739 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)
761 return Diag(IdLoc, diag::err_base_init_direct_and_virtual)
762 << MemberOrBase << SourceRange(IdLoc, RParenLoc);
763 // 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
772
773 return new CXXBaseOrMemberInitializer(BaseType, (Expr **)Args, NumArgs,
774 IdLoc);
775}
776
777void Sema::ActOnMemInitializers(DeclPtrTy ConstructorDecl,
778 SourceLocation ColonLoc,
779 MemInitTy **MemInits, unsigned NumMemInits) {
780 if (!ConstructorDecl)
781 return;
782
783 CXXConstructorDecl *Constructor
784 = dyn_cast<CXXConstructorDecl>(ConstructorDecl.getAs<Decl>());
785
786 if (!Constructor) {
787 Diag(ColonLoc, diag::err_only_constructors_take_base_inits);
788 return;
789 }
790 llvm::DenseMap<void*, CXXBaseOrMemberInitializer *>Members;
791 bool err = false;
792 for (unsigned i = 0; i < NumMemInits; i++) {
793 CXXBaseOrMemberInitializer *Member =
794 static_cast<CXXBaseOrMemberInitializer*>(MemInits[i]);
795 void *KeyToMember = Member->getBaseOrMember();
796 // For fields injected into the class via declaration of an anonymous union,
797 // use its anonymous union class declaration as the unique key.
798 if (FieldDecl *Field = Member->getMember())
799 if (Field->getDeclContext()->isRecord() &&
800 cast<RecordDecl>(Field->getDeclContext())->isAnonymousStructOrUnion())
801 KeyToMember = static_cast<void *>(Field->getDeclContext());
802 CXXBaseOrMemberInitializer *&PrevMember = Members[KeyToMember];
803 if (!PrevMember) {
804 PrevMember = Member;
805 continue;
806 }
807 if (FieldDecl *Field = Member->getMember())
808 Diag(Member->getSourceLocation(),
809 diag::error_multiple_mem_initialization)
810 << Field->getNameAsString();
811 else {
812 Type *BaseClass = Member->getBaseClass();
813 assert(BaseClass && "ActOnMemInitializers - neither field or base");
814 Diag(Member->getSourceLocation(),
815 diag::error_multiple_base_initialization)
816 << BaseClass->getDesugaredType(true);
817 }
818 Diag(PrevMember->getSourceLocation(), diag::note_previous_initializer)
819 << 0;
820 err = true;
821 }
822 if (!err)
823 Constructor->setBaseOrMemberInitializers(Context,
824 reinterpret_cast<CXXBaseOrMemberInitializer **>(MemInits),
825 NumMemInits);
826}
827
828namespace {
829 /// PureVirtualMethodCollector - traverses a class and its superclasses
830 /// and determines if it has any pure virtual methods.
831 class VISIBILITY_HIDDEN PureVirtualMethodCollector {
832 ASTContext &Context;
833
834 public:
835 typedef llvm::SmallVector<const CXXMethodDecl*, 8> MethodList;
836
837 private:
838 MethodList Methods;
839
840 void Collect(const CXXRecordDecl* RD, MethodList& Methods);
841
842 public:
843 PureVirtualMethodCollector(ASTContext &Ctx, const CXXRecordDecl* RD)
844 : Context(Ctx) {
845
846 MethodList List;
847 Collect(RD, List);
848
849 // Copy the temporary list to methods, and make sure to ignore any
850 // null entries.
851 for (size_t i = 0, e = List.size(); i != e; ++i) {
852 if (List[i])
853 Methods.push_back(List[i]);
854 }
855 }
856
857 bool empty() const { return Methods.empty(); }
858
859 MethodList::const_iterator methods_begin() { return Methods.begin(); }
860 MethodList::const_iterator methods_end() { return Methods.end(); }
861 };
862
863 void PureVirtualMethodCollector::Collect(const CXXRecordDecl* RD,
864 MethodList& Methods) {
865 // First, collect the pure virtual methods for the base classes.
866 for (CXXRecordDecl::base_class_const_iterator Base = RD->bases_begin(),
867 BaseEnd = RD->bases_end(); Base != BaseEnd; ++Base) {
868 if (const RecordType *RT = Base->getType()->getAsRecordType()) {
869 const CXXRecordDecl *BaseDecl = cast<CXXRecordDecl>(RT->getDecl());
870 if (BaseDecl && BaseDecl->isAbstract())
871 Collect(BaseDecl, Methods);
872 }
873 }
874
875 // Next, zero out any pure virtual methods that this class overrides.
876 typedef llvm::SmallPtrSet<const CXXMethodDecl*, 4> MethodSetTy;
877
878 MethodSetTy OverriddenMethods;
879 size_t MethodsSize = Methods.size();
880
881 for (RecordDecl::decl_iterator i = RD->decls_begin(), e = RD->decls_end();
882 i != e; ++i) {
883 // Traverse the record, looking for methods.
884 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(*i)) {
885 // If the method is pre virtual, add it to the methods vector.
886 if (MD->isPure()) {
887 Methods.push_back(MD);
888 continue;
889 }
890
891 // Otherwise, record all the overridden methods in our set.
892 for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(),
893 E = MD->end_overridden_methods(); I != E; ++I) {
894 // Keep track of the overridden methods.
895 OverriddenMethods.insert(*I);
896 }
897 }
898 }
899
900 // Now go through the methods and zero out all the ones we know are
901 // overridden.
902 for (size_t i = 0, e = MethodsSize; i != e; ++i) {
903 if (OverriddenMethods.count(Methods[i]))
904 Methods[i] = 0;
905 }
906
907 }
908}
909
910bool Sema::RequireNonAbstractType(SourceLocation Loc, QualType T,
911 unsigned DiagID, AbstractDiagSelID SelID,
912 const CXXRecordDecl *CurrentRD) {
913
914 if (!getLangOptions().CPlusPlus)
915 return false;
916
917 if (const ArrayType *AT = Context.getAsArrayType(T))
918 return RequireNonAbstractType(Loc, AT->getElementType(), DiagID, SelID,
919 CurrentRD);
920
921 if (const PointerType *PT = T->getAsPointerType()) {
922 // Find the innermost pointer type.
923 while (const PointerType *T = PT->getPointeeType()->getAsPointerType())
924 PT = T;
925
926 if (const ArrayType *AT = Context.getAsArrayType(PT->getPointeeType()))
927 return RequireNonAbstractType(Loc, AT->getElementType(), DiagID, SelID,
928 CurrentRD);
929 }
930
931 const RecordType *RT = T->getAsRecordType();
932 if (!RT)
933 return false;
934
935 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl());
936 if (!RD)
937 return false;
938
939 if (CurrentRD && CurrentRD != RD)
940 return false;
941
942 if (!RD->isAbstract())
943 return false;
944
945 Diag(Loc, DiagID) << RD->getDeclName() << SelID;
946
947 // Check if we've already emitted the list of pure virtual functions for this
948 // class.
949 if (PureVirtualClassDiagSet && PureVirtualClassDiagSet->count(RD))
950 return true;
951
952 PureVirtualMethodCollector Collector(Context, RD);
953
954 for (PureVirtualMethodCollector::MethodList::const_iterator I =
955 Collector.methods_begin(), E = Collector.methods_end(); I != E; ++I) {
956 const CXXMethodDecl *MD = *I;
957
958 Diag(MD->getLocation(), diag::note_pure_virtual_function) <<
959 MD->getDeclName();
960 }
961
962 if (!PureVirtualClassDiagSet)
963 PureVirtualClassDiagSet.reset(new RecordDeclSetTy);
964 PureVirtualClassDiagSet->insert(RD);
965
966 return true;
967}
968
969namespace {
970 class VISIBILITY_HIDDEN AbstractClassUsageDiagnoser
971 : public DeclVisitor<AbstractClassUsageDiagnoser, bool> {
972 Sema &SemaRef;
973 CXXRecordDecl *AbstractClass;
974
975 bool VisitDeclContext(const DeclContext *DC) {
976 bool Invalid = false;
977
978 for (CXXRecordDecl::decl_iterator I = DC->decls_begin(),
979 E = DC->decls_end(); I != E; ++I)
980 Invalid |= Visit(*I);
981
982 return Invalid;
983 }
984
985 public:
986 AbstractClassUsageDiagnoser(Sema& SemaRef, CXXRecordDecl *ac)
987 : SemaRef(SemaRef), AbstractClass(ac) {
988 Visit(SemaRef.Context.getTranslationUnitDecl());
989 }
990
991 bool VisitFunctionDecl(const FunctionDecl *FD) {
992 if (FD->isThisDeclarationADefinition()) {
993 // No need to do the check if we're in a definition, because it requires
994 // that the return/param types are complete.
995 // because that requires
996 return VisitDeclContext(FD);
997 }
998
999 // Check the return type.
1000 QualType RTy = FD->getType()->getAsFunctionType()->getResultType();
1001 bool Invalid =
1002 SemaRef.RequireNonAbstractType(FD->getLocation(), RTy,
1003 diag::err_abstract_type_in_decl,
1004 Sema::AbstractReturnType,
1005 AbstractClass);
1006
1007 for (FunctionDecl::param_const_iterator I = FD->param_begin(),
1008 E = FD->param_end(); I != E; ++I) {
1009 const ParmVarDecl *VD = *I;
1010 Invalid |=
1011 SemaRef.RequireNonAbstractType(VD->getLocation(),
1012 VD->getOriginalType(),
1013 diag::err_abstract_type_in_decl,
1014 Sema::AbstractParamType,
1015 AbstractClass);
1016 }
1017
1018 return Invalid;
1019 }
1020
1021 bool VisitDecl(const Decl* D) {
1022 if (const DeclContext *DC = dyn_cast<DeclContext>(D))
1023 return VisitDeclContext(DC);
1024
1025 return false;
1026 }
1027 };
1028}
1029
1030void Sema::ActOnFinishCXXMemberSpecification(Scope* S, SourceLocation RLoc,
1031 DeclPtrTy TagDecl,
1032 SourceLocation LBrac,
1033 SourceLocation RBrac) {
1034 if (!TagDecl)
1035 return;
1036
1037 AdjustDeclIfTemplate(TagDecl);
1038 ActOnFields(S, RLoc, TagDecl,
1039 (DeclPtrTy*)FieldCollector->getCurFields(),
1040 FieldCollector->getCurNumFields(), LBrac, RBrac, 0);
1041
1042 CXXRecordDecl *RD = cast<CXXRecordDecl>(TagDecl.getAs<Decl>());
1043 if (!RD->isAbstract()) {
1044 // Collect all the pure virtual methods and see if this is an abstract
1045 // class after all.
1046 PureVirtualMethodCollector Collector(Context, RD);
1047 if (!Collector.empty())
1048 RD->setAbstract(true);
1049 }
1050
1051 if (RD->isAbstract())
1052 AbstractClassUsageDiagnoser(*this, RD);
1053
1054 if (RD->hasTrivialConstructor() || RD->hasTrivialDestructor()) {
1055 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
1056 i != e; ++i) {
1057 // All the nonstatic data members must have trivial constructors.
1058 QualType FTy = i->getType();
1059 while (const ArrayType *AT = Context.getAsArrayType(FTy))
1060 FTy = AT->getElementType();
1061
1062 if (const RecordType *RT = FTy->getAsRecordType()) {
1063 CXXRecordDecl *FieldRD = cast<CXXRecordDecl>(RT->getDecl());
1064
1065 if (!FieldRD->hasTrivialConstructor())
1066 RD->setHasTrivialConstructor(false);
1067 if (!FieldRD->hasTrivialDestructor())
1068 RD->setHasTrivialDestructor(false);
1069
1070 // If RD has neither a trivial constructor nor a trivial destructor
1071 // we don't need to continue checking.
1072 if (!RD->hasTrivialConstructor() && !RD->hasTrivialDestructor())
1073 break;
1074 }
1075 }
1076 }
1077
1078 if (!RD->isDependentType())
1079 AddImplicitlyDeclaredMembersToClass(RD);
1080}
1081
1082/// AddImplicitlyDeclaredMembersToClass - Adds any implicitly-declared
1083/// special functions, such as the default constructor, copy
1084/// constructor, or destructor, to the given C++ class (C++
1085/// [special]p1). This routine can only be executed just before the
1086/// definition of the class is complete.
1087void Sema::AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl) {
1088 QualType ClassType = Context.getTypeDeclType(ClassDecl);
1089 ClassType = Context.getCanonicalType(ClassType);
1090
1091 // FIXME: Implicit declarations have exception specifications, which are
1092 // the union of the specifications of the implicitly called functions.
1093
1094 if (!ClassDecl->hasUserDeclaredConstructor()) {
1095 // C++ [class.ctor]p5:
1096 // A default constructor for a class X is a constructor of class X
1097 // that can be called without an argument. If there is no
1098 // user-declared constructor for class X, a default constructor is
1099 // implicitly declared. An implicitly-declared default constructor
1100 // is an inline public member of its class.
1101 DeclarationName Name
1102 = Context.DeclarationNames.getCXXConstructorName(ClassType);
1103 CXXConstructorDecl *DefaultCon =
1104 CXXConstructorDecl::Create(Context, ClassDecl,
1105 ClassDecl->getLocation(), Name,
1106 Context.getFunctionType(Context.VoidTy,
1107 0, 0, false, 0),
1108 /*isExplicit=*/false,
1109 /*isInline=*/true,
1110 /*isImplicitlyDeclared=*/true);
1111 DefaultCon->setAccess(AS_public);
1112 DefaultCon->setImplicit();
1113 ClassDecl->addDecl(DefaultCon);
1114 }
1115
1116 if (!ClassDecl->hasUserDeclaredCopyConstructor()) {
1117 // C++ [class.copy]p4:
1118 // If the class definition does not explicitly declare a copy
1119 // constructor, one is declared implicitly.
1120
1121 // C++ [class.copy]p5:
1122 // The implicitly-declared copy constructor for a class X will
1123 // have the form
1124 //
1125 // X::X(const X&)
1126 //
1127 // if
1128 bool HasConstCopyConstructor = true;
1129
1130 // -- each direct or virtual base class B of X has a copy
1131 // constructor whose first parameter is of type const B& or
1132 // const volatile B&, and
1133 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin();
1134 HasConstCopyConstructor && Base != ClassDecl->bases_end(); ++Base) {
1135 const CXXRecordDecl *BaseClassDecl
1136 = cast<CXXRecordDecl>(Base->getType()->getAsRecordType()->getDecl());
1137 HasConstCopyConstructor
1138 = BaseClassDecl->hasConstCopyConstructor(Context);
1139 }
1140
1141 // -- for all the nonstatic data members of X that are of a
1142 // class type M (or array thereof), each such class type
1143 // has a copy constructor whose first parameter is of type
1144 // const M& or const volatile M&.
1145 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin();
1146 HasConstCopyConstructor && Field != ClassDecl->field_end();
1147 ++Field) {
1148 QualType FieldType = (*Field)->getType();
1149 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
1150 FieldType = Array->getElementType();
1151 if (const RecordType *FieldClassType = FieldType->getAsRecordType()) {
1152 const CXXRecordDecl *FieldClassDecl
1153 = cast<CXXRecordDecl>(FieldClassType->getDecl());
1154 HasConstCopyConstructor
1155 = FieldClassDecl->hasConstCopyConstructor(Context);
1156 }
1157 }
1158
1159 // Otherwise, the implicitly declared copy constructor will have
1160 // the form
1161 //
1162 // X::X(X&)
1163 QualType ArgType = ClassType;
1164 if (HasConstCopyConstructor)
1165 ArgType = ArgType.withConst();
1166 ArgType = Context.getLValueReferenceType(ArgType);
1167
1168 // An implicitly-declared copy constructor is an inline public
1169 // member of its class.
1170 DeclarationName Name
1171 = Context.DeclarationNames.getCXXConstructorName(ClassType);
1172 CXXConstructorDecl *CopyConstructor
1173 = CXXConstructorDecl::Create(Context, ClassDecl,
1174 ClassDecl->getLocation(), Name,
1175 Context.getFunctionType(Context.VoidTy,
1176 &ArgType, 1,
1177 false, 0),
1178 /*isExplicit=*/false,
1179 /*isInline=*/true,
1180 /*isImplicitlyDeclared=*/true);
1181 CopyConstructor->setAccess(AS_public);
1182 CopyConstructor->setImplicit();
1183
1184 // Add the parameter to the constructor.
1185 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyConstructor,
1186 ClassDecl->getLocation(),
1187 /*IdentifierInfo=*/0,
1188 ArgType, VarDecl::None, 0);
1189 CopyConstructor->setParams(Context, &FromParam, 1);
1190 ClassDecl->addDecl(CopyConstructor);
1191 }
1192
1193 if (!ClassDecl->hasUserDeclaredCopyAssignment()) {
1194 // Note: The following rules are largely analoguous to the copy
1195 // constructor rules. Note that virtual bases are not taken into account
1196 // for determining the argument type of the operator. Note also that
1197 // operators taking an object instead of a reference are allowed.
1198 //
1199 // C++ [class.copy]p10:
1200 // If the class definition does not explicitly declare a copy
1201 // assignment operator, one is declared implicitly.
1202 // The implicitly-defined copy assignment operator for a class X
1203 // will have the form
1204 //
1205 // X& X::operator=(const X&)
1206 //
1207 // if
1208 bool HasConstCopyAssignment = true;
1209
1210 // -- each direct base class B of X has a copy assignment operator
1211 // whose parameter is of type const B&, const volatile B& or B,
1212 // and
1213 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin();
1214 HasConstCopyAssignment && Base != ClassDecl->bases_end(); ++Base) {
1215 const CXXRecordDecl *BaseClassDecl
1216 = cast<CXXRecordDecl>(Base->getType()->getAsRecordType()->getDecl());
1217 HasConstCopyAssignment = BaseClassDecl->hasConstCopyAssignment(Context);
1218 }
1219
1220 // -- for all the nonstatic data members of X that are of a class
1221 // type M (or array thereof), each such class type has a copy
1222 // assignment operator whose parameter is of type const M&,
1223 // const volatile M& or M.
1224 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin();
1225 HasConstCopyAssignment && Field != ClassDecl->field_end();
1226 ++Field) {
1227 QualType FieldType = (*Field)->getType();
1228 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
1229 FieldType = Array->getElementType();
1230 if (const RecordType *FieldClassType = FieldType->getAsRecordType()) {
1231 const CXXRecordDecl *FieldClassDecl
1232 = cast<CXXRecordDecl>(FieldClassType->getDecl());
1233 HasConstCopyAssignment
1234 = FieldClassDecl->hasConstCopyAssignment(Context);
1235 }
1236 }
1237
1238 // Otherwise, the implicitly declared copy assignment operator will
1239 // have the form
1240 //
1241 // X& X::operator=(X&)
1242 QualType ArgType = ClassType;
1243 QualType RetType = Context.getLValueReferenceType(ArgType);
1244 if (HasConstCopyAssignment)
1245 ArgType = ArgType.withConst();
1246 ArgType = Context.getLValueReferenceType(ArgType);
1247
1248 // An implicitly-declared copy assignment operator is an inline public
1249 // member of its class.
1250 DeclarationName Name =
1251 Context.DeclarationNames.getCXXOperatorName(OO_Equal);
1252 CXXMethodDecl *CopyAssignment =
1253 CXXMethodDecl::Create(Context, ClassDecl, ClassDecl->getLocation(), Name,
1254 Context.getFunctionType(RetType, &ArgType, 1,
1255 false, 0),
1256 /*isStatic=*/false, /*isInline=*/true);
1257 CopyAssignment->setAccess(AS_public);
1258 CopyAssignment->setImplicit();
1259
1260 // Add the parameter to the operator.
1261 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyAssignment,
1262 ClassDecl->getLocation(),
1263 /*IdentifierInfo=*/0,
1264 ArgType, VarDecl::None, 0);
1265 CopyAssignment->setParams(Context, &FromParam, 1);
1266
1267 // Don't call addedAssignmentOperator. There is no way to distinguish an
1268 // implicit from an explicit assignment operator.
1269 ClassDecl->addDecl(CopyAssignment);
1270 }
1271
1272 if (!ClassDecl->hasUserDeclaredDestructor()) {
1273 // C++ [class.dtor]p2:
1274 // If a class has no user-declared destructor, a destructor is
1275 // declared implicitly. An implicitly-declared destructor is an
1276 // inline public member of its class.
1277 DeclarationName Name
1278 = Context.DeclarationNames.getCXXDestructorName(ClassType);
1279 CXXDestructorDecl *Destructor
1280 = CXXDestructorDecl::Create(Context, ClassDecl,
1281 ClassDecl->getLocation(), Name,
1282 Context.getFunctionType(Context.VoidTy,
1283 0, 0, false, 0),
1284 /*isInline=*/true,
1285 /*isImplicitlyDeclared=*/true);
1286 Destructor->setAccess(AS_public);
1287 Destructor->setImplicit();
1288 ClassDecl->addDecl(Destructor);
1289 }
1290}
1291
1292void Sema::ActOnReenterTemplateScope(Scope *S, DeclPtrTy TemplateD) {
1293 TemplateDecl *Template = TemplateD.getAs<TemplateDecl>();
1294 if (!Template)
1295 return;
1296
1297 TemplateParameterList *Params = Template->getTemplateParameters();
1298 for (TemplateParameterList::iterator Param = Params->begin(),
1299 ParamEnd = Params->end();
1300 Param != ParamEnd; ++Param) {
1301 NamedDecl *Named = cast<NamedDecl>(*Param);
1302 if (Named->getDeclName()) {
1303 S->AddDecl(DeclPtrTy::make(Named));
1304 IdResolver.AddDecl(Named);
1305 }
1306 }
1307}
1308
1309/// ActOnStartDelayedCXXMethodDeclaration - We have completed
1310/// parsing a top-level (non-nested) C++ class, and we are now
1311/// parsing those parts of the given Method declaration that could
1312/// not be parsed earlier (C++ [class.mem]p2), such as default
1313/// arguments. This action should enter the scope of the given
1314/// Method declaration as if we had just parsed the qualified method
1315/// name. However, it should not bring the parameters into scope;
1316/// that will be performed by ActOnDelayedCXXMethodParameter.
1317void Sema::ActOnStartDelayedCXXMethodDeclaration(Scope *S, DeclPtrTy MethodD) {
1318 if (!MethodD)
1319 return;
1320
1321 CXXScopeSpec SS;
1322 FunctionDecl *Method = cast<FunctionDecl>(MethodD.getAs<Decl>());
1323 QualType ClassTy
1324 = Context.getTypeDeclType(cast<RecordDecl>(Method->getDeclContext()));
1325 SS.setScopeRep(
1326 NestedNameSpecifier::Create(Context, 0, false, ClassTy.getTypePtr()));
1327 ActOnCXXEnterDeclaratorScope(S, SS);
1328}
1329
1330/// ActOnDelayedCXXMethodParameter - We've already started a delayed
1331/// C++ method declaration. We're (re-)introducing the given
1332/// function parameter into scope for use in parsing later parts of
1333/// the method declaration. For example, we could see an
1334/// ActOnParamDefaultArgument event for this parameter.
1335void Sema::ActOnDelayedCXXMethodParameter(Scope *S, DeclPtrTy ParamD) {
1336 if (!ParamD)
1337 return;
1338
1339 ParmVarDecl *Param = cast<ParmVarDecl>(ParamD.getAs<Decl>());
1340
1341 // If this parameter has an unparsed default argument, clear it out
1342 // to make way for the parsed default argument.
1343 if (Param->hasUnparsedDefaultArg())
1344 Param->setDefaultArg(0);
1345
1346 S->AddDecl(DeclPtrTy::make(Param));
1347 if (Param->getDeclName())
1348 IdResolver.AddDecl(Param);
1349}
1350
1351/// ActOnFinishDelayedCXXMethodDeclaration - We have finished
1352/// processing the delayed method declaration for Method. The method
1353/// declaration is now considered finished. There may be a separate
1354/// ActOnStartOfFunctionDef action later (not necessarily
1355/// immediately!) for this method, if it was also defined inside the
1356/// class body.
1357void Sema::ActOnFinishDelayedCXXMethodDeclaration(Scope *S, DeclPtrTy MethodD) {
1358 if (!MethodD)
1359 return;
1360
1361 FunctionDecl *Method = cast<FunctionDecl>(MethodD.getAs<Decl>());
1362 CXXScopeSpec SS;
1363 QualType ClassTy
1364 = Context.getTypeDeclType(cast<RecordDecl>(Method->getDeclContext()));
1365 SS.setScopeRep(
1366 NestedNameSpecifier::Create(Context, 0, false, ClassTy.getTypePtr()));
1367 ActOnCXXExitDeclaratorScope(S, SS);
1368
1369 // Now that we have our default arguments, check the constructor
1370 // again. It could produce additional diagnostics or affect whether
1371 // the class has implicitly-declared destructors, among other
1372 // things.
1373 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Method))
1374 CheckConstructor(Constructor);
1375
1376 // Check the default arguments, which we may have added.
1377 if (!Method->isInvalidDecl())
1378 CheckCXXDefaultArguments(Method);
1379}
1380
1381/// CheckConstructorDeclarator - Called by ActOnDeclarator to check
1382/// the well-formedness of the constructor declarator @p D with type @p
1383/// R. If there are any errors in the declarator, this routine will
1384/// emit diagnostics and set the invalid bit to true. In any case, the type
1385/// will be updated to reflect a well-formed type for the constructor and
1386/// returned.
1387QualType Sema::CheckConstructorDeclarator(Declarator &D, QualType R,
1388 FunctionDecl::StorageClass &SC) {
1389 bool isVirtual = D.getDeclSpec().isVirtualSpecified();
1390
1391 // C++ [class.ctor]p3:
1392 // A constructor shall not be virtual (10.3) or static (9.4). A
1393 // constructor can be invoked for a const, volatile or const
1394 // volatile object. A constructor shall not be declared const,
1395 // volatile, or const volatile (9.3.2).
1396 if (isVirtual) {
1397 if (!D.isInvalidType())
1398 Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
1399 << "virtual" << SourceRange(D.getDeclSpec().getVirtualSpecLoc())
1400 << SourceRange(D.getIdentifierLoc());
1401 D.setInvalidType();
1402 }
1403 if (SC == FunctionDecl::Static) {
1404 if (!D.isInvalidType())
1405 Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
1406 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
1407 << SourceRange(D.getIdentifierLoc());
1408 D.setInvalidType();
1409 SC = FunctionDecl::None;
1410 }
1411
1412 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
1413 if (FTI.TypeQuals != 0) {
1414 if (FTI.TypeQuals & QualType::Const)
1415 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
1416 << "const" << SourceRange(D.getIdentifierLoc());
1417 if (FTI.TypeQuals & QualType::Volatile)
1418 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
1419 << "volatile" << SourceRange(D.getIdentifierLoc());
1420 if (FTI.TypeQuals & QualType::Restrict)
1421 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
1422 << "restrict" << SourceRange(D.getIdentifierLoc());
1423 }
1424
1425 // Rebuild the function type "R" without any type qualifiers (in
1426 // case any of the errors above fired) and with "void" as the
1427 // return type, since constructors don't have return types. We
1428 // *always* have to do this, because GetTypeForDeclarator will
1429 // put in a result type of "int" when none was specified.
1430 const FunctionProtoType *Proto = R->getAsFunctionProtoType();
1431 return Context.getFunctionType(Context.VoidTy, Proto->arg_type_begin(),
1432 Proto->getNumArgs(),
1433 Proto->isVariadic(), 0);
1434}
1435
1436/// CheckConstructor - Checks a fully-formed constructor for
1437/// well-formedness, issuing any diagnostics required. Returns true if
1438/// the constructor declarator is invalid.
1439void Sema::CheckConstructor(CXXConstructorDecl *Constructor) {
1440 CXXRecordDecl *ClassDecl
1441 = dyn_cast<CXXRecordDecl>(Constructor->getDeclContext());
1442 if (!ClassDecl)
1443 return Constructor->setInvalidDecl();
1444
1445 // C++ [class.copy]p3:
1446 // A declaration of a constructor for a class X is ill-formed if
1447 // its first parameter is of type (optionally cv-qualified) X and
1448 // either there are no other parameters or else all other
1449 // parameters have default arguments.
1450 if (!Constructor->isInvalidDecl() &&
1451 ((Constructor->getNumParams() == 1) ||
1452 (Constructor->getNumParams() > 1 &&
1453 Constructor->getParamDecl(1)->hasDefaultArg()))) {
1454 QualType ParamType = Constructor->getParamDecl(0)->getType();
1455 QualType ClassTy = Context.getTagDeclType(ClassDecl);
1456 if (Context.getCanonicalType(ParamType).getUnqualifiedType() == ClassTy) {
1457 SourceLocation ParamLoc = Constructor->getParamDecl(0)->getLocation();
1458 Diag(ParamLoc, diag::err_constructor_byvalue_arg)
1459 << CodeModificationHint::CreateInsertion(ParamLoc, " const &");
1460 Constructor->setInvalidDecl();
1461 }
1462 }
1463
1464 // Notify the class that we've added a constructor.
1465 ClassDecl->addedConstructor(Context, Constructor);
1466}
1467
1468static inline bool
1469FTIHasSingleVoidArgument(DeclaratorChunk::FunctionTypeInfo &FTI) {
1470 return (FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 &&
1471 FTI.ArgInfo[0].Param &&
1472 FTI.ArgInfo[0].Param.getAs<ParmVarDecl>()->getType()->isVoidType());
1473}
1474
1475/// CheckDestructorDeclarator - Called by ActOnDeclarator to check
1476/// the well-formednes of the destructor declarator @p D with type @p
1477/// R. If there are any errors in the declarator, this routine will
1478/// emit diagnostics and set the declarator to invalid. Even if this happens,
1479/// will be updated to reflect a well-formed type for the destructor and
1480/// returned.
1481QualType Sema::CheckDestructorDeclarator(Declarator &D,
1482 FunctionDecl::StorageClass& SC) {
1483 // C++ [class.dtor]p1:
1484 // [...] A typedef-name that names a class is a class-name
1485 // (7.1.3); however, a typedef-name that names a class shall not
1486 // be used as the identifier in the declarator for a destructor
1487 // declaration.
1488 QualType DeclaratorType = QualType::getFromOpaquePtr(D.getDeclaratorIdType());
1489 if (isa<TypedefType>(DeclaratorType)) {
1490 Diag(D.getIdentifierLoc(), diag::err_destructor_typedef_name)
1491 << DeclaratorType;
1492 D.setInvalidType();
1493 }
1494
1495 // C++ [class.dtor]p2:
1496 // A destructor is used to destroy objects of its class type. A
1497 // destructor takes no parameters, and no return type can be
1498 // specified for it (not even void). The address of a destructor
1499 // shall not be taken. A destructor shall not be static. A
1500 // destructor can be invoked for a const, volatile or const
1501 // volatile object. A destructor shall not be declared const,
1502 // volatile or const volatile (9.3.2).
1503 if (SC == FunctionDecl::Static) {
1504 if (!D.isInvalidType())
1505 Diag(D.getIdentifierLoc(), diag::err_destructor_cannot_be)
1506 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
1507 << SourceRange(D.getIdentifierLoc());
1508 SC = FunctionDecl::None;
1509 D.setInvalidType();
1510 }
1511 if (D.getDeclSpec().hasTypeSpecifier() && !D.isInvalidType()) {
1512 // Destructors don't have return types, but the parser will
1513 // happily parse something like:
1514 //
1515 // class X {
1516 // float ~X();
1517 // };
1518 //
1519 // The return type will be eliminated later.
1520 Diag(D.getIdentifierLoc(), diag::err_destructor_return_type)
1521 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
1522 << SourceRange(D.getIdentifierLoc());
1523 }
1524
1525 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
1526 if (FTI.TypeQuals != 0 && !D.isInvalidType()) {
1527 if (FTI.TypeQuals & QualType::Const)
1528 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
1529 << "const" << SourceRange(D.getIdentifierLoc());
1530 if (FTI.TypeQuals & QualType::Volatile)
1531 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
1532 << "volatile" << SourceRange(D.getIdentifierLoc());
1533 if (FTI.TypeQuals & QualType::Restrict)
1534 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
1535 << "restrict" << SourceRange(D.getIdentifierLoc());
1536 D.setInvalidType();
1537 }
1538
1539 // Make sure we don't have any parameters.
1540 if (FTI.NumArgs > 0 && !FTIHasSingleVoidArgument(FTI)) {
1541 Diag(D.getIdentifierLoc(), diag::err_destructor_with_params);
1542
1543 // Delete the parameters.
1544 FTI.freeArgs();
1545 D.setInvalidType();
1546 }
1547
1548 // Make sure the destructor isn't variadic.
1549 if (FTI.isVariadic) {
1550 Diag(D.getIdentifierLoc(), diag::err_destructor_variadic);
1551 D.setInvalidType();
1552 }
1553
1554 // Rebuild the function type "R" without any type qualifiers or
1555 // parameters (in case any of the errors above fired) and with
1556 // "void" as the return type, since destructors don't have return
1557 // types. We *always* have to do this, because GetTypeForDeclarator
1558 // will put in a result type of "int" when none was specified.
1559 return Context.getFunctionType(Context.VoidTy, 0, 0, false, 0);
1560}
1561
1562/// CheckConversionDeclarator - Called by ActOnDeclarator to check the
1563/// well-formednes of the conversion function declarator @p D with
1564/// type @p R. If there are any errors in the declarator, this routine
1565/// will emit diagnostics and return true. Otherwise, it will return
1566/// false. Either way, the type @p R will be updated to reflect a
1567/// well-formed type for the conversion operator.
1568void Sema::CheckConversionDeclarator(Declarator &D, QualType &R,
1569 FunctionDecl::StorageClass& SC) {
1570 // C++ [class.conv.fct]p1:
1571 // Neither parameter types nor return type can be specified. The
1572 // type of a conversion function (8.3.5) is ���function taking no
1573 // parameter returning conversion-type-id.���
1574 if (SC == FunctionDecl::Static) {
1575 if (!D.isInvalidType())
1576 Diag(D.getIdentifierLoc(), diag::err_conv_function_not_member)
1577 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
1578 << SourceRange(D.getIdentifierLoc());
1579 D.setInvalidType();
1580 SC = FunctionDecl::None;
1581 }
1582 if (D.getDeclSpec().hasTypeSpecifier() && !D.isInvalidType()) {
1583 // Conversion functions don't have return types, but the parser will
1584 // happily parse something like:
1585 //
1586 // class X {
1587 // float operator bool();
1588 // };
1589 //
1590 // The return type will be changed later anyway.
1591 Diag(D.getIdentifierLoc(), diag::err_conv_function_return_type)
1592 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
1593 << SourceRange(D.getIdentifierLoc());
1594 }
1595
1596 // Make sure we don't have any parameters.
1597 if (R->getAsFunctionProtoType()->getNumArgs() > 0) {
1598 Diag(D.getIdentifierLoc(), diag::err_conv_function_with_params);
1599
1600 // Delete the parameters.
1601 D.getTypeObject(0).Fun.freeArgs();
1602 D.setInvalidType();
1603 }
1604
1605 // Make sure the conversion function isn't variadic.
1606 if (R->getAsFunctionProtoType()->isVariadic() && !D.isInvalidType()) {
1607 Diag(D.getIdentifierLoc(), diag::err_conv_function_variadic);
1608 D.setInvalidType();
1609 }
1610
1611 // C++ [class.conv.fct]p4:
1612 // The conversion-type-id shall not represent a function type nor
1613 // an array type.
1614 QualType ConvType = QualType::getFromOpaquePtr(D.getDeclaratorIdType());
1615 if (ConvType->isArrayType()) {
1616 Diag(D.getIdentifierLoc(), diag::err_conv_function_to_array);
1617 ConvType = Context.getPointerType(ConvType);
1618 D.setInvalidType();
1619 } else if (ConvType->isFunctionType()) {
1620 Diag(D.getIdentifierLoc(), diag::err_conv_function_to_function);
1621 ConvType = Context.getPointerType(ConvType);
1622 D.setInvalidType();
1623 }
1624
1625 // Rebuild the function type "R" without any parameters (in case any
1626 // of the errors above fired) and with the conversion type as the
1627 // return type.
1628 R = Context.getFunctionType(ConvType, 0, 0, false,
1629 R->getAsFunctionProtoType()->getTypeQuals());
1630
1631 // C++0x explicit conversion operators.
1632 if (D.getDeclSpec().isExplicitSpecified() && !getLangOptions().CPlusPlus0x)
1633 Diag(D.getDeclSpec().getExplicitSpecLoc(),
1634 diag::warn_explicit_conversion_functions)
1635 << SourceRange(D.getDeclSpec().getExplicitSpecLoc());
1636}
1637
1638/// ActOnConversionDeclarator - Called by ActOnDeclarator to complete
1639/// the declaration of the given C++ conversion function. This routine
1640/// is responsible for recording the conversion function in the C++
1641/// class, if possible.
1642Sema::DeclPtrTy Sema::ActOnConversionDeclarator(CXXConversionDecl *Conversion) {
1643 assert(Conversion && "Expected to receive a conversion function declaration");
1644
1645 // Set the lexical context of this conversion function
1646 Conversion->setLexicalDeclContext(CurContext);
1647
1648 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Conversion->getDeclContext());
1649
1650 // Make sure we aren't redeclaring the conversion function.
1651 QualType ConvType = Context.getCanonicalType(Conversion->getConversionType());
1652
1653 // C++ [class.conv.fct]p1:
1654 // [...] A conversion function is never used to convert a
1655 // (possibly cv-qualified) object to the (possibly cv-qualified)
1656 // same object type (or a reference to it), to a (possibly
1657 // cv-qualified) base class of that type (or a reference to it),
1658 // or to (possibly cv-qualified) void.
1659 // FIXME: Suppress this warning if the conversion function ends up being a
1660 // virtual function that overrides a virtual function in a base class.
1661 QualType ClassType
1662 = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
1663 if (const ReferenceType *ConvTypeRef = ConvType->getAsReferenceType())
1664 ConvType = ConvTypeRef->getPointeeType();
1665 if (ConvType->isRecordType()) {
1666 ConvType = Context.getCanonicalType(ConvType).getUnqualifiedType();
1667 if (ConvType == ClassType)
1668 Diag(Conversion->getLocation(), diag::warn_conv_to_self_not_used)
1669 << ClassType;
1670 else if (IsDerivedFrom(ClassType, ConvType))
1671 Diag(Conversion->getLocation(), diag::warn_conv_to_base_not_used)
1672 << ClassType << ConvType;
1673 } else if (ConvType->isVoidType()) {
1674 Diag(Conversion->getLocation(), diag::warn_conv_to_void_not_used)
1675 << ClassType << ConvType;
1676 }
1677
1678 if (Conversion->getPreviousDeclaration()) {
1679 OverloadedFunctionDecl *Conversions = ClassDecl->getConversionFunctions();
1680 for (OverloadedFunctionDecl::function_iterator
1681 Conv = Conversions->function_begin(),
1682 ConvEnd = Conversions->function_end();
1683 Conv != ConvEnd; ++Conv) {
1684 if (*Conv
1685 == cast_or_null<NamedDecl>(Conversion->getPreviousDeclaration())) {
1686 *Conv = Conversion;
1687 return DeclPtrTy::make(Conversion);
1688 }
1689 }
1690 assert(Conversion->isInvalidDecl() && "Conversion should not get here.");
1691 } else
1692 ClassDecl->addConversionFunction(Context, Conversion);
1693
1694 return DeclPtrTy::make(Conversion);
1695}
1696
1697//===----------------------------------------------------------------------===//
1698// Namespace Handling
1699//===----------------------------------------------------------------------===//
1700
1701/// ActOnStartNamespaceDef - This is called at the start of a namespace
1702/// definition.
1703Sema::DeclPtrTy Sema::ActOnStartNamespaceDef(Scope *NamespcScope,
1704 SourceLocation IdentLoc,
1705 IdentifierInfo *II,
1706 SourceLocation LBrace) {
1707 NamespaceDecl *Namespc =
1708 NamespaceDecl::Create(Context, CurContext, IdentLoc, II);
1709 Namespc->setLBracLoc(LBrace);
1710
1711 Scope *DeclRegionScope = NamespcScope->getParent();
1712
1713 if (II) {
1714 // C++ [namespace.def]p2:
1715 // The identifier in an original-namespace-definition shall not have been
1716 // previously defined in the declarative region in which the
1717 // original-namespace-definition appears. The identifier in an
1718 // original-namespace-definition is the name of the namespace. Subsequently
1719 // in that declarative region, it is treated as an original-namespace-name.
1720
1721 NamedDecl *PrevDecl = LookupName(DeclRegionScope, II, LookupOrdinaryName,
1722 true);
1723
1724 if (NamespaceDecl *OrigNS = dyn_cast_or_null<NamespaceDecl>(PrevDecl)) {
1725 // This is an extended namespace definition.
1726 // Attach this namespace decl to the chain of extended namespace
1727 // definitions.
1728 OrigNS->setNextNamespace(Namespc);
1729 Namespc->setOriginalNamespace(OrigNS->getOriginalNamespace());
1730
1731 // Remove the previous declaration from the scope.
1732 if (DeclRegionScope->isDeclScope(DeclPtrTy::make(OrigNS))) {
1733 IdResolver.RemoveDecl(OrigNS);
1734 DeclRegionScope->RemoveDecl(DeclPtrTy::make(OrigNS));
1735 }
1736 } else if (PrevDecl) {
1737 // This is an invalid name redefinition.
1738 Diag(Namespc->getLocation(), diag::err_redefinition_different_kind)
1739 << Namespc->getDeclName();
1740 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
1741 Namespc->setInvalidDecl();
1742 // Continue on to push Namespc as current DeclContext and return it.
1743 }
1744
1745 PushOnScopeChains(Namespc, DeclRegionScope);
1746 } else {
1747 // FIXME: Handle anonymous namespaces
1748 }
1749
1750 // Although we could have an invalid decl (i.e. the namespace name is a
1751 // redefinition), push it as current DeclContext and try to continue parsing.
1752 // FIXME: We should be able to push Namespc here, so that the each DeclContext
1753 // for the namespace has the declarations that showed up in that particular
1754 // namespace definition.
1755 PushDeclContext(NamespcScope, Namespc);
1756 return DeclPtrTy::make(Namespc);
1757}
1758
1759/// ActOnFinishNamespaceDef - This callback is called after a namespace is
1760/// exited. Decl is the DeclTy returned by ActOnStartNamespaceDef.
1761void Sema::ActOnFinishNamespaceDef(DeclPtrTy D, SourceLocation RBrace) {
1762 Decl *Dcl = D.getAs<Decl>();
1763 NamespaceDecl *Namespc = dyn_cast_or_null<NamespaceDecl>(Dcl);
1764 assert(Namespc && "Invalid parameter, expected NamespaceDecl");
1765 Namespc->setRBracLoc(RBrace);
1766 PopDeclContext();
1767}
1768
1769Sema::DeclPtrTy Sema::ActOnUsingDirective(Scope *S,
1770 SourceLocation UsingLoc,
1771 SourceLocation NamespcLoc,
1772 const CXXScopeSpec &SS,
1773 SourceLocation IdentLoc,
1774 IdentifierInfo *NamespcName,
1775 AttributeList *AttrList) {
1776 assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
1777 assert(NamespcName && "Invalid NamespcName.");
1778 assert(IdentLoc.isValid() && "Invalid NamespceName location.");
1779 assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
1780
1781 UsingDirectiveDecl *UDir = 0;
1782
1783 // Lookup namespace name.
1784 LookupResult R = LookupParsedName(S, &SS, NamespcName,
1785 LookupNamespaceName, false);
1786 if (R.isAmbiguous()) {
1787 DiagnoseAmbiguousLookup(R, NamespcName, IdentLoc);
1788 return DeclPtrTy();
1789 }
1790 if (NamedDecl *NS = R) {
1791 assert(isa<NamespaceDecl>(NS) && "expected namespace decl");
1792 // C++ [namespace.udir]p1:
1793 // A using-directive specifies that the names in the nominated
1794 // namespace can be used in the scope in which the
1795 // using-directive appears after the using-directive. During
1796 // unqualified name lookup (3.4.1), the names appear as if they
1797 // were declared in the nearest enclosing namespace which
1798 // contains both the using-directive and the nominated
1799 // namespace. [Note: in this context, ���contains��� means ���contains
1800 // directly or indirectly���. ]
1801
1802 // Find enclosing context containing both using-directive and
1803 // nominated namespace.
1804 DeclContext *CommonAncestor = cast<DeclContext>(NS);
1805 while (CommonAncestor && !CommonAncestor->Encloses(CurContext))
1806 CommonAncestor = CommonAncestor->getParent();
1807
1808 UDir = UsingDirectiveDecl::Create(Context,
1809 CurContext, UsingLoc,
1810 NamespcLoc,
1811 SS.getRange(),
1812 (NestedNameSpecifier *)SS.getScopeRep(),
1813 IdentLoc,
1814 cast<NamespaceDecl>(NS),
1815 CommonAncestor);
1816 PushUsingDirective(S, UDir);
1817 } else {
1818 Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
1819 }
1820
1821 // FIXME: We ignore attributes for now.
1822 delete AttrList;
1823 return DeclPtrTy::make(UDir);
1824}
1825
1826void Sema::PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir) {
1827 // If scope has associated entity, then using directive is at namespace
1828 // or translation unit scope. We add UsingDirectiveDecls, into
1829 // it's lookup structure.
1830 if (DeclContext *Ctx = static_cast<DeclContext*>(S->getEntity()))
1831 Ctx->addDecl(UDir);
1832 else
1833 // Otherwise it is block-sope. using-directives will affect lookup
1834 // only to the end of scope.
1835 S->PushUsingDirective(DeclPtrTy::make(UDir));
1836}
1837
1838
1839Sema::DeclPtrTy Sema::ActOnUsingDeclaration(Scope *S,
1840 SourceLocation UsingLoc,
1841 const CXXScopeSpec &SS,
1842 SourceLocation IdentLoc,
1843 IdentifierInfo *TargetName,
1844 OverloadedOperatorKind Op,
1845 AttributeList *AttrList,
1846 bool IsTypeName) {
1847 assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
1848 assert((TargetName || Op) && "Invalid TargetName.");
1849 assert(IdentLoc.isValid() && "Invalid TargetName location.");
1850 assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
1851
1852 UsingDecl *UsingAlias = 0;
1853
1854 DeclarationName Name;
1855 if (TargetName)
1856 Name = TargetName;
1857 else
1858 Name = Context.DeclarationNames.getCXXOperatorName(Op);
1859
1860 // Lookup target name.
1861 LookupResult R = LookupParsedName(S, &SS, Name, LookupOrdinaryName, false);
1862
1863 if (NamedDecl *NS = R) {
1864 if (IsTypeName && !isa<TypeDecl>(NS)) {
1865 Diag(IdentLoc, diag::err_using_typename_non_type);
1866 }
1867 UsingAlias = UsingDecl::Create(Context, CurContext, IdentLoc, SS.getRange(),
1868 NS->getLocation(), UsingLoc, NS,
1869 static_cast<NestedNameSpecifier *>(SS.getScopeRep()),
1870 IsTypeName);
1871 PushOnScopeChains(UsingAlias, S);
1872 } else {
1873 Diag(IdentLoc, diag::err_using_requires_qualname) << SS.getRange();
1874 }
1875
1876 // FIXME: We ignore attributes for now.
1877 delete AttrList;
1878 return DeclPtrTy::make(UsingAlias);
1879}
1880
1881/// getNamespaceDecl - Returns the namespace a decl represents. If the decl
1882/// is a namespace alias, returns the namespace it points to.
1883static inline NamespaceDecl *getNamespaceDecl(NamedDecl *D) {
1884 if (NamespaceAliasDecl *AD = dyn_cast_or_null<NamespaceAliasDecl>(D))
1885 return AD->getNamespace();
1886 return dyn_cast_or_null<NamespaceDecl>(D);
1887}
1888
1889Sema::DeclPtrTy Sema::ActOnNamespaceAliasDef(Scope *S,
1890 SourceLocation NamespaceLoc,
1891 SourceLocation AliasLoc,
1892 IdentifierInfo *Alias,
1893 const CXXScopeSpec &SS,
1894 SourceLocation IdentLoc,
1895 IdentifierInfo *Ident) {
1896
1897 // Lookup the namespace name.
1898 LookupResult R = LookupParsedName(S, &SS, Ident, LookupNamespaceName, false);
1899
1900 // Check if we have a previous declaration with the same name.
1901 if (NamedDecl *PrevDecl = LookupName(S, Alias, LookupOrdinaryName, true)) {
1902 if (NamespaceAliasDecl *AD = dyn_cast<NamespaceAliasDecl>(PrevDecl)) {
1903 // We already have an alias with the same name that points to the same
1904 // namespace, so don't create a new one.
1905 if (!R.isAmbiguous() && AD->getNamespace() == getNamespaceDecl(R))
1906 return DeclPtrTy();
1907 }
1908
1909 unsigned DiagID = isa<NamespaceDecl>(PrevDecl) ? diag::err_redefinition :
1910 diag::err_redefinition_different_kind;
1911 Diag(AliasLoc, DiagID) << Alias;
1912 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
1913 return DeclPtrTy();
1914 }
1915
1916 if (R.isAmbiguous()) {
1917 DiagnoseAmbiguousLookup(R, Ident, IdentLoc);
1918 return DeclPtrTy();
1919 }
1920
1921 if (!R) {
1922 Diag(NamespaceLoc, diag::err_expected_namespace_name) << SS.getRange();
1923 return DeclPtrTy();
1924 }
1925
1926 NamespaceAliasDecl *AliasDecl =
1927 NamespaceAliasDecl::Create(Context, CurContext, NamespaceLoc, AliasLoc,
1928 Alias, SS.getRange(),
1929 (NestedNameSpecifier *)SS.getScopeRep(),
1930 IdentLoc, R);
1931
1932 CurContext->addDecl(AliasDecl);
1933 return DeclPtrTy::make(AliasDecl);
1934}
1935
1936void Sema::DefineImplicitDefaultConstructor(SourceLocation CurrentLocation,
1937 CXXConstructorDecl *Constructor) {
1938 assert((Constructor->isImplicit() && Constructor->isDefaultConstructor() &&
1939 !Constructor->isUsed()) &&
1940 "DefineImplicitDefaultConstructor - call it for implicit default ctor");
1941
1942 CXXRecordDecl *ClassDecl
1943 = cast<CXXRecordDecl>(Constructor->getDeclContext());
1944 assert(ClassDecl && "DefineImplicitDefaultConstructor - invalid constructor");
1945 // Before the implicitly-declared default constructor for a class is
1946 // implicitly defined, all the implicitly-declared default constructors
1947 // for its base class and its non-static data members shall have been
1948 // implicitly defined.
1949 bool err = false;
1950 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
1951 E = ClassDecl->bases_end(); Base != E; ++Base) {
1952 CXXRecordDecl *BaseClassDecl
1953 = cast<CXXRecordDecl>(Base->getType()->getAsRecordType()->getDecl());
1954 if (!BaseClassDecl->hasTrivialConstructor()) {
1955 if (CXXConstructorDecl *BaseCtor =
1956 BaseClassDecl->getDefaultConstructor(Context))
1957 MarkDeclarationReferenced(CurrentLocation, BaseCtor);
1958 else {
1959 Diag(CurrentLocation, diag::err_defining_default_ctor)
1960 << Context.getTagDeclType(ClassDecl) << 1
1961 << Context.getTagDeclType(BaseClassDecl);
1962 Diag(BaseClassDecl->getLocation(), diag::note_previous_class_decl)
1963 << Context.getTagDeclType(BaseClassDecl);
1964 err = true;
1965 }
1966 }
1967 }
1968 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
1969 E = ClassDecl->field_end(); Field != E; ++Field) {
1970 QualType FieldType = Context.getCanonicalType((*Field)->getType());
1971 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
1972 FieldType = Array->getElementType();
1973 if (const RecordType *FieldClassType = FieldType->getAsRecordType()) {
1974 CXXRecordDecl *FieldClassDecl
1975 = cast<CXXRecordDecl>(FieldClassType->getDecl());
1976 if (!FieldClassDecl->hasTrivialConstructor()) {
1977 if (CXXConstructorDecl *FieldCtor =
1978 FieldClassDecl->getDefaultConstructor(Context))
1979 MarkDeclarationReferenced(CurrentLocation, FieldCtor);
1980 else {
1981 Diag(CurrentLocation, diag::err_defining_default_ctor)
1982 << Context.getTagDeclType(ClassDecl) << 0 <<
1983 Context.getTagDeclType(FieldClassDecl);
1984 Diag(FieldClassDecl->getLocation(), diag::note_previous_class_decl)
1985 << Context.getTagDeclType(FieldClassDecl);
1986 err = true;
1987 }
1988 }
1989 }
1990 else if (FieldType->isReferenceType()) {
1991 Diag(CurrentLocation, diag::err_unintialized_member)
1992 << Context.getTagDeclType(ClassDecl) << 0 << (*Field)->getNameAsCString();
1993 Diag((*Field)->getLocation(), diag::note_declared_at);
1994 err = true;
1995 }
1996 else if (FieldType.isConstQualified()) {
1997 Diag(CurrentLocation, diag::err_unintialized_member)
1998 << Context.getTagDeclType(ClassDecl) << 1 << (*Field)->getNameAsCString();
1999 Diag((*Field)->getLocation(), diag::note_declared_at);
2000 err = true;
2001 }
2002 }
2003 if (!err)
2004 Constructor->setUsed();
2005 else
2006 Constructor->setInvalidDecl();
2007}
2008
2009void Sema::DefineImplicitDestructor(SourceLocation CurrentLocation,
2010 CXXDestructorDecl *Destructor) {
2011 assert((Destructor->isImplicit() && !Destructor->isUsed()) &&
2012 "DefineImplicitDestructor - call it for implicit default dtor");
2013
2014 CXXRecordDecl *ClassDecl
2015 = cast<CXXRecordDecl>(Destructor->getDeclContext());
2016 assert(ClassDecl && "DefineImplicitDestructor - invalid destructor");
2017 // C++ [class.dtor] p5
2018 // Before the implicitly-declared default destructor for a class is
2019 // implicitly defined, all the implicitly-declared default destructors
2020 // for its base class and its non-static data members shall have been
2021 // implicitly defined.
2022 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
2023 E = ClassDecl->bases_end(); Base != E; ++Base) {
2024 CXXRecordDecl *BaseClassDecl
2025 = cast<CXXRecordDecl>(Base->getType()->getAsRecordType()->getDecl());
2026 if (!BaseClassDecl->hasTrivialDestructor()) {
2027 if (CXXDestructorDecl *BaseDtor =
2028 const_cast<CXXDestructorDecl*>(BaseClassDecl->getDestructor(Context)))
2029 MarkDeclarationReferenced(CurrentLocation, BaseDtor);
2030 else
2031 assert(false &&
2032 "DefineImplicitDestructor - missing dtor in a base class");
2033 }
2034 }
2035
2036 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
2037 E = ClassDecl->field_end(); Field != E; ++Field) {
2038 QualType FieldType = Context.getCanonicalType((*Field)->getType());
2039 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
2040 FieldType = Array->getElementType();
2041 if (const RecordType *FieldClassType = FieldType->getAsRecordType()) {
2042 CXXRecordDecl *FieldClassDecl
2043 = cast<CXXRecordDecl>(FieldClassType->getDecl());
2044 if (!FieldClassDecl->hasTrivialDestructor()) {
2045 if (CXXDestructorDecl *FieldDtor =
2046 const_cast<CXXDestructorDecl*>(
2047 FieldClassDecl->getDestructor(Context)))
2048 MarkDeclarationReferenced(CurrentLocation, FieldDtor);
2049 else
2050 assert(false &&
2051 "DefineImplicitDestructor - missing dtor in class of a data member");
2052 }
2053 }
2054 }
2055 Destructor->setUsed();
2056}
2057
2058void Sema::DefineImplicitOverloadedAssign(SourceLocation CurrentLocation,
2059 CXXMethodDecl *MethodDecl) {
2060 assert((MethodDecl->isImplicit() && MethodDecl->isOverloadedOperator() &&
2061 MethodDecl->getOverloadedOperator() == OO_Equal &&
2062 !MethodDecl->isUsed()) &&
2063 "DefineImplicitOverloadedAssign - call it for implicit assignment op");
2064
2065 CXXRecordDecl *ClassDecl
2066 = cast<CXXRecordDecl>(MethodDecl->getDeclContext());
2067
2068 // C++[class.copy] p12
2069 // Before the implicitly-declared copy assignment operator for a class is
2070 // implicitly defined, all implicitly-declared copy assignment operators
2071 // for its direct base classes and its nonstatic data members shall have
2072 // been implicitly defined.
2073 bool err = false;
2074 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
2075 E = ClassDecl->bases_end(); Base != E; ++Base) {
2076 CXXRecordDecl *BaseClassDecl
2077 = cast<CXXRecordDecl>(Base->getType()->getAsRecordType()->getDecl());
2078 if (CXXMethodDecl *BaseAssignOpMethod =
2079 getAssignOperatorMethod(MethodDecl->getParamDecl(0), BaseClassDecl))
2080 MarkDeclarationReferenced(CurrentLocation, BaseAssignOpMethod);
2081 }
2082 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
2083 E = ClassDecl->field_end(); Field != E; ++Field) {
2084 QualType FieldType = Context.getCanonicalType((*Field)->getType());
2085 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
2086 FieldType = Array->getElementType();
2087 if (const RecordType *FieldClassType = FieldType->getAsRecordType()) {
2088 CXXRecordDecl *FieldClassDecl
2089 = cast<CXXRecordDecl>(FieldClassType->getDecl());
2090 if (CXXMethodDecl *FieldAssignOpMethod =
2091 getAssignOperatorMethod(MethodDecl->getParamDecl(0), FieldClassDecl))
2092 MarkDeclarationReferenced(CurrentLocation, FieldAssignOpMethod);
2093 }
2094 else if (FieldType->isReferenceType()) {
2095 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
2096 << Context.getTagDeclType(ClassDecl) << 0 << (*Field)->getNameAsCString();
2097 Diag((*Field)->getLocation(), diag::note_declared_at);
2098 Diag(CurrentLocation, diag::note_first_required_here);
2099 err = true;
2100 }
2101 else if (FieldType.isConstQualified()) {
2102 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
2103 << Context.getTagDeclType(ClassDecl) << 1 << (*Field)->getNameAsCString();
2104 Diag((*Field)->getLocation(), diag::note_declared_at);
2105 Diag(CurrentLocation, diag::note_first_required_here);
2106 err = true;
2107 }
2108 }
2109 if (!err)
2110 MethodDecl->setUsed();
2111}
2112
2113CXXMethodDecl *
2114Sema::getAssignOperatorMethod(ParmVarDecl *ParmDecl,
2115 CXXRecordDecl *ClassDecl) {
2116 QualType LHSType = Context.getTypeDeclType(ClassDecl);
2117 QualType RHSType(LHSType);
2118 // If class's assignment operator argument is const/volatile qualified,
2119 // look for operator = (const/volatile B&). Otherwise, look for
2120 // operator = (B&).
2121 if (ParmDecl->getType().isConstQualified())
2122 RHSType.addConst();
2123 if (ParmDecl->getType().isVolatileQualified())
2124 RHSType.addVolatile();
2125 ExprOwningPtr<Expr> LHS(this, new (Context) DeclRefExpr(ParmDecl,
2126 LHSType,
2127 SourceLocation()));
2128 ExprOwningPtr<Expr> RHS(this, new (Context) DeclRefExpr(ParmDecl,
2129 RHSType,
2130 SourceLocation()));
2131 Expr *Args[2] = { &*LHS, &*RHS };
2132 OverloadCandidateSet CandidateSet;
2133 AddMemberOperatorCandidates(clang::OO_Equal, SourceLocation(), Args, 2,
2134 CandidateSet);
2135 OverloadCandidateSet::iterator Best;
2136 if (BestViableFunction(CandidateSet,
2137 ClassDecl->getLocation(), Best) == OR_Success)
2138 return cast<CXXMethodDecl>(Best->Function);
2139 assert(false &&
2140 "getAssignOperatorMethod - copy assignment operator method not found");
2141 return 0;
2142}
2143
2144void Sema::DefineImplicitCopyConstructor(SourceLocation CurrentLocation,
2145 CXXConstructorDecl *CopyConstructor,
2146 unsigned TypeQuals) {
2147 assert((CopyConstructor->isImplicit() &&
2148 CopyConstructor->isCopyConstructor(Context, TypeQuals) &&
2149 !CopyConstructor->isUsed()) &&
2150 "DefineImplicitCopyConstructor - call it for implicit copy ctor");
2151
2152 CXXRecordDecl *ClassDecl
2153 = cast<CXXRecordDecl>(CopyConstructor->getDeclContext());
2154 assert(ClassDecl && "DefineImplicitCopyConstructor - invalid constructor");
2155 // C++ [class.copy] p209
2156 // Before the implicitly-declared copy constructor for a class is
2157 // implicitly defined, all the implicitly-declared copy constructors
2158 // for its base class and its non-static data members shall have been
2159 // implicitly defined.
2160 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin();
2161 Base != ClassDecl->bases_end(); ++Base) {
2162 CXXRecordDecl *BaseClassDecl
2163 = cast<CXXRecordDecl>(Base->getType()->getAsRecordType()->getDecl());
2164 if (CXXConstructorDecl *BaseCopyCtor =
2165 BaseClassDecl->getCopyConstructor(Context, TypeQuals))
2166 MarkDeclarationReferenced(CurrentLocation, BaseCopyCtor);
2167 }
2168 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
2169 FieldEnd = ClassDecl->field_end();
2170 Field != FieldEnd; ++Field) {
2171 QualType FieldType = Context.getCanonicalType((*Field)->getType());
2172 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
2173 FieldType = Array->getElementType();
2174 if (const RecordType *FieldClassType = FieldType->getAsRecordType()) {
2175 CXXRecordDecl *FieldClassDecl
2176 = cast<CXXRecordDecl>(FieldClassType->getDecl());
2177 if (CXXConstructorDecl *FieldCopyCtor =
2178 FieldClassDecl->getCopyConstructor(Context, TypeQuals))
2179 MarkDeclarationReferenced(CurrentLocation, FieldCopyCtor);
2180 }
2181 }
2182 CopyConstructor->setUsed();
2183}
2184
2185void Sema::InitializeVarWithConstructor(VarDecl *VD,
2186 CXXConstructorDecl *Constructor,
2187 QualType DeclInitType,
2188 Expr **Exprs, unsigned NumExprs) {
2189 Expr *Temp = CXXConstructExpr::Create(Context, DeclInitType, Constructor,
2190 false, Exprs, NumExprs);
2191 MarkDeclarationReferenced(VD->getLocation(), Constructor);
2192 VD->setInit(Context, Temp);
2193}
2194
2195void Sema::MarkDestructorReferenced(SourceLocation Loc, QualType DeclInitType)
2196{
2197 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(
2198 DeclInitType->getAsRecordType()->getDecl());
2199 if (!ClassDecl->hasTrivialDestructor())
2200 if (CXXDestructorDecl *Destructor =
2201 const_cast<CXXDestructorDecl*>(ClassDecl->getDestructor(Context)))
2202 MarkDeclarationReferenced(Loc, Destructor);
2203}
2204
2205/// AddCXXDirectInitializerToDecl - This action is called immediately after
2206/// ActOnDeclarator, when a C++ direct initializer is present.
2207/// e.g: "int x(1);"
2208void Sema::AddCXXDirectInitializerToDecl(DeclPtrTy Dcl,
2209 SourceLocation LParenLoc,
2210 MultiExprArg Exprs,
2211 SourceLocation *CommaLocs,
2212 SourceLocation RParenLoc) {
2213 unsigned NumExprs = Exprs.size();
2214 assert(NumExprs != 0 && Exprs.get() && "missing expressions");
2215 Decl *RealDecl = Dcl.getAs<Decl>();
2216
2217 // If there is no declaration, there was an error parsing it. Just ignore
2218 // the initializer.
2219 if (RealDecl == 0)
2220 return;
2221
2222 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
2223 if (!VDecl) {
2224 Diag(RealDecl->getLocation(), diag::err_illegal_initializer);
2225 RealDecl->setInvalidDecl();
2226 return;
2227 }
2228
2229 // FIXME: Need to handle dependent types and expressions here.
2230
2231 // We will treat direct-initialization as a copy-initialization:
2232 // int x(1); -as-> int x = 1;
2233 // ClassType x(a,b,c); -as-> ClassType x = ClassType(a,b,c);
2234 //
2235 // Clients that want to distinguish between the two forms, can check for
2236 // direct initializer using VarDecl::hasCXXDirectInitializer().
2237 // A major benefit is that clients that don't particularly care about which
2238 // exactly form was it (like the CodeGen) can handle both cases without
2239 // special case code.
2240
2241 // C++ 8.5p11:
2242 // The form of initialization (using parentheses or '=') is generally
2243 // insignificant, but does matter when the entity being initialized has a
2244 // class type.
2245 QualType DeclInitType = VDecl->getType();
2246 if (const ArrayType *Array = Context.getAsArrayType(DeclInitType))
2247 DeclInitType = Array->getElementType();
2248
2249 // FIXME: This isn't the right place to complete the type.
2250 if (RequireCompleteType(VDecl->getLocation(), VDecl->getType(),
2251 diag::err_typecheck_decl_incomplete_type)) {
2252 VDecl->setInvalidDecl();
2253 return;
2254 }
2255
2256 if (VDecl->getType()->isRecordType()) {
2257 CXXConstructorDecl *Constructor
2258 = PerformInitializationByConstructor(DeclInitType,
2259 (Expr **)Exprs.get(), NumExprs,
2260 VDecl->getLocation(),
2261 SourceRange(VDecl->getLocation(),
2262 RParenLoc),
2263 VDecl->getDeclName(),
2264 IK_Direct);
2265 if (!Constructor)
2266 RealDecl->setInvalidDecl();
2267 else {
2268 VDecl->setCXXDirectInitializer(true);
2269 InitializeVarWithConstructor(VDecl, Constructor, DeclInitType,
2270 (Expr**)Exprs.release(), NumExprs);
2271 // FIXME. Must do all that is needed to destroy the object
2272 // on scope exit. For now, just mark the destructor as used.
2273 MarkDestructorReferenced(VDecl->getLocation(), DeclInitType);
2274 }
2275 return;
2276 }
2277
2278 if (NumExprs > 1) {
2279 Diag(CommaLocs[0], diag::err_builtin_direct_init_more_than_one_arg)
2280 << SourceRange(VDecl->getLocation(), RParenLoc);
2281 RealDecl->setInvalidDecl();
2282 return;
2283 }
2284
2285 // Let clients know that initialization was done with a direct initializer.
2286 VDecl->setCXXDirectInitializer(true);
2287
2288 assert(NumExprs == 1 && "Expected 1 expression");
2289 // Set the init expression, handles conversions.
2290 AddInitializerToDecl(Dcl, ExprArg(*this, Exprs.release()[0]),
2291 /*DirectInit=*/true);
2292}
2293
2294/// PerformInitializationByConstructor - Perform initialization by
2295/// constructor (C++ [dcl.init]p14), which may occur as part of
2296/// direct-initialization or copy-initialization. We are initializing
2297/// an object of type @p ClassType with the given arguments @p
2298/// Args. @p Loc is the location in the source code where the
2299/// initializer occurs (e.g., a declaration, member initializer,
2300/// functional cast, etc.) while @p Range covers the whole
2301/// initialization. @p InitEntity is the entity being initialized,
2302/// which may by the name of a declaration or a type. @p Kind is the
2303/// kind of initialization we're performing, which affects whether
2304/// explicit constructors will be considered. When successful, returns
2305/// the constructor that will be used to perform the initialization;
2306/// when the initialization fails, emits a diagnostic and returns
2307/// null.
2308CXXConstructorDecl *
2309Sema::PerformInitializationByConstructor(QualType ClassType,
2310 Expr **Args, unsigned NumArgs,
2311 SourceLocation Loc, SourceRange Range,
2312 DeclarationName InitEntity,
2313 InitializationKind Kind) {
2314 const RecordType *ClassRec = ClassType->getAsRecordType();
2315 assert(ClassRec && "Can only initialize a class type here");
2316
2317 // C++ [dcl.init]p14:
2318 //
2319 // If the initialization is direct-initialization, or if it is
2320 // copy-initialization where the cv-unqualified version of the
2321 // source type is the same class as, or a derived class of, the
2322 // class of the destination, constructors are considered. The
2323 // applicable constructors are enumerated (13.3.1.3), and the
2324 // best one is chosen through overload resolution (13.3). The
2325 // constructor so selected is called to initialize the object,
2326 // with the initializer expression(s) as its argument(s). If no
2327 // constructor applies, or the overload resolution is ambiguous,
2328 // the initialization is ill-formed.
2329 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(ClassRec->getDecl());
2330 OverloadCandidateSet CandidateSet;
2331
2332 // Add constructors to the overload set.
2333 DeclarationName ConstructorName
2334 = Context.DeclarationNames.getCXXConstructorName(
2335 Context.getCanonicalType(ClassType.getUnqualifiedType()));
2336 DeclContext::lookup_const_iterator Con, ConEnd;
2337 for (llvm::tie(Con, ConEnd) = ClassDecl->lookup(ConstructorName);
2338 Con != ConEnd; ++Con) {
2339 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(*Con);
2340 if ((Kind == IK_Direct) ||
2341 (Kind == IK_Copy && Constructor->isConvertingConstructor()) ||
2342 (Kind == IK_Default && Constructor->isDefaultConstructor()))
2343 AddOverloadCandidate(Constructor, Args, NumArgs, CandidateSet);
2344 }
2345
2346 // FIXME: When we decide not to synthesize the implicitly-declared
2347 // constructors, we'll need to make them appear here.
2348
2349 OverloadCandidateSet::iterator Best;
2350 switch (BestViableFunction(CandidateSet, Loc, Best)) {
2351 case OR_Success:
2352 // We found a constructor. Return it.
2353 return cast<CXXConstructorDecl>(Best->Function);
2354
2355 case OR_No_Viable_Function:
2356 if (InitEntity)
2357 Diag(Loc, diag::err_ovl_no_viable_function_in_init)
2358 << InitEntity << Range;
2359 else
2360 Diag(Loc, diag::err_ovl_no_viable_function_in_init)
2361 << ClassType << Range;
2362 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/false);
2363 return 0;
2364
2365 case OR_Ambiguous:
2366 if (InitEntity)
2367 Diag(Loc, diag::err_ovl_ambiguous_init) << InitEntity << Range;
2368 else
2369 Diag(Loc, diag::err_ovl_ambiguous_init) << ClassType << Range;
2370 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
2371 return 0;
2372
2373 case OR_Deleted:
2374 if (InitEntity)
2375 Diag(Loc, diag::err_ovl_deleted_init)
2376 << Best->Function->isDeleted()
2377 << InitEntity << Range;
2378 else
2379 Diag(Loc, diag::err_ovl_deleted_init)
2380 << Best->Function->isDeleted()
2381 << InitEntity << Range;
2382 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
2383 return 0;
2384 }
2385
2386 return 0;
2387}
2388
2389/// CompareReferenceRelationship - Compare the two types T1 and T2 to
2390/// determine whether they are reference-related,
2391/// reference-compatible, reference-compatible with added
2392/// qualification, or incompatible, for use in C++ initialization by
2393/// reference (C++ [dcl.ref.init]p4). Neither type can be a reference
2394/// type, and the first type (T1) is the pointee type of the reference
2395/// type being initialized.
2396Sema::ReferenceCompareResult
2397Sema::CompareReferenceRelationship(QualType T1, QualType T2,
2398 bool& DerivedToBase) {
2399 assert(!T1->isReferenceType() &&
2400 "T1 must be the pointee type of the reference type");
2401 assert(!T2->isReferenceType() && "T2 cannot be a reference type");
2402
2403 T1 = Context.getCanonicalType(T1);
2404 T2 = Context.getCanonicalType(T2);
2405 QualType UnqualT1 = T1.getUnqualifiedType();
2406 QualType UnqualT2 = T2.getUnqualifiedType();
2407
2408 // C++ [dcl.init.ref]p4:
2409 // Given types ���cv1 T1��� and ���cv2 T2,��� ���cv1 T1��� is
2410 // reference-related to ���cv2 T2��� if T1 is the same type as T2, or
2411 // T1 is a base class of T2.
2412 if (UnqualT1 == UnqualT2)
2413 DerivedToBase = false;
2414 else if (IsDerivedFrom(UnqualT2, UnqualT1))
2415 DerivedToBase = true;
2416 else
2417 return Ref_Incompatible;
2418
2419 // At this point, we know that T1 and T2 are reference-related (at
2420 // least).
2421
2422 // C++ [dcl.init.ref]p4:
2423 // "cv1 T1��� is reference-compatible with ���cv2 T2��� if T1 is
2424 // reference-related to T2 and cv1 is the same cv-qualification
2425 // as, or greater cv-qualification than, cv2. For purposes of
2426 // overload resolution, cases for which cv1 is greater
2427 // cv-qualification than cv2 are identified as
2428 // reference-compatible with added qualification (see 13.3.3.2).
2429 if (T1.getCVRQualifiers() == T2.getCVRQualifiers())
2430 return Ref_Compatible;
2431 else if (T1.isMoreQualifiedThan(T2))
2432 return Ref_Compatible_With_Added_Qualification;
2433 else
2434 return Ref_Related;
2435}
2436
2437/// CheckReferenceInit - Check the initialization of a reference
2438/// variable with the given initializer (C++ [dcl.init.ref]). Init is
2439/// the initializer (either a simple initializer or an initializer
2440/// list), and DeclType is the type of the declaration. When ICS is
2441/// non-null, this routine will compute the implicit conversion
2442/// sequence according to C++ [over.ics.ref] and will not produce any
2443/// diagnostics; when ICS is null, it will emit diagnostics when any
2444/// errors are found. Either way, a return value of true indicates
2445/// that there was a failure, a return value of false indicates that
2446/// the reference initialization succeeded.
2447///
2448/// When @p SuppressUserConversions, user-defined conversions are
2449/// suppressed.
2450/// When @p AllowExplicit, we also permit explicit user-defined
2451/// conversion functions.
2452/// When @p ForceRValue, we unconditionally treat the initializer as an rvalue.
2453bool
2454Sema::CheckReferenceInit(Expr *&Init, QualType DeclType,
2455 ImplicitConversionSequence *ICS,
2456 bool SuppressUserConversions,
2457 bool AllowExplicit, bool ForceRValue) {
2458 assert(DeclType->isReferenceType() && "Reference init needs a reference");
2459
2460 QualType T1 = DeclType->getAsReferenceType()->getPointeeType();
2461 QualType T2 = Init->getType();
2462
2463 // If the initializer is the address of an overloaded function, try
2464 // to resolve the overloaded function. If all goes well, T2 is the
2465 // type of the resulting function.
2466 if (Context.getCanonicalType(T2) == Context.OverloadTy) {
2467 FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Init, DeclType,
2468 ICS != 0);
2469 if (Fn) {
2470 // Since we're performing this reference-initialization for
2471 // real, update the initializer with the resulting function.
2472 if (!ICS) {
2473 if (DiagnoseUseOfDecl(Fn, Init->getSourceRange().getBegin()))
2474 return true;
2475
2476 FixOverloadedFunctionReference(Init, Fn);
2477 }
2478
2479 T2 = Fn->getType();
2480 }
2481 }
2482
2483 // Compute some basic properties of the types and the initializer.
2484 bool isRValRef = DeclType->isRValueReferenceType();
2485 bool DerivedToBase = false;
2486 Expr::isLvalueResult InitLvalue = ForceRValue ? Expr::LV_InvalidExpression :
2487 Init->isLvalue(Context);
2488 ReferenceCompareResult RefRelationship
2489 = CompareReferenceRelationship(T1, T2, DerivedToBase);
2490
2491 // Most paths end in a failed conversion.
2492 if (ICS)
2493 ICS->ConversionKind = ImplicitConversionSequence::BadConversion;
2494
2495 // C++ [dcl.init.ref]p5:
2496 // A reference to type ���cv1 T1��� is initialized by an expression
2497 // of type ���cv2 T2��� as follows:
2498
2499 // -- If the initializer expression
2500
2501 // Rvalue references cannot bind to lvalues (N2812).
2502 // There is absolutely no situation where they can. In particular, note that
2503 // this is ill-formed, even if B has a user-defined conversion to A&&:
2504 // B b;
2505 // A&& r = b;
2506 if (isRValRef && InitLvalue == Expr::LV_Valid) {
2507 if (!ICS)
2508 Diag(Init->getSourceRange().getBegin(), diag::err_lvalue_to_rvalue_ref)
2509 << Init->getSourceRange();
2510 return true;
2511 }
2512
2513 bool BindsDirectly = false;
2514 // -- is an lvalue (but is not a bit-field), and ���cv1 T1��� is
2515 // reference-compatible with ���cv2 T2,��� or
2516 //
2517 // Note that the bit-field check is skipped if we are just computing
2518 // the implicit conversion sequence (C++ [over.best.ics]p2).
2519 if (InitLvalue == Expr::LV_Valid && (ICS || !Init->getBitField()) &&
2520 RefRelationship >= Ref_Compatible_With_Added_Qualification) {
2521 BindsDirectly = true;
2522
2523 if (ICS) {
2524 // C++ [over.ics.ref]p1:
2525 // When a parameter of reference type binds directly (8.5.3)
2526 // to an argument expression, the implicit conversion sequence
2527 // is the identity conversion, unless the argument expression
2528 // has a type that is a derived class of the parameter type,
2529 // in which case the implicit conversion sequence is a
2530 // derived-to-base Conversion (13.3.3.1).
2531 ICS->ConversionKind = ImplicitConversionSequence::StandardConversion;
2532 ICS->Standard.First = ICK_Identity;
2533 ICS->Standard.Second = DerivedToBase? ICK_Derived_To_Base : ICK_Identity;
2534 ICS->Standard.Third = ICK_Identity;
2535 ICS->Standard.FromTypePtr = T2.getAsOpaquePtr();
2536 ICS->Standard.ToTypePtr = T1.getAsOpaquePtr();
2537 ICS->Standard.ReferenceBinding = true;
2538 ICS->Standard.DirectBinding = true;
2539 ICS->Standard.RRefBinding = false;
2540 ICS->Standard.CopyConstructor = 0;
2541
2542 // Nothing more to do: the inaccessibility/ambiguity check for
2543 // derived-to-base conversions is suppressed when we're
2544 // computing the implicit conversion sequence (C++
2545 // [over.best.ics]p2).
2546 return false;
2547 } else {
2548 // Perform the conversion.
2549 // FIXME: Binding to a subobject of the lvalue is going to require more
2550 // AST annotation than this.
2551 ImpCastExprToType(Init, T1, /*isLvalue=*/true);
2552 }
2553 }
2554
2555 // -- has a class type (i.e., T2 is a class type) and can be
2556 // implicitly converted to an lvalue of type ���cv3 T3,���
2557 // where ���cv1 T1��� is reference-compatible with ���cv3 T3���
2558 // 92) (this conversion is selected by enumerating the
2559 // applicable conversion functions (13.3.1.6) and choosing
2560 // the best one through overload resolution (13.3)),
2561 if (!isRValRef && !SuppressUserConversions && T2->isRecordType()) {
2562 // FIXME: Look for conversions in base classes!
2563 CXXRecordDecl *T2RecordDecl
2564 = dyn_cast<CXXRecordDecl>(T2->getAsRecordType()->getDecl());
2565
2566 OverloadCandidateSet CandidateSet;
2567 OverloadedFunctionDecl *Conversions
2568 = T2RecordDecl->getConversionFunctions();
2569 for (OverloadedFunctionDecl::function_iterator Func
2570 = Conversions->function_begin();
2571 Func != Conversions->function_end(); ++Func) {
2572 CXXConversionDecl *Conv = cast<CXXConversionDecl>(*Func);
2573
2574 // If the conversion function doesn't return a reference type,
2575 // it can't be considered for this conversion.
2576 if (Conv->getConversionType()->isLValueReferenceType() &&
2577 (AllowExplicit || !Conv->isExplicit()))
2578 AddConversionCandidate(Conv, Init, DeclType, CandidateSet);
2579 }
2580
2581 OverloadCandidateSet::iterator Best;
2582 switch (BestViableFunction(CandidateSet, Init->getLocStart(), Best)) {
2583 case OR_Success:
2584 // This is a direct binding.
2585 BindsDirectly = true;
2586
2587 if (ICS) {
2588 // C++ [over.ics.ref]p1:
2589 //
2590 // [...] If the parameter binds directly to the result of
2591 // applying a conversion function to the argument
2592 // expression, the implicit conversion sequence is a
2593 // user-defined conversion sequence (13.3.3.1.2), with the
2594 // second standard conversion sequence either an identity
2595 // conversion or, if the conversion function returns an
2596 // entity of a type that is a derived class of the parameter
2597 // type, a derived-to-base Conversion.
2598 ICS->ConversionKind = ImplicitConversionSequence::UserDefinedConversion;
2599 ICS->UserDefined.Before = Best->Conversions[0].Standard;
2600 ICS->UserDefined.After = Best->FinalConversion;
2601 ICS->UserDefined.ConversionFunction = Best->Function;
2602 assert(ICS->UserDefined.After.ReferenceBinding &&
2603 ICS->UserDefined.After.DirectBinding &&
2604 "Expected a direct reference binding!");
2605 return false;
2606 } else {
2607 // Perform the conversion.
2608 // FIXME: Binding to a subobject of the lvalue is going to require more
2609 // AST annotation than this.
2610 ImpCastExprToType(Init, T1, /*isLvalue=*/true);
2611 }
2612 break;
2613
2614 case OR_Ambiguous:
2615 assert(false && "Ambiguous reference binding conversions not implemented.");
2616 return true;
2617
2618 case OR_No_Viable_Function:
2619 case OR_Deleted:
2620 // There was no suitable conversion, or we found a deleted
2621 // conversion; continue with other checks.
2622 break;
2623 }
2624 }
2625
2626 if (BindsDirectly) {
2627 // C++ [dcl.init.ref]p4:
2628 // [...] In all cases where the reference-related or
2629 // reference-compatible relationship of two types is used to
2630 // establish the validity of a reference binding, and T1 is a
2631 // base class of T2, a program that necessitates such a binding
2632 // is ill-formed if T1 is an inaccessible (clause 11) or
2633 // ambiguous (10.2) base class of T2.
2634 //
2635 // Note that we only check this condition when we're allowed to
2636 // complain about errors, because we should not be checking for
2637 // ambiguity (or inaccessibility) unless the reference binding
2638 // actually happens.
2639 if (DerivedToBase)
2640 return CheckDerivedToBaseConversion(T2, T1,
2641 Init->getSourceRange().getBegin(),
2642 Init->getSourceRange());
2643 else
2644 return false;
2645 }
2646
2647 // -- Otherwise, the reference shall be to a non-volatile const
2648 // type (i.e., cv1 shall be const), or the reference shall be an
2649 // rvalue reference and the initializer expression shall be an rvalue.
2650 if (!isRValRef && T1.getCVRQualifiers() != QualType::Const) {
2651 if (!ICS)
2652 Diag(Init->getSourceRange().getBegin(),
2653 diag::err_not_reference_to_const_init)
2654 << T1 << (InitLvalue != Expr::LV_Valid? "temporary" : "value")
2655 << T2 << Init->getSourceRange();
2656 return true;
2657 }
2658
2659 // -- If the initializer expression is an rvalue, with T2 a
2660 // class type, and ���cv1 T1��� is reference-compatible with
2661 // ���cv2 T2,��� the reference is bound in one of the
2662 // following ways (the choice is implementation-defined):
2663 //
2664 // -- The reference is bound to the object represented by
2665 // the rvalue (see 3.10) or to a sub-object within that
2666 // object.
2667 //
2668 // -- A temporary of type ���cv1 T2��� [sic] is created, and
2669 // a constructor is called to copy the entire rvalue
2670 // object into the temporary. The reference is bound to
2671 // the temporary or to a sub-object within the
2672 // temporary.
2673 //
2674 // The constructor that would be used to make the copy
2675 // shall be callable whether or not the copy is actually
2676 // done.
2677 //
2678 // Note that C++0x [dcl.init.ref]p5 takes away this implementation
2679 // freedom, so we will always take the first option and never build
2680 // a temporary in this case. FIXME: We will, however, have to check
2681 // for the presence of a copy constructor in C++98/03 mode.
2682 if (InitLvalue != Expr::LV_Valid && T2->isRecordType() &&
2683 RefRelationship >= Ref_Compatible_With_Added_Qualification) {
2684 if (ICS) {
2685 ICS->ConversionKind = ImplicitConversionSequence::StandardConversion;
2686 ICS->Standard.First = ICK_Identity;
2687 ICS->Standard.Second = DerivedToBase? ICK_Derived_To_Base : ICK_Identity;
2688 ICS->Standard.Third = ICK_Identity;
2689 ICS->Standard.FromTypePtr = T2.getAsOpaquePtr();
2690 ICS->Standard.ToTypePtr = T1.getAsOpaquePtr();
2691 ICS->Standard.ReferenceBinding = true;
2692 ICS->Standard.DirectBinding = false;
2693 ICS->Standard.RRefBinding = isRValRef;
2694 ICS->Standard.CopyConstructor = 0;
2695 } else {
2696 // FIXME: Binding to a subobject of the rvalue is going to require more
2697 // AST annotation than this.
2698 ImpCastExprToType(Init, T1, /*isLvalue=*/false);
2699 }
2700 return false;
2701 }
2702
2703 // -- Otherwise, a temporary of type ���cv1 T1��� is created and
2704 // initialized from the initializer expression using the
2705 // rules for a non-reference copy initialization (8.5). The
2706 // reference is then bound to the temporary. If T1 is
2707 // reference-related to T2, cv1 must be the same
2708 // cv-qualification as, or greater cv-qualification than,
2709 // cv2; otherwise, the program is ill-formed.
2710 if (RefRelationship == Ref_Related) {
2711 // If cv1 == cv2 or cv1 is a greater cv-qualified than cv2, then
2712 // we would be reference-compatible or reference-compatible with
2713 // added qualification. But that wasn't the case, so the reference
2714 // initialization fails.
2715 if (!ICS)
2716 Diag(Init->getSourceRange().getBegin(),
2717 diag::err_reference_init_drops_quals)
2718 << T1 << (InitLvalue != Expr::LV_Valid? "temporary" : "value")
2719 << T2 << Init->getSourceRange();
2720 return true;
2721 }
2722
2723 // If at least one of the types is a class type, the types are not
2724 // related, and we aren't allowed any user conversions, the
2725 // reference binding fails. This case is important for breaking
2726 // recursion, since TryImplicitConversion below will attempt to
2727 // create a temporary through the use of a copy constructor.
2728 if (SuppressUserConversions && RefRelationship == Ref_Incompatible &&
2729 (T1->isRecordType() || T2->isRecordType())) {
2730 if (!ICS)
2731 Diag(Init->getSourceRange().getBegin(),
2732 diag::err_typecheck_convert_incompatible)
2733 << DeclType << Init->getType() << "initializing" << Init->getSourceRange();
2734 return true;
2735 }
2736
2737 // Actually try to convert the initializer to T1.
2738 if (ICS) {
2739 // C++ [over.ics.ref]p2:
2740 //
2741 // When a parameter of reference type is not bound directly to
2742 // an argument expression, the conversion sequence is the one
2743 // required to convert the argument expression to the
2744 // underlying type of the reference according to
2745 // 13.3.3.1. Conceptually, this conversion sequence corresponds
2746 // to copy-initializing a temporary of the underlying type with
2747 // the argument expression. Any difference in top-level
2748 // cv-qualification is subsumed by the initialization itself
2749 // and does not constitute a conversion.
2750 *ICS = TryImplicitConversion(Init, T1, SuppressUserConversions);
2751 // Of course, that's still a reference binding.
2752 if (ICS->ConversionKind == ImplicitConversionSequence::StandardConversion) {
2753 ICS->Standard.ReferenceBinding = true;
2754 ICS->Standard.RRefBinding = isRValRef;
2755 } else if(ICS->ConversionKind ==
2756 ImplicitConversionSequence::UserDefinedConversion) {
2757 ICS->UserDefined.After.ReferenceBinding = true;
2758 ICS->UserDefined.After.RRefBinding = isRValRef;
2759 }
2760 return ICS->ConversionKind == ImplicitConversionSequence::BadConversion;
2761 } else {
2762 return PerformImplicitConversion(Init, T1, "initializing");
2763 }
2764}
2765
2766/// CheckOverloadedOperatorDeclaration - Check whether the declaration
2767/// of this overloaded operator is well-formed. If so, returns false;
2768/// otherwise, emits appropriate diagnostics and returns true.
2769bool Sema::CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl) {
2770 assert(FnDecl && FnDecl->isOverloadedOperator() &&
2771 "Expected an overloaded operator declaration");
2772
2773 OverloadedOperatorKind Op = FnDecl->getOverloadedOperator();
2774
2775 // C++ [over.oper]p5:
2776 // The allocation and deallocation functions, operator new,
2777 // operator new[], operator delete and operator delete[], are
2778 // described completely in 3.7.3. The attributes and restrictions
2779 // found in the rest of this subclause do not apply to them unless
2780 // explicitly stated in 3.7.3.
2781 // FIXME: Write a separate routine for checking this. For now, just allow it.
2782 if (Op == OO_New || Op == OO_Array_New ||
2783 Op == OO_Delete || Op == OO_Array_Delete)
2784 return false;
2785
2786 // C++ [over.oper]p6:
2787 // An operator function shall either be a non-static member
2788 // function or be a non-member function and have at least one
2789 // parameter whose type is a class, a reference to a class, an
2790 // enumeration, or a reference to an enumeration.
2791 if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) {
2792 if (MethodDecl->isStatic())
2793 return Diag(FnDecl->getLocation(),
2794 diag::err_operator_overload_static) << FnDecl->getDeclName();
2795 } else {
2796 bool ClassOrEnumParam = false;
2797 for (FunctionDecl::param_iterator Param = FnDecl->param_begin(),
2798 ParamEnd = FnDecl->param_end();
2799 Param != ParamEnd; ++Param) {
2800 QualType ParamType = (*Param)->getType().getNonReferenceType();
2801 if (ParamType->isDependentType() || ParamType->isRecordType() ||
2802 ParamType->isEnumeralType()) {
2803 ClassOrEnumParam = true;
2804 break;
2805 }
2806 }
2807
2808 if (!ClassOrEnumParam)
2809 return Diag(FnDecl->getLocation(),
2810 diag::err_operator_overload_needs_class_or_enum)
2811 << FnDecl->getDeclName();
2812 }
2813
2814 // C++ [over.oper]p8:
2815 // An operator function cannot have default arguments (8.3.6),
2816 // except where explicitly stated below.
2817 //
2818 // Only the function-call operator allows default arguments
2819 // (C++ [over.call]p1).
2820 if (Op != OO_Call) {
2821 for (FunctionDecl::param_iterator Param = FnDecl->param_begin();
2822 Param != FnDecl->param_end(); ++Param) {
2823 if ((*Param)->hasUnparsedDefaultArg())
2824 return Diag((*Param)->getLocation(),
2825 diag::err_operator_overload_default_arg)
2826 << FnDecl->getDeclName();
2827 else if (Expr *DefArg = (*Param)->getDefaultArg())
2828 return Diag((*Param)->getLocation(),
2829 diag::err_operator_overload_default_arg)
2830 << FnDecl->getDeclName() << DefArg->getSourceRange();
2831 }
2832 }
2833
2834 static const bool OperatorUses[NUM_OVERLOADED_OPERATORS][3] = {
2835 { false, false, false }
2836#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
2837 , { Unary, Binary, MemberOnly }
2838#include "clang/Basic/OperatorKinds.def"
2839 };
2840
2841 bool CanBeUnaryOperator = OperatorUses[Op][0];
2842 bool CanBeBinaryOperator = OperatorUses[Op][1];
2843 bool MustBeMemberOperator = OperatorUses[Op][2];
2844
2845 // C++ [over.oper]p8:
2846 // [...] Operator functions cannot have more or fewer parameters
2847 // than the number required for the corresponding operator, as
2848 // described in the rest of this subclause.
2849 unsigned NumParams = FnDecl->getNumParams()
2850 + (isa<CXXMethodDecl>(FnDecl)? 1 : 0);
2851 if (Op != OO_Call &&
2852 ((NumParams == 1 && !CanBeUnaryOperator) ||
2853 (NumParams == 2 && !CanBeBinaryOperator) ||
2854 (NumParams < 1) || (NumParams > 2))) {
2855 // We have the wrong number of parameters.
2856 unsigned ErrorKind;
2857 if (CanBeUnaryOperator && CanBeBinaryOperator) {
2858 ErrorKind = 2; // 2 -> unary or binary.
2859 } else if (CanBeUnaryOperator) {
2860 ErrorKind = 0; // 0 -> unary
2861 } else {
2862 assert(CanBeBinaryOperator &&
2863 "All non-call overloaded operators are unary or binary!");
2864 ErrorKind = 1; // 1 -> binary
2865 }
2866
2867 return Diag(FnDecl->getLocation(), diag::err_operator_overload_must_be)
2868 << FnDecl->getDeclName() << NumParams << ErrorKind;
2869 }
2870
2871 // Overloaded operators other than operator() cannot be variadic.
2872 if (Op != OO_Call &&
2873 FnDecl->getType()->getAsFunctionProtoType()->isVariadic()) {
2874 return Diag(FnDecl->getLocation(), diag::err_operator_overload_variadic)
2875 << FnDecl->getDeclName();
2876 }
2877
2878 // Some operators must be non-static member functions.
2879 if (MustBeMemberOperator && !isa<CXXMethodDecl>(FnDecl)) {
2880 return Diag(FnDecl->getLocation(),
2881 diag::err_operator_overload_must_be_member)
2882 << FnDecl->getDeclName();
2883 }
2884
2885 // C++ [over.inc]p1:
2886 // The user-defined function called operator++ implements the
2887 // prefix and postfix ++ operator. If this function is a member
2888 // function with no parameters, or a non-member function with one
2889 // parameter of class or enumeration type, it defines the prefix
2890 // increment operator ++ for objects of that type. If the function
2891 // is a member function with one parameter (which shall be of type
2892 // int) or a non-member function with two parameters (the second
2893 // of which shall be of type int), it defines the postfix
2894 // increment operator ++ for objects of that type.
2895 if ((Op == OO_PlusPlus || Op == OO_MinusMinus) && NumParams == 2) {
2896 ParmVarDecl *LastParam = FnDecl->getParamDecl(FnDecl->getNumParams() - 1);
2897 bool ParamIsInt = false;
2898 if (const BuiltinType *BT = LastParam->getType()->getAsBuiltinType())
2899 ParamIsInt = BT->getKind() == BuiltinType::Int;
2900
2901 if (!ParamIsInt)
2902 return Diag(LastParam->getLocation(),
2903 diag::err_operator_overload_post_incdec_must_be_int)
2904 << LastParam->getType() << (Op == OO_MinusMinus);
2905 }
2906
2907 // Notify the class if it got an assignment operator.
2908 if (Op == OO_Equal) {
2909 // Would have returned earlier otherwise.
2910 assert(isa<CXXMethodDecl>(FnDecl) &&
2911 "Overloaded = not member, but not filtered.");
2912 CXXMethodDecl *Method = cast<CXXMethodDecl>(FnDecl);
2913 Method->getParent()->addedAssignmentOperator(Context, Method);
2914 }
2915
2916 return false;
2917}
2918
2919/// ActOnStartLinkageSpecification - Parsed the beginning of a C++
2920/// linkage specification, including the language and (if present)
2921/// the '{'. ExternLoc is the location of the 'extern', LangLoc is
2922/// the location of the language string literal, which is provided
2923/// by Lang/StrSize. LBraceLoc, if valid, provides the location of
2924/// the '{' brace. Otherwise, this linkage specification does not
2925/// have any braces.
2926Sema::DeclPtrTy Sema::ActOnStartLinkageSpecification(Scope *S,
2927 SourceLocation ExternLoc,
2928 SourceLocation LangLoc,
2929 const char *Lang,
2930 unsigned StrSize,
2931 SourceLocation LBraceLoc) {
2932 LinkageSpecDecl::LanguageIDs Language;
2933 if (strncmp(Lang, "\"C\"", StrSize) == 0)
2934 Language = LinkageSpecDecl::lang_c;
2935 else if (strncmp(Lang, "\"C++\"", StrSize) == 0)
2936 Language = LinkageSpecDecl::lang_cxx;
2937 else {
2938 Diag(LangLoc, diag::err_bad_language);
2939 return DeclPtrTy();
2940 }
2941
2942 // FIXME: Add all the various semantics of linkage specifications
2943
2944 LinkageSpecDecl *D = LinkageSpecDecl::Create(Context, CurContext,
2945 LangLoc, Language,
2946 LBraceLoc.isValid());
2947 CurContext->addDecl(D);
2948 PushDeclContext(S, D);
2949 return DeclPtrTy::make(D);
2950}
2951
2952/// ActOnFinishLinkageSpecification - Completely the definition of
2953/// the C++ linkage specification LinkageSpec. If RBraceLoc is
2954/// valid, it's the position of the closing '}' brace in a linkage
2955/// specification that uses braces.
2956Sema::DeclPtrTy Sema::ActOnFinishLinkageSpecification(Scope *S,
2957 DeclPtrTy LinkageSpec,
2958 SourceLocation RBraceLoc) {
2959 if (LinkageSpec)
2960 PopDeclContext();
2961 return LinkageSpec;
2962}
2963
2964/// \brief Perform semantic analysis for the variable declaration that
2965/// occurs within a C++ catch clause, returning the newly-created
2966/// variable.
2967VarDecl *Sema::BuildExceptionDeclaration(Scope *S, QualType ExDeclType,
2968 IdentifierInfo *Name,
2969 SourceLocation Loc,
2970 SourceRange Range) {
2971 bool Invalid = false;
2972
2973 // Arrays and functions decay.
2974 if (ExDeclType->isArrayType())
2975 ExDeclType = Context.getArrayDecayedType(ExDeclType);
2976 else if (ExDeclType->isFunctionType())
2977 ExDeclType = Context.getPointerType(ExDeclType);
2978
2979 // C++ 15.3p1: The exception-declaration shall not denote an incomplete type.
2980 // The exception-declaration shall not denote a pointer or reference to an
2981 // incomplete type, other than [cv] void*.
2982 // N2844 forbids rvalue references.
2983 if(!ExDeclType->isDependentType() && ExDeclType->isRValueReferenceType()) {
2984 Diag(Loc, diag::err_catch_rvalue_ref) << Range;
2985 Invalid = true;
2986 }
2987
2988 QualType BaseType = ExDeclType;
2989 int Mode = 0; // 0 for direct type, 1 for pointer, 2 for reference
2990 unsigned DK = diag::err_catch_incomplete;
2991 if (const PointerType *Ptr = BaseType->getAsPointerType()) {
2992 BaseType = Ptr->getPointeeType();
2993 Mode = 1;
2994 DK = diag::err_catch_incomplete_ptr;
2995 } else if(const ReferenceType *Ref = BaseType->getAsReferenceType()) {
2996 // For the purpose of error recovery, we treat rvalue refs like lvalue refs.
2997 BaseType = Ref->getPointeeType();
2998 Mode = 2;
2999 DK = diag::err_catch_incomplete_ref;
3000 }
3001 if (!Invalid && (Mode == 0 || !BaseType->isVoidType()) &&
3002 !BaseType->isDependentType() && RequireCompleteType(Loc, BaseType, DK))
3003 Invalid = true;
3004
3005 if (!Invalid && !ExDeclType->isDependentType() &&
3006 RequireNonAbstractType(Loc, ExDeclType,
3007 diag::err_abstract_type_in_decl,
3008 AbstractVariableType))
3009 Invalid = true;
3010
3011 // FIXME: Need to test for ability to copy-construct and destroy the
3012 // exception variable.
3013
3014 // FIXME: Need to check for abstract classes.
3015
3016 VarDecl *ExDecl = VarDecl::Create(Context, CurContext, Loc,
3017 Name, ExDeclType, VarDecl::None,
3018 Range.getBegin());
3019
3020 if (Invalid)
3021 ExDecl->setInvalidDecl();
3022
3023 return ExDecl;
3024}
3025
3026/// ActOnExceptionDeclarator - Parsed the exception-declarator in a C++ catch
3027/// handler.
3028Sema::DeclPtrTy Sema::ActOnExceptionDeclarator(Scope *S, Declarator &D) {
3029 QualType ExDeclType = GetTypeForDeclarator(D, S);
3030
3031 bool Invalid = D.isInvalidType();
3032 IdentifierInfo *II = D.getIdentifier();
3033 if (NamedDecl *PrevDecl = LookupName(S, II, LookupOrdinaryName)) {
3034 // The scope should be freshly made just for us. There is just no way
3035 // it contains any previous declaration.
3036 assert(!S->isDeclScope(DeclPtrTy::make(PrevDecl)));
3037 if (PrevDecl->isTemplateParameter()) {
3038 // Maybe we will complain about the shadowed template parameter.
3039 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
3040 }
3041 }
3042
3043 if (D.getCXXScopeSpec().isSet() && !Invalid) {
3044 Diag(D.getIdentifierLoc(), diag::err_qualified_catch_declarator)
3045 << D.getCXXScopeSpec().getRange();
3046 Invalid = true;
3047 }
3048
3049 VarDecl *ExDecl = BuildExceptionDeclaration(S, ExDeclType,
3050 D.getIdentifier(),
3051 D.getIdentifierLoc(),
3052 D.getDeclSpec().getSourceRange());
3053
3054 if (Invalid)
3055 ExDecl->setInvalidDecl();
3056
3057 // Add the exception declaration into this scope.
3058 if (II)
3059 PushOnScopeChains(ExDecl, S);
3060 else
3061 CurContext->addDecl(ExDecl);
3062
3063 ProcessDeclAttributes(S, ExDecl, D);
3064 return DeclPtrTy::make(ExDecl);
3065}
3066
3067Sema::DeclPtrTy Sema::ActOnStaticAssertDeclaration(SourceLocation AssertLoc,
3068 ExprArg assertexpr,
3069 ExprArg assertmessageexpr) {
3070 Expr *AssertExpr = (Expr *)assertexpr.get();
3071 StringLiteral *AssertMessage =
3072 cast<StringLiteral>((Expr *)assertmessageexpr.get());
3073
3074 if (!AssertExpr->isTypeDependent() && !AssertExpr->isValueDependent()) {
3075 llvm::APSInt Value(32);
3076 if (!AssertExpr->isIntegerConstantExpr(Value, Context)) {
3077 Diag(AssertLoc, diag::err_static_assert_expression_is_not_constant) <<
3078 AssertExpr->getSourceRange();
3079 return DeclPtrTy();
3080 }
3081
3082 if (Value == 0) {
3083 std::string str(AssertMessage->getStrData(),
3084 AssertMessage->getByteLength());
3085 Diag(AssertLoc, diag::err_static_assert_failed)
3086 << str << AssertExpr->getSourceRange();
3087 }
3088 }
3089
3090 assertexpr.release();
3091 assertmessageexpr.release();
3092 Decl *Decl = StaticAssertDecl::Create(Context, CurContext, AssertLoc,
3093 AssertExpr, AssertMessage);
3094
3095 CurContext->addDecl(Decl);
3096 return DeclPtrTy::make(Decl);
3097}
3098
3099bool Sema::ActOnFriendDecl(Scope *S, SourceLocation FriendLoc, DeclPtrTy Dcl) {
3100 if (!(S->getFlags() & Scope::ClassScope)) {
3101 Diag(FriendLoc, diag::err_friend_decl_outside_class);
3102 return true;
3103 }
3104
3105 return false;
3106}
3107
3108void Sema::SetDeclDeleted(DeclPtrTy dcl, SourceLocation DelLoc) {
3109 Decl *Dcl = dcl.getAs<Decl>();
3110 FunctionDecl *Fn = dyn_cast<FunctionDecl>(Dcl);
3111 if (!Fn) {
3112 Diag(DelLoc, diag::err_deleted_non_function);
3113 return;
3114 }
3115 if (const FunctionDecl *Prev = Fn->getPreviousDeclaration()) {
3116 Diag(DelLoc, diag::err_deleted_decl_not_first);
3117 Diag(Prev->getLocation(), diag::note_previous_declaration);
3118 // If the declaration wasn't the first, we delete the function anyway for
3119 // recovery.
3120 }
3121 Fn->setDeleted();
3122}
3123
3124static void SearchForReturnInStmt(Sema &Self, Stmt *S) {
3125 for (Stmt::child_iterator CI = S->child_begin(), E = S->child_end(); CI != E;
3126 ++CI) {
3127 Stmt *SubStmt = *CI;
3128 if (!SubStmt)
3129 continue;
3130 if (isa<ReturnStmt>(SubStmt))
3131 Self.Diag(SubStmt->getSourceRange().getBegin(),
3132 diag::err_return_in_constructor_handler);
3133 if (!isa<Expr>(SubStmt))
3134 SearchForReturnInStmt(Self, SubStmt);
3135 }
3136}
3137
3138void Sema::DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock) {
3139 for (unsigned I = 0, E = TryBlock->getNumHandlers(); I != E; ++I) {
3140 CXXCatchStmt *Handler = TryBlock->getHandler(I);
3141 SearchForReturnInStmt(*this, Handler);
3142 }
3143}
3144
3145bool Sema::CheckOverridingFunctionReturnType(const CXXMethodDecl *New,
3146 const CXXMethodDecl *Old) {
3147 QualType NewTy = New->getType()->getAsFunctionType()->getResultType();
3148 QualType OldTy = Old->getType()->getAsFunctionType()->getResultType();
3149
3150 QualType CNewTy = Context.getCanonicalType(NewTy);
3151 QualType COldTy = Context.getCanonicalType(OldTy);
3152
3153 if (CNewTy == COldTy &&
3154 CNewTy.getCVRQualifiers() == COldTy.getCVRQualifiers())
3155 return false;
3156
3157 // Check if the return types are covariant
3158 QualType NewClassTy, OldClassTy;
3159
3160 /// Both types must be pointers or references to classes.
3161 if (PointerType *NewPT = dyn_cast<PointerType>(NewTy)) {
3162 if (PointerType *OldPT = dyn_cast<PointerType>(OldTy)) {
3163 NewClassTy = NewPT->getPointeeType();
3164 OldClassTy = OldPT->getPointeeType();
3165 }
3166 } else if (ReferenceType *NewRT = dyn_cast<ReferenceType>(NewTy)) {
3167 if (ReferenceType *OldRT = dyn_cast<ReferenceType>(OldTy)) {
3168 NewClassTy = NewRT->getPointeeType();
3169 OldClassTy = OldRT->getPointeeType();
3170 }
3171 }
3172
3173 // The return types aren't either both pointers or references to a class type.
3174 if (NewClassTy.isNull()) {
3175 Diag(New->getLocation(),
3176 diag::err_different_return_type_for_overriding_virtual_function)
3177 << New->getDeclName() << NewTy << OldTy;
3178 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
3179
3180 return true;
3181 }
3182
3183 if (NewClassTy.getUnqualifiedType() != OldClassTy.getUnqualifiedType()) {
3184 // Check if the new class derives from the old class.
3185 if (!IsDerivedFrom(NewClassTy, OldClassTy)) {
3186 Diag(New->getLocation(),
3187 diag::err_covariant_return_not_derived)
3188 << New->getDeclName() << NewTy << OldTy;
3189 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
3190 return true;
3191 }
3192
3193 // Check if we the conversion from derived to base is valid.
3194 if (CheckDerivedToBaseConversion(NewClassTy, OldClassTy,
3195 diag::err_covariant_return_inaccessible_base,
3196 diag::err_covariant_return_ambiguous_derived_to_base_conv,
3197 // FIXME: Should this point to the return type?
3198 New->getLocation(), SourceRange(), New->getDeclName())) {
3199 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
3200 return true;
3201 }
3202 }
3203
3204 // The qualifiers of the return types must be the same.
3205 if (CNewTy.getCVRQualifiers() != COldTy.getCVRQualifiers()) {
3206 Diag(New->getLocation(),
3207 diag::err_covariant_return_type_different_qualifications)
3208 << New->getDeclName() << NewTy << OldTy;
3209 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
3210 return true;
3211 };
3212
3213
3214 // The new class type must have the same or less qualifiers as the old type.
3215 if (NewClassTy.isMoreQualifiedThan(OldClassTy)) {
3216 Diag(New->getLocation(),
3217 diag::err_covariant_return_type_class_type_more_qualified)
3218 << New->getDeclName() << NewTy << OldTy;
3219 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
3220 return true;
3221 };
3222
3223 return false;
3224}
3225
3226/// ActOnCXXEnterDeclInitializer - Invoked when we are about to parse an
3227/// initializer for the declaration 'Dcl'.
3228/// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
3229/// static data member of class X, names should be looked up in the scope of
3230/// class X.
3231void Sema::ActOnCXXEnterDeclInitializer(Scope *S, DeclPtrTy Dcl) {
3232 Decl *D = Dcl.getAs<Decl>();
3233 // If there is no declaration, there was an error parsing it.
3234 if (D == 0)
3235 return;
3236
3237 // Check whether it is a declaration with a nested name specifier like
3238 // int foo::bar;
3239 if (!D->isOutOfLine())
3240 return;
3241
3242 // C++ [basic.lookup.unqual]p13
3243 //
3244 // A name used in the definition of a static data member of class X
3245 // (after the qualified-id of the static member) is looked up as if the name
3246 // was used in a member function of X.
3247
3248 // Change current context into the context of the initializing declaration.
3249 EnterDeclaratorContext(S, D->getDeclContext());
3250}
3251
3252/// ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an
3253/// initializer for the declaration 'Dcl'.
3254void Sema::ActOnCXXExitDeclInitializer(Scope *S, DeclPtrTy Dcl) {
3255 Decl *D = Dcl.getAs<Decl>();
3256 // If there is no declaration, there was an error parsing it.
3257 if (D == 0)
3258 return;
3259
3260 // Check whether it is a declaration with a nested name specifier like
3261 // int foo::bar;
3262 if (!D->isOutOfLine())
3263 return;
3264
3265 assert(S->getEntity() == D->getDeclContext() && "Context imbalance!");
3266 ExitDeclaratorContext(S);
3267}
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"
15#include "SemaInherit.h"
16#include "clang/AST/ASTConsumer.h"
17#include "clang/AST/ASTContext.h"
18#include "clang/AST/DeclVisitor.h"
19#include "clang/AST/TypeOrdering.h"
20#include "clang/AST/StmtVisitor.h"
21#include "clang/Lex/Preprocessor.h"
22#include "clang/Parse/DeclSpec.h"
23#include "llvm/ADT/STLExtras.h"
24#include "llvm/Support/Compiler.h"
25#include <algorithm> // for std::equal
26#include <map>
27
28using namespace clang;
29
30//===----------------------------------------------------------------------===//
31// CheckDefaultArgumentVisitor
32//===----------------------------------------------------------------------===//
33
34namespace {
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
41 : public StmtVisitor<CheckDefaultArgumentVisitor, bool> {
42 Expr *DefaultArg;
43 Sema *S;
44
45 public:
46 CheckDefaultArgumentVisitor(Expr *defarg, Sema *s)
47 : DefaultArg(defarg), S(s) {}
48
49 bool VisitExpr(Expr *Node);
50 bool VisitDeclRefExpr(DeclRefExpr *DRE);
51 bool VisitCXXThisExpr(CXXThisExpr *ThisE);
52 };
53
54 /// VisitExpr - Visit all of the children of this expression.
55 bool CheckDefaultArgumentVisitor::VisitExpr(Expr *Node) {
56 bool IsInvalid = false;
57 for (Stmt::child_iterator I = Node->child_begin(),
58 E = Node->child_end(); I != E; ++I)
59 IsInvalid |= Visit(*I);
60 return IsInvalid;
61 }
62
63 /// 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) {
67 NamedDecl *Decl = DRE->getDecl();
68 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(),
78 diag::err_param_default_argument_references_param)
79 << Param->getDeclName() << DefaultArg->getSourceRange();
80 } else if (VarDecl *VDecl = dyn_cast<VarDecl>(Decl)) {
81 // C++ [dcl.fct.default]p7
82 // Local variables shall not be used in default argument
83 // expressions.
84 if (VDecl->isBlockVarDecl())
85 return S->Diag(DRE->getSourceRange().getBegin(),
86 diag::err_param_default_argument_references_local)
87 << VDecl->getDeclName() << DefaultArg->getSourceRange();
88 }
89
90 return false;
91 }
92
93 /// 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(),
99 diag::err_param_default_argument_references_this)
100 << ThisE->getSourceRange();
101 }
102}
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.
107void
108Sema::ActOnParamDefaultArgument(DeclPtrTy param, SourceLocation EqualLoc,
109 ExprArg defarg) {
110 if (!param || !defarg.get())
111 return;
112
113 ParmVarDecl *Param = cast<ParmVarDecl>(param.getAs<Decl>());
114 UnparsedDefaultArgLocs.erase(Param);
115
116 ExprOwningPtr<Expr> DefaultArg(this, defarg.takeAs<Expr>());
117 QualType ParamType = Param->getType();
118
119 // Default arguments are only permitted in C++
120 if (!getLangOptions().CPlusPlus) {
121 Diag(EqualLoc, diag::err_param_default_argument)
122 << DefaultArg->getSourceRange();
123 Param->setInvalidDecl();
124 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).
133 Expr *DefaultArgPtr = DefaultArg.get();
134 bool DefaultInitFailed = CheckInitializerTypes(DefaultArgPtr, ParamType,
135 EqualLoc,
136 Param->getDeclName(),
137 /*DirectInit=*/false);
138 if (DefaultArgPtr != DefaultArg.get()) {
139 DefaultArg.take();
140 DefaultArg.reset(DefaultArgPtr);
141 }
142 if (DefaultInitFailed) {
143 return;
144 }
145
146 // Check that the default argument is well-formed
147 CheckDefaultArgumentVisitor DefaultArgChecker(DefaultArg.get(), this);
148 if (DefaultArgChecker.Visit(DefaultArg.get())) {
149 Param->setInvalidDecl();
150 return;
151 }
152
153 DefaultArgPtr = MaybeCreateCXXExprWithTemporaries(DefaultArg.take(),
154 /*DestroyTemps=*/false);
155
156 // Okay: add the default argument to the parameter
157 Param->setDefaultArg(DefaultArgPtr);
158}
159
160/// 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.
164void Sema::ActOnParamUnparsedDefaultArgument(DeclPtrTy param,
165 SourceLocation EqualLoc,
166 SourceLocation ArgLoc) {
167 if (!param)
168 return;
169
170 ParmVarDecl *Param = cast<ParmVarDecl>(param.getAs<Decl>());
171 if (Param)
172 Param->setUnparsedDefaultArg();
173
174 UnparsedDefaultArgLocs[Param] = ArgLoc;
175}
176
177/// ActOnParamDefaultArgumentError - Parsing or semantic analysis of
178/// the default argument for the parameter param failed.
179void Sema::ActOnParamDefaultArgumentError(DeclPtrTy param) {
180 if (!param)
181 return;
182
183 ParmVarDecl *Param = cast<ParmVarDecl>(param.getAs<Decl>());
184
185 Param->setInvalidDecl();
186
187 UnparsedDefaultArgLocs.erase(Param);
188}
189
190/// 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.
203 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
204 DeclaratorChunk &chunk = D.getTypeObject(i);
205 if (chunk.Kind == DeclaratorChunk::Function) {
206 for (unsigned argIdx = 0, e = chunk.Fun.NumArgs; argIdx != e; ++argIdx) {
207 ParmVarDecl *Param =
208 cast<ParmVarDecl>(chunk.Fun.ArgInfo[argIdx].Param.getAs<Decl>());
209 if (Param->hasUnparsedDefaultArg()) {
210 CachedTokens *Toks = chunk.Fun.ArgInfo[argIdx].DefaultArgTokens;
211 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;
215 } else if (Param->getDefaultArg()) {
216 Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
217 << Param->getDefaultArg()->getSourceRange();
218 Param->setDefaultArg(0);
219 }
220 }
221 }
222 }
223}
224
225// MergeCXXFunctionDecl - Merge two declarations of the same C++
226// function, once we already know that they have the same
227// 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
232 // 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(),
251 diag::err_param_default_argument_redefinition)
252 << NewParam->getDefaultArg()->getSourceRange();
253 Diag(OldParam->getLocation(), diag::note_previous_definition);
254 Invalid = true;
255 } else if (OldParam->getDefaultArg()) {
256 // Merge the old default argument into the new parameter
257 NewParam->setDefaultArg(OldParam->getDefaultArg());
258 }
259 }
260
261 if (CheckEquivalentExceptionSpec(
262 Old->getType()->getAsFunctionProtoType(), Old->getLocation(),
263 New->getType()->getAsFunctionProtoType(), New->getLocation())) {
264 Invalid = true;
265 }
266
267 return Invalid;
268}
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()) {
294 if (Param->isInvalidDecl())
295 /* We already complained about this parameter. */;
296 else if (Param->getIdentifier())
297 Diag(Param->getLocation(),
298 diag::err_param_default_argument_missing_name)
299 << Param->getIdentifier();
300 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);
315 if (Param->hasDefaultArg()) {
316 if (!Param->hasUnparsedDefaultArg())
317 Param->getDefaultArg()->Destroy(Context);
318 Param->setDefaultArg(0);
319 }
320 }
321 }
322}
323
324/// 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.
328bool Sema::isCurrentClassName(const IdentifierInfo &II, Scope *,
329 const CXXScopeSpec *SS) {
330 CXXRecordDecl *CurDecl;
331 if (SS && SS->isSet() && !SS->isInvalid()) {
332 DeclContext *DC = computeDeclContext(*SS);
333 CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC);
334 } else
335 CurDecl = dyn_cast_or_null<CXXRecordDecl>(CurContext);
336
337 if (CurDecl)
338 return &II == CurDecl->getIdentifier();
339 else
340 return false;
341}
342
343/// \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.
382 if (RequireCompleteType(BaseLoc, BaseType, diag::err_incomplete_base_class,
383 SpecifierRange))
384 return 0;
385
386 // If the base class is polymorphic, the new one is, too.
387 RecordDecl *BaseDecl = BaseType->getAsRecordType()->getDecl();
388 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
399 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 }
410
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());
416
417 // 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
424/// 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.
429Sema::BaseResult
430Sema::ActOnBaseSpecifier(DeclPtrTy classdecl, SourceRange SpecifierRange,
431 bool Virtual, AccessSpecifier Access,
432 TypeTy *basetype, SourceLocation BaseLoc) {
433 if (!classdecl)
434 return true;
435
436 AdjustDeclIfTemplate(classdecl);
437 CXXRecordDecl *Class = cast<CXXRecordDecl>(classdecl.getAs<Decl>());
438 QualType BaseType = QualType::getFromOpaquePtr(basetype);
439 if (CXXBaseSpecifier *BaseSpec = CheckBaseSpecifier(Class, SpecifierRange,
440 Virtual, Access,
441 BaseType, BaseLoc))
442 return BaseSpec;
443
444 return true;
445}
446
447/// \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;
453
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
456 // that the key is always the unqualified canonical type of the base
457 // class.
458 std::map<QualType, CXXBaseSpecifier*, QualTypeOrdering> KnownBaseTypes;
459
460 // Copy non-redundant base specifiers into permanent storage.
461 unsigned NumGoodBases = 0;
462 bool Invalid = false;
463 for (unsigned idx = 0; idx < NumBases; ++idx) {
464 QualType NewBaseType
465 = Context.getCanonicalType(Bases[idx]->getType());
466 NewBaseType = NewBaseType.getUnqualifiedType();
467
468 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.
472 Diag(Bases[idx]->getSourceRange().getBegin(),
473 diag::err_duplicate_base_class)
474 << KnownBaseTypes[NewBaseType]->getType()
475 << Bases[idx]->getSourceRange();
476
477 // Delete the duplicate base class specifier; we're going to
478 // overwrite its pointer later.
479 delete Bases[idx];
480
481 Invalid = true;
482 } else {
483 // Okay, add this new base class.
484 KnownBaseTypes[NewBaseType] = Bases[idx];
485 Bases[NumGoodBases++] = Bases[idx];
486 }
487 }
488
489 // Attach the remaining base class specifiers to the derived class.
490 Class->setBases(Context, Bases, NumGoodBases);
491
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)
495 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.
503void Sema::ActOnBaseSpecifiers(DeclPtrTy ClassDecl, BaseTy **Bases,
504 unsigned NumBases) {
505 if (!ClassDecl || !Bases || !NumBases)
506 return;
507
508 AdjustDeclIfTemplate(ClassDecl);
509 AttachBaseSpecifiers(cast<CXXRecordDecl>(ClassDecl.getAs<Decl>()),
510 (CXXBaseSpecifier**)(Bases), NumBases);
511}
512
513//===----------------------------------------------------------------------===//
514// C++ class member Handling
515//===----------------------------------------------------------------------===//
516
517/// 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
520/// any.
521Sema::DeclPtrTy
522Sema::ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS, Declarator &D,
523 ExprTy *BW, ExprTy *InitExpr, bool Deleted) {
524 const DeclSpec &DS = D.getDeclSpec();
525 DeclarationName Name = GetNameForDeclarator(D);
526 Expr *BitWidth = static_cast<Expr*>(BW);
527 Expr *Init = static_cast<Expr*>(InitExpr);
528 SourceLocation Loc = D.getIdentifierLoc();
529
530 bool isFunc = D.isFunctionDeclarator();
531
532 // C++ 9.2p6: A member shall not be declared to have automatic storage
533 // duration (auto, register) or with the extern storage-class-specifier.
534 // 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.
537 switch (DS.getStorageClassSpec()) {
538 case DeclSpec::SCS_unspecified:
539 case DeclSpec::SCS_typedef:
540 case DeclSpec::SCS_static:
541 // FALL THROUGH.
542 break;
543 case DeclSpec::SCS_mutable:
544 if (isFunc) {
545 if (DS.getStorageClassSpecLoc().isValid())
546 Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_function);
547 else
548 Diag(DS.getThreadSpecLoc(), diag::err_mutable_function);
549
550 // FIXME: It would be nicer if the keyword was ignored only for this
551 // declarator. Otherwise we could get follow-up errors.
552 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);
565 // FIXME: It would be nicer if the keyword was ignored only for this
566 // declarator. Otherwise we could get follow-up errors.
567 D.getMutableDeclSpec().ClearStorageClassSpecs();
568 }
569 }
570 break;
571 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
580 if (!isFunc &&
581 D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_typename &&
582 D.getNumTypeObjects() == 0) {
583 // Check also for this case:
584 //
585 // typedef int f();
586 // f a;
587 //
588 QualType TDType = QualType::getFromOpaquePtr(DS.getTypeRep());
589 isFunc = TDType->isFunctionType();
590 }
591
592 bool isInstField = ((DS.getStorageClassSpec() == DeclSpec::SCS_unspecified ||
593 DS.getStorageClassSpec() == DeclSpec::SCS_mutable) &&
594 !isFunc);
595
596 Decl *Member;
597 if (isInstField) {
598 Member = HandleField(S, cast<CXXRecordDecl>(CurContext), Loc, D, BitWidth,
599 AS);
600 assert(Member && "HandleField never returns null");
601 } else {
602 Member = ActOnDeclarator(S, D).getAs<Decl>();
603 if (!Member) {
604 if (BitWidth) DeleteExpr(BitWidth);
605 return DeclPtrTy();
606 }
607
608 // Non-instance-fields can't have a bitfield.
609 if (BitWidth) {
610 if (Member->isInvalidDecl()) {
611 // don't emit another diagnostic.
612 } else if (isa<VarDecl>(Member)) {
613 // 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)
625 << Name << cast<ValueDecl>(Member)->getType()
626 << BitWidth->getSourceRange();
627 }
628
629 DeleteExpr(BitWidth);
630 BitWidth = 0;
631 Member->setInvalidDecl();
632 }
633
634 Member->setAccess(AS);
635 }
636
637 assert((Name || isInstField) && "No identifier for non-field ?");
638
639 if (Init)
640 AddInitializerToDecl(DeclPtrTy::make(Member), ExprArg(*this, Init), false);
641 if (Deleted) // FIXME: Source location is not very good.
642 SetDeclDeleted(DeclPtrTy::make(Member), D.getSourceRange().getBegin());
643
644 if (isInstField) {
645 FieldCollector->Add(cast<FieldDecl>(Member));
646 return DeclPtrTy();
647 }
648 return DeclPtrTy::make(Member);
649}
650
651/// ActOnMemInitializer - Handle a C++ member initializer.
652Sema::MemInitResult
653Sema::ActOnMemInitializer(DeclPtrTy ConstructorD,
654 Scope *S,
655 const CXXScopeSpec &SS,
656 IdentifierInfo *MemberOrBase,
657 TypeTy *TemplateTypeTy,
658 SourceLocation IdLoc,
659 SourceLocation LParenLoc,
660 ExprTy **Args, unsigned NumArgs,
661 SourceLocation *CommaLocs,
662 SourceLocation RParenLoc) {
663 if (!ConstructorD)
664 return true;
665
666 CXXConstructorDecl *Constructor
667 = dyn_cast<CXXConstructorDecl>(ConstructorD.getAs<Decl>());
668 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. ]
688 if (!SS.getScopeRep() && !TemplateTypeTy) {
689 // 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);
695
696 // FIXME: Handle members of an anonymous union.
697
698 if (Member) {
699 // FIXME: Perform direct initialization of the member.
700 return new CXXBaseOrMemberInitializer(Member, (Expr **)Args, NumArgs,
701 IdLoc);
702 }
703 }
704 // It didn't name a member, so see if it names a class.
705 TypeTy *BaseTy = TemplateTypeTy ? TemplateTypeTy
706 : getTypeName(*MemberOrBase, IdLoc, S, &SS);
707 if (!BaseTy)
708 return Diag(IdLoc, diag::err_mem_init_not_member_or_class)
709 << MemberOrBase << SourceRange(IdLoc, RParenLoc);
710
711 QualType BaseType = QualType::getFromOpaquePtr(BaseTy);
712 if (!BaseType->isRecordType() && !BaseType->isDependentType())
713 return Diag(IdLoc, diag::err_base_init_does_not_name_class)
714 << BaseType << SourceRange(IdLoc, RParenLoc);
715
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.
737 // FIXME: We might be able to short-circuit this if we know in advance that
738 // there are no virtual bases.
739 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)
761 return Diag(IdLoc, diag::err_base_init_direct_and_virtual)
762 << MemberOrBase << SourceRange(IdLoc, RParenLoc);
763 // 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
772
773 return new CXXBaseOrMemberInitializer(BaseType, (Expr **)Args, NumArgs,
774 IdLoc);
775}
776
777void Sema::ActOnMemInitializers(DeclPtrTy ConstructorDecl,
778 SourceLocation ColonLoc,
779 MemInitTy **MemInits, unsigned NumMemInits) {
780 if (!ConstructorDecl)
781 return;
782
783 CXXConstructorDecl *Constructor
784 = dyn_cast<CXXConstructorDecl>(ConstructorDecl.getAs<Decl>());
785
786 if (!Constructor) {
787 Diag(ColonLoc, diag::err_only_constructors_take_base_inits);
788 return;
789 }
790 llvm::DenseMap<void*, CXXBaseOrMemberInitializer *>Members;
791 bool err = false;
792 for (unsigned i = 0; i < NumMemInits; i++) {
793 CXXBaseOrMemberInitializer *Member =
794 static_cast<CXXBaseOrMemberInitializer*>(MemInits[i]);
795 void *KeyToMember = Member->getBaseOrMember();
796 // For fields injected into the class via declaration of an anonymous union,
797 // use its anonymous union class declaration as the unique key.
798 if (FieldDecl *Field = Member->getMember())
799 if (Field->getDeclContext()->isRecord() &&
800 cast<RecordDecl>(Field->getDeclContext())->isAnonymousStructOrUnion())
801 KeyToMember = static_cast<void *>(Field->getDeclContext());
802 CXXBaseOrMemberInitializer *&PrevMember = Members[KeyToMember];
803 if (!PrevMember) {
804 PrevMember = Member;
805 continue;
806 }
807 if (FieldDecl *Field = Member->getMember())
808 Diag(Member->getSourceLocation(),
809 diag::error_multiple_mem_initialization)
810 << Field->getNameAsString();
811 else {
812 Type *BaseClass = Member->getBaseClass();
813 assert(BaseClass && "ActOnMemInitializers - neither field or base");
814 Diag(Member->getSourceLocation(),
815 diag::error_multiple_base_initialization)
816 << BaseClass->getDesugaredType(true);
817 }
818 Diag(PrevMember->getSourceLocation(), diag::note_previous_initializer)
819 << 0;
820 err = true;
821 }
822 if (!err)
823 Constructor->setBaseOrMemberInitializers(Context,
824 reinterpret_cast<CXXBaseOrMemberInitializer **>(MemInits),
825 NumMemInits);
826}
827
828namespace {
829 /// PureVirtualMethodCollector - traverses a class and its superclasses
830 /// and determines if it has any pure virtual methods.
831 class VISIBILITY_HIDDEN PureVirtualMethodCollector {
832 ASTContext &Context;
833
834 public:
835 typedef llvm::SmallVector<const CXXMethodDecl*, 8> MethodList;
836
837 private:
838 MethodList Methods;
839
840 void Collect(const CXXRecordDecl* RD, MethodList& Methods);
841
842 public:
843 PureVirtualMethodCollector(ASTContext &Ctx, const CXXRecordDecl* RD)
844 : Context(Ctx) {
845
846 MethodList List;
847 Collect(RD, List);
848
849 // Copy the temporary list to methods, and make sure to ignore any
850 // null entries.
851 for (size_t i = 0, e = List.size(); i != e; ++i) {
852 if (List[i])
853 Methods.push_back(List[i]);
854 }
855 }
856
857 bool empty() const { return Methods.empty(); }
858
859 MethodList::const_iterator methods_begin() { return Methods.begin(); }
860 MethodList::const_iterator methods_end() { return Methods.end(); }
861 };
862
863 void PureVirtualMethodCollector::Collect(const CXXRecordDecl* RD,
864 MethodList& Methods) {
865 // First, collect the pure virtual methods for the base classes.
866 for (CXXRecordDecl::base_class_const_iterator Base = RD->bases_begin(),
867 BaseEnd = RD->bases_end(); Base != BaseEnd; ++Base) {
868 if (const RecordType *RT = Base->getType()->getAsRecordType()) {
869 const CXXRecordDecl *BaseDecl = cast<CXXRecordDecl>(RT->getDecl());
870 if (BaseDecl && BaseDecl->isAbstract())
871 Collect(BaseDecl, Methods);
872 }
873 }
874
875 // Next, zero out any pure virtual methods that this class overrides.
876 typedef llvm::SmallPtrSet<const CXXMethodDecl*, 4> MethodSetTy;
877
878 MethodSetTy OverriddenMethods;
879 size_t MethodsSize = Methods.size();
880
881 for (RecordDecl::decl_iterator i = RD->decls_begin(), e = RD->decls_end();
882 i != e; ++i) {
883 // Traverse the record, looking for methods.
884 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(*i)) {
885 // If the method is pre virtual, add it to the methods vector.
886 if (MD->isPure()) {
887 Methods.push_back(MD);
888 continue;
889 }
890
891 // Otherwise, record all the overridden methods in our set.
892 for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(),
893 E = MD->end_overridden_methods(); I != E; ++I) {
894 // Keep track of the overridden methods.
895 OverriddenMethods.insert(*I);
896 }
897 }
898 }
899
900 // Now go through the methods and zero out all the ones we know are
901 // overridden.
902 for (size_t i = 0, e = MethodsSize; i != e; ++i) {
903 if (OverriddenMethods.count(Methods[i]))
904 Methods[i] = 0;
905 }
906
907 }
908}
909
910bool Sema::RequireNonAbstractType(SourceLocation Loc, QualType T,
911 unsigned DiagID, AbstractDiagSelID SelID,
912 const CXXRecordDecl *CurrentRD) {
913
914 if (!getLangOptions().CPlusPlus)
915 return false;
916
917 if (const ArrayType *AT = Context.getAsArrayType(T))
918 return RequireNonAbstractType(Loc, AT->getElementType(), DiagID, SelID,
919 CurrentRD);
920
921 if (const PointerType *PT = T->getAsPointerType()) {
922 // Find the innermost pointer type.
923 while (const PointerType *T = PT->getPointeeType()->getAsPointerType())
924 PT = T;
925
926 if (const ArrayType *AT = Context.getAsArrayType(PT->getPointeeType()))
927 return RequireNonAbstractType(Loc, AT->getElementType(), DiagID, SelID,
928 CurrentRD);
929 }
930
931 const RecordType *RT = T->getAsRecordType();
932 if (!RT)
933 return false;
934
935 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl());
936 if (!RD)
937 return false;
938
939 if (CurrentRD && CurrentRD != RD)
940 return false;
941
942 if (!RD->isAbstract())
943 return false;
944
945 Diag(Loc, DiagID) << RD->getDeclName() << SelID;
946
947 // Check if we've already emitted the list of pure virtual functions for this
948 // class.
949 if (PureVirtualClassDiagSet && PureVirtualClassDiagSet->count(RD))
950 return true;
951
952 PureVirtualMethodCollector Collector(Context, RD);
953
954 for (PureVirtualMethodCollector::MethodList::const_iterator I =
955 Collector.methods_begin(), E = Collector.methods_end(); I != E; ++I) {
956 const CXXMethodDecl *MD = *I;
957
958 Diag(MD->getLocation(), diag::note_pure_virtual_function) <<
959 MD->getDeclName();
960 }
961
962 if (!PureVirtualClassDiagSet)
963 PureVirtualClassDiagSet.reset(new RecordDeclSetTy);
964 PureVirtualClassDiagSet->insert(RD);
965
966 return true;
967}
968
969namespace {
970 class VISIBILITY_HIDDEN AbstractClassUsageDiagnoser
971 : public DeclVisitor<AbstractClassUsageDiagnoser, bool> {
972 Sema &SemaRef;
973 CXXRecordDecl *AbstractClass;
974
975 bool VisitDeclContext(const DeclContext *DC) {
976 bool Invalid = false;
977
978 for (CXXRecordDecl::decl_iterator I = DC->decls_begin(),
979 E = DC->decls_end(); I != E; ++I)
980 Invalid |= Visit(*I);
981
982 return Invalid;
983 }
984
985 public:
986 AbstractClassUsageDiagnoser(Sema& SemaRef, CXXRecordDecl *ac)
987 : SemaRef(SemaRef), AbstractClass(ac) {
988 Visit(SemaRef.Context.getTranslationUnitDecl());
989 }
990
991 bool VisitFunctionDecl(const FunctionDecl *FD) {
992 if (FD->isThisDeclarationADefinition()) {
993 // No need to do the check if we're in a definition, because it requires
994 // that the return/param types are complete.
995 // because that requires
996 return VisitDeclContext(FD);
997 }
998
999 // Check the return type.
1000 QualType RTy = FD->getType()->getAsFunctionType()->getResultType();
1001 bool Invalid =
1002 SemaRef.RequireNonAbstractType(FD->getLocation(), RTy,
1003 diag::err_abstract_type_in_decl,
1004 Sema::AbstractReturnType,
1005 AbstractClass);
1006
1007 for (FunctionDecl::param_const_iterator I = FD->param_begin(),
1008 E = FD->param_end(); I != E; ++I) {
1009 const ParmVarDecl *VD = *I;
1010 Invalid |=
1011 SemaRef.RequireNonAbstractType(VD->getLocation(),
1012 VD->getOriginalType(),
1013 diag::err_abstract_type_in_decl,
1014 Sema::AbstractParamType,
1015 AbstractClass);
1016 }
1017
1018 return Invalid;
1019 }
1020
1021 bool VisitDecl(const Decl* D) {
1022 if (const DeclContext *DC = dyn_cast<DeclContext>(D))
1023 return VisitDeclContext(DC);
1024
1025 return false;
1026 }
1027 };
1028}
1029
1030void Sema::ActOnFinishCXXMemberSpecification(Scope* S, SourceLocation RLoc,
1031 DeclPtrTy TagDecl,
1032 SourceLocation LBrac,
1033 SourceLocation RBrac) {
1034 if (!TagDecl)
1035 return;
1036
1037 AdjustDeclIfTemplate(TagDecl);
1038 ActOnFields(S, RLoc, TagDecl,
1039 (DeclPtrTy*)FieldCollector->getCurFields(),
1040 FieldCollector->getCurNumFields(), LBrac, RBrac, 0);
1041
1042 CXXRecordDecl *RD = cast<CXXRecordDecl>(TagDecl.getAs<Decl>());
1043 if (!RD->isAbstract()) {
1044 // Collect all the pure virtual methods and see if this is an abstract
1045 // class after all.
1046 PureVirtualMethodCollector Collector(Context, RD);
1047 if (!Collector.empty())
1048 RD->setAbstract(true);
1049 }
1050
1051 if (RD->isAbstract())
1052 AbstractClassUsageDiagnoser(*this, RD);
1053
1054 if (RD->hasTrivialConstructor() || RD->hasTrivialDestructor()) {
1055 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
1056 i != e; ++i) {
1057 // All the nonstatic data members must have trivial constructors.
1058 QualType FTy = i->getType();
1059 while (const ArrayType *AT = Context.getAsArrayType(FTy))
1060 FTy = AT->getElementType();
1061
1062 if (const RecordType *RT = FTy->getAsRecordType()) {
1063 CXXRecordDecl *FieldRD = cast<CXXRecordDecl>(RT->getDecl());
1064
1065 if (!FieldRD->hasTrivialConstructor())
1066 RD->setHasTrivialConstructor(false);
1067 if (!FieldRD->hasTrivialDestructor())
1068 RD->setHasTrivialDestructor(false);
1069
1070 // If RD has neither a trivial constructor nor a trivial destructor
1071 // we don't need to continue checking.
1072 if (!RD->hasTrivialConstructor() && !RD->hasTrivialDestructor())
1073 break;
1074 }
1075 }
1076 }
1077
1078 if (!RD->isDependentType())
1079 AddImplicitlyDeclaredMembersToClass(RD);
1080}
1081
1082/// AddImplicitlyDeclaredMembersToClass - Adds any implicitly-declared
1083/// special functions, such as the default constructor, copy
1084/// constructor, or destructor, to the given C++ class (C++
1085/// [special]p1). This routine can only be executed just before the
1086/// definition of the class is complete.
1087void Sema::AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl) {
1088 QualType ClassType = Context.getTypeDeclType(ClassDecl);
1089 ClassType = Context.getCanonicalType(ClassType);
1090
1091 // FIXME: Implicit declarations have exception specifications, which are
1092 // the union of the specifications of the implicitly called functions.
1093
1094 if (!ClassDecl->hasUserDeclaredConstructor()) {
1095 // C++ [class.ctor]p5:
1096 // A default constructor for a class X is a constructor of class X
1097 // that can be called without an argument. If there is no
1098 // user-declared constructor for class X, a default constructor is
1099 // implicitly declared. An implicitly-declared default constructor
1100 // is an inline public member of its class.
1101 DeclarationName Name
1102 = Context.DeclarationNames.getCXXConstructorName(ClassType);
1103 CXXConstructorDecl *DefaultCon =
1104 CXXConstructorDecl::Create(Context, ClassDecl,
1105 ClassDecl->getLocation(), Name,
1106 Context.getFunctionType(Context.VoidTy,
1107 0, 0, false, 0),
1108 /*isExplicit=*/false,
1109 /*isInline=*/true,
1110 /*isImplicitlyDeclared=*/true);
1111 DefaultCon->setAccess(AS_public);
1112 DefaultCon->setImplicit();
1113 ClassDecl->addDecl(DefaultCon);
1114 }
1115
1116 if (!ClassDecl->hasUserDeclaredCopyConstructor()) {
1117 // C++ [class.copy]p4:
1118 // If the class definition does not explicitly declare a copy
1119 // constructor, one is declared implicitly.
1120
1121 // C++ [class.copy]p5:
1122 // The implicitly-declared copy constructor for a class X will
1123 // have the form
1124 //
1125 // X::X(const X&)
1126 //
1127 // if
1128 bool HasConstCopyConstructor = true;
1129
1130 // -- each direct or virtual base class B of X has a copy
1131 // constructor whose first parameter is of type const B& or
1132 // const volatile B&, and
1133 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin();
1134 HasConstCopyConstructor && Base != ClassDecl->bases_end(); ++Base) {
1135 const CXXRecordDecl *BaseClassDecl
1136 = cast<CXXRecordDecl>(Base->getType()->getAsRecordType()->getDecl());
1137 HasConstCopyConstructor
1138 = BaseClassDecl->hasConstCopyConstructor(Context);
1139 }
1140
1141 // -- for all the nonstatic data members of X that are of a
1142 // class type M (or array thereof), each such class type
1143 // has a copy constructor whose first parameter is of type
1144 // const M& or const volatile M&.
1145 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin();
1146 HasConstCopyConstructor && Field != ClassDecl->field_end();
1147 ++Field) {
1148 QualType FieldType = (*Field)->getType();
1149 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
1150 FieldType = Array->getElementType();
1151 if (const RecordType *FieldClassType = FieldType->getAsRecordType()) {
1152 const CXXRecordDecl *FieldClassDecl
1153 = cast<CXXRecordDecl>(FieldClassType->getDecl());
1154 HasConstCopyConstructor
1155 = FieldClassDecl->hasConstCopyConstructor(Context);
1156 }
1157 }
1158
1159 // Otherwise, the implicitly declared copy constructor will have
1160 // the form
1161 //
1162 // X::X(X&)
1163 QualType ArgType = ClassType;
1164 if (HasConstCopyConstructor)
1165 ArgType = ArgType.withConst();
1166 ArgType = Context.getLValueReferenceType(ArgType);
1167
1168 // An implicitly-declared copy constructor is an inline public
1169 // member of its class.
1170 DeclarationName Name
1171 = Context.DeclarationNames.getCXXConstructorName(ClassType);
1172 CXXConstructorDecl *CopyConstructor
1173 = CXXConstructorDecl::Create(Context, ClassDecl,
1174 ClassDecl->getLocation(), Name,
1175 Context.getFunctionType(Context.VoidTy,
1176 &ArgType, 1,
1177 false, 0),
1178 /*isExplicit=*/false,
1179 /*isInline=*/true,
1180 /*isImplicitlyDeclared=*/true);
1181 CopyConstructor->setAccess(AS_public);
1182 CopyConstructor->setImplicit();
1183
1184 // Add the parameter to the constructor.
1185 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyConstructor,
1186 ClassDecl->getLocation(),
1187 /*IdentifierInfo=*/0,
1188 ArgType, VarDecl::None, 0);
1189 CopyConstructor->setParams(Context, &FromParam, 1);
1190 ClassDecl->addDecl(CopyConstructor);
1191 }
1192
1193 if (!ClassDecl->hasUserDeclaredCopyAssignment()) {
1194 // Note: The following rules are largely analoguous to the copy
1195 // constructor rules. Note that virtual bases are not taken into account
1196 // for determining the argument type of the operator. Note also that
1197 // operators taking an object instead of a reference are allowed.
1198 //
1199 // C++ [class.copy]p10:
1200 // If the class definition does not explicitly declare a copy
1201 // assignment operator, one is declared implicitly.
1202 // The implicitly-defined copy assignment operator for a class X
1203 // will have the form
1204 //
1205 // X& X::operator=(const X&)
1206 //
1207 // if
1208 bool HasConstCopyAssignment = true;
1209
1210 // -- each direct base class B of X has a copy assignment operator
1211 // whose parameter is of type const B&, const volatile B& or B,
1212 // and
1213 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin();
1214 HasConstCopyAssignment && Base != ClassDecl->bases_end(); ++Base) {
1215 const CXXRecordDecl *BaseClassDecl
1216 = cast<CXXRecordDecl>(Base->getType()->getAsRecordType()->getDecl());
1217 HasConstCopyAssignment = BaseClassDecl->hasConstCopyAssignment(Context);
1218 }
1219
1220 // -- for all the nonstatic data members of X that are of a class
1221 // type M (or array thereof), each such class type has a copy
1222 // assignment operator whose parameter is of type const M&,
1223 // const volatile M& or M.
1224 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin();
1225 HasConstCopyAssignment && Field != ClassDecl->field_end();
1226 ++Field) {
1227 QualType FieldType = (*Field)->getType();
1228 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
1229 FieldType = Array->getElementType();
1230 if (const RecordType *FieldClassType = FieldType->getAsRecordType()) {
1231 const CXXRecordDecl *FieldClassDecl
1232 = cast<CXXRecordDecl>(FieldClassType->getDecl());
1233 HasConstCopyAssignment
1234 = FieldClassDecl->hasConstCopyAssignment(Context);
1235 }
1236 }
1237
1238 // Otherwise, the implicitly declared copy assignment operator will
1239 // have the form
1240 //
1241 // X& X::operator=(X&)
1242 QualType ArgType = ClassType;
1243 QualType RetType = Context.getLValueReferenceType(ArgType);
1244 if (HasConstCopyAssignment)
1245 ArgType = ArgType.withConst();
1246 ArgType = Context.getLValueReferenceType(ArgType);
1247
1248 // An implicitly-declared copy assignment operator is an inline public
1249 // member of its class.
1250 DeclarationName Name =
1251 Context.DeclarationNames.getCXXOperatorName(OO_Equal);
1252 CXXMethodDecl *CopyAssignment =
1253 CXXMethodDecl::Create(Context, ClassDecl, ClassDecl->getLocation(), Name,
1254 Context.getFunctionType(RetType, &ArgType, 1,
1255 false, 0),
1256 /*isStatic=*/false, /*isInline=*/true);
1257 CopyAssignment->setAccess(AS_public);
1258 CopyAssignment->setImplicit();
1259
1260 // Add the parameter to the operator.
1261 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyAssignment,
1262 ClassDecl->getLocation(),
1263 /*IdentifierInfo=*/0,
1264 ArgType, VarDecl::None, 0);
1265 CopyAssignment->setParams(Context, &FromParam, 1);
1266
1267 // Don't call addedAssignmentOperator. There is no way to distinguish an
1268 // implicit from an explicit assignment operator.
1269 ClassDecl->addDecl(CopyAssignment);
1270 }
1271
1272 if (!ClassDecl->hasUserDeclaredDestructor()) {
1273 // C++ [class.dtor]p2:
1274 // If a class has no user-declared destructor, a destructor is
1275 // declared implicitly. An implicitly-declared destructor is an
1276 // inline public member of its class.
1277 DeclarationName Name
1278 = Context.DeclarationNames.getCXXDestructorName(ClassType);
1279 CXXDestructorDecl *Destructor
1280 = CXXDestructorDecl::Create(Context, ClassDecl,
1281 ClassDecl->getLocation(), Name,
1282 Context.getFunctionType(Context.VoidTy,
1283 0, 0, false, 0),
1284 /*isInline=*/true,
1285 /*isImplicitlyDeclared=*/true);
1286 Destructor->setAccess(AS_public);
1287 Destructor->setImplicit();
1288 ClassDecl->addDecl(Destructor);
1289 }
1290}
1291
1292void Sema::ActOnReenterTemplateScope(Scope *S, DeclPtrTy TemplateD) {
1293 TemplateDecl *Template = TemplateD.getAs<TemplateDecl>();
1294 if (!Template)
1295 return;
1296
1297 TemplateParameterList *Params = Template->getTemplateParameters();
1298 for (TemplateParameterList::iterator Param = Params->begin(),
1299 ParamEnd = Params->end();
1300 Param != ParamEnd; ++Param) {
1301 NamedDecl *Named = cast<NamedDecl>(*Param);
1302 if (Named->getDeclName()) {
1303 S->AddDecl(DeclPtrTy::make(Named));
1304 IdResolver.AddDecl(Named);
1305 }
1306 }
1307}
1308
1309/// ActOnStartDelayedCXXMethodDeclaration - We have completed
1310/// parsing a top-level (non-nested) C++ class, and we are now
1311/// parsing those parts of the given Method declaration that could
1312/// not be parsed earlier (C++ [class.mem]p2), such as default
1313/// arguments. This action should enter the scope of the given
1314/// Method declaration as if we had just parsed the qualified method
1315/// name. However, it should not bring the parameters into scope;
1316/// that will be performed by ActOnDelayedCXXMethodParameter.
1317void Sema::ActOnStartDelayedCXXMethodDeclaration(Scope *S, DeclPtrTy MethodD) {
1318 if (!MethodD)
1319 return;
1320
1321 CXXScopeSpec SS;
1322 FunctionDecl *Method = cast<FunctionDecl>(MethodD.getAs<Decl>());
1323 QualType ClassTy
1324 = Context.getTypeDeclType(cast<RecordDecl>(Method->getDeclContext()));
1325 SS.setScopeRep(
1326 NestedNameSpecifier::Create(Context, 0, false, ClassTy.getTypePtr()));
1327 ActOnCXXEnterDeclaratorScope(S, SS);
1328}
1329
1330/// ActOnDelayedCXXMethodParameter - We've already started a delayed
1331/// C++ method declaration. We're (re-)introducing the given
1332/// function parameter into scope for use in parsing later parts of
1333/// the method declaration. For example, we could see an
1334/// ActOnParamDefaultArgument event for this parameter.
1335void Sema::ActOnDelayedCXXMethodParameter(Scope *S, DeclPtrTy ParamD) {
1336 if (!ParamD)
1337 return;
1338
1339 ParmVarDecl *Param = cast<ParmVarDecl>(ParamD.getAs<Decl>());
1340
1341 // If this parameter has an unparsed default argument, clear it out
1342 // to make way for the parsed default argument.
1343 if (Param->hasUnparsedDefaultArg())
1344 Param->setDefaultArg(0);
1345
1346 S->AddDecl(DeclPtrTy::make(Param));
1347 if (Param->getDeclName())
1348 IdResolver.AddDecl(Param);
1349}
1350
1351/// ActOnFinishDelayedCXXMethodDeclaration - We have finished
1352/// processing the delayed method declaration for Method. The method
1353/// declaration is now considered finished. There may be a separate
1354/// ActOnStartOfFunctionDef action later (not necessarily
1355/// immediately!) for this method, if it was also defined inside the
1356/// class body.
1357void Sema::ActOnFinishDelayedCXXMethodDeclaration(Scope *S, DeclPtrTy MethodD) {
1358 if (!MethodD)
1359 return;
1360
1361 FunctionDecl *Method = cast<FunctionDecl>(MethodD.getAs<Decl>());
1362 CXXScopeSpec SS;
1363 QualType ClassTy
1364 = Context.getTypeDeclType(cast<RecordDecl>(Method->getDeclContext()));
1365 SS.setScopeRep(
1366 NestedNameSpecifier::Create(Context, 0, false, ClassTy.getTypePtr()));
1367 ActOnCXXExitDeclaratorScope(S, SS);
1368
1369 // Now that we have our default arguments, check the constructor
1370 // again. It could produce additional diagnostics or affect whether
1371 // the class has implicitly-declared destructors, among other
1372 // things.
1373 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Method))
1374 CheckConstructor(Constructor);
1375
1376 // Check the default arguments, which we may have added.
1377 if (!Method->isInvalidDecl())
1378 CheckCXXDefaultArguments(Method);
1379}
1380
1381/// CheckConstructorDeclarator - Called by ActOnDeclarator to check
1382/// the well-formedness of the constructor declarator @p D with type @p
1383/// R. If there are any errors in the declarator, this routine will
1384/// emit diagnostics and set the invalid bit to true. In any case, the type
1385/// will be updated to reflect a well-formed type for the constructor and
1386/// returned.
1387QualType Sema::CheckConstructorDeclarator(Declarator &D, QualType R,
1388 FunctionDecl::StorageClass &SC) {
1389 bool isVirtual = D.getDeclSpec().isVirtualSpecified();
1390
1391 // C++ [class.ctor]p3:
1392 // A constructor shall not be virtual (10.3) or static (9.4). A
1393 // constructor can be invoked for a const, volatile or const
1394 // volatile object. A constructor shall not be declared const,
1395 // volatile, or const volatile (9.3.2).
1396 if (isVirtual) {
1397 if (!D.isInvalidType())
1398 Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
1399 << "virtual" << SourceRange(D.getDeclSpec().getVirtualSpecLoc())
1400 << SourceRange(D.getIdentifierLoc());
1401 D.setInvalidType();
1402 }
1403 if (SC == FunctionDecl::Static) {
1404 if (!D.isInvalidType())
1405 Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
1406 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
1407 << SourceRange(D.getIdentifierLoc());
1408 D.setInvalidType();
1409 SC = FunctionDecl::None;
1410 }
1411
1412 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
1413 if (FTI.TypeQuals != 0) {
1414 if (FTI.TypeQuals & QualType::Const)
1415 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
1416 << "const" << SourceRange(D.getIdentifierLoc());
1417 if (FTI.TypeQuals & QualType::Volatile)
1418 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
1419 << "volatile" << SourceRange(D.getIdentifierLoc());
1420 if (FTI.TypeQuals & QualType::Restrict)
1421 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
1422 << "restrict" << SourceRange(D.getIdentifierLoc());
1423 }
1424
1425 // Rebuild the function type "R" without any type qualifiers (in
1426 // case any of the errors above fired) and with "void" as the
1427 // return type, since constructors don't have return types. We
1428 // *always* have to do this, because GetTypeForDeclarator will
1429 // put in a result type of "int" when none was specified.
1430 const FunctionProtoType *Proto = R->getAsFunctionProtoType();
1431 return Context.getFunctionType(Context.VoidTy, Proto->arg_type_begin(),
1432 Proto->getNumArgs(),
1433 Proto->isVariadic(), 0);
1434}
1435
1436/// CheckConstructor - Checks a fully-formed constructor for
1437/// well-formedness, issuing any diagnostics required. Returns true if
1438/// the constructor declarator is invalid.
1439void Sema::CheckConstructor(CXXConstructorDecl *Constructor) {
1440 CXXRecordDecl *ClassDecl
1441 = dyn_cast<CXXRecordDecl>(Constructor->getDeclContext());
1442 if (!ClassDecl)
1443 return Constructor->setInvalidDecl();
1444
1445 // C++ [class.copy]p3:
1446 // A declaration of a constructor for a class X is ill-formed if
1447 // its first parameter is of type (optionally cv-qualified) X and
1448 // either there are no other parameters or else all other
1449 // parameters have default arguments.
1450 if (!Constructor->isInvalidDecl() &&
1451 ((Constructor->getNumParams() == 1) ||
1452 (Constructor->getNumParams() > 1 &&
1453 Constructor->getParamDecl(1)->hasDefaultArg()))) {
1454 QualType ParamType = Constructor->getParamDecl(0)->getType();
1455 QualType ClassTy = Context.getTagDeclType(ClassDecl);
1456 if (Context.getCanonicalType(ParamType).getUnqualifiedType() == ClassTy) {
1457 SourceLocation ParamLoc = Constructor->getParamDecl(0)->getLocation();
1458 Diag(ParamLoc, diag::err_constructor_byvalue_arg)
1459 << CodeModificationHint::CreateInsertion(ParamLoc, " const &");
1460 Constructor->setInvalidDecl();
1461 }
1462 }
1463
1464 // Notify the class that we've added a constructor.
1465 ClassDecl->addedConstructor(Context, Constructor);
1466}
1467
1468static inline bool
1469FTIHasSingleVoidArgument(DeclaratorChunk::FunctionTypeInfo &FTI) {
1470 return (FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 &&
1471 FTI.ArgInfo[0].Param &&
1472 FTI.ArgInfo[0].Param.getAs<ParmVarDecl>()->getType()->isVoidType());
1473}
1474
1475/// CheckDestructorDeclarator - Called by ActOnDeclarator to check
1476/// the well-formednes of the destructor declarator @p D with type @p
1477/// R. If there are any errors in the declarator, this routine will
1478/// emit diagnostics and set the declarator to invalid. Even if this happens,
1479/// will be updated to reflect a well-formed type for the destructor and
1480/// returned.
1481QualType Sema::CheckDestructorDeclarator(Declarator &D,
1482 FunctionDecl::StorageClass& SC) {
1483 // C++ [class.dtor]p1:
1484 // [...] A typedef-name that names a class is a class-name
1485 // (7.1.3); however, a typedef-name that names a class shall not
1486 // be used as the identifier in the declarator for a destructor
1487 // declaration.
1488 QualType DeclaratorType = QualType::getFromOpaquePtr(D.getDeclaratorIdType());
1489 if (isa<TypedefType>(DeclaratorType)) {
1490 Diag(D.getIdentifierLoc(), diag::err_destructor_typedef_name)
1491 << DeclaratorType;
1492 D.setInvalidType();
1493 }
1494
1495 // C++ [class.dtor]p2:
1496 // A destructor is used to destroy objects of its class type. A
1497 // destructor takes no parameters, and no return type can be
1498 // specified for it (not even void). The address of a destructor
1499 // shall not be taken. A destructor shall not be static. A
1500 // destructor can be invoked for a const, volatile or const
1501 // volatile object. A destructor shall not be declared const,
1502 // volatile or const volatile (9.3.2).
1503 if (SC == FunctionDecl::Static) {
1504 if (!D.isInvalidType())
1505 Diag(D.getIdentifierLoc(), diag::err_destructor_cannot_be)
1506 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
1507 << SourceRange(D.getIdentifierLoc());
1508 SC = FunctionDecl::None;
1509 D.setInvalidType();
1510 }
1511 if (D.getDeclSpec().hasTypeSpecifier() && !D.isInvalidType()) {
1512 // Destructors don't have return types, but the parser will
1513 // happily parse something like:
1514 //
1515 // class X {
1516 // float ~X();
1517 // };
1518 //
1519 // The return type will be eliminated later.
1520 Diag(D.getIdentifierLoc(), diag::err_destructor_return_type)
1521 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
1522 << SourceRange(D.getIdentifierLoc());
1523 }
1524
1525 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
1526 if (FTI.TypeQuals != 0 && !D.isInvalidType()) {
1527 if (FTI.TypeQuals & QualType::Const)
1528 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
1529 << "const" << SourceRange(D.getIdentifierLoc());
1530 if (FTI.TypeQuals & QualType::Volatile)
1531 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
1532 << "volatile" << SourceRange(D.getIdentifierLoc());
1533 if (FTI.TypeQuals & QualType::Restrict)
1534 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
1535 << "restrict" << SourceRange(D.getIdentifierLoc());
1536 D.setInvalidType();
1537 }
1538
1539 // Make sure we don't have any parameters.
1540 if (FTI.NumArgs > 0 && !FTIHasSingleVoidArgument(FTI)) {
1541 Diag(D.getIdentifierLoc(), diag::err_destructor_with_params);
1542
1543 // Delete the parameters.
1544 FTI.freeArgs();
1545 D.setInvalidType();
1546 }
1547
1548 // Make sure the destructor isn't variadic.
1549 if (FTI.isVariadic) {
1550 Diag(D.getIdentifierLoc(), diag::err_destructor_variadic);
1551 D.setInvalidType();
1552 }
1553
1554 // Rebuild the function type "R" without any type qualifiers or
1555 // parameters (in case any of the errors above fired) and with
1556 // "void" as the return type, since destructors don't have return
1557 // types. We *always* have to do this, because GetTypeForDeclarator
1558 // will put in a result type of "int" when none was specified.
1559 return Context.getFunctionType(Context.VoidTy, 0, 0, false, 0);
1560}
1561
1562/// CheckConversionDeclarator - Called by ActOnDeclarator to check the
1563/// well-formednes of the conversion function declarator @p D with
1564/// type @p R. If there are any errors in the declarator, this routine
1565/// will emit diagnostics and return true. Otherwise, it will return
1566/// false. Either way, the type @p R will be updated to reflect a
1567/// well-formed type for the conversion operator.
1568void Sema::CheckConversionDeclarator(Declarator &D, QualType &R,
1569 FunctionDecl::StorageClass& SC) {
1570 // C++ [class.conv.fct]p1:
1571 // Neither parameter types nor return type can be specified. The
1572 // type of a conversion function (8.3.5) is ���function taking no
1573 // parameter returning conversion-type-id.���
1574 if (SC == FunctionDecl::Static) {
1575 if (!D.isInvalidType())
1576 Diag(D.getIdentifierLoc(), diag::err_conv_function_not_member)
1577 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
1578 << SourceRange(D.getIdentifierLoc());
1579 D.setInvalidType();
1580 SC = FunctionDecl::None;
1581 }
1582 if (D.getDeclSpec().hasTypeSpecifier() && !D.isInvalidType()) {
1583 // Conversion functions don't have return types, but the parser will
1584 // happily parse something like:
1585 //
1586 // class X {
1587 // float operator bool();
1588 // };
1589 //
1590 // The return type will be changed later anyway.
1591 Diag(D.getIdentifierLoc(), diag::err_conv_function_return_type)
1592 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
1593 << SourceRange(D.getIdentifierLoc());
1594 }
1595
1596 // Make sure we don't have any parameters.
1597 if (R->getAsFunctionProtoType()->getNumArgs() > 0) {
1598 Diag(D.getIdentifierLoc(), diag::err_conv_function_with_params);
1599
1600 // Delete the parameters.
1601 D.getTypeObject(0).Fun.freeArgs();
1602 D.setInvalidType();
1603 }
1604
1605 // Make sure the conversion function isn't variadic.
1606 if (R->getAsFunctionProtoType()->isVariadic() && !D.isInvalidType()) {
1607 Diag(D.getIdentifierLoc(), diag::err_conv_function_variadic);
1608 D.setInvalidType();
1609 }
1610
1611 // C++ [class.conv.fct]p4:
1612 // The conversion-type-id shall not represent a function type nor
1613 // an array type.
1614 QualType ConvType = QualType::getFromOpaquePtr(D.getDeclaratorIdType());
1615 if (ConvType->isArrayType()) {
1616 Diag(D.getIdentifierLoc(), diag::err_conv_function_to_array);
1617 ConvType = Context.getPointerType(ConvType);
1618 D.setInvalidType();
1619 } else if (ConvType->isFunctionType()) {
1620 Diag(D.getIdentifierLoc(), diag::err_conv_function_to_function);
1621 ConvType = Context.getPointerType(ConvType);
1622 D.setInvalidType();
1623 }
1624
1625 // Rebuild the function type "R" without any parameters (in case any
1626 // of the errors above fired) and with the conversion type as the
1627 // return type.
1628 R = Context.getFunctionType(ConvType, 0, 0, false,
1629 R->getAsFunctionProtoType()->getTypeQuals());
1630
1631 // C++0x explicit conversion operators.
1632 if (D.getDeclSpec().isExplicitSpecified() && !getLangOptions().CPlusPlus0x)
1633 Diag(D.getDeclSpec().getExplicitSpecLoc(),
1634 diag::warn_explicit_conversion_functions)
1635 << SourceRange(D.getDeclSpec().getExplicitSpecLoc());
1636}
1637
1638/// ActOnConversionDeclarator - Called by ActOnDeclarator to complete
1639/// the declaration of the given C++ conversion function. This routine
1640/// is responsible for recording the conversion function in the C++
1641/// class, if possible.
1642Sema::DeclPtrTy Sema::ActOnConversionDeclarator(CXXConversionDecl *Conversion) {
1643 assert(Conversion && "Expected to receive a conversion function declaration");
1644
1645 // Set the lexical context of this conversion function
1646 Conversion->setLexicalDeclContext(CurContext);
1647
1648 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Conversion->getDeclContext());
1649
1650 // Make sure we aren't redeclaring the conversion function.
1651 QualType ConvType = Context.getCanonicalType(Conversion->getConversionType());
1652
1653 // C++ [class.conv.fct]p1:
1654 // [...] A conversion function is never used to convert a
1655 // (possibly cv-qualified) object to the (possibly cv-qualified)
1656 // same object type (or a reference to it), to a (possibly
1657 // cv-qualified) base class of that type (or a reference to it),
1658 // or to (possibly cv-qualified) void.
1659 // FIXME: Suppress this warning if the conversion function ends up being a
1660 // virtual function that overrides a virtual function in a base class.
1661 QualType ClassType
1662 = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
1663 if (const ReferenceType *ConvTypeRef = ConvType->getAsReferenceType())
1664 ConvType = ConvTypeRef->getPointeeType();
1665 if (ConvType->isRecordType()) {
1666 ConvType = Context.getCanonicalType(ConvType).getUnqualifiedType();
1667 if (ConvType == ClassType)
1668 Diag(Conversion->getLocation(), diag::warn_conv_to_self_not_used)
1669 << ClassType;
1670 else if (IsDerivedFrom(ClassType, ConvType))
1671 Diag(Conversion->getLocation(), diag::warn_conv_to_base_not_used)
1672 << ClassType << ConvType;
1673 } else if (ConvType->isVoidType()) {
1674 Diag(Conversion->getLocation(), diag::warn_conv_to_void_not_used)
1675 << ClassType << ConvType;
1676 }
1677
1678 if (Conversion->getPreviousDeclaration()) {
1679 OverloadedFunctionDecl *Conversions = ClassDecl->getConversionFunctions();
1680 for (OverloadedFunctionDecl::function_iterator
1681 Conv = Conversions->function_begin(),
1682 ConvEnd = Conversions->function_end();
1683 Conv != ConvEnd; ++Conv) {
1684 if (*Conv
1685 == cast_or_null<NamedDecl>(Conversion->getPreviousDeclaration())) {
1686 *Conv = Conversion;
1687 return DeclPtrTy::make(Conversion);
1688 }
1689 }
1690 assert(Conversion->isInvalidDecl() && "Conversion should not get here.");
1691 } else
1692 ClassDecl->addConversionFunction(Context, Conversion);
1693
1694 return DeclPtrTy::make(Conversion);
1695}
1696
1697//===----------------------------------------------------------------------===//
1698// Namespace Handling
1699//===----------------------------------------------------------------------===//
1700
1701/// ActOnStartNamespaceDef - This is called at the start of a namespace
1702/// definition.
1703Sema::DeclPtrTy Sema::ActOnStartNamespaceDef(Scope *NamespcScope,
1704 SourceLocation IdentLoc,
1705 IdentifierInfo *II,
1706 SourceLocation LBrace) {
1707 NamespaceDecl *Namespc =
1708 NamespaceDecl::Create(Context, CurContext, IdentLoc, II);
1709 Namespc->setLBracLoc(LBrace);
1710
1711 Scope *DeclRegionScope = NamespcScope->getParent();
1712
1713 if (II) {
1714 // C++ [namespace.def]p2:
1715 // The identifier in an original-namespace-definition shall not have been
1716 // previously defined in the declarative region in which the
1717 // original-namespace-definition appears. The identifier in an
1718 // original-namespace-definition is the name of the namespace. Subsequently
1719 // in that declarative region, it is treated as an original-namespace-name.
1720
1721 NamedDecl *PrevDecl = LookupName(DeclRegionScope, II, LookupOrdinaryName,
1722 true);
1723
1724 if (NamespaceDecl *OrigNS = dyn_cast_or_null<NamespaceDecl>(PrevDecl)) {
1725 // This is an extended namespace definition.
1726 // Attach this namespace decl to the chain of extended namespace
1727 // definitions.
1728 OrigNS->setNextNamespace(Namespc);
1729 Namespc->setOriginalNamespace(OrigNS->getOriginalNamespace());
1730
1731 // Remove the previous declaration from the scope.
1732 if (DeclRegionScope->isDeclScope(DeclPtrTy::make(OrigNS))) {
1733 IdResolver.RemoveDecl(OrigNS);
1734 DeclRegionScope->RemoveDecl(DeclPtrTy::make(OrigNS));
1735 }
1736 } else if (PrevDecl) {
1737 // This is an invalid name redefinition.
1738 Diag(Namespc->getLocation(), diag::err_redefinition_different_kind)
1739 << Namespc->getDeclName();
1740 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
1741 Namespc->setInvalidDecl();
1742 // Continue on to push Namespc as current DeclContext and return it.
1743 }
1744
1745 PushOnScopeChains(Namespc, DeclRegionScope);
1746 } else {
1747 // FIXME: Handle anonymous namespaces
1748 }
1749
1750 // Although we could have an invalid decl (i.e. the namespace name is a
1751 // redefinition), push it as current DeclContext and try to continue parsing.
1752 // FIXME: We should be able to push Namespc here, so that the each DeclContext
1753 // for the namespace has the declarations that showed up in that particular
1754 // namespace definition.
1755 PushDeclContext(NamespcScope, Namespc);
1756 return DeclPtrTy::make(Namespc);
1757}
1758
1759/// ActOnFinishNamespaceDef - This callback is called after a namespace is
1760/// exited. Decl is the DeclTy returned by ActOnStartNamespaceDef.
1761void Sema::ActOnFinishNamespaceDef(DeclPtrTy D, SourceLocation RBrace) {
1762 Decl *Dcl = D.getAs<Decl>();
1763 NamespaceDecl *Namespc = dyn_cast_or_null<NamespaceDecl>(Dcl);
1764 assert(Namespc && "Invalid parameter, expected NamespaceDecl");
1765 Namespc->setRBracLoc(RBrace);
1766 PopDeclContext();
1767}
1768
1769Sema::DeclPtrTy Sema::ActOnUsingDirective(Scope *S,
1770 SourceLocation UsingLoc,
1771 SourceLocation NamespcLoc,
1772 const CXXScopeSpec &SS,
1773 SourceLocation IdentLoc,
1774 IdentifierInfo *NamespcName,
1775 AttributeList *AttrList) {
1776 assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
1777 assert(NamespcName && "Invalid NamespcName.");
1778 assert(IdentLoc.isValid() && "Invalid NamespceName location.");
1779 assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
1780
1781 UsingDirectiveDecl *UDir = 0;
1782
1783 // Lookup namespace name.
1784 LookupResult R = LookupParsedName(S, &SS, NamespcName,
1785 LookupNamespaceName, false);
1786 if (R.isAmbiguous()) {
1787 DiagnoseAmbiguousLookup(R, NamespcName, IdentLoc);
1788 return DeclPtrTy();
1789 }
1790 if (NamedDecl *NS = R) {
1791 assert(isa<NamespaceDecl>(NS) && "expected namespace decl");
1792 // C++ [namespace.udir]p1:
1793 // A using-directive specifies that the names in the nominated
1794 // namespace can be used in the scope in which the
1795 // using-directive appears after the using-directive. During
1796 // unqualified name lookup (3.4.1), the names appear as if they
1797 // were declared in the nearest enclosing namespace which
1798 // contains both the using-directive and the nominated
1799 // namespace. [Note: in this context, ���contains��� means ���contains
1800 // directly or indirectly���. ]
1801
1802 // Find enclosing context containing both using-directive and
1803 // nominated namespace.
1804 DeclContext *CommonAncestor = cast<DeclContext>(NS);
1805 while (CommonAncestor && !CommonAncestor->Encloses(CurContext))
1806 CommonAncestor = CommonAncestor->getParent();
1807
1808 UDir = UsingDirectiveDecl::Create(Context,
1809 CurContext, UsingLoc,
1810 NamespcLoc,
1811 SS.getRange(),
1812 (NestedNameSpecifier *)SS.getScopeRep(),
1813 IdentLoc,
1814 cast<NamespaceDecl>(NS),
1815 CommonAncestor);
1816 PushUsingDirective(S, UDir);
1817 } else {
1818 Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
1819 }
1820
1821 // FIXME: We ignore attributes for now.
1822 delete AttrList;
1823 return DeclPtrTy::make(UDir);
1824}
1825
1826void Sema::PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir) {
1827 // If scope has associated entity, then using directive is at namespace
1828 // or translation unit scope. We add UsingDirectiveDecls, into
1829 // it's lookup structure.
1830 if (DeclContext *Ctx = static_cast<DeclContext*>(S->getEntity()))
1831 Ctx->addDecl(UDir);
1832 else
1833 // Otherwise it is block-sope. using-directives will affect lookup
1834 // only to the end of scope.
1835 S->PushUsingDirective(DeclPtrTy::make(UDir));
1836}
1837
1838
1839Sema::DeclPtrTy Sema::ActOnUsingDeclaration(Scope *S,
1840 SourceLocation UsingLoc,
1841 const CXXScopeSpec &SS,
1842 SourceLocation IdentLoc,
1843 IdentifierInfo *TargetName,
1844 OverloadedOperatorKind Op,
1845 AttributeList *AttrList,
1846 bool IsTypeName) {
1847 assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
1848 assert((TargetName || Op) && "Invalid TargetName.");
1849 assert(IdentLoc.isValid() && "Invalid TargetName location.");
1850 assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
1851
1852 UsingDecl *UsingAlias = 0;
1853
1854 DeclarationName Name;
1855 if (TargetName)
1856 Name = TargetName;
1857 else
1858 Name = Context.DeclarationNames.getCXXOperatorName(Op);
1859
1860 // Lookup target name.
1861 LookupResult R = LookupParsedName(S, &SS, Name, LookupOrdinaryName, false);
1862
1863 if (NamedDecl *NS = R) {
1864 if (IsTypeName && !isa<TypeDecl>(NS)) {
1865 Diag(IdentLoc, diag::err_using_typename_non_type);
1866 }
1867 UsingAlias = UsingDecl::Create(Context, CurContext, IdentLoc, SS.getRange(),
1868 NS->getLocation(), UsingLoc, NS,
1869 static_cast<NestedNameSpecifier *>(SS.getScopeRep()),
1870 IsTypeName);
1871 PushOnScopeChains(UsingAlias, S);
1872 } else {
1873 Diag(IdentLoc, diag::err_using_requires_qualname) << SS.getRange();
1874 }
1875
1876 // FIXME: We ignore attributes for now.
1877 delete AttrList;
1878 return DeclPtrTy::make(UsingAlias);
1879}
1880
1881/// getNamespaceDecl - Returns the namespace a decl represents. If the decl
1882/// is a namespace alias, returns the namespace it points to.
1883static inline NamespaceDecl *getNamespaceDecl(NamedDecl *D) {
1884 if (NamespaceAliasDecl *AD = dyn_cast_or_null<NamespaceAliasDecl>(D))
1885 return AD->getNamespace();
1886 return dyn_cast_or_null<NamespaceDecl>(D);
1887}
1888
1889Sema::DeclPtrTy Sema::ActOnNamespaceAliasDef(Scope *S,
1890 SourceLocation NamespaceLoc,
1891 SourceLocation AliasLoc,
1892 IdentifierInfo *Alias,
1893 const CXXScopeSpec &SS,
1894 SourceLocation IdentLoc,
1895 IdentifierInfo *Ident) {
1896
1897 // Lookup the namespace name.
1898 LookupResult R = LookupParsedName(S, &SS, Ident, LookupNamespaceName, false);
1899
1900 // Check if we have a previous declaration with the same name.
1901 if (NamedDecl *PrevDecl = LookupName(S, Alias, LookupOrdinaryName, true)) {
1902 if (NamespaceAliasDecl *AD = dyn_cast<NamespaceAliasDecl>(PrevDecl)) {
1903 // We already have an alias with the same name that points to the same
1904 // namespace, so don't create a new one.
1905 if (!R.isAmbiguous() && AD->getNamespace() == getNamespaceDecl(R))
1906 return DeclPtrTy();
1907 }
1908
1909 unsigned DiagID = isa<NamespaceDecl>(PrevDecl) ? diag::err_redefinition :
1910 diag::err_redefinition_different_kind;
1911 Diag(AliasLoc, DiagID) << Alias;
1912 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
1913 return DeclPtrTy();
1914 }
1915
1916 if (R.isAmbiguous()) {
1917 DiagnoseAmbiguousLookup(R, Ident, IdentLoc);
1918 return DeclPtrTy();
1919 }
1920
1921 if (!R) {
1922 Diag(NamespaceLoc, diag::err_expected_namespace_name) << SS.getRange();
1923 return DeclPtrTy();
1924 }
1925
1926 NamespaceAliasDecl *AliasDecl =
1927 NamespaceAliasDecl::Create(Context, CurContext, NamespaceLoc, AliasLoc,
1928 Alias, SS.getRange(),
1929 (NestedNameSpecifier *)SS.getScopeRep(),
1930 IdentLoc, R);
1931
1932 CurContext->addDecl(AliasDecl);
1933 return DeclPtrTy::make(AliasDecl);
1934}
1935
1936void Sema::DefineImplicitDefaultConstructor(SourceLocation CurrentLocation,
1937 CXXConstructorDecl *Constructor) {
1938 assert((Constructor->isImplicit() && Constructor->isDefaultConstructor() &&
1939 !Constructor->isUsed()) &&
1940 "DefineImplicitDefaultConstructor - call it for implicit default ctor");
1941
1942 CXXRecordDecl *ClassDecl
1943 = cast<CXXRecordDecl>(Constructor->getDeclContext());
1944 assert(ClassDecl && "DefineImplicitDefaultConstructor - invalid constructor");
1945 // Before the implicitly-declared default constructor for a class is
1946 // implicitly defined, all the implicitly-declared default constructors
1947 // for its base class and its non-static data members shall have been
1948 // implicitly defined.
1949 bool err = false;
1950 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
1951 E = ClassDecl->bases_end(); Base != E; ++Base) {
1952 CXXRecordDecl *BaseClassDecl
1953 = cast<CXXRecordDecl>(Base->getType()->getAsRecordType()->getDecl());
1954 if (!BaseClassDecl->hasTrivialConstructor()) {
1955 if (CXXConstructorDecl *BaseCtor =
1956 BaseClassDecl->getDefaultConstructor(Context))
1957 MarkDeclarationReferenced(CurrentLocation, BaseCtor);
1958 else {
1959 Diag(CurrentLocation, diag::err_defining_default_ctor)
1960 << Context.getTagDeclType(ClassDecl) << 1
1961 << Context.getTagDeclType(BaseClassDecl);
1962 Diag(BaseClassDecl->getLocation(), diag::note_previous_class_decl)
1963 << Context.getTagDeclType(BaseClassDecl);
1964 err = true;
1965 }
1966 }
1967 }
1968 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
1969 E = ClassDecl->field_end(); Field != E; ++Field) {
1970 QualType FieldType = Context.getCanonicalType((*Field)->getType());
1971 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
1972 FieldType = Array->getElementType();
1973 if (const RecordType *FieldClassType = FieldType->getAsRecordType()) {
1974 CXXRecordDecl *FieldClassDecl
1975 = cast<CXXRecordDecl>(FieldClassType->getDecl());
1976 if (!FieldClassDecl->hasTrivialConstructor()) {
1977 if (CXXConstructorDecl *FieldCtor =
1978 FieldClassDecl->getDefaultConstructor(Context))
1979 MarkDeclarationReferenced(CurrentLocation, FieldCtor);
1980 else {
1981 Diag(CurrentLocation, diag::err_defining_default_ctor)
1982 << Context.getTagDeclType(ClassDecl) << 0 <<
1983 Context.getTagDeclType(FieldClassDecl);
1984 Diag(FieldClassDecl->getLocation(), diag::note_previous_class_decl)
1985 << Context.getTagDeclType(FieldClassDecl);
1986 err = true;
1987 }
1988 }
1989 }
1990 else if (FieldType->isReferenceType()) {
1991 Diag(CurrentLocation, diag::err_unintialized_member)
1992 << Context.getTagDeclType(ClassDecl) << 0 << (*Field)->getNameAsCString();
1993 Diag((*Field)->getLocation(), diag::note_declared_at);
1994 err = true;
1995 }
1996 else if (FieldType.isConstQualified()) {
1997 Diag(CurrentLocation, diag::err_unintialized_member)
1998 << Context.getTagDeclType(ClassDecl) << 1 << (*Field)->getNameAsCString();
1999 Diag((*Field)->getLocation(), diag::note_declared_at);
2000 err = true;
2001 }
2002 }
2003 if (!err)
2004 Constructor->setUsed();
2005 else
2006 Constructor->setInvalidDecl();
2007}
2008
2009void Sema::DefineImplicitDestructor(SourceLocation CurrentLocation,
2010 CXXDestructorDecl *Destructor) {
2011 assert((Destructor->isImplicit() && !Destructor->isUsed()) &&
2012 "DefineImplicitDestructor - call it for implicit default dtor");
2013
2014 CXXRecordDecl *ClassDecl
2015 = cast<CXXRecordDecl>(Destructor->getDeclContext());
2016 assert(ClassDecl && "DefineImplicitDestructor - invalid destructor");
2017 // C++ [class.dtor] p5
2018 // Before the implicitly-declared default destructor for a class is
2019 // implicitly defined, all the implicitly-declared default destructors
2020 // for its base class and its non-static data members shall have been
2021 // implicitly defined.
2022 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
2023 E = ClassDecl->bases_end(); Base != E; ++Base) {
2024 CXXRecordDecl *BaseClassDecl
2025 = cast<CXXRecordDecl>(Base->getType()->getAsRecordType()->getDecl());
2026 if (!BaseClassDecl->hasTrivialDestructor()) {
2027 if (CXXDestructorDecl *BaseDtor =
2028 const_cast<CXXDestructorDecl*>(BaseClassDecl->getDestructor(Context)))
2029 MarkDeclarationReferenced(CurrentLocation, BaseDtor);
2030 else
2031 assert(false &&
2032 "DefineImplicitDestructor - missing dtor in a base class");
2033 }
2034 }
2035
2036 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
2037 E = ClassDecl->field_end(); Field != E; ++Field) {
2038 QualType FieldType = Context.getCanonicalType((*Field)->getType());
2039 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
2040 FieldType = Array->getElementType();
2041 if (const RecordType *FieldClassType = FieldType->getAsRecordType()) {
2042 CXXRecordDecl *FieldClassDecl
2043 = cast<CXXRecordDecl>(FieldClassType->getDecl());
2044 if (!FieldClassDecl->hasTrivialDestructor()) {
2045 if (CXXDestructorDecl *FieldDtor =
2046 const_cast<CXXDestructorDecl*>(
2047 FieldClassDecl->getDestructor(Context)))
2048 MarkDeclarationReferenced(CurrentLocation, FieldDtor);
2049 else
2050 assert(false &&
2051 "DefineImplicitDestructor - missing dtor in class of a data member");
2052 }
2053 }
2054 }
2055 Destructor->setUsed();
2056}
2057
2058void Sema::DefineImplicitOverloadedAssign(SourceLocation CurrentLocation,
2059 CXXMethodDecl *MethodDecl) {
2060 assert((MethodDecl->isImplicit() && MethodDecl->isOverloadedOperator() &&
2061 MethodDecl->getOverloadedOperator() == OO_Equal &&
2062 !MethodDecl->isUsed()) &&
2063 "DefineImplicitOverloadedAssign - call it for implicit assignment op");
2064
2065 CXXRecordDecl *ClassDecl
2066 = cast<CXXRecordDecl>(MethodDecl->getDeclContext());
2067
2068 // C++[class.copy] p12
2069 // Before the implicitly-declared copy assignment operator for a class is
2070 // implicitly defined, all implicitly-declared copy assignment operators
2071 // for its direct base classes and its nonstatic data members shall have
2072 // been implicitly defined.
2073 bool err = false;
2074 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
2075 E = ClassDecl->bases_end(); Base != E; ++Base) {
2076 CXXRecordDecl *BaseClassDecl
2077 = cast<CXXRecordDecl>(Base->getType()->getAsRecordType()->getDecl());
2078 if (CXXMethodDecl *BaseAssignOpMethod =
2079 getAssignOperatorMethod(MethodDecl->getParamDecl(0), BaseClassDecl))
2080 MarkDeclarationReferenced(CurrentLocation, BaseAssignOpMethod);
2081 }
2082 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
2083 E = ClassDecl->field_end(); Field != E; ++Field) {
2084 QualType FieldType = Context.getCanonicalType((*Field)->getType());
2085 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
2086 FieldType = Array->getElementType();
2087 if (const RecordType *FieldClassType = FieldType->getAsRecordType()) {
2088 CXXRecordDecl *FieldClassDecl
2089 = cast<CXXRecordDecl>(FieldClassType->getDecl());
2090 if (CXXMethodDecl *FieldAssignOpMethod =
2091 getAssignOperatorMethod(MethodDecl->getParamDecl(0), FieldClassDecl))
2092 MarkDeclarationReferenced(CurrentLocation, FieldAssignOpMethod);
2093 }
2094 else if (FieldType->isReferenceType()) {
2095 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
2096 << Context.getTagDeclType(ClassDecl) << 0 << (*Field)->getNameAsCString();
2097 Diag((*Field)->getLocation(), diag::note_declared_at);
2098 Diag(CurrentLocation, diag::note_first_required_here);
2099 err = true;
2100 }
2101 else if (FieldType.isConstQualified()) {
2102 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
2103 << Context.getTagDeclType(ClassDecl) << 1 << (*Field)->getNameAsCString();
2104 Diag((*Field)->getLocation(), diag::note_declared_at);
2105 Diag(CurrentLocation, diag::note_first_required_here);
2106 err = true;
2107 }
2108 }
2109 if (!err)
2110 MethodDecl->setUsed();
2111}
2112
2113CXXMethodDecl *
2114Sema::getAssignOperatorMethod(ParmVarDecl *ParmDecl,
2115 CXXRecordDecl *ClassDecl) {
2116 QualType LHSType = Context.getTypeDeclType(ClassDecl);
2117 QualType RHSType(LHSType);
2118 // If class's assignment operator argument is const/volatile qualified,
2119 // look for operator = (const/volatile B&). Otherwise, look for
2120 // operator = (B&).
2121 if (ParmDecl->getType().isConstQualified())
2122 RHSType.addConst();
2123 if (ParmDecl->getType().isVolatileQualified())
2124 RHSType.addVolatile();
2125 ExprOwningPtr<Expr> LHS(this, new (Context) DeclRefExpr(ParmDecl,
2126 LHSType,
2127 SourceLocation()));
2128 ExprOwningPtr<Expr> RHS(this, new (Context) DeclRefExpr(ParmDecl,
2129 RHSType,
2130 SourceLocation()));
2131 Expr *Args[2] = { &*LHS, &*RHS };
2132 OverloadCandidateSet CandidateSet;
2133 AddMemberOperatorCandidates(clang::OO_Equal, SourceLocation(), Args, 2,
2134 CandidateSet);
2135 OverloadCandidateSet::iterator Best;
2136 if (BestViableFunction(CandidateSet,
2137 ClassDecl->getLocation(), Best) == OR_Success)
2138 return cast<CXXMethodDecl>(Best->Function);
2139 assert(false &&
2140 "getAssignOperatorMethod - copy assignment operator method not found");
2141 return 0;
2142}
2143
2144void Sema::DefineImplicitCopyConstructor(SourceLocation CurrentLocation,
2145 CXXConstructorDecl *CopyConstructor,
2146 unsigned TypeQuals) {
2147 assert((CopyConstructor->isImplicit() &&
2148 CopyConstructor->isCopyConstructor(Context, TypeQuals) &&
2149 !CopyConstructor->isUsed()) &&
2150 "DefineImplicitCopyConstructor - call it for implicit copy ctor");
2151
2152 CXXRecordDecl *ClassDecl
2153 = cast<CXXRecordDecl>(CopyConstructor->getDeclContext());
2154 assert(ClassDecl && "DefineImplicitCopyConstructor - invalid constructor");
2155 // C++ [class.copy] p209
2156 // Before the implicitly-declared copy constructor for a class is
2157 // implicitly defined, all the implicitly-declared copy constructors
2158 // for its base class and its non-static data members shall have been
2159 // implicitly defined.
2160 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin();
2161 Base != ClassDecl->bases_end(); ++Base) {
2162 CXXRecordDecl *BaseClassDecl
2163 = cast<CXXRecordDecl>(Base->getType()->getAsRecordType()->getDecl());
2164 if (CXXConstructorDecl *BaseCopyCtor =
2165 BaseClassDecl->getCopyConstructor(Context, TypeQuals))
2166 MarkDeclarationReferenced(CurrentLocation, BaseCopyCtor);
2167 }
2168 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
2169 FieldEnd = ClassDecl->field_end();
2170 Field != FieldEnd; ++Field) {
2171 QualType FieldType = Context.getCanonicalType((*Field)->getType());
2172 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
2173 FieldType = Array->getElementType();
2174 if (const RecordType *FieldClassType = FieldType->getAsRecordType()) {
2175 CXXRecordDecl *FieldClassDecl
2176 = cast<CXXRecordDecl>(FieldClassType->getDecl());
2177 if (CXXConstructorDecl *FieldCopyCtor =
2178 FieldClassDecl->getCopyConstructor(Context, TypeQuals))
2179 MarkDeclarationReferenced(CurrentLocation, FieldCopyCtor);
2180 }
2181 }
2182 CopyConstructor->setUsed();
2183}
2184
2185void Sema::InitializeVarWithConstructor(VarDecl *VD,
2186 CXXConstructorDecl *Constructor,
2187 QualType DeclInitType,
2188 Expr **Exprs, unsigned NumExprs) {
2189 Expr *Temp = CXXConstructExpr::Create(Context, DeclInitType, Constructor,
2190 false, Exprs, NumExprs);
2191 MarkDeclarationReferenced(VD->getLocation(), Constructor);
2192 VD->setInit(Context, Temp);
2193}
2194
2195void Sema::MarkDestructorReferenced(SourceLocation Loc, QualType DeclInitType)
2196{
2197 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(
2198 DeclInitType->getAsRecordType()->getDecl());
2199 if (!ClassDecl->hasTrivialDestructor())
2200 if (CXXDestructorDecl *Destructor =
2201 const_cast<CXXDestructorDecl*>(ClassDecl->getDestructor(Context)))
2202 MarkDeclarationReferenced(Loc, Destructor);
2203}
2204
2205/// AddCXXDirectInitializerToDecl - This action is called immediately after
2206/// ActOnDeclarator, when a C++ direct initializer is present.
2207/// e.g: "int x(1);"
2208void Sema::AddCXXDirectInitializerToDecl(DeclPtrTy Dcl,
2209 SourceLocation LParenLoc,
2210 MultiExprArg Exprs,
2211 SourceLocation *CommaLocs,
2212 SourceLocation RParenLoc) {
2213 unsigned NumExprs = Exprs.size();
2214 assert(NumExprs != 0 && Exprs.get() && "missing expressions");
2215 Decl *RealDecl = Dcl.getAs<Decl>();
2216
2217 // If there is no declaration, there was an error parsing it. Just ignore
2218 // the initializer.
2219 if (RealDecl == 0)
2220 return;
2221
2222 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
2223 if (!VDecl) {
2224 Diag(RealDecl->getLocation(), diag::err_illegal_initializer);
2225 RealDecl->setInvalidDecl();
2226 return;
2227 }
2228
2229 // FIXME: Need to handle dependent types and expressions here.
2230
2231 // We will treat direct-initialization as a copy-initialization:
2232 // int x(1); -as-> int x = 1;
2233 // ClassType x(a,b,c); -as-> ClassType x = ClassType(a,b,c);
2234 //
2235 // Clients that want to distinguish between the two forms, can check for
2236 // direct initializer using VarDecl::hasCXXDirectInitializer().
2237 // A major benefit is that clients that don't particularly care about which
2238 // exactly form was it (like the CodeGen) can handle both cases without
2239 // special case code.
2240
2241 // C++ 8.5p11:
2242 // The form of initialization (using parentheses or '=') is generally
2243 // insignificant, but does matter when the entity being initialized has a
2244 // class type.
2245 QualType DeclInitType = VDecl->getType();
2246 if (const ArrayType *Array = Context.getAsArrayType(DeclInitType))
2247 DeclInitType = Array->getElementType();
2248
2249 // FIXME: This isn't the right place to complete the type.
2250 if (RequireCompleteType(VDecl->getLocation(), VDecl->getType(),
2251 diag::err_typecheck_decl_incomplete_type)) {
2252 VDecl->setInvalidDecl();
2253 return;
2254 }
2255
2256 if (VDecl->getType()->isRecordType()) {
2257 CXXConstructorDecl *Constructor
2258 = PerformInitializationByConstructor(DeclInitType,
2259 (Expr **)Exprs.get(), NumExprs,
2260 VDecl->getLocation(),
2261 SourceRange(VDecl->getLocation(),
2262 RParenLoc),
2263 VDecl->getDeclName(),
2264 IK_Direct);
2265 if (!Constructor)
2266 RealDecl->setInvalidDecl();
2267 else {
2268 VDecl->setCXXDirectInitializer(true);
2269 InitializeVarWithConstructor(VDecl, Constructor, DeclInitType,
2270 (Expr**)Exprs.release(), NumExprs);
2271 // FIXME. Must do all that is needed to destroy the object
2272 // on scope exit. For now, just mark the destructor as used.
2273 MarkDestructorReferenced(VDecl->getLocation(), DeclInitType);
2274 }
2275 return;
2276 }
2277
2278 if (NumExprs > 1) {
2279 Diag(CommaLocs[0], diag::err_builtin_direct_init_more_than_one_arg)
2280 << SourceRange(VDecl->getLocation(), RParenLoc);
2281 RealDecl->setInvalidDecl();
2282 return;
2283 }
2284
2285 // Let clients know that initialization was done with a direct initializer.
2286 VDecl->setCXXDirectInitializer(true);
2287
2288 assert(NumExprs == 1 && "Expected 1 expression");
2289 // Set the init expression, handles conversions.
2290 AddInitializerToDecl(Dcl, ExprArg(*this, Exprs.release()[0]),
2291 /*DirectInit=*/true);
2292}
2293
2294/// PerformInitializationByConstructor - Perform initialization by
2295/// constructor (C++ [dcl.init]p14), which may occur as part of
2296/// direct-initialization or copy-initialization. We are initializing
2297/// an object of type @p ClassType with the given arguments @p
2298/// Args. @p Loc is the location in the source code where the
2299/// initializer occurs (e.g., a declaration, member initializer,
2300/// functional cast, etc.) while @p Range covers the whole
2301/// initialization. @p InitEntity is the entity being initialized,
2302/// which may by the name of a declaration or a type. @p Kind is the
2303/// kind of initialization we're performing, which affects whether
2304/// explicit constructors will be considered. When successful, returns
2305/// the constructor that will be used to perform the initialization;
2306/// when the initialization fails, emits a diagnostic and returns
2307/// null.
2308CXXConstructorDecl *
2309Sema::PerformInitializationByConstructor(QualType ClassType,
2310 Expr **Args, unsigned NumArgs,
2311 SourceLocation Loc, SourceRange Range,
2312 DeclarationName InitEntity,
2313 InitializationKind Kind) {
2314 const RecordType *ClassRec = ClassType->getAsRecordType();
2315 assert(ClassRec && "Can only initialize a class type here");
2316
2317 // C++ [dcl.init]p14:
2318 //
2319 // If the initialization is direct-initialization, or if it is
2320 // copy-initialization where the cv-unqualified version of the
2321 // source type is the same class as, or a derived class of, the
2322 // class of the destination, constructors are considered. The
2323 // applicable constructors are enumerated (13.3.1.3), and the
2324 // best one is chosen through overload resolution (13.3). The
2325 // constructor so selected is called to initialize the object,
2326 // with the initializer expression(s) as its argument(s). If no
2327 // constructor applies, or the overload resolution is ambiguous,
2328 // the initialization is ill-formed.
2329 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(ClassRec->getDecl());
2330 OverloadCandidateSet CandidateSet;
2331
2332 // Add constructors to the overload set.
2333 DeclarationName ConstructorName
2334 = Context.DeclarationNames.getCXXConstructorName(
2335 Context.getCanonicalType(ClassType.getUnqualifiedType()));
2336 DeclContext::lookup_const_iterator Con, ConEnd;
2337 for (llvm::tie(Con, ConEnd) = ClassDecl->lookup(ConstructorName);
2338 Con != ConEnd; ++Con) {
2339 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(*Con);
2340 if ((Kind == IK_Direct) ||
2341 (Kind == IK_Copy && Constructor->isConvertingConstructor()) ||
2342 (Kind == IK_Default && Constructor->isDefaultConstructor()))
2343 AddOverloadCandidate(Constructor, Args, NumArgs, CandidateSet);
2344 }
2345
2346 // FIXME: When we decide not to synthesize the implicitly-declared
2347 // constructors, we'll need to make them appear here.
2348
2349 OverloadCandidateSet::iterator Best;
2350 switch (BestViableFunction(CandidateSet, Loc, Best)) {
2351 case OR_Success:
2352 // We found a constructor. Return it.
2353 return cast<CXXConstructorDecl>(Best->Function);
2354
2355 case OR_No_Viable_Function:
2356 if (InitEntity)
2357 Diag(Loc, diag::err_ovl_no_viable_function_in_init)
2358 << InitEntity << Range;
2359 else
2360 Diag(Loc, diag::err_ovl_no_viable_function_in_init)
2361 << ClassType << Range;
2362 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/false);
2363 return 0;
2364
2365 case OR_Ambiguous:
2366 if (InitEntity)
2367 Diag(Loc, diag::err_ovl_ambiguous_init) << InitEntity << Range;
2368 else
2369 Diag(Loc, diag::err_ovl_ambiguous_init) << ClassType << Range;
2370 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
2371 return 0;
2372
2373 case OR_Deleted:
2374 if (InitEntity)
2375 Diag(Loc, diag::err_ovl_deleted_init)
2376 << Best->Function->isDeleted()
2377 << InitEntity << Range;
2378 else
2379 Diag(Loc, diag::err_ovl_deleted_init)
2380 << Best->Function->isDeleted()
2381 << InitEntity << Range;
2382 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
2383 return 0;
2384 }
2385
2386 return 0;
2387}
2388
2389/// CompareReferenceRelationship - Compare the two types T1 and T2 to
2390/// determine whether they are reference-related,
2391/// reference-compatible, reference-compatible with added
2392/// qualification, or incompatible, for use in C++ initialization by
2393/// reference (C++ [dcl.ref.init]p4). Neither type can be a reference
2394/// type, and the first type (T1) is the pointee type of the reference
2395/// type being initialized.
2396Sema::ReferenceCompareResult
2397Sema::CompareReferenceRelationship(QualType T1, QualType T2,
2398 bool& DerivedToBase) {
2399 assert(!T1->isReferenceType() &&
2400 "T1 must be the pointee type of the reference type");
2401 assert(!T2->isReferenceType() && "T2 cannot be a reference type");
2402
2403 T1 = Context.getCanonicalType(T1);
2404 T2 = Context.getCanonicalType(T2);
2405 QualType UnqualT1 = T1.getUnqualifiedType();
2406 QualType UnqualT2 = T2.getUnqualifiedType();
2407
2408 // C++ [dcl.init.ref]p4:
2409 // Given types ���cv1 T1��� and ���cv2 T2,��� ���cv1 T1��� is
2410 // reference-related to ���cv2 T2��� if T1 is the same type as T2, or
2411 // T1 is a base class of T2.
2412 if (UnqualT1 == UnqualT2)
2413 DerivedToBase = false;
2414 else if (IsDerivedFrom(UnqualT2, UnqualT1))
2415 DerivedToBase = true;
2416 else
2417 return Ref_Incompatible;
2418
2419 // At this point, we know that T1 and T2 are reference-related (at
2420 // least).
2421
2422 // C++ [dcl.init.ref]p4:
2423 // "cv1 T1��� is reference-compatible with ���cv2 T2��� if T1 is
2424 // reference-related to T2 and cv1 is the same cv-qualification
2425 // as, or greater cv-qualification than, cv2. For purposes of
2426 // overload resolution, cases for which cv1 is greater
2427 // cv-qualification than cv2 are identified as
2428 // reference-compatible with added qualification (see 13.3.3.2).
2429 if (T1.getCVRQualifiers() == T2.getCVRQualifiers())
2430 return Ref_Compatible;
2431 else if (T1.isMoreQualifiedThan(T2))
2432 return Ref_Compatible_With_Added_Qualification;
2433 else
2434 return Ref_Related;
2435}
2436
2437/// CheckReferenceInit - Check the initialization of a reference
2438/// variable with the given initializer (C++ [dcl.init.ref]). Init is
2439/// the initializer (either a simple initializer or an initializer
2440/// list), and DeclType is the type of the declaration. When ICS is
2441/// non-null, this routine will compute the implicit conversion
2442/// sequence according to C++ [over.ics.ref] and will not produce any
2443/// diagnostics; when ICS is null, it will emit diagnostics when any
2444/// errors are found. Either way, a return value of true indicates
2445/// that there was a failure, a return value of false indicates that
2446/// the reference initialization succeeded.
2447///
2448/// When @p SuppressUserConversions, user-defined conversions are
2449/// suppressed.
2450/// When @p AllowExplicit, we also permit explicit user-defined
2451/// conversion functions.
2452/// When @p ForceRValue, we unconditionally treat the initializer as an rvalue.
2453bool
2454Sema::CheckReferenceInit(Expr *&Init, QualType DeclType,
2455 ImplicitConversionSequence *ICS,
2456 bool SuppressUserConversions,
2457 bool AllowExplicit, bool ForceRValue) {
2458 assert(DeclType->isReferenceType() && "Reference init needs a reference");
2459
2460 QualType T1 = DeclType->getAsReferenceType()->getPointeeType();
2461 QualType T2 = Init->getType();
2462
2463 // If the initializer is the address of an overloaded function, try
2464 // to resolve the overloaded function. If all goes well, T2 is the
2465 // type of the resulting function.
2466 if (Context.getCanonicalType(T2) == Context.OverloadTy) {
2467 FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Init, DeclType,
2468 ICS != 0);
2469 if (Fn) {
2470 // Since we're performing this reference-initialization for
2471 // real, update the initializer with the resulting function.
2472 if (!ICS) {
2473 if (DiagnoseUseOfDecl(Fn, Init->getSourceRange().getBegin()))
2474 return true;
2475
2476 FixOverloadedFunctionReference(Init, Fn);
2477 }
2478
2479 T2 = Fn->getType();
2480 }
2481 }
2482
2483 // Compute some basic properties of the types and the initializer.
2484 bool isRValRef = DeclType->isRValueReferenceType();
2485 bool DerivedToBase = false;
2486 Expr::isLvalueResult InitLvalue = ForceRValue ? Expr::LV_InvalidExpression :
2487 Init->isLvalue(Context);
2488 ReferenceCompareResult RefRelationship
2489 = CompareReferenceRelationship(T1, T2, DerivedToBase);
2490
2491 // Most paths end in a failed conversion.
2492 if (ICS)
2493 ICS->ConversionKind = ImplicitConversionSequence::BadConversion;
2494
2495 // C++ [dcl.init.ref]p5:
2496 // A reference to type ���cv1 T1��� is initialized by an expression
2497 // of type ���cv2 T2��� as follows:
2498
2499 // -- If the initializer expression
2500
2501 // Rvalue references cannot bind to lvalues (N2812).
2502 // There is absolutely no situation where they can. In particular, note that
2503 // this is ill-formed, even if B has a user-defined conversion to A&&:
2504 // B b;
2505 // A&& r = b;
2506 if (isRValRef && InitLvalue == Expr::LV_Valid) {
2507 if (!ICS)
2508 Diag(Init->getSourceRange().getBegin(), diag::err_lvalue_to_rvalue_ref)
2509 << Init->getSourceRange();
2510 return true;
2511 }
2512
2513 bool BindsDirectly = false;
2514 // -- is an lvalue (but is not a bit-field), and ���cv1 T1��� is
2515 // reference-compatible with ���cv2 T2,��� or
2516 //
2517 // Note that the bit-field check is skipped if we are just computing
2518 // the implicit conversion sequence (C++ [over.best.ics]p2).
2519 if (InitLvalue == Expr::LV_Valid && (ICS || !Init->getBitField()) &&
2520 RefRelationship >= Ref_Compatible_With_Added_Qualification) {
2521 BindsDirectly = true;
2522
2523 if (ICS) {
2524 // C++ [over.ics.ref]p1:
2525 // When a parameter of reference type binds directly (8.5.3)
2526 // to an argument expression, the implicit conversion sequence
2527 // is the identity conversion, unless the argument expression
2528 // has a type that is a derived class of the parameter type,
2529 // in which case the implicit conversion sequence is a
2530 // derived-to-base Conversion (13.3.3.1).
2531 ICS->ConversionKind = ImplicitConversionSequence::StandardConversion;
2532 ICS->Standard.First = ICK_Identity;
2533 ICS->Standard.Second = DerivedToBase? ICK_Derived_To_Base : ICK_Identity;
2534 ICS->Standard.Third = ICK_Identity;
2535 ICS->Standard.FromTypePtr = T2.getAsOpaquePtr();
2536 ICS->Standard.ToTypePtr = T1.getAsOpaquePtr();
2537 ICS->Standard.ReferenceBinding = true;
2538 ICS->Standard.DirectBinding = true;
2539 ICS->Standard.RRefBinding = false;
2540 ICS->Standard.CopyConstructor = 0;
2541
2542 // Nothing more to do: the inaccessibility/ambiguity check for
2543 // derived-to-base conversions is suppressed when we're
2544 // computing the implicit conversion sequence (C++
2545 // [over.best.ics]p2).
2546 return false;
2547 } else {
2548 // Perform the conversion.
2549 // FIXME: Binding to a subobject of the lvalue is going to require more
2550 // AST annotation than this.
2551 ImpCastExprToType(Init, T1, /*isLvalue=*/true);
2552 }
2553 }
2554
2555 // -- has a class type (i.e., T2 is a class type) and can be
2556 // implicitly converted to an lvalue of type ���cv3 T3,���
2557 // where ���cv1 T1��� is reference-compatible with ���cv3 T3���
2558 // 92) (this conversion is selected by enumerating the
2559 // applicable conversion functions (13.3.1.6) and choosing
2560 // the best one through overload resolution (13.3)),
2561 if (!isRValRef && !SuppressUserConversions && T2->isRecordType()) {
2562 // FIXME: Look for conversions in base classes!
2563 CXXRecordDecl *T2RecordDecl
2564 = dyn_cast<CXXRecordDecl>(T2->getAsRecordType()->getDecl());
2565
2566 OverloadCandidateSet CandidateSet;
2567 OverloadedFunctionDecl *Conversions
2568 = T2RecordDecl->getConversionFunctions();
2569 for (OverloadedFunctionDecl::function_iterator Func
2570 = Conversions->function_begin();
2571 Func != Conversions->function_end(); ++Func) {
2572 CXXConversionDecl *Conv = cast<CXXConversionDecl>(*Func);
2573
2574 // If the conversion function doesn't return a reference type,
2575 // it can't be considered for this conversion.
2576 if (Conv->getConversionType()->isLValueReferenceType() &&
2577 (AllowExplicit || !Conv->isExplicit()))
2578 AddConversionCandidate(Conv, Init, DeclType, CandidateSet);
2579 }
2580
2581 OverloadCandidateSet::iterator Best;
2582 switch (BestViableFunction(CandidateSet, Init->getLocStart(), Best)) {
2583 case OR_Success:
2584 // This is a direct binding.
2585 BindsDirectly = true;
2586
2587 if (ICS) {
2588 // C++ [over.ics.ref]p1:
2589 //
2590 // [...] If the parameter binds directly to the result of
2591 // applying a conversion function to the argument
2592 // expression, the implicit conversion sequence is a
2593 // user-defined conversion sequence (13.3.3.1.2), with the
2594 // second standard conversion sequence either an identity
2595 // conversion or, if the conversion function returns an
2596 // entity of a type that is a derived class of the parameter
2597 // type, a derived-to-base Conversion.
2598 ICS->ConversionKind = ImplicitConversionSequence::UserDefinedConversion;
2599 ICS->UserDefined.Before = Best->Conversions[0].Standard;
2600 ICS->UserDefined.After = Best->FinalConversion;
2601 ICS->UserDefined.ConversionFunction = Best->Function;
2602 assert(ICS->UserDefined.After.ReferenceBinding &&
2603 ICS->UserDefined.After.DirectBinding &&
2604 "Expected a direct reference binding!");
2605 return false;
2606 } else {
2607 // Perform the conversion.
2608 // FIXME: Binding to a subobject of the lvalue is going to require more
2609 // AST annotation than this.
2610 ImpCastExprToType(Init, T1, /*isLvalue=*/true);
2611 }
2612 break;
2613
2614 case OR_Ambiguous:
2615 assert(false && "Ambiguous reference binding conversions not implemented.");
2616 return true;
2617
2618 case OR_No_Viable_Function:
2619 case OR_Deleted:
2620 // There was no suitable conversion, or we found a deleted
2621 // conversion; continue with other checks.
2622 break;
2623 }
2624 }
2625
2626 if (BindsDirectly) {
2627 // C++ [dcl.init.ref]p4:
2628 // [...] In all cases where the reference-related or
2629 // reference-compatible relationship of two types is used to
2630 // establish the validity of a reference binding, and T1 is a
2631 // base class of T2, a program that necessitates such a binding
2632 // is ill-formed if T1 is an inaccessible (clause 11) or
2633 // ambiguous (10.2) base class of T2.
2634 //
2635 // Note that we only check this condition when we're allowed to
2636 // complain about errors, because we should not be checking for
2637 // ambiguity (or inaccessibility) unless the reference binding
2638 // actually happens.
2639 if (DerivedToBase)
2640 return CheckDerivedToBaseConversion(T2, T1,
2641 Init->getSourceRange().getBegin(),
2642 Init->getSourceRange());
2643 else
2644 return false;
2645 }
2646
2647 // -- Otherwise, the reference shall be to a non-volatile const
2648 // type (i.e., cv1 shall be const), or the reference shall be an
2649 // rvalue reference and the initializer expression shall be an rvalue.
2650 if (!isRValRef && T1.getCVRQualifiers() != QualType::Const) {
2651 if (!ICS)
2652 Diag(Init->getSourceRange().getBegin(),
2653 diag::err_not_reference_to_const_init)
2654 << T1 << (InitLvalue != Expr::LV_Valid? "temporary" : "value")
2655 << T2 << Init->getSourceRange();
2656 return true;
2657 }
2658
2659 // -- If the initializer expression is an rvalue, with T2 a
2660 // class type, and ���cv1 T1��� is reference-compatible with
2661 // ���cv2 T2,��� the reference is bound in one of the
2662 // following ways (the choice is implementation-defined):
2663 //
2664 // -- The reference is bound to the object represented by
2665 // the rvalue (see 3.10) or to a sub-object within that
2666 // object.
2667 //
2668 // -- A temporary of type ���cv1 T2��� [sic] is created, and
2669 // a constructor is called to copy the entire rvalue
2670 // object into the temporary. The reference is bound to
2671 // the temporary or to a sub-object within the
2672 // temporary.
2673 //
2674 // The constructor that would be used to make the copy
2675 // shall be callable whether or not the copy is actually
2676 // done.
2677 //
2678 // Note that C++0x [dcl.init.ref]p5 takes away this implementation
2679 // freedom, so we will always take the first option and never build
2680 // a temporary in this case. FIXME: We will, however, have to check
2681 // for the presence of a copy constructor in C++98/03 mode.
2682 if (InitLvalue != Expr::LV_Valid && T2->isRecordType() &&
2683 RefRelationship >= Ref_Compatible_With_Added_Qualification) {
2684 if (ICS) {
2685 ICS->ConversionKind = ImplicitConversionSequence::StandardConversion;
2686 ICS->Standard.First = ICK_Identity;
2687 ICS->Standard.Second = DerivedToBase? ICK_Derived_To_Base : ICK_Identity;
2688 ICS->Standard.Third = ICK_Identity;
2689 ICS->Standard.FromTypePtr = T2.getAsOpaquePtr();
2690 ICS->Standard.ToTypePtr = T1.getAsOpaquePtr();
2691 ICS->Standard.ReferenceBinding = true;
2692 ICS->Standard.DirectBinding = false;
2693 ICS->Standard.RRefBinding = isRValRef;
2694 ICS->Standard.CopyConstructor = 0;
2695 } else {
2696 // FIXME: Binding to a subobject of the rvalue is going to require more
2697 // AST annotation than this.
2698 ImpCastExprToType(Init, T1, /*isLvalue=*/false);
2699 }
2700 return false;
2701 }
2702
2703 // -- Otherwise, a temporary of type ���cv1 T1��� is created and
2704 // initialized from the initializer expression using the
2705 // rules for a non-reference copy initialization (8.5). The
2706 // reference is then bound to the temporary. If T1 is
2707 // reference-related to T2, cv1 must be the same
2708 // cv-qualification as, or greater cv-qualification than,
2709 // cv2; otherwise, the program is ill-formed.
2710 if (RefRelationship == Ref_Related) {
2711 // If cv1 == cv2 or cv1 is a greater cv-qualified than cv2, then
2712 // we would be reference-compatible or reference-compatible with
2713 // added qualification. But that wasn't the case, so the reference
2714 // initialization fails.
2715 if (!ICS)
2716 Diag(Init->getSourceRange().getBegin(),
2717 diag::err_reference_init_drops_quals)
2718 << T1 << (InitLvalue != Expr::LV_Valid? "temporary" : "value")
2719 << T2 << Init->getSourceRange();
2720 return true;
2721 }
2722
2723 // If at least one of the types is a class type, the types are not
2724 // related, and we aren't allowed any user conversions, the
2725 // reference binding fails. This case is important for breaking
2726 // recursion, since TryImplicitConversion below will attempt to
2727 // create a temporary through the use of a copy constructor.
2728 if (SuppressUserConversions && RefRelationship == Ref_Incompatible &&
2729 (T1->isRecordType() || T2->isRecordType())) {
2730 if (!ICS)
2731 Diag(Init->getSourceRange().getBegin(),
2732 diag::err_typecheck_convert_incompatible)
2733 << DeclType << Init->getType() << "initializing" << Init->getSourceRange();
2734 return true;
2735 }
2736
2737 // Actually try to convert the initializer to T1.
2738 if (ICS) {
2739 // C++ [over.ics.ref]p2:
2740 //
2741 // When a parameter of reference type is not bound directly to
2742 // an argument expression, the conversion sequence is the one
2743 // required to convert the argument expression to the
2744 // underlying type of the reference according to
2745 // 13.3.3.1. Conceptually, this conversion sequence corresponds
2746 // to copy-initializing a temporary of the underlying type with
2747 // the argument expression. Any difference in top-level
2748 // cv-qualification is subsumed by the initialization itself
2749 // and does not constitute a conversion.
2750 *ICS = TryImplicitConversion(Init, T1, SuppressUserConversions);
2751 // Of course, that's still a reference binding.
2752 if (ICS->ConversionKind == ImplicitConversionSequence::StandardConversion) {
2753 ICS->Standard.ReferenceBinding = true;
2754 ICS->Standard.RRefBinding = isRValRef;
2755 } else if(ICS->ConversionKind ==
2756 ImplicitConversionSequence::UserDefinedConversion) {
2757 ICS->UserDefined.After.ReferenceBinding = true;
2758 ICS->UserDefined.After.RRefBinding = isRValRef;
2759 }
2760 return ICS->ConversionKind == ImplicitConversionSequence::BadConversion;
2761 } else {
2762 return PerformImplicitConversion(Init, T1, "initializing");
2763 }
2764}
2765
2766/// CheckOverloadedOperatorDeclaration - Check whether the declaration
2767/// of this overloaded operator is well-formed. If so, returns false;
2768/// otherwise, emits appropriate diagnostics and returns true.
2769bool Sema::CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl) {
2770 assert(FnDecl && FnDecl->isOverloadedOperator() &&
2771 "Expected an overloaded operator declaration");
2772
2773 OverloadedOperatorKind Op = FnDecl->getOverloadedOperator();
2774
2775 // C++ [over.oper]p5:
2776 // The allocation and deallocation functions, operator new,
2777 // operator new[], operator delete and operator delete[], are
2778 // described completely in 3.7.3. The attributes and restrictions
2779 // found in the rest of this subclause do not apply to them unless
2780 // explicitly stated in 3.7.3.
2781 // FIXME: Write a separate routine for checking this. For now, just allow it.
2782 if (Op == OO_New || Op == OO_Array_New ||
2783 Op == OO_Delete || Op == OO_Array_Delete)
2784 return false;
2785
2786 // C++ [over.oper]p6:
2787 // An operator function shall either be a non-static member
2788 // function or be a non-member function and have at least one
2789 // parameter whose type is a class, a reference to a class, an
2790 // enumeration, or a reference to an enumeration.
2791 if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) {
2792 if (MethodDecl->isStatic())
2793 return Diag(FnDecl->getLocation(),
2794 diag::err_operator_overload_static) << FnDecl->getDeclName();
2795 } else {
2796 bool ClassOrEnumParam = false;
2797 for (FunctionDecl::param_iterator Param = FnDecl->param_begin(),
2798 ParamEnd = FnDecl->param_end();
2799 Param != ParamEnd; ++Param) {
2800 QualType ParamType = (*Param)->getType().getNonReferenceType();
2801 if (ParamType->isDependentType() || ParamType->isRecordType() ||
2802 ParamType->isEnumeralType()) {
2803 ClassOrEnumParam = true;
2804 break;
2805 }
2806 }
2807
2808 if (!ClassOrEnumParam)
2809 return Diag(FnDecl->getLocation(),
2810 diag::err_operator_overload_needs_class_or_enum)
2811 << FnDecl->getDeclName();
2812 }
2813
2814 // C++ [over.oper]p8:
2815 // An operator function cannot have default arguments (8.3.6),
2816 // except where explicitly stated below.
2817 //
2818 // Only the function-call operator allows default arguments
2819 // (C++ [over.call]p1).
2820 if (Op != OO_Call) {
2821 for (FunctionDecl::param_iterator Param = FnDecl->param_begin();
2822 Param != FnDecl->param_end(); ++Param) {
2823 if ((*Param)->hasUnparsedDefaultArg())
2824 return Diag((*Param)->getLocation(),
2825 diag::err_operator_overload_default_arg)
2826 << FnDecl->getDeclName();
2827 else if (Expr *DefArg = (*Param)->getDefaultArg())
2828 return Diag((*Param)->getLocation(),
2829 diag::err_operator_overload_default_arg)
2830 << FnDecl->getDeclName() << DefArg->getSourceRange();
2831 }
2832 }
2833
2834 static const bool OperatorUses[NUM_OVERLOADED_OPERATORS][3] = {
2835 { false, false, false }
2836#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
2837 , { Unary, Binary, MemberOnly }
2838#include "clang/Basic/OperatorKinds.def"
2839 };
2840
2841 bool CanBeUnaryOperator = OperatorUses[Op][0];
2842 bool CanBeBinaryOperator = OperatorUses[Op][1];
2843 bool MustBeMemberOperator = OperatorUses[Op][2];
2844
2845 // C++ [over.oper]p8:
2846 // [...] Operator functions cannot have more or fewer parameters
2847 // than the number required for the corresponding operator, as
2848 // described in the rest of this subclause.
2849 unsigned NumParams = FnDecl->getNumParams()
2850 + (isa<CXXMethodDecl>(FnDecl)? 1 : 0);
2851 if (Op != OO_Call &&
2852 ((NumParams == 1 && !CanBeUnaryOperator) ||
2853 (NumParams == 2 && !CanBeBinaryOperator) ||
2854 (NumParams < 1) || (NumParams > 2))) {
2855 // We have the wrong number of parameters.
2856 unsigned ErrorKind;
2857 if (CanBeUnaryOperator && CanBeBinaryOperator) {
2858 ErrorKind = 2; // 2 -> unary or binary.
2859 } else if (CanBeUnaryOperator) {
2860 ErrorKind = 0; // 0 -> unary
2861 } else {
2862 assert(CanBeBinaryOperator &&
2863 "All non-call overloaded operators are unary or binary!");
2864 ErrorKind = 1; // 1 -> binary
2865 }
2866
2867 return Diag(FnDecl->getLocation(), diag::err_operator_overload_must_be)
2868 << FnDecl->getDeclName() << NumParams << ErrorKind;
2869 }
2870
2871 // Overloaded operators other than operator() cannot be variadic.
2872 if (Op != OO_Call &&
2873 FnDecl->getType()->getAsFunctionProtoType()->isVariadic()) {
2874 return Diag(FnDecl->getLocation(), diag::err_operator_overload_variadic)
2875 << FnDecl->getDeclName();
2876 }
2877
2878 // Some operators must be non-static member functions.
2879 if (MustBeMemberOperator && !isa<CXXMethodDecl>(FnDecl)) {
2880 return Diag(FnDecl->getLocation(),
2881 diag::err_operator_overload_must_be_member)
2882 << FnDecl->getDeclName();
2883 }
2884
2885 // C++ [over.inc]p1:
2886 // The user-defined function called operator++ implements the
2887 // prefix and postfix ++ operator. If this function is a member
2888 // function with no parameters, or a non-member function with one
2889 // parameter of class or enumeration type, it defines the prefix
2890 // increment operator ++ for objects of that type. If the function
2891 // is a member function with one parameter (which shall be of type
2892 // int) or a non-member function with two parameters (the second
2893 // of which shall be of type int), it defines the postfix
2894 // increment operator ++ for objects of that type.
2895 if ((Op == OO_PlusPlus || Op == OO_MinusMinus) && NumParams == 2) {
2896 ParmVarDecl *LastParam = FnDecl->getParamDecl(FnDecl->getNumParams() - 1);
2897 bool ParamIsInt = false;
2898 if (const BuiltinType *BT = LastParam->getType()->getAsBuiltinType())
2899 ParamIsInt = BT->getKind() == BuiltinType::Int;
2900
2901 if (!ParamIsInt)
2902 return Diag(LastParam->getLocation(),
2903 diag::err_operator_overload_post_incdec_must_be_int)
2904 << LastParam->getType() << (Op == OO_MinusMinus);
2905 }
2906
2907 // Notify the class if it got an assignment operator.
2908 if (Op == OO_Equal) {
2909 // Would have returned earlier otherwise.
2910 assert(isa<CXXMethodDecl>(FnDecl) &&
2911 "Overloaded = not member, but not filtered.");
2912 CXXMethodDecl *Method = cast<CXXMethodDecl>(FnDecl);
2913 Method->getParent()->addedAssignmentOperator(Context, Method);
2914 }
2915
2916 return false;
2917}
2918
2919/// ActOnStartLinkageSpecification - Parsed the beginning of a C++
2920/// linkage specification, including the language and (if present)
2921/// the '{'. ExternLoc is the location of the 'extern', LangLoc is
2922/// the location of the language string literal, which is provided
2923/// by Lang/StrSize. LBraceLoc, if valid, provides the location of
2924/// the '{' brace. Otherwise, this linkage specification does not
2925/// have any braces.
2926Sema::DeclPtrTy Sema::ActOnStartLinkageSpecification(Scope *S,
2927 SourceLocation ExternLoc,
2928 SourceLocation LangLoc,
2929 const char *Lang,
2930 unsigned StrSize,
2931 SourceLocation LBraceLoc) {
2932 LinkageSpecDecl::LanguageIDs Language;
2933 if (strncmp(Lang, "\"C\"", StrSize) == 0)
2934 Language = LinkageSpecDecl::lang_c;
2935 else if (strncmp(Lang, "\"C++\"", StrSize) == 0)
2936 Language = LinkageSpecDecl::lang_cxx;
2937 else {
2938 Diag(LangLoc, diag::err_bad_language);
2939 return DeclPtrTy();
2940 }
2941
2942 // FIXME: Add all the various semantics of linkage specifications
2943
2944 LinkageSpecDecl *D = LinkageSpecDecl::Create(Context, CurContext,
2945 LangLoc, Language,
2946 LBraceLoc.isValid());
2947 CurContext->addDecl(D);
2948 PushDeclContext(S, D);
2949 return DeclPtrTy::make(D);
2950}
2951
2952/// ActOnFinishLinkageSpecification - Completely the definition of
2953/// the C++ linkage specification LinkageSpec. If RBraceLoc is
2954/// valid, it's the position of the closing '}' brace in a linkage
2955/// specification that uses braces.
2956Sema::DeclPtrTy Sema::ActOnFinishLinkageSpecification(Scope *S,
2957 DeclPtrTy LinkageSpec,
2958 SourceLocation RBraceLoc) {
2959 if (LinkageSpec)
2960 PopDeclContext();
2961 return LinkageSpec;
2962}
2963
2964/// \brief Perform semantic analysis for the variable declaration that
2965/// occurs within a C++ catch clause, returning the newly-created
2966/// variable.
2967VarDecl *Sema::BuildExceptionDeclaration(Scope *S, QualType ExDeclType,
2968 IdentifierInfo *Name,
2969 SourceLocation Loc,
2970 SourceRange Range) {
2971 bool Invalid = false;
2972
2973 // Arrays and functions decay.
2974 if (ExDeclType->isArrayType())
2975 ExDeclType = Context.getArrayDecayedType(ExDeclType);
2976 else if (ExDeclType->isFunctionType())
2977 ExDeclType = Context.getPointerType(ExDeclType);
2978
2979 // C++ 15.3p1: The exception-declaration shall not denote an incomplete type.
2980 // The exception-declaration shall not denote a pointer or reference to an
2981 // incomplete type, other than [cv] void*.
2982 // N2844 forbids rvalue references.
2983 if(!ExDeclType->isDependentType() && ExDeclType->isRValueReferenceType()) {
2984 Diag(Loc, diag::err_catch_rvalue_ref) << Range;
2985 Invalid = true;
2986 }
2987
2988 QualType BaseType = ExDeclType;
2989 int Mode = 0; // 0 for direct type, 1 for pointer, 2 for reference
2990 unsigned DK = diag::err_catch_incomplete;
2991 if (const PointerType *Ptr = BaseType->getAsPointerType()) {
2992 BaseType = Ptr->getPointeeType();
2993 Mode = 1;
2994 DK = diag::err_catch_incomplete_ptr;
2995 } else if(const ReferenceType *Ref = BaseType->getAsReferenceType()) {
2996 // For the purpose of error recovery, we treat rvalue refs like lvalue refs.
2997 BaseType = Ref->getPointeeType();
2998 Mode = 2;
2999 DK = diag::err_catch_incomplete_ref;
3000 }
3001 if (!Invalid && (Mode == 0 || !BaseType->isVoidType()) &&
3002 !BaseType->isDependentType() && RequireCompleteType(Loc, BaseType, DK))
3003 Invalid = true;
3004
3005 if (!Invalid && !ExDeclType->isDependentType() &&
3006 RequireNonAbstractType(Loc, ExDeclType,
3007 diag::err_abstract_type_in_decl,
3008 AbstractVariableType))
3009 Invalid = true;
3010
3011 // FIXME: Need to test for ability to copy-construct and destroy the
3012 // exception variable.
3013
3014 // FIXME: Need to check for abstract classes.
3015
3016 VarDecl *ExDecl = VarDecl::Create(Context, CurContext, Loc,
3017 Name, ExDeclType, VarDecl::None,
3018 Range.getBegin());
3019
3020 if (Invalid)
3021 ExDecl->setInvalidDecl();
3022
3023 return ExDecl;
3024}
3025
3026/// ActOnExceptionDeclarator - Parsed the exception-declarator in a C++ catch
3027/// handler.
3028Sema::DeclPtrTy Sema::ActOnExceptionDeclarator(Scope *S, Declarator &D) {
3029 QualType ExDeclType = GetTypeForDeclarator(D, S);
3030
3031 bool Invalid = D.isInvalidType();
3032 IdentifierInfo *II = D.getIdentifier();
3033 if (NamedDecl *PrevDecl = LookupName(S, II, LookupOrdinaryName)) {
3034 // The scope should be freshly made just for us. There is just no way
3035 // it contains any previous declaration.
3036 assert(!S->isDeclScope(DeclPtrTy::make(PrevDecl)));
3037 if (PrevDecl->isTemplateParameter()) {
3038 // Maybe we will complain about the shadowed template parameter.
3039 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
3040 }
3041 }
3042
3043 if (D.getCXXScopeSpec().isSet() && !Invalid) {
3044 Diag(D.getIdentifierLoc(), diag::err_qualified_catch_declarator)
3045 << D.getCXXScopeSpec().getRange();
3046 Invalid = true;
3047 }
3048
3049 VarDecl *ExDecl = BuildExceptionDeclaration(S, ExDeclType,
3050 D.getIdentifier(),
3051 D.getIdentifierLoc(),
3052 D.getDeclSpec().getSourceRange());
3053
3054 if (Invalid)
3055 ExDecl->setInvalidDecl();
3056
3057 // Add the exception declaration into this scope.
3058 if (II)
3059 PushOnScopeChains(ExDecl, S);
3060 else
3061 CurContext->addDecl(ExDecl);
3062
3063 ProcessDeclAttributes(S, ExDecl, D);
3064 return DeclPtrTy::make(ExDecl);
3065}
3066
3067Sema::DeclPtrTy Sema::ActOnStaticAssertDeclaration(SourceLocation AssertLoc,
3068 ExprArg assertexpr,
3069 ExprArg assertmessageexpr) {
3070 Expr *AssertExpr = (Expr *)assertexpr.get();
3071 StringLiteral *AssertMessage =
3072 cast<StringLiteral>((Expr *)assertmessageexpr.get());
3073
3074 if (!AssertExpr->isTypeDependent() && !AssertExpr->isValueDependent()) {
3075 llvm::APSInt Value(32);
3076 if (!AssertExpr->isIntegerConstantExpr(Value, Context)) {
3077 Diag(AssertLoc, diag::err_static_assert_expression_is_not_constant) <<
3078 AssertExpr->getSourceRange();
3079 return DeclPtrTy();
3080 }
3081
3082 if (Value == 0) {
3083 std::string str(AssertMessage->getStrData(),
3084 AssertMessage->getByteLength());
3085 Diag(AssertLoc, diag::err_static_assert_failed)
3086 << str << AssertExpr->getSourceRange();
3087 }
3088 }
3089
3090 assertexpr.release();
3091 assertmessageexpr.release();
3092 Decl *Decl = StaticAssertDecl::Create(Context, CurContext, AssertLoc,
3093 AssertExpr, AssertMessage);
3094
3095 CurContext->addDecl(Decl);
3096 return DeclPtrTy::make(Decl);
3097}
3098
3099bool Sema::ActOnFriendDecl(Scope *S, SourceLocation FriendLoc, DeclPtrTy Dcl) {
3100 if (!(S->getFlags() & Scope::ClassScope)) {
3101 Diag(FriendLoc, diag::err_friend_decl_outside_class);
3102 return true;
3103 }
3104
3105 return false;
3106}
3107
3108void Sema::SetDeclDeleted(DeclPtrTy dcl, SourceLocation DelLoc) {
3109 Decl *Dcl = dcl.getAs<Decl>();
3110 FunctionDecl *Fn = dyn_cast<FunctionDecl>(Dcl);
3111 if (!Fn) {
3112 Diag(DelLoc, diag::err_deleted_non_function);
3113 return;
3114 }
3115 if (const FunctionDecl *Prev = Fn->getPreviousDeclaration()) {
3116 Diag(DelLoc, diag::err_deleted_decl_not_first);
3117 Diag(Prev->getLocation(), diag::note_previous_declaration);
3118 // If the declaration wasn't the first, we delete the function anyway for
3119 // recovery.
3120 }
3121 Fn->setDeleted();
3122}
3123
3124static void SearchForReturnInStmt(Sema &Self, Stmt *S) {
3125 for (Stmt::child_iterator CI = S->child_begin(), E = S->child_end(); CI != E;
3126 ++CI) {
3127 Stmt *SubStmt = *CI;
3128 if (!SubStmt)
3129 continue;
3130 if (isa<ReturnStmt>(SubStmt))
3131 Self.Diag(SubStmt->getSourceRange().getBegin(),
3132 diag::err_return_in_constructor_handler);
3133 if (!isa<Expr>(SubStmt))
3134 SearchForReturnInStmt(Self, SubStmt);
3135 }
3136}
3137
3138void Sema::DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock) {
3139 for (unsigned I = 0, E = TryBlock->getNumHandlers(); I != E; ++I) {
3140 CXXCatchStmt *Handler = TryBlock->getHandler(I);
3141 SearchForReturnInStmt(*this, Handler);
3142 }
3143}
3144
3145bool Sema::CheckOverridingFunctionReturnType(const CXXMethodDecl *New,
3146 const CXXMethodDecl *Old) {
3147 QualType NewTy = New->getType()->getAsFunctionType()->getResultType();
3148 QualType OldTy = Old->getType()->getAsFunctionType()->getResultType();
3149
3150 QualType CNewTy = Context.getCanonicalType(NewTy);
3151 QualType COldTy = Context.getCanonicalType(OldTy);
3152
3153 if (CNewTy == COldTy &&
3154 CNewTy.getCVRQualifiers() == COldTy.getCVRQualifiers())
3155 return false;
3156
3157 // Check if the return types are covariant
3158 QualType NewClassTy, OldClassTy;
3159
3160 /// Both types must be pointers or references to classes.
3161 if (PointerType *NewPT = dyn_cast<PointerType>(NewTy)) {
3162 if (PointerType *OldPT = dyn_cast<PointerType>(OldTy)) {
3163 NewClassTy = NewPT->getPointeeType();
3164 OldClassTy = OldPT->getPointeeType();
3165 }
3166 } else if (ReferenceType *NewRT = dyn_cast<ReferenceType>(NewTy)) {
3167 if (ReferenceType *OldRT = dyn_cast<ReferenceType>(OldTy)) {
3168 NewClassTy = NewRT->getPointeeType();
3169 OldClassTy = OldRT->getPointeeType();
3170 }
3171 }
3172
3173 // The return types aren't either both pointers or references to a class type.
3174 if (NewClassTy.isNull()) {
3175 Diag(New->getLocation(),
3176 diag::err_different_return_type_for_overriding_virtual_function)
3177 << New->getDeclName() << NewTy << OldTy;
3178 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
3179
3180 return true;
3181 }
3182
3183 if (NewClassTy.getUnqualifiedType() != OldClassTy.getUnqualifiedType()) {
3184 // Check if the new class derives from the old class.
3185 if (!IsDerivedFrom(NewClassTy, OldClassTy)) {
3186 Diag(New->getLocation(),
3187 diag::err_covariant_return_not_derived)
3188 << New->getDeclName() << NewTy << OldTy;
3189 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
3190 return true;
3191 }
3192
3193 // Check if we the conversion from derived to base is valid.
3194 if (CheckDerivedToBaseConversion(NewClassTy, OldClassTy,
3195 diag::err_covariant_return_inaccessible_base,
3196 diag::err_covariant_return_ambiguous_derived_to_base_conv,
3197 // FIXME: Should this point to the return type?
3198 New->getLocation(), SourceRange(), New->getDeclName())) {
3199 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
3200 return true;
3201 }
3202 }
3203
3204 // The qualifiers of the return types must be the same.
3205 if (CNewTy.getCVRQualifiers() != COldTy.getCVRQualifiers()) {
3206 Diag(New->getLocation(),
3207 diag::err_covariant_return_type_different_qualifications)
3208 << New->getDeclName() << NewTy << OldTy;
3209 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
3210 return true;
3211 };
3212
3213
3214 // The new class type must have the same or less qualifiers as the old type.
3215 if (NewClassTy.isMoreQualifiedThan(OldClassTy)) {
3216 Diag(New->getLocation(),
3217 diag::err_covariant_return_type_class_type_more_qualified)
3218 << New->getDeclName() << NewTy << OldTy;
3219 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
3220 return true;
3221 };
3222
3223 return false;
3224}
3225
3226/// ActOnCXXEnterDeclInitializer - Invoked when we are about to parse an
3227/// initializer for the declaration 'Dcl'.
3228/// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
3229/// static data member of class X, names should be looked up in the scope of
3230/// class X.
3231void Sema::ActOnCXXEnterDeclInitializer(Scope *S, DeclPtrTy Dcl) {
3232 Decl *D = Dcl.getAs<Decl>();
3233 // If there is no declaration, there was an error parsing it.
3234 if (D == 0)
3235 return;
3236
3237 // Check whether it is a declaration with a nested name specifier like
3238 // int foo::bar;
3239 if (!D->isOutOfLine())
3240 return;
3241
3242 // C++ [basic.lookup.unqual]p13
3243 //
3244 // A name used in the definition of a static data member of class X
3245 // (after the qualified-id of the static member) is looked up as if the name
3246 // was used in a member function of X.
3247
3248 // Change current context into the context of the initializing declaration.
3249 EnterDeclaratorContext(S, D->getDeclContext());
3250}
3251
3252/// ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an
3253/// initializer for the declaration 'Dcl'.
3254void Sema::ActOnCXXExitDeclInitializer(Scope *S, DeclPtrTy Dcl) {
3255 Decl *D = Dcl.getAs<Decl>();
3256 // If there is no declaration, there was an error parsing it.
3257 if (D == 0)
3258 return;
3259
3260 // Check whether it is a declaration with a nested name specifier like
3261 // int foo::bar;
3262 if (!D->isOutOfLine())
3263 return;
3264
3265 assert(S->getEntity() == D->getDeclContext() && "Context imbalance!");
3266 ExitDeclaratorContext(S);
3267}