SemaOverload.cpp revision 263508
1//===--- SemaOverload.cpp - C++ Overloading -------------------------------===// 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 provides Sema routines for C++ overloading. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/Sema/Overload.h" 15#include "clang/AST/ASTContext.h" 16#include "clang/AST/CXXInheritance.h" 17#include "clang/AST/DeclObjC.h" 18#include "clang/AST/Expr.h" 19#include "clang/AST/ExprCXX.h" 20#include "clang/AST/ExprObjC.h" 21#include "clang/AST/TypeOrdering.h" 22#include "clang/Basic/Diagnostic.h" 23#include "clang/Basic/PartialDiagnostic.h" 24#include "clang/Basic/TargetInfo.h" 25#include "clang/Lex/Preprocessor.h" 26#include "clang/Sema/Initialization.h" 27#include "clang/Sema/Lookup.h" 28#include "clang/Sema/SemaInternal.h" 29#include "clang/Sema/Template.h" 30#include "clang/Sema/TemplateDeduction.h" 31#include "llvm/ADT/DenseSet.h" 32#include "llvm/ADT/STLExtras.h" 33#include "llvm/ADT/SmallPtrSet.h" 34#include "llvm/ADT/SmallString.h" 35#include <algorithm> 36 37namespace clang { 38using namespace sema; 39 40/// A convenience routine for creating a decayed reference to a function. 41static ExprResult 42CreateFunctionRefExpr(Sema &S, FunctionDecl *Fn, NamedDecl *FoundDecl, 43 bool HadMultipleCandidates, 44 SourceLocation Loc = SourceLocation(), 45 const DeclarationNameLoc &LocInfo = DeclarationNameLoc()){ 46 if (S.DiagnoseUseOfDecl(FoundDecl, Loc)) 47 return ExprError(); 48 // If FoundDecl is different from Fn (such as if one is a template 49 // and the other a specialization), make sure DiagnoseUseOfDecl is 50 // called on both. 51 // FIXME: This would be more comprehensively addressed by modifying 52 // DiagnoseUseOfDecl to accept both the FoundDecl and the decl 53 // being used. 54 if (FoundDecl != Fn && S.DiagnoseUseOfDecl(Fn, Loc)) 55 return ExprError(); 56 DeclRefExpr *DRE = new (S.Context) DeclRefExpr(Fn, false, Fn->getType(), 57 VK_LValue, Loc, LocInfo); 58 if (HadMultipleCandidates) 59 DRE->setHadMultipleCandidates(true); 60 61 S.MarkDeclRefReferenced(DRE); 62 63 ExprResult E = S.Owned(DRE); 64 E = S.DefaultFunctionArrayConversion(E.take()); 65 if (E.isInvalid()) 66 return ExprError(); 67 return E; 68} 69 70static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType, 71 bool InOverloadResolution, 72 StandardConversionSequence &SCS, 73 bool CStyle, 74 bool AllowObjCWritebackConversion); 75 76static bool IsTransparentUnionStandardConversion(Sema &S, Expr* From, 77 QualType &ToType, 78 bool InOverloadResolution, 79 StandardConversionSequence &SCS, 80 bool CStyle); 81static OverloadingResult 82IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType, 83 UserDefinedConversionSequence& User, 84 OverloadCandidateSet& Conversions, 85 bool AllowExplicit, 86 bool AllowObjCConversionOnExplicit); 87 88 89static ImplicitConversionSequence::CompareKind 90CompareStandardConversionSequences(Sema &S, 91 const StandardConversionSequence& SCS1, 92 const StandardConversionSequence& SCS2); 93 94static ImplicitConversionSequence::CompareKind 95CompareQualificationConversions(Sema &S, 96 const StandardConversionSequence& SCS1, 97 const StandardConversionSequence& SCS2); 98 99static ImplicitConversionSequence::CompareKind 100CompareDerivedToBaseConversions(Sema &S, 101 const StandardConversionSequence& SCS1, 102 const StandardConversionSequence& SCS2); 103 104 105 106/// GetConversionCategory - Retrieve the implicit conversion 107/// category corresponding to the given implicit conversion kind. 108ImplicitConversionCategory 109GetConversionCategory(ImplicitConversionKind Kind) { 110 static const ImplicitConversionCategory 111 Category[(int)ICK_Num_Conversion_Kinds] = { 112 ICC_Identity, 113 ICC_Lvalue_Transformation, 114 ICC_Lvalue_Transformation, 115 ICC_Lvalue_Transformation, 116 ICC_Identity, 117 ICC_Qualification_Adjustment, 118 ICC_Promotion, 119 ICC_Promotion, 120 ICC_Promotion, 121 ICC_Conversion, 122 ICC_Conversion, 123 ICC_Conversion, 124 ICC_Conversion, 125 ICC_Conversion, 126 ICC_Conversion, 127 ICC_Conversion, 128 ICC_Conversion, 129 ICC_Conversion, 130 ICC_Conversion, 131 ICC_Conversion, 132 ICC_Conversion, 133 ICC_Conversion 134 }; 135 return Category[(int)Kind]; 136} 137 138/// GetConversionRank - Retrieve the implicit conversion rank 139/// corresponding to the given implicit conversion kind. 140ImplicitConversionRank GetConversionRank(ImplicitConversionKind Kind) { 141 static const ImplicitConversionRank 142 Rank[(int)ICK_Num_Conversion_Kinds] = { 143 ICR_Exact_Match, 144 ICR_Exact_Match, 145 ICR_Exact_Match, 146 ICR_Exact_Match, 147 ICR_Exact_Match, 148 ICR_Exact_Match, 149 ICR_Promotion, 150 ICR_Promotion, 151 ICR_Promotion, 152 ICR_Conversion, 153 ICR_Conversion, 154 ICR_Conversion, 155 ICR_Conversion, 156 ICR_Conversion, 157 ICR_Conversion, 158 ICR_Conversion, 159 ICR_Conversion, 160 ICR_Conversion, 161 ICR_Conversion, 162 ICR_Conversion, 163 ICR_Complex_Real_Conversion, 164 ICR_Conversion, 165 ICR_Conversion, 166 ICR_Writeback_Conversion 167 }; 168 return Rank[(int)Kind]; 169} 170 171/// GetImplicitConversionName - Return the name of this kind of 172/// implicit conversion. 173const char* GetImplicitConversionName(ImplicitConversionKind Kind) { 174 static const char* const Name[(int)ICK_Num_Conversion_Kinds] = { 175 "No conversion", 176 "Lvalue-to-rvalue", 177 "Array-to-pointer", 178 "Function-to-pointer", 179 "Noreturn adjustment", 180 "Qualification", 181 "Integral promotion", 182 "Floating point promotion", 183 "Complex promotion", 184 "Integral conversion", 185 "Floating conversion", 186 "Complex conversion", 187 "Floating-integral conversion", 188 "Pointer conversion", 189 "Pointer-to-member conversion", 190 "Boolean conversion", 191 "Compatible-types conversion", 192 "Derived-to-base conversion", 193 "Vector conversion", 194 "Vector splat", 195 "Complex-real conversion", 196 "Block Pointer conversion", 197 "Transparent Union Conversion" 198 "Writeback conversion" 199 }; 200 return Name[Kind]; 201} 202 203/// StandardConversionSequence - Set the standard conversion 204/// sequence to the identity conversion. 205void StandardConversionSequence::setAsIdentityConversion() { 206 First = ICK_Identity; 207 Second = ICK_Identity; 208 Third = ICK_Identity; 209 DeprecatedStringLiteralToCharPtr = false; 210 QualificationIncludesObjCLifetime = false; 211 ReferenceBinding = false; 212 DirectBinding = false; 213 IsLvalueReference = true; 214 BindsToFunctionLvalue = false; 215 BindsToRvalue = false; 216 BindsImplicitObjectArgumentWithoutRefQualifier = false; 217 ObjCLifetimeConversionBinding = false; 218 CopyConstructor = 0; 219} 220 221/// getRank - Retrieve the rank of this standard conversion sequence 222/// (C++ 13.3.3.1.1p3). The rank is the largest rank of each of the 223/// implicit conversions. 224ImplicitConversionRank StandardConversionSequence::getRank() const { 225 ImplicitConversionRank Rank = ICR_Exact_Match; 226 if (GetConversionRank(First) > Rank) 227 Rank = GetConversionRank(First); 228 if (GetConversionRank(Second) > Rank) 229 Rank = GetConversionRank(Second); 230 if (GetConversionRank(Third) > Rank) 231 Rank = GetConversionRank(Third); 232 return Rank; 233} 234 235/// isPointerConversionToBool - Determines whether this conversion is 236/// a conversion of a pointer or pointer-to-member to bool. This is 237/// used as part of the ranking of standard conversion sequences 238/// (C++ 13.3.3.2p4). 239bool StandardConversionSequence::isPointerConversionToBool() const { 240 // Note that FromType has not necessarily been transformed by the 241 // array-to-pointer or function-to-pointer implicit conversions, so 242 // check for their presence as well as checking whether FromType is 243 // a pointer. 244 if (getToType(1)->isBooleanType() && 245 (getFromType()->isPointerType() || 246 getFromType()->isObjCObjectPointerType() || 247 getFromType()->isBlockPointerType() || 248 getFromType()->isNullPtrType() || 249 First == ICK_Array_To_Pointer || First == ICK_Function_To_Pointer)) 250 return true; 251 252 return false; 253} 254 255/// isPointerConversionToVoidPointer - Determines whether this 256/// conversion is a conversion of a pointer to a void pointer. This is 257/// used as part of the ranking of standard conversion sequences (C++ 258/// 13.3.3.2p4). 259bool 260StandardConversionSequence:: 261isPointerConversionToVoidPointer(ASTContext& Context) const { 262 QualType FromType = getFromType(); 263 QualType ToType = getToType(1); 264 265 // Note that FromType has not necessarily been transformed by the 266 // array-to-pointer implicit conversion, so check for its presence 267 // and redo the conversion to get a pointer. 268 if (First == ICK_Array_To_Pointer) 269 FromType = Context.getArrayDecayedType(FromType); 270 271 if (Second == ICK_Pointer_Conversion && FromType->isAnyPointerType()) 272 if (const PointerType* ToPtrType = ToType->getAs<PointerType>()) 273 return ToPtrType->getPointeeType()->isVoidType(); 274 275 return false; 276} 277 278/// Skip any implicit casts which could be either part of a narrowing conversion 279/// or after one in an implicit conversion. 280static const Expr *IgnoreNarrowingConversion(const Expr *Converted) { 281 while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Converted)) { 282 switch (ICE->getCastKind()) { 283 case CK_NoOp: 284 case CK_IntegralCast: 285 case CK_IntegralToBoolean: 286 case CK_IntegralToFloating: 287 case CK_FloatingToIntegral: 288 case CK_FloatingToBoolean: 289 case CK_FloatingCast: 290 Converted = ICE->getSubExpr(); 291 continue; 292 293 default: 294 return Converted; 295 } 296 } 297 298 return Converted; 299} 300 301/// Check if this standard conversion sequence represents a narrowing 302/// conversion, according to C++11 [dcl.init.list]p7. 303/// 304/// \param Ctx The AST context. 305/// \param Converted The result of applying this standard conversion sequence. 306/// \param ConstantValue If this is an NK_Constant_Narrowing conversion, the 307/// value of the expression prior to the narrowing conversion. 308/// \param ConstantType If this is an NK_Constant_Narrowing conversion, the 309/// type of the expression prior to the narrowing conversion. 310NarrowingKind 311StandardConversionSequence::getNarrowingKind(ASTContext &Ctx, 312 const Expr *Converted, 313 APValue &ConstantValue, 314 QualType &ConstantType) const { 315 assert(Ctx.getLangOpts().CPlusPlus && "narrowing check outside C++"); 316 317 // C++11 [dcl.init.list]p7: 318 // A narrowing conversion is an implicit conversion ... 319 QualType FromType = getToType(0); 320 QualType ToType = getToType(1); 321 switch (Second) { 322 // -- from a floating-point type to an integer type, or 323 // 324 // -- from an integer type or unscoped enumeration type to a floating-point 325 // type, except where the source is a constant expression and the actual 326 // value after conversion will fit into the target type and will produce 327 // the original value when converted back to the original type, or 328 case ICK_Floating_Integral: 329 if (FromType->isRealFloatingType() && ToType->isIntegralType(Ctx)) { 330 return NK_Type_Narrowing; 331 } else if (FromType->isIntegralType(Ctx) && ToType->isRealFloatingType()) { 332 llvm::APSInt IntConstantValue; 333 const Expr *Initializer = IgnoreNarrowingConversion(Converted); 334 if (Initializer && 335 Initializer->isIntegerConstantExpr(IntConstantValue, Ctx)) { 336 // Convert the integer to the floating type. 337 llvm::APFloat Result(Ctx.getFloatTypeSemantics(ToType)); 338 Result.convertFromAPInt(IntConstantValue, IntConstantValue.isSigned(), 339 llvm::APFloat::rmNearestTiesToEven); 340 // And back. 341 llvm::APSInt ConvertedValue = IntConstantValue; 342 bool ignored; 343 Result.convertToInteger(ConvertedValue, 344 llvm::APFloat::rmTowardZero, &ignored); 345 // If the resulting value is different, this was a narrowing conversion. 346 if (IntConstantValue != ConvertedValue) { 347 ConstantValue = APValue(IntConstantValue); 348 ConstantType = Initializer->getType(); 349 return NK_Constant_Narrowing; 350 } 351 } else { 352 // Variables are always narrowings. 353 return NK_Variable_Narrowing; 354 } 355 } 356 return NK_Not_Narrowing; 357 358 // -- from long double to double or float, or from double to float, except 359 // where the source is a constant expression and the actual value after 360 // conversion is within the range of values that can be represented (even 361 // if it cannot be represented exactly), or 362 case ICK_Floating_Conversion: 363 if (FromType->isRealFloatingType() && ToType->isRealFloatingType() && 364 Ctx.getFloatingTypeOrder(FromType, ToType) == 1) { 365 // FromType is larger than ToType. 366 const Expr *Initializer = IgnoreNarrowingConversion(Converted); 367 if (Initializer->isCXX11ConstantExpr(Ctx, &ConstantValue)) { 368 // Constant! 369 assert(ConstantValue.isFloat()); 370 llvm::APFloat FloatVal = ConstantValue.getFloat(); 371 // Convert the source value into the target type. 372 bool ignored; 373 llvm::APFloat::opStatus ConvertStatus = FloatVal.convert( 374 Ctx.getFloatTypeSemantics(ToType), 375 llvm::APFloat::rmNearestTiesToEven, &ignored); 376 // If there was no overflow, the source value is within the range of 377 // values that can be represented. 378 if (ConvertStatus & llvm::APFloat::opOverflow) { 379 ConstantType = Initializer->getType(); 380 return NK_Constant_Narrowing; 381 } 382 } else { 383 return NK_Variable_Narrowing; 384 } 385 } 386 return NK_Not_Narrowing; 387 388 // -- from an integer type or unscoped enumeration type to an integer type 389 // that cannot represent all the values of the original type, except where 390 // the source is a constant expression and the actual value after 391 // conversion will fit into the target type and will produce the original 392 // value when converted back to the original type. 393 case ICK_Boolean_Conversion: // Bools are integers too. 394 if (!FromType->isIntegralOrUnscopedEnumerationType()) { 395 // Boolean conversions can be from pointers and pointers to members 396 // [conv.bool], and those aren't considered narrowing conversions. 397 return NK_Not_Narrowing; 398 } // Otherwise, fall through to the integral case. 399 case ICK_Integral_Conversion: { 400 assert(FromType->isIntegralOrUnscopedEnumerationType()); 401 assert(ToType->isIntegralOrUnscopedEnumerationType()); 402 const bool FromSigned = FromType->isSignedIntegerOrEnumerationType(); 403 const unsigned FromWidth = Ctx.getIntWidth(FromType); 404 const bool ToSigned = ToType->isSignedIntegerOrEnumerationType(); 405 const unsigned ToWidth = Ctx.getIntWidth(ToType); 406 407 if (FromWidth > ToWidth || 408 (FromWidth == ToWidth && FromSigned != ToSigned) || 409 (FromSigned && !ToSigned)) { 410 // Not all values of FromType can be represented in ToType. 411 llvm::APSInt InitializerValue; 412 const Expr *Initializer = IgnoreNarrowingConversion(Converted); 413 if (!Initializer->isIntegerConstantExpr(InitializerValue, Ctx)) { 414 // Such conversions on variables are always narrowing. 415 return NK_Variable_Narrowing; 416 } 417 bool Narrowing = false; 418 if (FromWidth < ToWidth) { 419 // Negative -> unsigned is narrowing. Otherwise, more bits is never 420 // narrowing. 421 if (InitializerValue.isSigned() && InitializerValue.isNegative()) 422 Narrowing = true; 423 } else { 424 // Add a bit to the InitializerValue so we don't have to worry about 425 // signed vs. unsigned comparisons. 426 InitializerValue = InitializerValue.extend( 427 InitializerValue.getBitWidth() + 1); 428 // Convert the initializer to and from the target width and signed-ness. 429 llvm::APSInt ConvertedValue = InitializerValue; 430 ConvertedValue = ConvertedValue.trunc(ToWidth); 431 ConvertedValue.setIsSigned(ToSigned); 432 ConvertedValue = ConvertedValue.extend(InitializerValue.getBitWidth()); 433 ConvertedValue.setIsSigned(InitializerValue.isSigned()); 434 // If the result is different, this was a narrowing conversion. 435 if (ConvertedValue != InitializerValue) 436 Narrowing = true; 437 } 438 if (Narrowing) { 439 ConstantType = Initializer->getType(); 440 ConstantValue = APValue(InitializerValue); 441 return NK_Constant_Narrowing; 442 } 443 } 444 return NK_Not_Narrowing; 445 } 446 447 default: 448 // Other kinds of conversions are not narrowings. 449 return NK_Not_Narrowing; 450 } 451} 452 453/// dump - Print this standard conversion sequence to standard 454/// error. Useful for debugging overloading issues. 455void StandardConversionSequence::dump() const { 456 raw_ostream &OS = llvm::errs(); 457 bool PrintedSomething = false; 458 if (First != ICK_Identity) { 459 OS << GetImplicitConversionName(First); 460 PrintedSomething = true; 461 } 462 463 if (Second != ICK_Identity) { 464 if (PrintedSomething) { 465 OS << " -> "; 466 } 467 OS << GetImplicitConversionName(Second); 468 469 if (CopyConstructor) { 470 OS << " (by copy constructor)"; 471 } else if (DirectBinding) { 472 OS << " (direct reference binding)"; 473 } else if (ReferenceBinding) { 474 OS << " (reference binding)"; 475 } 476 PrintedSomething = true; 477 } 478 479 if (Third != ICK_Identity) { 480 if (PrintedSomething) { 481 OS << " -> "; 482 } 483 OS << GetImplicitConversionName(Third); 484 PrintedSomething = true; 485 } 486 487 if (!PrintedSomething) { 488 OS << "No conversions required"; 489 } 490} 491 492/// dump - Print this user-defined conversion sequence to standard 493/// error. Useful for debugging overloading issues. 494void UserDefinedConversionSequence::dump() const { 495 raw_ostream &OS = llvm::errs(); 496 if (Before.First || Before.Second || Before.Third) { 497 Before.dump(); 498 OS << " -> "; 499 } 500 if (ConversionFunction) 501 OS << '\'' << *ConversionFunction << '\''; 502 else 503 OS << "aggregate initialization"; 504 if (After.First || After.Second || After.Third) { 505 OS << " -> "; 506 After.dump(); 507 } 508} 509 510/// dump - Print this implicit conversion sequence to standard 511/// error. Useful for debugging overloading issues. 512void ImplicitConversionSequence::dump() const { 513 raw_ostream &OS = llvm::errs(); 514 if (isStdInitializerListElement()) 515 OS << "Worst std::initializer_list element conversion: "; 516 switch (ConversionKind) { 517 case StandardConversion: 518 OS << "Standard conversion: "; 519 Standard.dump(); 520 break; 521 case UserDefinedConversion: 522 OS << "User-defined conversion: "; 523 UserDefined.dump(); 524 break; 525 case EllipsisConversion: 526 OS << "Ellipsis conversion"; 527 break; 528 case AmbiguousConversion: 529 OS << "Ambiguous conversion"; 530 break; 531 case BadConversion: 532 OS << "Bad conversion"; 533 break; 534 } 535 536 OS << "\n"; 537} 538 539void AmbiguousConversionSequence::construct() { 540 new (&conversions()) ConversionSet(); 541} 542 543void AmbiguousConversionSequence::destruct() { 544 conversions().~ConversionSet(); 545} 546 547void 548AmbiguousConversionSequence::copyFrom(const AmbiguousConversionSequence &O) { 549 FromTypePtr = O.FromTypePtr; 550 ToTypePtr = O.ToTypePtr; 551 new (&conversions()) ConversionSet(O.conversions()); 552} 553 554namespace { 555 // Structure used by DeductionFailureInfo to store 556 // template argument information. 557 struct DFIArguments { 558 TemplateArgument FirstArg; 559 TemplateArgument SecondArg; 560 }; 561 // Structure used by DeductionFailureInfo to store 562 // template parameter and template argument information. 563 struct DFIParamWithArguments : DFIArguments { 564 TemplateParameter Param; 565 }; 566} 567 568/// \brief Convert from Sema's representation of template deduction information 569/// to the form used in overload-candidate information. 570DeductionFailureInfo MakeDeductionFailureInfo(ASTContext &Context, 571 Sema::TemplateDeductionResult TDK, 572 TemplateDeductionInfo &Info) { 573 DeductionFailureInfo Result; 574 Result.Result = static_cast<unsigned>(TDK); 575 Result.HasDiagnostic = false; 576 Result.Data = 0; 577 switch (TDK) { 578 case Sema::TDK_Success: 579 case Sema::TDK_Invalid: 580 case Sema::TDK_InstantiationDepth: 581 case Sema::TDK_TooManyArguments: 582 case Sema::TDK_TooFewArguments: 583 break; 584 585 case Sema::TDK_Incomplete: 586 case Sema::TDK_InvalidExplicitArguments: 587 Result.Data = Info.Param.getOpaqueValue(); 588 break; 589 590 case Sema::TDK_NonDeducedMismatch: { 591 // FIXME: Should allocate from normal heap so that we can free this later. 592 DFIArguments *Saved = new (Context) DFIArguments; 593 Saved->FirstArg = Info.FirstArg; 594 Saved->SecondArg = Info.SecondArg; 595 Result.Data = Saved; 596 break; 597 } 598 599 case Sema::TDK_Inconsistent: 600 case Sema::TDK_Underqualified: { 601 // FIXME: Should allocate from normal heap so that we can free this later. 602 DFIParamWithArguments *Saved = new (Context) DFIParamWithArguments; 603 Saved->Param = Info.Param; 604 Saved->FirstArg = Info.FirstArg; 605 Saved->SecondArg = Info.SecondArg; 606 Result.Data = Saved; 607 break; 608 } 609 610 case Sema::TDK_SubstitutionFailure: 611 Result.Data = Info.take(); 612 if (Info.hasSFINAEDiagnostic()) { 613 PartialDiagnosticAt *Diag = new (Result.Diagnostic) PartialDiagnosticAt( 614 SourceLocation(), PartialDiagnostic::NullDiagnostic()); 615 Info.takeSFINAEDiagnostic(*Diag); 616 Result.HasDiagnostic = true; 617 } 618 break; 619 620 case Sema::TDK_FailedOverloadResolution: 621 Result.Data = Info.Expression; 622 break; 623 624 case Sema::TDK_MiscellaneousDeductionFailure: 625 break; 626 } 627 628 return Result; 629} 630 631void DeductionFailureInfo::Destroy() { 632 switch (static_cast<Sema::TemplateDeductionResult>(Result)) { 633 case Sema::TDK_Success: 634 case Sema::TDK_Invalid: 635 case Sema::TDK_InstantiationDepth: 636 case Sema::TDK_Incomplete: 637 case Sema::TDK_TooManyArguments: 638 case Sema::TDK_TooFewArguments: 639 case Sema::TDK_InvalidExplicitArguments: 640 case Sema::TDK_FailedOverloadResolution: 641 break; 642 643 case Sema::TDK_Inconsistent: 644 case Sema::TDK_Underqualified: 645 case Sema::TDK_NonDeducedMismatch: 646 // FIXME: Destroy the data? 647 Data = 0; 648 break; 649 650 case Sema::TDK_SubstitutionFailure: 651 // FIXME: Destroy the template argument list? 652 Data = 0; 653 if (PartialDiagnosticAt *Diag = getSFINAEDiagnostic()) { 654 Diag->~PartialDiagnosticAt(); 655 HasDiagnostic = false; 656 } 657 break; 658 659 // Unhandled 660 case Sema::TDK_MiscellaneousDeductionFailure: 661 break; 662 } 663} 664 665PartialDiagnosticAt *DeductionFailureInfo::getSFINAEDiagnostic() { 666 if (HasDiagnostic) 667 return static_cast<PartialDiagnosticAt*>(static_cast<void*>(Diagnostic)); 668 return 0; 669} 670 671TemplateParameter DeductionFailureInfo::getTemplateParameter() { 672 switch (static_cast<Sema::TemplateDeductionResult>(Result)) { 673 case Sema::TDK_Success: 674 case Sema::TDK_Invalid: 675 case Sema::TDK_InstantiationDepth: 676 case Sema::TDK_TooManyArguments: 677 case Sema::TDK_TooFewArguments: 678 case Sema::TDK_SubstitutionFailure: 679 case Sema::TDK_NonDeducedMismatch: 680 case Sema::TDK_FailedOverloadResolution: 681 return TemplateParameter(); 682 683 case Sema::TDK_Incomplete: 684 case Sema::TDK_InvalidExplicitArguments: 685 return TemplateParameter::getFromOpaqueValue(Data); 686 687 case Sema::TDK_Inconsistent: 688 case Sema::TDK_Underqualified: 689 return static_cast<DFIParamWithArguments*>(Data)->Param; 690 691 // Unhandled 692 case Sema::TDK_MiscellaneousDeductionFailure: 693 break; 694 } 695 696 return TemplateParameter(); 697} 698 699TemplateArgumentList *DeductionFailureInfo::getTemplateArgumentList() { 700 switch (static_cast<Sema::TemplateDeductionResult>(Result)) { 701 case Sema::TDK_Success: 702 case Sema::TDK_Invalid: 703 case Sema::TDK_InstantiationDepth: 704 case Sema::TDK_TooManyArguments: 705 case Sema::TDK_TooFewArguments: 706 case Sema::TDK_Incomplete: 707 case Sema::TDK_InvalidExplicitArguments: 708 case Sema::TDK_Inconsistent: 709 case Sema::TDK_Underqualified: 710 case Sema::TDK_NonDeducedMismatch: 711 case Sema::TDK_FailedOverloadResolution: 712 return 0; 713 714 case Sema::TDK_SubstitutionFailure: 715 return static_cast<TemplateArgumentList*>(Data); 716 717 // Unhandled 718 case Sema::TDK_MiscellaneousDeductionFailure: 719 break; 720 } 721 722 return 0; 723} 724 725const TemplateArgument *DeductionFailureInfo::getFirstArg() { 726 switch (static_cast<Sema::TemplateDeductionResult>(Result)) { 727 case Sema::TDK_Success: 728 case Sema::TDK_Invalid: 729 case Sema::TDK_InstantiationDepth: 730 case Sema::TDK_Incomplete: 731 case Sema::TDK_TooManyArguments: 732 case Sema::TDK_TooFewArguments: 733 case Sema::TDK_InvalidExplicitArguments: 734 case Sema::TDK_SubstitutionFailure: 735 case Sema::TDK_FailedOverloadResolution: 736 return 0; 737 738 case Sema::TDK_Inconsistent: 739 case Sema::TDK_Underqualified: 740 case Sema::TDK_NonDeducedMismatch: 741 return &static_cast<DFIArguments*>(Data)->FirstArg; 742 743 // Unhandled 744 case Sema::TDK_MiscellaneousDeductionFailure: 745 break; 746 } 747 748 return 0; 749} 750 751const TemplateArgument *DeductionFailureInfo::getSecondArg() { 752 switch (static_cast<Sema::TemplateDeductionResult>(Result)) { 753 case Sema::TDK_Success: 754 case Sema::TDK_Invalid: 755 case Sema::TDK_InstantiationDepth: 756 case Sema::TDK_Incomplete: 757 case Sema::TDK_TooManyArguments: 758 case Sema::TDK_TooFewArguments: 759 case Sema::TDK_InvalidExplicitArguments: 760 case Sema::TDK_SubstitutionFailure: 761 case Sema::TDK_FailedOverloadResolution: 762 return 0; 763 764 case Sema::TDK_Inconsistent: 765 case Sema::TDK_Underqualified: 766 case Sema::TDK_NonDeducedMismatch: 767 return &static_cast<DFIArguments*>(Data)->SecondArg; 768 769 // Unhandled 770 case Sema::TDK_MiscellaneousDeductionFailure: 771 break; 772 } 773 774 return 0; 775} 776 777Expr *DeductionFailureInfo::getExpr() { 778 if (static_cast<Sema::TemplateDeductionResult>(Result) == 779 Sema::TDK_FailedOverloadResolution) 780 return static_cast<Expr*>(Data); 781 782 return 0; 783} 784 785void OverloadCandidateSet::destroyCandidates() { 786 for (iterator i = begin(), e = end(); i != e; ++i) { 787 for (unsigned ii = 0, ie = i->NumConversions; ii != ie; ++ii) 788 i->Conversions[ii].~ImplicitConversionSequence(); 789 if (!i->Viable && i->FailureKind == ovl_fail_bad_deduction) 790 i->DeductionFailure.Destroy(); 791 } 792} 793 794void OverloadCandidateSet::clear() { 795 destroyCandidates(); 796 NumInlineSequences = 0; 797 Candidates.clear(); 798 Functions.clear(); 799} 800 801namespace { 802 class UnbridgedCastsSet { 803 struct Entry { 804 Expr **Addr; 805 Expr *Saved; 806 }; 807 SmallVector<Entry, 2> Entries; 808 809 public: 810 void save(Sema &S, Expr *&E) { 811 assert(E->hasPlaceholderType(BuiltinType::ARCUnbridgedCast)); 812 Entry entry = { &E, E }; 813 Entries.push_back(entry); 814 E = S.stripARCUnbridgedCast(E); 815 } 816 817 void restore() { 818 for (SmallVectorImpl<Entry>::iterator 819 i = Entries.begin(), e = Entries.end(); i != e; ++i) 820 *i->Addr = i->Saved; 821 } 822 }; 823} 824 825/// checkPlaceholderForOverload - Do any interesting placeholder-like 826/// preprocessing on the given expression. 827/// 828/// \param unbridgedCasts a collection to which to add unbridged casts; 829/// without this, they will be immediately diagnosed as errors 830/// 831/// Return true on unrecoverable error. 832static bool checkPlaceholderForOverload(Sema &S, Expr *&E, 833 UnbridgedCastsSet *unbridgedCasts = 0) { 834 if (const BuiltinType *placeholder = E->getType()->getAsPlaceholderType()) { 835 // We can't handle overloaded expressions here because overload 836 // resolution might reasonably tweak them. 837 if (placeholder->getKind() == BuiltinType::Overload) return false; 838 839 // If the context potentially accepts unbridged ARC casts, strip 840 // the unbridged cast and add it to the collection for later restoration. 841 if (placeholder->getKind() == BuiltinType::ARCUnbridgedCast && 842 unbridgedCasts) { 843 unbridgedCasts->save(S, E); 844 return false; 845 } 846 847 // Go ahead and check everything else. 848 ExprResult result = S.CheckPlaceholderExpr(E); 849 if (result.isInvalid()) 850 return true; 851 852 E = result.take(); 853 return false; 854 } 855 856 // Nothing to do. 857 return false; 858} 859 860/// checkArgPlaceholdersForOverload - Check a set of call operands for 861/// placeholders. 862static bool checkArgPlaceholdersForOverload(Sema &S, 863 MultiExprArg Args, 864 UnbridgedCastsSet &unbridged) { 865 for (unsigned i = 0, e = Args.size(); i != e; ++i) 866 if (checkPlaceholderForOverload(S, Args[i], &unbridged)) 867 return true; 868 869 return false; 870} 871 872// IsOverload - Determine whether the given New declaration is an 873// overload of the declarations in Old. This routine returns false if 874// New and Old cannot be overloaded, e.g., if New has the same 875// signature as some function in Old (C++ 1.3.10) or if the Old 876// declarations aren't functions (or function templates) at all. When 877// it does return false, MatchedDecl will point to the decl that New 878// cannot be overloaded with. This decl may be a UsingShadowDecl on 879// top of the underlying declaration. 880// 881// Example: Given the following input: 882// 883// void f(int, float); // #1 884// void f(int, int); // #2 885// int f(int, int); // #3 886// 887// When we process #1, there is no previous declaration of "f", 888// so IsOverload will not be used. 889// 890// When we process #2, Old contains only the FunctionDecl for #1. By 891// comparing the parameter types, we see that #1 and #2 are overloaded 892// (since they have different signatures), so this routine returns 893// false; MatchedDecl is unchanged. 894// 895// When we process #3, Old is an overload set containing #1 and #2. We 896// compare the signatures of #3 to #1 (they're overloaded, so we do 897// nothing) and then #3 to #2. Since the signatures of #3 and #2 are 898// identical (return types of functions are not part of the 899// signature), IsOverload returns false and MatchedDecl will be set to 900// point to the FunctionDecl for #2. 901// 902// 'NewIsUsingShadowDecl' indicates that 'New' is being introduced 903// into a class by a using declaration. The rules for whether to hide 904// shadow declarations ignore some properties which otherwise figure 905// into a function template's signature. 906Sema::OverloadKind 907Sema::CheckOverload(Scope *S, FunctionDecl *New, const LookupResult &Old, 908 NamedDecl *&Match, bool NewIsUsingDecl) { 909 for (LookupResult::iterator I = Old.begin(), E = Old.end(); 910 I != E; ++I) { 911 NamedDecl *OldD = *I; 912 913 bool OldIsUsingDecl = false; 914 if (isa<UsingShadowDecl>(OldD)) { 915 OldIsUsingDecl = true; 916 917 // We can always introduce two using declarations into the same 918 // context, even if they have identical signatures. 919 if (NewIsUsingDecl) continue; 920 921 OldD = cast<UsingShadowDecl>(OldD)->getTargetDecl(); 922 } 923 924 // If either declaration was introduced by a using declaration, 925 // we'll need to use slightly different rules for matching. 926 // Essentially, these rules are the normal rules, except that 927 // function templates hide function templates with different 928 // return types or template parameter lists. 929 bool UseMemberUsingDeclRules = 930 (OldIsUsingDecl || NewIsUsingDecl) && CurContext->isRecord() && 931 !New->getFriendObjectKind(); 932 933 if (FunctionTemplateDecl *OldT = dyn_cast<FunctionTemplateDecl>(OldD)) { 934 if (!IsOverload(New, OldT->getTemplatedDecl(), UseMemberUsingDeclRules)) { 935 if (UseMemberUsingDeclRules && OldIsUsingDecl) { 936 HideUsingShadowDecl(S, cast<UsingShadowDecl>(*I)); 937 continue; 938 } 939 940 Match = *I; 941 return Ovl_Match; 942 } 943 } else if (FunctionDecl *OldF = dyn_cast<FunctionDecl>(OldD)) { 944 if (!IsOverload(New, OldF, UseMemberUsingDeclRules)) { 945 if (UseMemberUsingDeclRules && OldIsUsingDecl) { 946 HideUsingShadowDecl(S, cast<UsingShadowDecl>(*I)); 947 continue; 948 } 949 950 if (!shouldLinkPossiblyHiddenDecl(*I, New)) 951 continue; 952 953 Match = *I; 954 return Ovl_Match; 955 } 956 } else if (isa<UsingDecl>(OldD)) { 957 // We can overload with these, which can show up when doing 958 // redeclaration checks for UsingDecls. 959 assert(Old.getLookupKind() == LookupUsingDeclName); 960 } else if (isa<TagDecl>(OldD)) { 961 // We can always overload with tags by hiding them. 962 } else if (isa<UnresolvedUsingValueDecl>(OldD)) { 963 // Optimistically assume that an unresolved using decl will 964 // overload; if it doesn't, we'll have to diagnose during 965 // template instantiation. 966 } else { 967 // (C++ 13p1): 968 // Only function declarations can be overloaded; object and type 969 // declarations cannot be overloaded. 970 Match = *I; 971 return Ovl_NonFunction; 972 } 973 } 974 975 return Ovl_Overload; 976} 977 978bool Sema::IsOverload(FunctionDecl *New, FunctionDecl *Old, 979 bool UseUsingDeclRules) { 980 // C++ [basic.start.main]p2: This function shall not be overloaded. 981 if (New->isMain()) 982 return false; 983 984 // MSVCRT user defined entry points cannot be overloaded. 985 if (New->isMSVCRTEntryPoint()) 986 return false; 987 988 FunctionTemplateDecl *OldTemplate = Old->getDescribedFunctionTemplate(); 989 FunctionTemplateDecl *NewTemplate = New->getDescribedFunctionTemplate(); 990 991 // C++ [temp.fct]p2: 992 // A function template can be overloaded with other function templates 993 // and with normal (non-template) functions. 994 if ((OldTemplate == 0) != (NewTemplate == 0)) 995 return true; 996 997 // Is the function New an overload of the function Old? 998 QualType OldQType = Context.getCanonicalType(Old->getType()); 999 QualType NewQType = Context.getCanonicalType(New->getType()); 1000 1001 // Compare the signatures (C++ 1.3.10) of the two functions to 1002 // determine whether they are overloads. If we find any mismatch 1003 // in the signature, they are overloads. 1004 1005 // If either of these functions is a K&R-style function (no 1006 // prototype), then we consider them to have matching signatures. 1007 if (isa<FunctionNoProtoType>(OldQType.getTypePtr()) || 1008 isa<FunctionNoProtoType>(NewQType.getTypePtr())) 1009 return false; 1010 1011 const FunctionProtoType* OldType = cast<FunctionProtoType>(OldQType); 1012 const FunctionProtoType* NewType = cast<FunctionProtoType>(NewQType); 1013 1014 // The signature of a function includes the types of its 1015 // parameters (C++ 1.3.10), which includes the presence or absence 1016 // of the ellipsis; see C++ DR 357). 1017 if (OldQType != NewQType && 1018 (OldType->getNumArgs() != NewType->getNumArgs() || 1019 OldType->isVariadic() != NewType->isVariadic() || 1020 !FunctionArgTypesAreEqual(OldType, NewType))) 1021 return true; 1022 1023 // C++ [temp.over.link]p4: 1024 // The signature of a function template consists of its function 1025 // signature, its return type and its template parameter list. The names 1026 // of the template parameters are significant only for establishing the 1027 // relationship between the template parameters and the rest of the 1028 // signature. 1029 // 1030 // We check the return type and template parameter lists for function 1031 // templates first; the remaining checks follow. 1032 // 1033 // However, we don't consider either of these when deciding whether 1034 // a member introduced by a shadow declaration is hidden. 1035 if (!UseUsingDeclRules && NewTemplate && 1036 (!TemplateParameterListsAreEqual(NewTemplate->getTemplateParameters(), 1037 OldTemplate->getTemplateParameters(), 1038 false, TPL_TemplateMatch) || 1039 OldType->getResultType() != NewType->getResultType())) 1040 return true; 1041 1042 // If the function is a class member, its signature includes the 1043 // cv-qualifiers (if any) and ref-qualifier (if any) on the function itself. 1044 // 1045 // As part of this, also check whether one of the member functions 1046 // is static, in which case they are not overloads (C++ 1047 // 13.1p2). While not part of the definition of the signature, 1048 // this check is important to determine whether these functions 1049 // can be overloaded. 1050 CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old); 1051 CXXMethodDecl *NewMethod = dyn_cast<CXXMethodDecl>(New); 1052 if (OldMethod && NewMethod && 1053 !OldMethod->isStatic() && !NewMethod->isStatic()) { 1054 if (OldMethod->getRefQualifier() != NewMethod->getRefQualifier()) { 1055 if (!UseUsingDeclRules && 1056 (OldMethod->getRefQualifier() == RQ_None || 1057 NewMethod->getRefQualifier() == RQ_None)) { 1058 // C++0x [over.load]p2: 1059 // - Member function declarations with the same name and the same 1060 // parameter-type-list as well as member function template 1061 // declarations with the same name, the same parameter-type-list, and 1062 // the same template parameter lists cannot be overloaded if any of 1063 // them, but not all, have a ref-qualifier (8.3.5). 1064 Diag(NewMethod->getLocation(), diag::err_ref_qualifier_overload) 1065 << NewMethod->getRefQualifier() << OldMethod->getRefQualifier(); 1066 Diag(OldMethod->getLocation(), diag::note_previous_declaration); 1067 } 1068 return true; 1069 } 1070 1071 // We may not have applied the implicit const for a constexpr member 1072 // function yet (because we haven't yet resolved whether this is a static 1073 // or non-static member function). Add it now, on the assumption that this 1074 // is a redeclaration of OldMethod. 1075 unsigned OldQuals = OldMethod->getTypeQualifiers(); 1076 unsigned NewQuals = NewMethod->getTypeQualifiers(); 1077 if (!getLangOpts().CPlusPlus1y && NewMethod->isConstexpr() && 1078 !isa<CXXConstructorDecl>(NewMethod)) 1079 NewQuals |= Qualifiers::Const; 1080 1081 // We do not allow overloading based off of '__restrict'. 1082 OldQuals &= ~Qualifiers::Restrict; 1083 NewQuals &= ~Qualifiers::Restrict; 1084 if (OldQuals != NewQuals) 1085 return true; 1086 } 1087 1088 // The signatures match; this is not an overload. 1089 return false; 1090} 1091 1092/// \brief Checks availability of the function depending on the current 1093/// function context. Inside an unavailable function, unavailability is ignored. 1094/// 1095/// \returns true if \arg FD is unavailable and current context is inside 1096/// an available function, false otherwise. 1097bool Sema::isFunctionConsideredUnavailable(FunctionDecl *FD) { 1098 return FD->isUnavailable() && !cast<Decl>(CurContext)->isUnavailable(); 1099} 1100 1101/// \brief Tries a user-defined conversion from From to ToType. 1102/// 1103/// Produces an implicit conversion sequence for when a standard conversion 1104/// is not an option. See TryImplicitConversion for more information. 1105static ImplicitConversionSequence 1106TryUserDefinedConversion(Sema &S, Expr *From, QualType ToType, 1107 bool SuppressUserConversions, 1108 bool AllowExplicit, 1109 bool InOverloadResolution, 1110 bool CStyle, 1111 bool AllowObjCWritebackConversion, 1112 bool AllowObjCConversionOnExplicit) { 1113 ImplicitConversionSequence ICS; 1114 1115 if (SuppressUserConversions) { 1116 // We're not in the case above, so there is no conversion that 1117 // we can perform. 1118 ICS.setBad(BadConversionSequence::no_conversion, From, ToType); 1119 return ICS; 1120 } 1121 1122 // Attempt user-defined conversion. 1123 OverloadCandidateSet Conversions(From->getExprLoc()); 1124 OverloadingResult UserDefResult 1125 = IsUserDefinedConversion(S, From, ToType, ICS.UserDefined, Conversions, 1126 AllowExplicit, AllowObjCConversionOnExplicit); 1127 1128 if (UserDefResult == OR_Success) { 1129 ICS.setUserDefined(); 1130 // C++ [over.ics.user]p4: 1131 // A conversion of an expression of class type to the same class 1132 // type is given Exact Match rank, and a conversion of an 1133 // expression of class type to a base class of that type is 1134 // given Conversion rank, in spite of the fact that a copy 1135 // constructor (i.e., a user-defined conversion function) is 1136 // called for those cases. 1137 if (CXXConstructorDecl *Constructor 1138 = dyn_cast<CXXConstructorDecl>(ICS.UserDefined.ConversionFunction)) { 1139 QualType FromCanon 1140 = S.Context.getCanonicalType(From->getType().getUnqualifiedType()); 1141 QualType ToCanon 1142 = S.Context.getCanonicalType(ToType).getUnqualifiedType(); 1143 if (Constructor->isCopyConstructor() && 1144 (FromCanon == ToCanon || S.IsDerivedFrom(FromCanon, ToCanon))) { 1145 // Turn this into a "standard" conversion sequence, so that it 1146 // gets ranked with standard conversion sequences. 1147 ICS.setStandard(); 1148 ICS.Standard.setAsIdentityConversion(); 1149 ICS.Standard.setFromType(From->getType()); 1150 ICS.Standard.setAllToTypes(ToType); 1151 ICS.Standard.CopyConstructor = Constructor; 1152 if (ToCanon != FromCanon) 1153 ICS.Standard.Second = ICK_Derived_To_Base; 1154 } 1155 } 1156 1157 // C++ [over.best.ics]p4: 1158 // However, when considering the argument of a user-defined 1159 // conversion function that is a candidate by 13.3.1.3 when 1160 // invoked for the copying of the temporary in the second step 1161 // of a class copy-initialization, or by 13.3.1.4, 13.3.1.5, or 1162 // 13.3.1.6 in all cases, only standard conversion sequences and 1163 // ellipsis conversion sequences are allowed. 1164 if (SuppressUserConversions && ICS.isUserDefined()) { 1165 ICS.setBad(BadConversionSequence::suppressed_user, From, ToType); 1166 } 1167 } else if (UserDefResult == OR_Ambiguous && !SuppressUserConversions) { 1168 ICS.setAmbiguous(); 1169 ICS.Ambiguous.setFromType(From->getType()); 1170 ICS.Ambiguous.setToType(ToType); 1171 for (OverloadCandidateSet::iterator Cand = Conversions.begin(); 1172 Cand != Conversions.end(); ++Cand) 1173 if (Cand->Viable) 1174 ICS.Ambiguous.addConversion(Cand->Function); 1175 } else { 1176 ICS.setBad(BadConversionSequence::no_conversion, From, ToType); 1177 } 1178 1179 return ICS; 1180} 1181 1182/// TryImplicitConversion - Attempt to perform an implicit conversion 1183/// from the given expression (Expr) to the given type (ToType). This 1184/// function returns an implicit conversion sequence that can be used 1185/// to perform the initialization. Given 1186/// 1187/// void f(float f); 1188/// void g(int i) { f(i); } 1189/// 1190/// this routine would produce an implicit conversion sequence to 1191/// describe the initialization of f from i, which will be a standard 1192/// conversion sequence containing an lvalue-to-rvalue conversion (C++ 1193/// 4.1) followed by a floating-integral conversion (C++ 4.9). 1194// 1195/// Note that this routine only determines how the conversion can be 1196/// performed; it does not actually perform the conversion. As such, 1197/// it will not produce any diagnostics if no conversion is available, 1198/// but will instead return an implicit conversion sequence of kind 1199/// "BadConversion". 1200/// 1201/// If @p SuppressUserConversions, then user-defined conversions are 1202/// not permitted. 1203/// If @p AllowExplicit, then explicit user-defined conversions are 1204/// permitted. 1205/// 1206/// \param AllowObjCWritebackConversion Whether we allow the Objective-C 1207/// writeback conversion, which allows __autoreleasing id* parameters to 1208/// be initialized with __strong id* or __weak id* arguments. 1209static ImplicitConversionSequence 1210TryImplicitConversion(Sema &S, Expr *From, QualType ToType, 1211 bool SuppressUserConversions, 1212 bool AllowExplicit, 1213 bool InOverloadResolution, 1214 bool CStyle, 1215 bool AllowObjCWritebackConversion, 1216 bool AllowObjCConversionOnExplicit) { 1217 ImplicitConversionSequence ICS; 1218 if (IsStandardConversion(S, From, ToType, InOverloadResolution, 1219 ICS.Standard, CStyle, AllowObjCWritebackConversion)){ 1220 ICS.setStandard(); 1221 return ICS; 1222 } 1223 1224 if (!S.getLangOpts().CPlusPlus) { 1225 ICS.setBad(BadConversionSequence::no_conversion, From, ToType); 1226 return ICS; 1227 } 1228 1229 // C++ [over.ics.user]p4: 1230 // A conversion of an expression of class type to the same class 1231 // type is given Exact Match rank, and a conversion of an 1232 // expression of class type to a base class of that type is 1233 // given Conversion rank, in spite of the fact that a copy/move 1234 // constructor (i.e., a user-defined conversion function) is 1235 // called for those cases. 1236 QualType FromType = From->getType(); 1237 if (ToType->getAs<RecordType>() && FromType->getAs<RecordType>() && 1238 (S.Context.hasSameUnqualifiedType(FromType, ToType) || 1239 S.IsDerivedFrom(FromType, ToType))) { 1240 ICS.setStandard(); 1241 ICS.Standard.setAsIdentityConversion(); 1242 ICS.Standard.setFromType(FromType); 1243 ICS.Standard.setAllToTypes(ToType); 1244 1245 // We don't actually check at this point whether there is a valid 1246 // copy/move constructor, since overloading just assumes that it 1247 // exists. When we actually perform initialization, we'll find the 1248 // appropriate constructor to copy the returned object, if needed. 1249 ICS.Standard.CopyConstructor = 0; 1250 1251 // Determine whether this is considered a derived-to-base conversion. 1252 if (!S.Context.hasSameUnqualifiedType(FromType, ToType)) 1253 ICS.Standard.Second = ICK_Derived_To_Base; 1254 1255 return ICS; 1256 } 1257 1258 return TryUserDefinedConversion(S, From, ToType, SuppressUserConversions, 1259 AllowExplicit, InOverloadResolution, CStyle, 1260 AllowObjCWritebackConversion, 1261 AllowObjCConversionOnExplicit); 1262} 1263 1264ImplicitConversionSequence 1265Sema::TryImplicitConversion(Expr *From, QualType ToType, 1266 bool SuppressUserConversions, 1267 bool AllowExplicit, 1268 bool InOverloadResolution, 1269 bool CStyle, 1270 bool AllowObjCWritebackConversion) { 1271 return clang::TryImplicitConversion(*this, From, ToType, 1272 SuppressUserConversions, AllowExplicit, 1273 InOverloadResolution, CStyle, 1274 AllowObjCWritebackConversion, 1275 /*AllowObjCConversionOnExplicit=*/false); 1276} 1277 1278/// PerformImplicitConversion - Perform an implicit conversion of the 1279/// expression From to the type ToType. Returns the 1280/// converted expression. Flavor is the kind of conversion we're 1281/// performing, used in the error message. If @p AllowExplicit, 1282/// explicit user-defined conversions are permitted. 1283ExprResult 1284Sema::PerformImplicitConversion(Expr *From, QualType ToType, 1285 AssignmentAction Action, bool AllowExplicit) { 1286 ImplicitConversionSequence ICS; 1287 return PerformImplicitConversion(From, ToType, Action, AllowExplicit, ICS); 1288} 1289 1290ExprResult 1291Sema::PerformImplicitConversion(Expr *From, QualType ToType, 1292 AssignmentAction Action, bool AllowExplicit, 1293 ImplicitConversionSequence& ICS) { 1294 if (checkPlaceholderForOverload(*this, From)) 1295 return ExprError(); 1296 1297 // Objective-C ARC: Determine whether we will allow the writeback conversion. 1298 bool AllowObjCWritebackConversion 1299 = getLangOpts().ObjCAutoRefCount && 1300 (Action == AA_Passing || Action == AA_Sending); 1301 1302 ICS = clang::TryImplicitConversion(*this, From, ToType, 1303 /*SuppressUserConversions=*/false, 1304 AllowExplicit, 1305 /*InOverloadResolution=*/false, 1306 /*CStyle=*/false, 1307 AllowObjCWritebackConversion, 1308 /*AllowObjCConversionOnExplicit=*/false); 1309 return PerformImplicitConversion(From, ToType, ICS, Action); 1310} 1311 1312/// \brief Determine whether the conversion from FromType to ToType is a valid 1313/// conversion that strips "noreturn" off the nested function type. 1314bool Sema::IsNoReturnConversion(QualType FromType, QualType ToType, 1315 QualType &ResultTy) { 1316 if (Context.hasSameUnqualifiedType(FromType, ToType)) 1317 return false; 1318 1319 // Permit the conversion F(t __attribute__((noreturn))) -> F(t) 1320 // where F adds one of the following at most once: 1321 // - a pointer 1322 // - a member pointer 1323 // - a block pointer 1324 CanQualType CanTo = Context.getCanonicalType(ToType); 1325 CanQualType CanFrom = Context.getCanonicalType(FromType); 1326 Type::TypeClass TyClass = CanTo->getTypeClass(); 1327 if (TyClass != CanFrom->getTypeClass()) return false; 1328 if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto) { 1329 if (TyClass == Type::Pointer) { 1330 CanTo = CanTo.getAs<PointerType>()->getPointeeType(); 1331 CanFrom = CanFrom.getAs<PointerType>()->getPointeeType(); 1332 } else if (TyClass == Type::BlockPointer) { 1333 CanTo = CanTo.getAs<BlockPointerType>()->getPointeeType(); 1334 CanFrom = CanFrom.getAs<BlockPointerType>()->getPointeeType(); 1335 } else if (TyClass == Type::MemberPointer) { 1336 CanTo = CanTo.getAs<MemberPointerType>()->getPointeeType(); 1337 CanFrom = CanFrom.getAs<MemberPointerType>()->getPointeeType(); 1338 } else { 1339 return false; 1340 } 1341 1342 TyClass = CanTo->getTypeClass(); 1343 if (TyClass != CanFrom->getTypeClass()) return false; 1344 if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto) 1345 return false; 1346 } 1347 1348 const FunctionType *FromFn = cast<FunctionType>(CanFrom); 1349 FunctionType::ExtInfo EInfo = FromFn->getExtInfo(); 1350 if (!EInfo.getNoReturn()) return false; 1351 1352 FromFn = Context.adjustFunctionType(FromFn, EInfo.withNoReturn(false)); 1353 assert(QualType(FromFn, 0).isCanonical()); 1354 if (QualType(FromFn, 0) != CanTo) return false; 1355 1356 ResultTy = ToType; 1357 return true; 1358} 1359 1360/// \brief Determine whether the conversion from FromType to ToType is a valid 1361/// vector conversion. 1362/// 1363/// \param ICK Will be set to the vector conversion kind, if this is a vector 1364/// conversion. 1365static bool IsVectorConversion(ASTContext &Context, QualType FromType, 1366 QualType ToType, ImplicitConversionKind &ICK) { 1367 // We need at least one of these types to be a vector type to have a vector 1368 // conversion. 1369 if (!ToType->isVectorType() && !FromType->isVectorType()) 1370 return false; 1371 1372 // Identical types require no conversions. 1373 if (Context.hasSameUnqualifiedType(FromType, ToType)) 1374 return false; 1375 1376 // There are no conversions between extended vector types, only identity. 1377 if (ToType->isExtVectorType()) { 1378 // There are no conversions between extended vector types other than the 1379 // identity conversion. 1380 if (FromType->isExtVectorType()) 1381 return false; 1382 1383 // Vector splat from any arithmetic type to a vector. 1384 if (FromType->isArithmeticType()) { 1385 ICK = ICK_Vector_Splat; 1386 return true; 1387 } 1388 } 1389 1390 // We can perform the conversion between vector types in the following cases: 1391 // 1)vector types are equivalent AltiVec and GCC vector types 1392 // 2)lax vector conversions are permitted and the vector types are of the 1393 // same size 1394 if (ToType->isVectorType() && FromType->isVectorType()) { 1395 if (Context.areCompatibleVectorTypes(FromType, ToType) || 1396 (Context.getLangOpts().LaxVectorConversions && 1397 (Context.getTypeSize(FromType) == Context.getTypeSize(ToType)))) { 1398 ICK = ICK_Vector_Conversion; 1399 return true; 1400 } 1401 } 1402 1403 return false; 1404} 1405 1406static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType, 1407 bool InOverloadResolution, 1408 StandardConversionSequence &SCS, 1409 bool CStyle); 1410 1411/// IsStandardConversion - Determines whether there is a standard 1412/// conversion sequence (C++ [conv], C++ [over.ics.scs]) from the 1413/// expression From to the type ToType. Standard conversion sequences 1414/// only consider non-class types; for conversions that involve class 1415/// types, use TryImplicitConversion. If a conversion exists, SCS will 1416/// contain the standard conversion sequence required to perform this 1417/// conversion and this routine will return true. Otherwise, this 1418/// routine will return false and the value of SCS is unspecified. 1419static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType, 1420 bool InOverloadResolution, 1421 StandardConversionSequence &SCS, 1422 bool CStyle, 1423 bool AllowObjCWritebackConversion) { 1424 QualType FromType = From->getType(); 1425 1426 // Standard conversions (C++ [conv]) 1427 SCS.setAsIdentityConversion(); 1428 SCS.DeprecatedStringLiteralToCharPtr = false; 1429 SCS.IncompatibleObjC = false; 1430 SCS.setFromType(FromType); 1431 SCS.CopyConstructor = 0; 1432 1433 // There are no standard conversions for class types in C++, so 1434 // abort early. When overloading in C, however, we do permit 1435 if (FromType->isRecordType() || ToType->isRecordType()) { 1436 if (S.getLangOpts().CPlusPlus) 1437 return false; 1438 1439 // When we're overloading in C, we allow, as standard conversions, 1440 } 1441 1442 // The first conversion can be an lvalue-to-rvalue conversion, 1443 // array-to-pointer conversion, or function-to-pointer conversion 1444 // (C++ 4p1). 1445 1446 if (FromType == S.Context.OverloadTy) { 1447 DeclAccessPair AccessPair; 1448 if (FunctionDecl *Fn 1449 = S.ResolveAddressOfOverloadedFunction(From, ToType, false, 1450 AccessPair)) { 1451 // We were able to resolve the address of the overloaded function, 1452 // so we can convert to the type of that function. 1453 FromType = Fn->getType(); 1454 1455 // we can sometimes resolve &foo<int> regardless of ToType, so check 1456 // if the type matches (identity) or we are converting to bool 1457 if (!S.Context.hasSameUnqualifiedType( 1458 S.ExtractUnqualifiedFunctionType(ToType), FromType)) { 1459 QualType resultTy; 1460 // if the function type matches except for [[noreturn]], it's ok 1461 if (!S.IsNoReturnConversion(FromType, 1462 S.ExtractUnqualifiedFunctionType(ToType), resultTy)) 1463 // otherwise, only a boolean conversion is standard 1464 if (!ToType->isBooleanType()) 1465 return false; 1466 } 1467 1468 // Check if the "from" expression is taking the address of an overloaded 1469 // function and recompute the FromType accordingly. Take advantage of the 1470 // fact that non-static member functions *must* have such an address-of 1471 // expression. 1472 CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn); 1473 if (Method && !Method->isStatic()) { 1474 assert(isa<UnaryOperator>(From->IgnoreParens()) && 1475 "Non-unary operator on non-static member address"); 1476 assert(cast<UnaryOperator>(From->IgnoreParens())->getOpcode() 1477 == UO_AddrOf && 1478 "Non-address-of operator on non-static member address"); 1479 const Type *ClassType 1480 = S.Context.getTypeDeclType(Method->getParent()).getTypePtr(); 1481 FromType = S.Context.getMemberPointerType(FromType, ClassType); 1482 } else if (isa<UnaryOperator>(From->IgnoreParens())) { 1483 assert(cast<UnaryOperator>(From->IgnoreParens())->getOpcode() == 1484 UO_AddrOf && 1485 "Non-address-of operator for overloaded function expression"); 1486 FromType = S.Context.getPointerType(FromType); 1487 } 1488 1489 // Check that we've computed the proper type after overload resolution. 1490 assert(S.Context.hasSameType( 1491 FromType, 1492 S.FixOverloadedFunctionReference(From, AccessPair, Fn)->getType())); 1493 } else { 1494 return false; 1495 } 1496 } 1497 // Lvalue-to-rvalue conversion (C++11 4.1): 1498 // A glvalue (3.10) of a non-function, non-array type T can 1499 // be converted to a prvalue. 1500 bool argIsLValue = From->isGLValue(); 1501 if (argIsLValue && 1502 !FromType->isFunctionType() && !FromType->isArrayType() && 1503 S.Context.getCanonicalType(FromType) != S.Context.OverloadTy) { 1504 SCS.First = ICK_Lvalue_To_Rvalue; 1505 1506 // C11 6.3.2.1p2: 1507 // ... if the lvalue has atomic type, the value has the non-atomic version 1508 // of the type of the lvalue ... 1509 if (const AtomicType *Atomic = FromType->getAs<AtomicType>()) 1510 FromType = Atomic->getValueType(); 1511 1512 // If T is a non-class type, the type of the rvalue is the 1513 // cv-unqualified version of T. Otherwise, the type of the rvalue 1514 // is T (C++ 4.1p1). C++ can't get here with class types; in C, we 1515 // just strip the qualifiers because they don't matter. 1516 FromType = FromType.getUnqualifiedType(); 1517 } else if (FromType->isArrayType()) { 1518 // Array-to-pointer conversion (C++ 4.2) 1519 SCS.First = ICK_Array_To_Pointer; 1520 1521 // An lvalue or rvalue of type "array of N T" or "array of unknown 1522 // bound of T" can be converted to an rvalue of type "pointer to 1523 // T" (C++ 4.2p1). 1524 FromType = S.Context.getArrayDecayedType(FromType); 1525 1526 if (S.IsStringLiteralToNonConstPointerConversion(From, ToType)) { 1527 // This conversion is deprecated. (C++ D.4). 1528 SCS.DeprecatedStringLiteralToCharPtr = true; 1529 1530 // For the purpose of ranking in overload resolution 1531 // (13.3.3.1.1), this conversion is considered an 1532 // array-to-pointer conversion followed by a qualification 1533 // conversion (4.4). (C++ 4.2p2) 1534 SCS.Second = ICK_Identity; 1535 SCS.Third = ICK_Qualification; 1536 SCS.QualificationIncludesObjCLifetime = false; 1537 SCS.setAllToTypes(FromType); 1538 return true; 1539 } 1540 } else if (FromType->isFunctionType() && argIsLValue) { 1541 // Function-to-pointer conversion (C++ 4.3). 1542 SCS.First = ICK_Function_To_Pointer; 1543 1544 // An lvalue of function type T can be converted to an rvalue of 1545 // type "pointer to T." The result is a pointer to the 1546 // function. (C++ 4.3p1). 1547 FromType = S.Context.getPointerType(FromType); 1548 } else { 1549 // We don't require any conversions for the first step. 1550 SCS.First = ICK_Identity; 1551 } 1552 SCS.setToType(0, FromType); 1553 1554 // The second conversion can be an integral promotion, floating 1555 // point promotion, integral conversion, floating point conversion, 1556 // floating-integral conversion, pointer conversion, 1557 // pointer-to-member conversion, or boolean conversion (C++ 4p1). 1558 // For overloading in C, this can also be a "compatible-type" 1559 // conversion. 1560 bool IncompatibleObjC = false; 1561 ImplicitConversionKind SecondICK = ICK_Identity; 1562 if (S.Context.hasSameUnqualifiedType(FromType, ToType)) { 1563 // The unqualified versions of the types are the same: there's no 1564 // conversion to do. 1565 SCS.Second = ICK_Identity; 1566 } else if (S.IsIntegralPromotion(From, FromType, ToType)) { 1567 // Integral promotion (C++ 4.5). 1568 SCS.Second = ICK_Integral_Promotion; 1569 FromType = ToType.getUnqualifiedType(); 1570 } else if (S.IsFloatingPointPromotion(FromType, ToType)) { 1571 // Floating point promotion (C++ 4.6). 1572 SCS.Second = ICK_Floating_Promotion; 1573 FromType = ToType.getUnqualifiedType(); 1574 } else if (S.IsComplexPromotion(FromType, ToType)) { 1575 // Complex promotion (Clang extension) 1576 SCS.Second = ICK_Complex_Promotion; 1577 FromType = ToType.getUnqualifiedType(); 1578 } else if (ToType->isBooleanType() && 1579 (FromType->isArithmeticType() || 1580 FromType->isAnyPointerType() || 1581 FromType->isBlockPointerType() || 1582 FromType->isMemberPointerType() || 1583 FromType->isNullPtrType())) { 1584 // Boolean conversions (C++ 4.12). 1585 SCS.Second = ICK_Boolean_Conversion; 1586 FromType = S.Context.BoolTy; 1587 } else if (FromType->isIntegralOrUnscopedEnumerationType() && 1588 ToType->isIntegralType(S.Context)) { 1589 // Integral conversions (C++ 4.7). 1590 SCS.Second = ICK_Integral_Conversion; 1591 FromType = ToType.getUnqualifiedType(); 1592 } else if (FromType->isAnyComplexType() && ToType->isAnyComplexType()) { 1593 // Complex conversions (C99 6.3.1.6) 1594 SCS.Second = ICK_Complex_Conversion; 1595 FromType = ToType.getUnqualifiedType(); 1596 } else if ((FromType->isAnyComplexType() && ToType->isArithmeticType()) || 1597 (ToType->isAnyComplexType() && FromType->isArithmeticType())) { 1598 // Complex-real conversions (C99 6.3.1.7) 1599 SCS.Second = ICK_Complex_Real; 1600 FromType = ToType.getUnqualifiedType(); 1601 } else if (FromType->isRealFloatingType() && ToType->isRealFloatingType()) { 1602 // Floating point conversions (C++ 4.8). 1603 SCS.Second = ICK_Floating_Conversion; 1604 FromType = ToType.getUnqualifiedType(); 1605 } else if ((FromType->isRealFloatingType() && 1606 ToType->isIntegralType(S.Context)) || 1607 (FromType->isIntegralOrUnscopedEnumerationType() && 1608 ToType->isRealFloatingType())) { 1609 // Floating-integral conversions (C++ 4.9). 1610 SCS.Second = ICK_Floating_Integral; 1611 FromType = ToType.getUnqualifiedType(); 1612 } else if (S.IsBlockPointerConversion(FromType, ToType, FromType)) { 1613 SCS.Second = ICK_Block_Pointer_Conversion; 1614 } else if (AllowObjCWritebackConversion && 1615 S.isObjCWritebackConversion(FromType, ToType, FromType)) { 1616 SCS.Second = ICK_Writeback_Conversion; 1617 } else if (S.IsPointerConversion(From, FromType, ToType, InOverloadResolution, 1618 FromType, IncompatibleObjC)) { 1619 // Pointer conversions (C++ 4.10). 1620 SCS.Second = ICK_Pointer_Conversion; 1621 SCS.IncompatibleObjC = IncompatibleObjC; 1622 FromType = FromType.getUnqualifiedType(); 1623 } else if (S.IsMemberPointerConversion(From, FromType, ToType, 1624 InOverloadResolution, FromType)) { 1625 // Pointer to member conversions (4.11). 1626 SCS.Second = ICK_Pointer_Member; 1627 } else if (IsVectorConversion(S.Context, FromType, ToType, SecondICK)) { 1628 SCS.Second = SecondICK; 1629 FromType = ToType.getUnqualifiedType(); 1630 } else if (!S.getLangOpts().CPlusPlus && 1631 S.Context.typesAreCompatible(ToType, FromType)) { 1632 // Compatible conversions (Clang extension for C function overloading) 1633 SCS.Second = ICK_Compatible_Conversion; 1634 FromType = ToType.getUnqualifiedType(); 1635 } else if (S.IsNoReturnConversion(FromType, ToType, FromType)) { 1636 // Treat a conversion that strips "noreturn" as an identity conversion. 1637 SCS.Second = ICK_NoReturn_Adjustment; 1638 } else if (IsTransparentUnionStandardConversion(S, From, ToType, 1639 InOverloadResolution, 1640 SCS, CStyle)) { 1641 SCS.Second = ICK_TransparentUnionConversion; 1642 FromType = ToType; 1643 } else if (tryAtomicConversion(S, From, ToType, InOverloadResolution, SCS, 1644 CStyle)) { 1645 // tryAtomicConversion has updated the standard conversion sequence 1646 // appropriately. 1647 return true; 1648 } else if (ToType->isEventT() && 1649 From->isIntegerConstantExpr(S.getASTContext()) && 1650 (From->EvaluateKnownConstInt(S.getASTContext()) == 0)) { 1651 SCS.Second = ICK_Zero_Event_Conversion; 1652 FromType = ToType; 1653 } else { 1654 // No second conversion required. 1655 SCS.Second = ICK_Identity; 1656 } 1657 SCS.setToType(1, FromType); 1658 1659 QualType CanonFrom; 1660 QualType CanonTo; 1661 // The third conversion can be a qualification conversion (C++ 4p1). 1662 bool ObjCLifetimeConversion; 1663 if (S.IsQualificationConversion(FromType, ToType, CStyle, 1664 ObjCLifetimeConversion)) { 1665 SCS.Third = ICK_Qualification; 1666 SCS.QualificationIncludesObjCLifetime = ObjCLifetimeConversion; 1667 FromType = ToType; 1668 CanonFrom = S.Context.getCanonicalType(FromType); 1669 CanonTo = S.Context.getCanonicalType(ToType); 1670 } else { 1671 // No conversion required 1672 SCS.Third = ICK_Identity; 1673 1674 // C++ [over.best.ics]p6: 1675 // [...] Any difference in top-level cv-qualification is 1676 // subsumed by the initialization itself and does not constitute 1677 // a conversion. [...] 1678 CanonFrom = S.Context.getCanonicalType(FromType); 1679 CanonTo = S.Context.getCanonicalType(ToType); 1680 if (CanonFrom.getLocalUnqualifiedType() 1681 == CanonTo.getLocalUnqualifiedType() && 1682 CanonFrom.getLocalQualifiers() != CanonTo.getLocalQualifiers()) { 1683 FromType = ToType; 1684 CanonFrom = CanonTo; 1685 } 1686 } 1687 SCS.setToType(2, FromType); 1688 1689 // If we have not converted the argument type to the parameter type, 1690 // this is a bad conversion sequence. 1691 if (CanonFrom != CanonTo) 1692 return false; 1693 1694 return true; 1695} 1696 1697static bool 1698IsTransparentUnionStandardConversion(Sema &S, Expr* From, 1699 QualType &ToType, 1700 bool InOverloadResolution, 1701 StandardConversionSequence &SCS, 1702 bool CStyle) { 1703 1704 const RecordType *UT = ToType->getAsUnionType(); 1705 if (!UT || !UT->getDecl()->hasAttr<TransparentUnionAttr>()) 1706 return false; 1707 // The field to initialize within the transparent union. 1708 RecordDecl *UD = UT->getDecl(); 1709 // It's compatible if the expression matches any of the fields. 1710 for (RecordDecl::field_iterator it = UD->field_begin(), 1711 itend = UD->field_end(); 1712 it != itend; ++it) { 1713 if (IsStandardConversion(S, From, it->getType(), InOverloadResolution, SCS, 1714 CStyle, /*ObjCWritebackConversion=*/false)) { 1715 ToType = it->getType(); 1716 return true; 1717 } 1718 } 1719 return false; 1720} 1721 1722/// IsIntegralPromotion - Determines whether the conversion from the 1723/// expression From (whose potentially-adjusted type is FromType) to 1724/// ToType is an integral promotion (C++ 4.5). If so, returns true and 1725/// sets PromotedType to the promoted type. 1726bool Sema::IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType) { 1727 const BuiltinType *To = ToType->getAs<BuiltinType>(); 1728 // All integers are built-in. 1729 if (!To) { 1730 return false; 1731 } 1732 1733 // An rvalue of type char, signed char, unsigned char, short int, or 1734 // unsigned short int can be converted to an rvalue of type int if 1735 // int can represent all the values of the source type; otherwise, 1736 // the source rvalue can be converted to an rvalue of type unsigned 1737 // int (C++ 4.5p1). 1738 if (FromType->isPromotableIntegerType() && !FromType->isBooleanType() && 1739 !FromType->isEnumeralType()) { 1740 if (// We can promote any signed, promotable integer type to an int 1741 (FromType->isSignedIntegerType() || 1742 // We can promote any unsigned integer type whose size is 1743 // less than int to an int. 1744 (!FromType->isSignedIntegerType() && 1745 Context.getTypeSize(FromType) < Context.getTypeSize(ToType)))) { 1746 return To->getKind() == BuiltinType::Int; 1747 } 1748 1749 return To->getKind() == BuiltinType::UInt; 1750 } 1751 1752 // C++11 [conv.prom]p3: 1753 // A prvalue of an unscoped enumeration type whose underlying type is not 1754 // fixed (7.2) can be converted to an rvalue a prvalue of the first of the 1755 // following types that can represent all the values of the enumeration 1756 // (i.e., the values in the range bmin to bmax as described in 7.2): int, 1757 // unsigned int, long int, unsigned long int, long long int, or unsigned 1758 // long long int. If none of the types in that list can represent all the 1759 // values of the enumeration, an rvalue a prvalue of an unscoped enumeration 1760 // type can be converted to an rvalue a prvalue of the extended integer type 1761 // with lowest integer conversion rank (4.13) greater than the rank of long 1762 // long in which all the values of the enumeration can be represented. If 1763 // there are two such extended types, the signed one is chosen. 1764 // C++11 [conv.prom]p4: 1765 // A prvalue of an unscoped enumeration type whose underlying type is fixed 1766 // can be converted to a prvalue of its underlying type. Moreover, if 1767 // integral promotion can be applied to its underlying type, a prvalue of an 1768 // unscoped enumeration type whose underlying type is fixed can also be 1769 // converted to a prvalue of the promoted underlying type. 1770 if (const EnumType *FromEnumType = FromType->getAs<EnumType>()) { 1771 // C++0x 7.2p9: Note that this implicit enum to int conversion is not 1772 // provided for a scoped enumeration. 1773 if (FromEnumType->getDecl()->isScoped()) 1774 return false; 1775 1776 // We can perform an integral promotion to the underlying type of the enum, 1777 // even if that's not the promoted type. 1778 if (FromEnumType->getDecl()->isFixed()) { 1779 QualType Underlying = FromEnumType->getDecl()->getIntegerType(); 1780 return Context.hasSameUnqualifiedType(Underlying, ToType) || 1781 IsIntegralPromotion(From, Underlying, ToType); 1782 } 1783 1784 // We have already pre-calculated the promotion type, so this is trivial. 1785 if (ToType->isIntegerType() && 1786 !RequireCompleteType(From->getLocStart(), FromType, 0)) 1787 return Context.hasSameUnqualifiedType(ToType, 1788 FromEnumType->getDecl()->getPromotionType()); 1789 } 1790 1791 // C++0x [conv.prom]p2: 1792 // A prvalue of type char16_t, char32_t, or wchar_t (3.9.1) can be converted 1793 // to an rvalue a prvalue of the first of the following types that can 1794 // represent all the values of its underlying type: int, unsigned int, 1795 // long int, unsigned long int, long long int, or unsigned long long int. 1796 // If none of the types in that list can represent all the values of its 1797 // underlying type, an rvalue a prvalue of type char16_t, char32_t, 1798 // or wchar_t can be converted to an rvalue a prvalue of its underlying 1799 // type. 1800 if (FromType->isAnyCharacterType() && !FromType->isCharType() && 1801 ToType->isIntegerType()) { 1802 // Determine whether the type we're converting from is signed or 1803 // unsigned. 1804 bool FromIsSigned = FromType->isSignedIntegerType(); 1805 uint64_t FromSize = Context.getTypeSize(FromType); 1806 1807 // The types we'll try to promote to, in the appropriate 1808 // order. Try each of these types. 1809 QualType PromoteTypes[6] = { 1810 Context.IntTy, Context.UnsignedIntTy, 1811 Context.LongTy, Context.UnsignedLongTy , 1812 Context.LongLongTy, Context.UnsignedLongLongTy 1813 }; 1814 for (int Idx = 0; Idx < 6; ++Idx) { 1815 uint64_t ToSize = Context.getTypeSize(PromoteTypes[Idx]); 1816 if (FromSize < ToSize || 1817 (FromSize == ToSize && 1818 FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType())) { 1819 // We found the type that we can promote to. If this is the 1820 // type we wanted, we have a promotion. Otherwise, no 1821 // promotion. 1822 return Context.hasSameUnqualifiedType(ToType, PromoteTypes[Idx]); 1823 } 1824 } 1825 } 1826 1827 // An rvalue for an integral bit-field (9.6) can be converted to an 1828 // rvalue of type int if int can represent all the values of the 1829 // bit-field; otherwise, it can be converted to unsigned int if 1830 // unsigned int can represent all the values of the bit-field. If 1831 // the bit-field is larger yet, no integral promotion applies to 1832 // it. If the bit-field has an enumerated type, it is treated as any 1833 // other value of that type for promotion purposes (C++ 4.5p3). 1834 // FIXME: We should delay checking of bit-fields until we actually perform the 1835 // conversion. 1836 using llvm::APSInt; 1837 if (From) 1838 if (FieldDecl *MemberDecl = From->getSourceBitField()) { 1839 APSInt BitWidth; 1840 if (FromType->isIntegralType(Context) && 1841 MemberDecl->getBitWidth()->isIntegerConstantExpr(BitWidth, Context)) { 1842 APSInt ToSize(BitWidth.getBitWidth(), BitWidth.isUnsigned()); 1843 ToSize = Context.getTypeSize(ToType); 1844 1845 // Are we promoting to an int from a bitfield that fits in an int? 1846 if (BitWidth < ToSize || 1847 (FromType->isSignedIntegerType() && BitWidth <= ToSize)) { 1848 return To->getKind() == BuiltinType::Int; 1849 } 1850 1851 // Are we promoting to an unsigned int from an unsigned bitfield 1852 // that fits into an unsigned int? 1853 if (FromType->isUnsignedIntegerType() && BitWidth <= ToSize) { 1854 return To->getKind() == BuiltinType::UInt; 1855 } 1856 1857 return false; 1858 } 1859 } 1860 1861 // An rvalue of type bool can be converted to an rvalue of type int, 1862 // with false becoming zero and true becoming one (C++ 4.5p4). 1863 if (FromType->isBooleanType() && To->getKind() == BuiltinType::Int) { 1864 return true; 1865 } 1866 1867 return false; 1868} 1869 1870/// IsFloatingPointPromotion - Determines whether the conversion from 1871/// FromType to ToType is a floating point promotion (C++ 4.6). If so, 1872/// returns true and sets PromotedType to the promoted type. 1873bool Sema::IsFloatingPointPromotion(QualType FromType, QualType ToType) { 1874 if (const BuiltinType *FromBuiltin = FromType->getAs<BuiltinType>()) 1875 if (const BuiltinType *ToBuiltin = ToType->getAs<BuiltinType>()) { 1876 /// An rvalue of type float can be converted to an rvalue of type 1877 /// double. (C++ 4.6p1). 1878 if (FromBuiltin->getKind() == BuiltinType::Float && 1879 ToBuiltin->getKind() == BuiltinType::Double) 1880 return true; 1881 1882 // C99 6.3.1.5p1: 1883 // When a float is promoted to double or long double, or a 1884 // double is promoted to long double [...]. 1885 if (!getLangOpts().CPlusPlus && 1886 (FromBuiltin->getKind() == BuiltinType::Float || 1887 FromBuiltin->getKind() == BuiltinType::Double) && 1888 (ToBuiltin->getKind() == BuiltinType::LongDouble)) 1889 return true; 1890 1891 // Half can be promoted to float. 1892 if (!getLangOpts().NativeHalfType && 1893 FromBuiltin->getKind() == BuiltinType::Half && 1894 ToBuiltin->getKind() == BuiltinType::Float) 1895 return true; 1896 } 1897 1898 return false; 1899} 1900 1901/// \brief Determine if a conversion is a complex promotion. 1902/// 1903/// A complex promotion is defined as a complex -> complex conversion 1904/// where the conversion between the underlying real types is a 1905/// floating-point or integral promotion. 1906bool Sema::IsComplexPromotion(QualType FromType, QualType ToType) { 1907 const ComplexType *FromComplex = FromType->getAs<ComplexType>(); 1908 if (!FromComplex) 1909 return false; 1910 1911 const ComplexType *ToComplex = ToType->getAs<ComplexType>(); 1912 if (!ToComplex) 1913 return false; 1914 1915 return IsFloatingPointPromotion(FromComplex->getElementType(), 1916 ToComplex->getElementType()) || 1917 IsIntegralPromotion(0, FromComplex->getElementType(), 1918 ToComplex->getElementType()); 1919} 1920 1921/// BuildSimilarlyQualifiedPointerType - In a pointer conversion from 1922/// the pointer type FromPtr to a pointer to type ToPointee, with the 1923/// same type qualifiers as FromPtr has on its pointee type. ToType, 1924/// if non-empty, will be a pointer to ToType that may or may not have 1925/// the right set of qualifiers on its pointee. 1926/// 1927static QualType 1928BuildSimilarlyQualifiedPointerType(const Type *FromPtr, 1929 QualType ToPointee, QualType ToType, 1930 ASTContext &Context, 1931 bool StripObjCLifetime = false) { 1932 assert((FromPtr->getTypeClass() == Type::Pointer || 1933 FromPtr->getTypeClass() == Type::ObjCObjectPointer) && 1934 "Invalid similarly-qualified pointer type"); 1935 1936 /// Conversions to 'id' subsume cv-qualifier conversions. 1937 if (ToType->isObjCIdType() || ToType->isObjCQualifiedIdType()) 1938 return ToType.getUnqualifiedType(); 1939 1940 QualType CanonFromPointee 1941 = Context.getCanonicalType(FromPtr->getPointeeType()); 1942 QualType CanonToPointee = Context.getCanonicalType(ToPointee); 1943 Qualifiers Quals = CanonFromPointee.getQualifiers(); 1944 1945 if (StripObjCLifetime) 1946 Quals.removeObjCLifetime(); 1947 1948 // Exact qualifier match -> return the pointer type we're converting to. 1949 if (CanonToPointee.getLocalQualifiers() == Quals) { 1950 // ToType is exactly what we need. Return it. 1951 if (!ToType.isNull()) 1952 return ToType.getUnqualifiedType(); 1953 1954 // Build a pointer to ToPointee. It has the right qualifiers 1955 // already. 1956 if (isa<ObjCObjectPointerType>(ToType)) 1957 return Context.getObjCObjectPointerType(ToPointee); 1958 return Context.getPointerType(ToPointee); 1959 } 1960 1961 // Just build a canonical type that has the right qualifiers. 1962 QualType QualifiedCanonToPointee 1963 = Context.getQualifiedType(CanonToPointee.getLocalUnqualifiedType(), Quals); 1964 1965 if (isa<ObjCObjectPointerType>(ToType)) 1966 return Context.getObjCObjectPointerType(QualifiedCanonToPointee); 1967 return Context.getPointerType(QualifiedCanonToPointee); 1968} 1969 1970static bool isNullPointerConstantForConversion(Expr *Expr, 1971 bool InOverloadResolution, 1972 ASTContext &Context) { 1973 // Handle value-dependent integral null pointer constants correctly. 1974 // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#903 1975 if (Expr->isValueDependent() && !Expr->isTypeDependent() && 1976 Expr->getType()->isIntegerType() && !Expr->getType()->isEnumeralType()) 1977 return !InOverloadResolution; 1978 1979 return Expr->isNullPointerConstant(Context, 1980 InOverloadResolution? Expr::NPC_ValueDependentIsNotNull 1981 : Expr::NPC_ValueDependentIsNull); 1982} 1983 1984/// IsPointerConversion - Determines whether the conversion of the 1985/// expression From, which has the (possibly adjusted) type FromType, 1986/// can be converted to the type ToType via a pointer conversion (C++ 1987/// 4.10). If so, returns true and places the converted type (that 1988/// might differ from ToType in its cv-qualifiers at some level) into 1989/// ConvertedType. 1990/// 1991/// This routine also supports conversions to and from block pointers 1992/// and conversions with Objective-C's 'id', 'id<protocols...>', and 1993/// pointers to interfaces. FIXME: Once we've determined the 1994/// appropriate overloading rules for Objective-C, we may want to 1995/// split the Objective-C checks into a different routine; however, 1996/// GCC seems to consider all of these conversions to be pointer 1997/// conversions, so for now they live here. IncompatibleObjC will be 1998/// set if the conversion is an allowed Objective-C conversion that 1999/// should result in a warning. 2000bool Sema::IsPointerConversion(Expr *From, QualType FromType, QualType ToType, 2001 bool InOverloadResolution, 2002 QualType& ConvertedType, 2003 bool &IncompatibleObjC) { 2004 IncompatibleObjC = false; 2005 if (isObjCPointerConversion(FromType, ToType, ConvertedType, 2006 IncompatibleObjC)) 2007 return true; 2008 2009 // Conversion from a null pointer constant to any Objective-C pointer type. 2010 if (ToType->isObjCObjectPointerType() && 2011 isNullPointerConstantForConversion(From, InOverloadResolution, Context)) { 2012 ConvertedType = ToType; 2013 return true; 2014 } 2015 2016 // Blocks: Block pointers can be converted to void*. 2017 if (FromType->isBlockPointerType() && ToType->isPointerType() && 2018 ToType->getAs<PointerType>()->getPointeeType()->isVoidType()) { 2019 ConvertedType = ToType; 2020 return true; 2021 } 2022 // Blocks: A null pointer constant can be converted to a block 2023 // pointer type. 2024 if (ToType->isBlockPointerType() && 2025 isNullPointerConstantForConversion(From, InOverloadResolution, Context)) { 2026 ConvertedType = ToType; 2027 return true; 2028 } 2029 2030 // If the left-hand-side is nullptr_t, the right side can be a null 2031 // pointer constant. 2032 if (ToType->isNullPtrType() && 2033 isNullPointerConstantForConversion(From, InOverloadResolution, Context)) { 2034 ConvertedType = ToType; 2035 return true; 2036 } 2037 2038 const PointerType* ToTypePtr = ToType->getAs<PointerType>(); 2039 if (!ToTypePtr) 2040 return false; 2041 2042 // A null pointer constant can be converted to a pointer type (C++ 4.10p1). 2043 if (isNullPointerConstantForConversion(From, InOverloadResolution, Context)) { 2044 ConvertedType = ToType; 2045 return true; 2046 } 2047 2048 // Beyond this point, both types need to be pointers 2049 // , including objective-c pointers. 2050 QualType ToPointeeType = ToTypePtr->getPointeeType(); 2051 if (FromType->isObjCObjectPointerType() && ToPointeeType->isVoidType() && 2052 !getLangOpts().ObjCAutoRefCount) { 2053 ConvertedType = BuildSimilarlyQualifiedPointerType( 2054 FromType->getAs<ObjCObjectPointerType>(), 2055 ToPointeeType, 2056 ToType, Context); 2057 return true; 2058 } 2059 const PointerType *FromTypePtr = FromType->getAs<PointerType>(); 2060 if (!FromTypePtr) 2061 return false; 2062 2063 QualType FromPointeeType = FromTypePtr->getPointeeType(); 2064 2065 // If the unqualified pointee types are the same, this can't be a 2066 // pointer conversion, so don't do all of the work below. 2067 if (Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType)) 2068 return false; 2069 2070 // An rvalue of type "pointer to cv T," where T is an object type, 2071 // can be converted to an rvalue of type "pointer to cv void" (C++ 2072 // 4.10p2). 2073 if (FromPointeeType->isIncompleteOrObjectType() && 2074 ToPointeeType->isVoidType()) { 2075 ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr, 2076 ToPointeeType, 2077 ToType, Context, 2078 /*StripObjCLifetime=*/true); 2079 return true; 2080 } 2081 2082 // MSVC allows implicit function to void* type conversion. 2083 if (getLangOpts().MicrosoftExt && FromPointeeType->isFunctionType() && 2084 ToPointeeType->isVoidType()) { 2085 ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr, 2086 ToPointeeType, 2087 ToType, Context); 2088 return true; 2089 } 2090 2091 // When we're overloading in C, we allow a special kind of pointer 2092 // conversion for compatible-but-not-identical pointee types. 2093 if (!getLangOpts().CPlusPlus && 2094 Context.typesAreCompatible(FromPointeeType, ToPointeeType)) { 2095 ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr, 2096 ToPointeeType, 2097 ToType, Context); 2098 return true; 2099 } 2100 2101 // C++ [conv.ptr]p3: 2102 // 2103 // An rvalue of type "pointer to cv D," where D is a class type, 2104 // can be converted to an rvalue of type "pointer to cv B," where 2105 // B is a base class (clause 10) of D. If B is an inaccessible 2106 // (clause 11) or ambiguous (10.2) base class of D, a program that 2107 // necessitates this conversion is ill-formed. The result of the 2108 // conversion is a pointer to the base class sub-object of the 2109 // derived class object. The null pointer value is converted to 2110 // the null pointer value of the destination type. 2111 // 2112 // Note that we do not check for ambiguity or inaccessibility 2113 // here. That is handled by CheckPointerConversion. 2114 if (getLangOpts().CPlusPlus && 2115 FromPointeeType->isRecordType() && ToPointeeType->isRecordType() && 2116 !Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType) && 2117 !RequireCompleteType(From->getLocStart(), FromPointeeType, 0) && 2118 IsDerivedFrom(FromPointeeType, ToPointeeType)) { 2119 ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr, 2120 ToPointeeType, 2121 ToType, Context); 2122 return true; 2123 } 2124 2125 if (FromPointeeType->isVectorType() && ToPointeeType->isVectorType() && 2126 Context.areCompatibleVectorTypes(FromPointeeType, ToPointeeType)) { 2127 ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr, 2128 ToPointeeType, 2129 ToType, Context); 2130 return true; 2131 } 2132 2133 return false; 2134} 2135 2136/// \brief Adopt the given qualifiers for the given type. 2137static QualType AdoptQualifiers(ASTContext &Context, QualType T, Qualifiers Qs){ 2138 Qualifiers TQs = T.getQualifiers(); 2139 2140 // Check whether qualifiers already match. 2141 if (TQs == Qs) 2142 return T; 2143 2144 if (Qs.compatiblyIncludes(TQs)) 2145 return Context.getQualifiedType(T, Qs); 2146 2147 return Context.getQualifiedType(T.getUnqualifiedType(), Qs); 2148} 2149 2150/// isObjCPointerConversion - Determines whether this is an 2151/// Objective-C pointer conversion. Subroutine of IsPointerConversion, 2152/// with the same arguments and return values. 2153bool Sema::isObjCPointerConversion(QualType FromType, QualType ToType, 2154 QualType& ConvertedType, 2155 bool &IncompatibleObjC) { 2156 if (!getLangOpts().ObjC1) 2157 return false; 2158 2159 // The set of qualifiers on the type we're converting from. 2160 Qualifiers FromQualifiers = FromType.getQualifiers(); 2161 2162 // First, we handle all conversions on ObjC object pointer types. 2163 const ObjCObjectPointerType* ToObjCPtr = 2164 ToType->getAs<ObjCObjectPointerType>(); 2165 const ObjCObjectPointerType *FromObjCPtr = 2166 FromType->getAs<ObjCObjectPointerType>(); 2167 2168 if (ToObjCPtr && FromObjCPtr) { 2169 // If the pointee types are the same (ignoring qualifications), 2170 // then this is not a pointer conversion. 2171 if (Context.hasSameUnqualifiedType(ToObjCPtr->getPointeeType(), 2172 FromObjCPtr->getPointeeType())) 2173 return false; 2174 2175 // Check for compatible 2176 // Objective C++: We're able to convert between "id" or "Class" and a 2177 // pointer to any interface (in both directions). 2178 if (ToObjCPtr->isObjCBuiltinType() && FromObjCPtr->isObjCBuiltinType()) { 2179 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers); 2180 return true; 2181 } 2182 // Conversions with Objective-C's id<...>. 2183 if ((FromObjCPtr->isObjCQualifiedIdType() || 2184 ToObjCPtr->isObjCQualifiedIdType()) && 2185 Context.ObjCQualifiedIdTypesAreCompatible(ToType, FromType, 2186 /*compare=*/false)) { 2187 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers); 2188 return true; 2189 } 2190 // Objective C++: We're able to convert from a pointer to an 2191 // interface to a pointer to a different interface. 2192 if (Context.canAssignObjCInterfaces(ToObjCPtr, FromObjCPtr)) { 2193 const ObjCInterfaceType* LHS = ToObjCPtr->getInterfaceType(); 2194 const ObjCInterfaceType* RHS = FromObjCPtr->getInterfaceType(); 2195 if (getLangOpts().CPlusPlus && LHS && RHS && 2196 !ToObjCPtr->getPointeeType().isAtLeastAsQualifiedAs( 2197 FromObjCPtr->getPointeeType())) 2198 return false; 2199 ConvertedType = BuildSimilarlyQualifiedPointerType(FromObjCPtr, 2200 ToObjCPtr->getPointeeType(), 2201 ToType, Context); 2202 ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers); 2203 return true; 2204 } 2205 2206 if (Context.canAssignObjCInterfaces(FromObjCPtr, ToObjCPtr)) { 2207 // Okay: this is some kind of implicit downcast of Objective-C 2208 // interfaces, which is permitted. However, we're going to 2209 // complain about it. 2210 IncompatibleObjC = true; 2211 ConvertedType = BuildSimilarlyQualifiedPointerType(FromObjCPtr, 2212 ToObjCPtr->getPointeeType(), 2213 ToType, Context); 2214 ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers); 2215 return true; 2216 } 2217 } 2218 // Beyond this point, both types need to be C pointers or block pointers. 2219 QualType ToPointeeType; 2220 if (const PointerType *ToCPtr = ToType->getAs<PointerType>()) 2221 ToPointeeType = ToCPtr->getPointeeType(); 2222 else if (const BlockPointerType *ToBlockPtr = 2223 ToType->getAs<BlockPointerType>()) { 2224 // Objective C++: We're able to convert from a pointer to any object 2225 // to a block pointer type. 2226 if (FromObjCPtr && FromObjCPtr->isObjCBuiltinType()) { 2227 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers); 2228 return true; 2229 } 2230 ToPointeeType = ToBlockPtr->getPointeeType(); 2231 } 2232 else if (FromType->getAs<BlockPointerType>() && 2233 ToObjCPtr && ToObjCPtr->isObjCBuiltinType()) { 2234 // Objective C++: We're able to convert from a block pointer type to a 2235 // pointer to any object. 2236 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers); 2237 return true; 2238 } 2239 else 2240 return false; 2241 2242 QualType FromPointeeType; 2243 if (const PointerType *FromCPtr = FromType->getAs<PointerType>()) 2244 FromPointeeType = FromCPtr->getPointeeType(); 2245 else if (const BlockPointerType *FromBlockPtr = 2246 FromType->getAs<BlockPointerType>()) 2247 FromPointeeType = FromBlockPtr->getPointeeType(); 2248 else 2249 return false; 2250 2251 // If we have pointers to pointers, recursively check whether this 2252 // is an Objective-C conversion. 2253 if (FromPointeeType->isPointerType() && ToPointeeType->isPointerType() && 2254 isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType, 2255 IncompatibleObjC)) { 2256 // We always complain about this conversion. 2257 IncompatibleObjC = true; 2258 ConvertedType = Context.getPointerType(ConvertedType); 2259 ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers); 2260 return true; 2261 } 2262 // Allow conversion of pointee being objective-c pointer to another one; 2263 // as in I* to id. 2264 if (FromPointeeType->getAs<ObjCObjectPointerType>() && 2265 ToPointeeType->getAs<ObjCObjectPointerType>() && 2266 isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType, 2267 IncompatibleObjC)) { 2268 2269 ConvertedType = Context.getPointerType(ConvertedType); 2270 ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers); 2271 return true; 2272 } 2273 2274 // If we have pointers to functions or blocks, check whether the only 2275 // differences in the argument and result types are in Objective-C 2276 // pointer conversions. If so, we permit the conversion (but 2277 // complain about it). 2278 const FunctionProtoType *FromFunctionType 2279 = FromPointeeType->getAs<FunctionProtoType>(); 2280 const FunctionProtoType *ToFunctionType 2281 = ToPointeeType->getAs<FunctionProtoType>(); 2282 if (FromFunctionType && ToFunctionType) { 2283 // If the function types are exactly the same, this isn't an 2284 // Objective-C pointer conversion. 2285 if (Context.getCanonicalType(FromPointeeType) 2286 == Context.getCanonicalType(ToPointeeType)) 2287 return false; 2288 2289 // Perform the quick checks that will tell us whether these 2290 // function types are obviously different. 2291 if (FromFunctionType->getNumArgs() != ToFunctionType->getNumArgs() || 2292 FromFunctionType->isVariadic() != ToFunctionType->isVariadic() || 2293 FromFunctionType->getTypeQuals() != ToFunctionType->getTypeQuals()) 2294 return false; 2295 2296 bool HasObjCConversion = false; 2297 if (Context.getCanonicalType(FromFunctionType->getResultType()) 2298 == Context.getCanonicalType(ToFunctionType->getResultType())) { 2299 // Okay, the types match exactly. Nothing to do. 2300 } else if (isObjCPointerConversion(FromFunctionType->getResultType(), 2301 ToFunctionType->getResultType(), 2302 ConvertedType, IncompatibleObjC)) { 2303 // Okay, we have an Objective-C pointer conversion. 2304 HasObjCConversion = true; 2305 } else { 2306 // Function types are too different. Abort. 2307 return false; 2308 } 2309 2310 // Check argument types. 2311 for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumArgs(); 2312 ArgIdx != NumArgs; ++ArgIdx) { 2313 QualType FromArgType = FromFunctionType->getArgType(ArgIdx); 2314 QualType ToArgType = ToFunctionType->getArgType(ArgIdx); 2315 if (Context.getCanonicalType(FromArgType) 2316 == Context.getCanonicalType(ToArgType)) { 2317 // Okay, the types match exactly. Nothing to do. 2318 } else if (isObjCPointerConversion(FromArgType, ToArgType, 2319 ConvertedType, IncompatibleObjC)) { 2320 // Okay, we have an Objective-C pointer conversion. 2321 HasObjCConversion = true; 2322 } else { 2323 // Argument types are too different. Abort. 2324 return false; 2325 } 2326 } 2327 2328 if (HasObjCConversion) { 2329 // We had an Objective-C conversion. Allow this pointer 2330 // conversion, but complain about it. 2331 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers); 2332 IncompatibleObjC = true; 2333 return true; 2334 } 2335 } 2336 2337 return false; 2338} 2339 2340/// \brief Determine whether this is an Objective-C writeback conversion, 2341/// used for parameter passing when performing automatic reference counting. 2342/// 2343/// \param FromType The type we're converting form. 2344/// 2345/// \param ToType The type we're converting to. 2346/// 2347/// \param ConvertedType The type that will be produced after applying 2348/// this conversion. 2349bool Sema::isObjCWritebackConversion(QualType FromType, QualType ToType, 2350 QualType &ConvertedType) { 2351 if (!getLangOpts().ObjCAutoRefCount || 2352 Context.hasSameUnqualifiedType(FromType, ToType)) 2353 return false; 2354 2355 // Parameter must be a pointer to __autoreleasing (with no other qualifiers). 2356 QualType ToPointee; 2357 if (const PointerType *ToPointer = ToType->getAs<PointerType>()) 2358 ToPointee = ToPointer->getPointeeType(); 2359 else 2360 return false; 2361 2362 Qualifiers ToQuals = ToPointee.getQualifiers(); 2363 if (!ToPointee->isObjCLifetimeType() || 2364 ToQuals.getObjCLifetime() != Qualifiers::OCL_Autoreleasing || 2365 !ToQuals.withoutObjCLifetime().empty()) 2366 return false; 2367 2368 // Argument must be a pointer to __strong to __weak. 2369 QualType FromPointee; 2370 if (const PointerType *FromPointer = FromType->getAs<PointerType>()) 2371 FromPointee = FromPointer->getPointeeType(); 2372 else 2373 return false; 2374 2375 Qualifiers FromQuals = FromPointee.getQualifiers(); 2376 if (!FromPointee->isObjCLifetimeType() || 2377 (FromQuals.getObjCLifetime() != Qualifiers::OCL_Strong && 2378 FromQuals.getObjCLifetime() != Qualifiers::OCL_Weak)) 2379 return false; 2380 2381 // Make sure that we have compatible qualifiers. 2382 FromQuals.setObjCLifetime(Qualifiers::OCL_Autoreleasing); 2383 if (!ToQuals.compatiblyIncludes(FromQuals)) 2384 return false; 2385 2386 // Remove qualifiers from the pointee type we're converting from; they 2387 // aren't used in the compatibility check belong, and we'll be adding back 2388 // qualifiers (with __autoreleasing) if the compatibility check succeeds. 2389 FromPointee = FromPointee.getUnqualifiedType(); 2390 2391 // The unqualified form of the pointee types must be compatible. 2392 ToPointee = ToPointee.getUnqualifiedType(); 2393 bool IncompatibleObjC; 2394 if (Context.typesAreCompatible(FromPointee, ToPointee)) 2395 FromPointee = ToPointee; 2396 else if (!isObjCPointerConversion(FromPointee, ToPointee, FromPointee, 2397 IncompatibleObjC)) 2398 return false; 2399 2400 /// \brief Construct the type we're converting to, which is a pointer to 2401 /// __autoreleasing pointee. 2402 FromPointee = Context.getQualifiedType(FromPointee, FromQuals); 2403 ConvertedType = Context.getPointerType(FromPointee); 2404 return true; 2405} 2406 2407bool Sema::IsBlockPointerConversion(QualType FromType, QualType ToType, 2408 QualType& ConvertedType) { 2409 QualType ToPointeeType; 2410 if (const BlockPointerType *ToBlockPtr = 2411 ToType->getAs<BlockPointerType>()) 2412 ToPointeeType = ToBlockPtr->getPointeeType(); 2413 else 2414 return false; 2415 2416 QualType FromPointeeType; 2417 if (const BlockPointerType *FromBlockPtr = 2418 FromType->getAs<BlockPointerType>()) 2419 FromPointeeType = FromBlockPtr->getPointeeType(); 2420 else 2421 return false; 2422 // We have pointer to blocks, check whether the only 2423 // differences in the argument and result types are in Objective-C 2424 // pointer conversions. If so, we permit the conversion. 2425 2426 const FunctionProtoType *FromFunctionType 2427 = FromPointeeType->getAs<FunctionProtoType>(); 2428 const FunctionProtoType *ToFunctionType 2429 = ToPointeeType->getAs<FunctionProtoType>(); 2430 2431 if (!FromFunctionType || !ToFunctionType) 2432 return false; 2433 2434 if (Context.hasSameType(FromPointeeType, ToPointeeType)) 2435 return true; 2436 2437 // Perform the quick checks that will tell us whether these 2438 // function types are obviously different. 2439 if (FromFunctionType->getNumArgs() != ToFunctionType->getNumArgs() || 2440 FromFunctionType->isVariadic() != ToFunctionType->isVariadic()) 2441 return false; 2442 2443 FunctionType::ExtInfo FromEInfo = FromFunctionType->getExtInfo(); 2444 FunctionType::ExtInfo ToEInfo = ToFunctionType->getExtInfo(); 2445 if (FromEInfo != ToEInfo) 2446 return false; 2447 2448 bool IncompatibleObjC = false; 2449 if (Context.hasSameType(FromFunctionType->getResultType(), 2450 ToFunctionType->getResultType())) { 2451 // Okay, the types match exactly. Nothing to do. 2452 } else { 2453 QualType RHS = FromFunctionType->getResultType(); 2454 QualType LHS = ToFunctionType->getResultType(); 2455 if ((!getLangOpts().CPlusPlus || !RHS->isRecordType()) && 2456 !RHS.hasQualifiers() && LHS.hasQualifiers()) 2457 LHS = LHS.getUnqualifiedType(); 2458 2459 if (Context.hasSameType(RHS,LHS)) { 2460 // OK exact match. 2461 } else if (isObjCPointerConversion(RHS, LHS, 2462 ConvertedType, IncompatibleObjC)) { 2463 if (IncompatibleObjC) 2464 return false; 2465 // Okay, we have an Objective-C pointer conversion. 2466 } 2467 else 2468 return false; 2469 } 2470 2471 // Check argument types. 2472 for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumArgs(); 2473 ArgIdx != NumArgs; ++ArgIdx) { 2474 IncompatibleObjC = false; 2475 QualType FromArgType = FromFunctionType->getArgType(ArgIdx); 2476 QualType ToArgType = ToFunctionType->getArgType(ArgIdx); 2477 if (Context.hasSameType(FromArgType, ToArgType)) { 2478 // Okay, the types match exactly. Nothing to do. 2479 } else if (isObjCPointerConversion(ToArgType, FromArgType, 2480 ConvertedType, IncompatibleObjC)) { 2481 if (IncompatibleObjC) 2482 return false; 2483 // Okay, we have an Objective-C pointer conversion. 2484 } else 2485 // Argument types are too different. Abort. 2486 return false; 2487 } 2488 if (LangOpts.ObjCAutoRefCount && 2489 !Context.FunctionTypesMatchOnNSConsumedAttrs(FromFunctionType, 2490 ToFunctionType)) 2491 return false; 2492 2493 ConvertedType = ToType; 2494 return true; 2495} 2496 2497enum { 2498 ft_default, 2499 ft_different_class, 2500 ft_parameter_arity, 2501 ft_parameter_mismatch, 2502 ft_return_type, 2503 ft_qualifer_mismatch 2504}; 2505 2506/// HandleFunctionTypeMismatch - Gives diagnostic information for differeing 2507/// function types. Catches different number of parameter, mismatch in 2508/// parameter types, and different return types. 2509void Sema::HandleFunctionTypeMismatch(PartialDiagnostic &PDiag, 2510 QualType FromType, QualType ToType) { 2511 // If either type is not valid, include no extra info. 2512 if (FromType.isNull() || ToType.isNull()) { 2513 PDiag << ft_default; 2514 return; 2515 } 2516 2517 // Get the function type from the pointers. 2518 if (FromType->isMemberPointerType() && ToType->isMemberPointerType()) { 2519 const MemberPointerType *FromMember = FromType->getAs<MemberPointerType>(), 2520 *ToMember = ToType->getAs<MemberPointerType>(); 2521 if (FromMember->getClass() != ToMember->getClass()) { 2522 PDiag << ft_different_class << QualType(ToMember->getClass(), 0) 2523 << QualType(FromMember->getClass(), 0); 2524 return; 2525 } 2526 FromType = FromMember->getPointeeType(); 2527 ToType = ToMember->getPointeeType(); 2528 } 2529 2530 if (FromType->isPointerType()) 2531 FromType = FromType->getPointeeType(); 2532 if (ToType->isPointerType()) 2533 ToType = ToType->getPointeeType(); 2534 2535 // Remove references. 2536 FromType = FromType.getNonReferenceType(); 2537 ToType = ToType.getNonReferenceType(); 2538 2539 // Don't print extra info for non-specialized template functions. 2540 if (FromType->isInstantiationDependentType() && 2541 !FromType->getAs<TemplateSpecializationType>()) { 2542 PDiag << ft_default; 2543 return; 2544 } 2545 2546 // No extra info for same types. 2547 if (Context.hasSameType(FromType, ToType)) { 2548 PDiag << ft_default; 2549 return; 2550 } 2551 2552 const FunctionProtoType *FromFunction = FromType->getAs<FunctionProtoType>(), 2553 *ToFunction = ToType->getAs<FunctionProtoType>(); 2554 2555 // Both types need to be function types. 2556 if (!FromFunction || !ToFunction) { 2557 PDiag << ft_default; 2558 return; 2559 } 2560 2561 if (FromFunction->getNumArgs() != ToFunction->getNumArgs()) { 2562 PDiag << ft_parameter_arity << ToFunction->getNumArgs() 2563 << FromFunction->getNumArgs(); 2564 return; 2565 } 2566 2567 // Handle different parameter types. 2568 unsigned ArgPos; 2569 if (!FunctionArgTypesAreEqual(FromFunction, ToFunction, &ArgPos)) { 2570 PDiag << ft_parameter_mismatch << ArgPos + 1 2571 << ToFunction->getArgType(ArgPos) 2572 << FromFunction->getArgType(ArgPos); 2573 return; 2574 } 2575 2576 // Handle different return type. 2577 if (!Context.hasSameType(FromFunction->getResultType(), 2578 ToFunction->getResultType())) { 2579 PDiag << ft_return_type << ToFunction->getResultType() 2580 << FromFunction->getResultType(); 2581 return; 2582 } 2583 2584 unsigned FromQuals = FromFunction->getTypeQuals(), 2585 ToQuals = ToFunction->getTypeQuals(); 2586 if (FromQuals != ToQuals) { 2587 PDiag << ft_qualifer_mismatch << ToQuals << FromQuals; 2588 return; 2589 } 2590 2591 // Unable to find a difference, so add no extra info. 2592 PDiag << ft_default; 2593} 2594 2595/// FunctionArgTypesAreEqual - This routine checks two function proto types 2596/// for equality of their argument types. Caller has already checked that 2597/// they have same number of arguments. If the parameters are different, 2598/// ArgPos will have the parameter index of the first different parameter. 2599bool Sema::FunctionArgTypesAreEqual(const FunctionProtoType *OldType, 2600 const FunctionProtoType *NewType, 2601 unsigned *ArgPos) { 2602 for (FunctionProtoType::arg_type_iterator O = OldType->arg_type_begin(), 2603 N = NewType->arg_type_begin(), 2604 E = OldType->arg_type_end(); O && (O != E); ++O, ++N) { 2605 if (!Context.hasSameType(O->getUnqualifiedType(), 2606 N->getUnqualifiedType())) { 2607 if (ArgPos) *ArgPos = O - OldType->arg_type_begin(); 2608 return false; 2609 } 2610 } 2611 return true; 2612} 2613 2614/// CheckPointerConversion - Check the pointer conversion from the 2615/// expression From to the type ToType. This routine checks for 2616/// ambiguous or inaccessible derived-to-base pointer 2617/// conversions for which IsPointerConversion has already returned 2618/// true. It returns true and produces a diagnostic if there was an 2619/// error, or returns false otherwise. 2620bool Sema::CheckPointerConversion(Expr *From, QualType ToType, 2621 CastKind &Kind, 2622 CXXCastPath& BasePath, 2623 bool IgnoreBaseAccess) { 2624 QualType FromType = From->getType(); 2625 bool IsCStyleOrFunctionalCast = IgnoreBaseAccess; 2626 2627 Kind = CK_BitCast; 2628 2629 if (!IsCStyleOrFunctionalCast && !FromType->isAnyPointerType() && 2630 From->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNotNull) == 2631 Expr::NPCK_ZeroExpression) { 2632 if (Context.hasSameUnqualifiedType(From->getType(), Context.BoolTy)) 2633 DiagRuntimeBehavior(From->getExprLoc(), From, 2634 PDiag(diag::warn_impcast_bool_to_null_pointer) 2635 << ToType << From->getSourceRange()); 2636 else if (!isUnevaluatedContext()) 2637 Diag(From->getExprLoc(), diag::warn_non_literal_null_pointer) 2638 << ToType << From->getSourceRange(); 2639 } 2640 if (const PointerType *ToPtrType = ToType->getAs<PointerType>()) { 2641 if (const PointerType *FromPtrType = FromType->getAs<PointerType>()) { 2642 QualType FromPointeeType = FromPtrType->getPointeeType(), 2643 ToPointeeType = ToPtrType->getPointeeType(); 2644 2645 if (FromPointeeType->isRecordType() && ToPointeeType->isRecordType() && 2646 !Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType)) { 2647 // We must have a derived-to-base conversion. Check an 2648 // ambiguous or inaccessible conversion. 2649 if (CheckDerivedToBaseConversion(FromPointeeType, ToPointeeType, 2650 From->getExprLoc(), 2651 From->getSourceRange(), &BasePath, 2652 IgnoreBaseAccess)) 2653 return true; 2654 2655 // The conversion was successful. 2656 Kind = CK_DerivedToBase; 2657 } 2658 } 2659 } else if (const ObjCObjectPointerType *ToPtrType = 2660 ToType->getAs<ObjCObjectPointerType>()) { 2661 if (const ObjCObjectPointerType *FromPtrType = 2662 FromType->getAs<ObjCObjectPointerType>()) { 2663 // Objective-C++ conversions are always okay. 2664 // FIXME: We should have a different class of conversions for the 2665 // Objective-C++ implicit conversions. 2666 if (FromPtrType->isObjCBuiltinType() || ToPtrType->isObjCBuiltinType()) 2667 return false; 2668 } else if (FromType->isBlockPointerType()) { 2669 Kind = CK_BlockPointerToObjCPointerCast; 2670 } else { 2671 Kind = CK_CPointerToObjCPointerCast; 2672 } 2673 } else if (ToType->isBlockPointerType()) { 2674 if (!FromType->isBlockPointerType()) 2675 Kind = CK_AnyPointerToBlockPointerCast; 2676 } 2677 2678 // We shouldn't fall into this case unless it's valid for other 2679 // reasons. 2680 if (From->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) 2681 Kind = CK_NullToPointer; 2682 2683 return false; 2684} 2685 2686/// IsMemberPointerConversion - Determines whether the conversion of the 2687/// expression From, which has the (possibly adjusted) type FromType, can be 2688/// converted to the type ToType via a member pointer conversion (C++ 4.11). 2689/// If so, returns true and places the converted type (that might differ from 2690/// ToType in its cv-qualifiers at some level) into ConvertedType. 2691bool Sema::IsMemberPointerConversion(Expr *From, QualType FromType, 2692 QualType ToType, 2693 bool InOverloadResolution, 2694 QualType &ConvertedType) { 2695 const MemberPointerType *ToTypePtr = ToType->getAs<MemberPointerType>(); 2696 if (!ToTypePtr) 2697 return false; 2698 2699 // A null pointer constant can be converted to a member pointer (C++ 4.11p1) 2700 if (From->isNullPointerConstant(Context, 2701 InOverloadResolution? Expr::NPC_ValueDependentIsNotNull 2702 : Expr::NPC_ValueDependentIsNull)) { 2703 ConvertedType = ToType; 2704 return true; 2705 } 2706 2707 // Otherwise, both types have to be member pointers. 2708 const MemberPointerType *FromTypePtr = FromType->getAs<MemberPointerType>(); 2709 if (!FromTypePtr) 2710 return false; 2711 2712 // A pointer to member of B can be converted to a pointer to member of D, 2713 // where D is derived from B (C++ 4.11p2). 2714 QualType FromClass(FromTypePtr->getClass(), 0); 2715 QualType ToClass(ToTypePtr->getClass(), 0); 2716 2717 if (!Context.hasSameUnqualifiedType(FromClass, ToClass) && 2718 !RequireCompleteType(From->getLocStart(), ToClass, 0) && 2719 IsDerivedFrom(ToClass, FromClass)) { 2720 ConvertedType = Context.getMemberPointerType(FromTypePtr->getPointeeType(), 2721 ToClass.getTypePtr()); 2722 return true; 2723 } 2724 2725 return false; 2726} 2727 2728/// CheckMemberPointerConversion - Check the member pointer conversion from the 2729/// expression From to the type ToType. This routine checks for ambiguous or 2730/// virtual or inaccessible base-to-derived member pointer conversions 2731/// for which IsMemberPointerConversion has already returned true. It returns 2732/// true and produces a diagnostic if there was an error, or returns false 2733/// otherwise. 2734bool Sema::CheckMemberPointerConversion(Expr *From, QualType ToType, 2735 CastKind &Kind, 2736 CXXCastPath &BasePath, 2737 bool IgnoreBaseAccess) { 2738 QualType FromType = From->getType(); 2739 const MemberPointerType *FromPtrType = FromType->getAs<MemberPointerType>(); 2740 if (!FromPtrType) { 2741 // This must be a null pointer to member pointer conversion 2742 assert(From->isNullPointerConstant(Context, 2743 Expr::NPC_ValueDependentIsNull) && 2744 "Expr must be null pointer constant!"); 2745 Kind = CK_NullToMemberPointer; 2746 return false; 2747 } 2748 2749 const MemberPointerType *ToPtrType = ToType->getAs<MemberPointerType>(); 2750 assert(ToPtrType && "No member pointer cast has a target type " 2751 "that is not a member pointer."); 2752 2753 QualType FromClass = QualType(FromPtrType->getClass(), 0); 2754 QualType ToClass = QualType(ToPtrType->getClass(), 0); 2755 2756 // FIXME: What about dependent types? 2757 assert(FromClass->isRecordType() && "Pointer into non-class."); 2758 assert(ToClass->isRecordType() && "Pointer into non-class."); 2759 2760 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, 2761 /*DetectVirtual=*/true); 2762 bool DerivationOkay = IsDerivedFrom(ToClass, FromClass, Paths); 2763 assert(DerivationOkay && 2764 "Should not have been called if derivation isn't OK."); 2765 (void)DerivationOkay; 2766 2767 if (Paths.isAmbiguous(Context.getCanonicalType(FromClass). 2768 getUnqualifiedType())) { 2769 std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths); 2770 Diag(From->getExprLoc(), diag::err_ambiguous_memptr_conv) 2771 << 0 << FromClass << ToClass << PathDisplayStr << From->getSourceRange(); 2772 return true; 2773 } 2774 2775 if (const RecordType *VBase = Paths.getDetectedVirtual()) { 2776 Diag(From->getExprLoc(), diag::err_memptr_conv_via_virtual) 2777 << FromClass << ToClass << QualType(VBase, 0) 2778 << From->getSourceRange(); 2779 return true; 2780 } 2781 2782 if (!IgnoreBaseAccess) 2783 CheckBaseClassAccess(From->getExprLoc(), FromClass, ToClass, 2784 Paths.front(), 2785 diag::err_downcast_from_inaccessible_base); 2786 2787 // Must be a base to derived member conversion. 2788 BuildBasePathArray(Paths, BasePath); 2789 Kind = CK_BaseToDerivedMemberPointer; 2790 return false; 2791} 2792 2793/// Determine whether the lifetime conversion between the two given 2794/// qualifiers sets is nontrivial. 2795static bool isNonTrivialObjCLifetimeConversion(Qualifiers FromQuals, 2796 Qualifiers ToQuals) { 2797 // Converting anything to const __unsafe_unretained is trivial. 2798 if (ToQuals.hasConst() && 2799 ToQuals.getObjCLifetime() == Qualifiers::OCL_ExplicitNone) 2800 return false; 2801 2802 return true; 2803} 2804 2805/// IsQualificationConversion - Determines whether the conversion from 2806/// an rvalue of type FromType to ToType is a qualification conversion 2807/// (C++ 4.4). 2808/// 2809/// \param ObjCLifetimeConversion Output parameter that will be set to indicate 2810/// when the qualification conversion involves a change in the Objective-C 2811/// object lifetime. 2812bool 2813Sema::IsQualificationConversion(QualType FromType, QualType ToType, 2814 bool CStyle, bool &ObjCLifetimeConversion) { 2815 FromType = Context.getCanonicalType(FromType); 2816 ToType = Context.getCanonicalType(ToType); 2817 ObjCLifetimeConversion = false; 2818 2819 // If FromType and ToType are the same type, this is not a 2820 // qualification conversion. 2821 if (FromType.getUnqualifiedType() == ToType.getUnqualifiedType()) 2822 return false; 2823 2824 // (C++ 4.4p4): 2825 // A conversion can add cv-qualifiers at levels other than the first 2826 // in multi-level pointers, subject to the following rules: [...] 2827 bool PreviousToQualsIncludeConst = true; 2828 bool UnwrappedAnyPointer = false; 2829 while (Context.UnwrapSimilarPointerTypes(FromType, ToType)) { 2830 // Within each iteration of the loop, we check the qualifiers to 2831 // determine if this still looks like a qualification 2832 // conversion. Then, if all is well, we unwrap one more level of 2833 // pointers or pointers-to-members and do it all again 2834 // until there are no more pointers or pointers-to-members left to 2835 // unwrap. 2836 UnwrappedAnyPointer = true; 2837 2838 Qualifiers FromQuals = FromType.getQualifiers(); 2839 Qualifiers ToQuals = ToType.getQualifiers(); 2840 2841 // Objective-C ARC: 2842 // Check Objective-C lifetime conversions. 2843 if (FromQuals.getObjCLifetime() != ToQuals.getObjCLifetime() && 2844 UnwrappedAnyPointer) { 2845 if (ToQuals.compatiblyIncludesObjCLifetime(FromQuals)) { 2846 if (isNonTrivialObjCLifetimeConversion(FromQuals, ToQuals)) 2847 ObjCLifetimeConversion = true; 2848 FromQuals.removeObjCLifetime(); 2849 ToQuals.removeObjCLifetime(); 2850 } else { 2851 // Qualification conversions cannot cast between different 2852 // Objective-C lifetime qualifiers. 2853 return false; 2854 } 2855 } 2856 2857 // Allow addition/removal of GC attributes but not changing GC attributes. 2858 if (FromQuals.getObjCGCAttr() != ToQuals.getObjCGCAttr() && 2859 (!FromQuals.hasObjCGCAttr() || !ToQuals.hasObjCGCAttr())) { 2860 FromQuals.removeObjCGCAttr(); 2861 ToQuals.removeObjCGCAttr(); 2862 } 2863 2864 // -- for every j > 0, if const is in cv 1,j then const is in cv 2865 // 2,j, and similarly for volatile. 2866 if (!CStyle && !ToQuals.compatiblyIncludes(FromQuals)) 2867 return false; 2868 2869 // -- if the cv 1,j and cv 2,j are different, then const is in 2870 // every cv for 0 < k < j. 2871 if (!CStyle && FromQuals.getCVRQualifiers() != ToQuals.getCVRQualifiers() 2872 && !PreviousToQualsIncludeConst) 2873 return false; 2874 2875 // Keep track of whether all prior cv-qualifiers in the "to" type 2876 // include const. 2877 PreviousToQualsIncludeConst 2878 = PreviousToQualsIncludeConst && ToQuals.hasConst(); 2879 } 2880 2881 // We are left with FromType and ToType being the pointee types 2882 // after unwrapping the original FromType and ToType the same number 2883 // of types. If we unwrapped any pointers, and if FromType and 2884 // ToType have the same unqualified type (since we checked 2885 // qualifiers above), then this is a qualification conversion. 2886 return UnwrappedAnyPointer && Context.hasSameUnqualifiedType(FromType,ToType); 2887} 2888 2889/// \brief - Determine whether this is a conversion from a scalar type to an 2890/// atomic type. 2891/// 2892/// If successful, updates \c SCS's second and third steps in the conversion 2893/// sequence to finish the conversion. 2894static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType, 2895 bool InOverloadResolution, 2896 StandardConversionSequence &SCS, 2897 bool CStyle) { 2898 const AtomicType *ToAtomic = ToType->getAs<AtomicType>(); 2899 if (!ToAtomic) 2900 return false; 2901 2902 StandardConversionSequence InnerSCS; 2903 if (!IsStandardConversion(S, From, ToAtomic->getValueType(), 2904 InOverloadResolution, InnerSCS, 2905 CStyle, /*AllowObjCWritebackConversion=*/false)) 2906 return false; 2907 2908 SCS.Second = InnerSCS.Second; 2909 SCS.setToType(1, InnerSCS.getToType(1)); 2910 SCS.Third = InnerSCS.Third; 2911 SCS.QualificationIncludesObjCLifetime 2912 = InnerSCS.QualificationIncludesObjCLifetime; 2913 SCS.setToType(2, InnerSCS.getToType(2)); 2914 return true; 2915} 2916 2917static bool isFirstArgumentCompatibleWithType(ASTContext &Context, 2918 CXXConstructorDecl *Constructor, 2919 QualType Type) { 2920 const FunctionProtoType *CtorType = 2921 Constructor->getType()->getAs<FunctionProtoType>(); 2922 if (CtorType->getNumArgs() > 0) { 2923 QualType FirstArg = CtorType->getArgType(0); 2924 if (Context.hasSameUnqualifiedType(Type, FirstArg.getNonReferenceType())) 2925 return true; 2926 } 2927 return false; 2928} 2929 2930static OverloadingResult 2931IsInitializerListConstructorConversion(Sema &S, Expr *From, QualType ToType, 2932 CXXRecordDecl *To, 2933 UserDefinedConversionSequence &User, 2934 OverloadCandidateSet &CandidateSet, 2935 bool AllowExplicit) { 2936 DeclContext::lookup_result R = S.LookupConstructors(To); 2937 for (DeclContext::lookup_iterator Con = R.begin(), ConEnd = R.end(); 2938 Con != ConEnd; ++Con) { 2939 NamedDecl *D = *Con; 2940 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess()); 2941 2942 // Find the constructor (which may be a template). 2943 CXXConstructorDecl *Constructor = 0; 2944 FunctionTemplateDecl *ConstructorTmpl 2945 = dyn_cast<FunctionTemplateDecl>(D); 2946 if (ConstructorTmpl) 2947 Constructor 2948 = cast<CXXConstructorDecl>(ConstructorTmpl->getTemplatedDecl()); 2949 else 2950 Constructor = cast<CXXConstructorDecl>(D); 2951 2952 bool Usable = !Constructor->isInvalidDecl() && 2953 S.isInitListConstructor(Constructor) && 2954 (AllowExplicit || !Constructor->isExplicit()); 2955 if (Usable) { 2956 // If the first argument is (a reference to) the target type, 2957 // suppress conversions. 2958 bool SuppressUserConversions = 2959 isFirstArgumentCompatibleWithType(S.Context, Constructor, ToType); 2960 if (ConstructorTmpl) 2961 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl, 2962 /*ExplicitArgs*/ 0, 2963 From, CandidateSet, 2964 SuppressUserConversions); 2965 else 2966 S.AddOverloadCandidate(Constructor, FoundDecl, 2967 From, CandidateSet, 2968 SuppressUserConversions); 2969 } 2970 } 2971 2972 bool HadMultipleCandidates = (CandidateSet.size() > 1); 2973 2974 OverloadCandidateSet::iterator Best; 2975 switch (CandidateSet.BestViableFunction(S, From->getLocStart(), Best, true)) { 2976 case OR_Success: { 2977 // Record the standard conversion we used and the conversion function. 2978 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function); 2979 QualType ThisType = Constructor->getThisType(S.Context); 2980 // Initializer lists don't have conversions as such. 2981 User.Before.setAsIdentityConversion(); 2982 User.HadMultipleCandidates = HadMultipleCandidates; 2983 User.ConversionFunction = Constructor; 2984 User.FoundConversionFunction = Best->FoundDecl; 2985 User.After.setAsIdentityConversion(); 2986 User.After.setFromType(ThisType->getAs<PointerType>()->getPointeeType()); 2987 User.After.setAllToTypes(ToType); 2988 return OR_Success; 2989 } 2990 2991 case OR_No_Viable_Function: 2992 return OR_No_Viable_Function; 2993 case OR_Deleted: 2994 return OR_Deleted; 2995 case OR_Ambiguous: 2996 return OR_Ambiguous; 2997 } 2998 2999 llvm_unreachable("Invalid OverloadResult!"); 3000} 3001 3002/// Determines whether there is a user-defined conversion sequence 3003/// (C++ [over.ics.user]) that converts expression From to the type 3004/// ToType. If such a conversion exists, User will contain the 3005/// user-defined conversion sequence that performs such a conversion 3006/// and this routine will return true. Otherwise, this routine returns 3007/// false and User is unspecified. 3008/// 3009/// \param AllowExplicit true if the conversion should consider C++0x 3010/// "explicit" conversion functions as well as non-explicit conversion 3011/// functions (C++0x [class.conv.fct]p2). 3012/// 3013/// \param AllowObjCConversionOnExplicit true if the conversion should 3014/// allow an extra Objective-C pointer conversion on uses of explicit 3015/// constructors. Requires \c AllowExplicit to also be set. 3016static OverloadingResult 3017IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType, 3018 UserDefinedConversionSequence &User, 3019 OverloadCandidateSet &CandidateSet, 3020 bool AllowExplicit, 3021 bool AllowObjCConversionOnExplicit) { 3022 assert(AllowExplicit || !AllowObjCConversionOnExplicit); 3023 3024 // Whether we will only visit constructors. 3025 bool ConstructorsOnly = false; 3026 3027 // If the type we are conversion to is a class type, enumerate its 3028 // constructors. 3029 if (const RecordType *ToRecordType = ToType->getAs<RecordType>()) { 3030 // C++ [over.match.ctor]p1: 3031 // When objects of class type are direct-initialized (8.5), or 3032 // copy-initialized from an expression of the same or a 3033 // derived class type (8.5), overload resolution selects the 3034 // constructor. [...] For copy-initialization, the candidate 3035 // functions are all the converting constructors (12.3.1) of 3036 // that class. The argument list is the expression-list within 3037 // the parentheses of the initializer. 3038 if (S.Context.hasSameUnqualifiedType(ToType, From->getType()) || 3039 (From->getType()->getAs<RecordType>() && 3040 S.IsDerivedFrom(From->getType(), ToType))) 3041 ConstructorsOnly = true; 3042 3043 S.RequireCompleteType(From->getExprLoc(), ToType, 0); 3044 // RequireCompleteType may have returned true due to some invalid decl 3045 // during template instantiation, but ToType may be complete enough now 3046 // to try to recover. 3047 if (ToType->isIncompleteType()) { 3048 // We're not going to find any constructors. 3049 } else if (CXXRecordDecl *ToRecordDecl 3050 = dyn_cast<CXXRecordDecl>(ToRecordType->getDecl())) { 3051 3052 Expr **Args = &From; 3053 unsigned NumArgs = 1; 3054 bool ListInitializing = false; 3055 if (InitListExpr *InitList = dyn_cast<InitListExpr>(From)) { 3056 // But first, see if there is an init-list-constructor that will work. 3057 OverloadingResult Result = IsInitializerListConstructorConversion( 3058 S, From, ToType, ToRecordDecl, User, CandidateSet, AllowExplicit); 3059 if (Result != OR_No_Viable_Function) 3060 return Result; 3061 // Never mind. 3062 CandidateSet.clear(); 3063 3064 // If we're list-initializing, we pass the individual elements as 3065 // arguments, not the entire list. 3066 Args = InitList->getInits(); 3067 NumArgs = InitList->getNumInits(); 3068 ListInitializing = true; 3069 } 3070 3071 DeclContext::lookup_result R = S.LookupConstructors(ToRecordDecl); 3072 for (DeclContext::lookup_iterator Con = R.begin(), ConEnd = R.end(); 3073 Con != ConEnd; ++Con) { 3074 NamedDecl *D = *Con; 3075 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess()); 3076 3077 // Find the constructor (which may be a template). 3078 CXXConstructorDecl *Constructor = 0; 3079 FunctionTemplateDecl *ConstructorTmpl 3080 = dyn_cast<FunctionTemplateDecl>(D); 3081 if (ConstructorTmpl) 3082 Constructor 3083 = cast<CXXConstructorDecl>(ConstructorTmpl->getTemplatedDecl()); 3084 else 3085 Constructor = cast<CXXConstructorDecl>(D); 3086 3087 bool Usable = !Constructor->isInvalidDecl(); 3088 if (ListInitializing) 3089 Usable = Usable && (AllowExplicit || !Constructor->isExplicit()); 3090 else 3091 Usable = Usable &&Constructor->isConvertingConstructor(AllowExplicit); 3092 if (Usable) { 3093 bool SuppressUserConversions = !ConstructorsOnly; 3094 if (SuppressUserConversions && ListInitializing) { 3095 SuppressUserConversions = false; 3096 if (NumArgs == 1) { 3097 // If the first argument is (a reference to) the target type, 3098 // suppress conversions. 3099 SuppressUserConversions = isFirstArgumentCompatibleWithType( 3100 S.Context, Constructor, ToType); 3101 } 3102 } 3103 if (ConstructorTmpl) 3104 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl, 3105 /*ExplicitArgs*/ 0, 3106 llvm::makeArrayRef(Args, NumArgs), 3107 CandidateSet, SuppressUserConversions); 3108 else 3109 // Allow one user-defined conversion when user specifies a 3110 // From->ToType conversion via an static cast (c-style, etc). 3111 S.AddOverloadCandidate(Constructor, FoundDecl, 3112 llvm::makeArrayRef(Args, NumArgs), 3113 CandidateSet, SuppressUserConversions); 3114 } 3115 } 3116 } 3117 } 3118 3119 // Enumerate conversion functions, if we're allowed to. 3120 if (ConstructorsOnly || isa<InitListExpr>(From)) { 3121 } else if (S.RequireCompleteType(From->getLocStart(), From->getType(), 0)) { 3122 // No conversion functions from incomplete types. 3123 } else if (const RecordType *FromRecordType 3124 = From->getType()->getAs<RecordType>()) { 3125 if (CXXRecordDecl *FromRecordDecl 3126 = dyn_cast<CXXRecordDecl>(FromRecordType->getDecl())) { 3127 // Add all of the conversion functions as candidates. 3128 std::pair<CXXRecordDecl::conversion_iterator, 3129 CXXRecordDecl::conversion_iterator> 3130 Conversions = FromRecordDecl->getVisibleConversionFunctions(); 3131 for (CXXRecordDecl::conversion_iterator 3132 I = Conversions.first, E = Conversions.second; I != E; ++I) { 3133 DeclAccessPair FoundDecl = I.getPair(); 3134 NamedDecl *D = FoundDecl.getDecl(); 3135 CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext()); 3136 if (isa<UsingShadowDecl>(D)) 3137 D = cast<UsingShadowDecl>(D)->getTargetDecl(); 3138 3139 CXXConversionDecl *Conv; 3140 FunctionTemplateDecl *ConvTemplate; 3141 if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D))) 3142 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl()); 3143 else 3144 Conv = cast<CXXConversionDecl>(D); 3145 3146 if (AllowExplicit || !Conv->isExplicit()) { 3147 if (ConvTemplate) 3148 S.AddTemplateConversionCandidate(ConvTemplate, FoundDecl, 3149 ActingContext, From, ToType, 3150 CandidateSet, 3151 AllowObjCConversionOnExplicit); 3152 else 3153 S.AddConversionCandidate(Conv, FoundDecl, ActingContext, 3154 From, ToType, CandidateSet, 3155 AllowObjCConversionOnExplicit); 3156 } 3157 } 3158 } 3159 } 3160 3161 bool HadMultipleCandidates = (CandidateSet.size() > 1); 3162 3163 OverloadCandidateSet::iterator Best; 3164 switch (CandidateSet.BestViableFunction(S, From->getLocStart(), Best, true)) { 3165 case OR_Success: 3166 // Record the standard conversion we used and the conversion function. 3167 if (CXXConstructorDecl *Constructor 3168 = dyn_cast<CXXConstructorDecl>(Best->Function)) { 3169 // C++ [over.ics.user]p1: 3170 // If the user-defined conversion is specified by a 3171 // constructor (12.3.1), the initial standard conversion 3172 // sequence converts the source type to the type required by 3173 // the argument of the constructor. 3174 // 3175 QualType ThisType = Constructor->getThisType(S.Context); 3176 if (isa<InitListExpr>(From)) { 3177 // Initializer lists don't have conversions as such. 3178 User.Before.setAsIdentityConversion(); 3179 } else { 3180 if (Best->Conversions[0].isEllipsis()) 3181 User.EllipsisConversion = true; 3182 else { 3183 User.Before = Best->Conversions[0].Standard; 3184 User.EllipsisConversion = false; 3185 } 3186 } 3187 User.HadMultipleCandidates = HadMultipleCandidates; 3188 User.ConversionFunction = Constructor; 3189 User.FoundConversionFunction = Best->FoundDecl; 3190 User.After.setAsIdentityConversion(); 3191 User.After.setFromType(ThisType->getAs<PointerType>()->getPointeeType()); 3192 User.After.setAllToTypes(ToType); 3193 return OR_Success; 3194 } 3195 if (CXXConversionDecl *Conversion 3196 = dyn_cast<CXXConversionDecl>(Best->Function)) { 3197 // C++ [over.ics.user]p1: 3198 // 3199 // [...] If the user-defined conversion is specified by a 3200 // conversion function (12.3.2), the initial standard 3201 // conversion sequence converts the source type to the 3202 // implicit object parameter of the conversion function. 3203 User.Before = Best->Conversions[0].Standard; 3204 User.HadMultipleCandidates = HadMultipleCandidates; 3205 User.ConversionFunction = Conversion; 3206 User.FoundConversionFunction = Best->FoundDecl; 3207 User.EllipsisConversion = false; 3208 3209 // C++ [over.ics.user]p2: 3210 // The second standard conversion sequence converts the 3211 // result of the user-defined conversion to the target type 3212 // for the sequence. Since an implicit conversion sequence 3213 // is an initialization, the special rules for 3214 // initialization by user-defined conversion apply when 3215 // selecting the best user-defined conversion for a 3216 // user-defined conversion sequence (see 13.3.3 and 3217 // 13.3.3.1). 3218 User.After = Best->FinalConversion; 3219 return OR_Success; 3220 } 3221 llvm_unreachable("Not a constructor or conversion function?"); 3222 3223 case OR_No_Viable_Function: 3224 return OR_No_Viable_Function; 3225 case OR_Deleted: 3226 // No conversion here! We're done. 3227 return OR_Deleted; 3228 3229 case OR_Ambiguous: 3230 return OR_Ambiguous; 3231 } 3232 3233 llvm_unreachable("Invalid OverloadResult!"); 3234} 3235 3236bool 3237Sema::DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType) { 3238 ImplicitConversionSequence ICS; 3239 OverloadCandidateSet CandidateSet(From->getExprLoc()); 3240 OverloadingResult OvResult = 3241 IsUserDefinedConversion(*this, From, ToType, ICS.UserDefined, 3242 CandidateSet, false, false); 3243 if (OvResult == OR_Ambiguous) 3244 Diag(From->getLocStart(), 3245 diag::err_typecheck_ambiguous_condition) 3246 << From->getType() << ToType << From->getSourceRange(); 3247 else if (OvResult == OR_No_Viable_Function && !CandidateSet.empty()) { 3248 if (!RequireCompleteType(From->getLocStart(), ToType, 3249 diag::err_typecheck_nonviable_condition_incomplete, 3250 From->getType(), From->getSourceRange())) 3251 Diag(From->getLocStart(), 3252 diag::err_typecheck_nonviable_condition) 3253 << From->getType() << From->getSourceRange() << ToType; 3254 } 3255 else 3256 return false; 3257 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, From); 3258 return true; 3259} 3260 3261/// \brief Compare the user-defined conversion functions or constructors 3262/// of two user-defined conversion sequences to determine whether any ordering 3263/// is possible. 3264static ImplicitConversionSequence::CompareKind 3265compareConversionFunctions(Sema &S, 3266 FunctionDecl *Function1, 3267 FunctionDecl *Function2) { 3268 if (!S.getLangOpts().ObjC1 || !S.getLangOpts().CPlusPlus11) 3269 return ImplicitConversionSequence::Indistinguishable; 3270 3271 // Objective-C++: 3272 // If both conversion functions are implicitly-declared conversions from 3273 // a lambda closure type to a function pointer and a block pointer, 3274 // respectively, always prefer the conversion to a function pointer, 3275 // because the function pointer is more lightweight and is more likely 3276 // to keep code working. 3277 CXXConversionDecl *Conv1 = dyn_cast<CXXConversionDecl>(Function1); 3278 if (!Conv1) 3279 return ImplicitConversionSequence::Indistinguishable; 3280 3281 CXXConversionDecl *Conv2 = dyn_cast<CXXConversionDecl>(Function2); 3282 if (!Conv2) 3283 return ImplicitConversionSequence::Indistinguishable; 3284 3285 if (Conv1->getParent()->isLambda() && Conv2->getParent()->isLambda()) { 3286 bool Block1 = Conv1->getConversionType()->isBlockPointerType(); 3287 bool Block2 = Conv2->getConversionType()->isBlockPointerType(); 3288 if (Block1 != Block2) 3289 return Block1? ImplicitConversionSequence::Worse 3290 : ImplicitConversionSequence::Better; 3291 } 3292 3293 return ImplicitConversionSequence::Indistinguishable; 3294} 3295 3296/// CompareImplicitConversionSequences - Compare two implicit 3297/// conversion sequences to determine whether one is better than the 3298/// other or if they are indistinguishable (C++ 13.3.3.2). 3299static ImplicitConversionSequence::CompareKind 3300CompareImplicitConversionSequences(Sema &S, 3301 const ImplicitConversionSequence& ICS1, 3302 const ImplicitConversionSequence& ICS2) 3303{ 3304 // (C++ 13.3.3.2p2): When comparing the basic forms of implicit 3305 // conversion sequences (as defined in 13.3.3.1) 3306 // -- a standard conversion sequence (13.3.3.1.1) is a better 3307 // conversion sequence than a user-defined conversion sequence or 3308 // an ellipsis conversion sequence, and 3309 // -- a user-defined conversion sequence (13.3.3.1.2) is a better 3310 // conversion sequence than an ellipsis conversion sequence 3311 // (13.3.3.1.3). 3312 // 3313 // C++0x [over.best.ics]p10: 3314 // For the purpose of ranking implicit conversion sequences as 3315 // described in 13.3.3.2, the ambiguous conversion sequence is 3316 // treated as a user-defined sequence that is indistinguishable 3317 // from any other user-defined conversion sequence. 3318 if (ICS1.getKindRank() < ICS2.getKindRank()) 3319 return ImplicitConversionSequence::Better; 3320 if (ICS2.getKindRank() < ICS1.getKindRank()) 3321 return ImplicitConversionSequence::Worse; 3322 3323 // The following checks require both conversion sequences to be of 3324 // the same kind. 3325 if (ICS1.getKind() != ICS2.getKind()) 3326 return ImplicitConversionSequence::Indistinguishable; 3327 3328 ImplicitConversionSequence::CompareKind Result = 3329 ImplicitConversionSequence::Indistinguishable; 3330 3331 // Two implicit conversion sequences of the same form are 3332 // indistinguishable conversion sequences unless one of the 3333 // following rules apply: (C++ 13.3.3.2p3): 3334 if (ICS1.isStandard()) 3335 Result = CompareStandardConversionSequences(S, 3336 ICS1.Standard, ICS2.Standard); 3337 else if (ICS1.isUserDefined()) { 3338 // User-defined conversion sequence U1 is a better conversion 3339 // sequence than another user-defined conversion sequence U2 if 3340 // they contain the same user-defined conversion function or 3341 // constructor and if the second standard conversion sequence of 3342 // U1 is better than the second standard conversion sequence of 3343 // U2 (C++ 13.3.3.2p3). 3344 if (ICS1.UserDefined.ConversionFunction == 3345 ICS2.UserDefined.ConversionFunction) 3346 Result = CompareStandardConversionSequences(S, 3347 ICS1.UserDefined.After, 3348 ICS2.UserDefined.After); 3349 else 3350 Result = compareConversionFunctions(S, 3351 ICS1.UserDefined.ConversionFunction, 3352 ICS2.UserDefined.ConversionFunction); 3353 } 3354 3355 // List-initialization sequence L1 is a better conversion sequence than 3356 // list-initialization sequence L2 if L1 converts to std::initializer_list<X> 3357 // for some X and L2 does not. 3358 if (Result == ImplicitConversionSequence::Indistinguishable && 3359 !ICS1.isBad()) { 3360 if (ICS1.isStdInitializerListElement() && 3361 !ICS2.isStdInitializerListElement()) 3362 return ImplicitConversionSequence::Better; 3363 if (!ICS1.isStdInitializerListElement() && 3364 ICS2.isStdInitializerListElement()) 3365 return ImplicitConversionSequence::Worse; 3366 } 3367 3368 return Result; 3369} 3370 3371static bool hasSimilarType(ASTContext &Context, QualType T1, QualType T2) { 3372 while (Context.UnwrapSimilarPointerTypes(T1, T2)) { 3373 Qualifiers Quals; 3374 T1 = Context.getUnqualifiedArrayType(T1, Quals); 3375 T2 = Context.getUnqualifiedArrayType(T2, Quals); 3376 } 3377 3378 return Context.hasSameUnqualifiedType(T1, T2); 3379} 3380 3381// Per 13.3.3.2p3, compare the given standard conversion sequences to 3382// determine if one is a proper subset of the other. 3383static ImplicitConversionSequence::CompareKind 3384compareStandardConversionSubsets(ASTContext &Context, 3385 const StandardConversionSequence& SCS1, 3386 const StandardConversionSequence& SCS2) { 3387 ImplicitConversionSequence::CompareKind Result 3388 = ImplicitConversionSequence::Indistinguishable; 3389 3390 // the identity conversion sequence is considered to be a subsequence of 3391 // any non-identity conversion sequence 3392 if (SCS1.isIdentityConversion() && !SCS2.isIdentityConversion()) 3393 return ImplicitConversionSequence::Better; 3394 else if (!SCS1.isIdentityConversion() && SCS2.isIdentityConversion()) 3395 return ImplicitConversionSequence::Worse; 3396 3397 if (SCS1.Second != SCS2.Second) { 3398 if (SCS1.Second == ICK_Identity) 3399 Result = ImplicitConversionSequence::Better; 3400 else if (SCS2.Second == ICK_Identity) 3401 Result = ImplicitConversionSequence::Worse; 3402 else 3403 return ImplicitConversionSequence::Indistinguishable; 3404 } else if (!hasSimilarType(Context, SCS1.getToType(1), SCS2.getToType(1))) 3405 return ImplicitConversionSequence::Indistinguishable; 3406 3407 if (SCS1.Third == SCS2.Third) { 3408 return Context.hasSameType(SCS1.getToType(2), SCS2.getToType(2))? Result 3409 : ImplicitConversionSequence::Indistinguishable; 3410 } 3411 3412 if (SCS1.Third == ICK_Identity) 3413 return Result == ImplicitConversionSequence::Worse 3414 ? ImplicitConversionSequence::Indistinguishable 3415 : ImplicitConversionSequence::Better; 3416 3417 if (SCS2.Third == ICK_Identity) 3418 return Result == ImplicitConversionSequence::Better 3419 ? ImplicitConversionSequence::Indistinguishable 3420 : ImplicitConversionSequence::Worse; 3421 3422 return ImplicitConversionSequence::Indistinguishable; 3423} 3424 3425/// \brief Determine whether one of the given reference bindings is better 3426/// than the other based on what kind of bindings they are. 3427static bool isBetterReferenceBindingKind(const StandardConversionSequence &SCS1, 3428 const StandardConversionSequence &SCS2) { 3429 // C++0x [over.ics.rank]p3b4: 3430 // -- S1 and S2 are reference bindings (8.5.3) and neither refers to an 3431 // implicit object parameter of a non-static member function declared 3432 // without a ref-qualifier, and *either* S1 binds an rvalue reference 3433 // to an rvalue and S2 binds an lvalue reference *or S1 binds an 3434 // lvalue reference to a function lvalue and S2 binds an rvalue 3435 // reference*. 3436 // 3437 // FIXME: Rvalue references. We're going rogue with the above edits, 3438 // because the semantics in the current C++0x working paper (N3225 at the 3439 // time of this writing) break the standard definition of std::forward 3440 // and std::reference_wrapper when dealing with references to functions. 3441 // Proposed wording changes submitted to CWG for consideration. 3442 if (SCS1.BindsImplicitObjectArgumentWithoutRefQualifier || 3443 SCS2.BindsImplicitObjectArgumentWithoutRefQualifier) 3444 return false; 3445 3446 return (!SCS1.IsLvalueReference && SCS1.BindsToRvalue && 3447 SCS2.IsLvalueReference) || 3448 (SCS1.IsLvalueReference && SCS1.BindsToFunctionLvalue && 3449 !SCS2.IsLvalueReference); 3450} 3451 3452/// CompareStandardConversionSequences - Compare two standard 3453/// conversion sequences to determine whether one is better than the 3454/// other or if they are indistinguishable (C++ 13.3.3.2p3). 3455static ImplicitConversionSequence::CompareKind 3456CompareStandardConversionSequences(Sema &S, 3457 const StandardConversionSequence& SCS1, 3458 const StandardConversionSequence& SCS2) 3459{ 3460 // Standard conversion sequence S1 is a better conversion sequence 3461 // than standard conversion sequence S2 if (C++ 13.3.3.2p3): 3462 3463 // -- S1 is a proper subsequence of S2 (comparing the conversion 3464 // sequences in the canonical form defined by 13.3.3.1.1, 3465 // excluding any Lvalue Transformation; the identity conversion 3466 // sequence is considered to be a subsequence of any 3467 // non-identity conversion sequence) or, if not that, 3468 if (ImplicitConversionSequence::CompareKind CK 3469 = compareStandardConversionSubsets(S.Context, SCS1, SCS2)) 3470 return CK; 3471 3472 // -- the rank of S1 is better than the rank of S2 (by the rules 3473 // defined below), or, if not that, 3474 ImplicitConversionRank Rank1 = SCS1.getRank(); 3475 ImplicitConversionRank Rank2 = SCS2.getRank(); 3476 if (Rank1 < Rank2) 3477 return ImplicitConversionSequence::Better; 3478 else if (Rank2 < Rank1) 3479 return ImplicitConversionSequence::Worse; 3480 3481 // (C++ 13.3.3.2p4): Two conversion sequences with the same rank 3482 // are indistinguishable unless one of the following rules 3483 // applies: 3484 3485 // A conversion that is not a conversion of a pointer, or 3486 // pointer to member, to bool is better than another conversion 3487 // that is such a conversion. 3488 if (SCS1.isPointerConversionToBool() != SCS2.isPointerConversionToBool()) 3489 return SCS2.isPointerConversionToBool() 3490 ? ImplicitConversionSequence::Better 3491 : ImplicitConversionSequence::Worse; 3492 3493 // C++ [over.ics.rank]p4b2: 3494 // 3495 // If class B is derived directly or indirectly from class A, 3496 // conversion of B* to A* is better than conversion of B* to 3497 // void*, and conversion of A* to void* is better than conversion 3498 // of B* to void*. 3499 bool SCS1ConvertsToVoid 3500 = SCS1.isPointerConversionToVoidPointer(S.Context); 3501 bool SCS2ConvertsToVoid 3502 = SCS2.isPointerConversionToVoidPointer(S.Context); 3503 if (SCS1ConvertsToVoid != SCS2ConvertsToVoid) { 3504 // Exactly one of the conversion sequences is a conversion to 3505 // a void pointer; it's the worse conversion. 3506 return SCS2ConvertsToVoid ? ImplicitConversionSequence::Better 3507 : ImplicitConversionSequence::Worse; 3508 } else if (!SCS1ConvertsToVoid && !SCS2ConvertsToVoid) { 3509 // Neither conversion sequence converts to a void pointer; compare 3510 // their derived-to-base conversions. 3511 if (ImplicitConversionSequence::CompareKind DerivedCK 3512 = CompareDerivedToBaseConversions(S, SCS1, SCS2)) 3513 return DerivedCK; 3514 } else if (SCS1ConvertsToVoid && SCS2ConvertsToVoid && 3515 !S.Context.hasSameType(SCS1.getFromType(), SCS2.getFromType())) { 3516 // Both conversion sequences are conversions to void 3517 // pointers. Compare the source types to determine if there's an 3518 // inheritance relationship in their sources. 3519 QualType FromType1 = SCS1.getFromType(); 3520 QualType FromType2 = SCS2.getFromType(); 3521 3522 // Adjust the types we're converting from via the array-to-pointer 3523 // conversion, if we need to. 3524 if (SCS1.First == ICK_Array_To_Pointer) 3525 FromType1 = S.Context.getArrayDecayedType(FromType1); 3526 if (SCS2.First == ICK_Array_To_Pointer) 3527 FromType2 = S.Context.getArrayDecayedType(FromType2); 3528 3529 QualType FromPointee1 = FromType1->getPointeeType().getUnqualifiedType(); 3530 QualType FromPointee2 = FromType2->getPointeeType().getUnqualifiedType(); 3531 3532 if (S.IsDerivedFrom(FromPointee2, FromPointee1)) 3533 return ImplicitConversionSequence::Better; 3534 else if (S.IsDerivedFrom(FromPointee1, FromPointee2)) 3535 return ImplicitConversionSequence::Worse; 3536 3537 // Objective-C++: If one interface is more specific than the 3538 // other, it is the better one. 3539 const ObjCObjectPointerType* FromObjCPtr1 3540 = FromType1->getAs<ObjCObjectPointerType>(); 3541 const ObjCObjectPointerType* FromObjCPtr2 3542 = FromType2->getAs<ObjCObjectPointerType>(); 3543 if (FromObjCPtr1 && FromObjCPtr2) { 3544 bool AssignLeft = S.Context.canAssignObjCInterfaces(FromObjCPtr1, 3545 FromObjCPtr2); 3546 bool AssignRight = S.Context.canAssignObjCInterfaces(FromObjCPtr2, 3547 FromObjCPtr1); 3548 if (AssignLeft != AssignRight) { 3549 return AssignLeft? ImplicitConversionSequence::Better 3550 : ImplicitConversionSequence::Worse; 3551 } 3552 } 3553 } 3554 3555 // Compare based on qualification conversions (C++ 13.3.3.2p3, 3556 // bullet 3). 3557 if (ImplicitConversionSequence::CompareKind QualCK 3558 = CompareQualificationConversions(S, SCS1, SCS2)) 3559 return QualCK; 3560 3561 if (SCS1.ReferenceBinding && SCS2.ReferenceBinding) { 3562 // Check for a better reference binding based on the kind of bindings. 3563 if (isBetterReferenceBindingKind(SCS1, SCS2)) 3564 return ImplicitConversionSequence::Better; 3565 else if (isBetterReferenceBindingKind(SCS2, SCS1)) 3566 return ImplicitConversionSequence::Worse; 3567 3568 // C++ [over.ics.rank]p3b4: 3569 // -- S1 and S2 are reference bindings (8.5.3), and the types to 3570 // which the references refer are the same type except for 3571 // top-level cv-qualifiers, and the type to which the reference 3572 // initialized by S2 refers is more cv-qualified than the type 3573 // to which the reference initialized by S1 refers. 3574 QualType T1 = SCS1.getToType(2); 3575 QualType T2 = SCS2.getToType(2); 3576 T1 = S.Context.getCanonicalType(T1); 3577 T2 = S.Context.getCanonicalType(T2); 3578 Qualifiers T1Quals, T2Quals; 3579 QualType UnqualT1 = S.Context.getUnqualifiedArrayType(T1, T1Quals); 3580 QualType UnqualT2 = S.Context.getUnqualifiedArrayType(T2, T2Quals); 3581 if (UnqualT1 == UnqualT2) { 3582 // Objective-C++ ARC: If the references refer to objects with different 3583 // lifetimes, prefer bindings that don't change lifetime. 3584 if (SCS1.ObjCLifetimeConversionBinding != 3585 SCS2.ObjCLifetimeConversionBinding) { 3586 return SCS1.ObjCLifetimeConversionBinding 3587 ? ImplicitConversionSequence::Worse 3588 : ImplicitConversionSequence::Better; 3589 } 3590 3591 // If the type is an array type, promote the element qualifiers to the 3592 // type for comparison. 3593 if (isa<ArrayType>(T1) && T1Quals) 3594 T1 = S.Context.getQualifiedType(UnqualT1, T1Quals); 3595 if (isa<ArrayType>(T2) && T2Quals) 3596 T2 = S.Context.getQualifiedType(UnqualT2, T2Quals); 3597 if (T2.isMoreQualifiedThan(T1)) 3598 return ImplicitConversionSequence::Better; 3599 else if (T1.isMoreQualifiedThan(T2)) 3600 return ImplicitConversionSequence::Worse; 3601 } 3602 } 3603 3604 // In Microsoft mode, prefer an integral conversion to a 3605 // floating-to-integral conversion if the integral conversion 3606 // is between types of the same size. 3607 // For example: 3608 // void f(float); 3609 // void f(int); 3610 // int main { 3611 // long a; 3612 // f(a); 3613 // } 3614 // Here, MSVC will call f(int) instead of generating a compile error 3615 // as clang will do in standard mode. 3616 if (S.getLangOpts().MicrosoftMode && 3617 SCS1.Second == ICK_Integral_Conversion && 3618 SCS2.Second == ICK_Floating_Integral && 3619 S.Context.getTypeSize(SCS1.getFromType()) == 3620 S.Context.getTypeSize(SCS1.getToType(2))) 3621 return ImplicitConversionSequence::Better; 3622 3623 return ImplicitConversionSequence::Indistinguishable; 3624} 3625 3626/// CompareQualificationConversions - Compares two standard conversion 3627/// sequences to determine whether they can be ranked based on their 3628/// qualification conversions (C++ 13.3.3.2p3 bullet 3). 3629ImplicitConversionSequence::CompareKind 3630CompareQualificationConversions(Sema &S, 3631 const StandardConversionSequence& SCS1, 3632 const StandardConversionSequence& SCS2) { 3633 // C++ 13.3.3.2p3: 3634 // -- S1 and S2 differ only in their qualification conversion and 3635 // yield similar types T1 and T2 (C++ 4.4), respectively, and the 3636 // cv-qualification signature of type T1 is a proper subset of 3637 // the cv-qualification signature of type T2, and S1 is not the 3638 // deprecated string literal array-to-pointer conversion (4.2). 3639 if (SCS1.First != SCS2.First || SCS1.Second != SCS2.Second || 3640 SCS1.Third != SCS2.Third || SCS1.Third != ICK_Qualification) 3641 return ImplicitConversionSequence::Indistinguishable; 3642 3643 // FIXME: the example in the standard doesn't use a qualification 3644 // conversion (!) 3645 QualType T1 = SCS1.getToType(2); 3646 QualType T2 = SCS2.getToType(2); 3647 T1 = S.Context.getCanonicalType(T1); 3648 T2 = S.Context.getCanonicalType(T2); 3649 Qualifiers T1Quals, T2Quals; 3650 QualType UnqualT1 = S.Context.getUnqualifiedArrayType(T1, T1Quals); 3651 QualType UnqualT2 = S.Context.getUnqualifiedArrayType(T2, T2Quals); 3652 3653 // If the types are the same, we won't learn anything by unwrapped 3654 // them. 3655 if (UnqualT1 == UnqualT2) 3656 return ImplicitConversionSequence::Indistinguishable; 3657 3658 // If the type is an array type, promote the element qualifiers to the type 3659 // for comparison. 3660 if (isa<ArrayType>(T1) && T1Quals) 3661 T1 = S.Context.getQualifiedType(UnqualT1, T1Quals); 3662 if (isa<ArrayType>(T2) && T2Quals) 3663 T2 = S.Context.getQualifiedType(UnqualT2, T2Quals); 3664 3665 ImplicitConversionSequence::CompareKind Result 3666 = ImplicitConversionSequence::Indistinguishable; 3667 3668 // Objective-C++ ARC: 3669 // Prefer qualification conversions not involving a change in lifetime 3670 // to qualification conversions that do not change lifetime. 3671 if (SCS1.QualificationIncludesObjCLifetime != 3672 SCS2.QualificationIncludesObjCLifetime) { 3673 Result = SCS1.QualificationIncludesObjCLifetime 3674 ? ImplicitConversionSequence::Worse 3675 : ImplicitConversionSequence::Better; 3676 } 3677 3678 while (S.Context.UnwrapSimilarPointerTypes(T1, T2)) { 3679 // Within each iteration of the loop, we check the qualifiers to 3680 // determine if this still looks like a qualification 3681 // conversion. Then, if all is well, we unwrap one more level of 3682 // pointers or pointers-to-members and do it all again 3683 // until there are no more pointers or pointers-to-members left 3684 // to unwrap. This essentially mimics what 3685 // IsQualificationConversion does, but here we're checking for a 3686 // strict subset of qualifiers. 3687 if (T1.getCVRQualifiers() == T2.getCVRQualifiers()) 3688 // The qualifiers are the same, so this doesn't tell us anything 3689 // about how the sequences rank. 3690 ; 3691 else if (T2.isMoreQualifiedThan(T1)) { 3692 // T1 has fewer qualifiers, so it could be the better sequence. 3693 if (Result == ImplicitConversionSequence::Worse) 3694 // Neither has qualifiers that are a subset of the other's 3695 // qualifiers. 3696 return ImplicitConversionSequence::Indistinguishable; 3697 3698 Result = ImplicitConversionSequence::Better; 3699 } else if (T1.isMoreQualifiedThan(T2)) { 3700 // T2 has fewer qualifiers, so it could be the better sequence. 3701 if (Result == ImplicitConversionSequence::Better) 3702 // Neither has qualifiers that are a subset of the other's 3703 // qualifiers. 3704 return ImplicitConversionSequence::Indistinguishable; 3705 3706 Result = ImplicitConversionSequence::Worse; 3707 } else { 3708 // Qualifiers are disjoint. 3709 return ImplicitConversionSequence::Indistinguishable; 3710 } 3711 3712 // If the types after this point are equivalent, we're done. 3713 if (S.Context.hasSameUnqualifiedType(T1, T2)) 3714 break; 3715 } 3716 3717 // Check that the winning standard conversion sequence isn't using 3718 // the deprecated string literal array to pointer conversion. 3719 switch (Result) { 3720 case ImplicitConversionSequence::Better: 3721 if (SCS1.DeprecatedStringLiteralToCharPtr) 3722 Result = ImplicitConversionSequence::Indistinguishable; 3723 break; 3724 3725 case ImplicitConversionSequence::Indistinguishable: 3726 break; 3727 3728 case ImplicitConversionSequence::Worse: 3729 if (SCS2.DeprecatedStringLiteralToCharPtr) 3730 Result = ImplicitConversionSequence::Indistinguishable; 3731 break; 3732 } 3733 3734 return Result; 3735} 3736 3737/// CompareDerivedToBaseConversions - Compares two standard conversion 3738/// sequences to determine whether they can be ranked based on their 3739/// various kinds of derived-to-base conversions (C++ 3740/// [over.ics.rank]p4b3). As part of these checks, we also look at 3741/// conversions between Objective-C interface types. 3742ImplicitConversionSequence::CompareKind 3743CompareDerivedToBaseConversions(Sema &S, 3744 const StandardConversionSequence& SCS1, 3745 const StandardConversionSequence& SCS2) { 3746 QualType FromType1 = SCS1.getFromType(); 3747 QualType ToType1 = SCS1.getToType(1); 3748 QualType FromType2 = SCS2.getFromType(); 3749 QualType ToType2 = SCS2.getToType(1); 3750 3751 // Adjust the types we're converting from via the array-to-pointer 3752 // conversion, if we need to. 3753 if (SCS1.First == ICK_Array_To_Pointer) 3754 FromType1 = S.Context.getArrayDecayedType(FromType1); 3755 if (SCS2.First == ICK_Array_To_Pointer) 3756 FromType2 = S.Context.getArrayDecayedType(FromType2); 3757 3758 // Canonicalize all of the types. 3759 FromType1 = S.Context.getCanonicalType(FromType1); 3760 ToType1 = S.Context.getCanonicalType(ToType1); 3761 FromType2 = S.Context.getCanonicalType(FromType2); 3762 ToType2 = S.Context.getCanonicalType(ToType2); 3763 3764 // C++ [over.ics.rank]p4b3: 3765 // 3766 // If class B is derived directly or indirectly from class A and 3767 // class C is derived directly or indirectly from B, 3768 // 3769 // Compare based on pointer conversions. 3770 if (SCS1.Second == ICK_Pointer_Conversion && 3771 SCS2.Second == ICK_Pointer_Conversion && 3772 /*FIXME: Remove if Objective-C id conversions get their own rank*/ 3773 FromType1->isPointerType() && FromType2->isPointerType() && 3774 ToType1->isPointerType() && ToType2->isPointerType()) { 3775 QualType FromPointee1 3776 = FromType1->getAs<PointerType>()->getPointeeType().getUnqualifiedType(); 3777 QualType ToPointee1 3778 = ToType1->getAs<PointerType>()->getPointeeType().getUnqualifiedType(); 3779 QualType FromPointee2 3780 = FromType2->getAs<PointerType>()->getPointeeType().getUnqualifiedType(); 3781 QualType ToPointee2 3782 = ToType2->getAs<PointerType>()->getPointeeType().getUnqualifiedType(); 3783 3784 // -- conversion of C* to B* is better than conversion of C* to A*, 3785 if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) { 3786 if (S.IsDerivedFrom(ToPointee1, ToPointee2)) 3787 return ImplicitConversionSequence::Better; 3788 else if (S.IsDerivedFrom(ToPointee2, ToPointee1)) 3789 return ImplicitConversionSequence::Worse; 3790 } 3791 3792 // -- conversion of B* to A* is better than conversion of C* to A*, 3793 if (FromPointee1 != FromPointee2 && ToPointee1 == ToPointee2) { 3794 if (S.IsDerivedFrom(FromPointee2, FromPointee1)) 3795 return ImplicitConversionSequence::Better; 3796 else if (S.IsDerivedFrom(FromPointee1, FromPointee2)) 3797 return ImplicitConversionSequence::Worse; 3798 } 3799 } else if (SCS1.Second == ICK_Pointer_Conversion && 3800 SCS2.Second == ICK_Pointer_Conversion) { 3801 const ObjCObjectPointerType *FromPtr1 3802 = FromType1->getAs<ObjCObjectPointerType>(); 3803 const ObjCObjectPointerType *FromPtr2 3804 = FromType2->getAs<ObjCObjectPointerType>(); 3805 const ObjCObjectPointerType *ToPtr1 3806 = ToType1->getAs<ObjCObjectPointerType>(); 3807 const ObjCObjectPointerType *ToPtr2 3808 = ToType2->getAs<ObjCObjectPointerType>(); 3809 3810 if (FromPtr1 && FromPtr2 && ToPtr1 && ToPtr2) { 3811 // Apply the same conversion ranking rules for Objective-C pointer types 3812 // that we do for C++ pointers to class types. However, we employ the 3813 // Objective-C pseudo-subtyping relationship used for assignment of 3814 // Objective-C pointer types. 3815 bool FromAssignLeft 3816 = S.Context.canAssignObjCInterfaces(FromPtr1, FromPtr2); 3817 bool FromAssignRight 3818 = S.Context.canAssignObjCInterfaces(FromPtr2, FromPtr1); 3819 bool ToAssignLeft 3820 = S.Context.canAssignObjCInterfaces(ToPtr1, ToPtr2); 3821 bool ToAssignRight 3822 = S.Context.canAssignObjCInterfaces(ToPtr2, ToPtr1); 3823 3824 // A conversion to an a non-id object pointer type or qualified 'id' 3825 // type is better than a conversion to 'id'. 3826 if (ToPtr1->isObjCIdType() && 3827 (ToPtr2->isObjCQualifiedIdType() || ToPtr2->getInterfaceDecl())) 3828 return ImplicitConversionSequence::Worse; 3829 if (ToPtr2->isObjCIdType() && 3830 (ToPtr1->isObjCQualifiedIdType() || ToPtr1->getInterfaceDecl())) 3831 return ImplicitConversionSequence::Better; 3832 3833 // A conversion to a non-id object pointer type is better than a 3834 // conversion to a qualified 'id' type 3835 if (ToPtr1->isObjCQualifiedIdType() && ToPtr2->getInterfaceDecl()) 3836 return ImplicitConversionSequence::Worse; 3837 if (ToPtr2->isObjCQualifiedIdType() && ToPtr1->getInterfaceDecl()) 3838 return ImplicitConversionSequence::Better; 3839 3840 // A conversion to an a non-Class object pointer type or qualified 'Class' 3841 // type is better than a conversion to 'Class'. 3842 if (ToPtr1->isObjCClassType() && 3843 (ToPtr2->isObjCQualifiedClassType() || ToPtr2->getInterfaceDecl())) 3844 return ImplicitConversionSequence::Worse; 3845 if (ToPtr2->isObjCClassType() && 3846 (ToPtr1->isObjCQualifiedClassType() || ToPtr1->getInterfaceDecl())) 3847 return ImplicitConversionSequence::Better; 3848 3849 // A conversion to a non-Class object pointer type is better than a 3850 // conversion to a qualified 'Class' type. 3851 if (ToPtr1->isObjCQualifiedClassType() && ToPtr2->getInterfaceDecl()) 3852 return ImplicitConversionSequence::Worse; 3853 if (ToPtr2->isObjCQualifiedClassType() && ToPtr1->getInterfaceDecl()) 3854 return ImplicitConversionSequence::Better; 3855 3856 // -- "conversion of C* to B* is better than conversion of C* to A*," 3857 if (S.Context.hasSameType(FromType1, FromType2) && 3858 !FromPtr1->isObjCIdType() && !FromPtr1->isObjCClassType() && 3859 (ToAssignLeft != ToAssignRight)) 3860 return ToAssignLeft? ImplicitConversionSequence::Worse 3861 : ImplicitConversionSequence::Better; 3862 3863 // -- "conversion of B* to A* is better than conversion of C* to A*," 3864 if (S.Context.hasSameUnqualifiedType(ToType1, ToType2) && 3865 (FromAssignLeft != FromAssignRight)) 3866 return FromAssignLeft? ImplicitConversionSequence::Better 3867 : ImplicitConversionSequence::Worse; 3868 } 3869 } 3870 3871 // Ranking of member-pointer types. 3872 if (SCS1.Second == ICK_Pointer_Member && SCS2.Second == ICK_Pointer_Member && 3873 FromType1->isMemberPointerType() && FromType2->isMemberPointerType() && 3874 ToType1->isMemberPointerType() && ToType2->isMemberPointerType()) { 3875 const MemberPointerType * FromMemPointer1 = 3876 FromType1->getAs<MemberPointerType>(); 3877 const MemberPointerType * ToMemPointer1 = 3878 ToType1->getAs<MemberPointerType>(); 3879 const MemberPointerType * FromMemPointer2 = 3880 FromType2->getAs<MemberPointerType>(); 3881 const MemberPointerType * ToMemPointer2 = 3882 ToType2->getAs<MemberPointerType>(); 3883 const Type *FromPointeeType1 = FromMemPointer1->getClass(); 3884 const Type *ToPointeeType1 = ToMemPointer1->getClass(); 3885 const Type *FromPointeeType2 = FromMemPointer2->getClass(); 3886 const Type *ToPointeeType2 = ToMemPointer2->getClass(); 3887 QualType FromPointee1 = QualType(FromPointeeType1, 0).getUnqualifiedType(); 3888 QualType ToPointee1 = QualType(ToPointeeType1, 0).getUnqualifiedType(); 3889 QualType FromPointee2 = QualType(FromPointeeType2, 0).getUnqualifiedType(); 3890 QualType ToPointee2 = QualType(ToPointeeType2, 0).getUnqualifiedType(); 3891 // conversion of A::* to B::* is better than conversion of A::* to C::*, 3892 if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) { 3893 if (S.IsDerivedFrom(ToPointee1, ToPointee2)) 3894 return ImplicitConversionSequence::Worse; 3895 else if (S.IsDerivedFrom(ToPointee2, ToPointee1)) 3896 return ImplicitConversionSequence::Better; 3897 } 3898 // conversion of B::* to C::* is better than conversion of A::* to C::* 3899 if (ToPointee1 == ToPointee2 && FromPointee1 != FromPointee2) { 3900 if (S.IsDerivedFrom(FromPointee1, FromPointee2)) 3901 return ImplicitConversionSequence::Better; 3902 else if (S.IsDerivedFrom(FromPointee2, FromPointee1)) 3903 return ImplicitConversionSequence::Worse; 3904 } 3905 } 3906 3907 if (SCS1.Second == ICK_Derived_To_Base) { 3908 // -- conversion of C to B is better than conversion of C to A, 3909 // -- binding of an expression of type C to a reference of type 3910 // B& is better than binding an expression of type C to a 3911 // reference of type A&, 3912 if (S.Context.hasSameUnqualifiedType(FromType1, FromType2) && 3913 !S.Context.hasSameUnqualifiedType(ToType1, ToType2)) { 3914 if (S.IsDerivedFrom(ToType1, ToType2)) 3915 return ImplicitConversionSequence::Better; 3916 else if (S.IsDerivedFrom(ToType2, ToType1)) 3917 return ImplicitConversionSequence::Worse; 3918 } 3919 3920 // -- conversion of B to A is better than conversion of C to A. 3921 // -- binding of an expression of type B to a reference of type 3922 // A& is better than binding an expression of type C to a 3923 // reference of type A&, 3924 if (!S.Context.hasSameUnqualifiedType(FromType1, FromType2) && 3925 S.Context.hasSameUnqualifiedType(ToType1, ToType2)) { 3926 if (S.IsDerivedFrom(FromType2, FromType1)) 3927 return ImplicitConversionSequence::Better; 3928 else if (S.IsDerivedFrom(FromType1, FromType2)) 3929 return ImplicitConversionSequence::Worse; 3930 } 3931 } 3932 3933 return ImplicitConversionSequence::Indistinguishable; 3934} 3935 3936/// \brief Determine whether the given type is valid, e.g., it is not an invalid 3937/// C++ class. 3938static bool isTypeValid(QualType T) { 3939 if (CXXRecordDecl *Record = T->getAsCXXRecordDecl()) 3940 return !Record->isInvalidDecl(); 3941 3942 return true; 3943} 3944 3945/// CompareReferenceRelationship - Compare the two types T1 and T2 to 3946/// determine whether they are reference-related, 3947/// reference-compatible, reference-compatible with added 3948/// qualification, or incompatible, for use in C++ initialization by 3949/// reference (C++ [dcl.ref.init]p4). Neither type can be a reference 3950/// type, and the first type (T1) is the pointee type of the reference 3951/// type being initialized. 3952Sema::ReferenceCompareResult 3953Sema::CompareReferenceRelationship(SourceLocation Loc, 3954 QualType OrigT1, QualType OrigT2, 3955 bool &DerivedToBase, 3956 bool &ObjCConversion, 3957 bool &ObjCLifetimeConversion) { 3958 assert(!OrigT1->isReferenceType() && 3959 "T1 must be the pointee type of the reference type"); 3960 assert(!OrigT2->isReferenceType() && "T2 cannot be a reference type"); 3961 3962 QualType T1 = Context.getCanonicalType(OrigT1); 3963 QualType T2 = Context.getCanonicalType(OrigT2); 3964 Qualifiers T1Quals, T2Quals; 3965 QualType UnqualT1 = Context.getUnqualifiedArrayType(T1, T1Quals); 3966 QualType UnqualT2 = Context.getUnqualifiedArrayType(T2, T2Quals); 3967 3968 // C++ [dcl.init.ref]p4: 3969 // Given types "cv1 T1" and "cv2 T2," "cv1 T1" is 3970 // reference-related to "cv2 T2" if T1 is the same type as T2, or 3971 // T1 is a base class of T2. 3972 DerivedToBase = false; 3973 ObjCConversion = false; 3974 ObjCLifetimeConversion = false; 3975 if (UnqualT1 == UnqualT2) { 3976 // Nothing to do. 3977 } else if (!RequireCompleteType(Loc, OrigT2, 0) && 3978 isTypeValid(UnqualT1) && isTypeValid(UnqualT2) && 3979 IsDerivedFrom(UnqualT2, UnqualT1)) 3980 DerivedToBase = true; 3981 else if (UnqualT1->isObjCObjectOrInterfaceType() && 3982 UnqualT2->isObjCObjectOrInterfaceType() && 3983 Context.canBindObjCObjectType(UnqualT1, UnqualT2)) 3984 ObjCConversion = true; 3985 else 3986 return Ref_Incompatible; 3987 3988 // At this point, we know that T1 and T2 are reference-related (at 3989 // least). 3990 3991 // If the type is an array type, promote the element qualifiers to the type 3992 // for comparison. 3993 if (isa<ArrayType>(T1) && T1Quals) 3994 T1 = Context.getQualifiedType(UnqualT1, T1Quals); 3995 if (isa<ArrayType>(T2) && T2Quals) 3996 T2 = Context.getQualifiedType(UnqualT2, T2Quals); 3997 3998 // C++ [dcl.init.ref]p4: 3999 // "cv1 T1" is reference-compatible with "cv2 T2" if T1 is 4000 // reference-related to T2 and cv1 is the same cv-qualification 4001 // as, or greater cv-qualification than, cv2. For purposes of 4002 // overload resolution, cases for which cv1 is greater 4003 // cv-qualification than cv2 are identified as 4004 // reference-compatible with added qualification (see 13.3.3.2). 4005 // 4006 // Note that we also require equivalence of Objective-C GC and address-space 4007 // qualifiers when performing these computations, so that e.g., an int in 4008 // address space 1 is not reference-compatible with an int in address 4009 // space 2. 4010 if (T1Quals.getObjCLifetime() != T2Quals.getObjCLifetime() && 4011 T1Quals.compatiblyIncludesObjCLifetime(T2Quals)) { 4012 if (isNonTrivialObjCLifetimeConversion(T2Quals, T1Quals)) 4013 ObjCLifetimeConversion = true; 4014 4015 T1Quals.removeObjCLifetime(); 4016 T2Quals.removeObjCLifetime(); 4017 } 4018 4019 if (T1Quals == T2Quals) 4020 return Ref_Compatible; 4021 else if (T1Quals.compatiblyIncludes(T2Quals)) 4022 return Ref_Compatible_With_Added_Qualification; 4023 else 4024 return Ref_Related; 4025} 4026 4027/// \brief Look for a user-defined conversion to an value reference-compatible 4028/// with DeclType. Return true if something definite is found. 4029static bool 4030FindConversionForRefInit(Sema &S, ImplicitConversionSequence &ICS, 4031 QualType DeclType, SourceLocation DeclLoc, 4032 Expr *Init, QualType T2, bool AllowRvalues, 4033 bool AllowExplicit) { 4034 assert(T2->isRecordType() && "Can only find conversions of record types."); 4035 CXXRecordDecl *T2RecordDecl 4036 = dyn_cast<CXXRecordDecl>(T2->getAs<RecordType>()->getDecl()); 4037 4038 OverloadCandidateSet CandidateSet(DeclLoc); 4039 std::pair<CXXRecordDecl::conversion_iterator, 4040 CXXRecordDecl::conversion_iterator> 4041 Conversions = T2RecordDecl->getVisibleConversionFunctions(); 4042 for (CXXRecordDecl::conversion_iterator 4043 I = Conversions.first, E = Conversions.second; I != E; ++I) { 4044 NamedDecl *D = *I; 4045 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext()); 4046 if (isa<UsingShadowDecl>(D)) 4047 D = cast<UsingShadowDecl>(D)->getTargetDecl(); 4048 4049 FunctionTemplateDecl *ConvTemplate 4050 = dyn_cast<FunctionTemplateDecl>(D); 4051 CXXConversionDecl *Conv; 4052 if (ConvTemplate) 4053 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl()); 4054 else 4055 Conv = cast<CXXConversionDecl>(D); 4056 4057 // If this is an explicit conversion, and we're not allowed to consider 4058 // explicit conversions, skip it. 4059 if (!AllowExplicit && Conv->isExplicit()) 4060 continue; 4061 4062 if (AllowRvalues) { 4063 bool DerivedToBase = false; 4064 bool ObjCConversion = false; 4065 bool ObjCLifetimeConversion = false; 4066 4067 // If we are initializing an rvalue reference, don't permit conversion 4068 // functions that return lvalues. 4069 if (!ConvTemplate && DeclType->isRValueReferenceType()) { 4070 const ReferenceType *RefType 4071 = Conv->getConversionType()->getAs<LValueReferenceType>(); 4072 if (RefType && !RefType->getPointeeType()->isFunctionType()) 4073 continue; 4074 } 4075 4076 if (!ConvTemplate && 4077 S.CompareReferenceRelationship( 4078 DeclLoc, 4079 Conv->getConversionType().getNonReferenceType() 4080 .getUnqualifiedType(), 4081 DeclType.getNonReferenceType().getUnqualifiedType(), 4082 DerivedToBase, ObjCConversion, ObjCLifetimeConversion) == 4083 Sema::Ref_Incompatible) 4084 continue; 4085 } else { 4086 // If the conversion function doesn't return a reference type, 4087 // it can't be considered for this conversion. An rvalue reference 4088 // is only acceptable if its referencee is a function type. 4089 4090 const ReferenceType *RefType = 4091 Conv->getConversionType()->getAs<ReferenceType>(); 4092 if (!RefType || 4093 (!RefType->isLValueReferenceType() && 4094 !RefType->getPointeeType()->isFunctionType())) 4095 continue; 4096 } 4097 4098 if (ConvTemplate) 4099 S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(), ActingDC, 4100 Init, DeclType, CandidateSet, 4101 /*AllowObjCConversionOnExplicit=*/false); 4102 else 4103 S.AddConversionCandidate(Conv, I.getPair(), ActingDC, Init, 4104 DeclType, CandidateSet, 4105 /*AllowObjCConversionOnExplicit=*/false); 4106 } 4107 4108 bool HadMultipleCandidates = (CandidateSet.size() > 1); 4109 4110 OverloadCandidateSet::iterator Best; 4111 switch (CandidateSet.BestViableFunction(S, DeclLoc, Best, true)) { 4112 case OR_Success: 4113 // C++ [over.ics.ref]p1: 4114 // 4115 // [...] If the parameter binds directly to the result of 4116 // applying a conversion function to the argument 4117 // expression, the implicit conversion sequence is a 4118 // user-defined conversion sequence (13.3.3.1.2), with the 4119 // second standard conversion sequence either an identity 4120 // conversion or, if the conversion function returns an 4121 // entity of a type that is a derived class of the parameter 4122 // type, a derived-to-base Conversion. 4123 if (!Best->FinalConversion.DirectBinding) 4124 return false; 4125 4126 ICS.setUserDefined(); 4127 ICS.UserDefined.Before = Best->Conversions[0].Standard; 4128 ICS.UserDefined.After = Best->FinalConversion; 4129 ICS.UserDefined.HadMultipleCandidates = HadMultipleCandidates; 4130 ICS.UserDefined.ConversionFunction = Best->Function; 4131 ICS.UserDefined.FoundConversionFunction = Best->FoundDecl; 4132 ICS.UserDefined.EllipsisConversion = false; 4133 assert(ICS.UserDefined.After.ReferenceBinding && 4134 ICS.UserDefined.After.DirectBinding && 4135 "Expected a direct reference binding!"); 4136 return true; 4137 4138 case OR_Ambiguous: 4139 ICS.setAmbiguous(); 4140 for (OverloadCandidateSet::iterator Cand = CandidateSet.begin(); 4141 Cand != CandidateSet.end(); ++Cand) 4142 if (Cand->Viable) 4143 ICS.Ambiguous.addConversion(Cand->Function); 4144 return true; 4145 4146 case OR_No_Viable_Function: 4147 case OR_Deleted: 4148 // There was no suitable conversion, or we found a deleted 4149 // conversion; continue with other checks. 4150 return false; 4151 } 4152 4153 llvm_unreachable("Invalid OverloadResult!"); 4154} 4155 4156/// \brief Compute an implicit conversion sequence for reference 4157/// initialization. 4158static ImplicitConversionSequence 4159TryReferenceInit(Sema &S, Expr *Init, QualType DeclType, 4160 SourceLocation DeclLoc, 4161 bool SuppressUserConversions, 4162 bool AllowExplicit) { 4163 assert(DeclType->isReferenceType() && "Reference init needs a reference"); 4164 4165 // Most paths end in a failed conversion. 4166 ImplicitConversionSequence ICS; 4167 ICS.setBad(BadConversionSequence::no_conversion, Init, DeclType); 4168 4169 QualType T1 = DeclType->getAs<ReferenceType>()->getPointeeType(); 4170 QualType T2 = Init->getType(); 4171 4172 // If the initializer is the address of an overloaded function, try 4173 // to resolve the overloaded function. If all goes well, T2 is the 4174 // type of the resulting function. 4175 if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) { 4176 DeclAccessPair Found; 4177 if (FunctionDecl *Fn = S.ResolveAddressOfOverloadedFunction(Init, DeclType, 4178 false, Found)) 4179 T2 = Fn->getType(); 4180 } 4181 4182 // Compute some basic properties of the types and the initializer. 4183 bool isRValRef = DeclType->isRValueReferenceType(); 4184 bool DerivedToBase = false; 4185 bool ObjCConversion = false; 4186 bool ObjCLifetimeConversion = false; 4187 Expr::Classification InitCategory = Init->Classify(S.Context); 4188 Sema::ReferenceCompareResult RefRelationship 4189 = S.CompareReferenceRelationship(DeclLoc, T1, T2, DerivedToBase, 4190 ObjCConversion, ObjCLifetimeConversion); 4191 4192 4193 // C++0x [dcl.init.ref]p5: 4194 // A reference to type "cv1 T1" is initialized by an expression 4195 // of type "cv2 T2" as follows: 4196 4197 // -- If reference is an lvalue reference and the initializer expression 4198 if (!isRValRef) { 4199 // -- is an lvalue (but is not a bit-field), and "cv1 T1" is 4200 // reference-compatible with "cv2 T2," or 4201 // 4202 // Per C++ [over.ics.ref]p4, we don't check the bit-field property here. 4203 if (InitCategory.isLValue() && 4204 RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification) { 4205 // C++ [over.ics.ref]p1: 4206 // When a parameter of reference type binds directly (8.5.3) 4207 // to an argument expression, the implicit conversion sequence 4208 // is the identity conversion, unless the argument expression 4209 // has a type that is a derived class of the parameter type, 4210 // in which case the implicit conversion sequence is a 4211 // derived-to-base Conversion (13.3.3.1). 4212 ICS.setStandard(); 4213 ICS.Standard.First = ICK_Identity; 4214 ICS.Standard.Second = DerivedToBase? ICK_Derived_To_Base 4215 : ObjCConversion? ICK_Compatible_Conversion 4216 : ICK_Identity; 4217 ICS.Standard.Third = ICK_Identity; 4218 ICS.Standard.FromTypePtr = T2.getAsOpaquePtr(); 4219 ICS.Standard.setToType(0, T2); 4220 ICS.Standard.setToType(1, T1); 4221 ICS.Standard.setToType(2, T1); 4222 ICS.Standard.ReferenceBinding = true; 4223 ICS.Standard.DirectBinding = true; 4224 ICS.Standard.IsLvalueReference = !isRValRef; 4225 ICS.Standard.BindsToFunctionLvalue = T2->isFunctionType(); 4226 ICS.Standard.BindsToRvalue = false; 4227 ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false; 4228 ICS.Standard.ObjCLifetimeConversionBinding = ObjCLifetimeConversion; 4229 ICS.Standard.CopyConstructor = 0; 4230 4231 // Nothing more to do: the inaccessibility/ambiguity check for 4232 // derived-to-base conversions is suppressed when we're 4233 // computing the implicit conversion sequence (C++ 4234 // [over.best.ics]p2). 4235 return ICS; 4236 } 4237 4238 // -- has a class type (i.e., T2 is a class type), where T1 is 4239 // not reference-related to T2, and can be implicitly 4240 // converted to an lvalue of type "cv3 T3," where "cv1 T1" 4241 // is reference-compatible with "cv3 T3" 92) (this 4242 // conversion is selected by enumerating the applicable 4243 // conversion functions (13.3.1.6) and choosing the best 4244 // one through overload resolution (13.3)), 4245 if (!SuppressUserConversions && T2->isRecordType() && 4246 !S.RequireCompleteType(DeclLoc, T2, 0) && 4247 RefRelationship == Sema::Ref_Incompatible) { 4248 if (FindConversionForRefInit(S, ICS, DeclType, DeclLoc, 4249 Init, T2, /*AllowRvalues=*/false, 4250 AllowExplicit)) 4251 return ICS; 4252 } 4253 } 4254 4255 // -- Otherwise, the reference shall be an lvalue reference to a 4256 // non-volatile const type (i.e., cv1 shall be const), or the reference 4257 // shall be an rvalue reference. 4258 // 4259 // We actually handle one oddity of C++ [over.ics.ref] at this 4260 // point, which is that, due to p2 (which short-circuits reference 4261 // binding by only attempting a simple conversion for non-direct 4262 // bindings) and p3's strange wording, we allow a const volatile 4263 // reference to bind to an rvalue. Hence the check for the presence 4264 // of "const" rather than checking for "const" being the only 4265 // qualifier. 4266 // This is also the point where rvalue references and lvalue inits no longer 4267 // go together. 4268 if (!isRValRef && (!T1.isConstQualified() || T1.isVolatileQualified())) 4269 return ICS; 4270 4271 // -- If the initializer expression 4272 // 4273 // -- is an xvalue, class prvalue, array prvalue or function 4274 // lvalue and "cv1 T1" is reference-compatible with "cv2 T2", or 4275 if (RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification && 4276 (InitCategory.isXValue() || 4277 (InitCategory.isPRValue() && (T2->isRecordType() || T2->isArrayType())) || 4278 (InitCategory.isLValue() && T2->isFunctionType()))) { 4279 ICS.setStandard(); 4280 ICS.Standard.First = ICK_Identity; 4281 ICS.Standard.Second = DerivedToBase? ICK_Derived_To_Base 4282 : ObjCConversion? ICK_Compatible_Conversion 4283 : ICK_Identity; 4284 ICS.Standard.Third = ICK_Identity; 4285 ICS.Standard.FromTypePtr = T2.getAsOpaquePtr(); 4286 ICS.Standard.setToType(0, T2); 4287 ICS.Standard.setToType(1, T1); 4288 ICS.Standard.setToType(2, T1); 4289 ICS.Standard.ReferenceBinding = true; 4290 // In C++0x, this is always a direct binding. In C++98/03, it's a direct 4291 // binding unless we're binding to a class prvalue. 4292 // Note: Although xvalues wouldn't normally show up in C++98/03 code, we 4293 // allow the use of rvalue references in C++98/03 for the benefit of 4294 // standard library implementors; therefore, we need the xvalue check here. 4295 ICS.Standard.DirectBinding = 4296 S.getLangOpts().CPlusPlus11 || 4297 (InitCategory.isPRValue() && !T2->isRecordType()); 4298 ICS.Standard.IsLvalueReference = !isRValRef; 4299 ICS.Standard.BindsToFunctionLvalue = T2->isFunctionType(); 4300 ICS.Standard.BindsToRvalue = InitCategory.isRValue(); 4301 ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false; 4302 ICS.Standard.ObjCLifetimeConversionBinding = ObjCLifetimeConversion; 4303 ICS.Standard.CopyConstructor = 0; 4304 return ICS; 4305 } 4306 4307 // -- has a class type (i.e., T2 is a class type), where T1 is not 4308 // reference-related to T2, and can be implicitly converted to 4309 // an xvalue, class prvalue, or function lvalue of type 4310 // "cv3 T3", where "cv1 T1" is reference-compatible with 4311 // "cv3 T3", 4312 // 4313 // then the reference is bound to the value of the initializer 4314 // expression in the first case and to the result of the conversion 4315 // in the second case (or, in either case, to an appropriate base 4316 // class subobject). 4317 if (!SuppressUserConversions && RefRelationship == Sema::Ref_Incompatible && 4318 T2->isRecordType() && !S.RequireCompleteType(DeclLoc, T2, 0) && 4319 FindConversionForRefInit(S, ICS, DeclType, DeclLoc, 4320 Init, T2, /*AllowRvalues=*/true, 4321 AllowExplicit)) { 4322 // In the second case, if the reference is an rvalue reference 4323 // and the second standard conversion sequence of the 4324 // user-defined conversion sequence includes an lvalue-to-rvalue 4325 // conversion, the program is ill-formed. 4326 if (ICS.isUserDefined() && isRValRef && 4327 ICS.UserDefined.After.First == ICK_Lvalue_To_Rvalue) 4328 ICS.setBad(BadConversionSequence::no_conversion, Init, DeclType); 4329 4330 return ICS; 4331 } 4332 4333 // -- Otherwise, a temporary of type "cv1 T1" is created and 4334 // initialized from the initializer expression using the 4335 // rules for a non-reference copy initialization (8.5). The 4336 // reference is then bound to the temporary. If T1 is 4337 // reference-related to T2, cv1 must be the same 4338 // cv-qualification as, or greater cv-qualification than, 4339 // cv2; otherwise, the program is ill-formed. 4340 if (RefRelationship == Sema::Ref_Related) { 4341 // If cv1 == cv2 or cv1 is a greater cv-qualified than cv2, then 4342 // we would be reference-compatible or reference-compatible with 4343 // added qualification. But that wasn't the case, so the reference 4344 // initialization fails. 4345 // 4346 // Note that we only want to check address spaces and cvr-qualifiers here. 4347 // ObjC GC and lifetime qualifiers aren't important. 4348 Qualifiers T1Quals = T1.getQualifiers(); 4349 Qualifiers T2Quals = T2.getQualifiers(); 4350 T1Quals.removeObjCGCAttr(); 4351 T1Quals.removeObjCLifetime(); 4352 T2Quals.removeObjCGCAttr(); 4353 T2Quals.removeObjCLifetime(); 4354 if (!T1Quals.compatiblyIncludes(T2Quals)) 4355 return ICS; 4356 } 4357 4358 // If at least one of the types is a class type, the types are not 4359 // related, and we aren't allowed any user conversions, the 4360 // reference binding fails. This case is important for breaking 4361 // recursion, since TryImplicitConversion below will attempt to 4362 // create a temporary through the use of a copy constructor. 4363 if (SuppressUserConversions && RefRelationship == Sema::Ref_Incompatible && 4364 (T1->isRecordType() || T2->isRecordType())) 4365 return ICS; 4366 4367 // If T1 is reference-related to T2 and the reference is an rvalue 4368 // reference, the initializer expression shall not be an lvalue. 4369 if (RefRelationship >= Sema::Ref_Related && 4370 isRValRef && Init->Classify(S.Context).isLValue()) 4371 return ICS; 4372 4373 // C++ [over.ics.ref]p2: 4374 // When a parameter of reference type is not bound directly to 4375 // an argument expression, the conversion sequence is the one 4376 // required to convert the argument expression to the 4377 // underlying type of the reference according to 4378 // 13.3.3.1. Conceptually, this conversion sequence corresponds 4379 // to copy-initializing a temporary of the underlying type with 4380 // the argument expression. Any difference in top-level 4381 // cv-qualification is subsumed by the initialization itself 4382 // and does not constitute a conversion. 4383 ICS = TryImplicitConversion(S, Init, T1, SuppressUserConversions, 4384 /*AllowExplicit=*/false, 4385 /*InOverloadResolution=*/false, 4386 /*CStyle=*/false, 4387 /*AllowObjCWritebackConversion=*/false, 4388 /*AllowObjCConversionOnExplicit=*/false); 4389 4390 // Of course, that's still a reference binding. 4391 if (ICS.isStandard()) { 4392 ICS.Standard.ReferenceBinding = true; 4393 ICS.Standard.IsLvalueReference = !isRValRef; 4394 ICS.Standard.BindsToFunctionLvalue = T2->isFunctionType(); 4395 ICS.Standard.BindsToRvalue = true; 4396 ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false; 4397 ICS.Standard.ObjCLifetimeConversionBinding = false; 4398 } else if (ICS.isUserDefined()) { 4399 // Don't allow rvalue references to bind to lvalues. 4400 if (DeclType->isRValueReferenceType()) { 4401 if (const ReferenceType *RefType 4402 = ICS.UserDefined.ConversionFunction->getResultType() 4403 ->getAs<LValueReferenceType>()) { 4404 if (!RefType->getPointeeType()->isFunctionType()) { 4405 ICS.setBad(BadConversionSequence::lvalue_ref_to_rvalue, Init, 4406 DeclType); 4407 return ICS; 4408 } 4409 } 4410 } 4411 4412 ICS.UserDefined.After.ReferenceBinding = true; 4413 ICS.UserDefined.After.IsLvalueReference = !isRValRef; 4414 ICS.UserDefined.After.BindsToFunctionLvalue = T2->isFunctionType(); 4415 ICS.UserDefined.After.BindsToRvalue = true; 4416 ICS.UserDefined.After.BindsImplicitObjectArgumentWithoutRefQualifier = false; 4417 ICS.UserDefined.After.ObjCLifetimeConversionBinding = false; 4418 } 4419 4420 return ICS; 4421} 4422 4423static ImplicitConversionSequence 4424TryCopyInitialization(Sema &S, Expr *From, QualType ToType, 4425 bool SuppressUserConversions, 4426 bool InOverloadResolution, 4427 bool AllowObjCWritebackConversion, 4428 bool AllowExplicit = false); 4429 4430/// TryListConversion - Try to copy-initialize a value of type ToType from the 4431/// initializer list From. 4432static ImplicitConversionSequence 4433TryListConversion(Sema &S, InitListExpr *From, QualType ToType, 4434 bool SuppressUserConversions, 4435 bool InOverloadResolution, 4436 bool AllowObjCWritebackConversion) { 4437 // C++11 [over.ics.list]p1: 4438 // When an argument is an initializer list, it is not an expression and 4439 // special rules apply for converting it to a parameter type. 4440 4441 ImplicitConversionSequence Result; 4442 Result.setBad(BadConversionSequence::no_conversion, From, ToType); 4443 4444 // We need a complete type for what follows. Incomplete types can never be 4445 // initialized from init lists. 4446 if (S.RequireCompleteType(From->getLocStart(), ToType, 0)) 4447 return Result; 4448 4449 // C++11 [over.ics.list]p2: 4450 // If the parameter type is std::initializer_list<X> or "array of X" and 4451 // all the elements can be implicitly converted to X, the implicit 4452 // conversion sequence is the worst conversion necessary to convert an 4453 // element of the list to X. 4454 bool toStdInitializerList = false; 4455 QualType X; 4456 if (ToType->isArrayType()) 4457 X = S.Context.getAsArrayType(ToType)->getElementType(); 4458 else 4459 toStdInitializerList = S.isStdInitializerList(ToType, &X); 4460 if (!X.isNull()) { 4461 for (unsigned i = 0, e = From->getNumInits(); i < e; ++i) { 4462 Expr *Init = From->getInit(i); 4463 ImplicitConversionSequence ICS = 4464 TryCopyInitialization(S, Init, X, SuppressUserConversions, 4465 InOverloadResolution, 4466 AllowObjCWritebackConversion); 4467 // If a single element isn't convertible, fail. 4468 if (ICS.isBad()) { 4469 Result = ICS; 4470 break; 4471 } 4472 // Otherwise, look for the worst conversion. 4473 if (Result.isBad() || 4474 CompareImplicitConversionSequences(S, ICS, Result) == 4475 ImplicitConversionSequence::Worse) 4476 Result = ICS; 4477 } 4478 4479 // For an empty list, we won't have computed any conversion sequence. 4480 // Introduce the identity conversion sequence. 4481 if (From->getNumInits() == 0) { 4482 Result.setStandard(); 4483 Result.Standard.setAsIdentityConversion(); 4484 Result.Standard.setFromType(ToType); 4485 Result.Standard.setAllToTypes(ToType); 4486 } 4487 4488 Result.setStdInitializerListElement(toStdInitializerList); 4489 return Result; 4490 } 4491 4492 // C++11 [over.ics.list]p3: 4493 // Otherwise, if the parameter is a non-aggregate class X and overload 4494 // resolution chooses a single best constructor [...] the implicit 4495 // conversion sequence is a user-defined conversion sequence. If multiple 4496 // constructors are viable but none is better than the others, the 4497 // implicit conversion sequence is a user-defined conversion sequence. 4498 if (ToType->isRecordType() && !ToType->isAggregateType()) { 4499 // This function can deal with initializer lists. 4500 return TryUserDefinedConversion(S, From, ToType, SuppressUserConversions, 4501 /*AllowExplicit=*/false, 4502 InOverloadResolution, /*CStyle=*/false, 4503 AllowObjCWritebackConversion, 4504 /*AllowObjCConversionOnExplicit=*/false); 4505 } 4506 4507 // C++11 [over.ics.list]p4: 4508 // Otherwise, if the parameter has an aggregate type which can be 4509 // initialized from the initializer list [...] the implicit conversion 4510 // sequence is a user-defined conversion sequence. 4511 if (ToType->isAggregateType()) { 4512 // Type is an aggregate, argument is an init list. At this point it comes 4513 // down to checking whether the initialization works. 4514 // FIXME: Find out whether this parameter is consumed or not. 4515 InitializedEntity Entity = 4516 InitializedEntity::InitializeParameter(S.Context, ToType, 4517 /*Consumed=*/false); 4518 if (S.CanPerformCopyInitialization(Entity, S.Owned(From))) { 4519 Result.setUserDefined(); 4520 Result.UserDefined.Before.setAsIdentityConversion(); 4521 // Initializer lists don't have a type. 4522 Result.UserDefined.Before.setFromType(QualType()); 4523 Result.UserDefined.Before.setAllToTypes(QualType()); 4524 4525 Result.UserDefined.After.setAsIdentityConversion(); 4526 Result.UserDefined.After.setFromType(ToType); 4527 Result.UserDefined.After.setAllToTypes(ToType); 4528 Result.UserDefined.ConversionFunction = 0; 4529 } 4530 return Result; 4531 } 4532 4533 // C++11 [over.ics.list]p5: 4534 // Otherwise, if the parameter is a reference, see 13.3.3.1.4. 4535 if (ToType->isReferenceType()) { 4536 // The standard is notoriously unclear here, since 13.3.3.1.4 doesn't 4537 // mention initializer lists in any way. So we go by what list- 4538 // initialization would do and try to extrapolate from that. 4539 4540 QualType T1 = ToType->getAs<ReferenceType>()->getPointeeType(); 4541 4542 // If the initializer list has a single element that is reference-related 4543 // to the parameter type, we initialize the reference from that. 4544 if (From->getNumInits() == 1) { 4545 Expr *Init = From->getInit(0); 4546 4547 QualType T2 = Init->getType(); 4548 4549 // If the initializer is the address of an overloaded function, try 4550 // to resolve the overloaded function. If all goes well, T2 is the 4551 // type of the resulting function. 4552 if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) { 4553 DeclAccessPair Found; 4554 if (FunctionDecl *Fn = S.ResolveAddressOfOverloadedFunction( 4555 Init, ToType, false, Found)) 4556 T2 = Fn->getType(); 4557 } 4558 4559 // Compute some basic properties of the types and the initializer. 4560 bool dummy1 = false; 4561 bool dummy2 = false; 4562 bool dummy3 = false; 4563 Sema::ReferenceCompareResult RefRelationship 4564 = S.CompareReferenceRelationship(From->getLocStart(), T1, T2, dummy1, 4565 dummy2, dummy3); 4566 4567 if (RefRelationship >= Sema::Ref_Related) { 4568 return TryReferenceInit(S, Init, ToType, /*FIXME*/From->getLocStart(), 4569 SuppressUserConversions, 4570 /*AllowExplicit=*/false); 4571 } 4572 } 4573 4574 // Otherwise, we bind the reference to a temporary created from the 4575 // initializer list. 4576 Result = TryListConversion(S, From, T1, SuppressUserConversions, 4577 InOverloadResolution, 4578 AllowObjCWritebackConversion); 4579 if (Result.isFailure()) 4580 return Result; 4581 assert(!Result.isEllipsis() && 4582 "Sub-initialization cannot result in ellipsis conversion."); 4583 4584 // Can we even bind to a temporary? 4585 if (ToType->isRValueReferenceType() || 4586 (T1.isConstQualified() && !T1.isVolatileQualified())) { 4587 StandardConversionSequence &SCS = Result.isStandard() ? Result.Standard : 4588 Result.UserDefined.After; 4589 SCS.ReferenceBinding = true; 4590 SCS.IsLvalueReference = ToType->isLValueReferenceType(); 4591 SCS.BindsToRvalue = true; 4592 SCS.BindsToFunctionLvalue = false; 4593 SCS.BindsImplicitObjectArgumentWithoutRefQualifier = false; 4594 SCS.ObjCLifetimeConversionBinding = false; 4595 } else 4596 Result.setBad(BadConversionSequence::lvalue_ref_to_rvalue, 4597 From, ToType); 4598 return Result; 4599 } 4600 4601 // C++11 [over.ics.list]p6: 4602 // Otherwise, if the parameter type is not a class: 4603 if (!ToType->isRecordType()) { 4604 // - if the initializer list has one element, the implicit conversion 4605 // sequence is the one required to convert the element to the 4606 // parameter type. 4607 unsigned NumInits = From->getNumInits(); 4608 if (NumInits == 1) 4609 Result = TryCopyInitialization(S, From->getInit(0), ToType, 4610 SuppressUserConversions, 4611 InOverloadResolution, 4612 AllowObjCWritebackConversion); 4613 // - if the initializer list has no elements, the implicit conversion 4614 // sequence is the identity conversion. 4615 else if (NumInits == 0) { 4616 Result.setStandard(); 4617 Result.Standard.setAsIdentityConversion(); 4618 Result.Standard.setFromType(ToType); 4619 Result.Standard.setAllToTypes(ToType); 4620 } 4621 return Result; 4622 } 4623 4624 // C++11 [over.ics.list]p7: 4625 // In all cases other than those enumerated above, no conversion is possible 4626 return Result; 4627} 4628 4629/// TryCopyInitialization - Try to copy-initialize a value of type 4630/// ToType from the expression From. Return the implicit conversion 4631/// sequence required to pass this argument, which may be a bad 4632/// conversion sequence (meaning that the argument cannot be passed to 4633/// a parameter of this type). If @p SuppressUserConversions, then we 4634/// do not permit any user-defined conversion sequences. 4635static ImplicitConversionSequence 4636TryCopyInitialization(Sema &S, Expr *From, QualType ToType, 4637 bool SuppressUserConversions, 4638 bool InOverloadResolution, 4639 bool AllowObjCWritebackConversion, 4640 bool AllowExplicit) { 4641 if (InitListExpr *FromInitList = dyn_cast<InitListExpr>(From)) 4642 return TryListConversion(S, FromInitList, ToType, SuppressUserConversions, 4643 InOverloadResolution,AllowObjCWritebackConversion); 4644 4645 if (ToType->isReferenceType()) 4646 return TryReferenceInit(S, From, ToType, 4647 /*FIXME:*/From->getLocStart(), 4648 SuppressUserConversions, 4649 AllowExplicit); 4650 4651 return TryImplicitConversion(S, From, ToType, 4652 SuppressUserConversions, 4653 /*AllowExplicit=*/false, 4654 InOverloadResolution, 4655 /*CStyle=*/false, 4656 AllowObjCWritebackConversion, 4657 /*AllowObjCConversionOnExplicit=*/false); 4658} 4659 4660static bool TryCopyInitialization(const CanQualType FromQTy, 4661 const CanQualType ToQTy, 4662 Sema &S, 4663 SourceLocation Loc, 4664 ExprValueKind FromVK) { 4665 OpaqueValueExpr TmpExpr(Loc, FromQTy, FromVK); 4666 ImplicitConversionSequence ICS = 4667 TryCopyInitialization(S, &TmpExpr, ToQTy, true, true, false); 4668 4669 return !ICS.isBad(); 4670} 4671 4672/// TryObjectArgumentInitialization - Try to initialize the object 4673/// parameter of the given member function (@c Method) from the 4674/// expression @p From. 4675static ImplicitConversionSequence 4676TryObjectArgumentInitialization(Sema &S, QualType FromType, 4677 Expr::Classification FromClassification, 4678 CXXMethodDecl *Method, 4679 CXXRecordDecl *ActingContext) { 4680 QualType ClassType = S.Context.getTypeDeclType(ActingContext); 4681 // [class.dtor]p2: A destructor can be invoked for a const, volatile or 4682 // const volatile object. 4683 unsigned Quals = isa<CXXDestructorDecl>(Method) ? 4684 Qualifiers::Const | Qualifiers::Volatile : Method->getTypeQualifiers(); 4685 QualType ImplicitParamType = S.Context.getCVRQualifiedType(ClassType, Quals); 4686 4687 // Set up the conversion sequence as a "bad" conversion, to allow us 4688 // to exit early. 4689 ImplicitConversionSequence ICS; 4690 4691 // We need to have an object of class type. 4692 if (const PointerType *PT = FromType->getAs<PointerType>()) { 4693 FromType = PT->getPointeeType(); 4694 4695 // When we had a pointer, it's implicitly dereferenced, so we 4696 // better have an lvalue. 4697 assert(FromClassification.isLValue()); 4698 } 4699 4700 assert(FromType->isRecordType()); 4701 4702 // C++0x [over.match.funcs]p4: 4703 // For non-static member functions, the type of the implicit object 4704 // parameter is 4705 // 4706 // - "lvalue reference to cv X" for functions declared without a 4707 // ref-qualifier or with the & ref-qualifier 4708 // - "rvalue reference to cv X" for functions declared with the && 4709 // ref-qualifier 4710 // 4711 // where X is the class of which the function is a member and cv is the 4712 // cv-qualification on the member function declaration. 4713 // 4714 // However, when finding an implicit conversion sequence for the argument, we 4715 // are not allowed to create temporaries or perform user-defined conversions 4716 // (C++ [over.match.funcs]p5). We perform a simplified version of 4717 // reference binding here, that allows class rvalues to bind to 4718 // non-constant references. 4719 4720 // First check the qualifiers. 4721 QualType FromTypeCanon = S.Context.getCanonicalType(FromType); 4722 if (ImplicitParamType.getCVRQualifiers() 4723 != FromTypeCanon.getLocalCVRQualifiers() && 4724 !ImplicitParamType.isAtLeastAsQualifiedAs(FromTypeCanon)) { 4725 ICS.setBad(BadConversionSequence::bad_qualifiers, 4726 FromType, ImplicitParamType); 4727 return ICS; 4728 } 4729 4730 // Check that we have either the same type or a derived type. It 4731 // affects the conversion rank. 4732 QualType ClassTypeCanon = S.Context.getCanonicalType(ClassType); 4733 ImplicitConversionKind SecondKind; 4734 if (ClassTypeCanon == FromTypeCanon.getLocalUnqualifiedType()) { 4735 SecondKind = ICK_Identity; 4736 } else if (S.IsDerivedFrom(FromType, ClassType)) 4737 SecondKind = ICK_Derived_To_Base; 4738 else { 4739 ICS.setBad(BadConversionSequence::unrelated_class, 4740 FromType, ImplicitParamType); 4741 return ICS; 4742 } 4743 4744 // Check the ref-qualifier. 4745 switch (Method->getRefQualifier()) { 4746 case RQ_None: 4747 // Do nothing; we don't care about lvalueness or rvalueness. 4748 break; 4749 4750 case RQ_LValue: 4751 if (!FromClassification.isLValue() && Quals != Qualifiers::Const) { 4752 // non-const lvalue reference cannot bind to an rvalue 4753 ICS.setBad(BadConversionSequence::lvalue_ref_to_rvalue, FromType, 4754 ImplicitParamType); 4755 return ICS; 4756 } 4757 break; 4758 4759 case RQ_RValue: 4760 if (!FromClassification.isRValue()) { 4761 // rvalue reference cannot bind to an lvalue 4762 ICS.setBad(BadConversionSequence::rvalue_ref_to_lvalue, FromType, 4763 ImplicitParamType); 4764 return ICS; 4765 } 4766 break; 4767 } 4768 4769 // Success. Mark this as a reference binding. 4770 ICS.setStandard(); 4771 ICS.Standard.setAsIdentityConversion(); 4772 ICS.Standard.Second = SecondKind; 4773 ICS.Standard.setFromType(FromType); 4774 ICS.Standard.setAllToTypes(ImplicitParamType); 4775 ICS.Standard.ReferenceBinding = true; 4776 ICS.Standard.DirectBinding = true; 4777 ICS.Standard.IsLvalueReference = Method->getRefQualifier() != RQ_RValue; 4778 ICS.Standard.BindsToFunctionLvalue = false; 4779 ICS.Standard.BindsToRvalue = FromClassification.isRValue(); 4780 ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier 4781 = (Method->getRefQualifier() == RQ_None); 4782 return ICS; 4783} 4784 4785/// PerformObjectArgumentInitialization - Perform initialization of 4786/// the implicit object parameter for the given Method with the given 4787/// expression. 4788ExprResult 4789Sema::PerformObjectArgumentInitialization(Expr *From, 4790 NestedNameSpecifier *Qualifier, 4791 NamedDecl *FoundDecl, 4792 CXXMethodDecl *Method) { 4793 QualType FromRecordType, DestType; 4794 QualType ImplicitParamRecordType = 4795 Method->getThisType(Context)->getAs<PointerType>()->getPointeeType(); 4796 4797 Expr::Classification FromClassification; 4798 if (const PointerType *PT = From->getType()->getAs<PointerType>()) { 4799 FromRecordType = PT->getPointeeType(); 4800 DestType = Method->getThisType(Context); 4801 FromClassification = Expr::Classification::makeSimpleLValue(); 4802 } else { 4803 FromRecordType = From->getType(); 4804 DestType = ImplicitParamRecordType; 4805 FromClassification = From->Classify(Context); 4806 } 4807 4808 // Note that we always use the true parent context when performing 4809 // the actual argument initialization. 4810 ImplicitConversionSequence ICS 4811 = TryObjectArgumentInitialization(*this, From->getType(), FromClassification, 4812 Method, Method->getParent()); 4813 if (ICS.isBad()) { 4814 if (ICS.Bad.Kind == BadConversionSequence::bad_qualifiers) { 4815 Qualifiers FromQs = FromRecordType.getQualifiers(); 4816 Qualifiers ToQs = DestType.getQualifiers(); 4817 unsigned CVR = FromQs.getCVRQualifiers() & ~ToQs.getCVRQualifiers(); 4818 if (CVR) { 4819 Diag(From->getLocStart(), 4820 diag::err_member_function_call_bad_cvr) 4821 << Method->getDeclName() << FromRecordType << (CVR - 1) 4822 << From->getSourceRange(); 4823 Diag(Method->getLocation(), diag::note_previous_decl) 4824 << Method->getDeclName(); 4825 return ExprError(); 4826 } 4827 } 4828 4829 return Diag(From->getLocStart(), 4830 diag::err_implicit_object_parameter_init) 4831 << ImplicitParamRecordType << FromRecordType << From->getSourceRange(); 4832 } 4833 4834 if (ICS.Standard.Second == ICK_Derived_To_Base) { 4835 ExprResult FromRes = 4836 PerformObjectMemberConversion(From, Qualifier, FoundDecl, Method); 4837 if (FromRes.isInvalid()) 4838 return ExprError(); 4839 From = FromRes.take(); 4840 } 4841 4842 if (!Context.hasSameType(From->getType(), DestType)) 4843 From = ImpCastExprToType(From, DestType, CK_NoOp, 4844 From->getValueKind()).take(); 4845 return Owned(From); 4846} 4847 4848/// TryContextuallyConvertToBool - Attempt to contextually convert the 4849/// expression From to bool (C++0x [conv]p3). 4850static ImplicitConversionSequence 4851TryContextuallyConvertToBool(Sema &S, Expr *From) { 4852 return TryImplicitConversion(S, From, S.Context.BoolTy, 4853 /*SuppressUserConversions=*/false, 4854 /*AllowExplicit=*/true, 4855 /*InOverloadResolution=*/false, 4856 /*CStyle=*/false, 4857 /*AllowObjCWritebackConversion=*/false, 4858 /*AllowObjCConversionOnExplicit=*/false); 4859} 4860 4861/// PerformContextuallyConvertToBool - Perform a contextual conversion 4862/// of the expression From to bool (C++0x [conv]p3). 4863ExprResult Sema::PerformContextuallyConvertToBool(Expr *From) { 4864 if (checkPlaceholderForOverload(*this, From)) 4865 return ExprError(); 4866 4867 ImplicitConversionSequence ICS = TryContextuallyConvertToBool(*this, From); 4868 if (!ICS.isBad()) 4869 return PerformImplicitConversion(From, Context.BoolTy, ICS, AA_Converting); 4870 4871 if (!DiagnoseMultipleUserDefinedConversion(From, Context.BoolTy)) 4872 return Diag(From->getLocStart(), 4873 diag::err_typecheck_bool_condition) 4874 << From->getType() << From->getSourceRange(); 4875 return ExprError(); 4876} 4877 4878/// Check that the specified conversion is permitted in a converted constant 4879/// expression, according to C++11 [expr.const]p3. Return true if the conversion 4880/// is acceptable. 4881static bool CheckConvertedConstantConversions(Sema &S, 4882 StandardConversionSequence &SCS) { 4883 // Since we know that the target type is an integral or unscoped enumeration 4884 // type, most conversion kinds are impossible. All possible First and Third 4885 // conversions are fine. 4886 switch (SCS.Second) { 4887 case ICK_Identity: 4888 case ICK_Integral_Promotion: 4889 case ICK_Integral_Conversion: 4890 case ICK_Zero_Event_Conversion: 4891 return true; 4892 4893 case ICK_Boolean_Conversion: 4894 // Conversion from an integral or unscoped enumeration type to bool is 4895 // classified as ICK_Boolean_Conversion, but it's also an integral 4896 // conversion, so it's permitted in a converted constant expression. 4897 return SCS.getFromType()->isIntegralOrUnscopedEnumerationType() && 4898 SCS.getToType(2)->isBooleanType(); 4899 4900 case ICK_Floating_Integral: 4901 case ICK_Complex_Real: 4902 return false; 4903 4904 case ICK_Lvalue_To_Rvalue: 4905 case ICK_Array_To_Pointer: 4906 case ICK_Function_To_Pointer: 4907 case ICK_NoReturn_Adjustment: 4908 case ICK_Qualification: 4909 case ICK_Compatible_Conversion: 4910 case ICK_Vector_Conversion: 4911 case ICK_Vector_Splat: 4912 case ICK_Derived_To_Base: 4913 case ICK_Pointer_Conversion: 4914 case ICK_Pointer_Member: 4915 case ICK_Block_Pointer_Conversion: 4916 case ICK_Writeback_Conversion: 4917 case ICK_Floating_Promotion: 4918 case ICK_Complex_Promotion: 4919 case ICK_Complex_Conversion: 4920 case ICK_Floating_Conversion: 4921 case ICK_TransparentUnionConversion: 4922 llvm_unreachable("unexpected second conversion kind"); 4923 4924 case ICK_Num_Conversion_Kinds: 4925 break; 4926 } 4927 4928 llvm_unreachable("unknown conversion kind"); 4929} 4930 4931/// CheckConvertedConstantExpression - Check that the expression From is a 4932/// converted constant expression of type T, perform the conversion and produce 4933/// the converted expression, per C++11 [expr.const]p3. 4934ExprResult Sema::CheckConvertedConstantExpression(Expr *From, QualType T, 4935 llvm::APSInt &Value, 4936 CCEKind CCE) { 4937 assert(LangOpts.CPlusPlus11 && "converted constant expression outside C++11"); 4938 assert(T->isIntegralOrEnumerationType() && "unexpected converted const type"); 4939 4940 if (checkPlaceholderForOverload(*this, From)) 4941 return ExprError(); 4942 4943 // C++11 [expr.const]p3 with proposed wording fixes: 4944 // A converted constant expression of type T is a core constant expression, 4945 // implicitly converted to a prvalue of type T, where the converted 4946 // expression is a literal constant expression and the implicit conversion 4947 // sequence contains only user-defined conversions, lvalue-to-rvalue 4948 // conversions, integral promotions, and integral conversions other than 4949 // narrowing conversions. 4950 ImplicitConversionSequence ICS = 4951 TryImplicitConversion(From, T, 4952 /*SuppressUserConversions=*/false, 4953 /*AllowExplicit=*/false, 4954 /*InOverloadResolution=*/false, 4955 /*CStyle=*/false, 4956 /*AllowObjcWritebackConversion=*/false); 4957 StandardConversionSequence *SCS = 0; 4958 switch (ICS.getKind()) { 4959 case ImplicitConversionSequence::StandardConversion: 4960 if (!CheckConvertedConstantConversions(*this, ICS.Standard)) 4961 return Diag(From->getLocStart(), 4962 diag::err_typecheck_converted_constant_expression_disallowed) 4963 << From->getType() << From->getSourceRange() << T; 4964 SCS = &ICS.Standard; 4965 break; 4966 case ImplicitConversionSequence::UserDefinedConversion: 4967 // We are converting from class type to an integral or enumeration type, so 4968 // the Before sequence must be trivial. 4969 if (!CheckConvertedConstantConversions(*this, ICS.UserDefined.After)) 4970 return Diag(From->getLocStart(), 4971 diag::err_typecheck_converted_constant_expression_disallowed) 4972 << From->getType() << From->getSourceRange() << T; 4973 SCS = &ICS.UserDefined.After; 4974 break; 4975 case ImplicitConversionSequence::AmbiguousConversion: 4976 case ImplicitConversionSequence::BadConversion: 4977 if (!DiagnoseMultipleUserDefinedConversion(From, T)) 4978 return Diag(From->getLocStart(), 4979 diag::err_typecheck_converted_constant_expression) 4980 << From->getType() << From->getSourceRange() << T; 4981 return ExprError(); 4982 4983 case ImplicitConversionSequence::EllipsisConversion: 4984 llvm_unreachable("ellipsis conversion in converted constant expression"); 4985 } 4986 4987 ExprResult Result = PerformImplicitConversion(From, T, ICS, AA_Converting); 4988 if (Result.isInvalid()) 4989 return Result; 4990 4991 // Check for a narrowing implicit conversion. 4992 APValue PreNarrowingValue; 4993 QualType PreNarrowingType; 4994 switch (SCS->getNarrowingKind(Context, Result.get(), PreNarrowingValue, 4995 PreNarrowingType)) { 4996 case NK_Variable_Narrowing: 4997 // Implicit conversion to a narrower type, and the value is not a constant 4998 // expression. We'll diagnose this in a moment. 4999 case NK_Not_Narrowing: 5000 break; 5001 5002 case NK_Constant_Narrowing: 5003 Diag(From->getLocStart(), diag::ext_cce_narrowing) 5004 << CCE << /*Constant*/1 5005 << PreNarrowingValue.getAsString(Context, PreNarrowingType) << T; 5006 break; 5007 5008 case NK_Type_Narrowing: 5009 Diag(From->getLocStart(), diag::ext_cce_narrowing) 5010 << CCE << /*Constant*/0 << From->getType() << T; 5011 break; 5012 } 5013 5014 // Check the expression is a constant expression. 5015 SmallVector<PartialDiagnosticAt, 8> Notes; 5016 Expr::EvalResult Eval; 5017 Eval.Diag = &Notes; 5018 5019 if (!Result.get()->EvaluateAsRValue(Eval, Context) || !Eval.Val.isInt()) { 5020 // The expression can't be folded, so we can't keep it at this position in 5021 // the AST. 5022 Result = ExprError(); 5023 } else { 5024 Value = Eval.Val.getInt(); 5025 5026 if (Notes.empty()) { 5027 // It's a constant expression. 5028 return Result; 5029 } 5030 } 5031 5032 // It's not a constant expression. Produce an appropriate diagnostic. 5033 if (Notes.size() == 1 && 5034 Notes[0].second.getDiagID() == diag::note_invalid_subexpr_in_const_expr) 5035 Diag(Notes[0].first, diag::err_expr_not_cce) << CCE; 5036 else { 5037 Diag(From->getLocStart(), diag::err_expr_not_cce) 5038 << CCE << From->getSourceRange(); 5039 for (unsigned I = 0; I < Notes.size(); ++I) 5040 Diag(Notes[I].first, Notes[I].second); 5041 } 5042 return Result; 5043} 5044 5045/// dropPointerConversions - If the given standard conversion sequence 5046/// involves any pointer conversions, remove them. This may change 5047/// the result type of the conversion sequence. 5048static void dropPointerConversion(StandardConversionSequence &SCS) { 5049 if (SCS.Second == ICK_Pointer_Conversion) { 5050 SCS.Second = ICK_Identity; 5051 SCS.Third = ICK_Identity; 5052 SCS.ToTypePtrs[2] = SCS.ToTypePtrs[1] = SCS.ToTypePtrs[0]; 5053 } 5054} 5055 5056/// TryContextuallyConvertToObjCPointer - Attempt to contextually 5057/// convert the expression From to an Objective-C pointer type. 5058static ImplicitConversionSequence 5059TryContextuallyConvertToObjCPointer(Sema &S, Expr *From) { 5060 // Do an implicit conversion to 'id'. 5061 QualType Ty = S.Context.getObjCIdType(); 5062 ImplicitConversionSequence ICS 5063 = TryImplicitConversion(S, From, Ty, 5064 // FIXME: Are these flags correct? 5065 /*SuppressUserConversions=*/false, 5066 /*AllowExplicit=*/true, 5067 /*InOverloadResolution=*/false, 5068 /*CStyle=*/false, 5069 /*AllowObjCWritebackConversion=*/false, 5070 /*AllowObjCConversionOnExplicit=*/true); 5071 5072 // Strip off any final conversions to 'id'. 5073 switch (ICS.getKind()) { 5074 case ImplicitConversionSequence::BadConversion: 5075 case ImplicitConversionSequence::AmbiguousConversion: 5076 case ImplicitConversionSequence::EllipsisConversion: 5077 break; 5078 5079 case ImplicitConversionSequence::UserDefinedConversion: 5080 dropPointerConversion(ICS.UserDefined.After); 5081 break; 5082 5083 case ImplicitConversionSequence::StandardConversion: 5084 dropPointerConversion(ICS.Standard); 5085 break; 5086 } 5087 5088 return ICS; 5089} 5090 5091/// PerformContextuallyConvertToObjCPointer - Perform a contextual 5092/// conversion of the expression From to an Objective-C pointer type. 5093ExprResult Sema::PerformContextuallyConvertToObjCPointer(Expr *From) { 5094 if (checkPlaceholderForOverload(*this, From)) 5095 return ExprError(); 5096 5097 QualType Ty = Context.getObjCIdType(); 5098 ImplicitConversionSequence ICS = 5099 TryContextuallyConvertToObjCPointer(*this, From); 5100 if (!ICS.isBad()) 5101 return PerformImplicitConversion(From, Ty, ICS, AA_Converting); 5102 return ExprError(); 5103} 5104 5105/// Determine whether the provided type is an integral type, or an enumeration 5106/// type of a permitted flavor. 5107bool Sema::ICEConvertDiagnoser::match(QualType T) { 5108 return AllowScopedEnumerations ? T->isIntegralOrEnumerationType() 5109 : T->isIntegralOrUnscopedEnumerationType(); 5110} 5111 5112static ExprResult 5113diagnoseAmbiguousConversion(Sema &SemaRef, SourceLocation Loc, Expr *From, 5114 Sema::ContextualImplicitConverter &Converter, 5115 QualType T, UnresolvedSetImpl &ViableConversions) { 5116 5117 if (Converter.Suppress) 5118 return ExprError(); 5119 5120 Converter.diagnoseAmbiguous(SemaRef, Loc, T) << From->getSourceRange(); 5121 for (unsigned I = 0, N = ViableConversions.size(); I != N; ++I) { 5122 CXXConversionDecl *Conv = 5123 cast<CXXConversionDecl>(ViableConversions[I]->getUnderlyingDecl()); 5124 QualType ConvTy = Conv->getConversionType().getNonReferenceType(); 5125 Converter.noteAmbiguous(SemaRef, Conv, ConvTy); 5126 } 5127 return SemaRef.Owned(From); 5128} 5129 5130static bool 5131diagnoseNoViableConversion(Sema &SemaRef, SourceLocation Loc, Expr *&From, 5132 Sema::ContextualImplicitConverter &Converter, 5133 QualType T, bool HadMultipleCandidates, 5134 UnresolvedSetImpl &ExplicitConversions) { 5135 if (ExplicitConversions.size() == 1 && !Converter.Suppress) { 5136 DeclAccessPair Found = ExplicitConversions[0]; 5137 CXXConversionDecl *Conversion = 5138 cast<CXXConversionDecl>(Found->getUnderlyingDecl()); 5139 5140 // The user probably meant to invoke the given explicit 5141 // conversion; use it. 5142 QualType ConvTy = Conversion->getConversionType().getNonReferenceType(); 5143 std::string TypeStr; 5144 ConvTy.getAsStringInternal(TypeStr, SemaRef.getPrintingPolicy()); 5145 5146 Converter.diagnoseExplicitConv(SemaRef, Loc, T, ConvTy) 5147 << FixItHint::CreateInsertion(From->getLocStart(), 5148 "static_cast<" + TypeStr + ">(") 5149 << FixItHint::CreateInsertion( 5150 SemaRef.PP.getLocForEndOfToken(From->getLocEnd()), ")"); 5151 Converter.noteExplicitConv(SemaRef, Conversion, ConvTy); 5152 5153 // If we aren't in a SFINAE context, build a call to the 5154 // explicit conversion function. 5155 if (SemaRef.isSFINAEContext()) 5156 return true; 5157 5158 SemaRef.CheckMemberOperatorAccess(From->getExprLoc(), From, 0, Found); 5159 ExprResult Result = SemaRef.BuildCXXMemberCallExpr(From, Found, Conversion, 5160 HadMultipleCandidates); 5161 if (Result.isInvalid()) 5162 return true; 5163 // Record usage of conversion in an implicit cast. 5164 From = ImplicitCastExpr::Create(SemaRef.Context, Result.get()->getType(), 5165 CK_UserDefinedConversion, Result.get(), 0, 5166 Result.get()->getValueKind()); 5167 } 5168 return false; 5169} 5170 5171static bool recordConversion(Sema &SemaRef, SourceLocation Loc, Expr *&From, 5172 Sema::ContextualImplicitConverter &Converter, 5173 QualType T, bool HadMultipleCandidates, 5174 DeclAccessPair &Found) { 5175 CXXConversionDecl *Conversion = 5176 cast<CXXConversionDecl>(Found->getUnderlyingDecl()); 5177 SemaRef.CheckMemberOperatorAccess(From->getExprLoc(), From, 0, Found); 5178 5179 QualType ToType = Conversion->getConversionType().getNonReferenceType(); 5180 if (!Converter.SuppressConversion) { 5181 if (SemaRef.isSFINAEContext()) 5182 return true; 5183 5184 Converter.diagnoseConversion(SemaRef, Loc, T, ToType) 5185 << From->getSourceRange(); 5186 } 5187 5188 ExprResult Result = SemaRef.BuildCXXMemberCallExpr(From, Found, Conversion, 5189 HadMultipleCandidates); 5190 if (Result.isInvalid()) 5191 return true; 5192 // Record usage of conversion in an implicit cast. 5193 From = ImplicitCastExpr::Create(SemaRef.Context, Result.get()->getType(), 5194 CK_UserDefinedConversion, Result.get(), 0, 5195 Result.get()->getValueKind()); 5196 return false; 5197} 5198 5199static ExprResult finishContextualImplicitConversion( 5200 Sema &SemaRef, SourceLocation Loc, Expr *From, 5201 Sema::ContextualImplicitConverter &Converter) { 5202 if (!Converter.match(From->getType()) && !Converter.Suppress) 5203 Converter.diagnoseNoMatch(SemaRef, Loc, From->getType()) 5204 << From->getSourceRange(); 5205 5206 return SemaRef.DefaultLvalueConversion(From); 5207} 5208 5209static void 5210collectViableConversionCandidates(Sema &SemaRef, Expr *From, QualType ToType, 5211 UnresolvedSetImpl &ViableConversions, 5212 OverloadCandidateSet &CandidateSet) { 5213 for (unsigned I = 0, N = ViableConversions.size(); I != N; ++I) { 5214 DeclAccessPair FoundDecl = ViableConversions[I]; 5215 NamedDecl *D = FoundDecl.getDecl(); 5216 CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext()); 5217 if (isa<UsingShadowDecl>(D)) 5218 D = cast<UsingShadowDecl>(D)->getTargetDecl(); 5219 5220 CXXConversionDecl *Conv; 5221 FunctionTemplateDecl *ConvTemplate; 5222 if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D))) 5223 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl()); 5224 else 5225 Conv = cast<CXXConversionDecl>(D); 5226 5227 if (ConvTemplate) 5228 SemaRef.AddTemplateConversionCandidate( 5229 ConvTemplate, FoundDecl, ActingContext, From, ToType, CandidateSet, 5230 /*AllowObjCConversionOnExplicit=*/false); 5231 else 5232 SemaRef.AddConversionCandidate(Conv, FoundDecl, ActingContext, From, 5233 ToType, CandidateSet, 5234 /*AllowObjCConversionOnExplicit=*/false); 5235 } 5236} 5237 5238/// \brief Attempt to convert the given expression to a type which is accepted 5239/// by the given converter. 5240/// 5241/// This routine will attempt to convert an expression of class type to a 5242/// type accepted by the specified converter. In C++11 and before, the class 5243/// must have a single non-explicit conversion function converting to a matching 5244/// type. In C++1y, there can be multiple such conversion functions, but only 5245/// one target type. 5246/// 5247/// \param Loc The source location of the construct that requires the 5248/// conversion. 5249/// 5250/// \param From The expression we're converting from. 5251/// 5252/// \param Converter Used to control and diagnose the conversion process. 5253/// 5254/// \returns The expression, converted to an integral or enumeration type if 5255/// successful. 5256ExprResult Sema::PerformContextualImplicitConversion( 5257 SourceLocation Loc, Expr *From, ContextualImplicitConverter &Converter) { 5258 // We can't perform any more checking for type-dependent expressions. 5259 if (From->isTypeDependent()) 5260 return Owned(From); 5261 5262 // Process placeholders immediately. 5263 if (From->hasPlaceholderType()) { 5264 ExprResult result = CheckPlaceholderExpr(From); 5265 if (result.isInvalid()) 5266 return result; 5267 From = result.take(); 5268 } 5269 5270 // If the expression already has a matching type, we're golden. 5271 QualType T = From->getType(); 5272 if (Converter.match(T)) 5273 return DefaultLvalueConversion(From); 5274 5275 // FIXME: Check for missing '()' if T is a function type? 5276 5277 // We can only perform contextual implicit conversions on objects of class 5278 // type. 5279 const RecordType *RecordTy = T->getAs<RecordType>(); 5280 if (!RecordTy || !getLangOpts().CPlusPlus) { 5281 if (!Converter.Suppress) 5282 Converter.diagnoseNoMatch(*this, Loc, T) << From->getSourceRange(); 5283 return Owned(From); 5284 } 5285 5286 // We must have a complete class type. 5287 struct TypeDiagnoserPartialDiag : TypeDiagnoser { 5288 ContextualImplicitConverter &Converter; 5289 Expr *From; 5290 5291 TypeDiagnoserPartialDiag(ContextualImplicitConverter &Converter, Expr *From) 5292 : TypeDiagnoser(Converter.Suppress), Converter(Converter), From(From) {} 5293 5294 virtual void diagnose(Sema &S, SourceLocation Loc, QualType T) { 5295 Converter.diagnoseIncomplete(S, Loc, T) << From->getSourceRange(); 5296 } 5297 } IncompleteDiagnoser(Converter, From); 5298 5299 if (RequireCompleteType(Loc, T, IncompleteDiagnoser)) 5300 return Owned(From); 5301 5302 // Look for a conversion to an integral or enumeration type. 5303 UnresolvedSet<4> 5304 ViableConversions; // These are *potentially* viable in C++1y. 5305 UnresolvedSet<4> ExplicitConversions; 5306 std::pair<CXXRecordDecl::conversion_iterator, 5307 CXXRecordDecl::conversion_iterator> Conversions = 5308 cast<CXXRecordDecl>(RecordTy->getDecl())->getVisibleConversionFunctions(); 5309 5310 bool HadMultipleCandidates = 5311 (std::distance(Conversions.first, Conversions.second) > 1); 5312 5313 // To check that there is only one target type, in C++1y: 5314 QualType ToType; 5315 bool HasUniqueTargetType = true; 5316 5317 // Collect explicit or viable (potentially in C++1y) conversions. 5318 for (CXXRecordDecl::conversion_iterator I = Conversions.first, 5319 E = Conversions.second; 5320 I != E; ++I) { 5321 NamedDecl *D = (*I)->getUnderlyingDecl(); 5322 CXXConversionDecl *Conversion; 5323 FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D); 5324 if (ConvTemplate) { 5325 if (getLangOpts().CPlusPlus1y) 5326 Conversion = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl()); 5327 else 5328 continue; // C++11 does not consider conversion operator templates(?). 5329 } else 5330 Conversion = cast<CXXConversionDecl>(D); 5331 5332 assert((!ConvTemplate || getLangOpts().CPlusPlus1y) && 5333 "Conversion operator templates are considered potentially " 5334 "viable in C++1y"); 5335 5336 QualType CurToType = Conversion->getConversionType().getNonReferenceType(); 5337 if (Converter.match(CurToType) || ConvTemplate) { 5338 5339 if (Conversion->isExplicit()) { 5340 // FIXME: For C++1y, do we need this restriction? 5341 // cf. diagnoseNoViableConversion() 5342 if (!ConvTemplate) 5343 ExplicitConversions.addDecl(I.getDecl(), I.getAccess()); 5344 } else { 5345 if (!ConvTemplate && getLangOpts().CPlusPlus1y) { 5346 if (ToType.isNull()) 5347 ToType = CurToType.getUnqualifiedType(); 5348 else if (HasUniqueTargetType && 5349 (CurToType.getUnqualifiedType() != ToType)) 5350 HasUniqueTargetType = false; 5351 } 5352 ViableConversions.addDecl(I.getDecl(), I.getAccess()); 5353 } 5354 } 5355 } 5356 5357 if (getLangOpts().CPlusPlus1y) { 5358 // C++1y [conv]p6: 5359 // ... An expression e of class type E appearing in such a context 5360 // is said to be contextually implicitly converted to a specified 5361 // type T and is well-formed if and only if e can be implicitly 5362 // converted to a type T that is determined as follows: E is searched 5363 // for conversion functions whose return type is cv T or reference to 5364 // cv T such that T is allowed by the context. There shall be 5365 // exactly one such T. 5366 5367 // If no unique T is found: 5368 if (ToType.isNull()) { 5369 if (diagnoseNoViableConversion(*this, Loc, From, Converter, T, 5370 HadMultipleCandidates, 5371 ExplicitConversions)) 5372 return ExprError(); 5373 return finishContextualImplicitConversion(*this, Loc, From, Converter); 5374 } 5375 5376 // If more than one unique Ts are found: 5377 if (!HasUniqueTargetType) 5378 return diagnoseAmbiguousConversion(*this, Loc, From, Converter, T, 5379 ViableConversions); 5380 5381 // If one unique T is found: 5382 // First, build a candidate set from the previously recorded 5383 // potentially viable conversions. 5384 OverloadCandidateSet CandidateSet(Loc); 5385 collectViableConversionCandidates(*this, From, ToType, ViableConversions, 5386 CandidateSet); 5387 5388 // Then, perform overload resolution over the candidate set. 5389 OverloadCandidateSet::iterator Best; 5390 switch (CandidateSet.BestViableFunction(*this, Loc, Best)) { 5391 case OR_Success: { 5392 // Apply this conversion. 5393 DeclAccessPair Found = 5394 DeclAccessPair::make(Best->Function, Best->FoundDecl.getAccess()); 5395 if (recordConversion(*this, Loc, From, Converter, T, 5396 HadMultipleCandidates, Found)) 5397 return ExprError(); 5398 break; 5399 } 5400 case OR_Ambiguous: 5401 return diagnoseAmbiguousConversion(*this, Loc, From, Converter, T, 5402 ViableConversions); 5403 case OR_No_Viable_Function: 5404 if (diagnoseNoViableConversion(*this, Loc, From, Converter, T, 5405 HadMultipleCandidates, 5406 ExplicitConversions)) 5407 return ExprError(); 5408 // fall through 'OR_Deleted' case. 5409 case OR_Deleted: 5410 // We'll complain below about a non-integral condition type. 5411 break; 5412 } 5413 } else { 5414 switch (ViableConversions.size()) { 5415 case 0: { 5416 if (diagnoseNoViableConversion(*this, Loc, From, Converter, T, 5417 HadMultipleCandidates, 5418 ExplicitConversions)) 5419 return ExprError(); 5420 5421 // We'll complain below about a non-integral condition type. 5422 break; 5423 } 5424 case 1: { 5425 // Apply this conversion. 5426 DeclAccessPair Found = ViableConversions[0]; 5427 if (recordConversion(*this, Loc, From, Converter, T, 5428 HadMultipleCandidates, Found)) 5429 return ExprError(); 5430 break; 5431 } 5432 default: 5433 return diagnoseAmbiguousConversion(*this, Loc, From, Converter, T, 5434 ViableConversions); 5435 } 5436 } 5437 5438 return finishContextualImplicitConversion(*this, Loc, From, Converter); 5439} 5440 5441/// AddOverloadCandidate - Adds the given function to the set of 5442/// candidate functions, using the given function call arguments. If 5443/// @p SuppressUserConversions, then don't allow user-defined 5444/// conversions via constructors or conversion operators. 5445/// 5446/// \param PartialOverloading true if we are performing "partial" overloading 5447/// based on an incomplete set of function arguments. This feature is used by 5448/// code completion. 5449void 5450Sema::AddOverloadCandidate(FunctionDecl *Function, 5451 DeclAccessPair FoundDecl, 5452 ArrayRef<Expr *> Args, 5453 OverloadCandidateSet& CandidateSet, 5454 bool SuppressUserConversions, 5455 bool PartialOverloading, 5456 bool AllowExplicit) { 5457 const FunctionProtoType* Proto 5458 = dyn_cast<FunctionProtoType>(Function->getType()->getAs<FunctionType>()); 5459 assert(Proto && "Functions without a prototype cannot be overloaded"); 5460 assert(!Function->getDescribedFunctionTemplate() && 5461 "Use AddTemplateOverloadCandidate for function templates"); 5462 5463 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Function)) { 5464 if (!isa<CXXConstructorDecl>(Method)) { 5465 // If we get here, it's because we're calling a member function 5466 // that is named without a member access expression (e.g., 5467 // "this->f") that was either written explicitly or created 5468 // implicitly. This can happen with a qualified call to a member 5469 // function, e.g., X::f(). We use an empty type for the implied 5470 // object argument (C++ [over.call.func]p3), and the acting context 5471 // is irrelevant. 5472 AddMethodCandidate(Method, FoundDecl, Method->getParent(), 5473 QualType(), Expr::Classification::makeSimpleLValue(), 5474 Args, CandidateSet, SuppressUserConversions); 5475 return; 5476 } 5477 // We treat a constructor like a non-member function, since its object 5478 // argument doesn't participate in overload resolution. 5479 } 5480 5481 if (!CandidateSet.isNewCandidate(Function)) 5482 return; 5483 5484 // C++11 [class.copy]p11: [DR1402] 5485 // A defaulted move constructor that is defined as deleted is ignored by 5486 // overload resolution. 5487 CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Function); 5488 if (Constructor && Constructor->isDefaulted() && Constructor->isDeleted() && 5489 Constructor->isMoveConstructor()) 5490 return; 5491 5492 // Overload resolution is always an unevaluated context. 5493 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); 5494 5495 if (Constructor) { 5496 // C++ [class.copy]p3: 5497 // A member function template is never instantiated to perform the copy 5498 // of a class object to an object of its class type. 5499 QualType ClassType = Context.getTypeDeclType(Constructor->getParent()); 5500 if (Args.size() == 1 && 5501 Constructor->isSpecializationCopyingObject() && 5502 (Context.hasSameUnqualifiedType(ClassType, Args[0]->getType()) || 5503 IsDerivedFrom(Args[0]->getType(), ClassType))) 5504 return; 5505 } 5506 5507 // Add this candidate 5508 OverloadCandidate &Candidate = CandidateSet.addCandidate(Args.size()); 5509 Candidate.FoundDecl = FoundDecl; 5510 Candidate.Function = Function; 5511 Candidate.Viable = true; 5512 Candidate.IsSurrogate = false; 5513 Candidate.IgnoreObjectArgument = false; 5514 Candidate.ExplicitCallArguments = Args.size(); 5515 5516 unsigned NumArgsInProto = Proto->getNumArgs(); 5517 5518 // (C++ 13.3.2p2): A candidate function having fewer than m 5519 // parameters is viable only if it has an ellipsis in its parameter 5520 // list (8.3.5). 5521 if ((Args.size() + (PartialOverloading && Args.size())) > NumArgsInProto && 5522 !Proto->isVariadic()) { 5523 Candidate.Viable = false; 5524 Candidate.FailureKind = ovl_fail_too_many_arguments; 5525 return; 5526 } 5527 5528 // (C++ 13.3.2p2): A candidate function having more than m parameters 5529 // is viable only if the (m+1)st parameter has a default argument 5530 // (8.3.6). For the purposes of overload resolution, the 5531 // parameter list is truncated on the right, so that there are 5532 // exactly m parameters. 5533 unsigned MinRequiredArgs = Function->getMinRequiredArguments(); 5534 if (Args.size() < MinRequiredArgs && !PartialOverloading) { 5535 // Not enough arguments. 5536 Candidate.Viable = false; 5537 Candidate.FailureKind = ovl_fail_too_few_arguments; 5538 return; 5539 } 5540 5541 // (CUDA B.1): Check for invalid calls between targets. 5542 if (getLangOpts().CUDA) 5543 if (const FunctionDecl *Caller = dyn_cast<FunctionDecl>(CurContext)) 5544 if (CheckCUDATarget(Caller, Function)) { 5545 Candidate.Viable = false; 5546 Candidate.FailureKind = ovl_fail_bad_target; 5547 return; 5548 } 5549 5550 // Determine the implicit conversion sequences for each of the 5551 // arguments. 5552 for (unsigned ArgIdx = 0; ArgIdx < Args.size(); ++ArgIdx) { 5553 if (ArgIdx < NumArgsInProto) { 5554 // (C++ 13.3.2p3): for F to be a viable function, there shall 5555 // exist for each argument an implicit conversion sequence 5556 // (13.3.3.1) that converts that argument to the corresponding 5557 // parameter of F. 5558 QualType ParamType = Proto->getArgType(ArgIdx); 5559 Candidate.Conversions[ArgIdx] 5560 = TryCopyInitialization(*this, Args[ArgIdx], ParamType, 5561 SuppressUserConversions, 5562 /*InOverloadResolution=*/true, 5563 /*AllowObjCWritebackConversion=*/ 5564 getLangOpts().ObjCAutoRefCount, 5565 AllowExplicit); 5566 if (Candidate.Conversions[ArgIdx].isBad()) { 5567 Candidate.Viable = false; 5568 Candidate.FailureKind = ovl_fail_bad_conversion; 5569 break; 5570 } 5571 } else { 5572 // (C++ 13.3.2p2): For the purposes of overload resolution, any 5573 // argument for which there is no corresponding parameter is 5574 // considered to ""match the ellipsis" (C+ 13.3.3.1.3). 5575 Candidate.Conversions[ArgIdx].setEllipsis(); 5576 } 5577 } 5578} 5579 5580/// \brief Add all of the function declarations in the given function set to 5581/// the overload candidate set. 5582void Sema::AddFunctionCandidates(const UnresolvedSetImpl &Fns, 5583 ArrayRef<Expr *> Args, 5584 OverloadCandidateSet& CandidateSet, 5585 bool SuppressUserConversions, 5586 TemplateArgumentListInfo *ExplicitTemplateArgs) { 5587 for (UnresolvedSetIterator F = Fns.begin(), E = Fns.end(); F != E; ++F) { 5588 NamedDecl *D = F.getDecl()->getUnderlyingDecl(); 5589 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 5590 if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic()) 5591 AddMethodCandidate(cast<CXXMethodDecl>(FD), F.getPair(), 5592 cast<CXXMethodDecl>(FD)->getParent(), 5593 Args[0]->getType(), Args[0]->Classify(Context), 5594 Args.slice(1), CandidateSet, 5595 SuppressUserConversions); 5596 else 5597 AddOverloadCandidate(FD, F.getPair(), Args, CandidateSet, 5598 SuppressUserConversions); 5599 } else { 5600 FunctionTemplateDecl *FunTmpl = cast<FunctionTemplateDecl>(D); 5601 if (isa<CXXMethodDecl>(FunTmpl->getTemplatedDecl()) && 5602 !cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl())->isStatic()) 5603 AddMethodTemplateCandidate(FunTmpl, F.getPair(), 5604 cast<CXXRecordDecl>(FunTmpl->getDeclContext()), 5605 ExplicitTemplateArgs, 5606 Args[0]->getType(), 5607 Args[0]->Classify(Context), Args.slice(1), 5608 CandidateSet, SuppressUserConversions); 5609 else 5610 AddTemplateOverloadCandidate(FunTmpl, F.getPair(), 5611 ExplicitTemplateArgs, Args, 5612 CandidateSet, SuppressUserConversions); 5613 } 5614 } 5615} 5616 5617/// AddMethodCandidate - Adds a named decl (which is some kind of 5618/// method) as a method candidate to the given overload set. 5619void Sema::AddMethodCandidate(DeclAccessPair FoundDecl, 5620 QualType ObjectType, 5621 Expr::Classification ObjectClassification, 5622 ArrayRef<Expr *> Args, 5623 OverloadCandidateSet& CandidateSet, 5624 bool SuppressUserConversions) { 5625 NamedDecl *Decl = FoundDecl.getDecl(); 5626 CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(Decl->getDeclContext()); 5627 5628 if (isa<UsingShadowDecl>(Decl)) 5629 Decl = cast<UsingShadowDecl>(Decl)->getTargetDecl(); 5630 5631 if (FunctionTemplateDecl *TD = dyn_cast<FunctionTemplateDecl>(Decl)) { 5632 assert(isa<CXXMethodDecl>(TD->getTemplatedDecl()) && 5633 "Expected a member function template"); 5634 AddMethodTemplateCandidate(TD, FoundDecl, ActingContext, 5635 /*ExplicitArgs*/ 0, 5636 ObjectType, ObjectClassification, 5637 Args, CandidateSet, 5638 SuppressUserConversions); 5639 } else { 5640 AddMethodCandidate(cast<CXXMethodDecl>(Decl), FoundDecl, ActingContext, 5641 ObjectType, ObjectClassification, 5642 Args, 5643 CandidateSet, SuppressUserConversions); 5644 } 5645} 5646 5647/// AddMethodCandidate - Adds the given C++ member function to the set 5648/// of candidate functions, using the given function call arguments 5649/// and the object argument (@c Object). For example, in a call 5650/// @c o.f(a1,a2), @c Object will contain @c o and @c Args will contain 5651/// both @c a1 and @c a2. If @p SuppressUserConversions, then don't 5652/// allow user-defined conversions via constructors or conversion 5653/// operators. 5654void 5655Sema::AddMethodCandidate(CXXMethodDecl *Method, DeclAccessPair FoundDecl, 5656 CXXRecordDecl *ActingContext, QualType ObjectType, 5657 Expr::Classification ObjectClassification, 5658 ArrayRef<Expr *> Args, 5659 OverloadCandidateSet& CandidateSet, 5660 bool SuppressUserConversions) { 5661 const FunctionProtoType* Proto 5662 = dyn_cast<FunctionProtoType>(Method->getType()->getAs<FunctionType>()); 5663 assert(Proto && "Methods without a prototype cannot be overloaded"); 5664 assert(!isa<CXXConstructorDecl>(Method) && 5665 "Use AddOverloadCandidate for constructors"); 5666 5667 if (!CandidateSet.isNewCandidate(Method)) 5668 return; 5669 5670 // C++11 [class.copy]p23: [DR1402] 5671 // A defaulted move assignment operator that is defined as deleted is 5672 // ignored by overload resolution. 5673 if (Method->isDefaulted() && Method->isDeleted() && 5674 Method->isMoveAssignmentOperator()) 5675 return; 5676 5677 // Overload resolution is always an unevaluated context. 5678 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); 5679 5680 // Add this candidate 5681 OverloadCandidate &Candidate = CandidateSet.addCandidate(Args.size() + 1); 5682 Candidate.FoundDecl = FoundDecl; 5683 Candidate.Function = Method; 5684 Candidate.IsSurrogate = false; 5685 Candidate.IgnoreObjectArgument = false; 5686 Candidate.ExplicitCallArguments = Args.size(); 5687 5688 unsigned NumArgsInProto = Proto->getNumArgs(); 5689 5690 // (C++ 13.3.2p2): A candidate function having fewer than m 5691 // parameters is viable only if it has an ellipsis in its parameter 5692 // list (8.3.5). 5693 if (Args.size() > NumArgsInProto && !Proto->isVariadic()) { 5694 Candidate.Viable = false; 5695 Candidate.FailureKind = ovl_fail_too_many_arguments; 5696 return; 5697 } 5698 5699 // (C++ 13.3.2p2): A candidate function having more than m parameters 5700 // is viable only if the (m+1)st parameter has a default argument 5701 // (8.3.6). For the purposes of overload resolution, the 5702 // parameter list is truncated on the right, so that there are 5703 // exactly m parameters. 5704 unsigned MinRequiredArgs = Method->getMinRequiredArguments(); 5705 if (Args.size() < MinRequiredArgs) { 5706 // Not enough arguments. 5707 Candidate.Viable = false; 5708 Candidate.FailureKind = ovl_fail_too_few_arguments; 5709 return; 5710 } 5711 5712 Candidate.Viable = true; 5713 5714 if (Method->isStatic() || ObjectType.isNull()) 5715 // The implicit object argument is ignored. 5716 Candidate.IgnoreObjectArgument = true; 5717 else { 5718 // Determine the implicit conversion sequence for the object 5719 // parameter. 5720 Candidate.Conversions[0] 5721 = TryObjectArgumentInitialization(*this, ObjectType, ObjectClassification, 5722 Method, ActingContext); 5723 if (Candidate.Conversions[0].isBad()) { 5724 Candidate.Viable = false; 5725 Candidate.FailureKind = ovl_fail_bad_conversion; 5726 return; 5727 } 5728 } 5729 5730 // Determine the implicit conversion sequences for each of the 5731 // arguments. 5732 for (unsigned ArgIdx = 0; ArgIdx < Args.size(); ++ArgIdx) { 5733 if (ArgIdx < NumArgsInProto) { 5734 // (C++ 13.3.2p3): for F to be a viable function, there shall 5735 // exist for each argument an implicit conversion sequence 5736 // (13.3.3.1) that converts that argument to the corresponding 5737 // parameter of F. 5738 QualType ParamType = Proto->getArgType(ArgIdx); 5739 Candidate.Conversions[ArgIdx + 1] 5740 = TryCopyInitialization(*this, Args[ArgIdx], ParamType, 5741 SuppressUserConversions, 5742 /*InOverloadResolution=*/true, 5743 /*AllowObjCWritebackConversion=*/ 5744 getLangOpts().ObjCAutoRefCount); 5745 if (Candidate.Conversions[ArgIdx + 1].isBad()) { 5746 Candidate.Viable = false; 5747 Candidate.FailureKind = ovl_fail_bad_conversion; 5748 break; 5749 } 5750 } else { 5751 // (C++ 13.3.2p2): For the purposes of overload resolution, any 5752 // argument for which there is no corresponding parameter is 5753 // considered to ""match the ellipsis" (C+ 13.3.3.1.3). 5754 Candidate.Conversions[ArgIdx + 1].setEllipsis(); 5755 } 5756 } 5757} 5758 5759/// \brief Add a C++ member function template as a candidate to the candidate 5760/// set, using template argument deduction to produce an appropriate member 5761/// function template specialization. 5762void 5763Sema::AddMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl, 5764 DeclAccessPair FoundDecl, 5765 CXXRecordDecl *ActingContext, 5766 TemplateArgumentListInfo *ExplicitTemplateArgs, 5767 QualType ObjectType, 5768 Expr::Classification ObjectClassification, 5769 ArrayRef<Expr *> Args, 5770 OverloadCandidateSet& CandidateSet, 5771 bool SuppressUserConversions) { 5772 if (!CandidateSet.isNewCandidate(MethodTmpl)) 5773 return; 5774 5775 // C++ [over.match.funcs]p7: 5776 // In each case where a candidate is a function template, candidate 5777 // function template specializations are generated using template argument 5778 // deduction (14.8.3, 14.8.2). Those candidates are then handled as 5779 // candidate functions in the usual way.113) A given name can refer to one 5780 // or more function templates and also to a set of overloaded non-template 5781 // functions. In such a case, the candidate functions generated from each 5782 // function template are combined with the set of non-template candidate 5783 // functions. 5784 TemplateDeductionInfo Info(CandidateSet.getLocation()); 5785 FunctionDecl *Specialization = 0; 5786 if (TemplateDeductionResult Result 5787 = DeduceTemplateArguments(MethodTmpl, ExplicitTemplateArgs, Args, 5788 Specialization, Info)) { 5789 OverloadCandidate &Candidate = CandidateSet.addCandidate(); 5790 Candidate.FoundDecl = FoundDecl; 5791 Candidate.Function = MethodTmpl->getTemplatedDecl(); 5792 Candidate.Viable = false; 5793 Candidate.FailureKind = ovl_fail_bad_deduction; 5794 Candidate.IsSurrogate = false; 5795 Candidate.IgnoreObjectArgument = false; 5796 Candidate.ExplicitCallArguments = Args.size(); 5797 Candidate.DeductionFailure = MakeDeductionFailureInfo(Context, Result, 5798 Info); 5799 return; 5800 } 5801 5802 // Add the function template specialization produced by template argument 5803 // deduction as a candidate. 5804 assert(Specialization && "Missing member function template specialization?"); 5805 assert(isa<CXXMethodDecl>(Specialization) && 5806 "Specialization is not a member function?"); 5807 AddMethodCandidate(cast<CXXMethodDecl>(Specialization), FoundDecl, 5808 ActingContext, ObjectType, ObjectClassification, Args, 5809 CandidateSet, SuppressUserConversions); 5810} 5811 5812/// \brief Add a C++ function template specialization as a candidate 5813/// in the candidate set, using template argument deduction to produce 5814/// an appropriate function template specialization. 5815void 5816Sema::AddTemplateOverloadCandidate(FunctionTemplateDecl *FunctionTemplate, 5817 DeclAccessPair FoundDecl, 5818 TemplateArgumentListInfo *ExplicitTemplateArgs, 5819 ArrayRef<Expr *> Args, 5820 OverloadCandidateSet& CandidateSet, 5821 bool SuppressUserConversions) { 5822 if (!CandidateSet.isNewCandidate(FunctionTemplate)) 5823 return; 5824 5825 // C++ [over.match.funcs]p7: 5826 // In each case where a candidate is a function template, candidate 5827 // function template specializations are generated using template argument 5828 // deduction (14.8.3, 14.8.2). Those candidates are then handled as 5829 // candidate functions in the usual way.113) A given name can refer to one 5830 // or more function templates and also to a set of overloaded non-template 5831 // functions. In such a case, the candidate functions generated from each 5832 // function template are combined with the set of non-template candidate 5833 // functions. 5834 TemplateDeductionInfo Info(CandidateSet.getLocation()); 5835 FunctionDecl *Specialization = 0; 5836 if (TemplateDeductionResult Result 5837 = DeduceTemplateArguments(FunctionTemplate, ExplicitTemplateArgs, Args, 5838 Specialization, Info)) { 5839 OverloadCandidate &Candidate = CandidateSet.addCandidate(); 5840 Candidate.FoundDecl = FoundDecl; 5841 Candidate.Function = FunctionTemplate->getTemplatedDecl(); 5842 Candidate.Viable = false; 5843 Candidate.FailureKind = ovl_fail_bad_deduction; 5844 Candidate.IsSurrogate = false; 5845 Candidate.IgnoreObjectArgument = false; 5846 Candidate.ExplicitCallArguments = Args.size(); 5847 Candidate.DeductionFailure = MakeDeductionFailureInfo(Context, Result, 5848 Info); 5849 return; 5850 } 5851 5852 // Add the function template specialization produced by template argument 5853 // deduction as a candidate. 5854 assert(Specialization && "Missing function template specialization?"); 5855 AddOverloadCandidate(Specialization, FoundDecl, Args, CandidateSet, 5856 SuppressUserConversions); 5857} 5858 5859/// Determine whether this is an allowable conversion from the result 5860/// of an explicit conversion operator to the expected type, per C++ 5861/// [over.match.conv]p1 and [over.match.ref]p1. 5862/// 5863/// \param ConvType The return type of the conversion function. 5864/// 5865/// \param ToType The type we are converting to. 5866/// 5867/// \param AllowObjCPointerConversion Allow a conversion from one 5868/// Objective-C pointer to another. 5869/// 5870/// \returns true if the conversion is allowable, false otherwise. 5871static bool isAllowableExplicitConversion(Sema &S, 5872 QualType ConvType, QualType ToType, 5873 bool AllowObjCPointerConversion) { 5874 QualType ToNonRefType = ToType.getNonReferenceType(); 5875 5876 // Easy case: the types are the same. 5877 if (S.Context.hasSameUnqualifiedType(ConvType, ToNonRefType)) 5878 return true; 5879 5880 // Allow qualification conversions. 5881 bool ObjCLifetimeConversion; 5882 if (S.IsQualificationConversion(ConvType, ToNonRefType, /*CStyle*/false, 5883 ObjCLifetimeConversion)) 5884 return true; 5885 5886 // If we're not allowed to consider Objective-C pointer conversions, 5887 // we're done. 5888 if (!AllowObjCPointerConversion) 5889 return false; 5890 5891 // Is this an Objective-C pointer conversion? 5892 bool IncompatibleObjC = false; 5893 QualType ConvertedType; 5894 return S.isObjCPointerConversion(ConvType, ToNonRefType, ConvertedType, 5895 IncompatibleObjC); 5896} 5897 5898/// AddConversionCandidate - Add a C++ conversion function as a 5899/// candidate in the candidate set (C++ [over.match.conv], 5900/// C++ [over.match.copy]). From is the expression we're converting from, 5901/// and ToType is the type that we're eventually trying to convert to 5902/// (which may or may not be the same type as the type that the 5903/// conversion function produces). 5904void 5905Sema::AddConversionCandidate(CXXConversionDecl *Conversion, 5906 DeclAccessPair FoundDecl, 5907 CXXRecordDecl *ActingContext, 5908 Expr *From, QualType ToType, 5909 OverloadCandidateSet& CandidateSet, 5910 bool AllowObjCConversionOnExplicit) { 5911 assert(!Conversion->getDescribedFunctionTemplate() && 5912 "Conversion function templates use AddTemplateConversionCandidate"); 5913 QualType ConvType = Conversion->getConversionType().getNonReferenceType(); 5914 if (!CandidateSet.isNewCandidate(Conversion)) 5915 return; 5916 5917 // If the conversion function has an undeduced return type, trigger its 5918 // deduction now. 5919 if (getLangOpts().CPlusPlus1y && ConvType->isUndeducedType()) { 5920 if (DeduceReturnType(Conversion, From->getExprLoc())) 5921 return; 5922 ConvType = Conversion->getConversionType().getNonReferenceType(); 5923 } 5924 5925 // Per C++ [over.match.conv]p1, [over.match.ref]p1, an explicit conversion 5926 // operator is only a candidate if its return type is the target type or 5927 // can be converted to the target type with a qualification conversion. 5928 if (Conversion->isExplicit() && 5929 !isAllowableExplicitConversion(*this, ConvType, ToType, 5930 AllowObjCConversionOnExplicit)) 5931 return; 5932 5933 // Overload resolution is always an unevaluated context. 5934 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); 5935 5936 // Add this candidate 5937 OverloadCandidate &Candidate = CandidateSet.addCandidate(1); 5938 Candidate.FoundDecl = FoundDecl; 5939 Candidate.Function = Conversion; 5940 Candidate.IsSurrogate = false; 5941 Candidate.IgnoreObjectArgument = false; 5942 Candidate.FinalConversion.setAsIdentityConversion(); 5943 Candidate.FinalConversion.setFromType(ConvType); 5944 Candidate.FinalConversion.setAllToTypes(ToType); 5945 Candidate.Viable = true; 5946 Candidate.ExplicitCallArguments = 1; 5947 5948 // C++ [over.match.funcs]p4: 5949 // For conversion functions, the function is considered to be a member of 5950 // the class of the implicit implied object argument for the purpose of 5951 // defining the type of the implicit object parameter. 5952 // 5953 // Determine the implicit conversion sequence for the implicit 5954 // object parameter. 5955 QualType ImplicitParamType = From->getType(); 5956 if (const PointerType *FromPtrType = ImplicitParamType->getAs<PointerType>()) 5957 ImplicitParamType = FromPtrType->getPointeeType(); 5958 CXXRecordDecl *ConversionContext 5959 = cast<CXXRecordDecl>(ImplicitParamType->getAs<RecordType>()->getDecl()); 5960 5961 Candidate.Conversions[0] 5962 = TryObjectArgumentInitialization(*this, From->getType(), 5963 From->Classify(Context), 5964 Conversion, ConversionContext); 5965 5966 if (Candidate.Conversions[0].isBad()) { 5967 Candidate.Viable = false; 5968 Candidate.FailureKind = ovl_fail_bad_conversion; 5969 return; 5970 } 5971 5972 // We won't go through a user-define type conversion function to convert a 5973 // derived to base as such conversions are given Conversion Rank. They only 5974 // go through a copy constructor. 13.3.3.1.2-p4 [over.ics.user] 5975 QualType FromCanon 5976 = Context.getCanonicalType(From->getType().getUnqualifiedType()); 5977 QualType ToCanon = Context.getCanonicalType(ToType).getUnqualifiedType(); 5978 if (FromCanon == ToCanon || IsDerivedFrom(FromCanon, ToCanon)) { 5979 Candidate.Viable = false; 5980 Candidate.FailureKind = ovl_fail_trivial_conversion; 5981 return; 5982 } 5983 5984 // To determine what the conversion from the result of calling the 5985 // conversion function to the type we're eventually trying to 5986 // convert to (ToType), we need to synthesize a call to the 5987 // conversion function and attempt copy initialization from it. This 5988 // makes sure that we get the right semantics with respect to 5989 // lvalues/rvalues and the type. Fortunately, we can allocate this 5990 // call on the stack and we don't need its arguments to be 5991 // well-formed. 5992 DeclRefExpr ConversionRef(Conversion, false, Conversion->getType(), 5993 VK_LValue, From->getLocStart()); 5994 ImplicitCastExpr ConversionFn(ImplicitCastExpr::OnStack, 5995 Context.getPointerType(Conversion->getType()), 5996 CK_FunctionToPointerDecay, 5997 &ConversionRef, VK_RValue); 5998 5999 QualType ConversionType = Conversion->getConversionType(); 6000 if (RequireCompleteType(From->getLocStart(), ConversionType, 0)) { 6001 Candidate.Viable = false; 6002 Candidate.FailureKind = ovl_fail_bad_final_conversion; 6003 return; 6004 } 6005 6006 ExprValueKind VK = Expr::getValueKindForType(ConversionType); 6007 6008 // Note that it is safe to allocate CallExpr on the stack here because 6009 // there are 0 arguments (i.e., nothing is allocated using ASTContext's 6010 // allocator). 6011 QualType CallResultType = ConversionType.getNonLValueExprType(Context); 6012 CallExpr Call(Context, &ConversionFn, None, CallResultType, VK, 6013 From->getLocStart()); 6014 ImplicitConversionSequence ICS = 6015 TryCopyInitialization(*this, &Call, ToType, 6016 /*SuppressUserConversions=*/true, 6017 /*InOverloadResolution=*/false, 6018 /*AllowObjCWritebackConversion=*/false); 6019 6020 switch (ICS.getKind()) { 6021 case ImplicitConversionSequence::StandardConversion: 6022 Candidate.FinalConversion = ICS.Standard; 6023 6024 // C++ [over.ics.user]p3: 6025 // If the user-defined conversion is specified by a specialization of a 6026 // conversion function template, the second standard conversion sequence 6027 // shall have exact match rank. 6028 if (Conversion->getPrimaryTemplate() && 6029 GetConversionRank(ICS.Standard.Second) != ICR_Exact_Match) { 6030 Candidate.Viable = false; 6031 Candidate.FailureKind = ovl_fail_final_conversion_not_exact; 6032 } 6033 6034 // C++0x [dcl.init.ref]p5: 6035 // In the second case, if the reference is an rvalue reference and 6036 // the second standard conversion sequence of the user-defined 6037 // conversion sequence includes an lvalue-to-rvalue conversion, the 6038 // program is ill-formed. 6039 if (ToType->isRValueReferenceType() && 6040 ICS.Standard.First == ICK_Lvalue_To_Rvalue) { 6041 Candidate.Viable = false; 6042 Candidate.FailureKind = ovl_fail_bad_final_conversion; 6043 } 6044 break; 6045 6046 case ImplicitConversionSequence::BadConversion: 6047 Candidate.Viable = false; 6048 Candidate.FailureKind = ovl_fail_bad_final_conversion; 6049 break; 6050 6051 default: 6052 llvm_unreachable( 6053 "Can only end up with a standard conversion sequence or failure"); 6054 } 6055} 6056 6057/// \brief Adds a conversion function template specialization 6058/// candidate to the overload set, using template argument deduction 6059/// to deduce the template arguments of the conversion function 6060/// template from the type that we are converting to (C++ 6061/// [temp.deduct.conv]). 6062void 6063Sema::AddTemplateConversionCandidate(FunctionTemplateDecl *FunctionTemplate, 6064 DeclAccessPair FoundDecl, 6065 CXXRecordDecl *ActingDC, 6066 Expr *From, QualType ToType, 6067 OverloadCandidateSet &CandidateSet, 6068 bool AllowObjCConversionOnExplicit) { 6069 assert(isa<CXXConversionDecl>(FunctionTemplate->getTemplatedDecl()) && 6070 "Only conversion function templates permitted here"); 6071 6072 if (!CandidateSet.isNewCandidate(FunctionTemplate)) 6073 return; 6074 6075 TemplateDeductionInfo Info(CandidateSet.getLocation()); 6076 CXXConversionDecl *Specialization = 0; 6077 if (TemplateDeductionResult Result 6078 = DeduceTemplateArguments(FunctionTemplate, ToType, 6079 Specialization, Info)) { 6080 OverloadCandidate &Candidate = CandidateSet.addCandidate(); 6081 Candidate.FoundDecl = FoundDecl; 6082 Candidate.Function = FunctionTemplate->getTemplatedDecl(); 6083 Candidate.Viable = false; 6084 Candidate.FailureKind = ovl_fail_bad_deduction; 6085 Candidate.IsSurrogate = false; 6086 Candidate.IgnoreObjectArgument = false; 6087 Candidate.ExplicitCallArguments = 1; 6088 Candidate.DeductionFailure = MakeDeductionFailureInfo(Context, Result, 6089 Info); 6090 return; 6091 } 6092 6093 // Add the conversion function template specialization produced by 6094 // template argument deduction as a candidate. 6095 assert(Specialization && "Missing function template specialization?"); 6096 AddConversionCandidate(Specialization, FoundDecl, ActingDC, From, ToType, 6097 CandidateSet, AllowObjCConversionOnExplicit); 6098} 6099 6100/// AddSurrogateCandidate - Adds a "surrogate" candidate function that 6101/// converts the given @c Object to a function pointer via the 6102/// conversion function @c Conversion, and then attempts to call it 6103/// with the given arguments (C++ [over.call.object]p2-4). Proto is 6104/// the type of function that we'll eventually be calling. 6105void Sema::AddSurrogateCandidate(CXXConversionDecl *Conversion, 6106 DeclAccessPair FoundDecl, 6107 CXXRecordDecl *ActingContext, 6108 const FunctionProtoType *Proto, 6109 Expr *Object, 6110 ArrayRef<Expr *> Args, 6111 OverloadCandidateSet& CandidateSet) { 6112 if (!CandidateSet.isNewCandidate(Conversion)) 6113 return; 6114 6115 // Overload resolution is always an unevaluated context. 6116 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); 6117 6118 OverloadCandidate &Candidate = CandidateSet.addCandidate(Args.size() + 1); 6119 Candidate.FoundDecl = FoundDecl; 6120 Candidate.Function = 0; 6121 Candidate.Surrogate = Conversion; 6122 Candidate.Viable = true; 6123 Candidate.IsSurrogate = true; 6124 Candidate.IgnoreObjectArgument = false; 6125 Candidate.ExplicitCallArguments = Args.size(); 6126 6127 // Determine the implicit conversion sequence for the implicit 6128 // object parameter. 6129 ImplicitConversionSequence ObjectInit 6130 = TryObjectArgumentInitialization(*this, Object->getType(), 6131 Object->Classify(Context), 6132 Conversion, ActingContext); 6133 if (ObjectInit.isBad()) { 6134 Candidate.Viable = false; 6135 Candidate.FailureKind = ovl_fail_bad_conversion; 6136 Candidate.Conversions[0] = ObjectInit; 6137 return; 6138 } 6139 6140 // The first conversion is actually a user-defined conversion whose 6141 // first conversion is ObjectInit's standard conversion (which is 6142 // effectively a reference binding). Record it as such. 6143 Candidate.Conversions[0].setUserDefined(); 6144 Candidate.Conversions[0].UserDefined.Before = ObjectInit.Standard; 6145 Candidate.Conversions[0].UserDefined.EllipsisConversion = false; 6146 Candidate.Conversions[0].UserDefined.HadMultipleCandidates = false; 6147 Candidate.Conversions[0].UserDefined.ConversionFunction = Conversion; 6148 Candidate.Conversions[0].UserDefined.FoundConversionFunction = FoundDecl; 6149 Candidate.Conversions[0].UserDefined.After 6150 = Candidate.Conversions[0].UserDefined.Before; 6151 Candidate.Conversions[0].UserDefined.After.setAsIdentityConversion(); 6152 6153 // Find the 6154 unsigned NumArgsInProto = Proto->getNumArgs(); 6155 6156 // (C++ 13.3.2p2): A candidate function having fewer than m 6157 // parameters is viable only if it has an ellipsis in its parameter 6158 // list (8.3.5). 6159 if (Args.size() > NumArgsInProto && !Proto->isVariadic()) { 6160 Candidate.Viable = false; 6161 Candidate.FailureKind = ovl_fail_too_many_arguments; 6162 return; 6163 } 6164 6165 // Function types don't have any default arguments, so just check if 6166 // we have enough arguments. 6167 if (Args.size() < NumArgsInProto) { 6168 // Not enough arguments. 6169 Candidate.Viable = false; 6170 Candidate.FailureKind = ovl_fail_too_few_arguments; 6171 return; 6172 } 6173 6174 // Determine the implicit conversion sequences for each of the 6175 // arguments. 6176 for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) { 6177 if (ArgIdx < NumArgsInProto) { 6178 // (C++ 13.3.2p3): for F to be a viable function, there shall 6179 // exist for each argument an implicit conversion sequence 6180 // (13.3.3.1) that converts that argument to the corresponding 6181 // parameter of F. 6182 QualType ParamType = Proto->getArgType(ArgIdx); 6183 Candidate.Conversions[ArgIdx + 1] 6184 = TryCopyInitialization(*this, Args[ArgIdx], ParamType, 6185 /*SuppressUserConversions=*/false, 6186 /*InOverloadResolution=*/false, 6187 /*AllowObjCWritebackConversion=*/ 6188 getLangOpts().ObjCAutoRefCount); 6189 if (Candidate.Conversions[ArgIdx + 1].isBad()) { 6190 Candidate.Viable = false; 6191 Candidate.FailureKind = ovl_fail_bad_conversion; 6192 break; 6193 } 6194 } else { 6195 // (C++ 13.3.2p2): For the purposes of overload resolution, any 6196 // argument for which there is no corresponding parameter is 6197 // considered to ""match the ellipsis" (C+ 13.3.3.1.3). 6198 Candidate.Conversions[ArgIdx + 1].setEllipsis(); 6199 } 6200 } 6201} 6202 6203/// \brief Add overload candidates for overloaded operators that are 6204/// member functions. 6205/// 6206/// Add the overloaded operator candidates that are member functions 6207/// for the operator Op that was used in an operator expression such 6208/// as "x Op y". , Args/NumArgs provides the operator arguments, and 6209/// CandidateSet will store the added overload candidates. (C++ 6210/// [over.match.oper]). 6211void Sema::AddMemberOperatorCandidates(OverloadedOperatorKind Op, 6212 SourceLocation OpLoc, 6213 ArrayRef<Expr *> Args, 6214 OverloadCandidateSet& CandidateSet, 6215 SourceRange OpRange) { 6216 DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op); 6217 6218 // C++ [over.match.oper]p3: 6219 // For a unary operator @ with an operand of a type whose 6220 // cv-unqualified version is T1, and for a binary operator @ with 6221 // a left operand of a type whose cv-unqualified version is T1 and 6222 // a right operand of a type whose cv-unqualified version is T2, 6223 // three sets of candidate functions, designated member 6224 // candidates, non-member candidates and built-in candidates, are 6225 // constructed as follows: 6226 QualType T1 = Args[0]->getType(); 6227 6228 // -- If T1 is a complete class type or a class currently being 6229 // defined, the set of member candidates is the result of the 6230 // qualified lookup of T1::operator@ (13.3.1.1.1); otherwise, 6231 // the set of member candidates is empty. 6232 if (const RecordType *T1Rec = T1->getAs<RecordType>()) { 6233 // Complete the type if it can be completed. 6234 RequireCompleteType(OpLoc, T1, 0); 6235 // If the type is neither complete nor being defined, bail out now. 6236 if (!T1Rec->getDecl()->getDefinition()) 6237 return; 6238 6239 LookupResult Operators(*this, OpName, OpLoc, LookupOrdinaryName); 6240 LookupQualifiedName(Operators, T1Rec->getDecl()); 6241 Operators.suppressDiagnostics(); 6242 6243 for (LookupResult::iterator Oper = Operators.begin(), 6244 OperEnd = Operators.end(); 6245 Oper != OperEnd; 6246 ++Oper) 6247 AddMethodCandidate(Oper.getPair(), Args[0]->getType(), 6248 Args[0]->Classify(Context), 6249 Args.slice(1), 6250 CandidateSet, 6251 /* SuppressUserConversions = */ false); 6252 } 6253} 6254 6255/// AddBuiltinCandidate - Add a candidate for a built-in 6256/// operator. ResultTy and ParamTys are the result and parameter types 6257/// of the built-in candidate, respectively. Args and NumArgs are the 6258/// arguments being passed to the candidate. IsAssignmentOperator 6259/// should be true when this built-in candidate is an assignment 6260/// operator. NumContextualBoolArguments is the number of arguments 6261/// (at the beginning of the argument list) that will be contextually 6262/// converted to bool. 6263void Sema::AddBuiltinCandidate(QualType ResultTy, QualType *ParamTys, 6264 ArrayRef<Expr *> Args, 6265 OverloadCandidateSet& CandidateSet, 6266 bool IsAssignmentOperator, 6267 unsigned NumContextualBoolArguments) { 6268 // Overload resolution is always an unevaluated context. 6269 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); 6270 6271 // Add this candidate 6272 OverloadCandidate &Candidate = CandidateSet.addCandidate(Args.size()); 6273 Candidate.FoundDecl = DeclAccessPair::make(0, AS_none); 6274 Candidate.Function = 0; 6275 Candidate.IsSurrogate = false; 6276 Candidate.IgnoreObjectArgument = false; 6277 Candidate.BuiltinTypes.ResultTy = ResultTy; 6278 for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) 6279 Candidate.BuiltinTypes.ParamTypes[ArgIdx] = ParamTys[ArgIdx]; 6280 6281 // Determine the implicit conversion sequences for each of the 6282 // arguments. 6283 Candidate.Viable = true; 6284 Candidate.ExplicitCallArguments = Args.size(); 6285 for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) { 6286 // C++ [over.match.oper]p4: 6287 // For the built-in assignment operators, conversions of the 6288 // left operand are restricted as follows: 6289 // -- no temporaries are introduced to hold the left operand, and 6290 // -- no user-defined conversions are applied to the left 6291 // operand to achieve a type match with the left-most 6292 // parameter of a built-in candidate. 6293 // 6294 // We block these conversions by turning off user-defined 6295 // conversions, since that is the only way that initialization of 6296 // a reference to a non-class type can occur from something that 6297 // is not of the same type. 6298 if (ArgIdx < NumContextualBoolArguments) { 6299 assert(ParamTys[ArgIdx] == Context.BoolTy && 6300 "Contextual conversion to bool requires bool type"); 6301 Candidate.Conversions[ArgIdx] 6302 = TryContextuallyConvertToBool(*this, Args[ArgIdx]); 6303 } else { 6304 Candidate.Conversions[ArgIdx] 6305 = TryCopyInitialization(*this, Args[ArgIdx], ParamTys[ArgIdx], 6306 ArgIdx == 0 && IsAssignmentOperator, 6307 /*InOverloadResolution=*/false, 6308 /*AllowObjCWritebackConversion=*/ 6309 getLangOpts().ObjCAutoRefCount); 6310 } 6311 if (Candidate.Conversions[ArgIdx].isBad()) { 6312 Candidate.Viable = false; 6313 Candidate.FailureKind = ovl_fail_bad_conversion; 6314 break; 6315 } 6316 } 6317} 6318 6319namespace { 6320 6321/// BuiltinCandidateTypeSet - A set of types that will be used for the 6322/// candidate operator functions for built-in operators (C++ 6323/// [over.built]). The types are separated into pointer types and 6324/// enumeration types. 6325class BuiltinCandidateTypeSet { 6326 /// TypeSet - A set of types. 6327 typedef llvm::SmallPtrSet<QualType, 8> TypeSet; 6328 6329 /// PointerTypes - The set of pointer types that will be used in the 6330 /// built-in candidates. 6331 TypeSet PointerTypes; 6332 6333 /// MemberPointerTypes - The set of member pointer types that will be 6334 /// used in the built-in candidates. 6335 TypeSet MemberPointerTypes; 6336 6337 /// EnumerationTypes - The set of enumeration types that will be 6338 /// used in the built-in candidates. 6339 TypeSet EnumerationTypes; 6340 6341 /// \brief The set of vector types that will be used in the built-in 6342 /// candidates. 6343 TypeSet VectorTypes; 6344 6345 /// \brief A flag indicating non-record types are viable candidates 6346 bool HasNonRecordTypes; 6347 6348 /// \brief A flag indicating whether either arithmetic or enumeration types 6349 /// were present in the candidate set. 6350 bool HasArithmeticOrEnumeralTypes; 6351 6352 /// \brief A flag indicating whether the nullptr type was present in the 6353 /// candidate set. 6354 bool HasNullPtrType; 6355 6356 /// Sema - The semantic analysis instance where we are building the 6357 /// candidate type set. 6358 Sema &SemaRef; 6359 6360 /// Context - The AST context in which we will build the type sets. 6361 ASTContext &Context; 6362 6363 bool AddPointerWithMoreQualifiedTypeVariants(QualType Ty, 6364 const Qualifiers &VisibleQuals); 6365 bool AddMemberPointerWithMoreQualifiedTypeVariants(QualType Ty); 6366 6367public: 6368 /// iterator - Iterates through the types that are part of the set. 6369 typedef TypeSet::iterator iterator; 6370 6371 BuiltinCandidateTypeSet(Sema &SemaRef) 6372 : HasNonRecordTypes(false), 6373 HasArithmeticOrEnumeralTypes(false), 6374 HasNullPtrType(false), 6375 SemaRef(SemaRef), 6376 Context(SemaRef.Context) { } 6377 6378 void AddTypesConvertedFrom(QualType Ty, 6379 SourceLocation Loc, 6380 bool AllowUserConversions, 6381 bool AllowExplicitConversions, 6382 const Qualifiers &VisibleTypeConversionsQuals); 6383 6384 /// pointer_begin - First pointer type found; 6385 iterator pointer_begin() { return PointerTypes.begin(); } 6386 6387 /// pointer_end - Past the last pointer type found; 6388 iterator pointer_end() { return PointerTypes.end(); } 6389 6390 /// member_pointer_begin - First member pointer type found; 6391 iterator member_pointer_begin() { return MemberPointerTypes.begin(); } 6392 6393 /// member_pointer_end - Past the last member pointer type found; 6394 iterator member_pointer_end() { return MemberPointerTypes.end(); } 6395 6396 /// enumeration_begin - First enumeration type found; 6397 iterator enumeration_begin() { return EnumerationTypes.begin(); } 6398 6399 /// enumeration_end - Past the last enumeration type found; 6400 iterator enumeration_end() { return EnumerationTypes.end(); } 6401 6402 iterator vector_begin() { return VectorTypes.begin(); } 6403 iterator vector_end() { return VectorTypes.end(); } 6404 6405 bool hasNonRecordTypes() { return HasNonRecordTypes; } 6406 bool hasArithmeticOrEnumeralTypes() { return HasArithmeticOrEnumeralTypes; } 6407 bool hasNullPtrType() const { return HasNullPtrType; } 6408}; 6409 6410} // end anonymous namespace 6411 6412/// AddPointerWithMoreQualifiedTypeVariants - Add the pointer type @p Ty to 6413/// the set of pointer types along with any more-qualified variants of 6414/// that type. For example, if @p Ty is "int const *", this routine 6415/// will add "int const *", "int const volatile *", "int const 6416/// restrict *", and "int const volatile restrict *" to the set of 6417/// pointer types. Returns true if the add of @p Ty itself succeeded, 6418/// false otherwise. 6419/// 6420/// FIXME: what to do about extended qualifiers? 6421bool 6422BuiltinCandidateTypeSet::AddPointerWithMoreQualifiedTypeVariants(QualType Ty, 6423 const Qualifiers &VisibleQuals) { 6424 6425 // Insert this type. 6426 if (!PointerTypes.insert(Ty)) 6427 return false; 6428 6429 QualType PointeeTy; 6430 const PointerType *PointerTy = Ty->getAs<PointerType>(); 6431 bool buildObjCPtr = false; 6432 if (!PointerTy) { 6433 const ObjCObjectPointerType *PTy = Ty->castAs<ObjCObjectPointerType>(); 6434 PointeeTy = PTy->getPointeeType(); 6435 buildObjCPtr = true; 6436 } else { 6437 PointeeTy = PointerTy->getPointeeType(); 6438 } 6439 6440 // Don't add qualified variants of arrays. For one, they're not allowed 6441 // (the qualifier would sink to the element type), and for another, the 6442 // only overload situation where it matters is subscript or pointer +- int, 6443 // and those shouldn't have qualifier variants anyway. 6444 if (PointeeTy->isArrayType()) 6445 return true; 6446 6447 unsigned BaseCVR = PointeeTy.getCVRQualifiers(); 6448 bool hasVolatile = VisibleQuals.hasVolatile(); 6449 bool hasRestrict = VisibleQuals.hasRestrict(); 6450 6451 // Iterate through all strict supersets of BaseCVR. 6452 for (unsigned CVR = BaseCVR+1; CVR <= Qualifiers::CVRMask; ++CVR) { 6453 if ((CVR | BaseCVR) != CVR) continue; 6454 // Skip over volatile if no volatile found anywhere in the types. 6455 if ((CVR & Qualifiers::Volatile) && !hasVolatile) continue; 6456 6457 // Skip over restrict if no restrict found anywhere in the types, or if 6458 // the type cannot be restrict-qualified. 6459 if ((CVR & Qualifiers::Restrict) && 6460 (!hasRestrict || 6461 (!(PointeeTy->isAnyPointerType() || PointeeTy->isReferenceType())))) 6462 continue; 6463 6464 // Build qualified pointee type. 6465 QualType QPointeeTy = Context.getCVRQualifiedType(PointeeTy, CVR); 6466 6467 // Build qualified pointer type. 6468 QualType QPointerTy; 6469 if (!buildObjCPtr) 6470 QPointerTy = Context.getPointerType(QPointeeTy); 6471 else 6472 QPointerTy = Context.getObjCObjectPointerType(QPointeeTy); 6473 6474 // Insert qualified pointer type. 6475 PointerTypes.insert(QPointerTy); 6476 } 6477 6478 return true; 6479} 6480 6481/// AddMemberPointerWithMoreQualifiedTypeVariants - Add the pointer type @p Ty 6482/// to the set of pointer types along with any more-qualified variants of 6483/// that type. For example, if @p Ty is "int const *", this routine 6484/// will add "int const *", "int const volatile *", "int const 6485/// restrict *", and "int const volatile restrict *" to the set of 6486/// pointer types. Returns true if the add of @p Ty itself succeeded, 6487/// false otherwise. 6488/// 6489/// FIXME: what to do about extended qualifiers? 6490bool 6491BuiltinCandidateTypeSet::AddMemberPointerWithMoreQualifiedTypeVariants( 6492 QualType Ty) { 6493 // Insert this type. 6494 if (!MemberPointerTypes.insert(Ty)) 6495 return false; 6496 6497 const MemberPointerType *PointerTy = Ty->getAs<MemberPointerType>(); 6498 assert(PointerTy && "type was not a member pointer type!"); 6499 6500 QualType PointeeTy = PointerTy->getPointeeType(); 6501 // Don't add qualified variants of arrays. For one, they're not allowed 6502 // (the qualifier would sink to the element type), and for another, the 6503 // only overload situation where it matters is subscript or pointer +- int, 6504 // and those shouldn't have qualifier variants anyway. 6505 if (PointeeTy->isArrayType()) 6506 return true; 6507 const Type *ClassTy = PointerTy->getClass(); 6508 6509 // Iterate through all strict supersets of the pointee type's CVR 6510 // qualifiers. 6511 unsigned BaseCVR = PointeeTy.getCVRQualifiers(); 6512 for (unsigned CVR = BaseCVR+1; CVR <= Qualifiers::CVRMask; ++CVR) { 6513 if ((CVR | BaseCVR) != CVR) continue; 6514 6515 QualType QPointeeTy = Context.getCVRQualifiedType(PointeeTy, CVR); 6516 MemberPointerTypes.insert( 6517 Context.getMemberPointerType(QPointeeTy, ClassTy)); 6518 } 6519 6520 return true; 6521} 6522 6523/// AddTypesConvertedFrom - Add each of the types to which the type @p 6524/// Ty can be implicit converted to the given set of @p Types. We're 6525/// primarily interested in pointer types and enumeration types. We also 6526/// take member pointer types, for the conditional operator. 6527/// AllowUserConversions is true if we should look at the conversion 6528/// functions of a class type, and AllowExplicitConversions if we 6529/// should also include the explicit conversion functions of a class 6530/// type. 6531void 6532BuiltinCandidateTypeSet::AddTypesConvertedFrom(QualType Ty, 6533 SourceLocation Loc, 6534 bool AllowUserConversions, 6535 bool AllowExplicitConversions, 6536 const Qualifiers &VisibleQuals) { 6537 // Only deal with canonical types. 6538 Ty = Context.getCanonicalType(Ty); 6539 6540 // Look through reference types; they aren't part of the type of an 6541 // expression for the purposes of conversions. 6542 if (const ReferenceType *RefTy = Ty->getAs<ReferenceType>()) 6543 Ty = RefTy->getPointeeType(); 6544 6545 // If we're dealing with an array type, decay to the pointer. 6546 if (Ty->isArrayType()) 6547 Ty = SemaRef.Context.getArrayDecayedType(Ty); 6548 6549 // Otherwise, we don't care about qualifiers on the type. 6550 Ty = Ty.getLocalUnqualifiedType(); 6551 6552 // Flag if we ever add a non-record type. 6553 const RecordType *TyRec = Ty->getAs<RecordType>(); 6554 HasNonRecordTypes = HasNonRecordTypes || !TyRec; 6555 6556 // Flag if we encounter an arithmetic type. 6557 HasArithmeticOrEnumeralTypes = 6558 HasArithmeticOrEnumeralTypes || Ty->isArithmeticType(); 6559 6560 if (Ty->isObjCIdType() || Ty->isObjCClassType()) 6561 PointerTypes.insert(Ty); 6562 else if (Ty->getAs<PointerType>() || Ty->getAs<ObjCObjectPointerType>()) { 6563 // Insert our type, and its more-qualified variants, into the set 6564 // of types. 6565 if (!AddPointerWithMoreQualifiedTypeVariants(Ty, VisibleQuals)) 6566 return; 6567 } else if (Ty->isMemberPointerType()) { 6568 // Member pointers are far easier, since the pointee can't be converted. 6569 if (!AddMemberPointerWithMoreQualifiedTypeVariants(Ty)) 6570 return; 6571 } else if (Ty->isEnumeralType()) { 6572 HasArithmeticOrEnumeralTypes = true; 6573 EnumerationTypes.insert(Ty); 6574 } else if (Ty->isVectorType()) { 6575 // We treat vector types as arithmetic types in many contexts as an 6576 // extension. 6577 HasArithmeticOrEnumeralTypes = true; 6578 VectorTypes.insert(Ty); 6579 } else if (Ty->isNullPtrType()) { 6580 HasNullPtrType = true; 6581 } else if (AllowUserConversions && TyRec) { 6582 // No conversion functions in incomplete types. 6583 if (SemaRef.RequireCompleteType(Loc, Ty, 0)) 6584 return; 6585 6586 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(TyRec->getDecl()); 6587 std::pair<CXXRecordDecl::conversion_iterator, 6588 CXXRecordDecl::conversion_iterator> 6589 Conversions = ClassDecl->getVisibleConversionFunctions(); 6590 for (CXXRecordDecl::conversion_iterator 6591 I = Conversions.first, E = Conversions.second; I != E; ++I) { 6592 NamedDecl *D = I.getDecl(); 6593 if (isa<UsingShadowDecl>(D)) 6594 D = cast<UsingShadowDecl>(D)->getTargetDecl(); 6595 6596 // Skip conversion function templates; they don't tell us anything 6597 // about which builtin types we can convert to. 6598 if (isa<FunctionTemplateDecl>(D)) 6599 continue; 6600 6601 CXXConversionDecl *Conv = cast<CXXConversionDecl>(D); 6602 if (AllowExplicitConversions || !Conv->isExplicit()) { 6603 AddTypesConvertedFrom(Conv->getConversionType(), Loc, false, false, 6604 VisibleQuals); 6605 } 6606 } 6607 } 6608} 6609 6610/// \brief Helper function for AddBuiltinOperatorCandidates() that adds 6611/// the volatile- and non-volatile-qualified assignment operators for the 6612/// given type to the candidate set. 6613static void AddBuiltinAssignmentOperatorCandidates(Sema &S, 6614 QualType T, 6615 ArrayRef<Expr *> Args, 6616 OverloadCandidateSet &CandidateSet) { 6617 QualType ParamTypes[2]; 6618 6619 // T& operator=(T&, T) 6620 ParamTypes[0] = S.Context.getLValueReferenceType(T); 6621 ParamTypes[1] = T; 6622 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet, 6623 /*IsAssignmentOperator=*/true); 6624 6625 if (!S.Context.getCanonicalType(T).isVolatileQualified()) { 6626 // volatile T& operator=(volatile T&, T) 6627 ParamTypes[0] 6628 = S.Context.getLValueReferenceType(S.Context.getVolatileType(T)); 6629 ParamTypes[1] = T; 6630 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet, 6631 /*IsAssignmentOperator=*/true); 6632 } 6633} 6634 6635/// CollectVRQualifiers - This routine returns Volatile/Restrict qualifiers, 6636/// if any, found in visible type conversion functions found in ArgExpr's type. 6637static Qualifiers CollectVRQualifiers(ASTContext &Context, Expr* ArgExpr) { 6638 Qualifiers VRQuals; 6639 const RecordType *TyRec; 6640 if (const MemberPointerType *RHSMPType = 6641 ArgExpr->getType()->getAs<MemberPointerType>()) 6642 TyRec = RHSMPType->getClass()->getAs<RecordType>(); 6643 else 6644 TyRec = ArgExpr->getType()->getAs<RecordType>(); 6645 if (!TyRec) { 6646 // Just to be safe, assume the worst case. 6647 VRQuals.addVolatile(); 6648 VRQuals.addRestrict(); 6649 return VRQuals; 6650 } 6651 6652 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(TyRec->getDecl()); 6653 if (!ClassDecl->hasDefinition()) 6654 return VRQuals; 6655 6656 std::pair<CXXRecordDecl::conversion_iterator, 6657 CXXRecordDecl::conversion_iterator> 6658 Conversions = ClassDecl->getVisibleConversionFunctions(); 6659 6660 for (CXXRecordDecl::conversion_iterator 6661 I = Conversions.first, E = Conversions.second; I != E; ++I) { 6662 NamedDecl *D = I.getDecl(); 6663 if (isa<UsingShadowDecl>(D)) 6664 D = cast<UsingShadowDecl>(D)->getTargetDecl(); 6665 if (CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(D)) { 6666 QualType CanTy = Context.getCanonicalType(Conv->getConversionType()); 6667 if (const ReferenceType *ResTypeRef = CanTy->getAs<ReferenceType>()) 6668 CanTy = ResTypeRef->getPointeeType(); 6669 // Need to go down the pointer/mempointer chain and add qualifiers 6670 // as see them. 6671 bool done = false; 6672 while (!done) { 6673 if (CanTy.isRestrictQualified()) 6674 VRQuals.addRestrict(); 6675 if (const PointerType *ResTypePtr = CanTy->getAs<PointerType>()) 6676 CanTy = ResTypePtr->getPointeeType(); 6677 else if (const MemberPointerType *ResTypeMPtr = 6678 CanTy->getAs<MemberPointerType>()) 6679 CanTy = ResTypeMPtr->getPointeeType(); 6680 else 6681 done = true; 6682 if (CanTy.isVolatileQualified()) 6683 VRQuals.addVolatile(); 6684 if (VRQuals.hasRestrict() && VRQuals.hasVolatile()) 6685 return VRQuals; 6686 } 6687 } 6688 } 6689 return VRQuals; 6690} 6691 6692namespace { 6693 6694/// \brief Helper class to manage the addition of builtin operator overload 6695/// candidates. It provides shared state and utility methods used throughout 6696/// the process, as well as a helper method to add each group of builtin 6697/// operator overloads from the standard to a candidate set. 6698class BuiltinOperatorOverloadBuilder { 6699 // Common instance state available to all overload candidate addition methods. 6700 Sema &S; 6701 ArrayRef<Expr *> Args; 6702 Qualifiers VisibleTypeConversionsQuals; 6703 bool HasArithmeticOrEnumeralCandidateType; 6704 SmallVectorImpl<BuiltinCandidateTypeSet> &CandidateTypes; 6705 OverloadCandidateSet &CandidateSet; 6706 6707 // Define some constants used to index and iterate over the arithemetic types 6708 // provided via the getArithmeticType() method below. 6709 // The "promoted arithmetic types" are the arithmetic 6710 // types are that preserved by promotion (C++ [over.built]p2). 6711 static const unsigned FirstIntegralType = 3; 6712 static const unsigned LastIntegralType = 20; 6713 static const unsigned FirstPromotedIntegralType = 3, 6714 LastPromotedIntegralType = 11; 6715 static const unsigned FirstPromotedArithmeticType = 0, 6716 LastPromotedArithmeticType = 11; 6717 static const unsigned NumArithmeticTypes = 20; 6718 6719 /// \brief Get the canonical type for a given arithmetic type index. 6720 CanQualType getArithmeticType(unsigned index) { 6721 assert(index < NumArithmeticTypes); 6722 static CanQualType ASTContext::* const 6723 ArithmeticTypes[NumArithmeticTypes] = { 6724 // Start of promoted types. 6725 &ASTContext::FloatTy, 6726 &ASTContext::DoubleTy, 6727 &ASTContext::LongDoubleTy, 6728 6729 // Start of integral types. 6730 &ASTContext::IntTy, 6731 &ASTContext::LongTy, 6732 &ASTContext::LongLongTy, 6733 &ASTContext::Int128Ty, 6734 &ASTContext::UnsignedIntTy, 6735 &ASTContext::UnsignedLongTy, 6736 &ASTContext::UnsignedLongLongTy, 6737 &ASTContext::UnsignedInt128Ty, 6738 // End of promoted types. 6739 6740 &ASTContext::BoolTy, 6741 &ASTContext::CharTy, 6742 &ASTContext::WCharTy, 6743 &ASTContext::Char16Ty, 6744 &ASTContext::Char32Ty, 6745 &ASTContext::SignedCharTy, 6746 &ASTContext::ShortTy, 6747 &ASTContext::UnsignedCharTy, 6748 &ASTContext::UnsignedShortTy, 6749 // End of integral types. 6750 // FIXME: What about complex? What about half? 6751 }; 6752 return S.Context.*ArithmeticTypes[index]; 6753 } 6754 6755 /// \brief Gets the canonical type resulting from the usual arithemetic 6756 /// converions for the given arithmetic types. 6757 CanQualType getUsualArithmeticConversions(unsigned L, unsigned R) { 6758 // Accelerator table for performing the usual arithmetic conversions. 6759 // The rules are basically: 6760 // - if either is floating-point, use the wider floating-point 6761 // - if same signedness, use the higher rank 6762 // - if same size, use unsigned of the higher rank 6763 // - use the larger type 6764 // These rules, together with the axiom that higher ranks are 6765 // never smaller, are sufficient to precompute all of these results 6766 // *except* when dealing with signed types of higher rank. 6767 // (we could precompute SLL x UI for all known platforms, but it's 6768 // better not to make any assumptions). 6769 // We assume that int128 has a higher rank than long long on all platforms. 6770 enum PromotedType { 6771 Dep=-1, 6772 Flt, Dbl, LDbl, SI, SL, SLL, S128, UI, UL, ULL, U128 6773 }; 6774 static const PromotedType ConversionsTable[LastPromotedArithmeticType] 6775 [LastPromotedArithmeticType] = { 6776/* Flt*/ { Flt, Dbl, LDbl, Flt, Flt, Flt, Flt, Flt, Flt, Flt, Flt }, 6777/* Dbl*/ { Dbl, Dbl, LDbl, Dbl, Dbl, Dbl, Dbl, Dbl, Dbl, Dbl, Dbl }, 6778/*LDbl*/ { LDbl, LDbl, LDbl, LDbl, LDbl, LDbl, LDbl, LDbl, LDbl, LDbl, LDbl }, 6779/* SI*/ { Flt, Dbl, LDbl, SI, SL, SLL, S128, UI, UL, ULL, U128 }, 6780/* SL*/ { Flt, Dbl, LDbl, SL, SL, SLL, S128, Dep, UL, ULL, U128 }, 6781/* SLL*/ { Flt, Dbl, LDbl, SLL, SLL, SLL, S128, Dep, Dep, ULL, U128 }, 6782/*S128*/ { Flt, Dbl, LDbl, S128, S128, S128, S128, S128, S128, S128, U128 }, 6783/* UI*/ { Flt, Dbl, LDbl, UI, Dep, Dep, S128, UI, UL, ULL, U128 }, 6784/* UL*/ { Flt, Dbl, LDbl, UL, UL, Dep, S128, UL, UL, ULL, U128 }, 6785/* ULL*/ { Flt, Dbl, LDbl, ULL, ULL, ULL, S128, ULL, ULL, ULL, U128 }, 6786/*U128*/ { Flt, Dbl, LDbl, U128, U128, U128, U128, U128, U128, U128, U128 }, 6787 }; 6788 6789 assert(L < LastPromotedArithmeticType); 6790 assert(R < LastPromotedArithmeticType); 6791 int Idx = ConversionsTable[L][R]; 6792 6793 // Fast path: the table gives us a concrete answer. 6794 if (Idx != Dep) return getArithmeticType(Idx); 6795 6796 // Slow path: we need to compare widths. 6797 // An invariant is that the signed type has higher rank. 6798 CanQualType LT = getArithmeticType(L), 6799 RT = getArithmeticType(R); 6800 unsigned LW = S.Context.getIntWidth(LT), 6801 RW = S.Context.getIntWidth(RT); 6802 6803 // If they're different widths, use the signed type. 6804 if (LW > RW) return LT; 6805 else if (LW < RW) return RT; 6806 6807 // Otherwise, use the unsigned type of the signed type's rank. 6808 if (L == SL || R == SL) return S.Context.UnsignedLongTy; 6809 assert(L == SLL || R == SLL); 6810 return S.Context.UnsignedLongLongTy; 6811 } 6812 6813 /// \brief Helper method to factor out the common pattern of adding overloads 6814 /// for '++' and '--' builtin operators. 6815 void addPlusPlusMinusMinusStyleOverloads(QualType CandidateTy, 6816 bool HasVolatile, 6817 bool HasRestrict) { 6818 QualType ParamTypes[2] = { 6819 S.Context.getLValueReferenceType(CandidateTy), 6820 S.Context.IntTy 6821 }; 6822 6823 // Non-volatile version. 6824 if (Args.size() == 1) 6825 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet); 6826 else 6827 S.AddBuiltinCandidate(CandidateTy, ParamTypes, Args, CandidateSet); 6828 6829 // Use a heuristic to reduce number of builtin candidates in the set: 6830 // add volatile version only if there are conversions to a volatile type. 6831 if (HasVolatile) { 6832 ParamTypes[0] = 6833 S.Context.getLValueReferenceType( 6834 S.Context.getVolatileType(CandidateTy)); 6835 if (Args.size() == 1) 6836 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet); 6837 else 6838 S.AddBuiltinCandidate(CandidateTy, ParamTypes, Args, CandidateSet); 6839 } 6840 6841 // Add restrict version only if there are conversions to a restrict type 6842 // and our candidate type is a non-restrict-qualified pointer. 6843 if (HasRestrict && CandidateTy->isAnyPointerType() && 6844 !CandidateTy.isRestrictQualified()) { 6845 ParamTypes[0] 6846 = S.Context.getLValueReferenceType( 6847 S.Context.getCVRQualifiedType(CandidateTy, Qualifiers::Restrict)); 6848 if (Args.size() == 1) 6849 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet); 6850 else 6851 S.AddBuiltinCandidate(CandidateTy, ParamTypes, Args, CandidateSet); 6852 6853 if (HasVolatile) { 6854 ParamTypes[0] 6855 = S.Context.getLValueReferenceType( 6856 S.Context.getCVRQualifiedType(CandidateTy, 6857 (Qualifiers::Volatile | 6858 Qualifiers::Restrict))); 6859 if (Args.size() == 1) 6860 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet); 6861 else 6862 S.AddBuiltinCandidate(CandidateTy, ParamTypes, Args, CandidateSet); 6863 } 6864 } 6865 6866 } 6867 6868public: 6869 BuiltinOperatorOverloadBuilder( 6870 Sema &S, ArrayRef<Expr *> Args, 6871 Qualifiers VisibleTypeConversionsQuals, 6872 bool HasArithmeticOrEnumeralCandidateType, 6873 SmallVectorImpl<BuiltinCandidateTypeSet> &CandidateTypes, 6874 OverloadCandidateSet &CandidateSet) 6875 : S(S), Args(Args), 6876 VisibleTypeConversionsQuals(VisibleTypeConversionsQuals), 6877 HasArithmeticOrEnumeralCandidateType( 6878 HasArithmeticOrEnumeralCandidateType), 6879 CandidateTypes(CandidateTypes), 6880 CandidateSet(CandidateSet) { 6881 // Validate some of our static helper constants in debug builds. 6882 assert(getArithmeticType(FirstPromotedIntegralType) == S.Context.IntTy && 6883 "Invalid first promoted integral type"); 6884 assert(getArithmeticType(LastPromotedIntegralType - 1) 6885 == S.Context.UnsignedInt128Ty && 6886 "Invalid last promoted integral type"); 6887 assert(getArithmeticType(FirstPromotedArithmeticType) 6888 == S.Context.FloatTy && 6889 "Invalid first promoted arithmetic type"); 6890 assert(getArithmeticType(LastPromotedArithmeticType - 1) 6891 == S.Context.UnsignedInt128Ty && 6892 "Invalid last promoted arithmetic type"); 6893 } 6894 6895 // C++ [over.built]p3: 6896 // 6897 // For every pair (T, VQ), where T is an arithmetic type, and VQ 6898 // is either volatile or empty, there exist candidate operator 6899 // functions of the form 6900 // 6901 // VQ T& operator++(VQ T&); 6902 // T operator++(VQ T&, int); 6903 // 6904 // C++ [over.built]p4: 6905 // 6906 // For every pair (T, VQ), where T is an arithmetic type other 6907 // than bool, and VQ is either volatile or empty, there exist 6908 // candidate operator functions of the form 6909 // 6910 // VQ T& operator--(VQ T&); 6911 // T operator--(VQ T&, int); 6912 void addPlusPlusMinusMinusArithmeticOverloads(OverloadedOperatorKind Op) { 6913 if (!HasArithmeticOrEnumeralCandidateType) 6914 return; 6915 6916 for (unsigned Arith = (Op == OO_PlusPlus? 0 : 1); 6917 Arith < NumArithmeticTypes; ++Arith) { 6918 addPlusPlusMinusMinusStyleOverloads( 6919 getArithmeticType(Arith), 6920 VisibleTypeConversionsQuals.hasVolatile(), 6921 VisibleTypeConversionsQuals.hasRestrict()); 6922 } 6923 } 6924 6925 // C++ [over.built]p5: 6926 // 6927 // For every pair (T, VQ), where T is a cv-qualified or 6928 // cv-unqualified object type, and VQ is either volatile or 6929 // empty, there exist candidate operator functions of the form 6930 // 6931 // T*VQ& operator++(T*VQ&); 6932 // T*VQ& operator--(T*VQ&); 6933 // T* operator++(T*VQ&, int); 6934 // T* operator--(T*VQ&, int); 6935 void addPlusPlusMinusMinusPointerOverloads() { 6936 for (BuiltinCandidateTypeSet::iterator 6937 Ptr = CandidateTypes[0].pointer_begin(), 6938 PtrEnd = CandidateTypes[0].pointer_end(); 6939 Ptr != PtrEnd; ++Ptr) { 6940 // Skip pointer types that aren't pointers to object types. 6941 if (!(*Ptr)->getPointeeType()->isObjectType()) 6942 continue; 6943 6944 addPlusPlusMinusMinusStyleOverloads(*Ptr, 6945 (!(*Ptr).isVolatileQualified() && 6946 VisibleTypeConversionsQuals.hasVolatile()), 6947 (!(*Ptr).isRestrictQualified() && 6948 VisibleTypeConversionsQuals.hasRestrict())); 6949 } 6950 } 6951 6952 // C++ [over.built]p6: 6953 // For every cv-qualified or cv-unqualified object type T, there 6954 // exist candidate operator functions of the form 6955 // 6956 // T& operator*(T*); 6957 // 6958 // C++ [over.built]p7: 6959 // For every function type T that does not have cv-qualifiers or a 6960 // ref-qualifier, there exist candidate operator functions of the form 6961 // T& operator*(T*); 6962 void addUnaryStarPointerOverloads() { 6963 for (BuiltinCandidateTypeSet::iterator 6964 Ptr = CandidateTypes[0].pointer_begin(), 6965 PtrEnd = CandidateTypes[0].pointer_end(); 6966 Ptr != PtrEnd; ++Ptr) { 6967 QualType ParamTy = *Ptr; 6968 QualType PointeeTy = ParamTy->getPointeeType(); 6969 if (!PointeeTy->isObjectType() && !PointeeTy->isFunctionType()) 6970 continue; 6971 6972 if (const FunctionProtoType *Proto =PointeeTy->getAs<FunctionProtoType>()) 6973 if (Proto->getTypeQuals() || Proto->getRefQualifier()) 6974 continue; 6975 6976 S.AddBuiltinCandidate(S.Context.getLValueReferenceType(PointeeTy), 6977 &ParamTy, Args, CandidateSet); 6978 } 6979 } 6980 6981 // C++ [over.built]p9: 6982 // For every promoted arithmetic type T, there exist candidate 6983 // operator functions of the form 6984 // 6985 // T operator+(T); 6986 // T operator-(T); 6987 void addUnaryPlusOrMinusArithmeticOverloads() { 6988 if (!HasArithmeticOrEnumeralCandidateType) 6989 return; 6990 6991 for (unsigned Arith = FirstPromotedArithmeticType; 6992 Arith < LastPromotedArithmeticType; ++Arith) { 6993 QualType ArithTy = getArithmeticType(Arith); 6994 S.AddBuiltinCandidate(ArithTy, &ArithTy, Args, CandidateSet); 6995 } 6996 6997 // Extension: We also add these operators for vector types. 6998 for (BuiltinCandidateTypeSet::iterator 6999 Vec = CandidateTypes[0].vector_begin(), 7000 VecEnd = CandidateTypes[0].vector_end(); 7001 Vec != VecEnd; ++Vec) { 7002 QualType VecTy = *Vec; 7003 S.AddBuiltinCandidate(VecTy, &VecTy, Args, CandidateSet); 7004 } 7005 } 7006 7007 // C++ [over.built]p8: 7008 // For every type T, there exist candidate operator functions of 7009 // the form 7010 // 7011 // T* operator+(T*); 7012 void addUnaryPlusPointerOverloads() { 7013 for (BuiltinCandidateTypeSet::iterator 7014 Ptr = CandidateTypes[0].pointer_begin(), 7015 PtrEnd = CandidateTypes[0].pointer_end(); 7016 Ptr != PtrEnd; ++Ptr) { 7017 QualType ParamTy = *Ptr; 7018 S.AddBuiltinCandidate(ParamTy, &ParamTy, Args, CandidateSet); 7019 } 7020 } 7021 7022 // C++ [over.built]p10: 7023 // For every promoted integral type T, there exist candidate 7024 // operator functions of the form 7025 // 7026 // T operator~(T); 7027 void addUnaryTildePromotedIntegralOverloads() { 7028 if (!HasArithmeticOrEnumeralCandidateType) 7029 return; 7030 7031 for (unsigned Int = FirstPromotedIntegralType; 7032 Int < LastPromotedIntegralType; ++Int) { 7033 QualType IntTy = getArithmeticType(Int); 7034 S.AddBuiltinCandidate(IntTy, &IntTy, Args, CandidateSet); 7035 } 7036 7037 // Extension: We also add this operator for vector types. 7038 for (BuiltinCandidateTypeSet::iterator 7039 Vec = CandidateTypes[0].vector_begin(), 7040 VecEnd = CandidateTypes[0].vector_end(); 7041 Vec != VecEnd; ++Vec) { 7042 QualType VecTy = *Vec; 7043 S.AddBuiltinCandidate(VecTy, &VecTy, Args, CandidateSet); 7044 } 7045 } 7046 7047 // C++ [over.match.oper]p16: 7048 // For every pointer to member type T, there exist candidate operator 7049 // functions of the form 7050 // 7051 // bool operator==(T,T); 7052 // bool operator!=(T,T); 7053 void addEqualEqualOrNotEqualMemberPointerOverloads() { 7054 /// Set of (canonical) types that we've already handled. 7055 llvm::SmallPtrSet<QualType, 8> AddedTypes; 7056 7057 for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) { 7058 for (BuiltinCandidateTypeSet::iterator 7059 MemPtr = CandidateTypes[ArgIdx].member_pointer_begin(), 7060 MemPtrEnd = CandidateTypes[ArgIdx].member_pointer_end(); 7061 MemPtr != MemPtrEnd; 7062 ++MemPtr) { 7063 // Don't add the same builtin candidate twice. 7064 if (!AddedTypes.insert(S.Context.getCanonicalType(*MemPtr))) 7065 continue; 7066 7067 QualType ParamTypes[2] = { *MemPtr, *MemPtr }; 7068 S.AddBuiltinCandidate(S.Context.BoolTy, ParamTypes, Args, CandidateSet); 7069 } 7070 } 7071 } 7072 7073 // C++ [over.built]p15: 7074 // 7075 // For every T, where T is an enumeration type, a pointer type, or 7076 // std::nullptr_t, there exist candidate operator functions of the form 7077 // 7078 // bool operator<(T, T); 7079 // bool operator>(T, T); 7080 // bool operator<=(T, T); 7081 // bool operator>=(T, T); 7082 // bool operator==(T, T); 7083 // bool operator!=(T, T); 7084 void addRelationalPointerOrEnumeralOverloads() { 7085 // C++ [over.match.oper]p3: 7086 // [...]the built-in candidates include all of the candidate operator 7087 // functions defined in 13.6 that, compared to the given operator, [...] 7088 // do not have the same parameter-type-list as any non-template non-member 7089 // candidate. 7090 // 7091 // Note that in practice, this only affects enumeration types because there 7092 // aren't any built-in candidates of record type, and a user-defined operator 7093 // must have an operand of record or enumeration type. Also, the only other 7094 // overloaded operator with enumeration arguments, operator=, 7095 // cannot be overloaded for enumeration types, so this is the only place 7096 // where we must suppress candidates like this. 7097 llvm::DenseSet<std::pair<CanQualType, CanQualType> > 7098 UserDefinedBinaryOperators; 7099 7100 for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) { 7101 if (CandidateTypes[ArgIdx].enumeration_begin() != 7102 CandidateTypes[ArgIdx].enumeration_end()) { 7103 for (OverloadCandidateSet::iterator C = CandidateSet.begin(), 7104 CEnd = CandidateSet.end(); 7105 C != CEnd; ++C) { 7106 if (!C->Viable || !C->Function || C->Function->getNumParams() != 2) 7107 continue; 7108 7109 if (C->Function->isFunctionTemplateSpecialization()) 7110 continue; 7111 7112 QualType FirstParamType = 7113 C->Function->getParamDecl(0)->getType().getUnqualifiedType(); 7114 QualType SecondParamType = 7115 C->Function->getParamDecl(1)->getType().getUnqualifiedType(); 7116 7117 // Skip if either parameter isn't of enumeral type. 7118 if (!FirstParamType->isEnumeralType() || 7119 !SecondParamType->isEnumeralType()) 7120 continue; 7121 7122 // Add this operator to the set of known user-defined operators. 7123 UserDefinedBinaryOperators.insert( 7124 std::make_pair(S.Context.getCanonicalType(FirstParamType), 7125 S.Context.getCanonicalType(SecondParamType))); 7126 } 7127 } 7128 } 7129 7130 /// Set of (canonical) types that we've already handled. 7131 llvm::SmallPtrSet<QualType, 8> AddedTypes; 7132 7133 for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) { 7134 for (BuiltinCandidateTypeSet::iterator 7135 Ptr = CandidateTypes[ArgIdx].pointer_begin(), 7136 PtrEnd = CandidateTypes[ArgIdx].pointer_end(); 7137 Ptr != PtrEnd; ++Ptr) { 7138 // Don't add the same builtin candidate twice. 7139 if (!AddedTypes.insert(S.Context.getCanonicalType(*Ptr))) 7140 continue; 7141 7142 QualType ParamTypes[2] = { *Ptr, *Ptr }; 7143 S.AddBuiltinCandidate(S.Context.BoolTy, ParamTypes, Args, CandidateSet); 7144 } 7145 for (BuiltinCandidateTypeSet::iterator 7146 Enum = CandidateTypes[ArgIdx].enumeration_begin(), 7147 EnumEnd = CandidateTypes[ArgIdx].enumeration_end(); 7148 Enum != EnumEnd; ++Enum) { 7149 CanQualType CanonType = S.Context.getCanonicalType(*Enum); 7150 7151 // Don't add the same builtin candidate twice, or if a user defined 7152 // candidate exists. 7153 if (!AddedTypes.insert(CanonType) || 7154 UserDefinedBinaryOperators.count(std::make_pair(CanonType, 7155 CanonType))) 7156 continue; 7157 7158 QualType ParamTypes[2] = { *Enum, *Enum }; 7159 S.AddBuiltinCandidate(S.Context.BoolTy, ParamTypes, Args, CandidateSet); 7160 } 7161 7162 if (CandidateTypes[ArgIdx].hasNullPtrType()) { 7163 CanQualType NullPtrTy = S.Context.getCanonicalType(S.Context.NullPtrTy); 7164 if (AddedTypes.insert(NullPtrTy) && 7165 !UserDefinedBinaryOperators.count(std::make_pair(NullPtrTy, 7166 NullPtrTy))) { 7167 QualType ParamTypes[2] = { NullPtrTy, NullPtrTy }; 7168 S.AddBuiltinCandidate(S.Context.BoolTy, ParamTypes, Args, 7169 CandidateSet); 7170 } 7171 } 7172 } 7173 } 7174 7175 // C++ [over.built]p13: 7176 // 7177 // For every cv-qualified or cv-unqualified object type T 7178 // there exist candidate operator functions of the form 7179 // 7180 // T* operator+(T*, ptrdiff_t); 7181 // T& operator[](T*, ptrdiff_t); [BELOW] 7182 // T* operator-(T*, ptrdiff_t); 7183 // T* operator+(ptrdiff_t, T*); 7184 // T& operator[](ptrdiff_t, T*); [BELOW] 7185 // 7186 // C++ [over.built]p14: 7187 // 7188 // For every T, where T is a pointer to object type, there 7189 // exist candidate operator functions of the form 7190 // 7191 // ptrdiff_t operator-(T, T); 7192 void addBinaryPlusOrMinusPointerOverloads(OverloadedOperatorKind Op) { 7193 /// Set of (canonical) types that we've already handled. 7194 llvm::SmallPtrSet<QualType, 8> AddedTypes; 7195 7196 for (int Arg = 0; Arg < 2; ++Arg) { 7197 QualType AsymetricParamTypes[2] = { 7198 S.Context.getPointerDiffType(), 7199 S.Context.getPointerDiffType(), 7200 }; 7201 for (BuiltinCandidateTypeSet::iterator 7202 Ptr = CandidateTypes[Arg].pointer_begin(), 7203 PtrEnd = CandidateTypes[Arg].pointer_end(); 7204 Ptr != PtrEnd; ++Ptr) { 7205 QualType PointeeTy = (*Ptr)->getPointeeType(); 7206 if (!PointeeTy->isObjectType()) 7207 continue; 7208 7209 AsymetricParamTypes[Arg] = *Ptr; 7210 if (Arg == 0 || Op == OO_Plus) { 7211 // operator+(T*, ptrdiff_t) or operator-(T*, ptrdiff_t) 7212 // T* operator+(ptrdiff_t, T*); 7213 S.AddBuiltinCandidate(*Ptr, AsymetricParamTypes, Args, CandidateSet); 7214 } 7215 if (Op == OO_Minus) { 7216 // ptrdiff_t operator-(T, T); 7217 if (!AddedTypes.insert(S.Context.getCanonicalType(*Ptr))) 7218 continue; 7219 7220 QualType ParamTypes[2] = { *Ptr, *Ptr }; 7221 S.AddBuiltinCandidate(S.Context.getPointerDiffType(), ParamTypes, 7222 Args, CandidateSet); 7223 } 7224 } 7225 } 7226 } 7227 7228 // C++ [over.built]p12: 7229 // 7230 // For every pair of promoted arithmetic types L and R, there 7231 // exist candidate operator functions of the form 7232 // 7233 // LR operator*(L, R); 7234 // LR operator/(L, R); 7235 // LR operator+(L, R); 7236 // LR operator-(L, R); 7237 // bool operator<(L, R); 7238 // bool operator>(L, R); 7239 // bool operator<=(L, R); 7240 // bool operator>=(L, R); 7241 // bool operator==(L, R); 7242 // bool operator!=(L, R); 7243 // 7244 // where LR is the result of the usual arithmetic conversions 7245 // between types L and R. 7246 // 7247 // C++ [over.built]p24: 7248 // 7249 // For every pair of promoted arithmetic types L and R, there exist 7250 // candidate operator functions of the form 7251 // 7252 // LR operator?(bool, L, R); 7253 // 7254 // where LR is the result of the usual arithmetic conversions 7255 // between types L and R. 7256 // Our candidates ignore the first parameter. 7257 void addGenericBinaryArithmeticOverloads(bool isComparison) { 7258 if (!HasArithmeticOrEnumeralCandidateType) 7259 return; 7260 7261 for (unsigned Left = FirstPromotedArithmeticType; 7262 Left < LastPromotedArithmeticType; ++Left) { 7263 for (unsigned Right = FirstPromotedArithmeticType; 7264 Right < LastPromotedArithmeticType; ++Right) { 7265 QualType LandR[2] = { getArithmeticType(Left), 7266 getArithmeticType(Right) }; 7267 QualType Result = 7268 isComparison ? S.Context.BoolTy 7269 : getUsualArithmeticConversions(Left, Right); 7270 S.AddBuiltinCandidate(Result, LandR, Args, CandidateSet); 7271 } 7272 } 7273 7274 // Extension: Add the binary operators ==, !=, <, <=, >=, >, *, /, and the 7275 // conditional operator for vector types. 7276 for (BuiltinCandidateTypeSet::iterator 7277 Vec1 = CandidateTypes[0].vector_begin(), 7278 Vec1End = CandidateTypes[0].vector_end(); 7279 Vec1 != Vec1End; ++Vec1) { 7280 for (BuiltinCandidateTypeSet::iterator 7281 Vec2 = CandidateTypes[1].vector_begin(), 7282 Vec2End = CandidateTypes[1].vector_end(); 7283 Vec2 != Vec2End; ++Vec2) { 7284 QualType LandR[2] = { *Vec1, *Vec2 }; 7285 QualType Result = S.Context.BoolTy; 7286 if (!isComparison) { 7287 if ((*Vec1)->isExtVectorType() || !(*Vec2)->isExtVectorType()) 7288 Result = *Vec1; 7289 else 7290 Result = *Vec2; 7291 } 7292 7293 S.AddBuiltinCandidate(Result, LandR, Args, CandidateSet); 7294 } 7295 } 7296 } 7297 7298 // C++ [over.built]p17: 7299 // 7300 // For every pair of promoted integral types L and R, there 7301 // exist candidate operator functions of the form 7302 // 7303 // LR operator%(L, R); 7304 // LR operator&(L, R); 7305 // LR operator^(L, R); 7306 // LR operator|(L, R); 7307 // L operator<<(L, R); 7308 // L operator>>(L, R); 7309 // 7310 // where LR is the result of the usual arithmetic conversions 7311 // between types L and R. 7312 void addBinaryBitwiseArithmeticOverloads(OverloadedOperatorKind Op) { 7313 if (!HasArithmeticOrEnumeralCandidateType) 7314 return; 7315 7316 for (unsigned Left = FirstPromotedIntegralType; 7317 Left < LastPromotedIntegralType; ++Left) { 7318 for (unsigned Right = FirstPromotedIntegralType; 7319 Right < LastPromotedIntegralType; ++Right) { 7320 QualType LandR[2] = { getArithmeticType(Left), 7321 getArithmeticType(Right) }; 7322 QualType Result = (Op == OO_LessLess || Op == OO_GreaterGreater) 7323 ? LandR[0] 7324 : getUsualArithmeticConversions(Left, Right); 7325 S.AddBuiltinCandidate(Result, LandR, Args, CandidateSet); 7326 } 7327 } 7328 } 7329 7330 // C++ [over.built]p20: 7331 // 7332 // For every pair (T, VQ), where T is an enumeration or 7333 // pointer to member type and VQ is either volatile or 7334 // empty, there exist candidate operator functions of the form 7335 // 7336 // VQ T& operator=(VQ T&, T); 7337 void addAssignmentMemberPointerOrEnumeralOverloads() { 7338 /// Set of (canonical) types that we've already handled. 7339 llvm::SmallPtrSet<QualType, 8> AddedTypes; 7340 7341 for (unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) { 7342 for (BuiltinCandidateTypeSet::iterator 7343 Enum = CandidateTypes[ArgIdx].enumeration_begin(), 7344 EnumEnd = CandidateTypes[ArgIdx].enumeration_end(); 7345 Enum != EnumEnd; ++Enum) { 7346 if (!AddedTypes.insert(S.Context.getCanonicalType(*Enum))) 7347 continue; 7348 7349 AddBuiltinAssignmentOperatorCandidates(S, *Enum, Args, CandidateSet); 7350 } 7351 7352 for (BuiltinCandidateTypeSet::iterator 7353 MemPtr = CandidateTypes[ArgIdx].member_pointer_begin(), 7354 MemPtrEnd = CandidateTypes[ArgIdx].member_pointer_end(); 7355 MemPtr != MemPtrEnd; ++MemPtr) { 7356 if (!AddedTypes.insert(S.Context.getCanonicalType(*MemPtr))) 7357 continue; 7358 7359 AddBuiltinAssignmentOperatorCandidates(S, *MemPtr, Args, CandidateSet); 7360 } 7361 } 7362 } 7363 7364 // C++ [over.built]p19: 7365 // 7366 // For every pair (T, VQ), where T is any type and VQ is either 7367 // volatile or empty, there exist candidate operator functions 7368 // of the form 7369 // 7370 // T*VQ& operator=(T*VQ&, T*); 7371 // 7372 // C++ [over.built]p21: 7373 // 7374 // For every pair (T, VQ), where T is a cv-qualified or 7375 // cv-unqualified object type and VQ is either volatile or 7376 // empty, there exist candidate operator functions of the form 7377 // 7378 // T*VQ& operator+=(T*VQ&, ptrdiff_t); 7379 // T*VQ& operator-=(T*VQ&, ptrdiff_t); 7380 void addAssignmentPointerOverloads(bool isEqualOp) { 7381 /// Set of (canonical) types that we've already handled. 7382 llvm::SmallPtrSet<QualType, 8> AddedTypes; 7383 7384 for (BuiltinCandidateTypeSet::iterator 7385 Ptr = CandidateTypes[0].pointer_begin(), 7386 PtrEnd = CandidateTypes[0].pointer_end(); 7387 Ptr != PtrEnd; ++Ptr) { 7388 // If this is operator=, keep track of the builtin candidates we added. 7389 if (isEqualOp) 7390 AddedTypes.insert(S.Context.getCanonicalType(*Ptr)); 7391 else if (!(*Ptr)->getPointeeType()->isObjectType()) 7392 continue; 7393 7394 // non-volatile version 7395 QualType ParamTypes[2] = { 7396 S.Context.getLValueReferenceType(*Ptr), 7397 isEqualOp ? *Ptr : S.Context.getPointerDiffType(), 7398 }; 7399 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet, 7400 /*IsAssigmentOperator=*/ isEqualOp); 7401 7402 bool NeedVolatile = !(*Ptr).isVolatileQualified() && 7403 VisibleTypeConversionsQuals.hasVolatile(); 7404 if (NeedVolatile) { 7405 // volatile version 7406 ParamTypes[0] = 7407 S.Context.getLValueReferenceType(S.Context.getVolatileType(*Ptr)); 7408 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet, 7409 /*IsAssigmentOperator=*/isEqualOp); 7410 } 7411 7412 if (!(*Ptr).isRestrictQualified() && 7413 VisibleTypeConversionsQuals.hasRestrict()) { 7414 // restrict version 7415 ParamTypes[0] 7416 = S.Context.getLValueReferenceType(S.Context.getRestrictType(*Ptr)); 7417 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet, 7418 /*IsAssigmentOperator=*/isEqualOp); 7419 7420 if (NeedVolatile) { 7421 // volatile restrict version 7422 ParamTypes[0] 7423 = S.Context.getLValueReferenceType( 7424 S.Context.getCVRQualifiedType(*Ptr, 7425 (Qualifiers::Volatile | 7426 Qualifiers::Restrict))); 7427 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet, 7428 /*IsAssigmentOperator=*/isEqualOp); 7429 } 7430 } 7431 } 7432 7433 if (isEqualOp) { 7434 for (BuiltinCandidateTypeSet::iterator 7435 Ptr = CandidateTypes[1].pointer_begin(), 7436 PtrEnd = CandidateTypes[1].pointer_end(); 7437 Ptr != PtrEnd; ++Ptr) { 7438 // Make sure we don't add the same candidate twice. 7439 if (!AddedTypes.insert(S.Context.getCanonicalType(*Ptr))) 7440 continue; 7441 7442 QualType ParamTypes[2] = { 7443 S.Context.getLValueReferenceType(*Ptr), 7444 *Ptr, 7445 }; 7446 7447 // non-volatile version 7448 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet, 7449 /*IsAssigmentOperator=*/true); 7450 7451 bool NeedVolatile = !(*Ptr).isVolatileQualified() && 7452 VisibleTypeConversionsQuals.hasVolatile(); 7453 if (NeedVolatile) { 7454 // volatile version 7455 ParamTypes[0] = 7456 S.Context.getLValueReferenceType(S.Context.getVolatileType(*Ptr)); 7457 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet, 7458 /*IsAssigmentOperator=*/true); 7459 } 7460 7461 if (!(*Ptr).isRestrictQualified() && 7462 VisibleTypeConversionsQuals.hasRestrict()) { 7463 // restrict version 7464 ParamTypes[0] 7465 = S.Context.getLValueReferenceType(S.Context.getRestrictType(*Ptr)); 7466 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet, 7467 /*IsAssigmentOperator=*/true); 7468 7469 if (NeedVolatile) { 7470 // volatile restrict version 7471 ParamTypes[0] 7472 = S.Context.getLValueReferenceType( 7473 S.Context.getCVRQualifiedType(*Ptr, 7474 (Qualifiers::Volatile | 7475 Qualifiers::Restrict))); 7476 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet, 7477 /*IsAssigmentOperator=*/true); 7478 } 7479 } 7480 } 7481 } 7482 } 7483 7484 // C++ [over.built]p18: 7485 // 7486 // For every triple (L, VQ, R), where L is an arithmetic type, 7487 // VQ is either volatile or empty, and R is a promoted 7488 // arithmetic type, there exist candidate operator functions of 7489 // the form 7490 // 7491 // VQ L& operator=(VQ L&, R); 7492 // VQ L& operator*=(VQ L&, R); 7493 // VQ L& operator/=(VQ L&, R); 7494 // VQ L& operator+=(VQ L&, R); 7495 // VQ L& operator-=(VQ L&, R); 7496 void addAssignmentArithmeticOverloads(bool isEqualOp) { 7497 if (!HasArithmeticOrEnumeralCandidateType) 7498 return; 7499 7500 for (unsigned Left = 0; Left < NumArithmeticTypes; ++Left) { 7501 for (unsigned Right = FirstPromotedArithmeticType; 7502 Right < LastPromotedArithmeticType; ++Right) { 7503 QualType ParamTypes[2]; 7504 ParamTypes[1] = getArithmeticType(Right); 7505 7506 // Add this built-in operator as a candidate (VQ is empty). 7507 ParamTypes[0] = 7508 S.Context.getLValueReferenceType(getArithmeticType(Left)); 7509 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet, 7510 /*IsAssigmentOperator=*/isEqualOp); 7511 7512 // Add this built-in operator as a candidate (VQ is 'volatile'). 7513 if (VisibleTypeConversionsQuals.hasVolatile()) { 7514 ParamTypes[0] = 7515 S.Context.getVolatileType(getArithmeticType(Left)); 7516 ParamTypes[0] = S.Context.getLValueReferenceType(ParamTypes[0]); 7517 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet, 7518 /*IsAssigmentOperator=*/isEqualOp); 7519 } 7520 } 7521 } 7522 7523 // Extension: Add the binary operators =, +=, -=, *=, /= for vector types. 7524 for (BuiltinCandidateTypeSet::iterator 7525 Vec1 = CandidateTypes[0].vector_begin(), 7526 Vec1End = CandidateTypes[0].vector_end(); 7527 Vec1 != Vec1End; ++Vec1) { 7528 for (BuiltinCandidateTypeSet::iterator 7529 Vec2 = CandidateTypes[1].vector_begin(), 7530 Vec2End = CandidateTypes[1].vector_end(); 7531 Vec2 != Vec2End; ++Vec2) { 7532 QualType ParamTypes[2]; 7533 ParamTypes[1] = *Vec2; 7534 // Add this built-in operator as a candidate (VQ is empty). 7535 ParamTypes[0] = S.Context.getLValueReferenceType(*Vec1); 7536 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet, 7537 /*IsAssigmentOperator=*/isEqualOp); 7538 7539 // Add this built-in operator as a candidate (VQ is 'volatile'). 7540 if (VisibleTypeConversionsQuals.hasVolatile()) { 7541 ParamTypes[0] = S.Context.getVolatileType(*Vec1); 7542 ParamTypes[0] = S.Context.getLValueReferenceType(ParamTypes[0]); 7543 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet, 7544 /*IsAssigmentOperator=*/isEqualOp); 7545 } 7546 } 7547 } 7548 } 7549 7550 // C++ [over.built]p22: 7551 // 7552 // For every triple (L, VQ, R), where L is an integral type, VQ 7553 // is either volatile or empty, and R is a promoted integral 7554 // type, there exist candidate operator functions of the form 7555 // 7556 // VQ L& operator%=(VQ L&, R); 7557 // VQ L& operator<<=(VQ L&, R); 7558 // VQ L& operator>>=(VQ L&, R); 7559 // VQ L& operator&=(VQ L&, R); 7560 // VQ L& operator^=(VQ L&, R); 7561 // VQ L& operator|=(VQ L&, R); 7562 void addAssignmentIntegralOverloads() { 7563 if (!HasArithmeticOrEnumeralCandidateType) 7564 return; 7565 7566 for (unsigned Left = FirstIntegralType; Left < LastIntegralType; ++Left) { 7567 for (unsigned Right = FirstPromotedIntegralType; 7568 Right < LastPromotedIntegralType; ++Right) { 7569 QualType ParamTypes[2]; 7570 ParamTypes[1] = getArithmeticType(Right); 7571 7572 // Add this built-in operator as a candidate (VQ is empty). 7573 ParamTypes[0] = 7574 S.Context.getLValueReferenceType(getArithmeticType(Left)); 7575 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet); 7576 if (VisibleTypeConversionsQuals.hasVolatile()) { 7577 // Add this built-in operator as a candidate (VQ is 'volatile'). 7578 ParamTypes[0] = getArithmeticType(Left); 7579 ParamTypes[0] = S.Context.getVolatileType(ParamTypes[0]); 7580 ParamTypes[0] = S.Context.getLValueReferenceType(ParamTypes[0]); 7581 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet); 7582 } 7583 } 7584 } 7585 } 7586 7587 // C++ [over.operator]p23: 7588 // 7589 // There also exist candidate operator functions of the form 7590 // 7591 // bool operator!(bool); 7592 // bool operator&&(bool, bool); 7593 // bool operator||(bool, bool); 7594 void addExclaimOverload() { 7595 QualType ParamTy = S.Context.BoolTy; 7596 S.AddBuiltinCandidate(ParamTy, &ParamTy, Args, CandidateSet, 7597 /*IsAssignmentOperator=*/false, 7598 /*NumContextualBoolArguments=*/1); 7599 } 7600 void addAmpAmpOrPipePipeOverload() { 7601 QualType ParamTypes[2] = { S.Context.BoolTy, S.Context.BoolTy }; 7602 S.AddBuiltinCandidate(S.Context.BoolTy, ParamTypes, Args, CandidateSet, 7603 /*IsAssignmentOperator=*/false, 7604 /*NumContextualBoolArguments=*/2); 7605 } 7606 7607 // C++ [over.built]p13: 7608 // 7609 // For every cv-qualified or cv-unqualified object type T there 7610 // exist candidate operator functions of the form 7611 // 7612 // T* operator+(T*, ptrdiff_t); [ABOVE] 7613 // T& operator[](T*, ptrdiff_t); 7614 // T* operator-(T*, ptrdiff_t); [ABOVE] 7615 // T* operator+(ptrdiff_t, T*); [ABOVE] 7616 // T& operator[](ptrdiff_t, T*); 7617 void addSubscriptOverloads() { 7618 for (BuiltinCandidateTypeSet::iterator 7619 Ptr = CandidateTypes[0].pointer_begin(), 7620 PtrEnd = CandidateTypes[0].pointer_end(); 7621 Ptr != PtrEnd; ++Ptr) { 7622 QualType ParamTypes[2] = { *Ptr, S.Context.getPointerDiffType() }; 7623 QualType PointeeType = (*Ptr)->getPointeeType(); 7624 if (!PointeeType->isObjectType()) 7625 continue; 7626 7627 QualType ResultTy = S.Context.getLValueReferenceType(PointeeType); 7628 7629 // T& operator[](T*, ptrdiff_t) 7630 S.AddBuiltinCandidate(ResultTy, ParamTypes, Args, CandidateSet); 7631 } 7632 7633 for (BuiltinCandidateTypeSet::iterator 7634 Ptr = CandidateTypes[1].pointer_begin(), 7635 PtrEnd = CandidateTypes[1].pointer_end(); 7636 Ptr != PtrEnd; ++Ptr) { 7637 QualType ParamTypes[2] = { S.Context.getPointerDiffType(), *Ptr }; 7638 QualType PointeeType = (*Ptr)->getPointeeType(); 7639 if (!PointeeType->isObjectType()) 7640 continue; 7641 7642 QualType ResultTy = S.Context.getLValueReferenceType(PointeeType); 7643 7644 // T& operator[](ptrdiff_t, T*) 7645 S.AddBuiltinCandidate(ResultTy, ParamTypes, Args, CandidateSet); 7646 } 7647 } 7648 7649 // C++ [over.built]p11: 7650 // For every quintuple (C1, C2, T, CV1, CV2), where C2 is a class type, 7651 // C1 is the same type as C2 or is a derived class of C2, T is an object 7652 // type or a function type, and CV1 and CV2 are cv-qualifier-seqs, 7653 // there exist candidate operator functions of the form 7654 // 7655 // CV12 T& operator->*(CV1 C1*, CV2 T C2::*); 7656 // 7657 // where CV12 is the union of CV1 and CV2. 7658 void addArrowStarOverloads() { 7659 for (BuiltinCandidateTypeSet::iterator 7660 Ptr = CandidateTypes[0].pointer_begin(), 7661 PtrEnd = CandidateTypes[0].pointer_end(); 7662 Ptr != PtrEnd; ++Ptr) { 7663 QualType C1Ty = (*Ptr); 7664 QualType C1; 7665 QualifierCollector Q1; 7666 C1 = QualType(Q1.strip(C1Ty->getPointeeType()), 0); 7667 if (!isa<RecordType>(C1)) 7668 continue; 7669 // heuristic to reduce number of builtin candidates in the set. 7670 // Add volatile/restrict version only if there are conversions to a 7671 // volatile/restrict type. 7672 if (!VisibleTypeConversionsQuals.hasVolatile() && Q1.hasVolatile()) 7673 continue; 7674 if (!VisibleTypeConversionsQuals.hasRestrict() && Q1.hasRestrict()) 7675 continue; 7676 for (BuiltinCandidateTypeSet::iterator 7677 MemPtr = CandidateTypes[1].member_pointer_begin(), 7678 MemPtrEnd = CandidateTypes[1].member_pointer_end(); 7679 MemPtr != MemPtrEnd; ++MemPtr) { 7680 const MemberPointerType *mptr = cast<MemberPointerType>(*MemPtr); 7681 QualType C2 = QualType(mptr->getClass(), 0); 7682 C2 = C2.getUnqualifiedType(); 7683 if (C1 != C2 && !S.IsDerivedFrom(C1, C2)) 7684 break; 7685 QualType ParamTypes[2] = { *Ptr, *MemPtr }; 7686 // build CV12 T& 7687 QualType T = mptr->getPointeeType(); 7688 if (!VisibleTypeConversionsQuals.hasVolatile() && 7689 T.isVolatileQualified()) 7690 continue; 7691 if (!VisibleTypeConversionsQuals.hasRestrict() && 7692 T.isRestrictQualified()) 7693 continue; 7694 T = Q1.apply(S.Context, T); 7695 QualType ResultTy = S.Context.getLValueReferenceType(T); 7696 S.AddBuiltinCandidate(ResultTy, ParamTypes, Args, CandidateSet); 7697 } 7698 } 7699 } 7700 7701 // Note that we don't consider the first argument, since it has been 7702 // contextually converted to bool long ago. The candidates below are 7703 // therefore added as binary. 7704 // 7705 // C++ [over.built]p25: 7706 // For every type T, where T is a pointer, pointer-to-member, or scoped 7707 // enumeration type, there exist candidate operator functions of the form 7708 // 7709 // T operator?(bool, T, T); 7710 // 7711 void addConditionalOperatorOverloads() { 7712 /// Set of (canonical) types that we've already handled. 7713 llvm::SmallPtrSet<QualType, 8> AddedTypes; 7714 7715 for (unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) { 7716 for (BuiltinCandidateTypeSet::iterator 7717 Ptr = CandidateTypes[ArgIdx].pointer_begin(), 7718 PtrEnd = CandidateTypes[ArgIdx].pointer_end(); 7719 Ptr != PtrEnd; ++Ptr) { 7720 if (!AddedTypes.insert(S.Context.getCanonicalType(*Ptr))) 7721 continue; 7722 7723 QualType ParamTypes[2] = { *Ptr, *Ptr }; 7724 S.AddBuiltinCandidate(*Ptr, ParamTypes, Args, CandidateSet); 7725 } 7726 7727 for (BuiltinCandidateTypeSet::iterator 7728 MemPtr = CandidateTypes[ArgIdx].member_pointer_begin(), 7729 MemPtrEnd = CandidateTypes[ArgIdx].member_pointer_end(); 7730 MemPtr != MemPtrEnd; ++MemPtr) { 7731 if (!AddedTypes.insert(S.Context.getCanonicalType(*MemPtr))) 7732 continue; 7733 7734 QualType ParamTypes[2] = { *MemPtr, *MemPtr }; 7735 S.AddBuiltinCandidate(*MemPtr, ParamTypes, Args, CandidateSet); 7736 } 7737 7738 if (S.getLangOpts().CPlusPlus11) { 7739 for (BuiltinCandidateTypeSet::iterator 7740 Enum = CandidateTypes[ArgIdx].enumeration_begin(), 7741 EnumEnd = CandidateTypes[ArgIdx].enumeration_end(); 7742 Enum != EnumEnd; ++Enum) { 7743 if (!(*Enum)->getAs<EnumType>()->getDecl()->isScoped()) 7744 continue; 7745 7746 if (!AddedTypes.insert(S.Context.getCanonicalType(*Enum))) 7747 continue; 7748 7749 QualType ParamTypes[2] = { *Enum, *Enum }; 7750 S.AddBuiltinCandidate(*Enum, ParamTypes, Args, CandidateSet); 7751 } 7752 } 7753 } 7754 } 7755}; 7756 7757} // end anonymous namespace 7758 7759/// AddBuiltinOperatorCandidates - Add the appropriate built-in 7760/// operator overloads to the candidate set (C++ [over.built]), based 7761/// on the operator @p Op and the arguments given. For example, if the 7762/// operator is a binary '+', this routine might add "int 7763/// operator+(int, int)" to cover integer addition. 7764void Sema::AddBuiltinOperatorCandidates(OverloadedOperatorKind Op, 7765 SourceLocation OpLoc, 7766 ArrayRef<Expr *> Args, 7767 OverloadCandidateSet &CandidateSet) { 7768 // Find all of the types that the arguments can convert to, but only 7769 // if the operator we're looking at has built-in operator candidates 7770 // that make use of these types. Also record whether we encounter non-record 7771 // candidate types or either arithmetic or enumeral candidate types. 7772 Qualifiers VisibleTypeConversionsQuals; 7773 VisibleTypeConversionsQuals.addConst(); 7774 for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) 7775 VisibleTypeConversionsQuals += CollectVRQualifiers(Context, Args[ArgIdx]); 7776 7777 bool HasNonRecordCandidateType = false; 7778 bool HasArithmeticOrEnumeralCandidateType = false; 7779 SmallVector<BuiltinCandidateTypeSet, 2> CandidateTypes; 7780 for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) { 7781 CandidateTypes.push_back(BuiltinCandidateTypeSet(*this)); 7782 CandidateTypes[ArgIdx].AddTypesConvertedFrom(Args[ArgIdx]->getType(), 7783 OpLoc, 7784 true, 7785 (Op == OO_Exclaim || 7786 Op == OO_AmpAmp || 7787 Op == OO_PipePipe), 7788 VisibleTypeConversionsQuals); 7789 HasNonRecordCandidateType = HasNonRecordCandidateType || 7790 CandidateTypes[ArgIdx].hasNonRecordTypes(); 7791 HasArithmeticOrEnumeralCandidateType = 7792 HasArithmeticOrEnumeralCandidateType || 7793 CandidateTypes[ArgIdx].hasArithmeticOrEnumeralTypes(); 7794 } 7795 7796 // Exit early when no non-record types have been added to the candidate set 7797 // for any of the arguments to the operator. 7798 // 7799 // We can't exit early for !, ||, or &&, since there we have always have 7800 // 'bool' overloads. 7801 if (!HasNonRecordCandidateType && 7802 !(Op == OO_Exclaim || Op == OO_AmpAmp || Op == OO_PipePipe)) 7803 return; 7804 7805 // Setup an object to manage the common state for building overloads. 7806 BuiltinOperatorOverloadBuilder OpBuilder(*this, Args, 7807 VisibleTypeConversionsQuals, 7808 HasArithmeticOrEnumeralCandidateType, 7809 CandidateTypes, CandidateSet); 7810 7811 // Dispatch over the operation to add in only those overloads which apply. 7812 switch (Op) { 7813 case OO_None: 7814 case NUM_OVERLOADED_OPERATORS: 7815 llvm_unreachable("Expected an overloaded operator"); 7816 7817 case OO_New: 7818 case OO_Delete: 7819 case OO_Array_New: 7820 case OO_Array_Delete: 7821 case OO_Call: 7822 llvm_unreachable( 7823 "Special operators don't use AddBuiltinOperatorCandidates"); 7824 7825 case OO_Comma: 7826 case OO_Arrow: 7827 // C++ [over.match.oper]p3: 7828 // -- For the operator ',', the unary operator '&', or the 7829 // operator '->', the built-in candidates set is empty. 7830 break; 7831 7832 case OO_Plus: // '+' is either unary or binary 7833 if (Args.size() == 1) 7834 OpBuilder.addUnaryPlusPointerOverloads(); 7835 // Fall through. 7836 7837 case OO_Minus: // '-' is either unary or binary 7838 if (Args.size() == 1) { 7839 OpBuilder.addUnaryPlusOrMinusArithmeticOverloads(); 7840 } else { 7841 OpBuilder.addBinaryPlusOrMinusPointerOverloads(Op); 7842 OpBuilder.addGenericBinaryArithmeticOverloads(/*isComparison=*/false); 7843 } 7844 break; 7845 7846 case OO_Star: // '*' is either unary or binary 7847 if (Args.size() == 1) 7848 OpBuilder.addUnaryStarPointerOverloads(); 7849 else 7850 OpBuilder.addGenericBinaryArithmeticOverloads(/*isComparison=*/false); 7851 break; 7852 7853 case OO_Slash: 7854 OpBuilder.addGenericBinaryArithmeticOverloads(/*isComparison=*/false); 7855 break; 7856 7857 case OO_PlusPlus: 7858 case OO_MinusMinus: 7859 OpBuilder.addPlusPlusMinusMinusArithmeticOverloads(Op); 7860 OpBuilder.addPlusPlusMinusMinusPointerOverloads(); 7861 break; 7862 7863 case OO_EqualEqual: 7864 case OO_ExclaimEqual: 7865 OpBuilder.addEqualEqualOrNotEqualMemberPointerOverloads(); 7866 // Fall through. 7867 7868 case OO_Less: 7869 case OO_Greater: 7870 case OO_LessEqual: 7871 case OO_GreaterEqual: 7872 OpBuilder.addRelationalPointerOrEnumeralOverloads(); 7873 OpBuilder.addGenericBinaryArithmeticOverloads(/*isComparison=*/true); 7874 break; 7875 7876 case OO_Percent: 7877 case OO_Caret: 7878 case OO_Pipe: 7879 case OO_LessLess: 7880 case OO_GreaterGreater: 7881 OpBuilder.addBinaryBitwiseArithmeticOverloads(Op); 7882 break; 7883 7884 case OO_Amp: // '&' is either unary or binary 7885 if (Args.size() == 1) 7886 // C++ [over.match.oper]p3: 7887 // -- For the operator ',', the unary operator '&', or the 7888 // operator '->', the built-in candidates set is empty. 7889 break; 7890 7891 OpBuilder.addBinaryBitwiseArithmeticOverloads(Op); 7892 break; 7893 7894 case OO_Tilde: 7895 OpBuilder.addUnaryTildePromotedIntegralOverloads(); 7896 break; 7897 7898 case OO_Equal: 7899 OpBuilder.addAssignmentMemberPointerOrEnumeralOverloads(); 7900 // Fall through. 7901 7902 case OO_PlusEqual: 7903 case OO_MinusEqual: 7904 OpBuilder.addAssignmentPointerOverloads(Op == OO_Equal); 7905 // Fall through. 7906 7907 case OO_StarEqual: 7908 case OO_SlashEqual: 7909 OpBuilder.addAssignmentArithmeticOverloads(Op == OO_Equal); 7910 break; 7911 7912 case OO_PercentEqual: 7913 case OO_LessLessEqual: 7914 case OO_GreaterGreaterEqual: 7915 case OO_AmpEqual: 7916 case OO_CaretEqual: 7917 case OO_PipeEqual: 7918 OpBuilder.addAssignmentIntegralOverloads(); 7919 break; 7920 7921 case OO_Exclaim: 7922 OpBuilder.addExclaimOverload(); 7923 break; 7924 7925 case OO_AmpAmp: 7926 case OO_PipePipe: 7927 OpBuilder.addAmpAmpOrPipePipeOverload(); 7928 break; 7929 7930 case OO_Subscript: 7931 OpBuilder.addSubscriptOverloads(); 7932 break; 7933 7934 case OO_ArrowStar: 7935 OpBuilder.addArrowStarOverloads(); 7936 break; 7937 7938 case OO_Conditional: 7939 OpBuilder.addConditionalOperatorOverloads(); 7940 OpBuilder.addGenericBinaryArithmeticOverloads(/*isComparison=*/false); 7941 break; 7942 } 7943} 7944 7945/// \brief Add function candidates found via argument-dependent lookup 7946/// to the set of overloading candidates. 7947/// 7948/// This routine performs argument-dependent name lookup based on the 7949/// given function name (which may also be an operator name) and adds 7950/// all of the overload candidates found by ADL to the overload 7951/// candidate set (C++ [basic.lookup.argdep]). 7952void 7953Sema::AddArgumentDependentLookupCandidates(DeclarationName Name, 7954 bool Operator, SourceLocation Loc, 7955 ArrayRef<Expr *> Args, 7956 TemplateArgumentListInfo *ExplicitTemplateArgs, 7957 OverloadCandidateSet& CandidateSet, 7958 bool PartialOverloading) { 7959 ADLResult Fns; 7960 7961 // FIXME: This approach for uniquing ADL results (and removing 7962 // redundant candidates from the set) relies on pointer-equality, 7963 // which means we need to key off the canonical decl. However, 7964 // always going back to the canonical decl might not get us the 7965 // right set of default arguments. What default arguments are 7966 // we supposed to consider on ADL candidates, anyway? 7967 7968 // FIXME: Pass in the explicit template arguments? 7969 ArgumentDependentLookup(Name, Operator, Loc, Args, Fns); 7970 7971 // Erase all of the candidates we already knew about. 7972 for (OverloadCandidateSet::iterator Cand = CandidateSet.begin(), 7973 CandEnd = CandidateSet.end(); 7974 Cand != CandEnd; ++Cand) 7975 if (Cand->Function) { 7976 Fns.erase(Cand->Function); 7977 if (FunctionTemplateDecl *FunTmpl = Cand->Function->getPrimaryTemplate()) 7978 Fns.erase(FunTmpl); 7979 } 7980 7981 // For each of the ADL candidates we found, add it to the overload 7982 // set. 7983 for (ADLResult::iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) { 7984 DeclAccessPair FoundDecl = DeclAccessPair::make(*I, AS_none); 7985 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) { 7986 if (ExplicitTemplateArgs) 7987 continue; 7988 7989 AddOverloadCandidate(FD, FoundDecl, Args, CandidateSet, false, 7990 PartialOverloading); 7991 } else 7992 AddTemplateOverloadCandidate(cast<FunctionTemplateDecl>(*I), 7993 FoundDecl, ExplicitTemplateArgs, 7994 Args, CandidateSet); 7995 } 7996} 7997 7998/// isBetterOverloadCandidate - Determines whether the first overload 7999/// candidate is a better candidate than the second (C++ 13.3.3p1). 8000bool 8001isBetterOverloadCandidate(Sema &S, 8002 const OverloadCandidate &Cand1, 8003 const OverloadCandidate &Cand2, 8004 SourceLocation Loc, 8005 bool UserDefinedConversion) { 8006 // Define viable functions to be better candidates than non-viable 8007 // functions. 8008 if (!Cand2.Viable) 8009 return Cand1.Viable; 8010 else if (!Cand1.Viable) 8011 return false; 8012 8013 // C++ [over.match.best]p1: 8014 // 8015 // -- if F is a static member function, ICS1(F) is defined such 8016 // that ICS1(F) is neither better nor worse than ICS1(G) for 8017 // any function G, and, symmetrically, ICS1(G) is neither 8018 // better nor worse than ICS1(F). 8019 unsigned StartArg = 0; 8020 if (Cand1.IgnoreObjectArgument || Cand2.IgnoreObjectArgument) 8021 StartArg = 1; 8022 8023 // C++ [over.match.best]p1: 8024 // A viable function F1 is defined to be a better function than another 8025 // viable function F2 if for all arguments i, ICSi(F1) is not a worse 8026 // conversion sequence than ICSi(F2), and then... 8027 unsigned NumArgs = Cand1.NumConversions; 8028 assert(Cand2.NumConversions == NumArgs && "Overload candidate mismatch"); 8029 bool HasBetterConversion = false; 8030 for (unsigned ArgIdx = StartArg; ArgIdx < NumArgs; ++ArgIdx) { 8031 switch (CompareImplicitConversionSequences(S, 8032 Cand1.Conversions[ArgIdx], 8033 Cand2.Conversions[ArgIdx])) { 8034 case ImplicitConversionSequence::Better: 8035 // Cand1 has a better conversion sequence. 8036 HasBetterConversion = true; 8037 break; 8038 8039 case ImplicitConversionSequence::Worse: 8040 // Cand1 can't be better than Cand2. 8041 return false; 8042 8043 case ImplicitConversionSequence::Indistinguishable: 8044 // Do nothing. 8045 break; 8046 } 8047 } 8048 8049 // -- for some argument j, ICSj(F1) is a better conversion sequence than 8050 // ICSj(F2), or, if not that, 8051 if (HasBetterConversion) 8052 return true; 8053 8054 // - F1 is a non-template function and F2 is a function template 8055 // specialization, or, if not that, 8056 if ((!Cand1.Function || !Cand1.Function->getPrimaryTemplate()) && 8057 Cand2.Function && Cand2.Function->getPrimaryTemplate()) 8058 return true; 8059 8060 // -- F1 and F2 are function template specializations, and the function 8061 // template for F1 is more specialized than the template for F2 8062 // according to the partial ordering rules described in 14.5.5.2, or, 8063 // if not that, 8064 if (Cand1.Function && Cand1.Function->getPrimaryTemplate() && 8065 Cand2.Function && Cand2.Function->getPrimaryTemplate()) { 8066 if (FunctionTemplateDecl *BetterTemplate 8067 = S.getMoreSpecializedTemplate(Cand1.Function->getPrimaryTemplate(), 8068 Cand2.Function->getPrimaryTemplate(), 8069 Loc, 8070 isa<CXXConversionDecl>(Cand1.Function)? TPOC_Conversion 8071 : TPOC_Call, 8072 Cand1.ExplicitCallArguments, 8073 Cand2.ExplicitCallArguments)) 8074 return BetterTemplate == Cand1.Function->getPrimaryTemplate(); 8075 } 8076 8077 // -- the context is an initialization by user-defined conversion 8078 // (see 8.5, 13.3.1.5) and the standard conversion sequence 8079 // from the return type of F1 to the destination type (i.e., 8080 // the type of the entity being initialized) is a better 8081 // conversion sequence than the standard conversion sequence 8082 // from the return type of F2 to the destination type. 8083 if (UserDefinedConversion && Cand1.Function && Cand2.Function && 8084 isa<CXXConversionDecl>(Cand1.Function) && 8085 isa<CXXConversionDecl>(Cand2.Function)) { 8086 // First check whether we prefer one of the conversion functions over the 8087 // other. This only distinguishes the results in non-standard, extension 8088 // cases such as the conversion from a lambda closure type to a function 8089 // pointer or block. 8090 ImplicitConversionSequence::CompareKind FuncResult 8091 = compareConversionFunctions(S, Cand1.Function, Cand2.Function); 8092 if (FuncResult != ImplicitConversionSequence::Indistinguishable) 8093 return FuncResult; 8094 8095 switch (CompareStandardConversionSequences(S, 8096 Cand1.FinalConversion, 8097 Cand2.FinalConversion)) { 8098 case ImplicitConversionSequence::Better: 8099 // Cand1 has a better conversion sequence. 8100 return true; 8101 8102 case ImplicitConversionSequence::Worse: 8103 // Cand1 can't be better than Cand2. 8104 return false; 8105 8106 case ImplicitConversionSequence::Indistinguishable: 8107 // Do nothing 8108 break; 8109 } 8110 } 8111 8112 return false; 8113} 8114 8115/// \brief Computes the best viable function (C++ 13.3.3) 8116/// within an overload candidate set. 8117/// 8118/// \param Loc The location of the function name (or operator symbol) for 8119/// which overload resolution occurs. 8120/// 8121/// \param Best If overload resolution was successful or found a deleted 8122/// function, \p Best points to the candidate function found. 8123/// 8124/// \returns The result of overload resolution. 8125OverloadingResult 8126OverloadCandidateSet::BestViableFunction(Sema &S, SourceLocation Loc, 8127 iterator &Best, 8128 bool UserDefinedConversion) { 8129 // Find the best viable function. 8130 Best = end(); 8131 for (iterator Cand = begin(); Cand != end(); ++Cand) { 8132 if (Cand->Viable) 8133 if (Best == end() || isBetterOverloadCandidate(S, *Cand, *Best, Loc, 8134 UserDefinedConversion)) 8135 Best = Cand; 8136 } 8137 8138 // If we didn't find any viable functions, abort. 8139 if (Best == end()) 8140 return OR_No_Viable_Function; 8141 8142 // Make sure that this function is better than every other viable 8143 // function. If not, we have an ambiguity. 8144 for (iterator Cand = begin(); Cand != end(); ++Cand) { 8145 if (Cand->Viable && 8146 Cand != Best && 8147 !isBetterOverloadCandidate(S, *Best, *Cand, Loc, 8148 UserDefinedConversion)) { 8149 Best = end(); 8150 return OR_Ambiguous; 8151 } 8152 } 8153 8154 // Best is the best viable function. 8155 if (Best->Function && 8156 (Best->Function->isDeleted() || 8157 S.isFunctionConsideredUnavailable(Best->Function))) 8158 return OR_Deleted; 8159 8160 return OR_Success; 8161} 8162 8163namespace { 8164 8165enum OverloadCandidateKind { 8166 oc_function, 8167 oc_method, 8168 oc_constructor, 8169 oc_function_template, 8170 oc_method_template, 8171 oc_constructor_template, 8172 oc_implicit_default_constructor, 8173 oc_implicit_copy_constructor, 8174 oc_implicit_move_constructor, 8175 oc_implicit_copy_assignment, 8176 oc_implicit_move_assignment, 8177 oc_implicit_inherited_constructor 8178}; 8179 8180OverloadCandidateKind ClassifyOverloadCandidate(Sema &S, 8181 FunctionDecl *Fn, 8182 std::string &Description) { 8183 bool isTemplate = false; 8184 8185 if (FunctionTemplateDecl *FunTmpl = Fn->getPrimaryTemplate()) { 8186 isTemplate = true; 8187 Description = S.getTemplateArgumentBindingsText( 8188 FunTmpl->getTemplateParameters(), *Fn->getTemplateSpecializationArgs()); 8189 } 8190 8191 if (CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(Fn)) { 8192 if (!Ctor->isImplicit()) 8193 return isTemplate ? oc_constructor_template : oc_constructor; 8194 8195 if (Ctor->getInheritedConstructor()) 8196 return oc_implicit_inherited_constructor; 8197 8198 if (Ctor->isDefaultConstructor()) 8199 return oc_implicit_default_constructor; 8200 8201 if (Ctor->isMoveConstructor()) 8202 return oc_implicit_move_constructor; 8203 8204 assert(Ctor->isCopyConstructor() && 8205 "unexpected sort of implicit constructor"); 8206 return oc_implicit_copy_constructor; 8207 } 8208 8209 if (CXXMethodDecl *Meth = dyn_cast<CXXMethodDecl>(Fn)) { 8210 // This actually gets spelled 'candidate function' for now, but 8211 // it doesn't hurt to split it out. 8212 if (!Meth->isImplicit()) 8213 return isTemplate ? oc_method_template : oc_method; 8214 8215 if (Meth->isMoveAssignmentOperator()) 8216 return oc_implicit_move_assignment; 8217 8218 if (Meth->isCopyAssignmentOperator()) 8219 return oc_implicit_copy_assignment; 8220 8221 assert(isa<CXXConversionDecl>(Meth) && "expected conversion"); 8222 return oc_method; 8223 } 8224 8225 return isTemplate ? oc_function_template : oc_function; 8226} 8227 8228void MaybeEmitInheritedConstructorNote(Sema &S, Decl *Fn) { 8229 const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(Fn); 8230 if (!Ctor) return; 8231 8232 Ctor = Ctor->getInheritedConstructor(); 8233 if (!Ctor) return; 8234 8235 S.Diag(Ctor->getLocation(), diag::note_ovl_candidate_inherited_constructor); 8236} 8237 8238} // end anonymous namespace 8239 8240// Notes the location of an overload candidate. 8241void Sema::NoteOverloadCandidate(FunctionDecl *Fn, QualType DestType) { 8242 std::string FnDesc; 8243 OverloadCandidateKind K = ClassifyOverloadCandidate(*this, Fn, FnDesc); 8244 PartialDiagnostic PD = PDiag(diag::note_ovl_candidate) 8245 << (unsigned) K << FnDesc; 8246 HandleFunctionTypeMismatch(PD, Fn->getType(), DestType); 8247 Diag(Fn->getLocation(), PD); 8248 MaybeEmitInheritedConstructorNote(*this, Fn); 8249} 8250 8251// Notes the location of all overload candidates designated through 8252// OverloadedExpr 8253void Sema::NoteAllOverloadCandidates(Expr* OverloadedExpr, QualType DestType) { 8254 assert(OverloadedExpr->getType() == Context.OverloadTy); 8255 8256 OverloadExpr::FindResult Ovl = OverloadExpr::find(OverloadedExpr); 8257 OverloadExpr *OvlExpr = Ovl.Expression; 8258 8259 for (UnresolvedSetIterator I = OvlExpr->decls_begin(), 8260 IEnd = OvlExpr->decls_end(); 8261 I != IEnd; ++I) { 8262 if (FunctionTemplateDecl *FunTmpl = 8263 dyn_cast<FunctionTemplateDecl>((*I)->getUnderlyingDecl()) ) { 8264 NoteOverloadCandidate(FunTmpl->getTemplatedDecl(), DestType); 8265 } else if (FunctionDecl *Fun 8266 = dyn_cast<FunctionDecl>((*I)->getUnderlyingDecl()) ) { 8267 NoteOverloadCandidate(Fun, DestType); 8268 } 8269 } 8270} 8271 8272/// Diagnoses an ambiguous conversion. The partial diagnostic is the 8273/// "lead" diagnostic; it will be given two arguments, the source and 8274/// target types of the conversion. 8275void ImplicitConversionSequence::DiagnoseAmbiguousConversion( 8276 Sema &S, 8277 SourceLocation CaretLoc, 8278 const PartialDiagnostic &PDiag) const { 8279 S.Diag(CaretLoc, PDiag) 8280 << Ambiguous.getFromType() << Ambiguous.getToType(); 8281 // FIXME: The note limiting machinery is borrowed from 8282 // OverloadCandidateSet::NoteCandidates; there's an opportunity for 8283 // refactoring here. 8284 const OverloadsShown ShowOverloads = S.Diags.getShowOverloads(); 8285 unsigned CandsShown = 0; 8286 AmbiguousConversionSequence::const_iterator I, E; 8287 for (I = Ambiguous.begin(), E = Ambiguous.end(); I != E; ++I) { 8288 if (CandsShown >= 4 && ShowOverloads == Ovl_Best) 8289 break; 8290 ++CandsShown; 8291 S.NoteOverloadCandidate(*I); 8292 } 8293 if (I != E) 8294 S.Diag(SourceLocation(), diag::note_ovl_too_many_candidates) << int(E - I); 8295} 8296 8297namespace { 8298 8299void DiagnoseBadConversion(Sema &S, OverloadCandidate *Cand, unsigned I) { 8300 const ImplicitConversionSequence &Conv = Cand->Conversions[I]; 8301 assert(Conv.isBad()); 8302 assert(Cand->Function && "for now, candidate must be a function"); 8303 FunctionDecl *Fn = Cand->Function; 8304 8305 // There's a conversion slot for the object argument if this is a 8306 // non-constructor method. Note that 'I' corresponds the 8307 // conversion-slot index. 8308 bool isObjectArgument = false; 8309 if (isa<CXXMethodDecl>(Fn) && !isa<CXXConstructorDecl>(Fn)) { 8310 if (I == 0) 8311 isObjectArgument = true; 8312 else 8313 I--; 8314 } 8315 8316 std::string FnDesc; 8317 OverloadCandidateKind FnKind = ClassifyOverloadCandidate(S, Fn, FnDesc); 8318 8319 Expr *FromExpr = Conv.Bad.FromExpr; 8320 QualType FromTy = Conv.Bad.getFromType(); 8321 QualType ToTy = Conv.Bad.getToType(); 8322 8323 if (FromTy == S.Context.OverloadTy) { 8324 assert(FromExpr && "overload set argument came from implicit argument?"); 8325 Expr *E = FromExpr->IgnoreParens(); 8326 if (isa<UnaryOperator>(E)) 8327 E = cast<UnaryOperator>(E)->getSubExpr()->IgnoreParens(); 8328 DeclarationName Name = cast<OverloadExpr>(E)->getName(); 8329 8330 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_overload) 8331 << (unsigned) FnKind << FnDesc 8332 << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) 8333 << ToTy << Name << I+1; 8334 MaybeEmitInheritedConstructorNote(S, Fn); 8335 return; 8336 } 8337 8338 // Do some hand-waving analysis to see if the non-viability is due 8339 // to a qualifier mismatch. 8340 CanQualType CFromTy = S.Context.getCanonicalType(FromTy); 8341 CanQualType CToTy = S.Context.getCanonicalType(ToTy); 8342 if (CanQual<ReferenceType> RT = CToTy->getAs<ReferenceType>()) 8343 CToTy = RT->getPointeeType(); 8344 else { 8345 // TODO: detect and diagnose the full richness of const mismatches. 8346 if (CanQual<PointerType> FromPT = CFromTy->getAs<PointerType>()) 8347 if (CanQual<PointerType> ToPT = CToTy->getAs<PointerType>()) 8348 CFromTy = FromPT->getPointeeType(), CToTy = ToPT->getPointeeType(); 8349 } 8350 8351 if (CToTy.getUnqualifiedType() == CFromTy.getUnqualifiedType() && 8352 !CToTy.isAtLeastAsQualifiedAs(CFromTy)) { 8353 Qualifiers FromQs = CFromTy.getQualifiers(); 8354 Qualifiers ToQs = CToTy.getQualifiers(); 8355 8356 if (FromQs.getAddressSpace() != ToQs.getAddressSpace()) { 8357 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_addrspace) 8358 << (unsigned) FnKind << FnDesc 8359 << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) 8360 << FromTy 8361 << FromQs.getAddressSpace() << ToQs.getAddressSpace() 8362 << (unsigned) isObjectArgument << I+1; 8363 MaybeEmitInheritedConstructorNote(S, Fn); 8364 return; 8365 } 8366 8367 if (FromQs.getObjCLifetime() != ToQs.getObjCLifetime()) { 8368 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_ownership) 8369 << (unsigned) FnKind << FnDesc 8370 << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) 8371 << FromTy 8372 << FromQs.getObjCLifetime() << ToQs.getObjCLifetime() 8373 << (unsigned) isObjectArgument << I+1; 8374 MaybeEmitInheritedConstructorNote(S, Fn); 8375 return; 8376 } 8377 8378 if (FromQs.getObjCGCAttr() != ToQs.getObjCGCAttr()) { 8379 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_gc) 8380 << (unsigned) FnKind << FnDesc 8381 << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) 8382 << FromTy 8383 << FromQs.getObjCGCAttr() << ToQs.getObjCGCAttr() 8384 << (unsigned) isObjectArgument << I+1; 8385 MaybeEmitInheritedConstructorNote(S, Fn); 8386 return; 8387 } 8388 8389 unsigned CVR = FromQs.getCVRQualifiers() & ~ToQs.getCVRQualifiers(); 8390 assert(CVR && "unexpected qualifiers mismatch"); 8391 8392 if (isObjectArgument) { 8393 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_cvr_this) 8394 << (unsigned) FnKind << FnDesc 8395 << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) 8396 << FromTy << (CVR - 1); 8397 } else { 8398 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_cvr) 8399 << (unsigned) FnKind << FnDesc 8400 << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) 8401 << FromTy << (CVR - 1) << I+1; 8402 } 8403 MaybeEmitInheritedConstructorNote(S, Fn); 8404 return; 8405 } 8406 8407 // Special diagnostic for failure to convert an initializer list, since 8408 // telling the user that it has type void is not useful. 8409 if (FromExpr && isa<InitListExpr>(FromExpr)) { 8410 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_list_argument) 8411 << (unsigned) FnKind << FnDesc 8412 << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) 8413 << FromTy << ToTy << (unsigned) isObjectArgument << I+1; 8414 MaybeEmitInheritedConstructorNote(S, Fn); 8415 return; 8416 } 8417 8418 // Diagnose references or pointers to incomplete types differently, 8419 // since it's far from impossible that the incompleteness triggered 8420 // the failure. 8421 QualType TempFromTy = FromTy.getNonReferenceType(); 8422 if (const PointerType *PTy = TempFromTy->getAs<PointerType>()) 8423 TempFromTy = PTy->getPointeeType(); 8424 if (TempFromTy->isIncompleteType()) { 8425 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_conv_incomplete) 8426 << (unsigned) FnKind << FnDesc 8427 << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) 8428 << FromTy << ToTy << (unsigned) isObjectArgument << I+1; 8429 MaybeEmitInheritedConstructorNote(S, Fn); 8430 return; 8431 } 8432 8433 // Diagnose base -> derived pointer conversions. 8434 unsigned BaseToDerivedConversion = 0; 8435 if (const PointerType *FromPtrTy = FromTy->getAs<PointerType>()) { 8436 if (const PointerType *ToPtrTy = ToTy->getAs<PointerType>()) { 8437 if (ToPtrTy->getPointeeType().isAtLeastAsQualifiedAs( 8438 FromPtrTy->getPointeeType()) && 8439 !FromPtrTy->getPointeeType()->isIncompleteType() && 8440 !ToPtrTy->getPointeeType()->isIncompleteType() && 8441 S.IsDerivedFrom(ToPtrTy->getPointeeType(), 8442 FromPtrTy->getPointeeType())) 8443 BaseToDerivedConversion = 1; 8444 } 8445 } else if (const ObjCObjectPointerType *FromPtrTy 8446 = FromTy->getAs<ObjCObjectPointerType>()) { 8447 if (const ObjCObjectPointerType *ToPtrTy 8448 = ToTy->getAs<ObjCObjectPointerType>()) 8449 if (const ObjCInterfaceDecl *FromIface = FromPtrTy->getInterfaceDecl()) 8450 if (const ObjCInterfaceDecl *ToIface = ToPtrTy->getInterfaceDecl()) 8451 if (ToPtrTy->getPointeeType().isAtLeastAsQualifiedAs( 8452 FromPtrTy->getPointeeType()) && 8453 FromIface->isSuperClassOf(ToIface)) 8454 BaseToDerivedConversion = 2; 8455 } else if (const ReferenceType *ToRefTy = ToTy->getAs<ReferenceType>()) { 8456 if (ToRefTy->getPointeeType().isAtLeastAsQualifiedAs(FromTy) && 8457 !FromTy->isIncompleteType() && 8458 !ToRefTy->getPointeeType()->isIncompleteType() && 8459 S.IsDerivedFrom(ToRefTy->getPointeeType(), FromTy)) { 8460 BaseToDerivedConversion = 3; 8461 } else if (ToTy->isLValueReferenceType() && !FromExpr->isLValue() && 8462 ToTy.getNonReferenceType().getCanonicalType() == 8463 FromTy.getNonReferenceType().getCanonicalType()) { 8464 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_lvalue) 8465 << (unsigned) FnKind << FnDesc 8466 << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) 8467 << (unsigned) isObjectArgument << I + 1; 8468 MaybeEmitInheritedConstructorNote(S, Fn); 8469 return; 8470 } 8471 } 8472 8473 if (BaseToDerivedConversion) { 8474 S.Diag(Fn->getLocation(), 8475 diag::note_ovl_candidate_bad_base_to_derived_conv) 8476 << (unsigned) FnKind << FnDesc 8477 << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) 8478 << (BaseToDerivedConversion - 1) 8479 << FromTy << ToTy << I+1; 8480 MaybeEmitInheritedConstructorNote(S, Fn); 8481 return; 8482 } 8483 8484 if (isa<ObjCObjectPointerType>(CFromTy) && 8485 isa<PointerType>(CToTy)) { 8486 Qualifiers FromQs = CFromTy.getQualifiers(); 8487 Qualifiers ToQs = CToTy.getQualifiers(); 8488 if (FromQs.getObjCLifetime() != ToQs.getObjCLifetime()) { 8489 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_arc_conv) 8490 << (unsigned) FnKind << FnDesc 8491 << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) 8492 << FromTy << ToTy << (unsigned) isObjectArgument << I+1; 8493 MaybeEmitInheritedConstructorNote(S, Fn); 8494 return; 8495 } 8496 } 8497 8498 // Emit the generic diagnostic and, optionally, add the hints to it. 8499 PartialDiagnostic FDiag = S.PDiag(diag::note_ovl_candidate_bad_conv); 8500 FDiag << (unsigned) FnKind << FnDesc 8501 << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) 8502 << FromTy << ToTy << (unsigned) isObjectArgument << I + 1 8503 << (unsigned) (Cand->Fix.Kind); 8504 8505 // If we can fix the conversion, suggest the FixIts. 8506 for (std::vector<FixItHint>::iterator HI = Cand->Fix.Hints.begin(), 8507 HE = Cand->Fix.Hints.end(); HI != HE; ++HI) 8508 FDiag << *HI; 8509 S.Diag(Fn->getLocation(), FDiag); 8510 8511 MaybeEmitInheritedConstructorNote(S, Fn); 8512} 8513 8514/// Additional arity mismatch diagnosis specific to a function overload 8515/// candidates. This is not covered by the more general DiagnoseArityMismatch() 8516/// over a candidate in any candidate set. 8517bool CheckArityMismatch(Sema &S, OverloadCandidate *Cand, 8518 unsigned NumArgs) { 8519 FunctionDecl *Fn = Cand->Function; 8520 unsigned MinParams = Fn->getMinRequiredArguments(); 8521 8522 // With invalid overloaded operators, it's possible that we think we 8523 // have an arity mismatch when in fact it looks like we have the 8524 // right number of arguments, because only overloaded operators have 8525 // the weird behavior of overloading member and non-member functions. 8526 // Just don't report anything. 8527 if (Fn->isInvalidDecl() && 8528 Fn->getDeclName().getNameKind() == DeclarationName::CXXOperatorName) 8529 return true; 8530 8531 if (NumArgs < MinParams) { 8532 assert((Cand->FailureKind == ovl_fail_too_few_arguments) || 8533 (Cand->FailureKind == ovl_fail_bad_deduction && 8534 Cand->DeductionFailure.Result == Sema::TDK_TooFewArguments)); 8535 } else { 8536 assert((Cand->FailureKind == ovl_fail_too_many_arguments) || 8537 (Cand->FailureKind == ovl_fail_bad_deduction && 8538 Cand->DeductionFailure.Result == Sema::TDK_TooManyArguments)); 8539 } 8540 8541 return false; 8542} 8543 8544/// General arity mismatch diagnosis over a candidate in a candidate set. 8545void DiagnoseArityMismatch(Sema &S, Decl *D, unsigned NumFormalArgs) { 8546 assert(isa<FunctionDecl>(D) && 8547 "The templated declaration should at least be a function" 8548 " when diagnosing bad template argument deduction due to too many" 8549 " or too few arguments"); 8550 8551 FunctionDecl *Fn = cast<FunctionDecl>(D); 8552 8553 // TODO: treat calls to a missing default constructor as a special case 8554 const FunctionProtoType *FnTy = Fn->getType()->getAs<FunctionProtoType>(); 8555 unsigned MinParams = Fn->getMinRequiredArguments(); 8556 8557 // at least / at most / exactly 8558 unsigned mode, modeCount; 8559 if (NumFormalArgs < MinParams) { 8560 if (MinParams != FnTy->getNumArgs() || 8561 FnTy->isVariadic() || FnTy->isTemplateVariadic()) 8562 mode = 0; // "at least" 8563 else 8564 mode = 2; // "exactly" 8565 modeCount = MinParams; 8566 } else { 8567 if (MinParams != FnTy->getNumArgs()) 8568 mode = 1; // "at most" 8569 else 8570 mode = 2; // "exactly" 8571 modeCount = FnTy->getNumArgs(); 8572 } 8573 8574 std::string Description; 8575 OverloadCandidateKind FnKind = ClassifyOverloadCandidate(S, Fn, Description); 8576 8577 if (modeCount == 1 && Fn->getParamDecl(0)->getDeclName()) 8578 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_arity_one) 8579 << (unsigned) FnKind << (Fn->getDescribedFunctionTemplate() != 0) << mode 8580 << Fn->getParamDecl(0) << NumFormalArgs; 8581 else 8582 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_arity) 8583 << (unsigned) FnKind << (Fn->getDescribedFunctionTemplate() != 0) << mode 8584 << modeCount << NumFormalArgs; 8585 MaybeEmitInheritedConstructorNote(S, Fn); 8586} 8587 8588/// Arity mismatch diagnosis specific to a function overload candidate. 8589void DiagnoseArityMismatch(Sema &S, OverloadCandidate *Cand, 8590 unsigned NumFormalArgs) { 8591 if (!CheckArityMismatch(S, Cand, NumFormalArgs)) 8592 DiagnoseArityMismatch(S, Cand->Function, NumFormalArgs); 8593} 8594 8595TemplateDecl *getDescribedTemplate(Decl *Templated) { 8596 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(Templated)) 8597 return FD->getDescribedFunctionTemplate(); 8598 else if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Templated)) 8599 return RD->getDescribedClassTemplate(); 8600 8601 llvm_unreachable("Unsupported: Getting the described template declaration" 8602 " for bad deduction diagnosis"); 8603} 8604 8605/// Diagnose a failed template-argument deduction. 8606void DiagnoseBadDeduction(Sema &S, Decl *Templated, 8607 DeductionFailureInfo &DeductionFailure, 8608 unsigned NumArgs) { 8609 TemplateParameter Param = DeductionFailure.getTemplateParameter(); 8610 NamedDecl *ParamD; 8611 (ParamD = Param.dyn_cast<TemplateTypeParmDecl*>()) || 8612 (ParamD = Param.dyn_cast<NonTypeTemplateParmDecl*>()) || 8613 (ParamD = Param.dyn_cast<TemplateTemplateParmDecl*>()); 8614 switch (DeductionFailure.Result) { 8615 case Sema::TDK_Success: 8616 llvm_unreachable("TDK_success while diagnosing bad deduction"); 8617 8618 case Sema::TDK_Incomplete: { 8619 assert(ParamD && "no parameter found for incomplete deduction result"); 8620 S.Diag(Templated->getLocation(), 8621 diag::note_ovl_candidate_incomplete_deduction) 8622 << ParamD->getDeclName(); 8623 MaybeEmitInheritedConstructorNote(S, Templated); 8624 return; 8625 } 8626 8627 case Sema::TDK_Underqualified: { 8628 assert(ParamD && "no parameter found for bad qualifiers deduction result"); 8629 TemplateTypeParmDecl *TParam = cast<TemplateTypeParmDecl>(ParamD); 8630 8631 QualType Param = DeductionFailure.getFirstArg()->getAsType(); 8632 8633 // Param will have been canonicalized, but it should just be a 8634 // qualified version of ParamD, so move the qualifiers to that. 8635 QualifierCollector Qs; 8636 Qs.strip(Param); 8637 QualType NonCanonParam = Qs.apply(S.Context, TParam->getTypeForDecl()); 8638 assert(S.Context.hasSameType(Param, NonCanonParam)); 8639 8640 // Arg has also been canonicalized, but there's nothing we can do 8641 // about that. It also doesn't matter as much, because it won't 8642 // have any template parameters in it (because deduction isn't 8643 // done on dependent types). 8644 QualType Arg = DeductionFailure.getSecondArg()->getAsType(); 8645 8646 S.Diag(Templated->getLocation(), diag::note_ovl_candidate_underqualified) 8647 << ParamD->getDeclName() << Arg << NonCanonParam; 8648 MaybeEmitInheritedConstructorNote(S, Templated); 8649 return; 8650 } 8651 8652 case Sema::TDK_Inconsistent: { 8653 assert(ParamD && "no parameter found for inconsistent deduction result"); 8654 int which = 0; 8655 if (isa<TemplateTypeParmDecl>(ParamD)) 8656 which = 0; 8657 else if (isa<NonTypeTemplateParmDecl>(ParamD)) 8658 which = 1; 8659 else { 8660 which = 2; 8661 } 8662 8663 S.Diag(Templated->getLocation(), 8664 diag::note_ovl_candidate_inconsistent_deduction) 8665 << which << ParamD->getDeclName() << *DeductionFailure.getFirstArg() 8666 << *DeductionFailure.getSecondArg(); 8667 MaybeEmitInheritedConstructorNote(S, Templated); 8668 return; 8669 } 8670 8671 case Sema::TDK_InvalidExplicitArguments: 8672 assert(ParamD && "no parameter found for invalid explicit arguments"); 8673 if (ParamD->getDeclName()) 8674 S.Diag(Templated->getLocation(), 8675 diag::note_ovl_candidate_explicit_arg_mismatch_named) 8676 << ParamD->getDeclName(); 8677 else { 8678 int index = 0; 8679 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ParamD)) 8680 index = TTP->getIndex(); 8681 else if (NonTypeTemplateParmDecl *NTTP 8682 = dyn_cast<NonTypeTemplateParmDecl>(ParamD)) 8683 index = NTTP->getIndex(); 8684 else 8685 index = cast<TemplateTemplateParmDecl>(ParamD)->getIndex(); 8686 S.Diag(Templated->getLocation(), 8687 diag::note_ovl_candidate_explicit_arg_mismatch_unnamed) 8688 << (index + 1); 8689 } 8690 MaybeEmitInheritedConstructorNote(S, Templated); 8691 return; 8692 8693 case Sema::TDK_TooManyArguments: 8694 case Sema::TDK_TooFewArguments: 8695 DiagnoseArityMismatch(S, Templated, NumArgs); 8696 return; 8697 8698 case Sema::TDK_InstantiationDepth: 8699 S.Diag(Templated->getLocation(), 8700 diag::note_ovl_candidate_instantiation_depth); 8701 MaybeEmitInheritedConstructorNote(S, Templated); 8702 return; 8703 8704 case Sema::TDK_SubstitutionFailure: { 8705 // Format the template argument list into the argument string. 8706 SmallString<128> TemplateArgString; 8707 if (TemplateArgumentList *Args = 8708 DeductionFailure.getTemplateArgumentList()) { 8709 TemplateArgString = " "; 8710 TemplateArgString += S.getTemplateArgumentBindingsText( 8711 getDescribedTemplate(Templated)->getTemplateParameters(), *Args); 8712 } 8713 8714 // If this candidate was disabled by enable_if, say so. 8715 PartialDiagnosticAt *PDiag = DeductionFailure.getSFINAEDiagnostic(); 8716 if (PDiag && PDiag->second.getDiagID() == 8717 diag::err_typename_nested_not_found_enable_if) { 8718 // FIXME: Use the source range of the condition, and the fully-qualified 8719 // name of the enable_if template. These are both present in PDiag. 8720 S.Diag(PDiag->first, diag::note_ovl_candidate_disabled_by_enable_if) 8721 << "'enable_if'" << TemplateArgString; 8722 return; 8723 } 8724 8725 // Format the SFINAE diagnostic into the argument string. 8726 // FIXME: Add a general mechanism to include a PartialDiagnostic *'s 8727 // formatted message in another diagnostic. 8728 SmallString<128> SFINAEArgString; 8729 SourceRange R; 8730 if (PDiag) { 8731 SFINAEArgString = ": "; 8732 R = SourceRange(PDiag->first, PDiag->first); 8733 PDiag->second.EmitToString(S.getDiagnostics(), SFINAEArgString); 8734 } 8735 8736 S.Diag(Templated->getLocation(), 8737 diag::note_ovl_candidate_substitution_failure) 8738 << TemplateArgString << SFINAEArgString << R; 8739 MaybeEmitInheritedConstructorNote(S, Templated); 8740 return; 8741 } 8742 8743 case Sema::TDK_FailedOverloadResolution: { 8744 OverloadExpr::FindResult R = OverloadExpr::find(DeductionFailure.getExpr()); 8745 S.Diag(Templated->getLocation(), 8746 diag::note_ovl_candidate_failed_overload_resolution) 8747 << R.Expression->getName(); 8748 return; 8749 } 8750 8751 case Sema::TDK_NonDeducedMismatch: { 8752 // FIXME: Provide a source location to indicate what we couldn't match. 8753 TemplateArgument FirstTA = *DeductionFailure.getFirstArg(); 8754 TemplateArgument SecondTA = *DeductionFailure.getSecondArg(); 8755 if (FirstTA.getKind() == TemplateArgument::Template && 8756 SecondTA.getKind() == TemplateArgument::Template) { 8757 TemplateName FirstTN = FirstTA.getAsTemplate(); 8758 TemplateName SecondTN = SecondTA.getAsTemplate(); 8759 if (FirstTN.getKind() == TemplateName::Template && 8760 SecondTN.getKind() == TemplateName::Template) { 8761 if (FirstTN.getAsTemplateDecl()->getName() == 8762 SecondTN.getAsTemplateDecl()->getName()) { 8763 // FIXME: This fixes a bad diagnostic where both templates are named 8764 // the same. This particular case is a bit difficult since: 8765 // 1) It is passed as a string to the diagnostic printer. 8766 // 2) The diagnostic printer only attempts to find a better 8767 // name for types, not decls. 8768 // Ideally, this should folded into the diagnostic printer. 8769 S.Diag(Templated->getLocation(), 8770 diag::note_ovl_candidate_non_deduced_mismatch_qualified) 8771 << FirstTN.getAsTemplateDecl() << SecondTN.getAsTemplateDecl(); 8772 return; 8773 } 8774 } 8775 } 8776 // FIXME: For generic lambda parameters, check if the function is a lambda 8777 // call operator, and if so, emit a prettier and more informative 8778 // diagnostic that mentions 'auto' and lambda in addition to 8779 // (or instead of?) the canonical template type parameters. 8780 S.Diag(Templated->getLocation(), 8781 diag::note_ovl_candidate_non_deduced_mismatch) 8782 << FirstTA << SecondTA; 8783 return; 8784 } 8785 // TODO: diagnose these individually, then kill off 8786 // note_ovl_candidate_bad_deduction, which is uselessly vague. 8787 case Sema::TDK_MiscellaneousDeductionFailure: 8788 S.Diag(Templated->getLocation(), diag::note_ovl_candidate_bad_deduction); 8789 MaybeEmitInheritedConstructorNote(S, Templated); 8790 return; 8791 } 8792} 8793 8794/// Diagnose a failed template-argument deduction, for function calls. 8795void DiagnoseBadDeduction(Sema &S, OverloadCandidate *Cand, unsigned NumArgs) { 8796 unsigned TDK = Cand->DeductionFailure.Result; 8797 if (TDK == Sema::TDK_TooFewArguments || TDK == Sema::TDK_TooManyArguments) { 8798 if (CheckArityMismatch(S, Cand, NumArgs)) 8799 return; 8800 } 8801 DiagnoseBadDeduction(S, Cand->Function, // pattern 8802 Cand->DeductionFailure, NumArgs); 8803} 8804 8805/// CUDA: diagnose an invalid call across targets. 8806void DiagnoseBadTarget(Sema &S, OverloadCandidate *Cand) { 8807 FunctionDecl *Caller = cast<FunctionDecl>(S.CurContext); 8808 FunctionDecl *Callee = Cand->Function; 8809 8810 Sema::CUDAFunctionTarget CallerTarget = S.IdentifyCUDATarget(Caller), 8811 CalleeTarget = S.IdentifyCUDATarget(Callee); 8812 8813 std::string FnDesc; 8814 OverloadCandidateKind FnKind = ClassifyOverloadCandidate(S, Callee, FnDesc); 8815 8816 S.Diag(Callee->getLocation(), diag::note_ovl_candidate_bad_target) 8817 << (unsigned) FnKind << CalleeTarget << CallerTarget; 8818} 8819 8820/// Generates a 'note' diagnostic for an overload candidate. We've 8821/// already generated a primary error at the call site. 8822/// 8823/// It really does need to be a single diagnostic with its caret 8824/// pointed at the candidate declaration. Yes, this creates some 8825/// major challenges of technical writing. Yes, this makes pointing 8826/// out problems with specific arguments quite awkward. It's still 8827/// better than generating twenty screens of text for every failed 8828/// overload. 8829/// 8830/// It would be great to be able to express per-candidate problems 8831/// more richly for those diagnostic clients that cared, but we'd 8832/// still have to be just as careful with the default diagnostics. 8833void NoteFunctionCandidate(Sema &S, OverloadCandidate *Cand, 8834 unsigned NumArgs) { 8835 FunctionDecl *Fn = Cand->Function; 8836 8837 // Note deleted candidates, but only if they're viable. 8838 if (Cand->Viable && (Fn->isDeleted() || 8839 S.isFunctionConsideredUnavailable(Fn))) { 8840 std::string FnDesc; 8841 OverloadCandidateKind FnKind = ClassifyOverloadCandidate(S, Fn, FnDesc); 8842 8843 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_deleted) 8844 << FnKind << FnDesc 8845 << (Fn->isDeleted() ? (Fn->isDeletedAsWritten() ? 1 : 2) : 0); 8846 MaybeEmitInheritedConstructorNote(S, Fn); 8847 return; 8848 } 8849 8850 // We don't really have anything else to say about viable candidates. 8851 if (Cand->Viable) { 8852 S.NoteOverloadCandidate(Fn); 8853 return; 8854 } 8855 8856 switch (Cand->FailureKind) { 8857 case ovl_fail_too_many_arguments: 8858 case ovl_fail_too_few_arguments: 8859 return DiagnoseArityMismatch(S, Cand, NumArgs); 8860 8861 case ovl_fail_bad_deduction: 8862 return DiagnoseBadDeduction(S, Cand, NumArgs); 8863 8864 case ovl_fail_trivial_conversion: 8865 case ovl_fail_bad_final_conversion: 8866 case ovl_fail_final_conversion_not_exact: 8867 return S.NoteOverloadCandidate(Fn); 8868 8869 case ovl_fail_bad_conversion: { 8870 unsigned I = (Cand->IgnoreObjectArgument ? 1 : 0); 8871 for (unsigned N = Cand->NumConversions; I != N; ++I) 8872 if (Cand->Conversions[I].isBad()) 8873 return DiagnoseBadConversion(S, Cand, I); 8874 8875 // FIXME: this currently happens when we're called from SemaInit 8876 // when user-conversion overload fails. Figure out how to handle 8877 // those conditions and diagnose them well. 8878 return S.NoteOverloadCandidate(Fn); 8879 } 8880 8881 case ovl_fail_bad_target: 8882 return DiagnoseBadTarget(S, Cand); 8883 } 8884} 8885 8886void NoteSurrogateCandidate(Sema &S, OverloadCandidate *Cand) { 8887 // Desugar the type of the surrogate down to a function type, 8888 // retaining as many typedefs as possible while still showing 8889 // the function type (and, therefore, its parameter types). 8890 QualType FnType = Cand->Surrogate->getConversionType(); 8891 bool isLValueReference = false; 8892 bool isRValueReference = false; 8893 bool isPointer = false; 8894 if (const LValueReferenceType *FnTypeRef = 8895 FnType->getAs<LValueReferenceType>()) { 8896 FnType = FnTypeRef->getPointeeType(); 8897 isLValueReference = true; 8898 } else if (const RValueReferenceType *FnTypeRef = 8899 FnType->getAs<RValueReferenceType>()) { 8900 FnType = FnTypeRef->getPointeeType(); 8901 isRValueReference = true; 8902 } 8903 if (const PointerType *FnTypePtr = FnType->getAs<PointerType>()) { 8904 FnType = FnTypePtr->getPointeeType(); 8905 isPointer = true; 8906 } 8907 // Desugar down to a function type. 8908 FnType = QualType(FnType->getAs<FunctionType>(), 0); 8909 // Reconstruct the pointer/reference as appropriate. 8910 if (isPointer) FnType = S.Context.getPointerType(FnType); 8911 if (isRValueReference) FnType = S.Context.getRValueReferenceType(FnType); 8912 if (isLValueReference) FnType = S.Context.getLValueReferenceType(FnType); 8913 8914 S.Diag(Cand->Surrogate->getLocation(), diag::note_ovl_surrogate_cand) 8915 << FnType; 8916 MaybeEmitInheritedConstructorNote(S, Cand->Surrogate); 8917} 8918 8919void NoteBuiltinOperatorCandidate(Sema &S, 8920 StringRef Opc, 8921 SourceLocation OpLoc, 8922 OverloadCandidate *Cand) { 8923 assert(Cand->NumConversions <= 2 && "builtin operator is not binary"); 8924 std::string TypeStr("operator"); 8925 TypeStr += Opc; 8926 TypeStr += "("; 8927 TypeStr += Cand->BuiltinTypes.ParamTypes[0].getAsString(); 8928 if (Cand->NumConversions == 1) { 8929 TypeStr += ")"; 8930 S.Diag(OpLoc, diag::note_ovl_builtin_unary_candidate) << TypeStr; 8931 } else { 8932 TypeStr += ", "; 8933 TypeStr += Cand->BuiltinTypes.ParamTypes[1].getAsString(); 8934 TypeStr += ")"; 8935 S.Diag(OpLoc, diag::note_ovl_builtin_binary_candidate) << TypeStr; 8936 } 8937} 8938 8939void NoteAmbiguousUserConversions(Sema &S, SourceLocation OpLoc, 8940 OverloadCandidate *Cand) { 8941 unsigned NoOperands = Cand->NumConversions; 8942 for (unsigned ArgIdx = 0; ArgIdx < NoOperands; ++ArgIdx) { 8943 const ImplicitConversionSequence &ICS = Cand->Conversions[ArgIdx]; 8944 if (ICS.isBad()) break; // all meaningless after first invalid 8945 if (!ICS.isAmbiguous()) continue; 8946 8947 ICS.DiagnoseAmbiguousConversion(S, OpLoc, 8948 S.PDiag(diag::note_ambiguous_type_conversion)); 8949 } 8950} 8951 8952static SourceLocation GetLocationForCandidate(const OverloadCandidate *Cand) { 8953 if (Cand->Function) 8954 return Cand->Function->getLocation(); 8955 if (Cand->IsSurrogate) 8956 return Cand->Surrogate->getLocation(); 8957 return SourceLocation(); 8958} 8959 8960static unsigned RankDeductionFailure(const DeductionFailureInfo &DFI) { 8961 switch ((Sema::TemplateDeductionResult)DFI.Result) { 8962 case Sema::TDK_Success: 8963 llvm_unreachable("TDK_success while diagnosing bad deduction"); 8964 8965 case Sema::TDK_Invalid: 8966 case Sema::TDK_Incomplete: 8967 return 1; 8968 8969 case Sema::TDK_Underqualified: 8970 case Sema::TDK_Inconsistent: 8971 return 2; 8972 8973 case Sema::TDK_SubstitutionFailure: 8974 case Sema::TDK_NonDeducedMismatch: 8975 case Sema::TDK_MiscellaneousDeductionFailure: 8976 return 3; 8977 8978 case Sema::TDK_InstantiationDepth: 8979 case Sema::TDK_FailedOverloadResolution: 8980 return 4; 8981 8982 case Sema::TDK_InvalidExplicitArguments: 8983 return 5; 8984 8985 case Sema::TDK_TooManyArguments: 8986 case Sema::TDK_TooFewArguments: 8987 return 6; 8988 } 8989 llvm_unreachable("Unhandled deduction result"); 8990} 8991 8992struct CompareOverloadCandidatesForDisplay { 8993 Sema &S; 8994 CompareOverloadCandidatesForDisplay(Sema &S) : S(S) {} 8995 8996 bool operator()(const OverloadCandidate *L, 8997 const OverloadCandidate *R) { 8998 // Fast-path this check. 8999 if (L == R) return false; 9000 9001 // Order first by viability. 9002 if (L->Viable) { 9003 if (!R->Viable) return true; 9004 9005 // TODO: introduce a tri-valued comparison for overload 9006 // candidates. Would be more worthwhile if we had a sort 9007 // that could exploit it. 9008 if (isBetterOverloadCandidate(S, *L, *R, SourceLocation())) return true; 9009 if (isBetterOverloadCandidate(S, *R, *L, SourceLocation())) return false; 9010 } else if (R->Viable) 9011 return false; 9012 9013 assert(L->Viable == R->Viable); 9014 9015 // Criteria by which we can sort non-viable candidates: 9016 if (!L->Viable) { 9017 // 1. Arity mismatches come after other candidates. 9018 if (L->FailureKind == ovl_fail_too_many_arguments || 9019 L->FailureKind == ovl_fail_too_few_arguments) 9020 return false; 9021 if (R->FailureKind == ovl_fail_too_many_arguments || 9022 R->FailureKind == ovl_fail_too_few_arguments) 9023 return true; 9024 9025 // 2. Bad conversions come first and are ordered by the number 9026 // of bad conversions and quality of good conversions. 9027 if (L->FailureKind == ovl_fail_bad_conversion) { 9028 if (R->FailureKind != ovl_fail_bad_conversion) 9029 return true; 9030 9031 // The conversion that can be fixed with a smaller number of changes, 9032 // comes first. 9033 unsigned numLFixes = L->Fix.NumConversionsFixed; 9034 unsigned numRFixes = R->Fix.NumConversionsFixed; 9035 numLFixes = (numLFixes == 0) ? UINT_MAX : numLFixes; 9036 numRFixes = (numRFixes == 0) ? UINT_MAX : numRFixes; 9037 if (numLFixes != numRFixes) { 9038 if (numLFixes < numRFixes) 9039 return true; 9040 else 9041 return false; 9042 } 9043 9044 // If there's any ordering between the defined conversions... 9045 // FIXME: this might not be transitive. 9046 assert(L->NumConversions == R->NumConversions); 9047 9048 int leftBetter = 0; 9049 unsigned I = (L->IgnoreObjectArgument || R->IgnoreObjectArgument); 9050 for (unsigned E = L->NumConversions; I != E; ++I) { 9051 switch (CompareImplicitConversionSequences(S, 9052 L->Conversions[I], 9053 R->Conversions[I])) { 9054 case ImplicitConversionSequence::Better: 9055 leftBetter++; 9056 break; 9057 9058 case ImplicitConversionSequence::Worse: 9059 leftBetter--; 9060 break; 9061 9062 case ImplicitConversionSequence::Indistinguishable: 9063 break; 9064 } 9065 } 9066 if (leftBetter > 0) return true; 9067 if (leftBetter < 0) return false; 9068 9069 } else if (R->FailureKind == ovl_fail_bad_conversion) 9070 return false; 9071 9072 if (L->FailureKind == ovl_fail_bad_deduction) { 9073 if (R->FailureKind != ovl_fail_bad_deduction) 9074 return true; 9075 9076 if (L->DeductionFailure.Result != R->DeductionFailure.Result) 9077 return RankDeductionFailure(L->DeductionFailure) 9078 < RankDeductionFailure(R->DeductionFailure); 9079 } else if (R->FailureKind == ovl_fail_bad_deduction) 9080 return false; 9081 9082 // TODO: others? 9083 } 9084 9085 // Sort everything else by location. 9086 SourceLocation LLoc = GetLocationForCandidate(L); 9087 SourceLocation RLoc = GetLocationForCandidate(R); 9088 9089 // Put candidates without locations (e.g. builtins) at the end. 9090 if (LLoc.isInvalid()) return false; 9091 if (RLoc.isInvalid()) return true; 9092 9093 return S.SourceMgr.isBeforeInTranslationUnit(LLoc, RLoc); 9094 } 9095}; 9096 9097/// CompleteNonViableCandidate - Normally, overload resolution only 9098/// computes up to the first. Produces the FixIt set if possible. 9099void CompleteNonViableCandidate(Sema &S, OverloadCandidate *Cand, 9100 ArrayRef<Expr *> Args) { 9101 assert(!Cand->Viable); 9102 9103 // Don't do anything on failures other than bad conversion. 9104 if (Cand->FailureKind != ovl_fail_bad_conversion) return; 9105 9106 // We only want the FixIts if all the arguments can be corrected. 9107 bool Unfixable = false; 9108 // Use a implicit copy initialization to check conversion fixes. 9109 Cand->Fix.setConversionChecker(TryCopyInitialization); 9110 9111 // Skip forward to the first bad conversion. 9112 unsigned ConvIdx = (Cand->IgnoreObjectArgument ? 1 : 0); 9113 unsigned ConvCount = Cand->NumConversions; 9114 while (true) { 9115 assert(ConvIdx != ConvCount && "no bad conversion in candidate"); 9116 ConvIdx++; 9117 if (Cand->Conversions[ConvIdx - 1].isBad()) { 9118 Unfixable = !Cand->TryToFixBadConversion(ConvIdx - 1, S); 9119 break; 9120 } 9121 } 9122 9123 if (ConvIdx == ConvCount) 9124 return; 9125 9126 assert(!Cand->Conversions[ConvIdx].isInitialized() && 9127 "remaining conversion is initialized?"); 9128 9129 // FIXME: this should probably be preserved from the overload 9130 // operation somehow. 9131 bool SuppressUserConversions = false; 9132 9133 const FunctionProtoType* Proto; 9134 unsigned ArgIdx = ConvIdx; 9135 9136 if (Cand->IsSurrogate) { 9137 QualType ConvType 9138 = Cand->Surrogate->getConversionType().getNonReferenceType(); 9139 if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>()) 9140 ConvType = ConvPtrType->getPointeeType(); 9141 Proto = ConvType->getAs<FunctionProtoType>(); 9142 ArgIdx--; 9143 } else if (Cand->Function) { 9144 Proto = Cand->Function->getType()->getAs<FunctionProtoType>(); 9145 if (isa<CXXMethodDecl>(Cand->Function) && 9146 !isa<CXXConstructorDecl>(Cand->Function)) 9147 ArgIdx--; 9148 } else { 9149 // Builtin binary operator with a bad first conversion. 9150 assert(ConvCount <= 3); 9151 for (; ConvIdx != ConvCount; ++ConvIdx) 9152 Cand->Conversions[ConvIdx] 9153 = TryCopyInitialization(S, Args[ConvIdx], 9154 Cand->BuiltinTypes.ParamTypes[ConvIdx], 9155 SuppressUserConversions, 9156 /*InOverloadResolution*/ true, 9157 /*AllowObjCWritebackConversion=*/ 9158 S.getLangOpts().ObjCAutoRefCount); 9159 return; 9160 } 9161 9162 // Fill in the rest of the conversions. 9163 unsigned NumArgsInProto = Proto->getNumArgs(); 9164 for (; ConvIdx != ConvCount; ++ConvIdx, ++ArgIdx) { 9165 if (ArgIdx < NumArgsInProto) { 9166 Cand->Conversions[ConvIdx] 9167 = TryCopyInitialization(S, Args[ArgIdx], Proto->getArgType(ArgIdx), 9168 SuppressUserConversions, 9169 /*InOverloadResolution=*/true, 9170 /*AllowObjCWritebackConversion=*/ 9171 S.getLangOpts().ObjCAutoRefCount); 9172 // Store the FixIt in the candidate if it exists. 9173 if (!Unfixable && Cand->Conversions[ConvIdx].isBad()) 9174 Unfixable = !Cand->TryToFixBadConversion(ConvIdx, S); 9175 } 9176 else 9177 Cand->Conversions[ConvIdx].setEllipsis(); 9178 } 9179} 9180 9181} // end anonymous namespace 9182 9183/// PrintOverloadCandidates - When overload resolution fails, prints 9184/// diagnostic messages containing the candidates in the candidate 9185/// set. 9186void OverloadCandidateSet::NoteCandidates(Sema &S, 9187 OverloadCandidateDisplayKind OCD, 9188 ArrayRef<Expr *> Args, 9189 StringRef Opc, 9190 SourceLocation OpLoc) { 9191 // Sort the candidates by viability and position. Sorting directly would 9192 // be prohibitive, so we make a set of pointers and sort those. 9193 SmallVector<OverloadCandidate*, 32> Cands; 9194 if (OCD == OCD_AllCandidates) Cands.reserve(size()); 9195 for (iterator Cand = begin(), LastCand = end(); Cand != LastCand; ++Cand) { 9196 if (Cand->Viable) 9197 Cands.push_back(Cand); 9198 else if (OCD == OCD_AllCandidates) { 9199 CompleteNonViableCandidate(S, Cand, Args); 9200 if (Cand->Function || Cand->IsSurrogate) 9201 Cands.push_back(Cand); 9202 // Otherwise, this a non-viable builtin candidate. We do not, in general, 9203 // want to list every possible builtin candidate. 9204 } 9205 } 9206 9207 std::sort(Cands.begin(), Cands.end(), 9208 CompareOverloadCandidatesForDisplay(S)); 9209 9210 bool ReportedAmbiguousConversions = false; 9211 9212 SmallVectorImpl<OverloadCandidate*>::iterator I, E; 9213 const OverloadsShown ShowOverloads = S.Diags.getShowOverloads(); 9214 unsigned CandsShown = 0; 9215 for (I = Cands.begin(), E = Cands.end(); I != E; ++I) { 9216 OverloadCandidate *Cand = *I; 9217 9218 // Set an arbitrary limit on the number of candidate functions we'll spam 9219 // the user with. FIXME: This limit should depend on details of the 9220 // candidate list. 9221 if (CandsShown >= 4 && ShowOverloads == Ovl_Best) { 9222 break; 9223 } 9224 ++CandsShown; 9225 9226 if (Cand->Function) 9227 NoteFunctionCandidate(S, Cand, Args.size()); 9228 else if (Cand->IsSurrogate) 9229 NoteSurrogateCandidate(S, Cand); 9230 else { 9231 assert(Cand->Viable && 9232 "Non-viable built-in candidates are not added to Cands."); 9233 // Generally we only see ambiguities including viable builtin 9234 // operators if overload resolution got screwed up by an 9235 // ambiguous user-defined conversion. 9236 // 9237 // FIXME: It's quite possible for different conversions to see 9238 // different ambiguities, though. 9239 if (!ReportedAmbiguousConversions) { 9240 NoteAmbiguousUserConversions(S, OpLoc, Cand); 9241 ReportedAmbiguousConversions = true; 9242 } 9243 9244 // If this is a viable builtin, print it. 9245 NoteBuiltinOperatorCandidate(S, Opc, OpLoc, Cand); 9246 } 9247 } 9248 9249 if (I != E) 9250 S.Diag(OpLoc, diag::note_ovl_too_many_candidates) << int(E - I); 9251} 9252 9253static SourceLocation 9254GetLocationForCandidate(const TemplateSpecCandidate *Cand) { 9255 return Cand->Specialization ? Cand->Specialization->getLocation() 9256 : SourceLocation(); 9257} 9258 9259struct CompareTemplateSpecCandidatesForDisplay { 9260 Sema &S; 9261 CompareTemplateSpecCandidatesForDisplay(Sema &S) : S(S) {} 9262 9263 bool operator()(const TemplateSpecCandidate *L, 9264 const TemplateSpecCandidate *R) { 9265 // Fast-path this check. 9266 if (L == R) 9267 return false; 9268 9269 // Assuming that both candidates are not matches... 9270 9271 // Sort by the ranking of deduction failures. 9272 if (L->DeductionFailure.Result != R->DeductionFailure.Result) 9273 return RankDeductionFailure(L->DeductionFailure) < 9274 RankDeductionFailure(R->DeductionFailure); 9275 9276 // Sort everything else by location. 9277 SourceLocation LLoc = GetLocationForCandidate(L); 9278 SourceLocation RLoc = GetLocationForCandidate(R); 9279 9280 // Put candidates without locations (e.g. builtins) at the end. 9281 if (LLoc.isInvalid()) 9282 return false; 9283 if (RLoc.isInvalid()) 9284 return true; 9285 9286 return S.SourceMgr.isBeforeInTranslationUnit(LLoc, RLoc); 9287 } 9288}; 9289 9290/// Diagnose a template argument deduction failure. 9291/// We are treating these failures as overload failures due to bad 9292/// deductions. 9293void TemplateSpecCandidate::NoteDeductionFailure(Sema &S) { 9294 DiagnoseBadDeduction(S, Specialization, // pattern 9295 DeductionFailure, /*NumArgs=*/0); 9296} 9297 9298void TemplateSpecCandidateSet::destroyCandidates() { 9299 for (iterator i = begin(), e = end(); i != e; ++i) { 9300 i->DeductionFailure.Destroy(); 9301 } 9302} 9303 9304void TemplateSpecCandidateSet::clear() { 9305 destroyCandidates(); 9306 Candidates.clear(); 9307} 9308 9309/// NoteCandidates - When no template specialization match is found, prints 9310/// diagnostic messages containing the non-matching specializations that form 9311/// the candidate set. 9312/// This is analoguous to OverloadCandidateSet::NoteCandidates() with 9313/// OCD == OCD_AllCandidates and Cand->Viable == false. 9314void TemplateSpecCandidateSet::NoteCandidates(Sema &S, SourceLocation Loc) { 9315 // Sort the candidates by position (assuming no candidate is a match). 9316 // Sorting directly would be prohibitive, so we make a set of pointers 9317 // and sort those. 9318 SmallVector<TemplateSpecCandidate *, 32> Cands; 9319 Cands.reserve(size()); 9320 for (iterator Cand = begin(), LastCand = end(); Cand != LastCand; ++Cand) { 9321 if (Cand->Specialization) 9322 Cands.push_back(Cand); 9323 // Otherwise, this is a non matching builtin candidate. We do not, 9324 // in general, want to list every possible builtin candidate. 9325 } 9326 9327 std::sort(Cands.begin(), Cands.end(), 9328 CompareTemplateSpecCandidatesForDisplay(S)); 9329 9330 // FIXME: Perhaps rename OverloadsShown and getShowOverloads() 9331 // for generalization purposes (?). 9332 const OverloadsShown ShowOverloads = S.Diags.getShowOverloads(); 9333 9334 SmallVectorImpl<TemplateSpecCandidate *>::iterator I, E; 9335 unsigned CandsShown = 0; 9336 for (I = Cands.begin(), E = Cands.end(); I != E; ++I) { 9337 TemplateSpecCandidate *Cand = *I; 9338 9339 // Set an arbitrary limit on the number of candidates we'll spam 9340 // the user with. FIXME: This limit should depend on details of the 9341 // candidate list. 9342 if (CandsShown >= 4 && ShowOverloads == Ovl_Best) 9343 break; 9344 ++CandsShown; 9345 9346 assert(Cand->Specialization && 9347 "Non-matching built-in candidates are not added to Cands."); 9348 Cand->NoteDeductionFailure(S); 9349 } 9350 9351 if (I != E) 9352 S.Diag(Loc, diag::note_ovl_too_many_candidates) << int(E - I); 9353} 9354 9355// [PossiblyAFunctionType] --> [Return] 9356// NonFunctionType --> NonFunctionType 9357// R (A) --> R(A) 9358// R (*)(A) --> R (A) 9359// R (&)(A) --> R (A) 9360// R (S::*)(A) --> R (A) 9361QualType Sema::ExtractUnqualifiedFunctionType(QualType PossiblyAFunctionType) { 9362 QualType Ret = PossiblyAFunctionType; 9363 if (const PointerType *ToTypePtr = 9364 PossiblyAFunctionType->getAs<PointerType>()) 9365 Ret = ToTypePtr->getPointeeType(); 9366 else if (const ReferenceType *ToTypeRef = 9367 PossiblyAFunctionType->getAs<ReferenceType>()) 9368 Ret = ToTypeRef->getPointeeType(); 9369 else if (const MemberPointerType *MemTypePtr = 9370 PossiblyAFunctionType->getAs<MemberPointerType>()) 9371 Ret = MemTypePtr->getPointeeType(); 9372 Ret = 9373 Context.getCanonicalType(Ret).getUnqualifiedType(); 9374 return Ret; 9375} 9376 9377// A helper class to help with address of function resolution 9378// - allows us to avoid passing around all those ugly parameters 9379class AddressOfFunctionResolver 9380{ 9381 Sema& S; 9382 Expr* SourceExpr; 9383 const QualType& TargetType; 9384 QualType TargetFunctionType; // Extracted function type from target type 9385 9386 bool Complain; 9387 //DeclAccessPair& ResultFunctionAccessPair; 9388 ASTContext& Context; 9389 9390 bool TargetTypeIsNonStaticMemberFunction; 9391 bool FoundNonTemplateFunction; 9392 bool StaticMemberFunctionFromBoundPointer; 9393 9394 OverloadExpr::FindResult OvlExprInfo; 9395 OverloadExpr *OvlExpr; 9396 TemplateArgumentListInfo OvlExplicitTemplateArgs; 9397 SmallVector<std::pair<DeclAccessPair, FunctionDecl*>, 4> Matches; 9398 TemplateSpecCandidateSet FailedCandidates; 9399 9400public: 9401 AddressOfFunctionResolver(Sema &S, Expr *SourceExpr, 9402 const QualType &TargetType, bool Complain) 9403 : S(S), SourceExpr(SourceExpr), TargetType(TargetType), 9404 Complain(Complain), Context(S.getASTContext()), 9405 TargetTypeIsNonStaticMemberFunction( 9406 !!TargetType->getAs<MemberPointerType>()), 9407 FoundNonTemplateFunction(false), 9408 StaticMemberFunctionFromBoundPointer(false), 9409 OvlExprInfo(OverloadExpr::find(SourceExpr)), 9410 OvlExpr(OvlExprInfo.Expression), 9411 FailedCandidates(OvlExpr->getNameLoc()) { 9412 ExtractUnqualifiedFunctionTypeFromTargetType(); 9413 9414 if (TargetFunctionType->isFunctionType()) { 9415 if (UnresolvedMemberExpr *UME = dyn_cast<UnresolvedMemberExpr>(OvlExpr)) 9416 if (!UME->isImplicitAccess() && 9417 !S.ResolveSingleFunctionTemplateSpecialization(UME)) 9418 StaticMemberFunctionFromBoundPointer = true; 9419 } else if (OvlExpr->hasExplicitTemplateArgs()) { 9420 DeclAccessPair dap; 9421 if (FunctionDecl *Fn = S.ResolveSingleFunctionTemplateSpecialization( 9422 OvlExpr, false, &dap)) { 9423 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) 9424 if (!Method->isStatic()) { 9425 // If the target type is a non-function type and the function found 9426 // is a non-static member function, pretend as if that was the 9427 // target, it's the only possible type to end up with. 9428 TargetTypeIsNonStaticMemberFunction = true; 9429 9430 // And skip adding the function if its not in the proper form. 9431 // We'll diagnose this due to an empty set of functions. 9432 if (!OvlExprInfo.HasFormOfMemberPointer) 9433 return; 9434 } 9435 9436 Matches.push_back(std::make_pair(dap, Fn)); 9437 } 9438 return; 9439 } 9440 9441 if (OvlExpr->hasExplicitTemplateArgs()) 9442 OvlExpr->getExplicitTemplateArgs().copyInto(OvlExplicitTemplateArgs); 9443 9444 if (FindAllFunctionsThatMatchTargetTypeExactly()) { 9445 // C++ [over.over]p4: 9446 // If more than one function is selected, [...] 9447 if (Matches.size() > 1) { 9448 if (FoundNonTemplateFunction) 9449 EliminateAllTemplateMatches(); 9450 else 9451 EliminateAllExceptMostSpecializedTemplate(); 9452 } 9453 } 9454 } 9455 9456private: 9457 bool isTargetTypeAFunction() const { 9458 return TargetFunctionType->isFunctionType(); 9459 } 9460 9461 // [ToType] [Return] 9462 9463 // R (*)(A) --> R (A), IsNonStaticMemberFunction = false 9464 // R (&)(A) --> R (A), IsNonStaticMemberFunction = false 9465 // R (S::*)(A) --> R (A), IsNonStaticMemberFunction = true 9466 void inline ExtractUnqualifiedFunctionTypeFromTargetType() { 9467 TargetFunctionType = S.ExtractUnqualifiedFunctionType(TargetType); 9468 } 9469 9470 // return true if any matching specializations were found 9471 bool AddMatchingTemplateFunction(FunctionTemplateDecl* FunctionTemplate, 9472 const DeclAccessPair& CurAccessFunPair) { 9473 if (CXXMethodDecl *Method 9474 = dyn_cast<CXXMethodDecl>(FunctionTemplate->getTemplatedDecl())) { 9475 // Skip non-static function templates when converting to pointer, and 9476 // static when converting to member pointer. 9477 if (Method->isStatic() == TargetTypeIsNonStaticMemberFunction) 9478 return false; 9479 } 9480 else if (TargetTypeIsNonStaticMemberFunction) 9481 return false; 9482 9483 // C++ [over.over]p2: 9484 // If the name is a function template, template argument deduction is 9485 // done (14.8.2.2), and if the argument deduction succeeds, the 9486 // resulting template argument list is used to generate a single 9487 // function template specialization, which is added to the set of 9488 // overloaded functions considered. 9489 FunctionDecl *Specialization = 0; 9490 TemplateDeductionInfo Info(FailedCandidates.getLocation()); 9491 if (Sema::TemplateDeductionResult Result 9492 = S.DeduceTemplateArguments(FunctionTemplate, 9493 &OvlExplicitTemplateArgs, 9494 TargetFunctionType, Specialization, 9495 Info, /*InOverloadResolution=*/true)) { 9496 // Make a note of the failed deduction for diagnostics. 9497 FailedCandidates.addCandidate() 9498 .set(FunctionTemplate->getTemplatedDecl(), 9499 MakeDeductionFailureInfo(Context, Result, Info)); 9500 return false; 9501 } 9502 9503 // Template argument deduction ensures that we have an exact match or 9504 // compatible pointer-to-function arguments that would be adjusted by ICS. 9505 // This function template specicalization works. 9506 Specialization = cast<FunctionDecl>(Specialization->getCanonicalDecl()); 9507 assert(S.isSameOrCompatibleFunctionType( 9508 Context.getCanonicalType(Specialization->getType()), 9509 Context.getCanonicalType(TargetFunctionType))); 9510 Matches.push_back(std::make_pair(CurAccessFunPair, Specialization)); 9511 return true; 9512 } 9513 9514 bool AddMatchingNonTemplateFunction(NamedDecl* Fn, 9515 const DeclAccessPair& CurAccessFunPair) { 9516 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) { 9517 // Skip non-static functions when converting to pointer, and static 9518 // when converting to member pointer. 9519 if (Method->isStatic() == TargetTypeIsNonStaticMemberFunction) 9520 return false; 9521 } 9522 else if (TargetTypeIsNonStaticMemberFunction) 9523 return false; 9524 9525 if (FunctionDecl *FunDecl = dyn_cast<FunctionDecl>(Fn)) { 9526 if (S.getLangOpts().CUDA) 9527 if (FunctionDecl *Caller = dyn_cast<FunctionDecl>(S.CurContext)) 9528 if (S.CheckCUDATarget(Caller, FunDecl)) 9529 return false; 9530 9531 // If any candidate has a placeholder return type, trigger its deduction 9532 // now. 9533 if (S.getLangOpts().CPlusPlus1y && 9534 FunDecl->getResultType()->isUndeducedType() && 9535 S.DeduceReturnType(FunDecl, SourceExpr->getLocStart(), Complain)) 9536 return false; 9537 9538 QualType ResultTy; 9539 if (Context.hasSameUnqualifiedType(TargetFunctionType, 9540 FunDecl->getType()) || 9541 S.IsNoReturnConversion(FunDecl->getType(), TargetFunctionType, 9542 ResultTy)) { 9543 Matches.push_back(std::make_pair(CurAccessFunPair, 9544 cast<FunctionDecl>(FunDecl->getCanonicalDecl()))); 9545 FoundNonTemplateFunction = true; 9546 return true; 9547 } 9548 } 9549 9550 return false; 9551 } 9552 9553 bool FindAllFunctionsThatMatchTargetTypeExactly() { 9554 bool Ret = false; 9555 9556 // If the overload expression doesn't have the form of a pointer to 9557 // member, don't try to convert it to a pointer-to-member type. 9558 if (IsInvalidFormOfPointerToMemberFunction()) 9559 return false; 9560 9561 for (UnresolvedSetIterator I = OvlExpr->decls_begin(), 9562 E = OvlExpr->decls_end(); 9563 I != E; ++I) { 9564 // Look through any using declarations to find the underlying function. 9565 NamedDecl *Fn = (*I)->getUnderlyingDecl(); 9566 9567 // C++ [over.over]p3: 9568 // Non-member functions and static member functions match 9569 // targets of type "pointer-to-function" or "reference-to-function." 9570 // Nonstatic member functions match targets of 9571 // type "pointer-to-member-function." 9572 // Note that according to DR 247, the containing class does not matter. 9573 if (FunctionTemplateDecl *FunctionTemplate 9574 = dyn_cast<FunctionTemplateDecl>(Fn)) { 9575 if (AddMatchingTemplateFunction(FunctionTemplate, I.getPair())) 9576 Ret = true; 9577 } 9578 // If we have explicit template arguments supplied, skip non-templates. 9579 else if (!OvlExpr->hasExplicitTemplateArgs() && 9580 AddMatchingNonTemplateFunction(Fn, I.getPair())) 9581 Ret = true; 9582 } 9583 assert(Ret || Matches.empty()); 9584 return Ret; 9585 } 9586 9587 void EliminateAllExceptMostSpecializedTemplate() { 9588 // [...] and any given function template specialization F1 is 9589 // eliminated if the set contains a second function template 9590 // specialization whose function template is more specialized 9591 // than the function template of F1 according to the partial 9592 // ordering rules of 14.5.5.2. 9593 9594 // The algorithm specified above is quadratic. We instead use a 9595 // two-pass algorithm (similar to the one used to identify the 9596 // best viable function in an overload set) that identifies the 9597 // best function template (if it exists). 9598 9599 UnresolvedSet<4> MatchesCopy; // TODO: avoid! 9600 for (unsigned I = 0, E = Matches.size(); I != E; ++I) 9601 MatchesCopy.addDecl(Matches[I].second, Matches[I].first.getAccess()); 9602 9603 // TODO: It looks like FailedCandidates does not serve much purpose 9604 // here, since the no_viable diagnostic has index 0. 9605 UnresolvedSetIterator Result = S.getMostSpecialized( 9606 MatchesCopy.begin(), MatchesCopy.end(), FailedCandidates, 9607 SourceExpr->getLocStart(), S.PDiag(), 9608 S.PDiag(diag::err_addr_ovl_ambiguous) << Matches[0] 9609 .second->getDeclName(), 9610 S.PDiag(diag::note_ovl_candidate) << (unsigned)oc_function_template, 9611 Complain, TargetFunctionType); 9612 9613 if (Result != MatchesCopy.end()) { 9614 // Make it the first and only element 9615 Matches[0].first = Matches[Result - MatchesCopy.begin()].first; 9616 Matches[0].second = cast<FunctionDecl>(*Result); 9617 Matches.resize(1); 9618 } 9619 } 9620 9621 void EliminateAllTemplateMatches() { 9622 // [...] any function template specializations in the set are 9623 // eliminated if the set also contains a non-template function, [...] 9624 for (unsigned I = 0, N = Matches.size(); I != N; ) { 9625 if (Matches[I].second->getPrimaryTemplate() == 0) 9626 ++I; 9627 else { 9628 Matches[I] = Matches[--N]; 9629 Matches.set_size(N); 9630 } 9631 } 9632 } 9633 9634public: 9635 void ComplainNoMatchesFound() const { 9636 assert(Matches.empty()); 9637 S.Diag(OvlExpr->getLocStart(), diag::err_addr_ovl_no_viable) 9638 << OvlExpr->getName() << TargetFunctionType 9639 << OvlExpr->getSourceRange(); 9640 if (FailedCandidates.empty()) 9641 S.NoteAllOverloadCandidates(OvlExpr, TargetFunctionType); 9642 else { 9643 // We have some deduction failure messages. Use them to diagnose 9644 // the function templates, and diagnose the non-template candidates 9645 // normally. 9646 for (UnresolvedSetIterator I = OvlExpr->decls_begin(), 9647 IEnd = OvlExpr->decls_end(); 9648 I != IEnd; ++I) 9649 if (FunctionDecl *Fun = 9650 dyn_cast<FunctionDecl>((*I)->getUnderlyingDecl())) 9651 S.NoteOverloadCandidate(Fun, TargetFunctionType); 9652 FailedCandidates.NoteCandidates(S, OvlExpr->getLocStart()); 9653 } 9654 } 9655 9656 bool IsInvalidFormOfPointerToMemberFunction() const { 9657 return TargetTypeIsNonStaticMemberFunction && 9658 !OvlExprInfo.HasFormOfMemberPointer; 9659 } 9660 9661 void ComplainIsInvalidFormOfPointerToMemberFunction() const { 9662 // TODO: Should we condition this on whether any functions might 9663 // have matched, or is it more appropriate to do that in callers? 9664 // TODO: a fixit wouldn't hurt. 9665 S.Diag(OvlExpr->getNameLoc(), diag::err_addr_ovl_no_qualifier) 9666 << TargetType << OvlExpr->getSourceRange(); 9667 } 9668 9669 bool IsStaticMemberFunctionFromBoundPointer() const { 9670 return StaticMemberFunctionFromBoundPointer; 9671 } 9672 9673 void ComplainIsStaticMemberFunctionFromBoundPointer() const { 9674 S.Diag(OvlExpr->getLocStart(), 9675 diag::err_invalid_form_pointer_member_function) 9676 << OvlExpr->getSourceRange(); 9677 } 9678 9679 void ComplainOfInvalidConversion() const { 9680 S.Diag(OvlExpr->getLocStart(), diag::err_addr_ovl_not_func_ptrref) 9681 << OvlExpr->getName() << TargetType; 9682 } 9683 9684 void ComplainMultipleMatchesFound() const { 9685 assert(Matches.size() > 1); 9686 S.Diag(OvlExpr->getLocStart(), diag::err_addr_ovl_ambiguous) 9687 << OvlExpr->getName() 9688 << OvlExpr->getSourceRange(); 9689 S.NoteAllOverloadCandidates(OvlExpr, TargetFunctionType); 9690 } 9691 9692 bool hadMultipleCandidates() const { return (OvlExpr->getNumDecls() > 1); } 9693 9694 int getNumMatches() const { return Matches.size(); } 9695 9696 FunctionDecl* getMatchingFunctionDecl() const { 9697 if (Matches.size() != 1) return 0; 9698 return Matches[0].second; 9699 } 9700 9701 const DeclAccessPair* getMatchingFunctionAccessPair() const { 9702 if (Matches.size() != 1) return 0; 9703 return &Matches[0].first; 9704 } 9705}; 9706 9707/// ResolveAddressOfOverloadedFunction - Try to resolve the address of 9708/// an overloaded function (C++ [over.over]), where @p From is an 9709/// expression with overloaded function type and @p ToType is the type 9710/// we're trying to resolve to. For example: 9711/// 9712/// @code 9713/// int f(double); 9714/// int f(int); 9715/// 9716/// int (*pfd)(double) = f; // selects f(double) 9717/// @endcode 9718/// 9719/// This routine returns the resulting FunctionDecl if it could be 9720/// resolved, and NULL otherwise. When @p Complain is true, this 9721/// routine will emit diagnostics if there is an error. 9722FunctionDecl * 9723Sema::ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr, 9724 QualType TargetType, 9725 bool Complain, 9726 DeclAccessPair &FoundResult, 9727 bool *pHadMultipleCandidates) { 9728 assert(AddressOfExpr->getType() == Context.OverloadTy); 9729 9730 AddressOfFunctionResolver Resolver(*this, AddressOfExpr, TargetType, 9731 Complain); 9732 int NumMatches = Resolver.getNumMatches(); 9733 FunctionDecl* Fn = 0; 9734 if (NumMatches == 0 && Complain) { 9735 if (Resolver.IsInvalidFormOfPointerToMemberFunction()) 9736 Resolver.ComplainIsInvalidFormOfPointerToMemberFunction(); 9737 else 9738 Resolver.ComplainNoMatchesFound(); 9739 } 9740 else if (NumMatches > 1 && Complain) 9741 Resolver.ComplainMultipleMatchesFound(); 9742 else if (NumMatches == 1) { 9743 Fn = Resolver.getMatchingFunctionDecl(); 9744 assert(Fn); 9745 FoundResult = *Resolver.getMatchingFunctionAccessPair(); 9746 if (Complain) { 9747 if (Resolver.IsStaticMemberFunctionFromBoundPointer()) 9748 Resolver.ComplainIsStaticMemberFunctionFromBoundPointer(); 9749 else 9750 CheckAddressOfMemberAccess(AddressOfExpr, FoundResult); 9751 } 9752 } 9753 9754 if (pHadMultipleCandidates) 9755 *pHadMultipleCandidates = Resolver.hadMultipleCandidates(); 9756 return Fn; 9757} 9758 9759/// \brief Given an expression that refers to an overloaded function, try to 9760/// resolve that overloaded function expression down to a single function. 9761/// 9762/// This routine can only resolve template-ids that refer to a single function 9763/// template, where that template-id refers to a single template whose template 9764/// arguments are either provided by the template-id or have defaults, 9765/// as described in C++0x [temp.arg.explicit]p3. 9766/// 9767/// If no template-ids are found, no diagnostics are emitted and NULL is 9768/// returned. 9769FunctionDecl * 9770Sema::ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl, 9771 bool Complain, 9772 DeclAccessPair *FoundResult) { 9773 // C++ [over.over]p1: 9774 // [...] [Note: any redundant set of parentheses surrounding the 9775 // overloaded function name is ignored (5.1). ] 9776 // C++ [over.over]p1: 9777 // [...] The overloaded function name can be preceded by the & 9778 // operator. 9779 9780 // If we didn't actually find any template-ids, we're done. 9781 if (!ovl->hasExplicitTemplateArgs()) 9782 return 0; 9783 9784 TemplateArgumentListInfo ExplicitTemplateArgs; 9785 ovl->getExplicitTemplateArgs().copyInto(ExplicitTemplateArgs); 9786 TemplateSpecCandidateSet FailedCandidates(ovl->getNameLoc()); 9787 9788 // Look through all of the overloaded functions, searching for one 9789 // whose type matches exactly. 9790 FunctionDecl *Matched = 0; 9791 for (UnresolvedSetIterator I = ovl->decls_begin(), 9792 E = ovl->decls_end(); I != E; ++I) { 9793 // C++0x [temp.arg.explicit]p3: 9794 // [...] In contexts where deduction is done and fails, or in contexts 9795 // where deduction is not done, if a template argument list is 9796 // specified and it, along with any default template arguments, 9797 // identifies a single function template specialization, then the 9798 // template-id is an lvalue for the function template specialization. 9799 FunctionTemplateDecl *FunctionTemplate 9800 = cast<FunctionTemplateDecl>((*I)->getUnderlyingDecl()); 9801 9802 // C++ [over.over]p2: 9803 // If the name is a function template, template argument deduction is 9804 // done (14.8.2.2), and if the argument deduction succeeds, the 9805 // resulting template argument list is used to generate a single 9806 // function template specialization, which is added to the set of 9807 // overloaded functions considered. 9808 FunctionDecl *Specialization = 0; 9809 TemplateDeductionInfo Info(FailedCandidates.getLocation()); 9810 if (TemplateDeductionResult Result 9811 = DeduceTemplateArguments(FunctionTemplate, &ExplicitTemplateArgs, 9812 Specialization, Info, 9813 /*InOverloadResolution=*/true)) { 9814 // Make a note of the failed deduction for diagnostics. 9815 // TODO: Actually use the failed-deduction info? 9816 FailedCandidates.addCandidate() 9817 .set(FunctionTemplate->getTemplatedDecl(), 9818 MakeDeductionFailureInfo(Context, Result, Info)); 9819 continue; 9820 } 9821 9822 assert(Specialization && "no specialization and no error?"); 9823 9824 // Multiple matches; we can't resolve to a single declaration. 9825 if (Matched) { 9826 if (Complain) { 9827 Diag(ovl->getExprLoc(), diag::err_addr_ovl_ambiguous) 9828 << ovl->getName(); 9829 NoteAllOverloadCandidates(ovl); 9830 } 9831 return 0; 9832 } 9833 9834 Matched = Specialization; 9835 if (FoundResult) *FoundResult = I.getPair(); 9836 } 9837 9838 if (Matched && getLangOpts().CPlusPlus1y && 9839 Matched->getResultType()->isUndeducedType() && 9840 DeduceReturnType(Matched, ovl->getExprLoc(), Complain)) 9841 return 0; 9842 9843 return Matched; 9844} 9845 9846 9847 9848 9849// Resolve and fix an overloaded expression that can be resolved 9850// because it identifies a single function template specialization. 9851// 9852// Last three arguments should only be supplied if Complain = true 9853// 9854// Return true if it was logically possible to so resolve the 9855// expression, regardless of whether or not it succeeded. Always 9856// returns true if 'complain' is set. 9857bool Sema::ResolveAndFixSingleFunctionTemplateSpecialization( 9858 ExprResult &SrcExpr, bool doFunctionPointerConverion, 9859 bool complain, const SourceRange& OpRangeForComplaining, 9860 QualType DestTypeForComplaining, 9861 unsigned DiagIDForComplaining) { 9862 assert(SrcExpr.get()->getType() == Context.OverloadTy); 9863 9864 OverloadExpr::FindResult ovl = OverloadExpr::find(SrcExpr.get()); 9865 9866 DeclAccessPair found; 9867 ExprResult SingleFunctionExpression; 9868 if (FunctionDecl *fn = ResolveSingleFunctionTemplateSpecialization( 9869 ovl.Expression, /*complain*/ false, &found)) { 9870 if (DiagnoseUseOfDecl(fn, SrcExpr.get()->getLocStart())) { 9871 SrcExpr = ExprError(); 9872 return true; 9873 } 9874 9875 // It is only correct to resolve to an instance method if we're 9876 // resolving a form that's permitted to be a pointer to member. 9877 // Otherwise we'll end up making a bound member expression, which 9878 // is illegal in all the contexts we resolve like this. 9879 if (!ovl.HasFormOfMemberPointer && 9880 isa<CXXMethodDecl>(fn) && 9881 cast<CXXMethodDecl>(fn)->isInstance()) { 9882 if (!complain) return false; 9883 9884 Diag(ovl.Expression->getExprLoc(), 9885 diag::err_bound_member_function) 9886 << 0 << ovl.Expression->getSourceRange(); 9887 9888 // TODO: I believe we only end up here if there's a mix of 9889 // static and non-static candidates (otherwise the expression 9890 // would have 'bound member' type, not 'overload' type). 9891 // Ideally we would note which candidate was chosen and why 9892 // the static candidates were rejected. 9893 SrcExpr = ExprError(); 9894 return true; 9895 } 9896 9897 // Fix the expression to refer to 'fn'. 9898 SingleFunctionExpression = 9899 Owned(FixOverloadedFunctionReference(SrcExpr.take(), found, fn)); 9900 9901 // If desired, do function-to-pointer decay. 9902 if (doFunctionPointerConverion) { 9903 SingleFunctionExpression = 9904 DefaultFunctionArrayLvalueConversion(SingleFunctionExpression.take()); 9905 if (SingleFunctionExpression.isInvalid()) { 9906 SrcExpr = ExprError(); 9907 return true; 9908 } 9909 } 9910 } 9911 9912 if (!SingleFunctionExpression.isUsable()) { 9913 if (complain) { 9914 Diag(OpRangeForComplaining.getBegin(), DiagIDForComplaining) 9915 << ovl.Expression->getName() 9916 << DestTypeForComplaining 9917 << OpRangeForComplaining 9918 << ovl.Expression->getQualifierLoc().getSourceRange(); 9919 NoteAllOverloadCandidates(SrcExpr.get()); 9920 9921 SrcExpr = ExprError(); 9922 return true; 9923 } 9924 9925 return false; 9926 } 9927 9928 SrcExpr = SingleFunctionExpression; 9929 return true; 9930} 9931 9932/// \brief Add a single candidate to the overload set. 9933static void AddOverloadedCallCandidate(Sema &S, 9934 DeclAccessPair FoundDecl, 9935 TemplateArgumentListInfo *ExplicitTemplateArgs, 9936 ArrayRef<Expr *> Args, 9937 OverloadCandidateSet &CandidateSet, 9938 bool PartialOverloading, 9939 bool KnownValid) { 9940 NamedDecl *Callee = FoundDecl.getDecl(); 9941 if (isa<UsingShadowDecl>(Callee)) 9942 Callee = cast<UsingShadowDecl>(Callee)->getTargetDecl(); 9943 9944 if (FunctionDecl *Func = dyn_cast<FunctionDecl>(Callee)) { 9945 if (ExplicitTemplateArgs) { 9946 assert(!KnownValid && "Explicit template arguments?"); 9947 return; 9948 } 9949 S.AddOverloadCandidate(Func, FoundDecl, Args, CandidateSet, false, 9950 PartialOverloading); 9951 return; 9952 } 9953 9954 if (FunctionTemplateDecl *FuncTemplate 9955 = dyn_cast<FunctionTemplateDecl>(Callee)) { 9956 S.AddTemplateOverloadCandidate(FuncTemplate, FoundDecl, 9957 ExplicitTemplateArgs, Args, CandidateSet); 9958 return; 9959 } 9960 9961 assert(!KnownValid && "unhandled case in overloaded call candidate"); 9962} 9963 9964/// \brief Add the overload candidates named by callee and/or found by argument 9965/// dependent lookup to the given overload set. 9966void Sema::AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE, 9967 ArrayRef<Expr *> Args, 9968 OverloadCandidateSet &CandidateSet, 9969 bool PartialOverloading) { 9970 9971#ifndef NDEBUG 9972 // Verify that ArgumentDependentLookup is consistent with the rules 9973 // in C++0x [basic.lookup.argdep]p3: 9974 // 9975 // Let X be the lookup set produced by unqualified lookup (3.4.1) 9976 // and let Y be the lookup set produced by argument dependent 9977 // lookup (defined as follows). If X contains 9978 // 9979 // -- a declaration of a class member, or 9980 // 9981 // -- a block-scope function declaration that is not a 9982 // using-declaration, or 9983 // 9984 // -- a declaration that is neither a function or a function 9985 // template 9986 // 9987 // then Y is empty. 9988 9989 if (ULE->requiresADL()) { 9990 for (UnresolvedLookupExpr::decls_iterator I = ULE->decls_begin(), 9991 E = ULE->decls_end(); I != E; ++I) { 9992 assert(!(*I)->getDeclContext()->isRecord()); 9993 assert(isa<UsingShadowDecl>(*I) || 9994 !(*I)->getDeclContext()->isFunctionOrMethod()); 9995 assert((*I)->getUnderlyingDecl()->isFunctionOrFunctionTemplate()); 9996 } 9997 } 9998#endif 9999 10000 // It would be nice to avoid this copy. 10001 TemplateArgumentListInfo TABuffer; 10002 TemplateArgumentListInfo *ExplicitTemplateArgs = 0; 10003 if (ULE->hasExplicitTemplateArgs()) { 10004 ULE->copyTemplateArgumentsInto(TABuffer); 10005 ExplicitTemplateArgs = &TABuffer; 10006 } 10007 10008 for (UnresolvedLookupExpr::decls_iterator I = ULE->decls_begin(), 10009 E = ULE->decls_end(); I != E; ++I) 10010 AddOverloadedCallCandidate(*this, I.getPair(), ExplicitTemplateArgs, Args, 10011 CandidateSet, PartialOverloading, 10012 /*KnownValid*/ true); 10013 10014 if (ULE->requiresADL()) 10015 AddArgumentDependentLookupCandidates(ULE->getName(), /*Operator*/ false, 10016 ULE->getExprLoc(), 10017 Args, ExplicitTemplateArgs, 10018 CandidateSet, PartialOverloading); 10019} 10020 10021/// Determine whether a declaration with the specified name could be moved into 10022/// a different namespace. 10023static bool canBeDeclaredInNamespace(const DeclarationName &Name) { 10024 switch (Name.getCXXOverloadedOperator()) { 10025 case OO_New: case OO_Array_New: 10026 case OO_Delete: case OO_Array_Delete: 10027 return false; 10028 10029 default: 10030 return true; 10031 } 10032} 10033 10034/// Attempt to recover from an ill-formed use of a non-dependent name in a 10035/// template, where the non-dependent name was declared after the template 10036/// was defined. This is common in code written for a compilers which do not 10037/// correctly implement two-stage name lookup. 10038/// 10039/// Returns true if a viable candidate was found and a diagnostic was issued. 10040static bool 10041DiagnoseTwoPhaseLookup(Sema &SemaRef, SourceLocation FnLoc, 10042 const CXXScopeSpec &SS, LookupResult &R, 10043 TemplateArgumentListInfo *ExplicitTemplateArgs, 10044 ArrayRef<Expr *> Args) { 10045 if (SemaRef.ActiveTemplateInstantiations.empty() || !SS.isEmpty()) 10046 return false; 10047 10048 for (DeclContext *DC = SemaRef.CurContext; DC; DC = DC->getParent()) { 10049 if (DC->isTransparentContext()) 10050 continue; 10051 10052 SemaRef.LookupQualifiedName(R, DC); 10053 10054 if (!R.empty()) { 10055 R.suppressDiagnostics(); 10056 10057 if (isa<CXXRecordDecl>(DC)) { 10058 // Don't diagnose names we find in classes; we get much better 10059 // diagnostics for these from DiagnoseEmptyLookup. 10060 R.clear(); 10061 return false; 10062 } 10063 10064 OverloadCandidateSet Candidates(FnLoc); 10065 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) 10066 AddOverloadedCallCandidate(SemaRef, I.getPair(), 10067 ExplicitTemplateArgs, Args, 10068 Candidates, false, /*KnownValid*/ false); 10069 10070 OverloadCandidateSet::iterator Best; 10071 if (Candidates.BestViableFunction(SemaRef, FnLoc, Best) != OR_Success) { 10072 // No viable functions. Don't bother the user with notes for functions 10073 // which don't work and shouldn't be found anyway. 10074 R.clear(); 10075 return false; 10076 } 10077 10078 // Find the namespaces where ADL would have looked, and suggest 10079 // declaring the function there instead. 10080 Sema::AssociatedNamespaceSet AssociatedNamespaces; 10081 Sema::AssociatedClassSet AssociatedClasses; 10082 SemaRef.FindAssociatedClassesAndNamespaces(FnLoc, Args, 10083 AssociatedNamespaces, 10084 AssociatedClasses); 10085 Sema::AssociatedNamespaceSet SuggestedNamespaces; 10086 if (canBeDeclaredInNamespace(R.getLookupName())) { 10087 DeclContext *Std = SemaRef.getStdNamespace(); 10088 for (Sema::AssociatedNamespaceSet::iterator 10089 it = AssociatedNamespaces.begin(), 10090 end = AssociatedNamespaces.end(); it != end; ++it) { 10091 // Never suggest declaring a function within namespace 'std'. 10092 if (Std && Std->Encloses(*it)) 10093 continue; 10094 10095 // Never suggest declaring a function within a namespace with a 10096 // reserved name, like __gnu_cxx. 10097 NamespaceDecl *NS = dyn_cast<NamespaceDecl>(*it); 10098 if (NS && 10099 NS->getQualifiedNameAsString().find("__") != std::string::npos) 10100 continue; 10101 10102 SuggestedNamespaces.insert(*it); 10103 } 10104 } 10105 10106 SemaRef.Diag(R.getNameLoc(), diag::err_not_found_by_two_phase_lookup) 10107 << R.getLookupName(); 10108 if (SuggestedNamespaces.empty()) { 10109 SemaRef.Diag(Best->Function->getLocation(), 10110 diag::note_not_found_by_two_phase_lookup) 10111 << R.getLookupName() << 0; 10112 } else if (SuggestedNamespaces.size() == 1) { 10113 SemaRef.Diag(Best->Function->getLocation(), 10114 diag::note_not_found_by_two_phase_lookup) 10115 << R.getLookupName() << 1 << *SuggestedNamespaces.begin(); 10116 } else { 10117 // FIXME: It would be useful to list the associated namespaces here, 10118 // but the diagnostics infrastructure doesn't provide a way to produce 10119 // a localized representation of a list of items. 10120 SemaRef.Diag(Best->Function->getLocation(), 10121 diag::note_not_found_by_two_phase_lookup) 10122 << R.getLookupName() << 2; 10123 } 10124 10125 // Try to recover by calling this function. 10126 return true; 10127 } 10128 10129 R.clear(); 10130 } 10131 10132 return false; 10133} 10134 10135/// Attempt to recover from ill-formed use of a non-dependent operator in a 10136/// template, where the non-dependent operator was declared after the template 10137/// was defined. 10138/// 10139/// Returns true if a viable candidate was found and a diagnostic was issued. 10140static bool 10141DiagnoseTwoPhaseOperatorLookup(Sema &SemaRef, OverloadedOperatorKind Op, 10142 SourceLocation OpLoc, 10143 ArrayRef<Expr *> Args) { 10144 DeclarationName OpName = 10145 SemaRef.Context.DeclarationNames.getCXXOperatorName(Op); 10146 LookupResult R(SemaRef, OpName, OpLoc, Sema::LookupOperatorName); 10147 return DiagnoseTwoPhaseLookup(SemaRef, OpLoc, CXXScopeSpec(), R, 10148 /*ExplicitTemplateArgs=*/0, Args); 10149} 10150 10151namespace { 10152class BuildRecoveryCallExprRAII { 10153 Sema &SemaRef; 10154public: 10155 BuildRecoveryCallExprRAII(Sema &S) : SemaRef(S) { 10156 assert(SemaRef.IsBuildingRecoveryCallExpr == false); 10157 SemaRef.IsBuildingRecoveryCallExpr = true; 10158 } 10159 10160 ~BuildRecoveryCallExprRAII() { 10161 SemaRef.IsBuildingRecoveryCallExpr = false; 10162 } 10163}; 10164 10165} 10166 10167/// Attempts to recover from a call where no functions were found. 10168/// 10169/// Returns true if new candidates were found. 10170static ExprResult 10171BuildRecoveryCallExpr(Sema &SemaRef, Scope *S, Expr *Fn, 10172 UnresolvedLookupExpr *ULE, 10173 SourceLocation LParenLoc, 10174 llvm::MutableArrayRef<Expr *> Args, 10175 SourceLocation RParenLoc, 10176 bool EmptyLookup, bool AllowTypoCorrection) { 10177 // Do not try to recover if it is already building a recovery call. 10178 // This stops infinite loops for template instantiations like 10179 // 10180 // template <typename T> auto foo(T t) -> decltype(foo(t)) {} 10181 // template <typename T> auto foo(T t) -> decltype(foo(&t)) {} 10182 // 10183 if (SemaRef.IsBuildingRecoveryCallExpr) 10184 return ExprError(); 10185 BuildRecoveryCallExprRAII RCE(SemaRef); 10186 10187 CXXScopeSpec SS; 10188 SS.Adopt(ULE->getQualifierLoc()); 10189 SourceLocation TemplateKWLoc = ULE->getTemplateKeywordLoc(); 10190 10191 TemplateArgumentListInfo TABuffer; 10192 TemplateArgumentListInfo *ExplicitTemplateArgs = 0; 10193 if (ULE->hasExplicitTemplateArgs()) { 10194 ULE->copyTemplateArgumentsInto(TABuffer); 10195 ExplicitTemplateArgs = &TABuffer; 10196 } 10197 10198 LookupResult R(SemaRef, ULE->getName(), ULE->getNameLoc(), 10199 Sema::LookupOrdinaryName); 10200 FunctionCallFilterCCC Validator(SemaRef, Args.size(), 10201 ExplicitTemplateArgs != 0); 10202 NoTypoCorrectionCCC RejectAll; 10203 CorrectionCandidateCallback *CCC = AllowTypoCorrection ? 10204 (CorrectionCandidateCallback*)&Validator : 10205 (CorrectionCandidateCallback*)&RejectAll; 10206 if (!DiagnoseTwoPhaseLookup(SemaRef, Fn->getExprLoc(), SS, R, 10207 ExplicitTemplateArgs, Args) && 10208 (!EmptyLookup || 10209 SemaRef.DiagnoseEmptyLookup(S, SS, R, *CCC, 10210 ExplicitTemplateArgs, Args))) 10211 return ExprError(); 10212 10213 assert(!R.empty() && "lookup results empty despite recovery"); 10214 10215 // Build an implicit member call if appropriate. Just drop the 10216 // casts and such from the call, we don't really care. 10217 ExprResult NewFn = ExprError(); 10218 if ((*R.begin())->isCXXClassMember()) 10219 NewFn = SemaRef.BuildPossibleImplicitMemberExpr(SS, TemplateKWLoc, 10220 R, ExplicitTemplateArgs); 10221 else if (ExplicitTemplateArgs || TemplateKWLoc.isValid()) 10222 NewFn = SemaRef.BuildTemplateIdExpr(SS, TemplateKWLoc, R, false, 10223 ExplicitTemplateArgs); 10224 else 10225 NewFn = SemaRef.BuildDeclarationNameExpr(SS, R, false); 10226 10227 if (NewFn.isInvalid()) 10228 return ExprError(); 10229 10230 // This shouldn't cause an infinite loop because we're giving it 10231 // an expression with viable lookup results, which should never 10232 // end up here. 10233 return SemaRef.ActOnCallExpr(/*Scope*/ 0, NewFn.take(), LParenLoc, 10234 MultiExprArg(Args.data(), Args.size()), 10235 RParenLoc); 10236} 10237 10238/// \brief Constructs and populates an OverloadedCandidateSet from 10239/// the given function. 10240/// \returns true when an the ExprResult output parameter has been set. 10241bool Sema::buildOverloadedCallSet(Scope *S, Expr *Fn, 10242 UnresolvedLookupExpr *ULE, 10243 MultiExprArg Args, 10244 SourceLocation RParenLoc, 10245 OverloadCandidateSet *CandidateSet, 10246 ExprResult *Result) { 10247#ifndef NDEBUG 10248 if (ULE->requiresADL()) { 10249 // To do ADL, we must have found an unqualified name. 10250 assert(!ULE->getQualifier() && "qualified name with ADL"); 10251 10252 // We don't perform ADL for implicit declarations of builtins. 10253 // Verify that this was correctly set up. 10254 FunctionDecl *F; 10255 if (ULE->decls_begin() + 1 == ULE->decls_end() && 10256 (F = dyn_cast<FunctionDecl>(*ULE->decls_begin())) && 10257 F->getBuiltinID() && F->isImplicit()) 10258 llvm_unreachable("performing ADL for builtin"); 10259 10260 // We don't perform ADL in C. 10261 assert(getLangOpts().CPlusPlus && "ADL enabled in C"); 10262 } 10263#endif 10264 10265 UnbridgedCastsSet UnbridgedCasts; 10266 if (checkArgPlaceholdersForOverload(*this, Args, UnbridgedCasts)) { 10267 *Result = ExprError(); 10268 return true; 10269 } 10270 10271 // Add the functions denoted by the callee to the set of candidate 10272 // functions, including those from argument-dependent lookup. 10273 AddOverloadedCallCandidates(ULE, Args, *CandidateSet); 10274 10275 // If we found nothing, try to recover. 10276 // BuildRecoveryCallExpr diagnoses the error itself, so we just bail 10277 // out if it fails. 10278 if (CandidateSet->empty()) { 10279 // In Microsoft mode, if we are inside a template class member function then 10280 // create a type dependent CallExpr. The goal is to postpone name lookup 10281 // to instantiation time to be able to search into type dependent base 10282 // classes. 10283 if (getLangOpts().MicrosoftMode && CurContext->isDependentContext() && 10284 (isa<FunctionDecl>(CurContext) || isa<CXXRecordDecl>(CurContext))) { 10285 CallExpr *CE = new (Context) CallExpr(Context, Fn, Args, 10286 Context.DependentTy, VK_RValue, 10287 RParenLoc); 10288 CE->setTypeDependent(true); 10289 *Result = Owned(CE); 10290 return true; 10291 } 10292 return false; 10293 } 10294 10295 UnbridgedCasts.restore(); 10296 return false; 10297} 10298 10299/// FinishOverloadedCallExpr - given an OverloadCandidateSet, builds and returns 10300/// the completed call expression. If overload resolution fails, emits 10301/// diagnostics and returns ExprError() 10302static ExprResult FinishOverloadedCallExpr(Sema &SemaRef, Scope *S, Expr *Fn, 10303 UnresolvedLookupExpr *ULE, 10304 SourceLocation LParenLoc, 10305 MultiExprArg Args, 10306 SourceLocation RParenLoc, 10307 Expr *ExecConfig, 10308 OverloadCandidateSet *CandidateSet, 10309 OverloadCandidateSet::iterator *Best, 10310 OverloadingResult OverloadResult, 10311 bool AllowTypoCorrection) { 10312 if (CandidateSet->empty()) 10313 return BuildRecoveryCallExpr(SemaRef, S, Fn, ULE, LParenLoc, Args, 10314 RParenLoc, /*EmptyLookup=*/true, 10315 AllowTypoCorrection); 10316 10317 switch (OverloadResult) { 10318 case OR_Success: { 10319 FunctionDecl *FDecl = (*Best)->Function; 10320 SemaRef.CheckUnresolvedLookupAccess(ULE, (*Best)->FoundDecl); 10321 if (SemaRef.DiagnoseUseOfDecl(FDecl, ULE->getNameLoc())) 10322 return ExprError(); 10323 Fn = SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl); 10324 return SemaRef.BuildResolvedCallExpr(Fn, FDecl, LParenLoc, Args, RParenLoc, 10325 ExecConfig); 10326 } 10327 10328 case OR_No_Viable_Function: { 10329 // Try to recover by looking for viable functions which the user might 10330 // have meant to call. 10331 ExprResult Recovery = BuildRecoveryCallExpr(SemaRef, S, Fn, ULE, LParenLoc, 10332 Args, RParenLoc, 10333 /*EmptyLookup=*/false, 10334 AllowTypoCorrection); 10335 if (!Recovery.isInvalid()) 10336 return Recovery; 10337 10338 SemaRef.Diag(Fn->getLocStart(), 10339 diag::err_ovl_no_viable_function_in_call) 10340 << ULE->getName() << Fn->getSourceRange(); 10341 CandidateSet->NoteCandidates(SemaRef, OCD_AllCandidates, Args); 10342 break; 10343 } 10344 10345 case OR_Ambiguous: 10346 SemaRef.Diag(Fn->getLocStart(), diag::err_ovl_ambiguous_call) 10347 << ULE->getName() << Fn->getSourceRange(); 10348 CandidateSet->NoteCandidates(SemaRef, OCD_ViableCandidates, Args); 10349 break; 10350 10351 case OR_Deleted: { 10352 SemaRef.Diag(Fn->getLocStart(), diag::err_ovl_deleted_call) 10353 << (*Best)->Function->isDeleted() 10354 << ULE->getName() 10355 << SemaRef.getDeletedOrUnavailableSuffix((*Best)->Function) 10356 << Fn->getSourceRange(); 10357 CandidateSet->NoteCandidates(SemaRef, OCD_AllCandidates, Args); 10358 10359 // We emitted an error for the unvailable/deleted function call but keep 10360 // the call in the AST. 10361 FunctionDecl *FDecl = (*Best)->Function; 10362 Fn = SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl); 10363 return SemaRef.BuildResolvedCallExpr(Fn, FDecl, LParenLoc, Args, RParenLoc, 10364 ExecConfig); 10365 } 10366 } 10367 10368 // Overload resolution failed. 10369 return ExprError(); 10370} 10371 10372/// BuildOverloadedCallExpr - Given the call expression that calls Fn 10373/// (which eventually refers to the declaration Func) and the call 10374/// arguments Args/NumArgs, attempt to resolve the function call down 10375/// to a specific function. If overload resolution succeeds, returns 10376/// the call expression produced by overload resolution. 10377/// Otherwise, emits diagnostics and returns ExprError. 10378ExprResult Sema::BuildOverloadedCallExpr(Scope *S, Expr *Fn, 10379 UnresolvedLookupExpr *ULE, 10380 SourceLocation LParenLoc, 10381 MultiExprArg Args, 10382 SourceLocation RParenLoc, 10383 Expr *ExecConfig, 10384 bool AllowTypoCorrection) { 10385 OverloadCandidateSet CandidateSet(Fn->getExprLoc()); 10386 ExprResult result; 10387 10388 if (buildOverloadedCallSet(S, Fn, ULE, Args, LParenLoc, &CandidateSet, 10389 &result)) 10390 return result; 10391 10392 OverloadCandidateSet::iterator Best; 10393 OverloadingResult OverloadResult = 10394 CandidateSet.BestViableFunction(*this, Fn->getLocStart(), Best); 10395 10396 return FinishOverloadedCallExpr(*this, S, Fn, ULE, LParenLoc, Args, 10397 RParenLoc, ExecConfig, &CandidateSet, 10398 &Best, OverloadResult, 10399 AllowTypoCorrection); 10400} 10401 10402static bool IsOverloaded(const UnresolvedSetImpl &Functions) { 10403 return Functions.size() > 1 || 10404 (Functions.size() == 1 && isa<FunctionTemplateDecl>(*Functions.begin())); 10405} 10406 10407/// \brief Create a unary operation that may resolve to an overloaded 10408/// operator. 10409/// 10410/// \param OpLoc The location of the operator itself (e.g., '*'). 10411/// 10412/// \param OpcIn The UnaryOperator::Opcode that describes this 10413/// operator. 10414/// 10415/// \param Fns The set of non-member functions that will be 10416/// considered by overload resolution. The caller needs to build this 10417/// set based on the context using, e.g., 10418/// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This 10419/// set should not contain any member functions; those will be added 10420/// by CreateOverloadedUnaryOp(). 10421/// 10422/// \param Input The input argument. 10423ExprResult 10424Sema::CreateOverloadedUnaryOp(SourceLocation OpLoc, unsigned OpcIn, 10425 const UnresolvedSetImpl &Fns, 10426 Expr *Input) { 10427 UnaryOperator::Opcode Opc = static_cast<UnaryOperator::Opcode>(OpcIn); 10428 10429 OverloadedOperatorKind Op = UnaryOperator::getOverloadedOperator(Opc); 10430 assert(Op != OO_None && "Invalid opcode for overloaded unary operator"); 10431 DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op); 10432 // TODO: provide better source location info. 10433 DeclarationNameInfo OpNameInfo(OpName, OpLoc); 10434 10435 if (checkPlaceholderForOverload(*this, Input)) 10436 return ExprError(); 10437 10438 Expr *Args[2] = { Input, 0 }; 10439 unsigned NumArgs = 1; 10440 10441 // For post-increment and post-decrement, add the implicit '0' as 10442 // the second argument, so that we know this is a post-increment or 10443 // post-decrement. 10444 if (Opc == UO_PostInc || Opc == UO_PostDec) { 10445 llvm::APSInt Zero(Context.getTypeSize(Context.IntTy), false); 10446 Args[1] = IntegerLiteral::Create(Context, Zero, Context.IntTy, 10447 SourceLocation()); 10448 NumArgs = 2; 10449 } 10450 10451 ArrayRef<Expr *> ArgsArray(Args, NumArgs); 10452 10453 if (Input->isTypeDependent()) { 10454 if (Fns.empty()) 10455 return Owned(new (Context) UnaryOperator(Input, 10456 Opc, 10457 Context.DependentTy, 10458 VK_RValue, OK_Ordinary, 10459 OpLoc)); 10460 10461 CXXRecordDecl *NamingClass = 0; // because lookup ignores member operators 10462 UnresolvedLookupExpr *Fn 10463 = UnresolvedLookupExpr::Create(Context, NamingClass, 10464 NestedNameSpecifierLoc(), OpNameInfo, 10465 /*ADL*/ true, IsOverloaded(Fns), 10466 Fns.begin(), Fns.end()); 10467 return Owned(new (Context) CXXOperatorCallExpr(Context, Op, Fn, ArgsArray, 10468 Context.DependentTy, 10469 VK_RValue, 10470 OpLoc, false)); 10471 } 10472 10473 // Build an empty overload set. 10474 OverloadCandidateSet CandidateSet(OpLoc); 10475 10476 // Add the candidates from the given function set. 10477 AddFunctionCandidates(Fns, ArgsArray, CandidateSet, false); 10478 10479 // Add operator candidates that are member functions. 10480 AddMemberOperatorCandidates(Op, OpLoc, ArgsArray, CandidateSet); 10481 10482 // Add candidates from ADL. 10483 AddArgumentDependentLookupCandidates(OpName, /*Operator*/ true, OpLoc, 10484 ArgsArray, /*ExplicitTemplateArgs*/ 0, 10485 CandidateSet); 10486 10487 // Add builtin operator candidates. 10488 AddBuiltinOperatorCandidates(Op, OpLoc, ArgsArray, CandidateSet); 10489 10490 bool HadMultipleCandidates = (CandidateSet.size() > 1); 10491 10492 // Perform overload resolution. 10493 OverloadCandidateSet::iterator Best; 10494 switch (CandidateSet.BestViableFunction(*this, OpLoc, Best)) { 10495 case OR_Success: { 10496 // We found a built-in operator or an overloaded operator. 10497 FunctionDecl *FnDecl = Best->Function; 10498 10499 if (FnDecl) { 10500 // We matched an overloaded operator. Build a call to that 10501 // operator. 10502 10503 // Convert the arguments. 10504 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) { 10505 CheckMemberOperatorAccess(OpLoc, Args[0], 0, Best->FoundDecl); 10506 10507 ExprResult InputRes = 10508 PerformObjectArgumentInitialization(Input, /*Qualifier=*/0, 10509 Best->FoundDecl, Method); 10510 if (InputRes.isInvalid()) 10511 return ExprError(); 10512 Input = InputRes.take(); 10513 } else { 10514 // Convert the arguments. 10515 ExprResult InputInit 10516 = PerformCopyInitialization(InitializedEntity::InitializeParameter( 10517 Context, 10518 FnDecl->getParamDecl(0)), 10519 SourceLocation(), 10520 Input); 10521 if (InputInit.isInvalid()) 10522 return ExprError(); 10523 Input = InputInit.take(); 10524 } 10525 10526 // Build the actual expression node. 10527 ExprResult FnExpr = CreateFunctionRefExpr(*this, FnDecl, Best->FoundDecl, 10528 HadMultipleCandidates, OpLoc); 10529 if (FnExpr.isInvalid()) 10530 return ExprError(); 10531 10532 // Determine the result type. 10533 QualType ResultTy = FnDecl->getResultType(); 10534 ExprValueKind VK = Expr::getValueKindForType(ResultTy); 10535 ResultTy = ResultTy.getNonLValueExprType(Context); 10536 10537 Args[0] = Input; 10538 CallExpr *TheCall = 10539 new (Context) CXXOperatorCallExpr(Context, Op, FnExpr.take(), ArgsArray, 10540 ResultTy, VK, OpLoc, false); 10541 10542 if (CheckCallReturnType(FnDecl->getResultType(), OpLoc, TheCall, 10543 FnDecl)) 10544 return ExprError(); 10545 10546 return MaybeBindToTemporary(TheCall); 10547 } else { 10548 // We matched a built-in operator. Convert the arguments, then 10549 // break out so that we will build the appropriate built-in 10550 // operator node. 10551 ExprResult InputRes = 10552 PerformImplicitConversion(Input, Best->BuiltinTypes.ParamTypes[0], 10553 Best->Conversions[0], AA_Passing); 10554 if (InputRes.isInvalid()) 10555 return ExprError(); 10556 Input = InputRes.take(); 10557 break; 10558 } 10559 } 10560 10561 case OR_No_Viable_Function: 10562 // This is an erroneous use of an operator which can be overloaded by 10563 // a non-member function. Check for non-member operators which were 10564 // defined too late to be candidates. 10565 if (DiagnoseTwoPhaseOperatorLookup(*this, Op, OpLoc, ArgsArray)) 10566 // FIXME: Recover by calling the found function. 10567 return ExprError(); 10568 10569 // No viable function; fall through to handling this as a 10570 // built-in operator, which will produce an error message for us. 10571 break; 10572 10573 case OR_Ambiguous: 10574 Diag(OpLoc, diag::err_ovl_ambiguous_oper_unary) 10575 << UnaryOperator::getOpcodeStr(Opc) 10576 << Input->getType() 10577 << Input->getSourceRange(); 10578 CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, ArgsArray, 10579 UnaryOperator::getOpcodeStr(Opc), OpLoc); 10580 return ExprError(); 10581 10582 case OR_Deleted: 10583 Diag(OpLoc, diag::err_ovl_deleted_oper) 10584 << Best->Function->isDeleted() 10585 << UnaryOperator::getOpcodeStr(Opc) 10586 << getDeletedOrUnavailableSuffix(Best->Function) 10587 << Input->getSourceRange(); 10588 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, ArgsArray, 10589 UnaryOperator::getOpcodeStr(Opc), OpLoc); 10590 return ExprError(); 10591 } 10592 10593 // Either we found no viable overloaded operator or we matched a 10594 // built-in operator. In either case, fall through to trying to 10595 // build a built-in operation. 10596 return CreateBuiltinUnaryOp(OpLoc, Opc, Input); 10597} 10598 10599/// \brief Create a binary operation that may resolve to an overloaded 10600/// operator. 10601/// 10602/// \param OpLoc The location of the operator itself (e.g., '+'). 10603/// 10604/// \param OpcIn The BinaryOperator::Opcode that describes this 10605/// operator. 10606/// 10607/// \param Fns The set of non-member functions that will be 10608/// considered by overload resolution. The caller needs to build this 10609/// set based on the context using, e.g., 10610/// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This 10611/// set should not contain any member functions; those will be added 10612/// by CreateOverloadedBinOp(). 10613/// 10614/// \param LHS Left-hand argument. 10615/// \param RHS Right-hand argument. 10616ExprResult 10617Sema::CreateOverloadedBinOp(SourceLocation OpLoc, 10618 unsigned OpcIn, 10619 const UnresolvedSetImpl &Fns, 10620 Expr *LHS, Expr *RHS) { 10621 Expr *Args[2] = { LHS, RHS }; 10622 LHS=RHS=0; //Please use only Args instead of LHS/RHS couple 10623 10624 BinaryOperator::Opcode Opc = static_cast<BinaryOperator::Opcode>(OpcIn); 10625 OverloadedOperatorKind Op = BinaryOperator::getOverloadedOperator(Opc); 10626 DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op); 10627 10628 // If either side is type-dependent, create an appropriate dependent 10629 // expression. 10630 if (Args[0]->isTypeDependent() || Args[1]->isTypeDependent()) { 10631 if (Fns.empty()) { 10632 // If there are no functions to store, just build a dependent 10633 // BinaryOperator or CompoundAssignment. 10634 if (Opc <= BO_Assign || Opc > BO_OrAssign) 10635 return Owned(new (Context) BinaryOperator(Args[0], Args[1], Opc, 10636 Context.DependentTy, 10637 VK_RValue, OK_Ordinary, 10638 OpLoc, 10639 FPFeatures.fp_contract)); 10640 10641 return Owned(new (Context) CompoundAssignOperator(Args[0], Args[1], Opc, 10642 Context.DependentTy, 10643 VK_LValue, 10644 OK_Ordinary, 10645 Context.DependentTy, 10646 Context.DependentTy, 10647 OpLoc, 10648 FPFeatures.fp_contract)); 10649 } 10650 10651 // FIXME: save results of ADL from here? 10652 CXXRecordDecl *NamingClass = 0; // because lookup ignores member operators 10653 // TODO: provide better source location info in DNLoc component. 10654 DeclarationNameInfo OpNameInfo(OpName, OpLoc); 10655 UnresolvedLookupExpr *Fn 10656 = UnresolvedLookupExpr::Create(Context, NamingClass, 10657 NestedNameSpecifierLoc(), OpNameInfo, 10658 /*ADL*/ true, IsOverloaded(Fns), 10659 Fns.begin(), Fns.end()); 10660 return Owned(new (Context) CXXOperatorCallExpr(Context, Op, Fn, Args, 10661 Context.DependentTy, VK_RValue, 10662 OpLoc, FPFeatures.fp_contract)); 10663 } 10664 10665 // Always do placeholder-like conversions on the RHS. 10666 if (checkPlaceholderForOverload(*this, Args[1])) 10667 return ExprError(); 10668 10669 // Do placeholder-like conversion on the LHS; note that we should 10670 // not get here with a PseudoObject LHS. 10671 assert(Args[0]->getObjectKind() != OK_ObjCProperty); 10672 if (checkPlaceholderForOverload(*this, Args[0])) 10673 return ExprError(); 10674 10675 // If this is the assignment operator, we only perform overload resolution 10676 // if the left-hand side is a class or enumeration type. This is actually 10677 // a hack. The standard requires that we do overload resolution between the 10678 // various built-in candidates, but as DR507 points out, this can lead to 10679 // problems. So we do it this way, which pretty much follows what GCC does. 10680 // Note that we go the traditional code path for compound assignment forms. 10681 if (Opc == BO_Assign && !Args[0]->getType()->isOverloadableType()) 10682 return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]); 10683 10684 // If this is the .* operator, which is not overloadable, just 10685 // create a built-in binary operator. 10686 if (Opc == BO_PtrMemD) 10687 return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]); 10688 10689 // Build an empty overload set. 10690 OverloadCandidateSet CandidateSet(OpLoc); 10691 10692 // Add the candidates from the given function set. 10693 AddFunctionCandidates(Fns, Args, CandidateSet, false); 10694 10695 // Add operator candidates that are member functions. 10696 AddMemberOperatorCandidates(Op, OpLoc, Args, CandidateSet); 10697 10698 // Add candidates from ADL. 10699 AddArgumentDependentLookupCandidates(OpName, /*Operator*/ true, 10700 OpLoc, Args, 10701 /*ExplicitTemplateArgs*/ 0, 10702 CandidateSet); 10703 10704 // Add builtin operator candidates. 10705 AddBuiltinOperatorCandidates(Op, OpLoc, Args, CandidateSet); 10706 10707 bool HadMultipleCandidates = (CandidateSet.size() > 1); 10708 10709 // Perform overload resolution. 10710 OverloadCandidateSet::iterator Best; 10711 switch (CandidateSet.BestViableFunction(*this, OpLoc, Best)) { 10712 case OR_Success: { 10713 // We found a built-in operator or an overloaded operator. 10714 FunctionDecl *FnDecl = Best->Function; 10715 10716 if (FnDecl) { 10717 // We matched an overloaded operator. Build a call to that 10718 // operator. 10719 10720 // Convert the arguments. 10721 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) { 10722 // Best->Access is only meaningful for class members. 10723 CheckMemberOperatorAccess(OpLoc, Args[0], Args[1], Best->FoundDecl); 10724 10725 ExprResult Arg1 = 10726 PerformCopyInitialization( 10727 InitializedEntity::InitializeParameter(Context, 10728 FnDecl->getParamDecl(0)), 10729 SourceLocation(), Owned(Args[1])); 10730 if (Arg1.isInvalid()) 10731 return ExprError(); 10732 10733 ExprResult Arg0 = 10734 PerformObjectArgumentInitialization(Args[0], /*Qualifier=*/0, 10735 Best->FoundDecl, Method); 10736 if (Arg0.isInvalid()) 10737 return ExprError(); 10738 Args[0] = Arg0.takeAs<Expr>(); 10739 Args[1] = RHS = Arg1.takeAs<Expr>(); 10740 } else { 10741 // Convert the arguments. 10742 ExprResult Arg0 = PerformCopyInitialization( 10743 InitializedEntity::InitializeParameter(Context, 10744 FnDecl->getParamDecl(0)), 10745 SourceLocation(), Owned(Args[0])); 10746 if (Arg0.isInvalid()) 10747 return ExprError(); 10748 10749 ExprResult Arg1 = 10750 PerformCopyInitialization( 10751 InitializedEntity::InitializeParameter(Context, 10752 FnDecl->getParamDecl(1)), 10753 SourceLocation(), Owned(Args[1])); 10754 if (Arg1.isInvalid()) 10755 return ExprError(); 10756 Args[0] = LHS = Arg0.takeAs<Expr>(); 10757 Args[1] = RHS = Arg1.takeAs<Expr>(); 10758 } 10759 10760 // Build the actual expression node. 10761 ExprResult FnExpr = CreateFunctionRefExpr(*this, FnDecl, 10762 Best->FoundDecl, 10763 HadMultipleCandidates, OpLoc); 10764 if (FnExpr.isInvalid()) 10765 return ExprError(); 10766 10767 // Determine the result type. 10768 QualType ResultTy = FnDecl->getResultType(); 10769 ExprValueKind VK = Expr::getValueKindForType(ResultTy); 10770 ResultTy = ResultTy.getNonLValueExprType(Context); 10771 10772 CXXOperatorCallExpr *TheCall = 10773 new (Context) CXXOperatorCallExpr(Context, Op, FnExpr.take(), 10774 Args, ResultTy, VK, OpLoc, 10775 FPFeatures.fp_contract); 10776 10777 if (CheckCallReturnType(FnDecl->getResultType(), OpLoc, TheCall, 10778 FnDecl)) 10779 return ExprError(); 10780 10781 ArrayRef<const Expr *> ArgsArray(Args, 2); 10782 // Cut off the implicit 'this'. 10783 if (isa<CXXMethodDecl>(FnDecl)) 10784 ArgsArray = ArgsArray.slice(1); 10785 checkCall(FnDecl, ArgsArray, 0, isa<CXXMethodDecl>(FnDecl), OpLoc, 10786 TheCall->getSourceRange(), VariadicDoesNotApply); 10787 10788 return MaybeBindToTemporary(TheCall); 10789 } else { 10790 // We matched a built-in operator. Convert the arguments, then 10791 // break out so that we will build the appropriate built-in 10792 // operator node. 10793 ExprResult ArgsRes0 = 10794 PerformImplicitConversion(Args[0], Best->BuiltinTypes.ParamTypes[0], 10795 Best->Conversions[0], AA_Passing); 10796 if (ArgsRes0.isInvalid()) 10797 return ExprError(); 10798 Args[0] = ArgsRes0.take(); 10799 10800 ExprResult ArgsRes1 = 10801 PerformImplicitConversion(Args[1], Best->BuiltinTypes.ParamTypes[1], 10802 Best->Conversions[1], AA_Passing); 10803 if (ArgsRes1.isInvalid()) 10804 return ExprError(); 10805 Args[1] = ArgsRes1.take(); 10806 break; 10807 } 10808 } 10809 10810 case OR_No_Viable_Function: { 10811 // C++ [over.match.oper]p9: 10812 // If the operator is the operator , [...] and there are no 10813 // viable functions, then the operator is assumed to be the 10814 // built-in operator and interpreted according to clause 5. 10815 if (Opc == BO_Comma) 10816 break; 10817 10818 // For class as left operand for assignment or compound assigment 10819 // operator do not fall through to handling in built-in, but report that 10820 // no overloaded assignment operator found 10821 ExprResult Result = ExprError(); 10822 if (Args[0]->getType()->isRecordType() && 10823 Opc >= BO_Assign && Opc <= BO_OrAssign) { 10824 Diag(OpLoc, diag::err_ovl_no_viable_oper) 10825 << BinaryOperator::getOpcodeStr(Opc) 10826 << Args[0]->getSourceRange() << Args[1]->getSourceRange(); 10827 if (Args[0]->getType()->isIncompleteType()) { 10828 Diag(OpLoc, diag::note_assign_lhs_incomplete) 10829 << Args[0]->getType() 10830 << Args[0]->getSourceRange() << Args[1]->getSourceRange(); 10831 } 10832 } else { 10833 // This is an erroneous use of an operator which can be overloaded by 10834 // a non-member function. Check for non-member operators which were 10835 // defined too late to be candidates. 10836 if (DiagnoseTwoPhaseOperatorLookup(*this, Op, OpLoc, Args)) 10837 // FIXME: Recover by calling the found function. 10838 return ExprError(); 10839 10840 // No viable function; try to create a built-in operation, which will 10841 // produce an error. Then, show the non-viable candidates. 10842 Result = CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]); 10843 } 10844 assert(Result.isInvalid() && 10845 "C++ binary operator overloading is missing candidates!"); 10846 if (Result.isInvalid()) 10847 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args, 10848 BinaryOperator::getOpcodeStr(Opc), OpLoc); 10849 return Result; 10850 } 10851 10852 case OR_Ambiguous: 10853 Diag(OpLoc, diag::err_ovl_ambiguous_oper_binary) 10854 << BinaryOperator::getOpcodeStr(Opc) 10855 << Args[0]->getType() << Args[1]->getType() 10856 << Args[0]->getSourceRange() << Args[1]->getSourceRange(); 10857 CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, Args, 10858 BinaryOperator::getOpcodeStr(Opc), OpLoc); 10859 return ExprError(); 10860 10861 case OR_Deleted: 10862 if (isImplicitlyDeleted(Best->Function)) { 10863 CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function); 10864 Diag(OpLoc, diag::err_ovl_deleted_special_oper) 10865 << Context.getRecordType(Method->getParent()) 10866 << getSpecialMember(Method); 10867 10868 // The user probably meant to call this special member. Just 10869 // explain why it's deleted. 10870 NoteDeletedFunction(Method); 10871 return ExprError(); 10872 } else { 10873 Diag(OpLoc, diag::err_ovl_deleted_oper) 10874 << Best->Function->isDeleted() 10875 << BinaryOperator::getOpcodeStr(Opc) 10876 << getDeletedOrUnavailableSuffix(Best->Function) 10877 << Args[0]->getSourceRange() << Args[1]->getSourceRange(); 10878 } 10879 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args, 10880 BinaryOperator::getOpcodeStr(Opc), OpLoc); 10881 return ExprError(); 10882 } 10883 10884 // We matched a built-in operator; build it. 10885 return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]); 10886} 10887 10888ExprResult 10889Sema::CreateOverloadedArraySubscriptExpr(SourceLocation LLoc, 10890 SourceLocation RLoc, 10891 Expr *Base, Expr *Idx) { 10892 Expr *Args[2] = { Base, Idx }; 10893 DeclarationName OpName = 10894 Context.DeclarationNames.getCXXOperatorName(OO_Subscript); 10895 10896 // If either side is type-dependent, create an appropriate dependent 10897 // expression. 10898 if (Args[0]->isTypeDependent() || Args[1]->isTypeDependent()) { 10899 10900 CXXRecordDecl *NamingClass = 0; // because lookup ignores member operators 10901 // CHECKME: no 'operator' keyword? 10902 DeclarationNameInfo OpNameInfo(OpName, LLoc); 10903 OpNameInfo.setCXXOperatorNameRange(SourceRange(LLoc, RLoc)); 10904 UnresolvedLookupExpr *Fn 10905 = UnresolvedLookupExpr::Create(Context, NamingClass, 10906 NestedNameSpecifierLoc(), OpNameInfo, 10907 /*ADL*/ true, /*Overloaded*/ false, 10908 UnresolvedSetIterator(), 10909 UnresolvedSetIterator()); 10910 // Can't add any actual overloads yet 10911 10912 return Owned(new (Context) CXXOperatorCallExpr(Context, OO_Subscript, Fn, 10913 Args, 10914 Context.DependentTy, 10915 VK_RValue, 10916 RLoc, false)); 10917 } 10918 10919 // Handle placeholders on both operands. 10920 if (checkPlaceholderForOverload(*this, Args[0])) 10921 return ExprError(); 10922 if (checkPlaceholderForOverload(*this, Args[1])) 10923 return ExprError(); 10924 10925 // Build an empty overload set. 10926 OverloadCandidateSet CandidateSet(LLoc); 10927 10928 // Subscript can only be overloaded as a member function. 10929 10930 // Add operator candidates that are member functions. 10931 AddMemberOperatorCandidates(OO_Subscript, LLoc, Args, CandidateSet); 10932 10933 // Add builtin operator candidates. 10934 AddBuiltinOperatorCandidates(OO_Subscript, LLoc, Args, CandidateSet); 10935 10936 bool HadMultipleCandidates = (CandidateSet.size() > 1); 10937 10938 // Perform overload resolution. 10939 OverloadCandidateSet::iterator Best; 10940 switch (CandidateSet.BestViableFunction(*this, LLoc, Best)) { 10941 case OR_Success: { 10942 // We found a built-in operator or an overloaded operator. 10943 FunctionDecl *FnDecl = Best->Function; 10944 10945 if (FnDecl) { 10946 // We matched an overloaded operator. Build a call to that 10947 // operator. 10948 10949 CheckMemberOperatorAccess(LLoc, Args[0], Args[1], Best->FoundDecl); 10950 10951 // Convert the arguments. 10952 CXXMethodDecl *Method = cast<CXXMethodDecl>(FnDecl); 10953 ExprResult Arg0 = 10954 PerformObjectArgumentInitialization(Args[0], /*Qualifier=*/0, 10955 Best->FoundDecl, Method); 10956 if (Arg0.isInvalid()) 10957 return ExprError(); 10958 Args[0] = Arg0.take(); 10959 10960 // Convert the arguments. 10961 ExprResult InputInit 10962 = PerformCopyInitialization(InitializedEntity::InitializeParameter( 10963 Context, 10964 FnDecl->getParamDecl(0)), 10965 SourceLocation(), 10966 Owned(Args[1])); 10967 if (InputInit.isInvalid()) 10968 return ExprError(); 10969 10970 Args[1] = InputInit.takeAs<Expr>(); 10971 10972 // Build the actual expression node. 10973 DeclarationNameInfo OpLocInfo(OpName, LLoc); 10974 OpLocInfo.setCXXOperatorNameRange(SourceRange(LLoc, RLoc)); 10975 ExprResult FnExpr = CreateFunctionRefExpr(*this, FnDecl, 10976 Best->FoundDecl, 10977 HadMultipleCandidates, 10978 OpLocInfo.getLoc(), 10979 OpLocInfo.getInfo()); 10980 if (FnExpr.isInvalid()) 10981 return ExprError(); 10982 10983 // Determine the result type 10984 QualType ResultTy = FnDecl->getResultType(); 10985 ExprValueKind VK = Expr::getValueKindForType(ResultTy); 10986 ResultTy = ResultTy.getNonLValueExprType(Context); 10987 10988 CXXOperatorCallExpr *TheCall = 10989 new (Context) CXXOperatorCallExpr(Context, OO_Subscript, 10990 FnExpr.take(), Args, 10991 ResultTy, VK, RLoc, 10992 false); 10993 10994 if (CheckCallReturnType(FnDecl->getResultType(), LLoc, TheCall, 10995 FnDecl)) 10996 return ExprError(); 10997 10998 return MaybeBindToTemporary(TheCall); 10999 } else { 11000 // We matched a built-in operator. Convert the arguments, then 11001 // break out so that we will build the appropriate built-in 11002 // operator node. 11003 ExprResult ArgsRes0 = 11004 PerformImplicitConversion(Args[0], Best->BuiltinTypes.ParamTypes[0], 11005 Best->Conversions[0], AA_Passing); 11006 if (ArgsRes0.isInvalid()) 11007 return ExprError(); 11008 Args[0] = ArgsRes0.take(); 11009 11010 ExprResult ArgsRes1 = 11011 PerformImplicitConversion(Args[1], Best->BuiltinTypes.ParamTypes[1], 11012 Best->Conversions[1], AA_Passing); 11013 if (ArgsRes1.isInvalid()) 11014 return ExprError(); 11015 Args[1] = ArgsRes1.take(); 11016 11017 break; 11018 } 11019 } 11020 11021 case OR_No_Viable_Function: { 11022 if (CandidateSet.empty()) 11023 Diag(LLoc, diag::err_ovl_no_oper) 11024 << Args[0]->getType() << /*subscript*/ 0 11025 << Args[0]->getSourceRange() << Args[1]->getSourceRange(); 11026 else 11027 Diag(LLoc, diag::err_ovl_no_viable_subscript) 11028 << Args[0]->getType() 11029 << Args[0]->getSourceRange() << Args[1]->getSourceRange(); 11030 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args, 11031 "[]", LLoc); 11032 return ExprError(); 11033 } 11034 11035 case OR_Ambiguous: 11036 Diag(LLoc, diag::err_ovl_ambiguous_oper_binary) 11037 << "[]" 11038 << Args[0]->getType() << Args[1]->getType() 11039 << Args[0]->getSourceRange() << Args[1]->getSourceRange(); 11040 CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, Args, 11041 "[]", LLoc); 11042 return ExprError(); 11043 11044 case OR_Deleted: 11045 Diag(LLoc, diag::err_ovl_deleted_oper) 11046 << Best->Function->isDeleted() << "[]" 11047 << getDeletedOrUnavailableSuffix(Best->Function) 11048 << Args[0]->getSourceRange() << Args[1]->getSourceRange(); 11049 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args, 11050 "[]", LLoc); 11051 return ExprError(); 11052 } 11053 11054 // We matched a built-in operator; build it. 11055 return CreateBuiltinArraySubscriptExpr(Args[0], LLoc, Args[1], RLoc); 11056} 11057 11058/// BuildCallToMemberFunction - Build a call to a member 11059/// function. MemExpr is the expression that refers to the member 11060/// function (and includes the object parameter), Args/NumArgs are the 11061/// arguments to the function call (not including the object 11062/// parameter). The caller needs to validate that the member 11063/// expression refers to a non-static member function or an overloaded 11064/// member function. 11065ExprResult 11066Sema::BuildCallToMemberFunction(Scope *S, Expr *MemExprE, 11067 SourceLocation LParenLoc, 11068 MultiExprArg Args, 11069 SourceLocation RParenLoc) { 11070 assert(MemExprE->getType() == Context.BoundMemberTy || 11071 MemExprE->getType() == Context.OverloadTy); 11072 11073 // Dig out the member expression. This holds both the object 11074 // argument and the member function we're referring to. 11075 Expr *NakedMemExpr = MemExprE->IgnoreParens(); 11076 11077 // Determine whether this is a call to a pointer-to-member function. 11078 if (BinaryOperator *op = dyn_cast<BinaryOperator>(NakedMemExpr)) { 11079 assert(op->getType() == Context.BoundMemberTy); 11080 assert(op->getOpcode() == BO_PtrMemD || op->getOpcode() == BO_PtrMemI); 11081 11082 QualType fnType = 11083 op->getRHS()->getType()->castAs<MemberPointerType>()->getPointeeType(); 11084 11085 const FunctionProtoType *proto = fnType->castAs<FunctionProtoType>(); 11086 QualType resultType = proto->getCallResultType(Context); 11087 ExprValueKind valueKind = Expr::getValueKindForType(proto->getResultType()); 11088 11089 // Check that the object type isn't more qualified than the 11090 // member function we're calling. 11091 Qualifiers funcQuals = Qualifiers::fromCVRMask(proto->getTypeQuals()); 11092 11093 QualType objectType = op->getLHS()->getType(); 11094 if (op->getOpcode() == BO_PtrMemI) 11095 objectType = objectType->castAs<PointerType>()->getPointeeType(); 11096 Qualifiers objectQuals = objectType.getQualifiers(); 11097 11098 Qualifiers difference = objectQuals - funcQuals; 11099 difference.removeObjCGCAttr(); 11100 difference.removeAddressSpace(); 11101 if (difference) { 11102 std::string qualsString = difference.getAsString(); 11103 Diag(LParenLoc, diag::err_pointer_to_member_call_drops_quals) 11104 << fnType.getUnqualifiedType() 11105 << qualsString 11106 << (qualsString.find(' ') == std::string::npos ? 1 : 2); 11107 } 11108 11109 CXXMemberCallExpr *call 11110 = new (Context) CXXMemberCallExpr(Context, MemExprE, Args, 11111 resultType, valueKind, RParenLoc); 11112 11113 if (CheckCallReturnType(proto->getResultType(), 11114 op->getRHS()->getLocStart(), 11115 call, 0)) 11116 return ExprError(); 11117 11118 if (ConvertArgumentsForCall(call, op, 0, proto, Args, RParenLoc)) 11119 return ExprError(); 11120 11121 if (CheckOtherCall(call, proto)) 11122 return ExprError(); 11123 11124 return MaybeBindToTemporary(call); 11125 } 11126 11127 UnbridgedCastsSet UnbridgedCasts; 11128 if (checkArgPlaceholdersForOverload(*this, Args, UnbridgedCasts)) 11129 return ExprError(); 11130 11131 MemberExpr *MemExpr; 11132 CXXMethodDecl *Method = 0; 11133 DeclAccessPair FoundDecl = DeclAccessPair::make(0, AS_public); 11134 NestedNameSpecifier *Qualifier = 0; 11135 if (isa<MemberExpr>(NakedMemExpr)) { 11136 MemExpr = cast<MemberExpr>(NakedMemExpr); 11137 Method = cast<CXXMethodDecl>(MemExpr->getMemberDecl()); 11138 FoundDecl = MemExpr->getFoundDecl(); 11139 Qualifier = MemExpr->getQualifier(); 11140 UnbridgedCasts.restore(); 11141 } else { 11142 UnresolvedMemberExpr *UnresExpr = cast<UnresolvedMemberExpr>(NakedMemExpr); 11143 Qualifier = UnresExpr->getQualifier(); 11144 11145 QualType ObjectType = UnresExpr->getBaseType(); 11146 Expr::Classification ObjectClassification 11147 = UnresExpr->isArrow()? Expr::Classification::makeSimpleLValue() 11148 : UnresExpr->getBase()->Classify(Context); 11149 11150 // Add overload candidates 11151 OverloadCandidateSet CandidateSet(UnresExpr->getMemberLoc()); 11152 11153 // FIXME: avoid copy. 11154 TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = 0; 11155 if (UnresExpr->hasExplicitTemplateArgs()) { 11156 UnresExpr->copyTemplateArgumentsInto(TemplateArgsBuffer); 11157 TemplateArgs = &TemplateArgsBuffer; 11158 } 11159 11160 for (UnresolvedMemberExpr::decls_iterator I = UnresExpr->decls_begin(), 11161 E = UnresExpr->decls_end(); I != E; ++I) { 11162 11163 NamedDecl *Func = *I; 11164 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(Func->getDeclContext()); 11165 if (isa<UsingShadowDecl>(Func)) 11166 Func = cast<UsingShadowDecl>(Func)->getTargetDecl(); 11167 11168 11169 // Microsoft supports direct constructor calls. 11170 if (getLangOpts().MicrosoftExt && isa<CXXConstructorDecl>(Func)) { 11171 AddOverloadCandidate(cast<CXXConstructorDecl>(Func), I.getPair(), 11172 Args, CandidateSet); 11173 } else if ((Method = dyn_cast<CXXMethodDecl>(Func))) { 11174 // If explicit template arguments were provided, we can't call a 11175 // non-template member function. 11176 if (TemplateArgs) 11177 continue; 11178 11179 AddMethodCandidate(Method, I.getPair(), ActingDC, ObjectType, 11180 ObjectClassification, Args, CandidateSet, 11181 /*SuppressUserConversions=*/false); 11182 } else { 11183 AddMethodTemplateCandidate(cast<FunctionTemplateDecl>(Func), 11184 I.getPair(), ActingDC, TemplateArgs, 11185 ObjectType, ObjectClassification, 11186 Args, CandidateSet, 11187 /*SuppressUsedConversions=*/false); 11188 } 11189 } 11190 11191 DeclarationName DeclName = UnresExpr->getMemberName(); 11192 11193 UnbridgedCasts.restore(); 11194 11195 OverloadCandidateSet::iterator Best; 11196 switch (CandidateSet.BestViableFunction(*this, UnresExpr->getLocStart(), 11197 Best)) { 11198 case OR_Success: 11199 Method = cast<CXXMethodDecl>(Best->Function); 11200 FoundDecl = Best->FoundDecl; 11201 CheckUnresolvedMemberAccess(UnresExpr, Best->FoundDecl); 11202 if (DiagnoseUseOfDecl(Best->FoundDecl, UnresExpr->getNameLoc())) 11203 return ExprError(); 11204 // If FoundDecl is different from Method (such as if one is a template 11205 // and the other a specialization), make sure DiagnoseUseOfDecl is 11206 // called on both. 11207 // FIXME: This would be more comprehensively addressed by modifying 11208 // DiagnoseUseOfDecl to accept both the FoundDecl and the decl 11209 // being used. 11210 if (Method != FoundDecl.getDecl() && 11211 DiagnoseUseOfDecl(Method, UnresExpr->getNameLoc())) 11212 return ExprError(); 11213 break; 11214 11215 case OR_No_Viable_Function: 11216 Diag(UnresExpr->getMemberLoc(), 11217 diag::err_ovl_no_viable_member_function_in_call) 11218 << DeclName << MemExprE->getSourceRange(); 11219 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args); 11220 // FIXME: Leaking incoming expressions! 11221 return ExprError(); 11222 11223 case OR_Ambiguous: 11224 Diag(UnresExpr->getMemberLoc(), diag::err_ovl_ambiguous_member_call) 11225 << DeclName << MemExprE->getSourceRange(); 11226 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args); 11227 // FIXME: Leaking incoming expressions! 11228 return ExprError(); 11229 11230 case OR_Deleted: 11231 Diag(UnresExpr->getMemberLoc(), diag::err_ovl_deleted_member_call) 11232 << Best->Function->isDeleted() 11233 << DeclName 11234 << getDeletedOrUnavailableSuffix(Best->Function) 11235 << MemExprE->getSourceRange(); 11236 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args); 11237 // FIXME: Leaking incoming expressions! 11238 return ExprError(); 11239 } 11240 11241 MemExprE = FixOverloadedFunctionReference(MemExprE, FoundDecl, Method); 11242 11243 // If overload resolution picked a static member, build a 11244 // non-member call based on that function. 11245 if (Method->isStatic()) { 11246 return BuildResolvedCallExpr(MemExprE, Method, LParenLoc, Args, 11247 RParenLoc); 11248 } 11249 11250 MemExpr = cast<MemberExpr>(MemExprE->IgnoreParens()); 11251 } 11252 11253 QualType ResultType = Method->getResultType(); 11254 ExprValueKind VK = Expr::getValueKindForType(ResultType); 11255 ResultType = ResultType.getNonLValueExprType(Context); 11256 11257 assert(Method && "Member call to something that isn't a method?"); 11258 CXXMemberCallExpr *TheCall = 11259 new (Context) CXXMemberCallExpr(Context, MemExprE, Args, 11260 ResultType, VK, RParenLoc); 11261 11262 // Check for a valid return type. 11263 if (CheckCallReturnType(Method->getResultType(), MemExpr->getMemberLoc(), 11264 TheCall, Method)) 11265 return ExprError(); 11266 11267 // Convert the object argument (for a non-static member function call). 11268 // We only need to do this if there was actually an overload; otherwise 11269 // it was done at lookup. 11270 if (!Method->isStatic()) { 11271 ExprResult ObjectArg = 11272 PerformObjectArgumentInitialization(MemExpr->getBase(), Qualifier, 11273 FoundDecl, Method); 11274 if (ObjectArg.isInvalid()) 11275 return ExprError(); 11276 MemExpr->setBase(ObjectArg.take()); 11277 } 11278 11279 // Convert the rest of the arguments 11280 const FunctionProtoType *Proto = 11281 Method->getType()->getAs<FunctionProtoType>(); 11282 if (ConvertArgumentsForCall(TheCall, MemExpr, Method, Proto, Args, 11283 RParenLoc)) 11284 return ExprError(); 11285 11286 DiagnoseSentinelCalls(Method, LParenLoc, Args); 11287 11288 if (CheckFunctionCall(Method, TheCall, Proto)) 11289 return ExprError(); 11290 11291 if ((isa<CXXConstructorDecl>(CurContext) || 11292 isa<CXXDestructorDecl>(CurContext)) && 11293 TheCall->getMethodDecl()->isPure()) { 11294 const CXXMethodDecl *MD = TheCall->getMethodDecl(); 11295 11296 if (isa<CXXThisExpr>(MemExpr->getBase()->IgnoreParenCasts())) { 11297 Diag(MemExpr->getLocStart(), 11298 diag::warn_call_to_pure_virtual_member_function_from_ctor_dtor) 11299 << MD->getDeclName() << isa<CXXDestructorDecl>(CurContext) 11300 << MD->getParent()->getDeclName(); 11301 11302 Diag(MD->getLocStart(), diag::note_previous_decl) << MD->getDeclName(); 11303 } 11304 } 11305 return MaybeBindToTemporary(TheCall); 11306} 11307 11308/// BuildCallToObjectOfClassType - Build a call to an object of class 11309/// type (C++ [over.call.object]), which can end up invoking an 11310/// overloaded function call operator (@c operator()) or performing a 11311/// user-defined conversion on the object argument. 11312ExprResult 11313Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Obj, 11314 SourceLocation LParenLoc, 11315 MultiExprArg Args, 11316 SourceLocation RParenLoc) { 11317 if (checkPlaceholderForOverload(*this, Obj)) 11318 return ExprError(); 11319 ExprResult Object = Owned(Obj); 11320 11321 UnbridgedCastsSet UnbridgedCasts; 11322 if (checkArgPlaceholdersForOverload(*this, Args, UnbridgedCasts)) 11323 return ExprError(); 11324 11325 assert(Object.get()->getType()->isRecordType() && "Requires object type argument"); 11326 const RecordType *Record = Object.get()->getType()->getAs<RecordType>(); 11327 11328 // C++ [over.call.object]p1: 11329 // If the primary-expression E in the function call syntax 11330 // evaluates to a class object of type "cv T", then the set of 11331 // candidate functions includes at least the function call 11332 // operators of T. The function call operators of T are obtained by 11333 // ordinary lookup of the name operator() in the context of 11334 // (E).operator(). 11335 OverloadCandidateSet CandidateSet(LParenLoc); 11336 DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(OO_Call); 11337 11338 if (RequireCompleteType(LParenLoc, Object.get()->getType(), 11339 diag::err_incomplete_object_call, Object.get())) 11340 return true; 11341 11342 LookupResult R(*this, OpName, LParenLoc, LookupOrdinaryName); 11343 LookupQualifiedName(R, Record->getDecl()); 11344 R.suppressDiagnostics(); 11345 11346 for (LookupResult::iterator Oper = R.begin(), OperEnd = R.end(); 11347 Oper != OperEnd; ++Oper) { 11348 AddMethodCandidate(Oper.getPair(), Object.get()->getType(), 11349 Object.get()->Classify(Context), 11350 Args, CandidateSet, 11351 /*SuppressUserConversions=*/ false); 11352 } 11353 11354 // C++ [over.call.object]p2: 11355 // In addition, for each (non-explicit in C++0x) conversion function 11356 // declared in T of the form 11357 // 11358 // operator conversion-type-id () cv-qualifier; 11359 // 11360 // where cv-qualifier is the same cv-qualification as, or a 11361 // greater cv-qualification than, cv, and where conversion-type-id 11362 // denotes the type "pointer to function of (P1,...,Pn) returning 11363 // R", or the type "reference to pointer to function of 11364 // (P1,...,Pn) returning R", or the type "reference to function 11365 // of (P1,...,Pn) returning R", a surrogate call function [...] 11366 // is also considered as a candidate function. Similarly, 11367 // surrogate call functions are added to the set of candidate 11368 // functions for each conversion function declared in an 11369 // accessible base class provided the function is not hidden 11370 // within T by another intervening declaration. 11371 std::pair<CXXRecordDecl::conversion_iterator, 11372 CXXRecordDecl::conversion_iterator> Conversions 11373 = cast<CXXRecordDecl>(Record->getDecl())->getVisibleConversionFunctions(); 11374 for (CXXRecordDecl::conversion_iterator 11375 I = Conversions.first, E = Conversions.second; I != E; ++I) { 11376 NamedDecl *D = *I; 11377 CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext()); 11378 if (isa<UsingShadowDecl>(D)) 11379 D = cast<UsingShadowDecl>(D)->getTargetDecl(); 11380 11381 // Skip over templated conversion functions; they aren't 11382 // surrogates. 11383 if (isa<FunctionTemplateDecl>(D)) 11384 continue; 11385 11386 CXXConversionDecl *Conv = cast<CXXConversionDecl>(D); 11387 if (!Conv->isExplicit()) { 11388 // Strip the reference type (if any) and then the pointer type (if 11389 // any) to get down to what might be a function type. 11390 QualType ConvType = Conv->getConversionType().getNonReferenceType(); 11391 if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>()) 11392 ConvType = ConvPtrType->getPointeeType(); 11393 11394 if (const FunctionProtoType *Proto = ConvType->getAs<FunctionProtoType>()) 11395 { 11396 AddSurrogateCandidate(Conv, I.getPair(), ActingContext, Proto, 11397 Object.get(), Args, CandidateSet); 11398 } 11399 } 11400 } 11401 11402 bool HadMultipleCandidates = (CandidateSet.size() > 1); 11403 11404 // Perform overload resolution. 11405 OverloadCandidateSet::iterator Best; 11406 switch (CandidateSet.BestViableFunction(*this, Object.get()->getLocStart(), 11407 Best)) { 11408 case OR_Success: 11409 // Overload resolution succeeded; we'll build the appropriate call 11410 // below. 11411 break; 11412 11413 case OR_No_Viable_Function: 11414 if (CandidateSet.empty()) 11415 Diag(Object.get()->getLocStart(), diag::err_ovl_no_oper) 11416 << Object.get()->getType() << /*call*/ 1 11417 << Object.get()->getSourceRange(); 11418 else 11419 Diag(Object.get()->getLocStart(), 11420 diag::err_ovl_no_viable_object_call) 11421 << Object.get()->getType() << Object.get()->getSourceRange(); 11422 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args); 11423 break; 11424 11425 case OR_Ambiguous: 11426 Diag(Object.get()->getLocStart(), 11427 diag::err_ovl_ambiguous_object_call) 11428 << Object.get()->getType() << Object.get()->getSourceRange(); 11429 CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, Args); 11430 break; 11431 11432 case OR_Deleted: 11433 Diag(Object.get()->getLocStart(), 11434 diag::err_ovl_deleted_object_call) 11435 << Best->Function->isDeleted() 11436 << Object.get()->getType() 11437 << getDeletedOrUnavailableSuffix(Best->Function) 11438 << Object.get()->getSourceRange(); 11439 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args); 11440 break; 11441 } 11442 11443 if (Best == CandidateSet.end()) 11444 return true; 11445 11446 UnbridgedCasts.restore(); 11447 11448 if (Best->Function == 0) { 11449 // Since there is no function declaration, this is one of the 11450 // surrogate candidates. Dig out the conversion function. 11451 CXXConversionDecl *Conv 11452 = cast<CXXConversionDecl>( 11453 Best->Conversions[0].UserDefined.ConversionFunction); 11454 11455 CheckMemberOperatorAccess(LParenLoc, Object.get(), 0, Best->FoundDecl); 11456 if (DiagnoseUseOfDecl(Best->FoundDecl, LParenLoc)) 11457 return ExprError(); 11458 assert(Conv == Best->FoundDecl.getDecl() && 11459 "Found Decl & conversion-to-functionptr should be same, right?!"); 11460 // We selected one of the surrogate functions that converts the 11461 // object parameter to a function pointer. Perform the conversion 11462 // on the object argument, then let ActOnCallExpr finish the job. 11463 11464 // Create an implicit member expr to refer to the conversion operator. 11465 // and then call it. 11466 ExprResult Call = BuildCXXMemberCallExpr(Object.get(), Best->FoundDecl, 11467 Conv, HadMultipleCandidates); 11468 if (Call.isInvalid()) 11469 return ExprError(); 11470 // Record usage of conversion in an implicit cast. 11471 Call = Owned(ImplicitCastExpr::Create(Context, Call.get()->getType(), 11472 CK_UserDefinedConversion, 11473 Call.get(), 0, VK_RValue)); 11474 11475 return ActOnCallExpr(S, Call.get(), LParenLoc, Args, RParenLoc); 11476 } 11477 11478 CheckMemberOperatorAccess(LParenLoc, Object.get(), 0, Best->FoundDecl); 11479 11480 // We found an overloaded operator(). Build a CXXOperatorCallExpr 11481 // that calls this method, using Object for the implicit object 11482 // parameter and passing along the remaining arguments. 11483 CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function); 11484 11485 // An error diagnostic has already been printed when parsing the declaration. 11486 if (Method->isInvalidDecl()) 11487 return ExprError(); 11488 11489 const FunctionProtoType *Proto = 11490 Method->getType()->getAs<FunctionProtoType>(); 11491 11492 unsigned NumArgsInProto = Proto->getNumArgs(); 11493 11494 DeclarationNameInfo OpLocInfo( 11495 Context.DeclarationNames.getCXXOperatorName(OO_Call), LParenLoc); 11496 OpLocInfo.setCXXOperatorNameRange(SourceRange(LParenLoc, RParenLoc)); 11497 ExprResult NewFn = CreateFunctionRefExpr(*this, Method, Best->FoundDecl, 11498 HadMultipleCandidates, 11499 OpLocInfo.getLoc(), 11500 OpLocInfo.getInfo()); 11501 if (NewFn.isInvalid()) 11502 return true; 11503 11504 // Build the full argument list for the method call (the implicit object 11505 // parameter is placed at the beginning of the list). 11506 llvm::OwningArrayPtr<Expr *> MethodArgs(new Expr*[Args.size() + 1]); 11507 MethodArgs[0] = Object.get(); 11508 std::copy(Args.begin(), Args.end(), &MethodArgs[1]); 11509 11510 // Once we've built TheCall, all of the expressions are properly 11511 // owned. 11512 QualType ResultTy = Method->getResultType(); 11513 ExprValueKind VK = Expr::getValueKindForType(ResultTy); 11514 ResultTy = ResultTy.getNonLValueExprType(Context); 11515 11516 CXXOperatorCallExpr *TheCall = new (Context) 11517 CXXOperatorCallExpr(Context, OO_Call, NewFn.take(), 11518 llvm::makeArrayRef(MethodArgs.get(), Args.size() + 1), 11519 ResultTy, VK, RParenLoc, false); 11520 MethodArgs.reset(); 11521 11522 if (CheckCallReturnType(Method->getResultType(), LParenLoc, TheCall, 11523 Method)) 11524 return true; 11525 11526 // We may have default arguments. If so, we need to allocate more 11527 // slots in the call for them. 11528 if (Args.size() < NumArgsInProto) 11529 TheCall->setNumArgs(Context, NumArgsInProto + 1); 11530 11531 bool IsError = false; 11532 11533 // Initialize the implicit object parameter. 11534 ExprResult ObjRes = 11535 PerformObjectArgumentInitialization(Object.get(), /*Qualifier=*/0, 11536 Best->FoundDecl, Method); 11537 if (ObjRes.isInvalid()) 11538 IsError = true; 11539 else 11540 Object = ObjRes; 11541 TheCall->setArg(0, Object.take()); 11542 11543 // Check the argument types. 11544 for (unsigned i = 0; i != NumArgsInProto; i++) { 11545 Expr *Arg; 11546 if (i < Args.size()) { 11547 Arg = Args[i]; 11548 11549 // Pass the argument. 11550 11551 ExprResult InputInit 11552 = PerformCopyInitialization(InitializedEntity::InitializeParameter( 11553 Context, 11554 Method->getParamDecl(i)), 11555 SourceLocation(), Arg); 11556 11557 IsError |= InputInit.isInvalid(); 11558 Arg = InputInit.takeAs<Expr>(); 11559 } else { 11560 ExprResult DefArg 11561 = BuildCXXDefaultArgExpr(LParenLoc, Method, Method->getParamDecl(i)); 11562 if (DefArg.isInvalid()) { 11563 IsError = true; 11564 break; 11565 } 11566 11567 Arg = DefArg.takeAs<Expr>(); 11568 } 11569 11570 TheCall->setArg(i + 1, Arg); 11571 } 11572 11573 // If this is a variadic call, handle args passed through "...". 11574 if (Proto->isVariadic()) { 11575 // Promote the arguments (C99 6.5.2.2p7). 11576 for (unsigned i = NumArgsInProto, e = Args.size(); i < e; i++) { 11577 ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], VariadicMethod, 0); 11578 IsError |= Arg.isInvalid(); 11579 TheCall->setArg(i + 1, Arg.take()); 11580 } 11581 } 11582 11583 if (IsError) return true; 11584 11585 DiagnoseSentinelCalls(Method, LParenLoc, Args); 11586 11587 if (CheckFunctionCall(Method, TheCall, Proto)) 11588 return true; 11589 11590 return MaybeBindToTemporary(TheCall); 11591} 11592 11593/// BuildOverloadedArrowExpr - Build a call to an overloaded @c operator-> 11594/// (if one exists), where @c Base is an expression of class type and 11595/// @c Member is the name of the member we're trying to find. 11596ExprResult 11597Sema::BuildOverloadedArrowExpr(Scope *S, Expr *Base, SourceLocation OpLoc, 11598 bool *NoArrowOperatorFound) { 11599 assert(Base->getType()->isRecordType() && 11600 "left-hand side must have class type"); 11601 11602 if (checkPlaceholderForOverload(*this, Base)) 11603 return ExprError(); 11604 11605 SourceLocation Loc = Base->getExprLoc(); 11606 11607 // C++ [over.ref]p1: 11608 // 11609 // [...] An expression x->m is interpreted as (x.operator->())->m 11610 // for a class object x of type T if T::operator->() exists and if 11611 // the operator is selected as the best match function by the 11612 // overload resolution mechanism (13.3). 11613 DeclarationName OpName = 11614 Context.DeclarationNames.getCXXOperatorName(OO_Arrow); 11615 OverloadCandidateSet CandidateSet(Loc); 11616 const RecordType *BaseRecord = Base->getType()->getAs<RecordType>(); 11617 11618 if (RequireCompleteType(Loc, Base->getType(), 11619 diag::err_typecheck_incomplete_tag, Base)) 11620 return ExprError(); 11621 11622 LookupResult R(*this, OpName, OpLoc, LookupOrdinaryName); 11623 LookupQualifiedName(R, BaseRecord->getDecl()); 11624 R.suppressDiagnostics(); 11625 11626 for (LookupResult::iterator Oper = R.begin(), OperEnd = R.end(); 11627 Oper != OperEnd; ++Oper) { 11628 AddMethodCandidate(Oper.getPair(), Base->getType(), Base->Classify(Context), 11629 None, CandidateSet, /*SuppressUserConversions=*/false); 11630 } 11631 11632 bool HadMultipleCandidates = (CandidateSet.size() > 1); 11633 11634 // Perform overload resolution. 11635 OverloadCandidateSet::iterator Best; 11636 switch (CandidateSet.BestViableFunction(*this, OpLoc, Best)) { 11637 case OR_Success: 11638 // Overload resolution succeeded; we'll build the call below. 11639 break; 11640 11641 case OR_No_Viable_Function: 11642 if (CandidateSet.empty()) { 11643 QualType BaseType = Base->getType(); 11644 if (NoArrowOperatorFound) { 11645 // Report this specific error to the caller instead of emitting a 11646 // diagnostic, as requested. 11647 *NoArrowOperatorFound = true; 11648 return ExprError(); 11649 } 11650 Diag(OpLoc, diag::err_typecheck_member_reference_arrow) 11651 << BaseType << Base->getSourceRange(); 11652 if (BaseType->isRecordType() && !BaseType->isPointerType()) { 11653 Diag(OpLoc, diag::note_typecheck_member_reference_suggestion) 11654 << FixItHint::CreateReplacement(OpLoc, "."); 11655 } 11656 } else 11657 Diag(OpLoc, diag::err_ovl_no_viable_oper) 11658 << "operator->" << Base->getSourceRange(); 11659 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Base); 11660 return ExprError(); 11661 11662 case OR_Ambiguous: 11663 Diag(OpLoc, diag::err_ovl_ambiguous_oper_unary) 11664 << "->" << Base->getType() << Base->getSourceRange(); 11665 CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, Base); 11666 return ExprError(); 11667 11668 case OR_Deleted: 11669 Diag(OpLoc, diag::err_ovl_deleted_oper) 11670 << Best->Function->isDeleted() 11671 << "->" 11672 << getDeletedOrUnavailableSuffix(Best->Function) 11673 << Base->getSourceRange(); 11674 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Base); 11675 return ExprError(); 11676 } 11677 11678 CheckMemberOperatorAccess(OpLoc, Base, 0, Best->FoundDecl); 11679 11680 // Convert the object parameter. 11681 CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function); 11682 ExprResult BaseResult = 11683 PerformObjectArgumentInitialization(Base, /*Qualifier=*/0, 11684 Best->FoundDecl, Method); 11685 if (BaseResult.isInvalid()) 11686 return ExprError(); 11687 Base = BaseResult.take(); 11688 11689 // Build the operator call. 11690 ExprResult FnExpr = CreateFunctionRefExpr(*this, Method, Best->FoundDecl, 11691 HadMultipleCandidates, OpLoc); 11692 if (FnExpr.isInvalid()) 11693 return ExprError(); 11694 11695 QualType ResultTy = Method->getResultType(); 11696 ExprValueKind VK = Expr::getValueKindForType(ResultTy); 11697 ResultTy = ResultTy.getNonLValueExprType(Context); 11698 CXXOperatorCallExpr *TheCall = 11699 new (Context) CXXOperatorCallExpr(Context, OO_Arrow, FnExpr.take(), 11700 Base, ResultTy, VK, OpLoc, false); 11701 11702 if (CheckCallReturnType(Method->getResultType(), OpLoc, TheCall, 11703 Method)) 11704 return ExprError(); 11705 11706 return MaybeBindToTemporary(TheCall); 11707} 11708 11709/// BuildLiteralOperatorCall - Build a UserDefinedLiteral by creating a call to 11710/// a literal operator described by the provided lookup results. 11711ExprResult Sema::BuildLiteralOperatorCall(LookupResult &R, 11712 DeclarationNameInfo &SuffixInfo, 11713 ArrayRef<Expr*> Args, 11714 SourceLocation LitEndLoc, 11715 TemplateArgumentListInfo *TemplateArgs) { 11716 SourceLocation UDSuffixLoc = SuffixInfo.getCXXLiteralOperatorNameLoc(); 11717 11718 OverloadCandidateSet CandidateSet(UDSuffixLoc); 11719 AddFunctionCandidates(R.asUnresolvedSet(), Args, CandidateSet, true, 11720 TemplateArgs); 11721 11722 bool HadMultipleCandidates = (CandidateSet.size() > 1); 11723 11724 // Perform overload resolution. This will usually be trivial, but might need 11725 // to perform substitutions for a literal operator template. 11726 OverloadCandidateSet::iterator Best; 11727 switch (CandidateSet.BestViableFunction(*this, UDSuffixLoc, Best)) { 11728 case OR_Success: 11729 case OR_Deleted: 11730 break; 11731 11732 case OR_No_Viable_Function: 11733 Diag(UDSuffixLoc, diag::err_ovl_no_viable_function_in_call) 11734 << R.getLookupName(); 11735 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args); 11736 return ExprError(); 11737 11738 case OR_Ambiguous: 11739 Diag(R.getNameLoc(), diag::err_ovl_ambiguous_call) << R.getLookupName(); 11740 CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, Args); 11741 return ExprError(); 11742 } 11743 11744 FunctionDecl *FD = Best->Function; 11745 ExprResult Fn = CreateFunctionRefExpr(*this, FD, Best->FoundDecl, 11746 HadMultipleCandidates, 11747 SuffixInfo.getLoc(), 11748 SuffixInfo.getInfo()); 11749 if (Fn.isInvalid()) 11750 return true; 11751 11752 // Check the argument types. This should almost always be a no-op, except 11753 // that array-to-pointer decay is applied to string literals. 11754 Expr *ConvArgs[2]; 11755 for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) { 11756 ExprResult InputInit = PerformCopyInitialization( 11757 InitializedEntity::InitializeParameter(Context, FD->getParamDecl(ArgIdx)), 11758 SourceLocation(), Args[ArgIdx]); 11759 if (InputInit.isInvalid()) 11760 return true; 11761 ConvArgs[ArgIdx] = InputInit.take(); 11762 } 11763 11764 QualType ResultTy = FD->getResultType(); 11765 ExprValueKind VK = Expr::getValueKindForType(ResultTy); 11766 ResultTy = ResultTy.getNonLValueExprType(Context); 11767 11768 UserDefinedLiteral *UDL = 11769 new (Context) UserDefinedLiteral(Context, Fn.take(), 11770 llvm::makeArrayRef(ConvArgs, Args.size()), 11771 ResultTy, VK, LitEndLoc, UDSuffixLoc); 11772 11773 if (CheckCallReturnType(FD->getResultType(), UDSuffixLoc, UDL, FD)) 11774 return ExprError(); 11775 11776 if (CheckFunctionCall(FD, UDL, NULL)) 11777 return ExprError(); 11778 11779 return MaybeBindToTemporary(UDL); 11780} 11781 11782/// Build a call to 'begin' or 'end' for a C++11 for-range statement. If the 11783/// given LookupResult is non-empty, it is assumed to describe a member which 11784/// will be invoked. Otherwise, the function will be found via argument 11785/// dependent lookup. 11786/// CallExpr is set to a valid expression and FRS_Success returned on success, 11787/// otherwise CallExpr is set to ExprError() and some non-success value 11788/// is returned. 11789Sema::ForRangeStatus 11790Sema::BuildForRangeBeginEndCall(Scope *S, SourceLocation Loc, 11791 SourceLocation RangeLoc, VarDecl *Decl, 11792 BeginEndFunction BEF, 11793 const DeclarationNameInfo &NameInfo, 11794 LookupResult &MemberLookup, 11795 OverloadCandidateSet *CandidateSet, 11796 Expr *Range, ExprResult *CallExpr) { 11797 CandidateSet->clear(); 11798 if (!MemberLookup.empty()) { 11799 ExprResult MemberRef = 11800 BuildMemberReferenceExpr(Range, Range->getType(), Loc, 11801 /*IsPtr=*/false, CXXScopeSpec(), 11802 /*TemplateKWLoc=*/SourceLocation(), 11803 /*FirstQualifierInScope=*/0, 11804 MemberLookup, 11805 /*TemplateArgs=*/0); 11806 if (MemberRef.isInvalid()) { 11807 *CallExpr = ExprError(); 11808 Diag(Range->getLocStart(), diag::note_in_for_range) 11809 << RangeLoc << BEF << Range->getType(); 11810 return FRS_DiagnosticIssued; 11811 } 11812 *CallExpr = ActOnCallExpr(S, MemberRef.get(), Loc, None, Loc, 0); 11813 if (CallExpr->isInvalid()) { 11814 *CallExpr = ExprError(); 11815 Diag(Range->getLocStart(), diag::note_in_for_range) 11816 << RangeLoc << BEF << Range->getType(); 11817 return FRS_DiagnosticIssued; 11818 } 11819 } else { 11820 UnresolvedSet<0> FoundNames; 11821 UnresolvedLookupExpr *Fn = 11822 UnresolvedLookupExpr::Create(Context, /*NamingClass=*/0, 11823 NestedNameSpecifierLoc(), NameInfo, 11824 /*NeedsADL=*/true, /*Overloaded=*/false, 11825 FoundNames.begin(), FoundNames.end()); 11826 11827 bool CandidateSetError = buildOverloadedCallSet(S, Fn, Fn, Range, Loc, 11828 CandidateSet, CallExpr); 11829 if (CandidateSet->empty() || CandidateSetError) { 11830 *CallExpr = ExprError(); 11831 return FRS_NoViableFunction; 11832 } 11833 OverloadCandidateSet::iterator Best; 11834 OverloadingResult OverloadResult = 11835 CandidateSet->BestViableFunction(*this, Fn->getLocStart(), Best); 11836 11837 if (OverloadResult == OR_No_Viable_Function) { 11838 *CallExpr = ExprError(); 11839 return FRS_NoViableFunction; 11840 } 11841 *CallExpr = FinishOverloadedCallExpr(*this, S, Fn, Fn, Loc, Range, 11842 Loc, 0, CandidateSet, &Best, 11843 OverloadResult, 11844 /*AllowTypoCorrection=*/false); 11845 if (CallExpr->isInvalid() || OverloadResult != OR_Success) { 11846 *CallExpr = ExprError(); 11847 Diag(Range->getLocStart(), diag::note_in_for_range) 11848 << RangeLoc << BEF << Range->getType(); 11849 return FRS_DiagnosticIssued; 11850 } 11851 } 11852 return FRS_Success; 11853} 11854 11855 11856/// FixOverloadedFunctionReference - E is an expression that refers to 11857/// a C++ overloaded function (possibly with some parentheses and 11858/// perhaps a '&' around it). We have resolved the overloaded function 11859/// to the function declaration Fn, so patch up the expression E to 11860/// refer (possibly indirectly) to Fn. Returns the new expr. 11861Expr *Sema::FixOverloadedFunctionReference(Expr *E, DeclAccessPair Found, 11862 FunctionDecl *Fn) { 11863 if (ParenExpr *PE = dyn_cast<ParenExpr>(E)) { 11864 Expr *SubExpr = FixOverloadedFunctionReference(PE->getSubExpr(), 11865 Found, Fn); 11866 if (SubExpr == PE->getSubExpr()) 11867 return PE; 11868 11869 return new (Context) ParenExpr(PE->getLParen(), PE->getRParen(), SubExpr); 11870 } 11871 11872 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) { 11873 Expr *SubExpr = FixOverloadedFunctionReference(ICE->getSubExpr(), 11874 Found, Fn); 11875 assert(Context.hasSameType(ICE->getSubExpr()->getType(), 11876 SubExpr->getType()) && 11877 "Implicit cast type cannot be determined from overload"); 11878 assert(ICE->path_empty() && "fixing up hierarchy conversion?"); 11879 if (SubExpr == ICE->getSubExpr()) 11880 return ICE; 11881 11882 return ImplicitCastExpr::Create(Context, ICE->getType(), 11883 ICE->getCastKind(), 11884 SubExpr, 0, 11885 ICE->getValueKind()); 11886 } 11887 11888 if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(E)) { 11889 assert(UnOp->getOpcode() == UO_AddrOf && 11890 "Can only take the address of an overloaded function"); 11891 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) { 11892 if (Method->isStatic()) { 11893 // Do nothing: static member functions aren't any different 11894 // from non-member functions. 11895 } else { 11896 // Fix the sub expression, which really has to be an 11897 // UnresolvedLookupExpr holding an overloaded member function 11898 // or template. 11899 Expr *SubExpr = FixOverloadedFunctionReference(UnOp->getSubExpr(), 11900 Found, Fn); 11901 if (SubExpr == UnOp->getSubExpr()) 11902 return UnOp; 11903 11904 assert(isa<DeclRefExpr>(SubExpr) 11905 && "fixed to something other than a decl ref"); 11906 assert(cast<DeclRefExpr>(SubExpr)->getQualifier() 11907 && "fixed to a member ref with no nested name qualifier"); 11908 11909 // We have taken the address of a pointer to member 11910 // function. Perform the computation here so that we get the 11911 // appropriate pointer to member type. 11912 QualType ClassType 11913 = Context.getTypeDeclType(cast<RecordDecl>(Method->getDeclContext())); 11914 QualType MemPtrType 11915 = Context.getMemberPointerType(Fn->getType(), ClassType.getTypePtr()); 11916 11917 return new (Context) UnaryOperator(SubExpr, UO_AddrOf, MemPtrType, 11918 VK_RValue, OK_Ordinary, 11919 UnOp->getOperatorLoc()); 11920 } 11921 } 11922 Expr *SubExpr = FixOverloadedFunctionReference(UnOp->getSubExpr(), 11923 Found, Fn); 11924 if (SubExpr == UnOp->getSubExpr()) 11925 return UnOp; 11926 11927 return new (Context) UnaryOperator(SubExpr, UO_AddrOf, 11928 Context.getPointerType(SubExpr->getType()), 11929 VK_RValue, OK_Ordinary, 11930 UnOp->getOperatorLoc()); 11931 } 11932 11933 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(E)) { 11934 // FIXME: avoid copy. 11935 TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = 0; 11936 if (ULE->hasExplicitTemplateArgs()) { 11937 ULE->copyTemplateArgumentsInto(TemplateArgsBuffer); 11938 TemplateArgs = &TemplateArgsBuffer; 11939 } 11940 11941 DeclRefExpr *DRE = DeclRefExpr::Create(Context, 11942 ULE->getQualifierLoc(), 11943 ULE->getTemplateKeywordLoc(), 11944 Fn, 11945 /*enclosing*/ false, // FIXME? 11946 ULE->getNameLoc(), 11947 Fn->getType(), 11948 VK_LValue, 11949 Found.getDecl(), 11950 TemplateArgs); 11951 MarkDeclRefReferenced(DRE); 11952 DRE->setHadMultipleCandidates(ULE->getNumDecls() > 1); 11953 return DRE; 11954 } 11955 11956 if (UnresolvedMemberExpr *MemExpr = dyn_cast<UnresolvedMemberExpr>(E)) { 11957 // FIXME: avoid copy. 11958 TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = 0; 11959 if (MemExpr->hasExplicitTemplateArgs()) { 11960 MemExpr->copyTemplateArgumentsInto(TemplateArgsBuffer); 11961 TemplateArgs = &TemplateArgsBuffer; 11962 } 11963 11964 Expr *Base; 11965 11966 // If we're filling in a static method where we used to have an 11967 // implicit member access, rewrite to a simple decl ref. 11968 if (MemExpr->isImplicitAccess()) { 11969 if (cast<CXXMethodDecl>(Fn)->isStatic()) { 11970 DeclRefExpr *DRE = DeclRefExpr::Create(Context, 11971 MemExpr->getQualifierLoc(), 11972 MemExpr->getTemplateKeywordLoc(), 11973 Fn, 11974 /*enclosing*/ false, 11975 MemExpr->getMemberLoc(), 11976 Fn->getType(), 11977 VK_LValue, 11978 Found.getDecl(), 11979 TemplateArgs); 11980 MarkDeclRefReferenced(DRE); 11981 DRE->setHadMultipleCandidates(MemExpr->getNumDecls() > 1); 11982 return DRE; 11983 } else { 11984 SourceLocation Loc = MemExpr->getMemberLoc(); 11985 if (MemExpr->getQualifier()) 11986 Loc = MemExpr->getQualifierLoc().getBeginLoc(); 11987 CheckCXXThisCapture(Loc); 11988 Base = new (Context) CXXThisExpr(Loc, 11989 MemExpr->getBaseType(), 11990 /*isImplicit=*/true); 11991 } 11992 } else 11993 Base = MemExpr->getBase(); 11994 11995 ExprValueKind valueKind; 11996 QualType type; 11997 if (cast<CXXMethodDecl>(Fn)->isStatic()) { 11998 valueKind = VK_LValue; 11999 type = Fn->getType(); 12000 } else { 12001 valueKind = VK_RValue; 12002 type = Context.BoundMemberTy; 12003 } 12004 12005 MemberExpr *ME = MemberExpr::Create(Context, Base, 12006 MemExpr->isArrow(), 12007 MemExpr->getQualifierLoc(), 12008 MemExpr->getTemplateKeywordLoc(), 12009 Fn, 12010 Found, 12011 MemExpr->getMemberNameInfo(), 12012 TemplateArgs, 12013 type, valueKind, OK_Ordinary); 12014 ME->setHadMultipleCandidates(true); 12015 MarkMemberReferenced(ME); 12016 return ME; 12017 } 12018 12019 llvm_unreachable("Invalid reference to overloaded function"); 12020} 12021 12022ExprResult Sema::FixOverloadedFunctionReference(ExprResult E, 12023 DeclAccessPair Found, 12024 FunctionDecl *Fn) { 12025 return Owned(FixOverloadedFunctionReference((Expr *)E.get(), Found, Fn)); 12026} 12027 12028} // end namespace clang 12029