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