SemaExprCXX.cpp revision b2c352ed5586cf869a5dad87a528b9ac000d2fae 
1//===--- SemaExprCXX.cpp - Semantic Analysis for Expressions --------------===//
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++ expressions.
11//
12//===----------------------------------------------------------------------===//
13
14#include "SemaInherit.h"
15#include "Sema.h"
16#include "clang/AST/ExprCXX.h"
17#include "clang/AST/ASTContext.h"
18#include "clang/Parse/DeclSpec.h"
19#include "clang/Lex/Preprocessor.h"
20#include "clang/Basic/TargetInfo.h"
21#include "llvm/ADT/STLExtras.h"
22using namespace clang;
23
24/// ActOnCXXConversionFunctionExpr - Parse a C++ conversion function
25/// name (e.g., operator void const *) as an expression. This is
26/// very similar to ActOnIdentifierExpr, except that instead of
27/// providing an identifier the parser provides the type of the
28/// conversion function.
29Sema::OwningExprResult
30Sema::ActOnCXXConversionFunctionExpr(Scope *S, SourceLocation OperatorLoc,
31                                     TypeTy *Ty, bool HasTrailingLParen,
32                                     const CXXScopeSpec &SS,
33                                     bool isAddressOfOperand) {
34  QualType ConvType = QualType::getFromOpaquePtr(Ty);
35  CanQualType ConvTypeCanon = Context.getCanonicalType(ConvType);
36  DeclarationName ConvName
37    = Context.DeclarationNames.getCXXConversionFunctionName(ConvTypeCanon);
38  return ActOnDeclarationNameExpr(S, OperatorLoc, ConvName, HasTrailingLParen,
39                                  &SS, isAddressOfOperand);
40}
41
42/// ActOnCXXOperatorFunctionIdExpr - Parse a C++ overloaded operator
43/// name (e.g., @c operator+ ) as an expression. This is very
44/// similar to ActOnIdentifierExpr, except that instead of providing
45/// an identifier the parser provides the kind of overloaded
46/// operator that was parsed.
47Sema::OwningExprResult
48Sema::ActOnCXXOperatorFunctionIdExpr(Scope *S, SourceLocation OperatorLoc,
49                                     OverloadedOperatorKind Op,
50                                     bool HasTrailingLParen,
51                                     const CXXScopeSpec &SS,
52                                     bool isAddressOfOperand) {
53  DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(Op);
54  return ActOnDeclarationNameExpr(S, OperatorLoc, Name, HasTrailingLParen, &SS,
55                                  isAddressOfOperand);
56}
57
58/// ActOnCXXTypeidOfType - Parse typeid( type-id ).
59Action::OwningExprResult
60Sema::ActOnCXXTypeid(SourceLocation OpLoc, SourceLocation LParenLoc,
61                     bool isType, void *TyOrExpr, SourceLocation RParenLoc) {
62  NamespaceDecl *StdNs = GetStdNamespace();
63  if (!StdNs)
64    return ExprError(Diag(OpLoc, diag::err_need_header_before_typeid));
65
66  IdentifierInfo *TypeInfoII = &PP.getIdentifierTable().get("type_info");
67  Decl *TypeInfoDecl = LookupQualifiedName(StdNs, TypeInfoII, LookupTagName);
68  RecordDecl *TypeInfoRecordDecl = dyn_cast_or_null<RecordDecl>(TypeInfoDecl);
69  if (!TypeInfoRecordDecl)
70    return ExprError(Diag(OpLoc, diag::err_need_header_before_typeid));
71
72  QualType TypeInfoType = Context.getTypeDeclType(TypeInfoRecordDecl);
73
74  if (!isType) {
75    // C++0x [expr.typeid]p3:
76    //   When typeid is applied to an expression other than an lvalue of a
77    //   polymorphic class type [...] [the] expression is an unevaluated
78    //   operand.
79
80    // FIXME: if the type of the expression is a class type, the class
81    // shall be completely defined.
82    bool isUnevaluatedOperand = true;
83    Expr *E = static_cast<Expr *>(TyOrExpr);
84    if (E && !E->isTypeDependent() && E->isLvalue(Context) == Expr::LV_Valid) {
85      QualType T = E->getType();
86      if (const RecordType *RecordT = T->getAs<RecordType>()) {
87        CXXRecordDecl *RecordD = cast<CXXRecordDecl>(RecordT->getDecl());
88        if (RecordD->isPolymorphic())
89          isUnevaluatedOperand = false;
90      }
91    }
92
93    // If this is an unevaluated operand, clear out the set of declaration
94    // references we have been computing.
95    if (isUnevaluatedOperand)
96      PotentiallyReferencedDeclStack.back().clear();
97  }
98
99  return Owned(new (Context) CXXTypeidExpr(isType, TyOrExpr,
100                                           TypeInfoType.withConst(),
101                                           SourceRange(OpLoc, RParenLoc)));
102}
103
104/// ActOnCXXBoolLiteral - Parse {true,false} literals.
105Action::OwningExprResult
106Sema::ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind) {
107  assert((Kind == tok::kw_true || Kind == tok::kw_false) &&
108         "Unknown C++ Boolean value!");
109  return Owned(new (Context) CXXBoolLiteralExpr(Kind == tok::kw_true,
110                                                Context.BoolTy, OpLoc));
111}
112
113/// ActOnCXXNullPtrLiteral - Parse 'nullptr'.
114Action::OwningExprResult
115Sema::ActOnCXXNullPtrLiteral(SourceLocation Loc) {
116  return Owned(new (Context) CXXNullPtrLiteralExpr(Context.NullPtrTy, Loc));
117}
118
119/// ActOnCXXThrow - Parse throw expressions.
120Action::OwningExprResult
121Sema::ActOnCXXThrow(SourceLocation OpLoc, ExprArg E) {
122  Expr *Ex = E.takeAs<Expr>();
123  if (Ex && !Ex->isTypeDependent() && CheckCXXThrowOperand(OpLoc, Ex))
124    return ExprError();
125  return Owned(new (Context) CXXThrowExpr(Ex, Context.VoidTy, OpLoc));
126}
127
128/// CheckCXXThrowOperand - Validate the operand of a throw.
129bool Sema::CheckCXXThrowOperand(SourceLocation ThrowLoc, Expr *&E) {
130  // C++ [except.throw]p3:
131  //   [...] adjusting the type from "array of T" or "function returning T"
132  //   to "pointer to T" or "pointer to function returning T", [...]
133  DefaultFunctionArrayConversion(E);
134
135  //   If the type of the exception would be an incomplete type or a pointer
136  //   to an incomplete type other than (cv) void the program is ill-formed.
137  QualType Ty = E->getType();
138  int isPointer = 0;
139  if (const PointerType* Ptr = Ty->getAs<PointerType>()) {
140    Ty = Ptr->getPointeeType();
141    isPointer = 1;
142  }
143  if (!isPointer || !Ty->isVoidType()) {
144    if (RequireCompleteType(ThrowLoc, Ty,
145                            isPointer ? diag::err_throw_incomplete_ptr
146                                      : diag::err_throw_incomplete,
147                            E->getSourceRange(), SourceRange(), QualType()))
148      return true;
149  }
150
151  // FIXME: Construct a temporary here.
152  return false;
153}
154
155Action::OwningExprResult Sema::ActOnCXXThis(SourceLocation ThisLoc) {
156  /// C++ 9.3.2: In the body of a non-static member function, the keyword this
157  /// is a non-lvalue expression whose value is the address of the object for
158  /// which the function is called.
159
160  if (!isa<FunctionDecl>(CurContext))
161    return ExprError(Diag(ThisLoc, diag::err_invalid_this_use));
162
163  if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(CurContext))
164    if (MD->isInstance())
165      return Owned(new (Context) CXXThisExpr(ThisLoc,
166                                             MD->getThisType(Context)));
167
168  return ExprError(Diag(ThisLoc, diag::err_invalid_this_use));
169}
170
171/// ActOnCXXTypeConstructExpr - Parse construction of a specified type.
172/// Can be interpreted either as function-style casting ("int(x)")
173/// or class type construction ("ClassType(x,y,z)")
174/// or creation of a value-initialized type ("int()").
175Action::OwningExprResult
176Sema::ActOnCXXTypeConstructExpr(SourceRange TypeRange, TypeTy *TypeRep,
177                                SourceLocation LParenLoc,
178                                MultiExprArg exprs,
179                                SourceLocation *CommaLocs,
180                                SourceLocation RParenLoc) {
181  assert(TypeRep && "Missing type!");
182  QualType Ty = QualType::getFromOpaquePtr(TypeRep);
183  unsigned NumExprs = exprs.size();
184  Expr **Exprs = (Expr**)exprs.get();
185  SourceLocation TyBeginLoc = TypeRange.getBegin();
186  SourceRange FullRange = SourceRange(TyBeginLoc, RParenLoc);
187
188  if (Ty->isDependentType() ||
189      CallExpr::hasAnyTypeDependentArguments(Exprs, NumExprs)) {
190    exprs.release();
191
192    return Owned(CXXUnresolvedConstructExpr::Create(Context,
193                                                    TypeRange.getBegin(), Ty,
194                                                    LParenLoc,
195                                                    Exprs, NumExprs,
196                                                    RParenLoc));
197  }
198
199
200  // C++ [expr.type.conv]p1:
201  // If the expression list is a single expression, the type conversion
202  // expression is equivalent (in definedness, and if defined in meaning) to the
203  // corresponding cast expression.
204  //
205  if (NumExprs == 1) {
206    if (CheckCastTypes(TypeRange, Ty, Exprs[0], /*functional-style*/true))
207      return ExprError();
208    exprs.release();
209    return Owned(new (Context) CXXFunctionalCastExpr(Ty.getNonReferenceType(),
210                                                     Ty, TyBeginLoc,
211                                                     CastExpr::CK_Unknown,
212                                                     Exprs[0], RParenLoc));
213  }
214
215  if (const RecordType *RT = Ty->getAs<RecordType>()) {
216    CXXRecordDecl *Record = cast<CXXRecordDecl>(RT->getDecl());
217
218    // FIXME: We should always create a CXXTemporaryObjectExpr here unless
219    // both the ctor and dtor are trivial.
220    if (NumExprs > 1 || Record->hasUserDeclaredConstructor()) {
221      CXXConstructorDecl *Constructor
222        = PerformInitializationByConstructor(Ty, Exprs, NumExprs,
223                                             TypeRange.getBegin(),
224                                             SourceRange(TypeRange.getBegin(),
225                                                         RParenLoc),
226                                             DeclarationName(),
227                                             IK_Direct);
228
229      if (!Constructor)
230        return ExprError();
231
232      exprs.release();
233      Expr *E = new (Context) CXXTemporaryObjectExpr(Context, Constructor,
234                                                     Ty, TyBeginLoc, Exprs,
235                                                     NumExprs, RParenLoc);
236      return MaybeBindToTemporary(E);
237    }
238
239    // Fall through to value-initialize an object of class type that
240    // doesn't have a user-declared default constructor.
241  }
242
243  // C++ [expr.type.conv]p1:
244  // If the expression list specifies more than a single value, the type shall
245  // be a class with a suitably declared constructor.
246  //
247  if (NumExprs > 1)
248    return ExprError(Diag(CommaLocs[0],
249                          diag::err_builtin_func_cast_more_than_one_arg)
250      << FullRange);
251
252  assert(NumExprs == 0 && "Expected 0 expressions");
253
254  // C++ [expr.type.conv]p2:
255  // The expression T(), where T is a simple-type-specifier for a non-array
256  // complete object type or the (possibly cv-qualified) void type, creates an
257  // rvalue of the specified type, which is value-initialized.
258  //
259  if (Ty->isArrayType())
260    return ExprError(Diag(TyBeginLoc,
261                          diag::err_value_init_for_array_type) << FullRange);
262  if (!Ty->isDependentType() && !Ty->isVoidType() &&
263      RequireCompleteType(TyBeginLoc, Ty,
264                          diag::err_invalid_incomplete_type_use, FullRange))
265    return ExprError();
266
267  if (RequireNonAbstractType(TyBeginLoc, Ty,
268                             diag::err_allocation_of_abstract_type))
269    return ExprError();
270
271  exprs.release();
272  return Owned(new (Context) CXXZeroInitValueExpr(Ty, TyBeginLoc, RParenLoc));
273}
274
275
276/// ActOnCXXNew - Parsed a C++ 'new' expression (C++ 5.3.4), as in e.g.:
277/// @code new (memory) int[size][4] @endcode
278/// or
279/// @code ::new Foo(23, "hello") @endcode
280/// For the interpretation of this heap of arguments, consult the base version.
281Action::OwningExprResult
282Sema::ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal,
283                  SourceLocation PlacementLParen, MultiExprArg PlacementArgs,
284                  SourceLocation PlacementRParen, bool ParenTypeId,
285                  Declarator &D, SourceLocation ConstructorLParen,
286                  MultiExprArg ConstructorArgs,
287                  SourceLocation ConstructorRParen)
288{
289  Expr *ArraySize = 0;
290  unsigned Skip = 0;
291  // If the specified type is an array, unwrap it and save the expression.
292  if (D.getNumTypeObjects() > 0 &&
293      D.getTypeObject(0).Kind == DeclaratorChunk::Array) {
294    DeclaratorChunk &Chunk = D.getTypeObject(0);
295    if (Chunk.Arr.hasStatic)
296      return ExprError(Diag(Chunk.Loc, diag::err_static_illegal_in_new)
297        << D.getSourceRange());
298    if (!Chunk.Arr.NumElts)
299      return ExprError(Diag(Chunk.Loc, diag::err_array_new_needs_size)
300        << D.getSourceRange());
301    ArraySize = static_cast<Expr*>(Chunk.Arr.NumElts);
302    Skip = 1;
303  }
304
305  QualType AllocType = GetTypeForDeclarator(D, /*Scope=*/0, Skip);
306  if (D.isInvalidType())
307    return ExprError();
308
309  // Every dimension shall be of constant size.
310  unsigned i = 1;
311  QualType ElementType = AllocType;
312  while (const ArrayType *Array = Context.getAsArrayType(ElementType)) {
313    if (!Array->isConstantArrayType()) {
314      Diag(D.getTypeObject(i).Loc, diag::err_new_array_nonconst)
315        << static_cast<Expr*>(D.getTypeObject(i).Arr.NumElts)->getSourceRange();
316      return ExprError();
317    }
318    ElementType = Array->getElementType();
319    ++i;
320  }
321
322  return BuildCXXNew(StartLoc, UseGlobal,
323                     PlacementLParen,
324                     move(PlacementArgs),
325                     PlacementRParen,
326                     ParenTypeId,
327                     AllocType,
328                     D.getSourceRange().getBegin(),
329                     D.getSourceRange(),
330                     Owned(ArraySize),
331                     ConstructorLParen,
332                     move(ConstructorArgs),
333                     ConstructorRParen);
334}
335
336Sema::OwningExprResult
337Sema::BuildCXXNew(SourceLocation StartLoc, bool UseGlobal,
338                  SourceLocation PlacementLParen,
339                  MultiExprArg PlacementArgs,
340                  SourceLocation PlacementRParen,
341                  bool ParenTypeId,
342                  QualType AllocType,
343                  SourceLocation TypeLoc,
344                  SourceRange TypeRange,
345                  ExprArg ArraySizeE,
346                  SourceLocation ConstructorLParen,
347                  MultiExprArg ConstructorArgs,
348                  SourceLocation ConstructorRParen) {
349  if (CheckAllocatedType(AllocType, TypeLoc, TypeRange))
350    return ExprError();
351
352  QualType ResultType = Context.getPointerType(AllocType);
353
354  // That every array dimension except the first is constant was already
355  // checked by the type check above.
356
357  // C++ 5.3.4p6: "The expression in a direct-new-declarator shall have integral
358  //   or enumeration type with a non-negative value."
359  Expr *ArraySize = (Expr *)ArraySizeE.get();
360  if (ArraySize && !ArraySize->isTypeDependent()) {
361    QualType SizeType = ArraySize->getType();
362    if (!SizeType->isIntegralType() && !SizeType->isEnumeralType())
363      return ExprError(Diag(ArraySize->getSourceRange().getBegin(),
364                            diag::err_array_size_not_integral)
365        << SizeType << ArraySize->getSourceRange());
366    // Let's see if this is a constant < 0. If so, we reject it out of hand.
367    // We don't care about special rules, so we tell the machinery it's not
368    // evaluated - it gives us a result in more cases.
369    if (!ArraySize->isValueDependent()) {
370      llvm::APSInt Value;
371      if (ArraySize->isIntegerConstantExpr(Value, Context, 0, false)) {
372        if (Value < llvm::APSInt(
373                        llvm::APInt::getNullValue(Value.getBitWidth()), false))
374          return ExprError(Diag(ArraySize->getSourceRange().getBegin(),
375                           diag::err_typecheck_negative_array_size)
376            << ArraySize->getSourceRange());
377      }
378    }
379  }
380
381  FunctionDecl *OperatorNew = 0;
382  FunctionDecl *OperatorDelete = 0;
383  Expr **PlaceArgs = (Expr**)PlacementArgs.get();
384  unsigned NumPlaceArgs = PlacementArgs.size();
385  if (!AllocType->isDependentType() &&
386      !Expr::hasAnyTypeDependentArguments(PlaceArgs, NumPlaceArgs) &&
387      FindAllocationFunctions(StartLoc,
388                              SourceRange(PlacementLParen, PlacementRParen),
389                              UseGlobal, AllocType, ArraySize, PlaceArgs,
390                              NumPlaceArgs, OperatorNew, OperatorDelete))
391    return ExprError();
392
393  bool Init = ConstructorLParen.isValid();
394  // --- Choosing a constructor ---
395  // C++ 5.3.4p15
396  // 1) If T is a POD and there's no initializer (ConstructorLParen is invalid)
397  //   the object is not initialized. If the object, or any part of it, is
398  //   const-qualified, it's an error.
399  // 2) If T is a POD and there's an empty initializer, the object is value-
400  //   initialized.
401  // 3) If T is a POD and there's one initializer argument, the object is copy-
402  //   constructed.
403  // 4) If T is a POD and there's more initializer arguments, it's an error.
404  // 5) If T is not a POD, the initializer arguments are used as constructor
405  //   arguments.
406  //
407  // Or by the C++0x formulation:
408  // 1) If there's no initializer, the object is default-initialized according
409  //    to C++0x rules.
410  // 2) Otherwise, the object is direct-initialized.
411  CXXConstructorDecl *Constructor = 0;
412  Expr **ConsArgs = (Expr**)ConstructorArgs.get();
413  const RecordType *RT;
414  unsigned NumConsArgs = ConstructorArgs.size();
415  if (AllocType->isDependentType()) {
416    // Skip all the checks.
417  } else if ((RT = AllocType->getAs<RecordType>()) &&
418             !AllocType->isAggregateType()) {
419    Constructor = PerformInitializationByConstructor(
420                      AllocType, ConsArgs, NumConsArgs,
421                      TypeLoc,
422                      SourceRange(TypeLoc, ConstructorRParen),
423                      RT->getDecl()->getDeclName(),
424                      NumConsArgs != 0 ? IK_Direct : IK_Default);
425    if (!Constructor)
426      return ExprError();
427  } else {
428    if (!Init) {
429      // FIXME: Check that no subpart is const.
430      if (AllocType.isConstQualified())
431        return ExprError(Diag(StartLoc, diag::err_new_uninitialized_const)
432                           << TypeRange);
433    } else if (NumConsArgs == 0) {
434      // Object is value-initialized. Do nothing.
435    } else if (NumConsArgs == 1) {
436      // Object is direct-initialized.
437      // FIXME: What DeclarationName do we pass in here?
438      if (CheckInitializerTypes(ConsArgs[0], AllocType, StartLoc,
439                                DeclarationName() /*AllocType.getAsString()*/,
440                                /*DirectInit=*/true))
441        return ExprError();
442    } else {
443      return ExprError(Diag(StartLoc,
444                            diag::err_builtin_direct_init_more_than_one_arg)
445        << SourceRange(ConstructorLParen, ConstructorRParen));
446    }
447  }
448
449  // FIXME: Also check that the destructor is accessible. (C++ 5.3.4p16)
450
451  PlacementArgs.release();
452  ConstructorArgs.release();
453  ArraySizeE.release();
454  return Owned(new (Context) CXXNewExpr(UseGlobal, OperatorNew, PlaceArgs,
455                        NumPlaceArgs, ParenTypeId, ArraySize, Constructor, Init,
456                        ConsArgs, NumConsArgs, OperatorDelete, ResultType,
457                        StartLoc, Init ? ConstructorRParen : SourceLocation()));
458}
459
460/// CheckAllocatedType - Checks that a type is suitable as the allocated type
461/// in a new-expression.
462/// dimension off and stores the size expression in ArraySize.
463bool Sema::CheckAllocatedType(QualType AllocType, SourceLocation Loc,
464                              SourceRange R)
465{
466  // C++ 5.3.4p1: "[The] type shall be a complete object type, but not an
467  //   abstract class type or array thereof.
468  if (AllocType->isFunctionType())
469    return Diag(Loc, diag::err_bad_new_type)
470      << AllocType << 0 << R;
471  else if (AllocType->isReferenceType())
472    return Diag(Loc, diag::err_bad_new_type)
473      << AllocType << 1 << R;
474  else if (!AllocType->isDependentType() &&
475           RequireCompleteType(Loc, AllocType,
476                               diag::err_new_incomplete_type,
477                               R))
478    return true;
479  else if (RequireNonAbstractType(Loc, AllocType,
480                                  diag::err_allocation_of_abstract_type))
481    return true;
482
483  return false;
484}
485
486/// FindAllocationFunctions - Finds the overloads of operator new and delete
487/// that are appropriate for the allocation.
488bool Sema::FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
489                                   bool UseGlobal, QualType AllocType,
490                                   bool IsArray, Expr **PlaceArgs,
491                                   unsigned NumPlaceArgs,
492                                   FunctionDecl *&OperatorNew,
493                                   FunctionDecl *&OperatorDelete)
494{
495  // --- Choosing an allocation function ---
496  // C++ 5.3.4p8 - 14 & 18
497  // 1) If UseGlobal is true, only look in the global scope. Else, also look
498  //   in the scope of the allocated class.
499  // 2) If an array size is given, look for operator new[], else look for
500  //   operator new.
501  // 3) The first argument is always size_t. Append the arguments from the
502  //   placement form.
503  // FIXME: Also find the appropriate delete operator.
504
505  llvm::SmallVector<Expr*, 8> AllocArgs(1 + NumPlaceArgs);
506  // We don't care about the actual value of this argument.
507  // FIXME: Should the Sema create the expression and embed it in the syntax
508  // tree? Or should the consumer just recalculate the value?
509  AllocArgs[0] = new (Context) IntegerLiteral(llvm::APInt::getNullValue(
510                                        Context.Target.getPointerWidth(0)),
511                                    Context.getSizeType(),
512                                    SourceLocation());
513  std::copy(PlaceArgs, PlaceArgs + NumPlaceArgs, AllocArgs.begin() + 1);
514
515  DeclarationName NewName = Context.DeclarationNames.getCXXOperatorName(
516                                        IsArray ? OO_Array_New : OO_New);
517  if (AllocType->isRecordType() && !UseGlobal) {
518    CXXRecordDecl *Record
519      = cast<CXXRecordDecl>(AllocType->getAs<RecordType>()->getDecl());
520    // FIXME: We fail to find inherited overloads.
521    if (FindAllocationOverload(StartLoc, Range, NewName, &AllocArgs[0],
522                          AllocArgs.size(), Record, /*AllowMissing=*/true,
523                          OperatorNew))
524      return true;
525  }
526  if (!OperatorNew) {
527    // Didn't find a member overload. Look for a global one.
528    DeclareGlobalNewDelete();
529    DeclContext *TUDecl = Context.getTranslationUnitDecl();
530    if (FindAllocationOverload(StartLoc, Range, NewName, &AllocArgs[0],
531                          AllocArgs.size(), TUDecl, /*AllowMissing=*/false,
532                          OperatorNew))
533      return true;
534  }
535
536  // FindAllocationOverload can change the passed in arguments, so we need to
537  // copy them back.
538  if (NumPlaceArgs > 0)
539    std::copy(&AllocArgs[1], AllocArgs.end(), PlaceArgs);
540
541  // FIXME: This is leaked on error. But so much is currently in Sema that it's
542  // easier to clean it in one go.
543  AllocArgs[0]->Destroy(Context);
544  return false;
545}
546
547/// FindAllocationOverload - Find an fitting overload for the allocation
548/// function in the specified scope.
549bool Sema::FindAllocationOverload(SourceLocation StartLoc, SourceRange Range,
550                                  DeclarationName Name, Expr** Args,
551                                  unsigned NumArgs, DeclContext *Ctx,
552                                  bool AllowMissing, FunctionDecl *&Operator)
553{
554  DeclContext::lookup_iterator Alloc, AllocEnd;
555  llvm::tie(Alloc, AllocEnd) = Ctx->lookup(Name);
556  if (Alloc == AllocEnd) {
557    if (AllowMissing)
558      return false;
559    return Diag(StartLoc, diag::err_ovl_no_viable_function_in_call)
560      << Name << Range;
561  }
562
563  OverloadCandidateSet Candidates;
564  for (; Alloc != AllocEnd; ++Alloc) {
565    // Even member operator new/delete are implicitly treated as
566    // static, so don't use AddMemberCandidate.
567    if (FunctionDecl *Fn = dyn_cast<FunctionDecl>(*Alloc))
568      AddOverloadCandidate(Fn, Args, NumArgs, Candidates,
569                           /*SuppressUserConversions=*/false);
570  }
571
572  // Do the resolution.
573  OverloadCandidateSet::iterator Best;
574  switch(BestViableFunction(Candidates, StartLoc, Best)) {
575  case OR_Success: {
576    // Got one!
577    FunctionDecl *FnDecl = Best->Function;
578    // The first argument is size_t, and the first parameter must be size_t,
579    // too. This is checked on declaration and can be assumed. (It can't be
580    // asserted on, though, since invalid decls are left in there.)
581    for (unsigned i = 1; i < NumArgs; ++i) {
582      // FIXME: Passing word to diagnostic.
583      if (PerformCopyInitialization(Args[i],
584                                    FnDecl->getParamDecl(i)->getType(),
585                                    "passing"))
586        return true;
587    }
588    Operator = FnDecl;
589    return false;
590  }
591
592  case OR_No_Viable_Function:
593    Diag(StartLoc, diag::err_ovl_no_viable_function_in_call)
594      << Name << Range;
595    PrintOverloadCandidates(Candidates, /*OnlyViable=*/false);
596    return true;
597
598  case OR_Ambiguous:
599    Diag(StartLoc, diag::err_ovl_ambiguous_call)
600      << Name << Range;
601    PrintOverloadCandidates(Candidates, /*OnlyViable=*/true);
602    return true;
603
604  case OR_Deleted:
605    Diag(StartLoc, diag::err_ovl_deleted_call)
606      << Best->Function->isDeleted()
607      << Name << Range;
608    PrintOverloadCandidates(Candidates, /*OnlyViable=*/true);
609    return true;
610  }
611  assert(false && "Unreachable, bad result from BestViableFunction");
612  return true;
613}
614
615
616/// DeclareGlobalNewDelete - Declare the global forms of operator new and
617/// delete. These are:
618/// @code
619///   void* operator new(std::size_t) throw(std::bad_alloc);
620///   void* operator new[](std::size_t) throw(std::bad_alloc);
621///   void operator delete(void *) throw();
622///   void operator delete[](void *) throw();
623/// @endcode
624/// Note that the placement and nothrow forms of new are *not* implicitly
625/// declared. Their use requires including \<new\>.
626void Sema::DeclareGlobalNewDelete()
627{
628  if (GlobalNewDeleteDeclared)
629    return;
630  GlobalNewDeleteDeclared = true;
631
632  QualType VoidPtr = Context.getPointerType(Context.VoidTy);
633  QualType SizeT = Context.getSizeType();
634
635  // FIXME: Exception specifications are not added.
636  DeclareGlobalAllocationFunction(
637      Context.DeclarationNames.getCXXOperatorName(OO_New),
638      VoidPtr, SizeT);
639  DeclareGlobalAllocationFunction(
640      Context.DeclarationNames.getCXXOperatorName(OO_Array_New),
641      VoidPtr, SizeT);
642  DeclareGlobalAllocationFunction(
643      Context.DeclarationNames.getCXXOperatorName(OO_Delete),
644      Context.VoidTy, VoidPtr);
645  DeclareGlobalAllocationFunction(
646      Context.DeclarationNames.getCXXOperatorName(OO_Array_Delete),
647      Context.VoidTy, VoidPtr);
648}
649
650/// DeclareGlobalAllocationFunction - Declares a single implicit global
651/// allocation function if it doesn't already exist.
652void Sema::DeclareGlobalAllocationFunction(DeclarationName Name,
653                                           QualType Return, QualType Argument)
654{
655  DeclContext *GlobalCtx = Context.getTranslationUnitDecl();
656
657  // Check if this function is already declared.
658  {
659    DeclContext::lookup_iterator Alloc, AllocEnd;
660    for (llvm::tie(Alloc, AllocEnd) = GlobalCtx->lookup(Name);
661         Alloc != AllocEnd; ++Alloc) {
662      // FIXME: Do we need to check for default arguments here?
663      FunctionDecl *Func = cast<FunctionDecl>(*Alloc);
664      if (Func->getNumParams() == 1 &&
665          Context.getCanonicalType(Func->getParamDecl(0)->getType())==Argument)
666        return;
667    }
668  }
669
670  QualType FnType = Context.getFunctionType(Return, &Argument, 1, false, 0);
671  FunctionDecl *Alloc =
672    FunctionDecl::Create(Context, GlobalCtx, SourceLocation(), Name,
673                         FnType, FunctionDecl::None, false, true,
674                         SourceLocation());
675  Alloc->setImplicit();
676  ParmVarDecl *Param = ParmVarDecl::Create(Context, Alloc, SourceLocation(),
677                                           0, Argument, VarDecl::None, 0);
678  Alloc->setParams(Context, &Param, 1);
679
680  // FIXME: Also add this declaration to the IdentifierResolver, but
681  // make sure it is at the end of the chain to coincide with the
682  // global scope.
683  ((DeclContext *)TUScope->getEntity())->addDecl(Alloc);
684}
685
686/// ActOnCXXDelete - Parsed a C++ 'delete' expression (C++ 5.3.5), as in:
687/// @code ::delete ptr; @endcode
688/// or
689/// @code delete [] ptr; @endcode
690Action::OwningExprResult
691Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal,
692                     bool ArrayForm, ExprArg Operand)
693{
694  // C++ 5.3.5p1: "The operand shall have a pointer type, or a class type
695  //   having a single conversion function to a pointer type. The result has
696  //   type void."
697  // DR599 amends "pointer type" to "pointer to object type" in both cases.
698
699  Expr *Ex = (Expr *)Operand.get();
700  if (!Ex->isTypeDependent()) {
701    QualType Type = Ex->getType();
702
703    if (Type->isRecordType()) {
704      // FIXME: Find that one conversion function and amend the type.
705    }
706
707    if (!Type->isPointerType())
708      return ExprError(Diag(StartLoc, diag::err_delete_operand)
709        << Type << Ex->getSourceRange());
710
711    QualType Pointee = Type->getAs<PointerType>()->getPointeeType();
712    if (Pointee->isFunctionType() || Pointee->isVoidType())
713      return ExprError(Diag(StartLoc, diag::err_delete_operand)
714        << Type << Ex->getSourceRange());
715    else if (!Pointee->isDependentType() &&
716             RequireCompleteType(StartLoc, Pointee,
717                                 diag::warn_delete_incomplete,
718                                 Ex->getSourceRange()))
719      return ExprError();
720
721    // FIXME: Look up the correct operator delete overload and pass a pointer
722    // along.
723    // FIXME: Check access and ambiguity of operator delete and destructor.
724  }
725
726  Operand.release();
727  return Owned(new (Context) CXXDeleteExpr(Context.VoidTy, UseGlobal, ArrayForm,
728                                           0, Ex, StartLoc));
729}
730
731
732/// ActOnCXXConditionDeclarationExpr - Parsed a condition declaration of a
733/// C++ if/switch/while/for statement.
734/// e.g: "if (int x = f()) {...}"
735Action::OwningExprResult
736Sema::ActOnCXXConditionDeclarationExpr(Scope *S, SourceLocation StartLoc,
737                                       Declarator &D,
738                                       SourceLocation EqualLoc,
739                                       ExprArg AssignExprVal) {
740  assert(AssignExprVal.get() && "Null assignment expression");
741
742  // C++ 6.4p2:
743  // The declarator shall not specify a function or an array.
744  // The type-specifier-seq shall not contain typedef and shall not declare a
745  // new class or enumeration.
746
747  assert(D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef &&
748         "Parser allowed 'typedef' as storage class of condition decl.");
749
750  QualType Ty = GetTypeForDeclarator(D, S);
751
752  if (Ty->isFunctionType()) { // The declarator shall not specify a function...
753    // We exit without creating a CXXConditionDeclExpr because a FunctionDecl
754    // would be created and CXXConditionDeclExpr wants a VarDecl.
755    return ExprError(Diag(StartLoc, diag::err_invalid_use_of_function_type)
756      << SourceRange(StartLoc, EqualLoc));
757  } else if (Ty->isArrayType()) { // ...or an array.
758    Diag(StartLoc, diag::err_invalid_use_of_array_type)
759      << SourceRange(StartLoc, EqualLoc);
760  } else if (const RecordType *RT = Ty->getAs<RecordType>()) {
761    RecordDecl *RD = RT->getDecl();
762    // The type-specifier-seq shall not declare a new class...
763    if (RD->isDefinition() &&
764        (RD->getIdentifier() == 0 || S->isDeclScope(DeclPtrTy::make(RD))))
765      Diag(RD->getLocation(), diag::err_type_defined_in_condition);
766  } else if (const EnumType *ET = Ty->getAsEnumType()) {
767    EnumDecl *ED = ET->getDecl();
768    // ...or enumeration.
769    if (ED->isDefinition() &&
770        (ED->getIdentifier() == 0 || S->isDeclScope(DeclPtrTy::make(ED))))
771      Diag(ED->getLocation(), diag::err_type_defined_in_condition);
772  }
773
774  DeclPtrTy Dcl = ActOnDeclarator(S, D);
775  if (!Dcl)
776    return ExprError();
777  AddInitializerToDecl(Dcl, move(AssignExprVal), /*DirectInit=*/false);
778
779  // Mark this variable as one that is declared within a conditional.
780  // We know that the decl had to be a VarDecl because that is the only type of
781  // decl that can be assigned and the grammar requires an '='.
782  VarDecl *VD = cast<VarDecl>(Dcl.getAs<Decl>());
783  VD->setDeclaredInCondition(true);
784  return Owned(new (Context) CXXConditionDeclExpr(StartLoc, EqualLoc, VD));
785}
786
787/// CheckCXXBooleanCondition - Returns true if a conversion to bool is invalid.
788bool Sema::CheckCXXBooleanCondition(Expr *&CondExpr) {
789  // C++ 6.4p4:
790  // The value of a condition that is an initialized declaration in a statement
791  // other than a switch statement is the value of the declared variable
792  // implicitly converted to type bool. If that conversion is ill-formed, the
793  // program is ill-formed.
794  // The value of a condition that is an expression is the value of the
795  // expression, implicitly converted to bool.
796  //
797  return PerformContextuallyConvertToBool(CondExpr);
798}
799
800/// Helper function to determine whether this is the (deprecated) C++
801/// conversion from a string literal to a pointer to non-const char or
802/// non-const wchar_t (for narrow and wide string literals,
803/// respectively).
804bool
805Sema::IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType) {
806  // Look inside the implicit cast, if it exists.
807  if (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(From))
808    From = Cast->getSubExpr();
809
810  // A string literal (2.13.4) that is not a wide string literal can
811  // be converted to an rvalue of type "pointer to char"; a wide
812  // string literal can be converted to an rvalue of type "pointer
813  // to wchar_t" (C++ 4.2p2).
814  if (StringLiteral *StrLit = dyn_cast<StringLiteral>(From))
815    if (const PointerType *ToPtrType = ToType->getAs<PointerType>())
816      if (const BuiltinType *ToPointeeType
817          = ToPtrType->getPointeeType()->getAsBuiltinType()) {
818        // This conversion is considered only when there is an
819        // explicit appropriate pointer target type (C++ 4.2p2).
820        if (ToPtrType->getPointeeType().getCVRQualifiers() == 0 &&
821            ((StrLit->isWide() && ToPointeeType->isWideCharType()) ||
822             (!StrLit->isWide() &&
823              (ToPointeeType->getKind() == BuiltinType::Char_U ||
824               ToPointeeType->getKind() == BuiltinType::Char_S))))
825          return true;
826      }
827
828  return false;
829}
830
831/// PerformImplicitConversion - Perform an implicit conversion of the
832/// expression From to the type ToType. Returns true if there was an
833/// error, false otherwise. The expression From is replaced with the
834/// converted expression. Flavor is the kind of conversion we're
835/// performing, used in the error message. If @p AllowExplicit,
836/// explicit user-defined conversions are permitted. @p Elidable should be true
837/// when called for copies which may be elided (C++ 12.8p15). C++0x overload
838/// resolution works differently in that case.
839bool
840Sema::PerformImplicitConversion(Expr *&From, QualType ToType,
841                                const char *Flavor, bool AllowExplicit,
842                                bool Elidable)
843{
844  ImplicitConversionSequence ICS;
845  ICS.ConversionKind = ImplicitConversionSequence::BadConversion;
846  if (Elidable && getLangOptions().CPlusPlus0x) {
847    ICS = TryImplicitConversion(From, ToType, /*SuppressUserConversions*/false,
848                                AllowExplicit, /*ForceRValue*/true);
849  }
850  if (ICS.ConversionKind == ImplicitConversionSequence::BadConversion) {
851    ICS = TryImplicitConversion(From, ToType, false, AllowExplicit);
852  }
853  return PerformImplicitConversion(From, ToType, ICS, Flavor);
854}
855
856/// PerformImplicitConversion - Perform an implicit conversion of the
857/// expression From to the type ToType using the pre-computed implicit
858/// conversion sequence ICS. Returns true if there was an error, false
859/// otherwise. The expression From is replaced with the converted
860/// expression. Flavor is the kind of conversion we're performing,
861/// used in the error message.
862bool
863Sema::PerformImplicitConversion(Expr *&From, QualType ToType,
864                                const ImplicitConversionSequence &ICS,
865                                const char* Flavor) {
866  switch (ICS.ConversionKind) {
867  case ImplicitConversionSequence::StandardConversion:
868    if (PerformImplicitConversion(From, ToType, ICS.Standard, Flavor))
869      return true;
870    break;
871
872  case ImplicitConversionSequence::UserDefinedConversion:
873    // FIXME: This is, of course, wrong. We'll need to actually call the
874    // constructor or conversion operator, and then cope with the standard
875    // conversions.
876    ImpCastExprToType(From, ToType.getNonReferenceType(),
877                      CastExpr::CK_Unknown,
878                      ToType->isLValueReferenceType());
879    return false;
880
881  case ImplicitConversionSequence::EllipsisConversion:
882    assert(false && "Cannot perform an ellipsis conversion");
883    return false;
884
885  case ImplicitConversionSequence::BadConversion:
886    return true;
887  }
888
889  // Everything went well.
890  return false;
891}
892
893/// PerformImplicitConversion - Perform an implicit conversion of the
894/// expression From to the type ToType by following the standard
895/// conversion sequence SCS. Returns true if there was an error, false
896/// otherwise. The expression From is replaced with the converted
897/// expression. Flavor is the context in which we're performing this
898/// conversion, for use in error messages.
899bool
900Sema::PerformImplicitConversion(Expr *&From, QualType ToType,
901                                const StandardConversionSequence& SCS,
902                                const char *Flavor) {
903  // Overall FIXME: we are recomputing too many types here and doing far too
904  // much extra work. What this means is that we need to keep track of more
905  // information that is computed when we try the implicit conversion initially,
906  // so that we don't need to recompute anything here.
907  QualType FromType = From->getType();
908
909  if (SCS.CopyConstructor) {
910    // FIXME: When can ToType be a reference type?
911    assert(!ToType->isReferenceType());
912
913    // FIXME: Keep track of whether the copy constructor is elidable or not.
914    From = BuildCXXConstructExpr(Context,
915                                 ToType, SCS.CopyConstructor, false, &From, 1);
916    return false;
917  }
918
919  // Perform the first implicit conversion.
920  switch (SCS.First) {
921  case ICK_Identity:
922  case ICK_Lvalue_To_Rvalue:
923    // Nothing to do.
924    break;
925
926  case ICK_Array_To_Pointer:
927    FromType = Context.getArrayDecayedType(FromType);
928    ImpCastExprToType(From, FromType);
929    break;
930
931  case ICK_Function_To_Pointer:
932    if (Context.getCanonicalType(FromType) == Context.OverloadTy) {
933      FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(From, ToType, true);
934      if (!Fn)
935        return true;
936
937      if (DiagnoseUseOfDecl(Fn, From->getSourceRange().getBegin()))
938        return true;
939
940      FixOverloadedFunctionReference(From, Fn);
941      FromType = From->getType();
942    }
943    FromType = Context.getPointerType(FromType);
944    ImpCastExprToType(From, FromType);
945    break;
946
947  default:
948    assert(false && "Improper first standard conversion");
949    break;
950  }
951
952  // Perform the second implicit conversion
953  switch (SCS.Second) {
954  case ICK_Identity:
955    // Nothing to do.
956    break;
957
958  case ICK_Integral_Promotion:
959  case ICK_Floating_Promotion:
960  case ICK_Complex_Promotion:
961  case ICK_Integral_Conversion:
962  case ICK_Floating_Conversion:
963  case ICK_Complex_Conversion:
964  case ICK_Floating_Integral:
965  case ICK_Complex_Real:
966  case ICK_Compatible_Conversion:
967      // FIXME: Go deeper to get the unqualified type!
968    FromType = ToType.getUnqualifiedType();
969    ImpCastExprToType(From, FromType);
970    break;
971
972  case ICK_Pointer_Conversion:
973    if (SCS.IncompatibleObjC) {
974      // Diagnose incompatible Objective-C conversions
975      Diag(From->getSourceRange().getBegin(),
976           diag::ext_typecheck_convert_incompatible_pointer)
977        << From->getType() << ToType << Flavor
978        << From->getSourceRange();
979    }
980
981    if (CheckPointerConversion(From, ToType))
982      return true;
983    ImpCastExprToType(From, ToType);
984    break;
985
986  case ICK_Pointer_Member:
987    if (CheckMemberPointerConversion(From, ToType))
988      return true;
989    ImpCastExprToType(From, ToType);
990    break;
991
992  case ICK_Boolean_Conversion:
993    FromType = Context.BoolTy;
994    ImpCastExprToType(From, FromType);
995    break;
996
997  default:
998    assert(false && "Improper second standard conversion");
999    break;
1000  }
1001
1002  switch (SCS.Third) {
1003  case ICK_Identity:
1004    // Nothing to do.
1005    break;
1006
1007  case ICK_Qualification:
1008    // FIXME: Not sure about lvalue vs rvalue here in the presence of rvalue
1009    // references.
1010    ImpCastExprToType(From, ToType.getNonReferenceType(),
1011                      CastExpr::CK_Unknown,
1012                      ToType->isLValueReferenceType());
1013    break;
1014
1015  default:
1016    assert(false && "Improper second standard conversion");
1017    break;
1018  }
1019
1020  return false;
1021}
1022
1023Sema::OwningExprResult Sema::ActOnUnaryTypeTrait(UnaryTypeTrait OTT,
1024                                                 SourceLocation KWLoc,
1025                                                 SourceLocation LParen,
1026                                                 TypeTy *Ty,
1027                                                 SourceLocation RParen) {
1028  QualType T = QualType::getFromOpaquePtr(Ty);
1029
1030  // According to http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html
1031  // all traits except __is_class, __is_enum and __is_union require a the type
1032  // to be complete.
1033  if (OTT != UTT_IsClass && OTT != UTT_IsEnum && OTT != UTT_IsUnion) {
1034    if (RequireCompleteType(KWLoc, T,
1035                            diag::err_incomplete_type_used_in_type_trait_expr,
1036                            SourceRange(), SourceRange(), T))
1037      return ExprError();
1038  }
1039
1040  // There is no point in eagerly computing the value. The traits are designed
1041  // to be used from type trait templates, so Ty will be a template parameter
1042  // 99% of the time.
1043  return Owned(new (Context) UnaryTypeTraitExpr(KWLoc, OTT, T,
1044                                                RParen, Context.BoolTy));
1045}
1046
1047QualType Sema::CheckPointerToMemberOperands(
1048  Expr *&lex, Expr *&rex, SourceLocation Loc, bool isIndirect)
1049{
1050  const char *OpSpelling = isIndirect ? "->*" : ".*";
1051  // C++ 5.5p2
1052  //   The binary operator .* [p3: ->*] binds its second operand, which shall
1053  //   be of type "pointer to member of T" (where T is a completely-defined
1054  //   class type) [...]
1055  QualType RType = rex->getType();
1056  const MemberPointerType *MemPtr = RType->getAs<MemberPointerType>();
1057  if (!MemPtr) {
1058    Diag(Loc, diag::err_bad_memptr_rhs)
1059      << OpSpelling << RType << rex->getSourceRange();
1060    return QualType();
1061  }
1062
1063  QualType Class(MemPtr->getClass(), 0);
1064
1065  // C++ 5.5p2
1066  //   [...] to its first operand, which shall be of class T or of a class of
1067  //   which T is an unambiguous and accessible base class. [p3: a pointer to
1068  //   such a class]
1069  QualType LType = lex->getType();
1070  if (isIndirect) {
1071    if (const PointerType *Ptr = LType->getAs<PointerType>())
1072      LType = Ptr->getPointeeType().getNonReferenceType();
1073    else {
1074      Diag(Loc, diag::err_bad_memptr_lhs)
1075        << OpSpelling << 1 << LType << lex->getSourceRange();
1076      return QualType();
1077    }
1078  }
1079
1080  if (Context.getCanonicalType(Class).getUnqualifiedType() !=
1081      Context.getCanonicalType(LType).getUnqualifiedType()) {
1082    BasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/false,
1083                    /*DetectVirtual=*/false);
1084    // FIXME: Would it be useful to print full ambiguity paths, or is that
1085    // overkill?
1086    if (!IsDerivedFrom(LType, Class, Paths) ||
1087        Paths.isAmbiguous(Context.getCanonicalType(Class))) {
1088      Diag(Loc, diag::err_bad_memptr_lhs) << OpSpelling
1089        << (int)isIndirect << lex->getType() << lex->getSourceRange();
1090      return QualType();
1091    }
1092  }
1093
1094  // C++ 5.5p2
1095  //   The result is an object or a function of the type specified by the
1096  //   second operand.
1097  // The cv qualifiers are the union of those in the pointer and the left side,
1098  // in accordance with 5.5p5 and 5.2.5.
1099  // FIXME: This returns a dereferenced member function pointer as a normal
1100  // function type. However, the only operation valid on such functions is
1101  // calling them. There's also a GCC extension to get a function pointer to the
1102  // thing, which is another complication, because this type - unlike the type
1103  // that is the result of this expression - takes the class as the first
1104  // argument.
1105  // We probably need a "MemberFunctionClosureType" or something like that.
1106  QualType Result = MemPtr->getPointeeType();
1107  if (LType.isConstQualified())
1108    Result.addConst();
1109  if (LType.isVolatileQualified())
1110    Result.addVolatile();
1111  return Result;
1112}
1113
1114/// \brief Get the target type of a standard or user-defined conversion.
1115static QualType TargetType(const ImplicitConversionSequence &ICS) {
1116  assert((ICS.ConversionKind ==
1117              ImplicitConversionSequence::StandardConversion ||
1118          ICS.ConversionKind ==
1119              ImplicitConversionSequence::UserDefinedConversion) &&
1120         "function only valid for standard or user-defined conversions");
1121  if (ICS.ConversionKind == ImplicitConversionSequence::StandardConversion)
1122    return QualType::getFromOpaquePtr(ICS.Standard.ToTypePtr);
1123  return QualType::getFromOpaquePtr(ICS.UserDefined.After.ToTypePtr);
1124}
1125
1126/// \brief Try to convert a type to another according to C++0x 5.16p3.
1127///
1128/// This is part of the parameter validation for the ? operator. If either
1129/// value operand is a class type, the two operands are attempted to be
1130/// converted to each other. This function does the conversion in one direction.
1131/// It emits a diagnostic and returns true only if it finds an ambiguous
1132/// conversion.
1133static bool TryClassUnification(Sema &Self, Expr *From, Expr *To,
1134                                SourceLocation QuestionLoc,
1135                                ImplicitConversionSequence &ICS)
1136{
1137  // C++0x 5.16p3
1138  //   The process for determining whether an operand expression E1 of type T1
1139  //   can be converted to match an operand expression E2 of type T2 is defined
1140  //   as follows:
1141  //   -- If E2 is an lvalue:
1142  if (To->isLvalue(Self.Context) == Expr::LV_Valid) {
1143    //   E1 can be converted to match E2 if E1 can be implicitly converted to
1144    //   type "lvalue reference to T2", subject to the constraint that in the
1145    //   conversion the reference must bind directly to E1.
1146    if (!Self.CheckReferenceInit(From,
1147                            Self.Context.getLValueReferenceType(To->getType()),
1148                            &ICS))
1149    {
1150      assert((ICS.ConversionKind ==
1151                  ImplicitConversionSequence::StandardConversion ||
1152              ICS.ConversionKind ==
1153                  ImplicitConversionSequence::UserDefinedConversion) &&
1154             "expected a definite conversion");
1155      bool DirectBinding =
1156        ICS.ConversionKind == ImplicitConversionSequence::StandardConversion ?
1157        ICS.Standard.DirectBinding : ICS.UserDefined.After.DirectBinding;
1158      if (DirectBinding)
1159        return false;
1160    }
1161  }
1162  ICS.ConversionKind = ImplicitConversionSequence::BadConversion;
1163  //   -- If E2 is an rvalue, or if the conversion above cannot be done:
1164  //      -- if E1 and E2 have class type, and the underlying class types are
1165  //         the same or one is a base class of the other:
1166  QualType FTy = From->getType();
1167  QualType TTy = To->getType();
1168  const RecordType *FRec = FTy->getAs<RecordType>();
1169  const RecordType *TRec = TTy->getAs<RecordType>();
1170  bool FDerivedFromT = FRec && TRec && Self.IsDerivedFrom(FTy, TTy);
1171  if (FRec && TRec && (FRec == TRec ||
1172        FDerivedFromT || Self.IsDerivedFrom(TTy, FTy))) {
1173    //         E1 can be converted to match E2 if the class of T2 is the
1174    //         same type as, or a base class of, the class of T1, and
1175    //         [cv2 > cv1].
1176    if ((FRec == TRec || FDerivedFromT) && TTy.isAtLeastAsQualifiedAs(FTy)) {
1177      // Could still fail if there's no copy constructor.
1178      // FIXME: Is this a hard error then, or just a conversion failure? The
1179      // standard doesn't say.
1180      ICS = Self.TryCopyInitialization(From, TTy);
1181    }
1182  } else {
1183    //     -- Otherwise: E1 can be converted to match E2 if E1 can be
1184    //        implicitly converted to the type that expression E2 would have
1185    //        if E2 were converted to an rvalue.
1186    // First find the decayed type.
1187    if (TTy->isFunctionType())
1188      TTy = Self.Context.getPointerType(TTy);
1189    else if(TTy->isArrayType())
1190      TTy = Self.Context.getArrayDecayedType(TTy);
1191
1192    // Now try the implicit conversion.
1193    // FIXME: This doesn't detect ambiguities.
1194    ICS = Self.TryImplicitConversion(From, TTy);
1195  }
1196  return false;
1197}
1198
1199/// \brief Try to find a common type for two according to C++0x 5.16p5.
1200///
1201/// This is part of the parameter validation for the ? operator. If either
1202/// value operand is a class type, overload resolution is used to find a
1203/// conversion to a common type.
1204static bool FindConditionalOverload(Sema &Self, Expr *&LHS, Expr *&RHS,
1205                                    SourceLocation Loc) {
1206  Expr *Args[2] = { LHS, RHS };
1207  OverloadCandidateSet CandidateSet;
1208  Self.AddBuiltinOperatorCandidates(OO_Conditional, Args, 2, CandidateSet);
1209
1210  OverloadCandidateSet::iterator Best;
1211  switch (Self.BestViableFunction(CandidateSet, Loc, Best)) {
1212    case Sema::OR_Success:
1213      // We found a match. Perform the conversions on the arguments and move on.
1214      if (Self.PerformImplicitConversion(LHS, Best->BuiltinTypes.ParamTypes[0],
1215                                         Best->Conversions[0], "converting") ||
1216          Self.PerformImplicitConversion(RHS, Best->BuiltinTypes.ParamTypes[1],
1217                                         Best->Conversions[1], "converting"))
1218        break;
1219      return false;
1220
1221    case Sema::OR_No_Viable_Function:
1222      Self.Diag(Loc, diag::err_typecheck_cond_incompatible_operands)
1223        << LHS->getType() << RHS->getType()
1224        << LHS->getSourceRange() << RHS->getSourceRange();
1225      return true;
1226
1227    case Sema::OR_Ambiguous:
1228      Self.Diag(Loc, diag::err_conditional_ambiguous_ovl)
1229        << LHS->getType() << RHS->getType()
1230        << LHS->getSourceRange() << RHS->getSourceRange();
1231      // FIXME: Print the possible common types by printing the return types of
1232      // the viable candidates.
1233      break;
1234
1235    case Sema::OR_Deleted:
1236      assert(false && "Conditional operator has only built-in overloads");
1237      break;
1238  }
1239  return true;
1240}
1241
1242/// \brief Perform an "extended" implicit conversion as returned by
1243/// TryClassUnification.
1244///
1245/// TryClassUnification generates ICSs that include reference bindings.
1246/// PerformImplicitConversion is not suitable for this; it chokes if the
1247/// second part of a standard conversion is ICK_DerivedToBase. This function
1248/// handles the reference binding specially.
1249static bool ConvertForConditional(Sema &Self, Expr *&E,
1250                                  const ImplicitConversionSequence &ICS)
1251{
1252  if (ICS.ConversionKind == ImplicitConversionSequence::StandardConversion &&
1253      ICS.Standard.ReferenceBinding) {
1254    assert(ICS.Standard.DirectBinding &&
1255           "TryClassUnification should never generate indirect ref bindings");
1256    // FIXME: CheckReferenceInit should be able to reuse the ICS instead of
1257    // redoing all the work.
1258    return Self.CheckReferenceInit(E, Self.Context.getLValueReferenceType(
1259                                        TargetType(ICS)));
1260  }
1261  if (ICS.ConversionKind == ImplicitConversionSequence::UserDefinedConversion &&
1262      ICS.UserDefined.After.ReferenceBinding) {
1263    assert(ICS.UserDefined.After.DirectBinding &&
1264           "TryClassUnification should never generate indirect ref bindings");
1265    return Self.CheckReferenceInit(E, Self.Context.getLValueReferenceType(
1266                                        TargetType(ICS)));
1267  }
1268  if (Self.PerformImplicitConversion(E, TargetType(ICS), ICS, "converting"))
1269    return true;
1270  return false;
1271}
1272
1273/// \brief Check the operands of ?: under C++ semantics.
1274///
1275/// See C++ [expr.cond]. Note that LHS is never null, even for the GNU x ?: y
1276/// extension. In this case, LHS == Cond. (But they're not aliases.)
1277QualType Sema::CXXCheckConditionalOperands(Expr *&Cond, Expr *&LHS, Expr *&RHS,
1278                                           SourceLocation QuestionLoc) {
1279  // FIXME: Handle C99's complex types, vector types, block pointers and Obj-C++
1280  // interface pointers.
1281
1282  // C++0x 5.16p1
1283  //   The first expression is contextually converted to bool.
1284  if (!Cond->isTypeDependent()) {
1285    if (CheckCXXBooleanCondition(Cond))
1286      return QualType();
1287  }
1288
1289  // Either of the arguments dependent?
1290  if (LHS->isTypeDependent() || RHS->isTypeDependent())
1291    return Context.DependentTy;
1292
1293  // C++0x 5.16p2
1294  //   If either the second or the third operand has type (cv) void, ...
1295  QualType LTy = LHS->getType();
1296  QualType RTy = RHS->getType();
1297  bool LVoid = LTy->isVoidType();
1298  bool RVoid = RTy->isVoidType();
1299  if (LVoid || RVoid) {
1300    //   ... then the [l2r] conversions are performed on the second and third
1301    //   operands ...
1302    DefaultFunctionArrayConversion(LHS);
1303    DefaultFunctionArrayConversion(RHS);
1304    LTy = LHS->getType();
1305    RTy = RHS->getType();
1306
1307    //   ... and one of the following shall hold:
1308    //   -- The second or the third operand (but not both) is a throw-
1309    //      expression; the result is of the type of the other and is an rvalue.
1310    bool LThrow = isa<CXXThrowExpr>(LHS);
1311    bool RThrow = isa<CXXThrowExpr>(RHS);
1312    if (LThrow && !RThrow)
1313      return RTy;
1314    if (RThrow && !LThrow)
1315      return LTy;
1316
1317    //   -- Both the second and third operands have type void; the result is of
1318    //      type void and is an rvalue.
1319    if (LVoid && RVoid)
1320      return Context.VoidTy;
1321
1322    // Neither holds, error.
1323    Diag(QuestionLoc, diag::err_conditional_void_nonvoid)
1324      << (LVoid ? RTy : LTy) << (LVoid ? 0 : 1)
1325      << LHS->getSourceRange() << RHS->getSourceRange();
1326    return QualType();
1327  }
1328
1329  // Neither is void.
1330
1331  // C++0x 5.16p3
1332  //   Otherwise, if the second and third operand have different types, and
1333  //   either has (cv) class type, and attempt is made to convert each of those
1334  //   operands to the other.
1335  if (Context.getCanonicalType(LTy) != Context.getCanonicalType(RTy) &&
1336      (LTy->isRecordType() || RTy->isRecordType())) {
1337    ImplicitConversionSequence ICSLeftToRight, ICSRightToLeft;
1338    // These return true if a single direction is already ambiguous.
1339    if (TryClassUnification(*this, LHS, RHS, QuestionLoc, ICSLeftToRight))
1340      return QualType();
1341    if (TryClassUnification(*this, RHS, LHS, QuestionLoc, ICSRightToLeft))
1342      return QualType();
1343
1344    bool HaveL2R = ICSLeftToRight.ConversionKind !=
1345      ImplicitConversionSequence::BadConversion;
1346    bool HaveR2L = ICSRightToLeft.ConversionKind !=
1347      ImplicitConversionSequence::BadConversion;
1348    //   If both can be converted, [...] the program is ill-formed.
1349    if (HaveL2R && HaveR2L) {
1350      Diag(QuestionLoc, diag::err_conditional_ambiguous)
1351        << LTy << RTy << LHS->getSourceRange() << RHS->getSourceRange();
1352      return QualType();
1353    }
1354
1355    //   If exactly one conversion is possible, that conversion is applied to
1356    //   the chosen operand and the converted operands are used in place of the
1357    //   original operands for the remainder of this section.
1358    if (HaveL2R) {
1359      if (ConvertForConditional(*this, LHS, ICSLeftToRight))
1360        return QualType();
1361      LTy = LHS->getType();
1362    } else if (HaveR2L) {
1363      if (ConvertForConditional(*this, RHS, ICSRightToLeft))
1364        return QualType();
1365      RTy = RHS->getType();
1366    }
1367  }
1368
1369  // C++0x 5.16p4
1370  //   If the second and third operands are lvalues and have the same type,
1371  //   the result is of that type [...]
1372  bool Same = Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy);
1373  if (Same && LHS->isLvalue(Context) == Expr::LV_Valid &&
1374      RHS->isLvalue(Context) == Expr::LV_Valid)
1375    return LTy;
1376
1377  // C++0x 5.16p5
1378  //   Otherwise, the result is an rvalue. If the second and third operands
1379  //   do not have the same type, and either has (cv) class type, ...
1380  if (!Same && (LTy->isRecordType() || RTy->isRecordType())) {
1381    //   ... overload resolution is used to determine the conversions (if any)
1382    //   to be applied to the operands. If the overload resolution fails, the
1383    //   program is ill-formed.
1384    if (FindConditionalOverload(*this, LHS, RHS, QuestionLoc))
1385      return QualType();
1386  }
1387
1388  // C++0x 5.16p6
1389  //   LValue-to-rvalue, array-to-pointer, and function-to-pointer standard
1390  //   conversions are performed on the second and third operands.
1391  DefaultFunctionArrayConversion(LHS);
1392  DefaultFunctionArrayConversion(RHS);
1393  LTy = LHS->getType();
1394  RTy = RHS->getType();
1395
1396  //   After those conversions, one of the following shall hold:
1397  //   -- The second and third operands have the same type; the result
1398  //      is of that type.
1399  if (Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy))
1400    return LTy;
1401
1402  //   -- The second and third operands have arithmetic or enumeration type;
1403  //      the usual arithmetic conversions are performed to bring them to a
1404  //      common type, and the result is of that type.
1405  if (LTy->isArithmeticType() && RTy->isArithmeticType()) {
1406    UsualArithmeticConversions(LHS, RHS);
1407    return LHS->getType();
1408  }
1409
1410  //   -- The second and third operands have pointer type, or one has pointer
1411  //      type and the other is a null pointer constant; pointer conversions
1412  //      and qualification conversions are performed to bring them to their
1413  //      composite pointer type. The result is of the composite pointer type.
1414  QualType Composite = FindCompositePointerType(LHS, RHS);
1415  if (!Composite.isNull())
1416    return Composite;
1417
1418  // Fourth bullet is same for pointers-to-member. However, the possible
1419  // conversions are far more limited: we have null-to-pointer, upcast of
1420  // containing class, and second-level cv-ness.
1421  // cv-ness is not a union, but must match one of the two operands. (Which,
1422  // frankly, is stupid.)
1423  const MemberPointerType *LMemPtr = LTy->getAs<MemberPointerType>();
1424  const MemberPointerType *RMemPtr = RTy->getAs<MemberPointerType>();
1425  if (LMemPtr && RHS->isNullPointerConstant(Context)) {
1426    ImpCastExprToType(RHS, LTy);
1427    return LTy;
1428  }
1429  if (RMemPtr && LHS->isNullPointerConstant(Context)) {
1430    ImpCastExprToType(LHS, RTy);
1431    return RTy;
1432  }
1433  if (LMemPtr && RMemPtr) {
1434    QualType LPointee = LMemPtr->getPointeeType();
1435    QualType RPointee = RMemPtr->getPointeeType();
1436    // First, we check that the unqualified pointee type is the same. If it's
1437    // not, there's no conversion that will unify the two pointers.
1438    if (Context.getCanonicalType(LPointee).getUnqualifiedType() ==
1439        Context.getCanonicalType(RPointee).getUnqualifiedType()) {
1440      // Second, we take the greater of the two cv qualifications. If neither
1441      // is greater than the other, the conversion is not possible.
1442      unsigned Q = LPointee.getCVRQualifiers() | RPointee.getCVRQualifiers();
1443      if (Q == LPointee.getCVRQualifiers() || Q == RPointee.getCVRQualifiers()){
1444        // Third, we check if either of the container classes is derived from
1445        // the other.
1446        QualType LContainer(LMemPtr->getClass(), 0);
1447        QualType RContainer(RMemPtr->getClass(), 0);
1448        QualType MoreDerived;
1449        if (Context.getCanonicalType(LContainer) ==
1450            Context.getCanonicalType(RContainer))
1451          MoreDerived = LContainer;
1452        else if (IsDerivedFrom(LContainer, RContainer))
1453          MoreDerived = LContainer;
1454        else if (IsDerivedFrom(RContainer, LContainer))
1455          MoreDerived = RContainer;
1456
1457        if (!MoreDerived.isNull()) {
1458          // The type 'Q Pointee (MoreDerived::*)' is the common type.
1459          // We don't use ImpCastExprToType here because this could still fail
1460          // for ambiguous or inaccessible conversions.
1461          QualType Common = Context.getMemberPointerType(
1462            LPointee.getQualifiedType(Q), MoreDerived.getTypePtr());
1463          if (PerformImplicitConversion(LHS, Common, "converting"))
1464            return QualType();
1465          if (PerformImplicitConversion(RHS, Common, "converting"))
1466            return QualType();
1467          return Common;
1468        }
1469      }
1470    }
1471  }
1472
1473  Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
1474    << LHS->getType() << RHS->getType()
1475    << LHS->getSourceRange() << RHS->getSourceRange();
1476  return QualType();
1477}
1478
1479/// \brief Find a merged pointer type and convert the two expressions to it.
1480///
1481/// This finds the composite pointer type for @p E1 and @p E2 according to
1482/// C++0x 5.9p2. It converts both expressions to this type and returns it.
1483/// It does not emit diagnostics.
1484QualType Sema::FindCompositePointerType(Expr *&E1, Expr *&E2) {
1485  assert(getLangOptions().CPlusPlus && "This function assumes C++");
1486  QualType T1 = E1->getType(), T2 = E2->getType();
1487  if(!T1->isAnyPointerType() && !T2->isAnyPointerType())
1488    return QualType();
1489
1490  // C++0x 5.9p2
1491  //   Pointer conversions and qualification conversions are performed on
1492  //   pointer operands to bring them to their composite pointer type. If
1493  //   one operand is a null pointer constant, the composite pointer type is
1494  //   the type of the other operand.
1495  if (E1->isNullPointerConstant(Context)) {
1496    ImpCastExprToType(E1, T2);
1497    return T2;
1498  }
1499  if (E2->isNullPointerConstant(Context)) {
1500    ImpCastExprToType(E2, T1);
1501    return T1;
1502  }
1503  // Now both have to be pointers.
1504  if(!T1->isPointerType() || !T2->isPointerType())
1505    return QualType();
1506
1507  //   Otherwise, of one of the operands has type "pointer to cv1 void," then
1508  //   the other has type "pointer to cv2 T" and the composite pointer type is
1509  //   "pointer to cv12 void," where cv12 is the union of cv1 and cv2.
1510  //   Otherwise, the composite pointer type is a pointer type similar to the
1511  //   type of one of the operands, with a cv-qualification signature that is
1512  //   the union of the cv-qualification signatures of the operand types.
1513  // In practice, the first part here is redundant; it's subsumed by the second.
1514  // What we do here is, we build the two possible composite types, and try the
1515  // conversions in both directions. If only one works, or if the two composite
1516  // types are the same, we have succeeded.
1517  llvm::SmallVector<unsigned, 4> QualifierUnion;
1518  QualType Composite1 = T1, Composite2 = T2;
1519  const PointerType *Ptr1, *Ptr2;
1520  while ((Ptr1 = Composite1->getAs<PointerType>()) &&
1521         (Ptr2 = Composite2->getAs<PointerType>())) {
1522    Composite1 = Ptr1->getPointeeType();
1523    Composite2 = Ptr2->getPointeeType();
1524    QualifierUnion.push_back(
1525      Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers());
1526  }
1527  // Rewrap the composites as pointers with the union CVRs.
1528  for (llvm::SmallVector<unsigned, 4>::iterator I = QualifierUnion.begin(),
1529       E = QualifierUnion.end(); I != E; ++I) {
1530    Composite1 = Context.getPointerType(Composite1.getQualifiedType(*I));
1531    Composite2 = Context.getPointerType(Composite2.getQualifiedType(*I));
1532  }
1533
1534  ImplicitConversionSequence E1ToC1 = TryImplicitConversion(E1, Composite1);
1535  ImplicitConversionSequence E2ToC1 = TryImplicitConversion(E2, Composite1);
1536  ImplicitConversionSequence E1ToC2, E2ToC2;
1537  E1ToC2.ConversionKind = ImplicitConversionSequence::BadConversion;
1538  E2ToC2.ConversionKind = ImplicitConversionSequence::BadConversion;
1539  if (Context.getCanonicalType(Composite1) !=
1540      Context.getCanonicalType(Composite2)) {
1541    E1ToC2 = TryImplicitConversion(E1, Composite2);
1542    E2ToC2 = TryImplicitConversion(E2, Composite2);
1543  }
1544
1545  bool ToC1Viable = E1ToC1.ConversionKind !=
1546                      ImplicitConversionSequence::BadConversion
1547                 && E2ToC1.ConversionKind !=
1548                      ImplicitConversionSequence::BadConversion;
1549  bool ToC2Viable = E1ToC2.ConversionKind !=
1550                      ImplicitConversionSequence::BadConversion
1551                 && E2ToC2.ConversionKind !=
1552                      ImplicitConversionSequence::BadConversion;
1553  if (ToC1Viable && !ToC2Viable) {
1554    if (!PerformImplicitConversion(E1, Composite1, E1ToC1, "converting") &&
1555        !PerformImplicitConversion(E2, Composite1, E2ToC1, "converting"))
1556      return Composite1;
1557  }
1558  if (ToC2Viable && !ToC1Viable) {
1559    if (!PerformImplicitConversion(E1, Composite2, E1ToC2, "converting") &&
1560        !PerformImplicitConversion(E2, Composite2, E2ToC2, "converting"))
1561      return Composite2;
1562  }
1563  return QualType();
1564}
1565
1566Sema::OwningExprResult Sema::MaybeBindToTemporary(Expr *E) {
1567  const RecordType *RT = E->getType()->getAs<RecordType>();
1568  if (!RT)
1569    return Owned(E);
1570
1571  CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1572  if (RD->hasTrivialDestructor())
1573    return Owned(E);
1574
1575  CXXTemporary *Temp = CXXTemporary::Create(Context,
1576                                            RD->getDestructor(Context));
1577  ExprTemporaries.push_back(Temp);
1578  if (CXXDestructorDecl *Destructor =
1579        const_cast<CXXDestructorDecl*>(RD->getDestructor(Context)))
1580    MarkDeclarationReferenced(E->getExprLoc(), Destructor);
1581  // FIXME: Add the temporary to the temporaries vector.
1582  return Owned(CXXBindTemporaryExpr::Create(Context, Temp, E));
1583}
1584
1585Expr *Sema::MaybeCreateCXXExprWithTemporaries(Expr *SubExpr,
1586                                              bool ShouldDestroyTemps) {
1587  assert(SubExpr && "sub expression can't be null!");
1588
1589  if (ExprTemporaries.empty())
1590    return SubExpr;
1591
1592  Expr *E = CXXExprWithTemporaries::Create(Context, SubExpr,
1593                                           &ExprTemporaries[0],
1594                                           ExprTemporaries.size(),
1595                                           ShouldDestroyTemps);
1596  ExprTemporaries.clear();
1597
1598  return E;
1599}
1600
1601Sema::OwningExprResult Sema::ActOnFinishFullExpr(ExprArg Arg) {
1602  Expr *FullExpr = Arg.takeAs<Expr>();
1603  if (FullExpr)
1604    FullExpr = MaybeCreateCXXExprWithTemporaries(FullExpr,
1605                                                 /*ShouldDestroyTemps=*/true);
1606
1607  return Owned(FullExpr);
1608}
1609