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