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