1 //===------ SemaDeclCXX.cpp - Semantic Analysis for C++ Declarations ------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements semantic analysis for C++ declarations.
12 //===----------------------------------------------------------------------===//
17 #include "clang/AST/ASTConsumer.h"
18 #include "clang/AST/ASTContext.h"
19 #include "clang/AST/RecordLayout.h"
20 #include "clang/AST/CXXInheritance.h"
21 #include "clang/AST/DeclVisitor.h"
22 #include "clang/AST/TypeLoc.h"
23 #include "clang/AST/TypeOrdering.h"
24 #include "clang/AST/StmtVisitor.h"
25 #include "clang/Parse/DeclSpec.h"
26 #include "clang/Parse/Template.h"
27 #include "clang/Basic/PartialDiagnostic.h"
28 #include "clang/Lex/Preprocessor.h"
29 #include "llvm/ADT/STLExtras.h"
33 using namespace clang;
35 //===----------------------------------------------------------------------===//
36 // CheckDefaultArgumentVisitor
37 //===----------------------------------------------------------------------===//
40 /// CheckDefaultArgumentVisitor - C++ [dcl.fct.default] Traverses
41 /// the default argument of a parameter to determine whether it
42 /// contains any ill-formed subexpressions. For example, this will
43 /// diagnose the use of local variables or parameters within the
44 /// default argument expression.
45 class CheckDefaultArgumentVisitor
46 : public StmtVisitor<CheckDefaultArgumentVisitor, bool> {
51 CheckDefaultArgumentVisitor(Expr *defarg, Sema *s)
52 : DefaultArg(defarg), S(s) {}
54 bool VisitExpr(Expr *Node);
55 bool VisitDeclRefExpr(DeclRefExpr *DRE);
56 bool VisitCXXThisExpr(CXXThisExpr *ThisE);
59 /// VisitExpr - Visit all of the children of this expression.
60 bool CheckDefaultArgumentVisitor::VisitExpr(Expr *Node) {
61 bool IsInvalid = false;
62 for (Stmt::child_iterator I = Node->child_begin(),
63 E = Node->child_end(); I != E; ++I)
64 IsInvalid |= Visit(*I);
68 /// VisitDeclRefExpr - Visit a reference to a declaration, to
69 /// determine whether this declaration can be used in the default
70 /// argument expression.
71 bool CheckDefaultArgumentVisitor::VisitDeclRefExpr(DeclRefExpr *DRE) {
72 NamedDecl *Decl = DRE->getDecl();
73 if (ParmVarDecl *Param = dyn_cast<ParmVarDecl>(Decl)) {
74 // C++ [dcl.fct.default]p9
75 // Default arguments are evaluated each time the function is
76 // called. The order of evaluation of function arguments is
77 // unspecified. Consequently, parameters of a function shall not
78 // be used in default argument expressions, even if they are not
79 // evaluated. Parameters of a function declared before a default
80 // argument expression are in scope and can hide namespace and
81 // class member names.
82 return S->Diag(DRE->getSourceRange().getBegin(),
83 diag::err_param_default_argument_references_param)
84 << Param->getDeclName() << DefaultArg->getSourceRange();
85 } else if (VarDecl *VDecl = dyn_cast<VarDecl>(Decl)) {
86 // C++ [dcl.fct.default]p7
87 // Local variables shall not be used in default argument
89 if (VDecl->isBlockVarDecl())
90 return S->Diag(DRE->getSourceRange().getBegin(),
91 diag::err_param_default_argument_references_local)
92 << VDecl->getDeclName() << DefaultArg->getSourceRange();
98 /// VisitCXXThisExpr - Visit a C++ "this" expression.
99 bool CheckDefaultArgumentVisitor::VisitCXXThisExpr(CXXThisExpr *ThisE) {
100 // C++ [dcl.fct.default]p8:
101 // The keyword this shall not be used in a default argument of a
103 return S->Diag(ThisE->getSourceRange().getBegin(),
104 diag::err_param_default_argument_references_this)
105 << ThisE->getSourceRange();
110 Sema::SetParamDefaultArgument(ParmVarDecl *Param, ExprArg DefaultArg,
111 SourceLocation EqualLoc) {
112 if (RequireCompleteType(Param->getLocation(), Param->getType(),
113 diag::err_typecheck_decl_incomplete_type)) {
114 Param->setInvalidDecl();
118 Expr *Arg = (Expr *)DefaultArg.get();
120 // C++ [dcl.fct.default]p5
121 // A default argument expression is implicitly converted (clause
122 // 4) to the parameter type. The default argument expression has
123 // the same semantic constraints as the initializer expression in
124 // a declaration of a variable of the parameter type, using the
125 // copy-initialization semantics (8.5).
126 InitializedEntity Entity = InitializedEntity::InitializeParameter(Param);
127 InitializationKind Kind = InitializationKind::CreateCopy(Param->getLocation(),
129 InitializationSequence InitSeq(*this, Entity, Kind, &Arg, 1);
130 OwningExprResult Result = InitSeq.Perform(*this, Entity, Kind,
131 MultiExprArg(*this, (void**)&Arg, 1));
132 if (Result.isInvalid())
134 Arg = Result.takeAs<Expr>();
136 Arg = MaybeCreateCXXExprWithTemporaries(Arg);
138 // Okay: add the default argument to the parameter
139 Param->setDefaultArg(Arg);
141 DefaultArg.release();
146 /// ActOnParamDefaultArgument - Check whether the default argument
147 /// provided for a function parameter is well-formed. If so, attach it
148 /// to the parameter declaration.
150 Sema::ActOnParamDefaultArgument(DeclPtrTy param, SourceLocation EqualLoc,
152 if (!param || !defarg.get())
155 ParmVarDecl *Param = cast<ParmVarDecl>(param.getAs<Decl>());
156 UnparsedDefaultArgLocs.erase(Param);
158 ExprOwningPtr<Expr> DefaultArg(this, defarg.takeAs<Expr>());
160 // Default arguments are only permitted in C++
161 if (!getLangOptions().CPlusPlus) {
162 Diag(EqualLoc, diag::err_param_default_argument)
163 << DefaultArg->getSourceRange();
164 Param->setInvalidDecl();
168 // Check that the default argument is well-formed
169 CheckDefaultArgumentVisitor DefaultArgChecker(DefaultArg.get(), this);
170 if (DefaultArgChecker.Visit(DefaultArg.get())) {
171 Param->setInvalidDecl();
175 SetParamDefaultArgument(Param, move(DefaultArg), EqualLoc);
178 /// ActOnParamUnparsedDefaultArgument - We've seen a default
179 /// argument for a function parameter, but we can't parse it yet
180 /// because we're inside a class definition. Note that this default
181 /// argument will be parsed later.
182 void Sema::ActOnParamUnparsedDefaultArgument(DeclPtrTy param,
183 SourceLocation EqualLoc,
184 SourceLocation ArgLoc) {
188 ParmVarDecl *Param = cast<ParmVarDecl>(param.getAs<Decl>());
190 Param->setUnparsedDefaultArg();
192 UnparsedDefaultArgLocs[Param] = ArgLoc;
195 /// ActOnParamDefaultArgumentError - Parsing or semantic analysis of
196 /// the default argument for the parameter param failed.
197 void Sema::ActOnParamDefaultArgumentError(DeclPtrTy param) {
201 ParmVarDecl *Param = cast<ParmVarDecl>(param.getAs<Decl>());
203 Param->setInvalidDecl();
205 UnparsedDefaultArgLocs.erase(Param);
208 /// CheckExtraCXXDefaultArguments - Check for any extra default
209 /// arguments in the declarator, which is not a function declaration
210 /// or definition and therefore is not permitted to have default
211 /// arguments. This routine should be invoked for every declarator
212 /// that is not a function declaration or definition.
213 void Sema::CheckExtraCXXDefaultArguments(Declarator &D) {
214 // C++ [dcl.fct.default]p3
215 // A default argument expression shall be specified only in the
216 // parameter-declaration-clause of a function declaration or in a
217 // template-parameter (14.1). It shall not be specified for a
218 // parameter pack. If it is specified in a
219 // parameter-declaration-clause, it shall not occur within a
220 // declarator or abstract-declarator of a parameter-declaration.
221 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
222 DeclaratorChunk &chunk = D.getTypeObject(i);
223 if (chunk.Kind == DeclaratorChunk::Function) {
224 for (unsigned argIdx = 0, e = chunk.Fun.NumArgs; argIdx != e; ++argIdx) {
226 cast<ParmVarDecl>(chunk.Fun.ArgInfo[argIdx].Param.getAs<Decl>());
227 if (Param->hasUnparsedDefaultArg()) {
228 CachedTokens *Toks = chunk.Fun.ArgInfo[argIdx].DefaultArgTokens;
229 Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
230 << SourceRange((*Toks)[1].getLocation(), Toks->back().getLocation());
232 chunk.Fun.ArgInfo[argIdx].DefaultArgTokens = 0;
233 } else if (Param->getDefaultArg()) {
234 Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
235 << Param->getDefaultArg()->getSourceRange();
236 Param->setDefaultArg(0);
243 // MergeCXXFunctionDecl - Merge two declarations of the same C++
244 // function, once we already know that they have the same
245 // type. Subroutine of MergeFunctionDecl. Returns true if there was an
246 // error, false otherwise.
247 bool Sema::MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old) {
248 bool Invalid = false;
250 // C++ [dcl.fct.default]p4:
251 // For non-template functions, default arguments can be added in
252 // later declarations of a function in the same
253 // scope. Declarations in different scopes have completely
254 // distinct sets of default arguments. That is, declarations in
255 // inner scopes do not acquire default arguments from
256 // declarations in outer scopes, and vice versa. In a given
257 // function declaration, all parameters subsequent to a
258 // parameter with a default argument shall have default
259 // arguments supplied in this or previous declarations. A
260 // default argument shall not be redefined by a later
261 // declaration (not even to the same value).
263 // C++ [dcl.fct.default]p6:
264 // Except for member functions of class templates, the default arguments
265 // in a member function definition that appears outside of the class
266 // definition are added to the set of default arguments provided by the
267 // member function declaration in the class definition.
268 for (unsigned p = 0, NumParams = Old->getNumParams(); p < NumParams; ++p) {
269 ParmVarDecl *OldParam = Old->getParamDecl(p);
270 ParmVarDecl *NewParam = New->getParamDecl(p);
272 if (OldParam->hasDefaultArg() && NewParam->hasDefaultArg()) {
273 // FIXME: If we knew where the '=' was, we could easily provide a fix-it
274 // hint here. Alternatively, we could walk the type-source information
275 // for NewParam to find the last source location in the type... but it
276 // isn't worth the effort right now. This is the kind of test case that
277 // is hard to get right:
280 // void g(int (*fp)(int) = f);
281 // void g(int (*fp)(int) = &f);
282 Diag(NewParam->getLocation(),
283 diag::err_param_default_argument_redefinition)
284 << NewParam->getDefaultArgRange();
286 // Look for the function declaration where the default argument was
287 // actually written, which may be a declaration prior to Old.
288 for (FunctionDecl *Older = Old->getPreviousDeclaration();
289 Older; Older = Older->getPreviousDeclaration()) {
290 if (!Older->getParamDecl(p)->hasDefaultArg())
293 OldParam = Older->getParamDecl(p);
296 Diag(OldParam->getLocation(), diag::note_previous_definition)
297 << OldParam->getDefaultArgRange();
299 } else if (OldParam->hasDefaultArg()) {
300 // Merge the old default argument into the new parameter
301 NewParam->setHasInheritedDefaultArg();
302 if (OldParam->hasUninstantiatedDefaultArg())
303 NewParam->setUninstantiatedDefaultArg(
304 OldParam->getUninstantiatedDefaultArg());
306 NewParam->setDefaultArg(OldParam->getDefaultArg());
307 } else if (NewParam->hasDefaultArg()) {
308 if (New->getDescribedFunctionTemplate()) {
309 // Paragraph 4, quoted above, only applies to non-template functions.
310 Diag(NewParam->getLocation(),
311 diag::err_param_default_argument_template_redecl)
312 << NewParam->getDefaultArgRange();
313 Diag(Old->getLocation(), diag::note_template_prev_declaration)
315 } else if (New->getTemplateSpecializationKind()
316 != TSK_ImplicitInstantiation &&
317 New->getTemplateSpecializationKind() != TSK_Undeclared) {
318 // C++ [temp.expr.spec]p21:
319 // Default function arguments shall not be specified in a declaration
320 // or a definition for one of the following explicit specializations:
321 // - the explicit specialization of a function template;
322 // - the explicit specialization of a member function template;
323 // - the explicit specialization of a member function of a class
324 // template where the class template specialization to which the
325 // member function specialization belongs is implicitly
327 Diag(NewParam->getLocation(), diag::err_template_spec_default_arg)
328 << (New->getTemplateSpecializationKind() ==TSK_ExplicitSpecialization)
329 << New->getDeclName()
330 << NewParam->getDefaultArgRange();
331 } else if (New->getDeclContext()->isDependentContext()) {
332 // C++ [dcl.fct.default]p6 (DR217):
333 // Default arguments for a member function of a class template shall
334 // be specified on the initial declaration of the member function
335 // within the class template.
337 // Reading the tea leaves a bit in DR217 and its reference to DR205
338 // leads me to the conclusion that one cannot add default function
339 // arguments for an out-of-line definition of a member function of a
342 if (CXXRecordDecl *Record
343 = dyn_cast<CXXRecordDecl>(New->getDeclContext())) {
344 if (Record->getDescribedClassTemplate())
346 else if (isa<ClassTemplatePartialSpecializationDecl>(Record))
352 Diag(NewParam->getLocation(),
353 diag::err_param_default_argument_member_template_redecl)
355 << NewParam->getDefaultArgRange();
360 if (CheckEquivalentExceptionSpec(Old, New))
366 /// CheckCXXDefaultArguments - Verify that the default arguments for a
367 /// function declaration are well-formed according to C++
368 /// [dcl.fct.default].
369 void Sema::CheckCXXDefaultArguments(FunctionDecl *FD) {
370 unsigned NumParams = FD->getNumParams();
373 // Find first parameter with a default argument
374 for (p = 0; p < NumParams; ++p) {
375 ParmVarDecl *Param = FD->getParamDecl(p);
376 if (Param->hasDefaultArg())
380 // C++ [dcl.fct.default]p4:
381 // In a given function declaration, all parameters
382 // subsequent to a parameter with a default argument shall
383 // have default arguments supplied in this or previous
384 // declarations. A default argument shall not be redefined
385 // by a later declaration (not even to the same value).
386 unsigned LastMissingDefaultArg = 0;
387 for (; p < NumParams; ++p) {
388 ParmVarDecl *Param = FD->getParamDecl(p);
389 if (!Param->hasDefaultArg()) {
390 if (Param->isInvalidDecl())
391 /* We already complained about this parameter. */;
392 else if (Param->getIdentifier())
393 Diag(Param->getLocation(),
394 diag::err_param_default_argument_missing_name)
395 << Param->getIdentifier();
397 Diag(Param->getLocation(),
398 diag::err_param_default_argument_missing);
400 LastMissingDefaultArg = p;
404 if (LastMissingDefaultArg > 0) {
405 // Some default arguments were missing. Clear out all of the
406 // default arguments up to (and including) the last missing
407 // default argument, so that we leave the function parameters
408 // in a semantically valid state.
409 for (p = 0; p <= LastMissingDefaultArg; ++p) {
410 ParmVarDecl *Param = FD->getParamDecl(p);
411 if (Param->hasDefaultArg()) {
412 if (!Param->hasUnparsedDefaultArg())
413 Param->getDefaultArg()->Destroy(Context);
414 Param->setDefaultArg(0);
420 /// isCurrentClassName - Determine whether the identifier II is the
421 /// name of the class type currently being defined. In the case of
422 /// nested classes, this will only return true if II is the name of
423 /// the innermost class.
424 bool Sema::isCurrentClassName(const IdentifierInfo &II, Scope *,
425 const CXXScopeSpec *SS) {
426 assert(getLangOptions().CPlusPlus && "No class names in C!");
428 CXXRecordDecl *CurDecl;
429 if (SS && SS->isSet() && !SS->isInvalid()) {
430 DeclContext *DC = computeDeclContext(*SS, true);
431 CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC);
433 CurDecl = dyn_cast_or_null<CXXRecordDecl>(CurContext);
435 if (CurDecl && CurDecl->getIdentifier())
436 return &II == CurDecl->getIdentifier();
441 /// \brief Check the validity of a C++ base class specifier.
443 /// \returns a new CXXBaseSpecifier if well-formed, emits diagnostics
444 /// and returns NULL otherwise.
446 Sema::CheckBaseSpecifier(CXXRecordDecl *Class,
447 SourceRange SpecifierRange,
448 bool Virtual, AccessSpecifier Access,
450 SourceLocation BaseLoc) {
451 // C++ [class.union]p1:
452 // A union shall not have base classes.
453 if (Class->isUnion()) {
454 Diag(Class->getLocation(), diag::err_base_clause_on_union)
459 if (BaseType->isDependentType())
460 return new (Context) CXXBaseSpecifier(SpecifierRange, Virtual,
461 Class->getTagKind() == RecordDecl::TK_class,
464 // Base specifiers must be record types.
465 if (!BaseType->isRecordType()) {
466 Diag(BaseLoc, diag::err_base_must_be_class) << SpecifierRange;
470 // C++ [class.union]p1:
471 // A union shall not be used as a base class.
472 if (BaseType->isUnionType()) {
473 Diag(BaseLoc, diag::err_union_as_base_class) << SpecifierRange;
477 // C++ [class.derived]p2:
478 // The class-name in a base-specifier shall not be an incompletely
480 if (RequireCompleteType(BaseLoc, BaseType,
481 PDiag(diag::err_incomplete_base_class)
485 // If the base class is polymorphic or isn't empty, the new one is/isn't, too.
486 RecordDecl *BaseDecl = BaseType->getAs<RecordType>()->getDecl();
487 assert(BaseDecl && "Record type has no declaration");
488 BaseDecl = BaseDecl->getDefinition();
489 assert(BaseDecl && "Base type is not incomplete, but has no definition");
490 CXXRecordDecl * CXXBaseDecl = cast<CXXRecordDecl>(BaseDecl);
491 assert(CXXBaseDecl && "Base type is not a C++ type");
493 // C++0x CWG Issue #817 indicates that [[final]] classes shouldn't be bases.
494 if (CXXBaseDecl->hasAttr<FinalAttr>()) {
495 Diag(BaseLoc, diag::err_final_base) << BaseType.getAsString();
496 Diag(CXXBaseDecl->getLocation(), diag::note_previous_decl)
501 SetClassDeclAttributesFromBase(Class, CXXBaseDecl, Virtual);
503 // Create the base specifier.
504 // FIXME: Allocate via ASTContext?
505 return new (Context) CXXBaseSpecifier(SpecifierRange, Virtual,
506 Class->getTagKind() == RecordDecl::TK_class,
510 void Sema::SetClassDeclAttributesFromBase(CXXRecordDecl *Class,
511 const CXXRecordDecl *BaseClass,
512 bool BaseIsVirtual) {
513 // A class with a non-empty base class is not empty.
514 // FIXME: Standard ref?
515 if (!BaseClass->isEmpty())
516 Class->setEmpty(false);
518 // C++ [class.virtual]p1:
519 // A class that [...] inherits a virtual function is called a polymorphic
521 if (BaseClass->isPolymorphic())
522 Class->setPolymorphic(true);
524 // C++ [dcl.init.aggr]p1:
525 // An aggregate is [...] a class with [...] no base classes [...].
526 Class->setAggregate(false);
529 // A POD-struct is an aggregate class...
530 Class->setPOD(false);
533 // C++ [class.ctor]p5:
534 // A constructor is trivial if its class has no virtual base classes.
535 Class->setHasTrivialConstructor(false);
537 // C++ [class.copy]p6:
538 // A copy constructor is trivial if its class has no virtual base classes.
539 Class->setHasTrivialCopyConstructor(false);
541 // C++ [class.copy]p11:
542 // A copy assignment operator is trivial if its class has no virtual
544 Class->setHasTrivialCopyAssignment(false);
546 // C++0x [meta.unary.prop] is_empty:
547 // T is a class type, but not a union type, with ... no virtual base
549 Class->setEmpty(false);
551 // C++ [class.ctor]p5:
552 // A constructor is trivial if all the direct base classes of its
553 // class have trivial constructors.
554 if (!BaseClass->hasTrivialConstructor())
555 Class->setHasTrivialConstructor(false);
557 // C++ [class.copy]p6:
558 // A copy constructor is trivial if all the direct base classes of its
559 // class have trivial copy constructors.
560 if (!BaseClass->hasTrivialCopyConstructor())
561 Class->setHasTrivialCopyConstructor(false);
563 // C++ [class.copy]p11:
564 // A copy assignment operator is trivial if all the direct base classes
565 // of its class have trivial copy assignment operators.
566 if (!BaseClass->hasTrivialCopyAssignment())
567 Class->setHasTrivialCopyAssignment(false);
570 // C++ [class.ctor]p3:
571 // A destructor is trivial if all the direct base classes of its class
572 // have trivial destructors.
573 if (!BaseClass->hasTrivialDestructor())
574 Class->setHasTrivialDestructor(false);
577 /// ActOnBaseSpecifier - Parsed a base specifier. A base specifier is
578 /// one entry in the base class list of a class specifier, for
580 /// class foo : public bar, virtual private baz {
581 /// 'public bar' and 'virtual private baz' are each base-specifiers.
583 Sema::ActOnBaseSpecifier(DeclPtrTy classdecl, SourceRange SpecifierRange,
584 bool Virtual, AccessSpecifier Access,
585 TypeTy *basetype, SourceLocation BaseLoc) {
589 AdjustDeclIfTemplate(classdecl);
590 CXXRecordDecl *Class = dyn_cast<CXXRecordDecl>(classdecl.getAs<Decl>());
594 QualType BaseType = GetTypeFromParser(basetype);
595 if (CXXBaseSpecifier *BaseSpec = CheckBaseSpecifier(Class, SpecifierRange,
603 /// \brief Performs the actual work of attaching the given base class
604 /// specifiers to a C++ class.
605 bool Sema::AttachBaseSpecifiers(CXXRecordDecl *Class, CXXBaseSpecifier **Bases,
610 // Used to keep track of which base types we have already seen, so
611 // that we can properly diagnose redundant direct base types. Note
612 // that the key is always the unqualified canonical type of the base
614 std::map<QualType, CXXBaseSpecifier*, QualTypeOrdering> KnownBaseTypes;
616 // Copy non-redundant base specifiers into permanent storage.
617 unsigned NumGoodBases = 0;
618 bool Invalid = false;
619 for (unsigned idx = 0; idx < NumBases; ++idx) {
621 = Context.getCanonicalType(Bases[idx]->getType());
622 NewBaseType = NewBaseType.getLocalUnqualifiedType();
624 if (KnownBaseTypes[NewBaseType]) {
626 // A class shall not be specified as a direct base class of a
627 // derived class more than once.
628 Diag(Bases[idx]->getSourceRange().getBegin(),
629 diag::err_duplicate_base_class)
630 << KnownBaseTypes[NewBaseType]->getType()
631 << Bases[idx]->getSourceRange();
633 // Delete the duplicate base class specifier; we're going to
634 // overwrite its pointer later.
635 Context.Deallocate(Bases[idx]);
639 // Okay, add this new base class.
640 KnownBaseTypes[NewBaseType] = Bases[idx];
641 Bases[NumGoodBases++] = Bases[idx];
645 // Attach the remaining base class specifiers to the derived class.
646 Class->setBases(Bases, NumGoodBases);
648 // Delete the remaining (good) base class specifiers, since their
649 // data has been copied into the CXXRecordDecl.
650 for (unsigned idx = 0; idx < NumGoodBases; ++idx)
651 Context.Deallocate(Bases[idx]);
656 /// ActOnBaseSpecifiers - Attach the given base specifiers to the
657 /// class, after checking whether there are any duplicate base
659 void Sema::ActOnBaseSpecifiers(DeclPtrTy ClassDecl, BaseTy **Bases,
661 if (!ClassDecl || !Bases || !NumBases)
664 AdjustDeclIfTemplate(ClassDecl);
665 AttachBaseSpecifiers(cast<CXXRecordDecl>(ClassDecl.getAs<Decl>()),
666 (CXXBaseSpecifier**)(Bases), NumBases);
669 static CXXRecordDecl *GetClassForType(QualType T) {
670 if (const RecordType *RT = T->getAs<RecordType>())
671 return cast<CXXRecordDecl>(RT->getDecl());
672 else if (const InjectedClassNameType *ICT = T->getAs<InjectedClassNameType>())
673 return ICT->getDecl();
678 /// \brief Determine whether the type \p Derived is a C++ class that is
679 /// derived from the type \p Base.
680 bool Sema::IsDerivedFrom(QualType Derived, QualType Base) {
681 if (!getLangOptions().CPlusPlus)
684 CXXRecordDecl *DerivedRD = GetClassForType(Derived);
688 CXXRecordDecl *BaseRD = GetClassForType(Base);
692 // FIXME: instantiate DerivedRD if necessary. We need a PoI for this.
693 return DerivedRD->hasDefinition() && DerivedRD->isDerivedFrom(BaseRD);
696 /// \brief Determine whether the type \p Derived is a C++ class that is
697 /// derived from the type \p Base.
698 bool Sema::IsDerivedFrom(QualType Derived, QualType Base, CXXBasePaths &Paths) {
699 if (!getLangOptions().CPlusPlus)
702 CXXRecordDecl *DerivedRD = GetClassForType(Derived);
706 CXXRecordDecl *BaseRD = GetClassForType(Base);
710 return DerivedRD->isDerivedFrom(BaseRD, Paths);
713 /// CheckDerivedToBaseConversion - Check whether the Derived-to-Base
714 /// conversion (where Derived and Base are class types) is
715 /// well-formed, meaning that the conversion is unambiguous (and
716 /// that all of the base classes are accessible). Returns true
717 /// and emits a diagnostic if the code is ill-formed, returns false
718 /// otherwise. Loc is the location where this routine should point to
719 /// if there is an error, and Range is the source range to highlight
720 /// if there is an error.
722 Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base,
723 unsigned InaccessibleBaseID,
724 unsigned AmbigiousBaseConvID,
725 SourceLocation Loc, SourceRange Range,
726 DeclarationName Name) {
727 // First, determine whether the path from Derived to Base is
728 // ambiguous. This is slightly more expensive than checking whether
729 // the Derived to Base conversion exists, because here we need to
730 // explore multiple paths to determine if there is an ambiguity.
731 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
732 /*DetectVirtual=*/false);
733 bool DerivationOkay = IsDerivedFrom(Derived, Base, Paths);
734 assert(DerivationOkay &&
735 "Can only be used with a derived-to-base conversion");
736 (void)DerivationOkay;
738 if (!Paths.isAmbiguous(Context.getCanonicalType(Base).getUnqualifiedType())) {
739 if (!InaccessibleBaseID)
742 // Check that the base class can be accessed.
743 switch (CheckBaseClassAccess(Loc, Base, Derived, Paths.front(),
744 InaccessibleBaseID)) {
745 case AR_accessible: return false;
746 case AR_inaccessible: return true;
747 case AR_dependent: return false;
748 case AR_delayed: return false;
752 // We know that the derived-to-base conversion is ambiguous, and
753 // we're going to produce a diagnostic. Perform the derived-to-base
754 // search just one more time to compute all of the possible paths so
755 // that we can print them out. This is more expensive than any of
756 // the previous derived-to-base checks we've done, but at this point
757 // performance isn't as much of an issue.
759 Paths.setRecordingPaths(true);
760 bool StillOkay = IsDerivedFrom(Derived, Base, Paths);
761 assert(StillOkay && "Can only be used with a derived-to-base conversion");
764 // Build up a textual representation of the ambiguous paths, e.g.,
765 // D -> B -> A, that will be used to illustrate the ambiguous
766 // conversions in the diagnostic. We only print one of the paths
767 // to each base class subobject.
768 std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
770 Diag(Loc, AmbigiousBaseConvID)
771 << Derived << Base << PathDisplayStr << Range << Name;
776 Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base,
777 SourceLocation Loc, SourceRange Range,
779 return CheckDerivedToBaseConversion(Derived, Base,
781 : diag::err_upcast_to_inaccessible_base,
782 diag::err_ambiguous_derived_to_base_conv,
783 Loc, Range, DeclarationName());
787 /// @brief Builds a string representing ambiguous paths from a
788 /// specific derived class to different subobjects of the same base
791 /// This function builds a string that can be used in error messages
792 /// to show the different paths that one can take through the
793 /// inheritance hierarchy to go from the derived class to different
794 /// subobjects of a base class. The result looks something like this:
796 /// struct D -> struct B -> struct A
797 /// struct D -> struct C -> struct A
799 std::string Sema::getAmbiguousPathsDisplayString(CXXBasePaths &Paths) {
800 std::string PathDisplayStr;
801 std::set<unsigned> DisplayedPaths;
802 for (CXXBasePaths::paths_iterator Path = Paths.begin();
803 Path != Paths.end(); ++Path) {
804 if (DisplayedPaths.insert(Path->back().SubobjectNumber).second) {
805 // We haven't displayed a path to this particular base
806 // class subobject yet.
807 PathDisplayStr += "\n ";
808 PathDisplayStr += Context.getTypeDeclType(Paths.getOrigin()).getAsString();
809 for (CXXBasePath::const_iterator Element = Path->begin();
810 Element != Path->end(); ++Element)
811 PathDisplayStr += " -> " + Element->Base->getType().getAsString();
815 return PathDisplayStr;
818 //===----------------------------------------------------------------------===//
819 // C++ class member Handling
820 //===----------------------------------------------------------------------===//
822 /// ActOnCXXMemberDeclarator - This is invoked when a C++ class member
823 /// declarator is parsed. 'AS' is the access specifier, 'BW' specifies the
824 /// bitfield width if there is one and 'InitExpr' specifies the initializer if
827 Sema::ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS, Declarator &D,
828 MultiTemplateParamsArg TemplateParameterLists,
829 ExprTy *BW, ExprTy *InitExpr, bool IsDefinition,
831 const DeclSpec &DS = D.getDeclSpec();
832 DeclarationName Name = GetNameForDeclarator(D);
833 Expr *BitWidth = static_cast<Expr*>(BW);
834 Expr *Init = static_cast<Expr*>(InitExpr);
835 SourceLocation Loc = D.getIdentifierLoc();
837 bool isFunc = D.isFunctionDeclarator();
839 assert(!DS.isFriendSpecified());
841 // C++ 9.2p6: A member shall not be declared to have automatic storage
842 // duration (auto, register) or with the extern storage-class-specifier.
843 // C++ 7.1.1p8: The mutable specifier can be applied only to names of class
844 // data members and cannot be applied to names declared const or static,
845 // and cannot be applied to reference members.
846 switch (DS.getStorageClassSpec()) {
847 case DeclSpec::SCS_unspecified:
848 case DeclSpec::SCS_typedef:
849 case DeclSpec::SCS_static:
852 case DeclSpec::SCS_mutable:
854 if (DS.getStorageClassSpecLoc().isValid())
855 Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_function);
857 Diag(DS.getThreadSpecLoc(), diag::err_mutable_function);
859 // FIXME: It would be nicer if the keyword was ignored only for this
860 // declarator. Otherwise we could get follow-up errors.
861 D.getMutableDeclSpec().ClearStorageClassSpecs();
863 QualType T = GetTypeForDeclarator(D, S);
864 diag::kind err = static_cast<diag::kind>(0);
865 if (T->isReferenceType())
866 err = diag::err_mutable_reference;
867 else if (T.isConstQualified())
868 err = diag::err_mutable_const;
870 if (DS.getStorageClassSpecLoc().isValid())
871 Diag(DS.getStorageClassSpecLoc(), err);
873 Diag(DS.getThreadSpecLoc(), err);
874 // FIXME: It would be nicer if the keyword was ignored only for this
875 // declarator. Otherwise we could get follow-up errors.
876 D.getMutableDeclSpec().ClearStorageClassSpecs();
881 if (DS.getStorageClassSpecLoc().isValid())
882 Diag(DS.getStorageClassSpecLoc(),
883 diag::err_storageclass_invalid_for_member);
885 Diag(DS.getThreadSpecLoc(), diag::err_storageclass_invalid_for_member);
886 D.getMutableDeclSpec().ClearStorageClassSpecs();
890 D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_typename &&
891 D.getNumTypeObjects() == 0) {
892 // Check also for this case:
897 QualType TDType = GetTypeFromParser(DS.getTypeRep());
898 isFunc = TDType->isFunctionType();
901 bool isInstField = ((DS.getStorageClassSpec() == DeclSpec::SCS_unspecified ||
902 DS.getStorageClassSpec() == DeclSpec::SCS_mutable) &&
907 // FIXME: Check for template parameters!
908 Member = HandleField(S, cast<CXXRecordDecl>(CurContext), Loc, D, BitWidth,
910 assert(Member && "HandleField never returns null");
912 Member = HandleDeclarator(S, D, move(TemplateParameterLists), IsDefinition)
915 if (BitWidth) DeleteExpr(BitWidth);
919 // Non-instance-fields can't have a bitfield.
921 if (Member->isInvalidDecl()) {
922 // don't emit another diagnostic.
923 } else if (isa<VarDecl>(Member)) {
924 // C++ 9.6p3: A bit-field shall not be a static member.
925 // "static member 'A' cannot be a bit-field"
926 Diag(Loc, diag::err_static_not_bitfield)
927 << Name << BitWidth->getSourceRange();
928 } else if (isa<TypedefDecl>(Member)) {
929 // "typedef member 'x' cannot be a bit-field"
930 Diag(Loc, diag::err_typedef_not_bitfield)
931 << Name << BitWidth->getSourceRange();
933 // A function typedef ("typedef int f(); f a;").
934 // C++ 9.6p3: A bit-field shall have integral or enumeration type.
935 Diag(Loc, diag::err_not_integral_type_bitfield)
936 << Name << cast<ValueDecl>(Member)->getType()
937 << BitWidth->getSourceRange();
940 DeleteExpr(BitWidth);
942 Member->setInvalidDecl();
945 Member->setAccess(AS);
947 // If we have declared a member function template, set the access of the
948 // templated declaration as well.
949 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Member))
950 FunTmpl->getTemplatedDecl()->setAccess(AS);
953 assert((Name || isInstField) && "No identifier for non-field ?");
956 AddInitializerToDecl(DeclPtrTy::make(Member), ExprArg(*this, Init), false);
957 if (Deleted) // FIXME: Source location is not very good.
958 SetDeclDeleted(DeclPtrTy::make(Member), D.getSourceRange().getBegin());
961 FieldCollector->Add(cast<FieldDecl>(Member));
964 return DeclPtrTy::make(Member);
967 /// \brief Find the direct and/or virtual base specifiers that
968 /// correspond to the given base type, for use in base initialization
969 /// within a constructor.
970 static bool FindBaseInitializer(Sema &SemaRef,
971 CXXRecordDecl *ClassDecl,
973 const CXXBaseSpecifier *&DirectBaseSpec,
974 const CXXBaseSpecifier *&VirtualBaseSpec) {
975 // First, check for a direct base class.
977 for (CXXRecordDecl::base_class_const_iterator Base
978 = ClassDecl->bases_begin();
979 Base != ClassDecl->bases_end(); ++Base) {
980 if (SemaRef.Context.hasSameUnqualifiedType(BaseType, Base->getType())) {
981 // We found a direct base of this type. That's what we're
983 DirectBaseSpec = &*Base;
988 // Check for a virtual base class.
989 // FIXME: We might be able to short-circuit this if we know in advance that
990 // there are no virtual bases.
992 if (!DirectBaseSpec || !DirectBaseSpec->isVirtual()) {
993 // We haven't found a base yet; search the class hierarchy for a
994 // virtual base class.
995 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
996 /*DetectVirtual=*/false);
997 if (SemaRef.IsDerivedFrom(SemaRef.Context.getTypeDeclType(ClassDecl),
999 for (CXXBasePaths::paths_iterator Path = Paths.begin();
1000 Path != Paths.end(); ++Path) {
1001 if (Path->back().Base->isVirtual()) {
1002 VirtualBaseSpec = Path->back().Base;
1009 return DirectBaseSpec || VirtualBaseSpec;
1012 /// ActOnMemInitializer - Handle a C++ member initializer.
1014 Sema::ActOnMemInitializer(DeclPtrTy ConstructorD,
1016 const CXXScopeSpec &SS,
1017 IdentifierInfo *MemberOrBase,
1018 TypeTy *TemplateTypeTy,
1019 SourceLocation IdLoc,
1020 SourceLocation LParenLoc,
1021 ExprTy **Args, unsigned NumArgs,
1022 SourceLocation *CommaLocs,
1023 SourceLocation RParenLoc) {
1027 AdjustDeclIfTemplate(ConstructorD);
1029 CXXConstructorDecl *Constructor
1030 = dyn_cast<CXXConstructorDecl>(ConstructorD.getAs<Decl>());
1032 // The user wrote a constructor initializer on a function that is
1033 // not a C++ constructor. Ignore the error for now, because we may
1034 // have more member initializers coming; we'll diagnose it just
1035 // once in ActOnMemInitializers.
1039 CXXRecordDecl *ClassDecl = Constructor->getParent();
1041 // C++ [class.base.init]p2:
1042 // Names in a mem-initializer-id are looked up in the scope of the
1043 // constructor’s class and, if not found in that scope, are looked
1044 // up in the scope containing the constructor’s
1045 // definition. [Note: if the constructor’s class contains a member
1046 // with the same name as a direct or virtual base class of the
1047 // class, a mem-initializer-id naming the member or base class and
1048 // composed of a single identifier refers to the class member. A
1049 // mem-initializer-id for the hidden base class may be specified
1050 // using a qualified name. ]
1051 if (!SS.getScopeRep() && !TemplateTypeTy) {
1052 // Look for a member, first.
1053 FieldDecl *Member = 0;
1054 DeclContext::lookup_result Result
1055 = ClassDecl->lookup(MemberOrBase);
1056 if (Result.first != Result.second)
1057 Member = dyn_cast<FieldDecl>(*Result.first);
1059 // FIXME: Handle members of an anonymous union.
1062 return BuildMemberInitializer(Member, (Expr**)Args, NumArgs, IdLoc,
1063 LParenLoc, RParenLoc);
1065 // It didn't name a member, so see if it names a class.
1067 TypeSourceInfo *TInfo = 0;
1069 if (TemplateTypeTy) {
1070 BaseType = GetTypeFromParser(TemplateTypeTy, &TInfo);
1072 LookupResult R(*this, MemberOrBase, IdLoc, LookupOrdinaryName);
1073 LookupParsedName(R, S, &SS);
1075 TypeDecl *TyD = R.getAsSingle<TypeDecl>();
1077 if (R.isAmbiguous()) return true;
1079 if (SS.isSet() && isDependentScopeSpecifier(SS)) {
1080 bool NotUnknownSpecialization = false;
1081 DeclContext *DC = computeDeclContext(SS, false);
1082 if (CXXRecordDecl *Record = dyn_cast_or_null<CXXRecordDecl>(DC))
1083 NotUnknownSpecialization = !Record->hasAnyDependentBases();
1085 if (!NotUnknownSpecialization) {
1086 // When the scope specifier can refer to a member of an unknown
1087 // specialization, we take it as a type name.
1088 BaseType = CheckTypenameType((NestedNameSpecifier *)SS.getScopeRep(),
1089 *MemberOrBase, SS.getRange());
1090 if (BaseType.isNull())
1097 // If no results were found, try to correct typos.
1098 if (R.empty() && BaseType.isNull() &&
1099 CorrectTypo(R, S, &SS, ClassDecl) && R.isSingleResult()) {
1100 if (FieldDecl *Member = R.getAsSingle<FieldDecl>()) {
1101 if (Member->getDeclContext()->getLookupContext()->Equals(ClassDecl)) {
1102 // We have found a non-static data member with a similar
1103 // name to what was typed; complain and initialize that
1105 Diag(R.getNameLoc(), diag::err_mem_init_not_member_or_class_suggest)
1106 << MemberOrBase << true << R.getLookupName()
1107 << FixItHint::CreateReplacement(R.getNameLoc(),
1108 R.getLookupName().getAsString());
1109 Diag(Member->getLocation(), diag::note_previous_decl)
1110 << Member->getDeclName();
1112 return BuildMemberInitializer(Member, (Expr**)Args, NumArgs, IdLoc,
1113 LParenLoc, RParenLoc);
1115 } else if (TypeDecl *Type = R.getAsSingle<TypeDecl>()) {
1116 const CXXBaseSpecifier *DirectBaseSpec;
1117 const CXXBaseSpecifier *VirtualBaseSpec;
1118 if (FindBaseInitializer(*this, ClassDecl,
1119 Context.getTypeDeclType(Type),
1120 DirectBaseSpec, VirtualBaseSpec)) {
1121 // We have found a direct or virtual base class with a
1122 // similar name to what was typed; complain and initialize
1124 Diag(R.getNameLoc(), diag::err_mem_init_not_member_or_class_suggest)
1125 << MemberOrBase << false << R.getLookupName()
1126 << FixItHint::CreateReplacement(R.getNameLoc(),
1127 R.getLookupName().getAsString());
1129 const CXXBaseSpecifier *BaseSpec = DirectBaseSpec? DirectBaseSpec
1131 Diag(BaseSpec->getSourceRange().getBegin(),
1132 diag::note_base_class_specified_here)
1133 << BaseSpec->getType()
1134 << BaseSpec->getSourceRange();
1141 if (!TyD && BaseType.isNull()) {
1142 Diag(IdLoc, diag::err_mem_init_not_member_or_class)
1143 << MemberOrBase << SourceRange(IdLoc, RParenLoc);
1148 if (BaseType.isNull()) {
1149 BaseType = Context.getTypeDeclType(TyD);
1151 NestedNameSpecifier *Qualifier =
1152 static_cast<NestedNameSpecifier*>(SS.getScopeRep());
1154 // FIXME: preserve source range information
1155 BaseType = Context.getQualifiedNameType(Qualifier, BaseType);
1161 TInfo = Context.getTrivialTypeSourceInfo(BaseType, IdLoc);
1163 return BuildBaseInitializer(BaseType, TInfo, (Expr **)Args, NumArgs,
1164 LParenLoc, RParenLoc, ClassDecl);
1167 /// Checks an initializer expression for use of uninitialized fields, such as
1168 /// containing the field that is being initialized. Returns true if there is an
1169 /// uninitialized field was used an updates the SourceLocation parameter; false
1171 static bool InitExprContainsUninitializedFields(const Stmt* S,
1172 const FieldDecl* LhsField,
1173 SourceLocation* L) {
1174 const MemberExpr* ME = dyn_cast<MemberExpr>(S);
1176 const NamedDecl* RhsField = ME->getMemberDecl();
1177 if (RhsField == LhsField) {
1178 // Initializing a field with itself. Throw a warning.
1179 // But wait; there are exceptions!
1180 // Exception #1: The field may not belong to this record.
1181 // e.g. Foo(const Foo& rhs) : A(rhs.A) {}
1182 const Expr* base = ME->getBase();
1183 if (base != NULL && !isa<CXXThisExpr>(base->IgnoreParenCasts())) {
1184 // Even though the field matches, it does not belong to this record.
1187 // None of the exceptions triggered; return true to indicate an
1188 // uninitialized field was used.
1189 *L = ME->getMemberLoc();
1194 for (Stmt::const_child_iterator it = S->child_begin();
1195 it != S->child_end() && found == false;
1197 if (isa<CallExpr>(S)) {
1198 // Do not descend into function calls or constructors, as the use
1199 // of an uninitialized field may be valid. One would have to inspect
1200 // the contents of the function/ctor to determine if it is safe or not.
1201 // i.e. Pass-by-value is never safe, but pass-by-reference and pointers
1202 // may be safe, depending on what the function/ctor does.
1205 found = InitExprContainsUninitializedFields(*it, LhsField, L);
1211 Sema::BuildMemberInitializer(FieldDecl *Member, Expr **Args,
1212 unsigned NumArgs, SourceLocation IdLoc,
1213 SourceLocation LParenLoc,
1214 SourceLocation RParenLoc) {
1215 // Diagnose value-uses of fields to initialize themselves, e.g.
1217 // where foo is not also a parameter to the constructor.
1218 // TODO: implement -Wuninitialized and fold this into that framework.
1219 for (unsigned i = 0; i < NumArgs; ++i) {
1221 if (InitExprContainsUninitializedFields(Args[i], Member, &L)) {
1222 // FIXME: Return true in the case when other fields are used before being
1223 // uninitialized. For example, let this field be the i'th field. When
1224 // initializing the i'th field, throw a warning if any of the >= i'th
1225 // fields are used, as they are not yet initialized.
1226 // Right now we are only handling the case where the i'th field uses
1227 // itself in its initializer.
1228 Diag(L, diag::warn_field_is_uninit);
1232 bool HasDependentArg = false;
1233 for (unsigned i = 0; i < NumArgs; i++)
1234 HasDependentArg |= Args[i]->isTypeDependent();
1236 QualType FieldType = Member->getType();
1237 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
1238 FieldType = Array->getElementType();
1239 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(*this);
1240 if (FieldType->isDependentType() || HasDependentArg) {
1241 // Can't check initialization for a member of dependent type or when
1242 // any of the arguments are type-dependent expressions.
1243 OwningExprResult Init
1244 = Owned(new (Context) ParenListExpr(Context, LParenLoc, Args, NumArgs,
1247 // Erase any temporaries within this evaluation context; we're not
1248 // going to track them in the AST, since we'll be rebuilding the
1249 // ASTs during template instantiation.
1250 ExprTemporaries.erase(
1251 ExprTemporaries.begin() + ExprEvalContexts.back().NumTemporaries,
1252 ExprTemporaries.end());
1254 return new (Context) CXXBaseOrMemberInitializer(Context, Member, IdLoc,
1256 Init.takeAs<Expr>(),
1261 if (Member->isInvalidDecl())
1264 // Initialize the member.
1265 InitializedEntity MemberEntity =
1266 InitializedEntity::InitializeMember(Member, 0);
1267 InitializationKind Kind =
1268 InitializationKind::CreateDirect(IdLoc, LParenLoc, RParenLoc);
1270 InitializationSequence InitSeq(*this, MemberEntity, Kind, Args, NumArgs);
1272 OwningExprResult MemberInit =
1273 InitSeq.Perform(*this, MemberEntity, Kind,
1274 MultiExprArg(*this, (void**)Args, NumArgs), 0);
1275 if (MemberInit.isInvalid())
1278 // C++0x [class.base.init]p7:
1279 // The initialization of each base and member constitutes a
1281 MemberInit = MaybeCreateCXXExprWithTemporaries(move(MemberInit));
1282 if (MemberInit.isInvalid())
1285 // If we are in a dependent context, template instantiation will
1286 // perform this type-checking again. Just save the arguments that we
1287 // received in a ParenListExpr.
1288 // FIXME: This isn't quite ideal, since our ASTs don't capture all
1289 // of the information that we have about the member
1290 // initializer. However, deconstructing the ASTs is a dicey process,
1291 // and this approach is far more likely to get the corner cases right.
1292 if (CurContext->isDependentContext()) {
1293 // Bump the reference count of all of the arguments.
1294 for (unsigned I = 0; I != NumArgs; ++I)
1297 OwningExprResult Init
1298 = Owned(new (Context) ParenListExpr(Context, LParenLoc, Args, NumArgs,
1300 return new (Context) CXXBaseOrMemberInitializer(Context, Member, IdLoc,
1302 Init.takeAs<Expr>(),
1306 return new (Context) CXXBaseOrMemberInitializer(Context, Member, IdLoc,
1308 MemberInit.takeAs<Expr>(),
1313 Sema::BuildBaseInitializer(QualType BaseType, TypeSourceInfo *BaseTInfo,
1314 Expr **Args, unsigned NumArgs,
1315 SourceLocation LParenLoc, SourceLocation RParenLoc,
1316 CXXRecordDecl *ClassDecl) {
1317 bool HasDependentArg = false;
1318 for (unsigned i = 0; i < NumArgs; i++)
1319 HasDependentArg |= Args[i]->isTypeDependent();
1321 SourceLocation BaseLoc = BaseTInfo->getTypeLoc().getSourceRange().getBegin();
1322 if (BaseType->isDependentType() || HasDependentArg) {
1323 // Can't check initialization for a base of dependent type or when
1324 // any of the arguments are type-dependent expressions.
1325 OwningExprResult BaseInit
1326 = Owned(new (Context) ParenListExpr(Context, LParenLoc, Args, NumArgs,
1329 // Erase any temporaries within this evaluation context; we're not
1330 // going to track them in the AST, since we'll be rebuilding the
1331 // ASTs during template instantiation.
1332 ExprTemporaries.erase(
1333 ExprTemporaries.begin() + ExprEvalContexts.back().NumTemporaries,
1334 ExprTemporaries.end());
1336 return new (Context) CXXBaseOrMemberInitializer(Context, BaseTInfo,
1338 BaseInit.takeAs<Expr>(),
1342 if (!BaseType->isRecordType())
1343 return Diag(BaseLoc, diag::err_base_init_does_not_name_class)
1344 << BaseType << BaseTInfo->getTypeLoc().getSourceRange();
1346 // C++ [class.base.init]p2:
1347 // [...] Unless the mem-initializer-id names a nonstatic data
1348 // member of the constructor’s class or a direct or virtual base
1349 // of that class, the mem-initializer is ill-formed. A
1350 // mem-initializer-list can initialize a base class using any
1351 // name that denotes that base class type.
1353 // Check for direct and virtual base classes.
1354 const CXXBaseSpecifier *DirectBaseSpec = 0;
1355 const CXXBaseSpecifier *VirtualBaseSpec = 0;
1356 FindBaseInitializer(*this, ClassDecl, BaseType, DirectBaseSpec,
1359 // C++ [base.class.init]p2:
1360 // If a mem-initializer-id is ambiguous because it designates both
1361 // a direct non-virtual base class and an inherited virtual base
1362 // class, the mem-initializer is ill-formed.
1363 if (DirectBaseSpec && VirtualBaseSpec)
1364 return Diag(BaseLoc, diag::err_base_init_direct_and_virtual)
1365 << BaseType << BaseTInfo->getTypeLoc().getSourceRange();
1366 // C++ [base.class.init]p2:
1367 // Unless the mem-initializer-id names a nonstatic data membeer of the
1368 // constructor's class ot a direst or virtual base of that class, the
1369 // mem-initializer is ill-formed.
1370 if (!DirectBaseSpec && !VirtualBaseSpec)
1371 return Diag(BaseLoc, diag::err_not_direct_base_or_virtual)
1372 << BaseType << ClassDecl->getNameAsCString()
1373 << BaseTInfo->getTypeLoc().getSourceRange();
1375 CXXBaseSpecifier *BaseSpec
1376 = const_cast<CXXBaseSpecifier *>(DirectBaseSpec);
1378 BaseSpec = const_cast<CXXBaseSpecifier *>(VirtualBaseSpec);
1380 // Initialize the base.
1381 InitializedEntity BaseEntity =
1382 InitializedEntity::InitializeBase(Context, BaseSpec);
1383 InitializationKind Kind =
1384 InitializationKind::CreateDirect(BaseLoc, LParenLoc, RParenLoc);
1386 InitializationSequence InitSeq(*this, BaseEntity, Kind, Args, NumArgs);
1388 OwningExprResult BaseInit =
1389 InitSeq.Perform(*this, BaseEntity, Kind,
1390 MultiExprArg(*this, (void**)Args, NumArgs), 0);
1391 if (BaseInit.isInvalid())
1394 // C++0x [class.base.init]p7:
1395 // The initialization of each base and member constitutes a
1397 BaseInit = MaybeCreateCXXExprWithTemporaries(move(BaseInit));
1398 if (BaseInit.isInvalid())
1401 // If we are in a dependent context, template instantiation will
1402 // perform this type-checking again. Just save the arguments that we
1403 // received in a ParenListExpr.
1404 // FIXME: This isn't quite ideal, since our ASTs don't capture all
1405 // of the information that we have about the base
1406 // initializer. However, deconstructing the ASTs is a dicey process,
1407 // and this approach is far more likely to get the corner cases right.
1408 if (CurContext->isDependentContext()) {
1409 // Bump the reference count of all of the arguments.
1410 for (unsigned I = 0; I != NumArgs; ++I)
1413 OwningExprResult Init
1414 = Owned(new (Context) ParenListExpr(Context, LParenLoc, Args, NumArgs,
1416 return new (Context) CXXBaseOrMemberInitializer(Context, BaseTInfo,
1418 Init.takeAs<Expr>(),
1422 return new (Context) CXXBaseOrMemberInitializer(Context, BaseTInfo,
1424 BaseInit.takeAs<Expr>(),
1429 Sema::SetBaseOrMemberInitializers(CXXConstructorDecl *Constructor,
1430 CXXBaseOrMemberInitializer **Initializers,
1431 unsigned NumInitializers,
1433 if (Constructor->isDependentContext()) {
1434 // Just store the initializers as written, they will be checked during
1436 if (NumInitializers > 0) {
1437 Constructor->setNumBaseOrMemberInitializers(NumInitializers);
1438 CXXBaseOrMemberInitializer **baseOrMemberInitializers =
1439 new (Context) CXXBaseOrMemberInitializer*[NumInitializers];
1440 memcpy(baseOrMemberInitializers, Initializers,
1441 NumInitializers * sizeof(CXXBaseOrMemberInitializer*));
1442 Constructor->setBaseOrMemberInitializers(baseOrMemberInitializers);
1448 // We need to build the initializer AST according to order of construction
1449 // and not what user specified in the Initializers list.
1450 CXXRecordDecl *ClassDecl = Constructor->getParent()->getDefinition();
1454 llvm::SmallVector<CXXBaseOrMemberInitializer*, 32> AllToInit;
1455 llvm::DenseMap<const void *, CXXBaseOrMemberInitializer*> AllBaseFields;
1456 bool HadError = false;
1458 for (unsigned i = 0; i < NumInitializers; i++) {
1459 CXXBaseOrMemberInitializer *Member = Initializers[i];
1461 if (Member->isBaseInitializer())
1462 AllBaseFields[Member->getBaseClass()->getAs<RecordType>()] = Member;
1464 AllBaseFields[Member->getMember()] = Member;
1467 llvm::SmallVector<CXXBaseSpecifier *, 4> BasesToDefaultInit;
1469 // Push virtual bases before others.
1470 for (CXXRecordDecl::base_class_iterator VBase = ClassDecl->vbases_begin(),
1471 E = ClassDecl->vbases_end(); VBase != E; ++VBase) {
1473 if (CXXBaseOrMemberInitializer *Value
1474 = AllBaseFields.lookup(VBase->getType()->getAs<RecordType>())) {
1475 AllToInit.push_back(Value);
1476 } else if (!AnyErrors) {
1477 InitializedEntity InitEntity
1478 = InitializedEntity::InitializeBase(Context, VBase);
1479 InitializationKind InitKind
1480 = InitializationKind::CreateDefault(Constructor->getLocation());
1481 InitializationSequence InitSeq(*this, InitEntity, InitKind, 0, 0);
1482 OwningExprResult BaseInit = InitSeq.Perform(*this, InitEntity, InitKind,
1483 MultiExprArg(*this, 0, 0));
1484 BaseInit = MaybeCreateCXXExprWithTemporaries(move(BaseInit));
1485 if (BaseInit.isInvalid()) {
1490 CXXBaseOrMemberInitializer *CXXBaseInit =
1491 new (Context) CXXBaseOrMemberInitializer(Context,
1492 Context.getTrivialTypeSourceInfo(VBase->getType(),
1495 BaseInit.takeAs<Expr>(),
1497 AllToInit.push_back(CXXBaseInit);
1501 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
1502 E = ClassDecl->bases_end(); Base != E; ++Base) {
1503 // Virtuals are in the virtual base list and already constructed.
1504 if (Base->isVirtual())
1507 if (CXXBaseOrMemberInitializer *Value
1508 = AllBaseFields.lookup(Base->getType()->getAs<RecordType>())) {
1509 AllToInit.push_back(Value);
1510 } else if (!AnyErrors) {
1511 InitializedEntity InitEntity
1512 = InitializedEntity::InitializeBase(Context, Base);
1513 InitializationKind InitKind
1514 = InitializationKind::CreateDefault(Constructor->getLocation());
1515 InitializationSequence InitSeq(*this, InitEntity, InitKind, 0, 0);
1516 OwningExprResult BaseInit = InitSeq.Perform(*this, InitEntity, InitKind,
1517 MultiExprArg(*this, 0, 0));
1518 BaseInit = MaybeCreateCXXExprWithTemporaries(move(BaseInit));
1519 if (BaseInit.isInvalid()) {
1524 CXXBaseOrMemberInitializer *CXXBaseInit =
1525 new (Context) CXXBaseOrMemberInitializer(Context,
1526 Context.getTrivialTypeSourceInfo(Base->getType(),
1529 BaseInit.takeAs<Expr>(),
1531 AllToInit.push_back(CXXBaseInit);
1535 // non-static data members.
1536 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
1537 E = ClassDecl->field_end(); Field != E; ++Field) {
1538 if ((*Field)->isAnonymousStructOrUnion()) {
1539 if (const RecordType *FieldClassType =
1540 Field->getType()->getAs<RecordType>()) {
1541 CXXRecordDecl *FieldClassDecl
1542 = cast<CXXRecordDecl>(FieldClassType->getDecl());
1543 for (RecordDecl::field_iterator FA = FieldClassDecl->field_begin(),
1544 EA = FieldClassDecl->field_end(); FA != EA; FA++) {
1545 if (CXXBaseOrMemberInitializer *Value = AllBaseFields.lookup(*FA)) {
1546 // 'Member' is the anonymous union field and 'AnonUnionMember' is
1547 // set to the anonymous union data member used in the initializer
1549 Value->setMember(*Field);
1550 Value->setAnonUnionMember(*FA);
1551 AllToInit.push_back(Value);
1558 if (CXXBaseOrMemberInitializer *Value = AllBaseFields.lookup(*Field)) {
1559 AllToInit.push_back(Value);
1563 if ((*Field)->getType()->isDependentType() || AnyErrors)
1566 QualType FT = Context.getBaseElementType((*Field)->getType());
1567 if (FT->getAs<RecordType>()) {
1568 InitializedEntity InitEntity
1569 = InitializedEntity::InitializeMember(*Field);
1570 InitializationKind InitKind
1571 = InitializationKind::CreateDefault(Constructor->getLocation());
1573 InitializationSequence InitSeq(*this, InitEntity, InitKind, 0, 0);
1574 OwningExprResult MemberInit = InitSeq.Perform(*this, InitEntity, InitKind,
1575 MultiExprArg(*this, 0, 0));
1576 MemberInit = MaybeCreateCXXExprWithTemporaries(move(MemberInit));
1577 if (MemberInit.isInvalid()) {
1582 // Don't attach synthesized member initializers in a dependent
1583 // context; they'll be regenerated a template instantiation
1585 if (CurContext->isDependentContext())
1588 CXXBaseOrMemberInitializer *Member =
1589 new (Context) CXXBaseOrMemberInitializer(Context,
1590 *Field, SourceLocation(),
1592 MemberInit.takeAs<Expr>(),
1595 AllToInit.push_back(Member);
1597 else if (FT->isReferenceType()) {
1598 Diag(Constructor->getLocation(), diag::err_uninitialized_member_in_ctor)
1599 << (int)Constructor->isImplicit() << Context.getTagDeclType(ClassDecl)
1600 << 0 << (*Field)->getDeclName();
1601 Diag((*Field)->getLocation(), diag::note_declared_at);
1604 else if (FT.isConstQualified()) {
1605 Diag(Constructor->getLocation(), diag::err_uninitialized_member_in_ctor)
1606 << (int)Constructor->isImplicit() << Context.getTagDeclType(ClassDecl)
1607 << 1 << (*Field)->getDeclName();
1608 Diag((*Field)->getLocation(), diag::note_declared_at);
1613 NumInitializers = AllToInit.size();
1614 if (NumInitializers > 0) {
1615 Constructor->setNumBaseOrMemberInitializers(NumInitializers);
1616 CXXBaseOrMemberInitializer **baseOrMemberInitializers =
1617 new (Context) CXXBaseOrMemberInitializer*[NumInitializers];
1618 memcpy(baseOrMemberInitializers, AllToInit.data(),
1619 NumInitializers * sizeof(CXXBaseOrMemberInitializer*));
1620 Constructor->setBaseOrMemberInitializers(baseOrMemberInitializers);
1622 // Constructors implicitly reference the base and member
1624 MarkBaseAndMemberDestructorsReferenced(Constructor->getLocation(),
1625 Constructor->getParent());
1631 static void *GetKeyForTopLevelField(FieldDecl *Field) {
1632 // For anonymous unions, use the class declaration as the key.
1633 if (const RecordType *RT = Field->getType()->getAs<RecordType>()) {
1634 if (RT->getDecl()->isAnonymousStructOrUnion())
1635 return static_cast<void *>(RT->getDecl());
1637 return static_cast<void *>(Field);
1640 static void *GetKeyForBase(ASTContext &Context, QualType BaseType) {
1641 return Context.getCanonicalType(BaseType).getTypePtr();
1644 static void *GetKeyForMember(ASTContext &Context,
1645 CXXBaseOrMemberInitializer *Member,
1646 bool MemberMaybeAnon = false) {
1647 if (!Member->isMemberInitializer())
1648 return GetKeyForBase(Context, QualType(Member->getBaseClass(), 0));
1650 // For fields injected into the class via declaration of an anonymous union,
1651 // use its anonymous union class declaration as the unique key.
1652 FieldDecl *Field = Member->getMember();
1654 // After SetBaseOrMemberInitializers call, Field is the anonymous union
1655 // data member of the class. Data member used in the initializer list is
1656 // in AnonUnionMember field.
1657 if (MemberMaybeAnon && Field->isAnonymousStructOrUnion())
1658 Field = Member->getAnonUnionMember();
1660 // If the field is a member of an anonymous union, we use record decl of the
1661 // union as the key.
1662 RecordDecl *RD = Field->getParent();
1663 if (RD->isAnonymousStructOrUnion() && RD->isUnion())
1664 return static_cast<void *>(RD);
1666 return static_cast<void *>(Field);
1670 DiagnoseBaseOrMemInitializerOrder(Sema &SemaRef,
1671 const CXXConstructorDecl *Constructor,
1672 CXXBaseOrMemberInitializer **MemInits,
1673 unsigned NumMemInits) {
1674 if (Constructor->isDependentContext())
1677 if (SemaRef.Diags.getDiagnosticLevel(diag::warn_base_initialized) ==
1678 Diagnostic::Ignored &&
1679 SemaRef.Diags.getDiagnosticLevel(diag::warn_field_initialized) ==
1680 Diagnostic::Ignored)
1683 // Also issue warning if order of ctor-initializer list does not match order
1684 // of 1) base class declarations and 2) order of non-static data members.
1685 llvm::SmallVector<const void*, 32> AllBaseOrMembers;
1687 const CXXRecordDecl *ClassDecl = Constructor->getParent();
1689 // Push virtual bases before others.
1690 for (CXXRecordDecl::base_class_const_iterator VBase =
1691 ClassDecl->vbases_begin(),
1692 E = ClassDecl->vbases_end(); VBase != E; ++VBase)
1693 AllBaseOrMembers.push_back(GetKeyForBase(SemaRef.Context,
1696 for (CXXRecordDecl::base_class_const_iterator Base = ClassDecl->bases_begin(),
1697 E = ClassDecl->bases_end(); Base != E; ++Base) {
1698 // Virtuals are alread in the virtual base list and are constructed
1700 if (Base->isVirtual())
1702 AllBaseOrMembers.push_back(GetKeyForBase(SemaRef.Context,
1706 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
1707 E = ClassDecl->field_end(); Field != E; ++Field)
1708 AllBaseOrMembers.push_back(GetKeyForTopLevelField(*Field));
1710 int Last = AllBaseOrMembers.size();
1712 CXXBaseOrMemberInitializer *PrevMember = 0;
1713 for (unsigned i = 0; i < NumMemInits; i++) {
1714 CXXBaseOrMemberInitializer *Member = MemInits[i];
1715 void *MemberInCtorList = GetKeyForMember(SemaRef.Context, Member, true);
1717 for (; curIndex < Last; curIndex++)
1718 if (MemberInCtorList == AllBaseOrMembers[curIndex])
1720 if (curIndex == Last) {
1721 assert(PrevMember && "Member not in member list?!");
1722 // Initializer as specified in ctor-initializer list is out of order.
1723 // Issue a warning diagnostic.
1724 if (PrevMember->isBaseInitializer()) {
1725 // Diagnostics is for an initialized base class.
1726 Type *BaseClass = PrevMember->getBaseClass();
1727 SemaRef.Diag(PrevMember->getSourceLocation(),
1728 diag::warn_base_initialized)
1729 << QualType(BaseClass, 0);
1731 FieldDecl *Field = PrevMember->getMember();
1732 SemaRef.Diag(PrevMember->getSourceLocation(),
1733 diag::warn_field_initialized)
1734 << Field->getNameAsString();
1737 if (FieldDecl *Field = Member->getMember())
1738 SemaRef.Diag(Member->getSourceLocation(),
1739 diag::note_fieldorbase_initialized_here) << 0
1740 << Field->getNameAsString();
1742 Type *BaseClass = Member->getBaseClass();
1743 SemaRef.Diag(Member->getSourceLocation(),
1744 diag::note_fieldorbase_initialized_here) << 1
1745 << QualType(BaseClass, 0);
1747 for (curIndex = 0; curIndex < Last; curIndex++)
1748 if (MemberInCtorList == AllBaseOrMembers[curIndex])
1751 PrevMember = Member;
1755 /// ActOnMemInitializers - Handle the member initializers for a constructor.
1756 void Sema::ActOnMemInitializers(DeclPtrTy ConstructorDecl,
1757 SourceLocation ColonLoc,
1758 MemInitTy **meminits, unsigned NumMemInits,
1760 if (!ConstructorDecl)
1763 AdjustDeclIfTemplate(ConstructorDecl);
1765 CXXConstructorDecl *Constructor
1766 = dyn_cast<CXXConstructorDecl>(ConstructorDecl.getAs<Decl>());
1769 Diag(ColonLoc, diag::err_only_constructors_take_base_inits);
1773 CXXBaseOrMemberInitializer **MemInits =
1774 reinterpret_cast<CXXBaseOrMemberInitializer **>(meminits);
1776 llvm::DenseMap<void*, CXXBaseOrMemberInitializer *> Members;
1777 bool HadError = false;
1778 for (unsigned i = 0; i < NumMemInits; i++) {
1779 CXXBaseOrMemberInitializer *Member = MemInits[i];
1781 void *KeyToMember = GetKeyForMember(Context, Member);
1782 CXXBaseOrMemberInitializer *&PrevMember = Members[KeyToMember];
1784 PrevMember = Member;
1787 if (FieldDecl *Field = Member->getMember())
1788 Diag(Member->getSourceLocation(),
1789 diag::error_multiple_mem_initialization)
1790 << Field->getNameAsString()
1791 << Member->getSourceRange();
1793 Type *BaseClass = Member->getBaseClass();
1794 assert(BaseClass && "ActOnMemInitializers - neither field or base");
1795 Diag(Member->getSourceLocation(),
1796 diag::error_multiple_base_initialization)
1797 << QualType(BaseClass, 0)
1798 << Member->getSourceRange();
1800 Diag(PrevMember->getSourceLocation(), diag::note_previous_initializer)
1808 DiagnoseBaseOrMemInitializerOrder(*this, Constructor, MemInits, NumMemInits);
1810 SetBaseOrMemberInitializers(Constructor, MemInits, NumMemInits, AnyErrors);
1814 Sema::MarkBaseAndMemberDestructorsReferenced(SourceLocation Location,
1815 CXXRecordDecl *ClassDecl) {
1816 // Ignore dependent contexts.
1817 if (ClassDecl->isDependentContext())
1820 // FIXME: all the access-control diagnostics are positioned on the
1821 // field/base declaration. That's probably good; that said, the
1822 // user might reasonably want to know why the destructor is being
1823 // emitted, and we currently don't say.
1825 // Non-static data members.
1826 for (CXXRecordDecl::field_iterator I = ClassDecl->field_begin(),
1827 E = ClassDecl->field_end(); I != E; ++I) {
1828 FieldDecl *Field = *I;
1830 QualType FieldType = Context.getBaseElementType(Field->getType());
1832 const RecordType* RT = FieldType->getAs<RecordType>();
1836 CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl());
1837 if (FieldClassDecl->hasTrivialDestructor())
1840 CXXDestructorDecl *Dtor = FieldClassDecl->getDestructor(Context);
1841 CheckDestructorAccess(Field->getLocation(), Dtor,
1842 PDiag(diag::err_access_dtor_field)
1843 << Field->getDeclName()
1846 MarkDeclarationReferenced(Location, const_cast<CXXDestructorDecl*>(Dtor));
1849 llvm::SmallPtrSet<const RecordType *, 8> DirectVirtualBases;
1852 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
1853 E = ClassDecl->bases_end(); Base != E; ++Base) {
1854 // Bases are always records in a well-formed non-dependent class.
1855 const RecordType *RT = Base->getType()->getAs<RecordType>();
1857 // Remember direct virtual bases.
1858 if (Base->isVirtual())
1859 DirectVirtualBases.insert(RT);
1861 // Ignore trivial destructors.
1862 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(RT->getDecl());
1863 if (BaseClassDecl->hasTrivialDestructor())
1866 CXXDestructorDecl *Dtor = BaseClassDecl->getDestructor(Context);
1868 // FIXME: caret should be on the start of the class name
1869 CheckDestructorAccess(Base->getSourceRange().getBegin(), Dtor,
1870 PDiag(diag::err_access_dtor_base)
1872 << Base->getSourceRange());
1874 MarkDeclarationReferenced(Location, const_cast<CXXDestructorDecl*>(Dtor));
1878 for (CXXRecordDecl::base_class_iterator VBase = ClassDecl->vbases_begin(),
1879 E = ClassDecl->vbases_end(); VBase != E; ++VBase) {
1881 // Bases are always records in a well-formed non-dependent class.
1882 const RecordType *RT = VBase->getType()->getAs<RecordType>();
1884 // Ignore direct virtual bases.
1885 if (DirectVirtualBases.count(RT))
1888 // Ignore trivial destructors.
1889 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(RT->getDecl());
1890 if (BaseClassDecl->hasTrivialDestructor())
1893 CXXDestructorDecl *Dtor = BaseClassDecl->getDestructor(Context);
1894 CheckDestructorAccess(ClassDecl->getLocation(), Dtor,
1895 PDiag(diag::err_access_dtor_vbase)
1896 << VBase->getType());
1898 MarkDeclarationReferenced(Location, const_cast<CXXDestructorDecl*>(Dtor));
1902 void Sema::ActOnDefaultCtorInitializers(DeclPtrTy CDtorDecl) {
1906 if (CXXConstructorDecl *Constructor
1907 = dyn_cast<CXXConstructorDecl>(CDtorDecl.getAs<Decl>()))
1908 SetBaseOrMemberInitializers(Constructor, 0, 0, /*AnyErrors=*/false);
1911 bool Sema::RequireNonAbstractType(SourceLocation Loc, QualType T,
1912 unsigned DiagID, AbstractDiagSelID SelID,
1913 const CXXRecordDecl *CurrentRD) {
1915 return RequireNonAbstractType(Loc, T,
1916 PDiag(DiagID), CurrentRD);
1918 return RequireNonAbstractType(Loc, T,
1919 PDiag(DiagID) << SelID, CurrentRD);
1922 bool Sema::RequireNonAbstractType(SourceLocation Loc, QualType T,
1923 const PartialDiagnostic &PD,
1924 const CXXRecordDecl *CurrentRD) {
1925 if (!getLangOptions().CPlusPlus)
1928 if (const ArrayType *AT = Context.getAsArrayType(T))
1929 return RequireNonAbstractType(Loc, AT->getElementType(), PD,
1932 if (const PointerType *PT = T->getAs<PointerType>()) {
1933 // Find the innermost pointer type.
1934 while (const PointerType *T = PT->getPointeeType()->getAs<PointerType>())
1937 if (const ArrayType *AT = Context.getAsArrayType(PT->getPointeeType()))
1938 return RequireNonAbstractType(Loc, AT->getElementType(), PD, CurrentRD);
1941 const RecordType *RT = T->getAs<RecordType>();
1945 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1947 if (CurrentRD && CurrentRD != RD)
1950 // FIXME: is this reasonable? It matches current behavior, but....
1951 if (!RD->getDefinition())
1954 if (!RD->isAbstract())
1957 Diag(Loc, PD) << RD->getDeclName();
1959 // Check if we've already emitted the list of pure virtual functions for this
1961 if (PureVirtualClassDiagSet && PureVirtualClassDiagSet->count(RD))
1964 CXXFinalOverriderMap FinalOverriders;
1965 RD->getFinalOverriders(FinalOverriders);
1967 for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
1968 MEnd = FinalOverriders.end();
1971 for (OverridingMethods::iterator SO = M->second.begin(),
1972 SOEnd = M->second.end();
1973 SO != SOEnd; ++SO) {
1974 // C++ [class.abstract]p4:
1975 // A class is abstract if it contains or inherits at least one
1976 // pure virtual function for which the final overrider is pure
1980 if (SO->second.size() != 1)
1983 if (!SO->second.front().Method->isPure())
1986 Diag(SO->second.front().Method->getLocation(),
1987 diag::note_pure_virtual_function)
1988 << SO->second.front().Method->getDeclName();
1992 if (!PureVirtualClassDiagSet)
1993 PureVirtualClassDiagSet.reset(new RecordDeclSetTy);
1994 PureVirtualClassDiagSet->insert(RD);
2000 class AbstractClassUsageDiagnoser
2001 : public DeclVisitor<AbstractClassUsageDiagnoser, bool> {
2003 CXXRecordDecl *AbstractClass;
2005 bool VisitDeclContext(const DeclContext *DC) {
2006 bool Invalid = false;
2008 for (CXXRecordDecl::decl_iterator I = DC->decls_begin(),
2009 E = DC->decls_end(); I != E; ++I)
2010 Invalid |= Visit(*I);
2016 AbstractClassUsageDiagnoser(Sema& SemaRef, CXXRecordDecl *ac)
2017 : SemaRef(SemaRef), AbstractClass(ac) {
2018 Visit(SemaRef.Context.getTranslationUnitDecl());
2021 bool VisitFunctionDecl(const FunctionDecl *FD) {
2022 if (FD->isThisDeclarationADefinition()) {
2023 // No need to do the check if we're in a definition, because it requires
2024 // that the return/param types are complete.
2025 // because that requires
2026 return VisitDeclContext(FD);
2029 // Check the return type.
2030 QualType RTy = FD->getType()->getAs<FunctionType>()->getResultType();
2032 SemaRef.RequireNonAbstractType(FD->getLocation(), RTy,
2033 diag::err_abstract_type_in_decl,
2034 Sema::AbstractReturnType,
2037 for (FunctionDecl::param_const_iterator I = FD->param_begin(),
2038 E = FD->param_end(); I != E; ++I) {
2039 const ParmVarDecl *VD = *I;
2041 SemaRef.RequireNonAbstractType(VD->getLocation(),
2042 VD->getOriginalType(),
2043 diag::err_abstract_type_in_decl,
2044 Sema::AbstractParamType,
2051 bool VisitDecl(const Decl* D) {
2052 if (const DeclContext *DC = dyn_cast<DeclContext>(D))
2053 return VisitDeclContext(DC);
2060 /// \brief Perform semantic checks on a class definition that has been
2061 /// completing, introducing implicitly-declared members, checking for
2062 /// abstract types, etc.
2063 void Sema::CheckCompletedCXXClass(CXXRecordDecl *Record) {
2064 if (!Record || Record->isInvalidDecl())
2067 if (!Record->isDependentType())
2068 AddImplicitlyDeclaredMembersToClass(Record);
2070 if (Record->isInvalidDecl())
2073 // Set access bits correctly on the directly-declared conversions.
2074 UnresolvedSetImpl *Convs = Record->getConversionFunctions();
2075 for (UnresolvedSetIterator I = Convs->begin(), E = Convs->end(); I != E; ++I)
2076 Convs->setAccess(I, (*I)->getAccess());
2078 // Determine whether we need to check for final overriders. We do
2079 // this either when there are virtual base classes (in which case we
2080 // may end up finding multiple final overriders for a given virtual
2081 // function) or any of the base classes is abstract (in which case
2082 // we might detect that this class is abstract).
2083 bool CheckFinalOverriders = false;
2084 if (Record->isPolymorphic() && !Record->isInvalidDecl() &&
2085 !Record->isDependentType()) {
2086 if (Record->getNumVBases())
2087 CheckFinalOverriders = true;
2088 else if (!Record->isAbstract()) {
2089 for (CXXRecordDecl::base_class_const_iterator B = Record->bases_begin(),
2090 BEnd = Record->bases_end();
2092 CXXRecordDecl *BaseDecl
2093 = cast<CXXRecordDecl>(B->getType()->getAs<RecordType>()->getDecl());
2094 if (BaseDecl->isAbstract()) {
2095 CheckFinalOverriders = true;
2102 if (CheckFinalOverriders) {
2103 CXXFinalOverriderMap FinalOverriders;
2104 Record->getFinalOverriders(FinalOverriders);
2106 for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
2107 MEnd = FinalOverriders.end();
2109 for (OverridingMethods::iterator SO = M->second.begin(),
2110 SOEnd = M->second.end();
2111 SO != SOEnd; ++SO) {
2112 assert(SO->second.size() > 0 &&
2113 "All virtual functions have overridding virtual functions");
2114 if (SO->second.size() == 1) {
2115 // C++ [class.abstract]p4:
2116 // A class is abstract if it contains or inherits at least one
2117 // pure virtual function for which the final overrider is pure
2119 if (SO->second.front().Method->isPure())
2120 Record->setAbstract(true);
2124 // C++ [class.virtual]p2:
2125 // In a derived class, if a virtual member function of a base
2126 // class subobject has more than one final overrider the
2127 // program is ill-formed.
2128 Diag(Record->getLocation(), diag::err_multiple_final_overriders)
2129 << (NamedDecl *)M->first << Record;
2130 Diag(M->first->getLocation(), diag::note_overridden_virtual_function);
2131 for (OverridingMethods::overriding_iterator OM = SO->second.begin(),
2132 OMEnd = SO->second.end();
2134 Diag(OM->Method->getLocation(), diag::note_final_overrider)
2135 << (NamedDecl *)M->first << OM->Method->getParent();
2137 Record->setInvalidDecl();
2142 if (Record->isAbstract() && !Record->isInvalidDecl())
2143 (void)AbstractClassUsageDiagnoser(*this, Record);
2146 void Sema::ActOnFinishCXXMemberSpecification(Scope* S, SourceLocation RLoc,
2148 SourceLocation LBrac,
2149 SourceLocation RBrac,
2150 AttributeList *AttrList) {
2154 AdjustDeclIfTemplate(TagDecl);
2156 ActOnFields(S, RLoc, TagDecl,
2157 (DeclPtrTy*)FieldCollector->getCurFields(),
2158 FieldCollector->getCurNumFields(), LBrac, RBrac, AttrList);
2160 CheckCompletedCXXClass(
2161 dyn_cast_or_null<CXXRecordDecl>(TagDecl.getAs<Decl>()));
2164 /// AddImplicitlyDeclaredMembersToClass - Adds any implicitly-declared
2165 /// special functions, such as the default constructor, copy
2166 /// constructor, or destructor, to the given C++ class (C++
2167 /// [special]p1). This routine can only be executed just before the
2168 /// definition of the class is complete.
2169 void Sema::AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl) {
2170 CanQualType ClassType
2171 = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
2173 // FIXME: Implicit declarations have exception specifications, which are
2174 // the union of the specifications of the implicitly called functions.
2176 if (!ClassDecl->hasUserDeclaredConstructor()) {
2177 // C++ [class.ctor]p5:
2178 // A default constructor for a class X is a constructor of class X
2179 // that can be called without an argument. If there is no
2180 // user-declared constructor for class X, a default constructor is
2181 // implicitly declared. An implicitly-declared default constructor
2182 // is an inline public member of its class.
2183 DeclarationName Name
2184 = Context.DeclarationNames.getCXXConstructorName(ClassType);
2185 CXXConstructorDecl *DefaultCon =
2186 CXXConstructorDecl::Create(Context, ClassDecl,
2187 ClassDecl->getLocation(), Name,
2188 Context.getFunctionType(Context.VoidTy,
2190 /*FIXME*/false, false,
2192 FunctionType::ExtInfo()),
2194 /*isExplicit=*/false,
2196 /*isImplicitlyDeclared=*/true);
2197 DefaultCon->setAccess(AS_public);
2198 DefaultCon->setImplicit();
2199 DefaultCon->setTrivial(ClassDecl->hasTrivialConstructor());
2200 ClassDecl->addDecl(DefaultCon);
2203 if (!ClassDecl->hasUserDeclaredCopyConstructor()) {
2204 // C++ [class.copy]p4:
2205 // If the class definition does not explicitly declare a copy
2206 // constructor, one is declared implicitly.
2208 // C++ [class.copy]p5:
2209 // The implicitly-declared copy constructor for a class X will
2215 bool HasConstCopyConstructor = true;
2217 // -- each direct or virtual base class B of X has a copy
2218 // constructor whose first parameter is of type const B& or
2219 // const volatile B&, and
2220 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin();
2221 HasConstCopyConstructor && Base != ClassDecl->bases_end(); ++Base) {
2222 const CXXRecordDecl *BaseClassDecl
2223 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
2224 HasConstCopyConstructor
2225 = BaseClassDecl->hasConstCopyConstructor(Context);
2228 // -- for all the nonstatic data members of X that are of a
2229 // class type M (or array thereof), each such class type
2230 // has a copy constructor whose first parameter is of type
2231 // const M& or const volatile M&.
2232 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin();
2233 HasConstCopyConstructor && Field != ClassDecl->field_end();
2235 QualType FieldType = (*Field)->getType();
2236 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
2237 FieldType = Array->getElementType();
2238 if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
2239 const CXXRecordDecl *FieldClassDecl
2240 = cast<CXXRecordDecl>(FieldClassType->getDecl());
2241 HasConstCopyConstructor
2242 = FieldClassDecl->hasConstCopyConstructor(Context);
2246 // Otherwise, the implicitly declared copy constructor will have
2250 QualType ArgType = ClassType;
2251 if (HasConstCopyConstructor)
2252 ArgType = ArgType.withConst();
2253 ArgType = Context.getLValueReferenceType(ArgType);
2255 // An implicitly-declared copy constructor is an inline public
2256 // member of its class.
2257 DeclarationName Name
2258 = Context.DeclarationNames.getCXXConstructorName(ClassType);
2259 CXXConstructorDecl *CopyConstructor
2260 = CXXConstructorDecl::Create(Context, ClassDecl,
2261 ClassDecl->getLocation(), Name,
2262 Context.getFunctionType(Context.VoidTy,
2267 FunctionType::ExtInfo()),
2269 /*isExplicit=*/false,
2271 /*isImplicitlyDeclared=*/true);
2272 CopyConstructor->setAccess(AS_public);
2273 CopyConstructor->setImplicit();
2274 CopyConstructor->setTrivial(ClassDecl->hasTrivialCopyConstructor());
2276 // Add the parameter to the constructor.
2277 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyConstructor,
2278 ClassDecl->getLocation(),
2279 /*IdentifierInfo=*/0,
2280 ArgType, /*TInfo=*/0,
2282 CopyConstructor->setParams(&FromParam, 1);
2283 ClassDecl->addDecl(CopyConstructor);
2286 if (!ClassDecl->hasUserDeclaredCopyAssignment()) {
2287 // Note: The following rules are largely analoguous to the copy
2288 // constructor rules. Note that virtual bases are not taken into account
2289 // for determining the argument type of the operator. Note also that
2290 // operators taking an object instead of a reference are allowed.
2292 // C++ [class.copy]p10:
2293 // If the class definition does not explicitly declare a copy
2294 // assignment operator, one is declared implicitly.
2295 // The implicitly-defined copy assignment operator for a class X
2296 // will have the form
2298 // X& X::operator=(const X&)
2301 bool HasConstCopyAssignment = true;
2303 // -- each direct base class B of X has a copy assignment operator
2304 // whose parameter is of type const B&, const volatile B& or B,
2306 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin();
2307 HasConstCopyAssignment && Base != ClassDecl->bases_end(); ++Base) {
2308 assert(!Base->getType()->isDependentType() &&
2309 "Cannot generate implicit members for class with dependent bases.");
2310 const CXXRecordDecl *BaseClassDecl
2311 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
2312 const CXXMethodDecl *MD = 0;
2313 HasConstCopyAssignment = BaseClassDecl->hasConstCopyAssignment(Context,
2317 // -- for all the nonstatic data members of X that are of a class
2318 // type M (or array thereof), each such class type has a copy
2319 // assignment operator whose parameter is of type const M&,
2320 // const volatile M& or M.
2321 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin();
2322 HasConstCopyAssignment && Field != ClassDecl->field_end();
2324 QualType FieldType = (*Field)->getType();
2325 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
2326 FieldType = Array->getElementType();
2327 if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
2328 const CXXRecordDecl *FieldClassDecl
2329 = cast<CXXRecordDecl>(FieldClassType->getDecl());
2330 const CXXMethodDecl *MD = 0;
2331 HasConstCopyAssignment
2332 = FieldClassDecl->hasConstCopyAssignment(Context, MD);
2336 // Otherwise, the implicitly declared copy assignment operator will
2339 // X& X::operator=(X&)
2340 QualType ArgType = ClassType;
2341 QualType RetType = Context.getLValueReferenceType(ArgType);
2342 if (HasConstCopyAssignment)
2343 ArgType = ArgType.withConst();
2344 ArgType = Context.getLValueReferenceType(ArgType);
2346 // An implicitly-declared copy assignment operator is an inline public
2347 // member of its class.
2348 DeclarationName Name =
2349 Context.DeclarationNames.getCXXOperatorName(OO_Equal);
2350 CXXMethodDecl *CopyAssignment =
2351 CXXMethodDecl::Create(Context, ClassDecl, ClassDecl->getLocation(), Name,
2352 Context.getFunctionType(RetType, &ArgType, 1,
2356 FunctionType::ExtInfo()),
2357 /*TInfo=*/0, /*isStatic=*/false, /*isInline=*/true);
2358 CopyAssignment->setAccess(AS_public);
2359 CopyAssignment->setImplicit();
2360 CopyAssignment->setTrivial(ClassDecl->hasTrivialCopyAssignment());
2361 CopyAssignment->setCopyAssignment(true);
2363 // Add the parameter to the operator.
2364 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyAssignment,
2365 ClassDecl->getLocation(),
2366 /*IdentifierInfo=*/0,
2367 ArgType, /*TInfo=*/0,
2369 CopyAssignment->setParams(&FromParam, 1);
2371 // Don't call addedAssignmentOperator. There is no way to distinguish an
2372 // implicit from an explicit assignment operator.
2373 ClassDecl->addDecl(CopyAssignment);
2374 AddOverriddenMethods(ClassDecl, CopyAssignment);
2377 if (!ClassDecl->hasUserDeclaredDestructor()) {
2378 // C++ [class.dtor]p2:
2379 // If a class has no user-declared destructor, a destructor is
2380 // declared implicitly. An implicitly-declared destructor is an
2381 // inline public member of its class.
2382 QualType Ty = Context.getFunctionType(Context.VoidTy,
2385 false, 0, 0, FunctionType::ExtInfo());
2387 DeclarationName Name
2388 = Context.DeclarationNames.getCXXDestructorName(ClassType);
2389 CXXDestructorDecl *Destructor
2390 = CXXDestructorDecl::Create(Context, ClassDecl,
2391 ClassDecl->getLocation(), Name, Ty,
2393 /*isImplicitlyDeclared=*/true);
2394 Destructor->setAccess(AS_public);
2395 Destructor->setImplicit();
2396 Destructor->setTrivial(ClassDecl->hasTrivialDestructor());
2397 ClassDecl->addDecl(Destructor);
2399 // This could be uniqued if it ever proves significant.
2400 Destructor->setTypeSourceInfo(Context.getTrivialTypeSourceInfo(Ty));
2402 AddOverriddenMethods(ClassDecl, Destructor);
2406 void Sema::ActOnReenterTemplateScope(Scope *S, DeclPtrTy TemplateD) {
2407 Decl *D = TemplateD.getAs<Decl>();
2411 TemplateParameterList *Params = 0;
2412 if (TemplateDecl *Template = dyn_cast<TemplateDecl>(D))
2413 Params = Template->getTemplateParameters();
2414 else if (ClassTemplatePartialSpecializationDecl *PartialSpec
2415 = dyn_cast<ClassTemplatePartialSpecializationDecl>(D))
2416 Params = PartialSpec->getTemplateParameters();
2420 for (TemplateParameterList::iterator Param = Params->begin(),
2421 ParamEnd = Params->end();
2422 Param != ParamEnd; ++Param) {
2423 NamedDecl *Named = cast<NamedDecl>(*Param);
2424 if (Named->getDeclName()) {
2425 S->AddDecl(DeclPtrTy::make(Named));
2426 IdResolver.AddDecl(Named);
2431 void Sema::ActOnStartDelayedMemberDeclarations(Scope *S, DeclPtrTy RecordD) {
2432 if (!RecordD) return;
2433 AdjustDeclIfTemplate(RecordD);
2434 CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordD.getAs<Decl>());
2435 PushDeclContext(S, Record);
2438 void Sema::ActOnFinishDelayedMemberDeclarations(Scope *S, DeclPtrTy RecordD) {
2439 if (!RecordD) return;
2443 /// ActOnStartDelayedCXXMethodDeclaration - We have completed
2444 /// parsing a top-level (non-nested) C++ class, and we are now
2445 /// parsing those parts of the given Method declaration that could
2446 /// not be parsed earlier (C++ [class.mem]p2), such as default
2447 /// arguments. This action should enter the scope of the given
2448 /// Method declaration as if we had just parsed the qualified method
2449 /// name. However, it should not bring the parameters into scope;
2450 /// that will be performed by ActOnDelayedCXXMethodParameter.
2451 void Sema::ActOnStartDelayedCXXMethodDeclaration(Scope *S, DeclPtrTy MethodD) {
2454 /// ActOnDelayedCXXMethodParameter - We've already started a delayed
2455 /// C++ method declaration. We're (re-)introducing the given
2456 /// function parameter into scope for use in parsing later parts of
2457 /// the method declaration. For example, we could see an
2458 /// ActOnParamDefaultArgument event for this parameter.
2459 void Sema::ActOnDelayedCXXMethodParameter(Scope *S, DeclPtrTy ParamD) {
2463 ParmVarDecl *Param = cast<ParmVarDecl>(ParamD.getAs<Decl>());
2465 // If this parameter has an unparsed default argument, clear it out
2466 // to make way for the parsed default argument.
2467 if (Param->hasUnparsedDefaultArg())
2468 Param->setDefaultArg(0);
2470 S->AddDecl(DeclPtrTy::make(Param));
2471 if (Param->getDeclName())
2472 IdResolver.AddDecl(Param);
2475 /// ActOnFinishDelayedCXXMethodDeclaration - We have finished
2476 /// processing the delayed method declaration for Method. The method
2477 /// declaration is now considered finished. There may be a separate
2478 /// ActOnStartOfFunctionDef action later (not necessarily
2479 /// immediately!) for this method, if it was also defined inside the
2481 void Sema::ActOnFinishDelayedCXXMethodDeclaration(Scope *S, DeclPtrTy MethodD) {
2485 AdjustDeclIfTemplate(MethodD);
2487 FunctionDecl *Method = cast<FunctionDecl>(MethodD.getAs<Decl>());
2489 // Now that we have our default arguments, check the constructor
2490 // again. It could produce additional diagnostics or affect whether
2491 // the class has implicitly-declared destructors, among other
2493 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Method))
2494 CheckConstructor(Constructor);
2496 // Check the default arguments, which we may have added.
2497 if (!Method->isInvalidDecl())
2498 CheckCXXDefaultArguments(Method);
2501 /// CheckConstructorDeclarator - Called by ActOnDeclarator to check
2502 /// the well-formedness of the constructor declarator @p D with type @p
2503 /// R. If there are any errors in the declarator, this routine will
2504 /// emit diagnostics and set the invalid bit to true. In any case, the type
2505 /// will be updated to reflect a well-formed type for the constructor and
2507 QualType Sema::CheckConstructorDeclarator(Declarator &D, QualType R,
2508 FunctionDecl::StorageClass &SC) {
2509 bool isVirtual = D.getDeclSpec().isVirtualSpecified();
2511 // C++ [class.ctor]p3:
2512 // A constructor shall not be virtual (10.3) or static (9.4). A
2513 // constructor can be invoked for a const, volatile or const
2514 // volatile object. A constructor shall not be declared const,
2515 // volatile, or const volatile (9.3.2).
2517 if (!D.isInvalidType())
2518 Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
2519 << "virtual" << SourceRange(D.getDeclSpec().getVirtualSpecLoc())
2520 << SourceRange(D.getIdentifierLoc());
2523 if (SC == FunctionDecl::Static) {
2524 if (!D.isInvalidType())
2525 Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
2526 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
2527 << SourceRange(D.getIdentifierLoc());
2529 SC = FunctionDecl::None;
2532 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
2533 if (FTI.TypeQuals != 0) {
2534 if (FTI.TypeQuals & Qualifiers::Const)
2535 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
2536 << "const" << SourceRange(D.getIdentifierLoc());
2537 if (FTI.TypeQuals & Qualifiers::Volatile)
2538 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
2539 << "volatile" << SourceRange(D.getIdentifierLoc());
2540 if (FTI.TypeQuals & Qualifiers::Restrict)
2541 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
2542 << "restrict" << SourceRange(D.getIdentifierLoc());
2545 // Rebuild the function type "R" without any type qualifiers (in
2546 // case any of the errors above fired) and with "void" as the
2547 // return type, since constructors don't have return types. We
2548 // *always* have to do this, because GetTypeForDeclarator will
2549 // put in a result type of "int" when none was specified.
2550 const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
2551 return Context.getFunctionType(Context.VoidTy, Proto->arg_type_begin(),
2552 Proto->getNumArgs(),
2553 Proto->isVariadic(), 0,
2554 Proto->hasExceptionSpec(),
2555 Proto->hasAnyExceptionSpec(),
2556 Proto->getNumExceptions(),
2557 Proto->exception_begin(),
2558 Proto->getExtInfo());
2561 /// CheckConstructor - Checks a fully-formed constructor for
2562 /// well-formedness, issuing any diagnostics required. Returns true if
2563 /// the constructor declarator is invalid.
2564 void Sema::CheckConstructor(CXXConstructorDecl *Constructor) {
2565 CXXRecordDecl *ClassDecl
2566 = dyn_cast<CXXRecordDecl>(Constructor->getDeclContext());
2568 return Constructor->setInvalidDecl();
2570 // C++ [class.copy]p3:
2571 // A declaration of a constructor for a class X is ill-formed if
2572 // its first parameter is of type (optionally cv-qualified) X and
2573 // either there are no other parameters or else all other
2574 // parameters have default arguments.
2575 if (!Constructor->isInvalidDecl() &&
2576 ((Constructor->getNumParams() == 1) ||
2577 (Constructor->getNumParams() > 1 &&
2578 Constructor->getParamDecl(1)->hasDefaultArg())) &&
2579 Constructor->getTemplateSpecializationKind()
2580 != TSK_ImplicitInstantiation) {
2581 QualType ParamType = Constructor->getParamDecl(0)->getType();
2582 QualType ClassTy = Context.getTagDeclType(ClassDecl);
2583 if (Context.getCanonicalType(ParamType).getUnqualifiedType() == ClassTy) {
2584 SourceLocation ParamLoc = Constructor->getParamDecl(0)->getLocation();
2585 Diag(ParamLoc, diag::err_constructor_byvalue_arg)
2586 << FixItHint::CreateInsertion(ParamLoc, " const &");
2588 // FIXME: Rather that making the constructor invalid, we should endeavor
2590 Constructor->setInvalidDecl();
2594 // Notify the class that we've added a constructor.
2595 ClassDecl->addedConstructor(Context, Constructor);
2598 /// CheckDestructor - Checks a fully-formed destructor for well-formedness,
2599 /// issuing any diagnostics required. Returns true on error.
2600 bool Sema::CheckDestructor(CXXDestructorDecl *Destructor) {
2601 CXXRecordDecl *RD = Destructor->getParent();
2603 if (Destructor->isVirtual()) {
2606 if (!Destructor->isImplicit())
2607 Loc = Destructor->getLocation();
2609 Loc = RD->getLocation();
2611 // If we have a virtual destructor, look up the deallocation function
2612 FunctionDecl *OperatorDelete = 0;
2613 DeclarationName Name =
2614 Context.DeclarationNames.getCXXOperatorName(OO_Delete);
2615 if (FindDeallocationFunction(Loc, RD, Name, OperatorDelete))
2618 Destructor->setOperatorDelete(OperatorDelete);
2625 FTIHasSingleVoidArgument(DeclaratorChunk::FunctionTypeInfo &FTI) {
2626 return (FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 &&
2627 FTI.ArgInfo[0].Param &&
2628 FTI.ArgInfo[0].Param.getAs<ParmVarDecl>()->getType()->isVoidType());
2631 /// CheckDestructorDeclarator - Called by ActOnDeclarator to check
2632 /// the well-formednes of the destructor declarator @p D with type @p
2633 /// R. If there are any errors in the declarator, this routine will
2634 /// emit diagnostics and set the declarator to invalid. Even if this happens,
2635 /// will be updated to reflect a well-formed type for the destructor and
2637 QualType Sema::CheckDestructorDeclarator(Declarator &D,
2638 FunctionDecl::StorageClass& SC) {
2639 // C++ [class.dtor]p1:
2640 // [...] A typedef-name that names a class is a class-name
2641 // (7.1.3); however, a typedef-name that names a class shall not
2642 // be used as the identifier in the declarator for a destructor
2644 QualType DeclaratorType = GetTypeFromParser(D.getName().DestructorName);
2645 if (isa<TypedefType>(DeclaratorType)) {
2646 Diag(D.getIdentifierLoc(), diag::err_destructor_typedef_name)
2651 // C++ [class.dtor]p2:
2652 // A destructor is used to destroy objects of its class type. A
2653 // destructor takes no parameters, and no return type can be
2654 // specified for it (not even void). The address of a destructor
2655 // shall not be taken. A destructor shall not be static. A
2656 // destructor can be invoked for a const, volatile or const
2657 // volatile object. A destructor shall not be declared const,
2658 // volatile or const volatile (9.3.2).
2659 if (SC == FunctionDecl::Static) {
2660 if (!D.isInvalidType())
2661 Diag(D.getIdentifierLoc(), diag::err_destructor_cannot_be)
2662 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
2663 << SourceRange(D.getIdentifierLoc());
2664 SC = FunctionDecl::None;
2667 if (D.getDeclSpec().hasTypeSpecifier() && !D.isInvalidType()) {
2668 // Destructors don't have return types, but the parser will
2669 // happily parse something like:
2675 // The return type will be eliminated later.
2676 Diag(D.getIdentifierLoc(), diag::err_destructor_return_type)
2677 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
2678 << SourceRange(D.getIdentifierLoc());
2681 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
2682 if (FTI.TypeQuals != 0 && !D.isInvalidType()) {
2683 if (FTI.TypeQuals & Qualifiers::Const)
2684 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
2685 << "const" << SourceRange(D.getIdentifierLoc());
2686 if (FTI.TypeQuals & Qualifiers::Volatile)
2687 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
2688 << "volatile" << SourceRange(D.getIdentifierLoc());
2689 if (FTI.TypeQuals & Qualifiers::Restrict)
2690 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
2691 << "restrict" << SourceRange(D.getIdentifierLoc());
2695 // Make sure we don't have any parameters.
2696 if (FTI.NumArgs > 0 && !FTIHasSingleVoidArgument(FTI)) {
2697 Diag(D.getIdentifierLoc(), diag::err_destructor_with_params);
2699 // Delete the parameters.
2704 // Make sure the destructor isn't variadic.
2705 if (FTI.isVariadic) {
2706 Diag(D.getIdentifierLoc(), diag::err_destructor_variadic);
2710 // Rebuild the function type "R" without any type qualifiers or
2711 // parameters (in case any of the errors above fired) and with
2712 // "void" as the return type, since destructors don't have return
2713 // types. We *always* have to do this, because GetTypeForDeclarator
2714 // will put in a result type of "int" when none was specified.
2715 // FIXME: Exceptions!
2716 return Context.getFunctionType(Context.VoidTy, 0, 0, false, 0,
2717 false, false, 0, 0, FunctionType::ExtInfo());
2720 /// CheckConversionDeclarator - Called by ActOnDeclarator to check the
2721 /// well-formednes of the conversion function declarator @p D with
2722 /// type @p R. If there are any errors in the declarator, this routine
2723 /// will emit diagnostics and return true. Otherwise, it will return
2724 /// false. Either way, the type @p R will be updated to reflect a
2725 /// well-formed type for the conversion operator.
2726 void Sema::CheckConversionDeclarator(Declarator &D, QualType &R,
2727 FunctionDecl::StorageClass& SC) {
2728 // C++ [class.conv.fct]p1:
2729 // Neither parameter types nor return type can be specified. The
2730 // type of a conversion function (8.3.5) is "function taking no
2731 // parameter returning conversion-type-id."
2732 if (SC == FunctionDecl::Static) {
2733 if (!D.isInvalidType())
2734 Diag(D.getIdentifierLoc(), diag::err_conv_function_not_member)
2735 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
2736 << SourceRange(D.getIdentifierLoc());
2738 SC = FunctionDecl::None;
2740 if (D.getDeclSpec().hasTypeSpecifier() && !D.isInvalidType()) {
2741 // Conversion functions don't have return types, but the parser will
2742 // happily parse something like:
2745 // float operator bool();
2748 // The return type will be changed later anyway.
2749 Diag(D.getIdentifierLoc(), diag::err_conv_function_return_type)
2750 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
2751 << SourceRange(D.getIdentifierLoc());
2754 // Make sure we don't have any parameters.
2755 if (R->getAs<FunctionProtoType>()->getNumArgs() > 0) {
2756 Diag(D.getIdentifierLoc(), diag::err_conv_function_with_params);
2758 // Delete the parameters.
2759 D.getTypeObject(0).Fun.freeArgs();
2763 // Make sure the conversion function isn't variadic.
2764 if (R->getAs<FunctionProtoType>()->isVariadic() && !D.isInvalidType()) {
2765 Diag(D.getIdentifierLoc(), diag::err_conv_function_variadic);
2769 // C++ [class.conv.fct]p4:
2770 // The conversion-type-id shall not represent a function type nor
2772 QualType ConvType = GetTypeFromParser(D.getName().ConversionFunctionId);
2773 if (ConvType->isArrayType()) {
2774 Diag(D.getIdentifierLoc(), diag::err_conv_function_to_array);
2775 ConvType = Context.getPointerType(ConvType);
2777 } else if (ConvType->isFunctionType()) {
2778 Diag(D.getIdentifierLoc(), diag::err_conv_function_to_function);
2779 ConvType = Context.getPointerType(ConvType);
2783 // Rebuild the function type "R" without any parameters (in case any
2784 // of the errors above fired) and with the conversion type as the
2786 const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
2787 R = Context.getFunctionType(ConvType, 0, 0, false,
2788 Proto->getTypeQuals(),
2789 Proto->hasExceptionSpec(),
2790 Proto->hasAnyExceptionSpec(),
2791 Proto->getNumExceptions(),
2792 Proto->exception_begin(),
2793 Proto->getExtInfo());
2795 // C++0x explicit conversion operators.
2796 if (D.getDeclSpec().isExplicitSpecified() && !getLangOptions().CPlusPlus0x)
2797 Diag(D.getDeclSpec().getExplicitSpecLoc(),
2798 diag::warn_explicit_conversion_functions)
2799 << SourceRange(D.getDeclSpec().getExplicitSpecLoc());
2802 /// ActOnConversionDeclarator - Called by ActOnDeclarator to complete
2803 /// the declaration of the given C++ conversion function. This routine
2804 /// is responsible for recording the conversion function in the C++
2805 /// class, if possible.
2806 Sema::DeclPtrTy Sema::ActOnConversionDeclarator(CXXConversionDecl *Conversion) {
2807 assert(Conversion && "Expected to receive a conversion function declaration");
2809 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Conversion->getDeclContext());
2811 // Make sure we aren't redeclaring the conversion function.
2812 QualType ConvType = Context.getCanonicalType(Conversion->getConversionType());
2814 // C++ [class.conv.fct]p1:
2815 // [...] A conversion function is never used to convert a
2816 // (possibly cv-qualified) object to the (possibly cv-qualified)
2817 // same object type (or a reference to it), to a (possibly
2818 // cv-qualified) base class of that type (or a reference to it),
2819 // or to (possibly cv-qualified) void.
2820 // FIXME: Suppress this warning if the conversion function ends up being a
2821 // virtual function that overrides a virtual function in a base class.
2823 = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
2824 if (const ReferenceType *ConvTypeRef = ConvType->getAs<ReferenceType>())
2825 ConvType = ConvTypeRef->getPointeeType();
2826 if (ConvType->isRecordType()) {
2827 ConvType = Context.getCanonicalType(ConvType).getUnqualifiedType();
2828 if (ConvType == ClassType)
2829 Diag(Conversion->getLocation(), diag::warn_conv_to_self_not_used)
2831 else if (IsDerivedFrom(ClassType, ConvType))
2832 Diag(Conversion->getLocation(), diag::warn_conv_to_base_not_used)
2833 << ClassType << ConvType;
2834 } else if (ConvType->isVoidType()) {
2835 Diag(Conversion->getLocation(), diag::warn_conv_to_void_not_used)
2836 << ClassType << ConvType;
2839 if (Conversion->getPrimaryTemplate()) {
2840 // ignore specializations
2841 } else if (Conversion->getPreviousDeclaration()) {
2842 if (FunctionTemplateDecl *ConversionTemplate
2843 = Conversion->getDescribedFunctionTemplate()) {
2844 if (ClassDecl->replaceConversion(
2845 ConversionTemplate->getPreviousDeclaration(),
2846 ConversionTemplate))
2847 return DeclPtrTy::make(ConversionTemplate);
2848 } else if (ClassDecl->replaceConversion(Conversion->getPreviousDeclaration(),
2850 return DeclPtrTy::make(Conversion);
2851 assert(Conversion->isInvalidDecl() && "Conversion should not get here.");
2852 } else if (FunctionTemplateDecl *ConversionTemplate
2853 = Conversion->getDescribedFunctionTemplate())
2854 ClassDecl->addConversionFunction(ConversionTemplate);
2856 ClassDecl->addConversionFunction(Conversion);
2858 return DeclPtrTy::make(Conversion);
2861 //===----------------------------------------------------------------------===//
2862 // Namespace Handling
2863 //===----------------------------------------------------------------------===//
2865 /// ActOnStartNamespaceDef - This is called at the start of a namespace
2867 Sema::DeclPtrTy Sema::ActOnStartNamespaceDef(Scope *NamespcScope,
2868 SourceLocation IdentLoc,
2870 SourceLocation LBrace,
2871 AttributeList *AttrList) {
2872 NamespaceDecl *Namespc =
2873 NamespaceDecl::Create(Context, CurContext, IdentLoc, II);
2874 Namespc->setLBracLoc(LBrace);
2876 Scope *DeclRegionScope = NamespcScope->getParent();
2878 ProcessDeclAttributeList(DeclRegionScope, Namespc, AttrList);
2881 // C++ [namespace.def]p2:
2882 // The identifier in an original-namespace-definition shall not have been
2883 // previously defined in the declarative region in which the
2884 // original-namespace-definition appears. The identifier in an
2885 // original-namespace-definition is the name of the namespace. Subsequently
2886 // in that declarative region, it is treated as an original-namespace-name.
2889 = LookupSingleName(DeclRegionScope, II, LookupOrdinaryName,
2892 if (NamespaceDecl *OrigNS = dyn_cast_or_null<NamespaceDecl>(PrevDecl)) {
2893 // This is an extended namespace definition.
2894 // Attach this namespace decl to the chain of extended namespace
2896 OrigNS->setNextNamespace(Namespc);
2897 Namespc->setOriginalNamespace(OrigNS->getOriginalNamespace());
2899 // Remove the previous declaration from the scope.
2900 if (DeclRegionScope->isDeclScope(DeclPtrTy::make(OrigNS))) {
2901 IdResolver.RemoveDecl(OrigNS);
2902 DeclRegionScope->RemoveDecl(DeclPtrTy::make(OrigNS));
2904 } else if (PrevDecl) {
2905 // This is an invalid name redefinition.
2906 Diag(Namespc->getLocation(), diag::err_redefinition_different_kind)
2907 << Namespc->getDeclName();
2908 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
2909 Namespc->setInvalidDecl();
2910 // Continue on to push Namespc as current DeclContext and return it.
2911 } else if (II->isStr("std") &&
2912 CurContext->getLookupContext()->isTranslationUnit()) {
2913 // This is the first "real" definition of the namespace "std", so update
2914 // our cache of the "std" namespace to point at this definition.
2916 // We had already defined a dummy namespace "std". Link this new
2917 // namespace definition to the dummy namespace "std".
2918 StdNamespace->setNextNamespace(Namespc);
2919 StdNamespace->setLocation(IdentLoc);
2920 Namespc->setOriginalNamespace(StdNamespace->getOriginalNamespace());
2923 // Make our StdNamespace cache point at the first real definition of the
2925 StdNamespace = Namespc;
2928 PushOnScopeChains(Namespc, DeclRegionScope);
2930 // Anonymous namespaces.
2931 assert(Namespc->isAnonymousNamespace());
2933 // Link the anonymous namespace into its parent.
2934 NamespaceDecl *PrevDecl;
2935 DeclContext *Parent = CurContext->getLookupContext();
2936 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(Parent)) {
2937 PrevDecl = TU->getAnonymousNamespace();
2938 TU->setAnonymousNamespace(Namespc);
2940 NamespaceDecl *ND = cast<NamespaceDecl>(Parent);
2941 PrevDecl = ND->getAnonymousNamespace();
2942 ND->setAnonymousNamespace(Namespc);
2945 // Link the anonymous namespace with its previous declaration.
2947 assert(PrevDecl->isAnonymousNamespace());
2948 assert(!PrevDecl->getNextNamespace());
2949 Namespc->setOriginalNamespace(PrevDecl->getOriginalNamespace());
2950 PrevDecl->setNextNamespace(Namespc);
2953 CurContext->addDecl(Namespc);
2955 // C++ [namespace.unnamed]p1. An unnamed-namespace-definition
2956 // behaves as if it were replaced by
2957 // namespace unique { /* empty body */ }
2958 // using namespace unique;
2959 // namespace unique { namespace-body }
2960 // where all occurrences of 'unique' in a translation unit are
2961 // replaced by the same identifier and this identifier differs
2962 // from all other identifiers in the entire program.
2964 // We just create the namespace with an empty name and then add an
2965 // implicit using declaration, just like the standard suggests.
2967 // CodeGen enforces the "universally unique" aspect by giving all
2968 // declarations semantically contained within an anonymous
2969 // namespace internal linkage.
2972 UsingDirectiveDecl* UD
2973 = UsingDirectiveDecl::Create(Context, CurContext,
2974 /* 'using' */ LBrace,
2975 /* 'namespace' */ SourceLocation(),
2976 /* qualifier */ SourceRange(),
2978 /* identifier */ SourceLocation(),
2980 /* Ancestor */ CurContext);
2982 CurContext->addDecl(UD);
2986 // Although we could have an invalid decl (i.e. the namespace name is a
2987 // redefinition), push it as current DeclContext and try to continue parsing.
2988 // FIXME: We should be able to push Namespc here, so that the each DeclContext
2989 // for the namespace has the declarations that showed up in that particular
2990 // namespace definition.
2991 PushDeclContext(NamespcScope, Namespc);
2992 return DeclPtrTy::make(Namespc);
2995 /// getNamespaceDecl - Returns the namespace a decl represents. If the decl
2996 /// is a namespace alias, returns the namespace it points to.
2997 static inline NamespaceDecl *getNamespaceDecl(NamedDecl *D) {
2998 if (NamespaceAliasDecl *AD = dyn_cast_or_null<NamespaceAliasDecl>(D))
2999 return AD->getNamespace();
3000 return dyn_cast_or_null<NamespaceDecl>(D);
3003 /// ActOnFinishNamespaceDef - This callback is called after a namespace is
3004 /// exited. Decl is the DeclTy returned by ActOnStartNamespaceDef.
3005 void Sema::ActOnFinishNamespaceDef(DeclPtrTy D, SourceLocation RBrace) {
3006 Decl *Dcl = D.getAs<Decl>();
3007 NamespaceDecl *Namespc = dyn_cast_or_null<NamespaceDecl>(Dcl);
3008 assert(Namespc && "Invalid parameter, expected NamespaceDecl");
3009 Namespc->setRBracLoc(RBrace);
3013 Sema::DeclPtrTy Sema::ActOnUsingDirective(Scope *S,
3014 SourceLocation UsingLoc,
3015 SourceLocation NamespcLoc,
3016 const CXXScopeSpec &SS,
3017 SourceLocation IdentLoc,
3018 IdentifierInfo *NamespcName,
3019 AttributeList *AttrList) {
3020 assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
3021 assert(NamespcName && "Invalid NamespcName.");
3022 assert(IdentLoc.isValid() && "Invalid NamespceName location.");
3023 assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
3025 UsingDirectiveDecl *UDir = 0;
3027 // Lookup namespace name.
3028 LookupResult R(*this, NamespcName, IdentLoc, LookupNamespaceName);
3029 LookupParsedName(R, S, &SS);
3030 if (R.isAmbiguous())
3034 NamedDecl *Named = R.getFoundDecl();
3035 assert((isa<NamespaceDecl>(Named) || isa<NamespaceAliasDecl>(Named))
3036 && "expected namespace decl");
3037 // C++ [namespace.udir]p1:
3038 // A using-directive specifies that the names in the nominated
3039 // namespace can be used in the scope in which the
3040 // using-directive appears after the using-directive. During
3041 // unqualified name lookup (3.4.1), the names appear as if they
3042 // were declared in the nearest enclosing namespace which
3043 // contains both the using-directive and the nominated
3044 // namespace. [Note: in this context, "contains" means "contains
3045 // directly or indirectly". ]
3047 // Find enclosing context containing both using-directive and
3048 // nominated namespace.
3049 NamespaceDecl *NS = getNamespaceDecl(Named);
3050 DeclContext *CommonAncestor = cast<DeclContext>(NS);
3051 while (CommonAncestor && !CommonAncestor->Encloses(CurContext))
3052 CommonAncestor = CommonAncestor->getParent();
3054 UDir = UsingDirectiveDecl::Create(Context, CurContext, UsingLoc, NamespcLoc,
3056 (NestedNameSpecifier *)SS.getScopeRep(),
3057 IdentLoc, Named, CommonAncestor);
3058 PushUsingDirective(S, UDir);
3060 Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
3063 // FIXME: We ignore attributes for now.
3065 return DeclPtrTy::make(UDir);
3068 void Sema::PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir) {
3069 // If scope has associated entity, then using directive is at namespace
3070 // or translation unit scope. We add UsingDirectiveDecls, into
3071 // it's lookup structure.
3072 if (DeclContext *Ctx = static_cast<DeclContext*>(S->getEntity()))
3075 // Otherwise it is block-sope. using-directives will affect lookup
3076 // only to the end of scope.
3077 S->PushUsingDirective(DeclPtrTy::make(UDir));
3081 Sema::DeclPtrTy Sema::ActOnUsingDeclaration(Scope *S,
3083 bool HasUsingKeyword,
3084 SourceLocation UsingLoc,
3085 const CXXScopeSpec &SS,
3086 UnqualifiedId &Name,
3087 AttributeList *AttrList,
3089 SourceLocation TypenameLoc) {
3090 assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
3092 switch (Name.getKind()) {
3093 case UnqualifiedId::IK_Identifier:
3094 case UnqualifiedId::IK_OperatorFunctionId:
3095 case UnqualifiedId::IK_LiteralOperatorId:
3096 case UnqualifiedId::IK_ConversionFunctionId:
3099 case UnqualifiedId::IK_ConstructorName:
3100 case UnqualifiedId::IK_ConstructorTemplateId:
3101 // C++0x inherited constructors.
3102 if (getLangOptions().CPlusPlus0x) break;
3104 Diag(Name.getSourceRange().getBegin(), diag::err_using_decl_constructor)
3108 case UnqualifiedId::IK_DestructorName:
3109 Diag(Name.getSourceRange().getBegin(), diag::err_using_decl_destructor)
3113 case UnqualifiedId::IK_TemplateId:
3114 Diag(Name.getSourceRange().getBegin(), diag::err_using_decl_template_id)
3115 << SourceRange(Name.TemplateId->LAngleLoc, Name.TemplateId->RAngleLoc);
3119 DeclarationName TargetName = GetNameFromUnqualifiedId(Name);
3123 // Warn about using declarations.
3124 // TODO: store that the declaration was written without 'using' and
3125 // talk about access decls instead of using decls in the
3127 if (!HasUsingKeyword) {
3128 UsingLoc = Name.getSourceRange().getBegin();
3130 Diag(UsingLoc, diag::warn_access_decl_deprecated)
3131 << FixItHint::CreateInsertion(SS.getRange().getBegin(), "using ");
3134 NamedDecl *UD = BuildUsingDeclaration(S, AS, UsingLoc, SS,
3135 Name.getSourceRange().getBegin(),
3136 TargetName, AttrList,
3137 /* IsInstantiation */ false,
3138 IsTypeName, TypenameLoc);
3140 PushOnScopeChains(UD, S, /*AddToContext*/ false);
3142 return DeclPtrTy::make(UD);
3145 /// Determines whether to create a using shadow decl for a particular
3146 /// decl, given the set of decls existing prior to this using lookup.
3147 bool Sema::CheckUsingShadowDecl(UsingDecl *Using, NamedDecl *Orig,
3148 const LookupResult &Previous) {
3149 // Diagnose finding a decl which is not from a base class of the
3150 // current class. We do this now because there are cases where this
3151 // function will silently decide not to build a shadow decl, which
3152 // will pre-empt further diagnostics.
3154 // We don't need to do this in C++0x because we do the check once on
3157 // FIXME: diagnose the following if we care enough:
3158 // struct A { int foo; };
3159 // struct B : A { using A::foo; };
3160 // template <class T> struct C : A {};
3161 // template <class T> struct D : C<T> { using B::foo; } // <---
3162 // This is invalid (during instantiation) in C++03 because B::foo
3163 // resolves to the using decl in B, which is not a base class of D<T>.
3164 // We can't diagnose it immediately because C<T> is an unknown
3165 // specialization. The UsingShadowDecl in D<T> then points directly
3166 // to A::foo, which will look well-formed when we instantiate.
3167 // The right solution is to not collapse the shadow-decl chain.
3168 if (!getLangOptions().CPlusPlus0x && CurContext->isRecord()) {
3169 DeclContext *OrigDC = Orig->getDeclContext();
3171 // Handle enums and anonymous structs.
3172 if (isa<EnumDecl>(OrigDC)) OrigDC = OrigDC->getParent();
3173 CXXRecordDecl *OrigRec = cast<CXXRecordDecl>(OrigDC);
3174 while (OrigRec->isAnonymousStructOrUnion())
3175 OrigRec = cast<CXXRecordDecl>(OrigRec->getDeclContext());
3177 if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(OrigRec)) {
3178 if (OrigDC == CurContext) {
3179 Diag(Using->getLocation(),
3180 diag::err_using_decl_nested_name_specifier_is_current_class)
3181 << Using->getNestedNameRange();
3182 Diag(Orig->getLocation(), diag::note_using_decl_target);
3186 Diag(Using->getNestedNameRange().getBegin(),
3187 diag::err_using_decl_nested_name_specifier_is_not_base_class)
3188 << Using->getTargetNestedNameDecl()
3189 << cast<CXXRecordDecl>(CurContext)
3190 << Using->getNestedNameRange();
3191 Diag(Orig->getLocation(), diag::note_using_decl_target);
3196 if (Previous.empty()) return false;
3198 NamedDecl *Target = Orig;
3199 if (isa<UsingShadowDecl>(Target))
3200 Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
3202 // If the target happens to be one of the previous declarations, we
3203 // don't have a conflict.
3205 // FIXME: but we might be increasing its access, in which case we
3206 // should redeclare it.
3207 NamedDecl *NonTag = 0, *Tag = 0;
3208 for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
3210 NamedDecl *D = (*I)->getUnderlyingDecl();
3211 if (D->getCanonicalDecl() == Target->getCanonicalDecl())
3214 (isa<TagDecl>(D) ? Tag : NonTag) = D;
3217 if (Target->isFunctionOrFunctionTemplate()) {
3219 if (isa<FunctionTemplateDecl>(Target))
3220 FD = cast<FunctionTemplateDecl>(Target)->getTemplatedDecl();
3222 FD = cast<FunctionDecl>(Target);
3224 NamedDecl *OldDecl = 0;
3225 switch (CheckOverload(FD, Previous, OldDecl)) {
3229 case Ovl_NonFunction:
3230 Diag(Using->getLocation(), diag::err_using_decl_conflict);
3233 // We found a decl with the exact signature.
3235 if (isa<UsingShadowDecl>(OldDecl)) {
3236 // Silently ignore the possible conflict.
3240 // If we're in a record, we want to hide the target, so we
3241 // return true (without a diagnostic) to tell the caller not to
3242 // build a shadow decl.
3243 if (CurContext->isRecord())
3246 // If we're not in a record, this is an error.
3247 Diag(Using->getLocation(), diag::err_using_decl_conflict);
3251 Diag(Target->getLocation(), diag::note_using_decl_target);
3252 Diag(OldDecl->getLocation(), diag::note_using_decl_conflict);
3256 // Target is not a function.
3258 if (isa<TagDecl>(Target)) {
3259 // No conflict between a tag and a non-tag.
3260 if (!Tag) return false;
3262 Diag(Using->getLocation(), diag::err_using_decl_conflict);
3263 Diag(Target->getLocation(), diag::note_using_decl_target);
3264 Diag(Tag->getLocation(), diag::note_using_decl_conflict);
3268 // No conflict between a tag and a non-tag.
3269 if (!NonTag) return false;
3271 Diag(Using->getLocation(), diag::err_using_decl_conflict);
3272 Diag(Target->getLocation(), diag::note_using_decl_target);
3273 Diag(NonTag->getLocation(), diag::note_using_decl_conflict);
3277 /// Builds a shadow declaration corresponding to a 'using' declaration.
3278 UsingShadowDecl *Sema::BuildUsingShadowDecl(Scope *S,
3282 // If we resolved to another shadow declaration, just coalesce them.
3283 NamedDecl *Target = Orig;
3284 if (isa<UsingShadowDecl>(Target)) {
3285 Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
3286 assert(!isa<UsingShadowDecl>(Target) && "nested shadow declaration");
3289 UsingShadowDecl *Shadow
3290 = UsingShadowDecl::Create(Context, CurContext,
3291 UD->getLocation(), UD, Target);
3292 UD->addShadowDecl(Shadow);
3295 PushOnScopeChains(Shadow, S);
3297 CurContext->addDecl(Shadow);
3298 Shadow->setAccess(UD->getAccess());
3300 // Register it as a conversion if appropriate.
3301 if (Shadow->getDeclName().getNameKind()
3302 == DeclarationName::CXXConversionFunctionName)
3303 cast<CXXRecordDecl>(CurContext)->addConversionFunction(Shadow);
3305 if (Orig->isInvalidDecl() || UD->isInvalidDecl())
3306 Shadow->setInvalidDecl();
3311 /// Hides a using shadow declaration. This is required by the current
3312 /// using-decl implementation when a resolvable using declaration in a
3313 /// class is followed by a declaration which would hide or override
3314 /// one or more of the using decl's targets; for example:
3316 /// struct Base { void foo(int); };
3317 /// struct Derived : Base {
3318 /// using Base::foo;
3322 /// The governing language is C++03 [namespace.udecl]p12:
3324 /// When a using-declaration brings names from a base class into a
3325 /// derived class scope, member functions in the derived class
3326 /// override and/or hide member functions with the same name and
3327 /// parameter types in a base class (rather than conflicting).
3329 /// There are two ways to implement this:
3330 /// (1) optimistically create shadow decls when they're not hidden
3331 /// by existing declarations, or
3332 /// (2) don't create any shadow decls (or at least don't make them
3333 /// visible) until we've fully parsed/instantiated the class.
3334 /// The problem with (1) is that we might have to retroactively remove
3335 /// a shadow decl, which requires several O(n) operations because the
3336 /// decl structures are (very reasonably) not designed for removal.
3337 /// (2) avoids this but is very fiddly and phase-dependent.
3338 void Sema::HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow) {
3339 if (Shadow->getDeclName().getNameKind() ==
3340 DeclarationName::CXXConversionFunctionName)
3341 cast<CXXRecordDecl>(Shadow->getDeclContext())->removeConversion(Shadow);
3343 // Remove it from the DeclContext...
3344 Shadow->getDeclContext()->removeDecl(Shadow);
3346 // ...and the scope, if applicable...
3348 S->RemoveDecl(DeclPtrTy::make(static_cast<Decl*>(Shadow)));
3349 IdResolver.RemoveDecl(Shadow);
3352 // ...and the using decl.
3353 Shadow->getUsingDecl()->removeShadowDecl(Shadow);
3355 // TODO: complain somehow if Shadow was used. It shouldn't
3356 // be possible for this to happen, because...?
3359 /// Builds a using declaration.
3361 /// \param IsInstantiation - Whether this call arises from an
3362 /// instantiation of an unresolved using declaration. We treat
3363 /// the lookup differently for these declarations.
3364 NamedDecl *Sema::BuildUsingDeclaration(Scope *S, AccessSpecifier AS,
3365 SourceLocation UsingLoc,
3366 const CXXScopeSpec &SS,
3367 SourceLocation IdentLoc,
3368 DeclarationName Name,
3369 AttributeList *AttrList,
3370 bool IsInstantiation,
3372 SourceLocation TypenameLoc) {
3373 assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
3374 assert(IdentLoc.isValid() && "Invalid TargetName location.");
3376 // FIXME: We ignore attributes for now.
3380 Diag(IdentLoc, diag::err_using_requires_qualname);
3384 // Do the redeclaration lookup in the current scope.
3385 LookupResult Previous(*this, Name, IdentLoc, LookupUsingDeclName,
3387 Previous.setHideTags(false);
3389 LookupName(Previous, S);
3391 // It is really dumb that we have to do this.
3392 LookupResult::Filter F = Previous.makeFilter();
3393 while (F.hasNext()) {
3394 NamedDecl *D = F.next();
3395 if (!isDeclInScope(D, CurContext, S))
3400 assert(IsInstantiation && "no scope in non-instantiation");
3401 assert(CurContext->isRecord() && "scope not record in instantiation");
3402 LookupQualifiedName(Previous, CurContext);
3405 NestedNameSpecifier *NNS =
3406 static_cast<NestedNameSpecifier *>(SS.getScopeRep());
3408 // Check for invalid redeclarations.
3409 if (CheckUsingDeclRedeclaration(UsingLoc, IsTypeName, SS, IdentLoc, Previous))
3412 // Check for bad qualifiers.
3413 if (CheckUsingDeclQualifier(UsingLoc, SS, IdentLoc))
3416 DeclContext *LookupContext = computeDeclContext(SS);
3418 if (!LookupContext) {
3420 // FIXME: not all declaration name kinds are legal here
3421 D = UnresolvedUsingTypenameDecl::Create(Context, CurContext,
3422 UsingLoc, TypenameLoc,
3426 D = UnresolvedUsingValueDecl::Create(Context, CurContext,
3427 UsingLoc, SS.getRange(), NNS,
3431 D = UsingDecl::Create(Context, CurContext, IdentLoc,
3432 SS.getRange(), UsingLoc, NNS, Name,
3436 CurContext->addDecl(D);
3438 if (!LookupContext) return D;
3439 UsingDecl *UD = cast<UsingDecl>(D);
3441 if (RequireCompleteDeclContext(SS)) {
3442 UD->setInvalidDecl();
3446 // Look up the target name.
3448 LookupResult R(*this, Name, IdentLoc, LookupOrdinaryName);
3450 // Unlike most lookups, we don't always want to hide tag
3451 // declarations: tag names are visible through the using declaration
3452 // even if hidden by ordinary names, *except* in a dependent context
3453 // where it's important for the sanity of two-phase lookup.
3454 if (!IsInstantiation)
3455 R.setHideTags(false);
3457 LookupQualifiedName(R, LookupContext);
3460 Diag(IdentLoc, diag::err_no_member)
3461 << Name << LookupContext << SS.getRange();
3462 UD->setInvalidDecl();
3466 if (R.isAmbiguous()) {
3467 UD->setInvalidDecl();
3472 // If we asked for a typename and got a non-type decl, error out.
3473 if (!R.getAsSingle<TypeDecl>()) {
3474 Diag(IdentLoc, diag::err_using_typename_non_type);
3475 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I)
3476 Diag((*I)->getUnderlyingDecl()->getLocation(),
3477 diag::note_using_decl_target);
3478 UD->setInvalidDecl();
3482 // If we asked for a non-typename and we got a type, error out,
3483 // but only if this is an instantiation of an unresolved using
3484 // decl. Otherwise just silently find the type name.
3485 if (IsInstantiation && R.getAsSingle<TypeDecl>()) {
3486 Diag(IdentLoc, diag::err_using_dependent_value_is_type);
3487 Diag(R.getFoundDecl()->getLocation(), diag::note_using_decl_target);
3488 UD->setInvalidDecl();
3493 // C++0x N2914 [namespace.udecl]p6:
3494 // A using-declaration shall not name a namespace.
3495 if (R.getAsSingle<NamespaceDecl>()) {
3496 Diag(IdentLoc, diag::err_using_decl_can_not_refer_to_namespace)
3498 UD->setInvalidDecl();
3502 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {
3503 if (!CheckUsingShadowDecl(UD, *I, Previous))
3504 BuildUsingShadowDecl(S, UD, *I);
3510 /// Checks that the given using declaration is not an invalid
3511 /// redeclaration. Note that this is checking only for the using decl
3512 /// itself, not for any ill-formedness among the UsingShadowDecls.
3513 bool Sema::CheckUsingDeclRedeclaration(SourceLocation UsingLoc,
3515 const CXXScopeSpec &SS,
3516 SourceLocation NameLoc,
3517 const LookupResult &Prev) {
3518 // C++03 [namespace.udecl]p8:
3519 // C++0x [namespace.udecl]p10:
3520 // A using-declaration is a declaration and can therefore be used
3521 // repeatedly where (and only where) multiple declarations are
3523 // That's only in file contexts.
3524 if (CurContext->getLookupContext()->isFileContext())
3527 NestedNameSpecifier *Qual
3528 = static_cast<NestedNameSpecifier*>(SS.getScopeRep());
3530 for (LookupResult::iterator I = Prev.begin(), E = Prev.end(); I != E; ++I) {
3534 NestedNameSpecifier *DQual;
3535 if (UsingDecl *UD = dyn_cast<UsingDecl>(D)) {
3536 DTypename = UD->isTypeName();
3537 DQual = UD->getTargetNestedNameDecl();
3538 } else if (UnresolvedUsingValueDecl *UD
3539 = dyn_cast<UnresolvedUsingValueDecl>(D)) {
3541 DQual = UD->getTargetNestedNameSpecifier();
3542 } else if (UnresolvedUsingTypenameDecl *UD
3543 = dyn_cast<UnresolvedUsingTypenameDecl>(D)) {
3545 DQual = UD->getTargetNestedNameSpecifier();
3548 // using decls differ if one says 'typename' and the other doesn't.
3549 // FIXME: non-dependent using decls?
3550 if (isTypeName != DTypename) continue;
3552 // using decls differ if they name different scopes (but note that
3553 // template instantiation can cause this check to trigger when it
3554 // didn't before instantiation).
3555 if (Context.getCanonicalNestedNameSpecifier(Qual) !=
3556 Context.getCanonicalNestedNameSpecifier(DQual))
3559 Diag(NameLoc, diag::err_using_decl_redeclaration) << SS.getRange();
3560 Diag(D->getLocation(), diag::note_using_decl) << 1;
3568 /// Checks that the given nested-name qualifier used in a using decl
3569 /// in the current context is appropriately related to the current
3570 /// scope. If an error is found, diagnoses it and returns true.
3571 bool Sema::CheckUsingDeclQualifier(SourceLocation UsingLoc,
3572 const CXXScopeSpec &SS,
3573 SourceLocation NameLoc) {
3574 DeclContext *NamedContext = computeDeclContext(SS);
3576 if (!CurContext->isRecord()) {
3577 // C++03 [namespace.udecl]p3:
3578 // C++0x [namespace.udecl]p8:
3579 // A using-declaration for a class member shall be a member-declaration.
3581 // If we weren't able to compute a valid scope, it must be a
3582 // dependent class scope.
3583 if (!NamedContext || NamedContext->isRecord()) {
3584 Diag(NameLoc, diag::err_using_decl_can_not_refer_to_class_member)
3589 // Otherwise, everything is known to be fine.
3593 // The current scope is a record.
3595 // If the named context is dependent, we can't decide much.
3596 if (!NamedContext) {
3597 // FIXME: in C++0x, we can diagnose if we can prove that the
3598 // nested-name-specifier does not refer to a base class, which is
3599 // still possible in some cases.
3601 // Otherwise we have to conservatively report that things might be
3606 if (!NamedContext->isRecord()) {
3607 // Ideally this would point at the last name in the specifier,
3608 // but we don't have that level of source info.
3609 Diag(SS.getRange().getBegin(),
3610 diag::err_using_decl_nested_name_specifier_is_not_class)
3611 << (NestedNameSpecifier*) SS.getScopeRep() << SS.getRange();
3615 if (getLangOptions().CPlusPlus0x) {
3616 // C++0x [namespace.udecl]p3:
3617 // In a using-declaration used as a member-declaration, the
3618 // nested-name-specifier shall name a base class of the class
3621 if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(
3622 cast<CXXRecordDecl>(NamedContext))) {
3623 if (CurContext == NamedContext) {
3625 diag::err_using_decl_nested_name_specifier_is_current_class)
3630 Diag(SS.getRange().getBegin(),
3631 diag::err_using_decl_nested_name_specifier_is_not_base_class)
3632 << (NestedNameSpecifier*) SS.getScopeRep()
3633 << cast<CXXRecordDecl>(CurContext)
3641 // C++03 [namespace.udecl]p4:
3642 // A using-declaration used as a member-declaration shall refer
3643 // to a member of a base class of the class being defined [etc.].
3645 // Salient point: SS doesn't have to name a base class as long as
3646 // lookup only finds members from base classes. Therefore we can
3647 // diagnose here only if we can prove that that can't happen,
3648 // i.e. if the class hierarchies provably don't intersect.
3650 // TODO: it would be nice if "definitely valid" results were cached
3651 // in the UsingDecl and UsingShadowDecl so that these checks didn't
3652 // need to be repeated.
3655 llvm::DenseSet<const CXXRecordDecl*> Bases;
3657 static bool collect(const CXXRecordDecl *Base, void *OpaqueData) {
3658 UserData *Data = reinterpret_cast<UserData*>(OpaqueData);
3659 Data->Bases.insert(Base);
3663 bool hasDependentBases(const CXXRecordDecl *Class) {
3664 return !Class->forallBases(collect, this);
3667 /// Returns true if the base is dependent or is one of the
3668 /// accumulated base classes.
3669 static bool doesNotContain(const CXXRecordDecl *Base, void *OpaqueData) {
3670 UserData *Data = reinterpret_cast<UserData*>(OpaqueData);
3671 return !Data->Bases.count(Base);
3674 bool mightShareBases(const CXXRecordDecl *Class) {
3675 return Bases.count(Class) || !Class->forallBases(doesNotContain, this);
3681 // Returns false if we find a dependent base.
3682 if (Data.hasDependentBases(cast<CXXRecordDecl>(CurContext)))
3685 // Returns false if the class has a dependent base or if it or one
3686 // of its bases is present in the base set of the current context.
3687 if (Data.mightShareBases(cast<CXXRecordDecl>(NamedContext)))
3690 Diag(SS.getRange().getBegin(),
3691 diag::err_using_decl_nested_name_specifier_is_not_base_class)
3692 << (NestedNameSpecifier*) SS.getScopeRep()
3693 << cast<CXXRecordDecl>(CurContext)
3699 Sema::DeclPtrTy Sema::ActOnNamespaceAliasDef(Scope *S,
3700 SourceLocation NamespaceLoc,
3701 SourceLocation AliasLoc,
3702 IdentifierInfo *Alias,
3703 const CXXScopeSpec &SS,
3704 SourceLocation IdentLoc,
3705 IdentifierInfo *Ident) {
3707 // Lookup the namespace name.
3708 LookupResult R(*this, Ident, IdentLoc, LookupNamespaceName);
3709 LookupParsedName(R, S, &SS);
3711 // Check if we have a previous declaration with the same name.
3712 if (NamedDecl *PrevDecl
3713 = LookupSingleName(S, Alias, LookupOrdinaryName, ForRedeclaration)) {
3714 if (NamespaceAliasDecl *AD = dyn_cast<NamespaceAliasDecl>(PrevDecl)) {
3715 // We already have an alias with the same name that points to the same
3716 // namespace, so don't create a new one.
3717 // FIXME: At some point, we'll want to create the (redundant)
3718 // declaration to maintain better source information.
3719 if (!R.isAmbiguous() && !R.empty() &&
3720 AD->getNamespace()->Equals(getNamespaceDecl(R.getFoundDecl())))
3724 unsigned DiagID = isa<NamespaceDecl>(PrevDecl) ? diag::err_redefinition :
3725 diag::err_redefinition_different_kind;
3726 Diag(AliasLoc, DiagID) << Alias;
3727 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
3731 if (R.isAmbiguous())
3735 Diag(NamespaceLoc, diag::err_expected_namespace_name) << SS.getRange();
3739 NamespaceAliasDecl *AliasDecl =
3740 NamespaceAliasDecl::Create(Context, CurContext, NamespaceLoc, AliasLoc,
3741 Alias, SS.getRange(),
3742 (NestedNameSpecifier *)SS.getScopeRep(),
3743 IdentLoc, R.getFoundDecl());
3745 PushOnScopeChains(AliasDecl, S);
3746 return DeclPtrTy::make(AliasDecl);
3749 void Sema::DefineImplicitDefaultConstructor(SourceLocation CurrentLocation,
3750 CXXConstructorDecl *Constructor) {
3751 assert((Constructor->isImplicit() && Constructor->isDefaultConstructor() &&
3752 !Constructor->isUsed()) &&
3753 "DefineImplicitDefaultConstructor - call it for implicit default ctor");
3755 CXXRecordDecl *ClassDecl
3756 = cast<CXXRecordDecl>(Constructor->getDeclContext());
3757 assert(ClassDecl && "DefineImplicitDefaultConstructor - invalid constructor");
3759 DeclContext *PreviousContext = CurContext;
3760 CurContext = Constructor;
3761 if (SetBaseOrMemberInitializers(Constructor, 0, 0, /*AnyErrors=*/false)) {
3762 Diag(CurrentLocation, diag::note_member_synthesized_at)
3763 << CXXDefaultConstructor << Context.getTagDeclType(ClassDecl);
3764 Constructor->setInvalidDecl();
3766 Constructor->setUsed();
3768 CurContext = PreviousContext;
3771 void Sema::DefineImplicitDestructor(SourceLocation CurrentLocation,
3772 CXXDestructorDecl *Destructor) {
3773 assert((Destructor->isImplicit() && !Destructor->isUsed()) &&
3774 "DefineImplicitDestructor - call it for implicit default dtor");
3775 CXXRecordDecl *ClassDecl = Destructor->getParent();
3776 assert(ClassDecl && "DefineImplicitDestructor - invalid destructor");
3778 DeclContext *PreviousContext = CurContext;
3779 CurContext = Destructor;
3781 MarkBaseAndMemberDestructorsReferenced(Destructor->getLocation(),
3782 Destructor->getParent());
3784 // FIXME: If CheckDestructor fails, we should emit a note about where the
3785 // implicit destructor was needed.
3786 if (CheckDestructor(Destructor)) {
3787 Diag(CurrentLocation, diag::note_member_synthesized_at)
3788 << CXXDestructor << Context.getTagDeclType(ClassDecl);
3790 Destructor->setInvalidDecl();
3791 CurContext = PreviousContext;
3795 CurContext = PreviousContext;
3797 Destructor->setUsed();
3800 void Sema::DefineImplicitOverloadedAssign(SourceLocation CurrentLocation,
3801 CXXMethodDecl *MethodDecl) {
3802 assert((MethodDecl->isImplicit() && MethodDecl->isOverloadedOperator() &&
3803 MethodDecl->getOverloadedOperator() == OO_Equal &&
3804 !MethodDecl->isUsed()) &&
3805 "DefineImplicitOverloadedAssign - call it for implicit assignment op");
3807 CXXRecordDecl *ClassDecl
3808 = cast<CXXRecordDecl>(MethodDecl->getDeclContext());
3810 DeclContext *PreviousContext = CurContext;
3811 CurContext = MethodDecl;
3813 // C++[class.copy] p12
3814 // Before the implicitly-declared copy assignment operator for a class is
3815 // implicitly defined, all implicitly-declared copy assignment operators
3816 // for its direct base classes and its nonstatic data members shall have
3817 // been implicitly defined.
3819 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
3820 E = ClassDecl->bases_end(); Base != E; ++Base) {
3821 CXXRecordDecl *BaseClassDecl
3822 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
3823 if (CXXMethodDecl *BaseAssignOpMethod =
3824 getAssignOperatorMethod(CurrentLocation, MethodDecl->getParamDecl(0),
3826 CheckDirectMemberAccess(Base->getSourceRange().getBegin(),
3828 PDiag(diag::err_access_assign_base)
3829 << Base->getType());
3831 MarkDeclarationReferenced(CurrentLocation, BaseAssignOpMethod);
3834 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
3835 E = ClassDecl->field_end(); Field != E; ++Field) {
3836 QualType FieldType = Context.getCanonicalType((*Field)->getType());
3837 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
3838 FieldType = Array->getElementType();
3839 if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
3840 CXXRecordDecl *FieldClassDecl
3841 = cast<CXXRecordDecl>(FieldClassType->getDecl());
3842 if (CXXMethodDecl *FieldAssignOpMethod =
3843 getAssignOperatorMethod(CurrentLocation, MethodDecl->getParamDecl(0),
3845 CheckDirectMemberAccess(Field->getLocation(),
3846 FieldAssignOpMethod,
3847 PDiag(diag::err_access_assign_field)
3848 << Field->getDeclName() << Field->getType());
3850 MarkDeclarationReferenced(CurrentLocation, FieldAssignOpMethod);
3852 } else if (FieldType->isReferenceType()) {
3853 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
3854 << Context.getTagDeclType(ClassDecl) << 0 << Field->getDeclName();
3855 Diag(Field->getLocation(), diag::note_declared_at);
3856 Diag(CurrentLocation, diag::note_first_required_here);
3858 } else if (FieldType.isConstQualified()) {
3859 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
3860 << Context.getTagDeclType(ClassDecl) << 1 << Field->getDeclName();
3861 Diag(Field->getLocation(), diag::note_declared_at);
3862 Diag(CurrentLocation, diag::note_first_required_here);
3867 MethodDecl->setUsed();
3869 CurContext = PreviousContext;
3873 Sema::getAssignOperatorMethod(SourceLocation CurrentLocation,
3874 ParmVarDecl *ParmDecl,
3875 CXXRecordDecl *ClassDecl) {
3876 QualType LHSType = Context.getTypeDeclType(ClassDecl);
3877 QualType RHSType(LHSType);
3878 // If class's assignment operator argument is const/volatile qualified,
3879 // look for operator = (const/volatile B&). Otherwise, look for
3881 RHSType = Context.getCVRQualifiedType(RHSType,
3882 ParmDecl->getType().getCVRQualifiers());
3883 ExprOwningPtr<Expr> LHS(this, new (Context) DeclRefExpr(ParmDecl,
3886 ExprOwningPtr<Expr> RHS(this, new (Context) DeclRefExpr(ParmDecl,
3889 Expr *Args[2] = { &*LHS, &*RHS };
3890 OverloadCandidateSet CandidateSet(CurrentLocation);
3891 AddMemberOperatorCandidates(clang::OO_Equal, SourceLocation(), Args, 2,
3893 OverloadCandidateSet::iterator Best;
3894 if (BestViableFunction(CandidateSet, CurrentLocation, Best) == OR_Success)
3895 return cast<CXXMethodDecl>(Best->Function);
3897 "getAssignOperatorMethod - copy assignment operator method not found");
3901 void Sema::DefineImplicitCopyConstructor(SourceLocation CurrentLocation,
3902 CXXConstructorDecl *CopyConstructor,
3903 unsigned TypeQuals) {
3904 assert((CopyConstructor->isImplicit() &&
3905 CopyConstructor->isCopyConstructor(TypeQuals) &&
3906 !CopyConstructor->isUsed()) &&
3907 "DefineImplicitCopyConstructor - call it for implicit copy ctor");
3909 CXXRecordDecl *ClassDecl
3910 = cast<CXXRecordDecl>(CopyConstructor->getDeclContext());
3911 assert(ClassDecl && "DefineImplicitCopyConstructor - invalid constructor");
3913 DeclContext *PreviousContext = CurContext;
3914 CurContext = CopyConstructor;
3916 // C++ [class.copy] p209
3917 // Before the implicitly-declared copy constructor for a class is
3918 // implicitly defined, all the implicitly-declared copy constructors
3919 // for its base class and its non-static data members shall have been
3920 // implicitly defined.
3921 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin();
3922 Base != ClassDecl->bases_end(); ++Base) {
3923 CXXRecordDecl *BaseClassDecl
3924 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
3925 if (CXXConstructorDecl *BaseCopyCtor =
3926 BaseClassDecl->getCopyConstructor(Context, TypeQuals)) {
3927 CheckDirectMemberAccess(Base->getSourceRange().getBegin(),
3929 PDiag(diag::err_access_copy_base)
3930 << Base->getType());
3932 MarkDeclarationReferenced(CurrentLocation, BaseCopyCtor);
3935 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
3936 FieldEnd = ClassDecl->field_end();
3937 Field != FieldEnd; ++Field) {
3938 QualType FieldType = Context.getCanonicalType((*Field)->getType());
3939 if (const ArrayType *Array = Context.getAsArrayType(FieldType))
3940 FieldType = Array->getElementType();
3941 if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
3942 CXXRecordDecl *FieldClassDecl
3943 = cast<CXXRecordDecl>(FieldClassType->getDecl());
3944 if (CXXConstructorDecl *FieldCopyCtor =
3945 FieldClassDecl->getCopyConstructor(Context, TypeQuals)) {
3946 CheckDirectMemberAccess(Field->getLocation(),
3948 PDiag(diag::err_access_copy_field)
3949 << Field->getDeclName() << Field->getType());
3951 MarkDeclarationReferenced(CurrentLocation, FieldCopyCtor);
3955 CopyConstructor->setUsed();
3957 CurContext = PreviousContext;
3960 Sema::OwningExprResult
3961 Sema::BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
3962 CXXConstructorDecl *Constructor,
3963 MultiExprArg ExprArgs,
3964 bool RequiresZeroInit,
3965 bool BaseInitialization) {
3966 bool Elidable = false;
3968 // C++ [class.copy]p15:
3969 // Whenever a temporary class object is copied using a copy constructor, and
3970 // this object and the copy have the same cv-unqualified type, an
3971 // implementation is permitted to treat the original and the copy as two
3972 // different ways of referring to the same object and not perform a copy at
3973 // all, even if the class copy constructor or destructor have side effects.
3975 // FIXME: Is this enough?
3976 if (Constructor->isCopyConstructor()) {
3977 Expr *E = ((Expr **)ExprArgs.get())[0];
3978 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
3979 if (ICE->getCastKind() == CastExpr::CK_NoOp)
3980 E = ICE->getSubExpr();
3981 if (CXXFunctionalCastExpr *FCE = dyn_cast<CXXFunctionalCastExpr>(E))
3982 E = FCE->getSubExpr();
3983 while (CXXBindTemporaryExpr *BE = dyn_cast<CXXBindTemporaryExpr>(E))
3984 E = BE->getSubExpr();
3985 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
3986 if (ICE->getCastKind() == CastExpr::CK_NoOp)
3987 E = ICE->getSubExpr();
3989 if (CallExpr *CE = dyn_cast<CallExpr>(E))
3990 Elidable = !CE->getCallReturnType()->isReferenceType();
3991 else if (isa<CXXTemporaryObjectExpr>(E))
3993 else if (isa<CXXConstructExpr>(E))
3997 return BuildCXXConstructExpr(ConstructLoc, DeclInitType, Constructor,
3998 Elidable, move(ExprArgs), RequiresZeroInit,
3999 BaseInitialization);
4002 /// BuildCXXConstructExpr - Creates a complete call to a constructor,
4003 /// including handling of its default argument expressions.
4004 Sema::OwningExprResult
4005 Sema::BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
4006 CXXConstructorDecl *Constructor, bool Elidable,
4007 MultiExprArg ExprArgs,
4008 bool RequiresZeroInit,
4009 bool BaseInitialization) {
4010 unsigned NumExprs = ExprArgs.size();
4011 Expr **Exprs = (Expr **)ExprArgs.release();
4013 MarkDeclarationReferenced(ConstructLoc, Constructor);
4014 return Owned(CXXConstructExpr::Create(Context, DeclInitType, ConstructLoc,
4015 Constructor, Elidable, Exprs, NumExprs,
4016 RequiresZeroInit, BaseInitialization));
4019 bool Sema::InitializeVarWithConstructor(VarDecl *VD,
4020 CXXConstructorDecl *Constructor,
4021 MultiExprArg Exprs) {
4022 OwningExprResult TempResult =
4023 BuildCXXConstructExpr(VD->getLocation(), VD->getType(), Constructor,
4025 if (TempResult.isInvalid())
4028 Expr *Temp = TempResult.takeAs<Expr>();
4029 MarkDeclarationReferenced(VD->getLocation(), Constructor);
4030 Temp = MaybeCreateCXXExprWithTemporaries(Temp);
4036 void Sema::FinalizeVarWithDestructor(VarDecl *VD, const RecordType *Record) {
4037 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Record->getDecl());
4038 if (!ClassDecl->isInvalidDecl() && !VD->isInvalidDecl() &&
4039 !ClassDecl->hasTrivialDestructor()) {
4040 CXXDestructorDecl *Destructor = ClassDecl->getDestructor(Context);
4041 MarkDeclarationReferenced(VD->getLocation(), Destructor);
4042 CheckDestructorAccess(VD->getLocation(), Destructor,
4043 PDiag(diag::err_access_dtor_var)
4044 << VD->getDeclName()
4049 /// AddCXXDirectInitializerToDecl - This action is called immediately after
4050 /// ActOnDeclarator, when a C++ direct initializer is present.
4051 /// e.g: "int x(1);"
4052 void Sema::AddCXXDirectInitializerToDecl(DeclPtrTy Dcl,
4053 SourceLocation LParenLoc,
4055 SourceLocation *CommaLocs,
4056 SourceLocation RParenLoc) {
4057 assert(Exprs.size() != 0 && Exprs.get() && "missing expressions");
4058 Decl *RealDecl = Dcl.getAs<Decl>();
4060 // If there is no declaration, there was an error parsing it. Just ignore
4065 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
4067 Diag(RealDecl->getLocation(), diag::err_illegal_initializer);
4068 RealDecl->setInvalidDecl();
4072 // We will represent direct-initialization similarly to copy-initialization:
4073 // int x(1); -as-> int x = 1;
4074 // ClassType x(a,b,c); -as-> ClassType x = ClassType(a,b,c);
4076 // Clients that want to distinguish between the two forms, can check for
4077 // direct initializer using VarDecl::hasCXXDirectInitializer().
4078 // A major benefit is that clients that don't particularly care about which
4079 // exactly form was it (like the CodeGen) can handle both cases without
4080 // special case code.
4083 // The form of initialization (using parentheses or '=') is generally
4084 // insignificant, but does matter when the entity being initialized has a
4086 QualType DeclInitType = VDecl->getType();
4087 if (const ArrayType *Array = Context.getAsArrayType(DeclInitType))
4088 DeclInitType = Context.getBaseElementType(Array);
4090 if (!VDecl->getType()->isDependentType() &&
4091 RequireCompleteType(VDecl->getLocation(), VDecl->getType(),
4092 diag::err_typecheck_decl_incomplete_type)) {
4093 VDecl->setInvalidDecl();
4097 // The variable can not have an abstract class type.
4098 if (RequireNonAbstractType(VDecl->getLocation(), VDecl->getType(),
4099 diag::err_abstract_type_in_decl,
4100 AbstractVariableType))
4101 VDecl->setInvalidDecl();
4104 if ((Def = VDecl->getDefinition()) && Def != VDecl) {
4105 Diag(VDecl->getLocation(), diag::err_redefinition)
4106 << VDecl->getDeclName();
4107 Diag(Def->getLocation(), diag::note_previous_definition);
4108 VDecl->setInvalidDecl();
4112 // If either the declaration has a dependent type or if any of the
4113 // expressions is type-dependent, we represent the initialization
4114 // via a ParenListExpr for later use during template instantiation.
4115 if (VDecl->getType()->isDependentType() ||
4116 Expr::hasAnyTypeDependentArguments((Expr **)Exprs.get(), Exprs.size())) {
4117 // Let clients know that initialization was done with a direct initializer.
4118 VDecl->setCXXDirectInitializer(true);
4120 // Store the initialization expressions as a ParenListExpr.
4121 unsigned NumExprs = Exprs.size();
4122 VDecl->setInit(new (Context) ParenListExpr(Context, LParenLoc,
4123 (Expr **)Exprs.release(),
4124 NumExprs, RParenLoc));
4128 // Capture the variable that is being initialized and the style of
4130 InitializedEntity Entity = InitializedEntity::InitializeVariable(VDecl);
4132 // FIXME: Poor source location information.
4133 InitializationKind Kind
4134 = InitializationKind::CreateDirect(VDecl->getLocation(),
4135 LParenLoc, RParenLoc);
4137 InitializationSequence InitSeq(*this, Entity, Kind,
4138 (Expr**)Exprs.get(), Exprs.size());
4139 OwningExprResult Result = InitSeq.Perform(*this, Entity, Kind, move(Exprs));
4140 if (Result.isInvalid()) {
4141 VDecl->setInvalidDecl();
4145 Result = MaybeCreateCXXExprWithTemporaries(move(Result));
4146 VDecl->setInit(Result.takeAs<Expr>());
4147 VDecl->setCXXDirectInitializer(true);
4149 if (const RecordType *Record = VDecl->getType()->getAs<RecordType>())
4150 FinalizeVarWithDestructor(VDecl, Record);
4153 /// \brief Add the applicable constructor candidates for an initialization
4155 static void AddConstructorInitializationCandidates(Sema &SemaRef,
4159 InitializationKind Kind,
4160 OverloadCandidateSet &CandidateSet) {
4161 // C++ [dcl.init]p14:
4162 // If the initialization is direct-initialization, or if it is
4163 // copy-initialization where the cv-unqualified version of the
4164 // source type is the same class as, or a derived class of, the
4165 // class of the destination, constructors are considered. The
4166 // applicable constructors are enumerated (13.3.1.3), and the
4167 // best one is chosen through overload resolution (13.3). The
4168 // constructor so selected is called to initialize the object,
4169 // with the initializer expression(s) as its argument(s). If no
4170 // constructor applies, or the overload resolution is ambiguous,
4171 // the initialization is ill-formed.
4172 const RecordType *ClassRec = ClassType->getAs<RecordType>();
4173 assert(ClassRec && "Can only initialize a class type here");
4175 // FIXME: When we decide not to synthesize the implicitly-declared
4176 // constructors, we'll need to make them appear here.
4178 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(ClassRec->getDecl());
4179 DeclarationName ConstructorName
4180 = SemaRef.Context.DeclarationNames.getCXXConstructorName(
4181 SemaRef.Context.getCanonicalType(ClassType).getUnqualifiedType());
4182 DeclContext::lookup_const_iterator Con, ConEnd;
4183 for (llvm::tie(Con, ConEnd) = ClassDecl->lookup(ConstructorName);
4184 Con != ConEnd; ++Con) {
4185 DeclAccessPair FoundDecl = DeclAccessPair::make(*Con, (*Con)->getAccess());
4187 // Find the constructor (which may be a template).
4188 CXXConstructorDecl *Constructor = 0;
4189 FunctionTemplateDecl *ConstructorTmpl= dyn_cast<FunctionTemplateDecl>(*Con);
4190 if (ConstructorTmpl)
4192 = cast<CXXConstructorDecl>(ConstructorTmpl->getTemplatedDecl());
4194 Constructor = cast<CXXConstructorDecl>(*Con);
4196 if ((Kind.getKind() == InitializationKind::IK_Direct) ||
4197 (Kind.getKind() == InitializationKind::IK_Value) ||
4198 (Kind.getKind() == InitializationKind::IK_Copy &&
4199 Constructor->isConvertingConstructor(/*AllowExplicit=*/false)) ||
4200 ((Kind.getKind() == InitializationKind::IK_Default) &&
4201 Constructor->isDefaultConstructor())) {
4202 if (ConstructorTmpl)
4203 SemaRef.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
4205 Args, NumArgs, CandidateSet);
4207 SemaRef.AddOverloadCandidate(Constructor, FoundDecl,
4208 Args, NumArgs, CandidateSet);
4213 /// \brief Attempt to perform initialization by constructor
4214 /// (C++ [dcl.init]p14), which may occur as part of direct-initialization or
4215 /// copy-initialization.
4217 /// This routine determines whether initialization by constructor is possible,
4218 /// but it does not emit any diagnostics in the case where the initialization
4221 /// \param ClassType the type of the object being initialized, which must have
4224 /// \param Args the arguments provided to initialize the object
4226 /// \param NumArgs the number of arguments provided to initialize the object
4228 /// \param Kind the type of initialization being performed
4230 /// \returns the constructor used to initialize the object, if successful.
4231 /// Otherwise, emits a diagnostic and returns NULL.
4232 CXXConstructorDecl *
4233 Sema::TryInitializationByConstructor(QualType ClassType,
4234 Expr **Args, unsigned NumArgs,
4236 InitializationKind Kind) {
4237 // Build the overload candidate set
4238 OverloadCandidateSet CandidateSet(Loc);
4239 AddConstructorInitializationCandidates(*this, ClassType, Args, NumArgs, Kind,
4242 // Determine whether we found a constructor we can use.
4243 OverloadCandidateSet::iterator Best;
4244 switch (BestViableFunction(CandidateSet, Loc, Best)) {
4247 // We found a constructor. Return it.
4248 return cast<CXXConstructorDecl>(Best->Function);
4250 case OR_No_Viable_Function:
4252 // Overload resolution failed. Return nothing.
4256 // Silence GCC warning
4260 /// \brief Given a constructor and the set of arguments provided for the
4261 /// constructor, convert the arguments and add any required default arguments
4262 /// to form a proper call to this constructor.
4264 /// \returns true if an error occurred, false otherwise.
4266 Sema::CompleteConstructorCall(CXXConstructorDecl *Constructor,
4267 MultiExprArg ArgsPtr,
4269 ASTOwningVector<&ActionBase::DeleteExpr> &ConvertedArgs) {
4270 // FIXME: This duplicates a lot of code from Sema::ConvertArgumentsForCall.
4271 unsigned NumArgs = ArgsPtr.size();
4272 Expr **Args = (Expr **)ArgsPtr.get();
4274 const FunctionProtoType *Proto
4275 = Constructor->getType()->getAs<FunctionProtoType>();
4276 assert(Proto && "Constructor without a prototype?");
4277 unsigned NumArgsInProto = Proto->getNumArgs();
4279 // If too few arguments are available, we'll fill in the rest with defaults.
4280 if (NumArgs < NumArgsInProto)
4281 ConvertedArgs.reserve(NumArgsInProto);
4283 ConvertedArgs.reserve(NumArgs);
4285 VariadicCallType CallType =
4286 Proto->isVariadic() ? VariadicConstructor : VariadicDoesNotApply;
4287 llvm::SmallVector<Expr *, 8> AllArgs;
4288 bool Invalid = GatherArgumentsForCall(Loc, Constructor,
4289 Proto, 0, Args, NumArgs, AllArgs,
4291 for (unsigned i =0, size = AllArgs.size(); i < size; i++)
4292 ConvertedArgs.push_back(AllArgs[i]);
4296 /// CompareReferenceRelationship - Compare the two types T1 and T2 to
4297 /// determine whether they are reference-related,
4298 /// reference-compatible, reference-compatible with added
4299 /// qualification, or incompatible, for use in C++ initialization by
4300 /// reference (C++ [dcl.ref.init]p4). Neither type can be a reference
4301 /// type, and the first type (T1) is the pointee type of the reference
4302 /// type being initialized.
4303 Sema::ReferenceCompareResult
4304 Sema::CompareReferenceRelationship(SourceLocation Loc,
4305 QualType OrigT1, QualType OrigT2,
4306 bool& DerivedToBase) {
4307 assert(!OrigT1->isReferenceType() &&
4308 "T1 must be the pointee type of the reference type");
4309 assert(!OrigT2->isReferenceType() && "T2 cannot be a reference type");
4311 QualType T1 = Context.getCanonicalType(OrigT1);
4312 QualType T2 = Context.getCanonicalType(OrigT2);
4313 Qualifiers T1Quals, T2Quals;
4314 QualType UnqualT1 = Context.getUnqualifiedArrayType(T1, T1Quals);
4315 QualType UnqualT2 = Context.getUnqualifiedArrayType(T2, T2Quals);
4317 // C++ [dcl.init.ref]p4:
4318 // Given types "cv1 T1" and "cv2 T2," "cv1 T1" is
4319 // reference-related to "cv2 T2" if T1 is the same type as T2, or
4320 // T1 is a base class of T2.
4321 if (UnqualT1 == UnqualT2)
4322 DerivedToBase = false;
4323 else if (!RequireCompleteType(Loc, OrigT1, PDiag()) &&
4324 !RequireCompleteType(Loc, OrigT2, PDiag()) &&
4325 IsDerivedFrom(UnqualT2, UnqualT1))
4326 DerivedToBase = true;
4328 return Ref_Incompatible;
4330 // At this point, we know that T1 and T2 are reference-related (at
4333 // If the type is an array type, promote the element qualifiers to the type
4335 if (isa<ArrayType>(T1) && T1Quals)
4336 T1 = Context.getQualifiedType(UnqualT1, T1Quals);
4337 if (isa<ArrayType>(T2) && T2Quals)
4338 T2 = Context.getQualifiedType(UnqualT2, T2Quals);
4340 // C++ [dcl.init.ref]p4:
4341 // "cv1 T1" is reference-compatible with "cv2 T2" if T1 is
4342 // reference-related to T2 and cv1 is the same cv-qualification
4343 // as, or greater cv-qualification than, cv2. For purposes of
4344 // overload resolution, cases for which cv1 is greater
4345 // cv-qualification than cv2 are identified as
4346 // reference-compatible with added qualification (see 13.3.3.2).
4347 if (T1Quals.getCVRQualifiers() == T2Quals.getCVRQualifiers())
4348 return Ref_Compatible;
4349 else if (T1.isMoreQualifiedThan(T2))
4350 return Ref_Compatible_With_Added_Qualification;
4355 /// CheckReferenceInit - Check the initialization of a reference
4356 /// variable with the given initializer (C++ [dcl.init.ref]). Init is
4357 /// the initializer (either a simple initializer or an initializer
4358 /// list), and DeclType is the type of the declaration. When ICS is
4359 /// non-null, this routine will compute the implicit conversion
4360 /// sequence according to C++ [over.ics.ref] and will not produce any
4361 /// diagnostics; when ICS is null, it will emit diagnostics when any
4362 /// errors are found. Either way, a return value of true indicates
4363 /// that there was a failure, a return value of false indicates that
4364 /// the reference initialization succeeded.
4366 /// When @p SuppressUserConversions, user-defined conversions are
4368 /// When @p AllowExplicit, we also permit explicit user-defined
4369 /// conversion functions.
4370 /// When @p ForceRValue, we unconditionally treat the initializer as an rvalue.
4371 /// When @p IgnoreBaseAccess, we don't do access control on to-base conversion.
4372 /// This is used when this is called from a C-style cast.
4374 Sema::CheckReferenceInit(Expr *&Init, QualType DeclType,
4375 SourceLocation DeclLoc,
4376 bool SuppressUserConversions,
4377 bool AllowExplicit, bool ForceRValue,
4378 ImplicitConversionSequence *ICS,
4379 bool IgnoreBaseAccess) {
4380 assert(DeclType->isReferenceType() && "Reference init needs a reference");
4382 QualType T1 = DeclType->getAs<ReferenceType>()->getPointeeType();
4383 QualType T2 = Init->getType();
4385 // If the initializer is the address of an overloaded function, try
4386 // to resolve the overloaded function. If all goes well, T2 is the
4387 // type of the resulting function.
4388 if (Context.getCanonicalType(T2) == Context.OverloadTy) {
4389 DeclAccessPair Found;
4390 FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Init, DeclType,
4393 // Since we're performing this reference-initialization for
4394 // real, update the initializer with the resulting function.
4396 if (DiagnoseUseOfDecl(Fn, DeclLoc))
4399 CheckAddressOfMemberAccess(Init, Found);
4400 Init = FixOverloadedFunctionReference(Init, Found, Fn);
4407 // Compute some basic properties of the types and the initializer.
4408 bool isRValRef = DeclType->isRValueReferenceType();
4409 bool DerivedToBase = false;
4410 Expr::isLvalueResult InitLvalue = ForceRValue ? Expr::LV_InvalidExpression :
4411 Init->isLvalue(Context);
4412 ReferenceCompareResult RefRelationship
4413 = CompareReferenceRelationship(DeclLoc, T1, T2, DerivedToBase);
4415 // Most paths end in a failed conversion.
4417 ICS->setBad(BadConversionSequence::no_conversion, Init, DeclType);
4420 // C++ [dcl.init.ref]p5:
4421 // A reference to type "cv1 T1" is initialized by an expression
4422 // of type "cv2 T2" as follows:
4424 // -- If the initializer expression
4426 // Rvalue references cannot bind to lvalues (N2812).
4427 // There is absolutely no situation where they can. In particular, note that
4428 // this is ill-formed, even if B has a user-defined conversion to A&&:
4431 if (isRValRef && InitLvalue == Expr::LV_Valid) {
4433 Diag(DeclLoc, diag::err_lvalue_to_rvalue_ref)
4434 << Init->getSourceRange();
4438 bool BindsDirectly = false;
4439 // -- is an lvalue (but is not a bit-field), and "cv1 T1" is
4440 // reference-compatible with "cv2 T2," or
4442 // Note that the bit-field check is skipped if we are just computing
4443 // the implicit conversion sequence (C++ [over.best.ics]p2).
4444 if (InitLvalue == Expr::LV_Valid && (ICS || !Init->getBitField()) &&
4445 RefRelationship >= Ref_Compatible_With_Added_Qualification) {
4446 BindsDirectly = true;
4449 // C++ [over.ics.ref]p1:
4450 // When a parameter of reference type binds directly (8.5.3)
4451 // to an argument expression, the implicit conversion sequence
4452 // is the identity conversion, unless the argument expression
4453 // has a type that is a derived class of the parameter type,
4454 // in which case the implicit conversion sequence is a
4455 // derived-to-base Conversion (13.3.3.1).
4457 ICS->Standard.First = ICK_Identity;
4458 ICS->Standard.Second = DerivedToBase? ICK_Derived_To_Base : ICK_Identity;
4459 ICS->Standard.Third = ICK_Identity;
4460 ICS->Standard.FromTypePtr = T2.getAsOpaquePtr();
4461 ICS->Standard.setToType(0, T2);
4462 ICS->Standard.setToType(1, T1);
4463 ICS->Standard.setToType(2, T1);
4464 ICS->Standard.ReferenceBinding = true;
4465 ICS->Standard.DirectBinding = true;
4466 ICS->Standard.RRefBinding = false;
4467 ICS->Standard.CopyConstructor = 0;
4469 // Nothing more to do: the inaccessibility/ambiguity check for
4470 // derived-to-base conversions is suppressed when we're
4471 // computing the implicit conversion sequence (C++
4472 // [over.best.ics]p2).
4475 // Perform the conversion.
4476 CastExpr::CastKind CK = CastExpr::CK_NoOp;
4478 CK = CastExpr::CK_DerivedToBase;
4479 else if(CheckExceptionSpecCompatibility(Init, T1))
4481 ImpCastExprToType(Init, T1, CK, /*isLvalue=*/true);
4485 // -- has a class type (i.e., T2 is a class type) and can be
4486 // implicitly converted to an lvalue of type "cv3 T3,"
4487 // where "cv1 T1" is reference-compatible with "cv3 T3"
4488 // 92) (this conversion is selected by enumerating the
4489 // applicable conversion functions (13.3.1.6) and choosing
4490 // the best one through overload resolution (13.3)),
4491 if (!isRValRef && !SuppressUserConversions && T2->isRecordType() &&
4492 !RequireCompleteType(DeclLoc, T2, 0)) {
4493 CXXRecordDecl *T2RecordDecl
4494 = dyn_cast<CXXRecordDecl>(T2->getAs<RecordType>()->getDecl());
4496 OverloadCandidateSet CandidateSet(DeclLoc);
4497 const UnresolvedSetImpl *Conversions
4498 = T2RecordDecl->getVisibleConversionFunctions();
4499 for (UnresolvedSetImpl::iterator I = Conversions->begin(),
4500 E = Conversions->end(); I != E; ++I) {
4502 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
4503 if (isa<UsingShadowDecl>(D))
4504 D = cast<UsingShadowDecl>(D)->getTargetDecl();
4506 FunctionTemplateDecl *ConvTemplate
4507 = dyn_cast<FunctionTemplateDecl>(D);
4508 CXXConversionDecl *Conv;
4510 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
4512 Conv = cast<CXXConversionDecl>(D);
4514 // If the conversion function doesn't return a reference type,
4515 // it can't be considered for this conversion.
4516 if (Conv->getConversionType()->isLValueReferenceType() &&
4517 (AllowExplicit || !Conv->isExplicit())) {
4519 AddTemplateConversionCandidate(ConvTemplate, I.getPair(), ActingDC,
4520 Init, DeclType, CandidateSet);
4522 AddConversionCandidate(Conv, I.getPair(), ActingDC, Init,
4523 DeclType, CandidateSet);
4527 OverloadCandidateSet::iterator Best;
4528 switch (BestViableFunction(CandidateSet, DeclLoc, Best)) {
4530 // C++ [over.ics.ref]p1:
4532 // [...] If the parameter binds directly to the result of
4533 // applying a conversion function to the argument
4534 // expression, the implicit conversion sequence is a
4535 // user-defined conversion sequence (13.3.3.1.2), with the
4536 // second standard conversion sequence either an identity
4537 // conversion or, if the conversion function returns an
4538 // entity of a type that is a derived class of the parameter
4539 // type, a derived-to-base Conversion.
4540 if (!Best->FinalConversion.DirectBinding)
4543 // This is a direct binding.
4544 BindsDirectly = true;
4547 ICS->setUserDefined();
4548 ICS->UserDefined.Before = Best->Conversions[0].Standard;
4549 ICS->UserDefined.After = Best->FinalConversion;
4550 ICS->UserDefined.ConversionFunction = Best->Function;
4551 ICS->UserDefined.EllipsisConversion = false;
4552 assert(ICS->UserDefined.After.ReferenceBinding &&
4553 ICS->UserDefined.After.DirectBinding &&
4554 "Expected a direct reference binding!");
4557 OwningExprResult InitConversion =
4558 BuildCXXCastArgument(DeclLoc, QualType(),
4559 CastExpr::CK_UserDefinedConversion,
4560 cast<CXXMethodDecl>(Best->Function),
4562 Init = InitConversion.takeAs<Expr>();
4564 if (CheckExceptionSpecCompatibility(Init, T1))
4566 ImpCastExprToType(Init, T1, CastExpr::CK_UserDefinedConversion,
4573 ICS->setAmbiguous();
4574 for (OverloadCandidateSet::iterator Cand = CandidateSet.begin();
4575 Cand != CandidateSet.end(); ++Cand)
4577 ICS->Ambiguous.addConversion(Cand->Function);
4580 Diag(DeclLoc, diag::err_ref_init_ambiguous) << DeclType << Init->getType()
4581 << Init->getSourceRange();
4582 PrintOverloadCandidates(CandidateSet, OCD_ViableCandidates, &Init, 1);
4585 case OR_No_Viable_Function:
4587 // There was no suitable conversion, or we found a deleted
4588 // conversion; continue with other checks.
4593 if (BindsDirectly) {
4594 // C++ [dcl.init.ref]p4:
4595 // [...] In all cases where the reference-related or
4596 // reference-compatible relationship of two types is used to
4597 // establish the validity of a reference binding, and T1 is a
4598 // base class of T2, a program that necessitates such a binding
4599 // is ill-formed if T1 is an inaccessible (clause 11) or
4600 // ambiguous (10.2) base class of T2.
4602 // Note that we only check this condition when we're allowed to
4603 // complain about errors, because we should not be checking for
4604 // ambiguity (or inaccessibility) unless the reference binding
4605 // actually happens.
4607 return CheckDerivedToBaseConversion(T2, T1, DeclLoc,
4608 Init->getSourceRange(),
4614 // -- Otherwise, the reference shall be to a non-volatile const
4615 // type (i.e., cv1 shall be const), or the reference shall be an
4616 // rvalue reference and the initializer expression shall be an rvalue.
4617 if (!isRValRef && T1.getCVRQualifiers() != Qualifiers::Const) {
4619 Diag(DeclLoc, diag::err_not_reference_to_const_init)
4620 << T1.isVolatileQualified()
4621 << T1 << int(InitLvalue != Expr::LV_Valid)
4622 << T2 << Init->getSourceRange();
4626 // -- If the initializer expression is an rvalue, with T2 a
4627 // class type, and "cv1 T1" is reference-compatible with
4628 // "cv2 T2," the reference is bound in one of the
4629 // following ways (the choice is implementation-defined):
4631 // -- The reference is bound to the object represented by
4632 // the rvalue (see 3.10) or to a sub-object within that
4635 // -- A temporary of type "cv1 T2" [sic] is created, and
4636 // a constructor is called to copy the entire rvalue
4637 // object into the temporary. The reference is bound to
4638 // the temporary or to a sub-object within the
4641 // The constructor that would be used to make the copy
4642 // shall be callable whether or not the copy is actually
4645 // Note that C++0x [dcl.init.ref]p5 takes away this implementation
4646 // freedom, so we will always take the first option and never build
4647 // a temporary in this case. FIXME: We will, however, have to check
4648 // for the presence of a copy constructor in C++98/03 mode.
4649 if (InitLvalue != Expr::LV_Valid && T2->isRecordType() &&
4650 RefRelationship >= Ref_Compatible_With_Added_Qualification) {
4653 ICS->Standard.First = ICK_Identity;
4654 ICS->Standard.Second = DerivedToBase? ICK_Derived_To_Base : ICK_Identity;
4655 ICS->Standard.Third = ICK_Identity;
4656 ICS->Standard.FromTypePtr = T2.getAsOpaquePtr();
4657 ICS->Standard.setToType(0, T2);
4658 ICS->Standard.setToType(1, T1);
4659 ICS->Standard.setToType(2, T1);
4660 ICS->Standard.ReferenceBinding = true;
4661 ICS->Standard.DirectBinding = false;
4662 ICS->Standard.RRefBinding = isRValRef;
4663 ICS->Standard.CopyConstructor = 0;
4665 CastExpr::CastKind CK = CastExpr::CK_NoOp;
4667 CK = CastExpr::CK_DerivedToBase;
4668 else if(CheckExceptionSpecCompatibility(Init, T1))
4670 ImpCastExprToType(Init, T1, CK, /*isLvalue=*/false);
4675 // -- Otherwise, a temporary of type "cv1 T1" is created and
4676 // initialized from the initializer expression using the
4677 // rules for a non-reference copy initialization (8.5). The
4678 // reference is then bound to the temporary. If T1 is
4679 // reference-related to T2, cv1 must be the same
4680 // cv-qualification as, or greater cv-qualification than,
4681 // cv2; otherwise, the program is ill-formed.
4682 if (RefRelationship == Ref_Related) {
4683 // If cv1 == cv2 or cv1 is a greater cv-qualified than cv2, then
4684 // we would be reference-compatible or reference-compatible with
4685 // added qualification. But that wasn't the case, so the reference
4686 // initialization fails.
4688 Diag(DeclLoc, diag::err_reference_init_drops_quals)
4689 << T1 << int(InitLvalue != Expr::LV_Valid)
4690 << T2 << Init->getSourceRange();
4694 // If at least one of the types is a class type, the types are not
4695 // related, and we aren't allowed any user conversions, the
4696 // reference binding fails. This case is important for breaking
4697 // recursion, since TryImplicitConversion below will attempt to
4698 // create a temporary through the use of a copy constructor.
4699 if (SuppressUserConversions && RefRelationship == Ref_Incompatible &&
4700 (T1->isRecordType() || T2->isRecordType())) {
4702 Diag(DeclLoc, diag::err_typecheck_convert_incompatible)
4703 << DeclType << Init->getType() << AA_Initializing << Init->getSourceRange();
4707 // Actually try to convert the initializer to T1.
4709 // C++ [over.ics.ref]p2:
4711 // When a parameter of reference type is not bound directly to
4712 // an argument expression, the conversion sequence is the one
4713 // required to convert the argument expression to the
4714 // underlying type of the reference according to
4715 // 13.3.3.1. Conceptually, this conversion sequence corresponds
4716 // to copy-initializing a temporary of the underlying type with
4717 // the argument expression. Any difference in top-level
4718 // cv-qualification is subsumed by the initialization itself
4719 // and does not constitute a conversion.
4720 *ICS = TryImplicitConversion(Init, T1, SuppressUserConversions,
4721 /*AllowExplicit=*/false,
4722 /*ForceRValue=*/false,
4723 /*InOverloadResolution=*/false);
4725 // Of course, that's still a reference binding.
4726 if (ICS->isStandard()) {
4727 ICS->Standard.ReferenceBinding = true;
4728 ICS->Standard.RRefBinding = isRValRef;
4729 } else if (ICS->isUserDefined()) {
4730 ICS->UserDefined.After.ReferenceBinding = true;
4731 ICS->UserDefined.After.RRefBinding = isRValRef;
4733 return ICS->isBad();
4735 ImplicitConversionSequence Conversions;
4736 bool badConversion = PerformImplicitConversion(Init, T1, AA_Initializing,
4739 if (badConversion) {
4740 if (Conversions.isAmbiguous()) {
4742 diag::err_lvalue_to_rvalue_ambig_ref) << Init->getSourceRange();
4743 for (int j = Conversions.Ambiguous.conversions().size()-1;
4745 FunctionDecl *Func = Conversions.Ambiguous.conversions()[j];
4746 NoteOverloadCandidate(Func);
4751 Diag(DeclLoc, diag::err_lvalue_to_rvalue_ref)
4752 << Init->getSourceRange();
4754 Diag(DeclLoc, diag::err_invalid_initialization)
4755 << DeclType << Init->getType() << Init->getSourceRange();
4758 return badConversion;
4763 CheckOperatorNewDeleteDeclarationScope(Sema &SemaRef,
4764 const FunctionDecl *FnDecl) {
4765 const DeclContext *DC = FnDecl->getDeclContext()->getLookupContext();
4766 if (isa<NamespaceDecl>(DC)) {
4767 return SemaRef.Diag(FnDecl->getLocation(),
4768 diag::err_operator_new_delete_declared_in_namespace)
4769 << FnDecl->getDeclName();
4772 if (isa<TranslationUnitDecl>(DC) &&
4773 FnDecl->getStorageClass() == FunctionDecl::Static) {
4774 return SemaRef.Diag(FnDecl->getLocation(),
4775 diag::err_operator_new_delete_declared_static)
4776 << FnDecl->getDeclName();
4783 CheckOperatorNewDeleteTypes(Sema &SemaRef, const FunctionDecl *FnDecl,
4784 CanQualType ExpectedResultType,
4785 CanQualType ExpectedFirstParamType,
4786 unsigned DependentParamTypeDiag,
4787 unsigned InvalidParamTypeDiag) {
4788 QualType ResultType =
4789 FnDecl->getType()->getAs<FunctionType>()->getResultType();
4791 // Check that the result type is not dependent.
4792 if (ResultType->isDependentType())
4793 return SemaRef.Diag(FnDecl->getLocation(),
4794 diag::err_operator_new_delete_dependent_result_type)
4795 << FnDecl->getDeclName() << ExpectedResultType;
4797 // Check that the result type is what we expect.
4798 if (SemaRef.Context.getCanonicalType(ResultType) != ExpectedResultType)
4799 return SemaRef.Diag(FnDecl->getLocation(),
4800 diag::err_operator_new_delete_invalid_result_type)
4801 << FnDecl->getDeclName() << ExpectedResultType;
4803 // A function template must have at least 2 parameters.
4804 if (FnDecl->getDescribedFunctionTemplate() && FnDecl->getNumParams() < 2)
4805 return SemaRef.Diag(FnDecl->getLocation(),
4806 diag::err_operator_new_delete_template_too_few_parameters)
4807 << FnDecl->getDeclName();
4809 // The function decl must have at least 1 parameter.
4810 if (FnDecl->getNumParams() == 0)
4811 return SemaRef.Diag(FnDecl->getLocation(),
4812 diag::err_operator_new_delete_too_few_parameters)
4813 << FnDecl->getDeclName();
4815 // Check the the first parameter type is not dependent.
4816 QualType FirstParamType = FnDecl->getParamDecl(0)->getType();
4817 if (FirstParamType->isDependentType())
4818 return SemaRef.Diag(FnDecl->getLocation(), DependentParamTypeDiag)
4819 << FnDecl->getDeclName() << ExpectedFirstParamType;
4821 // Check that the first parameter type is what we expect.
4822 if (SemaRef.Context.getCanonicalType(FirstParamType).getUnqualifiedType() !=
4823 ExpectedFirstParamType)
4824 return SemaRef.Diag(FnDecl->getLocation(), InvalidParamTypeDiag)
4825 << FnDecl->getDeclName() << ExpectedFirstParamType;
4831 CheckOperatorNewDeclaration(Sema &SemaRef, const FunctionDecl *FnDecl) {
4832 // C++ [basic.stc.dynamic.allocation]p1:
4833 // A program is ill-formed if an allocation function is declared in a
4834 // namespace scope other than global scope or declared static in global
4836 if (CheckOperatorNewDeleteDeclarationScope(SemaRef, FnDecl))
4839 CanQualType SizeTy =
4840 SemaRef.Context.getCanonicalType(SemaRef.Context.getSizeType());
4842 // C++ [basic.stc.dynamic.allocation]p1:
4843 // The return type shall be void*. The first parameter shall have type
4845 if (CheckOperatorNewDeleteTypes(SemaRef, FnDecl, SemaRef.Context.VoidPtrTy,
4847 diag::err_operator_new_dependent_param_type,
4848 diag::err_operator_new_param_type))
4851 // C++ [basic.stc.dynamic.allocation]p1:
4852 // The first parameter shall not have an associated default argument.
4853 if (FnDecl->getParamDecl(0)->hasDefaultArg())
4854 return SemaRef.Diag(FnDecl->getLocation(),
4855 diag::err_operator_new_default_arg)
4856 << FnDecl->getDeclName() << FnDecl->getParamDecl(0)->getDefaultArgRange();
4862 CheckOperatorDeleteDeclaration(Sema &SemaRef, const FunctionDecl *FnDecl) {
4863 // C++ [basic.stc.dynamic.deallocation]p1:
4864 // A program is ill-formed if deallocation functions are declared in a
4865 // namespace scope other than global scope or declared static in global
4867 if (CheckOperatorNewDeleteDeclarationScope(SemaRef, FnDecl))
4870 // C++ [basic.stc.dynamic.deallocation]p2:
4871 // Each deallocation function shall return void and its first parameter
4873 if (CheckOperatorNewDeleteTypes(SemaRef, FnDecl, SemaRef.Context.VoidTy,
4874 SemaRef.Context.VoidPtrTy,
4875 diag::err_operator_delete_dependent_param_type,
4876 diag::err_operator_delete_param_type))
4879 QualType FirstParamType = FnDecl->getParamDecl(0)->getType();
4880 if (FirstParamType->isDependentType())
4881 return SemaRef.Diag(FnDecl->getLocation(),
4882 diag::err_operator_delete_dependent_param_type)
4883 << FnDecl->getDeclName() << SemaRef.Context.VoidPtrTy;
4885 if (SemaRef.Context.getCanonicalType(FirstParamType) !=
4886 SemaRef.Context.VoidPtrTy)
4887 return SemaRef.Diag(FnDecl->getLocation(),
4888 diag::err_operator_delete_param_type)
4889 << FnDecl->getDeclName() << SemaRef.Context.VoidPtrTy;
4894 /// CheckOverloadedOperatorDeclaration - Check whether the declaration
4895 /// of this overloaded operator is well-formed. If so, returns false;
4896 /// otherwise, emits appropriate diagnostics and returns true.
4897 bool Sema::CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl) {
4898 assert(FnDecl && FnDecl->isOverloadedOperator() &&
4899 "Expected an overloaded operator declaration");
4901 OverloadedOperatorKind Op = FnDecl->getOverloadedOperator();
4903 // C++ [over.oper]p5:
4904 // The allocation and deallocation functions, operator new,
4905 // operator new[], operator delete and operator delete[], are
4906 // described completely in 3.7.3. The attributes and restrictions
4907 // found in the rest of this subclause do not apply to them unless
4908 // explicitly stated in 3.7.3.
4909 if (Op == OO_Delete || Op == OO_Array_Delete)
4910 return CheckOperatorDeleteDeclaration(*this, FnDecl);
4912 if (Op == OO_New || Op == OO_Array_New)
4913 return CheckOperatorNewDeclaration(*this, FnDecl);
4915 // C++ [over.oper]p6:
4916 // An operator function shall either be a non-static member
4917 // function or be a non-member function and have at least one
4918 // parameter whose type is a class, a reference to a class, an
4919 // enumeration, or a reference to an enumeration.
4920 if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) {
4921 if (MethodDecl->isStatic())
4922 return Diag(FnDecl->getLocation(),
4923 diag::err_operator_overload_static) << FnDecl->getDeclName();
4925 bool ClassOrEnumParam = false;
4926 for (FunctionDecl::param_iterator Param = FnDecl->param_begin(),
4927 ParamEnd = FnDecl->param_end();
4928 Param != ParamEnd; ++Param) {
4929 QualType ParamType = (*Param)->getType().getNonReferenceType();
4930 if (ParamType->isDependentType() || ParamType->isRecordType() ||
4931 ParamType->isEnumeralType()) {
4932 ClassOrEnumParam = true;
4937 if (!ClassOrEnumParam)
4938 return Diag(FnDecl->getLocation(),
4939 diag::err_operator_overload_needs_class_or_enum)
4940 << FnDecl->getDeclName();
4943 // C++ [over.oper]p8:
4944 // An operator function cannot have default arguments (8.3.6),
4945 // except where explicitly stated below.
4947 // Only the function-call operator allows default arguments
4948 // (C++ [over.call]p1).
4949 if (Op != OO_Call) {
4950 for (FunctionDecl::param_iterator Param = FnDecl->param_begin();
4951 Param != FnDecl->param_end(); ++Param) {
4952 if ((*Param)->hasDefaultArg())
4953 return Diag((*Param)->getLocation(),
4954 diag::err_operator_overload_default_arg)
4955 << FnDecl->getDeclName() << (*Param)->getDefaultArgRange();
4959 static const bool OperatorUses[NUM_OVERLOADED_OPERATORS][3] = {
4960 { false, false, false }
4961 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
4962 , { Unary, Binary, MemberOnly }
4963 #include "clang/Basic/OperatorKinds.def"
4966 bool CanBeUnaryOperator = OperatorUses[Op][0];
4967 bool CanBeBinaryOperator = OperatorUses[Op][1];
4968 bool MustBeMemberOperator = OperatorUses[Op][2];
4970 // C++ [over.oper]p8:
4971 // [...] Operator functions cannot have more or fewer parameters
4972 // than the number required for the corresponding operator, as
4973 // described in the rest of this subclause.
4974 unsigned NumParams = FnDecl->getNumParams()
4975 + (isa<CXXMethodDecl>(FnDecl)? 1 : 0);
4976 if (Op != OO_Call &&
4977 ((NumParams == 1 && !CanBeUnaryOperator) ||
4978 (NumParams == 2 && !CanBeBinaryOperator) ||
4979 (NumParams < 1) || (NumParams > 2))) {
4980 // We have the wrong number of parameters.
4982 if (CanBeUnaryOperator && CanBeBinaryOperator) {
4983 ErrorKind = 2; // 2 -> unary or binary.
4984 } else if (CanBeUnaryOperator) {
4985 ErrorKind = 0; // 0 -> unary
4987 assert(CanBeBinaryOperator &&
4988 "All non-call overloaded operators are unary or binary!");
4989 ErrorKind = 1; // 1 -> binary
4992 return Diag(FnDecl->getLocation(), diag::err_operator_overload_must_be)
4993 << FnDecl->getDeclName() << NumParams << ErrorKind;
4996 // Overloaded operators other than operator() cannot be variadic.
4997 if (Op != OO_Call &&
4998 FnDecl->getType()->getAs<FunctionProtoType>()->isVariadic()) {
4999 return Diag(FnDecl->getLocation(), diag::err_operator_overload_variadic)
5000 << FnDecl->getDeclName();
5003 // Some operators must be non-static member functions.
5004 if (MustBeMemberOperator && !isa<CXXMethodDecl>(FnDecl)) {
5005 return Diag(FnDecl->getLocation(),
5006 diag::err_operator_overload_must_be_member)
5007 << FnDecl->getDeclName();
5010 // C++ [over.inc]p1:
5011 // The user-defined function called operator++ implements the
5012 // prefix and postfix ++ operator. If this function is a member
5013 // function with no parameters, or a non-member function with one
5014 // parameter of class or enumeration type, it defines the prefix
5015 // increment operator ++ for objects of that type. If the function
5016 // is a member function with one parameter (which shall be of type
5017 // int) or a non-member function with two parameters (the second
5018 // of which shall be of type int), it defines the postfix
5019 // increment operator ++ for objects of that type.
5020 if ((Op == OO_PlusPlus || Op == OO_MinusMinus) && NumParams == 2) {
5021 ParmVarDecl *LastParam = FnDecl->getParamDecl(FnDecl->getNumParams() - 1);
5022 bool ParamIsInt = false;
5023 if (const BuiltinType *BT = LastParam->getType()->getAs<BuiltinType>())
5024 ParamIsInt = BT->getKind() == BuiltinType::Int;
5027 return Diag(LastParam->getLocation(),
5028 diag::err_operator_overload_post_incdec_must_be_int)
5029 << LastParam->getType() << (Op == OO_MinusMinus);
5032 // Notify the class if it got an assignment operator.
5033 if (Op == OO_Equal) {
5034 // Would have returned earlier otherwise.
5035 assert(isa<CXXMethodDecl>(FnDecl) &&
5036 "Overloaded = not member, but not filtered.");
5037 CXXMethodDecl *Method = cast<CXXMethodDecl>(FnDecl);
5038 Method->getParent()->addedAssignmentOperator(Context, Method);
5044 /// CheckLiteralOperatorDeclaration - Check whether the declaration
5045 /// of this literal operator function is well-formed. If so, returns
5046 /// false; otherwise, emits appropriate diagnostics and returns true.
5047 bool Sema::CheckLiteralOperatorDeclaration(FunctionDecl *FnDecl) {
5048 DeclContext *DC = FnDecl->getDeclContext();
5049 Decl::Kind Kind = DC->getDeclKind();
5050 if (Kind != Decl::TranslationUnit && Kind != Decl::Namespace &&
5051 Kind != Decl::LinkageSpec) {
5052 Diag(FnDecl->getLocation(), diag::err_literal_operator_outside_namespace)
5053 << FnDecl->getDeclName();
5059 // FIXME: Check for the one valid template signature
5060 // template <char...> type operator "" name();
5062 if (FunctionDecl::param_iterator Param = FnDecl->param_begin()) {
5063 // Check the first parameter
5064 QualType T = (*Param)->getType();
5066 // unsigned long long int and long double are allowed, but only
5068 // We also allow any character type; their omission seems to be a bug
5070 if (Context.hasSameType(T, Context.UnsignedLongLongTy) ||
5071 Context.hasSameType(T, Context.LongDoubleTy) ||
5072 Context.hasSameType(T, Context.CharTy) ||
5073 Context.hasSameType(T, Context.WCharTy) ||
5074 Context.hasSameType(T, Context.Char16Ty) ||
5075 Context.hasSameType(T, Context.Char32Ty)) {
5076 if (++Param == FnDecl->param_end())
5078 goto FinishedParams;
5081 // Otherwise it must be a pointer to const; let's strip those.
5082 const PointerType *PT = T->getAs<PointerType>();
5084 goto FinishedParams;
5085 T = PT->getPointeeType();
5086 if (!T.isConstQualified())
5087 goto FinishedParams;
5088 T = T.getUnqualifiedType();
5090 // Move on to the second parameter;
5093 // If there is no second parameter, the first must be a const char *
5094 if (Param == FnDecl->param_end()) {
5095 if (Context.hasSameType(T, Context.CharTy))
5097 goto FinishedParams;
5100 // const char *, const wchar_t*, const char16_t*, and const char32_t*
5101 // are allowed as the first parameter to a two-parameter function
5102 if (!(Context.hasSameType(T, Context.CharTy) ||
5103 Context.hasSameType(T, Context.WCharTy) ||
5104 Context.hasSameType(T, Context.Char16Ty) ||
5105 Context.hasSameType(T, Context.Char32Ty)))
5106 goto FinishedParams;
5108 // The second and final parameter must be an std::size_t
5109 T = (*Param)->getType().getUnqualifiedType();
5110 if (Context.hasSameType(T, Context.getSizeType()) &&
5111 ++Param == FnDecl->param_end())
5115 // FIXME: This diagnostic is absolutely terrible.
5118 Diag(FnDecl->getLocation(), diag::err_literal_operator_params)
5119 << FnDecl->getDeclName();
5126 /// ActOnStartLinkageSpecification - Parsed the beginning of a C++
5127 /// linkage specification, including the language and (if present)
5128 /// the '{'. ExternLoc is the location of the 'extern', LangLoc is
5129 /// the location of the language string literal, which is provided
5130 /// by Lang/StrSize. LBraceLoc, if valid, provides the location of
5131 /// the '{' brace. Otherwise, this linkage specification does not
5132 /// have any braces.
5133 Sema::DeclPtrTy Sema::ActOnStartLinkageSpecification(Scope *S,
5134 SourceLocation ExternLoc,
5135 SourceLocation LangLoc,
5138 SourceLocation LBraceLoc) {
5139 LinkageSpecDecl::LanguageIDs Language;
5140 if (strncmp(Lang, "\"C\"", StrSize) == 0)
5141 Language = LinkageSpecDecl::lang_c;
5142 else if (strncmp(Lang, "\"C++\"", StrSize) == 0)
5143 Language = LinkageSpecDecl::lang_cxx;
5145 Diag(LangLoc, diag::err_bad_language);
5149 // FIXME: Add all the various semantics of linkage specifications
5151 LinkageSpecDecl *D = LinkageSpecDecl::Create(Context, CurContext,
5153 LBraceLoc.isValid());
5154 CurContext->addDecl(D);
5155 PushDeclContext(S, D);
5156 return DeclPtrTy::make(D);
5159 /// ActOnFinishLinkageSpecification - Completely the definition of
5160 /// the C++ linkage specification LinkageSpec. If RBraceLoc is
5161 /// valid, it's the position of the closing '}' brace in a linkage
5162 /// specification that uses braces.
5163 Sema::DeclPtrTy Sema::ActOnFinishLinkageSpecification(Scope *S,
5164 DeclPtrTy LinkageSpec,
5165 SourceLocation RBraceLoc) {
5171 /// \brief Perform semantic analysis for the variable declaration that
5172 /// occurs within a C++ catch clause, returning the newly-created
5174 VarDecl *Sema::BuildExceptionDeclaration(Scope *S, QualType ExDeclType,
5175 TypeSourceInfo *TInfo,
5176 IdentifierInfo *Name,
5178 SourceRange Range) {
5179 bool Invalid = false;
5181 // Arrays and functions decay.
5182 if (ExDeclType->isArrayType())
5183 ExDeclType = Context.getArrayDecayedType(ExDeclType);
5184 else if (ExDeclType->isFunctionType())
5185 ExDeclType = Context.getPointerType(ExDeclType);
5187 // C++ 15.3p1: The exception-declaration shall not denote an incomplete type.
5188 // The exception-declaration shall not denote a pointer or reference to an
5189 // incomplete type, other than [cv] void*.
5190 // N2844 forbids rvalue references.
5191 if (!ExDeclType->isDependentType() && ExDeclType->isRValueReferenceType()) {
5192 Diag(Loc, diag::err_catch_rvalue_ref) << Range;
5196 // GCC allows catching pointers and references to incomplete types
5197 // as an extension; so do we, but we warn by default.
5199 QualType BaseType = ExDeclType;
5200 int Mode = 0; // 0 for direct type, 1 for pointer, 2 for reference
5201 unsigned DK = diag::err_catch_incomplete;
5202 bool IncompleteCatchIsInvalid = true;
5203 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) {
5204 BaseType = Ptr->getPointeeType();
5206 DK = diag::ext_catch_incomplete_ptr;
5207 IncompleteCatchIsInvalid = false;
5208 } else if (const ReferenceType *Ref = BaseType->getAs<ReferenceType>()) {
5209 // For the purpose of error recovery, we treat rvalue refs like lvalue refs.
5210 BaseType = Ref->getPointeeType();
5212 DK = diag::ext_catch_incomplete_ref;
5213 IncompleteCatchIsInvalid = false;
5215 if (!Invalid && (Mode == 0 || !BaseType->isVoidType()) &&
5216 !BaseType->isDependentType() && RequireCompleteType(Loc, BaseType, DK) &&
5217 IncompleteCatchIsInvalid)
5220 if (!Invalid && !ExDeclType->isDependentType() &&
5221 RequireNonAbstractType(Loc, ExDeclType,
5222 diag::err_abstract_type_in_decl,
5223 AbstractVariableType))
5226 VarDecl *ExDecl = VarDecl::Create(Context, CurContext, Loc,
5227 Name, ExDeclType, TInfo, VarDecl::None);
5230 if (const RecordType *RecordTy = ExDeclType->getAs<RecordType>()) {
5231 // C++ [except.handle]p16:
5232 // The object declared in an exception-declaration or, if the
5233 // exception-declaration does not specify a name, a temporary (12.2) is
5234 // copy-initialized (8.5) from the exception object. [...]
5235 // The object is destroyed when the handler exits, after the destruction
5236 // of any automatic objects initialized within the handler.
5238 // We just pretend to initialize the object with itself, then make sure
5239 // it can be destroyed later.
5240 InitializedEntity Entity = InitializedEntity::InitializeVariable(ExDecl);
5241 Expr *ExDeclRef = DeclRefExpr::Create(Context, 0, SourceRange(), ExDecl,
5242 Loc, ExDeclType, 0);
5243 InitializationKind Kind = InitializationKind::CreateCopy(Loc,
5245 InitializationSequence InitSeq(*this, Entity, Kind, &ExDeclRef, 1);
5246 OwningExprResult Result = InitSeq.Perform(*this, Entity, Kind,
5247 MultiExprArg(*this, (void**)&ExDeclRef, 1));
5248 if (Result.isInvalid())
5251 FinalizeVarWithDestructor(ExDecl, RecordTy);
5256 ExDecl->setInvalidDecl();
5261 /// ActOnExceptionDeclarator - Parsed the exception-declarator in a C++ catch
5263 Sema::DeclPtrTy Sema::ActOnExceptionDeclarator(Scope *S, Declarator &D) {
5264 TypeSourceInfo *TInfo = 0;
5265 QualType ExDeclType = GetTypeForDeclarator(D, S, &TInfo);
5267 bool Invalid = D.isInvalidType();
5268 IdentifierInfo *II = D.getIdentifier();
5269 if (NamedDecl *PrevDecl = LookupSingleName(S, II, LookupOrdinaryName)) {
5270 // The scope should be freshly made just for us. There is just no way
5271 // it contains any previous declaration.
5272 assert(!S->isDeclScope(DeclPtrTy::make(PrevDecl)));
5273 if (PrevDecl->isTemplateParameter()) {
5274 // Maybe we will complain about the shadowed template parameter.
5275 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
5279 if (D.getCXXScopeSpec().isSet() && !Invalid) {
5280 Diag(D.getIdentifierLoc(), diag::err_qualified_catch_declarator)
5281 << D.getCXXScopeSpec().getRange();
5285 VarDecl *ExDecl = BuildExceptionDeclaration(S, ExDeclType, TInfo,
5287 D.getIdentifierLoc(),
5288 D.getDeclSpec().getSourceRange());
5291 ExDecl->setInvalidDecl();
5293 // Add the exception declaration into this scope.
5295 PushOnScopeChains(ExDecl, S);
5297 CurContext->addDecl(ExDecl);
5299 ProcessDeclAttributes(S, ExDecl, D);
5300 return DeclPtrTy::make(ExDecl);
5303 Sema::DeclPtrTy Sema::ActOnStaticAssertDeclaration(SourceLocation AssertLoc,
5305 ExprArg assertmessageexpr) {
5306 Expr *AssertExpr = (Expr *)assertexpr.get();
5307 StringLiteral *AssertMessage =
5308 cast<StringLiteral>((Expr *)assertmessageexpr.get());
5310 if (!AssertExpr->isTypeDependent() && !AssertExpr->isValueDependent()) {
5311 llvm::APSInt Value(32);
5312 if (!AssertExpr->isIntegerConstantExpr(Value, Context)) {
5313 Diag(AssertLoc, diag::err_static_assert_expression_is_not_constant) <<
5314 AssertExpr->getSourceRange();
5319 Diag(AssertLoc, diag::err_static_assert_failed)
5320 << AssertMessage->getString() << AssertExpr->getSourceRange();
5324 assertexpr.release();
5325 assertmessageexpr.release();
5326 Decl *Decl = StaticAssertDecl::Create(Context, CurContext, AssertLoc,
5327 AssertExpr, AssertMessage);
5329 CurContext->addDecl(Decl);
5330 return DeclPtrTy::make(Decl);
5333 /// Handle a friend type declaration. This works in tandem with
5336 /// Notes on friend class templates:
5338 /// We generally treat friend class declarations as if they were
5339 /// declaring a class. So, for example, the elaborated type specifier
5340 /// in a friend declaration is required to obey the restrictions of a
5341 /// class-head (i.e. no typedefs in the scope chain), template
5342 /// parameters are required to match up with simple template-ids, &c.
5343 /// However, unlike when declaring a template specialization, it's
5344 /// okay to refer to a template specialization without an empty
5345 /// template parameter declaration, e.g.
5346 /// friend class A<T>::B<unsigned>;
5347 /// We permit this as a special case; if there are any template
5348 /// parameters present at all, require proper matching, i.e.
5349 /// template <> template <class T> friend class A<int>::B;
5350 Sema::DeclPtrTy Sema::ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS,
5351 MultiTemplateParamsArg TempParams) {
5352 SourceLocation Loc = DS.getSourceRange().getBegin();
5354 assert(DS.isFriendSpecified());
5355 assert(DS.getStorageClassSpec() == DeclSpec::SCS_unspecified);
5357 // Try to convert the decl specifier to a type. This works for
5358 // friend templates because ActOnTag never produces a ClassTemplateDecl
5359 // for a TUK_Friend.
5360 Declarator TheDeclarator(DS, Declarator::MemberContext);
5361 TypeSourceInfo *TSI;
5362 QualType T = GetTypeForDeclarator(TheDeclarator, S, &TSI);
5363 if (TheDeclarator.isInvalidType())
5366 // This is definitely an error in C++98. It's probably meant to
5367 // be forbidden in C++0x, too, but the specification is just
5370 // The problem is with declarations like the following:
5371 // template <T> friend A<T>::foo;
5372 // where deciding whether a class C is a friend or not now hinges
5373 // on whether there exists an instantiation of A that causes
5374 // 'foo' to equal C. There are restrictions on class-heads
5375 // (which we declare (by fiat) elaborated friend declarations to
5376 // be) that makes this tractable.
5378 // FIXME: handle "template <> friend class A<T>;", which
5379 // is possibly well-formed? Who even knows?
5380 if (TempParams.size() && !T->isElaboratedTypeSpecifier()) {
5381 Diag(Loc, diag::err_tagless_friend_type_template)
5382 << DS.getSourceRange();
5386 // C++ [class.friend]p2:
5387 // An elaborated-type-specifier shall be used in a friend declaration
5389 // * The class-key of the elaborated-type-specifier is required.
5390 // This is one of the rare places in Clang where it's legitimate to
5391 // ask about the "spelling" of the type.
5392 if (!getLangOptions().CPlusPlus0x && !T->isElaboratedTypeSpecifier()) {
5393 // If we evaluated the type to a record type, suggest putting
5395 if (const RecordType *RT = T->getAs<RecordType>()) {
5396 RecordDecl *RD = RT->getDecl();
5398 std::string InsertionText = std::string(" ") + RD->getKindName();
5400 Diag(DS.getTypeSpecTypeLoc(), diag::err_unelaborated_friend_type)
5401 << (unsigned) RD->getTagKind()
5403 << SourceRange(DS.getFriendSpecLoc())
5404 << FixItHint::CreateInsertion(DS.getTypeSpecTypeLoc(), InsertionText);
5407 Diag(DS.getFriendSpecLoc(), diag::err_unexpected_friend)
5408 << DS.getSourceRange();
5413 // Enum types cannot be friends.
5414 if (T->getAs<EnumType>()) {
5415 Diag(DS.getTypeSpecTypeLoc(), diag::err_enum_friend)
5416 << SourceRange(DS.getFriendSpecLoc());
5420 // C++98 [class.friend]p1: A friend of a class is a function
5421 // or class that is not a member of the class . . .
5422 // This is fixed in DR77, which just barely didn't make the C++03
5423 // deadline. It's also a very silly restriction that seriously
5424 // affects inner classes and which nobody else seems to implement;
5425 // thus we never diagnose it, not even in -pedantic.
5427 // But note that we could warn about it: it's always useless to
5428 // friend one of your own members (it's not, however, worthless to
5429 // friend a member of an arbitrary specialization of your template).
5432 if (TempParams.size())
5433 D = FriendTemplateDecl::Create(Context, CurContext, Loc,
5435 (TemplateParameterList**) TempParams.release(),
5437 DS.getFriendSpecLoc());
5439 D = FriendDecl::Create(Context, CurContext, Loc, TSI,
5440 DS.getFriendSpecLoc());
5441 D->setAccess(AS_public);
5442 CurContext->addDecl(D);
5444 return DeclPtrTy::make(D);
5448 Sema::ActOnFriendFunctionDecl(Scope *S,
5451 MultiTemplateParamsArg TemplateParams) {
5452 const DeclSpec &DS = D.getDeclSpec();
5454 assert(DS.isFriendSpecified());
5455 assert(DS.getStorageClassSpec() == DeclSpec::SCS_unspecified);
5457 SourceLocation Loc = D.getIdentifierLoc();
5458 TypeSourceInfo *TInfo = 0;
5459 QualType T = GetTypeForDeclarator(D, S, &TInfo);
5461 // C++ [class.friend]p1
5462 // A friend of a class is a function or class....
5463 // Note that this sees through typedefs, which is intended.
5464 // It *doesn't* see through dependent types, which is correct
5465 // according to [temp.arg.type]p3:
5466 // If a declaration acquires a function type through a
5467 // type dependent on a template-parameter and this causes
5468 // a declaration that does not use the syntactic form of a
5469 // function declarator to have a function type, the program
5471 if (!T->isFunctionType()) {
5472 Diag(Loc, diag::err_unexpected_friend);
5474 // It might be worthwhile to try to recover by creating an
5475 // appropriate declaration.
5479 // C++ [namespace.memdef]p3
5480 // - If a friend declaration in a non-local class first declares a
5481 // class or function, the friend class or function is a member
5482 // of the innermost enclosing namespace.
5483 // - The name of the friend is not found by simple name lookup
5484 // until a matching declaration is provided in that namespace
5485 // scope (either before or after the class declaration granting
5487 // - If a friend function is called, its name may be found by the
5488 // name lookup that considers functions from namespaces and
5489 // classes associated with the types of the function arguments.
5490 // - When looking for a prior declaration of a class or a function
5491 // declared as a friend, scopes outside the innermost enclosing
5492 // namespace scope are not considered.
5494 CXXScopeSpec &ScopeQual = D.getCXXScopeSpec();
5495 DeclarationName Name = GetNameForDeclarator(D);
5498 // The context we found the declaration in, or in which we should
5499 // create the declaration.
5502 // FIXME: handle local classes
5504 // Recover from invalid scope qualifiers as if they just weren't there.
5505 LookupResult Previous(*this, Name, D.getIdentifierLoc(), LookupOrdinaryName,
5507 if (!ScopeQual.isInvalid() && ScopeQual.isSet()) {
5508 // FIXME: RequireCompleteDeclContext
5509 DC = computeDeclContext(ScopeQual);
5511 // FIXME: handle dependent contexts
5512 if (!DC) return DeclPtrTy();
5514 LookupQualifiedName(Previous, DC);
5516 // If searching in that context implicitly found a declaration in
5517 // a different context, treat it like it wasn't found at all.
5518 // TODO: better diagnostics for this case. Suggesting the right
5519 // qualified scope would be nice...
5520 // FIXME: getRepresentativeDecl() is not right here at all
5521 if (Previous.empty() ||
5522 !Previous.getRepresentativeDecl()->getDeclContext()->Equals(DC)) {
5524 Diag(Loc, diag::err_qualified_friend_not_found) << Name << T;
5528 // C++ [class.friend]p1: A friend of a class is a function or
5529 // class that is not a member of the class . . .
5530 if (DC->Equals(CurContext))
5531 Diag(DS.getFriendSpecLoc(), diag::err_friend_is_member);
5533 // Otherwise walk out to the nearest namespace scope looking for matches.
5535 // TODO: handle local class contexts.
5539 // Skip class contexts. If someone can cite chapter and verse
5540 // for this behavior, that would be nice --- it's what GCC and
5541 // EDG do, and it seems like a reasonable intent, but the spec
5542 // really only says that checks for unqualified existing
5543 // declarations should stop at the nearest enclosing namespace,
5544 // not that they should only consider the nearest enclosing
5546 while (DC->isRecord())
5547 DC = DC->getParent();
5549 LookupQualifiedName(Previous, DC);
5551 // TODO: decide what we think about using declarations.
5552 if (!Previous.empty())
5555 if (DC->isFileContext()) break;
5556 DC = DC->getParent();
5559 // C++ [class.friend]p1: A friend of a class is a function or
5560 // class that is not a member of the class . . .
5561 // C++0x changes this for both friend types and functions.
5562 // Most C++ 98 compilers do seem to give an error here, so
5564 if (!Previous.empty() && DC->Equals(CurContext)
5565 && !getLangOptions().CPlusPlus0x)
5566 Diag(DS.getFriendSpecLoc(), diag::err_friend_is_member);
5569 if (DC->isFileContext()) {
5570 // This implies that it has to be an operator or function.
5571 if (D.getName().getKind() == UnqualifiedId::IK_ConstructorName ||
5572 D.getName().getKind() == UnqualifiedId::IK_DestructorName ||
5573 D.getName().getKind() == UnqualifiedId::IK_ConversionFunctionId) {
5574 Diag(Loc, diag::err_introducing_special_friend) <<
5575 (D.getName().getKind() == UnqualifiedId::IK_ConstructorName ? 0 :
5576 D.getName().getKind() == UnqualifiedId::IK_DestructorName ? 1 : 2);
5581 bool Redeclaration = false;
5582 NamedDecl *ND = ActOnFunctionDeclarator(S, D, DC, T, TInfo, Previous,
5583 move(TemplateParams),
5586 if (!ND) return DeclPtrTy();
5588 assert(ND->getDeclContext() == DC);
5589 assert(ND->getLexicalDeclContext() == CurContext);
5591 // Add the function declaration to the appropriate lookup tables,
5592 // adjusting the redeclarations list as necessary. We don't
5593 // want to do this yet if the friending class is dependent.
5595 // Also update the scope-based lookup if the target context's
5596 // lookup context is in lexical scope.
5597 if (!CurContext->isDependentContext()) {
5598 DC = DC->getLookupContext();
5599 DC->makeDeclVisibleInContext(ND, /* Recoverable=*/ false);
5600 if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
5601 PushOnScopeChains(ND, EnclosingScope, /*AddToContext=*/ false);
5604 FriendDecl *FrD = FriendDecl::Create(Context, CurContext,
5605 D.getIdentifierLoc(), ND,
5606 DS.getFriendSpecLoc());
5607 FrD->setAccess(AS_public);
5608 CurContext->addDecl(FrD);
5610 if (D.getName().getKind() == UnqualifiedId::IK_TemplateId)
5611 FrD->setSpecialization(true);
5613 return DeclPtrTy::make(ND);
5616 void Sema::SetDeclDeleted(DeclPtrTy dcl, SourceLocation DelLoc) {
5617 AdjustDeclIfTemplate(dcl);
5619 Decl *Dcl = dcl.getAs<Decl>();
5620 FunctionDecl *Fn = dyn_cast<FunctionDecl>(Dcl);
5622 Diag(DelLoc, diag::err_deleted_non_function);
5625 if (const FunctionDecl *Prev = Fn->getPreviousDeclaration()) {
5626 Diag(DelLoc, diag::err_deleted_decl_not_first);
5627 Diag(Prev->getLocation(), diag::note_previous_declaration);
5628 // If the declaration wasn't the first, we delete the function anyway for
5634 static void SearchForReturnInStmt(Sema &Self, Stmt *S) {
5635 for (Stmt::child_iterator CI = S->child_begin(), E = S->child_end(); CI != E;
5637 Stmt *SubStmt = *CI;
5640 if (isa<ReturnStmt>(SubStmt))
5641 Self.Diag(SubStmt->getSourceRange().getBegin(),
5642 diag::err_return_in_constructor_handler);
5643 if (!isa<Expr>(SubStmt))
5644 SearchForReturnInStmt(Self, SubStmt);
5648 void Sema::DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock) {
5649 for (unsigned I = 0, E = TryBlock->getNumHandlers(); I != E; ++I) {
5650 CXXCatchStmt *Handler = TryBlock->getHandler(I);
5651 SearchForReturnInStmt(*this, Handler);
5655 bool Sema::CheckOverridingFunctionReturnType(const CXXMethodDecl *New,
5656 const CXXMethodDecl *Old) {
5657 QualType NewTy = New->getType()->getAs<FunctionType>()->getResultType();
5658 QualType OldTy = Old->getType()->getAs<FunctionType>()->getResultType();
5660 if (Context.hasSameType(NewTy, OldTy) ||
5661 NewTy->isDependentType() || OldTy->isDependentType())
5664 // Check if the return types are covariant
5665 QualType NewClassTy, OldClassTy;
5667 /// Both types must be pointers or references to classes.
5668 if (const PointerType *NewPT = NewTy->getAs<PointerType>()) {
5669 if (const PointerType *OldPT = OldTy->getAs<PointerType>()) {
5670 NewClassTy = NewPT->getPointeeType();
5671 OldClassTy = OldPT->getPointeeType();
5673 } else if (const ReferenceType *NewRT = NewTy->getAs<ReferenceType>()) {
5674 if (const ReferenceType *OldRT = OldTy->getAs<ReferenceType>()) {
5675 if (NewRT->getTypeClass() == OldRT->getTypeClass()) {
5676 NewClassTy = NewRT->getPointeeType();
5677 OldClassTy = OldRT->getPointeeType();
5682 // The return types aren't either both pointers or references to a class type.
5683 if (NewClassTy.isNull()) {
5684 Diag(New->getLocation(),
5685 diag::err_different_return_type_for_overriding_virtual_function)
5686 << New->getDeclName() << NewTy << OldTy;
5687 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
5692 // C++ [class.virtual]p6:
5693 // If the return type of D::f differs from the return type of B::f, the
5694 // class type in the return type of D::f shall be complete at the point of
5695 // declaration of D::f or shall be the class type D.
5696 if (const RecordType *RT = NewClassTy->getAs<RecordType>()) {
5697 if (!RT->isBeingDefined() &&
5698 RequireCompleteType(New->getLocation(), NewClassTy,
5699 PDiag(diag::err_covariant_return_incomplete)
5700 << New->getDeclName()))
5704 if (!Context.hasSameUnqualifiedType(NewClassTy, OldClassTy)) {
5705 // Check if the new class derives from the old class.
5706 if (!IsDerivedFrom(NewClassTy, OldClassTy)) {
5707 Diag(New->getLocation(),
5708 diag::err_covariant_return_not_derived)
5709 << New->getDeclName() << NewTy << OldTy;
5710 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
5714 // Check if we the conversion from derived to base is valid.
5715 if (CheckDerivedToBaseConversion(NewClassTy, OldClassTy,
5716 diag::err_covariant_return_inaccessible_base,
5717 diag::err_covariant_return_ambiguous_derived_to_base_conv,
5718 // FIXME: Should this point to the return type?
5719 New->getLocation(), SourceRange(), New->getDeclName())) {
5720 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
5725 // The qualifiers of the return types must be the same.
5726 if (NewTy.getLocalCVRQualifiers() != OldTy.getLocalCVRQualifiers()) {
5727 Diag(New->getLocation(),
5728 diag::err_covariant_return_type_different_qualifications)
5729 << New->getDeclName() << NewTy << OldTy;
5730 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
5735 // The new class type must have the same or less qualifiers as the old type.
5736 if (NewClassTy.isMoreQualifiedThan(OldClassTy)) {
5737 Diag(New->getLocation(),
5738 diag::err_covariant_return_type_class_type_more_qualified)
5739 << New->getDeclName() << NewTy << OldTy;
5740 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
5747 bool Sema::CheckOverridingFunctionAttributes(const CXXMethodDecl *New,
5748 const CXXMethodDecl *Old)
5750 if (Old->hasAttr<FinalAttr>()) {
5751 Diag(New->getLocation(), diag::err_final_function_overridden)
5752 << New->getDeclName();
5753 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
5760 /// \brief Mark the given method pure.
5762 /// \param Method the method to be marked pure.
5764 /// \param InitRange the source range that covers the "0" initializer.
5765 bool Sema::CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange) {
5766 if (Method->isVirtual() || Method->getParent()->isDependentContext()) {
5769 // A class is abstract if at least one function is pure virtual.
5770 Method->getParent()->setAbstract(true);
5774 if (!Method->isInvalidDecl())
5775 Diag(Method->getLocation(), diag::err_non_virtual_pure)
5776 << Method->getDeclName() << InitRange;
5780 /// ActOnCXXEnterDeclInitializer - Invoked when we are about to parse
5781 /// an initializer for the out-of-line declaration 'Dcl'. The scope
5782 /// is a fresh scope pushed for just this purpose.
5784 /// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
5785 /// static data member of class X, names should be looked up in the scope of
5787 void Sema::ActOnCXXEnterDeclInitializer(Scope *S, DeclPtrTy Dcl) {
5788 // If there is no declaration, there was an error parsing it.
5789 Decl *D = Dcl.getAs<Decl>();
5792 // We should only get called for declarations with scope specifiers, like:
5794 assert(D->isOutOfLine());
5795 EnterDeclaratorContext(S, D->getDeclContext());
5798 /// ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an
5799 /// initializer for the out-of-line declaration 'Dcl'.
5800 void Sema::ActOnCXXExitDeclInitializer(Scope *S, DeclPtrTy Dcl) {
5801 // If there is no declaration, there was an error parsing it.
5802 Decl *D = Dcl.getAs<Decl>();
5805 assert(D->isOutOfLine());
5806 ExitDeclaratorContext(S);
5809 /// ActOnCXXConditionDeclarationExpr - Parsed a condition declaration of a
5810 /// C++ if/switch/while/for statement.
5811 /// e.g: "if (int x = f()) {...}"
5813 Sema::ActOnCXXConditionDeclaration(Scope *S, Declarator &D) {
5815 // The declarator shall not specify a function or an array.
5816 // The type-specifier-seq shall not contain typedef and shall not declare a
5817 // new class or enumeration.
5818 assert(D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef &&
5819 "Parser allowed 'typedef' as storage class of condition decl.");
5821 TypeSourceInfo *TInfo = 0;
5822 TagDecl *OwnedTag = 0;
5823 QualType Ty = GetTypeForDeclarator(D, S, &TInfo, &OwnedTag);
5825 if (Ty->isFunctionType()) { // The declarator shall not specify a function...
5826 // We exit without creating a CXXConditionDeclExpr because a FunctionDecl
5827 // would be created and CXXConditionDeclExpr wants a VarDecl.
5828 Diag(D.getIdentifierLoc(), diag::err_invalid_use_of_function_type)
5829 << D.getSourceRange();
5830 return DeclResult();
5831 } else if (OwnedTag && OwnedTag->isDefinition()) {
5832 // The type-specifier-seq shall not declare a new class or enumeration.
5833 Diag(OwnedTag->getLocation(), diag::err_type_defined_in_condition);
5836 DeclPtrTy Dcl = ActOnDeclarator(S, D);
5838 return DeclResult();
5840 VarDecl *VD = cast<VarDecl>(Dcl.getAs<Decl>());
5841 VD->setDeclaredInCondition(true);
5845 static bool needsVtable(CXXMethodDecl *MD, ASTContext &Context) {
5846 // Ignore dependent types.
5847 if (MD->isDependentContext())
5850 // Ignore declarations that are not definitions.
5851 if (!MD->isThisDeclarationADefinition())
5854 CXXRecordDecl *RD = MD->getParent();
5856 // Ignore classes without a vtable.
5857 if (!RD->isDynamicClass())
5860 switch (MD->getParent()->getTemplateSpecializationKind()) {
5861 case TSK_Undeclared:
5862 case TSK_ExplicitSpecialization:
5863 // Classes that aren't instantiations of templates don't need their
5864 // virtual methods marked until we see the definition of the key
5868 case TSK_ImplicitInstantiation:
5869 // This is a constructor of a class template; mark all of the virtual
5870 // members as referenced to ensure that they get instantiatied.
5871 if (isa<CXXConstructorDecl>(MD) || isa<CXXDestructorDecl>(MD))
5875 case TSK_ExplicitInstantiationDeclaration:
5878 case TSK_ExplicitInstantiationDefinition:
5879 // This is method of a explicit instantiation; mark all of the virtual
5880 // members as referenced to ensure that they get instantiatied.
5884 // Consider only out-of-line definitions of member functions. When we see
5885 // an inline definition, it's too early to compute the key function.
5886 if (!MD->isOutOfLine())
5889 const CXXMethodDecl *KeyFunction = Context.getKeyFunction(RD);
5891 // If there is no key function, we will need a copy of the vtable.
5895 // If this is the key function, we need to mark virtual members.
5896 if (KeyFunction->getCanonicalDecl() == MD->getCanonicalDecl())
5902 void Sema::MaybeMarkVirtualMembersReferenced(SourceLocation Loc,
5903 CXXMethodDecl *MD) {
5904 CXXRecordDecl *RD = MD->getParent();
5906 // We will need to mark all of the virtual members as referenced to build the
5908 if (!needsVtable(MD, Context))
5911 TemplateSpecializationKind kind = RD->getTemplateSpecializationKind();
5912 if (kind == TSK_ImplicitInstantiation)
5913 ClassesWithUnmarkedVirtualMembers.push_back(std::make_pair(RD, Loc));
5915 MarkVirtualMembersReferenced(Loc, RD);
5918 bool Sema::ProcessPendingClassesWithUnmarkedVirtualMembers() {
5919 if (ClassesWithUnmarkedVirtualMembers.empty())
5922 while (!ClassesWithUnmarkedVirtualMembers.empty()) {
5923 CXXRecordDecl *RD = ClassesWithUnmarkedVirtualMembers.back().first;
5924 SourceLocation Loc = ClassesWithUnmarkedVirtualMembers.back().second;
5925 ClassesWithUnmarkedVirtualMembers.pop_back();
5926 MarkVirtualMembersReferenced(Loc, RD);
5932 void Sema::MarkVirtualMembersReferenced(SourceLocation Loc,
5933 const CXXRecordDecl *RD) {
5934 for (CXXRecordDecl::method_iterator i = RD->method_begin(),
5935 e = RD->method_end(); i != e; ++i) {
5936 CXXMethodDecl *MD = *i;
5938 // C++ [basic.def.odr]p2:
5939 // [...] A virtual member function is used if it is not pure. [...]
5940 if (MD->isVirtual() && !MD->isPure())
5941 MarkDeclarationReferenced(Loc, MD);
5944 // Only classes that have virtual bases need a VTT.
5945 if (RD->getNumVBases() == 0)
5948 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
5949 e = RD->bases_end(); i != e; ++i) {
5950 const CXXRecordDecl *Base =
5951 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
5954 if (Base->getNumVBases() == 0)
5956 MarkVirtualMembersReferenced(Loc, Base);