SemaExprCXX.cpp revision b2c352ed5586cf869a5dad87a528b9ac000d2fae
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 CanQualType 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->getAs<RecordType>()) { 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->getAs<PointerType>()) { 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], /*functional-style*/true)) 207 return ExprError(); 208 exprs.release(); 209 return Owned(new (Context) CXXFunctionalCastExpr(Ty.getNonReferenceType(), 210 Ty, TyBeginLoc, 211 CastExpr::CK_Unknown, 212 Exprs[0], RParenLoc)); 213 } 214 215 if (const RecordType *RT = Ty->getAs<RecordType>()) { 216 CXXRecordDecl *Record = cast<CXXRecordDecl>(RT->getDecl()); 217 218 // FIXME: We should always create a CXXTemporaryObjectExpr here unless 219 // both the ctor and dtor are trivial. 220 if (NumExprs > 1 || Record->hasUserDeclaredConstructor()) { 221 CXXConstructorDecl *Constructor 222 = PerformInitializationByConstructor(Ty, Exprs, NumExprs, 223 TypeRange.getBegin(), 224 SourceRange(TypeRange.getBegin(), 225 RParenLoc), 226 DeclarationName(), 227 IK_Direct); 228 229 if (!Constructor) 230 return ExprError(); 231 232 exprs.release(); 233 Expr *E = new (Context) CXXTemporaryObjectExpr(Context, Constructor, 234 Ty, TyBeginLoc, Exprs, 235 NumExprs, RParenLoc); 236 return MaybeBindToTemporary(E); 237 } 238 239 // Fall through to value-initialize an object of class type that 240 // doesn't have a user-declared default constructor. 241 } 242 243 // C++ [expr.type.conv]p1: 244 // If the expression list specifies more than a single value, the type shall 245 // be a class with a suitably declared constructor. 246 // 247 if (NumExprs > 1) 248 return ExprError(Diag(CommaLocs[0], 249 diag::err_builtin_func_cast_more_than_one_arg) 250 << FullRange); 251 252 assert(NumExprs == 0 && "Expected 0 expressions"); 253 254 // C++ [expr.type.conv]p2: 255 // The expression T(), where T is a simple-type-specifier for a non-array 256 // complete object type or the (possibly cv-qualified) void type, creates an 257 // rvalue of the specified type, which is value-initialized. 258 // 259 if (Ty->isArrayType()) 260 return ExprError(Diag(TyBeginLoc, 261 diag::err_value_init_for_array_type) << FullRange); 262 if (!Ty->isDependentType() && !Ty->isVoidType() && 263 RequireCompleteType(TyBeginLoc, Ty, 264 diag::err_invalid_incomplete_type_use, FullRange)) 265 return ExprError(); 266 267 if (RequireNonAbstractType(TyBeginLoc, Ty, 268 diag::err_allocation_of_abstract_type)) 269 return ExprError(); 270 271 exprs.release(); 272 return Owned(new (Context) CXXZeroInitValueExpr(Ty, TyBeginLoc, RParenLoc)); 273} 274 275 276/// ActOnCXXNew - Parsed a C++ 'new' expression (C++ 5.3.4), as in e.g.: 277/// @code new (memory) int[size][4] @endcode 278/// or 279/// @code ::new Foo(23, "hello") @endcode 280/// For the interpretation of this heap of arguments, consult the base version. 281Action::OwningExprResult 282Sema::ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal, 283 SourceLocation PlacementLParen, MultiExprArg PlacementArgs, 284 SourceLocation PlacementRParen, bool ParenTypeId, 285 Declarator &D, SourceLocation ConstructorLParen, 286 MultiExprArg ConstructorArgs, 287 SourceLocation ConstructorRParen) 288{ 289 Expr *ArraySize = 0; 290 unsigned Skip = 0; 291 // If the specified type is an array, unwrap it and save the expression. 292 if (D.getNumTypeObjects() > 0 && 293 D.getTypeObject(0).Kind == DeclaratorChunk::Array) { 294 DeclaratorChunk &Chunk = D.getTypeObject(0); 295 if (Chunk.Arr.hasStatic) 296 return ExprError(Diag(Chunk.Loc, diag::err_static_illegal_in_new) 297 << D.getSourceRange()); 298 if (!Chunk.Arr.NumElts) 299 return ExprError(Diag(Chunk.Loc, diag::err_array_new_needs_size) 300 << D.getSourceRange()); 301 ArraySize = static_cast<Expr*>(Chunk.Arr.NumElts); 302 Skip = 1; 303 } 304 305 QualType AllocType = GetTypeForDeclarator(D, /*Scope=*/0, Skip); 306 if (D.isInvalidType()) 307 return ExprError(); 308 309 // Every dimension shall be of constant size. 310 unsigned i = 1; 311 QualType ElementType = AllocType; 312 while (const ArrayType *Array = Context.getAsArrayType(ElementType)) { 313 if (!Array->isConstantArrayType()) { 314 Diag(D.getTypeObject(i).Loc, diag::err_new_array_nonconst) 315 << static_cast<Expr*>(D.getTypeObject(i).Arr.NumElts)->getSourceRange(); 316 return ExprError(); 317 } 318 ElementType = Array->getElementType(); 319 ++i; 320 } 321 322 return BuildCXXNew(StartLoc, UseGlobal, 323 PlacementLParen, 324 move(PlacementArgs), 325 PlacementRParen, 326 ParenTypeId, 327 AllocType, 328 D.getSourceRange().getBegin(), 329 D.getSourceRange(), 330 Owned(ArraySize), 331 ConstructorLParen, 332 move(ConstructorArgs), 333 ConstructorRParen); 334} 335 336Sema::OwningExprResult 337Sema::BuildCXXNew(SourceLocation StartLoc, bool UseGlobal, 338 SourceLocation PlacementLParen, 339 MultiExprArg PlacementArgs, 340 SourceLocation PlacementRParen, 341 bool ParenTypeId, 342 QualType AllocType, 343 SourceLocation TypeLoc, 344 SourceRange TypeRange, 345 ExprArg ArraySizeE, 346 SourceLocation ConstructorLParen, 347 MultiExprArg ConstructorArgs, 348 SourceLocation ConstructorRParen) { 349 if (CheckAllocatedType(AllocType, TypeLoc, TypeRange)) 350 return ExprError(); 351 352 QualType ResultType = Context.getPointerType(AllocType); 353 354 // That every array dimension except the first is constant was already 355 // checked by the type check above. 356 357 // C++ 5.3.4p6: "The expression in a direct-new-declarator shall have integral 358 // or enumeration type with a non-negative value." 359 Expr *ArraySize = (Expr *)ArraySizeE.get(); 360 if (ArraySize && !ArraySize->isTypeDependent()) { 361 QualType SizeType = ArraySize->getType(); 362 if (!SizeType->isIntegralType() && !SizeType->isEnumeralType()) 363 return ExprError(Diag(ArraySize->getSourceRange().getBegin(), 364 diag::err_array_size_not_integral) 365 << SizeType << ArraySize->getSourceRange()); 366 // Let's see if this is a constant < 0. If so, we reject it out of hand. 367 // We don't care about special rules, so we tell the machinery it's not 368 // evaluated - it gives us a result in more cases. 369 if (!ArraySize->isValueDependent()) { 370 llvm::APSInt Value; 371 if (ArraySize->isIntegerConstantExpr(Value, Context, 0, false)) { 372 if (Value < llvm::APSInt( 373 llvm::APInt::getNullValue(Value.getBitWidth()), false)) 374 return ExprError(Diag(ArraySize->getSourceRange().getBegin(), 375 diag::err_typecheck_negative_array_size) 376 << ArraySize->getSourceRange()); 377 } 378 } 379 } 380 381 FunctionDecl *OperatorNew = 0; 382 FunctionDecl *OperatorDelete = 0; 383 Expr **PlaceArgs = (Expr**)PlacementArgs.get(); 384 unsigned NumPlaceArgs = PlacementArgs.size(); 385 if (!AllocType->isDependentType() && 386 !Expr::hasAnyTypeDependentArguments(PlaceArgs, NumPlaceArgs) && 387 FindAllocationFunctions(StartLoc, 388 SourceRange(PlacementLParen, PlacementRParen), 389 UseGlobal, AllocType, ArraySize, PlaceArgs, 390 NumPlaceArgs, OperatorNew, OperatorDelete)) 391 return ExprError(); 392 393 bool Init = ConstructorLParen.isValid(); 394 // --- Choosing a constructor --- 395 // C++ 5.3.4p15 396 // 1) If T is a POD and there's no initializer (ConstructorLParen is invalid) 397 // the object is not initialized. If the object, or any part of it, is 398 // const-qualified, it's an error. 399 // 2) If T is a POD and there's an empty initializer, the object is value- 400 // initialized. 401 // 3) If T is a POD and there's one initializer argument, the object is copy- 402 // constructed. 403 // 4) If T is a POD and there's more initializer arguments, it's an error. 404 // 5) If T is not a POD, the initializer arguments are used as constructor 405 // arguments. 406 // 407 // Or by the C++0x formulation: 408 // 1) If there's no initializer, the object is default-initialized according 409 // to C++0x rules. 410 // 2) Otherwise, the object is direct-initialized. 411 CXXConstructorDecl *Constructor = 0; 412 Expr **ConsArgs = (Expr**)ConstructorArgs.get(); 413 const RecordType *RT; 414 unsigned NumConsArgs = ConstructorArgs.size(); 415 if (AllocType->isDependentType()) { 416 // Skip all the checks. 417 } else if ((RT = AllocType->getAs<RecordType>()) && 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->getAs<RecordType>()->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->getAs<PointerType>()->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->getAs<RecordType>()) { 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->getAs<PointerType>()) 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 CastExpr::CK_Unknown, 878 ToType->isLValueReferenceType()); 879 return false; 880 881 case ImplicitConversionSequence::EllipsisConversion: 882 assert(false && "Cannot perform an ellipsis conversion"); 883 return false; 884 885 case ImplicitConversionSequence::BadConversion: 886 return true; 887 } 888 889 // Everything went well. 890 return false; 891} 892 893/// PerformImplicitConversion - Perform an implicit conversion of the 894/// expression From to the type ToType by following the standard 895/// conversion sequence SCS. Returns true if there was an error, false 896/// otherwise. The expression From is replaced with the converted 897/// expression. Flavor is the context in which we're performing this 898/// conversion, for use in error messages. 899bool 900Sema::PerformImplicitConversion(Expr *&From, QualType ToType, 901 const StandardConversionSequence& SCS, 902 const char *Flavor) { 903 // Overall FIXME: we are recomputing too many types here and doing far too 904 // much extra work. What this means is that we need to keep track of more 905 // information that is computed when we try the implicit conversion initially, 906 // so that we don't need to recompute anything here. 907 QualType FromType = From->getType(); 908 909 if (SCS.CopyConstructor) { 910 // FIXME: When can ToType be a reference type? 911 assert(!ToType->isReferenceType()); 912 913 // FIXME: Keep track of whether the copy constructor is elidable or not. 914 From = BuildCXXConstructExpr(Context, 915 ToType, SCS.CopyConstructor, false, &From, 1); 916 return false; 917 } 918 919 // Perform the first implicit conversion. 920 switch (SCS.First) { 921 case ICK_Identity: 922 case ICK_Lvalue_To_Rvalue: 923 // Nothing to do. 924 break; 925 926 case ICK_Array_To_Pointer: 927 FromType = Context.getArrayDecayedType(FromType); 928 ImpCastExprToType(From, FromType); 929 break; 930 931 case ICK_Function_To_Pointer: 932 if (Context.getCanonicalType(FromType) == Context.OverloadTy) { 933 FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(From, ToType, true); 934 if (!Fn) 935 return true; 936 937 if (DiagnoseUseOfDecl(Fn, From->getSourceRange().getBegin())) 938 return true; 939 940 FixOverloadedFunctionReference(From, Fn); 941 FromType = From->getType(); 942 } 943 FromType = Context.getPointerType(FromType); 944 ImpCastExprToType(From, FromType); 945 break; 946 947 default: 948 assert(false && "Improper first standard conversion"); 949 break; 950 } 951 952 // Perform the second implicit conversion 953 switch (SCS.Second) { 954 case ICK_Identity: 955 // Nothing to do. 956 break; 957 958 case ICK_Integral_Promotion: 959 case ICK_Floating_Promotion: 960 case ICK_Complex_Promotion: 961 case ICK_Integral_Conversion: 962 case ICK_Floating_Conversion: 963 case ICK_Complex_Conversion: 964 case ICK_Floating_Integral: 965 case ICK_Complex_Real: 966 case ICK_Compatible_Conversion: 967 // FIXME: Go deeper to get the unqualified type! 968 FromType = ToType.getUnqualifiedType(); 969 ImpCastExprToType(From, FromType); 970 break; 971 972 case ICK_Pointer_Conversion: 973 if (SCS.IncompatibleObjC) { 974 // Diagnose incompatible Objective-C conversions 975 Diag(From->getSourceRange().getBegin(), 976 diag::ext_typecheck_convert_incompatible_pointer) 977 << From->getType() << ToType << Flavor 978 << From->getSourceRange(); 979 } 980 981 if (CheckPointerConversion(From, ToType)) 982 return true; 983 ImpCastExprToType(From, ToType); 984 break; 985 986 case ICK_Pointer_Member: 987 if (CheckMemberPointerConversion(From, ToType)) 988 return true; 989 ImpCastExprToType(From, ToType); 990 break; 991 992 case ICK_Boolean_Conversion: 993 FromType = Context.BoolTy; 994 ImpCastExprToType(From, FromType); 995 break; 996 997 default: 998 assert(false && "Improper second standard conversion"); 999 break; 1000 } 1001 1002 switch (SCS.Third) { 1003 case ICK_Identity: 1004 // Nothing to do. 1005 break; 1006 1007 case ICK_Qualification: 1008 // FIXME: Not sure about lvalue vs rvalue here in the presence of rvalue 1009 // references. 1010 ImpCastExprToType(From, ToType.getNonReferenceType(), 1011 CastExpr::CK_Unknown, 1012 ToType->isLValueReferenceType()); 1013 break; 1014 1015 default: 1016 assert(false && "Improper second standard conversion"); 1017 break; 1018 } 1019 1020 return false; 1021} 1022 1023Sema::OwningExprResult Sema::ActOnUnaryTypeTrait(UnaryTypeTrait OTT, 1024 SourceLocation KWLoc, 1025 SourceLocation LParen, 1026 TypeTy *Ty, 1027 SourceLocation RParen) { 1028 QualType T = QualType::getFromOpaquePtr(Ty); 1029 1030 // According to http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html 1031 // all traits except __is_class, __is_enum and __is_union require a the type 1032 // to be complete. 1033 if (OTT != UTT_IsClass && OTT != UTT_IsEnum && OTT != UTT_IsUnion) { 1034 if (RequireCompleteType(KWLoc, T, 1035 diag::err_incomplete_type_used_in_type_trait_expr, 1036 SourceRange(), SourceRange(), T)) 1037 return ExprError(); 1038 } 1039 1040 // There is no point in eagerly computing the value. The traits are designed 1041 // to be used from type trait templates, so Ty will be a template parameter 1042 // 99% of the time. 1043 return Owned(new (Context) UnaryTypeTraitExpr(KWLoc, OTT, T, 1044 RParen, Context.BoolTy)); 1045} 1046 1047QualType Sema::CheckPointerToMemberOperands( 1048 Expr *&lex, Expr *&rex, SourceLocation Loc, bool isIndirect) 1049{ 1050 const char *OpSpelling = isIndirect ? "->*" : ".*"; 1051 // C++ 5.5p2 1052 // The binary operator .* [p3: ->*] binds its second operand, which shall 1053 // be of type "pointer to member of T" (where T is a completely-defined 1054 // class type) [...] 1055 QualType RType = rex->getType(); 1056 const MemberPointerType *MemPtr = RType->getAs<MemberPointerType>(); 1057 if (!MemPtr) { 1058 Diag(Loc, diag::err_bad_memptr_rhs) 1059 << OpSpelling << RType << rex->getSourceRange(); 1060 return QualType(); 1061 } 1062 1063 QualType Class(MemPtr->getClass(), 0); 1064 1065 // C++ 5.5p2 1066 // [...] to its first operand, which shall be of class T or of a class of 1067 // which T is an unambiguous and accessible base class. [p3: a pointer to 1068 // such a class] 1069 QualType LType = lex->getType(); 1070 if (isIndirect) { 1071 if (const PointerType *Ptr = LType->getAs<PointerType>()) 1072 LType = Ptr->getPointeeType().getNonReferenceType(); 1073 else { 1074 Diag(Loc, diag::err_bad_memptr_lhs) 1075 << OpSpelling << 1 << LType << lex->getSourceRange(); 1076 return QualType(); 1077 } 1078 } 1079 1080 if (Context.getCanonicalType(Class).getUnqualifiedType() != 1081 Context.getCanonicalType(LType).getUnqualifiedType()) { 1082 BasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/false, 1083 /*DetectVirtual=*/false); 1084 // FIXME: Would it be useful to print full ambiguity paths, or is that 1085 // overkill? 1086 if (!IsDerivedFrom(LType, Class, Paths) || 1087 Paths.isAmbiguous(Context.getCanonicalType(Class))) { 1088 Diag(Loc, diag::err_bad_memptr_lhs) << OpSpelling 1089 << (int)isIndirect << lex->getType() << lex->getSourceRange(); 1090 return QualType(); 1091 } 1092 } 1093 1094 // C++ 5.5p2 1095 // The result is an object or a function of the type specified by the 1096 // second operand. 1097 // The cv qualifiers are the union of those in the pointer and the left side, 1098 // in accordance with 5.5p5 and 5.2.5. 1099 // FIXME: This returns a dereferenced member function pointer as a normal 1100 // function type. However, the only operation valid on such functions is 1101 // calling them. There's also a GCC extension to get a function pointer to the 1102 // thing, which is another complication, because this type - unlike the type 1103 // that is the result of this expression - takes the class as the first 1104 // argument. 1105 // We probably need a "MemberFunctionClosureType" or something like that. 1106 QualType Result = MemPtr->getPointeeType(); 1107 if (LType.isConstQualified()) 1108 Result.addConst(); 1109 if (LType.isVolatileQualified()) 1110 Result.addVolatile(); 1111 return Result; 1112} 1113 1114/// \brief Get the target type of a standard or user-defined conversion. 1115static QualType TargetType(const ImplicitConversionSequence &ICS) { 1116 assert((ICS.ConversionKind == 1117 ImplicitConversionSequence::StandardConversion || 1118 ICS.ConversionKind == 1119 ImplicitConversionSequence::UserDefinedConversion) && 1120 "function only valid for standard or user-defined conversions"); 1121 if (ICS.ConversionKind == ImplicitConversionSequence::StandardConversion) 1122 return QualType::getFromOpaquePtr(ICS.Standard.ToTypePtr); 1123 return QualType::getFromOpaquePtr(ICS.UserDefined.After.ToTypePtr); 1124} 1125 1126/// \brief Try to convert a type to another according to C++0x 5.16p3. 1127/// 1128/// This is part of the parameter validation for the ? operator. If either 1129/// value operand is a class type, the two operands are attempted to be 1130/// converted to each other. This function does the conversion in one direction. 1131/// It emits a diagnostic and returns true only if it finds an ambiguous 1132/// conversion. 1133static bool TryClassUnification(Sema &Self, Expr *From, Expr *To, 1134 SourceLocation QuestionLoc, 1135 ImplicitConversionSequence &ICS) 1136{ 1137 // C++0x 5.16p3 1138 // The process for determining whether an operand expression E1 of type T1 1139 // can be converted to match an operand expression E2 of type T2 is defined 1140 // as follows: 1141 // -- If E2 is an lvalue: 1142 if (To->isLvalue(Self.Context) == Expr::LV_Valid) { 1143 // E1 can be converted to match E2 if E1 can be implicitly converted to 1144 // type "lvalue reference to T2", subject to the constraint that in the 1145 // conversion the reference must bind directly to E1. 1146 if (!Self.CheckReferenceInit(From, 1147 Self.Context.getLValueReferenceType(To->getType()), 1148 &ICS)) 1149 { 1150 assert((ICS.ConversionKind == 1151 ImplicitConversionSequence::StandardConversion || 1152 ICS.ConversionKind == 1153 ImplicitConversionSequence::UserDefinedConversion) && 1154 "expected a definite conversion"); 1155 bool DirectBinding = 1156 ICS.ConversionKind == ImplicitConversionSequence::StandardConversion ? 1157 ICS.Standard.DirectBinding : ICS.UserDefined.After.DirectBinding; 1158 if (DirectBinding) 1159 return false; 1160 } 1161 } 1162 ICS.ConversionKind = ImplicitConversionSequence::BadConversion; 1163 // -- If E2 is an rvalue, or if the conversion above cannot be done: 1164 // -- if E1 and E2 have class type, and the underlying class types are 1165 // the same or one is a base class of the other: 1166 QualType FTy = From->getType(); 1167 QualType TTy = To->getType(); 1168 const RecordType *FRec = FTy->getAs<RecordType>(); 1169 const RecordType *TRec = TTy->getAs<RecordType>(); 1170 bool FDerivedFromT = FRec && TRec && Self.IsDerivedFrom(FTy, TTy); 1171 if (FRec && TRec && (FRec == TRec || 1172 FDerivedFromT || Self.IsDerivedFrom(TTy, FTy))) { 1173 // E1 can be converted to match E2 if the class of T2 is the 1174 // same type as, or a base class of, the class of T1, and 1175 // [cv2 > cv1]. 1176 if ((FRec == TRec || FDerivedFromT) && TTy.isAtLeastAsQualifiedAs(FTy)) { 1177 // Could still fail if there's no copy constructor. 1178 // FIXME: Is this a hard error then, or just a conversion failure? The 1179 // standard doesn't say. 1180 ICS = Self.TryCopyInitialization(From, TTy); 1181 } 1182 } else { 1183 // -- Otherwise: E1 can be converted to match E2 if E1 can be 1184 // implicitly converted to the type that expression E2 would have 1185 // if E2 were converted to an rvalue. 1186 // First find the decayed type. 1187 if (TTy->isFunctionType()) 1188 TTy = Self.Context.getPointerType(TTy); 1189 else if(TTy->isArrayType()) 1190 TTy = Self.Context.getArrayDecayedType(TTy); 1191 1192 // Now try the implicit conversion. 1193 // FIXME: This doesn't detect ambiguities. 1194 ICS = Self.TryImplicitConversion(From, TTy); 1195 } 1196 return false; 1197} 1198 1199/// \brief Try to find a common type for two according to C++0x 5.16p5. 1200/// 1201/// This is part of the parameter validation for the ? operator. If either 1202/// value operand is a class type, overload resolution is used to find a 1203/// conversion to a common type. 1204static bool FindConditionalOverload(Sema &Self, Expr *&LHS, Expr *&RHS, 1205 SourceLocation Loc) { 1206 Expr *Args[2] = { LHS, RHS }; 1207 OverloadCandidateSet CandidateSet; 1208 Self.AddBuiltinOperatorCandidates(OO_Conditional, Args, 2, CandidateSet); 1209 1210 OverloadCandidateSet::iterator Best; 1211 switch (Self.BestViableFunction(CandidateSet, Loc, Best)) { 1212 case Sema::OR_Success: 1213 // We found a match. Perform the conversions on the arguments and move on. 1214 if (Self.PerformImplicitConversion(LHS, Best->BuiltinTypes.ParamTypes[0], 1215 Best->Conversions[0], "converting") || 1216 Self.PerformImplicitConversion(RHS, Best->BuiltinTypes.ParamTypes[1], 1217 Best->Conversions[1], "converting")) 1218 break; 1219 return false; 1220 1221 case Sema::OR_No_Viable_Function: 1222 Self.Diag(Loc, diag::err_typecheck_cond_incompatible_operands) 1223 << LHS->getType() << RHS->getType() 1224 << LHS->getSourceRange() << RHS->getSourceRange(); 1225 return true; 1226 1227 case Sema::OR_Ambiguous: 1228 Self.Diag(Loc, diag::err_conditional_ambiguous_ovl) 1229 << LHS->getType() << RHS->getType() 1230 << LHS->getSourceRange() << RHS->getSourceRange(); 1231 // FIXME: Print the possible common types by printing the return types of 1232 // the viable candidates. 1233 break; 1234 1235 case Sema::OR_Deleted: 1236 assert(false && "Conditional operator has only built-in overloads"); 1237 break; 1238 } 1239 return true; 1240} 1241 1242/// \brief Perform an "extended" implicit conversion as returned by 1243/// TryClassUnification. 1244/// 1245/// TryClassUnification generates ICSs that include reference bindings. 1246/// PerformImplicitConversion is not suitable for this; it chokes if the 1247/// second part of a standard conversion is ICK_DerivedToBase. This function 1248/// handles the reference binding specially. 1249static bool ConvertForConditional(Sema &Self, Expr *&E, 1250 const ImplicitConversionSequence &ICS) 1251{ 1252 if (ICS.ConversionKind == ImplicitConversionSequence::StandardConversion && 1253 ICS.Standard.ReferenceBinding) { 1254 assert(ICS.Standard.DirectBinding && 1255 "TryClassUnification should never generate indirect ref bindings"); 1256 // FIXME: CheckReferenceInit should be able to reuse the ICS instead of 1257 // redoing all the work. 1258 return Self.CheckReferenceInit(E, Self.Context.getLValueReferenceType( 1259 TargetType(ICS))); 1260 } 1261 if (ICS.ConversionKind == ImplicitConversionSequence::UserDefinedConversion && 1262 ICS.UserDefined.After.ReferenceBinding) { 1263 assert(ICS.UserDefined.After.DirectBinding && 1264 "TryClassUnification should never generate indirect ref bindings"); 1265 return Self.CheckReferenceInit(E, Self.Context.getLValueReferenceType( 1266 TargetType(ICS))); 1267 } 1268 if (Self.PerformImplicitConversion(E, TargetType(ICS), ICS, "converting")) 1269 return true; 1270 return false; 1271} 1272 1273/// \brief Check the operands of ?: under C++ semantics. 1274/// 1275/// See C++ [expr.cond]. Note that LHS is never null, even for the GNU x ?: y 1276/// extension. In this case, LHS == Cond. (But they're not aliases.) 1277QualType Sema::CXXCheckConditionalOperands(Expr *&Cond, Expr *&LHS, Expr *&RHS, 1278 SourceLocation QuestionLoc) { 1279 // FIXME: Handle C99's complex types, vector types, block pointers and Obj-C++ 1280 // interface pointers. 1281 1282 // C++0x 5.16p1 1283 // The first expression is contextually converted to bool. 1284 if (!Cond->isTypeDependent()) { 1285 if (CheckCXXBooleanCondition(Cond)) 1286 return QualType(); 1287 } 1288 1289 // Either of the arguments dependent? 1290 if (LHS->isTypeDependent() || RHS->isTypeDependent()) 1291 return Context.DependentTy; 1292 1293 // C++0x 5.16p2 1294 // If either the second or the third operand has type (cv) void, ... 1295 QualType LTy = LHS->getType(); 1296 QualType RTy = RHS->getType(); 1297 bool LVoid = LTy->isVoidType(); 1298 bool RVoid = RTy->isVoidType(); 1299 if (LVoid || RVoid) { 1300 // ... then the [l2r] conversions are performed on the second and third 1301 // operands ... 1302 DefaultFunctionArrayConversion(LHS); 1303 DefaultFunctionArrayConversion(RHS); 1304 LTy = LHS->getType(); 1305 RTy = RHS->getType(); 1306 1307 // ... and one of the following shall hold: 1308 // -- The second or the third operand (but not both) is a throw- 1309 // expression; the result is of the type of the other and is an rvalue. 1310 bool LThrow = isa<CXXThrowExpr>(LHS); 1311 bool RThrow = isa<CXXThrowExpr>(RHS); 1312 if (LThrow && !RThrow) 1313 return RTy; 1314 if (RThrow && !LThrow) 1315 return LTy; 1316 1317 // -- Both the second and third operands have type void; the result is of 1318 // type void and is an rvalue. 1319 if (LVoid && RVoid) 1320 return Context.VoidTy; 1321 1322 // Neither holds, error. 1323 Diag(QuestionLoc, diag::err_conditional_void_nonvoid) 1324 << (LVoid ? RTy : LTy) << (LVoid ? 0 : 1) 1325 << LHS->getSourceRange() << RHS->getSourceRange(); 1326 return QualType(); 1327 } 1328 1329 // Neither is void. 1330 1331 // C++0x 5.16p3 1332 // Otherwise, if the second and third operand have different types, and 1333 // either has (cv) class type, and attempt is made to convert each of those 1334 // operands to the other. 1335 if (Context.getCanonicalType(LTy) != Context.getCanonicalType(RTy) && 1336 (LTy->isRecordType() || RTy->isRecordType())) { 1337 ImplicitConversionSequence ICSLeftToRight, ICSRightToLeft; 1338 // These return true if a single direction is already ambiguous. 1339 if (TryClassUnification(*this, LHS, RHS, QuestionLoc, ICSLeftToRight)) 1340 return QualType(); 1341 if (TryClassUnification(*this, RHS, LHS, QuestionLoc, ICSRightToLeft)) 1342 return QualType(); 1343 1344 bool HaveL2R = ICSLeftToRight.ConversionKind != 1345 ImplicitConversionSequence::BadConversion; 1346 bool HaveR2L = ICSRightToLeft.ConversionKind != 1347 ImplicitConversionSequence::BadConversion; 1348 // If both can be converted, [...] the program is ill-formed. 1349 if (HaveL2R && HaveR2L) { 1350 Diag(QuestionLoc, diag::err_conditional_ambiguous) 1351 << LTy << RTy << LHS->getSourceRange() << RHS->getSourceRange(); 1352 return QualType(); 1353 } 1354 1355 // If exactly one conversion is possible, that conversion is applied to 1356 // the chosen operand and the converted operands are used in place of the 1357 // original operands for the remainder of this section. 1358 if (HaveL2R) { 1359 if (ConvertForConditional(*this, LHS, ICSLeftToRight)) 1360 return QualType(); 1361 LTy = LHS->getType(); 1362 } else if (HaveR2L) { 1363 if (ConvertForConditional(*this, RHS, ICSRightToLeft)) 1364 return QualType(); 1365 RTy = RHS->getType(); 1366 } 1367 } 1368 1369 // C++0x 5.16p4 1370 // If the second and third operands are lvalues and have the same type, 1371 // the result is of that type [...] 1372 bool Same = Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy); 1373 if (Same && LHS->isLvalue(Context) == Expr::LV_Valid && 1374 RHS->isLvalue(Context) == Expr::LV_Valid) 1375 return LTy; 1376 1377 // C++0x 5.16p5 1378 // Otherwise, the result is an rvalue. If the second and third operands 1379 // do not have the same type, and either has (cv) class type, ... 1380 if (!Same && (LTy->isRecordType() || RTy->isRecordType())) { 1381 // ... overload resolution is used to determine the conversions (if any) 1382 // to be applied to the operands. If the overload resolution fails, the 1383 // program is ill-formed. 1384 if (FindConditionalOverload(*this, LHS, RHS, QuestionLoc)) 1385 return QualType(); 1386 } 1387 1388 // C++0x 5.16p6 1389 // LValue-to-rvalue, array-to-pointer, and function-to-pointer standard 1390 // conversions are performed on the second and third operands. 1391 DefaultFunctionArrayConversion(LHS); 1392 DefaultFunctionArrayConversion(RHS); 1393 LTy = LHS->getType(); 1394 RTy = RHS->getType(); 1395 1396 // After those conversions, one of the following shall hold: 1397 // -- The second and third operands have the same type; the result 1398 // is of that type. 1399 if (Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy)) 1400 return LTy; 1401 1402 // -- The second and third operands have arithmetic or enumeration type; 1403 // the usual arithmetic conversions are performed to bring them to a 1404 // common type, and the result is of that type. 1405 if (LTy->isArithmeticType() && RTy->isArithmeticType()) { 1406 UsualArithmeticConversions(LHS, RHS); 1407 return LHS->getType(); 1408 } 1409 1410 // -- The second and third operands have pointer type, or one has pointer 1411 // type and the other is a null pointer constant; pointer conversions 1412 // and qualification conversions are performed to bring them to their 1413 // composite pointer type. The result is of the composite pointer type. 1414 QualType Composite = FindCompositePointerType(LHS, RHS); 1415 if (!Composite.isNull()) 1416 return Composite; 1417 1418 // Fourth bullet is same for pointers-to-member. However, the possible 1419 // conversions are far more limited: we have null-to-pointer, upcast of 1420 // containing class, and second-level cv-ness. 1421 // cv-ness is not a union, but must match one of the two operands. (Which, 1422 // frankly, is stupid.) 1423 const MemberPointerType *LMemPtr = LTy->getAs<MemberPointerType>(); 1424 const MemberPointerType *RMemPtr = RTy->getAs<MemberPointerType>(); 1425 if (LMemPtr && RHS->isNullPointerConstant(Context)) { 1426 ImpCastExprToType(RHS, LTy); 1427 return LTy; 1428 } 1429 if (RMemPtr && LHS->isNullPointerConstant(Context)) { 1430 ImpCastExprToType(LHS, RTy); 1431 return RTy; 1432 } 1433 if (LMemPtr && RMemPtr) { 1434 QualType LPointee = LMemPtr->getPointeeType(); 1435 QualType RPointee = RMemPtr->getPointeeType(); 1436 // First, we check that the unqualified pointee type is the same. If it's 1437 // not, there's no conversion that will unify the two pointers. 1438 if (Context.getCanonicalType(LPointee).getUnqualifiedType() == 1439 Context.getCanonicalType(RPointee).getUnqualifiedType()) { 1440 // Second, we take the greater of the two cv qualifications. If neither 1441 // is greater than the other, the conversion is not possible. 1442 unsigned Q = LPointee.getCVRQualifiers() | RPointee.getCVRQualifiers(); 1443 if (Q == LPointee.getCVRQualifiers() || Q == RPointee.getCVRQualifiers()){ 1444 // Third, we check if either of the container classes is derived from 1445 // the other. 1446 QualType LContainer(LMemPtr->getClass(), 0); 1447 QualType RContainer(RMemPtr->getClass(), 0); 1448 QualType MoreDerived; 1449 if (Context.getCanonicalType(LContainer) == 1450 Context.getCanonicalType(RContainer)) 1451 MoreDerived = LContainer; 1452 else if (IsDerivedFrom(LContainer, RContainer)) 1453 MoreDerived = LContainer; 1454 else if (IsDerivedFrom(RContainer, LContainer)) 1455 MoreDerived = RContainer; 1456 1457 if (!MoreDerived.isNull()) { 1458 // The type 'Q Pointee (MoreDerived::*)' is the common type. 1459 // We don't use ImpCastExprToType here because this could still fail 1460 // for ambiguous or inaccessible conversions. 1461 QualType Common = Context.getMemberPointerType( 1462 LPointee.getQualifiedType(Q), MoreDerived.getTypePtr()); 1463 if (PerformImplicitConversion(LHS, Common, "converting")) 1464 return QualType(); 1465 if (PerformImplicitConversion(RHS, Common, "converting")) 1466 return QualType(); 1467 return Common; 1468 } 1469 } 1470 } 1471 } 1472 1473 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands) 1474 << LHS->getType() << RHS->getType() 1475 << LHS->getSourceRange() << RHS->getSourceRange(); 1476 return QualType(); 1477} 1478 1479/// \brief Find a merged pointer type and convert the two expressions to it. 1480/// 1481/// This finds the composite pointer type for @p E1 and @p E2 according to 1482/// C++0x 5.9p2. It converts both expressions to this type and returns it. 1483/// It does not emit diagnostics. 1484QualType Sema::FindCompositePointerType(Expr *&E1, Expr *&E2) { 1485 assert(getLangOptions().CPlusPlus && "This function assumes C++"); 1486 QualType T1 = E1->getType(), T2 = E2->getType(); 1487 if(!T1->isAnyPointerType() && !T2->isAnyPointerType()) 1488 return QualType(); 1489 1490 // C++0x 5.9p2 1491 // Pointer conversions and qualification conversions are performed on 1492 // pointer operands to bring them to their composite pointer type. If 1493 // one operand is a null pointer constant, the composite pointer type is 1494 // the type of the other operand. 1495 if (E1->isNullPointerConstant(Context)) { 1496 ImpCastExprToType(E1, T2); 1497 return T2; 1498 } 1499 if (E2->isNullPointerConstant(Context)) { 1500 ImpCastExprToType(E2, T1); 1501 return T1; 1502 } 1503 // Now both have to be pointers. 1504 if(!T1->isPointerType() || !T2->isPointerType()) 1505 return QualType(); 1506 1507 // Otherwise, of one of the operands has type "pointer to cv1 void," then 1508 // the other has type "pointer to cv2 T" and the composite pointer type is 1509 // "pointer to cv12 void," where cv12 is the union of cv1 and cv2. 1510 // Otherwise, the composite pointer type is a pointer type similar to the 1511 // type of one of the operands, with a cv-qualification signature that is 1512 // the union of the cv-qualification signatures of the operand types. 1513 // In practice, the first part here is redundant; it's subsumed by the second. 1514 // What we do here is, we build the two possible composite types, and try the 1515 // conversions in both directions. If only one works, or if the two composite 1516 // types are the same, we have succeeded. 1517 llvm::SmallVector<unsigned, 4> QualifierUnion; 1518 QualType Composite1 = T1, Composite2 = T2; 1519 const PointerType *Ptr1, *Ptr2; 1520 while ((Ptr1 = Composite1->getAs<PointerType>()) && 1521 (Ptr2 = Composite2->getAs<PointerType>())) { 1522 Composite1 = Ptr1->getPointeeType(); 1523 Composite2 = Ptr2->getPointeeType(); 1524 QualifierUnion.push_back( 1525 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers()); 1526 } 1527 // Rewrap the composites as pointers with the union CVRs. 1528 for (llvm::SmallVector<unsigned, 4>::iterator I = QualifierUnion.begin(), 1529 E = QualifierUnion.end(); I != E; ++I) { 1530 Composite1 = Context.getPointerType(Composite1.getQualifiedType(*I)); 1531 Composite2 = Context.getPointerType(Composite2.getQualifiedType(*I)); 1532 } 1533 1534 ImplicitConversionSequence E1ToC1 = TryImplicitConversion(E1, Composite1); 1535 ImplicitConversionSequence E2ToC1 = TryImplicitConversion(E2, Composite1); 1536 ImplicitConversionSequence E1ToC2, E2ToC2; 1537 E1ToC2.ConversionKind = ImplicitConversionSequence::BadConversion; 1538 E2ToC2.ConversionKind = ImplicitConversionSequence::BadConversion; 1539 if (Context.getCanonicalType(Composite1) != 1540 Context.getCanonicalType(Composite2)) { 1541 E1ToC2 = TryImplicitConversion(E1, Composite2); 1542 E2ToC2 = TryImplicitConversion(E2, Composite2); 1543 } 1544 1545 bool ToC1Viable = E1ToC1.ConversionKind != 1546 ImplicitConversionSequence::BadConversion 1547 && E2ToC1.ConversionKind != 1548 ImplicitConversionSequence::BadConversion; 1549 bool ToC2Viable = E1ToC2.ConversionKind != 1550 ImplicitConversionSequence::BadConversion 1551 && E2ToC2.ConversionKind != 1552 ImplicitConversionSequence::BadConversion; 1553 if (ToC1Viable && !ToC2Viable) { 1554 if (!PerformImplicitConversion(E1, Composite1, E1ToC1, "converting") && 1555 !PerformImplicitConversion(E2, Composite1, E2ToC1, "converting")) 1556 return Composite1; 1557 } 1558 if (ToC2Viable && !ToC1Viable) { 1559 if (!PerformImplicitConversion(E1, Composite2, E1ToC2, "converting") && 1560 !PerformImplicitConversion(E2, Composite2, E2ToC2, "converting")) 1561 return Composite2; 1562 } 1563 return QualType(); 1564} 1565 1566Sema::OwningExprResult Sema::MaybeBindToTemporary(Expr *E) { 1567 const RecordType *RT = E->getType()->getAs<RecordType>(); 1568 if (!RT) 1569 return Owned(E); 1570 1571 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 1572 if (RD->hasTrivialDestructor()) 1573 return Owned(E); 1574 1575 CXXTemporary *Temp = CXXTemporary::Create(Context, 1576 RD->getDestructor(Context)); 1577 ExprTemporaries.push_back(Temp); 1578 if (CXXDestructorDecl *Destructor = 1579 const_cast<CXXDestructorDecl*>(RD->getDestructor(Context))) 1580 MarkDeclarationReferenced(E->getExprLoc(), Destructor); 1581 // FIXME: Add the temporary to the temporaries vector. 1582 return Owned(CXXBindTemporaryExpr::Create(Context, Temp, E)); 1583} 1584 1585Expr *Sema::MaybeCreateCXXExprWithTemporaries(Expr *SubExpr, 1586 bool ShouldDestroyTemps) { 1587 assert(SubExpr && "sub expression can't be null!"); 1588 1589 if (ExprTemporaries.empty()) 1590 return SubExpr; 1591 1592 Expr *E = CXXExprWithTemporaries::Create(Context, SubExpr, 1593 &ExprTemporaries[0], 1594 ExprTemporaries.size(), 1595 ShouldDestroyTemps); 1596 ExprTemporaries.clear(); 1597 1598 return E; 1599} 1600 1601Sema::OwningExprResult Sema::ActOnFinishFullExpr(ExprArg Arg) { 1602 Expr *FullExpr = Arg.takeAs<Expr>(); 1603 if (FullExpr) 1604 FullExpr = MaybeCreateCXXExprWithTemporaries(FullExpr, 1605 /*ShouldDestroyTemps=*/true); 1606 1607 return Owned(FullExpr); 1608} 1609