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