SemaExprCXX.cpp revision 200583
1114402Sru//===--- SemaExprCXX.cpp - Semantic Analysis for Expressions --------------===// 2114402Sru// 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 // C++ 5.3.4p15 429 // 1) If T is a POD and there's no initializer (ConstructorLParen is invalid) 430 // the object is not initialized. If the object, or any part of it, is 431 // const-qualified, it's an error. 432 // 2) If T is a POD and there's an empty initializer, the object is value- 433 // initialized. 434 // 3) If T is a POD and there's one initializer argument, the object is copy- 435 // constructed. 436 // 4) If T is a POD and there's more initializer arguments, it's an error. 437 // 5) If T is not a POD, the initializer arguments are used as constructor 438 // arguments. 439 // 440 // Or by the C++0x formulation: 441 // 1) If there's no initializer, the object is default-initialized according 442 // to C++0x rules. 443 // 2) Otherwise, the object is direct-initialized. 444 CXXConstructorDecl *Constructor = 0; 445 Expr **ConsArgs = (Expr**)ConstructorArgs.get(); 446 const RecordType *RT; 447 unsigned NumConsArgs = ConstructorArgs.size(); 448 ASTOwningVector<&ActionBase::DeleteExpr> ConvertedConstructorArgs(*this); 449 450 if (AllocType->isDependentType() || 451 Expr::hasAnyTypeDependentArguments(ConsArgs, NumConsArgs)) { 452 // Skip all the checks. 453 } else if ((RT = AllocType->getAs<RecordType>()) && 454 !AllocType->isAggregateType()) { 455 InitializationKind InitKind = InitializationKind::CreateDefault(TypeLoc); 456 if (NumConsArgs > 0) 457 InitKind = InitializationKind::CreateDirect(TypeLoc, 458 PlacementLParen, 459 PlacementRParen); 460 Constructor = PerformInitializationByConstructor( 461 AllocType, move(ConstructorArgs), 462 TypeLoc, 463 SourceRange(TypeLoc, ConstructorRParen), 464 RT->getDecl()->getDeclName(), 465 InitKind, 466 ConvertedConstructorArgs); 467 if (!Constructor) 468 return ExprError(); 469 470 // Take the converted constructor arguments and use them for the new 471 // expression. 472 NumConsArgs = ConvertedConstructorArgs.size(); 473 ConsArgs = (Expr **)ConvertedConstructorArgs.take(); 474 } else { 475 if (!Init) { 476 // FIXME: Check that no subpart is const. 477 if (AllocType.isConstQualified()) 478 return ExprError(Diag(StartLoc, diag::err_new_uninitialized_const) 479 << TypeRange); 480 } else if (NumConsArgs == 0) { 481 // Object is value-initialized. Do nothing. 482 } else if (NumConsArgs == 1) { 483 // Object is direct-initialized. 484 // FIXME: What DeclarationName do we pass in here? 485 if (CheckInitializerTypes(ConsArgs[0], AllocType, StartLoc, 486 DeclarationName() /*AllocType.getAsString()*/, 487 /*DirectInit=*/true)) 488 return ExprError(); 489 } else { 490 return ExprError(Diag(StartLoc, 491 diag::err_builtin_direct_init_more_than_one_arg) 492 << SourceRange(ConstructorLParen, ConstructorRParen)); 493 } 494 } 495 496 // FIXME: Also check that the destructor is accessible. (C++ 5.3.4p16) 497 498 PlacementArgs.release(); 499 ConstructorArgs.release(); 500 ArraySizeE.release(); 501 return Owned(new (Context) CXXNewExpr(UseGlobal, OperatorNew, PlaceArgs, 502 NumPlaceArgs, ParenTypeId, ArraySize, Constructor, Init, 503 ConsArgs, NumConsArgs, OperatorDelete, ResultType, 504 StartLoc, Init ? ConstructorRParen : SourceLocation())); 505} 506 507/// CheckAllocatedType - Checks that a type is suitable as the allocated type 508/// in a new-expression. 509/// dimension off and stores the size expression in ArraySize. 510bool Sema::CheckAllocatedType(QualType AllocType, SourceLocation Loc, 511 SourceRange R) { 512 // C++ 5.3.4p1: "[The] type shall be a complete object type, but not an 513 // abstract class type or array thereof. 514 if (AllocType->isFunctionType()) 515 return Diag(Loc, diag::err_bad_new_type) 516 << AllocType << 0 << R; 517 else if (AllocType->isReferenceType()) 518 return Diag(Loc, diag::err_bad_new_type) 519 << AllocType << 1 << R; 520 else if (!AllocType->isDependentType() && 521 RequireCompleteType(Loc, AllocType, 522 PDiag(diag::err_new_incomplete_type) 523 << R)) 524 return true; 525 else if (RequireNonAbstractType(Loc, AllocType, 526 diag::err_allocation_of_abstract_type)) 527 return true; 528 529 return false; 530} 531 532/// FindAllocationFunctions - Finds the overloads of operator new and delete 533/// that are appropriate for the allocation. 534bool Sema::FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range, 535 bool UseGlobal, QualType AllocType, 536 bool IsArray, Expr **PlaceArgs, 537 unsigned NumPlaceArgs, 538 FunctionDecl *&OperatorNew, 539 FunctionDecl *&OperatorDelete) { 540 // --- Choosing an allocation function --- 541 // C++ 5.3.4p8 - 14 & 18 542 // 1) If UseGlobal is true, only look in the global scope. Else, also look 543 // in the scope of the allocated class. 544 // 2) If an array size is given, look for operator new[], else look for 545 // operator new. 546 // 3) The first argument is always size_t. Append the arguments from the 547 // placement form. 548 // FIXME: Also find the appropriate delete operator. 549 550 llvm::SmallVector<Expr*, 8> AllocArgs(1 + NumPlaceArgs); 551 // We don't care about the actual value of this argument. 552 // FIXME: Should the Sema create the expression and embed it in the syntax 553 // tree? Or should the consumer just recalculate the value? 554 IntegerLiteral Size(llvm::APInt::getNullValue( 555 Context.Target.getPointerWidth(0)), 556 Context.getSizeType(), 557 SourceLocation()); 558 AllocArgs[0] = &Size; 559 std::copy(PlaceArgs, PlaceArgs + NumPlaceArgs, AllocArgs.begin() + 1); 560 561 DeclarationName NewName = Context.DeclarationNames.getCXXOperatorName( 562 IsArray ? OO_Array_New : OO_New); 563 if (AllocType->isRecordType() && !UseGlobal) { 564 CXXRecordDecl *Record 565 = cast<CXXRecordDecl>(AllocType->getAs<RecordType>()->getDecl()); 566 // FIXME: We fail to find inherited overloads. 567 if (FindAllocationOverload(StartLoc, Range, NewName, &AllocArgs[0], 568 AllocArgs.size(), Record, /*AllowMissing=*/true, 569 OperatorNew)) 570 return true; 571 } 572 if (!OperatorNew) { 573 // Didn't find a member overload. Look for a global one. 574 DeclareGlobalNewDelete(); 575 DeclContext *TUDecl = Context.getTranslationUnitDecl(); 576 if (FindAllocationOverload(StartLoc, Range, NewName, &AllocArgs[0], 577 AllocArgs.size(), TUDecl, /*AllowMissing=*/false, 578 OperatorNew)) 579 return true; 580 } 581 582 // FindAllocationOverload can change the passed in arguments, so we need to 583 // copy them back. 584 if (NumPlaceArgs > 0) 585 std::copy(&AllocArgs[1], AllocArgs.end(), PlaceArgs); 586 587 return false; 588} 589 590/// FindAllocationOverload - Find an fitting overload for the allocation 591/// function in the specified scope. 592bool Sema::FindAllocationOverload(SourceLocation StartLoc, SourceRange Range, 593 DeclarationName Name, Expr** Args, 594 unsigned NumArgs, DeclContext *Ctx, 595 bool AllowMissing, FunctionDecl *&Operator) { 596 LookupResult R(*this, Name, StartLoc, LookupOrdinaryName); 597 LookupQualifiedName(R, Ctx); 598 if (R.empty()) { 599 if (AllowMissing) 600 return false; 601 return Diag(StartLoc, diag::err_ovl_no_viable_function_in_call) 602 << Name << Range; 603 } 604 605 // FIXME: handle ambiguity 606 607 OverloadCandidateSet Candidates; 608 for (LookupResult::iterator Alloc = R.begin(), AllocEnd = R.end(); 609 Alloc != AllocEnd; ++Alloc) { 610 // Even member operator new/delete are implicitly treated as 611 // static, so don't use AddMemberCandidate. 612 if (FunctionDecl *Fn = 613 dyn_cast<FunctionDecl>((*Alloc)->getUnderlyingDecl())) { 614 AddOverloadCandidate(Fn, Args, NumArgs, Candidates, 615 /*SuppressUserConversions=*/false); 616 continue; 617 } 618 619 // FIXME: Handle function templates 620 } 621 622 // Do the resolution. 623 OverloadCandidateSet::iterator Best; 624 switch(BestViableFunction(Candidates, StartLoc, Best)) { 625 case OR_Success: { 626 // Got one! 627 FunctionDecl *FnDecl = Best->Function; 628 // The first argument is size_t, and the first parameter must be size_t, 629 // too. This is checked on declaration and can be assumed. (It can't be 630 // asserted on, though, since invalid decls are left in there.) 631 // Whatch out for variadic allocator function. 632 unsigned NumArgsInFnDecl = FnDecl->getNumParams(); 633 for (unsigned i = 0; (i < NumArgs && i < NumArgsInFnDecl); ++i) { 634 // FIXME: Passing word to diagnostic. 635 if (PerformCopyInitialization(Args[i], 636 FnDecl->getParamDecl(i)->getType(), 637 "passing")) 638 return true; 639 } 640 Operator = FnDecl; 641 return false; 642 } 643 644 case OR_No_Viable_Function: 645 Diag(StartLoc, diag::err_ovl_no_viable_function_in_call) 646 << Name << Range; 647 PrintOverloadCandidates(Candidates, /*OnlyViable=*/false); 648 return true; 649 650 case OR_Ambiguous: 651 Diag(StartLoc, diag::err_ovl_ambiguous_call) 652 << Name << Range; 653 PrintOverloadCandidates(Candidates, /*OnlyViable=*/true); 654 return true; 655 656 case OR_Deleted: 657 Diag(StartLoc, diag::err_ovl_deleted_call) 658 << Best->Function->isDeleted() 659 << Name << Range; 660 PrintOverloadCandidates(Candidates, /*OnlyViable=*/true); 661 return true; 662 } 663 assert(false && "Unreachable, bad result from BestViableFunction"); 664 return true; 665} 666 667 668/// DeclareGlobalNewDelete - Declare the global forms of operator new and 669/// delete. These are: 670/// @code 671/// void* operator new(std::size_t) throw(std::bad_alloc); 672/// void* operator new[](std::size_t) throw(std::bad_alloc); 673/// void operator delete(void *) throw(); 674/// void operator delete[](void *) throw(); 675/// @endcode 676/// Note that the placement and nothrow forms of new are *not* implicitly 677/// declared. Their use requires including \<new\>. 678void Sema::DeclareGlobalNewDelete() { 679 if (GlobalNewDeleteDeclared) 680 return; 681 682 // C++ [basic.std.dynamic]p2: 683 // [...] The following allocation and deallocation functions (18.4) are 684 // implicitly declared in global scope in each translation unit of a 685 // program 686 // 687 // void* operator new(std::size_t) throw(std::bad_alloc); 688 // void* operator new[](std::size_t) throw(std::bad_alloc); 689 // void operator delete(void*) throw(); 690 // void operator delete[](void*) throw(); 691 // 692 // These implicit declarations introduce only the function names operator 693 // new, operator new[], operator delete, operator delete[]. 694 // 695 // Here, we need to refer to std::bad_alloc, so we will implicitly declare 696 // "std" or "bad_alloc" as necessary to form the exception specification. 697 // However, we do not make these implicit declarations visible to name 698 // lookup. 699 if (!StdNamespace) { 700 // The "std" namespace has not yet been defined, so build one implicitly. 701 StdNamespace = NamespaceDecl::Create(Context, 702 Context.getTranslationUnitDecl(), 703 SourceLocation(), 704 &PP.getIdentifierTable().get("std")); 705 StdNamespace->setImplicit(true); 706 } 707 708 if (!StdBadAlloc) { 709 // The "std::bad_alloc" class has not yet been declared, so build it 710 // implicitly. 711 StdBadAlloc = CXXRecordDecl::Create(Context, TagDecl::TK_class, 712 StdNamespace, 713 SourceLocation(), 714 &PP.getIdentifierTable().get("bad_alloc"), 715 SourceLocation(), 0); 716 StdBadAlloc->setImplicit(true); 717 } 718 719 GlobalNewDeleteDeclared = true; 720 721 QualType VoidPtr = Context.getPointerType(Context.VoidTy); 722 QualType SizeT = Context.getSizeType(); 723 724 DeclareGlobalAllocationFunction( 725 Context.DeclarationNames.getCXXOperatorName(OO_New), 726 VoidPtr, SizeT); 727 DeclareGlobalAllocationFunction( 728 Context.DeclarationNames.getCXXOperatorName(OO_Array_New), 729 VoidPtr, SizeT); 730 DeclareGlobalAllocationFunction( 731 Context.DeclarationNames.getCXXOperatorName(OO_Delete), 732 Context.VoidTy, VoidPtr); 733 DeclareGlobalAllocationFunction( 734 Context.DeclarationNames.getCXXOperatorName(OO_Array_Delete), 735 Context.VoidTy, VoidPtr); 736} 737 738/// DeclareGlobalAllocationFunction - Declares a single implicit global 739/// allocation function if it doesn't already exist. 740void Sema::DeclareGlobalAllocationFunction(DeclarationName Name, 741 QualType Return, QualType Argument) { 742 DeclContext *GlobalCtx = Context.getTranslationUnitDecl(); 743 744 // Check if this function is already declared. 745 { 746 DeclContext::lookup_iterator Alloc, AllocEnd; 747 for (llvm::tie(Alloc, AllocEnd) = GlobalCtx->lookup(Name); 748 Alloc != AllocEnd; ++Alloc) { 749 // FIXME: Do we need to check for default arguments here? 750 FunctionDecl *Func = cast<FunctionDecl>(*Alloc); 751 if (Func->getNumParams() == 1 && 752 Context.getCanonicalType(Func->getParamDecl(0)->getType())==Argument) 753 return; 754 } 755 } 756 757 QualType BadAllocType; 758 bool HasBadAllocExceptionSpec 759 = (Name.getCXXOverloadedOperator() == OO_New || 760 Name.getCXXOverloadedOperator() == OO_Array_New); 761 if (HasBadAllocExceptionSpec) { 762 assert(StdBadAlloc && "Must have std::bad_alloc declared"); 763 BadAllocType = Context.getTypeDeclType(StdBadAlloc); 764 } 765 766 QualType FnType = Context.getFunctionType(Return, &Argument, 1, false, 0, 767 true, false, 768 HasBadAllocExceptionSpec? 1 : 0, 769 &BadAllocType); 770 FunctionDecl *Alloc = 771 FunctionDecl::Create(Context, GlobalCtx, SourceLocation(), Name, 772 FnType, /*TInfo=*/0, FunctionDecl::None, false, true); 773 Alloc->setImplicit(); 774 ParmVarDecl *Param = ParmVarDecl::Create(Context, Alloc, SourceLocation(), 775 0, Argument, /*TInfo=*/0, 776 VarDecl::None, 0); 777 Alloc->setParams(Context, &Param, 1); 778 779 // FIXME: Also add this declaration to the IdentifierResolver, but 780 // make sure it is at the end of the chain to coincide with the 781 // global scope. 782 ((DeclContext *)TUScope->getEntity())->addDecl(Alloc); 783} 784 785bool Sema::FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD, 786 DeclarationName Name, 787 FunctionDecl* &Operator) { 788 LookupResult Found(*this, Name, StartLoc, LookupOrdinaryName); 789 // Try to find operator delete/operator delete[] in class scope. 790 LookupQualifiedName(Found, RD); 791 792 if (Found.isAmbiguous()) 793 return true; 794 795 for (LookupResult::iterator F = Found.begin(), FEnd = Found.end(); 796 F != FEnd; ++F) { 797 if (CXXMethodDecl *Delete = dyn_cast<CXXMethodDecl>(*F)) 798 if (Delete->isUsualDeallocationFunction()) { 799 Operator = Delete; 800 return false; 801 } 802 } 803 804 // We did find operator delete/operator delete[] declarations, but 805 // none of them were suitable. 806 if (!Found.empty()) { 807 Diag(StartLoc, diag::err_no_suitable_delete_member_function_found) 808 << Name << RD; 809 810 for (LookupResult::iterator F = Found.begin(), FEnd = Found.end(); 811 F != FEnd; ++F) { 812 Diag((*F)->getLocation(), 813 diag::note_delete_member_function_declared_here) 814 << Name; 815 } 816 817 return true; 818 } 819 820 // Look for a global declaration. 821 DeclareGlobalNewDelete(); 822 DeclContext *TUDecl = Context.getTranslationUnitDecl(); 823 824 CXXNullPtrLiteralExpr Null(Context.VoidPtrTy, SourceLocation()); 825 Expr* DeallocArgs[1]; 826 DeallocArgs[0] = &Null; 827 if (FindAllocationOverload(StartLoc, SourceRange(), Name, 828 DeallocArgs, 1, TUDecl, /*AllowMissing=*/false, 829 Operator)) 830 return true; 831 832 assert(Operator && "Did not find a deallocation function!"); 833 return false; 834} 835 836/// ActOnCXXDelete - Parsed a C++ 'delete' expression (C++ 5.3.5), as in: 837/// @code ::delete ptr; @endcode 838/// or 839/// @code delete [] ptr; @endcode 840Action::OwningExprResult 841Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal, 842 bool ArrayForm, ExprArg Operand) { 843 // C++ [expr.delete]p1: 844 // The operand shall have a pointer type, or a class type having a single 845 // conversion function to a pointer type. The result has type void. 846 // 847 // DR599 amends "pointer type" to "pointer to object type" in both cases. 848 849 FunctionDecl *OperatorDelete = 0; 850 851 Expr *Ex = (Expr *)Operand.get(); 852 if (!Ex->isTypeDependent()) { 853 QualType Type = Ex->getType(); 854 855 if (const RecordType *Record = Type->getAs<RecordType>()) { 856 llvm::SmallVector<CXXConversionDecl *, 4> ObjectPtrConversions; 857 CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl()); 858 const UnresolvedSet *Conversions = RD->getVisibleConversionFunctions(); 859 860 for (UnresolvedSet::iterator I = Conversions->begin(), 861 E = Conversions->end(); I != E; ++I) { 862 // Skip over templated conversion functions; they aren't considered. 863 if (isa<FunctionTemplateDecl>(*I)) 864 continue; 865 866 CXXConversionDecl *Conv = cast<CXXConversionDecl>(*I); 867 868 QualType ConvType = Conv->getConversionType().getNonReferenceType(); 869 if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>()) 870 if (ConvPtrType->getPointeeType()->isObjectType()) 871 ObjectPtrConversions.push_back(Conv); 872 } 873 if (ObjectPtrConversions.size() == 1) { 874 // We have a single conversion to a pointer-to-object type. Perform 875 // that conversion. 876 Operand.release(); 877 if (!PerformImplicitConversion(Ex, 878 ObjectPtrConversions.front()->getConversionType(), 879 "converting")) { 880 Operand = Owned(Ex); 881 Type = Ex->getType(); 882 } 883 } 884 else if (ObjectPtrConversions.size() > 1) { 885 Diag(StartLoc, diag::err_ambiguous_delete_operand) 886 << Type << Ex->getSourceRange(); 887 for (unsigned i= 0; i < ObjectPtrConversions.size(); i++) { 888 CXXConversionDecl *Conv = ObjectPtrConversions[i]; 889 Diag(Conv->getLocation(), diag::err_ovl_candidate); 890 } 891 return ExprError(); 892 } 893 } 894 895 if (!Type->isPointerType()) 896 return ExprError(Diag(StartLoc, diag::err_delete_operand) 897 << Type << Ex->getSourceRange()); 898 899 QualType Pointee = Type->getAs<PointerType>()->getPointeeType(); 900 if (Pointee->isFunctionType() || Pointee->isVoidType()) 901 return ExprError(Diag(StartLoc, diag::err_delete_operand) 902 << Type << Ex->getSourceRange()); 903 else if (!Pointee->isDependentType() && 904 RequireCompleteType(StartLoc, Pointee, 905 PDiag(diag::warn_delete_incomplete) 906 << Ex->getSourceRange())) 907 return ExprError(); 908 909 // C++ [expr.delete]p2: 910 // [Note: a pointer to a const type can be the operand of a 911 // delete-expression; it is not necessary to cast away the constness 912 // (5.2.11) of the pointer expression before it is used as the operand 913 // of the delete-expression. ] 914 ImpCastExprToType(Ex, Context.getPointerType(Context.VoidTy), 915 CastExpr::CK_NoOp); 916 917 // Update the operand. 918 Operand.take(); 919 Operand = ExprArg(*this, Ex); 920 921 DeclarationName DeleteName = Context.DeclarationNames.getCXXOperatorName( 922 ArrayForm ? OO_Array_Delete : OO_Delete); 923 924 if (const RecordType *RT = Pointee->getAs<RecordType>()) { 925 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 926 927 if (!UseGlobal && 928 FindDeallocationFunction(StartLoc, RD, DeleteName, OperatorDelete)) 929 return ExprError(); 930 931 if (!RD->hasTrivialDestructor()) 932 if (const CXXDestructorDecl *Dtor = RD->getDestructor(Context)) 933 MarkDeclarationReferenced(StartLoc, 934 const_cast<CXXDestructorDecl*>(Dtor)); 935 } 936 937 if (!OperatorDelete) { 938 // Look for a global declaration. 939 DeclareGlobalNewDelete(); 940 DeclContext *TUDecl = Context.getTranslationUnitDecl(); 941 if (FindAllocationOverload(StartLoc, SourceRange(), DeleteName, 942 &Ex, 1, TUDecl, /*AllowMissing=*/false, 943 OperatorDelete)) 944 return ExprError(); 945 } 946 947 // FIXME: Check access and ambiguity of operator delete and destructor. 948 } 949 950 Operand.release(); 951 return Owned(new (Context) CXXDeleteExpr(Context.VoidTy, UseGlobal, ArrayForm, 952 OperatorDelete, Ex, StartLoc)); 953} 954 955/// \brief Check the use of the given variable as a C++ condition in an if, 956/// while, do-while, or switch statement. 957Action::OwningExprResult Sema::CheckConditionVariable(VarDecl *ConditionVar) { 958 QualType T = ConditionVar->getType(); 959 960 // C++ [stmt.select]p2: 961 // The declarator shall not specify a function or an array. 962 if (T->isFunctionType()) 963 return ExprError(Diag(ConditionVar->getLocation(), 964 diag::err_invalid_use_of_function_type) 965 << ConditionVar->getSourceRange()); 966 else if (T->isArrayType()) 967 return ExprError(Diag(ConditionVar->getLocation(), 968 diag::err_invalid_use_of_array_type) 969 << ConditionVar->getSourceRange()); 970 971 return Owned(DeclRefExpr::Create(Context, 0, SourceRange(), ConditionVar, 972 ConditionVar->getLocation(), 973 ConditionVar->getType().getNonReferenceType())); 974} 975 976/// CheckCXXBooleanCondition - Returns true if a conversion to bool is invalid. 977bool Sema::CheckCXXBooleanCondition(Expr *&CondExpr) { 978 // C++ 6.4p4: 979 // The value of a condition that is an initialized declaration in a statement 980 // other than a switch statement is the value of the declared variable 981 // implicitly converted to type bool. If that conversion is ill-formed, the 982 // program is ill-formed. 983 // The value of a condition that is an expression is the value of the 984 // expression, implicitly converted to bool. 985 // 986 return PerformContextuallyConvertToBool(CondExpr); 987} 988 989/// Helper function to determine whether this is the (deprecated) C++ 990/// conversion from a string literal to a pointer to non-const char or 991/// non-const wchar_t (for narrow and wide string literals, 992/// respectively). 993bool 994Sema::IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType) { 995 // Look inside the implicit cast, if it exists. 996 if (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(From)) 997 From = Cast->getSubExpr(); 998 999 // A string literal (2.13.4) that is not a wide string literal can 1000 // be converted to an rvalue of type "pointer to char"; a wide 1001 // string literal can be converted to an rvalue of type "pointer 1002 // to wchar_t" (C++ 4.2p2). 1003 if (StringLiteral *StrLit = dyn_cast<StringLiteral>(From)) 1004 if (const PointerType *ToPtrType = ToType->getAs<PointerType>()) 1005 if (const BuiltinType *ToPointeeType 1006 = ToPtrType->getPointeeType()->getAs<BuiltinType>()) { 1007 // This conversion is considered only when there is an 1008 // explicit appropriate pointer target type (C++ 4.2p2). 1009 if (!ToPtrType->getPointeeType().hasQualifiers() && 1010 ((StrLit->isWide() && ToPointeeType->isWideCharType()) || 1011 (!StrLit->isWide() && 1012 (ToPointeeType->getKind() == BuiltinType::Char_U || 1013 ToPointeeType->getKind() == BuiltinType::Char_S)))) 1014 return true; 1015 } 1016 1017 return false; 1018} 1019 1020/// PerformImplicitConversion - Perform an implicit conversion of the 1021/// expression From to the type ToType. Returns true if there was an 1022/// error, false otherwise. The expression From is replaced with the 1023/// converted expression. Flavor is the kind of conversion we're 1024/// performing, used in the error message. If @p AllowExplicit, 1025/// explicit user-defined conversions are permitted. @p Elidable should be true 1026/// when called for copies which may be elided (C++ 12.8p15). C++0x overload 1027/// resolution works differently in that case. 1028bool 1029Sema::PerformImplicitConversion(Expr *&From, QualType ToType, 1030 const char *Flavor, bool AllowExplicit, 1031 bool Elidable) { 1032 ImplicitConversionSequence ICS; 1033 return PerformImplicitConversion(From, ToType, Flavor, AllowExplicit, 1034 Elidable, ICS); 1035} 1036 1037bool 1038Sema::PerformImplicitConversion(Expr *&From, QualType ToType, 1039 const char *Flavor, bool AllowExplicit, 1040 bool Elidable, 1041 ImplicitConversionSequence& ICS) { 1042 ICS.ConversionKind = ImplicitConversionSequence::BadConversion; 1043 if (Elidable && getLangOptions().CPlusPlus0x) { 1044 ICS = TryImplicitConversion(From, ToType, 1045 /*SuppressUserConversions=*/false, 1046 AllowExplicit, 1047 /*ForceRValue=*/true, 1048 /*InOverloadResolution=*/false); 1049 } 1050 if (ICS.ConversionKind == ImplicitConversionSequence::BadConversion) { 1051 ICS = TryImplicitConversion(From, ToType, 1052 /*SuppressUserConversions=*/false, 1053 AllowExplicit, 1054 /*ForceRValue=*/false, 1055 /*InOverloadResolution=*/false); 1056 } 1057 return PerformImplicitConversion(From, ToType, ICS, Flavor); 1058} 1059 1060/// BuildCXXDerivedToBaseExpr - This routine generates the suitable AST 1061/// for the derived to base conversion of the expression 'From'. All 1062/// necessary information is passed in ICS. 1063bool 1064Sema::BuildCXXDerivedToBaseExpr(Expr *&From, CastExpr::CastKind CastKind, 1065 const ImplicitConversionSequence& ICS, 1066 const char *Flavor) { 1067 QualType BaseType = 1068 QualType::getFromOpaquePtr(ICS.UserDefined.After.ToTypePtr); 1069 // Must do additional defined to base conversion. 1070 QualType DerivedType = 1071 QualType::getFromOpaquePtr(ICS.UserDefined.After.FromTypePtr); 1072 1073 From = new (Context) ImplicitCastExpr( 1074 DerivedType.getNonReferenceType(), 1075 CastKind, 1076 From, 1077 DerivedType->isLValueReferenceType()); 1078 From = new (Context) ImplicitCastExpr(BaseType.getNonReferenceType(), 1079 CastExpr::CK_DerivedToBase, From, 1080 BaseType->isLValueReferenceType()); 1081 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(*this); 1082 OwningExprResult FromResult = 1083 BuildCXXConstructExpr( 1084 ICS.UserDefined.After.CopyConstructor->getLocation(), 1085 BaseType, 1086 ICS.UserDefined.After.CopyConstructor, 1087 MultiExprArg(*this, (void **)&From, 1)); 1088 if (FromResult.isInvalid()) 1089 return true; 1090 From = FromResult.takeAs<Expr>(); 1091 return false; 1092} 1093 1094/// PerformImplicitConversion - Perform an implicit conversion of the 1095/// expression From to the type ToType using the pre-computed implicit 1096/// conversion sequence ICS. Returns true if there was an error, false 1097/// otherwise. The expression From is replaced with the converted 1098/// expression. Flavor is the kind of conversion we're performing, 1099/// used in the error message. 1100bool 1101Sema::PerformImplicitConversion(Expr *&From, QualType ToType, 1102 const ImplicitConversionSequence &ICS, 1103 const char* Flavor, bool IgnoreBaseAccess) { 1104 switch (ICS.ConversionKind) { 1105 case ImplicitConversionSequence::StandardConversion: 1106 if (PerformImplicitConversion(From, ToType, ICS.Standard, Flavor, 1107 IgnoreBaseAccess)) 1108 return true; 1109 break; 1110 1111 case ImplicitConversionSequence::UserDefinedConversion: { 1112 1113 FunctionDecl *FD = ICS.UserDefined.ConversionFunction; 1114 CastExpr::CastKind CastKind = CastExpr::CK_Unknown; 1115 QualType BeforeToType; 1116 if (const CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(FD)) { 1117 CastKind = CastExpr::CK_UserDefinedConversion; 1118 1119 // If the user-defined conversion is specified by a conversion function, 1120 // the initial standard conversion sequence converts the source type to 1121 // the implicit object parameter of the conversion function. 1122 BeforeToType = Context.getTagDeclType(Conv->getParent()); 1123 } else if (const CXXConstructorDecl *Ctor = 1124 dyn_cast<CXXConstructorDecl>(FD)) { 1125 CastKind = CastExpr::CK_ConstructorConversion; 1126 // Do no conversion if dealing with ... for the first conversion. 1127 if (!ICS.UserDefined.EllipsisConversion) { 1128 // If the user-defined conversion is specified by a constructor, the 1129 // initial standard conversion sequence converts the source type to the 1130 // type required by the argument of the constructor 1131 BeforeToType = Ctor->getParamDecl(0)->getType().getNonReferenceType(); 1132 } 1133 } 1134 else 1135 assert(0 && "Unknown conversion function kind!"); 1136 // Whatch out for elipsis conversion. 1137 if (!ICS.UserDefined.EllipsisConversion) { 1138 if (PerformImplicitConversion(From, BeforeToType, 1139 ICS.UserDefined.Before, "converting", 1140 IgnoreBaseAccess)) 1141 return true; 1142 } 1143 1144 OwningExprResult CastArg 1145 = BuildCXXCastArgument(From->getLocStart(), 1146 ToType.getNonReferenceType(), 1147 CastKind, cast<CXXMethodDecl>(FD), 1148 Owned(From)); 1149 1150 if (CastArg.isInvalid()) 1151 return true; 1152 1153 From = CastArg.takeAs<Expr>(); 1154 1155 // FIXME: This and the following if statement shouldn't be necessary, but 1156 // there's some nasty stuff involving MaybeBindToTemporary going on here. 1157 if (ICS.UserDefined.After.Second == ICK_Derived_To_Base && 1158 ICS.UserDefined.After.CopyConstructor) { 1159 return BuildCXXDerivedToBaseExpr(From, CastKind, ICS, Flavor); 1160 } 1161 1162 if (ICS.UserDefined.After.CopyConstructor) { 1163 From = new (Context) ImplicitCastExpr(ToType.getNonReferenceType(), 1164 CastKind, From, 1165 ToType->isLValueReferenceType()); 1166 return false; 1167 } 1168 1169 return PerformImplicitConversion(From, ToType, ICS.UserDefined.After, 1170 "converting", IgnoreBaseAccess); 1171 } 1172 1173 case ImplicitConversionSequence::EllipsisConversion: 1174 assert(false && "Cannot perform an ellipsis conversion"); 1175 return false; 1176 1177 case ImplicitConversionSequence::BadConversion: 1178 return true; 1179 } 1180 1181 // Everything went well. 1182 return false; 1183} 1184 1185/// PerformImplicitConversion - Perform an implicit conversion of the 1186/// expression From to the type ToType by following the standard 1187/// conversion sequence SCS. Returns true if there was an error, false 1188/// otherwise. The expression From is replaced with the converted 1189/// expression. Flavor is the context in which we're performing this 1190/// conversion, for use in error messages. 1191bool 1192Sema::PerformImplicitConversion(Expr *&From, QualType ToType, 1193 const StandardConversionSequence& SCS, 1194 const char *Flavor, bool IgnoreBaseAccess) { 1195 // Overall FIXME: we are recomputing too many types here and doing far too 1196 // much extra work. What this means is that we need to keep track of more 1197 // information that is computed when we try the implicit conversion initially, 1198 // so that we don't need to recompute anything here. 1199 QualType FromType = From->getType(); 1200 1201 if (SCS.CopyConstructor) { 1202 // FIXME: When can ToType be a reference type? 1203 assert(!ToType->isReferenceType()); 1204 if (SCS.Second == ICK_Derived_To_Base) { 1205 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(*this); 1206 if (CompleteConstructorCall(cast<CXXConstructorDecl>(SCS.CopyConstructor), 1207 MultiExprArg(*this, (void **)&From, 1), 1208 /*FIXME:ConstructLoc*/SourceLocation(), 1209 ConstructorArgs)) 1210 return true; 1211 OwningExprResult FromResult = 1212 BuildCXXConstructExpr(/*FIXME:ConstructLoc*/SourceLocation(), 1213 ToType, SCS.CopyConstructor, 1214 move_arg(ConstructorArgs)); 1215 if (FromResult.isInvalid()) 1216 return true; 1217 From = FromResult.takeAs<Expr>(); 1218 return false; 1219 } 1220 OwningExprResult FromResult = 1221 BuildCXXConstructExpr(/*FIXME:ConstructLoc*/SourceLocation(), 1222 ToType, SCS.CopyConstructor, 1223 MultiExprArg(*this, (void**)&From, 1)); 1224 1225 if (FromResult.isInvalid()) 1226 return true; 1227 1228 From = FromResult.takeAs<Expr>(); 1229 return false; 1230 } 1231 1232 // Perform the first implicit conversion. 1233 switch (SCS.First) { 1234 case ICK_Identity: 1235 case ICK_Lvalue_To_Rvalue: 1236 // Nothing to do. 1237 break; 1238 1239 case ICK_Array_To_Pointer: 1240 FromType = Context.getArrayDecayedType(FromType); 1241 ImpCastExprToType(From, FromType, CastExpr::CK_ArrayToPointerDecay); 1242 break; 1243 1244 case ICK_Function_To_Pointer: 1245 if (Context.getCanonicalType(FromType) == Context.OverloadTy) { 1246 FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(From, ToType, true); 1247 if (!Fn) 1248 return true; 1249 1250 if (DiagnoseUseOfDecl(Fn, From->getSourceRange().getBegin())) 1251 return true; 1252 1253 From = FixOverloadedFunctionReference(From, Fn); 1254 FromType = From->getType(); 1255 1256 // If there's already an address-of operator in the expression, we have 1257 // the right type already, and the code below would just introduce an 1258 // invalid additional pointer level. 1259 if (FromType->isPointerType() || FromType->isMemberFunctionPointerType()) 1260 break; 1261 } 1262 FromType = Context.getPointerType(FromType); 1263 ImpCastExprToType(From, FromType, CastExpr::CK_FunctionToPointerDecay); 1264 break; 1265 1266 default: 1267 assert(false && "Improper first standard conversion"); 1268 break; 1269 } 1270 1271 // Perform the second implicit conversion 1272 switch (SCS.Second) { 1273 case ICK_Identity: 1274 // If both sides are functions (or pointers/references to them), there could 1275 // be incompatible exception declarations. 1276 if (CheckExceptionSpecCompatibility(From, ToType)) 1277 return true; 1278 // Nothing else to do. 1279 break; 1280 1281 case ICK_NoReturn_Adjustment: 1282 // If both sides are functions (or pointers/references to them), there could 1283 // be incompatible exception declarations. 1284 if (CheckExceptionSpecCompatibility(From, ToType)) 1285 return true; 1286 1287 ImpCastExprToType(From, Context.getNoReturnType(From->getType(), false), 1288 CastExpr::CK_NoOp); 1289 break; 1290 1291 case ICK_Integral_Promotion: 1292 case ICK_Integral_Conversion: 1293 ImpCastExprToType(From, ToType, CastExpr::CK_IntegralCast); 1294 break; 1295 1296 case ICK_Floating_Promotion: 1297 case ICK_Floating_Conversion: 1298 ImpCastExprToType(From, ToType, CastExpr::CK_FloatingCast); 1299 break; 1300 1301 case ICK_Complex_Promotion: 1302 case ICK_Complex_Conversion: 1303 ImpCastExprToType(From, ToType, CastExpr::CK_Unknown); 1304 break; 1305 1306 case ICK_Floating_Integral: 1307 if (ToType->isFloatingType()) 1308 ImpCastExprToType(From, ToType, CastExpr::CK_IntegralToFloating); 1309 else 1310 ImpCastExprToType(From, ToType, CastExpr::CK_FloatingToIntegral); 1311 break; 1312 1313 case ICK_Complex_Real: 1314 ImpCastExprToType(From, ToType, CastExpr::CK_Unknown); 1315 break; 1316 1317 case ICK_Compatible_Conversion: 1318 ImpCastExprToType(From, ToType, CastExpr::CK_NoOp); 1319 break; 1320 1321 case ICK_Pointer_Conversion: { 1322 if (SCS.IncompatibleObjC) { 1323 // Diagnose incompatible Objective-C conversions 1324 Diag(From->getSourceRange().getBegin(), 1325 diag::ext_typecheck_convert_incompatible_pointer) 1326 << From->getType() << ToType << Flavor 1327 << From->getSourceRange(); 1328 } 1329 1330 1331 CastExpr::CastKind Kind = CastExpr::CK_Unknown; 1332 if (CheckPointerConversion(From, ToType, Kind, IgnoreBaseAccess)) 1333 return true; 1334 ImpCastExprToType(From, ToType, Kind); 1335 break; 1336 } 1337 1338 case ICK_Pointer_Member: { 1339 CastExpr::CastKind Kind = CastExpr::CK_Unknown; 1340 if (CheckMemberPointerConversion(From, ToType, Kind, IgnoreBaseAccess)) 1341 return true; 1342 if (CheckExceptionSpecCompatibility(From, ToType)) 1343 return true; 1344 ImpCastExprToType(From, ToType, Kind); 1345 break; 1346 } 1347 case ICK_Boolean_Conversion: { 1348 CastExpr::CastKind Kind = CastExpr::CK_Unknown; 1349 if (FromType->isMemberPointerType()) 1350 Kind = CastExpr::CK_MemberPointerToBoolean; 1351 1352 ImpCastExprToType(From, Context.BoolTy, Kind); 1353 break; 1354 } 1355 1356 case ICK_Derived_To_Base: 1357 if (CheckDerivedToBaseConversion(From->getType(), 1358 ToType.getNonReferenceType(), 1359 From->getLocStart(), 1360 From->getSourceRange(), 1361 IgnoreBaseAccess)) 1362 return true; 1363 ImpCastExprToType(From, ToType.getNonReferenceType(), 1364 CastExpr::CK_DerivedToBase); 1365 break; 1366 1367 default: 1368 assert(false && "Improper second standard conversion"); 1369 break; 1370 } 1371 1372 switch (SCS.Third) { 1373 case ICK_Identity: 1374 // Nothing to do. 1375 break; 1376 1377 case ICK_Qualification: 1378 // FIXME: Not sure about lvalue vs rvalue here in the presence of rvalue 1379 // references. 1380 ImpCastExprToType(From, ToType.getNonReferenceType(), 1381 CastExpr::CK_NoOp, 1382 ToType->isLValueReferenceType()); 1383 break; 1384 1385 default: 1386 assert(false && "Improper second standard conversion"); 1387 break; 1388 } 1389 1390 return false; 1391} 1392 1393Sema::OwningExprResult Sema::ActOnUnaryTypeTrait(UnaryTypeTrait OTT, 1394 SourceLocation KWLoc, 1395 SourceLocation LParen, 1396 TypeTy *Ty, 1397 SourceLocation RParen) { 1398 QualType T = GetTypeFromParser(Ty); 1399 1400 // According to http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html 1401 // all traits except __is_class, __is_enum and __is_union require a the type 1402 // to be complete. 1403 if (OTT != UTT_IsClass && OTT != UTT_IsEnum && OTT != UTT_IsUnion) { 1404 if (RequireCompleteType(KWLoc, T, 1405 diag::err_incomplete_type_used_in_type_trait_expr)) 1406 return ExprError(); 1407 } 1408 1409 // There is no point in eagerly computing the value. The traits are designed 1410 // to be used from type trait templates, so Ty will be a template parameter 1411 // 99% of the time. 1412 return Owned(new (Context) UnaryTypeTraitExpr(KWLoc, OTT, T, 1413 RParen, Context.BoolTy)); 1414} 1415 1416QualType Sema::CheckPointerToMemberOperands( 1417 Expr *&lex, Expr *&rex, SourceLocation Loc, bool isIndirect) { 1418 const char *OpSpelling = isIndirect ? "->*" : ".*"; 1419 // C++ 5.5p2 1420 // The binary operator .* [p3: ->*] binds its second operand, which shall 1421 // be of type "pointer to member of T" (where T is a completely-defined 1422 // class type) [...] 1423 QualType RType = rex->getType(); 1424 const MemberPointerType *MemPtr = RType->getAs<MemberPointerType>(); 1425 if (!MemPtr) { 1426 Diag(Loc, diag::err_bad_memptr_rhs) 1427 << OpSpelling << RType << rex->getSourceRange(); 1428 return QualType(); 1429 } 1430 1431 QualType Class(MemPtr->getClass(), 0); 1432 1433 // C++ 5.5p2 1434 // [...] to its first operand, which shall be of class T or of a class of 1435 // which T is an unambiguous and accessible base class. [p3: a pointer to 1436 // such a class] 1437 QualType LType = lex->getType(); 1438 if (isIndirect) { 1439 if (const PointerType *Ptr = LType->getAs<PointerType>()) 1440 LType = Ptr->getPointeeType().getNonReferenceType(); 1441 else { 1442 Diag(Loc, diag::err_bad_memptr_lhs) 1443 << OpSpelling << 1 << LType 1444 << CodeModificationHint::CreateReplacement(SourceRange(Loc), ".*"); 1445 return QualType(); 1446 } 1447 } 1448 1449 if (!Context.hasSameUnqualifiedType(Class, LType)) { 1450 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/false, 1451 /*DetectVirtual=*/false); 1452 // FIXME: Would it be useful to print full ambiguity paths, or is that 1453 // overkill? 1454 if (!IsDerivedFrom(LType, Class, Paths) || 1455 Paths.isAmbiguous(Context.getCanonicalType(Class))) { 1456 const char *ReplaceStr = isIndirect ? ".*" : "->*"; 1457 Diag(Loc, diag::err_bad_memptr_lhs) << OpSpelling 1458 << (int)isIndirect << lex->getType() << 1459 CodeModificationHint::CreateReplacement(SourceRange(Loc), ReplaceStr); 1460 return QualType(); 1461 } 1462 } 1463 1464 if (isa<CXXZeroInitValueExpr>(rex->IgnoreParens())) { 1465 // Diagnose use of pointer-to-member type which when used as 1466 // the functional cast in a pointer-to-member expression. 1467 Diag(Loc, diag::err_pointer_to_member_type) << isIndirect; 1468 return QualType(); 1469 } 1470 // C++ 5.5p2 1471 // The result is an object or a function of the type specified by the 1472 // second operand. 1473 // The cv qualifiers are the union of those in the pointer and the left side, 1474 // in accordance with 5.5p5 and 5.2.5. 1475 // FIXME: This returns a dereferenced member function pointer as a normal 1476 // function type. However, the only operation valid on such functions is 1477 // calling them. There's also a GCC extension to get a function pointer to the 1478 // thing, which is another complication, because this type - unlike the type 1479 // that is the result of this expression - takes the class as the first 1480 // argument. 1481 // We probably need a "MemberFunctionClosureType" or something like that. 1482 QualType Result = MemPtr->getPointeeType(); 1483 Result = Context.getCVRQualifiedType(Result, LType.getCVRQualifiers()); 1484 return Result; 1485} 1486 1487/// \brief Get the target type of a standard or user-defined conversion. 1488static QualType TargetType(const ImplicitConversionSequence &ICS) { 1489 assert((ICS.ConversionKind == 1490 ImplicitConversionSequence::StandardConversion || 1491 ICS.ConversionKind == 1492 ImplicitConversionSequence::UserDefinedConversion) && 1493 "function only valid for standard or user-defined conversions"); 1494 if (ICS.ConversionKind == ImplicitConversionSequence::StandardConversion) 1495 return QualType::getFromOpaquePtr(ICS.Standard.ToTypePtr); 1496 return QualType::getFromOpaquePtr(ICS.UserDefined.After.ToTypePtr); 1497} 1498 1499/// \brief Try to convert a type to another according to C++0x 5.16p3. 1500/// 1501/// This is part of the parameter validation for the ? operator. If either 1502/// value operand is a class type, the two operands are attempted to be 1503/// converted to each other. This function does the conversion in one direction. 1504/// It emits a diagnostic and returns true only if it finds an ambiguous 1505/// conversion. 1506static bool TryClassUnification(Sema &Self, Expr *From, Expr *To, 1507 SourceLocation QuestionLoc, 1508 ImplicitConversionSequence &ICS) { 1509 // C++0x 5.16p3 1510 // The process for determining whether an operand expression E1 of type T1 1511 // can be converted to match an operand expression E2 of type T2 is defined 1512 // as follows: 1513 // -- If E2 is an lvalue: 1514 if (To->isLvalue(Self.Context) == Expr::LV_Valid) { 1515 // E1 can be converted to match E2 if E1 can be implicitly converted to 1516 // type "lvalue reference to T2", subject to the constraint that in the 1517 // conversion the reference must bind directly to E1. 1518 if (!Self.CheckReferenceInit(From, 1519 Self.Context.getLValueReferenceType(To->getType()), 1520 To->getLocStart(), 1521 /*SuppressUserConversions=*/false, 1522 /*AllowExplicit=*/false, 1523 /*ForceRValue=*/false, 1524 &ICS)) 1525 { 1526 assert((ICS.ConversionKind == 1527 ImplicitConversionSequence::StandardConversion || 1528 ICS.ConversionKind == 1529 ImplicitConversionSequence::UserDefinedConversion) && 1530 "expected a definite conversion"); 1531 bool DirectBinding = 1532 ICS.ConversionKind == ImplicitConversionSequence::StandardConversion ? 1533 ICS.Standard.DirectBinding : ICS.UserDefined.After.DirectBinding; 1534 if (DirectBinding) 1535 return false; 1536 } 1537 } 1538 ICS.ConversionKind = ImplicitConversionSequence::BadConversion; 1539 // -- If E2 is an rvalue, or if the conversion above cannot be done: 1540 // -- if E1 and E2 have class type, and the underlying class types are 1541 // the same or one is a base class of the other: 1542 QualType FTy = From->getType(); 1543 QualType TTy = To->getType(); 1544 const RecordType *FRec = FTy->getAs<RecordType>(); 1545 const RecordType *TRec = TTy->getAs<RecordType>(); 1546 bool FDerivedFromT = FRec && TRec && Self.IsDerivedFrom(FTy, TTy); 1547 if (FRec && TRec && (FRec == TRec || 1548 FDerivedFromT || Self.IsDerivedFrom(TTy, FTy))) { 1549 // E1 can be converted to match E2 if the class of T2 is the 1550 // same type as, or a base class of, the class of T1, and 1551 // [cv2 > cv1]. 1552 if ((FRec == TRec || FDerivedFromT) && TTy.isAtLeastAsQualifiedAs(FTy)) { 1553 // Could still fail if there's no copy constructor. 1554 // FIXME: Is this a hard error then, or just a conversion failure? The 1555 // standard doesn't say. 1556 ICS = Self.TryCopyInitialization(From, TTy, 1557 /*SuppressUserConversions=*/false, 1558 /*ForceRValue=*/false, 1559 /*InOverloadResolution=*/false); 1560 } 1561 } else { 1562 // -- Otherwise: E1 can be converted to match E2 if E1 can be 1563 // implicitly converted to the type that expression E2 would have 1564 // if E2 were converted to an rvalue. 1565 // First find the decayed type. 1566 if (TTy->isFunctionType()) 1567 TTy = Self.Context.getPointerType(TTy); 1568 else if (TTy->isArrayType()) 1569 TTy = Self.Context.getArrayDecayedType(TTy); 1570 1571 // Now try the implicit conversion. 1572 // FIXME: This doesn't detect ambiguities. 1573 ICS = Self.TryImplicitConversion(From, TTy, 1574 /*SuppressUserConversions=*/false, 1575 /*AllowExplicit=*/false, 1576 /*ForceRValue=*/false, 1577 /*InOverloadResolution=*/false); 1578 } 1579 return false; 1580} 1581 1582/// \brief Try to find a common type for two according to C++0x 5.16p5. 1583/// 1584/// This is part of the parameter validation for the ? operator. If either 1585/// value operand is a class type, overload resolution is used to find a 1586/// conversion to a common type. 1587static bool FindConditionalOverload(Sema &Self, Expr *&LHS, Expr *&RHS, 1588 SourceLocation Loc) { 1589 Expr *Args[2] = { LHS, RHS }; 1590 OverloadCandidateSet CandidateSet; 1591 Self.AddBuiltinOperatorCandidates(OO_Conditional, Loc, Args, 2, CandidateSet); 1592 1593 OverloadCandidateSet::iterator Best; 1594 switch (Self.BestViableFunction(CandidateSet, Loc, Best)) { 1595 case OR_Success: 1596 // We found a match. Perform the conversions on the arguments and move on. 1597 if (Self.PerformImplicitConversion(LHS, Best->BuiltinTypes.ParamTypes[0], 1598 Best->Conversions[0], "converting") || 1599 Self.PerformImplicitConversion(RHS, Best->BuiltinTypes.ParamTypes[1], 1600 Best->Conversions[1], "converting")) 1601 break; 1602 return false; 1603 1604 case OR_No_Viable_Function: 1605 Self.Diag(Loc, diag::err_typecheck_cond_incompatible_operands) 1606 << LHS->getType() << RHS->getType() 1607 << LHS->getSourceRange() << RHS->getSourceRange(); 1608 return true; 1609 1610 case OR_Ambiguous: 1611 Self.Diag(Loc, diag::err_conditional_ambiguous_ovl) 1612 << LHS->getType() << RHS->getType() 1613 << LHS->getSourceRange() << RHS->getSourceRange(); 1614 // FIXME: Print the possible common types by printing the return types of 1615 // the viable candidates. 1616 break; 1617 1618 case OR_Deleted: 1619 assert(false && "Conditional operator has only built-in overloads"); 1620 break; 1621 } 1622 return true; 1623} 1624 1625/// \brief Perform an "extended" implicit conversion as returned by 1626/// TryClassUnification. 1627/// 1628/// TryClassUnification generates ICSs that include reference bindings. 1629/// PerformImplicitConversion is not suitable for this; it chokes if the 1630/// second part of a standard conversion is ICK_DerivedToBase. This function 1631/// handles the reference binding specially. 1632static bool ConvertForConditional(Sema &Self, Expr *&E, 1633 const ImplicitConversionSequence &ICS) { 1634 if (ICS.ConversionKind == ImplicitConversionSequence::StandardConversion && 1635 ICS.Standard.ReferenceBinding) { 1636 assert(ICS.Standard.DirectBinding && 1637 "TryClassUnification should never generate indirect ref bindings"); 1638 // FIXME: CheckReferenceInit should be able to reuse the ICS instead of 1639 // redoing all the work. 1640 return Self.CheckReferenceInit(E, Self.Context.getLValueReferenceType( 1641 TargetType(ICS)), 1642 /*FIXME:*/E->getLocStart(), 1643 /*SuppressUserConversions=*/false, 1644 /*AllowExplicit=*/false, 1645 /*ForceRValue=*/false); 1646 } 1647 if (ICS.ConversionKind == ImplicitConversionSequence::UserDefinedConversion && 1648 ICS.UserDefined.After.ReferenceBinding) { 1649 assert(ICS.UserDefined.After.DirectBinding && 1650 "TryClassUnification should never generate indirect ref bindings"); 1651 return Self.CheckReferenceInit(E, Self.Context.getLValueReferenceType( 1652 TargetType(ICS)), 1653 /*FIXME:*/E->getLocStart(), 1654 /*SuppressUserConversions=*/false, 1655 /*AllowExplicit=*/false, 1656 /*ForceRValue=*/false); 1657 } 1658 if (Self.PerformImplicitConversion(E, TargetType(ICS), ICS, "converting")) 1659 return true; 1660 return false; 1661} 1662 1663/// \brief Check the operands of ?: under C++ semantics. 1664/// 1665/// See C++ [expr.cond]. Note that LHS is never null, even for the GNU x ?: y 1666/// extension. In this case, LHS == Cond. (But they're not aliases.) 1667QualType Sema::CXXCheckConditionalOperands(Expr *&Cond, Expr *&LHS, Expr *&RHS, 1668 SourceLocation QuestionLoc) { 1669 // FIXME: Handle C99's complex types, vector types, block pointers and Obj-C++ 1670 // interface pointers. 1671 1672 // C++0x 5.16p1 1673 // The first expression is contextually converted to bool. 1674 if (!Cond->isTypeDependent()) { 1675 if (CheckCXXBooleanCondition(Cond)) 1676 return QualType(); 1677 } 1678 1679 // Either of the arguments dependent? 1680 if (LHS->isTypeDependent() || RHS->isTypeDependent()) 1681 return Context.DependentTy; 1682 1683 CheckSignCompare(LHS, RHS, QuestionLoc, diag::warn_mixed_sign_conditional); 1684 1685 // C++0x 5.16p2 1686 // If either the second or the third operand has type (cv) void, ... 1687 QualType LTy = LHS->getType(); 1688 QualType RTy = RHS->getType(); 1689 bool LVoid = LTy->isVoidType(); 1690 bool RVoid = RTy->isVoidType(); 1691 if (LVoid || RVoid) { 1692 // ... then the [l2r] conversions are performed on the second and third 1693 // operands ... 1694 DefaultFunctionArrayConversion(LHS); 1695 DefaultFunctionArrayConversion(RHS); 1696 LTy = LHS->getType(); 1697 RTy = RHS->getType(); 1698 1699 // ... and one of the following shall hold: 1700 // -- The second or the third operand (but not both) is a throw- 1701 // expression; the result is of the type of the other and is an rvalue. 1702 bool LThrow = isa<CXXThrowExpr>(LHS); 1703 bool RThrow = isa<CXXThrowExpr>(RHS); 1704 if (LThrow && !RThrow) 1705 return RTy; 1706 if (RThrow && !LThrow) 1707 return LTy; 1708 1709 // -- Both the second and third operands have type void; the result is of 1710 // type void and is an rvalue. 1711 if (LVoid && RVoid) 1712 return Context.VoidTy; 1713 1714 // Neither holds, error. 1715 Diag(QuestionLoc, diag::err_conditional_void_nonvoid) 1716 << (LVoid ? RTy : LTy) << (LVoid ? 0 : 1) 1717 << LHS->getSourceRange() << RHS->getSourceRange(); 1718 return QualType(); 1719 } 1720 1721 // Neither is void. 1722 1723 // C++0x 5.16p3 1724 // Otherwise, if the second and third operand have different types, and 1725 // either has (cv) class type, and attempt is made to convert each of those 1726 // operands to the other. 1727 if (Context.getCanonicalType(LTy) != Context.getCanonicalType(RTy) && 1728 (LTy->isRecordType() || RTy->isRecordType())) { 1729 ImplicitConversionSequence ICSLeftToRight, ICSRightToLeft; 1730 // These return true if a single direction is already ambiguous. 1731 if (TryClassUnification(*this, LHS, RHS, QuestionLoc, ICSLeftToRight)) 1732 return QualType(); 1733 if (TryClassUnification(*this, RHS, LHS, QuestionLoc, ICSRightToLeft)) 1734 return QualType(); 1735 1736 bool HaveL2R = ICSLeftToRight.ConversionKind != 1737 ImplicitConversionSequence::BadConversion; 1738 bool HaveR2L = ICSRightToLeft.ConversionKind != 1739 ImplicitConversionSequence::BadConversion; 1740 // If both can be converted, [...] the program is ill-formed. 1741 if (HaveL2R && HaveR2L) { 1742 Diag(QuestionLoc, diag::err_conditional_ambiguous) 1743 << LTy << RTy << LHS->getSourceRange() << RHS->getSourceRange(); 1744 return QualType(); 1745 } 1746 1747 // If exactly one conversion is possible, that conversion is applied to 1748 // the chosen operand and the converted operands are used in place of the 1749 // original operands for the remainder of this section. 1750 if (HaveL2R) { 1751 if (ConvertForConditional(*this, LHS, ICSLeftToRight)) 1752 return QualType(); 1753 LTy = LHS->getType(); 1754 } else if (HaveR2L) { 1755 if (ConvertForConditional(*this, RHS, ICSRightToLeft)) 1756 return QualType(); 1757 RTy = RHS->getType(); 1758 } 1759 } 1760 1761 // C++0x 5.16p4 1762 // If the second and third operands are lvalues and have the same type, 1763 // the result is of that type [...] 1764 bool Same = Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy); 1765 if (Same && LHS->isLvalue(Context) == Expr::LV_Valid && 1766 RHS->isLvalue(Context) == Expr::LV_Valid) 1767 return LTy; 1768 1769 // C++0x 5.16p5 1770 // Otherwise, the result is an rvalue. If the second and third operands 1771 // do not have the same type, and either has (cv) class type, ... 1772 if (!Same && (LTy->isRecordType() || RTy->isRecordType())) { 1773 // ... overload resolution is used to determine the conversions (if any) 1774 // to be applied to the operands. If the overload resolution fails, the 1775 // program is ill-formed. 1776 if (FindConditionalOverload(*this, LHS, RHS, QuestionLoc)) 1777 return QualType(); 1778 } 1779 1780 // C++0x 5.16p6 1781 // LValue-to-rvalue, array-to-pointer, and function-to-pointer standard 1782 // conversions are performed on the second and third operands. 1783 DefaultFunctionArrayConversion(LHS); 1784 DefaultFunctionArrayConversion(RHS); 1785 LTy = LHS->getType(); 1786 RTy = RHS->getType(); 1787 1788 // After those conversions, one of the following shall hold: 1789 // -- The second and third operands have the same type; the result 1790 // is of that type. 1791 if (Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy)) 1792 return LTy; 1793 1794 // -- The second and third operands have arithmetic or enumeration type; 1795 // the usual arithmetic conversions are performed to bring them to a 1796 // common type, and the result is of that type. 1797 if (LTy->isArithmeticType() && RTy->isArithmeticType()) { 1798 UsualArithmeticConversions(LHS, RHS); 1799 return LHS->getType(); 1800 } 1801 1802 // -- The second and third operands have pointer type, or one has pointer 1803 // type and the other is a null pointer constant; pointer conversions 1804 // and qualification conversions are performed to bring them to their 1805 // composite pointer type. The result is of the composite pointer type. 1806 QualType Composite = FindCompositePointerType(LHS, RHS); 1807 if (!Composite.isNull()) 1808 return Composite; 1809 1810 // Similarly, attempt to find composite type of twp objective-c pointers. 1811 Composite = FindCompositeObjCPointerType(LHS, RHS, QuestionLoc); 1812 if (!Composite.isNull()) 1813 return Composite; 1814 1815 // Fourth bullet is same for pointers-to-member. However, the possible 1816 // conversions are far more limited: we have null-to-pointer, upcast of 1817 // containing class, and second-level cv-ness. 1818 // cv-ness is not a union, but must match one of the two operands. (Which, 1819 // frankly, is stupid.) 1820 const MemberPointerType *LMemPtr = LTy->getAs<MemberPointerType>(); 1821 const MemberPointerType *RMemPtr = RTy->getAs<MemberPointerType>(); 1822 if (LMemPtr && 1823 RHS->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) { 1824 ImpCastExprToType(RHS, LTy, CastExpr::CK_NullToMemberPointer); 1825 return LTy; 1826 } 1827 if (RMemPtr && 1828 LHS->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) { 1829 ImpCastExprToType(LHS, RTy, CastExpr::CK_NullToMemberPointer); 1830 return RTy; 1831 } 1832 if (LMemPtr && RMemPtr) { 1833 QualType LPointee = LMemPtr->getPointeeType(); 1834 QualType RPointee = RMemPtr->getPointeeType(); 1835 1836 QualifierCollector LPQuals, RPQuals; 1837 const Type *LPCan = LPQuals.strip(Context.getCanonicalType(LPointee)); 1838 const Type *RPCan = RPQuals.strip(Context.getCanonicalType(RPointee)); 1839 1840 // First, we check that the unqualified pointee type is the same. If it's 1841 // not, there's no conversion that will unify the two pointers. 1842 if (LPCan == RPCan) { 1843 1844 // Second, we take the greater of the two qualifications. If neither 1845 // is greater than the other, the conversion is not possible. 1846 1847 Qualifiers MergedQuals = LPQuals + RPQuals; 1848 1849 bool CompatibleQuals = true; 1850 if (MergedQuals.getCVRQualifiers() != LPQuals.getCVRQualifiers() && 1851 MergedQuals.getCVRQualifiers() != RPQuals.getCVRQualifiers()) 1852 CompatibleQuals = false; 1853 else if (LPQuals.getAddressSpace() != RPQuals.getAddressSpace()) 1854 // FIXME: 1855 // C99 6.5.15 as modified by TR 18037: 1856 // If the second and third operands are pointers into different 1857 // address spaces, the address spaces must overlap. 1858 CompatibleQuals = false; 1859 // FIXME: GC qualifiers? 1860 1861 if (CompatibleQuals) { 1862 // Third, we check if either of the container classes is derived from 1863 // the other. 1864 QualType LContainer(LMemPtr->getClass(), 0); 1865 QualType RContainer(RMemPtr->getClass(), 0); 1866 QualType MoreDerived; 1867 if (Context.getCanonicalType(LContainer) == 1868 Context.getCanonicalType(RContainer)) 1869 MoreDerived = LContainer; 1870 else if (IsDerivedFrom(LContainer, RContainer)) 1871 MoreDerived = LContainer; 1872 else if (IsDerivedFrom(RContainer, LContainer)) 1873 MoreDerived = RContainer; 1874 1875 if (!MoreDerived.isNull()) { 1876 // The type 'Q Pointee (MoreDerived::*)' is the common type. 1877 // We don't use ImpCastExprToType here because this could still fail 1878 // for ambiguous or inaccessible conversions. 1879 LPointee = Context.getQualifiedType(LPointee, MergedQuals); 1880 QualType Common 1881 = Context.getMemberPointerType(LPointee, MoreDerived.getTypePtr()); 1882 if (PerformImplicitConversion(LHS, Common, "converting")) 1883 return QualType(); 1884 if (PerformImplicitConversion(RHS, Common, "converting")) 1885 return QualType(); 1886 return Common; 1887 } 1888 } 1889 } 1890 } 1891 1892 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands) 1893 << LHS->getType() << RHS->getType() 1894 << LHS->getSourceRange() << RHS->getSourceRange(); 1895 return QualType(); 1896} 1897 1898/// \brief Find a merged pointer type and convert the two expressions to it. 1899/// 1900/// This finds the composite pointer type (or member pointer type) for @p E1 1901/// and @p E2 according to C++0x 5.9p2. It converts both expressions to this 1902/// type and returns it. 1903/// It does not emit diagnostics. 1904QualType Sema::FindCompositePointerType(Expr *&E1, Expr *&E2) { 1905 assert(getLangOptions().CPlusPlus && "This function assumes C++"); 1906 QualType T1 = E1->getType(), T2 = E2->getType(); 1907 1908 if (!T1->isAnyPointerType() && !T1->isMemberPointerType() && 1909 !T2->isAnyPointerType() && !T2->isMemberPointerType()) 1910 return QualType(); 1911 1912 // C++0x 5.9p2 1913 // Pointer conversions and qualification conversions are performed on 1914 // pointer operands to bring them to their composite pointer type. If 1915 // one operand is a null pointer constant, the composite pointer type is 1916 // the type of the other operand. 1917 if (E1->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) { 1918 if (T2->isMemberPointerType()) 1919 ImpCastExprToType(E1, T2, CastExpr::CK_NullToMemberPointer); 1920 else 1921 ImpCastExprToType(E1, T2, CastExpr::CK_IntegralToPointer); 1922 return T2; 1923 } 1924 if (E2->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) { 1925 if (T1->isMemberPointerType()) 1926 ImpCastExprToType(E2, T1, CastExpr::CK_NullToMemberPointer); 1927 else 1928 ImpCastExprToType(E2, T1, CastExpr::CK_IntegralToPointer); 1929 return T1; 1930 } 1931 1932 // Now both have to be pointers or member pointers. 1933 if ((!T1->isPointerType() && !T1->isMemberPointerType()) || 1934 (!T2->isPointerType() && !T2->isMemberPointerType())) 1935 return QualType(); 1936 1937 // Otherwise, of one of the operands has type "pointer to cv1 void," then 1938 // the other has type "pointer to cv2 T" and the composite pointer type is 1939 // "pointer to cv12 void," where cv12 is the union of cv1 and cv2. 1940 // Otherwise, the composite pointer type is a pointer type similar to the 1941 // type of one of the operands, with a cv-qualification signature that is 1942 // the union of the cv-qualification signatures of the operand types. 1943 // In practice, the first part here is redundant; it's subsumed by the second. 1944 // What we do here is, we build the two possible composite types, and try the 1945 // conversions in both directions. If only one works, or if the two composite 1946 // types are the same, we have succeeded. 1947 // FIXME: extended qualifiers? 1948 typedef llvm::SmallVector<unsigned, 4> QualifierVector; 1949 QualifierVector QualifierUnion; 1950 typedef llvm::SmallVector<std::pair<const Type *, const Type *>, 4> 1951 ContainingClassVector; 1952 ContainingClassVector MemberOfClass; 1953 QualType Composite1 = Context.getCanonicalType(T1), 1954 Composite2 = Context.getCanonicalType(T2); 1955 do { 1956 const PointerType *Ptr1, *Ptr2; 1957 if ((Ptr1 = Composite1->getAs<PointerType>()) && 1958 (Ptr2 = Composite2->getAs<PointerType>())) { 1959 Composite1 = Ptr1->getPointeeType(); 1960 Composite2 = Ptr2->getPointeeType(); 1961 QualifierUnion.push_back( 1962 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers()); 1963 MemberOfClass.push_back(std::make_pair((const Type *)0, (const Type *)0)); 1964 continue; 1965 } 1966 1967 const MemberPointerType *MemPtr1, *MemPtr2; 1968 if ((MemPtr1 = Composite1->getAs<MemberPointerType>()) && 1969 (MemPtr2 = Composite2->getAs<MemberPointerType>())) { 1970 Composite1 = MemPtr1->getPointeeType(); 1971 Composite2 = MemPtr2->getPointeeType(); 1972 QualifierUnion.push_back( 1973 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers()); 1974 MemberOfClass.push_back(std::make_pair(MemPtr1->getClass(), 1975 MemPtr2->getClass())); 1976 continue; 1977 } 1978 1979 // FIXME: block pointer types? 1980 1981 // Cannot unwrap any more types. 1982 break; 1983 } while (true); 1984 1985 // Rewrap the composites as pointers or member pointers with the union CVRs. 1986 ContainingClassVector::reverse_iterator MOC 1987 = MemberOfClass.rbegin(); 1988 for (QualifierVector::reverse_iterator 1989 I = QualifierUnion.rbegin(), 1990 E = QualifierUnion.rend(); 1991 I != E; (void)++I, ++MOC) { 1992 Qualifiers Quals = Qualifiers::fromCVRMask(*I); 1993 if (MOC->first && MOC->second) { 1994 // Rebuild member pointer type 1995 Composite1 = Context.getMemberPointerType( 1996 Context.getQualifiedType(Composite1, Quals), 1997 MOC->first); 1998 Composite2 = Context.getMemberPointerType( 1999 Context.getQualifiedType(Composite2, Quals), 2000 MOC->second); 2001 } else { 2002 // Rebuild pointer type 2003 Composite1 2004 = Context.getPointerType(Context.getQualifiedType(Composite1, Quals)); 2005 Composite2 2006 = Context.getPointerType(Context.getQualifiedType(Composite2, Quals)); 2007 } 2008 } 2009 2010 ImplicitConversionSequence E1ToC1 = 2011 TryImplicitConversion(E1, Composite1, 2012 /*SuppressUserConversions=*/false, 2013 /*AllowExplicit=*/false, 2014 /*ForceRValue=*/false, 2015 /*InOverloadResolution=*/false); 2016 ImplicitConversionSequence E2ToC1 = 2017 TryImplicitConversion(E2, Composite1, 2018 /*SuppressUserConversions=*/false, 2019 /*AllowExplicit=*/false, 2020 /*ForceRValue=*/false, 2021 /*InOverloadResolution=*/false); 2022 2023 ImplicitConversionSequence E1ToC2, E2ToC2; 2024 E1ToC2.ConversionKind = ImplicitConversionSequence::BadConversion; 2025 E2ToC2.ConversionKind = ImplicitConversionSequence::BadConversion; 2026 if (Context.getCanonicalType(Composite1) != 2027 Context.getCanonicalType(Composite2)) { 2028 E1ToC2 = TryImplicitConversion(E1, Composite2, 2029 /*SuppressUserConversions=*/false, 2030 /*AllowExplicit=*/false, 2031 /*ForceRValue=*/false, 2032 /*InOverloadResolution=*/false); 2033 E2ToC2 = TryImplicitConversion(E2, Composite2, 2034 /*SuppressUserConversions=*/false, 2035 /*AllowExplicit=*/false, 2036 /*ForceRValue=*/false, 2037 /*InOverloadResolution=*/false); 2038 } 2039 2040 bool ToC1Viable = E1ToC1.ConversionKind != 2041 ImplicitConversionSequence::BadConversion 2042 && E2ToC1.ConversionKind != 2043 ImplicitConversionSequence::BadConversion; 2044 bool ToC2Viable = E1ToC2.ConversionKind != 2045 ImplicitConversionSequence::BadConversion 2046 && E2ToC2.ConversionKind != 2047 ImplicitConversionSequence::BadConversion; 2048 if (ToC1Viable && !ToC2Viable) { 2049 if (!PerformImplicitConversion(E1, Composite1, E1ToC1, "converting") && 2050 !PerformImplicitConversion(E2, Composite1, E2ToC1, "converting")) 2051 return Composite1; 2052 } 2053 if (ToC2Viable && !ToC1Viable) { 2054 if (!PerformImplicitConversion(E1, Composite2, E1ToC2, "converting") && 2055 !PerformImplicitConversion(E2, Composite2, E2ToC2, "converting")) 2056 return Composite2; 2057 } 2058 return QualType(); 2059} 2060 2061Sema::OwningExprResult Sema::MaybeBindToTemporary(Expr *E) { 2062 if (!Context.getLangOptions().CPlusPlus) 2063 return Owned(E); 2064 2065 const RecordType *RT = E->getType()->getAs<RecordType>(); 2066 if (!RT) 2067 return Owned(E); 2068 2069 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 2070 if (RD->hasTrivialDestructor()) 2071 return Owned(E); 2072 2073 if (CallExpr *CE = dyn_cast<CallExpr>(E)) { 2074 QualType Ty = CE->getCallee()->getType(); 2075 if (const PointerType *PT = Ty->getAs<PointerType>()) 2076 Ty = PT->getPointeeType(); 2077 2078 const FunctionType *FTy = Ty->getAs<FunctionType>(); 2079 if (FTy->getResultType()->isReferenceType()) 2080 return Owned(E); 2081 } 2082 CXXTemporary *Temp = CXXTemporary::Create(Context, 2083 RD->getDestructor(Context)); 2084 ExprTemporaries.push_back(Temp); 2085 if (CXXDestructorDecl *Destructor = 2086 const_cast<CXXDestructorDecl*>(RD->getDestructor(Context))) 2087 MarkDeclarationReferenced(E->getExprLoc(), Destructor); 2088 // FIXME: Add the temporary to the temporaries vector. 2089 return Owned(CXXBindTemporaryExpr::Create(Context, Temp, E)); 2090} 2091 2092Expr *Sema::MaybeCreateCXXExprWithTemporaries(Expr *SubExpr, 2093 bool ShouldDestroyTemps) { 2094 assert(SubExpr && "sub expression can't be null!"); 2095 2096 unsigned FirstTemporary = ExprEvalContexts.back().NumTemporaries; 2097 assert(ExprTemporaries.size() >= FirstTemporary); 2098 if (ExprTemporaries.size() == FirstTemporary) 2099 return SubExpr; 2100 2101 Expr *E = CXXExprWithTemporaries::Create(Context, SubExpr, 2102 &ExprTemporaries[FirstTemporary], 2103 ExprTemporaries.size() - FirstTemporary, 2104 ShouldDestroyTemps); 2105 ExprTemporaries.erase(ExprTemporaries.begin() + FirstTemporary, 2106 ExprTemporaries.end()); 2107 2108 return E; 2109} 2110 2111Sema::OwningExprResult 2112Sema::ActOnStartCXXMemberReference(Scope *S, ExprArg Base, SourceLocation OpLoc, 2113 tok::TokenKind OpKind, TypeTy *&ObjectType) { 2114 // Since this might be a postfix expression, get rid of ParenListExprs. 2115 Base = MaybeConvertParenListExprToParenExpr(S, move(Base)); 2116 2117 Expr *BaseExpr = (Expr*)Base.get(); 2118 assert(BaseExpr && "no record expansion"); 2119 2120 QualType BaseType = BaseExpr->getType(); 2121 if (BaseType->isDependentType()) { 2122 // If we have a pointer to a dependent type and are using the -> operator, 2123 // the object type is the type that the pointer points to. We might still 2124 // have enough information about that type to do something useful. 2125 if (OpKind == tok::arrow) 2126 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) 2127 BaseType = Ptr->getPointeeType(); 2128 2129 ObjectType = BaseType.getAsOpaquePtr(); 2130 return move(Base); 2131 } 2132 2133 // C++ [over.match.oper]p8: 2134 // [...] When operator->returns, the operator-> is applied to the value 2135 // returned, with the original second operand. 2136 if (OpKind == tok::arrow) { 2137 // The set of types we've considered so far. 2138 llvm::SmallPtrSet<CanQualType,8> CTypes; 2139 llvm::SmallVector<SourceLocation, 8> Locations; 2140 CTypes.insert(Context.getCanonicalType(BaseType)); 2141 2142 while (BaseType->isRecordType()) { 2143 Base = BuildOverloadedArrowExpr(S, move(Base), OpLoc); 2144 BaseExpr = (Expr*)Base.get(); 2145 if (BaseExpr == NULL) 2146 return ExprError(); 2147 if (CXXOperatorCallExpr *OpCall = dyn_cast<CXXOperatorCallExpr>(BaseExpr)) 2148 Locations.push_back(OpCall->getDirectCallee()->getLocation()); 2149 BaseType = BaseExpr->getType(); 2150 CanQualType CBaseType = Context.getCanonicalType(BaseType); 2151 if (!CTypes.insert(CBaseType)) { 2152 Diag(OpLoc, diag::err_operator_arrow_circular); 2153 for (unsigned i = 0; i < Locations.size(); i++) 2154 Diag(Locations[i], diag::note_declared_at); 2155 return ExprError(); 2156 } 2157 } 2158 2159 if (BaseType->isPointerType()) 2160 BaseType = BaseType->getPointeeType(); 2161 } 2162 2163 // We could end up with various non-record types here, such as extended 2164 // vector types or Objective-C interfaces. Just return early and let 2165 // ActOnMemberReferenceExpr do the work. 2166 if (!BaseType->isRecordType()) { 2167 // C++ [basic.lookup.classref]p2: 2168 // [...] If the type of the object expression is of pointer to scalar 2169 // type, the unqualified-id is looked up in the context of the complete 2170 // postfix-expression. 2171 ObjectType = 0; 2172 return move(Base); 2173 } 2174 2175 // The object type must be complete (or dependent). 2176 if (!BaseType->isDependentType() && 2177 RequireCompleteType(OpLoc, BaseType, 2178 PDiag(diag::err_incomplete_member_access))) 2179 return ExprError(); 2180 2181 // C++ [basic.lookup.classref]p2: 2182 // If the id-expression in a class member access (5.2.5) is an 2183 // unqualified-id, and the type of the object expression is of a class 2184 // type C (or of pointer to a class type C), the unqualified-id is looked 2185 // up in the scope of class C. [...] 2186 ObjectType = BaseType.getAsOpaquePtr(); 2187 2188 return move(Base); 2189} 2190 2191CXXMemberCallExpr *Sema::BuildCXXMemberCallExpr(Expr *Exp, 2192 CXXMethodDecl *Method) { 2193 if (PerformObjectArgumentInitialization(Exp, Method)) 2194 assert(0 && "Calling BuildCXXMemberCallExpr with invalid call?"); 2195 2196 MemberExpr *ME = 2197 new (Context) MemberExpr(Exp, /*IsArrow=*/false, Method, 2198 SourceLocation(), Method->getType()); 2199 QualType ResultType = Method->getResultType().getNonReferenceType(); 2200 MarkDeclarationReferenced(Exp->getLocStart(), Method); 2201 CXXMemberCallExpr *CE = 2202 new (Context) CXXMemberCallExpr(Context, ME, 0, 0, ResultType, 2203 Exp->getLocEnd()); 2204 return CE; 2205} 2206 2207Sema::OwningExprResult Sema::BuildCXXCastArgument(SourceLocation CastLoc, 2208 QualType Ty, 2209 CastExpr::CastKind Kind, 2210 CXXMethodDecl *Method, 2211 ExprArg Arg) { 2212 Expr *From = Arg.takeAs<Expr>(); 2213 2214 switch (Kind) { 2215 default: assert(0 && "Unhandled cast kind!"); 2216 case CastExpr::CK_ConstructorConversion: { 2217 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(*this); 2218 2219 if (CompleteConstructorCall(cast<CXXConstructorDecl>(Method), 2220 MultiExprArg(*this, (void **)&From, 1), 2221 CastLoc, ConstructorArgs)) 2222 return ExprError(); 2223 2224 OwningExprResult Result = 2225 BuildCXXConstructExpr(CastLoc, Ty, cast<CXXConstructorDecl>(Method), 2226 move_arg(ConstructorArgs)); 2227 if (Result.isInvalid()) 2228 return ExprError(); 2229 2230 return MaybeBindToTemporary(Result.takeAs<Expr>()); 2231 } 2232 2233 case CastExpr::CK_UserDefinedConversion: { 2234 assert(!From->getType()->isPointerType() && "Arg can't have pointer type!"); 2235 2236 // Create an implicit call expr that calls it. 2237 CXXMemberCallExpr *CE = BuildCXXMemberCallExpr(From, Method); 2238 return MaybeBindToTemporary(CE); 2239 } 2240 } 2241} 2242 2243Sema::OwningExprResult Sema::ActOnFinishFullExpr(ExprArg Arg) { 2244 Expr *FullExpr = Arg.takeAs<Expr>(); 2245 if (FullExpr) 2246 FullExpr = MaybeCreateCXXExprWithTemporaries(FullExpr, 2247 /*ShouldDestroyTemps=*/true); 2248 2249 2250 return Owned(FullExpr); 2251} 2252 2253/// \brief Determine whether a reference to the given declaration in the 2254/// current context is an implicit member access 2255/// (C++ [class.mfct.non-static]p2). 2256/// 2257/// FIXME: Should Objective-C also use this approach? 2258/// 2259/// \param D the declaration being referenced from the current scope. 2260/// 2261/// \param NameLoc the location of the name in the source. 2262/// 2263/// \param ThisType if the reference to this declaration is an implicit member 2264/// access, will be set to the type of the "this" pointer to be used when 2265/// building that implicit member access. 2266/// 2267/// \returns true if this is an implicit member reference (in which case 2268/// \p ThisType and \p MemberType will be set), or false if it is not an 2269/// implicit member reference. 2270bool Sema::isImplicitMemberReference(const LookupResult &R, 2271 QualType &ThisType) { 2272 // If this isn't a C++ method, then it isn't an implicit member reference. 2273 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(CurContext); 2274 if (!MD || MD->isStatic()) 2275 return false; 2276 2277 // C++ [class.mfct.nonstatic]p2: 2278 // [...] if name lookup (3.4.1) resolves the name in the 2279 // id-expression to a nonstatic nontype member of class X or of 2280 // a base class of X, the id-expression is transformed into a 2281 // class member access expression (5.2.5) using (*this) (9.3.2) 2282 // as the postfix-expression to the left of the '.' operator. 2283 DeclContext *Ctx = 0; 2284 if (R.isUnresolvableResult()) { 2285 // FIXME: this is just picking one at random 2286 Ctx = R.getRepresentativeDecl()->getDeclContext(); 2287 } else if (FieldDecl *FD = R.getAsSingle<FieldDecl>()) { 2288 Ctx = FD->getDeclContext(); 2289 } else { 2290 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) { 2291 CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(*I); 2292 FunctionTemplateDecl *FunTmpl = 0; 2293 if (!Method && (FunTmpl = dyn_cast<FunctionTemplateDecl>(*I))) 2294 Method = dyn_cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl()); 2295 2296 // FIXME: Do we have to know if there are explicit template arguments? 2297 if (Method && !Method->isStatic()) { 2298 Ctx = Method->getParent(); 2299 break; 2300 } 2301 } 2302 } 2303 2304 if (!Ctx || !Ctx->isRecord()) 2305 return false; 2306 2307 // Determine whether the declaration(s) we found are actually in a base 2308 // class. If not, this isn't an implicit member reference. 2309 ThisType = MD->getThisType(Context); 2310 2311 // FIXME: this doesn't really work for overloaded lookups. 2312 2313 QualType CtxType = Context.getTypeDeclType(cast<CXXRecordDecl>(Ctx)); 2314 QualType ClassType 2315 = Context.getTypeDeclType(cast<CXXRecordDecl>(MD->getParent())); 2316 return Context.hasSameType(CtxType, ClassType) || 2317 IsDerivedFrom(ClassType, CtxType); 2318} 2319 2320