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