lib/Sema/SemaExprCXX.cpp

   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 "Sema.h"
  15 #include "SemaInit.h"
  16 #include "Lookup.h"
  17 #include "clang/AST/ASTContext.h"
  18 #include "clang/AST/CXXInheritance.h"
  19 #include "clang/AST/ExprCXX.h"
  20 #include "clang/Basic/PartialDiagnostic.h"
  21 #include "clang/Basic/TargetInfo.h"
  22 #include "clang/Lex/Preprocessor.h"
  23 #include "clang/Parse/DeclSpec.h"
  24 #include "llvm/ADT/STLExtras.h"
  25 using namespace clang;
  26
  27 /// ActOnCXXTypeidOfType - Parse typeid( type-id ).
  28 Action::OwningExprResult
  29 Sema::ActOnCXXTypeid(SourceLocation OpLoc, SourceLocation LParenLoc,
  30                      bool isType, void *TyOrExpr, SourceLocation RParenLoc) {
  31   if (!StdNamespace)
  32     return ExprError(Diag(OpLoc, diag::err_need_header_before_typeid));
  33
  34   if (isType) {
  35     // C++ [expr.typeid]p4:
  36     //   The top-level cv-qualifiers of the lvalue expression or the type-id
  37     //   that is the operand of typeid are always ignored.
  38     // FIXME: Preserve type source info.
  39     // FIXME: Preserve the type before we stripped the cv-qualifiers?
  40     QualType T = GetTypeFromParser(TyOrExpr);
  41     if (T.isNull())
  42       return ExprError();
  43
  44     // C++ [expr.typeid]p4:
  45     //   If the type of the type-id is a class type or a reference to a class
  46     //   type, the class shall be completely-defined.
  47     QualType CheckT = T;
  48     if (const ReferenceType *RefType = CheckT->getAs<ReferenceType>())
  49       CheckT = RefType->getPointeeType();
  50
  51     if (CheckT->getAs<RecordType>() &&
  52         RequireCompleteType(OpLoc, CheckT, diag::err_incomplete_typeid))
  53       return ExprError();
  54
  55     TyOrExpr = T.getUnqualifiedType().getAsOpaquePtr();
  56   }
  57
  58   IdentifierInfo *TypeInfoII = &PP.getIdentifierTable().get("type_info");
  59   LookupResult R(*this, TypeInfoII, SourceLocation(), LookupTagName);
  60   LookupQualifiedName(R, StdNamespace);
  61   RecordDecl *TypeInfoRecordDecl = R.getAsSingle<RecordDecl>();
  62   if (!TypeInfoRecordDecl)
  63     return ExprError(Diag(OpLoc, diag::err_need_header_before_typeid));
  64
  65   QualType TypeInfoType = Context.getTypeDeclType(TypeInfoRecordDecl);
  66
  67   if (!isType) {
  68     bool isUnevaluatedOperand = true;
  69     Expr *E = static_cast<Expr *>(TyOrExpr);
  70     if (E && !E->isTypeDependent()) {
  71       QualType T = E->getType();
  72       if (const RecordType *RecordT = T->getAs<RecordType>()) {
  73         CXXRecordDecl *RecordD = cast<CXXRecordDecl>(RecordT->getDecl());
  74         // C++ [expr.typeid]p3:
  75         //   When typeid is applied to an expression other than an lvalue of a
  76         //   polymorphic class type [...] [the] expression is an unevaluated
  77         //   operand. [...]
  78         if (RecordD->isPolymorphic() && E->isLvalue(Context) == Expr::LV_Valid)
  79           isUnevaluatedOperand = false;
  80         else {
  81           // C++ [expr.typeid]p3:
  82           //   [...] If the type of the expression is a class type, the class
  83           //   shall be completely-defined.
  84           if (RequireCompleteType(OpLoc, T, diag::err_incomplete_typeid))
  85             return ExprError();
  86         }
  87       }
  88
  89       // C++ [expr.typeid]p4:
  90       //   [...] If the type of the type-id is a reference to a possibly
  91       //   cv-qualified type, the result of the typeid expression refers to a
  92       //   std::type_info object representing the cv-unqualified referenced
  93       //   type.
  94       if (T.hasQualifiers()) {
  95         ImpCastExprToType(E, T.getUnqualifiedType(), CastExpr::CK_NoOp,
  96                           E->isLvalue(Context));
  97         TyOrExpr = E;
  98       }
  99     }
 100
 101     // If this is an unevaluated operand, clear out the set of
 102     // declaration references we have been computing and eliminate any
 103     // temporaries introduced in its computation.
 104     if (isUnevaluatedOperand)
 105       ExprEvalContexts.back().Context = Unevaluated;
 106   }
 107
 108   return Owned(new (Context) CXXTypeidExpr(isType, TyOrExpr,
 109                                            TypeInfoType.withConst(),
 110                                            SourceRange(OpLoc, RParenLoc)));
 111 }
 112
 113 /// ActOnCXXBoolLiteral - Parse {true,false} literals.
 114 Action::OwningExprResult
 115 Sema::ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind) {
 116   assert((Kind == tok::kw_true || Kind == tok::kw_false) &&
 117          "Unknown C++ Boolean value!");
 118   return Owned(new (Context) CXXBoolLiteralExpr(Kind == tok::kw_true,
 119                                                 Context.BoolTy, OpLoc));
 120 }
 121
 122 /// ActOnCXXNullPtrLiteral - Parse 'nullptr'.
 123 Action::OwningExprResult
 124 Sema::ActOnCXXNullPtrLiteral(SourceLocation Loc) {
 125   return Owned(new (Context) CXXNullPtrLiteralExpr(Context.NullPtrTy, Loc));
 126 }
 127
 128 /// ActOnCXXThrow - Parse throw expressions.
 129 Action::OwningExprResult
 130 Sema::ActOnCXXThrow(SourceLocation OpLoc, ExprArg E) {
 131   Expr *Ex = E.takeAs<Expr>();
 132   if (Ex && !Ex->isTypeDependent() && CheckCXXThrowOperand(OpLoc, Ex))
 133     return ExprError();
 134   return Owned(new (Context) CXXThrowExpr(Ex, Context.VoidTy, OpLoc));
 135 }
 136
 137 /// CheckCXXThrowOperand - Validate the operand of a throw.
 138 bool Sema::CheckCXXThrowOperand(SourceLocation ThrowLoc, Expr *&E) {
 139   // C++ [except.throw]p3:
 140   //   A throw-expression initializes a temporary object, called the exception
 141   //   object, the type of which is determined by removing any top-level
 142   //   cv-qualifiers from the static type of the operand of throw and adjusting
 143   //   the type from "array of T" or "function returning T" to "pointer to T"
 144   //   or "pointer to function returning T", [...]
 145   if (E->getType().hasQualifiers())
 146     ImpCastExprToType(E, E->getType().getUnqualifiedType(), CastExpr::CK_NoOp,
 147                       E->isLvalue(Context) == Expr::LV_Valid);
 148
 149   DefaultFunctionArrayConversion(E);
 150
 151   //   If the type of the exception would be an incomplete type or a pointer
 152   //   to an incomplete type other than (cv) void the program is ill-formed.
 153   QualType Ty = E->getType();
 154   int isPointer = 0;
 155   if (const PointerType* Ptr = Ty->getAs<PointerType>()) {
 156     Ty = Ptr->getPointeeType();
 157     isPointer = 1;
 158   }
 159   if (!isPointer || !Ty->isVoidType()) {
 160     if (RequireCompleteType(ThrowLoc, Ty,
 161                             PDiag(isPointer ? diag::err_throw_incomplete_ptr
 162                                             : diag::err_throw_incomplete)
 163                               << E->getSourceRange()))
 164       return true;
 165   }
 166
 167   // FIXME: Construct a temporary here.
 168   return false;
 169 }
 170
 171 Action::OwningExprResult Sema::ActOnCXXThis(SourceLocation ThisLoc) {
 172   /// C++ 9.3.2: In the body of a non-static member function, the keyword this
 173   /// is a non-lvalue expression whose value is the address of the object for
 174   /// which the function is called.
 175
 176   if (!isa<FunctionDecl>(CurContext))
 177     return ExprError(Diag(ThisLoc, diag::err_invalid_this_use));
 178
 179   if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(CurContext))
 180     if (MD->isInstance())
 181       return Owned(new (Context) CXXThisExpr(ThisLoc,
 182                                              MD->getThisType(Context)));
 183
 184   return ExprError(Diag(ThisLoc, diag::err_invalid_this_use));
 185 }
 186
 187 /// ActOnCXXTypeConstructExpr - Parse construction of a specified type.
 188 /// Can be interpreted either as function-style casting ("int(x)")
 189 /// or class type construction ("ClassType(x,y,z)")
 190 /// or creation of a value-initialized type ("int()").
 191 Action::OwningExprResult
 192 Sema::ActOnCXXTypeConstructExpr(SourceRange TypeRange, TypeTy *TypeRep,
 193                                 SourceLocation LParenLoc,
 194                                 MultiExprArg exprs,
 195                                 SourceLocation *CommaLocs,
 196                                 SourceLocation RParenLoc) {
 197   assert(TypeRep && "Missing type!");
 198   // FIXME: Preserve type source info.
 199   QualType Ty = GetTypeFromParser(TypeRep);
 200   unsigned NumExprs = exprs.size();
 201   Expr **Exprs = (Expr**)exprs.get();
 202   SourceLocation TyBeginLoc = TypeRange.getBegin();
 203   SourceRange FullRange = SourceRange(TyBeginLoc, RParenLoc);
 204
 205   if (Ty->isDependentType() ||
 206       CallExpr::hasAnyTypeDependentArguments(Exprs, NumExprs)) {
 207     exprs.release();
 208
 209     return Owned(CXXUnresolvedConstructExpr::Create(Context,
 210                                                     TypeRange.getBegin(), Ty,
 211                                                     LParenLoc,
 212                                                     Exprs, NumExprs,
 213                                                     RParenLoc));
 214   }
 215
 216   if (Ty->isArrayType())
 217     return ExprError(Diag(TyBeginLoc,
 218                           diag::err_value_init_for_array_type) << FullRange);
 219   if (!Ty->isVoidType() &&
 220       RequireCompleteType(TyBeginLoc, Ty,
 221                           PDiag(diag::err_invalid_incomplete_type_use)
 222                             << FullRange))
 223     return ExprError();
 224
 225   if (RequireNonAbstractType(TyBeginLoc, Ty,
 226                              diag::err_allocation_of_abstract_type))
 227     return ExprError();
 228
 229
 230   // C++ [expr.type.conv]p1:
 231   // If the expression list is a single expression, the type conversion
 232   // expression is equivalent (in definedness, and if defined in meaning) to the
 233   // corresponding cast expression.
 234   //
 235   if (NumExprs == 1) {
 236     CastExpr::CastKind Kind = CastExpr::CK_Unknown;
 237     CXXMethodDecl *Method = 0;
 238     if (CheckCastTypes(TypeRange, Ty, Exprs[0], Kind, Method,
 239                        /*FunctionalStyle=*/true))
 240       return ExprError();
 241
 242     exprs.release();
 243     if (Method) {
 244       OwningExprResult CastArg
 245         = BuildCXXCastArgument(TypeRange.getBegin(), Ty.getNonReferenceType(),
 246                                Kind, Method, Owned(Exprs[0]));
 247       if (CastArg.isInvalid())
 248         return ExprError();
 249
 250       Exprs[0] = CastArg.takeAs<Expr>();
 251     }
 252
 253     return Owned(new (Context) CXXFunctionalCastExpr(Ty.getNonReferenceType(),
 254                                                      Ty, TyBeginLoc, Kind,
 255                                                      Exprs[0], RParenLoc));
 256   }
 257
 258   if (const RecordType *RT = Ty->getAs<RecordType>()) {
 259     CXXRecordDecl *Record = cast<CXXRecordDecl>(RT->getDecl());
 260
 261     if (NumExprs > 1 || !Record->hasTrivialConstructor() ||
 262         !Record->hasTrivialDestructor()) {
 263       ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(*this);
 264
 265       CXXConstructorDecl *Constructor
 266         = PerformInitializationByConstructor(Ty, move(exprs),
 267                                              TypeRange.getBegin(),
 268                                              SourceRange(TypeRange.getBegin(),
 269                                                          RParenLoc),
 270                                              DeclarationName(),
 271                          InitializationKind::CreateDirect(TypeRange.getBegin(),
 272                                                           LParenLoc,
 273                                                           RParenLoc),
 274                                              ConstructorArgs);
 275
 276       if (!Constructor)
 277         return ExprError();
 278
 279       OwningExprResult Result =
 280         BuildCXXTemporaryObjectExpr(Constructor, Ty, TyBeginLoc,
 281                                     move_arg(ConstructorArgs), RParenLoc);
 282       if (Result.isInvalid())
 283         return ExprError();
 284
 285       return MaybeBindToTemporary(Result.takeAs<Expr>());
 286     }
 287
 288     // Fall through to value-initialize an object of class type that
 289     // doesn't have a user-declared default constructor.
 290   }
 291
 292   // C++ [expr.type.conv]p1:
 293   // If the expression list specifies more than a single value, the type shall
 294   // be a class with a suitably declared constructor.
 295   //
 296   if (NumExprs > 1)
 297     return ExprError(Diag(CommaLocs[0],
 298                           diag::err_builtin_func_cast_more_than_one_arg)
 299       << FullRange);
 300
 301   assert(NumExprs == 0 && "Expected 0 expressions");
 302   // C++ [expr.type.conv]p2:
 303   // The expression T(), where T is a simple-type-specifier for a non-array
 304   // complete object type or the (possibly cv-qualified) void type, creates an
 305   // rvalue of the specified type, which is value-initialized.
 306   //
 307   exprs.release();
 308   return Owned(new (Context) CXXZeroInitValueExpr(Ty, TyBeginLoc, RParenLoc));
 309 }
 310
 311
 312 /// ActOnCXXNew - Parsed a C++ 'new' expression (C++ 5.3.4), as in e.g.:
 313 /// @code new (memory) int[size][4] @endcode
 314 /// or
 315 /// @code ::new Foo(23, "hello") @endcode
 316 /// For the interpretation of this heap of arguments, consult the base version.
 317 Action::OwningExprResult
 318 Sema::ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal,
 319                   SourceLocation PlacementLParen, MultiExprArg PlacementArgs,
 320                   SourceLocation PlacementRParen, bool ParenTypeId,
 321                   Declarator &D, SourceLocation ConstructorLParen,
 322                   MultiExprArg ConstructorArgs,
 323                   SourceLocation ConstructorRParen) {
 324   Expr *ArraySize = 0;
 325   // If the specified type is an array, unwrap it and save the expression.
 326   if (D.getNumTypeObjects() > 0 &&
 327       D.getTypeObject(0).Kind == DeclaratorChunk::Array) {
 328     DeclaratorChunk &Chunk = D.getTypeObject(0);
 329     if (Chunk.Arr.hasStatic)
 330       return ExprError(Diag(Chunk.Loc, diag::err_static_illegal_in_new)
 331         << D.getSourceRange());
 332     if (!Chunk.Arr.NumElts)
 333       return ExprError(Diag(Chunk.Loc, diag::err_array_new_needs_size)
 334         << D.getSourceRange());
 335
 336     if (ParenTypeId) {
 337       // Can't have dynamic array size when the type-id is in parentheses.
 338       Expr *NumElts = (Expr *)Chunk.Arr.NumElts;
 339       if (!NumElts->isTypeDependent() && !NumElts->isValueDependent() &&
 340           !NumElts->isIntegerConstantExpr(Context)) {
 341         Diag(D.getTypeObject(0).Loc, diag::err_new_paren_array_nonconst)
 342           << NumElts->getSourceRange();
 343         return ExprError();
 344       }
 345     }
 346
 347     ArraySize = static_cast<Expr*>(Chunk.Arr.NumElts);
 348     D.DropFirstTypeObject();
 349   }
 350
 351   // Every dimension shall be of constant size.
 352   if (ArraySize) {
 353     for (unsigned I = 0, N = D.getNumTypeObjects(); I < N; ++I) {
 354       if (D.getTypeObject(I).Kind != DeclaratorChunk::Array)
 355         break;
 356
 357       DeclaratorChunk::ArrayTypeInfo &Array = D.getTypeObject(I).Arr;
 358       if (Expr *NumElts = (Expr *)Array.NumElts) {
 359         if (!NumElts->isTypeDependent() && !NumElts->isValueDependent() &&
 360             !NumElts->isIntegerConstantExpr(Context)) {
 361           Diag(D.getTypeObject(I).Loc, diag::err_new_array_nonconst)
 362             << NumElts->getSourceRange();
 363           return ExprError();
 364         }
 365       }
 366     }
 367   }
 368
 369   //FIXME: Store TypeSourceInfo in CXXNew expression.
 370   TypeSourceInfo *TInfo = 0;
 371   QualType AllocType = GetTypeForDeclarator(D, /*Scope=*/0, &TInfo);
 372   if (D.isInvalidType())
 373     return ExprError();
 374
 375   return BuildCXXNew(StartLoc, UseGlobal,
 376                      PlacementLParen,
 377                      move(PlacementArgs),
 378                      PlacementRParen,
 379                      ParenTypeId,
 380                      AllocType,
 381                      D.getSourceRange().getBegin(),
 382                      D.getSourceRange(),
 383                      Owned(ArraySize),
 384                      ConstructorLParen,
 385                      move(ConstructorArgs),
 386                      ConstructorRParen);
 387 }
 388
 389 Sema::OwningExprResult
 390 Sema::BuildCXXNew(SourceLocation StartLoc, bool UseGlobal,
 391                   SourceLocation PlacementLParen,
 392                   MultiExprArg PlacementArgs,
 393                   SourceLocation PlacementRParen,
 394                   bool ParenTypeId,
 395                   QualType AllocType,
 396                   SourceLocation TypeLoc,
 397                   SourceRange TypeRange,
 398                   ExprArg ArraySizeE,
 399                   SourceLocation ConstructorLParen,
 400                   MultiExprArg ConstructorArgs,
 401                   SourceLocation ConstructorRParen) {
 402   if (CheckAllocatedType(AllocType, TypeLoc, TypeRange))
 403     return ExprError();
 404
 405   QualType ResultType = Context.getPointerType(AllocType);
 406
 407   // That every array dimension except the first is constant was already
 408   // checked by the type check above.
 409
 410   // C++ 5.3.4p6: "The expression in a direct-new-declarator shall have integral
 411   //   or enumeration type with a non-negative value."
 412   Expr *ArraySize = (Expr *)ArraySizeE.get();
 413   if (ArraySize && !ArraySize->isTypeDependent()) {
 414     QualType SizeType = ArraySize->getType();
 415     if (!SizeType->isIntegralType() && !SizeType->isEnumeralType())
 416       return ExprError(Diag(ArraySize->getSourceRange().getBegin(),
 417                             diag::err_array_size_not_integral)
 418         << SizeType << ArraySize->getSourceRange());
 419     // Let's see if this is a constant < 0. If so, we reject it out of hand.
 420     // We don't care about special rules, so we tell the machinery it's not
 421     // evaluated - it gives us a result in more cases.
 422     if (!ArraySize->isValueDependent()) {
 423       llvm::APSInt Value;
 424       if (ArraySize->isIntegerConstantExpr(Value, Context, 0, false)) {
 425         if (Value < llvm::APSInt(
 426                         llvm::APInt::getNullValue(Value.getBitWidth()),
 427                                  Value.isUnsigned()))
 428           return ExprError(Diag(ArraySize->getSourceRange().getBegin(),
 429                            diag::err_typecheck_negative_array_size)
 430             << ArraySize->getSourceRange());
 431       }
 432     }
 433
 434     ImpCastExprToType(ArraySize, Context.getSizeType(),
 435                       CastExpr::CK_IntegralCast);
 436   }
 437
 438   FunctionDecl *OperatorNew = 0;
 439   FunctionDecl *OperatorDelete = 0;
 440   Expr **PlaceArgs = (Expr**)PlacementArgs.get();
 441   unsigned NumPlaceArgs = PlacementArgs.size();
 442
 443   if (!AllocType->isDependentType() &&
 444       !Expr::hasAnyTypeDependentArguments(PlaceArgs, NumPlaceArgs) &&
 445       FindAllocationFunctions(StartLoc,
 446                               SourceRange(PlacementLParen, PlacementRParen),
 447                               UseGlobal, AllocType, ArraySize, PlaceArgs,
 448                               NumPlaceArgs, OperatorNew, OperatorDelete))
 449     return ExprError();
 450   llvm::SmallVector<Expr *, 8> AllPlaceArgs;
 451   if (OperatorNew) {
 452     // Add default arguments, if any.
 453     const FunctionProtoType *Proto =
 454       OperatorNew->getType()->getAs<FunctionProtoType>();
 455     VariadicCallType CallType =
 456       Proto->isVariadic() ? VariadicFunction : VariadicDoesNotApply;
 457     bool Invalid = GatherArgumentsForCall(PlacementLParen, OperatorNew,
 458                                           Proto, 1, PlaceArgs, NumPlaceArgs,
 459                                           AllPlaceArgs, CallType);
 460     if (Invalid)
 461       return ExprError();
 462
 463     NumPlaceArgs = AllPlaceArgs.size();
 464     if (NumPlaceArgs > 0)
 465       PlaceArgs = &AllPlaceArgs[0];
 466   }
 467
 468   bool Init = ConstructorLParen.isValid();
 469   // --- Choosing a constructor ---
 470   CXXConstructorDecl *Constructor = 0;
 471   Expr **ConsArgs = (Expr**)ConstructorArgs.get();
 472   unsigned NumConsArgs = ConstructorArgs.size();
 473   ASTOwningVector<&ActionBase::DeleteExpr> ConvertedConstructorArgs(*this);
 474
 475   if (!AllocType->isDependentType() &&
 476       !Expr::hasAnyTypeDependentArguments(ConsArgs, NumConsArgs)) {
 477     // C++0x [expr.new]p15:
 478     //   A new-expression that creates an object of type T initializes that
 479     //   object as follows:
 480     InitializationKind Kind
 481     //     - If the new-initializer is omitted, the object is default-
 482     //       initialized (8.5); if no initialization is performed,
 483     //       the object has indeterminate value
 484       = !Init? InitializationKind::CreateDefault(TypeLoc)
 485     //     - Otherwise, the new-initializer is interpreted according to the
 486     //       initialization rules of 8.5 for direct-initialization.
 487              : InitializationKind::CreateDirect(TypeLoc,
 488                                                 ConstructorLParen,
 489                                                 ConstructorRParen);
 490
 491     InitializedEntity Entity
 492       = InitializedEntity::InitializeNew(StartLoc, AllocType);
 493     InitializationSequence InitSeq(*this, Entity, Kind, ConsArgs, NumConsArgs);
 494     OwningExprResult FullInit = InitSeq.Perform(*this, Entity, Kind,
 495                                                 move(ConstructorArgs));
 496     if (FullInit.isInvalid())
 497       return ExprError();
 498
 499     // FullInit is our initializer; walk through it to determine if it's a
 500     // constructor call, which CXXNewExpr handles directly.
 501     if (Expr *FullInitExpr = (Expr *)FullInit.get()) {
 502       if (CXXBindTemporaryExpr *Binder
 503             = dyn_cast<CXXBindTemporaryExpr>(FullInitExpr))
 504         FullInitExpr = Binder->getSubExpr();
 505       if (CXXConstructExpr *Construct
 506                     = dyn_cast<CXXConstructExpr>(FullInitExpr)) {
 507         Constructor = Construct->getConstructor();
 508         for (CXXConstructExpr::arg_iterator A = Construct->arg_begin(),
 509                                          AEnd = Construct->arg_end();
 510              A != AEnd; ++A)
 511           ConvertedConstructorArgs.push_back(A->Retain());
 512       } else {
 513         // Take the converted initializer.
 514         ConvertedConstructorArgs.push_back(FullInit.release());
 515       }
 516     } else {
 517       // No initialization required.
 518     }
 519
 520     // Take the converted arguments and use them for the new expression.
 521     NumConsArgs = ConvertedConstructorArgs.size();
 522     ConsArgs = (Expr **)ConvertedConstructorArgs.take();
 523   }
 524
 525   // FIXME: Also check that the destructor is accessible. (C++ 5.3.4p16)
 526
 527   PlacementArgs.release();
 528   ConstructorArgs.release();
 529   ArraySizeE.release();
 530   return Owned(new (Context) CXXNewExpr(UseGlobal, OperatorNew, PlaceArgs,
 531                         NumPlaceArgs, ParenTypeId, ArraySize, Constructor, Init,
 532                         ConsArgs, NumConsArgs, OperatorDelete, ResultType,
 533                         StartLoc, Init ? ConstructorRParen : SourceLocation()));
 534 }
 535
 536 /// CheckAllocatedType - Checks that a type is suitable as the allocated type
 537 /// in a new-expression.
 538 /// dimension off and stores the size expression in ArraySize.
 539 bool Sema::CheckAllocatedType(QualType AllocType, SourceLocation Loc,
 540                               SourceRange R) {
 541   // C++ 5.3.4p1: "[The] type shall be a complete object type, but not an
 542   //   abstract class type or array thereof.
 543   if (AllocType->isFunctionType())
 544     return Diag(Loc, diag::err_bad_new_type)
 545       << AllocType << 0 << R;
 546   else if (AllocType->isReferenceType())
 547     return Diag(Loc, diag::err_bad_new_type)
 548       << AllocType << 1 << R;
 549   else if (!AllocType->isDependentType() &&
 550            RequireCompleteType(Loc, AllocType,
 551                                PDiag(diag::err_new_incomplete_type)
 552                                  << R))
 553     return true;
 554   else if (RequireNonAbstractType(Loc, AllocType,
 555                                   diag::err_allocation_of_abstract_type))
 556     return true;
 557
 558   return false;
 559 }
 560
 561 /// FindAllocationFunctions - Finds the overloads of operator new and delete
 562 /// that are appropriate for the allocation.
 563 bool Sema::FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
 564                                    bool UseGlobal, QualType AllocType,
 565                                    bool IsArray, Expr **PlaceArgs,
 566                                    unsigned NumPlaceArgs,
 567                                    FunctionDecl *&OperatorNew,
 568                                    FunctionDecl *&OperatorDelete) {
 569   // --- Choosing an allocation function ---
 570   // C++ 5.3.4p8 - 14 & 18
 571   // 1) If UseGlobal is true, only look in the global scope. Else, also look
 572   //   in the scope of the allocated class.
 573   // 2) If an array size is given, look for operator new[], else look for
 574   //   operator new.
 575   // 3) The first argument is always size_t. Append the arguments from the
 576   //   placement form.
 577   // FIXME: Also find the appropriate delete operator.
 578
 579   llvm::SmallVector<Expr*, 8> AllocArgs(1 + NumPlaceArgs);
 580   // We don't care about the actual value of this argument.
 581   // FIXME: Should the Sema create the expression and embed it in the syntax
 582   // tree? Or should the consumer just recalculate the value?
 583   IntegerLiteral Size(llvm::APInt::getNullValue(
 584                       Context.Target.getPointerWidth(0)),
 585                       Context.getSizeType(),
 586                       SourceLocation());
 587   AllocArgs[0] = &Size;
 588   std::copy(PlaceArgs, PlaceArgs + NumPlaceArgs, AllocArgs.begin() + 1);
 589
 590   DeclarationName NewName = Context.DeclarationNames.getCXXOperatorName(
 591                                         IsArray ? OO_Array_New : OO_New);
 592   if (AllocType->isRecordType() && !UseGlobal) {
 593     CXXRecordDecl *Record
 594       = cast<CXXRecordDecl>(AllocType->getAs<RecordType>()->getDecl());
 595     // FIXME: We fail to find inherited overloads.
 596     if (FindAllocationOverload(StartLoc, Range, NewName, &AllocArgs[0],
 597                           AllocArgs.size(), Record, /*AllowMissing=*/true,
 598                           OperatorNew))
 599       return true;
 600   }
 601   if (!OperatorNew) {
 602     // Didn't find a member overload. Look for a global one.
 603     DeclareGlobalNewDelete();
 604     DeclContext *TUDecl = Context.getTranslationUnitDecl();
 605     if (FindAllocationOverload(StartLoc, Range, NewName, &AllocArgs[0],
 606                           AllocArgs.size(), TUDecl, /*AllowMissing=*/false,
 607                           OperatorNew))
 608       return true;
 609   }
 610
 611   // FindAllocationOverload can change the passed in arguments, so we need to
 612   // copy them back.
 613   if (NumPlaceArgs > 0)
 614     std::copy(&AllocArgs[1], AllocArgs.end(), PlaceArgs);
 615
 616   return false;
 617 }
 618
 619 /// FindAllocationOverload - Find an fitting overload for the allocation
 620 /// function in the specified scope.
 621 bool Sema::FindAllocationOverload(SourceLocation StartLoc, SourceRange Range,
 622                                   DeclarationName Name, Expr** Args,
 623                                   unsigned NumArgs, DeclContext *Ctx,
 624                                   bool AllowMissing, FunctionDecl *&Operator) {
 625   LookupResult R(*this, Name, StartLoc, LookupOrdinaryName);
 626   LookupQualifiedName(R, Ctx);
 627   if (R.empty()) {
 628     if (AllowMissing)
 629       return false;
 630     return Diag(StartLoc, diag::err_ovl_no_viable_function_in_call)
 631       << Name << Range;
 632   }
 633
 634   // FIXME: handle ambiguity
 635
 636   OverloadCandidateSet Candidates;
 637   for (LookupResult::iterator Alloc = R.begin(), AllocEnd = R.end();
 638        Alloc != AllocEnd; ++Alloc) {
 639     // Even member operator new/delete are implicitly treated as
 640     // static, so don't use AddMemberCandidate.
 641     if (FunctionDecl *Fn =
 642           dyn_cast<FunctionDecl>((*Alloc)->getUnderlyingDecl())) {
 643       AddOverloadCandidate(Fn, Args, NumArgs, Candidates,
 644                            /*SuppressUserConversions=*/false);
 645       continue;
 646     }
 647
 648     // FIXME: Handle function templates
 649   }
 650
 651   // Do the resolution.
 652   OverloadCandidateSet::iterator Best;
 653   switch(BestViableFunction(Candidates, StartLoc, Best)) {
 654   case OR_Success: {
 655     // Got one!
 656     FunctionDecl *FnDecl = Best->Function;
 657     // The first argument is size_t, and the first parameter must be size_t,
 658     // too. This is checked on declaration and can be assumed. (It can't be
 659     // asserted on, though, since invalid decls are left in there.)
 660     // Whatch out for variadic allocator function.
 661     unsigned NumArgsInFnDecl = FnDecl->getNumParams();
 662     for (unsigned i = 0; (i < NumArgs && i < NumArgsInFnDecl); ++i) {
 663       if (PerformCopyInitialization(Args[i],
 664                                     FnDecl->getParamDecl(i)->getType(),
 665                                     AA_Passing))
 666         return true;
 667     }
 668     Operator = FnDecl;
 669     return false;
 670   }
 671
 672   case OR_No_Viable_Function:
 673     Diag(StartLoc, diag::err_ovl_no_viable_function_in_call)
 674       << Name << Range;
 675     PrintOverloadCandidates(Candidates, /*OnlyViable=*/false);
 676     return true;
 677
 678   case OR_Ambiguous:
 679     Diag(StartLoc, diag::err_ovl_ambiguous_call)
 680       << Name << Range;
 681     PrintOverloadCandidates(Candidates, /*OnlyViable=*/true);
 682     return true;
 683
 684   case OR_Deleted:
 685     Diag(StartLoc, diag::err_ovl_deleted_call)
 686       << Best->Function->isDeleted()
 687       << Name << Range;
 688     PrintOverloadCandidates(Candidates, /*OnlyViable=*/true);
 689     return true;
 690   }
 691   assert(false && "Unreachable, bad result from BestViableFunction");
 692   return true;
 693 }
 694
 695
 696 /// DeclareGlobalNewDelete - Declare the global forms of operator new and
 697 /// delete. These are:
 698 /// @code
 699 ///   void* operator new(std::size_t) throw(std::bad_alloc);
 700 ///   void* operator new[](std::size_t) throw(std::bad_alloc);
 701 ///   void operator delete(void *) throw();
 702 ///   void operator delete[](void *) throw();
 703 /// @endcode
 704 /// Note that the placement and nothrow forms of new are *not* implicitly
 705 /// declared. Their use requires including \<new\>.
 706 void Sema::DeclareGlobalNewDelete() {
 707   if (GlobalNewDeleteDeclared)
 708     return;
 709
 710   // C++ [basic.std.dynamic]p2:
 711   //   [...] The following allocation and deallocation functions (18.4) are
 712   //   implicitly declared in global scope in each translation unit of a
 713   //   program
 714   //
 715   //     void* operator new(std::size_t) throw(std::bad_alloc);
 716   //     void* operator new[](std::size_t) throw(std::bad_alloc);
 717   //     void  operator delete(void*) throw();
 718   //     void  operator delete[](void*) throw();
 719   //
 720   //   These implicit declarations introduce only the function names operator
 721   //   new, operator new[], operator delete, operator delete[].
 722   //
 723   // Here, we need to refer to std::bad_alloc, so we will implicitly declare
 724   // "std" or "bad_alloc" as necessary to form the exception specification.
 725   // However, we do not make these implicit declarations visible to name
 726   // lookup.
 727   if (!StdNamespace) {
 728     // The "std" namespace has not yet been defined, so build one implicitly.
 729     StdNamespace = NamespaceDecl::Create(Context,
 730                                          Context.getTranslationUnitDecl(),
 731                                          SourceLocation(),
 732                                          &PP.getIdentifierTable().get("std"));
 733     StdNamespace->setImplicit(true);
 734   }
 735
 736   if (!StdBadAlloc) {
 737     // The "std::bad_alloc" class has not yet been declared, so build it
 738     // implicitly.
 739     StdBadAlloc = CXXRecordDecl::Create(Context, TagDecl::TK_class,
 740                                         StdNamespace,
 741                                         SourceLocation(),
 742                                       &PP.getIdentifierTable().get("bad_alloc"),
 743                                         SourceLocation(), 0);
 744     StdBadAlloc->setImplicit(true);
 745   }
 746
 747   GlobalNewDeleteDeclared = true;
 748
 749   QualType VoidPtr = Context.getPointerType(Context.VoidTy);
 750   QualType SizeT = Context.getSizeType();
 751   bool AssumeSaneOperatorNew = getLangOptions().AssumeSaneOperatorNew;
 752
 753   DeclareGlobalAllocationFunction(
 754       Context.DeclarationNames.getCXXOperatorName(OO_New),
 755       VoidPtr, SizeT, AssumeSaneOperatorNew);
 756   DeclareGlobalAllocationFunction(
 757       Context.DeclarationNames.getCXXOperatorName(OO_Array_New),
 758       VoidPtr, SizeT, AssumeSaneOperatorNew);
 759   DeclareGlobalAllocationFunction(
 760       Context.DeclarationNames.getCXXOperatorName(OO_Delete),
 761       Context.VoidTy, VoidPtr);
 762   DeclareGlobalAllocationFunction(
 763       Context.DeclarationNames.getCXXOperatorName(OO_Array_Delete),
 764       Context.VoidTy, VoidPtr);
 765 }
 766
 767 /// DeclareGlobalAllocationFunction - Declares a single implicit global
 768 /// allocation function if it doesn't already exist.
 769 void Sema::DeclareGlobalAllocationFunction(DeclarationName Name,
 770                                            QualType Return, QualType Argument,
 771                                            bool AddMallocAttr) {
 772   DeclContext *GlobalCtx = Context.getTranslationUnitDecl();
 773
 774   // Check if this function is already declared.
 775   {
 776     DeclContext::lookup_iterator Alloc, AllocEnd;
 777     for (llvm::tie(Alloc, AllocEnd) = GlobalCtx->lookup(Name);
 778          Alloc != AllocEnd; ++Alloc) {
 779       // FIXME: Do we need to check for default arguments here?
 780       FunctionDecl *Func = cast<FunctionDecl>(*Alloc);
 781       if (Func->getNumParams() == 1 &&
 782           Context.getCanonicalType(
 783             Func->getParamDecl(0)->getType().getUnqualifiedType()) == Argument)
 784         return;
 785     }
 786   }
 787
 788   QualType BadAllocType;
 789   bool HasBadAllocExceptionSpec
 790     = (Name.getCXXOverloadedOperator() == OO_New ||
 791        Name.getCXXOverloadedOperator() == OO_Array_New);
 792   if (HasBadAllocExceptionSpec) {
 793     assert(StdBadAlloc && "Must have std::bad_alloc declared");
 794     BadAllocType = Context.getTypeDeclType(StdBadAlloc);
 795   }
 796
 797   QualType FnType = Context.getFunctionType(Return, &Argument, 1, false, 0,
 798                                             true, false,
 799                                             HasBadAllocExceptionSpec? 1 : 0,
 800                                             &BadAllocType);
 801   FunctionDecl *Alloc =
 802     FunctionDecl::Create(Context, GlobalCtx, SourceLocation(), Name,
 803                          FnType, /*TInfo=*/0, FunctionDecl::None, false, true);
 804   Alloc->setImplicit();
 805
 806   if (AddMallocAttr)
 807     Alloc->addAttr(::new (Context) MallocAttr());
 808
 809   ParmVarDecl *Param = ParmVarDecl::Create(Context, Alloc, SourceLocation(),
 810                                            0, Argument, /*TInfo=*/0,
 811                                            VarDecl::None, 0);
 812   Alloc->setParams(Context, &Param, 1);
 813
 814   // FIXME: Also add this declaration to the IdentifierResolver, but
 815   // make sure it is at the end of the chain to coincide with the
 816   // global scope.
 817   ((DeclContext *)TUScope->getEntity())->addDecl(Alloc);
 818 }
 819
 820 bool Sema::FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD,
 821                                     DeclarationName Name,
 822                                     FunctionDecl* &Operator) {
 823   LookupResult Found(*this, Name, StartLoc, LookupOrdinaryName);
 824   // Try to find operator delete/operator delete[] in class scope.
 825   LookupQualifiedName(Found, RD);
 826
 827   if (Found.isAmbiguous())
 828     return true;
 829
 830   for (LookupResult::iterator F = Found.begin(), FEnd = Found.end();
 831        F != FEnd; ++F) {
 832     if (CXXMethodDecl *Delete = dyn_cast<CXXMethodDecl>(*F))
 833       if (Delete->isUsualDeallocationFunction()) {
 834         Operator = Delete;
 835         return false;
 836       }
 837   }
 838
 839   // We did find operator delete/operator delete[] declarations, but
 840   // none of them were suitable.
 841   if (!Found.empty()) {
 842     Diag(StartLoc, diag::err_no_suitable_delete_member_function_found)
 843       << Name << RD;
 844
 845     for (LookupResult::iterator F = Found.begin(), FEnd = Found.end();
 846          F != FEnd; ++F) {
 847       Diag((*F)->getLocation(),
 848            diag::note_delete_member_function_declared_here)
 849         << Name;
 850     }
 851
 852     return true;
 853   }
 854
 855   // Look for a global declaration.
 856   DeclareGlobalNewDelete();
 857   DeclContext *TUDecl = Context.getTranslationUnitDecl();
 858
 859   CXXNullPtrLiteralExpr Null(Context.VoidPtrTy, SourceLocation());
 860   Expr* DeallocArgs[1];
 861   DeallocArgs[0] = &Null;
 862   if (FindAllocationOverload(StartLoc, SourceRange(), Name,
 863                              DeallocArgs, 1, TUDecl, /*AllowMissing=*/false,
 864                              Operator))
 865     return true;
 866
 867   assert(Operator && "Did not find a deallocation function!");
 868   return false;
 869 }
 870
 871 /// ActOnCXXDelete - Parsed a C++ 'delete' expression (C++ 5.3.5), as in:
 872 /// @code ::delete ptr; @endcode
 873 /// or
 874 /// @code delete [] ptr; @endcode
 875 Action::OwningExprResult
 876 Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal,
 877                      bool ArrayForm, ExprArg Operand) {
 878   // C++ [expr.delete]p1:
 879   //   The operand shall have a pointer type, or a class type having a single
 880   //   conversion function to a pointer type. The result has type void.
 881   //
 882   // DR599 amends "pointer type" to "pointer to object type" in both cases.
 883
 884   FunctionDecl *OperatorDelete = 0;
 885
 886   Expr *Ex = (Expr *)Operand.get();
 887   if (!Ex->isTypeDependent()) {
 888     QualType Type = Ex->getType();
 889
 890     if (const RecordType *Record = Type->getAs<RecordType>()) {
 891       llvm::SmallVector<CXXConversionDecl *, 4> ObjectPtrConversions;
 892       CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl());
 893       const UnresolvedSet *Conversions = RD->getVisibleConversionFunctions();
 894
 895       for (UnresolvedSet::iterator I = Conversions->begin(),
 896              E = Conversions->end(); I != E; ++I) {
 897         // Skip over templated conversion functions; they aren't considered.
 898         if (isa<FunctionTemplateDecl>(*I))
 899           continue;
 900
 901         CXXConversionDecl *Conv = cast<CXXConversionDecl>(*I);
 902
 903         QualType ConvType = Conv->getConversionType().getNonReferenceType();
 904         if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>())
 905           if (ConvPtrType->getPointeeType()->isObjectType())
 906             ObjectPtrConversions.push_back(Conv);
 907       }
 908       if (ObjectPtrConversions.size() == 1) {
 909         // We have a single conversion to a pointer-to-object type. Perform
 910         // that conversion.
 911         Operand.release();
 912         if (!PerformImplicitConversion(Ex,
 913                             ObjectPtrConversions.front()->getConversionType(),
 914                                       AA_Converting)) {
 915           Operand = Owned(Ex);
 916           Type = Ex->getType();
 917         }
 918       }
 919       else if (ObjectPtrConversions.size() > 1) {
 920         Diag(StartLoc, diag::err_ambiguous_delete_operand)
 921               << Type << Ex->getSourceRange();
 922         for (unsigned i= 0; i < ObjectPtrConversions.size(); i++) {
 923           CXXConversionDecl *Conv = ObjectPtrConversions[i];
 924           Diag(Conv->getLocation(), diag::err_ovl_candidate);
 925         }
 926         return ExprError();
 927       }
 928     }
 929
 930     if (!Type->isPointerType())
 931       return ExprError(Diag(StartLoc, diag::err_delete_operand)
 932         << Type << Ex->getSourceRange());
 933
 934     QualType Pointee = Type->getAs<PointerType>()->getPointeeType();
 935     if (Pointee->isFunctionType() || Pointee->isVoidType())
 936       return ExprError(Diag(StartLoc, diag::err_delete_operand)
 937         << Type << Ex->getSourceRange());
 938     else if (!Pointee->isDependentType() &&
 939              RequireCompleteType(StartLoc, Pointee,
 940                                  PDiag(diag::warn_delete_incomplete)
 941                                    << Ex->getSourceRange()))
 942       return ExprError();
 943
 944     // C++ [expr.delete]p2:
 945     //   [Note: a pointer to a const type can be the operand of a
 946     //   delete-expression; it is not necessary to cast away the constness
 947     //   (5.2.11) of the pointer expression before it is used as the operand
 948     //   of the delete-expression. ]
 949     ImpCastExprToType(Ex, Context.getPointerType(Context.VoidTy),
 950                       CastExpr::CK_NoOp);
 951
 952     // Update the operand.
 953     Operand.take();
 954     Operand = ExprArg(*this, Ex);
 955
 956     DeclarationName DeleteName = Context.DeclarationNames.getCXXOperatorName(
 957                                       ArrayForm ? OO_Array_Delete : OO_Delete);
 958
 959     if (const RecordType *RT = Pointee->getAs<RecordType>()) {
 960       CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
 961
 962       if (!UseGlobal &&
 963           FindDeallocationFunction(StartLoc, RD, DeleteName, OperatorDelete))
 964         return ExprError();
 965
 966       if (!RD->hasTrivialDestructor())
 967         if (const CXXDestructorDecl *Dtor = RD->getDestructor(Context))
 968           MarkDeclarationReferenced(StartLoc,
 969                                     const_cast<CXXDestructorDecl*>(Dtor));
 970     }
 971
 972     if (!OperatorDelete) {
 973       // Look for a global declaration.
 974       DeclareGlobalNewDelete();
 975       DeclContext *TUDecl = Context.getTranslationUnitDecl();
 976       if (FindAllocationOverload(StartLoc, SourceRange(), DeleteName,
 977                                  &Ex, 1, TUDecl, /*AllowMissing=*/false,
 978                                  OperatorDelete))
 979         return ExprError();
 980     }
 981
 982     // FIXME: Check access and ambiguity of operator delete and destructor.
 983   }
 984
 985   Operand.release();
 986   return Owned(new (Context) CXXDeleteExpr(Context.VoidTy, UseGlobal, ArrayForm,
 987                                            OperatorDelete, Ex, StartLoc));
 988 }
 989
 990 /// \brief Check the use of the given variable as a C++ condition in an if,
 991 /// while, do-while, or switch statement.
 992 Action::OwningExprResult Sema::CheckConditionVariable(VarDecl *ConditionVar) {
 993   QualType T = ConditionVar->getType();
 994
 995   // C++ [stmt.select]p2:
 996   //   The declarator shall not specify a function or an array.
 997   if (T->isFunctionType())
 998     return ExprError(Diag(ConditionVar->getLocation(),
 999                           diag::err_invalid_use_of_function_type)
1000                        << ConditionVar->getSourceRange());
1001   else if (T->isArrayType())
1002     return ExprError(Diag(ConditionVar->getLocation(),
1003                           diag::err_invalid_use_of_array_type)
1004                      << ConditionVar->getSourceRange());
1005
1006   return Owned(DeclRefExpr::Create(Context, 0, SourceRange(), ConditionVar,
1007                                    ConditionVar->getLocation(),
1008                                 ConditionVar->getType().getNonReferenceType()));
1009 }
1010
1011 /// CheckCXXBooleanCondition - Returns true if a conversion to bool is invalid.
1012 bool Sema::CheckCXXBooleanCondition(Expr *&CondExpr) {
1013   // C++ 6.4p4:
1014   // The value of a condition that is an initialized declaration in a statement
1015   // other than a switch statement is the value of the declared variable
1016   // implicitly converted to type bool. If that conversion is ill-formed, the
1017   // program is ill-formed.
1018   // The value of a condition that is an expression is the value of the
1019   // expression, implicitly converted to bool.
1020   //
1021   return PerformContextuallyConvertToBool(CondExpr);
1022 }
1023
1024 /// Helper function to determine whether this is the (deprecated) C++
1025 /// conversion from a string literal to a pointer to non-const char or
1026 /// non-const wchar_t (for narrow and wide string literals,
1027 /// respectively).
1028 bool
1029 Sema::IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType) {
1030   // Look inside the implicit cast, if it exists.
1031   if (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(From))
1032     From = Cast->getSubExpr();
1033
1034   // A string literal (2.13.4) that is not a wide string literal can
1035   // be converted to an rvalue of type "pointer to char"; a wide
1036   // string literal can be converted to an rvalue of type "pointer
1037   // to wchar_t" (C++ 4.2p2).
1038   if (StringLiteral *StrLit = dyn_cast<StringLiteral>(From))
1039     if (const PointerType *ToPtrType = ToType->getAs<PointerType>())
1040       if (const BuiltinType *ToPointeeType
1041           = ToPtrType->getPointeeType()->getAs<BuiltinType>()) {
1042         // This conversion is considered only when there is an
1043         // explicit appropriate pointer target type (C++ 4.2p2).
1044         if (!ToPtrType->getPointeeType().hasQualifiers() &&
1045             ((StrLit->isWide() && ToPointeeType->isWideCharType()) ||
1046              (!StrLit->isWide() &&
1047               (ToPointeeType->getKind() == BuiltinType::Char_U ||
1048                ToPointeeType->getKind() == BuiltinType::Char_S))))
1049           return true;
1050       }
1051
1052   return false;
1053 }
1054
1055 /// PerformImplicitConversion - Perform an implicit conversion of the
1056 /// expression From to the type ToType. Returns true if there was an
1057 /// error, false otherwise. The expression From is replaced with the
1058 /// converted expression. Flavor is the kind of conversion we're
1059 /// performing, used in the error message. If @p AllowExplicit,
1060 /// explicit user-defined conversions are permitted. @p Elidable should be true
1061 /// when called for copies which may be elided (C++ 12.8p15). C++0x overload
1062 /// resolution works differently in that case.
1063 bool
1064 Sema::PerformImplicitConversion(Expr *&From, QualType ToType,
1065                                 AssignmentAction Action, bool AllowExplicit,
1066                                 bool Elidable) {
1067   ImplicitConversionSequence ICS;
1068   return PerformImplicitConversion(From, ToType, Action, AllowExplicit,
1069                                    Elidable, ICS);
1070 }
1071
1072 bool
1073 Sema::PerformImplicitConversion(Expr *&From, QualType ToType,
1074                                 AssignmentAction Action, bool AllowExplicit,
1075                                 bool Elidable,
1076                                 ImplicitConversionSequence& ICS) {
1077   ICS.ConversionKind = ImplicitConversionSequence::BadConversion;
1078   if (Elidable && getLangOptions().CPlusPlus0x) {
1079     ICS = TryImplicitConversion(From, ToType,
1080                                 /*SuppressUserConversions=*/false,
1081                                 AllowExplicit,
1082                                 /*ForceRValue=*/true,
1083                                 /*InOverloadResolution=*/false);
1084   }
1085   if (ICS.ConversionKind == ImplicitConversionSequence::BadConversion) {
1086     ICS = TryImplicitConversion(From, ToType,
1087                                 /*SuppressUserConversions=*/false,
1088                                 AllowExplicit,
1089                                 /*ForceRValue=*/false,
1090                                 /*InOverloadResolution=*/false);
1091   }
1092   return PerformImplicitConversion(From, ToType, ICS, Action);
1093 }
1094
1095 /// BuildCXXDerivedToBaseExpr - This routine generates the suitable AST
1096 /// for the derived to base conversion of the expression 'From'. All
1097 /// necessary information is passed in ICS.
1098 bool
1099 Sema::BuildCXXDerivedToBaseExpr(Expr *&From, CastExpr::CastKind CastKind,
1100                                      const ImplicitConversionSequence& ICS) {
1101   QualType  BaseType =
1102     QualType::getFromOpaquePtr(ICS.UserDefined.After.ToTypePtr);
1103   // Must do additional defined to base conversion.
1104   QualType  DerivedType =
1105     QualType::getFromOpaquePtr(ICS.UserDefined.After.FromTypePtr);
1106
1107   From = new (Context) ImplicitCastExpr(
1108                                         DerivedType.getNonReferenceType(),
1109                                         CastKind,
1110                                         From,
1111                                         DerivedType->isLValueReferenceType());
1112   From = new (Context) ImplicitCastExpr(BaseType.getNonReferenceType(),
1113                                         CastExpr::CK_DerivedToBase, From,
1114                                         BaseType->isLValueReferenceType());
1115   ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(*this);
1116   OwningExprResult FromResult =
1117   BuildCXXConstructExpr(
1118                         ICS.UserDefined.After.CopyConstructor->getLocation(),
1119                         BaseType,
1120                         ICS.UserDefined.After.CopyConstructor,
1121                         MultiExprArg(*this, (void **)&From, 1));
1122   if (FromResult.isInvalid())
1123     return true;
1124   From = FromResult.takeAs<Expr>();
1125   return false;
1126 }
1127
1128 /// PerformImplicitConversion - Perform an implicit conversion of the
1129 /// expression From to the type ToType using the pre-computed implicit
1130 /// conversion sequence ICS. Returns true if there was an error, false
1131 /// otherwise. The expression From is replaced with the converted
1132 /// expression. Action is the kind of conversion we're performing,
1133 /// used in the error message.
1134 bool
1135 Sema::PerformImplicitConversion(Expr *&From, QualType ToType,
1136                                 const ImplicitConversionSequence &ICS,
1137                                 AssignmentAction Action, bool IgnoreBaseAccess) {
1138   switch (ICS.ConversionKind) {
1139   case ImplicitConversionSequence::StandardConversion:
1140     if (PerformImplicitConversion(From, ToType, ICS.Standard, Action,
1141                                   IgnoreBaseAccess))
1142       return true;
1143     break;
1144
1145   case ImplicitConversionSequence::UserDefinedConversion: {
1146
1147       FunctionDecl *FD = ICS.UserDefined.ConversionFunction;
1148       CastExpr::CastKind CastKind = CastExpr::CK_Unknown;
1149       QualType BeforeToType;
1150       if (const CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(FD)) {
1151         CastKind = CastExpr::CK_UserDefinedConversion;
1152
1153         // If the user-defined conversion is specified by a conversion function,
1154         // the initial standard conversion sequence converts the source type to
1155         // the implicit object parameter of the conversion function.
1156         BeforeToType = Context.getTagDeclType(Conv->getParent());
1157       } else if (const CXXConstructorDecl *Ctor =
1158                   dyn_cast<CXXConstructorDecl>(FD)) {
1159         CastKind = CastExpr::CK_ConstructorConversion;
1160         // Do no conversion if dealing with ... for the first conversion.
1161         if (!ICS.UserDefined.EllipsisConversion) {
1162           // If the user-defined conversion is specified by a constructor, the
1163           // initial standard conversion sequence converts the source type to the
1164           // type required by the argument of the constructor
1165           BeforeToType = Ctor->getParamDecl(0)->getType().getNonReferenceType();
1166         }
1167       }
1168       else
1169         assert(0 && "Unknown conversion function kind!");
1170       // Whatch out for elipsis conversion.
1171       if (!ICS.UserDefined.EllipsisConversion) {
1172         if (PerformImplicitConversion(From, BeforeToType,
1173                                       ICS.UserDefined.Before, AA_Converting,
1174                                       IgnoreBaseAccess))
1175           return true;
1176       }
1177
1178       OwningExprResult CastArg
1179         = BuildCXXCastArgument(From->getLocStart(),
1180                                ToType.getNonReferenceType(),
1181                                CastKind, cast<CXXMethodDecl>(FD),
1182                                Owned(From));
1183
1184       if (CastArg.isInvalid())
1185         return true;
1186
1187       From = CastArg.takeAs<Expr>();
1188
1189       // FIXME: This and the following if statement shouldn't be necessary, but
1190       // there's some nasty stuff involving MaybeBindToTemporary going on here.
1191       if (ICS.UserDefined.After.Second == ICK_Derived_To_Base &&
1192           ICS.UserDefined.After.CopyConstructor) {
1193         return BuildCXXDerivedToBaseExpr(From, CastKind, ICS);
1194       }
1195
1196       if (ICS.UserDefined.After.CopyConstructor) {
1197         From = new (Context) ImplicitCastExpr(ToType.getNonReferenceType(),
1198                                               CastKind, From,
1199                                               ToType->isLValueReferenceType());
1200         return false;
1201       }
1202
1203       return PerformImplicitConversion(From, ToType, ICS.UserDefined.After,
1204                                        AA_Converting, IgnoreBaseAccess);
1205   }
1206
1207   case ImplicitConversionSequence::EllipsisConversion:
1208     assert(false && "Cannot perform an ellipsis conversion");
1209     return false;
1210
1211   case ImplicitConversionSequence::BadConversion:
1212     return true;
1213   }
1214
1215   // Everything went well.
1216   return false;
1217 }
1218
1219 /// PerformImplicitConversion - Perform an implicit conversion of the
1220 /// expression From to the type ToType by following the standard
1221 /// conversion sequence SCS. Returns true if there was an error, false
1222 /// otherwise. The expression From is replaced with the converted
1223 /// expression. Flavor is the context in which we're performing this
1224 /// conversion, for use in error messages.
1225 bool
1226 Sema::PerformImplicitConversion(Expr *&From, QualType ToType,
1227                                 const StandardConversionSequence& SCS,
1228                                 AssignmentAction Action, bool IgnoreBaseAccess) {
1229   // Overall FIXME: we are recomputing too many types here and doing far too
1230   // much extra work. What this means is that we need to keep track of more
1231   // information that is computed when we try the implicit conversion initially,
1232   // so that we don't need to recompute anything here.
1233   QualType FromType = From->getType();
1234
1235   if (SCS.CopyConstructor) {
1236     // FIXME: When can ToType be a reference type?
1237     assert(!ToType->isReferenceType());
1238     if (SCS.Second == ICK_Derived_To_Base) {
1239       ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(*this);
1240       if (CompleteConstructorCall(cast<CXXConstructorDecl>(SCS.CopyConstructor),
1241                                   MultiExprArg(*this, (void **)&From, 1),
1242                                   /*FIXME:ConstructLoc*/SourceLocation(),
1243                                   ConstructorArgs))
1244         return true;
1245       OwningExprResult FromResult =
1246         BuildCXXConstructExpr(/*FIXME:ConstructLoc*/SourceLocation(),
1247                               ToType, SCS.CopyConstructor,
1248                               move_arg(ConstructorArgs));
1249       if (FromResult.isInvalid())
1250         return true;
1251       From = FromResult.takeAs<Expr>();
1252       return false;
1253     }
1254     OwningExprResult FromResult =
1255       BuildCXXConstructExpr(/*FIXME:ConstructLoc*/SourceLocation(),
1256                             ToType, SCS.CopyConstructor,
1257                             MultiExprArg(*this, (void**)&From, 1));
1258
1259     if (FromResult.isInvalid())
1260       return true;
1261
1262     From = FromResult.takeAs<Expr>();
1263     return false;
1264   }
1265
1266   // Perform the first implicit conversion.
1267   switch (SCS.First) {
1268   case ICK_Identity:
1269   case ICK_Lvalue_To_Rvalue:
1270     // Nothing to do.
1271     break;
1272
1273   case ICK_Array_To_Pointer:
1274     FromType = Context.getArrayDecayedType(FromType);
1275     ImpCastExprToType(From, FromType, CastExpr::CK_ArrayToPointerDecay);
1276     break;
1277
1278   case ICK_Function_To_Pointer:
1279     if (Context.getCanonicalType(FromType) == Context.OverloadTy) {
1280       FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(From, ToType, true);
1281       if (!Fn)
1282         return true;
1283
1284       if (DiagnoseUseOfDecl(Fn, From->getSourceRange().getBegin()))
1285         return true;
1286
1287       From = FixOverloadedFunctionReference(From, Fn);
1288       FromType = From->getType();
1289
1290       // If there's already an address-of operator in the expression, we have
1291       // the right type already, and the code below would just introduce an
1292       // invalid additional pointer level.
1293       if (FromType->isPointerType() || FromType->isMemberFunctionPointerType())
1294         break;
1295     }
1296     FromType = Context.getPointerType(FromType);
1297     ImpCastExprToType(From, FromType, CastExpr::CK_FunctionToPointerDecay);
1298     break;
1299
1300   default:
1301     assert(false && "Improper first standard conversion");
1302     break;
1303   }
1304
1305   // Perform the second implicit conversion
1306   switch (SCS.Second) {
1307   case ICK_Identity:
1308     // If both sides are functions (or pointers/references to them), there could
1309     // be incompatible exception declarations.
1310     if (CheckExceptionSpecCompatibility(From, ToType))
1311       return true;
1312     // Nothing else to do.
1313     break;
1314
1315   case ICK_NoReturn_Adjustment:
1316     // If both sides are functions (or pointers/references to them), there could
1317     // be incompatible exception declarations.
1318     if (CheckExceptionSpecCompatibility(From, ToType))
1319       return true;
1320
1321     ImpCastExprToType(From, Context.getNoReturnType(From->getType(), false),
1322                       CastExpr::CK_NoOp);
1323     break;
1324
1325   case ICK_Integral_Promotion:
1326   case ICK_Integral_Conversion:
1327     ImpCastExprToType(From, ToType, CastExpr::CK_IntegralCast);
1328     break;
1329
1330   case ICK_Floating_Promotion:
1331   case ICK_Floating_Conversion:
1332     ImpCastExprToType(From, ToType, CastExpr::CK_FloatingCast);
1333     break;
1334
1335   case ICK_Complex_Promotion:
1336   case ICK_Complex_Conversion:
1337     ImpCastExprToType(From, ToType, CastExpr::CK_Unknown);
1338     break;
1339
1340   case ICK_Floating_Integral:
1341     if (ToType->isFloatingType())
1342       ImpCastExprToType(From, ToType, CastExpr::CK_IntegralToFloating);
1343     else
1344       ImpCastExprToType(From, ToType, CastExpr::CK_FloatingToIntegral);
1345     break;
1346
1347   case ICK_Complex_Real:
1348     ImpCastExprToType(From, ToType, CastExpr::CK_Unknown);
1349     break;
1350
1351   case ICK_Compatible_Conversion:
1352     ImpCastExprToType(From, ToType, CastExpr::CK_NoOp);
1353     break;
1354
1355   case ICK_Pointer_Conversion: {
1356     if (SCS.IncompatibleObjC) {
1357       // Diagnose incompatible Objective-C conversions
1358       Diag(From->getSourceRange().getBegin(),
1359            diag::ext_typecheck_convert_incompatible_pointer)
1360         << From->getType() << ToType << Action
1361         << From->getSourceRange();
1362     }
1363
1364
1365     CastExpr::CastKind Kind = CastExpr::CK_Unknown;
1366     if (CheckPointerConversion(From, ToType, Kind, IgnoreBaseAccess))
1367       return true;
1368     ImpCastExprToType(From, ToType, Kind);
1369     break;
1370   }
1371
1372   case ICK_Pointer_Member: {
1373     CastExpr::CastKind Kind = CastExpr::CK_Unknown;
1374     if (CheckMemberPointerConversion(From, ToType, Kind, IgnoreBaseAccess))
1375       return true;
1376     if (CheckExceptionSpecCompatibility(From, ToType))
1377       return true;
1378     ImpCastExprToType(From, ToType, Kind);
1379     break;
1380   }
1381   case ICK_Boolean_Conversion: {
1382     CastExpr::CastKind Kind = CastExpr::CK_Unknown;
1383     if (FromType->isMemberPointerType())
1384       Kind = CastExpr::CK_MemberPointerToBoolean;
1385
1386     ImpCastExprToType(From, Context.BoolTy, Kind);
1387     break;
1388   }
1389
1390   case ICK_Derived_To_Base:
1391     if (CheckDerivedToBaseConversion(From->getType(),
1392                                      ToType.getNonReferenceType(),
1393                                      From->getLocStart(),
1394                                      From->getSourceRange(),
1395                                      IgnoreBaseAccess))
1396       return true;
1397     ImpCastExprToType(From, ToType.getNonReferenceType(),
1398                       CastExpr::CK_DerivedToBase);
1399     break;
1400
1401   default:
1402     assert(false && "Improper second standard conversion");
1403     break;
1404   }
1405
1406   switch (SCS.Third) {
1407   case ICK_Identity:
1408     // Nothing to do.
1409     break;
1410
1411   case ICK_Qualification:
1412     // FIXME: Not sure about lvalue vs rvalue here in the presence of rvalue
1413     // references.
1414     ImpCastExprToType(From, ToType.getNonReferenceType(),
1415                       CastExpr::CK_NoOp,
1416                       ToType->isLValueReferenceType());
1417     break;
1418
1419   default:
1420     assert(false && "Improper second standard conversion");
1421     break;
1422   }
1423
1424   return false;
1425 }
1426
1427 Sema::OwningExprResult Sema::ActOnUnaryTypeTrait(UnaryTypeTrait OTT,
1428                                                  SourceLocation KWLoc,
1429                                                  SourceLocation LParen,
1430                                                  TypeTy *Ty,
1431                                                  SourceLocation RParen) {
1432   QualType T = GetTypeFromParser(Ty);
1433
1434   // According to http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html
1435   // all traits except __is_class, __is_enum and __is_union require a the type
1436   // to be complete.
1437   if (OTT != UTT_IsClass && OTT != UTT_IsEnum && OTT != UTT_IsUnion) {
1438     if (RequireCompleteType(KWLoc, T,
1439                             diag::err_incomplete_type_used_in_type_trait_expr))
1440       return ExprError();
1441   }
1442
1443   // There is no point in eagerly computing the value. The traits are designed
1444   // to be used from type trait templates, so Ty will be a template parameter
1445   // 99% of the time.
1446   return Owned(new (Context) UnaryTypeTraitExpr(KWLoc, OTT, T,
1447                                                 RParen, Context.BoolTy));
1448 }
1449
1450 QualType Sema::CheckPointerToMemberOperands(
1451   Expr *&lex, Expr *&rex, SourceLocation Loc, bool isIndirect) {
1452   const char *OpSpelling = isIndirect ? "->*" : ".*";
1453   // C++ 5.5p2
1454   //   The binary operator .* [p3: ->*] binds its second operand, which shall
1455   //   be of type "pointer to member of T" (where T is a completely-defined
1456   //   class type) [...]
1457   QualType RType = rex->getType();
1458   const MemberPointerType *MemPtr = RType->getAs<MemberPointerType>();
1459   if (!MemPtr) {
1460     Diag(Loc, diag::err_bad_memptr_rhs)
1461       << OpSpelling << RType << rex->getSourceRange();
1462     return QualType();
1463   }
1464
1465   QualType Class(MemPtr->getClass(), 0);
1466
1467   // C++ 5.5p2
1468   //   [...] to its first operand, which shall be of class T or of a class of
1469   //   which T is an unambiguous and accessible base class. [p3: a pointer to
1470   //   such a class]
1471   QualType LType = lex->getType();
1472   if (isIndirect) {
1473     if (const PointerType *Ptr = LType->getAs<PointerType>())
1474       LType = Ptr->getPointeeType().getNonReferenceType();
1475     else {
1476       Diag(Loc, diag::err_bad_memptr_lhs)
1477         << OpSpelling << 1 << LType
1478         << CodeModificationHint::CreateReplacement(SourceRange(Loc), ".*");
1479       return QualType();
1480     }
1481   }
1482
1483   if (!Context.hasSameUnqualifiedType(Class, LType)) {
1484     CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/false,
1485                        /*DetectVirtual=*/false);
1486     // FIXME: Would it be useful to print full ambiguity paths, or is that
1487     // overkill?
1488     if (!IsDerivedFrom(LType, Class, Paths) ||
1489         Paths.isAmbiguous(Context.getCanonicalType(Class))) {
1490       const char *ReplaceStr = isIndirect ? ".*" : "->*";
1491       Diag(Loc, diag::err_bad_memptr_lhs) << OpSpelling
1492         << (int)isIndirect << lex->getType() <<
1493           CodeModificationHint::CreateReplacement(SourceRange(Loc), ReplaceStr);
1494       return QualType();
1495     }
1496   }
1497
1498   if (isa<CXXZeroInitValueExpr>(rex->IgnoreParens())) {
1499     // Diagnose use of pointer-to-member type which when used as
1500     // the functional cast in a pointer-to-member expression.
1501     Diag(Loc, diag::err_pointer_to_member_type) << isIndirect;
1502      return QualType();
1503   }
1504   // C++ 5.5p2
1505   //   The result is an object or a function of the type specified by the
1506   //   second operand.
1507   // The cv qualifiers are the union of those in the pointer and the left side,
1508   // in accordance with 5.5p5 and 5.2.5.
1509   // FIXME: This returns a dereferenced member function pointer as a normal
1510   // function type. However, the only operation valid on such functions is
1511   // calling them. There's also a GCC extension to get a function pointer to the
1512   // thing, which is another complication, because this type - unlike the type
1513   // that is the result of this expression - takes the class as the first
1514   // argument.
1515   // We probably need a "MemberFunctionClosureType" or something like that.
1516   QualType Result = MemPtr->getPointeeType();
1517   Result = Context.getCVRQualifiedType(Result, LType.getCVRQualifiers());
1518   return Result;
1519 }
1520
1521 /// \brief Get the target type of a standard or user-defined conversion.
1522 static QualType TargetType(const ImplicitConversionSequence &ICS) {
1523   assert((ICS.ConversionKind ==
1524               ImplicitConversionSequence::StandardConversion ||
1525           ICS.ConversionKind ==
1526               ImplicitConversionSequence::UserDefinedConversion) &&
1527          "function only valid for standard or user-defined conversions");
1528   if (ICS.ConversionKind == ImplicitConversionSequence::StandardConversion)
1529     return QualType::getFromOpaquePtr(ICS.Standard.ToTypePtr);
1530   return QualType::getFromOpaquePtr(ICS.UserDefined.After.ToTypePtr);
1531 }
1532
1533 /// \brief Try to convert a type to another according to C++0x 5.16p3.
1534 ///
1535 /// This is part of the parameter validation for the ? operator. If either
1536 /// value operand is a class type, the two operands are attempted to be
1537 /// converted to each other. This function does the conversion in one direction.
1538 /// It emits a diagnostic and returns true only if it finds an ambiguous
1539 /// conversion.
1540 static bool TryClassUnification(Sema &Self, Expr *From, Expr *To,
1541                                 SourceLocation QuestionLoc,
1542                                 ImplicitConversionSequence &ICS) {
1543   // C++0x 5.16p3
1544   //   The process for determining whether an operand expression E1 of type T1
1545   //   can be converted to match an operand expression E2 of type T2 is defined
1546   //   as follows:
1547   //   -- If E2 is an lvalue:
1548   if (To->isLvalue(Self.Context) == Expr::LV_Valid) {
1549     //   E1 can be converted to match E2 if E1 can be implicitly converted to
1550     //   type "lvalue reference to T2", subject to the constraint that in the
1551     //   conversion the reference must bind directly to E1.
1552     if (!Self.CheckReferenceInit(From,
1553                             Self.Context.getLValueReferenceType(To->getType()),
1554                                  To->getLocStart(),
1555                                  /*SuppressUserConversions=*/false,
1556                                  /*AllowExplicit=*/false,
1557                                  /*ForceRValue=*/false,
1558                                  &ICS))
1559     {
1560       assert((ICS.ConversionKind ==
1561                   ImplicitConversionSequence::StandardConversion ||
1562               ICS.ConversionKind ==
1563                   ImplicitConversionSequence::UserDefinedConversion) &&
1564              "expected a definite conversion");
1565       bool DirectBinding =
1566         ICS.ConversionKind == ImplicitConversionSequence::StandardConversion ?
1567         ICS.Standard.DirectBinding : ICS.UserDefined.After.DirectBinding;
1568       if (DirectBinding)
1569         return false;
1570     }
1571   }
1572   ICS.ConversionKind = ImplicitConversionSequence::BadConversion;
1573   //   -- If E2 is an rvalue, or if the conversion above cannot be done:
1574   //      -- if E1 and E2 have class type, and the underlying class types are
1575   //         the same or one is a base class of the other:
1576   QualType FTy = From->getType();
1577   QualType TTy = To->getType();
1578   const RecordType *FRec = FTy->getAs<RecordType>();
1579   const RecordType *TRec = TTy->getAs<RecordType>();
1580   bool FDerivedFromT = FRec && TRec && Self.IsDerivedFrom(FTy, TTy);
1581   if (FRec && TRec && (FRec == TRec ||
1582         FDerivedFromT || Self.IsDerivedFrom(TTy, FTy))) {
1583     //         E1 can be converted to match E2 if the class of T2 is the
1584     //         same type as, or a base class of, the class of T1, and
1585     //         [cv2 > cv1].
1586     if ((FRec == TRec || FDerivedFromT) && TTy.isAtLeastAsQualifiedAs(FTy)) {
1587       // Could still fail if there's no copy constructor.
1588       // FIXME: Is this a hard error then, or just a conversion failure? The
1589       // standard doesn't say.
1590       ICS = Self.TryCopyInitialization(From, TTy,
1591                                        /*SuppressUserConversions=*/false,
1592                                        /*ForceRValue=*/false,
1593                                        /*InOverloadResolution=*/false);
1594     }
1595   } else {
1596     //     -- Otherwise: E1 can be converted to match E2 if E1 can be
1597     //        implicitly converted to the type that expression E2 would have
1598     //        if E2 were converted to an rvalue.
1599     // First find the decayed type.
1600     if (TTy->isFunctionType())
1601       TTy = Self.Context.getPointerType(TTy);
1602     else if (TTy->isArrayType())
1603       TTy = Self.Context.getArrayDecayedType(TTy);
1604
1605     // Now try the implicit conversion.
1606     // FIXME: This doesn't detect ambiguities.
1607     ICS = Self.TryImplicitConversion(From, TTy,
1608                                      /*SuppressUserConversions=*/false,
1609                                      /*AllowExplicit=*/false,
1610                                      /*ForceRValue=*/false,
1611                                      /*InOverloadResolution=*/false);
1612   }
1613   return false;
1614 }
1615
1616 /// \brief Try to find a common type for two according to C++0x 5.16p5.
1617 ///
1618 /// This is part of the parameter validation for the ? operator. If either
1619 /// value operand is a class type, overload resolution is used to find a
1620 /// conversion to a common type.
1621 static bool FindConditionalOverload(Sema &Self, Expr *&LHS, Expr *&RHS,
1622                                     SourceLocation Loc) {
1623   Expr *Args[2] = { LHS, RHS };
1624   OverloadCandidateSet CandidateSet;
1625   Self.AddBuiltinOperatorCandidates(OO_Conditional, Loc, Args, 2, CandidateSet);
1626
1627   OverloadCandidateSet::iterator Best;
1628   switch (Self.BestViableFunction(CandidateSet, Loc, Best)) {
1629     case OR_Success:
1630       // We found a match. Perform the conversions on the arguments and move on.
1631       if (Self.PerformImplicitConversion(LHS, Best->BuiltinTypes.ParamTypes[0],
1632                                          Best->Conversions[0], Sema::AA_Converting) ||
1633           Self.PerformImplicitConversion(RHS, Best->BuiltinTypes.ParamTypes[1],
1634                                          Best->Conversions[1], Sema::AA_Converting))
1635         break;
1636       return false;
1637
1638     case OR_No_Viable_Function:
1639       Self.Diag(Loc, diag::err_typecheck_cond_incompatible_operands)
1640         << LHS->getType() << RHS->getType()
1641         << LHS->getSourceRange() << RHS->getSourceRange();
1642       return true;
1643
1644     case OR_Ambiguous:
1645       Self.Diag(Loc, diag::err_conditional_ambiguous_ovl)
1646         << LHS->getType() << RHS->getType()
1647         << LHS->getSourceRange() << RHS->getSourceRange();
1648       // FIXME: Print the possible common types by printing the return types of
1649       // the viable candidates.
1650       break;
1651
1652     case OR_Deleted:
1653       assert(false && "Conditional operator has only built-in overloads");
1654       break;
1655   }
1656   return true;
1657 }
1658
1659 /// \brief Perform an "extended" implicit conversion as returned by
1660 /// TryClassUnification.
1661 ///
1662 /// TryClassUnification generates ICSs that include reference bindings.
1663 /// PerformImplicitConversion is not suitable for this; it chokes if the
1664 /// second part of a standard conversion is ICK_DerivedToBase. This function
1665 /// handles the reference binding specially.
1666 static bool ConvertForConditional(Sema &Self, Expr *&E,
1667                                   const ImplicitConversionSequence &ICS) {
1668   if (ICS.ConversionKind == ImplicitConversionSequence::StandardConversion &&
1669       ICS.Standard.ReferenceBinding) {
1670     assert(ICS.Standard.DirectBinding &&
1671            "TryClassUnification should never generate indirect ref bindings");
1672     // FIXME: CheckReferenceInit should be able to reuse the ICS instead of
1673     // redoing all the work.
1674     return Self.CheckReferenceInit(E, Self.Context.getLValueReferenceType(
1675                                         TargetType(ICS)),
1676                                    /*FIXME:*/E->getLocStart(),
1677                                    /*SuppressUserConversions=*/false,
1678                                    /*AllowExplicit=*/false,
1679                                    /*ForceRValue=*/false);
1680   }
1681   if (ICS.ConversionKind == ImplicitConversionSequence::UserDefinedConversion &&
1682       ICS.UserDefined.After.ReferenceBinding) {
1683     assert(ICS.UserDefined.After.DirectBinding &&
1684            "TryClassUnification should never generate indirect ref bindings");
1685     return Self.CheckReferenceInit(E, Self.Context.getLValueReferenceType(
1686                                         TargetType(ICS)),
1687                                    /*FIXME:*/E->getLocStart(),
1688                                    /*SuppressUserConversions=*/false,
1689                                    /*AllowExplicit=*/false,
1690                                    /*ForceRValue=*/false);
1691   }
1692   if (Self.PerformImplicitConversion(E, TargetType(ICS), ICS, Sema::AA_Converting))
1693     return true;
1694   return false;
1695 }
1696
1697 /// \brief Check the operands of ?: under C++ semantics.
1698 ///
1699 /// See C++ [expr.cond]. Note that LHS is never null, even for the GNU x ?: y
1700 /// extension. In this case, LHS == Cond. (But they're not aliases.)
1701 QualType Sema::CXXCheckConditionalOperands(Expr *&Cond, Expr *&LHS, Expr *&RHS,
1702                                            SourceLocation QuestionLoc) {
1703   // FIXME: Handle C99's complex types, vector types, block pointers and Obj-C++
1704   // interface pointers.
1705
1706   // C++0x 5.16p1
1707   //   The first expression is contextually converted to bool.
1708   if (!Cond->isTypeDependent()) {
1709     if (CheckCXXBooleanCondition(Cond))
1710       return QualType();
1711   }
1712
1713   // Either of the arguments dependent?
1714   if (LHS->isTypeDependent() || RHS->isTypeDependent())
1715     return Context.DependentTy;
1716
1717   CheckSignCompare(LHS, RHS, QuestionLoc, diag::warn_mixed_sign_conditional);
1718
1719   // C++0x 5.16p2
1720   //   If either the second or the third operand has type (cv) void, ...
1721   QualType LTy = LHS->getType();
1722   QualType RTy = RHS->getType();
1723   bool LVoid = LTy->isVoidType();
1724   bool RVoid = RTy->isVoidType();
1725   if (LVoid || RVoid) {
1726     //   ... then the [l2r] conversions are performed on the second and third
1727     //   operands ...
1728     DefaultFunctionArrayConversion(LHS);
1729     DefaultFunctionArrayConversion(RHS);
1730     LTy = LHS->getType();
1731     RTy = RHS->getType();
1732
1733     //   ... and one of the following shall hold:
1734     //   -- The second or the third operand (but not both) is a throw-
1735     //      expression; the result is of the type of the other and is an rvalue.
1736     bool LThrow = isa<CXXThrowExpr>(LHS);
1737     bool RThrow = isa<CXXThrowExpr>(RHS);
1738     if (LThrow && !RThrow)
1739       return RTy;
1740     if (RThrow && !LThrow)
1741       return LTy;
1742
1743     //   -- Both the second and third operands have type void; the result is of
1744     //      type void and is an rvalue.
1745     if (LVoid && RVoid)
1746       return Context.VoidTy;
1747
1748     // Neither holds, error.
1749     Diag(QuestionLoc, diag::err_conditional_void_nonvoid)
1750       << (LVoid ? RTy : LTy) << (LVoid ? 0 : 1)
1751       << LHS->getSourceRange() << RHS->getSourceRange();
1752     return QualType();
1753   }
1754
1755   // Neither is void.
1756
1757   // C++0x 5.16p3
1758   //   Otherwise, if the second and third operand have different types, and
1759   //   either has (cv) class type, and attempt is made to convert each of those
1760   //   operands to the other.
1761   if (Context.getCanonicalType(LTy) != Context.getCanonicalType(RTy) &&
1762       (LTy->isRecordType() || RTy->isRecordType())) {
1763     ImplicitConversionSequence ICSLeftToRight, ICSRightToLeft;
1764     // These return true if a single direction is already ambiguous.
1765     if (TryClassUnification(*this, LHS, RHS, QuestionLoc, ICSLeftToRight))
1766       return QualType();
1767     if (TryClassUnification(*this, RHS, LHS, QuestionLoc, ICSRightToLeft))
1768       return QualType();
1769
1770     bool HaveL2R = ICSLeftToRight.ConversionKind !=
1771       ImplicitConversionSequence::BadConversion;
1772     bool HaveR2L = ICSRightToLeft.ConversionKind !=
1773       ImplicitConversionSequence::BadConversion;
1774     //   If both can be converted, [...] the program is ill-formed.
1775     if (HaveL2R && HaveR2L) {
1776       Diag(QuestionLoc, diag::err_conditional_ambiguous)
1777         << LTy << RTy << LHS->getSourceRange() << RHS->getSourceRange();
1778       return QualType();
1779     }
1780
1781     //   If exactly one conversion is possible, that conversion is applied to
1782     //   the chosen operand and the converted operands are used in place of the
1783     //   original operands for the remainder of this section.
1784     if (HaveL2R) {
1785       if (ConvertForConditional(*this, LHS, ICSLeftToRight))
1786         return QualType();
1787       LTy = LHS->getType();
1788     } else if (HaveR2L) {
1789       if (ConvertForConditional(*this, RHS, ICSRightToLeft))
1790         return QualType();
1791       RTy = RHS->getType();
1792     }
1793   }
1794
1795   // C++0x 5.16p4
1796   //   If the second and third operands are lvalues and have the same type,
1797   //   the result is of that type [...]
1798   bool Same = Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy);
1799   if (Same && LHS->isLvalue(Context) == Expr::LV_Valid &&
1800       RHS->isLvalue(Context) == Expr::LV_Valid)
1801     return LTy;
1802
1803   // C++0x 5.16p5
1804   //   Otherwise, the result is an rvalue. If the second and third operands
1805   //   do not have the same type, and either has (cv) class type, ...
1806   if (!Same && (LTy->isRecordType() || RTy->isRecordType())) {
1807     //   ... overload resolution is used to determine the conversions (if any)
1808     //   to be applied to the operands. If the overload resolution fails, the
1809     //   program is ill-formed.
1810     if (FindConditionalOverload(*this, LHS, RHS, QuestionLoc))
1811       return QualType();
1812   }
1813
1814   // C++0x 5.16p6
1815   //   LValue-to-rvalue, array-to-pointer, and function-to-pointer standard
1816   //   conversions are performed on the second and third operands.
1817   DefaultFunctionArrayConversion(LHS);
1818   DefaultFunctionArrayConversion(RHS);
1819   LTy = LHS->getType();
1820   RTy = RHS->getType();
1821
1822   //   After those conversions, one of the following shall hold:
1823   //   -- The second and third operands have the same type; the result
1824   //      is of that type.
1825   if (Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy))
1826     return LTy;
1827
1828   //   -- The second and third operands have arithmetic or enumeration type;
1829   //      the usual arithmetic conversions are performed to bring them to a
1830   //      common type, and the result is of that type.
1831   if (LTy->isArithmeticType() && RTy->isArithmeticType()) {
1832     UsualArithmeticConversions(LHS, RHS);
1833     return LHS->getType();
1834   }
1835
1836   //   -- The second and third operands have pointer type, or one has pointer
1837   //      type and the other is a null pointer constant; pointer conversions
1838   //      and qualification conversions are performed to bring them to their
1839   //      composite pointer type. The result is of the composite pointer type.
1840   QualType Composite = FindCompositePointerType(LHS, RHS);
1841   if (!Composite.isNull())
1842     return Composite;
1843
1844   // Similarly, attempt to find composite type of twp objective-c pointers.
1845   Composite = FindCompositeObjCPointerType(LHS, RHS, QuestionLoc);
1846   if (!Composite.isNull())
1847     return Composite;
1848
1849   // Fourth bullet is same for pointers-to-member. However, the possible
1850   // conversions are far more limited: we have null-to-pointer, upcast of
1851   // containing class, and second-level cv-ness.
1852   // cv-ness is not a union, but must match one of the two operands. (Which,
1853   // frankly, is stupid.)
1854   const MemberPointerType *LMemPtr = LTy->getAs<MemberPointerType>();
1855   const MemberPointerType *RMemPtr = RTy->getAs<MemberPointerType>();
1856   if (LMemPtr &&
1857       RHS->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
1858     ImpCastExprToType(RHS, LTy, CastExpr::CK_NullToMemberPointer);
1859     return LTy;
1860   }
1861   if (RMemPtr &&
1862       LHS->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
1863     ImpCastExprToType(LHS, RTy, CastExpr::CK_NullToMemberPointer);
1864     return RTy;
1865   }
1866   if (LMemPtr && RMemPtr) {
1867     QualType LPointee = LMemPtr->getPointeeType();
1868     QualType RPointee = RMemPtr->getPointeeType();
1869
1870     QualifierCollector LPQuals, RPQuals;
1871     const Type *LPCan = LPQuals.strip(Context.getCanonicalType(LPointee));
1872     const Type *RPCan = RPQuals.strip(Context.getCanonicalType(RPointee));
1873
1874     // First, we check that the unqualified pointee type is the same. If it's
1875     // not, there's no conversion that will unify the two pointers.
1876     if (LPCan == RPCan) {
1877
1878       // Second, we take the greater of the two qualifications. If neither
1879       // is greater than the other, the conversion is not possible.
1880
1881       Qualifiers MergedQuals = LPQuals + RPQuals;
1882
1883       bool CompatibleQuals = true;
1884       if (MergedQuals.getCVRQualifiers() != LPQuals.getCVRQualifiers() &&
1885           MergedQuals.getCVRQualifiers() != RPQuals.getCVRQualifiers())
1886         CompatibleQuals = false;
1887       else if (LPQuals.getAddressSpace() != RPQuals.getAddressSpace())
1888         // FIXME:
1889         // C99 6.5.15 as modified by TR 18037:
1890         //   If the second and third operands are pointers into different
1891         //   address spaces, the address spaces must overlap.
1892         CompatibleQuals = false;
1893       // FIXME: GC qualifiers?
1894
1895       if (CompatibleQuals) {
1896         // Third, we check if either of the container classes is derived from
1897         // the other.
1898         QualType LContainer(LMemPtr->getClass(), 0);
1899         QualType RContainer(RMemPtr->getClass(), 0);
1900         QualType MoreDerived;
1901         if (Context.getCanonicalType(LContainer) ==
1902             Context.getCanonicalType(RContainer))
1903           MoreDerived = LContainer;
1904         else if (IsDerivedFrom(LContainer, RContainer))
1905           MoreDerived = LContainer;
1906         else if (IsDerivedFrom(RContainer, LContainer))
1907           MoreDerived = RContainer;
1908
1909         if (!MoreDerived.isNull()) {
1910           // The type 'Q Pointee (MoreDerived::*)' is the common type.
1911           // We don't use ImpCastExprToType here because this could still fail
1912           // for ambiguous or inaccessible conversions.
1913           LPointee = Context.getQualifiedType(LPointee, MergedQuals);
1914           QualType Common
1915             = Context.getMemberPointerType(LPointee, MoreDerived.getTypePtr());
1916           if (PerformImplicitConversion(LHS, Common, Sema::AA_Converting))
1917             return QualType();
1918           if (PerformImplicitConversion(RHS, Common, Sema::AA_Converting))
1919             return QualType();
1920           return Common;
1921         }
1922       }
1923     }
1924   }
1925
1926   Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
1927     << LHS->getType() << RHS->getType()
1928     << LHS->getSourceRange() << RHS->getSourceRange();
1929   return QualType();
1930 }
1931
1932 /// \brief Find a merged pointer type and convert the two expressions to it.
1933 ///
1934 /// This finds the composite pointer type (or member pointer type) for @p E1
1935 /// and @p E2 according to C++0x 5.9p2. It converts both expressions to this
1936 /// type and returns it.
1937 /// It does not emit diagnostics.
1938 QualType Sema::FindCompositePointerType(Expr *&E1, Expr *&E2) {
1939   assert(getLangOptions().CPlusPlus && "This function assumes C++");
1940   QualType T1 = E1->getType(), T2 = E2->getType();
1941
1942   if (!T1->isAnyPointerType() && !T1->isMemberPointerType() &&
1943       !T2->isAnyPointerType() && !T2->isMemberPointerType())
1944    return QualType();
1945
1946   // C++0x 5.9p2
1947   //   Pointer conversions and qualification conversions are performed on
1948   //   pointer operands to bring them to their composite pointer type. If
1949   //   one operand is a null pointer constant, the composite pointer type is
1950   //   the type of the other operand.
1951   if (E1->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
1952     if (T2->isMemberPointerType())
1953       ImpCastExprToType(E1, T2, CastExpr::CK_NullToMemberPointer);
1954     else
1955       ImpCastExprToType(E1, T2, CastExpr::CK_IntegralToPointer);
1956     return T2;
1957   }
1958   if (E2->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
1959     if (T1->isMemberPointerType())
1960       ImpCastExprToType(E2, T1, CastExpr::CK_NullToMemberPointer);
1961     else
1962       ImpCastExprToType(E2, T1, CastExpr::CK_IntegralToPointer);
1963     return T1;
1964   }
1965
1966   // Now both have to be pointers or member pointers.
1967   if ((!T1->isPointerType() && !T1->isMemberPointerType()) ||
1968       (!T2->isPointerType() && !T2->isMemberPointerType()))
1969     return QualType();
1970
1971   //   Otherwise, of one of the operands has type "pointer to cv1 void," then
1972   //   the other has type "pointer to cv2 T" and the composite pointer type is
1973   //   "pointer to cv12 void," where cv12 is the union of cv1 and cv2.
1974   //   Otherwise, the composite pointer type is a pointer type similar to the
1975   //   type of one of the operands, with a cv-qualification signature that is
1976   //   the union of the cv-qualification signatures of the operand types.
1977   // In practice, the first part here is redundant; it's subsumed by the second.
1978   // What we do here is, we build the two possible composite types, and try the
1979   // conversions in both directions. If only one works, or if the two composite
1980   // types are the same, we have succeeded.
1981   // FIXME: extended qualifiers?
1982   typedef llvm::SmallVector<unsigned, 4> QualifierVector;
1983   QualifierVector QualifierUnion;
1984   typedef llvm::SmallVector<std::pair<const Type *, const Type *>, 4>
1985       ContainingClassVector;
1986   ContainingClassVector MemberOfClass;
1987   QualType Composite1 = Context.getCanonicalType(T1),
1988            Composite2 = Context.getCanonicalType(T2);
1989   do {
1990     const PointerType *Ptr1, *Ptr2;
1991     if ((Ptr1 = Composite1->getAs<PointerType>()) &&
1992         (Ptr2 = Composite2->getAs<PointerType>())) {
1993       Composite1 = Ptr1->getPointeeType();
1994       Composite2 = Ptr2->getPointeeType();
1995       QualifierUnion.push_back(
1996                  Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers());
1997       MemberOfClass.push_back(std::make_pair((const Type *)0, (const Type *)0));
1998       continue;
1999     }
2000
2001     const MemberPointerType *MemPtr1, *MemPtr2;
2002     if ((MemPtr1 = Composite1->getAs<MemberPointerType>()) &&
2003         (MemPtr2 = Composite2->getAs<MemberPointerType>())) {
2004       Composite1 = MemPtr1->getPointeeType();
2005       Composite2 = MemPtr2->getPointeeType();
2006       QualifierUnion.push_back(
2007                  Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers());
2008       MemberOfClass.push_back(std::make_pair(MemPtr1->getClass(),
2009                                              MemPtr2->getClass()));
2010       continue;
2011     }
2012
2013     // FIXME: block pointer types?
2014
2015     // Cannot unwrap any more types.
2016     break;
2017   } while (true);
2018
2019   // Rewrap the composites as pointers or member pointers with the union CVRs.
2020   ContainingClassVector::reverse_iterator MOC
2021     = MemberOfClass.rbegin();
2022   for (QualifierVector::reverse_iterator
2023          I = QualifierUnion.rbegin(),
2024          E = QualifierUnion.rend();
2025        I != E; (void)++I, ++MOC) {
2026     Qualifiers Quals = Qualifiers::fromCVRMask(*I);
2027     if (MOC->first && MOC->second) {
2028       // Rebuild member pointer type
2029       Composite1 = Context.getMemberPointerType(
2030                                     Context.getQualifiedType(Composite1, Quals),
2031                                     MOC->first);
2032       Composite2 = Context.getMemberPointerType(
2033                                     Context.getQualifiedType(Composite2, Quals),
2034                                     MOC->second);
2035     } else {
2036       // Rebuild pointer type
2037       Composite1
2038         = Context.getPointerType(Context.getQualifiedType(Composite1, Quals));
2039       Composite2
2040         = Context.getPointerType(Context.getQualifiedType(Composite2, Quals));
2041     }
2042   }
2043
2044   ImplicitConversionSequence E1ToC1 =
2045     TryImplicitConversion(E1, Composite1,
2046                           /*SuppressUserConversions=*/false,
2047                           /*AllowExplicit=*/false,
2048                           /*ForceRValue=*/false,
2049                           /*InOverloadResolution=*/false);
2050   ImplicitConversionSequence E2ToC1 =
2051     TryImplicitConversion(E2, Composite1,
2052                           /*SuppressUserConversions=*/false,
2053                           /*AllowExplicit=*/false,
2054                           /*ForceRValue=*/false,
2055                           /*InOverloadResolution=*/false);
2056
2057   ImplicitConversionSequence E1ToC2, E2ToC2;
2058   E1ToC2.ConversionKind = ImplicitConversionSequence::BadConversion;
2059   E2ToC2.ConversionKind = ImplicitConversionSequence::BadConversion;
2060   if (Context.getCanonicalType(Composite1) !=
2061       Context.getCanonicalType(Composite2)) {
2062     E1ToC2 = TryImplicitConversion(E1, Composite2,
2063                                    /*SuppressUserConversions=*/false,
2064                                    /*AllowExplicit=*/false,
2065                                    /*ForceRValue=*/false,
2066                                    /*InOverloadResolution=*/false);
2067     E2ToC2 = TryImplicitConversion(E2, Composite2,
2068                                    /*SuppressUserConversions=*/false,
2069                                    /*AllowExplicit=*/false,
2070                                    /*ForceRValue=*/false,
2071                                    /*InOverloadResolution=*/false);
2072   }
2073
2074   bool ToC1Viable = E1ToC1.ConversionKind !=
2075                       ImplicitConversionSequence::BadConversion
2076                  && E2ToC1.ConversionKind !=
2077                       ImplicitConversionSequence::BadConversion;
2078   bool ToC2Viable = E1ToC2.ConversionKind !=
2079                       ImplicitConversionSequence::BadConversion
2080                  && E2ToC2.ConversionKind !=
2081                       ImplicitConversionSequence::BadConversion;
2082   if (ToC1Viable && !ToC2Viable) {
2083     if (!PerformImplicitConversion(E1, Composite1, E1ToC1, Sema::AA_Converting) &&
2084         !PerformImplicitConversion(E2, Composite1, E2ToC1, Sema::AA_Converting))
2085       return Composite1;
2086   }
2087   if (ToC2Viable && !ToC1Viable) {
2088     if (!PerformImplicitConversion(E1, Composite2, E1ToC2, Sema::AA_Converting) &&
2089         !PerformImplicitConversion(E2, Composite2, E2ToC2, Sema::AA_Converting))
2090       return Composite2;
2091   }
2092   return QualType();
2093 }
2094
2095 Sema::OwningExprResult Sema::MaybeBindToTemporary(Expr *E) {
2096   if (!Context.getLangOptions().CPlusPlus)
2097     return Owned(E);
2098
2099   assert(!isa<CXXBindTemporaryExpr>(E) && "Double-bound temporary?");
2100
2101   const RecordType *RT = E->getType()->getAs<RecordType>();
2102   if (!RT)
2103     return Owned(E);
2104
2105   CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
2106   if (RD->hasTrivialDestructor())
2107     return Owned(E);
2108
2109   if (CallExpr *CE = dyn_cast<CallExpr>(E)) {
2110     QualType Ty = CE->getCallee()->getType();
2111     if (const PointerType *PT = Ty->getAs<PointerType>())
2112       Ty = PT->getPointeeType();
2113
2114     const FunctionType *FTy = Ty->getAs<FunctionType>();
2115     if (FTy->getResultType()->isReferenceType())
2116       return Owned(E);
2117   }
2118   CXXTemporary *Temp = CXXTemporary::Create(Context,
2119                                             RD->getDestructor(Context));
2120   ExprTemporaries.push_back(Temp);
2121   if (CXXDestructorDecl *Destructor =
2122         const_cast<CXXDestructorDecl*>(RD->getDestructor(Context)))
2123     MarkDeclarationReferenced(E->getExprLoc(), Destructor);
2124   // FIXME: Add the temporary to the temporaries vector.
2125   return Owned(CXXBindTemporaryExpr::Create(Context, Temp, E));
2126 }
2127
2128 Expr *Sema::MaybeCreateCXXExprWithTemporaries(Expr *SubExpr) {
2129   assert(SubExpr && "sub expression can't be null!");
2130
2131   unsigned FirstTemporary = ExprEvalContexts.back().NumTemporaries;
2132   assert(ExprTemporaries.size() >= FirstTemporary);
2133   if (ExprTemporaries.size() == FirstTemporary)
2134     return SubExpr;
2135
2136   Expr *E = CXXExprWithTemporaries::Create(Context, SubExpr,
2137                                            &ExprTemporaries[FirstTemporary],
2138                                        ExprTemporaries.size() - FirstTemporary);
2139   ExprTemporaries.erase(ExprTemporaries.begin() + FirstTemporary,
2140                         ExprTemporaries.end());
2141
2142   return E;
2143 }
2144
2145 Sema::OwningExprResult
2146 Sema::MaybeCreateCXXExprWithTemporaries(OwningExprResult SubExpr) {
2147   if (SubExpr.isInvalid())
2148     return ExprError();
2149
2150   return Owned(MaybeCreateCXXExprWithTemporaries(SubExpr.takeAs<Expr>()));
2151 }
2152
2153 FullExpr Sema::CreateFullExpr(Expr *SubExpr) {
2154   unsigned FirstTemporary = ExprEvalContexts.back().NumTemporaries;
2155   assert(ExprTemporaries.size() >= FirstTemporary);
2156
2157   unsigned NumTemporaries = ExprTemporaries.size() - FirstTemporary;
2158   CXXTemporary **Temporaries =
2159     NumTemporaries == 0 ? 0 : &ExprTemporaries[FirstTemporary];
2160
2161   FullExpr E = FullExpr::Create(Context, SubExpr, Temporaries, NumTemporaries);
2162
2163   ExprTemporaries.erase(ExprTemporaries.begin() + FirstTemporary,
2164                         ExprTemporaries.end());
2165
2166   return E;
2167 }
2168
2169 Sema::OwningExprResult
2170 Sema::ActOnStartCXXMemberReference(Scope *S, ExprArg Base, SourceLocation OpLoc,
2171                                    tok::TokenKind OpKind, TypeTy *&ObjectType) {
2172   // Since this might be a postfix expression, get rid of ParenListExprs.
2173   Base = MaybeConvertParenListExprToParenExpr(S, move(Base));
2174
2175   Expr *BaseExpr = (Expr*)Base.get();
2176   assert(BaseExpr && "no record expansion");
2177
2178   QualType BaseType = BaseExpr->getType();
2179   if (BaseType->isDependentType()) {
2180     // If we have a pointer to a dependent type and are using the -> operator,
2181     // the object type is the type that the pointer points to. We might still
2182     // have enough information about that type to do something useful.
2183     if (OpKind == tok::arrow)
2184       if (const PointerType *Ptr = BaseType->getAs<PointerType>())
2185         BaseType = Ptr->getPointeeType();
2186
2187     ObjectType = BaseType.getAsOpaquePtr();
2188     return move(Base);
2189   }
2190
2191   // C++ [over.match.oper]p8:
2192   //   [...] When operator->returns, the operator-> is applied  to the value
2193   //   returned, with the original second operand.
2194   if (OpKind == tok::arrow) {
2195     // The set of types we've considered so far.
2196     llvm::SmallPtrSet<CanQualType,8> CTypes;
2197     llvm::SmallVector<SourceLocation, 8> Locations;
2198     CTypes.insert(Context.getCanonicalType(BaseType));
2199
2200     while (BaseType->isRecordType()) {
2201       Base = BuildOverloadedArrowExpr(S, move(Base), OpLoc);
2202       BaseExpr = (Expr*)Base.get();
2203       if (BaseExpr == NULL)
2204         return ExprError();
2205       if (CXXOperatorCallExpr *OpCall = dyn_cast<CXXOperatorCallExpr>(BaseExpr))
2206         Locations.push_back(OpCall->getDirectCallee()->getLocation());
2207       BaseType = BaseExpr->getType();
2208       CanQualType CBaseType = Context.getCanonicalType(BaseType);
2209       if (!CTypes.insert(CBaseType)) {
2210         Diag(OpLoc, diag::err_operator_arrow_circular);
2211         for (unsigned i = 0; i < Locations.size(); i++)
2212           Diag(Locations[i], diag::note_declared_at);
2213         return ExprError();
2214       }
2215     }
2216
2217     if (BaseType->isPointerType())
2218       BaseType = BaseType->getPointeeType();
2219   }
2220
2221   // We could end up with various non-record types here, such as extended
2222   // vector types or Objective-C interfaces. Just return early and let
2223   // ActOnMemberReferenceExpr do the work.
2224   if (!BaseType->isRecordType()) {
2225     // C++ [basic.lookup.classref]p2:
2226     //   [...] If the type of the object expression is of pointer to scalar
2227     //   type, the unqualified-id is looked up in the context of the complete
2228     //   postfix-expression.
2229     ObjectType = 0;
2230     return move(Base);
2231   }
2232
2233   // The object type must be complete (or dependent).
2234   if (!BaseType->isDependentType() &&
2235       RequireCompleteType(OpLoc, BaseType,
2236                           PDiag(diag::err_incomplete_member_access)))
2237     return ExprError();
2238
2239   // C++ [basic.lookup.classref]p2:
2240   //   If the id-expression in a class member access (5.2.5) is an
2241   //   unqualified-id, and the type of the object expression is of a class
2242   //   type C (or of pointer to a class type C), the unqualified-id is looked
2243   //   up in the scope of class C. [...]
2244   ObjectType = BaseType.getAsOpaquePtr();
2245
2246   return move(Base);
2247 }
2248
2249 CXXMemberCallExpr *Sema::BuildCXXMemberCallExpr(Expr *Exp,
2250                                                 CXXMethodDecl *Method) {
2251   if (PerformObjectArgumentInitialization(Exp, Method))
2252     assert(0 && "Calling BuildCXXMemberCallExpr with invalid call?");
2253
2254   MemberExpr *ME =
2255       new (Context) MemberExpr(Exp, /*IsArrow=*/false, Method,
2256                                SourceLocation(), Method->getType());
2257   QualType ResultType = Method->getResultType().getNonReferenceType();
2258   MarkDeclarationReferenced(Exp->getLocStart(), Method);
2259   CXXMemberCallExpr *CE =
2260     new (Context) CXXMemberCallExpr(Context, ME, 0, 0, ResultType,
2261                                     Exp->getLocEnd());
2262   return CE;
2263 }
2264
2265 Sema::OwningExprResult Sema::BuildCXXCastArgument(SourceLocation CastLoc,
2266                                                   QualType Ty,
2267                                                   CastExpr::CastKind Kind,
2268                                                   CXXMethodDecl *Method,
2269                                                   ExprArg Arg) {
2270   Expr *From = Arg.takeAs<Expr>();
2271
2272   switch (Kind) {
2273   default: assert(0 && "Unhandled cast kind!");
2274   case CastExpr::CK_ConstructorConversion: {
2275     ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(*this);
2276
2277     if (CompleteConstructorCall(cast<CXXConstructorDecl>(Method),
2278                                 MultiExprArg(*this, (void **)&From, 1),
2279                                 CastLoc, ConstructorArgs))
2280       return ExprError();
2281
2282     OwningExprResult Result =
2283       BuildCXXConstructExpr(CastLoc, Ty, cast<CXXConstructorDecl>(Method),
2284                             move_arg(ConstructorArgs));
2285     if (Result.isInvalid())
2286       return ExprError();
2287
2288     return MaybeBindToTemporary(Result.takeAs<Expr>());
2289   }
2290
2291   case CastExpr::CK_UserDefinedConversion: {
2292     assert(!From->getType()->isPointerType() && "Arg can't have pointer type!");
2293
2294     // Create an implicit call expr that calls it.
2295     CXXMemberCallExpr *CE = BuildCXXMemberCallExpr(From, Method);
2296     return MaybeBindToTemporary(CE);
2297   }
2298   }
2299 }
2300
2301 Sema::OwningExprResult Sema::ActOnFinishFullExpr(ExprArg Arg) {
2302   Expr *FullExpr = Arg.takeAs<Expr>();
2303   if (FullExpr)
2304     FullExpr = MaybeCreateCXXExprWithTemporaries(FullExpr);
2305
2306   return Owned(FullExpr);
2307 }
2308
2309 /// \brief Determine whether a reference to the given declaration in the
2310 /// current context is an implicit member access
2311 /// (C++ [class.mfct.non-static]p2).
2312 ///
2313 /// FIXME: Should Objective-C also use this approach?
2314 ///
2315 /// \param D the declaration being referenced from the current scope.
2316 ///
2317 /// \param NameLoc the location of the name in the source.
2318 ///
2319 /// \param ThisType if the reference to this declaration is an implicit member
2320 /// access, will be set to the type of the "this" pointer to be used when
2321 /// building that implicit member access.
2322 ///
2323 /// \returns true if this is an implicit member reference (in which case
2324 /// \p ThisType and \p MemberType will be set), or false if it is not an
2325 /// implicit member reference.
2326 bool Sema::isImplicitMemberReference(const LookupResult &R,
2327                                      QualType &ThisType) {
2328   // If this isn't a C++ method, then it isn't an implicit member reference.
2329   CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(CurContext);
2330   if (!MD || MD->isStatic())
2331     return false;
2332
2333   // C++ [class.mfct.nonstatic]p2:
2334   //   [...] if name lookup (3.4.1) resolves the name in the
2335   //   id-expression to a nonstatic nontype member of class X or of
2336   //   a base class of X, the id-expression is transformed into a
2337   //   class member access expression (5.2.5) using (*this) (9.3.2)
2338   //   as the postfix-expression to the left of the '.' operator.
2339   DeclContext *Ctx = 0;
2340   if (R.isUnresolvableResult()) {
2341     // FIXME: this is just picking one at random
2342     Ctx = R.getRepresentativeDecl()->getDeclContext();
2343   } else if (FieldDecl *FD = R.getAsSingle<FieldDecl>()) {
2344     Ctx = FD->getDeclContext();
2345   } else {
2346     for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {
2347       CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(*I);
2348       FunctionTemplateDecl *FunTmpl = 0;
2349       if (!Method && (FunTmpl = dyn_cast<FunctionTemplateDecl>(*I)))
2350         Method = dyn_cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl());
2351
2352       // FIXME: Do we have to know if there are explicit template arguments?
2353       if (Method && !Method->isStatic()) {
2354         Ctx = Method->getParent();
2355         break;
2356       }
2357     }
2358   }
2359
2360   if (!Ctx || !Ctx->isRecord())
2361     return false;
2362
2363   // Determine whether the declaration(s) we found are actually in a base
2364   // class. If not, this isn't an implicit member reference.
2365   ThisType = MD->getThisType(Context);
2366
2367   // FIXME: this doesn't really work for overloaded lookups.
2368
2369   QualType CtxType = Context.getTypeDeclType(cast<CXXRecordDecl>(Ctx));
2370   QualType ClassType
2371     = Context.getTypeDeclType(cast<CXXRecordDecl>(MD->getParent()));
2372   return Context.hasSameType(CtxType, ClassType) ||
2373          IsDerivedFrom(ClassType, CtxType);
2374 }
2375