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