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