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