SemaDeclCXX.cpp revision e37ac4ff1620ed2d7026f52baccbfa022d79ced1 
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 "clang/Basic/LangOptions.h"
16#include "clang/AST/ASTContext.h"
17#include "clang/AST/Expr.h"
18#include "clang/AST/StmtVisitor.h"
19#include "clang/AST/Type.h"
20#include "llvm/ADT/OwningPtr.h"
21#include "llvm/Support/Compiler.h"
22
23using namespace clang;
24
25//===----------------------------------------------------------------------===//
26// CheckDefaultArgumentVisitor
27//===----------------------------------------------------------------------===//
28
29namespace {
30  /// CheckDefaultArgumentVisitor - C++ [dcl.fct.default] Traverses
31  /// the default argument of a parameter to determine whether it
32  /// contains any ill-formed subexpressions. For example, this will
33  /// diagnose the use of local variables or parameters within the
34  /// default argument expression.
35  class VISIBILITY_HIDDEN CheckDefaultArgumentVisitor
36    : public StmtVisitor<CheckDefaultArgumentVisitor, bool>
37  {
38    Expr *DefaultArg;
39    Sema *S;
40
41  public:
42    CheckDefaultArgumentVisitor(Expr *defarg, Sema *s)
43      : DefaultArg(defarg), S(s) {}
44
45    bool VisitExpr(Expr *Node);
46    bool VisitDeclRefExpr(DeclRefExpr *DRE);
47  };
48
49  /// VisitExpr - Visit all of the children of this expression.
50  bool CheckDefaultArgumentVisitor::VisitExpr(Expr *Node) {
51    bool IsInvalid = false;
52    for (Stmt::child_iterator first = Node->child_begin(),
53           last = Node->child_end();
54         first != last; ++first)
55      IsInvalid |= Visit(*first);
56
57    return IsInvalid;
58  }
59
60  /// VisitDeclRefExpr - Visit a reference to a declaration, to
61  /// determine whether this declaration can be used in the default
62  /// argument expression.
63  bool CheckDefaultArgumentVisitor::VisitDeclRefExpr(DeclRefExpr *DRE) {
64    ValueDecl *Decl = DRE->getDecl();
65    if (ParmVarDecl *Param = dyn_cast<ParmVarDecl>(Decl)) {
66      // C++ [dcl.fct.default]p9
67      //   Default arguments are evaluated each time the function is
68      //   called. The order of evaluation of function arguments is
69      //   unspecified. Consequently, parameters of a function shall not
70      //   be used in default argument expressions, even if they are not
71      //   evaluated. Parameters of a function declared before a default
72      //   argument expression are in scope and can hide namespace and
73      //   class member names.
74      return S->Diag(DRE->getSourceRange().getBegin(),
75                     diag::err_param_default_argument_references_param,
76                     Param->getName(), DefaultArg->getSourceRange());
77    } else if (BlockVarDecl *BlockVar = dyn_cast<BlockVarDecl>(Decl)) {
78      // C++ [dcl.fct.default]p7
79      //   Local variables shall not be used in default argument
80      //   expressions.
81      return S->Diag(DRE->getSourceRange().getBegin(),
82                     diag::err_param_default_argument_references_local,
83                     BlockVar->getName(), DefaultArg->getSourceRange());
84    }
85
86    // FIXME: when Clang has support for member functions, "this"
87    // will also need to be diagnosed.
88
89    return false;
90  }
91}
92
93/// ActOnParamDefaultArgument - Check whether the default argument
94/// provided for a function parameter is well-formed. If so, attach it
95/// to the parameter declaration.
96void
97Sema::ActOnParamDefaultArgument(DeclTy *param, SourceLocation EqualLoc,
98                                ExprTy *defarg) {
99  ParmVarDecl *Param = (ParmVarDecl *)param;
100  llvm::OwningPtr<Expr> DefaultArg((Expr *)defarg);
101  QualType ParamType = Param->getType();
102
103  // Default arguments are only permitted in C++
104  if (!getLangOptions().CPlusPlus) {
105    Diag(EqualLoc, diag::err_param_default_argument,
106         DefaultArg->getSourceRange());
107    return;
108  }
109
110  // C++ [dcl.fct.default]p5
111  //   A default argument expression is implicitly converted (clause
112  //   4) to the parameter type. The default argument expression has
113  //   the same semantic constraints as the initializer expression in
114  //   a declaration of a variable of the parameter type, using the
115  //   copy-initialization semantics (8.5).
116  //
117  // FIXME: CheckSingleAssignmentConstraints has the wrong semantics
118  // for C++ (since we want copy-initialization, not copy-assignment),
119  // but we don't have the right semantics implemented yet. Because of
120  // this, our error message is also very poor.
121  QualType DefaultArgType = DefaultArg->getType();
122  Expr *DefaultArgPtr = DefaultArg.get();
123  AssignConvertType ConvTy = CheckSingleAssignmentConstraints(ParamType,
124                                                              DefaultArgPtr);
125  if (DefaultArgPtr != DefaultArg.get()) {
126    DefaultArg.take();
127    DefaultArg.reset(DefaultArgPtr);
128  }
129  if (DiagnoseAssignmentResult(ConvTy, DefaultArg->getLocStart(),
130                               ParamType, DefaultArgType, DefaultArg.get(),
131                               "in default argument")) {
132    return;
133  }
134
135  // FIXME: C++ [dcl.fct.default]p3
136  //   A default argument expression shall be specified only in the
137  //   parameter-declaration-clause of a function declaration or in a
138  //   template-parameter (14.1). It shall not be specified for a
139  //   parameter pack. If it is specified in a
140  //   parameter-declaration-clause, it shall not occur within a
141  //   declarator or abstract-declarator of a parameter-declaration.
142
143  // Check that the default argument is well-formed
144  CheckDefaultArgumentVisitor DefaultArgChecker(DefaultArg.get(), this);
145  if (DefaultArgChecker.Visit(DefaultArg.get()))
146    return;
147
148  // Okay: add the default argument to the parameter
149  Param->setDefaultArg(DefaultArg.take());
150}
151
152// MergeCXXFunctionDecl - Merge two declarations of the same C++
153// function, once we already know that they have the same
154// type. Subroutine of MergeFunctionDecl.
155FunctionDecl *
156Sema::MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old) {
157  // C++ [dcl.fct.default]p4:
158  //
159  //   For non-template functions, default arguments can be added in
160  //   later declarations of a function in the same
161  //   scope. Declarations in different scopes have completely
162  //   distinct sets of default arguments. That is, declarations in
163  //   inner scopes do not acquire default arguments from
164  //   declarations in outer scopes, and vice versa. In a given
165  //   function declaration, all parameters subsequent to a
166  //   parameter with a default argument shall have default
167  //   arguments supplied in this or previous declarations. A
168  //   default argument shall not be redefined by a later
169  //   declaration (not even to the same value).
170  for (unsigned p = 0, NumParams = Old->getNumParams(); p < NumParams; ++p) {
171    ParmVarDecl *OldParam = Old->getParamDecl(p);
172    ParmVarDecl *NewParam = New->getParamDecl(p);
173
174    if(OldParam->getDefaultArg() && NewParam->getDefaultArg()) {
175      Diag(NewParam->getLocation(),
176           diag::err_param_default_argument_redefinition,
177           NewParam->getDefaultArg()->getSourceRange());
178      Diag(OldParam->getLocation(), diag::err_previous_definition);
179    } else if (OldParam->getDefaultArg()) {
180      // Merge the old default argument into the new parameter
181      NewParam->setDefaultArg(OldParam->getDefaultArg());
182    }
183  }
184
185  return New;
186}
187
188/// CheckCXXDefaultArguments - Verify that the default arguments for a
189/// function declaration are well-formed according to C++
190/// [dcl.fct.default].
191void Sema::CheckCXXDefaultArguments(FunctionDecl *FD) {
192  unsigned NumParams = FD->getNumParams();
193  unsigned p;
194
195  // Find first parameter with a default argument
196  for (p = 0; p < NumParams; ++p) {
197    ParmVarDecl *Param = FD->getParamDecl(p);
198    if (Param->getDefaultArg())
199      break;
200  }
201
202  // C++ [dcl.fct.default]p4:
203  //   In a given function declaration, all parameters
204  //   subsequent to a parameter with a default argument shall
205  //   have default arguments supplied in this or previous
206  //   declarations. A default argument shall not be redefined
207  //   by a later declaration (not even to the same value).
208  unsigned LastMissingDefaultArg = 0;
209  for(; p < NumParams; ++p) {
210    ParmVarDecl *Param = FD->getParamDecl(p);
211    if (!Param->getDefaultArg()) {
212      if (Param->getIdentifier())
213        Diag(Param->getLocation(),
214             diag::err_param_default_argument_missing_name,
215             Param->getIdentifier()->getName());
216      else
217        Diag(Param->getLocation(),
218             diag::err_param_default_argument_missing);
219
220      LastMissingDefaultArg = p;
221    }
222  }
223
224  if (LastMissingDefaultArg > 0) {
225    // Some default arguments were missing. Clear out all of the
226    // default arguments up to (and including) the last missing
227    // default argument, so that we leave the function parameters
228    // in a semantically valid state.
229    for (p = 0; p <= LastMissingDefaultArg; ++p) {
230      ParmVarDecl *Param = FD->getParamDecl(p);
231      if (Param->getDefaultArg()) {
232        delete Param->getDefaultArg();
233        Param->setDefaultArg(0);
234      }
235    }
236  }
237}
238
239/// ActOnBaseSpecifier - Parsed a base specifier. A base specifier is
240/// one entry in the base class list of a class specifier, for
241/// example:
242///    class foo : public bar, virtual private baz {
243/// 'public bar' and 'virtual private baz' are each base-specifiers.
244void Sema::ActOnBaseSpecifier(DeclTy *classdecl, SourceRange SpecifierRange,
245                              bool Virtual, AccessSpecifier Access,
246                              DeclTy *basetype, SourceLocation BaseLoc) {
247  RecordDecl *Decl = (RecordDecl*)classdecl;
248  QualType BaseType = Context.getTypeDeclType((TypeDecl*)basetype);
249
250  // Base specifiers must be record types.
251  if (!BaseType->isRecordType()) {
252    Diag(BaseLoc, diag::err_base_must_be_class, SpecifierRange);
253    return;
254  }
255
256  // C++ [class.union]p1:
257  //   A union shall not be used as a base class.
258  if (BaseType->isUnionType()) {
259    Diag(BaseLoc, diag::err_union_as_base_class, SpecifierRange);
260    return;
261  }
262
263  // C++ [class.union]p1:
264  //   A union shall not have base classes.
265  if (Decl->getKind() == Decl::Union) {
266    Diag(Decl->getLocation(), diag::err_base_clause_on_union,
267         SpecifierRange);
268    Decl->setInvalidDecl();
269    return;
270  }
271
272  // C++ [class.derived]p2:
273  //   The class-name in a base-specifier shall not be an incompletely
274  //   defined class.
275  if (BaseType->isIncompleteType()) {
276    Diag(BaseLoc, diag::err_incomplete_base_class, SpecifierRange);
277    return;
278  }
279
280  // FIXME: C++ [class.mi]p3:
281  //   A class shall not be specified as a direct base class of a
282  //   derived class more than once.
283
284  // FIXME: Attach base class to the record.
285}
286