SemaExprCXX.cpp revision a78c5c34fbd20fde02261c3f3e21933cd58fcc04
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 if (!Record->hasTrivialDestructor()) 761 if (const CXXDestructorDecl *Dtor = Record->getDestructor(Context)) 762 MarkDeclarationReferenced(StartLoc, 763 const_cast<CXXDestructorDecl*>(Dtor)); 764 } 765 766 if (!OperatorDelete) { 767 // Didn't find a member overload. Look for a global one. 768 DeclareGlobalNewDelete(); 769 DeclContext *TUDecl = Context.getTranslationUnitDecl(); 770 if (FindAllocationOverload(StartLoc, SourceRange(), DeleteName, 771 &DeleteArg, 1, TUDecl, /*AllowMissing=*/false, 772 OperatorDelete)) 773 return ExprError(); 774 } 775 776 // FIXME: Check access and ambiguity of operator delete and destructor. 777 } 778 779 Operand.release(); 780 return Owned(new (Context) CXXDeleteExpr(Context.VoidTy, UseGlobal, ArrayForm, 781 OperatorDelete, Ex, StartLoc)); 782} 783 784 785/// ActOnCXXConditionDeclarationExpr - Parsed a condition declaration of a 786/// C++ if/switch/while/for statement. 787/// e.g: "if (int x = f()) {...}" 788Action::OwningExprResult 789Sema::ActOnCXXConditionDeclarationExpr(Scope *S, SourceLocation StartLoc, 790 Declarator &D, 791 SourceLocation EqualLoc, 792 ExprArg AssignExprVal) { 793 assert(AssignExprVal.get() && "Null assignment expression"); 794 795 // C++ 6.4p2: 796 // The declarator shall not specify a function or an array. 797 // The type-specifier-seq shall not contain typedef and shall not declare a 798 // new class or enumeration. 799 800 assert(D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef && 801 "Parser allowed 'typedef' as storage class of condition decl."); 802 803 // FIXME: Store DeclaratorInfo in the expression. 804 DeclaratorInfo *DInfo = 0; 805 TagDecl *OwnedTag = 0; 806 QualType Ty = GetTypeForDeclarator(D, S, &DInfo, /*Skip=*/0, &OwnedTag); 807 808 if (Ty->isFunctionType()) { // The declarator shall not specify a function... 809 // We exit without creating a CXXConditionDeclExpr because a FunctionDecl 810 // would be created and CXXConditionDeclExpr wants a VarDecl. 811 return ExprError(Diag(StartLoc, diag::err_invalid_use_of_function_type) 812 << SourceRange(StartLoc, EqualLoc)); 813 } else if (Ty->isArrayType()) { // ...or an array. 814 Diag(StartLoc, diag::err_invalid_use_of_array_type) 815 << SourceRange(StartLoc, EqualLoc); 816 } else if (OwnedTag && OwnedTag->isDefinition()) { 817 // The type-specifier-seq shall not declare a new class or enumeration. 818 Diag(OwnedTag->getLocation(), diag::err_type_defined_in_condition); 819 } 820 821 DeclPtrTy Dcl = ActOnDeclarator(S, D); 822 if (!Dcl) 823 return ExprError(); 824 AddInitializerToDecl(Dcl, move(AssignExprVal), /*DirectInit=*/false); 825 826 // Mark this variable as one that is declared within a conditional. 827 // We know that the decl had to be a VarDecl because that is the only type of 828 // decl that can be assigned and the grammar requires an '='. 829 VarDecl *VD = cast<VarDecl>(Dcl.getAs<Decl>()); 830 VD->setDeclaredInCondition(true); 831 return Owned(new (Context) CXXConditionDeclExpr(StartLoc, EqualLoc, VD)); 832} 833 834/// CheckCXXBooleanCondition - Returns true if a conversion to bool is invalid. 835bool Sema::CheckCXXBooleanCondition(Expr *&CondExpr) { 836 // C++ 6.4p4: 837 // The value of a condition that is an initialized declaration in a statement 838 // other than a switch statement is the value of the declared variable 839 // implicitly converted to type bool. If that conversion is ill-formed, the 840 // program is ill-formed. 841 // The value of a condition that is an expression is the value of the 842 // expression, implicitly converted to bool. 843 // 844 return PerformContextuallyConvertToBool(CondExpr); 845} 846 847/// Helper function to determine whether this is the (deprecated) C++ 848/// conversion from a string literal to a pointer to non-const char or 849/// non-const wchar_t (for narrow and wide string literals, 850/// respectively). 851bool 852Sema::IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType) { 853 // Look inside the implicit cast, if it exists. 854 if (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(From)) 855 From = Cast->getSubExpr(); 856 857 // A string literal (2.13.4) that is not a wide string literal can 858 // be converted to an rvalue of type "pointer to char"; a wide 859 // string literal can be converted to an rvalue of type "pointer 860 // to wchar_t" (C++ 4.2p2). 861 if (StringLiteral *StrLit = dyn_cast<StringLiteral>(From)) 862 if (const PointerType *ToPtrType = ToType->getAs<PointerType>()) 863 if (const BuiltinType *ToPointeeType 864 = ToPtrType->getPointeeType()->getAsBuiltinType()) { 865 // This conversion is considered only when there is an 866 // explicit appropriate pointer target type (C++ 4.2p2). 867 if (ToPtrType->getPointeeType().getCVRQualifiers() == 0 && 868 ((StrLit->isWide() && ToPointeeType->isWideCharType()) || 869 (!StrLit->isWide() && 870 (ToPointeeType->getKind() == BuiltinType::Char_U || 871 ToPointeeType->getKind() == BuiltinType::Char_S)))) 872 return true; 873 } 874 875 return false; 876} 877 878/// PerformImplicitConversion - Perform an implicit conversion of the 879/// expression From to the type ToType. Returns true if there was an 880/// error, false otherwise. The expression From is replaced with the 881/// converted expression. Flavor is the kind of conversion we're 882/// performing, used in the error message. If @p AllowExplicit, 883/// explicit user-defined conversions are permitted. @p Elidable should be true 884/// when called for copies which may be elided (C++ 12.8p15). C++0x overload 885/// resolution works differently in that case. 886bool 887Sema::PerformImplicitConversion(Expr *&From, QualType ToType, 888 const char *Flavor, bool AllowExplicit, 889 bool Elidable) 890{ 891 ImplicitConversionSequence ICS; 892 ICS.ConversionKind = ImplicitConversionSequence::BadConversion; 893 if (Elidable && getLangOptions().CPlusPlus0x) { 894 ICS = TryImplicitConversion(From, ToType, 895 /*SuppressUserConversions=*/false, 896 AllowExplicit, 897 /*ForceRValue=*/true, 898 /*InOverloadResolution=*/false); 899 } 900 if (ICS.ConversionKind == ImplicitConversionSequence::BadConversion) { 901 ICS = TryImplicitConversion(From, ToType, 902 /*SuppressUserConversions=*/false, 903 AllowExplicit, 904 /*ForceRValue=*/false, 905 /*InOverloadResolution=*/false); 906 } 907 return PerformImplicitConversion(From, ToType, ICS, Flavor); 908} 909 910/// PerformImplicitConversion - Perform an implicit conversion of the 911/// expression From to the type ToType using the pre-computed implicit 912/// conversion sequence ICS. Returns true if there was an error, false 913/// otherwise. The expression From is replaced with the converted 914/// expression. Flavor is the kind of conversion we're performing, 915/// used in the error message. 916bool 917Sema::PerformImplicitConversion(Expr *&From, QualType ToType, 918 const ImplicitConversionSequence &ICS, 919 const char* Flavor) { 920 switch (ICS.ConversionKind) { 921 case ImplicitConversionSequence::StandardConversion: 922 if (PerformImplicitConversion(From, ToType, ICS.Standard, Flavor)) 923 return true; 924 break; 925 926 case ImplicitConversionSequence::UserDefinedConversion: 927 { 928 FunctionDecl *FD = ICS.UserDefined.ConversionFunction; 929 CastExpr::CastKind CastKind = CastExpr::CK_Unknown; 930 if (CXXConversionDecl *CV = dyn_cast<CXXConversionDecl>(FD)) { 931 // FIXME. Get actual Source Location. 932 From = 933 new (Context) CXXFunctionalCastExpr(ToType.getNonReferenceType(), 934 ToType, SourceLocation(), 935 CastExpr::CK_UserDefinedConversion, 936 From, CV, 937 SourceLocation()); 938 CastKind = CastExpr::CK_UserDefinedConversion; 939 } 940 else if (CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(FD)) { 941 // FIXME. Do we need to check for isLValueReferenceType? 942 DefaultFunctionArrayConversion(From); 943 OwningExprResult InitResult = 944 BuildCXXConstructExpr(ToType.getNonReferenceType(), 945 CD, &From, 1); 946 // Take ownership of this expression. 947 From = InitResult.takeAs<Expr>(); 948 CastKind = CastExpr::CK_ConstructorConversion ; 949 } 950 ImpCastExprToType(From, ToType.getNonReferenceType(), 951 CastKind, 952 ToType->isLValueReferenceType()); 953 return false; 954 } 955 956 case ImplicitConversionSequence::EllipsisConversion: 957 assert(false && "Cannot perform an ellipsis conversion"); 958 return false; 959 960 case ImplicitConversionSequence::BadConversion: 961 return true; 962 } 963 964 // Everything went well. 965 return false; 966} 967 968/// PerformImplicitConversion - Perform an implicit conversion of the 969/// expression From to the type ToType by following the standard 970/// conversion sequence SCS. Returns true if there was an error, false 971/// otherwise. The expression From is replaced with the converted 972/// expression. Flavor is the context in which we're performing this 973/// conversion, for use in error messages. 974bool 975Sema::PerformImplicitConversion(Expr *&From, QualType ToType, 976 const StandardConversionSequence& SCS, 977 const char *Flavor) { 978 // Overall FIXME: we are recomputing too many types here and doing far too 979 // much extra work. What this means is that we need to keep track of more 980 // information that is computed when we try the implicit conversion initially, 981 // so that we don't need to recompute anything here. 982 QualType FromType = From->getType(); 983 984 if (SCS.CopyConstructor) { 985 // FIXME: When can ToType be a reference type? 986 assert(!ToType->isReferenceType()); 987 988 OwningExprResult FromResult = 989 BuildCXXConstructExpr(ToType, SCS.CopyConstructor, &From, 1); 990 991 if (FromResult.isInvalid()) 992 return true; 993 994 From = FromResult.takeAs<Expr>(); 995 return false; 996 } 997 998 // Perform the first implicit conversion. 999 switch (SCS.First) { 1000 case ICK_Identity: 1001 case ICK_Lvalue_To_Rvalue: 1002 // Nothing to do. 1003 break; 1004 1005 case ICK_Array_To_Pointer: 1006 FromType = Context.getArrayDecayedType(FromType); 1007 ImpCastExprToType(From, FromType, CastExpr::CK_ArrayToPointerDecay); 1008 break; 1009 1010 case ICK_Function_To_Pointer: 1011 if (Context.getCanonicalType(FromType) == Context.OverloadTy) { 1012 FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(From, ToType, true); 1013 if (!Fn) 1014 return true; 1015 1016 if (DiagnoseUseOfDecl(Fn, From->getSourceRange().getBegin())) 1017 return true; 1018 1019 FixOverloadedFunctionReference(From, Fn); 1020 FromType = From->getType(); 1021 } 1022 FromType = Context.getPointerType(FromType); 1023 ImpCastExprToType(From, FromType, CastExpr::CK_FunctionToPointerDecay); 1024 break; 1025 1026 default: 1027 assert(false && "Improper first standard conversion"); 1028 break; 1029 } 1030 1031 // Perform the second implicit conversion 1032 switch (SCS.Second) { 1033 case ICK_Identity: 1034 // Nothing to do. 1035 break; 1036 1037 case ICK_Integral_Promotion: 1038 case ICK_Floating_Promotion: 1039 case ICK_Complex_Promotion: 1040 case ICK_Integral_Conversion: 1041 case ICK_Floating_Conversion: 1042 case ICK_Complex_Conversion: 1043 case ICK_Floating_Integral: 1044 case ICK_Complex_Real: 1045 case ICK_Compatible_Conversion: 1046 // FIXME: Go deeper to get the unqualified type! 1047 FromType = ToType.getUnqualifiedType(); 1048 ImpCastExprToType(From, FromType); 1049 break; 1050 1051 case ICK_Pointer_Conversion: 1052 if (SCS.IncompatibleObjC) { 1053 // Diagnose incompatible Objective-C conversions 1054 Diag(From->getSourceRange().getBegin(), 1055 diag::ext_typecheck_convert_incompatible_pointer) 1056 << From->getType() << ToType << Flavor 1057 << From->getSourceRange(); 1058 } 1059 1060 if (CheckPointerConversion(From, ToType)) 1061 return true; 1062 ImpCastExprToType(From, ToType); 1063 break; 1064 1065 case ICK_Pointer_Member: { 1066 CastExpr::CastKind Kind = CastExpr::CK_Unknown; 1067 if (CheckMemberPointerConversion(From, ToType, Kind)) 1068 return true; 1069 ImpCastExprToType(From, ToType, Kind); 1070 break; 1071 } 1072 case ICK_Boolean_Conversion: 1073 FromType = Context.BoolTy; 1074 ImpCastExprToType(From, FromType); 1075 break; 1076 1077 default: 1078 assert(false && "Improper second standard conversion"); 1079 break; 1080 } 1081 1082 switch (SCS.Third) { 1083 case ICK_Identity: 1084 // Nothing to do. 1085 break; 1086 1087 case ICK_Qualification: 1088 // FIXME: Not sure about lvalue vs rvalue here in the presence of rvalue 1089 // references. 1090 ImpCastExprToType(From, ToType.getNonReferenceType(), 1091 CastExpr::CK_Unknown, 1092 ToType->isLValueReferenceType()); 1093 break; 1094 1095 default: 1096 assert(false && "Improper second standard conversion"); 1097 break; 1098 } 1099 1100 return false; 1101} 1102 1103Sema::OwningExprResult Sema::ActOnUnaryTypeTrait(UnaryTypeTrait OTT, 1104 SourceLocation KWLoc, 1105 SourceLocation LParen, 1106 TypeTy *Ty, 1107 SourceLocation RParen) { 1108 QualType T = GetTypeFromParser(Ty); 1109 1110 // According to http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html 1111 // all traits except __is_class, __is_enum and __is_union require a the type 1112 // to be complete. 1113 if (OTT != UTT_IsClass && OTT != UTT_IsEnum && OTT != UTT_IsUnion) { 1114 if (RequireCompleteType(KWLoc, T, 1115 diag::err_incomplete_type_used_in_type_trait_expr)) 1116 return ExprError(); 1117 } 1118 1119 // There is no point in eagerly computing the value. The traits are designed 1120 // to be used from type trait templates, so Ty will be a template parameter 1121 // 99% of the time. 1122 return Owned(new (Context) UnaryTypeTraitExpr(KWLoc, OTT, T, 1123 RParen, Context.BoolTy)); 1124} 1125 1126QualType Sema::CheckPointerToMemberOperands( 1127 Expr *&lex, Expr *&rex, SourceLocation Loc, bool isIndirect) 1128{ 1129 const char *OpSpelling = isIndirect ? "->*" : ".*"; 1130 // C++ 5.5p2 1131 // The binary operator .* [p3: ->*] binds its second operand, which shall 1132 // be of type "pointer to member of T" (where T is a completely-defined 1133 // class type) [...] 1134 QualType RType = rex->getType(); 1135 const MemberPointerType *MemPtr = RType->getAs<MemberPointerType>(); 1136 if (!MemPtr) { 1137 Diag(Loc, diag::err_bad_memptr_rhs) 1138 << OpSpelling << RType << rex->getSourceRange(); 1139 return QualType(); 1140 } 1141 1142 QualType Class(MemPtr->getClass(), 0); 1143 1144 // C++ 5.5p2 1145 // [...] to its first operand, which shall be of class T or of a class of 1146 // which T is an unambiguous and accessible base class. [p3: a pointer to 1147 // such a class] 1148 QualType LType = lex->getType(); 1149 if (isIndirect) { 1150 if (const PointerType *Ptr = LType->getAs<PointerType>()) 1151 LType = Ptr->getPointeeType().getNonReferenceType(); 1152 else { 1153 Diag(Loc, diag::err_bad_memptr_lhs) 1154 << OpSpelling << 1 << LType << lex->getSourceRange(); 1155 return QualType(); 1156 } 1157 } 1158 1159 if (Context.getCanonicalType(Class).getUnqualifiedType() != 1160 Context.getCanonicalType(LType).getUnqualifiedType()) { 1161 BasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/false, 1162 /*DetectVirtual=*/false); 1163 // FIXME: Would it be useful to print full ambiguity paths, or is that 1164 // overkill? 1165 if (!IsDerivedFrom(LType, Class, Paths) || 1166 Paths.isAmbiguous(Context.getCanonicalType(Class))) { 1167 Diag(Loc, diag::err_bad_memptr_lhs) << OpSpelling 1168 << (int)isIndirect << lex->getType() << lex->getSourceRange(); 1169 return QualType(); 1170 } 1171 } 1172 1173 // C++ 5.5p2 1174 // The result is an object or a function of the type specified by the 1175 // second operand. 1176 // The cv qualifiers are the union of those in the pointer and the left side, 1177 // in accordance with 5.5p5 and 5.2.5. 1178 // FIXME: This returns a dereferenced member function pointer as a normal 1179 // function type. However, the only operation valid on such functions is 1180 // calling them. There's also a GCC extension to get a function pointer to the 1181 // thing, which is another complication, because this type - unlike the type 1182 // that is the result of this expression - takes the class as the first 1183 // argument. 1184 // We probably need a "MemberFunctionClosureType" or something like that. 1185 QualType Result = MemPtr->getPointeeType(); 1186 if (LType.isConstQualified()) 1187 Result.addConst(); 1188 if (LType.isVolatileQualified()) 1189 Result.addVolatile(); 1190 return Result; 1191} 1192 1193/// \brief Get the target type of a standard or user-defined conversion. 1194static QualType TargetType(const ImplicitConversionSequence &ICS) { 1195 assert((ICS.ConversionKind == 1196 ImplicitConversionSequence::StandardConversion || 1197 ICS.ConversionKind == 1198 ImplicitConversionSequence::UserDefinedConversion) && 1199 "function only valid for standard or user-defined conversions"); 1200 if (ICS.ConversionKind == ImplicitConversionSequence::StandardConversion) 1201 return QualType::getFromOpaquePtr(ICS.Standard.ToTypePtr); 1202 return QualType::getFromOpaquePtr(ICS.UserDefined.After.ToTypePtr); 1203} 1204 1205/// \brief Try to convert a type to another according to C++0x 5.16p3. 1206/// 1207/// This is part of the parameter validation for the ? operator. If either 1208/// value operand is a class type, the two operands are attempted to be 1209/// converted to each other. This function does the conversion in one direction. 1210/// It emits a diagnostic and returns true only if it finds an ambiguous 1211/// conversion. 1212static bool TryClassUnification(Sema &Self, Expr *From, Expr *To, 1213 SourceLocation QuestionLoc, 1214 ImplicitConversionSequence &ICS) 1215{ 1216 // C++0x 5.16p3 1217 // The process for determining whether an operand expression E1 of type T1 1218 // can be converted to match an operand expression E2 of type T2 is defined 1219 // as follows: 1220 // -- If E2 is an lvalue: 1221 if (To->isLvalue(Self.Context) == Expr::LV_Valid) { 1222 // E1 can be converted to match E2 if E1 can be implicitly converted to 1223 // type "lvalue reference to T2", subject to the constraint that in the 1224 // conversion the reference must bind directly to E1. 1225 if (!Self.CheckReferenceInit(From, 1226 Self.Context.getLValueReferenceType(To->getType()), 1227 /*SuppressUserConversions=*/false, 1228 /*AllowExplicit=*/false, 1229 /*ForceRValue=*/false, 1230 &ICS)) 1231 { 1232 assert((ICS.ConversionKind == 1233 ImplicitConversionSequence::StandardConversion || 1234 ICS.ConversionKind == 1235 ImplicitConversionSequence::UserDefinedConversion) && 1236 "expected a definite conversion"); 1237 bool DirectBinding = 1238 ICS.ConversionKind == ImplicitConversionSequence::StandardConversion ? 1239 ICS.Standard.DirectBinding : ICS.UserDefined.After.DirectBinding; 1240 if (DirectBinding) 1241 return false; 1242 } 1243 } 1244 ICS.ConversionKind = ImplicitConversionSequence::BadConversion; 1245 // -- If E2 is an rvalue, or if the conversion above cannot be done: 1246 // -- if E1 and E2 have class type, and the underlying class types are 1247 // the same or one is a base class of the other: 1248 QualType FTy = From->getType(); 1249 QualType TTy = To->getType(); 1250 const RecordType *FRec = FTy->getAs<RecordType>(); 1251 const RecordType *TRec = TTy->getAs<RecordType>(); 1252 bool FDerivedFromT = FRec && TRec && Self.IsDerivedFrom(FTy, TTy); 1253 if (FRec && TRec && (FRec == TRec || 1254 FDerivedFromT || Self.IsDerivedFrom(TTy, FTy))) { 1255 // E1 can be converted to match E2 if the class of T2 is the 1256 // same type as, or a base class of, the class of T1, and 1257 // [cv2 > cv1]. 1258 if ((FRec == TRec || FDerivedFromT) && TTy.isAtLeastAsQualifiedAs(FTy)) { 1259 // Could still fail if there's no copy constructor. 1260 // FIXME: Is this a hard error then, or just a conversion failure? The 1261 // standard doesn't say. 1262 ICS = Self.TryCopyInitialization(From, TTy, 1263 /*SuppressUserConversions=*/false, 1264 /*ForceRValue=*/false, 1265 /*InOverloadResolution=*/false); 1266 } 1267 } else { 1268 // -- Otherwise: E1 can be converted to match E2 if E1 can be 1269 // implicitly converted to the type that expression E2 would have 1270 // if E2 were converted to an rvalue. 1271 // First find the decayed type. 1272 if (TTy->isFunctionType()) 1273 TTy = Self.Context.getPointerType(TTy); 1274 else if(TTy->isArrayType()) 1275 TTy = Self.Context.getArrayDecayedType(TTy); 1276 1277 // Now try the implicit conversion. 1278 // FIXME: This doesn't detect ambiguities. 1279 ICS = Self.TryImplicitConversion(From, TTy, 1280 /*SuppressUserConversions=*/false, 1281 /*AllowExplicit=*/false, 1282 /*ForceRValue=*/false, 1283 /*InOverloadResolution=*/false); 1284 } 1285 return false; 1286} 1287 1288/// \brief Try to find a common type for two according to C++0x 5.16p5. 1289/// 1290/// This is part of the parameter validation for the ? operator. If either 1291/// value operand is a class type, overload resolution is used to find a 1292/// conversion to a common type. 1293static bool FindConditionalOverload(Sema &Self, Expr *&LHS, Expr *&RHS, 1294 SourceLocation Loc) { 1295 Expr *Args[2] = { LHS, RHS }; 1296 OverloadCandidateSet CandidateSet; 1297 Self.AddBuiltinOperatorCandidates(OO_Conditional, Args, 2, CandidateSet); 1298 1299 OverloadCandidateSet::iterator Best; 1300 switch (Self.BestViableFunction(CandidateSet, Loc, Best)) { 1301 case Sema::OR_Success: 1302 // We found a match. Perform the conversions on the arguments and move on. 1303 if (Self.PerformImplicitConversion(LHS, Best->BuiltinTypes.ParamTypes[0], 1304 Best->Conversions[0], "converting") || 1305 Self.PerformImplicitConversion(RHS, Best->BuiltinTypes.ParamTypes[1], 1306 Best->Conversions[1], "converting")) 1307 break; 1308 return false; 1309 1310 case Sema::OR_No_Viable_Function: 1311 Self.Diag(Loc, diag::err_typecheck_cond_incompatible_operands) 1312 << LHS->getType() << RHS->getType() 1313 << LHS->getSourceRange() << RHS->getSourceRange(); 1314 return true; 1315 1316 case Sema::OR_Ambiguous: 1317 Self.Diag(Loc, diag::err_conditional_ambiguous_ovl) 1318 << LHS->getType() << RHS->getType() 1319 << LHS->getSourceRange() << RHS->getSourceRange(); 1320 // FIXME: Print the possible common types by printing the return types of 1321 // the viable candidates. 1322 break; 1323 1324 case Sema::OR_Deleted: 1325 assert(false && "Conditional operator has only built-in overloads"); 1326 break; 1327 } 1328 return true; 1329} 1330 1331/// \brief Perform an "extended" implicit conversion as returned by 1332/// TryClassUnification. 1333/// 1334/// TryClassUnification generates ICSs that include reference bindings. 1335/// PerformImplicitConversion is not suitable for this; it chokes if the 1336/// second part of a standard conversion is ICK_DerivedToBase. This function 1337/// handles the reference binding specially. 1338static bool ConvertForConditional(Sema &Self, Expr *&E, 1339 const ImplicitConversionSequence &ICS) 1340{ 1341 if (ICS.ConversionKind == ImplicitConversionSequence::StandardConversion && 1342 ICS.Standard.ReferenceBinding) { 1343 assert(ICS.Standard.DirectBinding && 1344 "TryClassUnification should never generate indirect ref bindings"); 1345 // FIXME: CheckReferenceInit should be able to reuse the ICS instead of 1346 // redoing all the work. 1347 return Self.CheckReferenceInit(E, Self.Context.getLValueReferenceType( 1348 TargetType(ICS)), 1349 /*SuppressUserConversions=*/false, 1350 /*AllowExplicit=*/false, 1351 /*ForceRValue=*/false); 1352 } 1353 if (ICS.ConversionKind == ImplicitConversionSequence::UserDefinedConversion && 1354 ICS.UserDefined.After.ReferenceBinding) { 1355 assert(ICS.UserDefined.After.DirectBinding && 1356 "TryClassUnification should never generate indirect ref bindings"); 1357 return Self.CheckReferenceInit(E, Self.Context.getLValueReferenceType( 1358 TargetType(ICS)), 1359 /*SuppressUserConversions=*/false, 1360 /*AllowExplicit=*/false, 1361 /*ForceRValue=*/false); 1362 } 1363 if (Self.PerformImplicitConversion(E, TargetType(ICS), ICS, "converting")) 1364 return true; 1365 return false; 1366} 1367 1368/// \brief Check the operands of ?: under C++ semantics. 1369/// 1370/// See C++ [expr.cond]. Note that LHS is never null, even for the GNU x ?: y 1371/// extension. In this case, LHS == Cond. (But they're not aliases.) 1372QualType Sema::CXXCheckConditionalOperands(Expr *&Cond, Expr *&LHS, Expr *&RHS, 1373 SourceLocation QuestionLoc) { 1374 // FIXME: Handle C99's complex types, vector types, block pointers and Obj-C++ 1375 // interface pointers. 1376 1377 // C++0x 5.16p1 1378 // The first expression is contextually converted to bool. 1379 if (!Cond->isTypeDependent()) { 1380 if (CheckCXXBooleanCondition(Cond)) 1381 return QualType(); 1382 } 1383 1384 // Either of the arguments dependent? 1385 if (LHS->isTypeDependent() || RHS->isTypeDependent()) 1386 return Context.DependentTy; 1387 1388 // C++0x 5.16p2 1389 // If either the second or the third operand has type (cv) void, ... 1390 QualType LTy = LHS->getType(); 1391 QualType RTy = RHS->getType(); 1392 bool LVoid = LTy->isVoidType(); 1393 bool RVoid = RTy->isVoidType(); 1394 if (LVoid || RVoid) { 1395 // ... then the [l2r] conversions are performed on the second and third 1396 // operands ... 1397 DefaultFunctionArrayConversion(LHS); 1398 DefaultFunctionArrayConversion(RHS); 1399 LTy = LHS->getType(); 1400 RTy = RHS->getType(); 1401 1402 // ... and one of the following shall hold: 1403 // -- The second or the third operand (but not both) is a throw- 1404 // expression; the result is of the type of the other and is an rvalue. 1405 bool LThrow = isa<CXXThrowExpr>(LHS); 1406 bool RThrow = isa<CXXThrowExpr>(RHS); 1407 if (LThrow && !RThrow) 1408 return RTy; 1409 if (RThrow && !LThrow) 1410 return LTy; 1411 1412 // -- Both the second and third operands have type void; the result is of 1413 // type void and is an rvalue. 1414 if (LVoid && RVoid) 1415 return Context.VoidTy; 1416 1417 // Neither holds, error. 1418 Diag(QuestionLoc, diag::err_conditional_void_nonvoid) 1419 << (LVoid ? RTy : LTy) << (LVoid ? 0 : 1) 1420 << LHS->getSourceRange() << RHS->getSourceRange(); 1421 return QualType(); 1422 } 1423 1424 // Neither is void. 1425 1426 // C++0x 5.16p3 1427 // Otherwise, if the second and third operand have different types, and 1428 // either has (cv) class type, and attempt is made to convert each of those 1429 // operands to the other. 1430 if (Context.getCanonicalType(LTy) != Context.getCanonicalType(RTy) && 1431 (LTy->isRecordType() || RTy->isRecordType())) { 1432 ImplicitConversionSequence ICSLeftToRight, ICSRightToLeft; 1433 // These return true if a single direction is already ambiguous. 1434 if (TryClassUnification(*this, LHS, RHS, QuestionLoc, ICSLeftToRight)) 1435 return QualType(); 1436 if (TryClassUnification(*this, RHS, LHS, QuestionLoc, ICSRightToLeft)) 1437 return QualType(); 1438 1439 bool HaveL2R = ICSLeftToRight.ConversionKind != 1440 ImplicitConversionSequence::BadConversion; 1441 bool HaveR2L = ICSRightToLeft.ConversionKind != 1442 ImplicitConversionSequence::BadConversion; 1443 // If both can be converted, [...] the program is ill-formed. 1444 if (HaveL2R && HaveR2L) { 1445 Diag(QuestionLoc, diag::err_conditional_ambiguous) 1446 << LTy << RTy << LHS->getSourceRange() << RHS->getSourceRange(); 1447 return QualType(); 1448 } 1449 1450 // If exactly one conversion is possible, that conversion is applied to 1451 // the chosen operand and the converted operands are used in place of the 1452 // original operands for the remainder of this section. 1453 if (HaveL2R) { 1454 if (ConvertForConditional(*this, LHS, ICSLeftToRight)) 1455 return QualType(); 1456 LTy = LHS->getType(); 1457 } else if (HaveR2L) { 1458 if (ConvertForConditional(*this, RHS, ICSRightToLeft)) 1459 return QualType(); 1460 RTy = RHS->getType(); 1461 } 1462 } 1463 1464 // C++0x 5.16p4 1465 // If the second and third operands are lvalues and have the same type, 1466 // the result is of that type [...] 1467 bool Same = Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy); 1468 if (Same && LHS->isLvalue(Context) == Expr::LV_Valid && 1469 RHS->isLvalue(Context) == Expr::LV_Valid) 1470 return LTy; 1471 1472 // C++0x 5.16p5 1473 // Otherwise, the result is an rvalue. If the second and third operands 1474 // do not have the same type, and either has (cv) class type, ... 1475 if (!Same && (LTy->isRecordType() || RTy->isRecordType())) { 1476 // ... overload resolution is used to determine the conversions (if any) 1477 // to be applied to the operands. If the overload resolution fails, the 1478 // program is ill-formed. 1479 if (FindConditionalOverload(*this, LHS, RHS, QuestionLoc)) 1480 return QualType(); 1481 } 1482 1483 // C++0x 5.16p6 1484 // LValue-to-rvalue, array-to-pointer, and function-to-pointer standard 1485 // conversions are performed on the second and third operands. 1486 DefaultFunctionArrayConversion(LHS); 1487 DefaultFunctionArrayConversion(RHS); 1488 LTy = LHS->getType(); 1489 RTy = RHS->getType(); 1490 1491 // After those conversions, one of the following shall hold: 1492 // -- The second and third operands have the same type; the result 1493 // is of that type. 1494 if (Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy)) 1495 return LTy; 1496 1497 // -- The second and third operands have arithmetic or enumeration type; 1498 // the usual arithmetic conversions are performed to bring them to a 1499 // common type, and the result is of that type. 1500 if (LTy->isArithmeticType() && RTy->isArithmeticType()) { 1501 UsualArithmeticConversions(LHS, RHS); 1502 return LHS->getType(); 1503 } 1504 1505 // -- The second and third operands have pointer type, or one has pointer 1506 // type and the other is a null pointer constant; pointer conversions 1507 // and qualification conversions are performed to bring them to their 1508 // composite pointer type. The result is of the composite pointer type. 1509 QualType Composite = FindCompositePointerType(LHS, RHS); 1510 if (!Composite.isNull()) 1511 return Composite; 1512 1513 // Fourth bullet is same for pointers-to-member. However, the possible 1514 // conversions are far more limited: we have null-to-pointer, upcast of 1515 // containing class, and second-level cv-ness. 1516 // cv-ness is not a union, but must match one of the two operands. (Which, 1517 // frankly, is stupid.) 1518 const MemberPointerType *LMemPtr = LTy->getAs<MemberPointerType>(); 1519 const MemberPointerType *RMemPtr = RTy->getAs<MemberPointerType>(); 1520 if (LMemPtr && RHS->isNullPointerConstant(Context)) { 1521 ImpCastExprToType(RHS, LTy); 1522 return LTy; 1523 } 1524 if (RMemPtr && LHS->isNullPointerConstant(Context)) { 1525 ImpCastExprToType(LHS, RTy); 1526 return RTy; 1527 } 1528 if (LMemPtr && RMemPtr) { 1529 QualType LPointee = LMemPtr->getPointeeType(); 1530 QualType RPointee = RMemPtr->getPointeeType(); 1531 // First, we check that the unqualified pointee type is the same. If it's 1532 // not, there's no conversion that will unify the two pointers. 1533 if (Context.getCanonicalType(LPointee).getUnqualifiedType() == 1534 Context.getCanonicalType(RPointee).getUnqualifiedType()) { 1535 // Second, we take the greater of the two cv qualifications. If neither 1536 // is greater than the other, the conversion is not possible. 1537 unsigned Q = LPointee.getCVRQualifiers() | RPointee.getCVRQualifiers(); 1538 if (Q == LPointee.getCVRQualifiers() || Q == RPointee.getCVRQualifiers()){ 1539 // Third, we check if either of the container classes is derived from 1540 // the other. 1541 QualType LContainer(LMemPtr->getClass(), 0); 1542 QualType RContainer(RMemPtr->getClass(), 0); 1543 QualType MoreDerived; 1544 if (Context.getCanonicalType(LContainer) == 1545 Context.getCanonicalType(RContainer)) 1546 MoreDerived = LContainer; 1547 else if (IsDerivedFrom(LContainer, RContainer)) 1548 MoreDerived = LContainer; 1549 else if (IsDerivedFrom(RContainer, LContainer)) 1550 MoreDerived = RContainer; 1551 1552 if (!MoreDerived.isNull()) { 1553 // The type 'Q Pointee (MoreDerived::*)' is the common type. 1554 // We don't use ImpCastExprToType here because this could still fail 1555 // for ambiguous or inaccessible conversions. 1556 QualType Common = Context.getMemberPointerType( 1557 LPointee.getQualifiedType(Q), MoreDerived.getTypePtr()); 1558 if (PerformImplicitConversion(LHS, Common, "converting")) 1559 return QualType(); 1560 if (PerformImplicitConversion(RHS, Common, "converting")) 1561 return QualType(); 1562 return Common; 1563 } 1564 } 1565 } 1566 } 1567 1568 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands) 1569 << LHS->getType() << RHS->getType() 1570 << LHS->getSourceRange() << RHS->getSourceRange(); 1571 return QualType(); 1572} 1573 1574/// \brief Find a merged pointer type and convert the two expressions to it. 1575/// 1576/// This finds the composite pointer type (or member pointer type) for @p E1 1577/// and @p E2 according to C++0x 5.9p2. It converts both expressions to this 1578/// type and returns it. 1579/// It does not emit diagnostics. 1580QualType Sema::FindCompositePointerType(Expr *&E1, Expr *&E2) { 1581 assert(getLangOptions().CPlusPlus && "This function assumes C++"); 1582 QualType T1 = E1->getType(), T2 = E2->getType(); 1583 1584 if (!T1->isPointerType() && !T1->isMemberPointerType() && 1585 !T2->isPointerType() && !T2->isMemberPointerType()) 1586 return QualType(); 1587 1588 // FIXME: Do we need to work on the canonical types? 1589 1590 // C++0x 5.9p2 1591 // Pointer conversions and qualification conversions are performed on 1592 // pointer operands to bring them to their composite pointer type. If 1593 // one operand is a null pointer constant, the composite pointer type is 1594 // the type of the other operand. 1595 if (E1->isNullPointerConstant(Context)) { 1596 ImpCastExprToType(E1, T2); 1597 return T2; 1598 } 1599 if (E2->isNullPointerConstant(Context)) { 1600 ImpCastExprToType(E2, T1); 1601 return T1; 1602 } 1603 1604 // Now both have to be pointers or member pointers. 1605 if (!T1->isPointerType() && !T1->isMemberPointerType() && 1606 !T2->isPointerType() && !T2->isMemberPointerType()) 1607 return QualType(); 1608 1609 // Otherwise, of one of the operands has type "pointer to cv1 void," then 1610 // the other has type "pointer to cv2 T" and the composite pointer type is 1611 // "pointer to cv12 void," where cv12 is the union of cv1 and cv2. 1612 // Otherwise, the composite pointer type is a pointer type similar to the 1613 // type of one of the operands, with a cv-qualification signature that is 1614 // the union of the cv-qualification signatures of the operand types. 1615 // In practice, the first part here is redundant; it's subsumed by the second. 1616 // What we do here is, we build the two possible composite types, and try the 1617 // conversions in both directions. If only one works, or if the two composite 1618 // types are the same, we have succeeded. 1619 llvm::SmallVector<unsigned, 4> QualifierUnion; 1620 llvm::SmallVector<std::pair<const Type *, const Type *>, 4> MemberOfClass; 1621 QualType Composite1 = T1, Composite2 = T2; 1622 do { 1623 const PointerType *Ptr1, *Ptr2; 1624 if ((Ptr1 = Composite1->getAs<PointerType>()) && 1625 (Ptr2 = Composite2->getAs<PointerType>())) { 1626 Composite1 = Ptr1->getPointeeType(); 1627 Composite2 = Ptr2->getPointeeType(); 1628 QualifierUnion.push_back( 1629 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers()); 1630 MemberOfClass.push_back(std::make_pair((const Type *)0, (const Type *)0)); 1631 continue; 1632 } 1633 1634 const MemberPointerType *MemPtr1, *MemPtr2; 1635 if ((MemPtr1 = Composite1->getAs<MemberPointerType>()) && 1636 (MemPtr2 = Composite2->getAs<MemberPointerType>())) { 1637 Composite1 = MemPtr1->getPointeeType(); 1638 Composite2 = MemPtr2->getPointeeType(); 1639 QualifierUnion.push_back( 1640 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers()); 1641 MemberOfClass.push_back(std::make_pair(MemPtr1->getClass(), 1642 MemPtr2->getClass())); 1643 continue; 1644 } 1645 1646 // FIXME: block pointer types? 1647 1648 // Cannot unwrap any more types. 1649 break; 1650 } while (true); 1651 1652 // Rewrap the composites as pointers or member pointers with the union CVRs. 1653 llvm::SmallVector<std::pair<const Type *, const Type *>, 4>::iterator MOC 1654 = MemberOfClass.begin(); 1655 for (llvm::SmallVector<unsigned, 4>::iterator 1656 I = QualifierUnion.begin(), 1657 E = QualifierUnion.end(); 1658 I != E; (void)++I, ++MOC) { 1659 if (MOC->first && MOC->second) { 1660 // Rebuild member pointer type 1661 Composite1 = Context.getMemberPointerType(Composite1.getQualifiedType(*I), 1662 MOC->first); 1663 Composite2 = Context.getMemberPointerType(Composite2.getQualifiedType(*I), 1664 MOC->second); 1665 } else { 1666 // Rebuild pointer type 1667 Composite1 = Context.getPointerType(Composite1.getQualifiedType(*I)); 1668 Composite2 = Context.getPointerType(Composite2.getQualifiedType(*I)); 1669 } 1670 } 1671 1672 ImplicitConversionSequence E1ToC1 = 1673 TryImplicitConversion(E1, Composite1, 1674 /*SuppressUserConversions=*/false, 1675 /*AllowExplicit=*/false, 1676 /*ForceRValue=*/false, 1677 /*InOverloadResolution=*/false); 1678 ImplicitConversionSequence E2ToC1 = 1679 TryImplicitConversion(E2, Composite1, 1680 /*SuppressUserConversions=*/false, 1681 /*AllowExplicit=*/false, 1682 /*ForceRValue=*/false, 1683 /*InOverloadResolution=*/false); 1684 1685 ImplicitConversionSequence E1ToC2, E2ToC2; 1686 E1ToC2.ConversionKind = ImplicitConversionSequence::BadConversion; 1687 E2ToC2.ConversionKind = ImplicitConversionSequence::BadConversion; 1688 if (Context.getCanonicalType(Composite1) != 1689 Context.getCanonicalType(Composite2)) { 1690 E1ToC2 = TryImplicitConversion(E1, Composite2, 1691 /*SuppressUserConversions=*/false, 1692 /*AllowExplicit=*/false, 1693 /*ForceRValue=*/false, 1694 /*InOverloadResolution=*/false); 1695 E2ToC2 = TryImplicitConversion(E2, Composite2, 1696 /*SuppressUserConversions=*/false, 1697 /*AllowExplicit=*/false, 1698 /*ForceRValue=*/false, 1699 /*InOverloadResolution=*/false); 1700 } 1701 1702 bool ToC1Viable = E1ToC1.ConversionKind != 1703 ImplicitConversionSequence::BadConversion 1704 && E2ToC1.ConversionKind != 1705 ImplicitConversionSequence::BadConversion; 1706 bool ToC2Viable = E1ToC2.ConversionKind != 1707 ImplicitConversionSequence::BadConversion 1708 && E2ToC2.ConversionKind != 1709 ImplicitConversionSequence::BadConversion; 1710 if (ToC1Viable && !ToC2Viable) { 1711 if (!PerformImplicitConversion(E1, Composite1, E1ToC1, "converting") && 1712 !PerformImplicitConversion(E2, Composite1, E2ToC1, "converting")) 1713 return Composite1; 1714 } 1715 if (ToC2Viable && !ToC1Viable) { 1716 if (!PerformImplicitConversion(E1, Composite2, E1ToC2, "converting") && 1717 !PerformImplicitConversion(E2, Composite2, E2ToC2, "converting")) 1718 return Composite2; 1719 } 1720 return QualType(); 1721} 1722 1723Sema::OwningExprResult Sema::MaybeBindToTemporary(Expr *E) { 1724 if (!Context.getLangOptions().CPlusPlus) 1725 return Owned(E); 1726 1727 const RecordType *RT = E->getType()->getAs<RecordType>(); 1728 if (!RT) 1729 return Owned(E); 1730 1731 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 1732 if (RD->hasTrivialDestructor()) 1733 return Owned(E); 1734 1735 CXXTemporary *Temp = CXXTemporary::Create(Context, 1736 RD->getDestructor(Context)); 1737 ExprTemporaries.push_back(Temp); 1738 if (CXXDestructorDecl *Destructor = 1739 const_cast<CXXDestructorDecl*>(RD->getDestructor(Context))) 1740 MarkDeclarationReferenced(E->getExprLoc(), Destructor); 1741 // FIXME: Add the temporary to the temporaries vector. 1742 return Owned(CXXBindTemporaryExpr::Create(Context, Temp, E)); 1743} 1744 1745Expr *Sema::MaybeCreateCXXExprWithTemporaries(Expr *SubExpr, 1746 bool ShouldDestroyTemps) { 1747 assert(SubExpr && "sub expression can't be null!"); 1748 1749 if (ExprTemporaries.empty()) 1750 return SubExpr; 1751 1752 Expr *E = CXXExprWithTemporaries::Create(Context, SubExpr, 1753 &ExprTemporaries[0], 1754 ExprTemporaries.size(), 1755 ShouldDestroyTemps); 1756 ExprTemporaries.clear(); 1757 1758 return E; 1759} 1760 1761Sema::OwningExprResult 1762Sema::ActOnStartCXXMemberReference(Scope *S, ExprArg Base, SourceLocation OpLoc, 1763 tok::TokenKind OpKind, TypeTy *&ObjectType) { 1764 // Since this might be a postfix expression, get rid of ParenListExprs. 1765 Base = MaybeConvertParenListExprToParenExpr(S, move(Base)); 1766 1767 Expr *BaseExpr = (Expr*)Base.get(); 1768 assert(BaseExpr && "no record expansion"); 1769 1770 QualType BaseType = BaseExpr->getType(); 1771 if (BaseType->isDependentType()) { 1772 // FIXME: member of the current instantiation 1773 ObjectType = BaseType.getAsOpaquePtr(); 1774 return move(Base); 1775 } 1776 1777 // C++ [over.match.oper]p8: 1778 // [...] When operator->returns, the operator-> is applied to the value 1779 // returned, with the original second operand. 1780 if (OpKind == tok::arrow) { 1781 while (BaseType->isRecordType()) { 1782 Base = BuildOverloadedArrowExpr(S, move(Base), BaseExpr->getExprLoc()); 1783 BaseExpr = (Expr*)Base.get(); 1784 if (BaseExpr == NULL) 1785 return ExprError(); 1786 BaseType = BaseExpr->getType(); 1787 } 1788 } 1789 1790 if (BaseType->isPointerType()) 1791 BaseType = BaseType->getPointeeType(); 1792 1793 // We could end up with various non-record types here, such as extended 1794 // vector types or Objective-C interfaces. Just return early and let 1795 // ActOnMemberReferenceExpr do the work. 1796 if (!BaseType->isRecordType()) { 1797 // C++ [basic.lookup.classref]p2: 1798 // [...] If the type of the object expression is of pointer to scalar 1799 // type, the unqualified-id is looked up in the context of the complete 1800 // postfix-expression. 1801 ObjectType = 0; 1802 return move(Base); 1803 } 1804 1805 // C++ [basic.lookup.classref]p2: 1806 // If the id-expression in a class member access (5.2.5) is an 1807 // unqualified-id, and the type of the object expres- sion is of a class 1808 // type C (or of pointer to a class type C), the unqualified-id is looked 1809 // up in the scope of class C. [...] 1810 ObjectType = BaseType.getAsOpaquePtr(); 1811 return move(Base); 1812} 1813 1814Sema::OwningExprResult 1815Sema::ActOnDestructorReferenceExpr(Scope *S, ExprArg Base, 1816 SourceLocation OpLoc, 1817 tok::TokenKind OpKind, 1818 SourceLocation ClassNameLoc, 1819 IdentifierInfo *ClassName, 1820 const CXXScopeSpec &SS, 1821 bool HasTrailingLParen) { 1822 if (SS.isInvalid()) 1823 return ExprError(); 1824 1825 QualType BaseType; 1826 if (isUnknownSpecialization(SS)) 1827 BaseType = Context.getTypenameType((NestedNameSpecifier *)SS.getScopeRep(), 1828 ClassName); 1829 else { 1830 TypeTy *BaseTy = getTypeName(*ClassName, ClassNameLoc, S, &SS); 1831 if (!BaseTy) { 1832 Diag(ClassNameLoc, diag::err_ident_in_pseudo_dtor_not_a_type) 1833 << ClassName; 1834 return ExprError(); 1835 } 1836 1837 BaseType = GetTypeFromParser(BaseTy); 1838 } 1839 1840 CanQualType CanBaseType = Context.getCanonicalType(BaseType); 1841 DeclarationName DtorName = 1842 Context.DeclarationNames.getCXXDestructorName(CanBaseType); 1843 1844 OwningExprResult Result 1845 = BuildMemberReferenceExpr(S, move(Base), OpLoc, OpKind, ClassNameLoc, 1846 DtorName, DeclPtrTy(), &SS); 1847 if (Result.isInvalid() || HasTrailingLParen) 1848 return move(Result); 1849 1850 // The only way a reference to a destructor can be used is to 1851 // immediately call them. Since the next token is not a '(', produce a 1852 // diagnostic and build the call now. 1853 Expr *E = (Expr *)Result.get(); 1854 SourceLocation ExpectedLParenLoc = PP.getLocForEndOfToken(E->getLocEnd()); 1855 Diag(E->getLocStart(), diag::err_dtor_expr_without_call) 1856 << isa<CXXPseudoDestructorExpr>(E) 1857 << CodeModificationHint::CreateInsertion(ExpectedLParenLoc, "()"); 1858 1859 return ActOnCallExpr(0, move(Result), ExpectedLParenLoc, 1860 MultiExprArg(*this, 0, 0), 0, ExpectedLParenLoc); 1861} 1862 1863Sema::OwningExprResult 1864Sema::ActOnOverloadedOperatorReferenceExpr(Scope *S, ExprArg Base, 1865 SourceLocation OpLoc, 1866 tok::TokenKind OpKind, 1867 SourceLocation ClassNameLoc, 1868 OverloadedOperatorKind OverOpKind, 1869 const CXXScopeSpec *SS) { 1870 if (SS && SS->isInvalid()) 1871 return ExprError(); 1872 1873 DeclarationName Name = 1874 Context.DeclarationNames.getCXXOperatorName(OverOpKind); 1875 1876 return BuildMemberReferenceExpr(S, move(Base), OpLoc, OpKind, ClassNameLoc, 1877 Name, DeclPtrTy(), SS); 1878} 1879 1880Sema::OwningExprResult 1881Sema::ActOnConversionOperatorReferenceExpr(Scope *S, ExprArg Base, 1882 SourceLocation OpLoc, 1883 tok::TokenKind OpKind, 1884 SourceLocation ClassNameLoc, 1885 TypeTy *Ty, 1886 const CXXScopeSpec *SS) { 1887 if (SS && SS->isInvalid()) 1888 return ExprError(); 1889 1890 //FIXME: Preserve type source info. 1891 QualType ConvType = GetTypeFromParser(Ty); 1892 CanQualType ConvTypeCanon = Context.getCanonicalType(ConvType); 1893 DeclarationName ConvName = 1894 Context.DeclarationNames.getCXXConversionFunctionName(ConvTypeCanon); 1895 1896 return BuildMemberReferenceExpr(S, move(Base), OpLoc, OpKind, ClassNameLoc, 1897 ConvName, DeclPtrTy(), SS); 1898} 1899 1900Sema::OwningExprResult Sema::ActOnFinishFullExpr(ExprArg Arg) { 1901 Expr *FullExpr = Arg.takeAs<Expr>(); 1902 if (FullExpr) 1903 FullExpr = MaybeCreateCXXExprWithTemporaries(FullExpr, 1904 /*ShouldDestroyTemps=*/true); 1905 1906 1907 return Owned(FullExpr); 1908} 1909