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