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