SemaExprCXX.cpp revision 9583fa752f1d32c68daca069fb8dd34e0aa80478 
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    CastExpr::CastKind Kind = CastExpr::CK_Unknown;
207    if (CheckCastTypes(TypeRange, Ty, Exprs[0], Kind, /*functional-style*/true))
208      return ExprError();
209    exprs.release();
210    return Owned(new (Context) CXXFunctionalCastExpr(Ty.getNonReferenceType(),
211                                                     Ty, TyBeginLoc, Kind,
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    bool Elidable = (isa<CallExpr>(From) ||
915                     isa<CXXTemporaryObjectExpr>(From));
916    From = BuildCXXConstructExpr(Context, ToType,
917                                 SCS.CopyConstructor, Elidable, &From, 1);
918    return false;
919  }
920
921  // Perform the first implicit conversion.
922  switch (SCS.First) {
923  case ICK_Identity:
924  case ICK_Lvalue_To_Rvalue:
925    // Nothing to do.
926    break;
927
928  case ICK_Array_To_Pointer:
929    FromType = Context.getArrayDecayedType(FromType);
930    ImpCastExprToType(From, FromType);
931    break;
932
933  case ICK_Function_To_Pointer:
934    if (Context.getCanonicalType(FromType) == Context.OverloadTy) {
935      FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(From, ToType, true);
936      if (!Fn)
937        return true;
938
939      if (DiagnoseUseOfDecl(Fn, From->getSourceRange().getBegin()))
940        return true;
941
942      FixOverloadedFunctionReference(From, Fn);
943      FromType = From->getType();
944    }
945    FromType = Context.getPointerType(FromType);
946    ImpCastExprToType(From, FromType);
947    break;
948
949  default:
950    assert(false && "Improper first standard conversion");
951    break;
952  }
953
954  // Perform the second implicit conversion
955  switch (SCS.Second) {
956  case ICK_Identity:
957    // Nothing to do.
958    break;
959
960  case ICK_Integral_Promotion:
961  case ICK_Floating_Promotion:
962  case ICK_Complex_Promotion:
963  case ICK_Integral_Conversion:
964  case ICK_Floating_Conversion:
965  case ICK_Complex_Conversion:
966  case ICK_Floating_Integral:
967  case ICK_Complex_Real:
968  case ICK_Compatible_Conversion:
969      // FIXME: Go deeper to get the unqualified type!
970    FromType = ToType.getUnqualifiedType();
971    ImpCastExprToType(From, FromType);
972    break;
973
974  case ICK_Pointer_Conversion:
975    if (SCS.IncompatibleObjC) {
976      // Diagnose incompatible Objective-C conversions
977      Diag(From->getSourceRange().getBegin(),
978           diag::ext_typecheck_convert_incompatible_pointer)
979        << From->getType() << ToType << Flavor
980        << From->getSourceRange();
981    }
982
983    if (CheckPointerConversion(From, ToType))
984      return true;
985    ImpCastExprToType(From, ToType);
986    break;
987
988  case ICK_Pointer_Member:
989    if (CheckMemberPointerConversion(From, ToType))
990      return true;
991    ImpCastExprToType(From, ToType);
992    break;
993
994  case ICK_Boolean_Conversion:
995    FromType = Context.BoolTy;
996    ImpCastExprToType(From, FromType);
997    break;
998
999  default:
1000    assert(false && "Improper second standard conversion");
1001    break;
1002  }
1003
1004  switch (SCS.Third) {
1005  case ICK_Identity:
1006    // Nothing to do.
1007    break;
1008
1009  case ICK_Qualification:
1010    // FIXME: Not sure about lvalue vs rvalue here in the presence of rvalue
1011    // references.
1012    ImpCastExprToType(From, ToType.getNonReferenceType(),
1013                      CastExpr::CK_Unknown,
1014                      ToType->isLValueReferenceType());
1015    break;
1016
1017  default:
1018    assert(false && "Improper second standard conversion");
1019    break;
1020  }
1021
1022  return false;
1023}
1024
1025Sema::OwningExprResult Sema::ActOnUnaryTypeTrait(UnaryTypeTrait OTT,
1026                                                 SourceLocation KWLoc,
1027                                                 SourceLocation LParen,
1028                                                 TypeTy *Ty,
1029                                                 SourceLocation RParen) {
1030  QualType T = QualType::getFromOpaquePtr(Ty);
1031
1032  // According to http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html
1033  // all traits except __is_class, __is_enum and __is_union require a the type
1034  // to be complete.
1035  if (OTT != UTT_IsClass && OTT != UTT_IsEnum && OTT != UTT_IsUnion) {
1036    if (RequireCompleteType(KWLoc, T,
1037                            diag::err_incomplete_type_used_in_type_trait_expr,
1038                            SourceRange(), SourceRange(), T))
1039      return ExprError();
1040  }
1041
1042  // There is no point in eagerly computing the value. The traits are designed
1043  // to be used from type trait templates, so Ty will be a template parameter
1044  // 99% of the time.
1045  return Owned(new (Context) UnaryTypeTraitExpr(KWLoc, OTT, T,
1046                                                RParen, Context.BoolTy));
1047}
1048
1049QualType Sema::CheckPointerToMemberOperands(
1050  Expr *&lex, Expr *&rex, SourceLocation Loc, bool isIndirect)
1051{
1052  const char *OpSpelling = isIndirect ? "->*" : ".*";
1053  // C++ 5.5p2
1054  //   The binary operator .* [p3: ->*] binds its second operand, which shall
1055  //   be of type "pointer to member of T" (where T is a completely-defined
1056  //   class type) [...]
1057  QualType RType = rex->getType();
1058  const MemberPointerType *MemPtr = RType->getAs<MemberPointerType>();
1059  if (!MemPtr) {
1060    Diag(Loc, diag::err_bad_memptr_rhs)
1061      << OpSpelling << RType << rex->getSourceRange();
1062    return QualType();
1063  }
1064
1065  QualType Class(MemPtr->getClass(), 0);
1066
1067  // C++ 5.5p2
1068  //   [...] to its first operand, which shall be of class T or of a class of
1069  //   which T is an unambiguous and accessible base class. [p3: a pointer to
1070  //   such a class]
1071  QualType LType = lex->getType();
1072  if (isIndirect) {
1073    if (const PointerType *Ptr = LType->getAs<PointerType>())
1074      LType = Ptr->getPointeeType().getNonReferenceType();
1075    else {
1076      Diag(Loc, diag::err_bad_memptr_lhs)
1077        << OpSpelling << 1 << LType << lex->getSourceRange();
1078      return QualType();
1079    }
1080  }
1081
1082  if (Context.getCanonicalType(Class).getUnqualifiedType() !=
1083      Context.getCanonicalType(LType).getUnqualifiedType()) {
1084    BasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/false,
1085                    /*DetectVirtual=*/false);
1086    // FIXME: Would it be useful to print full ambiguity paths, or is that
1087    // overkill?
1088    if (!IsDerivedFrom(LType, Class, Paths) ||
1089        Paths.isAmbiguous(Context.getCanonicalType(Class))) {
1090      Diag(Loc, diag::err_bad_memptr_lhs) << OpSpelling
1091        << (int)isIndirect << lex->getType() << lex->getSourceRange();
1092      return QualType();
1093    }
1094  }
1095
1096  // C++ 5.5p2
1097  //   The result is an object or a function of the type specified by the
1098  //   second operand.
1099  // The cv qualifiers are the union of those in the pointer and the left side,
1100  // in accordance with 5.5p5 and 5.2.5.
1101  // FIXME: This returns a dereferenced member function pointer as a normal
1102  // function type. However, the only operation valid on such functions is
1103  // calling them. There's also a GCC extension to get a function pointer to the
1104  // thing, which is another complication, because this type - unlike the type
1105  // that is the result of this expression - takes the class as the first
1106  // argument.
1107  // We probably need a "MemberFunctionClosureType" or something like that.
1108  QualType Result = MemPtr->getPointeeType();
1109  if (LType.isConstQualified())
1110    Result.addConst();
1111  if (LType.isVolatileQualified())
1112    Result.addVolatile();
1113  return Result;
1114}
1115
1116/// \brief Get the target type of a standard or user-defined conversion.
1117static QualType TargetType(const ImplicitConversionSequence &ICS) {
1118  assert((ICS.ConversionKind ==
1119              ImplicitConversionSequence::StandardConversion ||
1120          ICS.ConversionKind ==
1121              ImplicitConversionSequence::UserDefinedConversion) &&
1122         "function only valid for standard or user-defined conversions");
1123  if (ICS.ConversionKind == ImplicitConversionSequence::StandardConversion)
1124    return QualType::getFromOpaquePtr(ICS.Standard.ToTypePtr);
1125  return QualType::getFromOpaquePtr(ICS.UserDefined.After.ToTypePtr);
1126}
1127
1128/// \brief Try to convert a type to another according to C++0x 5.16p3.
1129///
1130/// This is part of the parameter validation for the ? operator. If either
1131/// value operand is a class type, the two operands are attempted to be
1132/// converted to each other. This function does the conversion in one direction.
1133/// It emits a diagnostic and returns true only if it finds an ambiguous
1134/// conversion.
1135static bool TryClassUnification(Sema &Self, Expr *From, Expr *To,
1136                                SourceLocation QuestionLoc,
1137                                ImplicitConversionSequence &ICS)
1138{
1139  // C++0x 5.16p3
1140  //   The process for determining whether an operand expression E1 of type T1
1141  //   can be converted to match an operand expression E2 of type T2 is defined
1142  //   as follows:
1143  //   -- If E2 is an lvalue:
1144  if (To->isLvalue(Self.Context) == Expr::LV_Valid) {
1145    //   E1 can be converted to match E2 if E1 can be implicitly converted to
1146    //   type "lvalue reference to T2", subject to the constraint that in the
1147    //   conversion the reference must bind directly to E1.
1148    if (!Self.CheckReferenceInit(From,
1149                            Self.Context.getLValueReferenceType(To->getType()),
1150                            &ICS))
1151    {
1152      assert((ICS.ConversionKind ==
1153                  ImplicitConversionSequence::StandardConversion ||
1154              ICS.ConversionKind ==
1155                  ImplicitConversionSequence::UserDefinedConversion) &&
1156             "expected a definite conversion");
1157      bool DirectBinding =
1158        ICS.ConversionKind == ImplicitConversionSequence::StandardConversion ?
1159        ICS.Standard.DirectBinding : ICS.UserDefined.After.DirectBinding;
1160      if (DirectBinding)
1161        return false;
1162    }
1163  }
1164  ICS.ConversionKind = ImplicitConversionSequence::BadConversion;
1165  //   -- If E2 is an rvalue, or if the conversion above cannot be done:
1166  //      -- if E1 and E2 have class type, and the underlying class types are
1167  //         the same or one is a base class of the other:
1168  QualType FTy = From->getType();
1169  QualType TTy = To->getType();
1170  const RecordType *FRec = FTy->getAs<RecordType>();
1171  const RecordType *TRec = TTy->getAs<RecordType>();
1172  bool FDerivedFromT = FRec && TRec && Self.IsDerivedFrom(FTy, TTy);
1173  if (FRec && TRec && (FRec == TRec ||
1174        FDerivedFromT || Self.IsDerivedFrom(TTy, FTy))) {
1175    //         E1 can be converted to match E2 if the class of T2 is the
1176    //         same type as, or a base class of, the class of T1, and
1177    //         [cv2 > cv1].
1178    if ((FRec == TRec || FDerivedFromT) && TTy.isAtLeastAsQualifiedAs(FTy)) {
1179      // Could still fail if there's no copy constructor.
1180      // FIXME: Is this a hard error then, or just a conversion failure? The
1181      // standard doesn't say.
1182      ICS = Self.TryCopyInitialization(From, TTy);
1183    }
1184  } else {
1185    //     -- Otherwise: E1 can be converted to match E2 if E1 can be
1186    //        implicitly converted to the type that expression E2 would have
1187    //        if E2 were converted to an rvalue.
1188    // First find the decayed type.
1189    if (TTy->isFunctionType())
1190      TTy = Self.Context.getPointerType(TTy);
1191    else if(TTy->isArrayType())
1192      TTy = Self.Context.getArrayDecayedType(TTy);
1193
1194    // Now try the implicit conversion.
1195    // FIXME: This doesn't detect ambiguities.
1196    ICS = Self.TryImplicitConversion(From, TTy);
1197  }
1198  return false;
1199}
1200
1201/// \brief Try to find a common type for two according to C++0x 5.16p5.
1202///
1203/// This is part of the parameter validation for the ? operator. If either
1204/// value operand is a class type, overload resolution is used to find a
1205/// conversion to a common type.
1206static bool FindConditionalOverload(Sema &Self, Expr *&LHS, Expr *&RHS,
1207                                    SourceLocation Loc) {
1208  Expr *Args[2] = { LHS, RHS };
1209  OverloadCandidateSet CandidateSet;
1210  Self.AddBuiltinOperatorCandidates(OO_Conditional, Args, 2, CandidateSet);
1211
1212  OverloadCandidateSet::iterator Best;
1213  switch (Self.BestViableFunction(CandidateSet, Loc, Best)) {
1214    case Sema::OR_Success:
1215      // We found a match. Perform the conversions on the arguments and move on.
1216      if (Self.PerformImplicitConversion(LHS, Best->BuiltinTypes.ParamTypes[0],
1217                                         Best->Conversions[0], "converting") ||
1218          Self.PerformImplicitConversion(RHS, Best->BuiltinTypes.ParamTypes[1],
1219                                         Best->Conversions[1], "converting"))
1220        break;
1221      return false;
1222
1223    case Sema::OR_No_Viable_Function:
1224      Self.Diag(Loc, diag::err_typecheck_cond_incompatible_operands)
1225        << LHS->getType() << RHS->getType()
1226        << LHS->getSourceRange() << RHS->getSourceRange();
1227      return true;
1228
1229    case Sema::OR_Ambiguous:
1230      Self.Diag(Loc, diag::err_conditional_ambiguous_ovl)
1231        << LHS->getType() << RHS->getType()
1232        << LHS->getSourceRange() << RHS->getSourceRange();
1233      // FIXME: Print the possible common types by printing the return types of
1234      // the viable candidates.
1235      break;
1236
1237    case Sema::OR_Deleted:
1238      assert(false && "Conditional operator has only built-in overloads");
1239      break;
1240  }
1241  return true;
1242}
1243
1244/// \brief Perform an "extended" implicit conversion as returned by
1245/// TryClassUnification.
1246///
1247/// TryClassUnification generates ICSs that include reference bindings.
1248/// PerformImplicitConversion is not suitable for this; it chokes if the
1249/// second part of a standard conversion is ICK_DerivedToBase. This function
1250/// handles the reference binding specially.
1251static bool ConvertForConditional(Sema &Self, Expr *&E,
1252                                  const ImplicitConversionSequence &ICS)
1253{
1254  if (ICS.ConversionKind == ImplicitConversionSequence::StandardConversion &&
1255      ICS.Standard.ReferenceBinding) {
1256    assert(ICS.Standard.DirectBinding &&
1257           "TryClassUnification should never generate indirect ref bindings");
1258    // FIXME: CheckReferenceInit should be able to reuse the ICS instead of
1259    // redoing all the work.
1260    return Self.CheckReferenceInit(E, Self.Context.getLValueReferenceType(
1261                                        TargetType(ICS)));
1262  }
1263  if (ICS.ConversionKind == ImplicitConversionSequence::UserDefinedConversion &&
1264      ICS.UserDefined.After.ReferenceBinding) {
1265    assert(ICS.UserDefined.After.DirectBinding &&
1266           "TryClassUnification should never generate indirect ref bindings");
1267    return Self.CheckReferenceInit(E, Self.Context.getLValueReferenceType(
1268                                        TargetType(ICS)));
1269  }
1270  if (Self.PerformImplicitConversion(E, TargetType(ICS), ICS, "converting"))
1271    return true;
1272  return false;
1273}
1274
1275/// \brief Check the operands of ?: under C++ semantics.
1276///
1277/// See C++ [expr.cond]. Note that LHS is never null, even for the GNU x ?: y
1278/// extension. In this case, LHS == Cond. (But they're not aliases.)
1279QualType Sema::CXXCheckConditionalOperands(Expr *&Cond, Expr *&LHS, Expr *&RHS,
1280                                           SourceLocation QuestionLoc) {
1281  // FIXME: Handle C99's complex types, vector types, block pointers and Obj-C++
1282  // interface pointers.
1283
1284  // C++0x 5.16p1
1285  //   The first expression is contextually converted to bool.
1286  if (!Cond->isTypeDependent()) {
1287    if (CheckCXXBooleanCondition(Cond))
1288      return QualType();
1289  }
1290
1291  // Either of the arguments dependent?
1292  if (LHS->isTypeDependent() || RHS->isTypeDependent())
1293    return Context.DependentTy;
1294
1295  // C++0x 5.16p2
1296  //   If either the second or the third operand has type (cv) void, ...
1297  QualType LTy = LHS->getType();
1298  QualType RTy = RHS->getType();
1299  bool LVoid = LTy->isVoidType();
1300  bool RVoid = RTy->isVoidType();
1301  if (LVoid || RVoid) {
1302    //   ... then the [l2r] conversions are performed on the second and third
1303    //   operands ...
1304    DefaultFunctionArrayConversion(LHS);
1305    DefaultFunctionArrayConversion(RHS);
1306    LTy = LHS->getType();
1307    RTy = RHS->getType();
1308
1309    //   ... and one of the following shall hold:
1310    //   -- The second or the third operand (but not both) is a throw-
1311    //      expression; the result is of the type of the other and is an rvalue.
1312    bool LThrow = isa<CXXThrowExpr>(LHS);
1313    bool RThrow = isa<CXXThrowExpr>(RHS);
1314    if (LThrow && !RThrow)
1315      return RTy;
1316    if (RThrow && !LThrow)
1317      return LTy;
1318
1319    //   -- Both the second and third operands have type void; the result is of
1320    //      type void and is an rvalue.
1321    if (LVoid && RVoid)
1322      return Context.VoidTy;
1323
1324    // Neither holds, error.
1325    Diag(QuestionLoc, diag::err_conditional_void_nonvoid)
1326      << (LVoid ? RTy : LTy) << (LVoid ? 0 : 1)
1327      << LHS->getSourceRange() << RHS->getSourceRange();
1328    return QualType();
1329  }
1330
1331  // Neither is void.
1332
1333  // C++0x 5.16p3
1334  //   Otherwise, if the second and third operand have different types, and
1335  //   either has (cv) class type, and attempt is made to convert each of those
1336  //   operands to the other.
1337  if (Context.getCanonicalType(LTy) != Context.getCanonicalType(RTy) &&
1338      (LTy->isRecordType() || RTy->isRecordType())) {
1339    ImplicitConversionSequence ICSLeftToRight, ICSRightToLeft;
1340    // These return true if a single direction is already ambiguous.
1341    if (TryClassUnification(*this, LHS, RHS, QuestionLoc, ICSLeftToRight))
1342      return QualType();
1343    if (TryClassUnification(*this, RHS, LHS, QuestionLoc, ICSRightToLeft))
1344      return QualType();
1345
1346    bool HaveL2R = ICSLeftToRight.ConversionKind !=
1347      ImplicitConversionSequence::BadConversion;
1348    bool HaveR2L = ICSRightToLeft.ConversionKind !=
1349      ImplicitConversionSequence::BadConversion;
1350    //   If both can be converted, [...] the program is ill-formed.
1351    if (HaveL2R && HaveR2L) {
1352      Diag(QuestionLoc, diag::err_conditional_ambiguous)
1353        << LTy << RTy << LHS->getSourceRange() << RHS->getSourceRange();
1354      return QualType();
1355    }
1356
1357    //   If exactly one conversion is possible, that conversion is applied to
1358    //   the chosen operand and the converted operands are used in place of the
1359    //   original operands for the remainder of this section.
1360    if (HaveL2R) {
1361      if (ConvertForConditional(*this, LHS, ICSLeftToRight))
1362        return QualType();
1363      LTy = LHS->getType();
1364    } else if (HaveR2L) {
1365      if (ConvertForConditional(*this, RHS, ICSRightToLeft))
1366        return QualType();
1367      RTy = RHS->getType();
1368    }
1369  }
1370
1371  // C++0x 5.16p4
1372  //   If the second and third operands are lvalues and have the same type,
1373  //   the result is of that type [...]
1374  bool Same = Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy);
1375  if (Same && LHS->isLvalue(Context) == Expr::LV_Valid &&
1376      RHS->isLvalue(Context) == Expr::LV_Valid)
1377    return LTy;
1378
1379  // C++0x 5.16p5
1380  //   Otherwise, the result is an rvalue. If the second and third operands
1381  //   do not have the same type, and either has (cv) class type, ...
1382  if (!Same && (LTy->isRecordType() || RTy->isRecordType())) {
1383    //   ... overload resolution is used to determine the conversions (if any)
1384    //   to be applied to the operands. If the overload resolution fails, the
1385    //   program is ill-formed.
1386    if (FindConditionalOverload(*this, LHS, RHS, QuestionLoc))
1387      return QualType();
1388  }
1389
1390  // C++0x 5.16p6
1391  //   LValue-to-rvalue, array-to-pointer, and function-to-pointer standard
1392  //   conversions are performed on the second and third operands.
1393  DefaultFunctionArrayConversion(LHS);
1394  DefaultFunctionArrayConversion(RHS);
1395  LTy = LHS->getType();
1396  RTy = RHS->getType();
1397
1398  //   After those conversions, one of the following shall hold:
1399  //   -- The second and third operands have the same type; the result
1400  //      is of that type.
1401  if (Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy))
1402    return LTy;
1403
1404  //   -- The second and third operands have arithmetic or enumeration type;
1405  //      the usual arithmetic conversions are performed to bring them to a
1406  //      common type, and the result is of that type.
1407  if (LTy->isArithmeticType() && RTy->isArithmeticType()) {
1408    UsualArithmeticConversions(LHS, RHS);
1409    return LHS->getType();
1410  }
1411
1412  //   -- The second and third operands have pointer type, or one has pointer
1413  //      type and the other is a null pointer constant; pointer conversions
1414  //      and qualification conversions are performed to bring them to their
1415  //      composite pointer type. The result is of the composite pointer type.
1416  QualType Composite = FindCompositePointerType(LHS, RHS);
1417  if (!Composite.isNull())
1418    return Composite;
1419
1420  // Fourth bullet is same for pointers-to-member. However, the possible
1421  // conversions are far more limited: we have null-to-pointer, upcast of
1422  // containing class, and second-level cv-ness.
1423  // cv-ness is not a union, but must match one of the two operands. (Which,
1424  // frankly, is stupid.)
1425  const MemberPointerType *LMemPtr = LTy->getAs<MemberPointerType>();
1426  const MemberPointerType *RMemPtr = RTy->getAs<MemberPointerType>();
1427  if (LMemPtr && RHS->isNullPointerConstant(Context)) {
1428    ImpCastExprToType(RHS, LTy);
1429    return LTy;
1430  }
1431  if (RMemPtr && LHS->isNullPointerConstant(Context)) {
1432    ImpCastExprToType(LHS, RTy);
1433    return RTy;
1434  }
1435  if (LMemPtr && RMemPtr) {
1436    QualType LPointee = LMemPtr->getPointeeType();
1437    QualType RPointee = RMemPtr->getPointeeType();
1438    // First, we check that the unqualified pointee type is the same. If it's
1439    // not, there's no conversion that will unify the two pointers.
1440    if (Context.getCanonicalType(LPointee).getUnqualifiedType() ==
1441        Context.getCanonicalType(RPointee).getUnqualifiedType()) {
1442      // Second, we take the greater of the two cv qualifications. If neither
1443      // is greater than the other, the conversion is not possible.
1444      unsigned Q = LPointee.getCVRQualifiers() | RPointee.getCVRQualifiers();
1445      if (Q == LPointee.getCVRQualifiers() || Q == RPointee.getCVRQualifiers()){
1446        // Third, we check if either of the container classes is derived from
1447        // the other.
1448        QualType LContainer(LMemPtr->getClass(), 0);
1449        QualType RContainer(RMemPtr->getClass(), 0);
1450        QualType MoreDerived;
1451        if (Context.getCanonicalType(LContainer) ==
1452            Context.getCanonicalType(RContainer))
1453          MoreDerived = LContainer;
1454        else if (IsDerivedFrom(LContainer, RContainer))
1455          MoreDerived = LContainer;
1456        else if (IsDerivedFrom(RContainer, LContainer))
1457          MoreDerived = RContainer;
1458
1459        if (!MoreDerived.isNull()) {
1460          // The type 'Q Pointee (MoreDerived::*)' is the common type.
1461          // We don't use ImpCastExprToType here because this could still fail
1462          // for ambiguous or inaccessible conversions.
1463          QualType Common = Context.getMemberPointerType(
1464            LPointee.getQualifiedType(Q), MoreDerived.getTypePtr());
1465          if (PerformImplicitConversion(LHS, Common, "converting"))
1466            return QualType();
1467          if (PerformImplicitConversion(RHS, Common, "converting"))
1468            return QualType();
1469          return Common;
1470        }
1471      }
1472    }
1473  }
1474
1475  Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
1476    << LHS->getType() << RHS->getType()
1477    << LHS->getSourceRange() << RHS->getSourceRange();
1478  return QualType();
1479}
1480
1481/// \brief Find a merged pointer type and convert the two expressions to it.
1482///
1483/// This finds the composite pointer type for @p E1 and @p E2 according to
1484/// C++0x 5.9p2. It converts both expressions to this type and returns it.
1485/// It does not emit diagnostics.
1486QualType Sema::FindCompositePointerType(Expr *&E1, Expr *&E2) {
1487  assert(getLangOptions().CPlusPlus && "This function assumes C++");
1488  QualType T1 = E1->getType(), T2 = E2->getType();
1489  if(!T1->isAnyPointerType() && !T2->isAnyPointerType())
1490    return QualType();
1491
1492  // C++0x 5.9p2
1493  //   Pointer conversions and qualification conversions are performed on
1494  //   pointer operands to bring them to their composite pointer type. If
1495  //   one operand is a null pointer constant, the composite pointer type is
1496  //   the type of the other operand.
1497  if (E1->isNullPointerConstant(Context)) {
1498    ImpCastExprToType(E1, T2);
1499    return T2;
1500  }
1501  if (E2->isNullPointerConstant(Context)) {
1502    ImpCastExprToType(E2, T1);
1503    return T1;
1504  }
1505  // Now both have to be pointers.
1506  if(!T1->isPointerType() || !T2->isPointerType())
1507    return QualType();
1508
1509  //   Otherwise, of one of the operands has type "pointer to cv1 void," then
1510  //   the other has type "pointer to cv2 T" and the composite pointer type is
1511  //   "pointer to cv12 void," where cv12 is the union of cv1 and cv2.
1512  //   Otherwise, the composite pointer type is a pointer type similar to the
1513  //   type of one of the operands, with a cv-qualification signature that is
1514  //   the union of the cv-qualification signatures of the operand types.
1515  // In practice, the first part here is redundant; it's subsumed by the second.
1516  // What we do here is, we build the two possible composite types, and try the
1517  // conversions in both directions. If only one works, or if the two composite
1518  // types are the same, we have succeeded.
1519  llvm::SmallVector<unsigned, 4> QualifierUnion;
1520  QualType Composite1 = T1, Composite2 = T2;
1521  const PointerType *Ptr1, *Ptr2;
1522  while ((Ptr1 = Composite1->getAs<PointerType>()) &&
1523         (Ptr2 = Composite2->getAs<PointerType>())) {
1524    Composite1 = Ptr1->getPointeeType();
1525    Composite2 = Ptr2->getPointeeType();
1526    QualifierUnion.push_back(
1527      Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers());
1528  }
1529  // Rewrap the composites as pointers with the union CVRs.
1530  for (llvm::SmallVector<unsigned, 4>::iterator I = QualifierUnion.begin(),
1531       E = QualifierUnion.end(); I != E; ++I) {
1532    Composite1 = Context.getPointerType(Composite1.getQualifiedType(*I));
1533    Composite2 = Context.getPointerType(Composite2.getQualifiedType(*I));
1534  }
1535
1536  ImplicitConversionSequence E1ToC1 = TryImplicitConversion(E1, Composite1);
1537  ImplicitConversionSequence E2ToC1 = TryImplicitConversion(E2, Composite1);
1538  ImplicitConversionSequence E1ToC2, E2ToC2;
1539  E1ToC2.ConversionKind = ImplicitConversionSequence::BadConversion;
1540  E2ToC2.ConversionKind = ImplicitConversionSequence::BadConversion;
1541  if (Context.getCanonicalType(Composite1) !=
1542      Context.getCanonicalType(Composite2)) {
1543    E1ToC2 = TryImplicitConversion(E1, Composite2);
1544    E2ToC2 = TryImplicitConversion(E2, Composite2);
1545  }
1546
1547  bool ToC1Viable = E1ToC1.ConversionKind !=
1548                      ImplicitConversionSequence::BadConversion
1549                 && E2ToC1.ConversionKind !=
1550                      ImplicitConversionSequence::BadConversion;
1551  bool ToC2Viable = E1ToC2.ConversionKind !=
1552                      ImplicitConversionSequence::BadConversion
1553                 && E2ToC2.ConversionKind !=
1554                      ImplicitConversionSequence::BadConversion;
1555  if (ToC1Viable && !ToC2Viable) {
1556    if (!PerformImplicitConversion(E1, Composite1, E1ToC1, "converting") &&
1557        !PerformImplicitConversion(E2, Composite1, E2ToC1, "converting"))
1558      return Composite1;
1559  }
1560  if (ToC2Viable && !ToC1Viable) {
1561    if (!PerformImplicitConversion(E1, Composite2, E1ToC2, "converting") &&
1562        !PerformImplicitConversion(E2, Composite2, E2ToC2, "converting"))
1563      return Composite2;
1564  }
1565  return QualType();
1566}
1567
1568Sema::OwningExprResult Sema::MaybeBindToTemporary(Expr *E) {
1569  const RecordType *RT = E->getType()->getAs<RecordType>();
1570  if (!RT)
1571    return Owned(E);
1572
1573  CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1574  if (RD->hasTrivialDestructor())
1575    return Owned(E);
1576
1577  CXXTemporary *Temp = CXXTemporary::Create(Context,
1578                                            RD->getDestructor(Context));
1579  ExprTemporaries.push_back(Temp);
1580  if (CXXDestructorDecl *Destructor =
1581        const_cast<CXXDestructorDecl*>(RD->getDestructor(Context)))
1582    MarkDeclarationReferenced(E->getExprLoc(), Destructor);
1583  // FIXME: Add the temporary to the temporaries vector.
1584  return Owned(CXXBindTemporaryExpr::Create(Context, Temp, E));
1585}
1586
1587Expr *Sema::MaybeCreateCXXExprWithTemporaries(Expr *SubExpr,
1588                                              bool ShouldDestroyTemps) {
1589  assert(SubExpr && "sub expression can't be null!");
1590
1591  if (ExprTemporaries.empty())
1592    return SubExpr;
1593
1594  Expr *E = CXXExprWithTemporaries::Create(Context, SubExpr,
1595                                           &ExprTemporaries[0],
1596                                           ExprTemporaries.size(),
1597                                           ShouldDestroyTemps);
1598  ExprTemporaries.clear();
1599
1600  return E;
1601}
1602
1603Sema::OwningExprResult Sema::ActOnFinishFullExpr(ExprArg Arg) {
1604  Expr *FullExpr = Arg.takeAs<Expr>();
1605  if (FullExpr)
1606    FullExpr = MaybeCreateCXXExprWithTemporaries(FullExpr,
1607                                                 /*ShouldDestroyTemps=*/true);
1608
1609  return Owned(FullExpr);
1610}
1611