SemaDeclCXX.cpp revision ca29ad9fea0fd51ac622c3f2db1890fdc5dae201
1//===------ SemaDeclCXX.cpp - Semantic Analysis for C++ Declarations ------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10//  This file implements semantic analysis for C++ declarations.
11//
12//===----------------------------------------------------------------------===//
13
14#include "Sema.h"
15#include "SemaInherit.h"
16#include "clang/AST/ASTConsumer.h"
17#include "clang/AST/ASTContext.h"
18#include "clang/AST/DeclVisitor.h"
19#include "clang/AST/TypeOrdering.h"
20#include "clang/AST/StmtVisitor.h"
21#include "clang/Lex/Preprocessor.h"
22#include "clang/Parse/DeclSpec.h"
23#include "llvm/ADT/STLExtras.h"
24#include "llvm/Support/Compiler.h"
25#include <algorithm> // for std::equal
26#include <map>
27
28using namespace clang;
29
30//===----------------------------------------------------------------------===//
31// CheckDefaultArgumentVisitor
32//===----------------------------------------------------------------------===//
33
34namespace {
35  /// CheckDefaultArgumentVisitor - C++ [dcl.fct.default] Traverses
36  /// the default argument of a parameter to determine whether it
37  /// contains any ill-formed subexpressions. For example, this will
38  /// diagnose the use of local variables or parameters within the
39  /// default argument expression.
40  class VISIBILITY_HIDDEN CheckDefaultArgumentVisitor
41    : public StmtVisitor<CheckDefaultArgumentVisitor, bool> {
42    Expr *DefaultArg;
43    Sema *S;
44
45  public:
46    CheckDefaultArgumentVisitor(Expr *defarg, Sema *s)
47      : DefaultArg(defarg), S(s) {}
48
49    bool VisitExpr(Expr *Node);
50    bool VisitDeclRefExpr(DeclRefExpr *DRE);
51    bool VisitCXXThisExpr(CXXThisExpr *ThisE);
52  };
53
54  /// VisitExpr - Visit all of the children of this expression.
55  bool CheckDefaultArgumentVisitor::VisitExpr(Expr *Node) {
56    bool IsInvalid = false;
57    for (Stmt::child_iterator I = Node->child_begin(),
58         E = Node->child_end(); I != E; ++I)
59      IsInvalid |= Visit(*I);
60    return IsInvalid;
61  }
62
63  /// VisitDeclRefExpr - Visit a reference to a declaration, to
64  /// determine whether this declaration can be used in the default
65  /// argument expression.
66  bool CheckDefaultArgumentVisitor::VisitDeclRefExpr(DeclRefExpr *DRE) {
67    NamedDecl *Decl = DRE->getDecl();
68    if (ParmVarDecl *Param = dyn_cast<ParmVarDecl>(Decl)) {
69      // C++ [dcl.fct.default]p9
70      //   Default arguments are evaluated each time the function is
71      //   called. The order of evaluation of function arguments is
72      //   unspecified. Consequently, parameters of a function shall not
73      //   be used in default argument expressions, even if they are not
74      //   evaluated. Parameters of a function declared before a default
75      //   argument expression are in scope and can hide namespace and
76      //   class member names.
77      return S->Diag(DRE->getSourceRange().getBegin(),
78                     diag::err_param_default_argument_references_param)
79         << Param->getDeclName() << DefaultArg->getSourceRange();
80    } else if (VarDecl *VDecl = dyn_cast<VarDecl>(Decl)) {
81      // C++ [dcl.fct.default]p7
82      //   Local variables shall not be used in default argument
83      //   expressions.
84      if (VDecl->isBlockVarDecl())
85        return S->Diag(DRE->getSourceRange().getBegin(),
86                       diag::err_param_default_argument_references_local)
87          << VDecl->getDeclName() << DefaultArg->getSourceRange();
88    }
89
90    return false;
91  }
92
93  /// VisitCXXThisExpr - Visit a C++ "this" expression.
94  bool CheckDefaultArgumentVisitor::VisitCXXThisExpr(CXXThisExpr *ThisE) {
95    // C++ [dcl.fct.default]p8:
96    //   The keyword this shall not be used in a default argument of a
97    //   member function.
98    return S->Diag(ThisE->getSourceRange().getBegin(),
99                   diag::err_param_default_argument_references_this)
100               << ThisE->getSourceRange();
101  }
102}
103
104/// ActOnParamDefaultArgument - Check whether the default argument
105/// provided for a function parameter is well-formed. If so, attach it
106/// to the parameter declaration.
107void
108Sema::ActOnParamDefaultArgument(DeclPtrTy param, SourceLocation EqualLoc,
109                                ExprArg defarg) {
110  ParmVarDecl *Param = cast<ParmVarDecl>(param.getAs<Decl>());
111  ExprOwningPtr<Expr> DefaultArg(this, (Expr *)defarg.release());
112  QualType ParamType = Param->getType();
113
114  // Default arguments are only permitted in C++
115  if (!getLangOptions().CPlusPlus) {
116    Diag(EqualLoc, diag::err_param_default_argument)
117      << DefaultArg->getSourceRange();
118    Param->setInvalidDecl();
119    return;
120  }
121
122  // C++ [dcl.fct.default]p5
123  //   A default argument expression is implicitly converted (clause
124  //   4) to the parameter type. The default argument expression has
125  //   the same semantic constraints as the initializer expression in
126  //   a declaration of a variable of the parameter type, using the
127  //   copy-initialization semantics (8.5).
128  Expr *DefaultArgPtr = DefaultArg.get();
129  bool DefaultInitFailed = CheckInitializerTypes(DefaultArgPtr, ParamType,
130                                                 EqualLoc,
131                                                 Param->getDeclName(),
132                                                 /*DirectInit=*/false);
133  if (DefaultArgPtr != DefaultArg.get()) {
134    DefaultArg.take();
135    DefaultArg.reset(DefaultArgPtr);
136  }
137  if (DefaultInitFailed) {
138    return;
139  }
140
141  // Check that the default argument is well-formed
142  CheckDefaultArgumentVisitor DefaultArgChecker(DefaultArg.get(), this);
143  if (DefaultArgChecker.Visit(DefaultArg.get())) {
144    Param->setInvalidDecl();
145    return;
146  }
147
148  // Okay: add the default argument to the parameter
149  Param->setDefaultArg(DefaultArg.take());
150}
151
152/// ActOnParamUnparsedDefaultArgument - We've seen a default
153/// argument for a function parameter, but we can't parse it yet
154/// because we're inside a class definition. Note that this default
155/// argument will be parsed later.
156void Sema::ActOnParamUnparsedDefaultArgument(DeclPtrTy param,
157                                             SourceLocation EqualLoc) {
158  ParmVarDecl *Param = cast<ParmVarDecl>(param.getAs<Decl>());
159  if (Param)
160    Param->setUnparsedDefaultArg();
161}
162
163/// ActOnParamDefaultArgumentError - Parsing or semantic analysis of
164/// the default argument for the parameter param failed.
165void Sema::ActOnParamDefaultArgumentError(DeclPtrTy param) {
166  cast<ParmVarDecl>(param.getAs<Decl>())->setInvalidDecl();
167}
168
169/// CheckExtraCXXDefaultArguments - Check for any extra default
170/// arguments in the declarator, which is not a function declaration
171/// or definition and therefore is not permitted to have default
172/// arguments. This routine should be invoked for every declarator
173/// that is not a function declaration or definition.
174void Sema::CheckExtraCXXDefaultArguments(Declarator &D) {
175  // C++ [dcl.fct.default]p3
176  //   A default argument expression shall be specified only in the
177  //   parameter-declaration-clause of a function declaration or in a
178  //   template-parameter (14.1). It shall not be specified for a
179  //   parameter pack. If it is specified in a
180  //   parameter-declaration-clause, it shall not occur within a
181  //   declarator or abstract-declarator of a parameter-declaration.
182  for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
183    DeclaratorChunk &chunk = D.getTypeObject(i);
184    if (chunk.Kind == DeclaratorChunk::Function) {
185      for (unsigned argIdx = 0, e = chunk.Fun.NumArgs; argIdx != e; ++argIdx) {
186        ParmVarDecl *Param =
187          cast<ParmVarDecl>(chunk.Fun.ArgInfo[argIdx].Param.getAs<Decl>());
188        if (Param->hasUnparsedDefaultArg()) {
189          CachedTokens *Toks = chunk.Fun.ArgInfo[argIdx].DefaultArgTokens;
190          Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
191            << SourceRange((*Toks)[1].getLocation(), Toks->back().getLocation());
192          delete Toks;
193          chunk.Fun.ArgInfo[argIdx].DefaultArgTokens = 0;
194        } else if (Param->getDefaultArg()) {
195          Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
196            << Param->getDefaultArg()->getSourceRange();
197          Param->setDefaultArg(0);
198        }
199      }
200    }
201  }
202}
203
204// MergeCXXFunctionDecl - Merge two declarations of the same C++
205// function, once we already know that they have the same
206// type. Subroutine of MergeFunctionDecl. Returns true if there was an
207// error, false otherwise.
208bool Sema::MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old) {
209  bool Invalid = false;
210
211  // C++ [dcl.fct.default]p4:
212  //
213  //   For non-template functions, default arguments can be added in
214  //   later declarations of a function in the same
215  //   scope. Declarations in different scopes have completely
216  //   distinct sets of default arguments. That is, declarations in
217  //   inner scopes do not acquire default arguments from
218  //   declarations in outer scopes, and vice versa. In a given
219  //   function declaration, all parameters subsequent to a
220  //   parameter with a default argument shall have default
221  //   arguments supplied in this or previous declarations. A
222  //   default argument shall not be redefined by a later
223  //   declaration (not even to the same value).
224  for (unsigned p = 0, NumParams = Old->getNumParams(); p < NumParams; ++p) {
225    ParmVarDecl *OldParam = Old->getParamDecl(p);
226    ParmVarDecl *NewParam = New->getParamDecl(p);
227
228    if(OldParam->getDefaultArg() && NewParam->getDefaultArg()) {
229      Diag(NewParam->getLocation(),
230           diag::err_param_default_argument_redefinition)
231        << NewParam->getDefaultArg()->getSourceRange();
232      Diag(OldParam->getLocation(), diag::note_previous_definition);
233      Invalid = true;
234    } else if (OldParam->getDefaultArg()) {
235      // Merge the old default argument into the new parameter
236      NewParam->setDefaultArg(OldParam->getDefaultArg());
237    }
238  }
239
240  return Invalid;
241}
242
243/// CheckCXXDefaultArguments - Verify that the default arguments for a
244/// function declaration are well-formed according to C++
245/// [dcl.fct.default].
246void Sema::CheckCXXDefaultArguments(FunctionDecl *FD) {
247  unsigned NumParams = FD->getNumParams();
248  unsigned p;
249
250  // Find first parameter with a default argument
251  for (p = 0; p < NumParams; ++p) {
252    ParmVarDecl *Param = FD->getParamDecl(p);
253    if (Param->getDefaultArg())
254      break;
255  }
256
257  // C++ [dcl.fct.default]p4:
258  //   In a given function declaration, all parameters
259  //   subsequent to a parameter with a default argument shall
260  //   have default arguments supplied in this or previous
261  //   declarations. A default argument shall not be redefined
262  //   by a later declaration (not even to the same value).
263  unsigned LastMissingDefaultArg = 0;
264  for(; p < NumParams; ++p) {
265    ParmVarDecl *Param = FD->getParamDecl(p);
266    if (!Param->getDefaultArg()) {
267      if (Param->isInvalidDecl())
268        /* We already complained about this parameter. */;
269      else if (Param->getIdentifier())
270        Diag(Param->getLocation(),
271             diag::err_param_default_argument_missing_name)
272          << Param->getIdentifier();
273      else
274        Diag(Param->getLocation(),
275             diag::err_param_default_argument_missing);
276
277      LastMissingDefaultArg = p;
278    }
279  }
280
281  if (LastMissingDefaultArg > 0) {
282    // Some default arguments were missing. Clear out all of the
283    // default arguments up to (and including) the last missing
284    // default argument, so that we leave the function parameters
285    // in a semantically valid state.
286    for (p = 0; p <= LastMissingDefaultArg; ++p) {
287      ParmVarDecl *Param = FD->getParamDecl(p);
288      if (Param->getDefaultArg()) {
289        if (!Param->hasUnparsedDefaultArg())
290          Param->getDefaultArg()->Destroy(Context);
291        Param->setDefaultArg(0);
292      }
293    }
294  }
295}
296
297/// isCurrentClassName - Determine whether the identifier II is the
298/// name of the class type currently being defined. In the case of
299/// nested classes, this will only return true if II is the name of
300/// the innermost class.
301bool Sema::isCurrentClassName(const IdentifierInfo &II, Scope *,
302                              const CXXScopeSpec *SS) {
303  CXXRecordDecl *CurDecl;
304  if (SS && SS->isSet() && !SS->isInvalid()) {
305    DeclContext *DC = computeDeclContext(*SS);
306    CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC);
307  } else
308    CurDecl = dyn_cast_or_null<CXXRecordDecl>(CurContext);
309
310  if (CurDecl)
311    return &II == CurDecl->getIdentifier();
312  else
313    return false;
314}
315
316/// \brief Check the validity of a C++ base class specifier.
317///
318/// \returns a new CXXBaseSpecifier if well-formed, emits diagnostics
319/// and returns NULL otherwise.
320CXXBaseSpecifier *
321Sema::CheckBaseSpecifier(CXXRecordDecl *Class,
322                         SourceRange SpecifierRange,
323                         bool Virtual, AccessSpecifier Access,
324                         QualType BaseType,
325                         SourceLocation BaseLoc) {
326  // C++ [class.union]p1:
327  //   A union shall not have base classes.
328  if (Class->isUnion()) {
329    Diag(Class->getLocation(), diag::err_base_clause_on_union)
330      << SpecifierRange;
331    return 0;
332  }
333
334  if (BaseType->isDependentType())
335    return new CXXBaseSpecifier(SpecifierRange, Virtual,
336                                Class->getTagKind() == RecordDecl::TK_class,
337                                Access, BaseType);
338
339  // Base specifiers must be record types.
340  if (!BaseType->isRecordType()) {
341    Diag(BaseLoc, diag::err_base_must_be_class) << SpecifierRange;
342    return 0;
343  }
344
345  // C++ [class.union]p1:
346  //   A union shall not be used as a base class.
347  if (BaseType->isUnionType()) {
348    Diag(BaseLoc, diag::err_union_as_base_class) << SpecifierRange;
349    return 0;
350  }
351
352  // C++ [class.derived]p2:
353  //   The class-name in a base-specifier shall not be an incompletely
354  //   defined class.
355  if (RequireCompleteType(BaseLoc, BaseType, diag::err_incomplete_base_class,
356                          SpecifierRange))
357    return 0;
358
359  // If the base class is polymorphic, the new one is, too.
360  RecordDecl *BaseDecl = BaseType->getAsRecordType()->getDecl();
361  assert(BaseDecl && "Record type has no declaration");
362  BaseDecl = BaseDecl->getDefinition(Context);
363  assert(BaseDecl && "Base type is not incomplete, but has no definition");
364  if (cast<CXXRecordDecl>(BaseDecl)->isPolymorphic())
365    Class->setPolymorphic(true);
366
367  // C++ [dcl.init.aggr]p1:
368  //   An aggregate is [...] a class with [...] no base classes [...].
369  Class->setAggregate(false);
370  Class->setPOD(false);
371
372  // Create the base specifier.
373  // FIXME: Allocate via ASTContext?
374  return new CXXBaseSpecifier(SpecifierRange, Virtual,
375                              Class->getTagKind() == RecordDecl::TK_class,
376                              Access, BaseType);
377}
378
379/// ActOnBaseSpecifier - Parsed a base specifier. A base specifier is
380/// one entry in the base class list of a class specifier, for
381/// example:
382///    class foo : public bar, virtual private baz {
383/// 'public bar' and 'virtual private baz' are each base-specifiers.
384Sema::BaseResult
385Sema::ActOnBaseSpecifier(DeclPtrTy classdecl, SourceRange SpecifierRange,
386                         bool Virtual, AccessSpecifier Access,
387                         TypeTy *basetype, SourceLocation BaseLoc) {
388  AdjustDeclIfTemplate(classdecl);
389  CXXRecordDecl *Class = cast<CXXRecordDecl>(classdecl.getAs<Decl>());
390  QualType BaseType = QualType::getFromOpaquePtr(basetype);
391  if (CXXBaseSpecifier *BaseSpec = CheckBaseSpecifier(Class, SpecifierRange,
392                                                      Virtual, Access,
393                                                      BaseType, BaseLoc))
394    return BaseSpec;
395
396  return true;
397}
398
399/// \brief Performs the actual work of attaching the given base class
400/// specifiers to a C++ class.
401bool Sema::AttachBaseSpecifiers(CXXRecordDecl *Class, CXXBaseSpecifier **Bases,
402                                unsigned NumBases) {
403 if (NumBases == 0)
404    return false;
405
406  // Used to keep track of which base types we have already seen, so
407  // that we can properly diagnose redundant direct base types. Note
408  // that the key is always the unqualified canonical type of the base
409  // class.
410  std::map<QualType, CXXBaseSpecifier*, QualTypeOrdering> KnownBaseTypes;
411
412  // Copy non-redundant base specifiers into permanent storage.
413  unsigned NumGoodBases = 0;
414  bool Invalid = false;
415  for (unsigned idx = 0; idx < NumBases; ++idx) {
416    QualType NewBaseType
417      = Context.getCanonicalType(Bases[idx]->getType());
418    NewBaseType = NewBaseType.getUnqualifiedType();
419
420    if (KnownBaseTypes[NewBaseType]) {
421      // C++ [class.mi]p3:
422      //   A class shall not be specified as a direct base class of a
423      //   derived class more than once.
424      Diag(Bases[idx]->getSourceRange().getBegin(),
425           diag::err_duplicate_base_class)
426        << KnownBaseTypes[NewBaseType]->getType()
427        << Bases[idx]->getSourceRange();
428
429      // Delete the duplicate base class specifier; we're going to
430      // overwrite its pointer later.
431      delete Bases[idx];
432
433      Invalid = true;
434    } else {
435      // Okay, add this new base class.
436      KnownBaseTypes[NewBaseType] = Bases[idx];
437      Bases[NumGoodBases++] = Bases[idx];
438    }
439  }
440
441  // Attach the remaining base class specifiers to the derived class.
442  Class->setBases(Bases, NumGoodBases);
443
444  // Delete the remaining (good) base class specifiers, since their
445  // data has been copied into the CXXRecordDecl.
446  for (unsigned idx = 0; idx < NumGoodBases; ++idx)
447    delete Bases[idx];
448
449  return Invalid;
450}
451
452/// ActOnBaseSpecifiers - Attach the given base specifiers to the
453/// class, after checking whether there are any duplicate base
454/// classes.
455void Sema::ActOnBaseSpecifiers(DeclPtrTy ClassDecl, BaseTy **Bases,
456                               unsigned NumBases) {
457  if (!ClassDecl || !Bases || !NumBases)
458    return;
459
460  AdjustDeclIfTemplate(ClassDecl);
461  AttachBaseSpecifiers(cast<CXXRecordDecl>(ClassDecl.getAs<Decl>()),
462                       (CXXBaseSpecifier**)(Bases), NumBases);
463}
464
465//===----------------------------------------------------------------------===//
466// C++ class member Handling
467//===----------------------------------------------------------------------===//
468
469/// ActOnCXXMemberDeclarator - This is invoked when a C++ class member
470/// declarator is parsed. 'AS' is the access specifier, 'BW' specifies the
471/// bitfield width if there is one and 'InitExpr' specifies the initializer if
472/// any.
473Sema::DeclPtrTy
474Sema::ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS, Declarator &D,
475                               ExprTy *BW, ExprTy *InitExpr, bool Deleted) {
476  const DeclSpec &DS = D.getDeclSpec();
477  DeclarationName Name = GetNameForDeclarator(D);
478  Expr *BitWidth = static_cast<Expr*>(BW);
479  Expr *Init = static_cast<Expr*>(InitExpr);
480  SourceLocation Loc = D.getIdentifierLoc();
481
482  bool isFunc = D.isFunctionDeclarator();
483
484  // C++ 9.2p6: A member shall not be declared to have automatic storage
485  // duration (auto, register) or with the extern storage-class-specifier.
486  // C++ 7.1.1p8: The mutable specifier can be applied only to names of class
487  // data members and cannot be applied to names declared const or static,
488  // and cannot be applied to reference members.
489  switch (DS.getStorageClassSpec()) {
490    case DeclSpec::SCS_unspecified:
491    case DeclSpec::SCS_typedef:
492    case DeclSpec::SCS_static:
493      // FALL THROUGH.
494      break;
495    case DeclSpec::SCS_mutable:
496      if (isFunc) {
497        if (DS.getStorageClassSpecLoc().isValid())
498          Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_function);
499        else
500          Diag(DS.getThreadSpecLoc(), diag::err_mutable_function);
501
502        // FIXME: It would be nicer if the keyword was ignored only for this
503        // declarator. Otherwise we could get follow-up errors.
504        D.getMutableDeclSpec().ClearStorageClassSpecs();
505      } else {
506        QualType T = GetTypeForDeclarator(D, S);
507        diag::kind err = static_cast<diag::kind>(0);
508        if (T->isReferenceType())
509          err = diag::err_mutable_reference;
510        else if (T.isConstQualified())
511          err = diag::err_mutable_const;
512        if (err != 0) {
513          if (DS.getStorageClassSpecLoc().isValid())
514            Diag(DS.getStorageClassSpecLoc(), err);
515          else
516            Diag(DS.getThreadSpecLoc(), err);
517          // FIXME: It would be nicer if the keyword was ignored only for this
518          // declarator. Otherwise we could get follow-up errors.
519          D.getMutableDeclSpec().ClearStorageClassSpecs();
520        }
521      }
522      break;
523    default:
524      if (DS.getStorageClassSpecLoc().isValid())
525        Diag(DS.getStorageClassSpecLoc(),
526             diag::err_storageclass_invalid_for_member);
527      else
528        Diag(DS.getThreadSpecLoc(), diag::err_storageclass_invalid_for_member);
529      D.getMutableDeclSpec().ClearStorageClassSpecs();
530  }
531
532  if (!isFunc &&
533      D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_typename &&
534      D.getNumTypeObjects() == 0) {
535    // Check also for this case:
536    //
537    // typedef int f();
538    // f a;
539    //
540    QualType TDType = QualType::getFromOpaquePtr(DS.getTypeRep());
541    isFunc = TDType->isFunctionType();
542  }
543
544  bool isInstField = ((DS.getStorageClassSpec() == DeclSpec::SCS_unspecified ||
545                       DS.getStorageClassSpec() == DeclSpec::SCS_mutable) &&
546                      !isFunc);
547
548  Decl *Member;
549  if (isInstField) {
550    Member = HandleField(S, cast<CXXRecordDecl>(CurContext), Loc, D, BitWidth,
551                         AS);
552    assert(Member && "HandleField never returns null");
553  } else {
554    Member = ActOnDeclarator(S, D).getAs<Decl>();
555    if (!Member) {
556      if (BitWidth) DeleteExpr(BitWidth);
557      return DeclPtrTy();
558    }
559
560    // Non-instance-fields can't have a bitfield.
561    if (BitWidth) {
562      if (Member->isInvalidDecl()) {
563        // don't emit another diagnostic.
564      } else if (isa<VarDecl>(Member)) {
565        // C++ 9.6p3: A bit-field shall not be a static member.
566        // "static member 'A' cannot be a bit-field"
567        Diag(Loc, diag::err_static_not_bitfield)
568          << Name << BitWidth->getSourceRange();
569      } else if (isa<TypedefDecl>(Member)) {
570        // "typedef member 'x' cannot be a bit-field"
571        Diag(Loc, diag::err_typedef_not_bitfield)
572          << Name << BitWidth->getSourceRange();
573      } else {
574        // A function typedef ("typedef int f(); f a;").
575        // C++ 9.6p3: A bit-field shall have integral or enumeration type.
576        Diag(Loc, diag::err_not_integral_type_bitfield)
577          << Name << cast<ValueDecl>(Member)->getType()
578          << BitWidth->getSourceRange();
579      }
580
581      DeleteExpr(BitWidth);
582      BitWidth = 0;
583      Member->setInvalidDecl();
584    }
585
586    Member->setAccess(AS);
587  }
588
589  assert((Name || isInstField) && "No identifier for non-field ?");
590
591  if (Init)
592    AddInitializerToDecl(DeclPtrTy::make(Member), ExprArg(*this, Init), false);
593  if (Deleted) // FIXME: Source location is not very good.
594    SetDeclDeleted(DeclPtrTy::make(Member), D.getSourceRange().getBegin());
595
596  if (isInstField) {
597    FieldCollector->Add(cast<FieldDecl>(Member));
598    return DeclPtrTy();
599  }
600  return DeclPtrTy::make(Member);
601}
602
603/// ActOnMemInitializer - Handle a C++ member initializer.
604Sema::MemInitResult
605Sema::ActOnMemInitializer(DeclPtrTy ConstructorD,
606                          Scope *S,
607                          IdentifierInfo *MemberOrBase,
608                          SourceLocation IdLoc,
609                          SourceLocation LParenLoc,
610                          ExprTy **Args, unsigned NumArgs,
611                          SourceLocation *CommaLocs,
612                          SourceLocation RParenLoc) {
613  CXXConstructorDecl *Constructor
614    = dyn_cast<CXXConstructorDecl>(ConstructorD.getAs<Decl>());
615  if (!Constructor) {
616    // The user wrote a constructor initializer on a function that is
617    // not a C++ constructor. Ignore the error for now, because we may
618    // have more member initializers coming; we'll diagnose it just
619    // once in ActOnMemInitializers.
620    return true;
621  }
622
623  CXXRecordDecl *ClassDecl = Constructor->getParent();
624
625  // C++ [class.base.init]p2:
626  //   Names in a mem-initializer-id are looked up in the scope of the
627  //   constructor’s class and, if not found in that scope, are looked
628  //   up in the scope containing the constructor’s
629  //   definition. [Note: if the constructor’s class contains a member
630  //   with the same name as a direct or virtual base class of the
631  //   class, a mem-initializer-id naming the member or base class and
632  //   composed of a single identifier refers to the class member. A
633  //   mem-initializer-id for the hidden base class may be specified
634  //   using a qualified name. ]
635  // Look for a member, first.
636  FieldDecl *Member = 0;
637  DeclContext::lookup_result Result
638    = ClassDecl->lookup(Context, MemberOrBase);
639  if (Result.first != Result.second)
640    Member = dyn_cast<FieldDecl>(*Result.first);
641
642  // FIXME: Handle members of an anonymous union.
643
644  if (Member) {
645    // FIXME: Perform direct initialization of the member.
646    return new CXXBaseOrMemberInitializer(Member, (Expr **)Args, NumArgs);
647  }
648
649  // It didn't name a member, so see if it names a class.
650  TypeTy *BaseTy = getTypeName(*MemberOrBase, IdLoc, S, 0/*SS*/);
651  if (!BaseTy)
652    return Diag(IdLoc, diag::err_mem_init_not_member_or_class)
653      << MemberOrBase << SourceRange(IdLoc, RParenLoc);
654
655  QualType BaseType = QualType::getFromOpaquePtr(BaseTy);
656  if (!BaseType->isRecordType())
657    return Diag(IdLoc, diag::err_base_init_does_not_name_class)
658      << BaseType << SourceRange(IdLoc, RParenLoc);
659
660  // C++ [class.base.init]p2:
661  //   [...] Unless the mem-initializer-id names a nonstatic data
662  //   member of the constructor’s class or a direct or virtual base
663  //   of that class, the mem-initializer is ill-formed. A
664  //   mem-initializer-list can initialize a base class using any
665  //   name that denotes that base class type.
666
667  // First, check for a direct base class.
668  const CXXBaseSpecifier *DirectBaseSpec = 0;
669  for (CXXRecordDecl::base_class_const_iterator Base = ClassDecl->bases_begin();
670       Base != ClassDecl->bases_end(); ++Base) {
671    if (Context.getCanonicalType(BaseType).getUnqualifiedType() ==
672        Context.getCanonicalType(Base->getType()).getUnqualifiedType()) {
673      // We found a direct base of this type. That's what we're
674      // initializing.
675      DirectBaseSpec = &*Base;
676      break;
677    }
678  }
679
680  // Check for a virtual base class.
681  // FIXME: We might be able to short-circuit this if we know in
682  // advance that there are no virtual bases.
683  const CXXBaseSpecifier *VirtualBaseSpec = 0;
684  if (!DirectBaseSpec || !DirectBaseSpec->isVirtual()) {
685    // We haven't found a base yet; search the class hierarchy for a
686    // virtual base class.
687    BasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
688                    /*DetectVirtual=*/false);
689    if (IsDerivedFrom(Context.getTypeDeclType(ClassDecl), BaseType, Paths)) {
690      for (BasePaths::paths_iterator Path = Paths.begin();
691           Path != Paths.end(); ++Path) {
692        if (Path->back().Base->isVirtual()) {
693          VirtualBaseSpec = Path->back().Base;
694          break;
695        }
696      }
697    }
698  }
699
700  // C++ [base.class.init]p2:
701  //   If a mem-initializer-id is ambiguous because it designates both
702  //   a direct non-virtual base class and an inherited virtual base
703  //   class, the mem-initializer is ill-formed.
704  if (DirectBaseSpec && VirtualBaseSpec)
705    return Diag(IdLoc, diag::err_base_init_direct_and_virtual)
706      << MemberOrBase << SourceRange(IdLoc, RParenLoc);
707
708  return new CXXBaseOrMemberInitializer(BaseType, (Expr **)Args, NumArgs);
709}
710
711void Sema::ActOnMemInitializers(DeclPtrTy ConstructorDecl,
712                                SourceLocation ColonLoc,
713                                MemInitTy **MemInits, unsigned NumMemInits) {
714  CXXConstructorDecl *Constructor =
715  dyn_cast<CXXConstructorDecl>(ConstructorDecl.getAs<Decl>());
716
717  if (!Constructor) {
718    Diag(ColonLoc, diag::err_only_constructors_take_base_inits);
719    return;
720  }
721}
722
723namespace {
724  /// PureVirtualMethodCollector - traverses a class and its superclasses
725  /// and determines if it has any pure virtual methods.
726  class VISIBILITY_HIDDEN PureVirtualMethodCollector {
727    ASTContext &Context;
728
729  public:
730    typedef llvm::SmallVector<const CXXMethodDecl*, 8> MethodList;
731
732  private:
733    MethodList Methods;
734
735    void Collect(const CXXRecordDecl* RD, MethodList& Methods);
736
737  public:
738    PureVirtualMethodCollector(ASTContext &Ctx, const CXXRecordDecl* RD)
739      : Context(Ctx) {
740
741      MethodList List;
742      Collect(RD, List);
743
744      // Copy the temporary list to methods, and make sure to ignore any
745      // null entries.
746      for (size_t i = 0, e = List.size(); i != e; ++i) {
747        if (List[i])
748          Methods.push_back(List[i]);
749      }
750    }
751
752    bool empty() const { return Methods.empty(); }
753
754    MethodList::const_iterator methods_begin() { return Methods.begin(); }
755    MethodList::const_iterator methods_end() { return Methods.end(); }
756  };
757
758  void PureVirtualMethodCollector::Collect(const CXXRecordDecl* RD,
759                                           MethodList& Methods) {
760    // First, collect the pure virtual methods for the base classes.
761    for (CXXRecordDecl::base_class_const_iterator Base = RD->bases_begin(),
762         BaseEnd = RD->bases_end(); Base != BaseEnd; ++Base) {
763      if (const RecordType *RT = Base->getType()->getAsRecordType()) {
764        const CXXRecordDecl *BaseDecl = cast<CXXRecordDecl>(RT->getDecl());
765        if (BaseDecl && BaseDecl->isAbstract())
766          Collect(BaseDecl, Methods);
767      }
768    }
769
770    // Next, zero out any pure virtual methods that this class overrides.
771    for (size_t i = 0, e = Methods.size(); i != e; ++i) {
772      const CXXMethodDecl *VMD = dyn_cast_or_null<CXXMethodDecl>(Methods[i]);
773      if (!VMD)
774        continue;
775
776      DeclContext::lookup_const_iterator I, E;
777      for (llvm::tie(I, E) = RD->lookup(Context, VMD->getDeclName());
778           I != E; ++I) {
779        if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(*I)) {
780          if (Context.getCanonicalType(MD->getType()) ==
781              Context.getCanonicalType(VMD->getType())) {
782            // We did find a matching method, which means that this is not a
783            // pure virtual method in the current class. Zero it out.
784            Methods[i] = 0;
785          }
786        }
787      }
788    }
789
790    // Finally, add pure virtual methods from this class.
791    for (RecordDecl::decl_iterator i = RD->decls_begin(Context),
792                                   e = RD->decls_end(Context);
793         i != e; ++i) {
794      if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(*i)) {
795        if (MD->isPure())
796          Methods.push_back(MD);
797      }
798    }
799  }
800}
801
802bool Sema::RequireNonAbstractType(SourceLocation Loc, QualType T,
803                                  unsigned DiagID, AbstractDiagSelID SelID,
804                                  const CXXRecordDecl *CurrentRD) {
805
806  if (!getLangOptions().CPlusPlus)
807    return false;
808
809  if (const ArrayType *AT = Context.getAsArrayType(T))
810    return RequireNonAbstractType(Loc, AT->getElementType(), DiagID, SelID,
811                                  CurrentRD);
812
813  if (const PointerType *PT = T->getAsPointerType()) {
814    // Find the innermost pointer type.
815    while (const PointerType *T = PT->getPointeeType()->getAsPointerType())
816      PT = T;
817
818    if (const ArrayType *AT = Context.getAsArrayType(PT->getPointeeType()))
819      return RequireNonAbstractType(Loc, AT->getElementType(), DiagID, SelID,
820                                    CurrentRD);
821  }
822
823  const RecordType *RT = T->getAsRecordType();
824  if (!RT)
825    return false;
826
827  const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl());
828  if (!RD)
829    return false;
830
831  if (CurrentRD && CurrentRD != RD)
832    return false;
833
834  if (!RD->isAbstract())
835    return false;
836
837  Diag(Loc, DiagID) << RD->getDeclName() << SelID;
838
839  // Check if we've already emitted the list of pure virtual functions for this
840  // class.
841  if (PureVirtualClassDiagSet && PureVirtualClassDiagSet->count(RD))
842    return true;
843
844  PureVirtualMethodCollector Collector(Context, RD);
845
846  for (PureVirtualMethodCollector::MethodList::const_iterator I =
847       Collector.methods_begin(), E = Collector.methods_end(); I != E; ++I) {
848    const CXXMethodDecl *MD = *I;
849
850    Diag(MD->getLocation(), diag::note_pure_virtual_function) <<
851      MD->getDeclName();
852  }
853
854  if (!PureVirtualClassDiagSet)
855    PureVirtualClassDiagSet.reset(new RecordDeclSetTy);
856  PureVirtualClassDiagSet->insert(RD);
857
858  return true;
859}
860
861namespace {
862  class VISIBILITY_HIDDEN AbstractClassUsageDiagnoser
863    : public DeclVisitor<AbstractClassUsageDiagnoser, bool> {
864    Sema &SemaRef;
865    CXXRecordDecl *AbstractClass;
866
867    bool VisitDeclContext(const DeclContext *DC) {
868      bool Invalid = false;
869
870      for (CXXRecordDecl::decl_iterator I = DC->decls_begin(SemaRef.Context),
871           E = DC->decls_end(SemaRef.Context); I != E; ++I)
872        Invalid |= Visit(*I);
873
874      return Invalid;
875    }
876
877  public:
878    AbstractClassUsageDiagnoser(Sema& SemaRef, CXXRecordDecl *ac)
879      : SemaRef(SemaRef), AbstractClass(ac) {
880        Visit(SemaRef.Context.getTranslationUnitDecl());
881    }
882
883    bool VisitFunctionDecl(const FunctionDecl *FD) {
884      if (FD->isThisDeclarationADefinition()) {
885        // No need to do the check if we're in a definition, because it requires
886        // that the return/param types are complete.
887        // because that requires
888        return VisitDeclContext(FD);
889      }
890
891      // Check the return type.
892      QualType RTy = FD->getType()->getAsFunctionType()->getResultType();
893      bool Invalid =
894        SemaRef.RequireNonAbstractType(FD->getLocation(), RTy,
895                                       diag::err_abstract_type_in_decl,
896                                       Sema::AbstractReturnType,
897                                       AbstractClass);
898
899      for (FunctionDecl::param_const_iterator I = FD->param_begin(),
900           E = FD->param_end(); I != E; ++I) {
901        const ParmVarDecl *VD = *I;
902        Invalid |=
903          SemaRef.RequireNonAbstractType(VD->getLocation(),
904                                         VD->getOriginalType(),
905                                         diag::err_abstract_type_in_decl,
906                                         Sema::AbstractParamType,
907                                         AbstractClass);
908      }
909
910      return Invalid;
911    }
912
913    bool VisitDecl(const Decl* D) {
914      if (const DeclContext *DC = dyn_cast<DeclContext>(D))
915        return VisitDeclContext(DC);
916
917      return false;
918    }
919  };
920}
921
922void Sema::ActOnFinishCXXMemberSpecification(Scope* S, SourceLocation RLoc,
923                                             DeclPtrTy TagDecl,
924                                             SourceLocation LBrac,
925                                             SourceLocation RBrac) {
926  TemplateDecl *Template = AdjustDeclIfTemplate(TagDecl);
927  ActOnFields(S, RLoc, TagDecl,
928              (DeclPtrTy*)FieldCollector->getCurFields(),
929              FieldCollector->getCurNumFields(), LBrac, RBrac, 0);
930
931  CXXRecordDecl *RD = cast<CXXRecordDecl>(TagDecl.getAs<Decl>());
932  if (!RD->isAbstract()) {
933    // Collect all the pure virtual methods and see if this is an abstract
934    // class after all.
935    PureVirtualMethodCollector Collector(Context, RD);
936    if (!Collector.empty())
937      RD->setAbstract(true);
938  }
939
940  if (RD->isAbstract())
941    AbstractClassUsageDiagnoser(*this, RD);
942
943  if (!Template)
944    AddImplicitlyDeclaredMembersToClass(RD);
945}
946
947/// AddImplicitlyDeclaredMembersToClass - Adds any implicitly-declared
948/// special functions, such as the default constructor, copy
949/// constructor, or destructor, to the given C++ class (C++
950/// [special]p1).  This routine can only be executed just before the
951/// definition of the class is complete.
952void Sema::AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl) {
953  QualType ClassType = Context.getTypeDeclType(ClassDecl);
954  ClassType = Context.getCanonicalType(ClassType);
955
956  if (!ClassDecl->hasUserDeclaredConstructor()) {
957    // C++ [class.ctor]p5:
958    //   A default constructor for a class X is a constructor of class X
959    //   that can be called without an argument. If there is no
960    //   user-declared constructor for class X, a default constructor is
961    //   implicitly declared. An implicitly-declared default constructor
962    //   is an inline public member of its class.
963    DeclarationName Name
964      = Context.DeclarationNames.getCXXConstructorName(ClassType);
965    CXXConstructorDecl *DefaultCon =
966      CXXConstructorDecl::Create(Context, ClassDecl,
967                                 ClassDecl->getLocation(), Name,
968                                 Context.getFunctionType(Context.VoidTy,
969                                                         0, 0, false, 0),
970                                 /*isExplicit=*/false,
971                                 /*isInline=*/true,
972                                 /*isImplicitlyDeclared=*/true);
973    DefaultCon->setAccess(AS_public);
974    DefaultCon->setImplicit();
975    ClassDecl->addDecl(Context, DefaultCon);
976
977    // Notify the class that we've added a constructor.
978    ClassDecl->addedConstructor(Context, DefaultCon);
979  }
980
981  if (!ClassDecl->hasUserDeclaredCopyConstructor()) {
982    // C++ [class.copy]p4:
983    //   If the class definition does not explicitly declare a copy
984    //   constructor, one is declared implicitly.
985
986    // C++ [class.copy]p5:
987    //   The implicitly-declared copy constructor for a class X will
988    //   have the form
989    //
990    //       X::X(const X&)
991    //
992    //   if
993    bool HasConstCopyConstructor = true;
994
995    //     -- each direct or virtual base class B of X has a copy
996    //        constructor whose first parameter is of type const B& or
997    //        const volatile B&, and
998    for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin();
999         HasConstCopyConstructor && Base != ClassDecl->bases_end(); ++Base) {
1000      const CXXRecordDecl *BaseClassDecl
1001        = cast<CXXRecordDecl>(Base->getType()->getAsRecordType()->getDecl());
1002      HasConstCopyConstructor
1003        = BaseClassDecl->hasConstCopyConstructor(Context);
1004    }
1005
1006    //     -- for all the nonstatic data members of X that are of a
1007    //        class type M (or array thereof), each such class type
1008    //        has a copy constructor whose first parameter is of type
1009    //        const M& or const volatile M&.
1010    for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(Context);
1011         HasConstCopyConstructor && Field != ClassDecl->field_end(Context);
1012         ++Field) {
1013      QualType FieldType = (*Field)->getType();
1014      if (const ArrayType *Array = Context.getAsArrayType(FieldType))
1015        FieldType = Array->getElementType();
1016      if (const RecordType *FieldClassType = FieldType->getAsRecordType()) {
1017        const CXXRecordDecl *FieldClassDecl
1018          = cast<CXXRecordDecl>(FieldClassType->getDecl());
1019        HasConstCopyConstructor
1020          = FieldClassDecl->hasConstCopyConstructor(Context);
1021      }
1022    }
1023
1024    //   Otherwise, the implicitly declared copy constructor will have
1025    //   the form
1026    //
1027    //       X::X(X&)
1028    QualType ArgType = ClassType;
1029    if (HasConstCopyConstructor)
1030      ArgType = ArgType.withConst();
1031    ArgType = Context.getLValueReferenceType(ArgType);
1032
1033    //   An implicitly-declared copy constructor is an inline public
1034    //   member of its class.
1035    DeclarationName Name
1036      = Context.DeclarationNames.getCXXConstructorName(ClassType);
1037    CXXConstructorDecl *CopyConstructor
1038      = CXXConstructorDecl::Create(Context, ClassDecl,
1039                                   ClassDecl->getLocation(), Name,
1040                                   Context.getFunctionType(Context.VoidTy,
1041                                                           &ArgType, 1,
1042                                                           false, 0),
1043                                   /*isExplicit=*/false,
1044                                   /*isInline=*/true,
1045                                   /*isImplicitlyDeclared=*/true);
1046    CopyConstructor->setAccess(AS_public);
1047    CopyConstructor->setImplicit();
1048
1049    // Add the parameter to the constructor.
1050    ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyConstructor,
1051                                                 ClassDecl->getLocation(),
1052                                                 /*IdentifierInfo=*/0,
1053                                                 ArgType, VarDecl::None, 0);
1054    CopyConstructor->setParams(Context, &FromParam, 1);
1055
1056    ClassDecl->addedConstructor(Context, CopyConstructor);
1057    ClassDecl->addDecl(Context, CopyConstructor);
1058  }
1059
1060  if (!ClassDecl->hasUserDeclaredCopyAssignment()) {
1061    // Note: The following rules are largely analoguous to the copy
1062    // constructor rules. Note that virtual bases are not taken into account
1063    // for determining the argument type of the operator. Note also that
1064    // operators taking an object instead of a reference are allowed.
1065    //
1066    // C++ [class.copy]p10:
1067    //   If the class definition does not explicitly declare a copy
1068    //   assignment operator, one is declared implicitly.
1069    //   The implicitly-defined copy assignment operator for a class X
1070    //   will have the form
1071    //
1072    //       X& X::operator=(const X&)
1073    //
1074    //   if
1075    bool HasConstCopyAssignment = true;
1076
1077    //       -- each direct base class B of X has a copy assignment operator
1078    //          whose parameter is of type const B&, const volatile B& or B,
1079    //          and
1080    for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin();
1081         HasConstCopyAssignment && Base != ClassDecl->bases_end(); ++Base) {
1082      const CXXRecordDecl *BaseClassDecl
1083        = cast<CXXRecordDecl>(Base->getType()->getAsRecordType()->getDecl());
1084      HasConstCopyAssignment = BaseClassDecl->hasConstCopyAssignment(Context);
1085    }
1086
1087    //       -- for all the nonstatic data members of X that are of a class
1088    //          type M (or array thereof), each such class type has a copy
1089    //          assignment operator whose parameter is of type const M&,
1090    //          const volatile M& or M.
1091    for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(Context);
1092         HasConstCopyAssignment && Field != ClassDecl->field_end(Context);
1093         ++Field) {
1094      QualType FieldType = (*Field)->getType();
1095      if (const ArrayType *Array = Context.getAsArrayType(FieldType))
1096        FieldType = Array->getElementType();
1097      if (const RecordType *FieldClassType = FieldType->getAsRecordType()) {
1098        const CXXRecordDecl *FieldClassDecl
1099          = cast<CXXRecordDecl>(FieldClassType->getDecl());
1100        HasConstCopyAssignment
1101          = FieldClassDecl->hasConstCopyAssignment(Context);
1102      }
1103    }
1104
1105    //   Otherwise, the implicitly declared copy assignment operator will
1106    //   have the form
1107    //
1108    //       X& X::operator=(X&)
1109    QualType ArgType = ClassType;
1110    QualType RetType = Context.getLValueReferenceType(ArgType);
1111    if (HasConstCopyAssignment)
1112      ArgType = ArgType.withConst();
1113    ArgType = Context.getLValueReferenceType(ArgType);
1114
1115    //   An implicitly-declared copy assignment operator is an inline public
1116    //   member of its class.
1117    DeclarationName Name =
1118      Context.DeclarationNames.getCXXOperatorName(OO_Equal);
1119    CXXMethodDecl *CopyAssignment =
1120      CXXMethodDecl::Create(Context, ClassDecl, ClassDecl->getLocation(), Name,
1121                            Context.getFunctionType(RetType, &ArgType, 1,
1122                                                    false, 0),
1123                            /*isStatic=*/false, /*isInline=*/true);
1124    CopyAssignment->setAccess(AS_public);
1125    CopyAssignment->setImplicit();
1126
1127    // Add the parameter to the operator.
1128    ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyAssignment,
1129                                                 ClassDecl->getLocation(),
1130                                                 /*IdentifierInfo=*/0,
1131                                                 ArgType, VarDecl::None, 0);
1132    CopyAssignment->setParams(Context, &FromParam, 1);
1133
1134    // Don't call addedAssignmentOperator. There is no way to distinguish an
1135    // implicit from an explicit assignment operator.
1136    ClassDecl->addDecl(Context, CopyAssignment);
1137  }
1138
1139  if (!ClassDecl->hasUserDeclaredDestructor()) {
1140    // C++ [class.dtor]p2:
1141    //   If a class has no user-declared destructor, a destructor is
1142    //   declared implicitly. An implicitly-declared destructor is an
1143    //   inline public member of its class.
1144    DeclarationName Name
1145      = Context.DeclarationNames.getCXXDestructorName(ClassType);
1146    CXXDestructorDecl *Destructor
1147      = CXXDestructorDecl::Create(Context, ClassDecl,
1148                                  ClassDecl->getLocation(), Name,
1149                                  Context.getFunctionType(Context.VoidTy,
1150                                                          0, 0, false, 0),
1151                                  /*isInline=*/true,
1152                                  /*isImplicitlyDeclared=*/true);
1153    Destructor->setAccess(AS_public);
1154    Destructor->setImplicit();
1155    ClassDecl->addDecl(Context, Destructor);
1156  }
1157}
1158
1159/// ActOnStartDelayedCXXMethodDeclaration - We have completed
1160/// parsing a top-level (non-nested) C++ class, and we are now
1161/// parsing those parts of the given Method declaration that could
1162/// not be parsed earlier (C++ [class.mem]p2), such as default
1163/// arguments. This action should enter the scope of the given
1164/// Method declaration as if we had just parsed the qualified method
1165/// name. However, it should not bring the parameters into scope;
1166/// that will be performed by ActOnDelayedCXXMethodParameter.
1167void Sema::ActOnStartDelayedCXXMethodDeclaration(Scope *S, DeclPtrTy MethodD) {
1168  CXXScopeSpec SS;
1169  FunctionDecl *Method = cast<FunctionDecl>(MethodD.getAs<Decl>());
1170  QualType ClassTy
1171    = Context.getTypeDeclType(cast<RecordDecl>(Method->getDeclContext()));
1172  SS.setScopeRep(
1173    NestedNameSpecifier::Create(Context, 0, false, ClassTy.getTypePtr()));
1174  ActOnCXXEnterDeclaratorScope(S, SS);
1175}
1176
1177/// ActOnDelayedCXXMethodParameter - We've already started a delayed
1178/// C++ method declaration. We're (re-)introducing the given
1179/// function parameter into scope for use in parsing later parts of
1180/// the method declaration. For example, we could see an
1181/// ActOnParamDefaultArgument event for this parameter.
1182void Sema::ActOnDelayedCXXMethodParameter(Scope *S, DeclPtrTy ParamD) {
1183  ParmVarDecl *Param = cast<ParmVarDecl>(ParamD.getAs<Decl>());
1184
1185  // If this parameter has an unparsed default argument, clear it out
1186  // to make way for the parsed default argument.
1187  if (Param->hasUnparsedDefaultArg())
1188    Param->setDefaultArg(0);
1189
1190  S->AddDecl(DeclPtrTy::make(Param));
1191  if (Param->getDeclName())
1192    IdResolver.AddDecl(Param);
1193}
1194
1195/// ActOnFinishDelayedCXXMethodDeclaration - We have finished
1196/// processing the delayed method declaration for Method. The method
1197/// declaration is now considered finished. There may be a separate
1198/// ActOnStartOfFunctionDef action later (not necessarily
1199/// immediately!) for this method, if it was also defined inside the
1200/// class body.
1201void Sema::ActOnFinishDelayedCXXMethodDeclaration(Scope *S, DeclPtrTy MethodD) {
1202  FunctionDecl *Method = cast<FunctionDecl>(MethodD.getAs<Decl>());
1203  CXXScopeSpec SS;
1204  QualType ClassTy
1205    = Context.getTypeDeclType(cast<RecordDecl>(Method->getDeclContext()));
1206  SS.setScopeRep(
1207    NestedNameSpecifier::Create(Context, 0, false, ClassTy.getTypePtr()));
1208  ActOnCXXExitDeclaratorScope(S, SS);
1209
1210  // Now that we have our default arguments, check the constructor
1211  // again. It could produce additional diagnostics or affect whether
1212  // the class has implicitly-declared destructors, among other
1213  // things.
1214  if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Method)) {
1215    if (CheckConstructor(Constructor))
1216      Constructor->setInvalidDecl();
1217  }
1218
1219  // Check the default arguments, which we may have added.
1220  if (!Method->isInvalidDecl())
1221    CheckCXXDefaultArguments(Method);
1222}
1223
1224/// CheckConstructorDeclarator - Called by ActOnDeclarator to check
1225/// the well-formedness of the constructor declarator @p D with type @p
1226/// R. If there are any errors in the declarator, this routine will
1227/// emit diagnostics and return true. Otherwise, it will return
1228/// false. Either way, the type @p R will be updated to reflect a
1229/// well-formed type for the constructor.
1230bool Sema::CheckConstructorDeclarator(Declarator &D, QualType &R,
1231                                      FunctionDecl::StorageClass& SC) {
1232  bool isVirtual = D.getDeclSpec().isVirtualSpecified();
1233  bool isInvalid = false;
1234
1235  // C++ [class.ctor]p3:
1236  //   A constructor shall not be virtual (10.3) or static (9.4). A
1237  //   constructor can be invoked for a const, volatile or const
1238  //   volatile object. A constructor shall not be declared const,
1239  //   volatile, or const volatile (9.3.2).
1240  if (isVirtual) {
1241    Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
1242      << "virtual" << SourceRange(D.getDeclSpec().getVirtualSpecLoc())
1243      << SourceRange(D.getIdentifierLoc());
1244    isInvalid = true;
1245  }
1246  if (SC == FunctionDecl::Static) {
1247    Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
1248      << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
1249      << SourceRange(D.getIdentifierLoc());
1250    isInvalid = true;
1251    SC = FunctionDecl::None;
1252  }
1253  if (D.getDeclSpec().hasTypeSpecifier()) {
1254    // Constructors don't have return types, but the parser will
1255    // happily parse something like:
1256    //
1257    //   class X {
1258    //     float X(float);
1259    //   };
1260    //
1261    // The return type will be eliminated later.
1262    Diag(D.getIdentifierLoc(), diag::err_constructor_return_type)
1263      << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
1264      << SourceRange(D.getIdentifierLoc());
1265  }
1266  if (R->getAsFunctionProtoType()->getTypeQuals() != 0) {
1267    DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
1268    if (FTI.TypeQuals & QualType::Const)
1269      Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
1270        << "const" << SourceRange(D.getIdentifierLoc());
1271    if (FTI.TypeQuals & QualType::Volatile)
1272      Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
1273        << "volatile" << SourceRange(D.getIdentifierLoc());
1274    if (FTI.TypeQuals & QualType::Restrict)
1275      Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
1276        << "restrict" << SourceRange(D.getIdentifierLoc());
1277  }
1278
1279  // Rebuild the function type "R" without any type qualifiers (in
1280  // case any of the errors above fired) and with "void" as the
1281  // return type, since constructors don't have return types. We
1282  // *always* have to do this, because GetTypeForDeclarator will
1283  // put in a result type of "int" when none was specified.
1284  const FunctionProtoType *Proto = R->getAsFunctionProtoType();
1285  R = Context.getFunctionType(Context.VoidTy, Proto->arg_type_begin(),
1286                              Proto->getNumArgs(),
1287                              Proto->isVariadic(),
1288                              0);
1289
1290  return isInvalid;
1291}
1292
1293/// CheckConstructor - Checks a fully-formed constructor for
1294/// well-formedness, issuing any diagnostics required. Returns true if
1295/// the constructor declarator is invalid.
1296bool Sema::CheckConstructor(CXXConstructorDecl *Constructor) {
1297  CXXRecordDecl *ClassDecl
1298    = dyn_cast<CXXRecordDecl>(Constructor->getDeclContext());
1299  if (!ClassDecl)
1300    return true;
1301
1302  bool Invalid = Constructor->isInvalidDecl();
1303
1304  // C++ [class.copy]p3:
1305  //   A declaration of a constructor for a class X is ill-formed if
1306  //   its first parameter is of type (optionally cv-qualified) X and
1307  //   either there are no other parameters or else all other
1308  //   parameters have default arguments.
1309  if (!Constructor->isInvalidDecl() &&
1310      ((Constructor->getNumParams() == 1) ||
1311       (Constructor->getNumParams() > 1 &&
1312        Constructor->getParamDecl(1)->getDefaultArg() != 0))) {
1313    QualType ParamType = Constructor->getParamDecl(0)->getType();
1314    QualType ClassTy = Context.getTagDeclType(ClassDecl);
1315    if (Context.getCanonicalType(ParamType).getUnqualifiedType() == ClassTy) {
1316      SourceLocation ParamLoc = Constructor->getParamDecl(0)->getLocation();
1317      Diag(ParamLoc, diag::err_constructor_byvalue_arg)
1318        << CodeModificationHint::CreateInsertion(ParamLoc, " const &");
1319      Invalid = true;
1320    }
1321  }
1322
1323  // Notify the class that we've added a constructor.
1324  ClassDecl->addedConstructor(Context, Constructor);
1325
1326  return Invalid;
1327}
1328
1329/// CheckDestructorDeclarator - Called by ActOnDeclarator to check
1330/// the well-formednes of the destructor declarator @p D with type @p
1331/// R. If there are any errors in the declarator, this routine will
1332/// emit diagnostics and return true. Otherwise, it will return
1333/// false. Either way, the type @p R will be updated to reflect a
1334/// well-formed type for the destructor.
1335bool Sema::CheckDestructorDeclarator(Declarator &D, QualType &R,
1336                                     FunctionDecl::StorageClass& SC) {
1337  bool isInvalid = false;
1338
1339  // C++ [class.dtor]p1:
1340  //   [...] A typedef-name that names a class is a class-name
1341  //   (7.1.3); however, a typedef-name that names a class shall not
1342  //   be used as the identifier in the declarator for a destructor
1343  //   declaration.
1344  QualType DeclaratorType = QualType::getFromOpaquePtr(D.getDeclaratorIdType());
1345  if (DeclaratorType->getAsTypedefType()) {
1346    Diag(D.getIdentifierLoc(),  diag::err_destructor_typedef_name)
1347      << DeclaratorType;
1348    isInvalid = true;
1349  }
1350
1351  // C++ [class.dtor]p2:
1352  //   A destructor is used to destroy objects of its class type. A
1353  //   destructor takes no parameters, and no return type can be
1354  //   specified for it (not even void). The address of a destructor
1355  //   shall not be taken. A destructor shall not be static. A
1356  //   destructor can be invoked for a const, volatile or const
1357  //   volatile object. A destructor shall not be declared const,
1358  //   volatile or const volatile (9.3.2).
1359  if (SC == FunctionDecl::Static) {
1360    Diag(D.getIdentifierLoc(), diag::err_destructor_cannot_be)
1361      << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
1362      << SourceRange(D.getIdentifierLoc());
1363    isInvalid = true;
1364    SC = FunctionDecl::None;
1365  }
1366  if (D.getDeclSpec().hasTypeSpecifier()) {
1367    // Destructors don't have return types, but the parser will
1368    // happily parse something like:
1369    //
1370    //   class X {
1371    //     float ~X();
1372    //   };
1373    //
1374    // The return type will be eliminated later.
1375    Diag(D.getIdentifierLoc(), diag::err_destructor_return_type)
1376      << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
1377      << SourceRange(D.getIdentifierLoc());
1378  }
1379  if (R->getAsFunctionProtoType()->getTypeQuals() != 0) {
1380    DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
1381    if (FTI.TypeQuals & QualType::Const)
1382      Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
1383        << "const" << SourceRange(D.getIdentifierLoc());
1384    if (FTI.TypeQuals & QualType::Volatile)
1385      Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
1386        << "volatile" << SourceRange(D.getIdentifierLoc());
1387    if (FTI.TypeQuals & QualType::Restrict)
1388      Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
1389        << "restrict" << SourceRange(D.getIdentifierLoc());
1390  }
1391
1392  // Make sure we don't have any parameters.
1393  if (R->getAsFunctionProtoType()->getNumArgs() > 0) {
1394    Diag(D.getIdentifierLoc(), diag::err_destructor_with_params);
1395
1396    // Delete the parameters.
1397    D.getTypeObject(0).Fun.freeArgs();
1398  }
1399
1400  // Make sure the destructor isn't variadic.
1401  if (R->getAsFunctionProtoType()->isVariadic())
1402    Diag(D.getIdentifierLoc(), diag::err_destructor_variadic);
1403
1404  // Rebuild the function type "R" without any type qualifiers or
1405  // parameters (in case any of the errors above fired) and with
1406  // "void" as the return type, since destructors don't have return
1407  // types. We *always* have to do this, because GetTypeForDeclarator
1408  // will put in a result type of "int" when none was specified.
1409  R = Context.getFunctionType(Context.VoidTy, 0, 0, false, 0);
1410
1411  return isInvalid;
1412}
1413
1414/// CheckConversionDeclarator - Called by ActOnDeclarator to check the
1415/// well-formednes of the conversion function declarator @p D with
1416/// type @p R. If there are any errors in the declarator, this routine
1417/// will emit diagnostics and return true. Otherwise, it will return
1418/// false. Either way, the type @p R will be updated to reflect a
1419/// well-formed type for the conversion operator.
1420bool Sema::CheckConversionDeclarator(Declarator &D, QualType &R,
1421                                     FunctionDecl::StorageClass& SC) {
1422  bool isInvalid = false;
1423
1424  // C++ [class.conv.fct]p1:
1425  //   Neither parameter types nor return type can be specified. The
1426  //   type of a conversion function (8.3.5) is “function taking no
1427  //   parameter returning conversion-type-id.”
1428  if (SC == FunctionDecl::Static) {
1429    Diag(D.getIdentifierLoc(), diag::err_conv_function_not_member)
1430      << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
1431      << SourceRange(D.getIdentifierLoc());
1432    isInvalid = true;
1433    SC = FunctionDecl::None;
1434  }
1435  if (D.getDeclSpec().hasTypeSpecifier()) {
1436    // Conversion functions don't have return types, but the parser will
1437    // happily parse something like:
1438    //
1439    //   class X {
1440    //     float operator bool();
1441    //   };
1442    //
1443    // The return type will be changed later anyway.
1444    Diag(D.getIdentifierLoc(), diag::err_conv_function_return_type)
1445      << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
1446      << SourceRange(D.getIdentifierLoc());
1447  }
1448
1449  // Make sure we don't have any parameters.
1450  if (R->getAsFunctionProtoType()->getNumArgs() > 0) {
1451    Diag(D.getIdentifierLoc(), diag::err_conv_function_with_params);
1452
1453    // Delete the parameters.
1454    D.getTypeObject(0).Fun.freeArgs();
1455  }
1456
1457  // Make sure the conversion function isn't variadic.
1458  if (R->getAsFunctionProtoType()->isVariadic())
1459    Diag(D.getIdentifierLoc(), diag::err_conv_function_variadic);
1460
1461  // C++ [class.conv.fct]p4:
1462  //   The conversion-type-id shall not represent a function type nor
1463  //   an array type.
1464  QualType ConvType = QualType::getFromOpaquePtr(D.getDeclaratorIdType());
1465  if (ConvType->isArrayType()) {
1466    Diag(D.getIdentifierLoc(), diag::err_conv_function_to_array);
1467    ConvType = Context.getPointerType(ConvType);
1468  } else if (ConvType->isFunctionType()) {
1469    Diag(D.getIdentifierLoc(), diag::err_conv_function_to_function);
1470    ConvType = Context.getPointerType(ConvType);
1471  }
1472
1473  // Rebuild the function type "R" without any parameters (in case any
1474  // of the errors above fired) and with the conversion type as the
1475  // return type.
1476  R = Context.getFunctionType(ConvType, 0, 0, false,
1477                              R->getAsFunctionProtoType()->getTypeQuals());
1478
1479  // C++0x explicit conversion operators.
1480  if (D.getDeclSpec().isExplicitSpecified() && !getLangOptions().CPlusPlus0x)
1481    Diag(D.getDeclSpec().getExplicitSpecLoc(),
1482         diag::warn_explicit_conversion_functions)
1483      << SourceRange(D.getDeclSpec().getExplicitSpecLoc());
1484
1485  return isInvalid;
1486}
1487
1488/// ActOnConversionDeclarator - Called by ActOnDeclarator to complete
1489/// the declaration of the given C++ conversion function. This routine
1490/// is responsible for recording the conversion function in the C++
1491/// class, if possible.
1492Sema::DeclPtrTy Sema::ActOnConversionDeclarator(CXXConversionDecl *Conversion) {
1493  assert(Conversion && "Expected to receive a conversion function declaration");
1494
1495  // Set the lexical context of this conversion function
1496  Conversion->setLexicalDeclContext(CurContext);
1497
1498  CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Conversion->getDeclContext());
1499
1500  // Make sure we aren't redeclaring the conversion function.
1501  QualType ConvType = Context.getCanonicalType(Conversion->getConversionType());
1502
1503  // C++ [class.conv.fct]p1:
1504  //   [...] A conversion function is never used to convert a
1505  //   (possibly cv-qualified) object to the (possibly cv-qualified)
1506  //   same object type (or a reference to it), to a (possibly
1507  //   cv-qualified) base class of that type (or a reference to it),
1508  //   or to (possibly cv-qualified) void.
1509  // FIXME: Suppress this warning if the conversion function ends up
1510  // being a virtual function that overrides a virtual function in a
1511  // base class.
1512  QualType ClassType
1513    = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
1514  if (const ReferenceType *ConvTypeRef = ConvType->getAsReferenceType())
1515    ConvType = ConvTypeRef->getPointeeType();
1516  if (ConvType->isRecordType()) {
1517    ConvType = Context.getCanonicalType(ConvType).getUnqualifiedType();
1518    if (ConvType == ClassType)
1519      Diag(Conversion->getLocation(), diag::warn_conv_to_self_not_used)
1520        << ClassType;
1521    else if (IsDerivedFrom(ClassType, ConvType))
1522      Diag(Conversion->getLocation(), diag::warn_conv_to_base_not_used)
1523        <<  ClassType << ConvType;
1524  } else if (ConvType->isVoidType()) {
1525    Diag(Conversion->getLocation(), diag::warn_conv_to_void_not_used)
1526      << ClassType << ConvType;
1527  }
1528
1529  if (Conversion->getPreviousDeclaration()) {
1530    OverloadedFunctionDecl *Conversions = ClassDecl->getConversionFunctions();
1531    for (OverloadedFunctionDecl::function_iterator
1532           Conv = Conversions->function_begin(),
1533           ConvEnd = Conversions->function_end();
1534         Conv != ConvEnd; ++Conv) {
1535      if (*Conv == Conversion->getPreviousDeclaration()) {
1536        *Conv = Conversion;
1537        return DeclPtrTy::make(Conversion);
1538      }
1539    }
1540    assert(Conversion->isInvalidDecl() && "Conversion should not get here.");
1541  } else
1542    ClassDecl->addConversionFunction(Context, Conversion);
1543
1544  return DeclPtrTy::make(Conversion);
1545}
1546
1547//===----------------------------------------------------------------------===//
1548// Namespace Handling
1549//===----------------------------------------------------------------------===//
1550
1551/// ActOnStartNamespaceDef - This is called at the start of a namespace
1552/// definition.
1553Sema::DeclPtrTy Sema::ActOnStartNamespaceDef(Scope *NamespcScope,
1554                                             SourceLocation IdentLoc,
1555                                             IdentifierInfo *II,
1556                                             SourceLocation LBrace) {
1557  NamespaceDecl *Namespc =
1558      NamespaceDecl::Create(Context, CurContext, IdentLoc, II);
1559  Namespc->setLBracLoc(LBrace);
1560
1561  Scope *DeclRegionScope = NamespcScope->getParent();
1562
1563  if (II) {
1564    // C++ [namespace.def]p2:
1565    // The identifier in an original-namespace-definition shall not have been
1566    // previously defined in the declarative region in which the
1567    // original-namespace-definition appears. The identifier in an
1568    // original-namespace-definition is the name of the namespace. Subsequently
1569    // in that declarative region, it is treated as an original-namespace-name.
1570
1571    NamedDecl *PrevDecl = LookupName(DeclRegionScope, II, LookupOrdinaryName,
1572                                     true);
1573
1574    if (NamespaceDecl *OrigNS = dyn_cast_or_null<NamespaceDecl>(PrevDecl)) {
1575      // This is an extended namespace definition.
1576      // Attach this namespace decl to the chain of extended namespace
1577      // definitions.
1578      OrigNS->setNextNamespace(Namespc);
1579      Namespc->setOriginalNamespace(OrigNS->getOriginalNamespace());
1580
1581      // Remove the previous declaration from the scope.
1582      if (DeclRegionScope->isDeclScope(DeclPtrTy::make(OrigNS))) {
1583        IdResolver.RemoveDecl(OrigNS);
1584        DeclRegionScope->RemoveDecl(DeclPtrTy::make(OrigNS));
1585      }
1586    } else if (PrevDecl) {
1587      // This is an invalid name redefinition.
1588      Diag(Namespc->getLocation(), diag::err_redefinition_different_kind)
1589       << Namespc->getDeclName();
1590      Diag(PrevDecl->getLocation(), diag::note_previous_definition);
1591      Namespc->setInvalidDecl();
1592      // Continue on to push Namespc as current DeclContext and return it.
1593    }
1594
1595    PushOnScopeChains(Namespc, DeclRegionScope);
1596  } else {
1597    // FIXME: Handle anonymous namespaces
1598  }
1599
1600  // Although we could have an invalid decl (i.e. the namespace name is a
1601  // redefinition), push it as current DeclContext and try to continue parsing.
1602  // FIXME: We should be able to push Namespc here, so that the
1603  // each DeclContext for the namespace has the declarations
1604  // that showed up in that particular namespace definition.
1605  PushDeclContext(NamespcScope, Namespc);
1606  return DeclPtrTy::make(Namespc);
1607}
1608
1609/// ActOnFinishNamespaceDef - This callback is called after a namespace is
1610/// exited. Decl is the DeclTy returned by ActOnStartNamespaceDef.
1611void Sema::ActOnFinishNamespaceDef(DeclPtrTy D, SourceLocation RBrace) {
1612  Decl *Dcl = D.getAs<Decl>();
1613  NamespaceDecl *Namespc = dyn_cast_or_null<NamespaceDecl>(Dcl);
1614  assert(Namespc && "Invalid parameter, expected NamespaceDecl");
1615  Namespc->setRBracLoc(RBrace);
1616  PopDeclContext();
1617}
1618
1619Sema::DeclPtrTy Sema::ActOnUsingDirective(Scope *S,
1620                                          SourceLocation UsingLoc,
1621                                          SourceLocation NamespcLoc,
1622                                          const CXXScopeSpec &SS,
1623                                          SourceLocation IdentLoc,
1624                                          IdentifierInfo *NamespcName,
1625                                          AttributeList *AttrList) {
1626  assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
1627  assert(NamespcName && "Invalid NamespcName.");
1628  assert(IdentLoc.isValid() && "Invalid NamespceName location.");
1629  assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
1630
1631  UsingDirectiveDecl *UDir = 0;
1632
1633  // Lookup namespace name.
1634  LookupResult R = LookupParsedName(S, &SS, NamespcName,
1635                                    LookupNamespaceName, false);
1636  if (R.isAmbiguous()) {
1637    DiagnoseAmbiguousLookup(R, NamespcName, IdentLoc);
1638    return DeclPtrTy();
1639  }
1640  if (NamedDecl *NS = R) {
1641    assert(isa<NamespaceDecl>(NS) && "expected namespace decl");
1642    // C++ [namespace.udir]p1:
1643    //   A using-directive specifies that the names in the nominated
1644    //   namespace can be used in the scope in which the
1645    //   using-directive appears after the using-directive. During
1646    //   unqualified name lookup (3.4.1), the names appear as if they
1647    //   were declared in the nearest enclosing namespace which
1648    //   contains both the using-directive and the nominated
1649    //   namespace. [Note: in this context, “contains” means “contains
1650    //   directly or indirectly”. ]
1651
1652    // Find enclosing context containing both using-directive and
1653    // nominated namespace.
1654    DeclContext *CommonAncestor = cast<DeclContext>(NS);
1655    while (CommonAncestor && !CommonAncestor->Encloses(CurContext))
1656      CommonAncestor = CommonAncestor->getParent();
1657
1658    UDir = UsingDirectiveDecl::Create(Context, CurContext, UsingLoc,
1659                                      NamespcLoc, IdentLoc,
1660                                      cast<NamespaceDecl>(NS),
1661                                      CommonAncestor);
1662    PushUsingDirective(S, UDir);
1663  } else {
1664    Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
1665  }
1666
1667  // FIXME: We ignore attributes for now.
1668  delete AttrList;
1669  return DeclPtrTy::make(UDir);
1670}
1671
1672void Sema::PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir) {
1673  // If scope has associated entity, then using directive is at namespace
1674  // or translation unit scope. We add UsingDirectiveDecls, into
1675  // it's lookup structure.
1676  if (DeclContext *Ctx = static_cast<DeclContext*>(S->getEntity()))
1677    Ctx->addDecl(Context, UDir);
1678  else
1679    // Otherwise it is block-sope. using-directives will affect lookup
1680    // only to the end of scope.
1681    S->PushUsingDirective(DeclPtrTy::make(UDir));
1682}
1683
1684/// getNamespaceDecl - Returns the namespace a decl represents. If the decl
1685/// is a namespace alias, returns the namespace it points to.
1686static inline NamespaceDecl *getNamespaceDecl(NamedDecl *D) {
1687  if (NamespaceAliasDecl *AD = dyn_cast_or_null<NamespaceAliasDecl>(D))
1688    return AD->getNamespace();
1689  return dyn_cast_or_null<NamespaceDecl>(D);
1690}
1691
1692Sema::DeclPtrTy Sema::ActOnNamespaceAliasDef(Scope *S,
1693                                             SourceLocation NamespaceLoc,
1694                                             SourceLocation AliasLoc,
1695                                             IdentifierInfo *Alias,
1696                                             const CXXScopeSpec &SS,
1697                                             SourceLocation IdentLoc,
1698                                             IdentifierInfo *Ident) {
1699
1700  // Lookup the namespace name.
1701  LookupResult R = LookupParsedName(S, &SS, Ident, LookupNamespaceName, false);
1702
1703  // Check if we have a previous declaration with the same name.
1704  if (NamedDecl *PrevDecl = LookupName(S, Alias, LookupOrdinaryName, true)) {
1705    if (NamespaceAliasDecl *AD = dyn_cast<NamespaceAliasDecl>(PrevDecl)) {
1706      // We already have an alias with the same name that points to the same
1707      // namespace, so don't create a new one.
1708      if (!R.isAmbiguous() && AD->getNamespace() == getNamespaceDecl(R))
1709        return DeclPtrTy();
1710    }
1711
1712    unsigned DiagID = isa<NamespaceDecl>(PrevDecl) ? diag::err_redefinition :
1713      diag::err_redefinition_different_kind;
1714    Diag(AliasLoc, DiagID) << Alias;
1715    Diag(PrevDecl->getLocation(), diag::note_previous_definition);
1716    return DeclPtrTy();
1717  }
1718
1719  if (R.isAmbiguous()) {
1720    DiagnoseAmbiguousLookup(R, Ident, IdentLoc);
1721    return DeclPtrTy();
1722  }
1723
1724  if (!R) {
1725    Diag(NamespaceLoc, diag::err_expected_namespace_name) << SS.getRange();
1726    return DeclPtrTy();
1727  }
1728
1729  NamespaceAliasDecl *AliasDecl =
1730    NamespaceAliasDecl::Create(Context, CurContext, NamespaceLoc, AliasLoc, Alias,
1731                               IdentLoc, R);
1732
1733  CurContext->addDecl(Context, AliasDecl);
1734  return DeclPtrTy::make(AliasDecl);
1735}
1736
1737/// AddCXXDirectInitializerToDecl - This action is called immediately after
1738/// ActOnDeclarator, when a C++ direct initializer is present.
1739/// e.g: "int x(1);"
1740void Sema::AddCXXDirectInitializerToDecl(DeclPtrTy Dcl,
1741                                         SourceLocation LParenLoc,
1742                                         MultiExprArg Exprs,
1743                                         SourceLocation *CommaLocs,
1744                                         SourceLocation RParenLoc) {
1745  unsigned NumExprs = Exprs.size();
1746  assert(NumExprs != 0 && Exprs.get() && "missing expressions");
1747  Decl *RealDecl = Dcl.getAs<Decl>();
1748
1749  // If there is no declaration, there was an error parsing it.  Just ignore
1750  // the initializer.
1751  if (RealDecl == 0)
1752    return;
1753
1754  VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
1755  if (!VDecl) {
1756    Diag(RealDecl->getLocation(), diag::err_illegal_initializer);
1757    RealDecl->setInvalidDecl();
1758    return;
1759  }
1760
1761  // FIXME: Need to handle dependent types and expressions here.
1762
1763  // We will treat direct-initialization as a copy-initialization:
1764  //    int x(1);  -as-> int x = 1;
1765  //    ClassType x(a,b,c); -as-> ClassType x = ClassType(a,b,c);
1766  //
1767  // Clients that want to distinguish between the two forms, can check for
1768  // direct initializer using VarDecl::hasCXXDirectInitializer().
1769  // A major benefit is that clients that don't particularly care about which
1770  // exactly form was it (like the CodeGen) can handle both cases without
1771  // special case code.
1772
1773  // C++ 8.5p11:
1774  // The form of initialization (using parentheses or '=') is generally
1775  // insignificant, but does matter when the entity being initialized has a
1776  // class type.
1777  QualType DeclInitType = VDecl->getType();
1778  if (const ArrayType *Array = Context.getAsArrayType(DeclInitType))
1779    DeclInitType = Array->getElementType();
1780
1781  // FIXME: This isn't the right place to complete the type.
1782  if (RequireCompleteType(VDecl->getLocation(), VDecl->getType(),
1783                          diag::err_typecheck_decl_incomplete_type)) {
1784    VDecl->setInvalidDecl();
1785    return;
1786  }
1787
1788  if (VDecl->getType()->isRecordType()) {
1789    CXXConstructorDecl *Constructor
1790      = PerformInitializationByConstructor(DeclInitType,
1791                                           (Expr **)Exprs.get(), NumExprs,
1792                                           VDecl->getLocation(),
1793                                           SourceRange(VDecl->getLocation(),
1794                                                       RParenLoc),
1795                                           VDecl->getDeclName(),
1796                                           IK_Direct);
1797    if (!Constructor)
1798      RealDecl->setInvalidDecl();
1799    else {
1800      // Let clients know that initialization was done with a direct
1801      // initializer.
1802      VDecl->setCXXDirectInitializer(true);
1803
1804      Expr *Temp =
1805        new (Context) CXXTemporaryObjectExpr(Constructor, DeclInitType,
1806                                             SourceLocation(),
1807                                             (Expr**)Exprs.release(),
1808                                             NumExprs,
1809                                             SourceLocation());
1810      AddInitializerToDecl(Dcl, ExprArg(*this, Temp), /*DirectInit=*/true);
1811    }
1812    return;
1813  }
1814
1815  if (NumExprs > 1) {
1816    Diag(CommaLocs[0], diag::err_builtin_direct_init_more_than_one_arg)
1817      << SourceRange(VDecl->getLocation(), RParenLoc);
1818    RealDecl->setInvalidDecl();
1819    return;
1820  }
1821
1822  // Let clients know that initialization was done with a direct initializer.
1823  VDecl->setCXXDirectInitializer(true);
1824
1825  assert(NumExprs == 1 && "Expected 1 expression");
1826  // Set the init expression, handles conversions.
1827  AddInitializerToDecl(Dcl, ExprArg(*this, Exprs.release()[0]),
1828                       /*DirectInit=*/true);
1829}
1830
1831/// PerformInitializationByConstructor - Perform initialization by
1832/// constructor (C++ [dcl.init]p14), which may occur as part of
1833/// direct-initialization or copy-initialization. We are initializing
1834/// an object of type @p ClassType with the given arguments @p
1835/// Args. @p Loc is the location in the source code where the
1836/// initializer occurs (e.g., a declaration, member initializer,
1837/// functional cast, etc.) while @p Range covers the whole
1838/// initialization. @p InitEntity is the entity being initialized,
1839/// which may by the name of a declaration or a type. @p Kind is the
1840/// kind of initialization we're performing, which affects whether
1841/// explicit constructors will be considered. When successful, returns
1842/// the constructor that will be used to perform the initialization;
1843/// when the initialization fails, emits a diagnostic and returns
1844/// null.
1845CXXConstructorDecl *
1846Sema::PerformInitializationByConstructor(QualType ClassType,
1847                                         Expr **Args, unsigned NumArgs,
1848                                         SourceLocation Loc, SourceRange Range,
1849                                         DeclarationName InitEntity,
1850                                         InitializationKind Kind) {
1851  const RecordType *ClassRec = ClassType->getAsRecordType();
1852  assert(ClassRec && "Can only initialize a class type here");
1853
1854  // C++ [dcl.init]p14:
1855  //
1856  //   If the initialization is direct-initialization, or if it is
1857  //   copy-initialization where the cv-unqualified version of the
1858  //   source type is the same class as, or a derived class of, the
1859  //   class of the destination, constructors are considered. The
1860  //   applicable constructors are enumerated (13.3.1.3), and the
1861  //   best one is chosen through overload resolution (13.3). The
1862  //   constructor so selected is called to initialize the object,
1863  //   with the initializer expression(s) as its argument(s). If no
1864  //   constructor applies, or the overload resolution is ambiguous,
1865  //   the initialization is ill-formed.
1866  const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(ClassRec->getDecl());
1867  OverloadCandidateSet CandidateSet;
1868
1869  // Add constructors to the overload set.
1870  DeclarationName ConstructorName
1871    = Context.DeclarationNames.getCXXConstructorName(
1872                       Context.getCanonicalType(ClassType.getUnqualifiedType()));
1873  DeclContext::lookup_const_iterator Con, ConEnd;
1874  for (llvm::tie(Con, ConEnd) = ClassDecl->lookup(Context, ConstructorName);
1875       Con != ConEnd; ++Con) {
1876    CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(*Con);
1877    if ((Kind == IK_Direct) ||
1878        (Kind == IK_Copy && Constructor->isConvertingConstructor()) ||
1879        (Kind == IK_Default && Constructor->isDefaultConstructor()))
1880      AddOverloadCandidate(Constructor, Args, NumArgs, CandidateSet);
1881  }
1882
1883  // FIXME: When we decide not to synthesize the implicitly-declared
1884  // constructors, we'll need to make them appear here.
1885
1886  OverloadCandidateSet::iterator Best;
1887  switch (BestViableFunction(CandidateSet, Best)) {
1888  case OR_Success:
1889    // We found a constructor. Return it.
1890    return cast<CXXConstructorDecl>(Best->Function);
1891
1892  case OR_No_Viable_Function:
1893    if (InitEntity)
1894      Diag(Loc, diag::err_ovl_no_viable_function_in_init)
1895        << InitEntity << Range;
1896    else
1897      Diag(Loc, diag::err_ovl_no_viable_function_in_init)
1898        << ClassType << Range;
1899    PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/false);
1900    return 0;
1901
1902  case OR_Ambiguous:
1903    if (InitEntity)
1904      Diag(Loc, diag::err_ovl_ambiguous_init) << InitEntity << Range;
1905    else
1906      Diag(Loc, diag::err_ovl_ambiguous_init) << ClassType << Range;
1907    PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
1908    return 0;
1909
1910  case OR_Deleted:
1911    if (InitEntity)
1912      Diag(Loc, diag::err_ovl_deleted_init)
1913        << Best->Function->isDeleted()
1914        << InitEntity << Range;
1915    else
1916      Diag(Loc, diag::err_ovl_deleted_init)
1917        << Best->Function->isDeleted()
1918        << InitEntity << Range;
1919    PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
1920    return 0;
1921  }
1922
1923  return 0;
1924}
1925
1926/// CompareReferenceRelationship - Compare the two types T1 and T2 to
1927/// determine whether they are reference-related,
1928/// reference-compatible, reference-compatible with added
1929/// qualification, or incompatible, for use in C++ initialization by
1930/// reference (C++ [dcl.ref.init]p4). Neither type can be a reference
1931/// type, and the first type (T1) is the pointee type of the reference
1932/// type being initialized.
1933Sema::ReferenceCompareResult
1934Sema::CompareReferenceRelationship(QualType T1, QualType T2,
1935                                   bool& DerivedToBase) {
1936  assert(!T1->isReferenceType() &&
1937    "T1 must be the pointee type of the reference type");
1938  assert(!T2->isReferenceType() && "T2 cannot be a reference type");
1939
1940  T1 = Context.getCanonicalType(T1);
1941  T2 = Context.getCanonicalType(T2);
1942  QualType UnqualT1 = T1.getUnqualifiedType();
1943  QualType UnqualT2 = T2.getUnqualifiedType();
1944
1945  // C++ [dcl.init.ref]p4:
1946  //   Given types “cv1 T1” and “cv2 T2,” “cv1 T1” is
1947  //   reference-related to “cv2 T2” if T1 is the same type as T2, or
1948  //   T1 is a base class of T2.
1949  if (UnqualT1 == UnqualT2)
1950    DerivedToBase = false;
1951  else if (IsDerivedFrom(UnqualT2, UnqualT1))
1952    DerivedToBase = true;
1953  else
1954    return Ref_Incompatible;
1955
1956  // At this point, we know that T1 and T2 are reference-related (at
1957  // least).
1958
1959  // C++ [dcl.init.ref]p4:
1960  //   "cv1 T1” is reference-compatible with “cv2 T2” if T1 is
1961  //   reference-related to T2 and cv1 is the same cv-qualification
1962  //   as, or greater cv-qualification than, cv2. For purposes of
1963  //   overload resolution, cases for which cv1 is greater
1964  //   cv-qualification than cv2 are identified as
1965  //   reference-compatible with added qualification (see 13.3.3.2).
1966  if (T1.getCVRQualifiers() == T2.getCVRQualifiers())
1967    return Ref_Compatible;
1968  else if (T1.isMoreQualifiedThan(T2))
1969    return Ref_Compatible_With_Added_Qualification;
1970  else
1971    return Ref_Related;
1972}
1973
1974/// CheckReferenceInit - Check the initialization of a reference
1975/// variable with the given initializer (C++ [dcl.init.ref]). Init is
1976/// the initializer (either a simple initializer or an initializer
1977/// list), and DeclType is the type of the declaration. When ICS is
1978/// non-null, this routine will compute the implicit conversion
1979/// sequence according to C++ [over.ics.ref] and will not produce any
1980/// diagnostics; when ICS is null, it will emit diagnostics when any
1981/// errors are found. Either way, a return value of true indicates
1982/// that there was a failure, a return value of false indicates that
1983/// the reference initialization succeeded.
1984///
1985/// When @p SuppressUserConversions, user-defined conversions are
1986/// suppressed.
1987/// When @p AllowExplicit, we also permit explicit user-defined
1988/// conversion functions.
1989/// When @p ForceRValue, we unconditionally treat the initializer as an rvalue.
1990bool
1991Sema::CheckReferenceInit(Expr *&Init, QualType &DeclType,
1992                         ImplicitConversionSequence *ICS,
1993                         bool SuppressUserConversions,
1994                         bool AllowExplicit, bool ForceRValue) {
1995  assert(DeclType->isReferenceType() && "Reference init needs a reference");
1996
1997  QualType T1 = DeclType->getAsReferenceType()->getPointeeType();
1998  QualType T2 = Init->getType();
1999
2000  // If the initializer is the address of an overloaded function, try
2001  // to resolve the overloaded function. If all goes well, T2 is the
2002  // type of the resulting function.
2003  if (Context.getCanonicalType(T2) == Context.OverloadTy) {
2004    FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Init, DeclType,
2005                                                          ICS != 0);
2006    if (Fn) {
2007      // Since we're performing this reference-initialization for
2008      // real, update the initializer with the resulting function.
2009      if (!ICS) {
2010        if (DiagnoseUseOfDecl(Fn, Init->getSourceRange().getBegin()))
2011          return true;
2012
2013        FixOverloadedFunctionReference(Init, Fn);
2014      }
2015
2016      T2 = Fn->getType();
2017    }
2018  }
2019
2020  // Compute some basic properties of the types and the initializer.
2021  bool isRValRef = DeclType->isRValueReferenceType();
2022  bool DerivedToBase = false;
2023  Expr::isLvalueResult InitLvalue = ForceRValue ? Expr::LV_InvalidExpression :
2024                                                  Init->isLvalue(Context);
2025  ReferenceCompareResult RefRelationship
2026    = CompareReferenceRelationship(T1, T2, DerivedToBase);
2027
2028  // Most paths end in a failed conversion.
2029  if (ICS)
2030    ICS->ConversionKind = ImplicitConversionSequence::BadConversion;
2031
2032  // C++ [dcl.init.ref]p5:
2033  //   A reference to type “cv1 T1” is initialized by an expression
2034  //   of type “cv2 T2” as follows:
2035
2036  //     -- If the initializer expression
2037
2038  // Rvalue references cannot bind to lvalues (N2812).
2039  // There is absolutely no situation where they can. In particular, note that
2040  // this is ill-formed, even if B has a user-defined conversion to A&&:
2041  //   B b;
2042  //   A&& r = b;
2043  if (isRValRef && InitLvalue == Expr::LV_Valid) {
2044    if (!ICS)
2045      Diag(Init->getSourceRange().getBegin(), diag::err_lvalue_to_rvalue_ref)
2046        << Init->getSourceRange();
2047    return true;
2048  }
2049
2050  bool BindsDirectly = false;
2051  //       -- is an lvalue (but is not a bit-field), and “cv1 T1” is
2052  //          reference-compatible with “cv2 T2,” or
2053  //
2054  // Note that the bit-field check is skipped if we are just computing
2055  // the implicit conversion sequence (C++ [over.best.ics]p2).
2056  if (InitLvalue == Expr::LV_Valid && (ICS || !Init->isBitField()) &&
2057      RefRelationship >= Ref_Compatible_With_Added_Qualification) {
2058    BindsDirectly = true;
2059
2060    if (ICS) {
2061      // C++ [over.ics.ref]p1:
2062      //   When a parameter of reference type binds directly (8.5.3)
2063      //   to an argument expression, the implicit conversion sequence
2064      //   is the identity conversion, unless the argument expression
2065      //   has a type that is a derived class of the parameter type,
2066      //   in which case the implicit conversion sequence is a
2067      //   derived-to-base Conversion (13.3.3.1).
2068      ICS->ConversionKind = ImplicitConversionSequence::StandardConversion;
2069      ICS->Standard.First = ICK_Identity;
2070      ICS->Standard.Second = DerivedToBase? ICK_Derived_To_Base : ICK_Identity;
2071      ICS->Standard.Third = ICK_Identity;
2072      ICS->Standard.FromTypePtr = T2.getAsOpaquePtr();
2073      ICS->Standard.ToTypePtr = T1.getAsOpaquePtr();
2074      ICS->Standard.ReferenceBinding = true;
2075      ICS->Standard.DirectBinding = true;
2076      ICS->Standard.RRefBinding = false;
2077
2078      // Nothing more to do: the inaccessibility/ambiguity check for
2079      // derived-to-base conversions is suppressed when we're
2080      // computing the implicit conversion sequence (C++
2081      // [over.best.ics]p2).
2082      return false;
2083    } else {
2084      // Perform the conversion.
2085      // FIXME: Binding to a subobject of the lvalue is going to require
2086      // more AST annotation than this.
2087      ImpCastExprToType(Init, T1, /*isLvalue=*/true);
2088    }
2089  }
2090
2091  //       -- has a class type (i.e., T2 is a class type) and can be
2092  //          implicitly converted to an lvalue of type “cv3 T3,”
2093  //          where “cv1 T1” is reference-compatible with “cv3 T3”
2094  //          92) (this conversion is selected by enumerating the
2095  //          applicable conversion functions (13.3.1.6) and choosing
2096  //          the best one through overload resolution (13.3)),
2097  if (!isRValRef && !SuppressUserConversions && T2->isRecordType()) {
2098    // FIXME: Look for conversions in base classes!
2099    CXXRecordDecl *T2RecordDecl
2100      = dyn_cast<CXXRecordDecl>(T2->getAsRecordType()->getDecl());
2101
2102    OverloadCandidateSet CandidateSet;
2103    OverloadedFunctionDecl *Conversions
2104      = T2RecordDecl->getConversionFunctions();
2105    for (OverloadedFunctionDecl::function_iterator Func
2106           = Conversions->function_begin();
2107         Func != Conversions->function_end(); ++Func) {
2108      CXXConversionDecl *Conv = cast<CXXConversionDecl>(*Func);
2109
2110      // If the conversion function doesn't return a reference type,
2111      // it can't be considered for this conversion.
2112      if (Conv->getConversionType()->isLValueReferenceType() &&
2113          (AllowExplicit || !Conv->isExplicit()))
2114        AddConversionCandidate(Conv, Init, DeclType, CandidateSet);
2115    }
2116
2117    OverloadCandidateSet::iterator Best;
2118    switch (BestViableFunction(CandidateSet, Best)) {
2119    case OR_Success:
2120      // This is a direct binding.
2121      BindsDirectly = true;
2122
2123      if (ICS) {
2124        // C++ [over.ics.ref]p1:
2125        //
2126        //   [...] If the parameter binds directly to the result of
2127        //   applying a conversion function to the argument
2128        //   expression, the implicit conversion sequence is a
2129        //   user-defined conversion sequence (13.3.3.1.2), with the
2130        //   second standard conversion sequence either an identity
2131        //   conversion or, if the conversion function returns an
2132        //   entity of a type that is a derived class of the parameter
2133        //   type, a derived-to-base Conversion.
2134        ICS->ConversionKind = ImplicitConversionSequence::UserDefinedConversion;
2135        ICS->UserDefined.Before = Best->Conversions[0].Standard;
2136        ICS->UserDefined.After = Best->FinalConversion;
2137        ICS->UserDefined.ConversionFunction = Best->Function;
2138        assert(ICS->UserDefined.After.ReferenceBinding &&
2139               ICS->UserDefined.After.DirectBinding &&
2140               "Expected a direct reference binding!");
2141        return false;
2142      } else {
2143        // Perform the conversion.
2144        // FIXME: Binding to a subobject of the lvalue is going to require
2145        // more AST annotation than this.
2146        ImpCastExprToType(Init, T1, /*isLvalue=*/true);
2147      }
2148      break;
2149
2150    case OR_Ambiguous:
2151      assert(false && "Ambiguous reference binding conversions not implemented.");
2152      return true;
2153
2154    case OR_No_Viable_Function:
2155    case OR_Deleted:
2156      // There was no suitable conversion, or we found a deleted
2157      // conversion; continue with other checks.
2158      break;
2159    }
2160  }
2161
2162  if (BindsDirectly) {
2163    // C++ [dcl.init.ref]p4:
2164    //   [...] In all cases where the reference-related or
2165    //   reference-compatible relationship of two types is used to
2166    //   establish the validity of a reference binding, and T1 is a
2167    //   base class of T2, a program that necessitates such a binding
2168    //   is ill-formed if T1 is an inaccessible (clause 11) or
2169    //   ambiguous (10.2) base class of T2.
2170    //
2171    // Note that we only check this condition when we're allowed to
2172    // complain about errors, because we should not be checking for
2173    // ambiguity (or inaccessibility) unless the reference binding
2174    // actually happens.
2175    if (DerivedToBase)
2176      return CheckDerivedToBaseConversion(T2, T1,
2177                                          Init->getSourceRange().getBegin(),
2178                                          Init->getSourceRange());
2179    else
2180      return false;
2181  }
2182
2183  //     -- Otherwise, the reference shall be to a non-volatile const
2184  //        type (i.e., cv1 shall be const), or the reference shall be an
2185  //        rvalue reference and the initializer expression shall be an rvalue.
2186  if (!isRValRef && T1.getCVRQualifiers() != QualType::Const) {
2187    if (!ICS)
2188      Diag(Init->getSourceRange().getBegin(),
2189           diag::err_not_reference_to_const_init)
2190        << T1 << (InitLvalue != Expr::LV_Valid? "temporary" : "value")
2191        << T2 << Init->getSourceRange();
2192    return true;
2193  }
2194
2195  //       -- If the initializer expression is an rvalue, with T2 a
2196  //          class type, and “cv1 T1” is reference-compatible with
2197  //          “cv2 T2,” the reference is bound in one of the
2198  //          following ways (the choice is implementation-defined):
2199  //
2200  //          -- The reference is bound to the object represented by
2201  //             the rvalue (see 3.10) or to a sub-object within that
2202  //             object.
2203  //
2204  //          -- A temporary of type “cv1 T2” [sic] is created, and
2205  //             a constructor is called to copy the entire rvalue
2206  //             object into the temporary. The reference is bound to
2207  //             the temporary or to a sub-object within the
2208  //             temporary.
2209  //
2210  //          The constructor that would be used to make the copy
2211  //          shall be callable whether or not the copy is actually
2212  //          done.
2213  //
2214  // Note that C++0x [dcl.init.ref]p5 takes away this implementation
2215  // freedom, so we will always take the first option and never build
2216  // a temporary in this case. FIXME: We will, however, have to check
2217  // for the presence of a copy constructor in C++98/03 mode.
2218  if (InitLvalue != Expr::LV_Valid && T2->isRecordType() &&
2219      RefRelationship >= Ref_Compatible_With_Added_Qualification) {
2220    if (ICS) {
2221      ICS->ConversionKind = ImplicitConversionSequence::StandardConversion;
2222      ICS->Standard.First = ICK_Identity;
2223      ICS->Standard.Second = DerivedToBase? ICK_Derived_To_Base : ICK_Identity;
2224      ICS->Standard.Third = ICK_Identity;
2225      ICS->Standard.FromTypePtr = T2.getAsOpaquePtr();
2226      ICS->Standard.ToTypePtr = T1.getAsOpaquePtr();
2227      ICS->Standard.ReferenceBinding = true;
2228      ICS->Standard.DirectBinding = false;
2229      ICS->Standard.RRefBinding = isRValRef;
2230    } else {
2231      // FIXME: Binding to a subobject of the rvalue is going to require
2232      // more AST annotation than this.
2233      ImpCastExprToType(Init, T1, /*isLvalue=*/true);
2234    }
2235    return false;
2236  }
2237
2238  //       -- Otherwise, a temporary of type “cv1 T1” is created and
2239  //          initialized from the initializer expression using the
2240  //          rules for a non-reference copy initialization (8.5). The
2241  //          reference is then bound to the temporary. If T1 is
2242  //          reference-related to T2, cv1 must be the same
2243  //          cv-qualification as, or greater cv-qualification than,
2244  //          cv2; otherwise, the program is ill-formed.
2245  if (RefRelationship == Ref_Related) {
2246    // If cv1 == cv2 or cv1 is a greater cv-qualified than cv2, then
2247    // we would be reference-compatible or reference-compatible with
2248    // added qualification. But that wasn't the case, so the reference
2249    // initialization fails.
2250    if (!ICS)
2251      Diag(Init->getSourceRange().getBegin(),
2252           diag::err_reference_init_drops_quals)
2253        << T1 << (InitLvalue != Expr::LV_Valid? "temporary" : "value")
2254        << T2 << Init->getSourceRange();
2255    return true;
2256  }
2257
2258  // If at least one of the types is a class type, the types are not
2259  // related, and we aren't allowed any user conversions, the
2260  // reference binding fails. This case is important for breaking
2261  // recursion, since TryImplicitConversion below will attempt to
2262  // create a temporary through the use of a copy constructor.
2263  if (SuppressUserConversions && RefRelationship == Ref_Incompatible &&
2264      (T1->isRecordType() || T2->isRecordType())) {
2265    if (!ICS)
2266      Diag(Init->getSourceRange().getBegin(),
2267           diag::err_typecheck_convert_incompatible)
2268        << DeclType << Init->getType() << "initializing" << Init->getSourceRange();
2269    return true;
2270  }
2271
2272  // Actually try to convert the initializer to T1.
2273  if (ICS) {
2274    // C++ [over.ics.ref]p2:
2275    //
2276    //   When a parameter of reference type is not bound directly to
2277    //   an argument expression, the conversion sequence is the one
2278    //   required to convert the argument expression to the
2279    //   underlying type of the reference according to
2280    //   13.3.3.1. Conceptually, this conversion sequence corresponds
2281    //   to copy-initializing a temporary of the underlying type with
2282    //   the argument expression. Any difference in top-level
2283    //   cv-qualification is subsumed by the initialization itself
2284    //   and does not constitute a conversion.
2285    *ICS = TryImplicitConversion(Init, T1, SuppressUserConversions);
2286    // Of course, that's still a reference binding.
2287    if (ICS->ConversionKind == ImplicitConversionSequence::StandardConversion) {
2288      ICS->Standard.ReferenceBinding = true;
2289      ICS->Standard.RRefBinding = isRValRef;
2290    } else if(ICS->ConversionKind ==
2291              ImplicitConversionSequence::UserDefinedConversion) {
2292      ICS->UserDefined.After.ReferenceBinding = true;
2293      ICS->UserDefined.After.RRefBinding = isRValRef;
2294    }
2295    return ICS->ConversionKind == ImplicitConversionSequence::BadConversion;
2296  } else {
2297    return PerformImplicitConversion(Init, T1, "initializing");
2298  }
2299}
2300
2301/// CheckOverloadedOperatorDeclaration - Check whether the declaration
2302/// of this overloaded operator is well-formed. If so, returns false;
2303/// otherwise, emits appropriate diagnostics and returns true.
2304bool Sema::CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl) {
2305  assert(FnDecl && FnDecl->isOverloadedOperator() &&
2306         "Expected an overloaded operator declaration");
2307
2308  OverloadedOperatorKind Op = FnDecl->getOverloadedOperator();
2309
2310  // C++ [over.oper]p5:
2311  //   The allocation and deallocation functions, operator new,
2312  //   operator new[], operator delete and operator delete[], are
2313  //   described completely in 3.7.3. The attributes and restrictions
2314  //   found in the rest of this subclause do not apply to them unless
2315  //   explicitly stated in 3.7.3.
2316  // FIXME: Write a separate routine for checking this. For now, just
2317  // allow it.
2318  if (Op == OO_New || Op == OO_Array_New ||
2319      Op == OO_Delete || Op == OO_Array_Delete)
2320    return false;
2321
2322  // C++ [over.oper]p6:
2323  //   An operator function shall either be a non-static member
2324  //   function or be a non-member function and have at least one
2325  //   parameter whose type is a class, a reference to a class, an
2326  //   enumeration, or a reference to an enumeration.
2327  if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) {
2328    if (MethodDecl->isStatic())
2329      return Diag(FnDecl->getLocation(),
2330                  diag::err_operator_overload_static) << FnDecl->getDeclName();
2331  } else {
2332    bool ClassOrEnumParam = false;
2333    for (FunctionDecl::param_iterator Param = FnDecl->param_begin(),
2334                                   ParamEnd = FnDecl->param_end();
2335         Param != ParamEnd; ++Param) {
2336      QualType ParamType = (*Param)->getType().getNonReferenceType();
2337      if (ParamType->isRecordType() || ParamType->isEnumeralType()) {
2338        ClassOrEnumParam = true;
2339        break;
2340      }
2341    }
2342
2343    if (!ClassOrEnumParam)
2344      return Diag(FnDecl->getLocation(),
2345                  diag::err_operator_overload_needs_class_or_enum)
2346        << FnDecl->getDeclName();
2347  }
2348
2349  // C++ [over.oper]p8:
2350  //   An operator function cannot have default arguments (8.3.6),
2351  //   except where explicitly stated below.
2352  //
2353  // Only the function-call operator allows default arguments
2354  // (C++ [over.call]p1).
2355  if (Op != OO_Call) {
2356    for (FunctionDecl::param_iterator Param = FnDecl->param_begin();
2357         Param != FnDecl->param_end(); ++Param) {
2358      if ((*Param)->hasUnparsedDefaultArg())
2359        return Diag((*Param)->getLocation(),
2360                    diag::err_operator_overload_default_arg)
2361          << FnDecl->getDeclName();
2362      else if (Expr *DefArg = (*Param)->getDefaultArg())
2363        return Diag((*Param)->getLocation(),
2364                    diag::err_operator_overload_default_arg)
2365          << FnDecl->getDeclName() << DefArg->getSourceRange();
2366    }
2367  }
2368
2369  static const bool OperatorUses[NUM_OVERLOADED_OPERATORS][3] = {
2370    { false, false, false }
2371#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
2372    , { Unary, Binary, MemberOnly }
2373#include "clang/Basic/OperatorKinds.def"
2374  };
2375
2376  bool CanBeUnaryOperator = OperatorUses[Op][0];
2377  bool CanBeBinaryOperator = OperatorUses[Op][1];
2378  bool MustBeMemberOperator = OperatorUses[Op][2];
2379
2380  // C++ [over.oper]p8:
2381  //   [...] Operator functions cannot have more or fewer parameters
2382  //   than the number required for the corresponding operator, as
2383  //   described in the rest of this subclause.
2384  unsigned NumParams = FnDecl->getNumParams()
2385                     + (isa<CXXMethodDecl>(FnDecl)? 1 : 0);
2386  if (Op != OO_Call &&
2387      ((NumParams == 1 && !CanBeUnaryOperator) ||
2388       (NumParams == 2 && !CanBeBinaryOperator) ||
2389       (NumParams < 1) || (NumParams > 2))) {
2390    // We have the wrong number of parameters.
2391    unsigned ErrorKind;
2392    if (CanBeUnaryOperator && CanBeBinaryOperator) {
2393      ErrorKind = 2;  // 2 -> unary or binary.
2394    } else if (CanBeUnaryOperator) {
2395      ErrorKind = 0;  // 0 -> unary
2396    } else {
2397      assert(CanBeBinaryOperator &&
2398             "All non-call overloaded operators are unary or binary!");
2399      ErrorKind = 1;  // 1 -> binary
2400    }
2401
2402    return Diag(FnDecl->getLocation(), diag::err_operator_overload_must_be)
2403      << FnDecl->getDeclName() << NumParams << ErrorKind;
2404  }
2405
2406  // Overloaded operators other than operator() cannot be variadic.
2407  if (Op != OO_Call &&
2408      FnDecl->getType()->getAsFunctionProtoType()->isVariadic()) {
2409    return Diag(FnDecl->getLocation(), diag::err_operator_overload_variadic)
2410      << FnDecl->getDeclName();
2411  }
2412
2413  // Some operators must be non-static member functions.
2414  if (MustBeMemberOperator && !isa<CXXMethodDecl>(FnDecl)) {
2415    return Diag(FnDecl->getLocation(),
2416                diag::err_operator_overload_must_be_member)
2417      << FnDecl->getDeclName();
2418  }
2419
2420  // C++ [over.inc]p1:
2421  //   The user-defined function called operator++ implements the
2422  //   prefix and postfix ++ operator. If this function is a member
2423  //   function with no parameters, or a non-member function with one
2424  //   parameter of class or enumeration type, it defines the prefix
2425  //   increment operator ++ for objects of that type. If the function
2426  //   is a member function with one parameter (which shall be of type
2427  //   int) or a non-member function with two parameters (the second
2428  //   of which shall be of type int), it defines the postfix
2429  //   increment operator ++ for objects of that type.
2430  if ((Op == OO_PlusPlus || Op == OO_MinusMinus) && NumParams == 2) {
2431    ParmVarDecl *LastParam = FnDecl->getParamDecl(FnDecl->getNumParams() - 1);
2432    bool ParamIsInt = false;
2433    if (const BuiltinType *BT = LastParam->getType()->getAsBuiltinType())
2434      ParamIsInt = BT->getKind() == BuiltinType::Int;
2435
2436    if (!ParamIsInt)
2437      return Diag(LastParam->getLocation(),
2438                  diag::err_operator_overload_post_incdec_must_be_int)
2439        << LastParam->getType() << (Op == OO_MinusMinus);
2440  }
2441
2442  // Notify the class if it got an assignment operator.
2443  if (Op == OO_Equal) {
2444    // Would have returned earlier otherwise.
2445    assert(isa<CXXMethodDecl>(FnDecl) &&
2446      "Overloaded = not member, but not filtered.");
2447    CXXMethodDecl *Method = cast<CXXMethodDecl>(FnDecl);
2448    Method->getParent()->addedAssignmentOperator(Context, Method);
2449  }
2450
2451  return false;
2452}
2453
2454/// ActOnStartLinkageSpecification - Parsed the beginning of a C++
2455/// linkage specification, including the language and (if present)
2456/// the '{'. ExternLoc is the location of the 'extern', LangLoc is
2457/// the location of the language string literal, which is provided
2458/// by Lang/StrSize. LBraceLoc, if valid, provides the location of
2459/// the '{' brace. Otherwise, this linkage specification does not
2460/// have any braces.
2461Sema::DeclPtrTy Sema::ActOnStartLinkageSpecification(Scope *S,
2462                                                     SourceLocation ExternLoc,
2463                                                     SourceLocation LangLoc,
2464                                                     const char *Lang,
2465                                                     unsigned StrSize,
2466                                                     SourceLocation LBraceLoc) {
2467  LinkageSpecDecl::LanguageIDs Language;
2468  if (strncmp(Lang, "\"C\"", StrSize) == 0)
2469    Language = LinkageSpecDecl::lang_c;
2470  else if (strncmp(Lang, "\"C++\"", StrSize) == 0)
2471    Language = LinkageSpecDecl::lang_cxx;
2472  else {
2473    Diag(LangLoc, diag::err_bad_language);
2474    return DeclPtrTy();
2475  }
2476
2477  // FIXME: Add all the various semantics of linkage specifications
2478
2479  LinkageSpecDecl *D = LinkageSpecDecl::Create(Context, CurContext,
2480                                               LangLoc, Language,
2481                                               LBraceLoc.isValid());
2482  CurContext->addDecl(Context, D);
2483  PushDeclContext(S, D);
2484  return DeclPtrTy::make(D);
2485}
2486
2487/// ActOnFinishLinkageSpecification - Completely the definition of
2488/// the C++ linkage specification LinkageSpec. If RBraceLoc is
2489/// valid, it's the position of the closing '}' brace in a linkage
2490/// specification that uses braces.
2491Sema::DeclPtrTy Sema::ActOnFinishLinkageSpecification(Scope *S,
2492                                                      DeclPtrTy LinkageSpec,
2493                                                      SourceLocation RBraceLoc) {
2494  if (LinkageSpec)
2495    PopDeclContext();
2496  return LinkageSpec;
2497}
2498
2499/// ActOnExceptionDeclarator - Parsed the exception-declarator in a C++ catch
2500/// handler.
2501Sema::DeclPtrTy Sema::ActOnExceptionDeclarator(Scope *S, Declarator &D) {
2502  QualType ExDeclType = GetTypeForDeclarator(D, S);
2503  SourceLocation Begin = D.getDeclSpec().getSourceRange().getBegin();
2504
2505  bool Invalid = false;
2506
2507  // Arrays and functions decay.
2508  if (ExDeclType->isArrayType())
2509    ExDeclType = Context.getArrayDecayedType(ExDeclType);
2510  else if (ExDeclType->isFunctionType())
2511    ExDeclType = Context.getPointerType(ExDeclType);
2512
2513  // C++ 15.3p1: The exception-declaration shall not denote an incomplete type.
2514  // The exception-declaration shall not denote a pointer or reference to an
2515  // incomplete type, other than [cv] void*.
2516  // N2844 forbids rvalue references.
2517  if(ExDeclType->isRValueReferenceType()) {
2518    Diag(Begin, diag::err_catch_rvalue_ref) << D.getSourceRange();
2519    Invalid = true;
2520  }
2521  QualType BaseType = ExDeclType;
2522  int Mode = 0; // 0 for direct type, 1 for pointer, 2 for reference
2523  unsigned DK = diag::err_catch_incomplete;
2524  if (const PointerType *Ptr = BaseType->getAsPointerType()) {
2525    BaseType = Ptr->getPointeeType();
2526    Mode = 1;
2527    DK = diag::err_catch_incomplete_ptr;
2528  } else if(const ReferenceType *Ref = BaseType->getAsReferenceType()) {
2529    // For the purpose of error recovery, we treat rvalue refs like lvalue refs.
2530    BaseType = Ref->getPointeeType();
2531    Mode = 2;
2532    DK = diag::err_catch_incomplete_ref;
2533  }
2534  if (!Invalid && (Mode == 0 || !BaseType->isVoidType()) &&
2535      RequireCompleteType(Begin, BaseType, DK))
2536    Invalid = true;
2537
2538  // FIXME: Need to test for ability to copy-construct and destroy the
2539  // exception variable.
2540  // FIXME: Need to check for abstract classes.
2541
2542  IdentifierInfo *II = D.getIdentifier();
2543  if (NamedDecl *PrevDecl = LookupName(S, II, LookupOrdinaryName)) {
2544    // The scope should be freshly made just for us. There is just no way
2545    // it contains any previous declaration.
2546    assert(!S->isDeclScope(DeclPtrTy::make(PrevDecl)));
2547    if (PrevDecl->isTemplateParameter()) {
2548      // Maybe we will complain about the shadowed template parameter.
2549      DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
2550    }
2551  }
2552
2553  VarDecl *ExDecl = VarDecl::Create(Context, CurContext, D.getIdentifierLoc(),
2554                                    II, ExDeclType, VarDecl::None, Begin);
2555  if (D.getInvalidType() || Invalid)
2556    ExDecl->setInvalidDecl();
2557
2558  if (D.getCXXScopeSpec().isSet()) {
2559    Diag(D.getIdentifierLoc(), diag::err_qualified_catch_declarator)
2560      << D.getCXXScopeSpec().getRange();
2561    ExDecl->setInvalidDecl();
2562  }
2563
2564  // Add the exception declaration into this scope.
2565  S->AddDecl(DeclPtrTy::make(ExDecl));
2566  if (II)
2567    IdResolver.AddDecl(ExDecl);
2568
2569  ProcessDeclAttributes(ExDecl, D);
2570  return DeclPtrTy::make(ExDecl);
2571}
2572
2573Sema::DeclPtrTy Sema::ActOnStaticAssertDeclaration(SourceLocation AssertLoc,
2574                                                   ExprArg assertexpr,
2575                                                   ExprArg assertmessageexpr) {
2576  Expr *AssertExpr = (Expr *)assertexpr.get();
2577  StringLiteral *AssertMessage =
2578    cast<StringLiteral>((Expr *)assertmessageexpr.get());
2579
2580  if (!AssertExpr->isTypeDependent() && !AssertExpr->isValueDependent()) {
2581    llvm::APSInt Value(32);
2582    if (!AssertExpr->isIntegerConstantExpr(Value, Context)) {
2583      Diag(AssertLoc, diag::err_static_assert_expression_is_not_constant) <<
2584        AssertExpr->getSourceRange();
2585      return DeclPtrTy();
2586    }
2587
2588    if (Value == 0) {
2589      std::string str(AssertMessage->getStrData(),
2590                      AssertMessage->getByteLength());
2591      Diag(AssertLoc, diag::err_static_assert_failed)
2592        << str << AssertExpr->getSourceRange();
2593    }
2594  }
2595
2596  assertexpr.release();
2597  assertmessageexpr.release();
2598  Decl *Decl = StaticAssertDecl::Create(Context, CurContext, AssertLoc,
2599                                        AssertExpr, AssertMessage);
2600
2601  CurContext->addDecl(Context, Decl);
2602  return DeclPtrTy::make(Decl);
2603}
2604
2605void Sema::SetDeclDeleted(DeclPtrTy dcl, SourceLocation DelLoc) {
2606  Decl *Dcl = dcl.getAs<Decl>();
2607  FunctionDecl *Fn = dyn_cast<FunctionDecl>(Dcl);
2608  if (!Fn) {
2609    Diag(DelLoc, diag::err_deleted_non_function);
2610    return;
2611  }
2612  if (const FunctionDecl *Prev = Fn->getPreviousDeclaration()) {
2613    Diag(DelLoc, diag::err_deleted_decl_not_first);
2614    Diag(Prev->getLocation(), diag::note_previous_declaration);
2615    // If the declaration wasn't the first, we delete the function anyway for
2616    // recovery.
2617  }
2618  Fn->setDeleted();
2619}
2620