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