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