SemaExprCXX.cpp revision 195099
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(Context, 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(Context, 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(Context, 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 // FIXME: Some of the type traits have requirements. Interestingly, only the 1027 // __is_base_of requirement is explicitly stated to be diagnosed. Indeed, G++ 1028 // accepts __is_pod(Incomplete) without complaints, and claims that the type 1029 // is indeed a POD. 1030 1031 // There is no point in eagerly computing the value. The traits are designed 1032 // to be used from type trait templates, so Ty will be a template parameter 1033 // 99% of the time. 1034 return Owned(new (Context) UnaryTypeTraitExpr(KWLoc, OTT, 1035 QualType::getFromOpaquePtr(Ty), 1036 RParen, Context.BoolTy)); 1037} 1038 1039QualType Sema::CheckPointerToMemberOperands( 1040 Expr *&lex, Expr *&rex, SourceLocation Loc, bool isIndirect) 1041{ 1042 const char *OpSpelling = isIndirect ? "->*" : ".*"; 1043 // C++ 5.5p2 1044 // The binary operator .* [p3: ->*] binds its second operand, which shall 1045 // be of type "pointer to member of T" (where T is a completely-defined 1046 // class type) [...] 1047 QualType RType = rex->getType(); 1048 const MemberPointerType *MemPtr = RType->getAsMemberPointerType(); 1049 if (!MemPtr) { 1050 Diag(Loc, diag::err_bad_memptr_rhs) 1051 << OpSpelling << RType << rex->getSourceRange(); 1052 return QualType(); 1053 } 1054 1055 QualType Class(MemPtr->getClass(), 0); 1056 1057 // C++ 5.5p2 1058 // [...] to its first operand, which shall be of class T or of a class of 1059 // which T is an unambiguous and accessible base class. [p3: a pointer to 1060 // such a class] 1061 QualType LType = lex->getType(); 1062 if (isIndirect) { 1063 if (const PointerType *Ptr = LType->getAsPointerType()) 1064 LType = Ptr->getPointeeType().getNonReferenceType(); 1065 else { 1066 Diag(Loc, diag::err_bad_memptr_lhs) 1067 << OpSpelling << 1 << LType << lex->getSourceRange(); 1068 return QualType(); 1069 } 1070 } 1071 1072 if (Context.getCanonicalType(Class).getUnqualifiedType() != 1073 Context.getCanonicalType(LType).getUnqualifiedType()) { 1074 BasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/false, 1075 /*DetectVirtual=*/false); 1076 // FIXME: Would it be useful to print full ambiguity paths, or is that 1077 // overkill? 1078 if (!IsDerivedFrom(LType, Class, Paths) || 1079 Paths.isAmbiguous(Context.getCanonicalType(Class))) { 1080 Diag(Loc, diag::err_bad_memptr_lhs) << OpSpelling 1081 << (int)isIndirect << lex->getType() << lex->getSourceRange(); 1082 return QualType(); 1083 } 1084 } 1085 1086 // C++ 5.5p2 1087 // The result is an object or a function of the type specified by the 1088 // second operand. 1089 // The cv qualifiers are the union of those in the pointer and the left side, 1090 // in accordance with 5.5p5 and 5.2.5. 1091 // FIXME: This returns a dereferenced member function pointer as a normal 1092 // function type. However, the only operation valid on such functions is 1093 // calling them. There's also a GCC extension to get a function pointer to the 1094 // thing, which is another complication, because this type - unlike the type 1095 // that is the result of this expression - takes the class as the first 1096 // argument. 1097 // We probably need a "MemberFunctionClosureType" or something like that. 1098 QualType Result = MemPtr->getPointeeType(); 1099 if (LType.isConstQualified()) 1100 Result.addConst(); 1101 if (LType.isVolatileQualified()) 1102 Result.addVolatile(); 1103 return Result; 1104} 1105 1106/// \brief Get the target type of a standard or user-defined conversion. 1107static QualType TargetType(const ImplicitConversionSequence &ICS) { 1108 assert((ICS.ConversionKind == 1109 ImplicitConversionSequence::StandardConversion || 1110 ICS.ConversionKind == 1111 ImplicitConversionSequence::UserDefinedConversion) && 1112 "function only valid for standard or user-defined conversions"); 1113 if (ICS.ConversionKind == ImplicitConversionSequence::StandardConversion) 1114 return QualType::getFromOpaquePtr(ICS.Standard.ToTypePtr); 1115 return QualType::getFromOpaquePtr(ICS.UserDefined.After.ToTypePtr); 1116} 1117 1118/// \brief Try to convert a type to another according to C++0x 5.16p3. 1119/// 1120/// This is part of the parameter validation for the ? operator. If either 1121/// value operand is a class type, the two operands are attempted to be 1122/// converted to each other. This function does the conversion in one direction. 1123/// It emits a diagnostic and returns true only if it finds an ambiguous 1124/// conversion. 1125static bool TryClassUnification(Sema &Self, Expr *From, Expr *To, 1126 SourceLocation QuestionLoc, 1127 ImplicitConversionSequence &ICS) 1128{ 1129 // C++0x 5.16p3 1130 // The process for determining whether an operand expression E1 of type T1 1131 // can be converted to match an operand expression E2 of type T2 is defined 1132 // as follows: 1133 // -- If E2 is an lvalue: 1134 if (To->isLvalue(Self.Context) == Expr::LV_Valid) { 1135 // E1 can be converted to match E2 if E1 can be implicitly converted to 1136 // type "lvalue reference to T2", subject to the constraint that in the 1137 // conversion the reference must bind directly to E1. 1138 if (!Self.CheckReferenceInit(From, 1139 Self.Context.getLValueReferenceType(To->getType()), 1140 &ICS)) 1141 { 1142 assert((ICS.ConversionKind == 1143 ImplicitConversionSequence::StandardConversion || 1144 ICS.ConversionKind == 1145 ImplicitConversionSequence::UserDefinedConversion) && 1146 "expected a definite conversion"); 1147 bool DirectBinding = 1148 ICS.ConversionKind == ImplicitConversionSequence::StandardConversion ? 1149 ICS.Standard.DirectBinding : ICS.UserDefined.After.DirectBinding; 1150 if (DirectBinding) 1151 return false; 1152 } 1153 } 1154 ICS.ConversionKind = ImplicitConversionSequence::BadConversion; 1155 // -- If E2 is an rvalue, or if the conversion above cannot be done: 1156 // -- if E1 and E2 have class type, and the underlying class types are 1157 // the same or one is a base class of the other: 1158 QualType FTy = From->getType(); 1159 QualType TTy = To->getType(); 1160 const RecordType *FRec = FTy->getAsRecordType(); 1161 const RecordType *TRec = TTy->getAsRecordType(); 1162 bool FDerivedFromT = FRec && TRec && Self.IsDerivedFrom(FTy, TTy); 1163 if (FRec && TRec && (FRec == TRec || 1164 FDerivedFromT || Self.IsDerivedFrom(TTy, FTy))) { 1165 // E1 can be converted to match E2 if the class of T2 is the 1166 // same type as, or a base class of, the class of T1, and 1167 // [cv2 > cv1]. 1168 if ((FRec == TRec || FDerivedFromT) && TTy.isAtLeastAsQualifiedAs(FTy)) { 1169 // Could still fail if there's no copy constructor. 1170 // FIXME: Is this a hard error then, or just a conversion failure? The 1171 // standard doesn't say. 1172 ICS = Self.TryCopyInitialization(From, TTy); 1173 } 1174 } else { 1175 // -- Otherwise: E1 can be converted to match E2 if E1 can be 1176 // implicitly converted to the type that expression E2 would have 1177 // if E2 were converted to an rvalue. 1178 // First find the decayed type. 1179 if (TTy->isFunctionType()) 1180 TTy = Self.Context.getPointerType(TTy); 1181 else if(TTy->isArrayType()) 1182 TTy = Self.Context.getArrayDecayedType(TTy); 1183 1184 // Now try the implicit conversion. 1185 // FIXME: This doesn't detect ambiguities. 1186 ICS = Self.TryImplicitConversion(From, TTy); 1187 } 1188 return false; 1189} 1190 1191/// \brief Try to find a common type for two according to C++0x 5.16p5. 1192/// 1193/// This is part of the parameter validation for the ? operator. If either 1194/// value operand is a class type, overload resolution is used to find a 1195/// conversion to a common type. 1196static bool FindConditionalOverload(Sema &Self, Expr *&LHS, Expr *&RHS, 1197 SourceLocation Loc) { 1198 Expr *Args[2] = { LHS, RHS }; 1199 OverloadCandidateSet CandidateSet; 1200 Self.AddBuiltinOperatorCandidates(OO_Conditional, Args, 2, CandidateSet); 1201 1202 OverloadCandidateSet::iterator Best; 1203 switch (Self.BestViableFunction(CandidateSet, Loc, Best)) { 1204 case Sema::OR_Success: 1205 // We found a match. Perform the conversions on the arguments and move on. 1206 if (Self.PerformImplicitConversion(LHS, Best->BuiltinTypes.ParamTypes[0], 1207 Best->Conversions[0], "converting") || 1208 Self.PerformImplicitConversion(RHS, Best->BuiltinTypes.ParamTypes[1], 1209 Best->Conversions[1], "converting")) 1210 break; 1211 return false; 1212 1213 case Sema::OR_No_Viable_Function: 1214 Self.Diag(Loc, diag::err_typecheck_cond_incompatible_operands) 1215 << LHS->getType() << RHS->getType() 1216 << LHS->getSourceRange() << RHS->getSourceRange(); 1217 return true; 1218 1219 case Sema::OR_Ambiguous: 1220 Self.Diag(Loc, diag::err_conditional_ambiguous_ovl) 1221 << LHS->getType() << RHS->getType() 1222 << LHS->getSourceRange() << RHS->getSourceRange(); 1223 // FIXME: Print the possible common types by printing the return types of 1224 // the viable candidates. 1225 break; 1226 1227 case Sema::OR_Deleted: 1228 assert(false && "Conditional operator has only built-in overloads"); 1229 break; 1230 } 1231 return true; 1232} 1233 1234/// \brief Perform an "extended" implicit conversion as returned by 1235/// TryClassUnification. 1236/// 1237/// TryClassUnification generates ICSs that include reference bindings. 1238/// PerformImplicitConversion is not suitable for this; it chokes if the 1239/// second part of a standard conversion is ICK_DerivedToBase. This function 1240/// handles the reference binding specially. 1241static bool ConvertForConditional(Sema &Self, Expr *&E, 1242 const ImplicitConversionSequence &ICS) 1243{ 1244 if (ICS.ConversionKind == ImplicitConversionSequence::StandardConversion && 1245 ICS.Standard.ReferenceBinding) { 1246 assert(ICS.Standard.DirectBinding && 1247 "TryClassUnification should never generate indirect ref bindings"); 1248 // FIXME: CheckReferenceInit should be able to reuse the ICS instead of 1249 // redoing all the work. 1250 return Self.CheckReferenceInit(E, Self.Context.getLValueReferenceType( 1251 TargetType(ICS))); 1252 } 1253 if (ICS.ConversionKind == ImplicitConversionSequence::UserDefinedConversion && 1254 ICS.UserDefined.After.ReferenceBinding) { 1255 assert(ICS.UserDefined.After.DirectBinding && 1256 "TryClassUnification should never generate indirect ref bindings"); 1257 return Self.CheckReferenceInit(E, Self.Context.getLValueReferenceType( 1258 TargetType(ICS))); 1259 } 1260 if (Self.PerformImplicitConversion(E, TargetType(ICS), ICS, "converting")) 1261 return true; 1262 return false; 1263} 1264 1265/// \brief Check the operands of ?: under C++ semantics. 1266/// 1267/// See C++ [expr.cond]. Note that LHS is never null, even for the GNU x ?: y 1268/// extension. In this case, LHS == Cond. (But they're not aliases.) 1269QualType Sema::CXXCheckConditionalOperands(Expr *&Cond, Expr *&LHS, Expr *&RHS, 1270 SourceLocation QuestionLoc) { 1271 // FIXME: Handle C99's complex types, vector types, block pointers and Obj-C++ 1272 // interface pointers. 1273 1274 // C++0x 5.16p1 1275 // The first expression is contextually converted to bool. 1276 if (!Cond->isTypeDependent()) { 1277 if (CheckCXXBooleanCondition(Cond)) 1278 return QualType(); 1279 } 1280 1281 // Either of the arguments dependent? 1282 if (LHS->isTypeDependent() || RHS->isTypeDependent()) 1283 return Context.DependentTy; 1284 1285 // C++0x 5.16p2 1286 // If either the second or the third operand has type (cv) void, ... 1287 QualType LTy = LHS->getType(); 1288 QualType RTy = RHS->getType(); 1289 bool LVoid = LTy->isVoidType(); 1290 bool RVoid = RTy->isVoidType(); 1291 if (LVoid || RVoid) { 1292 // ... then the [l2r] conversions are performed on the second and third 1293 // operands ... 1294 DefaultFunctionArrayConversion(LHS); 1295 DefaultFunctionArrayConversion(RHS); 1296 LTy = LHS->getType(); 1297 RTy = RHS->getType(); 1298 1299 // ... and one of the following shall hold: 1300 // -- The second or the third operand (but not both) is a throw- 1301 // expression; the result is of the type of the other and is an rvalue. 1302 bool LThrow = isa<CXXThrowExpr>(LHS); 1303 bool RThrow = isa<CXXThrowExpr>(RHS); 1304 if (LThrow && !RThrow) 1305 return RTy; 1306 if (RThrow && !LThrow) 1307 return LTy; 1308 1309 // -- Both the second and third operands have type void; the result is of 1310 // type void and is an rvalue. 1311 if (LVoid && RVoid) 1312 return Context.VoidTy; 1313 1314 // Neither holds, error. 1315 Diag(QuestionLoc, diag::err_conditional_void_nonvoid) 1316 << (LVoid ? RTy : LTy) << (LVoid ? 0 : 1) 1317 << LHS->getSourceRange() << RHS->getSourceRange(); 1318 return QualType(); 1319 } 1320 1321 // Neither is void. 1322 1323 // C++0x 5.16p3 1324 // Otherwise, if the second and third operand have different types, and 1325 // either has (cv) class type, and attempt is made to convert each of those 1326 // operands to the other. 1327 if (Context.getCanonicalType(LTy) != Context.getCanonicalType(RTy) && 1328 (LTy->isRecordType() || RTy->isRecordType())) { 1329 ImplicitConversionSequence ICSLeftToRight, ICSRightToLeft; 1330 // These return true if a single direction is already ambiguous. 1331 if (TryClassUnification(*this, LHS, RHS, QuestionLoc, ICSLeftToRight)) 1332 return QualType(); 1333 if (TryClassUnification(*this, RHS, LHS, QuestionLoc, ICSRightToLeft)) 1334 return QualType(); 1335 1336 bool HaveL2R = ICSLeftToRight.ConversionKind != 1337 ImplicitConversionSequence::BadConversion; 1338 bool HaveR2L = ICSRightToLeft.ConversionKind != 1339 ImplicitConversionSequence::BadConversion; 1340 // If both can be converted, [...] the program is ill-formed. 1341 if (HaveL2R && HaveR2L) { 1342 Diag(QuestionLoc, diag::err_conditional_ambiguous) 1343 << LTy << RTy << LHS->getSourceRange() << RHS->getSourceRange(); 1344 return QualType(); 1345 } 1346 1347 // If exactly one conversion is possible, that conversion is applied to 1348 // the chosen operand and the converted operands are used in place of the 1349 // original operands for the remainder of this section. 1350 if (HaveL2R) { 1351 if (ConvertForConditional(*this, LHS, ICSLeftToRight)) 1352 return QualType(); 1353 LTy = LHS->getType(); 1354 } else if (HaveR2L) { 1355 if (ConvertForConditional(*this, RHS, ICSRightToLeft)) 1356 return QualType(); 1357 RTy = RHS->getType(); 1358 } 1359 } 1360 1361 // C++0x 5.16p4 1362 // If the second and third operands are lvalues and have the same type, 1363 // the result is of that type [...] 1364 bool Same = Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy); 1365 if (Same && LHS->isLvalue(Context) == Expr::LV_Valid && 1366 RHS->isLvalue(Context) == Expr::LV_Valid) 1367 return LTy; 1368 1369 // C++0x 5.16p5 1370 // Otherwise, the result is an rvalue. If the second and third operands 1371 // do not have the same type, and either has (cv) class type, ... 1372 if (!Same && (LTy->isRecordType() || RTy->isRecordType())) { 1373 // ... overload resolution is used to determine the conversions (if any) 1374 // to be applied to the operands. If the overload resolution fails, the 1375 // program is ill-formed. 1376 if (FindConditionalOverload(*this, LHS, RHS, QuestionLoc)) 1377 return QualType(); 1378 } 1379 1380 // C++0x 5.16p6 1381 // LValue-to-rvalue, array-to-pointer, and function-to-pointer standard 1382 // conversions are performed on the second and third operands. 1383 DefaultFunctionArrayConversion(LHS); 1384 DefaultFunctionArrayConversion(RHS); 1385 LTy = LHS->getType(); 1386 RTy = RHS->getType(); 1387 1388 // After those conversions, one of the following shall hold: 1389 // -- The second and third operands have the same type; the result 1390 // is of that type. 1391 if (Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy)) 1392 return LTy; 1393 1394 // -- The second and third operands have arithmetic or enumeration type; 1395 // the usual arithmetic conversions are performed to bring them to a 1396 // common type, and the result is of that type. 1397 if (LTy->isArithmeticType() && RTy->isArithmeticType()) { 1398 UsualArithmeticConversions(LHS, RHS); 1399 return LHS->getType(); 1400 } 1401 1402 // -- The second and third operands have pointer type, or one has pointer 1403 // type and the other is a null pointer constant; pointer conversions 1404 // and qualification conversions are performed to bring them to their 1405 // composite pointer type. The result is of the composite pointer type. 1406 QualType Composite = FindCompositePointerType(LHS, RHS); 1407 if (!Composite.isNull()) 1408 return Composite; 1409 1410 // Fourth bullet is same for pointers-to-member. However, the possible 1411 // conversions are far more limited: we have null-to-pointer, upcast of 1412 // containing class, and second-level cv-ness. 1413 // cv-ness is not a union, but must match one of the two operands. (Which, 1414 // frankly, is stupid.) 1415 const MemberPointerType *LMemPtr = LTy->getAsMemberPointerType(); 1416 const MemberPointerType *RMemPtr = RTy->getAsMemberPointerType(); 1417 if (LMemPtr && RHS->isNullPointerConstant(Context)) { 1418 ImpCastExprToType(RHS, LTy); 1419 return LTy; 1420 } 1421 if (RMemPtr && LHS->isNullPointerConstant(Context)) { 1422 ImpCastExprToType(LHS, RTy); 1423 return RTy; 1424 } 1425 if (LMemPtr && RMemPtr) { 1426 QualType LPointee = LMemPtr->getPointeeType(); 1427 QualType RPointee = RMemPtr->getPointeeType(); 1428 // First, we check that the unqualified pointee type is the same. If it's 1429 // not, there's no conversion that will unify the two pointers. 1430 if (Context.getCanonicalType(LPointee).getUnqualifiedType() == 1431 Context.getCanonicalType(RPointee).getUnqualifiedType()) { 1432 // Second, we take the greater of the two cv qualifications. If neither 1433 // is greater than the other, the conversion is not possible. 1434 unsigned Q = LPointee.getCVRQualifiers() | RPointee.getCVRQualifiers(); 1435 if (Q == LPointee.getCVRQualifiers() || Q == RPointee.getCVRQualifiers()){ 1436 // Third, we check if either of the container classes is derived from 1437 // the other. 1438 QualType LContainer(LMemPtr->getClass(), 0); 1439 QualType RContainer(RMemPtr->getClass(), 0); 1440 QualType MoreDerived; 1441 if (Context.getCanonicalType(LContainer) == 1442 Context.getCanonicalType(RContainer)) 1443 MoreDerived = LContainer; 1444 else if (IsDerivedFrom(LContainer, RContainer)) 1445 MoreDerived = LContainer; 1446 else if (IsDerivedFrom(RContainer, LContainer)) 1447 MoreDerived = RContainer; 1448 1449 if (!MoreDerived.isNull()) { 1450 // The type 'Q Pointee (MoreDerived::*)' is the common type. 1451 // We don't use ImpCastExprToType here because this could still fail 1452 // for ambiguous or inaccessible conversions. 1453 QualType Common = Context.getMemberPointerType( 1454 LPointee.getQualifiedType(Q), MoreDerived.getTypePtr()); 1455 if (PerformImplicitConversion(LHS, Common, "converting")) 1456 return QualType(); 1457 if (PerformImplicitConversion(RHS, Common, "converting")) 1458 return QualType(); 1459 return Common; 1460 } 1461 } 1462 } 1463 } 1464 1465 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands) 1466 << LHS->getType() << RHS->getType() 1467 << LHS->getSourceRange() << RHS->getSourceRange(); 1468 return QualType(); 1469} 1470 1471/// \brief Find a merged pointer type and convert the two expressions to it. 1472/// 1473/// This finds the composite pointer type for @p E1 and @p E2 according to 1474/// C++0x 5.9p2. It converts both expressions to this type and returns it. 1475/// It does not emit diagnostics. 1476QualType Sema::FindCompositePointerType(Expr *&E1, Expr *&E2) { 1477 assert(getLangOptions().CPlusPlus && "This function assumes C++"); 1478 QualType T1 = E1->getType(), T2 = E2->getType(); 1479 if(!T1->isPointerType() && !T2->isPointerType()) 1480 return QualType(); 1481 1482 // C++0x 5.9p2 1483 // Pointer conversions and qualification conversions are performed on 1484 // pointer operands to bring them to their composite pointer type. If 1485 // one operand is a null pointer constant, the composite pointer type is 1486 // the type of the other operand. 1487 if (E1->isNullPointerConstant(Context)) { 1488 ImpCastExprToType(E1, T2); 1489 return T2; 1490 } 1491 if (E2->isNullPointerConstant(Context)) { 1492 ImpCastExprToType(E2, T1); 1493 return T1; 1494 } 1495 // Now both have to be pointers. 1496 if(!T1->isPointerType() || !T2->isPointerType()) 1497 return QualType(); 1498 1499 // Otherwise, of one of the operands has type "pointer to cv1 void," then 1500 // the other has type "pointer to cv2 T" and the composite pointer type is 1501 // "pointer to cv12 void," where cv12 is the union of cv1 and cv2. 1502 // Otherwise, the composite pointer type is a pointer type similar to the 1503 // type of one of the operands, with a cv-qualification signature that is 1504 // the union of the cv-qualification signatures of the operand types. 1505 // In practice, the first part here is redundant; it's subsumed by the second. 1506 // What we do here is, we build the two possible composite types, and try the 1507 // conversions in both directions. If only one works, or if the two composite 1508 // types are the same, we have succeeded. 1509 llvm::SmallVector<unsigned, 4> QualifierUnion; 1510 QualType Composite1 = T1, Composite2 = T2; 1511 const PointerType *Ptr1, *Ptr2; 1512 while ((Ptr1 = Composite1->getAsPointerType()) && 1513 (Ptr2 = Composite2->getAsPointerType())) { 1514 Composite1 = Ptr1->getPointeeType(); 1515 Composite2 = Ptr2->getPointeeType(); 1516 QualifierUnion.push_back( 1517 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers()); 1518 } 1519 // Rewrap the composites as pointers with the union CVRs. 1520 for (llvm::SmallVector<unsigned, 4>::iterator I = QualifierUnion.begin(), 1521 E = QualifierUnion.end(); I != E; ++I) { 1522 Composite1 = Context.getPointerType(Composite1.getQualifiedType(*I)); 1523 Composite2 = Context.getPointerType(Composite2.getQualifiedType(*I)); 1524 } 1525 1526 ImplicitConversionSequence E1ToC1 = TryImplicitConversion(E1, Composite1); 1527 ImplicitConversionSequence E2ToC1 = TryImplicitConversion(E2, Composite1); 1528 ImplicitConversionSequence E1ToC2, E2ToC2; 1529 E1ToC2.ConversionKind = ImplicitConversionSequence::BadConversion; 1530 E2ToC2.ConversionKind = ImplicitConversionSequence::BadConversion; 1531 if (Context.getCanonicalType(Composite1) != 1532 Context.getCanonicalType(Composite2)) { 1533 E1ToC2 = TryImplicitConversion(E1, Composite2); 1534 E2ToC2 = TryImplicitConversion(E2, Composite2); 1535 } 1536 1537 bool ToC1Viable = E1ToC1.ConversionKind != 1538 ImplicitConversionSequence::BadConversion 1539 && E2ToC1.ConversionKind != 1540 ImplicitConversionSequence::BadConversion; 1541 bool ToC2Viable = E1ToC2.ConversionKind != 1542 ImplicitConversionSequence::BadConversion 1543 && E2ToC2.ConversionKind != 1544 ImplicitConversionSequence::BadConversion; 1545 if (ToC1Viable && !ToC2Viable) { 1546 if (!PerformImplicitConversion(E1, Composite1, E1ToC1, "converting") && 1547 !PerformImplicitConversion(E2, Composite1, E2ToC1, "converting")) 1548 return Composite1; 1549 } 1550 if (ToC2Viable && !ToC1Viable) { 1551 if (!PerformImplicitConversion(E1, Composite2, E1ToC2, "converting") && 1552 !PerformImplicitConversion(E2, Composite2, E2ToC2, "converting")) 1553 return Composite2; 1554 } 1555 return QualType(); 1556} 1557 1558Sema::OwningExprResult Sema::MaybeBindToTemporary(Expr *E) { 1559 const RecordType *RT = E->getType()->getAsRecordType(); 1560 if (!RT) 1561 return Owned(E); 1562 1563 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 1564 if (RD->hasTrivialDestructor()) 1565 return Owned(E); 1566 1567 CXXTemporary *Temp = CXXTemporary::Create(Context, 1568 RD->getDestructor(Context)); 1569 ExprTemporaries.push_back(Temp); 1570 MarcDestructorReferenced(E->getExprLoc(), E->getType()); 1571 // FIXME: Add the temporary to the temporaries vector. 1572 return Owned(CXXBindTemporaryExpr::Create(Context, Temp, E)); 1573} 1574 1575// FIXME: This doesn't handle casts yet. 1576Expr *Sema::RemoveOutermostTemporaryBinding(Expr *E) { 1577 const RecordType *RT = E->getType()->getAsRecordType(); 1578 if (!RT) 1579 return E; 1580 1581 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 1582 if (RD->hasTrivialDestructor()) 1583 return E; 1584 1585 /// The expr passed in must be a CXXExprWithTemporaries. 1586 CXXExprWithTemporaries *TempExpr = dyn_cast<CXXExprWithTemporaries>(E); 1587 if (!TempExpr) 1588 return E; 1589 1590 Expr *SubExpr = TempExpr->getSubExpr(); 1591 if (CXXBindTemporaryExpr *BE = dyn_cast<CXXBindTemporaryExpr>(SubExpr)) { 1592 assert(BE->getTemporary() == 1593 TempExpr->getTemporary(TempExpr->getNumTemporaries() - 1) && 1594 "Found temporary is not last in list!"); 1595 1596 Expr *BindSubExpr = BE->getSubExpr(); 1597 BE->setSubExpr(0); 1598 1599 if (TempExpr->getNumTemporaries() == 1) { 1600 // There's just one temporary left, so we don't need the TempExpr node. 1601 TempExpr->Destroy(Context); 1602 return BindSubExpr; 1603 } else { 1604 TempExpr->removeLastTemporary(); 1605 TempExpr->setSubExpr(BindSubExpr); 1606 BE->Destroy(Context); 1607 } 1608 1609 return E; 1610 } 1611 1612 // FIXME: We might need to handle other expressions here. 1613 return E; 1614} 1615 1616Expr *Sema::MaybeCreateCXXExprWithTemporaries(Expr *SubExpr, 1617 bool ShouldDestroyTemps) { 1618 assert(SubExpr && "sub expression can't be null!"); 1619 1620 if (ExprTemporaries.empty()) 1621 return SubExpr; 1622 1623 Expr *E = CXXExprWithTemporaries::Create(Context, SubExpr, 1624 &ExprTemporaries[0], 1625 ExprTemporaries.size(), 1626 ShouldDestroyTemps); 1627 ExprTemporaries.clear(); 1628 1629 return E; 1630} 1631 1632Sema::OwningExprResult Sema::ActOnFinishFullExpr(ExprArg Arg) { 1633 Expr *FullExpr = Arg.takeAs<Expr>(); 1634 if (FullExpr) 1635 FullExpr = MaybeCreateCXXExprWithTemporaries(FullExpr, 1636 /*ShouldDestroyTemps=*/true); 1637 1638 return Owned(FullExpr); 1639} 1640