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