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/Lex/Preprocessor.h" 25 #include "clang/Sema/Initialization.h" 26 #include "clang/Sema/Lookup.h" 27 #include "clang/Sema/SemaInternal.h" 28 #include "clang/Sema/Template.h" 29 #include "clang/Sema/TemplateDeduction.h" 30 #include "llvm/ADT/DenseSet.h" 31 #include "llvm/ADT/STLExtras.h" 32 #include "llvm/ADT/SmallPtrSet.h" 33 #include "llvm/ADT/SmallString.h" 34 #include <algorithm> 35 36 namespace clang { 37 using namespace sema; 38 39 /// A convenience routine for creating a decayed reference to a function. 40 static ExprResult 41 CreateFunctionRefExpr(Sema &S, FunctionDecl *Fn, NamedDecl *FoundDecl, 42 bool HadMultipleCandidates, 43 SourceLocation Loc = SourceLocation(), 44 const DeclarationNameLoc &LocInfo = DeclarationNameLoc()){ 45 if (S.DiagnoseUseOfDecl(FoundDecl, Loc)) 46 return ExprError(); 47 // If FoundDecl is different from Fn (such as if one is a template 48 // and the other a specialization), make sure DiagnoseUseOfDecl is 49 // called on both. 50 // FIXME: This would be more comprehensively addressed by modifying 51 // DiagnoseUseOfDecl to accept both the FoundDecl and the decl 52 // being used. 53 if (FoundDecl != Fn && S.DiagnoseUseOfDecl(Fn, Loc)) 54 return ExprError(); 55 DeclRefExpr *DRE = new (S.Context) DeclRefExpr(Fn, false, Fn->getType(), 56 VK_LValue, Loc, LocInfo); 57 if (HadMultipleCandidates) 58 DRE->setHadMultipleCandidates(true); 59 60 S.MarkDeclRefReferenced(DRE); 61 62 ExprResult E = S.Owned(DRE); 63 E = S.DefaultFunctionArrayConversion(E.take()); 64 if (E.isInvalid()) 65 return ExprError(); 66 return E; 67 } 68 69 static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType, 70 bool InOverloadResolution, 71 StandardConversionSequence &SCS, 72 bool CStyle, 73 bool AllowObjCWritebackConversion); 74 75 static bool IsTransparentUnionStandardConversion(Sema &S, Expr* From, 76 QualType &ToType, 77 bool InOverloadResolution, 78 StandardConversionSequence &SCS, 79 bool CStyle); 80 static OverloadingResult 81 IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType, 82 UserDefinedConversionSequence& User, 83 OverloadCandidateSet& Conversions, 84 bool AllowExplicit); 85 86 87 static ImplicitConversionSequence::CompareKind 88 CompareStandardConversionSequences(Sema &S, 89 const StandardConversionSequence& SCS1, 90 const StandardConversionSequence& SCS2); 91 92 static ImplicitConversionSequence::CompareKind 93 CompareQualificationConversions(Sema &S, 94 const StandardConversionSequence& SCS1, 95 const StandardConversionSequence& SCS2); 96 97 static ImplicitConversionSequence::CompareKind 98 CompareDerivedToBaseConversions(Sema &S, 99 const StandardConversionSequence& SCS1, 100 const StandardConversionSequence& SCS2); 101 102 103 104 /// GetConversionCategory - Retrieve the implicit conversion 105 /// category corresponding to the given implicit conversion kind. 106 ImplicitConversionCategory 107 GetConversionCategory(ImplicitConversionKind Kind) { 108 static const ImplicitConversionCategory 109 Category[(int)ICK_Num_Conversion_Kinds] = { 110 ICC_Identity, 111 ICC_Lvalue_Transformation, 112 ICC_Lvalue_Transformation, 113 ICC_Lvalue_Transformation, 114 ICC_Identity, 115 ICC_Qualification_Adjustment, 116 ICC_Promotion, 117 ICC_Promotion, 118 ICC_Promotion, 119 ICC_Conversion, 120 ICC_Conversion, 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 }; 133 return Category[(int)Kind]; 134 } 135 136 /// GetConversionRank - Retrieve the implicit conversion rank 137 /// corresponding to the given implicit conversion kind. 138 ImplicitConversionRank GetConversionRank(ImplicitConversionKind Kind) { 139 static const ImplicitConversionRank 140 Rank[(int)ICK_Num_Conversion_Kinds] = { 141 ICR_Exact_Match, 142 ICR_Exact_Match, 143 ICR_Exact_Match, 144 ICR_Exact_Match, 145 ICR_Exact_Match, 146 ICR_Exact_Match, 147 ICR_Promotion, 148 ICR_Promotion, 149 ICR_Promotion, 150 ICR_Conversion, 151 ICR_Conversion, 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_Complex_Real_Conversion, 162 ICR_Conversion, 163 ICR_Conversion, 164 ICR_Writeback_Conversion 165 }; 166 return Rank[(int)Kind]; 167 } 168 169 /// GetImplicitConversionName - Return the name of this kind of 170 /// implicit conversion. 171 const char* GetImplicitConversionName(ImplicitConversionKind Kind) { 172 static const char* const Name[(int)ICK_Num_Conversion_Kinds] = { 173 "No conversion", 174 "Lvalue-to-rvalue", 175 "Array-to-pointer", 176 "Function-to-pointer", 177 "Noreturn adjustment", 178 "Qualification", 179 "Integral promotion", 180 "Floating point promotion", 181 "Complex promotion", 182 "Integral conversion", 183 "Floating conversion", 184 "Complex conversion", 185 "Floating-integral conversion", 186 "Pointer conversion", 187 "Pointer-to-member conversion", 188 "Boolean conversion", 189 "Compatible-types conversion", 190 "Derived-to-base conversion", 191 "Vector conversion", 192 "Vector splat", 193 "Complex-real conversion", 194 "Block Pointer conversion", 195 "Transparent Union Conversion" 196 "Writeback conversion" 197 }; 198 return Name[Kind]; 199 } 200 201 /// StandardConversionSequence - Set the standard conversion 202 /// sequence to the identity conversion. 203 void StandardConversionSequence::setAsIdentityConversion() { 204 First = ICK_Identity; 205 Second = ICK_Identity; 206 Third = ICK_Identity; 207 DeprecatedStringLiteralToCharPtr = false; 208 QualificationIncludesObjCLifetime = false; 209 ReferenceBinding = false; 210 DirectBinding = false; 211 IsLvalueReference = true; 212 BindsToFunctionLvalue = false; 213 BindsToRvalue = false; 214 BindsImplicitObjectArgumentWithoutRefQualifier = false; 215 ObjCLifetimeConversionBinding = false; 216 CopyConstructor = 0; 217 } 218 219 /// getRank - Retrieve the rank of this standard conversion sequence 220 /// (C++ 13.3.3.1.1p3). The rank is the largest rank of each of the 221 /// implicit conversions. 222 ImplicitConversionRank StandardConversionSequence::getRank() const { 223 ImplicitConversionRank Rank = ICR_Exact_Match; 224 if (GetConversionRank(First) > Rank) 225 Rank = GetConversionRank(First); 226 if (GetConversionRank(Second) > Rank) 227 Rank = GetConversionRank(Second); 228 if (GetConversionRank(Third) > Rank) 229 Rank = GetConversionRank(Third); 230 return Rank; 231 } 232 233 /// isPointerConversionToBool - Determines whether this conversion is 234 /// a conversion of a pointer or pointer-to-member to bool. This is 235 /// used as part of the ranking of standard conversion sequences 236 /// (C++ 13.3.3.2p4). 237 bool StandardConversionSequence::isPointerConversionToBool() const { 238 // Note that FromType has not necessarily been transformed by the 239 // array-to-pointer or function-to-pointer implicit conversions, so 240 // check for their presence as well as checking whether FromType is 241 // a pointer. 242 if (getToType(1)->isBooleanType() && 243 (getFromType()->isPointerType() || 244 getFromType()->isObjCObjectPointerType() || 245 getFromType()->isBlockPointerType() || 246 getFromType()->isNullPtrType() || 247 First == ICK_Array_To_Pointer || First == ICK_Function_To_Pointer)) 248 return true; 249 250 return false; 251 } 252 253 /// isPointerConversionToVoidPointer - Determines whether this 254 /// conversion is a conversion of a pointer to a void pointer. This is 255 /// used as part of the ranking of standard conversion sequences (C++ 256 /// 13.3.3.2p4). 257 bool 258 StandardConversionSequence:: 259 isPointerConversionToVoidPointer(ASTContext& Context) const { 260 QualType FromType = getFromType(); 261 QualType ToType = getToType(1); 262 263 // Note that FromType has not necessarily been transformed by the 264 // array-to-pointer implicit conversion, so check for its presence 265 // and redo the conversion to get a pointer. 266 if (First == ICK_Array_To_Pointer) 267 FromType = Context.getArrayDecayedType(FromType); 268 269 if (Second == ICK_Pointer_Conversion && FromType->isAnyPointerType()) 270 if (const PointerType* ToPtrType = ToType->getAs<PointerType>()) 271 return ToPtrType->getPointeeType()->isVoidType(); 272 273 return false; 274 } 275 276 /// Skip any implicit casts which could be either part of a narrowing conversion 277 /// or after one in an implicit conversion. 278 static const Expr *IgnoreNarrowingConversion(const Expr *Converted) { 279 while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Converted)) { 280 switch (ICE->getCastKind()) { 281 case CK_NoOp: 282 case CK_IntegralCast: 283 case CK_IntegralToBoolean: 284 case CK_IntegralToFloating: 285 case CK_FloatingToIntegral: 286 case CK_FloatingToBoolean: 287 case CK_FloatingCast: 288 Converted = ICE->getSubExpr(); 289 continue; 290 291 default: 292 return Converted; 293 } 294 } 295 296 return Converted; 297 } 298 299 /// Check if this standard conversion sequence represents a narrowing 300 /// conversion, according to C++11 [dcl.init.list]p7. 301 /// 302 /// \param Ctx The AST context. 303 /// \param Converted The result of applying this standard conversion sequence. 304 /// \param ConstantValue If this is an NK_Constant_Narrowing conversion, the 305 /// value of the expression prior to the narrowing conversion. 306 /// \param ConstantType If this is an NK_Constant_Narrowing conversion, the 307 /// type of the expression prior to the narrowing conversion. 308 NarrowingKind 309 StandardConversionSequence::getNarrowingKind(ASTContext &Ctx, 310 const Expr *Converted, 311 APValue &ConstantValue, 312 QualType &ConstantType) const { 313 assert(Ctx.getLangOpts().CPlusPlus && "narrowing check outside C++"); 314 315 // C++11 [dcl.init.list]p7: 316 // A narrowing conversion is an implicit conversion ... 317 QualType FromType = getToType(0); 318 QualType ToType = getToType(1); 319 switch (Second) { 320 // -- from a floating-point type to an integer type, or 321 // 322 // -- from an integer type or unscoped enumeration type to a floating-point 323 // type, except where the source is a constant expression and the actual 324 // value after conversion will fit into the target type and will produce 325 // the original value when converted back to the original type, or 326 case ICK_Floating_Integral: 327 if (FromType->isRealFloatingType() && ToType->isIntegralType(Ctx)) { 328 return NK_Type_Narrowing; 329 } else if (FromType->isIntegralType(Ctx) && ToType->isRealFloatingType()) { 330 llvm::APSInt IntConstantValue; 331 const Expr *Initializer = IgnoreNarrowingConversion(Converted); 332 if (Initializer && 333 Initializer->isIntegerConstantExpr(IntConstantValue, Ctx)) { 334 // Convert the integer to the floating type. 335 llvm::APFloat Result(Ctx.getFloatTypeSemantics(ToType)); 336 Result.convertFromAPInt(IntConstantValue, IntConstantValue.isSigned(), 337 llvm::APFloat::rmNearestTiesToEven); 338 // And back. 339 llvm::APSInt ConvertedValue = IntConstantValue; 340 bool ignored; 341 Result.convertToInteger(ConvertedValue, 342 llvm::APFloat::rmTowardZero, &ignored); 343 // If the resulting value is different, this was a narrowing conversion. 344 if (IntConstantValue != ConvertedValue) { 345 ConstantValue = APValue(IntConstantValue); 346 ConstantType = Initializer->getType(); 347 return NK_Constant_Narrowing; 348 } 349 } else { 350 // Variables are always narrowings. 351 return NK_Variable_Narrowing; 352 } 353 } 354 return NK_Not_Narrowing; 355 356 // -- from long double to double or float, or from double to float, except 357 // where the source is a constant expression and the actual value after 358 // conversion is within the range of values that can be represented (even 359 // if it cannot be represented exactly), or 360 case ICK_Floating_Conversion: 361 if (FromType->isRealFloatingType() && ToType->isRealFloatingType() && 362 Ctx.getFloatingTypeOrder(FromType, ToType) == 1) { 363 // FromType is larger than ToType. 364 const Expr *Initializer = IgnoreNarrowingConversion(Converted); 365 if (Initializer->isCXX11ConstantExpr(Ctx, &ConstantValue)) { 366 // Constant! 367 assert(ConstantValue.isFloat()); 368 llvm::APFloat FloatVal = ConstantValue.getFloat(); 369 // Convert the source value into the target type. 370 bool ignored; 371 llvm::APFloat::opStatus ConvertStatus = FloatVal.convert( 372 Ctx.getFloatTypeSemantics(ToType), 373 llvm::APFloat::rmNearestTiesToEven, &ignored); 374 // If there was no overflow, the source value is within the range of 375 // values that can be represented. 376 if (ConvertStatus & llvm::APFloat::opOverflow) { 377 ConstantType = Initializer->getType(); 378 return NK_Constant_Narrowing; 379 } 380 } else { 381 return NK_Variable_Narrowing; 382 } 383 } 384 return NK_Not_Narrowing; 385 386 // -- from an integer type or unscoped enumeration type to an integer type 387 // that cannot represent all the values of the original type, except where 388 // the source is a constant expression and the actual value after 389 // conversion will fit into the target type and will produce the original 390 // value when converted back to the original type. 391 case ICK_Boolean_Conversion: // Bools are integers too. 392 if (!FromType->isIntegralOrUnscopedEnumerationType()) { 393 // Boolean conversions can be from pointers and pointers to members 394 // [conv.bool], and those aren't considered narrowing conversions. 395 return NK_Not_Narrowing; 396 } // Otherwise, fall through to the integral case. 397 case ICK_Integral_Conversion: { 398 assert(FromType->isIntegralOrUnscopedEnumerationType()); 399 assert(ToType->isIntegralOrUnscopedEnumerationType()); 400 const bool FromSigned = FromType->isSignedIntegerOrEnumerationType(); 401 const unsigned FromWidth = Ctx.getIntWidth(FromType); 402 const bool ToSigned = ToType->isSignedIntegerOrEnumerationType(); 403 const unsigned ToWidth = Ctx.getIntWidth(ToType); 404 405 if (FromWidth > ToWidth || 406 (FromWidth == ToWidth && FromSigned != ToSigned) || 407 (FromSigned && !ToSigned)) { 408 // Not all values of FromType can be represented in ToType. 409 llvm::APSInt InitializerValue; 410 const Expr *Initializer = IgnoreNarrowingConversion(Converted); 411 if (!Initializer->isIntegerConstantExpr(InitializerValue, Ctx)) { 412 // Such conversions on variables are always narrowing. 413 return NK_Variable_Narrowing; 414 } 415 bool Narrowing = false; 416 if (FromWidth < ToWidth) { 417 // Negative -> unsigned is narrowing. Otherwise, more bits is never 418 // narrowing. 419 if (InitializerValue.isSigned() && InitializerValue.isNegative()) 420 Narrowing = true; 421 } else { 422 // Add a bit to the InitializerValue so we don't have to worry about 423 // signed vs. unsigned comparisons. 424 InitializerValue = InitializerValue.extend( 425 InitializerValue.getBitWidth() + 1); 426 // Convert the initializer to and from the target width and signed-ness. 427 llvm::APSInt ConvertedValue = InitializerValue; 428 ConvertedValue = ConvertedValue.trunc(ToWidth); 429 ConvertedValue.setIsSigned(ToSigned); 430 ConvertedValue = ConvertedValue.extend(InitializerValue.getBitWidth()); 431 ConvertedValue.setIsSigned(InitializerValue.isSigned()); 432 // If the result is different, this was a narrowing conversion. 433 if (ConvertedValue != InitializerValue) 434 Narrowing = true; 435 } 436 if (Narrowing) { 437 ConstantType = Initializer->getType(); 438 ConstantValue = APValue(InitializerValue); 439 return NK_Constant_Narrowing; 440 } 441 } 442 return NK_Not_Narrowing; 443 } 444 445 default: 446 // Other kinds of conversions are not narrowings. 447 return NK_Not_Narrowing; 448 } 449 } 450 451 /// DebugPrint - Print this standard conversion sequence to standard 452 /// error. Useful for debugging overloading issues. 453 void StandardConversionSequence::DebugPrint() const { 454 raw_ostream &OS = llvm::errs(); 455 bool PrintedSomething = false; 456 if (First != ICK_Identity) { 457 OS << GetImplicitConversionName(First); 458 PrintedSomething = true; 459 } 460 461 if (Second != ICK_Identity) { 462 if (PrintedSomething) { 463 OS << " -> "; 464 } 465 OS << GetImplicitConversionName(Second); 466 467 if (CopyConstructor) { 468 OS << " (by copy constructor)"; 469 } else if (DirectBinding) { 470 OS << " (direct reference binding)"; 471 } else if (ReferenceBinding) { 472 OS << " (reference binding)"; 473 } 474 PrintedSomething = true; 475 } 476 477 if (Third != ICK_Identity) { 478 if (PrintedSomething) { 479 OS << " -> "; 480 } 481 OS << GetImplicitConversionName(Third); 482 PrintedSomething = true; 483 } 484 485 if (!PrintedSomething) { 486 OS << "No conversions required"; 487 } 488 } 489 490 /// DebugPrint - Print this user-defined conversion sequence to standard 491 /// error. Useful for debugging overloading issues. 492 void UserDefinedConversionSequence::DebugPrint() const { 493 raw_ostream &OS = llvm::errs(); 494 if (Before.First || Before.Second || Before.Third) { 495 Before.DebugPrint(); 496 OS << " -> "; 497 } 498 if (ConversionFunction) 499 OS << '\'' << *ConversionFunction << '\''; 500 else 501 OS << "aggregate initialization"; 502 if (After.First || After.Second || After.Third) { 503 OS << " -> "; 504 After.DebugPrint(); 505 } 506 } 507 508 /// DebugPrint - Print this implicit conversion sequence to standard 509 /// error. Useful for debugging overloading issues. 510 void ImplicitConversionSequence::DebugPrint() const { 511 raw_ostream &OS = llvm::errs(); 512 switch (ConversionKind) { 513 case StandardConversion: 514 OS << "Standard conversion: "; 515 Standard.DebugPrint(); 516 break; 517 case UserDefinedConversion: 518 OS << "User-defined conversion: "; 519 UserDefined.DebugPrint(); 520 break; 521 case EllipsisConversion: 522 OS << "Ellipsis conversion"; 523 break; 524 case AmbiguousConversion: 525 OS << "Ambiguous conversion"; 526 break; 527 case BadConversion: 528 OS << "Bad conversion"; 529 break; 530 } 531 532 OS << "\n"; 533 } 534 535 void AmbiguousConversionSequence::construct() { 536 new (&conversions()) ConversionSet(); 537 } 538 539 void AmbiguousConversionSequence::destruct() { 540 conversions().~ConversionSet(); 541 } 542 543 void 544 AmbiguousConversionSequence::copyFrom(const AmbiguousConversionSequence &O) { 545 FromTypePtr = O.FromTypePtr; 546 ToTypePtr = O.ToTypePtr; 547 new (&conversions()) ConversionSet(O.conversions()); 548 } 549 550 namespace { 551 // Structure used by DeductionFailureInfo to store 552 // template argument information. 553 struct DFIArguments { 554 TemplateArgument FirstArg; 555 TemplateArgument SecondArg; 556 }; 557 // Structure used by DeductionFailureInfo to store 558 // template parameter and template argument information. 559 struct DFIParamWithArguments : DFIArguments { 560 TemplateParameter Param; 561 }; 562 } 563 564 /// \brief Convert from Sema's representation of template deduction information 565 /// to the form used in overload-candidate information. 566 DeductionFailureInfo MakeDeductionFailureInfo(ASTContext &Context, 567 Sema::TemplateDeductionResult TDK, 568 TemplateDeductionInfo &Info) { 569 DeductionFailureInfo Result; 570 Result.Result = static_cast<unsigned>(TDK); 571 Result.HasDiagnostic = false; 572 Result.Data = 0; 573 switch (TDK) { 574 case Sema::TDK_Success: 575 case Sema::TDK_Invalid: 576 case Sema::TDK_InstantiationDepth: 577 case Sema::TDK_TooManyArguments: 578 case Sema::TDK_TooFewArguments: 579 break; 580 581 case Sema::TDK_Incomplete: 582 case Sema::TDK_InvalidExplicitArguments: 583 Result.Data = Info.Param.getOpaqueValue(); 584 break; 585 586 case Sema::TDK_NonDeducedMismatch: { 587 // FIXME: Should allocate from normal heap so that we can free this later. 588 DFIArguments *Saved = new (Context) DFIArguments; 589 Saved->FirstArg = Info.FirstArg; 590 Saved->SecondArg = Info.SecondArg; 591 Result.Data = Saved; 592 break; 593 } 594 595 case Sema::TDK_Inconsistent: 596 case Sema::TDK_Underqualified: { 597 // FIXME: Should allocate from normal heap so that we can free this later. 598 DFIParamWithArguments *Saved = new (Context) DFIParamWithArguments; 599 Saved->Param = Info.Param; 600 Saved->FirstArg = Info.FirstArg; 601 Saved->SecondArg = Info.SecondArg; 602 Result.Data = Saved; 603 break; 604 } 605 606 case Sema::TDK_SubstitutionFailure: 607 Result.Data = Info.take(); 608 if (Info.hasSFINAEDiagnostic()) { 609 PartialDiagnosticAt *Diag = new (Result.Diagnostic) PartialDiagnosticAt( 610 SourceLocation(), PartialDiagnostic::NullDiagnostic()); 611 Info.takeSFINAEDiagnostic(*Diag); 612 Result.HasDiagnostic = true; 613 } 614 break; 615 616 case Sema::TDK_FailedOverloadResolution: 617 Result.Data = Info.Expression; 618 break; 619 620 case Sema::TDK_MiscellaneousDeductionFailure: 621 break; 622 } 623 624 return Result; 625 } 626 627 void DeductionFailureInfo::Destroy() { 628 switch (static_cast<Sema::TemplateDeductionResult>(Result)) { 629 case Sema::TDK_Success: 630 case Sema::TDK_Invalid: 631 case Sema::TDK_InstantiationDepth: 632 case Sema::TDK_Incomplete: 633 case Sema::TDK_TooManyArguments: 634 case Sema::TDK_TooFewArguments: 635 case Sema::TDK_InvalidExplicitArguments: 636 case Sema::TDK_FailedOverloadResolution: 637 break; 638 639 case Sema::TDK_Inconsistent: 640 case Sema::TDK_Underqualified: 641 case Sema::TDK_NonDeducedMismatch: 642 // FIXME: Destroy the data? 643 Data = 0; 644 break; 645 646 case Sema::TDK_SubstitutionFailure: 647 // FIXME: Destroy the template argument list? 648 Data = 0; 649 if (PartialDiagnosticAt *Diag = getSFINAEDiagnostic()) { 650 Diag->~PartialDiagnosticAt(); 651 HasDiagnostic = false; 652 } 653 break; 654 655 // Unhandled 656 case Sema::TDK_MiscellaneousDeductionFailure: 657 break; 658 } 659 } 660 661 PartialDiagnosticAt *DeductionFailureInfo::getSFINAEDiagnostic() { 662 if (HasDiagnostic) 663 return static_cast<PartialDiagnosticAt*>(static_cast<void*>(Diagnostic)); 664 return 0; 665 } 666 667 TemplateParameter DeductionFailureInfo::getTemplateParameter() { 668 switch (static_cast<Sema::TemplateDeductionResult>(Result)) { 669 case Sema::TDK_Success: 670 case Sema::TDK_Invalid: 671 case Sema::TDK_InstantiationDepth: 672 case Sema::TDK_TooManyArguments: 673 case Sema::TDK_TooFewArguments: 674 case Sema::TDK_SubstitutionFailure: 675 case Sema::TDK_NonDeducedMismatch: 676 case Sema::TDK_FailedOverloadResolution: 677 return TemplateParameter(); 678 679 case Sema::TDK_Incomplete: 680 case Sema::TDK_InvalidExplicitArguments: 681 return TemplateParameter::getFromOpaqueValue(Data); 682 683 case Sema::TDK_Inconsistent: 684 case Sema::TDK_Underqualified: 685 return static_cast<DFIParamWithArguments*>(Data)->Param; 686 687 // Unhandled 688 case Sema::TDK_MiscellaneousDeductionFailure: 689 break; 690 } 691 692 return TemplateParameter(); 693 } 694 695 TemplateArgumentList *DeductionFailureInfo::getTemplateArgumentList() { 696 switch (static_cast<Sema::TemplateDeductionResult>(Result)) { 697 case Sema::TDK_Success: 698 case Sema::TDK_Invalid: 699 case Sema::TDK_InstantiationDepth: 700 case Sema::TDK_TooManyArguments: 701 case Sema::TDK_TooFewArguments: 702 case Sema::TDK_Incomplete: 703 case Sema::TDK_InvalidExplicitArguments: 704 case Sema::TDK_Inconsistent: 705 case Sema::TDK_Underqualified: 706 case Sema::TDK_NonDeducedMismatch: 707 case Sema::TDK_FailedOverloadResolution: 708 return 0; 709 710 case Sema::TDK_SubstitutionFailure: 711 return static_cast<TemplateArgumentList*>(Data); 712 713 // Unhandled 714 case Sema::TDK_MiscellaneousDeductionFailure: 715 break; 716 } 717 718 return 0; 719 } 720 721 const TemplateArgument *DeductionFailureInfo::getFirstArg() { 722 switch (static_cast<Sema::TemplateDeductionResult>(Result)) { 723 case Sema::TDK_Success: 724 case Sema::TDK_Invalid: 725 case Sema::TDK_InstantiationDepth: 726 case Sema::TDK_Incomplete: 727 case Sema::TDK_TooManyArguments: 728 case Sema::TDK_TooFewArguments: 729 case Sema::TDK_InvalidExplicitArguments: 730 case Sema::TDK_SubstitutionFailure: 731 case Sema::TDK_FailedOverloadResolution: 732 return 0; 733 734 case Sema::TDK_Inconsistent: 735 case Sema::TDK_Underqualified: 736 case Sema::TDK_NonDeducedMismatch: 737 return &static_cast<DFIArguments*>(Data)->FirstArg; 738 739 // Unhandled 740 case Sema::TDK_MiscellaneousDeductionFailure: 741 break; 742 } 743 744 return 0; 745 } 746 747 const TemplateArgument *DeductionFailureInfo::getSecondArg() { 748 switch (static_cast<Sema::TemplateDeductionResult>(Result)) { 749 case Sema::TDK_Success: 750 case Sema::TDK_Invalid: 751 case Sema::TDK_InstantiationDepth: 752 case Sema::TDK_Incomplete: 753 case Sema::TDK_TooManyArguments: 754 case Sema::TDK_TooFewArguments: 755 case Sema::TDK_InvalidExplicitArguments: 756 case Sema::TDK_SubstitutionFailure: 757 case Sema::TDK_FailedOverloadResolution: 758 return 0; 759 760 case Sema::TDK_Inconsistent: 761 case Sema::TDK_Underqualified: 762 case Sema::TDK_NonDeducedMismatch: 763 return &static_cast<DFIArguments*>(Data)->SecondArg; 764 765 // Unhandled 766 case Sema::TDK_MiscellaneousDeductionFailure: 767 break; 768 } 769 770 return 0; 771 } 772 773 Expr *DeductionFailureInfo::getExpr() { 774 if (static_cast<Sema::TemplateDeductionResult>(Result) == 775 Sema::TDK_FailedOverloadResolution) 776 return static_cast<Expr*>(Data); 777 778 return 0; 779 } 780 781 void OverloadCandidateSet::destroyCandidates() { 782 for (iterator i = begin(), e = end(); i != e; ++i) { 783 for (unsigned ii = 0, ie = i->NumConversions; ii != ie; ++ii) 784 i->Conversions[ii].~ImplicitConversionSequence(); 785 if (!i->Viable && i->FailureKind == ovl_fail_bad_deduction) 786 i->DeductionFailure.Destroy(); 787 } 788 } 789 790 void OverloadCandidateSet::clear() { 791 destroyCandidates(); 792 NumInlineSequences = 0; 793 Candidates.clear(); 794 Functions.clear(); 795 } 796 797 namespace { 798 class UnbridgedCastsSet { 799 struct Entry { 800 Expr **Addr; 801 Expr *Saved; 802 }; 803 SmallVector<Entry, 2> Entries; 804 805 public: 806 void save(Sema &S, Expr *&E) { 807 assert(E->hasPlaceholderType(BuiltinType::ARCUnbridgedCast)); 808 Entry entry = { &E, E }; 809 Entries.push_back(entry); 810 E = S.stripARCUnbridgedCast(E); 811 } 812 813 void restore() { 814 for (SmallVectorImpl<Entry>::iterator 815 i = Entries.begin(), e = Entries.end(); i != e; ++i) 816 *i->Addr = i->Saved; 817 } 818 }; 819 } 820 821 /// checkPlaceholderForOverload - Do any interesting placeholder-like 822 /// preprocessing on the given expression. 823 /// 824 /// \param unbridgedCasts a collection to which to add unbridged casts; 825 /// without this, they will be immediately diagnosed as errors 826 /// 827 /// Return true on unrecoverable error. 828 static bool checkPlaceholderForOverload(Sema &S, Expr *&E, 829 UnbridgedCastsSet *unbridgedCasts = 0) { 830 if (const BuiltinType *placeholder = E->getType()->getAsPlaceholderType()) { 831 // We can't handle overloaded expressions here because overload 832 // resolution might reasonably tweak them. 833 if (placeholder->getKind() == BuiltinType::Overload) return false; 834 835 // If the context potentially accepts unbridged ARC casts, strip 836 // the unbridged cast and add it to the collection for later restoration. 837 if (placeholder->getKind() == BuiltinType::ARCUnbridgedCast && 838 unbridgedCasts) { 839 unbridgedCasts->save(S, E); 840 return false; 841 } 842 843 // Go ahead and check everything else. 844 ExprResult result = S.CheckPlaceholderExpr(E); 845 if (result.isInvalid()) 846 return true; 847 848 E = result.take(); 849 return false; 850 } 851 852 // Nothing to do. 853 return false; 854 } 855 856 /// checkArgPlaceholdersForOverload - Check a set of call operands for 857 /// placeholders. 858 static bool checkArgPlaceholdersForOverload(Sema &S, 859 MultiExprArg Args, 860 UnbridgedCastsSet &unbridged) { 861 for (unsigned i = 0, e = Args.size(); i != e; ++i) 862 if (checkPlaceholderForOverload(S, Args[i], &unbridged)) 863 return true; 864 865 return false; 866 } 867 868 // IsOverload - Determine whether the given New declaration is an 869 // overload of the declarations in Old. This routine returns false if 870 // New and Old cannot be overloaded, e.g., if New has the same 871 // signature as some function in Old (C++ 1.3.10) or if the Old 872 // declarations aren't functions (or function templates) at all. When 873 // it does return false, MatchedDecl will point to the decl that New 874 // cannot be overloaded with. This decl may be a UsingShadowDecl on 875 // top of the underlying declaration. 876 // 877 // Example: Given the following input: 878 // 879 // void f(int, float); // #1 880 // void f(int, int); // #2 881 // int f(int, int); // #3 882 // 883 // When we process #1, there is no previous declaration of "f", 884 // so IsOverload will not be used. 885 // 886 // When we process #2, Old contains only the FunctionDecl for #1. By 887 // comparing the parameter types, we see that #1 and #2 are overloaded 888 // (since they have different signatures), so this routine returns 889 // false; MatchedDecl is unchanged. 890 // 891 // When we process #3, Old is an overload set containing #1 and #2. We 892 // compare the signatures of #3 to #1 (they're overloaded, so we do 893 // nothing) and then #3 to #2. Since the signatures of #3 and #2 are 894 // identical (return types of functions are not part of the 895 // signature), IsOverload returns false and MatchedDecl will be set to 896 // point to the FunctionDecl for #2. 897 // 898 // 'NewIsUsingShadowDecl' indicates that 'New' is being introduced 899 // into a class by a using declaration. The rules for whether to hide 900 // shadow declarations ignore some properties which otherwise figure 901 // into a function template's signature. 902 Sema::OverloadKind 903 Sema::CheckOverload(Scope *S, FunctionDecl *New, const LookupResult &Old, 904 NamedDecl *&Match, bool NewIsUsingDecl) { 905 for (LookupResult::iterator I = Old.begin(), E = Old.end(); 906 I != E; ++I) { 907 NamedDecl *OldD = *I; 908 909 bool OldIsUsingDecl = false; 910 if (isa<UsingShadowDecl>(OldD)) { 911 OldIsUsingDecl = true; 912 913 // We can always introduce two using declarations into the same 914 // context, even if they have identical signatures. 915 if (NewIsUsingDecl) continue; 916 917 OldD = cast<UsingShadowDecl>(OldD)->getTargetDecl(); 918 } 919 920 // If either declaration was introduced by a using declaration, 921 // we'll need to use slightly different rules for matching. 922 // Essentially, these rules are the normal rules, except that 923 // function templates hide function templates with different 924 // return types or template parameter lists. 925 bool UseMemberUsingDeclRules = 926 (OldIsUsingDecl || NewIsUsingDecl) && CurContext->isRecord() && 927 !New->getFriendObjectKind(); 928 929 if (FunctionTemplateDecl *OldT = dyn_cast<FunctionTemplateDecl>(OldD)) { 930 if (!IsOverload(New, OldT->getTemplatedDecl(), UseMemberUsingDeclRules)) { 931 if (UseMemberUsingDeclRules && OldIsUsingDecl) { 932 HideUsingShadowDecl(S, cast<UsingShadowDecl>(*I)); 933 continue; 934 } 935 936 Match = *I; 937 return Ovl_Match; 938 } 939 } else if (FunctionDecl *OldF = dyn_cast<FunctionDecl>(OldD)) { 940 if (!IsOverload(New, OldF, UseMemberUsingDeclRules)) { 941 if (UseMemberUsingDeclRules && OldIsUsingDecl) { 942 HideUsingShadowDecl(S, cast<UsingShadowDecl>(*I)); 943 continue; 944 } 945 946 if (!shouldLinkPossiblyHiddenDecl(*I, New)) 947 continue; 948 949 Match = *I; 950 return Ovl_Match; 951 } 952 } else if (isa<UsingDecl>(OldD)) { 953 // We can overload with these, which can show up when doing 954 // redeclaration checks for UsingDecls. 955 assert(Old.getLookupKind() == LookupUsingDeclName); 956 } else if (isa<TagDecl>(OldD)) { 957 // We can always overload with tags by hiding them. 958 } else if (isa<UnresolvedUsingValueDecl>(OldD)) { 959 // Optimistically assume that an unresolved using decl will 960 // overload; if it doesn't, we'll have to diagnose during 961 // template instantiation. 962 } else { 963 // (C++ 13p1): 964 // Only function declarations can be overloaded; object and type 965 // declarations cannot be overloaded. 966 Match = *I; 967 return Ovl_NonFunction; 968 } 969 } 970 971 return Ovl_Overload; 972 } 973 974 bool Sema::IsOverload(FunctionDecl *New, FunctionDecl *Old, 975 bool UseUsingDeclRules) { 976 // C++ [basic.start.main]p2: This function shall not be overloaded. 977 if (New->isMain()) 978 return false; 979 980 FunctionTemplateDecl *OldTemplate = Old->getDescribedFunctionTemplate(); 981 FunctionTemplateDecl *NewTemplate = New->getDescribedFunctionTemplate(); 982 983 // C++ [temp.fct]p2: 984 // A function template can be overloaded with other function templates 985 // and with normal (non-template) functions. 986 if ((OldTemplate == 0) != (NewTemplate == 0)) 987 return true; 988 989 // Is the function New an overload of the function Old? 990 QualType OldQType = Context.getCanonicalType(Old->getType()); 991 QualType NewQType = Context.getCanonicalType(New->getType()); 992 993 // Compare the signatures (C++ 1.3.10) of the two functions to 994 // determine whether they are overloads. If we find any mismatch 995 // in the signature, they are overloads. 996 997 // If either of these functions is a K&R-style function (no 998 // prototype), then we consider them to have matching signatures. 999 if (isa<FunctionNoProtoType>(OldQType.getTypePtr()) || 1000 isa<FunctionNoProtoType>(NewQType.getTypePtr())) 1001 return false; 1002 1003 const FunctionProtoType* OldType = cast<FunctionProtoType>(OldQType); 1004 const FunctionProtoType* NewType = cast<FunctionProtoType>(NewQType); 1005 1006 // The signature of a function includes the types of its 1007 // parameters (C++ 1.3.10), which includes the presence or absence 1008 // of the ellipsis; see C++ DR 357). 1009 if (OldQType != NewQType && 1010 (OldType->getNumArgs() != NewType->getNumArgs() || 1011 OldType->isVariadic() != NewType->isVariadic() || 1012 !FunctionArgTypesAreEqual(OldType, NewType))) 1013 return true; 1014 1015 // C++ [temp.over.link]p4: 1016 // The signature of a function template consists of its function 1017 // signature, its return type and its template parameter list. The names 1018 // of the template parameters are significant only for establishing the 1019 // relationship between the template parameters and the rest of the 1020 // signature. 1021 // 1022 // We check the return type and template parameter lists for function 1023 // templates first; the remaining checks follow. 1024 // 1025 // However, we don't consider either of these when deciding whether 1026 // a member introduced by a shadow declaration is hidden. 1027 if (!UseUsingDeclRules && NewTemplate && 1028 (!TemplateParameterListsAreEqual(NewTemplate->getTemplateParameters(), 1029 OldTemplate->getTemplateParameters(), 1030 false, TPL_TemplateMatch) || 1031 OldType->getResultType() != NewType->getResultType())) 1032 return true; 1033 1034 // If the function is a class member, its signature includes the 1035 // cv-qualifiers (if any) and ref-qualifier (if any) on the function itself. 1036 // 1037 // As part of this, also check whether one of the member functions 1038 // is static, in which case they are not overloads (C++ 1039 // 13.1p2). While not part of the definition of the signature, 1040 // this check is important to determine whether these functions 1041 // can be overloaded. 1042 CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old); 1043 CXXMethodDecl *NewMethod = dyn_cast<CXXMethodDecl>(New); 1044 if (OldMethod && NewMethod && 1045 !OldMethod->isStatic() && !NewMethod->isStatic()) { 1046 if (OldMethod->getRefQualifier() != NewMethod->getRefQualifier()) { 1047 if (!UseUsingDeclRules && 1048 (OldMethod->getRefQualifier() == RQ_None || 1049 NewMethod->getRefQualifier() == RQ_None)) { 1050 // C++0x [over.load]p2: 1051 // - Member function declarations with the same name and the same 1052 // parameter-type-list as well as member function template 1053 // declarations with the same name, the same parameter-type-list, and 1054 // the same template parameter lists cannot be overloaded if any of 1055 // them, but not all, have a ref-qualifier (8.3.5). 1056 Diag(NewMethod->getLocation(), diag::err_ref_qualifier_overload) 1057 << NewMethod->getRefQualifier() << OldMethod->getRefQualifier(); 1058 Diag(OldMethod->getLocation(), diag::note_previous_declaration); 1059 } 1060 return true; 1061 } 1062 1063 // We may not have applied the implicit const for a constexpr member 1064 // function yet (because we haven't yet resolved whether this is a static 1065 // or non-static member function). Add it now, on the assumption that this 1066 // is a redeclaration of OldMethod. 1067 unsigned NewQuals = NewMethod->getTypeQualifiers(); 1068 if (!getLangOpts().CPlusPlus1y && NewMethod->isConstexpr() && 1069 !isa<CXXConstructorDecl>(NewMethod)) 1070 NewQuals |= Qualifiers::Const; 1071 if (OldMethod->getTypeQualifiers() != NewQuals) 1072 return true; 1073 } 1074 1075 // The signatures match; this is not an overload. 1076 return false; 1077 } 1078 1079 /// \brief Checks availability of the function depending on the current 1080 /// function context. Inside an unavailable function, unavailability is ignored. 1081 /// 1082 /// \returns true if \arg FD is unavailable and current context is inside 1083 /// an available function, false otherwise. 1084 bool Sema::isFunctionConsideredUnavailable(FunctionDecl *FD) { 1085 return FD->isUnavailable() && !cast<Decl>(CurContext)->isUnavailable(); 1086 } 1087 1088 /// \brief Tries a user-defined conversion from From to ToType. 1089 /// 1090 /// Produces an implicit conversion sequence for when a standard conversion 1091 /// is not an option. See TryImplicitConversion for more information. 1092 static ImplicitConversionSequence 1093 TryUserDefinedConversion(Sema &S, Expr *From, QualType ToType, 1094 bool SuppressUserConversions, 1095 bool AllowExplicit, 1096 bool InOverloadResolution, 1097 bool CStyle, 1098 bool AllowObjCWritebackConversion) { 1099 ImplicitConversionSequence ICS; 1100 1101 if (SuppressUserConversions) { 1102 // We're not in the case above, so there is no conversion that 1103 // we can perform. 1104 ICS.setBad(BadConversionSequence::no_conversion, From, ToType); 1105 return ICS; 1106 } 1107 1108 // Attempt user-defined conversion. 1109 OverloadCandidateSet Conversions(From->getExprLoc()); 1110 OverloadingResult UserDefResult 1111 = IsUserDefinedConversion(S, From, ToType, ICS.UserDefined, Conversions, 1112 AllowExplicit); 1113 1114 if (UserDefResult == OR_Success) { 1115 ICS.setUserDefined(); 1116 // C++ [over.ics.user]p4: 1117 // A conversion of an expression of class type to the same class 1118 // type is given Exact Match rank, and a conversion of an 1119 // expression of class type to a base class of that type is 1120 // given Conversion rank, in spite of the fact that a copy 1121 // constructor (i.e., a user-defined conversion function) is 1122 // called for those cases. 1123 if (CXXConstructorDecl *Constructor 1124 = dyn_cast<CXXConstructorDecl>(ICS.UserDefined.ConversionFunction)) { 1125 QualType FromCanon 1126 = S.Context.getCanonicalType(From->getType().getUnqualifiedType()); 1127 QualType ToCanon 1128 = S.Context.getCanonicalType(ToType).getUnqualifiedType(); 1129 if (Constructor->isCopyConstructor() && 1130 (FromCanon == ToCanon || S.IsDerivedFrom(FromCanon, ToCanon))) { 1131 // Turn this into a "standard" conversion sequence, so that it 1132 // gets ranked with standard conversion sequences. 1133 ICS.setStandard(); 1134 ICS.Standard.setAsIdentityConversion(); 1135 ICS.Standard.setFromType(From->getType()); 1136 ICS.Standard.setAllToTypes(ToType); 1137 ICS.Standard.CopyConstructor = Constructor; 1138 if (ToCanon != FromCanon) 1139 ICS.Standard.Second = ICK_Derived_To_Base; 1140 } 1141 } 1142 1143 // C++ [over.best.ics]p4: 1144 // However, when considering the argument of a user-defined 1145 // conversion function that is a candidate by 13.3.1.3 when 1146 // invoked for the copying of the temporary in the second step 1147 // of a class copy-initialization, or by 13.3.1.4, 13.3.1.5, or 1148 // 13.3.1.6 in all cases, only standard conversion sequences and 1149 // ellipsis conversion sequences are allowed. 1150 if (SuppressUserConversions && ICS.isUserDefined()) { 1151 ICS.setBad(BadConversionSequence::suppressed_user, From, ToType); 1152 } 1153 } else if (UserDefResult == OR_Ambiguous && !SuppressUserConversions) { 1154 ICS.setAmbiguous(); 1155 ICS.Ambiguous.setFromType(From->getType()); 1156 ICS.Ambiguous.setToType(ToType); 1157 for (OverloadCandidateSet::iterator Cand = Conversions.begin(); 1158 Cand != Conversions.end(); ++Cand) 1159 if (Cand->Viable) 1160 ICS.Ambiguous.addConversion(Cand->Function); 1161 } else { 1162 ICS.setBad(BadConversionSequence::no_conversion, From, ToType); 1163 } 1164 1165 return ICS; 1166 } 1167 1168 /// TryImplicitConversion - Attempt to perform an implicit conversion 1169 /// from the given expression (Expr) to the given type (ToType). This 1170 /// function returns an implicit conversion sequence that can be used 1171 /// to perform the initialization. Given 1172 /// 1173 /// void f(float f); 1174 /// void g(int i) { f(i); } 1175 /// 1176 /// this routine would produce an implicit conversion sequence to 1177 /// describe the initialization of f from i, which will be a standard 1178 /// conversion sequence containing an lvalue-to-rvalue conversion (C++ 1179 /// 4.1) followed by a floating-integral conversion (C++ 4.9). 1180 // 1181 /// Note that this routine only determines how the conversion can be 1182 /// performed; it does not actually perform the conversion. As such, 1183 /// it will not produce any diagnostics if no conversion is available, 1184 /// but will instead return an implicit conversion sequence of kind 1185 /// "BadConversion". 1186 /// 1187 /// If @p SuppressUserConversions, then user-defined conversions are 1188 /// not permitted. 1189 /// If @p AllowExplicit, then explicit user-defined conversions are 1190 /// permitted. 1191 /// 1192 /// \param AllowObjCWritebackConversion Whether we allow the Objective-C 1193 /// writeback conversion, which allows __autoreleasing id* parameters to 1194 /// be initialized with __strong id* or __weak id* arguments. 1195 static ImplicitConversionSequence 1196 TryImplicitConversion(Sema &S, Expr *From, QualType ToType, 1197 bool SuppressUserConversions, 1198 bool AllowExplicit, 1199 bool InOverloadResolution, 1200 bool CStyle, 1201 bool AllowObjCWritebackConversion) { 1202 ImplicitConversionSequence ICS; 1203 if (IsStandardConversion(S, From, ToType, InOverloadResolution, 1204 ICS.Standard, CStyle, AllowObjCWritebackConversion)){ 1205 ICS.setStandard(); 1206 return ICS; 1207 } 1208 1209 if (!S.getLangOpts().CPlusPlus) { 1210 ICS.setBad(BadConversionSequence::no_conversion, From, ToType); 1211 return ICS; 1212 } 1213 1214 // C++ [over.ics.user]p4: 1215 // A conversion of an expression of class type to the same class 1216 // type is given Exact Match rank, and a conversion of an 1217 // expression of class type to a base class of that type is 1218 // given Conversion rank, in spite of the fact that a copy/move 1219 // constructor (i.e., a user-defined conversion function) is 1220 // called for those cases. 1221 QualType FromType = From->getType(); 1222 if (ToType->getAs<RecordType>() && FromType->getAs<RecordType>() && 1223 (S.Context.hasSameUnqualifiedType(FromType, ToType) || 1224 S.IsDerivedFrom(FromType, ToType))) { 1225 ICS.setStandard(); 1226 ICS.Standard.setAsIdentityConversion(); 1227 ICS.Standard.setFromType(FromType); 1228 ICS.Standard.setAllToTypes(ToType); 1229 1230 // We don't actually check at this point whether there is a valid 1231 // copy/move constructor, since overloading just assumes that it 1232 // exists. When we actually perform initialization, we'll find the 1233 // appropriate constructor to copy the returned object, if needed. 1234 ICS.Standard.CopyConstructor = 0; 1235 1236 // Determine whether this is considered a derived-to-base conversion. 1237 if (!S.Context.hasSameUnqualifiedType(FromType, ToType)) 1238 ICS.Standard.Second = ICK_Derived_To_Base; 1239 1240 return ICS; 1241 } 1242 1243 return TryUserDefinedConversion(S, From, ToType, SuppressUserConversions, 1244 AllowExplicit, InOverloadResolution, CStyle, 1245 AllowObjCWritebackConversion); 1246 } 1247 1248 ImplicitConversionSequence 1249 Sema::TryImplicitConversion(Expr *From, QualType ToType, 1250 bool SuppressUserConversions, 1251 bool AllowExplicit, 1252 bool InOverloadResolution, 1253 bool CStyle, 1254 bool AllowObjCWritebackConversion) { 1255 return clang::TryImplicitConversion(*this, From, ToType, 1256 SuppressUserConversions, AllowExplicit, 1257 InOverloadResolution, CStyle, 1258 AllowObjCWritebackConversion); 1259 } 1260 1261 /// PerformImplicitConversion - Perform an implicit conversion of the 1262 /// expression From to the type ToType. Returns the 1263 /// converted expression. Flavor is the kind of conversion we're 1264 /// performing, used in the error message. If @p AllowExplicit, 1265 /// explicit user-defined conversions are permitted. 1266 ExprResult 1267 Sema::PerformImplicitConversion(Expr *From, QualType ToType, 1268 AssignmentAction Action, bool AllowExplicit) { 1269 ImplicitConversionSequence ICS; 1270 return PerformImplicitConversion(From, ToType, Action, AllowExplicit, ICS); 1271 } 1272 1273 ExprResult 1274 Sema::PerformImplicitConversion(Expr *From, QualType ToType, 1275 AssignmentAction Action, bool AllowExplicit, 1276 ImplicitConversionSequence& ICS) { 1277 if (checkPlaceholderForOverload(*this, From)) 1278 return ExprError(); 1279 1280 // Objective-C ARC: Determine whether we will allow the writeback conversion. 1281 bool AllowObjCWritebackConversion 1282 = getLangOpts().ObjCAutoRefCount && 1283 (Action == AA_Passing || Action == AA_Sending); 1284 1285 ICS = clang::TryImplicitConversion(*this, From, ToType, 1286 /*SuppressUserConversions=*/false, 1287 AllowExplicit, 1288 /*InOverloadResolution=*/false, 1289 /*CStyle=*/false, 1290 AllowObjCWritebackConversion); 1291 return PerformImplicitConversion(From, ToType, ICS, Action); 1292 } 1293 1294 /// \brief Determine whether the conversion from FromType to ToType is a valid 1295 /// conversion that strips "noreturn" off the nested function type. 1296 bool Sema::IsNoReturnConversion(QualType FromType, QualType ToType, 1297 QualType &ResultTy) { 1298 if (Context.hasSameUnqualifiedType(FromType, ToType)) 1299 return false; 1300 1301 // Permit the conversion F(t __attribute__((noreturn))) -> F(t) 1302 // where F adds one of the following at most once: 1303 // - a pointer 1304 // - a member pointer 1305 // - a block pointer 1306 CanQualType CanTo = Context.getCanonicalType(ToType); 1307 CanQualType CanFrom = Context.getCanonicalType(FromType); 1308 Type::TypeClass TyClass = CanTo->getTypeClass(); 1309 if (TyClass != CanFrom->getTypeClass()) return false; 1310 if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto) { 1311 if (TyClass == Type::Pointer) { 1312 CanTo = CanTo.getAs<PointerType>()->getPointeeType(); 1313 CanFrom = CanFrom.getAs<PointerType>()->getPointeeType(); 1314 } else if (TyClass == Type::BlockPointer) { 1315 CanTo = CanTo.getAs<BlockPointerType>()->getPointeeType(); 1316 CanFrom = CanFrom.getAs<BlockPointerType>()->getPointeeType(); 1317 } else if (TyClass == Type::MemberPointer) { 1318 CanTo = CanTo.getAs<MemberPointerType>()->getPointeeType(); 1319 CanFrom = CanFrom.getAs<MemberPointerType>()->getPointeeType(); 1320 } else { 1321 return false; 1322 } 1323 1324 TyClass = CanTo->getTypeClass(); 1325 if (TyClass != CanFrom->getTypeClass()) return false; 1326 if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto) 1327 return false; 1328 } 1329 1330 const FunctionType *FromFn = cast<FunctionType>(CanFrom); 1331 FunctionType::ExtInfo EInfo = FromFn->getExtInfo(); 1332 if (!EInfo.getNoReturn()) return false; 1333 1334 FromFn = Context.adjustFunctionType(FromFn, EInfo.withNoReturn(false)); 1335 assert(QualType(FromFn, 0).isCanonical()); 1336 if (QualType(FromFn, 0) != CanTo) return false; 1337 1338 ResultTy = ToType; 1339 return true; 1340 } 1341 1342 /// \brief Determine whether the conversion from FromType to ToType is a valid 1343 /// vector conversion. 1344 /// 1345 /// \param ICK Will be set to the vector conversion kind, if this is a vector 1346 /// conversion. 1347 static bool IsVectorConversion(ASTContext &Context, QualType FromType, 1348 QualType ToType, ImplicitConversionKind &ICK) { 1349 // We need at least one of these types to be a vector type to have a vector 1350 // conversion. 1351 if (!ToType->isVectorType() && !FromType->isVectorType()) 1352 return false; 1353 1354 // Identical types require no conversions. 1355 if (Context.hasSameUnqualifiedType(FromType, ToType)) 1356 return false; 1357 1358 // There are no conversions between extended vector types, only identity. 1359 if (ToType->isExtVectorType()) { 1360 // There are no conversions between extended vector types other than the 1361 // identity conversion. 1362 if (FromType->isExtVectorType()) 1363 return false; 1364 1365 // Vector splat from any arithmetic type to a vector. 1366 if (FromType->isArithmeticType()) { 1367 ICK = ICK_Vector_Splat; 1368 return true; 1369 } 1370 } 1371 1372 // We can perform the conversion between vector types in the following cases: 1373 // 1)vector types are equivalent AltiVec and GCC vector types 1374 // 2)lax vector conversions are permitted and the vector types are of the 1375 // same size 1376 if (ToType->isVectorType() && FromType->isVectorType()) { 1377 if (Context.areCompatibleVectorTypes(FromType, ToType) || 1378 (Context.getLangOpts().LaxVectorConversions && 1379 (Context.getTypeSize(FromType) == Context.getTypeSize(ToType)))) { 1380 ICK = ICK_Vector_Conversion; 1381 return true; 1382 } 1383 } 1384 1385 return false; 1386 } 1387 1388 static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType, 1389 bool InOverloadResolution, 1390 StandardConversionSequence &SCS, 1391 bool CStyle); 1392 1393 /// IsStandardConversion - Determines whether there is a standard 1394 /// conversion sequence (C++ [conv], C++ [over.ics.scs]) from the 1395 /// expression From to the type ToType. Standard conversion sequences 1396 /// only consider non-class types; for conversions that involve class 1397 /// types, use TryImplicitConversion. If a conversion exists, SCS will 1398 /// contain the standard conversion sequence required to perform this 1399 /// conversion and this routine will return true. Otherwise, this 1400 /// routine will return false and the value of SCS is unspecified. 1401 static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType, 1402 bool InOverloadResolution, 1403 StandardConversionSequence &SCS, 1404 bool CStyle, 1405 bool AllowObjCWritebackConversion) { 1406 QualType FromType = From->getType(); 1407 1408 // Standard conversions (C++ [conv]) 1409 SCS.setAsIdentityConversion(); 1410 SCS.DeprecatedStringLiteralToCharPtr = false; 1411 SCS.IncompatibleObjC = false; 1412 SCS.setFromType(FromType); 1413 SCS.CopyConstructor = 0; 1414 1415 // There are no standard conversions for class types in C++, so 1416 // abort early. When overloading in C, however, we do permit 1417 if (FromType->isRecordType() || ToType->isRecordType()) { 1418 if (S.getLangOpts().CPlusPlus) 1419 return false; 1420 1421 // When we're overloading in C, we allow, as standard conversions, 1422 } 1423 1424 // The first conversion can be an lvalue-to-rvalue conversion, 1425 // array-to-pointer conversion, or function-to-pointer conversion 1426 // (C++ 4p1). 1427 1428 if (FromType == S.Context.OverloadTy) { 1429 DeclAccessPair AccessPair; 1430 if (FunctionDecl *Fn 1431 = S.ResolveAddressOfOverloadedFunction(From, ToType, false, 1432 AccessPair)) { 1433 // We were able to resolve the address of the overloaded function, 1434 // so we can convert to the type of that function. 1435 FromType = Fn->getType(); 1436 1437 // we can sometimes resolve &foo<int> regardless of ToType, so check 1438 // if the type matches (identity) or we are converting to bool 1439 if (!S.Context.hasSameUnqualifiedType( 1440 S.ExtractUnqualifiedFunctionType(ToType), FromType)) { 1441 QualType resultTy; 1442 // if the function type matches except for [[noreturn]], it's ok 1443 if (!S.IsNoReturnConversion(FromType, 1444 S.ExtractUnqualifiedFunctionType(ToType), resultTy)) 1445 // otherwise, only a boolean conversion is standard 1446 if (!ToType->isBooleanType()) 1447 return false; 1448 } 1449 1450 // Check if the "from" expression is taking the address of an overloaded 1451 // function and recompute the FromType accordingly. Take advantage of the 1452 // fact that non-static member functions *must* have such an address-of 1453 // expression. 1454 CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn); 1455 if (Method && !Method->isStatic()) { 1456 assert(isa<UnaryOperator>(From->IgnoreParens()) && 1457 "Non-unary operator on non-static member address"); 1458 assert(cast<UnaryOperator>(From->IgnoreParens())->getOpcode() 1459 == UO_AddrOf && 1460 "Non-address-of operator on non-static member address"); 1461 const Type *ClassType 1462 = S.Context.getTypeDeclType(Method->getParent()).getTypePtr(); 1463 FromType = S.Context.getMemberPointerType(FromType, ClassType); 1464 } else if (isa<UnaryOperator>(From->IgnoreParens())) { 1465 assert(cast<UnaryOperator>(From->IgnoreParens())->getOpcode() == 1466 UO_AddrOf && 1467 "Non-address-of operator for overloaded function expression"); 1468 FromType = S.Context.getPointerType(FromType); 1469 } 1470 1471 // Check that we've computed the proper type after overload resolution. 1472 assert(S.Context.hasSameType( 1473 FromType, 1474 S.FixOverloadedFunctionReference(From, AccessPair, Fn)->getType())); 1475 } else { 1476 return false; 1477 } 1478 } 1479 // Lvalue-to-rvalue conversion (C++11 4.1): 1480 // A glvalue (3.10) of a non-function, non-array type T can 1481 // be converted to a prvalue. 1482 bool argIsLValue = From->isGLValue(); 1483 if (argIsLValue && 1484 !FromType->isFunctionType() && !FromType->isArrayType() && 1485 S.Context.getCanonicalType(FromType) != S.Context.OverloadTy) { 1486 SCS.First = ICK_Lvalue_To_Rvalue; 1487 1488 // C11 6.3.2.1p2: 1489 // ... if the lvalue has atomic type, the value has the non-atomic version 1490 // of the type of the lvalue ... 1491 if (const AtomicType *Atomic = FromType->getAs<AtomicType>()) 1492 FromType = Atomic->getValueType(); 1493 1494 // If T is a non-class type, the type of the rvalue is the 1495 // cv-unqualified version of T. Otherwise, the type of the rvalue 1496 // is T (C++ 4.1p1). C++ can't get here with class types; in C, we 1497 // just strip the qualifiers because they don't matter. 1498 FromType = FromType.getUnqualifiedType(); 1499 } else if (FromType->isArrayType()) { 1500 // Array-to-pointer conversion (C++ 4.2) 1501 SCS.First = ICK_Array_To_Pointer; 1502 1503 // An lvalue or rvalue of type "array of N T" or "array of unknown 1504 // bound of T" can be converted to an rvalue of type "pointer to 1505 // T" (C++ 4.2p1). 1506 FromType = S.Context.getArrayDecayedType(FromType); 1507 1508 if (S.IsStringLiteralToNonConstPointerConversion(From, ToType)) { 1509 // This conversion is deprecated. (C++ D.4). 1510 SCS.DeprecatedStringLiteralToCharPtr = true; 1511 1512 // For the purpose of ranking in overload resolution 1513 // (13.3.3.1.1), this conversion is considered an 1514 // array-to-pointer conversion followed by a qualification 1515 // conversion (4.4). (C++ 4.2p2) 1516 SCS.Second = ICK_Identity; 1517 SCS.Third = ICK_Qualification; 1518 SCS.QualificationIncludesObjCLifetime = false; 1519 SCS.setAllToTypes(FromType); 1520 return true; 1521 } 1522 } else if (FromType->isFunctionType() && argIsLValue) { 1523 // Function-to-pointer conversion (C++ 4.3). 1524 SCS.First = ICK_Function_To_Pointer; 1525 1526 // An lvalue of function type T can be converted to an rvalue of 1527 // type "pointer to T." The result is a pointer to the 1528 // function. (C++ 4.3p1). 1529 FromType = S.Context.getPointerType(FromType); 1530 } else { 1531 // We don't require any conversions for the first step. 1532 SCS.First = ICK_Identity; 1533 } 1534 SCS.setToType(0, FromType); 1535 1536 // The second conversion can be an integral promotion, floating 1537 // point promotion, integral conversion, floating point conversion, 1538 // floating-integral conversion, pointer conversion, 1539 // pointer-to-member conversion, or boolean conversion (C++ 4p1). 1540 // For overloading in C, this can also be a "compatible-type" 1541 // conversion. 1542 bool IncompatibleObjC = false; 1543 ImplicitConversionKind SecondICK = ICK_Identity; 1544 if (S.Context.hasSameUnqualifiedType(FromType, ToType)) { 1545 // The unqualified versions of the types are the same: there's no 1546 // conversion to do. 1547 SCS.Second = ICK_Identity; 1548 } else if (S.IsIntegralPromotion(From, FromType, ToType)) { 1549 // Integral promotion (C++ 4.5). 1550 SCS.Second = ICK_Integral_Promotion; 1551 FromType = ToType.getUnqualifiedType(); 1552 } else if (S.IsFloatingPointPromotion(FromType, ToType)) { 1553 // Floating point promotion (C++ 4.6). 1554 SCS.Second = ICK_Floating_Promotion; 1555 FromType = ToType.getUnqualifiedType(); 1556 } else if (S.IsComplexPromotion(FromType, ToType)) { 1557 // Complex promotion (Clang extension) 1558 SCS.Second = ICK_Complex_Promotion; 1559 FromType = ToType.getUnqualifiedType(); 1560 } else if (ToType->isBooleanType() && 1561 (FromType->isArithmeticType() || 1562 FromType->isAnyPointerType() || 1563 FromType->isBlockPointerType() || 1564 FromType->isMemberPointerType() || 1565 FromType->isNullPtrType())) { 1566 // Boolean conversions (C++ 4.12). 1567 SCS.Second = ICK_Boolean_Conversion; 1568 FromType = S.Context.BoolTy; 1569 } else if (FromType->isIntegralOrUnscopedEnumerationType() && 1570 ToType->isIntegralType(S.Context)) { 1571 // Integral conversions (C++ 4.7). 1572 SCS.Second = ICK_Integral_Conversion; 1573 FromType = ToType.getUnqualifiedType(); 1574 } else if (FromType->isAnyComplexType() && ToType->isAnyComplexType()) { 1575 // Complex conversions (C99 6.3.1.6) 1576 SCS.Second = ICK_Complex_Conversion; 1577 FromType = ToType.getUnqualifiedType(); 1578 } else if ((FromType->isAnyComplexType() && ToType->isArithmeticType()) || 1579 (ToType->isAnyComplexType() && FromType->isArithmeticType())) { 1580 // Complex-real conversions (C99 6.3.1.7) 1581 SCS.Second = ICK_Complex_Real; 1582 FromType = ToType.getUnqualifiedType(); 1583 } else if (FromType->isRealFloatingType() && ToType->isRealFloatingType()) { 1584 // Floating point conversions (C++ 4.8). 1585 SCS.Second = ICK_Floating_Conversion; 1586 FromType = ToType.getUnqualifiedType(); 1587 } else if ((FromType->isRealFloatingType() && 1588 ToType->isIntegralType(S.Context)) || 1589 (FromType->isIntegralOrUnscopedEnumerationType() && 1590 ToType->isRealFloatingType())) { 1591 // Floating-integral conversions (C++ 4.9). 1592 SCS.Second = ICK_Floating_Integral; 1593 FromType = ToType.getUnqualifiedType(); 1594 } else if (S.IsBlockPointerConversion(FromType, ToType, FromType)) { 1595 SCS.Second = ICK_Block_Pointer_Conversion; 1596 } else if (AllowObjCWritebackConversion && 1597 S.isObjCWritebackConversion(FromType, ToType, FromType)) { 1598 SCS.Second = ICK_Writeback_Conversion; 1599 } else if (S.IsPointerConversion(From, FromType, ToType, InOverloadResolution, 1600 FromType, IncompatibleObjC)) { 1601 // Pointer conversions (C++ 4.10). 1602 SCS.Second = ICK_Pointer_Conversion; 1603 SCS.IncompatibleObjC = IncompatibleObjC; 1604 FromType = FromType.getUnqualifiedType(); 1605 } else if (S.IsMemberPointerConversion(From, FromType, ToType, 1606 InOverloadResolution, FromType)) { 1607 // Pointer to member conversions (4.11). 1608 SCS.Second = ICK_Pointer_Member; 1609 } else if (IsVectorConversion(S.Context, FromType, ToType, SecondICK)) { 1610 SCS.Second = SecondICK; 1611 FromType = ToType.getUnqualifiedType(); 1612 } else if (!S.getLangOpts().CPlusPlus && 1613 S.Context.typesAreCompatible(ToType, FromType)) { 1614 // Compatible conversions (Clang extension for C function overloading) 1615 SCS.Second = ICK_Compatible_Conversion; 1616 FromType = ToType.getUnqualifiedType(); 1617 } else if (S.IsNoReturnConversion(FromType, ToType, FromType)) { 1618 // Treat a conversion that strips "noreturn" as an identity conversion. 1619 SCS.Second = ICK_NoReturn_Adjustment; 1620 } else if (IsTransparentUnionStandardConversion(S, From, ToType, 1621 InOverloadResolution, 1622 SCS, CStyle)) { 1623 SCS.Second = ICK_TransparentUnionConversion; 1624 FromType = ToType; 1625 } else if (tryAtomicConversion(S, From, ToType, InOverloadResolution, SCS, 1626 CStyle)) { 1627 // tryAtomicConversion has updated the standard conversion sequence 1628 // appropriately. 1629 return true; 1630 } else if (ToType->isEventT() && 1631 From->isIntegerConstantExpr(S.getASTContext()) && 1632 (From->EvaluateKnownConstInt(S.getASTContext()) == 0)) { 1633 SCS.Second = ICK_Zero_Event_Conversion; 1634 FromType = ToType; 1635 } else { 1636 // No second conversion required. 1637 SCS.Second = ICK_Identity; 1638 } 1639 SCS.setToType(1, FromType); 1640 1641 QualType CanonFrom; 1642 QualType CanonTo; 1643 // The third conversion can be a qualification conversion (C++ 4p1). 1644 bool ObjCLifetimeConversion; 1645 if (S.IsQualificationConversion(FromType, ToType, CStyle, 1646 ObjCLifetimeConversion)) { 1647 SCS.Third = ICK_Qualification; 1648 SCS.QualificationIncludesObjCLifetime = ObjCLifetimeConversion; 1649 FromType = ToType; 1650 CanonFrom = S.Context.getCanonicalType(FromType); 1651 CanonTo = S.Context.getCanonicalType(ToType); 1652 } else { 1653 // No conversion required 1654 SCS.Third = ICK_Identity; 1655 1656 // C++ [over.best.ics]p6: 1657 // [...] Any difference in top-level cv-qualification is 1658 // subsumed by the initialization itself and does not constitute 1659 // a conversion. [...] 1660 CanonFrom = S.Context.getCanonicalType(FromType); 1661 CanonTo = S.Context.getCanonicalType(ToType); 1662 if (CanonFrom.getLocalUnqualifiedType() 1663 == CanonTo.getLocalUnqualifiedType() && 1664 CanonFrom.getLocalQualifiers() != CanonTo.getLocalQualifiers()) { 1665 FromType = ToType; 1666 CanonFrom = CanonTo; 1667 } 1668 } 1669 SCS.setToType(2, FromType); 1670 1671 // If we have not converted the argument type to the parameter type, 1672 // this is a bad conversion sequence. 1673 if (CanonFrom != CanonTo) 1674 return false; 1675 1676 return true; 1677 } 1678 1679 static bool 1680 IsTransparentUnionStandardConversion(Sema &S, Expr* From, 1681 QualType &ToType, 1682 bool InOverloadResolution, 1683 StandardConversionSequence &SCS, 1684 bool CStyle) { 1685 1686 const RecordType *UT = ToType->getAsUnionType(); 1687 if (!UT || !UT->getDecl()->hasAttr<TransparentUnionAttr>()) 1688 return false; 1689 // The field to initialize within the transparent union. 1690 RecordDecl *UD = UT->getDecl(); 1691 // It's compatible if the expression matches any of the fields. 1692 for (RecordDecl::field_iterator it = UD->field_begin(), 1693 itend = UD->field_end(); 1694 it != itend; ++it) { 1695 if (IsStandardConversion(S, From, it->getType(), InOverloadResolution, SCS, 1696 CStyle, /*ObjCWritebackConversion=*/false)) { 1697 ToType = it->getType(); 1698 return true; 1699 } 1700 } 1701 return false; 1702 } 1703 1704 /// IsIntegralPromotion - Determines whether the conversion from the 1705 /// expression From (whose potentially-adjusted type is FromType) to 1706 /// ToType is an integral promotion (C++ 4.5). If so, returns true and 1707 /// sets PromotedType to the promoted type. 1708 bool Sema::IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType) { 1709 const BuiltinType *To = ToType->getAs<BuiltinType>(); 1710 // All integers are built-in. 1711 if (!To) { 1712 return false; 1713 } 1714 1715 // An rvalue of type char, signed char, unsigned char, short int, or 1716 // unsigned short int can be converted to an rvalue of type int if 1717 // int can represent all the values of the source type; otherwise, 1718 // the source rvalue can be converted to an rvalue of type unsigned 1719 // int (C++ 4.5p1). 1720 if (FromType->isPromotableIntegerType() && !FromType->isBooleanType() && 1721 !FromType->isEnumeralType()) { 1722 if (// We can promote any signed, promotable integer type to an int 1723 (FromType->isSignedIntegerType() || 1724 // We can promote any unsigned integer type whose size is 1725 // less than int to an int. 1726 (!FromType->isSignedIntegerType() && 1727 Context.getTypeSize(FromType) < Context.getTypeSize(ToType)))) { 1728 return To->getKind() == BuiltinType::Int; 1729 } 1730 1731 return To->getKind() == BuiltinType::UInt; 1732 } 1733 1734 // C++11 [conv.prom]p3: 1735 // A prvalue of an unscoped enumeration type whose underlying type is not 1736 // fixed (7.2) can be converted to an rvalue a prvalue of the first of the 1737 // following types that can represent all the values of the enumeration 1738 // (i.e., the values in the range bmin to bmax as described in 7.2): int, 1739 // unsigned int, long int, unsigned long int, long long int, or unsigned 1740 // long long int. If none of the types in that list can represent all the 1741 // values of the enumeration, an rvalue a prvalue of an unscoped enumeration 1742 // type can be converted to an rvalue a prvalue of the extended integer type 1743 // with lowest integer conversion rank (4.13) greater than the rank of long 1744 // long in which all the values of the enumeration can be represented. If 1745 // there are two such extended types, the signed one is chosen. 1746 // C++11 [conv.prom]p4: 1747 // A prvalue of an unscoped enumeration type whose underlying type is fixed 1748 // can be converted to a prvalue of its underlying type. Moreover, if 1749 // integral promotion can be applied to its underlying type, a prvalue of an 1750 // unscoped enumeration type whose underlying type is fixed can also be 1751 // converted to a prvalue of the promoted underlying type. 1752 if (const EnumType *FromEnumType = FromType->getAs<EnumType>()) { 1753 // C++0x 7.2p9: Note that this implicit enum to int conversion is not 1754 // provided for a scoped enumeration. 1755 if (FromEnumType->getDecl()->isScoped()) 1756 return false; 1757 1758 // We can perform an integral promotion to the underlying type of the enum, 1759 // even if that's not the promoted type. 1760 if (FromEnumType->getDecl()->isFixed()) { 1761 QualType Underlying = FromEnumType->getDecl()->getIntegerType(); 1762 return Context.hasSameUnqualifiedType(Underlying, ToType) || 1763 IsIntegralPromotion(From, Underlying, ToType); 1764 } 1765 1766 // We have already pre-calculated the promotion type, so this is trivial. 1767 if (ToType->isIntegerType() && 1768 !RequireCompleteType(From->getLocStart(), FromType, 0)) 1769 return Context.hasSameUnqualifiedType(ToType, 1770 FromEnumType->getDecl()->getPromotionType()); 1771 } 1772 1773 // C++0x [conv.prom]p2: 1774 // A prvalue of type char16_t, char32_t, or wchar_t (3.9.1) can be converted 1775 // to an rvalue a prvalue of the first of the following types that can 1776 // represent all the values of its underlying type: int, unsigned int, 1777 // long int, unsigned long int, long long int, or unsigned long long int. 1778 // If none of the types in that list can represent all the values of its 1779 // underlying type, an rvalue a prvalue of type char16_t, char32_t, 1780 // or wchar_t can be converted to an rvalue a prvalue of its underlying 1781 // type. 1782 if (FromType->isAnyCharacterType() && !FromType->isCharType() && 1783 ToType->isIntegerType()) { 1784 // Determine whether the type we're converting from is signed or 1785 // unsigned. 1786 bool FromIsSigned = FromType->isSignedIntegerType(); 1787 uint64_t FromSize = Context.getTypeSize(FromType); 1788 1789 // The types we'll try to promote to, in the appropriate 1790 // order. Try each of these types. 1791 QualType PromoteTypes[6] = { 1792 Context.IntTy, Context.UnsignedIntTy, 1793 Context.LongTy, Context.UnsignedLongTy , 1794 Context.LongLongTy, Context.UnsignedLongLongTy 1795 }; 1796 for (int Idx = 0; Idx < 6; ++Idx) { 1797 uint64_t ToSize = Context.getTypeSize(PromoteTypes[Idx]); 1798 if (FromSize < ToSize || 1799 (FromSize == ToSize && 1800 FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType())) { 1801 // We found the type that we can promote to. If this is the 1802 // type we wanted, we have a promotion. Otherwise, no 1803 // promotion. 1804 return Context.hasSameUnqualifiedType(ToType, PromoteTypes[Idx]); 1805 } 1806 } 1807 } 1808 1809 // An rvalue for an integral bit-field (9.6) can be converted to an 1810 // rvalue of type int if int can represent all the values of the 1811 // bit-field; otherwise, it can be converted to unsigned int if 1812 // unsigned int can represent all the values of the bit-field. If 1813 // the bit-field is larger yet, no integral promotion applies to 1814 // it. If the bit-field has an enumerated type, it is treated as any 1815 // other value of that type for promotion purposes (C++ 4.5p3). 1816 // FIXME: We should delay checking of bit-fields until we actually perform the 1817 // conversion. 1818 using llvm::APSInt; 1819 if (From) 1820 if (FieldDecl *MemberDecl = From->getSourceBitField()) { 1821 APSInt BitWidth; 1822 if (FromType->isIntegralType(Context) && 1823 MemberDecl->getBitWidth()->isIntegerConstantExpr(BitWidth, Context)) { 1824 APSInt ToSize(BitWidth.getBitWidth(), BitWidth.isUnsigned()); 1825 ToSize = Context.getTypeSize(ToType); 1826 1827 // Are we promoting to an int from a bitfield that fits in an int? 1828 if (BitWidth < ToSize || 1829 (FromType->isSignedIntegerType() && BitWidth <= ToSize)) { 1830 return To->getKind() == BuiltinType::Int; 1831 } 1832 1833 // Are we promoting to an unsigned int from an unsigned bitfield 1834 // that fits into an unsigned int? 1835 if (FromType->isUnsignedIntegerType() && BitWidth <= ToSize) { 1836 return To->getKind() == BuiltinType::UInt; 1837 } 1838 1839 return false; 1840 } 1841 } 1842 1843 // An rvalue of type bool can be converted to an rvalue of type int, 1844 // with false becoming zero and true becoming one (C++ 4.5p4). 1845 if (FromType->isBooleanType() && To->getKind() == BuiltinType::Int) { 1846 return true; 1847 } 1848 1849 return false; 1850 } 1851 1852 /// IsFloatingPointPromotion - Determines whether the conversion from 1853 /// FromType to ToType is a floating point promotion (C++ 4.6). If so, 1854 /// returns true and sets PromotedType to the promoted type. 1855 bool Sema::IsFloatingPointPromotion(QualType FromType, QualType ToType) { 1856 if (const BuiltinType *FromBuiltin = FromType->getAs<BuiltinType>()) 1857 if (const BuiltinType *ToBuiltin = ToType->getAs<BuiltinType>()) { 1858 /// An rvalue of type float can be converted to an rvalue of type 1859 /// double. (C++ 4.6p1). 1860 if (FromBuiltin->getKind() == BuiltinType::Float && 1861 ToBuiltin->getKind() == BuiltinType::Double) 1862 return true; 1863 1864 // C99 6.3.1.5p1: 1865 // When a float is promoted to double or long double, or a 1866 // double is promoted to long double [...]. 1867 if (!getLangOpts().CPlusPlus && 1868 (FromBuiltin->getKind() == BuiltinType::Float || 1869 FromBuiltin->getKind() == BuiltinType::Double) && 1870 (ToBuiltin->getKind() == BuiltinType::LongDouble)) 1871 return true; 1872 1873 // Half can be promoted to float. 1874 if (!getLangOpts().NativeHalfType && 1875 FromBuiltin->getKind() == BuiltinType::Half && 1876 ToBuiltin->getKind() == BuiltinType::Float) 1877 return true; 1878 } 1879 1880 return false; 1881 } 1882 1883 /// \brief Determine if a conversion is a complex promotion. 1884 /// 1885 /// A complex promotion is defined as a complex -> complex conversion 1886 /// where the conversion between the underlying real types is a 1887 /// floating-point or integral promotion. 1888 bool Sema::IsComplexPromotion(QualType FromType, QualType ToType) { 1889 const ComplexType *FromComplex = FromType->getAs<ComplexType>(); 1890 if (!FromComplex) 1891 return false; 1892 1893 const ComplexType *ToComplex = ToType->getAs<ComplexType>(); 1894 if (!ToComplex) 1895 return false; 1896 1897 return IsFloatingPointPromotion(FromComplex->getElementType(), 1898 ToComplex->getElementType()) || 1899 IsIntegralPromotion(0, FromComplex->getElementType(), 1900 ToComplex->getElementType()); 1901 } 1902 1903 /// BuildSimilarlyQualifiedPointerType - In a pointer conversion from 1904 /// the pointer type FromPtr to a pointer to type ToPointee, with the 1905 /// same type qualifiers as FromPtr has on its pointee type. ToType, 1906 /// if non-empty, will be a pointer to ToType that may or may not have 1907 /// the right set of qualifiers on its pointee. 1908 /// 1909 static QualType 1910 BuildSimilarlyQualifiedPointerType(const Type *FromPtr, 1911 QualType ToPointee, QualType ToType, 1912 ASTContext &Context, 1913 bool StripObjCLifetime = false) { 1914 assert((FromPtr->getTypeClass() == Type::Pointer || 1915 FromPtr->getTypeClass() == Type::ObjCObjectPointer) && 1916 "Invalid similarly-qualified pointer type"); 1917 1918 /// Conversions to 'id' subsume cv-qualifier conversions. 1919 if (ToType->isObjCIdType() || ToType->isObjCQualifiedIdType()) 1920 return ToType.getUnqualifiedType(); 1921 1922 QualType CanonFromPointee 1923 = Context.getCanonicalType(FromPtr->getPointeeType()); 1924 QualType CanonToPointee = Context.getCanonicalType(ToPointee); 1925 Qualifiers Quals = CanonFromPointee.getQualifiers(); 1926 1927 if (StripObjCLifetime) 1928 Quals.removeObjCLifetime(); 1929 1930 // Exact qualifier match -> return the pointer type we're converting to. 1931 if (CanonToPointee.getLocalQualifiers() == Quals) { 1932 // ToType is exactly what we need. Return it. 1933 if (!ToType.isNull()) 1934 return ToType.getUnqualifiedType(); 1935 1936 // Build a pointer to ToPointee. It has the right qualifiers 1937 // already. 1938 if (isa<ObjCObjectPointerType>(ToType)) 1939 return Context.getObjCObjectPointerType(ToPointee); 1940 return Context.getPointerType(ToPointee); 1941 } 1942 1943 // Just build a canonical type that has the right qualifiers. 1944 QualType QualifiedCanonToPointee 1945 = Context.getQualifiedType(CanonToPointee.getLocalUnqualifiedType(), Quals); 1946 1947 if (isa<ObjCObjectPointerType>(ToType)) 1948 return Context.getObjCObjectPointerType(QualifiedCanonToPointee); 1949 return Context.getPointerType(QualifiedCanonToPointee); 1950 } 1951 1952 static bool isNullPointerConstantForConversion(Expr *Expr, 1953 bool InOverloadResolution, 1954 ASTContext &Context) { 1955 // Handle value-dependent integral null pointer constants correctly. 1956 // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#903 1957 if (Expr->isValueDependent() && !Expr->isTypeDependent() && 1958 Expr->getType()->isIntegerType() && !Expr->getType()->isEnumeralType()) 1959 return !InOverloadResolution; 1960 1961 return Expr->isNullPointerConstant(Context, 1962 InOverloadResolution? Expr::NPC_ValueDependentIsNotNull 1963 : Expr::NPC_ValueDependentIsNull); 1964 } 1965 1966 /// IsPointerConversion - Determines whether the conversion of the 1967 /// expression From, which has the (possibly adjusted) type FromType, 1968 /// can be converted to the type ToType via a pointer conversion (C++ 1969 /// 4.10). If so, returns true and places the converted type (that 1970 /// might differ from ToType in its cv-qualifiers at some level) into 1971 /// ConvertedType. 1972 /// 1973 /// This routine also supports conversions to and from block pointers 1974 /// and conversions with Objective-C's 'id', 'id<protocols...>', and 1975 /// pointers to interfaces. FIXME: Once we've determined the 1976 /// appropriate overloading rules for Objective-C, we may want to 1977 /// split the Objective-C checks into a different routine; however, 1978 /// GCC seems to consider all of these conversions to be pointer 1979 /// conversions, so for now they live here. IncompatibleObjC will be 1980 /// set if the conversion is an allowed Objective-C conversion that 1981 /// should result in a warning. 1982 bool Sema::IsPointerConversion(Expr *From, QualType FromType, QualType ToType, 1983 bool InOverloadResolution, 1984 QualType& ConvertedType, 1985 bool &IncompatibleObjC) { 1986 IncompatibleObjC = false; 1987 if (isObjCPointerConversion(FromType, ToType, ConvertedType, 1988 IncompatibleObjC)) 1989 return true; 1990 1991 // Conversion from a null pointer constant to any Objective-C pointer type. 1992 if (ToType->isObjCObjectPointerType() && 1993 isNullPointerConstantForConversion(From, InOverloadResolution, Context)) { 1994 ConvertedType = ToType; 1995 return true; 1996 } 1997 1998 // Blocks: Block pointers can be converted to void*. 1999 if (FromType->isBlockPointerType() && ToType->isPointerType() && 2000 ToType->getAs<PointerType>()->getPointeeType()->isVoidType()) { 2001 ConvertedType = ToType; 2002 return true; 2003 } 2004 // Blocks: A null pointer constant can be converted to a block 2005 // pointer type. 2006 if (ToType->isBlockPointerType() && 2007 isNullPointerConstantForConversion(From, InOverloadResolution, Context)) { 2008 ConvertedType = ToType; 2009 return true; 2010 } 2011 2012 // If the left-hand-side is nullptr_t, the right side can be a null 2013 // pointer constant. 2014 if (ToType->isNullPtrType() && 2015 isNullPointerConstantForConversion(From, InOverloadResolution, Context)) { 2016 ConvertedType = ToType; 2017 return true; 2018 } 2019 2020 const PointerType* ToTypePtr = ToType->getAs<PointerType>(); 2021 if (!ToTypePtr) 2022 return false; 2023 2024 // A null pointer constant can be converted to a pointer type (C++ 4.10p1). 2025 if (isNullPointerConstantForConversion(From, InOverloadResolution, Context)) { 2026 ConvertedType = ToType; 2027 return true; 2028 } 2029 2030 // Beyond this point, both types need to be pointers 2031 // , including objective-c pointers. 2032 QualType ToPointeeType = ToTypePtr->getPointeeType(); 2033 if (FromType->isObjCObjectPointerType() && ToPointeeType->isVoidType() && 2034 !getLangOpts().ObjCAutoRefCount) { 2035 ConvertedType = BuildSimilarlyQualifiedPointerType( 2036 FromType->getAs<ObjCObjectPointerType>(), 2037 ToPointeeType, 2038 ToType, Context); 2039 return true; 2040 } 2041 const PointerType *FromTypePtr = FromType->getAs<PointerType>(); 2042 if (!FromTypePtr) 2043 return false; 2044 2045 QualType FromPointeeType = FromTypePtr->getPointeeType(); 2046 2047 // If the unqualified pointee types are the same, this can't be a 2048 // pointer conversion, so don't do all of the work below. 2049 if (Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType)) 2050 return false; 2051 2052 // An rvalue of type "pointer to cv T," where T is an object type, 2053 // can be converted to an rvalue of type "pointer to cv void" (C++ 2054 // 4.10p2). 2055 if (FromPointeeType->isIncompleteOrObjectType() && 2056 ToPointeeType->isVoidType()) { 2057 ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr, 2058 ToPointeeType, 2059 ToType, Context, 2060 /*StripObjCLifetime=*/true); 2061 return true; 2062 } 2063 2064 // MSVC allows implicit function to void* type conversion. 2065 if (getLangOpts().MicrosoftExt && FromPointeeType->isFunctionType() && 2066 ToPointeeType->isVoidType()) { 2067 ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr, 2068 ToPointeeType, 2069 ToType, Context); 2070 return true; 2071 } 2072 2073 // When we're overloading in C, we allow a special kind of pointer 2074 // conversion for compatible-but-not-identical pointee types. 2075 if (!getLangOpts().CPlusPlus && 2076 Context.typesAreCompatible(FromPointeeType, ToPointeeType)) { 2077 ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr, 2078 ToPointeeType, 2079 ToType, Context); 2080 return true; 2081 } 2082 2083 // C++ [conv.ptr]p3: 2084 // 2085 // An rvalue of type "pointer to cv D," where D is a class type, 2086 // can be converted to an rvalue of type "pointer to cv B," where 2087 // B is a base class (clause 10) of D. If B is an inaccessible 2088 // (clause 11) or ambiguous (10.2) base class of D, a program that 2089 // necessitates this conversion is ill-formed. The result of the 2090 // conversion is a pointer to the base class sub-object of the 2091 // derived class object. The null pointer value is converted to 2092 // the null pointer value of the destination type. 2093 // 2094 // Note that we do not check for ambiguity or inaccessibility 2095 // here. That is handled by CheckPointerConversion. 2096 if (getLangOpts().CPlusPlus && 2097 FromPointeeType->isRecordType() && ToPointeeType->isRecordType() && 2098 !Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType) && 2099 !RequireCompleteType(From->getLocStart(), FromPointeeType, 0) && 2100 IsDerivedFrom(FromPointeeType, ToPointeeType)) { 2101 ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr, 2102 ToPointeeType, 2103 ToType, Context); 2104 return true; 2105 } 2106 2107 if (FromPointeeType->isVectorType() && ToPointeeType->isVectorType() && 2108 Context.areCompatibleVectorTypes(FromPointeeType, ToPointeeType)) { 2109 ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr, 2110 ToPointeeType, 2111 ToType, Context); 2112 return true; 2113 } 2114 2115 return false; 2116 } 2117 2118 /// \brief Adopt the given qualifiers for the given type. 2119 static QualType AdoptQualifiers(ASTContext &Context, QualType T, Qualifiers Qs){ 2120 Qualifiers TQs = T.getQualifiers(); 2121 2122 // Check whether qualifiers already match. 2123 if (TQs == Qs) 2124 return T; 2125 2126 if (Qs.compatiblyIncludes(TQs)) 2127 return Context.getQualifiedType(T, Qs); 2128 2129 return Context.getQualifiedType(T.getUnqualifiedType(), Qs); 2130 } 2131 2132 /// isObjCPointerConversion - Determines whether this is an 2133 /// Objective-C pointer conversion. Subroutine of IsPointerConversion, 2134 /// with the same arguments and return values. 2135 bool Sema::isObjCPointerConversion(QualType FromType, QualType ToType, 2136 QualType& ConvertedType, 2137 bool &IncompatibleObjC) { 2138 if (!getLangOpts().ObjC1) 2139 return false; 2140 2141 // The set of qualifiers on the type we're converting from. 2142 Qualifiers FromQualifiers = FromType.getQualifiers(); 2143 2144 // First, we handle all conversions on ObjC object pointer types. 2145 const ObjCObjectPointerType* ToObjCPtr = 2146 ToType->getAs<ObjCObjectPointerType>(); 2147 const ObjCObjectPointerType *FromObjCPtr = 2148 FromType->getAs<ObjCObjectPointerType>(); 2149 2150 if (ToObjCPtr && FromObjCPtr) { 2151 // If the pointee types are the same (ignoring qualifications), 2152 // then this is not a pointer conversion. 2153 if (Context.hasSameUnqualifiedType(ToObjCPtr->getPointeeType(), 2154 FromObjCPtr->getPointeeType())) 2155 return false; 2156 2157 // Check for compatible 2158 // Objective C++: We're able to convert between "id" or "Class" and a 2159 // pointer to any interface (in both directions). 2160 if (ToObjCPtr->isObjCBuiltinType() && FromObjCPtr->isObjCBuiltinType()) { 2161 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers); 2162 return true; 2163 } 2164 // Conversions with Objective-C's id<...>. 2165 if ((FromObjCPtr->isObjCQualifiedIdType() || 2166 ToObjCPtr->isObjCQualifiedIdType()) && 2167 Context.ObjCQualifiedIdTypesAreCompatible(ToType, FromType, 2168 /*compare=*/false)) { 2169 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers); 2170 return true; 2171 } 2172 // Objective C++: We're able to convert from a pointer to an 2173 // interface to a pointer to a different interface. 2174 if (Context.canAssignObjCInterfaces(ToObjCPtr, FromObjCPtr)) { 2175 const ObjCInterfaceType* LHS = ToObjCPtr->getInterfaceType(); 2176 const ObjCInterfaceType* RHS = FromObjCPtr->getInterfaceType(); 2177 if (getLangOpts().CPlusPlus && LHS && RHS && 2178 !ToObjCPtr->getPointeeType().isAtLeastAsQualifiedAs( 2179 FromObjCPtr->getPointeeType())) 2180 return false; 2181 ConvertedType = BuildSimilarlyQualifiedPointerType(FromObjCPtr, 2182 ToObjCPtr->getPointeeType(), 2183 ToType, Context); 2184 ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers); 2185 return true; 2186 } 2187 2188 if (Context.canAssignObjCInterfaces(FromObjCPtr, ToObjCPtr)) { 2189 // Okay: this is some kind of implicit downcast of Objective-C 2190 // interfaces, which is permitted. However, we're going to 2191 // complain about it. 2192 IncompatibleObjC = true; 2193 ConvertedType = BuildSimilarlyQualifiedPointerType(FromObjCPtr, 2194 ToObjCPtr->getPointeeType(), 2195 ToType, Context); 2196 ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers); 2197 return true; 2198 } 2199 } 2200 // Beyond this point, both types need to be C pointers or block pointers. 2201 QualType ToPointeeType; 2202 if (const PointerType *ToCPtr = ToType->getAs<PointerType>()) 2203 ToPointeeType = ToCPtr->getPointeeType(); 2204 else if (const BlockPointerType *ToBlockPtr = 2205 ToType->getAs<BlockPointerType>()) { 2206 // Objective C++: We're able to convert from a pointer to any object 2207 // to a block pointer type. 2208 if (FromObjCPtr && FromObjCPtr->isObjCBuiltinType()) { 2209 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers); 2210 return true; 2211 } 2212 ToPointeeType = ToBlockPtr->getPointeeType(); 2213 } 2214 else if (FromType->getAs<BlockPointerType>() && 2215 ToObjCPtr && ToObjCPtr->isObjCBuiltinType()) { 2216 // Objective C++: We're able to convert from a block pointer type to a 2217 // pointer to any object. 2218 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers); 2219 return true; 2220 } 2221 else 2222 return false; 2223 2224 QualType FromPointeeType; 2225 if (const PointerType *FromCPtr = FromType->getAs<PointerType>()) 2226 FromPointeeType = FromCPtr->getPointeeType(); 2227 else if (const BlockPointerType *FromBlockPtr = 2228 FromType->getAs<BlockPointerType>()) 2229 FromPointeeType = FromBlockPtr->getPointeeType(); 2230 else 2231 return false; 2232 2233 // If we have pointers to pointers, recursively check whether this 2234 // is an Objective-C conversion. 2235 if (FromPointeeType->isPointerType() && ToPointeeType->isPointerType() && 2236 isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType, 2237 IncompatibleObjC)) { 2238 // We always complain about this conversion. 2239 IncompatibleObjC = true; 2240 ConvertedType = Context.getPointerType(ConvertedType); 2241 ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers); 2242 return true; 2243 } 2244 // Allow conversion of pointee being objective-c pointer to another one; 2245 // as in I* to id. 2246 if (FromPointeeType->getAs<ObjCObjectPointerType>() && 2247 ToPointeeType->getAs<ObjCObjectPointerType>() && 2248 isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType, 2249 IncompatibleObjC)) { 2250 2251 ConvertedType = Context.getPointerType(ConvertedType); 2252 ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers); 2253 return true; 2254 } 2255 2256 // If we have pointers to functions or blocks, check whether the only 2257 // differences in the argument and result types are in Objective-C 2258 // pointer conversions. If so, we permit the conversion (but 2259 // complain about it). 2260 const FunctionProtoType *FromFunctionType 2261 = FromPointeeType->getAs<FunctionProtoType>(); 2262 const FunctionProtoType *ToFunctionType 2263 = ToPointeeType->getAs<FunctionProtoType>(); 2264 if (FromFunctionType && ToFunctionType) { 2265 // If the function types are exactly the same, this isn't an 2266 // Objective-C pointer conversion. 2267 if (Context.getCanonicalType(FromPointeeType) 2268 == Context.getCanonicalType(ToPointeeType)) 2269 return false; 2270 2271 // Perform the quick checks that will tell us whether these 2272 // function types are obviously different. 2273 if (FromFunctionType->getNumArgs() != ToFunctionType->getNumArgs() || 2274 FromFunctionType->isVariadic() != ToFunctionType->isVariadic() || 2275 FromFunctionType->getTypeQuals() != ToFunctionType->getTypeQuals()) 2276 return false; 2277 2278 bool HasObjCConversion = false; 2279 if (Context.getCanonicalType(FromFunctionType->getResultType()) 2280 == Context.getCanonicalType(ToFunctionType->getResultType())) { 2281 // Okay, the types match exactly. Nothing to do. 2282 } else if (isObjCPointerConversion(FromFunctionType->getResultType(), 2283 ToFunctionType->getResultType(), 2284 ConvertedType, IncompatibleObjC)) { 2285 // Okay, we have an Objective-C pointer conversion. 2286 HasObjCConversion = true; 2287 } else { 2288 // Function types are too different. Abort. 2289 return false; 2290 } 2291 2292 // Check argument types. 2293 for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumArgs(); 2294 ArgIdx != NumArgs; ++ArgIdx) { 2295 QualType FromArgType = FromFunctionType->getArgType(ArgIdx); 2296 QualType ToArgType = ToFunctionType->getArgType(ArgIdx); 2297 if (Context.getCanonicalType(FromArgType) 2298 == Context.getCanonicalType(ToArgType)) { 2299 // Okay, the types match exactly. Nothing to do. 2300 } else if (isObjCPointerConversion(FromArgType, ToArgType, 2301 ConvertedType, IncompatibleObjC)) { 2302 // Okay, we have an Objective-C pointer conversion. 2303 HasObjCConversion = true; 2304 } else { 2305 // Argument types are too different. Abort. 2306 return false; 2307 } 2308 } 2309 2310 if (HasObjCConversion) { 2311 // We had an Objective-C conversion. Allow this pointer 2312 // conversion, but complain about it. 2313 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers); 2314 IncompatibleObjC = true; 2315 return true; 2316 } 2317 } 2318 2319 return false; 2320 } 2321 2322 /// \brief Determine whether this is an Objective-C writeback conversion, 2323 /// used for parameter passing when performing automatic reference counting. 2324 /// 2325 /// \param FromType The type we're converting form. 2326 /// 2327 /// \param ToType The type we're converting to. 2328 /// 2329 /// \param ConvertedType The type that will be produced after applying 2330 /// this conversion. 2331 bool Sema::isObjCWritebackConversion(QualType FromType, QualType ToType, 2332 QualType &ConvertedType) { 2333 if (!getLangOpts().ObjCAutoRefCount || 2334 Context.hasSameUnqualifiedType(FromType, ToType)) 2335 return false; 2336 2337 // Parameter must be a pointer to __autoreleasing (with no other qualifiers). 2338 QualType ToPointee; 2339 if (const PointerType *ToPointer = ToType->getAs<PointerType>()) 2340 ToPointee = ToPointer->getPointeeType(); 2341 else 2342 return false; 2343 2344 Qualifiers ToQuals = ToPointee.getQualifiers(); 2345 if (!ToPointee->isObjCLifetimeType() || 2346 ToQuals.getObjCLifetime() != Qualifiers::OCL_Autoreleasing || 2347 !ToQuals.withoutObjCLifetime().empty()) 2348 return false; 2349 2350 // Argument must be a pointer to __strong to __weak. 2351 QualType FromPointee; 2352 if (const PointerType *FromPointer = FromType->getAs<PointerType>()) 2353 FromPointee = FromPointer->getPointeeType(); 2354 else 2355 return false; 2356 2357 Qualifiers FromQuals = FromPointee.getQualifiers(); 2358 if (!FromPointee->isObjCLifetimeType() || 2359 (FromQuals.getObjCLifetime() != Qualifiers::OCL_Strong && 2360 FromQuals.getObjCLifetime() != Qualifiers::OCL_Weak)) 2361 return false; 2362 2363 // Make sure that we have compatible qualifiers. 2364 FromQuals.setObjCLifetime(Qualifiers::OCL_Autoreleasing); 2365 if (!ToQuals.compatiblyIncludes(FromQuals)) 2366 return false; 2367 2368 // Remove qualifiers from the pointee type we're converting from; they 2369 // aren't used in the compatibility check belong, and we'll be adding back 2370 // qualifiers (with __autoreleasing) if the compatibility check succeeds. 2371 FromPointee = FromPointee.getUnqualifiedType(); 2372 2373 // The unqualified form of the pointee types must be compatible. 2374 ToPointee = ToPointee.getUnqualifiedType(); 2375 bool IncompatibleObjC; 2376 if (Context.typesAreCompatible(FromPointee, ToPointee)) 2377 FromPointee = ToPointee; 2378 else if (!isObjCPointerConversion(FromPointee, ToPointee, FromPointee, 2379 IncompatibleObjC)) 2380 return false; 2381 2382 /// \brief Construct the type we're converting to, which is a pointer to 2383 /// __autoreleasing pointee. 2384 FromPointee = Context.getQualifiedType(FromPointee, FromQuals); 2385 ConvertedType = Context.getPointerType(FromPointee); 2386 return true; 2387 } 2388 2389 bool Sema::IsBlockPointerConversion(QualType FromType, QualType ToType, 2390 QualType& ConvertedType) { 2391 QualType ToPointeeType; 2392 if (const BlockPointerType *ToBlockPtr = 2393 ToType->getAs<BlockPointerType>()) 2394 ToPointeeType = ToBlockPtr->getPointeeType(); 2395 else 2396 return false; 2397 2398 QualType FromPointeeType; 2399 if (const BlockPointerType *FromBlockPtr = 2400 FromType->getAs<BlockPointerType>()) 2401 FromPointeeType = FromBlockPtr->getPointeeType(); 2402 else 2403 return false; 2404 // We have pointer to blocks, check whether the only 2405 // differences in the argument and result types are in Objective-C 2406 // pointer conversions. If so, we permit the conversion. 2407 2408 const FunctionProtoType *FromFunctionType 2409 = FromPointeeType->getAs<FunctionProtoType>(); 2410 const FunctionProtoType *ToFunctionType 2411 = ToPointeeType->getAs<FunctionProtoType>(); 2412 2413 if (!FromFunctionType || !ToFunctionType) 2414 return false; 2415 2416 if (Context.hasSameType(FromPointeeType, ToPointeeType)) 2417 return true; 2418 2419 // Perform the quick checks that will tell us whether these 2420 // function types are obviously different. 2421 if (FromFunctionType->getNumArgs() != ToFunctionType->getNumArgs() || 2422 FromFunctionType->isVariadic() != ToFunctionType->isVariadic()) 2423 return false; 2424 2425 FunctionType::ExtInfo FromEInfo = FromFunctionType->getExtInfo(); 2426 FunctionType::ExtInfo ToEInfo = ToFunctionType->getExtInfo(); 2427 if (FromEInfo != ToEInfo) 2428 return false; 2429 2430 bool IncompatibleObjC = false; 2431 if (Context.hasSameType(FromFunctionType->getResultType(), 2432 ToFunctionType->getResultType())) { 2433 // Okay, the types match exactly. Nothing to do. 2434 } else { 2435 QualType RHS = FromFunctionType->getResultType(); 2436 QualType LHS = ToFunctionType->getResultType(); 2437 if ((!getLangOpts().CPlusPlus || !RHS->isRecordType()) && 2438 !RHS.hasQualifiers() && LHS.hasQualifiers()) 2439 LHS = LHS.getUnqualifiedType(); 2440 2441 if (Context.hasSameType(RHS,LHS)) { 2442 // OK exact match. 2443 } else if (isObjCPointerConversion(RHS, LHS, 2444 ConvertedType, IncompatibleObjC)) { 2445 if (IncompatibleObjC) 2446 return false; 2447 // Okay, we have an Objective-C pointer conversion. 2448 } 2449 else 2450 return false; 2451 } 2452 2453 // Check argument types. 2454 for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumArgs(); 2455 ArgIdx != NumArgs; ++ArgIdx) { 2456 IncompatibleObjC = false; 2457 QualType FromArgType = FromFunctionType->getArgType(ArgIdx); 2458 QualType ToArgType = ToFunctionType->getArgType(ArgIdx); 2459 if (Context.hasSameType(FromArgType, ToArgType)) { 2460 // Okay, the types match exactly. Nothing to do. 2461 } else if (isObjCPointerConversion(ToArgType, FromArgType, 2462 ConvertedType, IncompatibleObjC)) { 2463 if (IncompatibleObjC) 2464 return false; 2465 // Okay, we have an Objective-C pointer conversion. 2466 } else 2467 // Argument types are too different. Abort. 2468 return false; 2469 } 2470 if (LangOpts.ObjCAutoRefCount && 2471 !Context.FunctionTypesMatchOnNSConsumedAttrs(FromFunctionType, 2472 ToFunctionType)) 2473 return false; 2474 2475 ConvertedType = ToType; 2476 return true; 2477 } 2478 2479 enum { 2480 ft_default, 2481 ft_different_class, 2482 ft_parameter_arity, 2483 ft_parameter_mismatch, 2484 ft_return_type, 2485 ft_qualifer_mismatch 2486 }; 2487 2488 /// HandleFunctionTypeMismatch - Gives diagnostic information for differeing 2489 /// function types. Catches different number of parameter, mismatch in 2490 /// parameter types, and different return types. 2491 void Sema::HandleFunctionTypeMismatch(PartialDiagnostic &PDiag, 2492 QualType FromType, QualType ToType) { 2493 // If either type is not valid, include no extra info. 2494 if (FromType.isNull() || ToType.isNull()) { 2495 PDiag << ft_default; 2496 return; 2497 } 2498 2499 // Get the function type from the pointers. 2500 if (FromType->isMemberPointerType() && ToType->isMemberPointerType()) { 2501 const MemberPointerType *FromMember = FromType->getAs<MemberPointerType>(), 2502 *ToMember = ToType->getAs<MemberPointerType>(); 2503 if (FromMember->getClass() != ToMember->getClass()) { 2504 PDiag << ft_different_class << QualType(ToMember->getClass(), 0) 2505 << QualType(FromMember->getClass(), 0); 2506 return; 2507 } 2508 FromType = FromMember->getPointeeType(); 2509 ToType = ToMember->getPointeeType(); 2510 } 2511 2512 if (FromType->isPointerType()) 2513 FromType = FromType->getPointeeType(); 2514 if (ToType->isPointerType()) 2515 ToType = ToType->getPointeeType(); 2516 2517 // Remove references. 2518 FromType = FromType.getNonReferenceType(); 2519 ToType = ToType.getNonReferenceType(); 2520 2521 // Don't print extra info for non-specialized template functions. 2522 if (FromType->isInstantiationDependentType() && 2523 !FromType->getAs<TemplateSpecializationType>()) { 2524 PDiag << ft_default; 2525 return; 2526 } 2527 2528 // No extra info for same types. 2529 if (Context.hasSameType(FromType, ToType)) { 2530 PDiag << ft_default; 2531 return; 2532 } 2533 2534 const FunctionProtoType *FromFunction = FromType->getAs<FunctionProtoType>(), 2535 *ToFunction = ToType->getAs<FunctionProtoType>(); 2536 2537 // Both types need to be function types. 2538 if (!FromFunction || !ToFunction) { 2539 PDiag << ft_default; 2540 return; 2541 } 2542 2543 if (FromFunction->getNumArgs() != ToFunction->getNumArgs()) { 2544 PDiag << ft_parameter_arity << ToFunction->getNumArgs() 2545 << FromFunction->getNumArgs(); 2546 return; 2547 } 2548 2549 // Handle different parameter types. 2550 unsigned ArgPos; 2551 if (!FunctionArgTypesAreEqual(FromFunction, ToFunction, &ArgPos)) { 2552 PDiag << ft_parameter_mismatch << ArgPos + 1 2553 << ToFunction->getArgType(ArgPos) 2554 << FromFunction->getArgType(ArgPos); 2555 return; 2556 } 2557 2558 // Handle different return type. 2559 if (!Context.hasSameType(FromFunction->getResultType(), 2560 ToFunction->getResultType())) { 2561 PDiag << ft_return_type << ToFunction->getResultType() 2562 << FromFunction->getResultType(); 2563 return; 2564 } 2565 2566 unsigned FromQuals = FromFunction->getTypeQuals(), 2567 ToQuals = ToFunction->getTypeQuals(); 2568 if (FromQuals != ToQuals) { 2569 PDiag << ft_qualifer_mismatch << ToQuals << FromQuals; 2570 return; 2571 } 2572 2573 // Unable to find a difference, so add no extra info. 2574 PDiag << ft_default; 2575 } 2576 2577 /// FunctionArgTypesAreEqual - This routine checks two function proto types 2578 /// for equality of their argument types. Caller has already checked that 2579 /// they have same number of arguments. If the parameters are different, 2580 /// ArgPos will have the parameter index of the first different parameter. 2581 bool Sema::FunctionArgTypesAreEqual(const FunctionProtoType *OldType, 2582 const FunctionProtoType *NewType, 2583 unsigned *ArgPos) { 2584 for (FunctionProtoType::arg_type_iterator O = OldType->arg_type_begin(), 2585 N = NewType->arg_type_begin(), 2586 E = OldType->arg_type_end(); O && (O != E); ++O, ++N) { 2587 if (!Context.hasSameType(*O, *N)) { 2588 if (ArgPos) *ArgPos = O - OldType->arg_type_begin(); 2589 return false; 2590 } 2591 } 2592 return true; 2593 } 2594 2595 /// CheckPointerConversion - Check the pointer conversion from the 2596 /// expression From to the type ToType. This routine checks for 2597 /// ambiguous or inaccessible derived-to-base pointer 2598 /// conversions for which IsPointerConversion has already returned 2599 /// true. It returns true and produces a diagnostic if there was an 2600 /// error, or returns false otherwise. 2601 bool Sema::CheckPointerConversion(Expr *From, QualType ToType, 2602 CastKind &Kind, 2603 CXXCastPath& BasePath, 2604 bool IgnoreBaseAccess) { 2605 QualType FromType = From->getType(); 2606 bool IsCStyleOrFunctionalCast = IgnoreBaseAccess; 2607 2608 Kind = CK_BitCast; 2609 2610 if (!IsCStyleOrFunctionalCast && !FromType->isAnyPointerType() && 2611 From->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNotNull) == 2612 Expr::NPCK_ZeroExpression) { 2613 if (Context.hasSameUnqualifiedType(From->getType(), Context.BoolTy)) 2614 DiagRuntimeBehavior(From->getExprLoc(), From, 2615 PDiag(diag::warn_impcast_bool_to_null_pointer) 2616 << ToType << From->getSourceRange()); 2617 else if (!isUnevaluatedContext()) 2618 Diag(From->getExprLoc(), diag::warn_non_literal_null_pointer) 2619 << ToType << From->getSourceRange(); 2620 } 2621 if (const PointerType *ToPtrType = ToType->getAs<PointerType>()) { 2622 if (const PointerType *FromPtrType = FromType->getAs<PointerType>()) { 2623 QualType FromPointeeType = FromPtrType->getPointeeType(), 2624 ToPointeeType = ToPtrType->getPointeeType(); 2625 2626 if (FromPointeeType->isRecordType() && ToPointeeType->isRecordType() && 2627 !Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType)) { 2628 // We must have a derived-to-base conversion. Check an 2629 // ambiguous or inaccessible conversion. 2630 if (CheckDerivedToBaseConversion(FromPointeeType, ToPointeeType, 2631 From->getExprLoc(), 2632 From->getSourceRange(), &BasePath, 2633 IgnoreBaseAccess)) 2634 return true; 2635 2636 // The conversion was successful. 2637 Kind = CK_DerivedToBase; 2638 } 2639 } 2640 } else if (const ObjCObjectPointerType *ToPtrType = 2641 ToType->getAs<ObjCObjectPointerType>()) { 2642 if (const ObjCObjectPointerType *FromPtrType = 2643 FromType->getAs<ObjCObjectPointerType>()) { 2644 // Objective-C++ conversions are always okay. 2645 // FIXME: We should have a different class of conversions for the 2646 // Objective-C++ implicit conversions. 2647 if (FromPtrType->isObjCBuiltinType() || ToPtrType->isObjCBuiltinType()) 2648 return false; 2649 } else if (FromType->isBlockPointerType()) { 2650 Kind = CK_BlockPointerToObjCPointerCast; 2651 } else { 2652 Kind = CK_CPointerToObjCPointerCast; 2653 } 2654 } else if (ToType->isBlockPointerType()) { 2655 if (!FromType->isBlockPointerType()) 2656 Kind = CK_AnyPointerToBlockPointerCast; 2657 } 2658 2659 // We shouldn't fall into this case unless it's valid for other 2660 // reasons. 2661 if (From->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) 2662 Kind = CK_NullToPointer; 2663 2664 return false; 2665 } 2666 2667 /// IsMemberPointerConversion - Determines whether the conversion of the 2668 /// expression From, which has the (possibly adjusted) type FromType, can be 2669 /// converted to the type ToType via a member pointer conversion (C++ 4.11). 2670 /// If so, returns true and places the converted type (that might differ from 2671 /// ToType in its cv-qualifiers at some level) into ConvertedType. 2672 bool Sema::IsMemberPointerConversion(Expr *From, QualType FromType, 2673 QualType ToType, 2674 bool InOverloadResolution, 2675 QualType &ConvertedType) { 2676 const MemberPointerType *ToTypePtr = ToType->getAs<MemberPointerType>(); 2677 if (!ToTypePtr) 2678 return false; 2679 2680 // A null pointer constant can be converted to a member pointer (C++ 4.11p1) 2681 if (From->isNullPointerConstant(Context, 2682 InOverloadResolution? Expr::NPC_ValueDependentIsNotNull 2683 : Expr::NPC_ValueDependentIsNull)) { 2684 ConvertedType = ToType; 2685 return true; 2686 } 2687 2688 // Otherwise, both types have to be member pointers. 2689 const MemberPointerType *FromTypePtr = FromType->getAs<MemberPointerType>(); 2690 if (!FromTypePtr) 2691 return false; 2692 2693 // A pointer to member of B can be converted to a pointer to member of D, 2694 // where D is derived from B (C++ 4.11p2). 2695 QualType FromClass(FromTypePtr->getClass(), 0); 2696 QualType ToClass(ToTypePtr->getClass(), 0); 2697 2698 if (!Context.hasSameUnqualifiedType(FromClass, ToClass) && 2699 !RequireCompleteType(From->getLocStart(), ToClass, 0) && 2700 IsDerivedFrom(ToClass, FromClass)) { 2701 ConvertedType = Context.getMemberPointerType(FromTypePtr->getPointeeType(), 2702 ToClass.getTypePtr()); 2703 return true; 2704 } 2705 2706 return false; 2707 } 2708 2709 /// CheckMemberPointerConversion - Check the member pointer conversion from the 2710 /// expression From to the type ToType. This routine checks for ambiguous or 2711 /// virtual or inaccessible base-to-derived member pointer conversions 2712 /// for which IsMemberPointerConversion has already returned true. It returns 2713 /// true and produces a diagnostic if there was an error, or returns false 2714 /// otherwise. 2715 bool Sema::CheckMemberPointerConversion(Expr *From, QualType ToType, 2716 CastKind &Kind, 2717 CXXCastPath &BasePath, 2718 bool IgnoreBaseAccess) { 2719 QualType FromType = From->getType(); 2720 const MemberPointerType *FromPtrType = FromType->getAs<MemberPointerType>(); 2721 if (!FromPtrType) { 2722 // This must be a null pointer to member pointer conversion 2723 assert(From->isNullPointerConstant(Context, 2724 Expr::NPC_ValueDependentIsNull) && 2725 "Expr must be null pointer constant!"); 2726 Kind = CK_NullToMemberPointer; 2727 return false; 2728 } 2729 2730 const MemberPointerType *ToPtrType = ToType->getAs<MemberPointerType>(); 2731 assert(ToPtrType && "No member pointer cast has a target type " 2732 "that is not a member pointer."); 2733 2734 QualType FromClass = QualType(FromPtrType->getClass(), 0); 2735 QualType ToClass = QualType(ToPtrType->getClass(), 0); 2736 2737 // FIXME: What about dependent types? 2738 assert(FromClass->isRecordType() && "Pointer into non-class."); 2739 assert(ToClass->isRecordType() && "Pointer into non-class."); 2740 2741 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, 2742 /*DetectVirtual=*/true); 2743 bool DerivationOkay = IsDerivedFrom(ToClass, FromClass, Paths); 2744 assert(DerivationOkay && 2745 "Should not have been called if derivation isn't OK."); 2746 (void)DerivationOkay; 2747 2748 if (Paths.isAmbiguous(Context.getCanonicalType(FromClass). 2749 getUnqualifiedType())) { 2750 std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths); 2751 Diag(From->getExprLoc(), diag::err_ambiguous_memptr_conv) 2752 << 0 << FromClass << ToClass << PathDisplayStr << From->getSourceRange(); 2753 return true; 2754 } 2755 2756 if (const RecordType *VBase = Paths.getDetectedVirtual()) { 2757 Diag(From->getExprLoc(), diag::err_memptr_conv_via_virtual) 2758 << FromClass << ToClass << QualType(VBase, 0) 2759 << From->getSourceRange(); 2760 return true; 2761 } 2762 2763 if (!IgnoreBaseAccess) 2764 CheckBaseClassAccess(From->getExprLoc(), FromClass, ToClass, 2765 Paths.front(), 2766 diag::err_downcast_from_inaccessible_base); 2767 2768 // Must be a base to derived member conversion. 2769 BuildBasePathArray(Paths, BasePath); 2770 Kind = CK_BaseToDerivedMemberPointer; 2771 return false; 2772 } 2773 2774 /// IsQualificationConversion - Determines whether the conversion from 2775 /// an rvalue of type FromType to ToType is a qualification conversion 2776 /// (C++ 4.4). 2777 /// 2778 /// \param ObjCLifetimeConversion Output parameter that will be set to indicate 2779 /// when the qualification conversion involves a change in the Objective-C 2780 /// object lifetime. 2781 bool 2782 Sema::IsQualificationConversion(QualType FromType, QualType ToType, 2783 bool CStyle, bool &ObjCLifetimeConversion) { 2784 FromType = Context.getCanonicalType(FromType); 2785 ToType = Context.getCanonicalType(ToType); 2786 ObjCLifetimeConversion = false; 2787 2788 // If FromType and ToType are the same type, this is not a 2789 // qualification conversion. 2790 if (FromType.getUnqualifiedType() == ToType.getUnqualifiedType()) 2791 return false; 2792 2793 // (C++ 4.4p4): 2794 // A conversion can add cv-qualifiers at levels other than the first 2795 // in multi-level pointers, subject to the following rules: [...] 2796 bool PreviousToQualsIncludeConst = true; 2797 bool UnwrappedAnyPointer = false; 2798 while (Context.UnwrapSimilarPointerTypes(FromType, ToType)) { 2799 // Within each iteration of the loop, we check the qualifiers to 2800 // determine if this still looks like a qualification 2801 // conversion. Then, if all is well, we unwrap one more level of 2802 // pointers or pointers-to-members and do it all again 2803 // until there are no more pointers or pointers-to-members left to 2804 // unwrap. 2805 UnwrappedAnyPointer = true; 2806 2807 Qualifiers FromQuals = FromType.getQualifiers(); 2808 Qualifiers ToQuals = ToType.getQualifiers(); 2809 2810 // Objective-C ARC: 2811 // Check Objective-C lifetime conversions. 2812 if (FromQuals.getObjCLifetime() != ToQuals.getObjCLifetime() && 2813 UnwrappedAnyPointer) { 2814 if (ToQuals.compatiblyIncludesObjCLifetime(FromQuals)) { 2815 ObjCLifetimeConversion = true; 2816 FromQuals.removeObjCLifetime(); 2817 ToQuals.removeObjCLifetime(); 2818 } else { 2819 // Qualification conversions cannot cast between different 2820 // Objective-C lifetime qualifiers. 2821 return false; 2822 } 2823 } 2824 2825 // Allow addition/removal of GC attributes but not changing GC attributes. 2826 if (FromQuals.getObjCGCAttr() != ToQuals.getObjCGCAttr() && 2827 (!FromQuals.hasObjCGCAttr() || !ToQuals.hasObjCGCAttr())) { 2828 FromQuals.removeObjCGCAttr(); 2829 ToQuals.removeObjCGCAttr(); 2830 } 2831 2832 // -- for every j > 0, if const is in cv 1,j then const is in cv 2833 // 2,j, and similarly for volatile. 2834 if (!CStyle && !ToQuals.compatiblyIncludes(FromQuals)) 2835 return false; 2836 2837 // -- if the cv 1,j and cv 2,j are different, then const is in 2838 // every cv for 0 < k < j. 2839 if (!CStyle && FromQuals.getCVRQualifiers() != ToQuals.getCVRQualifiers() 2840 && !PreviousToQualsIncludeConst) 2841 return false; 2842 2843 // Keep track of whether all prior cv-qualifiers in the "to" type 2844 // include const. 2845 PreviousToQualsIncludeConst 2846 = PreviousToQualsIncludeConst && ToQuals.hasConst(); 2847 } 2848 2849 // We are left with FromType and ToType being the pointee types 2850 // after unwrapping the original FromType and ToType the same number 2851 // of types. If we unwrapped any pointers, and if FromType and 2852 // ToType have the same unqualified type (since we checked 2853 // qualifiers above), then this is a qualification conversion. 2854 return UnwrappedAnyPointer && Context.hasSameUnqualifiedType(FromType,ToType); 2855 } 2856 2857 /// \brief - Determine whether this is a conversion from a scalar type to an 2858 /// atomic type. 2859 /// 2860 /// If successful, updates \c SCS's second and third steps in the conversion 2861 /// sequence to finish the conversion. 2862 static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType, 2863 bool InOverloadResolution, 2864 StandardConversionSequence &SCS, 2865 bool CStyle) { 2866 const AtomicType *ToAtomic = ToType->getAs<AtomicType>(); 2867 if (!ToAtomic) 2868 return false; 2869 2870 StandardConversionSequence InnerSCS; 2871 if (!IsStandardConversion(S, From, ToAtomic->getValueType(), 2872 InOverloadResolution, InnerSCS, 2873 CStyle, /*AllowObjCWritebackConversion=*/false)) 2874 return false; 2875 2876 SCS.Second = InnerSCS.Second; 2877 SCS.setToType(1, InnerSCS.getToType(1)); 2878 SCS.Third = InnerSCS.Third; 2879 SCS.QualificationIncludesObjCLifetime 2880 = InnerSCS.QualificationIncludesObjCLifetime; 2881 SCS.setToType(2, InnerSCS.getToType(2)); 2882 return true; 2883 } 2884 2885 static bool isFirstArgumentCompatibleWithType(ASTContext &Context, 2886 CXXConstructorDecl *Constructor, 2887 QualType Type) { 2888 const FunctionProtoType *CtorType = 2889 Constructor->getType()->getAs<FunctionProtoType>(); 2890 if (CtorType->getNumArgs() > 0) { 2891 QualType FirstArg = CtorType->getArgType(0); 2892 if (Context.hasSameUnqualifiedType(Type, FirstArg.getNonReferenceType())) 2893 return true; 2894 } 2895 return false; 2896 } 2897 2898 static OverloadingResult 2899 IsInitializerListConstructorConversion(Sema &S, Expr *From, QualType ToType, 2900 CXXRecordDecl *To, 2901 UserDefinedConversionSequence &User, 2902 OverloadCandidateSet &CandidateSet, 2903 bool AllowExplicit) { 2904 DeclContext::lookup_result R = S.LookupConstructors(To); 2905 for (DeclContext::lookup_iterator Con = R.begin(), ConEnd = R.end(); 2906 Con != ConEnd; ++Con) { 2907 NamedDecl *D = *Con; 2908 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess()); 2909 2910 // Find the constructor (which may be a template). 2911 CXXConstructorDecl *Constructor = 0; 2912 FunctionTemplateDecl *ConstructorTmpl 2913 = dyn_cast<FunctionTemplateDecl>(D); 2914 if (ConstructorTmpl) 2915 Constructor 2916 = cast<CXXConstructorDecl>(ConstructorTmpl->getTemplatedDecl()); 2917 else 2918 Constructor = cast<CXXConstructorDecl>(D); 2919 2920 bool Usable = !Constructor->isInvalidDecl() && 2921 S.isInitListConstructor(Constructor) && 2922 (AllowExplicit || !Constructor->isExplicit()); 2923 if (Usable) { 2924 // If the first argument is (a reference to) the target type, 2925 // suppress conversions. 2926 bool SuppressUserConversions = 2927 isFirstArgumentCompatibleWithType(S.Context, Constructor, ToType); 2928 if (ConstructorTmpl) 2929 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl, 2930 /*ExplicitArgs*/ 0, 2931 From, CandidateSet, 2932 SuppressUserConversions); 2933 else 2934 S.AddOverloadCandidate(Constructor, FoundDecl, 2935 From, CandidateSet, 2936 SuppressUserConversions); 2937 } 2938 } 2939 2940 bool HadMultipleCandidates = (CandidateSet.size() > 1); 2941 2942 OverloadCandidateSet::iterator Best; 2943 switch (CandidateSet.BestViableFunction(S, From->getLocStart(), Best, true)) { 2944 case OR_Success: { 2945 // Record the standard conversion we used and the conversion function. 2946 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function); 2947 QualType ThisType = Constructor->getThisType(S.Context); 2948 // Initializer lists don't have conversions as such. 2949 User.Before.setAsIdentityConversion(); 2950 User.HadMultipleCandidates = HadMultipleCandidates; 2951 User.ConversionFunction = Constructor; 2952 User.FoundConversionFunction = Best->FoundDecl; 2953 User.After.setAsIdentityConversion(); 2954 User.After.setFromType(ThisType->getAs<PointerType>()->getPointeeType()); 2955 User.After.setAllToTypes(ToType); 2956 return OR_Success; 2957 } 2958 2959 case OR_No_Viable_Function: 2960 return OR_No_Viable_Function; 2961 case OR_Deleted: 2962 return OR_Deleted; 2963 case OR_Ambiguous: 2964 return OR_Ambiguous; 2965 } 2966 2967 llvm_unreachable("Invalid OverloadResult!"); 2968 } 2969 2970 /// Determines whether there is a user-defined conversion sequence 2971 /// (C++ [over.ics.user]) that converts expression From to the type 2972 /// ToType. If such a conversion exists, User will contain the 2973 /// user-defined conversion sequence that performs such a conversion 2974 /// and this routine will return true. Otherwise, this routine returns 2975 /// false and User is unspecified. 2976 /// 2977 /// \param AllowExplicit true if the conversion should consider C++0x 2978 /// "explicit" conversion functions as well as non-explicit conversion 2979 /// functions (C++0x [class.conv.fct]p2). 2980 static OverloadingResult 2981 IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType, 2982 UserDefinedConversionSequence &User, 2983 OverloadCandidateSet &CandidateSet, 2984 bool AllowExplicit) { 2985 // Whether we will only visit constructors. 2986 bool ConstructorsOnly = false; 2987 2988 // If the type we are conversion to is a class type, enumerate its 2989 // constructors. 2990 if (const RecordType *ToRecordType = ToType->getAs<RecordType>()) { 2991 // C++ [over.match.ctor]p1: 2992 // When objects of class type are direct-initialized (8.5), or 2993 // copy-initialized from an expression of the same or a 2994 // derived class type (8.5), overload resolution selects the 2995 // constructor. [...] For copy-initialization, the candidate 2996 // functions are all the converting constructors (12.3.1) of 2997 // that class. The argument list is the expression-list within 2998 // the parentheses of the initializer. 2999 if (S.Context.hasSameUnqualifiedType(ToType, From->getType()) || 3000 (From->getType()->getAs<RecordType>() && 3001 S.IsDerivedFrom(From->getType(), ToType))) 3002 ConstructorsOnly = true; 3003 3004 S.RequireCompleteType(From->getExprLoc(), ToType, 0); 3005 // RequireCompleteType may have returned true due to some invalid decl 3006 // during template instantiation, but ToType may be complete enough now 3007 // to try to recover. 3008 if (ToType->isIncompleteType()) { 3009 // We're not going to find any constructors. 3010 } else if (CXXRecordDecl *ToRecordDecl 3011 = dyn_cast<CXXRecordDecl>(ToRecordType->getDecl())) { 3012 3013 Expr **Args = &From; 3014 unsigned NumArgs = 1; 3015 bool ListInitializing = false; 3016 if (InitListExpr *InitList = dyn_cast<InitListExpr>(From)) { 3017 // But first, see if there is an init-list-contructor that will work. 3018 OverloadingResult Result = IsInitializerListConstructorConversion( 3019 S, From, ToType, ToRecordDecl, User, CandidateSet, AllowExplicit); 3020 if (Result != OR_No_Viable_Function) 3021 return Result; 3022 // Never mind. 3023 CandidateSet.clear(); 3024 3025 // If we're list-initializing, we pass the individual elements as 3026 // arguments, not the entire list. 3027 Args = InitList->getInits(); 3028 NumArgs = InitList->getNumInits(); 3029 ListInitializing = true; 3030 } 3031 3032 DeclContext::lookup_result R = S.LookupConstructors(ToRecordDecl); 3033 for (DeclContext::lookup_iterator Con = R.begin(), ConEnd = R.end(); 3034 Con != ConEnd; ++Con) { 3035 NamedDecl *D = *Con; 3036 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess()); 3037 3038 // Find the constructor (which may be a template). 3039 CXXConstructorDecl *Constructor = 0; 3040 FunctionTemplateDecl *ConstructorTmpl 3041 = dyn_cast<FunctionTemplateDecl>(D); 3042 if (ConstructorTmpl) 3043 Constructor 3044 = cast<CXXConstructorDecl>(ConstructorTmpl->getTemplatedDecl()); 3045 else 3046 Constructor = cast<CXXConstructorDecl>(D); 3047 3048 bool Usable = !Constructor->isInvalidDecl(); 3049 if (ListInitializing) 3050 Usable = Usable && (AllowExplicit || !Constructor->isExplicit()); 3051 else 3052 Usable = Usable &&Constructor->isConvertingConstructor(AllowExplicit); 3053 if (Usable) { 3054 bool SuppressUserConversions = !ConstructorsOnly; 3055 if (SuppressUserConversions && ListInitializing) { 3056 SuppressUserConversions = false; 3057 if (NumArgs == 1) { 3058 // If the first argument is (a reference to) the target type, 3059 // suppress conversions. 3060 SuppressUserConversions = isFirstArgumentCompatibleWithType( 3061 S.Context, Constructor, ToType); 3062 } 3063 } 3064 if (ConstructorTmpl) 3065 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl, 3066 /*ExplicitArgs*/ 0, 3067 llvm::makeArrayRef(Args, NumArgs), 3068 CandidateSet, SuppressUserConversions); 3069 else 3070 // Allow one user-defined conversion when user specifies a 3071 // From->ToType conversion via an static cast (c-style, etc). 3072 S.AddOverloadCandidate(Constructor, FoundDecl, 3073 llvm::makeArrayRef(Args, NumArgs), 3074 CandidateSet, SuppressUserConversions); 3075 } 3076 } 3077 } 3078 } 3079 3080 // Enumerate conversion functions, if we're allowed to. 3081 if (ConstructorsOnly || isa<InitListExpr>(From)) { 3082 } else if (S.RequireCompleteType(From->getLocStart(), From->getType(), 0)) { 3083 // No conversion functions from incomplete types. 3084 } else if (const RecordType *FromRecordType 3085 = From->getType()->getAs<RecordType>()) { 3086 if (CXXRecordDecl *FromRecordDecl 3087 = dyn_cast<CXXRecordDecl>(FromRecordType->getDecl())) { 3088 // Add all of the conversion functions as candidates. 3089 std::pair<CXXRecordDecl::conversion_iterator, 3090 CXXRecordDecl::conversion_iterator> 3091 Conversions = FromRecordDecl->getVisibleConversionFunctions(); 3092 for (CXXRecordDecl::conversion_iterator 3093 I = Conversions.first, E = Conversions.second; I != E; ++I) { 3094 DeclAccessPair FoundDecl = I.getPair(); 3095 NamedDecl *D = FoundDecl.getDecl(); 3096 CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext()); 3097 if (isa<UsingShadowDecl>(D)) 3098 D = cast<UsingShadowDecl>(D)->getTargetDecl(); 3099 3100 CXXConversionDecl *Conv; 3101 FunctionTemplateDecl *ConvTemplate; 3102 if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D))) 3103 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl()); 3104 else 3105 Conv = cast<CXXConversionDecl>(D); 3106 3107 if (AllowExplicit || !Conv->isExplicit()) { 3108 if (ConvTemplate) 3109 S.AddTemplateConversionCandidate(ConvTemplate, FoundDecl, 3110 ActingContext, From, ToType, 3111 CandidateSet); 3112 else 3113 S.AddConversionCandidate(Conv, FoundDecl, ActingContext, 3114 From, ToType, CandidateSet); 3115 } 3116 } 3117 } 3118 } 3119 3120 bool HadMultipleCandidates = (CandidateSet.size() > 1); 3121 3122 OverloadCandidateSet::iterator Best; 3123 switch (CandidateSet.BestViableFunction(S, From->getLocStart(), Best, true)) { 3124 case OR_Success: 3125 // Record the standard conversion we used and the conversion function. 3126 if (CXXConstructorDecl *Constructor 3127 = dyn_cast<CXXConstructorDecl>(Best->Function)) { 3128 // C++ [over.ics.user]p1: 3129 // If the user-defined conversion is specified by a 3130 // constructor (12.3.1), the initial standard conversion 3131 // sequence converts the source type to the type required by 3132 // the argument of the constructor. 3133 // 3134 QualType ThisType = Constructor->getThisType(S.Context); 3135 if (isa<InitListExpr>(From)) { 3136 // Initializer lists don't have conversions as such. 3137 User.Before.setAsIdentityConversion(); 3138 } else { 3139 if (Best->Conversions[0].isEllipsis()) 3140 User.EllipsisConversion = true; 3141 else { 3142 User.Before = Best->Conversions[0].Standard; 3143 User.EllipsisConversion = false; 3144 } 3145 } 3146 User.HadMultipleCandidates = HadMultipleCandidates; 3147 User.ConversionFunction = Constructor; 3148 User.FoundConversionFunction = Best->FoundDecl; 3149 User.After.setAsIdentityConversion(); 3150 User.After.setFromType(ThisType->getAs<PointerType>()->getPointeeType()); 3151 User.After.setAllToTypes(ToType); 3152 return OR_Success; 3153 } 3154 if (CXXConversionDecl *Conversion 3155 = dyn_cast<CXXConversionDecl>(Best->Function)) { 3156 // C++ [over.ics.user]p1: 3157 // 3158 // [...] If the user-defined conversion is specified by a 3159 // conversion function (12.3.2), the initial standard 3160 // conversion sequence converts the source type to the 3161 // implicit object parameter of the conversion function. 3162 User.Before = Best->Conversions[0].Standard; 3163 User.HadMultipleCandidates = HadMultipleCandidates; 3164 User.ConversionFunction = Conversion; 3165 User.FoundConversionFunction = Best->FoundDecl; 3166 User.EllipsisConversion = false; 3167 3168 // C++ [over.ics.user]p2: 3169 // The second standard conversion sequence converts the 3170 // result of the user-defined conversion to the target type 3171 // for the sequence. Since an implicit conversion sequence 3172 // is an initialization, the special rules for 3173 // initialization by user-defined conversion apply when 3174 // selecting the best user-defined conversion for a 3175 // user-defined conversion sequence (see 13.3.3 and 3176 // 13.3.3.1). 3177 User.After = Best->FinalConversion; 3178 return OR_Success; 3179 } 3180 llvm_unreachable("Not a constructor or conversion function?"); 3181 3182 case OR_No_Viable_Function: 3183 return OR_No_Viable_Function; 3184 case OR_Deleted: 3185 // No conversion here! We're done. 3186 return OR_Deleted; 3187 3188 case OR_Ambiguous: 3189 return OR_Ambiguous; 3190 } 3191 3192 llvm_unreachable("Invalid OverloadResult!"); 3193 } 3194 3195 bool 3196 Sema::DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType) { 3197 ImplicitConversionSequence ICS; 3198 OverloadCandidateSet CandidateSet(From->getExprLoc()); 3199 OverloadingResult OvResult = 3200 IsUserDefinedConversion(*this, From, ToType, ICS.UserDefined, 3201 CandidateSet, false); 3202 if (OvResult == OR_Ambiguous) 3203 Diag(From->getLocStart(), 3204 diag::err_typecheck_ambiguous_condition) 3205 << From->getType() << ToType << From->getSourceRange(); 3206 else if (OvResult == OR_No_Viable_Function && !CandidateSet.empty()) { 3207 if (!RequireCompleteType(From->getLocStart(), ToType, 3208 diag::err_typecheck_nonviable_condition_incomplete, 3209 From->getType(), From->getSourceRange())) 3210 Diag(From->getLocStart(), 3211 diag::err_typecheck_nonviable_condition) 3212 << From->getType() << From->getSourceRange() << ToType; 3213 } 3214 else 3215 return false; 3216 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, From); 3217 return true; 3218 } 3219 3220 /// \brief Compare the user-defined conversion functions or constructors 3221 /// of two user-defined conversion sequences to determine whether any ordering 3222 /// is possible. 3223 static ImplicitConversionSequence::CompareKind 3224 compareConversionFunctions(Sema &S, 3225 FunctionDecl *Function1, 3226 FunctionDecl *Function2) { 3227 if (!S.getLangOpts().ObjC1 || !S.getLangOpts().CPlusPlus11) 3228 return ImplicitConversionSequence::Indistinguishable; 3229 3230 // Objective-C++: 3231 // If both conversion functions are implicitly-declared conversions from 3232 // a lambda closure type to a function pointer and a block pointer, 3233 // respectively, always prefer the conversion to a function pointer, 3234 // because the function pointer is more lightweight and is more likely 3235 // to keep code working. 3236 CXXConversionDecl *Conv1 = dyn_cast<CXXConversionDecl>(Function1); 3237 if (!Conv1) 3238 return ImplicitConversionSequence::Indistinguishable; 3239 3240 CXXConversionDecl *Conv2 = dyn_cast<CXXConversionDecl>(Function2); 3241 if (!Conv2) 3242 return ImplicitConversionSequence::Indistinguishable; 3243 3244 if (Conv1->getParent()->isLambda() && Conv2->getParent()->isLambda()) { 3245 bool Block1 = Conv1->getConversionType()->isBlockPointerType(); 3246 bool Block2 = Conv2->getConversionType()->isBlockPointerType(); 3247 if (Block1 != Block2) 3248 return Block1? ImplicitConversionSequence::Worse 3249 : ImplicitConversionSequence::Better; 3250 } 3251 3252 return ImplicitConversionSequence::Indistinguishable; 3253 } 3254 3255 /// CompareImplicitConversionSequences - Compare two implicit 3256 /// conversion sequences to determine whether one is better than the 3257 /// other or if they are indistinguishable (C++ 13.3.3.2). 3258 static ImplicitConversionSequence::CompareKind 3259 CompareImplicitConversionSequences(Sema &S, 3260 const ImplicitConversionSequence& ICS1, 3261 const ImplicitConversionSequence& ICS2) 3262 { 3263 // (C++ 13.3.3.2p2): When comparing the basic forms of implicit 3264 // conversion sequences (as defined in 13.3.3.1) 3265 // -- a standard conversion sequence (13.3.3.1.1) is a better 3266 // conversion sequence than a user-defined conversion sequence or 3267 // an ellipsis conversion sequence, and 3268 // -- a user-defined conversion sequence (13.3.3.1.2) is a better 3269 // conversion sequence than an ellipsis conversion sequence 3270 // (13.3.3.1.3). 3271 // 3272 // C++0x [over.best.ics]p10: 3273 // For the purpose of ranking implicit conversion sequences as 3274 // described in 13.3.3.2, the ambiguous conversion sequence is 3275 // treated as a user-defined sequence that is indistinguishable 3276 // from any other user-defined conversion sequence. 3277 if (ICS1.getKindRank() < ICS2.getKindRank()) 3278 return ImplicitConversionSequence::Better; 3279 if (ICS2.getKindRank() < ICS1.getKindRank()) 3280 return ImplicitConversionSequence::Worse; 3281 3282 // The following checks require both conversion sequences to be of 3283 // the same kind. 3284 if (ICS1.getKind() != ICS2.getKind()) 3285 return ImplicitConversionSequence::Indistinguishable; 3286 3287 ImplicitConversionSequence::CompareKind Result = 3288 ImplicitConversionSequence::Indistinguishable; 3289 3290 // Two implicit conversion sequences of the same form are 3291 // indistinguishable conversion sequences unless one of the 3292 // following rules apply: (C++ 13.3.3.2p3): 3293 if (ICS1.isStandard()) 3294 Result = CompareStandardConversionSequences(S, 3295 ICS1.Standard, ICS2.Standard); 3296 else if (ICS1.isUserDefined()) { 3297 // User-defined conversion sequence U1 is a better conversion 3298 // sequence than another user-defined conversion sequence U2 if 3299 // they contain the same user-defined conversion function or 3300 // constructor and if the second standard conversion sequence of 3301 // U1 is better than the second standard conversion sequence of 3302 // U2 (C++ 13.3.3.2p3). 3303 if (ICS1.UserDefined.ConversionFunction == 3304 ICS2.UserDefined.ConversionFunction) 3305 Result = CompareStandardConversionSequences(S, 3306 ICS1.UserDefined.After, 3307 ICS2.UserDefined.After); 3308 else 3309 Result = compareConversionFunctions(S, 3310 ICS1.UserDefined.ConversionFunction, 3311 ICS2.UserDefined.ConversionFunction); 3312 } 3313 3314 // List-initialization sequence L1 is a better conversion sequence than 3315 // list-initialization sequence L2 if L1 converts to std::initializer_list<X> 3316 // for some X and L2 does not. 3317 if (Result == ImplicitConversionSequence::Indistinguishable && 3318 !ICS1.isBad() && 3319 ICS1.isListInitializationSequence() && 3320 ICS2.isListInitializationSequence()) { 3321 if (ICS1.isStdInitializerListElement() && 3322 !ICS2.isStdInitializerListElement()) 3323 return ImplicitConversionSequence::Better; 3324 if (!ICS1.isStdInitializerListElement() && 3325 ICS2.isStdInitializerListElement()) 3326 return ImplicitConversionSequence::Worse; 3327 } 3328 3329 return Result; 3330 } 3331 3332 static bool hasSimilarType(ASTContext &Context, QualType T1, QualType T2) { 3333 while (Context.UnwrapSimilarPointerTypes(T1, T2)) { 3334 Qualifiers Quals; 3335 T1 = Context.getUnqualifiedArrayType(T1, Quals); 3336 T2 = Context.getUnqualifiedArrayType(T2, Quals); 3337 } 3338 3339 return Context.hasSameUnqualifiedType(T1, T2); 3340 } 3341 3342 // Per 13.3.3.2p3, compare the given standard conversion sequences to 3343 // determine if one is a proper subset of the other. 3344 static ImplicitConversionSequence::CompareKind 3345 compareStandardConversionSubsets(ASTContext &Context, 3346 const StandardConversionSequence& SCS1, 3347 const StandardConversionSequence& SCS2) { 3348 ImplicitConversionSequence::CompareKind Result 3349 = ImplicitConversionSequence::Indistinguishable; 3350 3351 // the identity conversion sequence is considered to be a subsequence of 3352 // any non-identity conversion sequence 3353 if (SCS1.isIdentityConversion() && !SCS2.isIdentityConversion()) 3354 return ImplicitConversionSequence::Better; 3355 else if (!SCS1.isIdentityConversion() && SCS2.isIdentityConversion()) 3356 return ImplicitConversionSequence::Worse; 3357 3358 if (SCS1.Second != SCS2.Second) { 3359 if (SCS1.Second == ICK_Identity) 3360 Result = ImplicitConversionSequence::Better; 3361 else if (SCS2.Second == ICK_Identity) 3362 Result = ImplicitConversionSequence::Worse; 3363 else 3364 return ImplicitConversionSequence::Indistinguishable; 3365 } else if (!hasSimilarType(Context, SCS1.getToType(1), SCS2.getToType(1))) 3366 return ImplicitConversionSequence::Indistinguishable; 3367 3368 if (SCS1.Third == SCS2.Third) { 3369 return Context.hasSameType(SCS1.getToType(2), SCS2.getToType(2))? Result 3370 : ImplicitConversionSequence::Indistinguishable; 3371 } 3372 3373 if (SCS1.Third == ICK_Identity) 3374 return Result == ImplicitConversionSequence::Worse 3375 ? ImplicitConversionSequence::Indistinguishable 3376 : ImplicitConversionSequence::Better; 3377 3378 if (SCS2.Third == ICK_Identity) 3379 return Result == ImplicitConversionSequence::Better 3380 ? ImplicitConversionSequence::Indistinguishable 3381 : ImplicitConversionSequence::Worse; 3382 3383 return ImplicitConversionSequence::Indistinguishable; 3384 } 3385 3386 /// \brief Determine whether one of the given reference bindings is better 3387 /// than the other based on what kind of bindings they are. 3388 static bool isBetterReferenceBindingKind(const StandardConversionSequence &SCS1, 3389 const StandardConversionSequence &SCS2) { 3390 // C++0x [over.ics.rank]p3b4: 3391 // -- S1 and S2 are reference bindings (8.5.3) and neither refers to an 3392 // implicit object parameter of a non-static member function declared 3393 // without a ref-qualifier, and *either* S1 binds an rvalue reference 3394 // to an rvalue and S2 binds an lvalue reference *or S1 binds an 3395 // lvalue reference to a function lvalue and S2 binds an rvalue 3396 // reference*. 3397 // 3398 // FIXME: Rvalue references. We're going rogue with the above edits, 3399 // because the semantics in the current C++0x working paper (N3225 at the 3400 // time of this writing) break the standard definition of std::forward 3401 // and std::reference_wrapper when dealing with references to functions. 3402 // Proposed wording changes submitted to CWG for consideration. 3403 if (SCS1.BindsImplicitObjectArgumentWithoutRefQualifier || 3404 SCS2.BindsImplicitObjectArgumentWithoutRefQualifier) 3405 return false; 3406 3407 return (!SCS1.IsLvalueReference && SCS1.BindsToRvalue && 3408 SCS2.IsLvalueReference) || 3409 (SCS1.IsLvalueReference && SCS1.BindsToFunctionLvalue && 3410 !SCS2.IsLvalueReference); 3411 } 3412 3413 /// CompareStandardConversionSequences - Compare two standard 3414 /// conversion sequences to determine whether one is better than the 3415 /// other or if they are indistinguishable (C++ 13.3.3.2p3). 3416 static ImplicitConversionSequence::CompareKind 3417 CompareStandardConversionSequences(Sema &S, 3418 const StandardConversionSequence& SCS1, 3419 const StandardConversionSequence& SCS2) 3420 { 3421 // Standard conversion sequence S1 is a better conversion sequence 3422 // than standard conversion sequence S2 if (C++ 13.3.3.2p3): 3423 3424 // -- S1 is a proper subsequence of S2 (comparing the conversion 3425 // sequences in the canonical form defined by 13.3.3.1.1, 3426 // excluding any Lvalue Transformation; the identity conversion 3427 // sequence is considered to be a subsequence of any 3428 // non-identity conversion sequence) or, if not that, 3429 if (ImplicitConversionSequence::CompareKind CK 3430 = compareStandardConversionSubsets(S.Context, SCS1, SCS2)) 3431 return CK; 3432 3433 // -- the rank of S1 is better than the rank of S2 (by the rules 3434 // defined below), or, if not that, 3435 ImplicitConversionRank Rank1 = SCS1.getRank(); 3436 ImplicitConversionRank Rank2 = SCS2.getRank(); 3437 if (Rank1 < Rank2) 3438 return ImplicitConversionSequence::Better; 3439 else if (Rank2 < Rank1) 3440 return ImplicitConversionSequence::Worse; 3441 3442 // (C++ 13.3.3.2p4): Two conversion sequences with the same rank 3443 // are indistinguishable unless one of the following rules 3444 // applies: 3445 3446 // A conversion that is not a conversion of a pointer, or 3447 // pointer to member, to bool is better than another conversion 3448 // that is such a conversion. 3449 if (SCS1.isPointerConversionToBool() != SCS2.isPointerConversionToBool()) 3450 return SCS2.isPointerConversionToBool() 3451 ? ImplicitConversionSequence::Better 3452 : ImplicitConversionSequence::Worse; 3453 3454 // C++ [over.ics.rank]p4b2: 3455 // 3456 // If class B is derived directly or indirectly from class A, 3457 // conversion of B* to A* is better than conversion of B* to 3458 // void*, and conversion of A* to void* is better than conversion 3459 // of B* to void*. 3460 bool SCS1ConvertsToVoid 3461 = SCS1.isPointerConversionToVoidPointer(S.Context); 3462 bool SCS2ConvertsToVoid 3463 = SCS2.isPointerConversionToVoidPointer(S.Context); 3464 if (SCS1ConvertsToVoid != SCS2ConvertsToVoid) { 3465 // Exactly one of the conversion sequences is a conversion to 3466 // a void pointer; it's the worse conversion. 3467 return SCS2ConvertsToVoid ? ImplicitConversionSequence::Better 3468 : ImplicitConversionSequence::Worse; 3469 } else if (!SCS1ConvertsToVoid && !SCS2ConvertsToVoid) { 3470 // Neither conversion sequence converts to a void pointer; compare 3471 // their derived-to-base conversions. 3472 if (ImplicitConversionSequence::CompareKind DerivedCK 3473 = CompareDerivedToBaseConversions(S, SCS1, SCS2)) 3474 return DerivedCK; 3475 } else if (SCS1ConvertsToVoid && SCS2ConvertsToVoid && 3476 !S.Context.hasSameType(SCS1.getFromType(), SCS2.getFromType())) { 3477 // Both conversion sequences are conversions to void 3478 // pointers. Compare the source types to determine if there's an 3479 // inheritance relationship in their sources. 3480 QualType FromType1 = SCS1.getFromType(); 3481 QualType FromType2 = SCS2.getFromType(); 3482 3483 // Adjust the types we're converting from via the array-to-pointer 3484 // conversion, if we need to. 3485 if (SCS1.First == ICK_Array_To_Pointer) 3486 FromType1 = S.Context.getArrayDecayedType(FromType1); 3487 if (SCS2.First == ICK_Array_To_Pointer) 3488 FromType2 = S.Context.getArrayDecayedType(FromType2); 3489 3490 QualType FromPointee1 = FromType1->getPointeeType().getUnqualifiedType(); 3491 QualType FromPointee2 = FromType2->getPointeeType().getUnqualifiedType(); 3492 3493 if (S.IsDerivedFrom(FromPointee2, FromPointee1)) 3494 return ImplicitConversionSequence::Better; 3495 else if (S.IsDerivedFrom(FromPointee1, FromPointee2)) 3496 return ImplicitConversionSequence::Worse; 3497 3498 // Objective-C++: If one interface is more specific than the 3499 // other, it is the better one. 3500 const ObjCObjectPointerType* FromObjCPtr1 3501 = FromType1->getAs<ObjCObjectPointerType>(); 3502 const ObjCObjectPointerType* FromObjCPtr2 3503 = FromType2->getAs<ObjCObjectPointerType>(); 3504 if (FromObjCPtr1 && FromObjCPtr2) { 3505 bool AssignLeft = S.Context.canAssignObjCInterfaces(FromObjCPtr1, 3506 FromObjCPtr2); 3507 bool AssignRight = S.Context.canAssignObjCInterfaces(FromObjCPtr2, 3508 FromObjCPtr1); 3509 if (AssignLeft != AssignRight) { 3510 return AssignLeft? ImplicitConversionSequence::Better 3511 : ImplicitConversionSequence::Worse; 3512 } 3513 } 3514 } 3515 3516 // Compare based on qualification conversions (C++ 13.3.3.2p3, 3517 // bullet 3). 3518 if (ImplicitConversionSequence::CompareKind QualCK 3519 = CompareQualificationConversions(S, SCS1, SCS2)) 3520 return QualCK; 3521 3522 if (SCS1.ReferenceBinding && SCS2.ReferenceBinding) { 3523 // Check for a better reference binding based on the kind of bindings. 3524 if (isBetterReferenceBindingKind(SCS1, SCS2)) 3525 return ImplicitConversionSequence::Better; 3526 else if (isBetterReferenceBindingKind(SCS2, SCS1)) 3527 return ImplicitConversionSequence::Worse; 3528 3529 // C++ [over.ics.rank]p3b4: 3530 // -- S1 and S2 are reference bindings (8.5.3), and the types to 3531 // which the references refer are the same type except for 3532 // top-level cv-qualifiers, and the type to which the reference 3533 // initialized by S2 refers is more cv-qualified than the type 3534 // to which the reference initialized by S1 refers. 3535 QualType T1 = SCS1.getToType(2); 3536 QualType T2 = SCS2.getToType(2); 3537 T1 = S.Context.getCanonicalType(T1); 3538 T2 = S.Context.getCanonicalType(T2); 3539 Qualifiers T1Quals, T2Quals; 3540 QualType UnqualT1 = S.Context.getUnqualifiedArrayType(T1, T1Quals); 3541 QualType UnqualT2 = S.Context.getUnqualifiedArrayType(T2, T2Quals); 3542 if (UnqualT1 == UnqualT2) { 3543 // Objective-C++ ARC: If the references refer to objects with different 3544 // lifetimes, prefer bindings that don't change lifetime. 3545 if (SCS1.ObjCLifetimeConversionBinding != 3546 SCS2.ObjCLifetimeConversionBinding) { 3547 return SCS1.ObjCLifetimeConversionBinding 3548 ? ImplicitConversionSequence::Worse 3549 : ImplicitConversionSequence::Better; 3550 } 3551 3552 // If the type is an array type, promote the element qualifiers to the 3553 // type for comparison. 3554 if (isa<ArrayType>(T1) && T1Quals) 3555 T1 = S.Context.getQualifiedType(UnqualT1, T1Quals); 3556 if (isa<ArrayType>(T2) && T2Quals) 3557 T2 = S.Context.getQualifiedType(UnqualT2, T2Quals); 3558 if (T2.isMoreQualifiedThan(T1)) 3559 return ImplicitConversionSequence::Better; 3560 else if (T1.isMoreQualifiedThan(T2)) 3561 return ImplicitConversionSequence::Worse; 3562 } 3563 } 3564 3565 // In Microsoft mode, prefer an integral conversion to a 3566 // floating-to-integral conversion if the integral conversion 3567 // is between types of the same size. 3568 // For example: 3569 // void f(float); 3570 // void f(int); 3571 // int main { 3572 // long a; 3573 // f(a); 3574 // } 3575 // Here, MSVC will call f(int) instead of generating a compile error 3576 // as clang will do in standard mode. 3577 if (S.getLangOpts().MicrosoftMode && 3578 SCS1.Second == ICK_Integral_Conversion && 3579 SCS2.Second == ICK_Floating_Integral && 3580 S.Context.getTypeSize(SCS1.getFromType()) == 3581 S.Context.getTypeSize(SCS1.getToType(2))) 3582 return ImplicitConversionSequence::Better; 3583 3584 return ImplicitConversionSequence::Indistinguishable; 3585 } 3586 3587 /// CompareQualificationConversions - Compares two standard conversion 3588 /// sequences to determine whether they can be ranked based on their 3589 /// qualification conversions (C++ 13.3.3.2p3 bullet 3). 3590 ImplicitConversionSequence::CompareKind 3591 CompareQualificationConversions(Sema &S, 3592 const StandardConversionSequence& SCS1, 3593 const StandardConversionSequence& SCS2) { 3594 // C++ 13.3.3.2p3: 3595 // -- S1 and S2 differ only in their qualification conversion and 3596 // yield similar types T1 and T2 (C++ 4.4), respectively, and the 3597 // cv-qualification signature of type T1 is a proper subset of 3598 // the cv-qualification signature of type T2, and S1 is not the 3599 // deprecated string literal array-to-pointer conversion (4.2). 3600 if (SCS1.First != SCS2.First || SCS1.Second != SCS2.Second || 3601 SCS1.Third != SCS2.Third || SCS1.Third != ICK_Qualification) 3602 return ImplicitConversionSequence::Indistinguishable; 3603 3604 // FIXME: the example in the standard doesn't use a qualification 3605 // conversion (!) 3606 QualType T1 = SCS1.getToType(2); 3607 QualType T2 = SCS2.getToType(2); 3608 T1 = S.Context.getCanonicalType(T1); 3609 T2 = S.Context.getCanonicalType(T2); 3610 Qualifiers T1Quals, T2Quals; 3611 QualType UnqualT1 = S.Context.getUnqualifiedArrayType(T1, T1Quals); 3612 QualType UnqualT2 = S.Context.getUnqualifiedArrayType(T2, T2Quals); 3613 3614 // If the types are the same, we won't learn anything by unwrapped 3615 // them. 3616 if (UnqualT1 == UnqualT2) 3617 return ImplicitConversionSequence::Indistinguishable; 3618 3619 // If the type is an array type, promote the element qualifiers to the type 3620 // for comparison. 3621 if (isa<ArrayType>(T1) && T1Quals) 3622 T1 = S.Context.getQualifiedType(UnqualT1, T1Quals); 3623 if (isa<ArrayType>(T2) && T2Quals) 3624 T2 = S.Context.getQualifiedType(UnqualT2, T2Quals); 3625 3626 ImplicitConversionSequence::CompareKind Result 3627 = ImplicitConversionSequence::Indistinguishable; 3628 3629 // Objective-C++ ARC: 3630 // Prefer qualification conversions not involving a change in lifetime 3631 // to qualification conversions that do not change lifetime. 3632 if (SCS1.QualificationIncludesObjCLifetime != 3633 SCS2.QualificationIncludesObjCLifetime) { 3634 Result = SCS1.QualificationIncludesObjCLifetime 3635 ? ImplicitConversionSequence::Worse 3636 : ImplicitConversionSequence::Better; 3637 } 3638 3639 while (S.Context.UnwrapSimilarPointerTypes(T1, T2)) { 3640 // Within each iteration of the loop, we check the qualifiers to 3641 // determine if this still looks like a qualification 3642 // conversion. Then, if all is well, we unwrap one more level of 3643 // pointers or pointers-to-members and do it all again 3644 // until there are no more pointers or pointers-to-members left 3645 // to unwrap. This essentially mimics what 3646 // IsQualificationConversion does, but here we're checking for a 3647 // strict subset of qualifiers. 3648 if (T1.getCVRQualifiers() == T2.getCVRQualifiers()) 3649 // The qualifiers are the same, so this doesn't tell us anything 3650 // about how the sequences rank. 3651 ; 3652 else if (T2.isMoreQualifiedThan(T1)) { 3653 // T1 has fewer qualifiers, so it could be the better sequence. 3654 if (Result == ImplicitConversionSequence::Worse) 3655 // Neither has qualifiers that are a subset of the other's 3656 // qualifiers. 3657 return ImplicitConversionSequence::Indistinguishable; 3658 3659 Result = ImplicitConversionSequence::Better; 3660 } else if (T1.isMoreQualifiedThan(T2)) { 3661 // T2 has fewer qualifiers, so it could be the better sequence. 3662 if (Result == ImplicitConversionSequence::Better) 3663 // Neither has qualifiers that are a subset of the other's 3664 // qualifiers. 3665 return ImplicitConversionSequence::Indistinguishable; 3666 3667 Result = ImplicitConversionSequence::Worse; 3668 } else { 3669 // Qualifiers are disjoint. 3670 return ImplicitConversionSequence::Indistinguishable; 3671 } 3672 3673 // If the types after this point are equivalent, we're done. 3674 if (S.Context.hasSameUnqualifiedType(T1, T2)) 3675 break; 3676 } 3677 3678 // Check that the winning standard conversion sequence isn't using 3679 // the deprecated string literal array to pointer conversion. 3680 switch (Result) { 3681 case ImplicitConversionSequence::Better: 3682 if (SCS1.DeprecatedStringLiteralToCharPtr) 3683 Result = ImplicitConversionSequence::Indistinguishable; 3684 break; 3685 3686 case ImplicitConversionSequence::Indistinguishable: 3687 break; 3688 3689 case ImplicitConversionSequence::Worse: 3690 if (SCS2.DeprecatedStringLiteralToCharPtr) 3691 Result = ImplicitConversionSequence::Indistinguishable; 3692 break; 3693 } 3694 3695 return Result; 3696 } 3697 3698 /// CompareDerivedToBaseConversions - Compares two standard conversion 3699 /// sequences to determine whether they can be ranked based on their 3700 /// various kinds of derived-to-base conversions (C++ 3701 /// [over.ics.rank]p4b3). As part of these checks, we also look at 3702 /// conversions between Objective-C interface types. 3703 ImplicitConversionSequence::CompareKind 3704 CompareDerivedToBaseConversions(Sema &S, 3705 const StandardConversionSequence& SCS1, 3706 const StandardConversionSequence& SCS2) { 3707 QualType FromType1 = SCS1.getFromType(); 3708 QualType ToType1 = SCS1.getToType(1); 3709 QualType FromType2 = SCS2.getFromType(); 3710 QualType ToType2 = SCS2.getToType(1); 3711 3712 // Adjust the types we're converting from via the array-to-pointer 3713 // conversion, if we need to. 3714 if (SCS1.First == ICK_Array_To_Pointer) 3715 FromType1 = S.Context.getArrayDecayedType(FromType1); 3716 if (SCS2.First == ICK_Array_To_Pointer) 3717 FromType2 = S.Context.getArrayDecayedType(FromType2); 3718 3719 // Canonicalize all of the types. 3720 FromType1 = S.Context.getCanonicalType(FromType1); 3721 ToType1 = S.Context.getCanonicalType(ToType1); 3722 FromType2 = S.Context.getCanonicalType(FromType2); 3723 ToType2 = S.Context.getCanonicalType(ToType2); 3724 3725 // C++ [over.ics.rank]p4b3: 3726 // 3727 // If class B is derived directly or indirectly from class A and 3728 // class C is derived directly or indirectly from B, 3729 // 3730 // Compare based on pointer conversions. 3731 if (SCS1.Second == ICK_Pointer_Conversion && 3732 SCS2.Second == ICK_Pointer_Conversion && 3733 /*FIXME: Remove if Objective-C id conversions get their own rank*/ 3734 FromType1->isPointerType() && FromType2->isPointerType() && 3735 ToType1->isPointerType() && ToType2->isPointerType()) { 3736 QualType FromPointee1 3737 = FromType1->getAs<PointerType>()->getPointeeType().getUnqualifiedType(); 3738 QualType ToPointee1 3739 = ToType1->getAs<PointerType>()->getPointeeType().getUnqualifiedType(); 3740 QualType FromPointee2 3741 = FromType2->getAs<PointerType>()->getPointeeType().getUnqualifiedType(); 3742 QualType ToPointee2 3743 = ToType2->getAs<PointerType>()->getPointeeType().getUnqualifiedType(); 3744 3745 // -- conversion of C* to B* is better than conversion of C* to A*, 3746 if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) { 3747 if (S.IsDerivedFrom(ToPointee1, ToPointee2)) 3748 return ImplicitConversionSequence::Better; 3749 else if (S.IsDerivedFrom(ToPointee2, ToPointee1)) 3750 return ImplicitConversionSequence::Worse; 3751 } 3752 3753 // -- conversion of B* to A* is better than conversion of C* to A*, 3754 if (FromPointee1 != FromPointee2 && ToPointee1 == ToPointee2) { 3755 if (S.IsDerivedFrom(FromPointee2, FromPointee1)) 3756 return ImplicitConversionSequence::Better; 3757 else if (S.IsDerivedFrom(FromPointee1, FromPointee2)) 3758 return ImplicitConversionSequence::Worse; 3759 } 3760 } else if (SCS1.Second == ICK_Pointer_Conversion && 3761 SCS2.Second == ICK_Pointer_Conversion) { 3762 const ObjCObjectPointerType *FromPtr1 3763 = FromType1->getAs<ObjCObjectPointerType>(); 3764 const ObjCObjectPointerType *FromPtr2 3765 = FromType2->getAs<ObjCObjectPointerType>(); 3766 const ObjCObjectPointerType *ToPtr1 3767 = ToType1->getAs<ObjCObjectPointerType>(); 3768 const ObjCObjectPointerType *ToPtr2 3769 = ToType2->getAs<ObjCObjectPointerType>(); 3770 3771 if (FromPtr1 && FromPtr2 && ToPtr1 && ToPtr2) { 3772 // Apply the same conversion ranking rules for Objective-C pointer types 3773 // that we do for C++ pointers to class types. However, we employ the 3774 // Objective-C pseudo-subtyping relationship used for assignment of 3775 // Objective-C pointer types. 3776 bool FromAssignLeft 3777 = S.Context.canAssignObjCInterfaces(FromPtr1, FromPtr2); 3778 bool FromAssignRight 3779 = S.Context.canAssignObjCInterfaces(FromPtr2, FromPtr1); 3780 bool ToAssignLeft 3781 = S.Context.canAssignObjCInterfaces(ToPtr1, ToPtr2); 3782 bool ToAssignRight 3783 = S.Context.canAssignObjCInterfaces(ToPtr2, ToPtr1); 3784 3785 // A conversion to an a non-id object pointer type or qualified 'id' 3786 // type is better than a conversion to 'id'. 3787 if (ToPtr1->isObjCIdType() && 3788 (ToPtr2->isObjCQualifiedIdType() || ToPtr2->getInterfaceDecl())) 3789 return ImplicitConversionSequence::Worse; 3790 if (ToPtr2->isObjCIdType() && 3791 (ToPtr1->isObjCQualifiedIdType() || ToPtr1->getInterfaceDecl())) 3792 return ImplicitConversionSequence::Better; 3793 3794 // A conversion to a non-id object pointer type is better than a 3795 // conversion to a qualified 'id' type 3796 if (ToPtr1->isObjCQualifiedIdType() && ToPtr2->getInterfaceDecl()) 3797 return ImplicitConversionSequence::Worse; 3798 if (ToPtr2->isObjCQualifiedIdType() && ToPtr1->getInterfaceDecl()) 3799 return ImplicitConversionSequence::Better; 3800 3801 // A conversion to an a non-Class object pointer type or qualified 'Class' 3802 // type is better than a conversion to 'Class'. 3803 if (ToPtr1->isObjCClassType() && 3804 (ToPtr2->isObjCQualifiedClassType() || ToPtr2->getInterfaceDecl())) 3805 return ImplicitConversionSequence::Worse; 3806 if (ToPtr2->isObjCClassType() && 3807 (ToPtr1->isObjCQualifiedClassType() || ToPtr1->getInterfaceDecl())) 3808 return ImplicitConversionSequence::Better; 3809 3810 // A conversion to a non-Class object pointer type is better than a 3811 // conversion to a qualified 'Class' type. 3812 if (ToPtr1->isObjCQualifiedClassType() && ToPtr2->getInterfaceDecl()) 3813 return ImplicitConversionSequence::Worse; 3814 if (ToPtr2->isObjCQualifiedClassType() && ToPtr1->getInterfaceDecl()) 3815 return ImplicitConversionSequence::Better; 3816 3817 // -- "conversion of C* to B* is better than conversion of C* to A*," 3818 if (S.Context.hasSameType(FromType1, FromType2) && 3819 !FromPtr1->isObjCIdType() && !FromPtr1->isObjCClassType() && 3820 (ToAssignLeft != ToAssignRight)) 3821 return ToAssignLeft? ImplicitConversionSequence::Worse 3822 : ImplicitConversionSequence::Better; 3823 3824 // -- "conversion of B* to A* is better than conversion of C* to A*," 3825 if (S.Context.hasSameUnqualifiedType(ToType1, ToType2) && 3826 (FromAssignLeft != FromAssignRight)) 3827 return FromAssignLeft? ImplicitConversionSequence::Better 3828 : ImplicitConversionSequence::Worse; 3829 } 3830 } 3831 3832 // Ranking of member-pointer types. 3833 if (SCS1.Second == ICK_Pointer_Member && SCS2.Second == ICK_Pointer_Member && 3834 FromType1->isMemberPointerType() && FromType2->isMemberPointerType() && 3835 ToType1->isMemberPointerType() && ToType2->isMemberPointerType()) { 3836 const MemberPointerType * FromMemPointer1 = 3837 FromType1->getAs<MemberPointerType>(); 3838 const MemberPointerType * ToMemPointer1 = 3839 ToType1->getAs<MemberPointerType>(); 3840 const MemberPointerType * FromMemPointer2 = 3841 FromType2->getAs<MemberPointerType>(); 3842 const MemberPointerType * ToMemPointer2 = 3843 ToType2->getAs<MemberPointerType>(); 3844 const Type *FromPointeeType1 = FromMemPointer1->getClass(); 3845 const Type *ToPointeeType1 = ToMemPointer1->getClass(); 3846 const Type *FromPointeeType2 = FromMemPointer2->getClass(); 3847 const Type *ToPointeeType2 = ToMemPointer2->getClass(); 3848 QualType FromPointee1 = QualType(FromPointeeType1, 0).getUnqualifiedType(); 3849 QualType ToPointee1 = QualType(ToPointeeType1, 0).getUnqualifiedType(); 3850 QualType FromPointee2 = QualType(FromPointeeType2, 0).getUnqualifiedType(); 3851 QualType ToPointee2 = QualType(ToPointeeType2, 0).getUnqualifiedType(); 3852 // conversion of A::* to B::* is better than conversion of A::* to C::*, 3853 if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) { 3854 if (S.IsDerivedFrom(ToPointee1, ToPointee2)) 3855 return ImplicitConversionSequence::Worse; 3856 else if (S.IsDerivedFrom(ToPointee2, ToPointee1)) 3857 return ImplicitConversionSequence::Better; 3858 } 3859 // conversion of B::* to C::* is better than conversion of A::* to C::* 3860 if (ToPointee1 == ToPointee2 && FromPointee1 != FromPointee2) { 3861 if (S.IsDerivedFrom(FromPointee1, FromPointee2)) 3862 return ImplicitConversionSequence::Better; 3863 else if (S.IsDerivedFrom(FromPointee2, FromPointee1)) 3864 return ImplicitConversionSequence::Worse; 3865 } 3866 } 3867 3868 if (SCS1.Second == ICK_Derived_To_Base) { 3869 // -- conversion of C to B is better than conversion of C to A, 3870 // -- binding of an expression of type C to a reference of type 3871 // B& is better than binding an expression of type C to a 3872 // reference of type A&, 3873 if (S.Context.hasSameUnqualifiedType(FromType1, FromType2) && 3874 !S.Context.hasSameUnqualifiedType(ToType1, ToType2)) { 3875 if (S.IsDerivedFrom(ToType1, ToType2)) 3876 return ImplicitConversionSequence::Better; 3877 else if (S.IsDerivedFrom(ToType2, ToType1)) 3878 return ImplicitConversionSequence::Worse; 3879 } 3880 3881 // -- conversion of B to A is better than conversion of C to A. 3882 // -- binding of an expression of type B to a reference of type 3883 // A& is better than binding an expression of type C to a 3884 // reference of type A&, 3885 if (!S.Context.hasSameUnqualifiedType(FromType1, FromType2) && 3886 S.Context.hasSameUnqualifiedType(ToType1, ToType2)) { 3887 if (S.IsDerivedFrom(FromType2, FromType1)) 3888 return ImplicitConversionSequence::Better; 3889 else if (S.IsDerivedFrom(FromType1, FromType2)) 3890 return ImplicitConversionSequence::Worse; 3891 } 3892 } 3893 3894 return ImplicitConversionSequence::Indistinguishable; 3895 } 3896 3897 /// \brief Determine whether the given type is valid, e.g., it is not an invalid 3898 /// C++ class. 3899 static bool isTypeValid(QualType T) { 3900 if (CXXRecordDecl *Record = T->getAsCXXRecordDecl()) 3901 return !Record->isInvalidDecl(); 3902 3903 return true; 3904 } 3905 3906 /// CompareReferenceRelationship - Compare the two types T1 and T2 to 3907 /// determine whether they are reference-related, 3908 /// reference-compatible, reference-compatible with added 3909 /// qualification, or incompatible, for use in C++ initialization by 3910 /// reference (C++ [dcl.ref.init]p4). Neither type can be a reference 3911 /// type, and the first type (T1) is the pointee type of the reference 3912 /// type being initialized. 3913 Sema::ReferenceCompareResult 3914 Sema::CompareReferenceRelationship(SourceLocation Loc, 3915 QualType OrigT1, QualType OrigT2, 3916 bool &DerivedToBase, 3917 bool &ObjCConversion, 3918 bool &ObjCLifetimeConversion) { 3919 assert(!OrigT1->isReferenceType() && 3920 "T1 must be the pointee type of the reference type"); 3921 assert(!OrigT2->isReferenceType() && "T2 cannot be a reference type"); 3922 3923 QualType T1 = Context.getCanonicalType(OrigT1); 3924 QualType T2 = Context.getCanonicalType(OrigT2); 3925 Qualifiers T1Quals, T2Quals; 3926 QualType UnqualT1 = Context.getUnqualifiedArrayType(T1, T1Quals); 3927 QualType UnqualT2 = Context.getUnqualifiedArrayType(T2, T2Quals); 3928 3929 // C++ [dcl.init.ref]p4: 3930 // Given types "cv1 T1" and "cv2 T2," "cv1 T1" is 3931 // reference-related to "cv2 T2" if T1 is the same type as T2, or 3932 // T1 is a base class of T2. 3933 DerivedToBase = false; 3934 ObjCConversion = false; 3935 ObjCLifetimeConversion = false; 3936 if (UnqualT1 == UnqualT2) { 3937 // Nothing to do. 3938 } else if (!RequireCompleteType(Loc, OrigT2, 0) && 3939 isTypeValid(UnqualT1) && isTypeValid(UnqualT2) && 3940 IsDerivedFrom(UnqualT2, UnqualT1)) 3941 DerivedToBase = true; 3942 else if (UnqualT1->isObjCObjectOrInterfaceType() && 3943 UnqualT2->isObjCObjectOrInterfaceType() && 3944 Context.canBindObjCObjectType(UnqualT1, UnqualT2)) 3945 ObjCConversion = true; 3946 else 3947 return Ref_Incompatible; 3948 3949 // At this point, we know that T1 and T2 are reference-related (at 3950 // least). 3951 3952 // If the type is an array type, promote the element qualifiers to the type 3953 // for comparison. 3954 if (isa<ArrayType>(T1) && T1Quals) 3955 T1 = Context.getQualifiedType(UnqualT1, T1Quals); 3956 if (isa<ArrayType>(T2) && T2Quals) 3957 T2 = Context.getQualifiedType(UnqualT2, T2Quals); 3958 3959 // C++ [dcl.init.ref]p4: 3960 // "cv1 T1" is reference-compatible with "cv2 T2" if T1 is 3961 // reference-related to T2 and cv1 is the same cv-qualification 3962 // as, or greater cv-qualification than, cv2. For purposes of 3963 // overload resolution, cases for which cv1 is greater 3964 // cv-qualification than cv2 are identified as 3965 // reference-compatible with added qualification (see 13.3.3.2). 3966 // 3967 // Note that we also require equivalence of Objective-C GC and address-space 3968 // qualifiers when performing these computations, so that e.g., an int in 3969 // address space 1 is not reference-compatible with an int in address 3970 // space 2. 3971 if (T1Quals.getObjCLifetime() != T2Quals.getObjCLifetime() && 3972 T1Quals.compatiblyIncludesObjCLifetime(T2Quals)) { 3973 T1Quals.removeObjCLifetime(); 3974 T2Quals.removeObjCLifetime(); 3975 ObjCLifetimeConversion = true; 3976 } 3977 3978 if (T1Quals == T2Quals) 3979 return Ref_Compatible; 3980 else if (T1Quals.compatiblyIncludes(T2Quals)) 3981 return Ref_Compatible_With_Added_Qualification; 3982 else 3983 return Ref_Related; 3984 } 3985 3986 /// \brief Look for a user-defined conversion to an value reference-compatible 3987 /// with DeclType. Return true if something definite is found. 3988 static bool 3989 FindConversionForRefInit(Sema &S, ImplicitConversionSequence &ICS, 3990 QualType DeclType, SourceLocation DeclLoc, 3991 Expr *Init, QualType T2, bool AllowRvalues, 3992 bool AllowExplicit) { 3993 assert(T2->isRecordType() && "Can only find conversions of record types."); 3994 CXXRecordDecl *T2RecordDecl 3995 = dyn_cast<CXXRecordDecl>(T2->getAs<RecordType>()->getDecl()); 3996 3997 OverloadCandidateSet CandidateSet(DeclLoc); 3998 std::pair<CXXRecordDecl::conversion_iterator, 3999 CXXRecordDecl::conversion_iterator> 4000 Conversions = T2RecordDecl->getVisibleConversionFunctions(); 4001 for (CXXRecordDecl::conversion_iterator 4002 I = Conversions.first, E = Conversions.second; I != E; ++I) { 4003 NamedDecl *D = *I; 4004 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext()); 4005 if (isa<UsingShadowDecl>(D)) 4006 D = cast<UsingShadowDecl>(D)->getTargetDecl(); 4007 4008 FunctionTemplateDecl *ConvTemplate 4009 = dyn_cast<FunctionTemplateDecl>(D); 4010 CXXConversionDecl *Conv; 4011 if (ConvTemplate) 4012 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl()); 4013 else 4014 Conv = cast<CXXConversionDecl>(D); 4015 4016 // If this is an explicit conversion, and we're not allowed to consider 4017 // explicit conversions, skip it. 4018 if (!AllowExplicit && Conv->isExplicit()) 4019 continue; 4020 4021 if (AllowRvalues) { 4022 bool DerivedToBase = false; 4023 bool ObjCConversion = false; 4024 bool ObjCLifetimeConversion = false; 4025 4026 // If we are initializing an rvalue reference, don't permit conversion 4027 // functions that return lvalues. 4028 if (!ConvTemplate && DeclType->isRValueReferenceType()) { 4029 const ReferenceType *RefType 4030 = Conv->getConversionType()->getAs<LValueReferenceType>(); 4031 if (RefType && !RefType->getPointeeType()->isFunctionType()) 4032 continue; 4033 } 4034 4035 if (!ConvTemplate && 4036 S.CompareReferenceRelationship( 4037 DeclLoc, 4038 Conv->getConversionType().getNonReferenceType() 4039 .getUnqualifiedType(), 4040 DeclType.getNonReferenceType().getUnqualifiedType(), 4041 DerivedToBase, ObjCConversion, ObjCLifetimeConversion) == 4042 Sema::Ref_Incompatible) 4043 continue; 4044 } else { 4045 // If the conversion function doesn't return a reference type, 4046 // it can't be considered for this conversion. An rvalue reference 4047 // is only acceptable if its referencee is a function type. 4048 4049 const ReferenceType *RefType = 4050 Conv->getConversionType()->getAs<ReferenceType>(); 4051 if (!RefType || 4052 (!RefType->isLValueReferenceType() && 4053 !RefType->getPointeeType()->isFunctionType())) 4054 continue; 4055 } 4056 4057 if (ConvTemplate) 4058 S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(), ActingDC, 4059 Init, DeclType, CandidateSet); 4060 else 4061 S.AddConversionCandidate(Conv, I.getPair(), ActingDC, Init, 4062 DeclType, CandidateSet); 4063 } 4064 4065 bool HadMultipleCandidates = (CandidateSet.size() > 1); 4066 4067 OverloadCandidateSet::iterator Best; 4068 switch (CandidateSet.BestViableFunction(S, DeclLoc, Best, true)) { 4069 case OR_Success: 4070 // C++ [over.ics.ref]p1: 4071 // 4072 // [...] If the parameter binds directly to the result of 4073 // applying a conversion function to the argument 4074 // expression, the implicit conversion sequence is a 4075 // user-defined conversion sequence (13.3.3.1.2), with the 4076 // second standard conversion sequence either an identity 4077 // conversion or, if the conversion function returns an 4078 // entity of a type that is a derived class of the parameter 4079 // type, a derived-to-base Conversion. 4080 if (!Best->FinalConversion.DirectBinding) 4081 return false; 4082 4083 ICS.setUserDefined(); 4084 ICS.UserDefined.Before = Best->Conversions[0].Standard; 4085 ICS.UserDefined.After = Best->FinalConversion; 4086 ICS.UserDefined.HadMultipleCandidates = HadMultipleCandidates; 4087 ICS.UserDefined.ConversionFunction = Best->Function; 4088 ICS.UserDefined.FoundConversionFunction = Best->FoundDecl; 4089 ICS.UserDefined.EllipsisConversion = false; 4090 assert(ICS.UserDefined.After.ReferenceBinding && 4091 ICS.UserDefined.After.DirectBinding && 4092 "Expected a direct reference binding!"); 4093 return true; 4094 4095 case OR_Ambiguous: 4096 ICS.setAmbiguous(); 4097 for (OverloadCandidateSet::iterator Cand = CandidateSet.begin(); 4098 Cand != CandidateSet.end(); ++Cand) 4099 if (Cand->Viable) 4100 ICS.Ambiguous.addConversion(Cand->Function); 4101 return true; 4102 4103 case OR_No_Viable_Function: 4104 case OR_Deleted: 4105 // There was no suitable conversion, or we found a deleted 4106 // conversion; continue with other checks. 4107 return false; 4108 } 4109 4110 llvm_unreachable("Invalid OverloadResult!"); 4111 } 4112 4113 /// \brief Compute an implicit conversion sequence for reference 4114 /// initialization. 4115 static ImplicitConversionSequence 4116 TryReferenceInit(Sema &S, Expr *Init, QualType DeclType, 4117 SourceLocation DeclLoc, 4118 bool SuppressUserConversions, 4119 bool AllowExplicit) { 4120 assert(DeclType->isReferenceType() && "Reference init needs a reference"); 4121 4122 // Most paths end in a failed conversion. 4123 ImplicitConversionSequence ICS; 4124 ICS.setBad(BadConversionSequence::no_conversion, Init, DeclType); 4125 4126 QualType T1 = DeclType->getAs<ReferenceType>()->getPointeeType(); 4127 QualType T2 = Init->getType(); 4128 4129 // If the initializer is the address of an overloaded function, try 4130 // to resolve the overloaded function. If all goes well, T2 is the 4131 // type of the resulting function. 4132 if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) { 4133 DeclAccessPair Found; 4134 if (FunctionDecl *Fn = S.ResolveAddressOfOverloadedFunction(Init, DeclType, 4135 false, Found)) 4136 T2 = Fn->getType(); 4137 } 4138 4139 // Compute some basic properties of the types and the initializer. 4140 bool isRValRef = DeclType->isRValueReferenceType(); 4141 bool DerivedToBase = false; 4142 bool ObjCConversion = false; 4143 bool ObjCLifetimeConversion = false; 4144 Expr::Classification InitCategory = Init->Classify(S.Context); 4145 Sema::ReferenceCompareResult RefRelationship 4146 = S.CompareReferenceRelationship(DeclLoc, T1, T2, DerivedToBase, 4147 ObjCConversion, ObjCLifetimeConversion); 4148 4149 4150 // C++0x [dcl.init.ref]p5: 4151 // A reference to type "cv1 T1" is initialized by an expression 4152 // of type "cv2 T2" as follows: 4153 4154 // -- If reference is an lvalue reference and the initializer expression 4155 if (!isRValRef) { 4156 // -- is an lvalue (but is not a bit-field), and "cv1 T1" is 4157 // reference-compatible with "cv2 T2," or 4158 // 4159 // Per C++ [over.ics.ref]p4, we don't check the bit-field property here. 4160 if (InitCategory.isLValue() && 4161 RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification) { 4162 // C++ [over.ics.ref]p1: 4163 // When a parameter of reference type binds directly (8.5.3) 4164 // to an argument expression, the implicit conversion sequence 4165 // is the identity conversion, unless the argument expression 4166 // has a type that is a derived class of the parameter type, 4167 // in which case the implicit conversion sequence is a 4168 // derived-to-base Conversion (13.3.3.1). 4169 ICS.setStandard(); 4170 ICS.Standard.First = ICK_Identity; 4171 ICS.Standard.Second = DerivedToBase? ICK_Derived_To_Base 4172 : ObjCConversion? ICK_Compatible_Conversion 4173 : ICK_Identity; 4174 ICS.Standard.Third = ICK_Identity; 4175 ICS.Standard.FromTypePtr = T2.getAsOpaquePtr(); 4176 ICS.Standard.setToType(0, T2); 4177 ICS.Standard.setToType(1, T1); 4178 ICS.Standard.setToType(2, T1); 4179 ICS.Standard.ReferenceBinding = true; 4180 ICS.Standard.DirectBinding = true; 4181 ICS.Standard.IsLvalueReference = !isRValRef; 4182 ICS.Standard.BindsToFunctionLvalue = T2->isFunctionType(); 4183 ICS.Standard.BindsToRvalue = false; 4184 ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false; 4185 ICS.Standard.ObjCLifetimeConversionBinding = ObjCLifetimeConversion; 4186 ICS.Standard.CopyConstructor = 0; 4187 4188 // Nothing more to do: the inaccessibility/ambiguity check for 4189 // derived-to-base conversions is suppressed when we're 4190 // computing the implicit conversion sequence (C++ 4191 // [over.best.ics]p2). 4192 return ICS; 4193 } 4194 4195 // -- has a class type (i.e., T2 is a class type), where T1 is 4196 // not reference-related to T2, and can be implicitly 4197 // converted to an lvalue of type "cv3 T3," where "cv1 T1" 4198 // is reference-compatible with "cv3 T3" 92) (this 4199 // conversion is selected by enumerating the applicable 4200 // conversion functions (13.3.1.6) and choosing the best 4201 // one through overload resolution (13.3)), 4202 if (!SuppressUserConversions && T2->isRecordType() && 4203 !S.RequireCompleteType(DeclLoc, T2, 0) && 4204 RefRelationship == Sema::Ref_Incompatible) { 4205 if (FindConversionForRefInit(S, ICS, DeclType, DeclLoc, 4206 Init, T2, /*AllowRvalues=*/false, 4207 AllowExplicit)) 4208 return ICS; 4209 } 4210 } 4211 4212 // -- Otherwise, the reference shall be an lvalue reference to a 4213 // non-volatile const type (i.e., cv1 shall be const), or the reference 4214 // shall be an rvalue reference. 4215 // 4216 // We actually handle one oddity of C++ [over.ics.ref] at this 4217 // point, which is that, due to p2 (which short-circuits reference 4218 // binding by only attempting a simple conversion for non-direct 4219 // bindings) and p3's strange wording, we allow a const volatile 4220 // reference to bind to an rvalue. Hence the check for the presence 4221 // of "const" rather than checking for "const" being the only 4222 // qualifier. 4223 // This is also the point where rvalue references and lvalue inits no longer 4224 // go together. 4225 if (!isRValRef && (!T1.isConstQualified() || T1.isVolatileQualified())) 4226 return ICS; 4227 4228 // -- If the initializer expression 4229 // 4230 // -- is an xvalue, class prvalue, array prvalue or function 4231 // lvalue and "cv1 T1" is reference-compatible with "cv2 T2", or 4232 if (RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification && 4233 (InitCategory.isXValue() || 4234 (InitCategory.isPRValue() && (T2->isRecordType() || T2->isArrayType())) || 4235 (InitCategory.isLValue() && T2->isFunctionType()))) { 4236 ICS.setStandard(); 4237 ICS.Standard.First = ICK_Identity; 4238 ICS.Standard.Second = DerivedToBase? ICK_Derived_To_Base 4239 : ObjCConversion? ICK_Compatible_Conversion 4240 : ICK_Identity; 4241 ICS.Standard.Third = ICK_Identity; 4242 ICS.Standard.FromTypePtr = T2.getAsOpaquePtr(); 4243 ICS.Standard.setToType(0, T2); 4244 ICS.Standard.setToType(1, T1); 4245 ICS.Standard.setToType(2, T1); 4246 ICS.Standard.ReferenceBinding = true; 4247 // In C++0x, this is always a direct binding. In C++98/03, it's a direct 4248 // binding unless we're binding to a class prvalue. 4249 // Note: Although xvalues wouldn't normally show up in C++98/03 code, we 4250 // allow the use of rvalue references in C++98/03 for the benefit of 4251 // standard library implementors; therefore, we need the xvalue check here. 4252 ICS.Standard.DirectBinding = 4253 S.getLangOpts().CPlusPlus11 || 4254 (InitCategory.isPRValue() && !T2->isRecordType()); 4255 ICS.Standard.IsLvalueReference = !isRValRef; 4256 ICS.Standard.BindsToFunctionLvalue = T2->isFunctionType(); 4257 ICS.Standard.BindsToRvalue = InitCategory.isRValue(); 4258 ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false; 4259 ICS.Standard.ObjCLifetimeConversionBinding = ObjCLifetimeConversion; 4260 ICS.Standard.CopyConstructor = 0; 4261 return ICS; 4262 } 4263 4264 // -- has a class type (i.e., T2 is a class type), where T1 is not 4265 // reference-related to T2, and can be implicitly converted to 4266 // an xvalue, class prvalue, or function lvalue of type 4267 // "cv3 T3", where "cv1 T1" is reference-compatible with 4268 // "cv3 T3", 4269 // 4270 // then the reference is bound to the value of the initializer 4271 // expression in the first case and to the result of the conversion 4272 // in the second case (or, in either case, to an appropriate base 4273 // class subobject). 4274 if (!SuppressUserConversions && RefRelationship == Sema::Ref_Incompatible && 4275 T2->isRecordType() && !S.RequireCompleteType(DeclLoc, T2, 0) && 4276 FindConversionForRefInit(S, ICS, DeclType, DeclLoc, 4277 Init, T2, /*AllowRvalues=*/true, 4278 AllowExplicit)) { 4279 // In the second case, if the reference is an rvalue reference 4280 // and the second standard conversion sequence of the 4281 // user-defined conversion sequence includes an lvalue-to-rvalue 4282 // conversion, the program is ill-formed. 4283 if (ICS.isUserDefined() && isRValRef && 4284 ICS.UserDefined.After.First == ICK_Lvalue_To_Rvalue) 4285 ICS.setBad(BadConversionSequence::no_conversion, Init, DeclType); 4286 4287 return ICS; 4288 } 4289 4290 // -- Otherwise, a temporary of type "cv1 T1" is created and 4291 // initialized from the initializer expression using the 4292 // rules for a non-reference copy initialization (8.5). The 4293 // reference is then bound to the temporary. If T1 is 4294 // reference-related to T2, cv1 must be the same 4295 // cv-qualification as, or greater cv-qualification than, 4296 // cv2; otherwise, the program is ill-formed. 4297 if (RefRelationship == Sema::Ref_Related) { 4298 // If cv1 == cv2 or cv1 is a greater cv-qualified than cv2, then 4299 // we would be reference-compatible or reference-compatible with 4300 // added qualification. But that wasn't the case, so the reference 4301 // initialization fails. 4302 // 4303 // Note that we only want to check address spaces and cvr-qualifiers here. 4304 // ObjC GC and lifetime qualifiers aren't important. 4305 Qualifiers T1Quals = T1.getQualifiers(); 4306 Qualifiers T2Quals = T2.getQualifiers(); 4307 T1Quals.removeObjCGCAttr(); 4308 T1Quals.removeObjCLifetime(); 4309 T2Quals.removeObjCGCAttr(); 4310 T2Quals.removeObjCLifetime(); 4311 if (!T1Quals.compatiblyIncludes(T2Quals)) 4312 return ICS; 4313 } 4314 4315 // If at least one of the types is a class type, the types are not 4316 // related, and we aren't allowed any user conversions, the 4317 // reference binding fails. This case is important for breaking 4318 // recursion, since TryImplicitConversion below will attempt to 4319 // create a temporary through the use of a copy constructor. 4320 if (SuppressUserConversions && RefRelationship == Sema::Ref_Incompatible && 4321 (T1->isRecordType() || T2->isRecordType())) 4322 return ICS; 4323 4324 // If T1 is reference-related to T2 and the reference is an rvalue 4325 // reference, the initializer expression shall not be an lvalue. 4326 if (RefRelationship >= Sema::Ref_Related && 4327 isRValRef && Init->Classify(S.Context).isLValue()) 4328 return ICS; 4329 4330 // C++ [over.ics.ref]p2: 4331 // When a parameter of reference type is not bound directly to 4332 // an argument expression, the conversion sequence is the one 4333 // required to convert the argument expression to the 4334 // underlying type of the reference according to 4335 // 13.3.3.1. Conceptually, this conversion sequence corresponds 4336 // to copy-initializing a temporary of the underlying type with 4337 // the argument expression. Any difference in top-level 4338 // cv-qualification is subsumed by the initialization itself 4339 // and does not constitute a conversion. 4340 ICS = TryImplicitConversion(S, Init, T1, SuppressUserConversions, 4341 /*AllowExplicit=*/false, 4342 /*InOverloadResolution=*/false, 4343 /*CStyle=*/false, 4344 /*AllowObjCWritebackConversion=*/false); 4345 4346 // Of course, that's still a reference binding. 4347 if (ICS.isStandard()) { 4348 ICS.Standard.ReferenceBinding = true; 4349 ICS.Standard.IsLvalueReference = !isRValRef; 4350 ICS.Standard.BindsToFunctionLvalue = T2->isFunctionType(); 4351 ICS.Standard.BindsToRvalue = true; 4352 ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false; 4353 ICS.Standard.ObjCLifetimeConversionBinding = false; 4354 } else if (ICS.isUserDefined()) { 4355 // Don't allow rvalue references to bind to lvalues. 4356 if (DeclType->isRValueReferenceType()) { 4357 if (const ReferenceType *RefType 4358 = ICS.UserDefined.ConversionFunction->getResultType() 4359 ->getAs<LValueReferenceType>()) { 4360 if (!RefType->getPointeeType()->isFunctionType()) { 4361 ICS.setBad(BadConversionSequence::lvalue_ref_to_rvalue, Init, 4362 DeclType); 4363 return ICS; 4364 } 4365 } 4366 } 4367 4368 ICS.UserDefined.After.ReferenceBinding = true; 4369 ICS.UserDefined.After.IsLvalueReference = !isRValRef; 4370 ICS.UserDefined.After.BindsToFunctionLvalue = T2->isFunctionType(); 4371 ICS.UserDefined.After.BindsToRvalue = true; 4372 ICS.UserDefined.After.BindsImplicitObjectArgumentWithoutRefQualifier = false; 4373 ICS.UserDefined.After.ObjCLifetimeConversionBinding = false; 4374 } 4375 4376 return ICS; 4377 } 4378 4379 static ImplicitConversionSequence 4380 TryCopyInitialization(Sema &S, Expr *From, QualType ToType, 4381 bool SuppressUserConversions, 4382 bool InOverloadResolution, 4383 bool AllowObjCWritebackConversion, 4384 bool AllowExplicit = false); 4385 4386 /// TryListConversion - Try to copy-initialize a value of type ToType from the 4387 /// initializer list From. 4388 static ImplicitConversionSequence 4389 TryListConversion(Sema &S, InitListExpr *From, QualType ToType, 4390 bool SuppressUserConversions, 4391 bool InOverloadResolution, 4392 bool AllowObjCWritebackConversion) { 4393 // C++11 [over.ics.list]p1: 4394 // When an argument is an initializer list, it is not an expression and 4395 // special rules apply for converting it to a parameter type. 4396 4397 ImplicitConversionSequence Result; 4398 Result.setBad(BadConversionSequence::no_conversion, From, ToType); 4399 Result.setListInitializationSequence(); 4400 4401 // We need a complete type for what follows. Incomplete types can never be 4402 // initialized from init lists. 4403 if (S.RequireCompleteType(From->getLocStart(), ToType, 0)) 4404 return Result; 4405 4406 // C++11 [over.ics.list]p2: 4407 // If the parameter type is std::initializer_list<X> or "array of X" and 4408 // all the elements can be implicitly converted to X, the implicit 4409 // conversion sequence is the worst conversion necessary to convert an 4410 // element of the list to X. 4411 bool toStdInitializerList = false; 4412 QualType X; 4413 if (ToType->isArrayType()) 4414 X = S.Context.getAsArrayType(ToType)->getElementType(); 4415 else 4416 toStdInitializerList = S.isStdInitializerList(ToType, &X); 4417 if (!X.isNull()) { 4418 for (unsigned i = 0, e = From->getNumInits(); i < e; ++i) { 4419 Expr *Init = From->getInit(i); 4420 ImplicitConversionSequence ICS = 4421 TryCopyInitialization(S, Init, X, SuppressUserConversions, 4422 InOverloadResolution, 4423 AllowObjCWritebackConversion); 4424 // If a single element isn't convertible, fail. 4425 if (ICS.isBad()) { 4426 Result = ICS; 4427 break; 4428 } 4429 // Otherwise, look for the worst conversion. 4430 if (Result.isBad() || 4431 CompareImplicitConversionSequences(S, ICS, Result) == 4432 ImplicitConversionSequence::Worse) 4433 Result = ICS; 4434 } 4435 4436 // For an empty list, we won't have computed any conversion sequence. 4437 // Introduce the identity conversion sequence. 4438 if (From->getNumInits() == 0) { 4439 Result.setStandard(); 4440 Result.Standard.setAsIdentityConversion(); 4441 Result.Standard.setFromType(ToType); 4442 Result.Standard.setAllToTypes(ToType); 4443 } 4444 4445 Result.setListInitializationSequence(); 4446 Result.setStdInitializerListElement(toStdInitializerList); 4447 return Result; 4448 } 4449 4450 // C++11 [over.ics.list]p3: 4451 // Otherwise, if the parameter is a non-aggregate class X and overload 4452 // resolution chooses a single best constructor [...] the implicit 4453 // conversion sequence is a user-defined conversion sequence. If multiple 4454 // constructors are viable but none is better than the others, the 4455 // implicit conversion sequence is a user-defined conversion sequence. 4456 if (ToType->isRecordType() && !ToType->isAggregateType()) { 4457 // This function can deal with initializer lists. 4458 Result = TryUserDefinedConversion(S, From, ToType, SuppressUserConversions, 4459 /*AllowExplicit=*/false, 4460 InOverloadResolution, /*CStyle=*/false, 4461 AllowObjCWritebackConversion); 4462 Result.setListInitializationSequence(); 4463 return Result; 4464 } 4465 4466 // C++11 [over.ics.list]p4: 4467 // Otherwise, if the parameter has an aggregate type which can be 4468 // initialized from the initializer list [...] the implicit conversion 4469 // sequence is a user-defined conversion sequence. 4470 if (ToType->isAggregateType()) { 4471 // Type is an aggregate, argument is an init list. At this point it comes 4472 // down to checking whether the initialization works. 4473 // FIXME: Find out whether this parameter is consumed or not. 4474 InitializedEntity Entity = 4475 InitializedEntity::InitializeParameter(S.Context, ToType, 4476 /*Consumed=*/false); 4477 if (S.CanPerformCopyInitialization(Entity, S.Owned(From))) { 4478 Result.setUserDefined(); 4479 Result.UserDefined.Before.setAsIdentityConversion(); 4480 // Initializer lists don't have a type. 4481 Result.UserDefined.Before.setFromType(QualType()); 4482 Result.UserDefined.Before.setAllToTypes(QualType()); 4483 4484 Result.UserDefined.After.setAsIdentityConversion(); 4485 Result.UserDefined.After.setFromType(ToType); 4486 Result.UserDefined.After.setAllToTypes(ToType); 4487 Result.UserDefined.ConversionFunction = 0; 4488 } 4489 return Result; 4490 } 4491 4492 // C++11 [over.ics.list]p5: 4493 // Otherwise, if the parameter is a reference, see 13.3.3.1.4. 4494 if (ToType->isReferenceType()) { 4495 // The standard is notoriously unclear here, since 13.3.3.1.4 doesn't 4496 // mention initializer lists in any way. So we go by what list- 4497 // initialization would do and try to extrapolate from that. 4498 4499 QualType T1 = ToType->getAs<ReferenceType>()->getPointeeType(); 4500 4501 // If the initializer list has a single element that is reference-related 4502 // to the parameter type, we initialize the reference from that. 4503 if (From->getNumInits() == 1) { 4504 Expr *Init = From->getInit(0); 4505 4506 QualType T2 = Init->getType(); 4507 4508 // If the initializer is the address of an overloaded function, try 4509 // to resolve the overloaded function. If all goes well, T2 is the 4510 // type of the resulting function. 4511 if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) { 4512 DeclAccessPair Found; 4513 if (FunctionDecl *Fn = S.ResolveAddressOfOverloadedFunction( 4514 Init, ToType, false, Found)) 4515 T2 = Fn->getType(); 4516 } 4517 4518 // Compute some basic properties of the types and the initializer. 4519 bool dummy1 = false; 4520 bool dummy2 = false; 4521 bool dummy3 = false; 4522 Sema::ReferenceCompareResult RefRelationship 4523 = S.CompareReferenceRelationship(From->getLocStart(), T1, T2, dummy1, 4524 dummy2, dummy3); 4525 4526 if (RefRelationship >= Sema::Ref_Related) 4527 return TryReferenceInit(S, Init, ToType, 4528 /*FIXME:*/From->getLocStart(), 4529 SuppressUserConversions, 4530 /*AllowExplicit=*/false); 4531 } 4532 4533 // Otherwise, we bind the reference to a temporary created from the 4534 // initializer list. 4535 Result = TryListConversion(S, From, T1, SuppressUserConversions, 4536 InOverloadResolution, 4537 AllowObjCWritebackConversion); 4538 if (Result.isFailure()) 4539 return Result; 4540 assert(!Result.isEllipsis() && 4541 "Sub-initialization cannot result in ellipsis conversion."); 4542 4543 // Can we even bind to a temporary? 4544 if (ToType->isRValueReferenceType() || 4545 (T1.isConstQualified() && !T1.isVolatileQualified())) { 4546 StandardConversionSequence &SCS = Result.isStandard() ? Result.Standard : 4547 Result.UserDefined.After; 4548 SCS.ReferenceBinding = true; 4549 SCS.IsLvalueReference = ToType->isLValueReferenceType(); 4550 SCS.BindsToRvalue = true; 4551 SCS.BindsToFunctionLvalue = false; 4552 SCS.BindsImplicitObjectArgumentWithoutRefQualifier = false; 4553 SCS.ObjCLifetimeConversionBinding = false; 4554 } else 4555 Result.setBad(BadConversionSequence::lvalue_ref_to_rvalue, 4556 From, ToType); 4557 return Result; 4558 } 4559 4560 // C++11 [over.ics.list]p6: 4561 // Otherwise, if the parameter type is not a class: 4562 if (!ToType->isRecordType()) { 4563 // - if the initializer list has one element, the implicit conversion 4564 // sequence is the one required to convert the element to the 4565 // parameter type. 4566 unsigned NumInits = From->getNumInits(); 4567 if (NumInits == 1) 4568 Result = TryCopyInitialization(S, From->getInit(0), ToType, 4569 SuppressUserConversions, 4570 InOverloadResolution, 4571 AllowObjCWritebackConversion); 4572 // - if the initializer list has no elements, the implicit conversion 4573 // sequence is the identity conversion. 4574 else if (NumInits == 0) { 4575 Result.setStandard(); 4576 Result.Standard.setAsIdentityConversion(); 4577 Result.Standard.setFromType(ToType); 4578 Result.Standard.setAllToTypes(ToType); 4579 } 4580 Result.setListInitializationSequence(); 4581 return Result; 4582 } 4583 4584 // C++11 [over.ics.list]p7: 4585 // In all cases other than those enumerated above, no conversion is possible 4586 return Result; 4587 } 4588 4589 /// TryCopyInitialization - Try to copy-initialize a value of type 4590 /// ToType from the expression From. Return the implicit conversion 4591 /// sequence required to pass this argument, which may be a bad 4592 /// conversion sequence (meaning that the argument cannot be passed to 4593 /// a parameter of this type). If @p SuppressUserConversions, then we 4594 /// do not permit any user-defined conversion sequences. 4595 static ImplicitConversionSequence 4596 TryCopyInitialization(Sema &S, Expr *From, QualType ToType, 4597 bool SuppressUserConversions, 4598 bool InOverloadResolution, 4599 bool AllowObjCWritebackConversion, 4600 bool AllowExplicit) { 4601 if (InitListExpr *FromInitList = dyn_cast<InitListExpr>(From)) 4602 return TryListConversion(S, FromInitList, ToType, SuppressUserConversions, 4603 InOverloadResolution,AllowObjCWritebackConversion); 4604 4605 if (ToType->isReferenceType()) 4606 return TryReferenceInit(S, From, ToType, 4607 /*FIXME:*/From->getLocStart(), 4608 SuppressUserConversions, 4609 AllowExplicit); 4610 4611 return TryImplicitConversion(S, From, ToType, 4612 SuppressUserConversions, 4613 /*AllowExplicit=*/false, 4614 InOverloadResolution, 4615 /*CStyle=*/false, 4616 AllowObjCWritebackConversion); 4617 } 4618 4619 static bool TryCopyInitialization(const CanQualType FromQTy, 4620 const CanQualType ToQTy, 4621 Sema &S, 4622 SourceLocation Loc, 4623 ExprValueKind FromVK) { 4624 OpaqueValueExpr TmpExpr(Loc, FromQTy, FromVK); 4625 ImplicitConversionSequence ICS = 4626 TryCopyInitialization(S, &TmpExpr, ToQTy, true, true, false); 4627 4628 return !ICS.isBad(); 4629 } 4630 4631 /// TryObjectArgumentInitialization - Try to initialize the object 4632 /// parameter of the given member function (@c Method) from the 4633 /// expression @p From. 4634 static ImplicitConversionSequence 4635 TryObjectArgumentInitialization(Sema &S, QualType FromType, 4636 Expr::Classification FromClassification, 4637 CXXMethodDecl *Method, 4638 CXXRecordDecl *ActingContext) { 4639 QualType ClassType = S.Context.getTypeDeclType(ActingContext); 4640 // [class.dtor]p2: A destructor can be invoked for a const, volatile or 4641 // const volatile object. 4642 unsigned Quals = isa<CXXDestructorDecl>(Method) ? 4643 Qualifiers::Const | Qualifiers::Volatile : Method->getTypeQualifiers(); 4644 QualType ImplicitParamType = S.Context.getCVRQualifiedType(ClassType, Quals); 4645 4646 // Set up the conversion sequence as a "bad" conversion, to allow us 4647 // to exit early. 4648 ImplicitConversionSequence ICS; 4649 4650 // We need to have an object of class type. 4651 if (const PointerType *PT = FromType->getAs<PointerType>()) { 4652 FromType = PT->getPointeeType(); 4653 4654 // When we had a pointer, it's implicitly dereferenced, so we 4655 // better have an lvalue. 4656 assert(FromClassification.isLValue()); 4657 } 4658 4659 assert(FromType->isRecordType()); 4660 4661 // C++0x [over.match.funcs]p4: 4662 // For non-static member functions, the type of the implicit object 4663 // parameter is 4664 // 4665 // - "lvalue reference to cv X" for functions declared without a 4666 // ref-qualifier or with the & ref-qualifier 4667 // - "rvalue reference to cv X" for functions declared with the && 4668 // ref-qualifier 4669 // 4670 // where X is the class of which the function is a member and cv is the 4671 // cv-qualification on the member function declaration. 4672 // 4673 // However, when finding an implicit conversion sequence for the argument, we 4674 // are not allowed to create temporaries or perform user-defined conversions 4675 // (C++ [over.match.funcs]p5). We perform a simplified version of 4676 // reference binding here, that allows class rvalues to bind to 4677 // non-constant references. 4678 4679 // First check the qualifiers. 4680 QualType FromTypeCanon = S.Context.getCanonicalType(FromType); 4681 if (ImplicitParamType.getCVRQualifiers() 4682 != FromTypeCanon.getLocalCVRQualifiers() && 4683 !ImplicitParamType.isAtLeastAsQualifiedAs(FromTypeCanon)) { 4684 ICS.setBad(BadConversionSequence::bad_qualifiers, 4685 FromType, ImplicitParamType); 4686 return ICS; 4687 } 4688 4689 // Check that we have either the same type or a derived type. It 4690 // affects the conversion rank. 4691 QualType ClassTypeCanon = S.Context.getCanonicalType(ClassType); 4692 ImplicitConversionKind SecondKind; 4693 if (ClassTypeCanon == FromTypeCanon.getLocalUnqualifiedType()) { 4694 SecondKind = ICK_Identity; 4695 } else if (S.IsDerivedFrom(FromType, ClassType)) 4696 SecondKind = ICK_Derived_To_Base; 4697 else { 4698 ICS.setBad(BadConversionSequence::unrelated_class, 4699 FromType, ImplicitParamType); 4700 return ICS; 4701 } 4702 4703 // Check the ref-qualifier. 4704 switch (Method->getRefQualifier()) { 4705 case RQ_None: 4706 // Do nothing; we don't care about lvalueness or rvalueness. 4707 break; 4708 4709 case RQ_LValue: 4710 if (!FromClassification.isLValue() && Quals != Qualifiers::Const) { 4711 // non-const lvalue reference cannot bind to an rvalue 4712 ICS.setBad(BadConversionSequence::lvalue_ref_to_rvalue, FromType, 4713 ImplicitParamType); 4714 return ICS; 4715 } 4716 break; 4717 4718 case RQ_RValue: 4719 if (!FromClassification.isRValue()) { 4720 // rvalue reference cannot bind to an lvalue 4721 ICS.setBad(BadConversionSequence::rvalue_ref_to_lvalue, FromType, 4722 ImplicitParamType); 4723 return ICS; 4724 } 4725 break; 4726 } 4727 4728 // Success. Mark this as a reference binding. 4729 ICS.setStandard(); 4730 ICS.Standard.setAsIdentityConversion(); 4731 ICS.Standard.Second = SecondKind; 4732 ICS.Standard.setFromType(FromType); 4733 ICS.Standard.setAllToTypes(ImplicitParamType); 4734 ICS.Standard.ReferenceBinding = true; 4735 ICS.Standard.DirectBinding = true; 4736 ICS.Standard.IsLvalueReference = Method->getRefQualifier() != RQ_RValue; 4737 ICS.Standard.BindsToFunctionLvalue = false; 4738 ICS.Standard.BindsToRvalue = FromClassification.isRValue(); 4739 ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier 4740 = (Method->getRefQualifier() == RQ_None); 4741 return ICS; 4742 } 4743 4744 /// PerformObjectArgumentInitialization - Perform initialization of 4745 /// the implicit object parameter for the given Method with the given 4746 /// expression. 4747 ExprResult 4748 Sema::PerformObjectArgumentInitialization(Expr *From, 4749 NestedNameSpecifier *Qualifier, 4750 NamedDecl *FoundDecl, 4751 CXXMethodDecl *Method) { 4752 QualType FromRecordType, DestType; 4753 QualType ImplicitParamRecordType = 4754 Method->getThisType(Context)->getAs<PointerType>()->getPointeeType(); 4755 4756 Expr::Classification FromClassification; 4757 if (const PointerType *PT = From->getType()->getAs<PointerType>()) { 4758 FromRecordType = PT->getPointeeType(); 4759 DestType = Method->getThisType(Context); 4760 FromClassification = Expr::Classification::makeSimpleLValue(); 4761 } else { 4762 FromRecordType = From->getType(); 4763 DestType = ImplicitParamRecordType; 4764 FromClassification = From->Classify(Context); 4765 } 4766 4767 // Note that we always use the true parent context when performing 4768 // the actual argument initialization. 4769 ImplicitConversionSequence ICS 4770 = TryObjectArgumentInitialization(*this, From->getType(), FromClassification, 4771 Method, Method->getParent()); 4772 if (ICS.isBad()) { 4773 if (ICS.Bad.Kind == BadConversionSequence::bad_qualifiers) { 4774 Qualifiers FromQs = FromRecordType.getQualifiers(); 4775 Qualifiers ToQs = DestType.getQualifiers(); 4776 unsigned CVR = FromQs.getCVRQualifiers() & ~ToQs.getCVRQualifiers(); 4777 if (CVR) { 4778 Diag(From->getLocStart(), 4779 diag::err_member_function_call_bad_cvr) 4780 << Method->getDeclName() << FromRecordType << (CVR - 1) 4781 << From->getSourceRange(); 4782 Diag(Method->getLocation(), diag::note_previous_decl) 4783 << Method->getDeclName(); 4784 return ExprError(); 4785 } 4786 } 4787 4788 return Diag(From->getLocStart(), 4789 diag::err_implicit_object_parameter_init) 4790 << ImplicitParamRecordType << FromRecordType << From->getSourceRange(); 4791 } 4792 4793 if (ICS.Standard.Second == ICK_Derived_To_Base) { 4794 ExprResult FromRes = 4795 PerformObjectMemberConversion(From, Qualifier, FoundDecl, Method); 4796 if (FromRes.isInvalid()) 4797 return ExprError(); 4798 From = FromRes.take(); 4799 } 4800 4801 if (!Context.hasSameType(From->getType(), DestType)) 4802 From = ImpCastExprToType(From, DestType, CK_NoOp, 4803 From->getValueKind()).take(); 4804 return Owned(From); 4805 } 4806 4807 /// TryContextuallyConvertToBool - Attempt to contextually convert the 4808 /// expression From to bool (C++0x [conv]p3). 4809 static ImplicitConversionSequence 4810 TryContextuallyConvertToBool(Sema &S, Expr *From) { 4811 // FIXME: This is pretty broken. 4812 return TryImplicitConversion(S, From, S.Context.BoolTy, 4813 // FIXME: Are these flags correct? 4814 /*SuppressUserConversions=*/false, 4815 /*AllowExplicit=*/true, 4816 /*InOverloadResolution=*/false, 4817 /*CStyle=*/false, 4818 /*AllowObjCWritebackConversion=*/false); 4819 } 4820 4821 /// PerformContextuallyConvertToBool - Perform a contextual conversion 4822 /// of the expression From to bool (C++0x [conv]p3). 4823 ExprResult Sema::PerformContextuallyConvertToBool(Expr *From) { 4824 if (checkPlaceholderForOverload(*this, From)) 4825 return ExprError(); 4826 4827 ImplicitConversionSequence ICS = TryContextuallyConvertToBool(*this, From); 4828 if (!ICS.isBad()) 4829 return PerformImplicitConversion(From, Context.BoolTy, ICS, AA_Converting); 4830 4831 if (!DiagnoseMultipleUserDefinedConversion(From, Context.BoolTy)) 4832 return Diag(From->getLocStart(), 4833 diag::err_typecheck_bool_condition) 4834 << From->getType() << From->getSourceRange(); 4835 return ExprError(); 4836 } 4837 4838 /// Check that the specified conversion is permitted in a converted constant 4839 /// expression, according to C++11 [expr.const]p3. Return true if the conversion 4840 /// is acceptable. 4841 static bool CheckConvertedConstantConversions(Sema &S, 4842 StandardConversionSequence &SCS) { 4843 // Since we know that the target type is an integral or unscoped enumeration 4844 // type, most conversion kinds are impossible. All possible First and Third 4845 // conversions are fine. 4846 switch (SCS.Second) { 4847 case ICK_Identity: 4848 case ICK_Integral_Promotion: 4849 case ICK_Integral_Conversion: 4850 case ICK_Zero_Event_Conversion: 4851 return true; 4852 4853 case ICK_Boolean_Conversion: 4854 // Conversion from an integral or unscoped enumeration type to bool is 4855 // classified as ICK_Boolean_Conversion, but it's also an integral 4856 // conversion, so it's permitted in a converted constant expression. 4857 return SCS.getFromType()->isIntegralOrUnscopedEnumerationType() && 4858 SCS.getToType(2)->isBooleanType(); 4859 4860 case ICK_Floating_Integral: 4861 case ICK_Complex_Real: 4862 return false; 4863 4864 case ICK_Lvalue_To_Rvalue: 4865 case ICK_Array_To_Pointer: 4866 case ICK_Function_To_Pointer: 4867 case ICK_NoReturn_Adjustment: 4868 case ICK_Qualification: 4869 case ICK_Compatible_Conversion: 4870 case ICK_Vector_Conversion: 4871 case ICK_Vector_Splat: 4872 case ICK_Derived_To_Base: 4873 case ICK_Pointer_Conversion: 4874 case ICK_Pointer_Member: 4875 case ICK_Block_Pointer_Conversion: 4876 case ICK_Writeback_Conversion: 4877 case ICK_Floating_Promotion: 4878 case ICK_Complex_Promotion: 4879 case ICK_Complex_Conversion: 4880 case ICK_Floating_Conversion: 4881 case ICK_TransparentUnionConversion: 4882 llvm_unreachable("unexpected second conversion kind"); 4883 4884 case ICK_Num_Conversion_Kinds: 4885 break; 4886 } 4887 4888 llvm_unreachable("unknown conversion kind"); 4889 } 4890 4891 /// CheckConvertedConstantExpression - Check that the expression From is a 4892 /// converted constant expression of type T, perform the conversion and produce 4893 /// the converted expression, per C++11 [expr.const]p3. 4894 ExprResult Sema::CheckConvertedConstantExpression(Expr *From, QualType T, 4895 llvm::APSInt &Value, 4896 CCEKind CCE) { 4897 assert(LangOpts.CPlusPlus11 && "converted constant expression outside C++11"); 4898 assert(T->isIntegralOrEnumerationType() && "unexpected converted const type"); 4899 4900 if (checkPlaceholderForOverload(*this, From)) 4901 return ExprError(); 4902 4903 // C++11 [expr.const]p3 with proposed wording fixes: 4904 // A converted constant expression of type T is a core constant expression, 4905 // implicitly converted to a prvalue of type T, where the converted 4906 // expression is a literal constant expression and the implicit conversion 4907 // sequence contains only user-defined conversions, lvalue-to-rvalue 4908 // conversions, integral promotions, and integral conversions other than 4909 // narrowing conversions. 4910 ImplicitConversionSequence ICS = 4911 TryImplicitConversion(From, T, 4912 /*SuppressUserConversions=*/false, 4913 /*AllowExplicit=*/false, 4914 /*InOverloadResolution=*/false, 4915 /*CStyle=*/false, 4916 /*AllowObjcWritebackConversion=*/false); 4917 StandardConversionSequence *SCS = 0; 4918 switch (ICS.getKind()) { 4919 case ImplicitConversionSequence::StandardConversion: 4920 if (!CheckConvertedConstantConversions(*this, ICS.Standard)) 4921 return Diag(From->getLocStart(), 4922 diag::err_typecheck_converted_constant_expression_disallowed) 4923 << From->getType() << From->getSourceRange() << T; 4924 SCS = &ICS.Standard; 4925 break; 4926 case ImplicitConversionSequence::UserDefinedConversion: 4927 // We are converting from class type to an integral or enumeration type, so 4928 // the Before sequence must be trivial. 4929 if (!CheckConvertedConstantConversions(*this, ICS.UserDefined.After)) 4930 return Diag(From->getLocStart(), 4931 diag::err_typecheck_converted_constant_expression_disallowed) 4932 << From->getType() << From->getSourceRange() << T; 4933 SCS = &ICS.UserDefined.After; 4934 break; 4935 case ImplicitConversionSequence::AmbiguousConversion: 4936 case ImplicitConversionSequence::BadConversion: 4937 if (!DiagnoseMultipleUserDefinedConversion(From, T)) 4938 return Diag(From->getLocStart(), 4939 diag::err_typecheck_converted_constant_expression) 4940 << From->getType() << From->getSourceRange() << T; 4941 return ExprError(); 4942 4943 case ImplicitConversionSequence::EllipsisConversion: 4944 llvm_unreachable("ellipsis conversion in converted constant expression"); 4945 } 4946 4947 ExprResult Result = PerformImplicitConversion(From, T, ICS, AA_Converting); 4948 if (Result.isInvalid()) 4949 return Result; 4950 4951 // Check for a narrowing implicit conversion. 4952 APValue PreNarrowingValue; 4953 QualType PreNarrowingType; 4954 switch (SCS->getNarrowingKind(Context, Result.get(), PreNarrowingValue, 4955 PreNarrowingType)) { 4956 case NK_Variable_Narrowing: 4957 // Implicit conversion to a narrower type, and the value is not a constant 4958 // expression. We'll diagnose this in a moment. 4959 case NK_Not_Narrowing: 4960 break; 4961 4962 case NK_Constant_Narrowing: 4963 Diag(From->getLocStart(), 4964 isSFINAEContext() ? diag::err_cce_narrowing_sfinae : 4965 diag::err_cce_narrowing) 4966 << CCE << /*Constant*/1 4967 << PreNarrowingValue.getAsString(Context, PreNarrowingType) << T; 4968 break; 4969 4970 case NK_Type_Narrowing: 4971 Diag(From->getLocStart(), 4972 isSFINAEContext() ? diag::err_cce_narrowing_sfinae : 4973 diag::err_cce_narrowing) 4974 << CCE << /*Constant*/0 << From->getType() << T; 4975 break; 4976 } 4977 4978 // Check the expression is a constant expression. 4979 SmallVector<PartialDiagnosticAt, 8> Notes; 4980 Expr::EvalResult Eval; 4981 Eval.Diag = &Notes; 4982 4983 if (!Result.get()->EvaluateAsRValue(Eval, Context) || !Eval.Val.isInt()) { 4984 // The expression can't be folded, so we can't keep it at this position in 4985 // the AST. 4986 Result = ExprError(); 4987 } else { 4988 Value = Eval.Val.getInt(); 4989 4990 if (Notes.empty()) { 4991 // It's a constant expression. 4992 return Result; 4993 } 4994 } 4995 4996 // It's not a constant expression. Produce an appropriate diagnostic. 4997 if (Notes.size() == 1 && 4998 Notes[0].second.getDiagID() == diag::note_invalid_subexpr_in_const_expr) 4999 Diag(Notes[0].first, diag::err_expr_not_cce) << CCE; 5000 else { 5001 Diag(From->getLocStart(), diag::err_expr_not_cce) 5002 << CCE << From->getSourceRange(); 5003 for (unsigned I = 0; I < Notes.size(); ++I) 5004 Diag(Notes[I].first, Notes[I].second); 5005 } 5006 return Result; 5007 } 5008 5009 /// dropPointerConversions - If the given standard conversion sequence 5010 /// involves any pointer conversions, remove them. This may change 5011 /// the result type of the conversion sequence. 5012 static void dropPointerConversion(StandardConversionSequence &SCS) { 5013 if (SCS.Second == ICK_Pointer_Conversion) { 5014 SCS.Second = ICK_Identity; 5015 SCS.Third = ICK_Identity; 5016 SCS.ToTypePtrs[2] = SCS.ToTypePtrs[1] = SCS.ToTypePtrs[0]; 5017 } 5018 } 5019 5020 /// TryContextuallyConvertToObjCPointer - Attempt to contextually 5021 /// convert the expression From to an Objective-C pointer type. 5022 static ImplicitConversionSequence 5023 TryContextuallyConvertToObjCPointer(Sema &S, Expr *From) { 5024 // Do an implicit conversion to 'id'. 5025 QualType Ty = S.Context.getObjCIdType(); 5026 ImplicitConversionSequence ICS 5027 = TryImplicitConversion(S, From, Ty, 5028 // FIXME: Are these flags correct? 5029 /*SuppressUserConversions=*/false, 5030 /*AllowExplicit=*/true, 5031 /*InOverloadResolution=*/false, 5032 /*CStyle=*/false, 5033 /*AllowObjCWritebackConversion=*/false); 5034 5035 // Strip off any final conversions to 'id'. 5036 switch (ICS.getKind()) { 5037 case ImplicitConversionSequence::BadConversion: 5038 case ImplicitConversionSequence::AmbiguousConversion: 5039 case ImplicitConversionSequence::EllipsisConversion: 5040 break; 5041 5042 case ImplicitConversionSequence::UserDefinedConversion: 5043 dropPointerConversion(ICS.UserDefined.After); 5044 break; 5045 5046 case ImplicitConversionSequence::StandardConversion: 5047 dropPointerConversion(ICS.Standard); 5048 break; 5049 } 5050 5051 return ICS; 5052 } 5053 5054 /// PerformContextuallyConvertToObjCPointer - Perform a contextual 5055 /// conversion of the expression From to an Objective-C pointer type. 5056 ExprResult Sema::PerformContextuallyConvertToObjCPointer(Expr *From) { 5057 if (checkPlaceholderForOverload(*this, From)) 5058 return ExprError(); 5059 5060 QualType Ty = Context.getObjCIdType(); 5061 ImplicitConversionSequence ICS = 5062 TryContextuallyConvertToObjCPointer(*this, From); 5063 if (!ICS.isBad()) 5064 return PerformImplicitConversion(From, Ty, ICS, AA_Converting); 5065 return ExprError(); 5066 } 5067 5068 /// Determine whether the provided type is an integral type, or an enumeration 5069 /// type of a permitted flavor. 5070 bool Sema::ICEConvertDiagnoser::match(QualType T) { 5071 return AllowScopedEnumerations ? T->isIntegralOrEnumerationType() 5072 : T->isIntegralOrUnscopedEnumerationType(); 5073 } 5074 5075 static ExprResult 5076 diagnoseAmbiguousConversion(Sema &SemaRef, SourceLocation Loc, Expr *From, 5077 Sema::ContextualImplicitConverter &Converter, 5078 QualType T, UnresolvedSetImpl &ViableConversions) { 5079 5080 if (Converter.Suppress) 5081 return ExprError(); 5082 5083 Converter.diagnoseAmbiguous(SemaRef, Loc, T) << From->getSourceRange(); 5084 for (unsigned I = 0, N = ViableConversions.size(); I != N; ++I) { 5085 CXXConversionDecl *Conv = 5086 cast<CXXConversionDecl>(ViableConversions[I]->getUnderlyingDecl()); 5087 QualType ConvTy = Conv->getConversionType().getNonReferenceType(); 5088 Converter.noteAmbiguous(SemaRef, Conv, ConvTy); 5089 } 5090 return SemaRef.Owned(From); 5091 } 5092 5093 static bool 5094 diagnoseNoViableConversion(Sema &SemaRef, SourceLocation Loc, Expr *&From, 5095 Sema::ContextualImplicitConverter &Converter, 5096 QualType T, bool HadMultipleCandidates, 5097 UnresolvedSetImpl &ExplicitConversions) { 5098 if (ExplicitConversions.size() == 1 && !Converter.Suppress) { 5099 DeclAccessPair Found = ExplicitConversions[0]; 5100 CXXConversionDecl *Conversion = 5101 cast<CXXConversionDecl>(Found->getUnderlyingDecl()); 5102 5103 // The user probably meant to invoke the given explicit 5104 // conversion; use it. 5105 QualType ConvTy = Conversion->getConversionType().getNonReferenceType(); 5106 std::string TypeStr; 5107 ConvTy.getAsStringInternal(TypeStr, SemaRef.getPrintingPolicy()); 5108 5109 Converter.diagnoseExplicitConv(SemaRef, Loc, T, ConvTy) 5110 << FixItHint::CreateInsertion(From->getLocStart(), 5111 "static_cast<" + TypeStr + ">(") 5112 << FixItHint::CreateInsertion( 5113 SemaRef.PP.getLocForEndOfToken(From->getLocEnd()), ")"); 5114 Converter.noteExplicitConv(SemaRef, Conversion, ConvTy); 5115 5116 // If we aren't in a SFINAE context, build a call to the 5117 // explicit conversion function. 5118 if (SemaRef.isSFINAEContext()) 5119 return true; 5120 5121 SemaRef.CheckMemberOperatorAccess(From->getExprLoc(), From, 0, Found); 5122 ExprResult Result = SemaRef.BuildCXXMemberCallExpr(From, Found, Conversion, 5123 HadMultipleCandidates); 5124 if (Result.isInvalid()) 5125 return true; 5126 // Record usage of conversion in an implicit cast. 5127 From = ImplicitCastExpr::Create(SemaRef.Context, Result.get()->getType(), 5128 CK_UserDefinedConversion, Result.get(), 0, 5129 Result.get()->getValueKind()); 5130 } 5131 return false; 5132 } 5133 5134 static bool recordConversion(Sema &SemaRef, SourceLocation Loc, Expr *&From, 5135 Sema::ContextualImplicitConverter &Converter, 5136 QualType T, bool HadMultipleCandidates, 5137 DeclAccessPair &Found) { 5138 CXXConversionDecl *Conversion = 5139 cast<CXXConversionDecl>(Found->getUnderlyingDecl()); 5140 SemaRef.CheckMemberOperatorAccess(From->getExprLoc(), From, 0, Found); 5141 5142 QualType ToType = Conversion->getConversionType().getNonReferenceType(); 5143 if (!Converter.SuppressConversion) { 5144 if (SemaRef.isSFINAEContext()) 5145 return true; 5146 5147 Converter.diagnoseConversion(SemaRef, Loc, T, ToType) 5148 << From->getSourceRange(); 5149 } 5150 5151 ExprResult Result = SemaRef.BuildCXXMemberCallExpr(From, Found, Conversion, 5152 HadMultipleCandidates); 5153 if (Result.isInvalid()) 5154 return true; 5155 // Record usage of conversion in an implicit cast. 5156 From = ImplicitCastExpr::Create(SemaRef.Context, Result.get()->getType(), 5157 CK_UserDefinedConversion, Result.get(), 0, 5158 Result.get()->getValueKind()); 5159 return false; 5160 } 5161 5162 static ExprResult finishContextualImplicitConversion( 5163 Sema &SemaRef, SourceLocation Loc, Expr *From, 5164 Sema::ContextualImplicitConverter &Converter) { 5165 if (!Converter.match(From->getType()) && !Converter.Suppress) 5166 Converter.diagnoseNoMatch(SemaRef, Loc, From->getType()) 5167 << From->getSourceRange(); 5168 5169 return SemaRef.DefaultLvalueConversion(From); 5170 } 5171 5172 static void 5173 collectViableConversionCandidates(Sema &SemaRef, Expr *From, QualType ToType, 5174 UnresolvedSetImpl &ViableConversions, 5175 OverloadCandidateSet &CandidateSet) { 5176 for (unsigned I = 0, N = ViableConversions.size(); I != N; ++I) { 5177 DeclAccessPair FoundDecl = ViableConversions[I]; 5178 NamedDecl *D = FoundDecl.getDecl(); 5179 CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext()); 5180 if (isa<UsingShadowDecl>(D)) 5181 D = cast<UsingShadowDecl>(D)->getTargetDecl(); 5182 5183 CXXConversionDecl *Conv; 5184 FunctionTemplateDecl *ConvTemplate; 5185 if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D))) 5186 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl()); 5187 else 5188 Conv = cast<CXXConversionDecl>(D); 5189 5190 if (ConvTemplate) 5191 SemaRef.AddTemplateConversionCandidate( 5192 ConvTemplate, FoundDecl, ActingContext, From, ToType, CandidateSet); 5193 else 5194 SemaRef.AddConversionCandidate(Conv, FoundDecl, ActingContext, From, 5195 ToType, CandidateSet); 5196 } 5197 } 5198 5199 /// \brief Attempt to convert the given expression to a type which is accepted 5200 /// by the given converter. 5201 /// 5202 /// This routine will attempt to convert an expression of class type to a 5203 /// type accepted by the specified converter. In C++11 and before, the class 5204 /// must have a single non-explicit conversion function converting to a matching 5205 /// type. In C++1y, there can be multiple such conversion functions, but only 5206 /// one target type. 5207 /// 5208 /// \param Loc The source location of the construct that requires the 5209 /// conversion. 5210 /// 5211 /// \param From The expression we're converting from. 5212 /// 5213 /// \param Converter Used to control and diagnose the conversion process. 5214 /// 5215 /// \returns The expression, converted to an integral or enumeration type if 5216 /// successful. 5217 ExprResult Sema::PerformContextualImplicitConversion( 5218 SourceLocation Loc, Expr *From, ContextualImplicitConverter &Converter) { 5219 // We can't perform any more checking for type-dependent expressions. 5220 if (From->isTypeDependent()) 5221 return Owned(From); 5222 5223 // Process placeholders immediately. 5224 if (From->hasPlaceholderType()) { 5225 ExprResult result = CheckPlaceholderExpr(From); 5226 if (result.isInvalid()) 5227 return result; 5228 From = result.take(); 5229 } 5230 5231 // If the expression already has a matching type, we're golden. 5232 QualType T = From->getType(); 5233 if (Converter.match(T)) 5234 return DefaultLvalueConversion(From); 5235 5236 // FIXME: Check for missing '()' if T is a function type? 5237 5238 // We can only perform contextual implicit conversions on objects of class 5239 // type. 5240 const RecordType *RecordTy = T->getAs<RecordType>(); 5241 if (!RecordTy || !getLangOpts().CPlusPlus) { 5242 if (!Converter.Suppress) 5243 Converter.diagnoseNoMatch(*this, Loc, T) << From->getSourceRange(); 5244 return Owned(From); 5245 } 5246 5247 // We must have a complete class type. 5248 struct TypeDiagnoserPartialDiag : TypeDiagnoser { 5249 ContextualImplicitConverter &Converter; 5250 Expr *From; 5251 5252 TypeDiagnoserPartialDiag(ContextualImplicitConverter &Converter, Expr *From) 5253 : TypeDiagnoser(Converter.Suppress), Converter(Converter), From(From) {} 5254 5255 virtual void diagnose(Sema &S, SourceLocation Loc, QualType T) { 5256 Converter.diagnoseIncomplete(S, Loc, T) << From->getSourceRange(); 5257 } 5258 } IncompleteDiagnoser(Converter, From); 5259 5260 if (RequireCompleteType(Loc, T, IncompleteDiagnoser)) 5261 return Owned(From); 5262 5263 // Look for a conversion to an integral or enumeration type. 5264 UnresolvedSet<4> 5265 ViableConversions; // These are *potentially* viable in C++1y. 5266 UnresolvedSet<4> ExplicitConversions; 5267 std::pair<CXXRecordDecl::conversion_iterator, 5268 CXXRecordDecl::conversion_iterator> Conversions = 5269 cast<CXXRecordDecl>(RecordTy->getDecl())->getVisibleConversionFunctions(); 5270 5271 bool HadMultipleCandidates = 5272 (std::distance(Conversions.first, Conversions.second) > 1); 5273 5274 // To check that there is only one target type, in C++1y: 5275 QualType ToType; 5276 bool HasUniqueTargetType = true; 5277 5278 // Collect explicit or viable (potentially in C++1y) conversions. 5279 for (CXXRecordDecl::conversion_iterator I = Conversions.first, 5280 E = Conversions.second; 5281 I != E; ++I) { 5282 NamedDecl *D = (*I)->getUnderlyingDecl(); 5283 CXXConversionDecl *Conversion; 5284 FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D); 5285 if (ConvTemplate) { 5286 if (getLangOpts().CPlusPlus1y) 5287 Conversion = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl()); 5288 else 5289 continue; // C++11 does not consider conversion operator templates(?). 5290 } else 5291 Conversion = cast<CXXConversionDecl>(D); 5292 5293 assert((!ConvTemplate || getLangOpts().CPlusPlus1y) && 5294 "Conversion operator templates are considered potentially " 5295 "viable in C++1y"); 5296 5297 QualType CurToType = Conversion->getConversionType().getNonReferenceType(); 5298 if (Converter.match(CurToType) || ConvTemplate) { 5299 5300 if (Conversion->isExplicit()) { 5301 // FIXME: For C++1y, do we need this restriction? 5302 // cf. diagnoseNoViableConversion() 5303 if (!ConvTemplate) 5304 ExplicitConversions.addDecl(I.getDecl(), I.getAccess()); 5305 } else { 5306 if (!ConvTemplate && getLangOpts().CPlusPlus1y) { 5307 if (ToType.isNull()) 5308 ToType = CurToType.getUnqualifiedType(); 5309 else if (HasUniqueTargetType && 5310 (CurToType.getUnqualifiedType() != ToType)) 5311 HasUniqueTargetType = false; 5312 } 5313 ViableConversions.addDecl(I.getDecl(), I.getAccess()); 5314 } 5315 } 5316 } 5317 5318 if (getLangOpts().CPlusPlus1y) { 5319 // C++1y [conv]p6: 5320 // ... An expression e of class type E appearing in such a context 5321 // is said to be contextually implicitly converted to a specified 5322 // type T and is well-formed if and only if e can be implicitly 5323 // converted to a type T that is determined as follows: E is searched 5324 // for conversion functions whose return type is cv T or reference to 5325 // cv T such that T is allowed by the context. There shall be 5326 // exactly one such T. 5327 5328 // If no unique T is found: 5329 if (ToType.isNull()) { 5330 if (diagnoseNoViableConversion(*this, Loc, From, Converter, T, 5331 HadMultipleCandidates, 5332 ExplicitConversions)) 5333 return ExprError(); 5334 return finishContextualImplicitConversion(*this, Loc, From, Converter); 5335 } 5336 5337 // If more than one unique Ts are found: 5338 if (!HasUniqueTargetType) 5339 return diagnoseAmbiguousConversion(*this, Loc, From, Converter, T, 5340 ViableConversions); 5341 5342 // If one unique T is found: 5343 // First, build a candidate set from the previously recorded 5344 // potentially viable conversions. 5345 OverloadCandidateSet CandidateSet(Loc); 5346 collectViableConversionCandidates(*this, From, ToType, ViableConversions, 5347 CandidateSet); 5348 5349 // Then, perform overload resolution over the candidate set. 5350 OverloadCandidateSet::iterator Best; 5351 switch (CandidateSet.BestViableFunction(*this, Loc, Best)) { 5352 case OR_Success: { 5353 // Apply this conversion. 5354 DeclAccessPair Found = 5355 DeclAccessPair::make(Best->Function, Best->FoundDecl.getAccess()); 5356 if (recordConversion(*this, Loc, From, Converter, T, 5357 HadMultipleCandidates, Found)) 5358 return ExprError(); 5359 break; 5360 } 5361 case OR_Ambiguous: 5362 return diagnoseAmbiguousConversion(*this, Loc, From, Converter, T, 5363 ViableConversions); 5364 case OR_No_Viable_Function: 5365 if (diagnoseNoViableConversion(*this, Loc, From, Converter, T, 5366 HadMultipleCandidates, 5367 ExplicitConversions)) 5368 return ExprError(); 5369 // fall through 'OR_Deleted' case. 5370 case OR_Deleted: 5371 // We'll complain below about a non-integral condition type. 5372 break; 5373 } 5374 } else { 5375 switch (ViableConversions.size()) { 5376 case 0: { 5377 if (diagnoseNoViableConversion(*this, Loc, From, Converter, T, 5378 HadMultipleCandidates, 5379 ExplicitConversions)) 5380 return ExprError(); 5381 5382 // We'll complain below about a non-integral condition type. 5383 break; 5384 } 5385 case 1: { 5386 // Apply this conversion. 5387 DeclAccessPair Found = ViableConversions[0]; 5388 if (recordConversion(*this, Loc, From, Converter, T, 5389 HadMultipleCandidates, Found)) 5390 return ExprError(); 5391 break; 5392 } 5393 default: 5394 return diagnoseAmbiguousConversion(*this, Loc, From, Converter, T, 5395 ViableConversions); 5396 } 5397 } 5398 5399 return finishContextualImplicitConversion(*this, Loc, From, Converter); 5400 } 5401 5402 /// AddOverloadCandidate - Adds the given function to the set of 5403 /// candidate functions, using the given function call arguments. If 5404 /// @p SuppressUserConversions, then don't allow user-defined 5405 /// conversions via constructors or conversion operators. 5406 /// 5407 /// \param PartialOverloading true if we are performing "partial" overloading 5408 /// based on an incomplete set of function arguments. This feature is used by 5409 /// code completion. 5410 void 5411 Sema::AddOverloadCandidate(FunctionDecl *Function, 5412 DeclAccessPair FoundDecl, 5413 ArrayRef<Expr *> Args, 5414 OverloadCandidateSet& CandidateSet, 5415 bool SuppressUserConversions, 5416 bool PartialOverloading, 5417 bool AllowExplicit) { 5418 const FunctionProtoType* Proto 5419 = dyn_cast<FunctionProtoType>(Function->getType()->getAs<FunctionType>()); 5420 assert(Proto && "Functions without a prototype cannot be overloaded"); 5421 assert(!Function->getDescribedFunctionTemplate() && 5422 "Use AddTemplateOverloadCandidate for function templates"); 5423 5424 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Function)) { 5425 if (!isa<CXXConstructorDecl>(Method)) { 5426 // If we get here, it's because we're calling a member function 5427 // that is named without a member access expression (e.g., 5428 // "this->f") that was either written explicitly or created 5429 // implicitly. This can happen with a qualified call to a member 5430 // function, e.g., X::f(). We use an empty type for the implied 5431 // object argument (C++ [over.call.func]p3), and the acting context 5432 // is irrelevant. 5433 AddMethodCandidate(Method, FoundDecl, Method->getParent(), 5434 QualType(), Expr::Classification::makeSimpleLValue(), 5435 Args, CandidateSet, SuppressUserConversions); 5436 return; 5437 } 5438 // We treat a constructor like a non-member function, since its object 5439 // argument doesn't participate in overload resolution. 5440 } 5441 5442 if (!CandidateSet.isNewCandidate(Function)) 5443 return; 5444 5445 // Overload resolution is always an unevaluated context. 5446 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); 5447 5448 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Function)){ 5449 // C++ [class.copy]p3: 5450 // A member function template is never instantiated to perform the copy 5451 // of a class object to an object of its class type. 5452 QualType ClassType = Context.getTypeDeclType(Constructor->getParent()); 5453 if (Args.size() == 1 && 5454 Constructor->isSpecializationCopyingObject() && 5455 (Context.hasSameUnqualifiedType(ClassType, Args[0]->getType()) || 5456 IsDerivedFrom(Args[0]->getType(), ClassType))) 5457 return; 5458 } 5459 5460 // Add this candidate 5461 OverloadCandidate &Candidate = CandidateSet.addCandidate(Args.size()); 5462 Candidate.FoundDecl = FoundDecl; 5463 Candidate.Function = Function; 5464 Candidate.Viable = true; 5465 Candidate.IsSurrogate = false; 5466 Candidate.IgnoreObjectArgument = false; 5467 Candidate.ExplicitCallArguments = Args.size(); 5468 5469 unsigned NumArgsInProto = Proto->getNumArgs(); 5470 5471 // (C++ 13.3.2p2): A candidate function having fewer than m 5472 // parameters is viable only if it has an ellipsis in its parameter 5473 // list (8.3.5). 5474 if ((Args.size() + (PartialOverloading && Args.size())) > NumArgsInProto && 5475 !Proto->isVariadic()) { 5476 Candidate.Viable = false; 5477 Candidate.FailureKind = ovl_fail_too_many_arguments; 5478 return; 5479 } 5480 5481 // (C++ 13.3.2p2): A candidate function having more than m parameters 5482 // is viable only if the (m+1)st parameter has a default argument 5483 // (8.3.6). For the purposes of overload resolution, the 5484 // parameter list is truncated on the right, so that there are 5485 // exactly m parameters. 5486 unsigned MinRequiredArgs = Function->getMinRequiredArguments(); 5487 if (Args.size() < MinRequiredArgs && !PartialOverloading) { 5488 // Not enough arguments. 5489 Candidate.Viable = false; 5490 Candidate.FailureKind = ovl_fail_too_few_arguments; 5491 return; 5492 } 5493 5494 // (CUDA B.1): Check for invalid calls between targets. 5495 if (getLangOpts().CUDA) 5496 if (const FunctionDecl *Caller = dyn_cast<FunctionDecl>(CurContext)) 5497 if (CheckCUDATarget(Caller, Function)) { 5498 Candidate.Viable = false; 5499 Candidate.FailureKind = ovl_fail_bad_target; 5500 return; 5501 } 5502 5503 // Determine the implicit conversion sequences for each of the 5504 // arguments. 5505 for (unsigned ArgIdx = 0; ArgIdx < Args.size(); ++ArgIdx) { 5506 if (ArgIdx < NumArgsInProto) { 5507 // (C++ 13.3.2p3): for F to be a viable function, there shall 5508 // exist for each argument an implicit conversion sequence 5509 // (13.3.3.1) that converts that argument to the corresponding 5510 // parameter of F. 5511 QualType ParamType = Proto->getArgType(ArgIdx); 5512 Candidate.Conversions[ArgIdx] 5513 = TryCopyInitialization(*this, Args[ArgIdx], ParamType, 5514 SuppressUserConversions, 5515 /*InOverloadResolution=*/true, 5516 /*AllowObjCWritebackConversion=*/ 5517 getLangOpts().ObjCAutoRefCount, 5518 AllowExplicit); 5519 if (Candidate.Conversions[ArgIdx].isBad()) { 5520 Candidate.Viable = false; 5521 Candidate.FailureKind = ovl_fail_bad_conversion; 5522 break; 5523 } 5524 } else { 5525 // (C++ 13.3.2p2): For the purposes of overload resolution, any 5526 // argument for which there is no corresponding parameter is 5527 // considered to ""match the ellipsis" (C+ 13.3.3.1.3). 5528 Candidate.Conversions[ArgIdx].setEllipsis(); 5529 } 5530 } 5531 } 5532 5533 /// \brief Add all of the function declarations in the given function set to 5534 /// the overload canddiate set. 5535 void Sema::AddFunctionCandidates(const UnresolvedSetImpl &Fns, 5536 ArrayRef<Expr *> Args, 5537 OverloadCandidateSet& CandidateSet, 5538 bool SuppressUserConversions, 5539 TemplateArgumentListInfo *ExplicitTemplateArgs) { 5540 for (UnresolvedSetIterator F = Fns.begin(), E = Fns.end(); F != E; ++F) { 5541 NamedDecl *D = F.getDecl()->getUnderlyingDecl(); 5542 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 5543 if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic()) 5544 AddMethodCandidate(cast<CXXMethodDecl>(FD), F.getPair(), 5545 cast<CXXMethodDecl>(FD)->getParent(), 5546 Args[0]->getType(), Args[0]->Classify(Context), 5547 Args.slice(1), CandidateSet, 5548 SuppressUserConversions); 5549 else 5550 AddOverloadCandidate(FD, F.getPair(), Args, CandidateSet, 5551 SuppressUserConversions); 5552 } else { 5553 FunctionTemplateDecl *FunTmpl = cast<FunctionTemplateDecl>(D); 5554 if (isa<CXXMethodDecl>(FunTmpl->getTemplatedDecl()) && 5555 !cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl())->isStatic()) 5556 AddMethodTemplateCandidate(FunTmpl, F.getPair(), 5557 cast<CXXRecordDecl>(FunTmpl->getDeclContext()), 5558 ExplicitTemplateArgs, 5559 Args[0]->getType(), 5560 Args[0]->Classify(Context), Args.slice(1), 5561 CandidateSet, SuppressUserConversions); 5562 else 5563 AddTemplateOverloadCandidate(FunTmpl, F.getPair(), 5564 ExplicitTemplateArgs, Args, 5565 CandidateSet, SuppressUserConversions); 5566 } 5567 } 5568 } 5569 5570 /// AddMethodCandidate - Adds a named decl (which is some kind of 5571 /// method) as a method candidate to the given overload set. 5572 void Sema::AddMethodCandidate(DeclAccessPair FoundDecl, 5573 QualType ObjectType, 5574 Expr::Classification ObjectClassification, 5575 ArrayRef<Expr *> Args, 5576 OverloadCandidateSet& CandidateSet, 5577 bool SuppressUserConversions) { 5578 NamedDecl *Decl = FoundDecl.getDecl(); 5579 CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(Decl->getDeclContext()); 5580 5581 if (isa<UsingShadowDecl>(Decl)) 5582 Decl = cast<UsingShadowDecl>(Decl)->getTargetDecl(); 5583 5584 if (FunctionTemplateDecl *TD = dyn_cast<FunctionTemplateDecl>(Decl)) { 5585 assert(isa<CXXMethodDecl>(TD->getTemplatedDecl()) && 5586 "Expected a member function template"); 5587 AddMethodTemplateCandidate(TD, FoundDecl, ActingContext, 5588 /*ExplicitArgs*/ 0, 5589 ObjectType, ObjectClassification, 5590 Args, CandidateSet, 5591 SuppressUserConversions); 5592 } else { 5593 AddMethodCandidate(cast<CXXMethodDecl>(Decl), FoundDecl, ActingContext, 5594 ObjectType, ObjectClassification, 5595 Args, 5596 CandidateSet, SuppressUserConversions); 5597 } 5598 } 5599 5600 /// AddMethodCandidate - Adds the given C++ member function to the set 5601 /// of candidate functions, using the given function call arguments 5602 /// and the object argument (@c Object). For example, in a call 5603 /// @c o.f(a1,a2), @c Object will contain @c o and @c Args will contain 5604 /// both @c a1 and @c a2. If @p SuppressUserConversions, then don't 5605 /// allow user-defined conversions via constructors or conversion 5606 /// operators. 5607 void 5608 Sema::AddMethodCandidate(CXXMethodDecl *Method, DeclAccessPair FoundDecl, 5609 CXXRecordDecl *ActingContext, QualType ObjectType, 5610 Expr::Classification ObjectClassification, 5611 ArrayRef<Expr *> Args, 5612 OverloadCandidateSet& CandidateSet, 5613 bool SuppressUserConversions) { 5614 const FunctionProtoType* Proto 5615 = dyn_cast<FunctionProtoType>(Method->getType()->getAs<FunctionType>()); 5616 assert(Proto && "Methods without a prototype cannot be overloaded"); 5617 assert(!isa<CXXConstructorDecl>(Method) && 5618 "Use AddOverloadCandidate for constructors"); 5619 5620 if (!CandidateSet.isNewCandidate(Method)) 5621 return; 5622 5623 // Overload resolution is always an unevaluated context. 5624 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); 5625 5626 // Add this candidate 5627 OverloadCandidate &Candidate = CandidateSet.addCandidate(Args.size() + 1); 5628 Candidate.FoundDecl = FoundDecl; 5629 Candidate.Function = Method; 5630 Candidate.IsSurrogate = false; 5631 Candidate.IgnoreObjectArgument = false; 5632 Candidate.ExplicitCallArguments = Args.size(); 5633 5634 unsigned NumArgsInProto = Proto->getNumArgs(); 5635 5636 // (C++ 13.3.2p2): A candidate function having fewer than m 5637 // parameters is viable only if it has an ellipsis in its parameter 5638 // list (8.3.5). 5639 if (Args.size() > NumArgsInProto && !Proto->isVariadic()) { 5640 Candidate.Viable = false; 5641 Candidate.FailureKind = ovl_fail_too_many_arguments; 5642 return; 5643 } 5644 5645 // (C++ 13.3.2p2): A candidate function having more than m parameters 5646 // is viable only if the (m+1)st parameter has a default argument 5647 // (8.3.6). For the purposes of overload resolution, the 5648 // parameter list is truncated on the right, so that there are 5649 // exactly m parameters. 5650 unsigned MinRequiredArgs = Method->getMinRequiredArguments(); 5651 if (Args.size() < MinRequiredArgs) { 5652 // Not enough arguments. 5653 Candidate.Viable = false; 5654 Candidate.FailureKind = ovl_fail_too_few_arguments; 5655 return; 5656 } 5657 5658 Candidate.Viable = true; 5659 5660 if (Method->isStatic() || ObjectType.isNull()) 5661 // The implicit object argument is ignored. 5662 Candidate.IgnoreObjectArgument = true; 5663 else { 5664 // Determine the implicit conversion sequence for the object 5665 // parameter. 5666 Candidate.Conversions[0] 5667 = TryObjectArgumentInitialization(*this, ObjectType, ObjectClassification, 5668 Method, ActingContext); 5669 if (Candidate.Conversions[0].isBad()) { 5670 Candidate.Viable = false; 5671 Candidate.FailureKind = ovl_fail_bad_conversion; 5672 return; 5673 } 5674 } 5675 5676 // Determine the implicit conversion sequences for each of the 5677 // arguments. 5678 for (unsigned ArgIdx = 0; ArgIdx < Args.size(); ++ArgIdx) { 5679 if (ArgIdx < NumArgsInProto) { 5680 // (C++ 13.3.2p3): for F to be a viable function, there shall 5681 // exist for each argument an implicit conversion sequence 5682 // (13.3.3.1) that converts that argument to the corresponding 5683 // parameter of F. 5684 QualType ParamType = Proto->getArgType(ArgIdx); 5685 Candidate.Conversions[ArgIdx + 1] 5686 = TryCopyInitialization(*this, Args[ArgIdx], ParamType, 5687 SuppressUserConversions, 5688 /*InOverloadResolution=*/true, 5689 /*AllowObjCWritebackConversion=*/ 5690 getLangOpts().ObjCAutoRefCount); 5691 if (Candidate.Conversions[ArgIdx + 1].isBad()) { 5692 Candidate.Viable = false; 5693 Candidate.FailureKind = ovl_fail_bad_conversion; 5694 break; 5695 } 5696 } else { 5697 // (C++ 13.3.2p2): For the purposes of overload resolution, any 5698 // argument for which there is no corresponding parameter is 5699 // considered to ""match the ellipsis" (C+ 13.3.3.1.3). 5700 Candidate.Conversions[ArgIdx + 1].setEllipsis(); 5701 } 5702 } 5703 } 5704 5705 /// \brief Add a C++ member function template as a candidate to the candidate 5706 /// set, using template argument deduction to produce an appropriate member 5707 /// function template specialization. 5708 void 5709 Sema::AddMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl, 5710 DeclAccessPair FoundDecl, 5711 CXXRecordDecl *ActingContext, 5712 TemplateArgumentListInfo *ExplicitTemplateArgs, 5713 QualType ObjectType, 5714 Expr::Classification ObjectClassification, 5715 ArrayRef<Expr *> Args, 5716 OverloadCandidateSet& CandidateSet, 5717 bool SuppressUserConversions) { 5718 if (!CandidateSet.isNewCandidate(MethodTmpl)) 5719 return; 5720 5721 // C++ [over.match.funcs]p7: 5722 // In each case where a candidate is a function template, candidate 5723 // function template specializations are generated using template argument 5724 // deduction (14.8.3, 14.8.2). Those candidates are then handled as 5725 // candidate functions in the usual way.113) A given name can refer to one 5726 // or more function templates and also to a set of overloaded non-template 5727 // functions. In such a case, the candidate functions generated from each 5728 // function template are combined with the set of non-template candidate 5729 // functions. 5730 TemplateDeductionInfo Info(CandidateSet.getLocation()); 5731 FunctionDecl *Specialization = 0; 5732 if (TemplateDeductionResult Result 5733 = DeduceTemplateArguments(MethodTmpl, ExplicitTemplateArgs, Args, 5734 Specialization, Info)) { 5735 OverloadCandidate &Candidate = CandidateSet.addCandidate(); 5736 Candidate.FoundDecl = FoundDecl; 5737 Candidate.Function = MethodTmpl->getTemplatedDecl(); 5738 Candidate.Viable = false; 5739 Candidate.FailureKind = ovl_fail_bad_deduction; 5740 Candidate.IsSurrogate = false; 5741 Candidate.IgnoreObjectArgument = false; 5742 Candidate.ExplicitCallArguments = Args.size(); 5743 Candidate.DeductionFailure = MakeDeductionFailureInfo(Context, Result, 5744 Info); 5745 return; 5746 } 5747 5748 // Add the function template specialization produced by template argument 5749 // deduction as a candidate. 5750 assert(Specialization && "Missing member function template specialization?"); 5751 assert(isa<CXXMethodDecl>(Specialization) && 5752 "Specialization is not a member function?"); 5753 AddMethodCandidate(cast<CXXMethodDecl>(Specialization), FoundDecl, 5754 ActingContext, ObjectType, ObjectClassification, Args, 5755 CandidateSet, SuppressUserConversions); 5756 } 5757 5758 /// \brief Add a C++ function template specialization as a candidate 5759 /// in the candidate set, using template argument deduction to produce 5760 /// an appropriate function template specialization. 5761 void 5762 Sema::AddTemplateOverloadCandidate(FunctionTemplateDecl *FunctionTemplate, 5763 DeclAccessPair FoundDecl, 5764 TemplateArgumentListInfo *ExplicitTemplateArgs, 5765 ArrayRef<Expr *> Args, 5766 OverloadCandidateSet& CandidateSet, 5767 bool SuppressUserConversions) { 5768 if (!CandidateSet.isNewCandidate(FunctionTemplate)) 5769 return; 5770 5771 // C++ [over.match.funcs]p7: 5772 // In each case where a candidate is a function template, candidate 5773 // function template specializations are generated using template argument 5774 // deduction (14.8.3, 14.8.2). Those candidates are then handled as 5775 // candidate functions in the usual way.113) A given name can refer to one 5776 // or more function templates and also to a set of overloaded non-template 5777 // functions. In such a case, the candidate functions generated from each 5778 // function template are combined with the set of non-template candidate 5779 // functions. 5780 TemplateDeductionInfo Info(CandidateSet.getLocation()); 5781 FunctionDecl *Specialization = 0; 5782 if (TemplateDeductionResult Result 5783 = DeduceTemplateArguments(FunctionTemplate, ExplicitTemplateArgs, Args, 5784 Specialization, Info)) { 5785 OverloadCandidate &Candidate = CandidateSet.addCandidate(); 5786 Candidate.FoundDecl = FoundDecl; 5787 Candidate.Function = FunctionTemplate->getTemplatedDecl(); 5788 Candidate.Viable = false; 5789 Candidate.FailureKind = ovl_fail_bad_deduction; 5790 Candidate.IsSurrogate = false; 5791 Candidate.IgnoreObjectArgument = false; 5792 Candidate.ExplicitCallArguments = Args.size(); 5793 Candidate.DeductionFailure = MakeDeductionFailureInfo(Context, Result, 5794 Info); 5795 return; 5796 } 5797 5798 // Add the function template specialization produced by template argument 5799 // deduction as a candidate. 5800 assert(Specialization && "Missing function template specialization?"); 5801 AddOverloadCandidate(Specialization, FoundDecl, Args, CandidateSet, 5802 SuppressUserConversions); 5803 } 5804 5805 /// AddConversionCandidate - Add a C++ conversion function as a 5806 /// candidate in the candidate set (C++ [over.match.conv], 5807 /// C++ [over.match.copy]). From is the expression we're converting from, 5808 /// and ToType is the type that we're eventually trying to convert to 5809 /// (which may or may not be the same type as the type that the 5810 /// conversion function produces). 5811 void 5812 Sema::AddConversionCandidate(CXXConversionDecl *Conversion, 5813 DeclAccessPair FoundDecl, 5814 CXXRecordDecl *ActingContext, 5815 Expr *From, QualType ToType, 5816 OverloadCandidateSet& CandidateSet) { 5817 assert(!Conversion->getDescribedFunctionTemplate() && 5818 "Conversion function templates use AddTemplateConversionCandidate"); 5819 QualType ConvType = Conversion->getConversionType().getNonReferenceType(); 5820 if (!CandidateSet.isNewCandidate(Conversion)) 5821 return; 5822 5823 // If the conversion function has an undeduced return type, trigger its 5824 // deduction now. 5825 if (getLangOpts().CPlusPlus1y && ConvType->isUndeducedType()) { 5826 if (DeduceReturnType(Conversion, From->getExprLoc())) 5827 return; 5828 ConvType = Conversion->getConversionType().getNonReferenceType(); 5829 } 5830 5831 // Overload resolution is always an unevaluated context. 5832 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); 5833 5834 // Add this candidate 5835 OverloadCandidate &Candidate = CandidateSet.addCandidate(1); 5836 Candidate.FoundDecl = FoundDecl; 5837 Candidate.Function = Conversion; 5838 Candidate.IsSurrogate = false; 5839 Candidate.IgnoreObjectArgument = false; 5840 Candidate.FinalConversion.setAsIdentityConversion(); 5841 Candidate.FinalConversion.setFromType(ConvType); 5842 Candidate.FinalConversion.setAllToTypes(ToType); 5843 Candidate.Viable = true; 5844 Candidate.ExplicitCallArguments = 1; 5845 5846 // C++ [over.match.funcs]p4: 5847 // For conversion functions, the function is considered to be a member of 5848 // the class of the implicit implied object argument for the purpose of 5849 // defining the type of the implicit object parameter. 5850 // 5851 // Determine the implicit conversion sequence for the implicit 5852 // object parameter. 5853 QualType ImplicitParamType = From->getType(); 5854 if (const PointerType *FromPtrType = ImplicitParamType->getAs<PointerType>()) 5855 ImplicitParamType = FromPtrType->getPointeeType(); 5856 CXXRecordDecl *ConversionContext 5857 = cast<CXXRecordDecl>(ImplicitParamType->getAs<RecordType>()->getDecl()); 5858 5859 Candidate.Conversions[0] 5860 = TryObjectArgumentInitialization(*this, From->getType(), 5861 From->Classify(Context), 5862 Conversion, ConversionContext); 5863 5864 if (Candidate.Conversions[0].isBad()) { 5865 Candidate.Viable = false; 5866 Candidate.FailureKind = ovl_fail_bad_conversion; 5867 return; 5868 } 5869 5870 // We won't go through a user-define type conversion function to convert a 5871 // derived to base as such conversions are given Conversion Rank. They only 5872 // go through a copy constructor. 13.3.3.1.2-p4 [over.ics.user] 5873 QualType FromCanon 5874 = Context.getCanonicalType(From->getType().getUnqualifiedType()); 5875 QualType ToCanon = Context.getCanonicalType(ToType).getUnqualifiedType(); 5876 if (FromCanon == ToCanon || IsDerivedFrom(FromCanon, ToCanon)) { 5877 Candidate.Viable = false; 5878 Candidate.FailureKind = ovl_fail_trivial_conversion; 5879 return; 5880 } 5881 5882 // To determine what the conversion from the result of calling the 5883 // conversion function to the type we're eventually trying to 5884 // convert to (ToType), we need to synthesize a call to the 5885 // conversion function and attempt copy initialization from it. This 5886 // makes sure that we get the right semantics with respect to 5887 // lvalues/rvalues and the type. Fortunately, we can allocate this 5888 // call on the stack and we don't need its arguments to be 5889 // well-formed. 5890 DeclRefExpr ConversionRef(Conversion, false, Conversion->getType(), 5891 VK_LValue, From->getLocStart()); 5892 ImplicitCastExpr ConversionFn(ImplicitCastExpr::OnStack, 5893 Context.getPointerType(Conversion->getType()), 5894 CK_FunctionToPointerDecay, 5895 &ConversionRef, VK_RValue); 5896 5897 QualType ConversionType = Conversion->getConversionType(); 5898 if (RequireCompleteType(From->getLocStart(), ConversionType, 0)) { 5899 Candidate.Viable = false; 5900 Candidate.FailureKind = ovl_fail_bad_final_conversion; 5901 return; 5902 } 5903 5904 ExprValueKind VK = Expr::getValueKindForType(ConversionType); 5905 5906 // Note that it is safe to allocate CallExpr on the stack here because 5907 // there are 0 arguments (i.e., nothing is allocated using ASTContext's 5908 // allocator). 5909 QualType CallResultType = ConversionType.getNonLValueExprType(Context); 5910 CallExpr Call(Context, &ConversionFn, None, CallResultType, VK, 5911 From->getLocStart()); 5912 ImplicitConversionSequence ICS = 5913 TryCopyInitialization(*this, &Call, ToType, 5914 /*SuppressUserConversions=*/true, 5915 /*InOverloadResolution=*/false, 5916 /*AllowObjCWritebackConversion=*/false); 5917 5918 switch (ICS.getKind()) { 5919 case ImplicitConversionSequence::StandardConversion: 5920 Candidate.FinalConversion = ICS.Standard; 5921 5922 // C++ [over.ics.user]p3: 5923 // If the user-defined conversion is specified by a specialization of a 5924 // conversion function template, the second standard conversion sequence 5925 // shall have exact match rank. 5926 if (Conversion->getPrimaryTemplate() && 5927 GetConversionRank(ICS.Standard.Second) != ICR_Exact_Match) { 5928 Candidate.Viable = false; 5929 Candidate.FailureKind = ovl_fail_final_conversion_not_exact; 5930 } 5931 5932 // C++0x [dcl.init.ref]p5: 5933 // In the second case, if the reference is an rvalue reference and 5934 // the second standard conversion sequence of the user-defined 5935 // conversion sequence includes an lvalue-to-rvalue conversion, the 5936 // program is ill-formed. 5937 if (ToType->isRValueReferenceType() && 5938 ICS.Standard.First == ICK_Lvalue_To_Rvalue) { 5939 Candidate.Viable = false; 5940 Candidate.FailureKind = ovl_fail_bad_final_conversion; 5941 } 5942 break; 5943 5944 case ImplicitConversionSequence::BadConversion: 5945 Candidate.Viable = false; 5946 Candidate.FailureKind = ovl_fail_bad_final_conversion; 5947 break; 5948 5949 default: 5950 llvm_unreachable( 5951 "Can only end up with a standard conversion sequence or failure"); 5952 } 5953 } 5954 5955 /// \brief Adds a conversion function template specialization 5956 /// candidate to the overload set, using template argument deduction 5957 /// to deduce the template arguments of the conversion function 5958 /// template from the type that we are converting to (C++ 5959 /// [temp.deduct.conv]). 5960 void 5961 Sema::AddTemplateConversionCandidate(FunctionTemplateDecl *FunctionTemplate, 5962 DeclAccessPair FoundDecl, 5963 CXXRecordDecl *ActingDC, 5964 Expr *From, QualType ToType, 5965 OverloadCandidateSet &CandidateSet) { 5966 assert(isa<CXXConversionDecl>(FunctionTemplate->getTemplatedDecl()) && 5967 "Only conversion function templates permitted here"); 5968 5969 if (!CandidateSet.isNewCandidate(FunctionTemplate)) 5970 return; 5971 5972 TemplateDeductionInfo Info(CandidateSet.getLocation()); 5973 CXXConversionDecl *Specialization = 0; 5974 if (TemplateDeductionResult Result 5975 = DeduceTemplateArguments(FunctionTemplate, ToType, 5976 Specialization, Info)) { 5977 OverloadCandidate &Candidate = CandidateSet.addCandidate(); 5978 Candidate.FoundDecl = FoundDecl; 5979 Candidate.Function = FunctionTemplate->getTemplatedDecl(); 5980 Candidate.Viable = false; 5981 Candidate.FailureKind = ovl_fail_bad_deduction; 5982 Candidate.IsSurrogate = false; 5983 Candidate.IgnoreObjectArgument = false; 5984 Candidate.ExplicitCallArguments = 1; 5985 Candidate.DeductionFailure = MakeDeductionFailureInfo(Context, Result, 5986 Info); 5987 return; 5988 } 5989 5990 // Add the conversion function template specialization produced by 5991 // template argument deduction as a candidate. 5992 assert(Specialization && "Missing function template specialization?"); 5993 AddConversionCandidate(Specialization, FoundDecl, ActingDC, From, ToType, 5994 CandidateSet); 5995 } 5996 5997 /// AddSurrogateCandidate - Adds a "surrogate" candidate function that 5998 /// converts the given @c Object to a function pointer via the 5999 /// conversion function @c Conversion, and then attempts to call it 6000 /// with the given arguments (C++ [over.call.object]p2-4). Proto is 6001 /// the type of function that we'll eventually be calling. 6002 void Sema::AddSurrogateCandidate(CXXConversionDecl *Conversion, 6003 DeclAccessPair FoundDecl, 6004 CXXRecordDecl *ActingContext, 6005 const FunctionProtoType *Proto, 6006 Expr *Object, 6007 ArrayRef<Expr *> Args, 6008 OverloadCandidateSet& CandidateSet) { 6009 if (!CandidateSet.isNewCandidate(Conversion)) 6010 return; 6011 6012 // Overload resolution is always an unevaluated context. 6013 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); 6014 6015 OverloadCandidate &Candidate = CandidateSet.addCandidate(Args.size() + 1); 6016 Candidate.FoundDecl = FoundDecl; 6017 Candidate.Function = 0; 6018 Candidate.Surrogate = Conversion; 6019 Candidate.Viable = true; 6020 Candidate.IsSurrogate = true; 6021 Candidate.IgnoreObjectArgument = false; 6022 Candidate.ExplicitCallArguments = Args.size(); 6023 6024 // Determine the implicit conversion sequence for the implicit 6025 // object parameter. 6026 ImplicitConversionSequence ObjectInit 6027 = TryObjectArgumentInitialization(*this, Object->getType(), 6028 Object->Classify(Context), 6029 Conversion, ActingContext); 6030 if (ObjectInit.isBad()) { 6031 Candidate.Viable = false; 6032 Candidate.FailureKind = ovl_fail_bad_conversion; 6033 Candidate.Conversions[0] = ObjectInit; 6034 return; 6035 } 6036 6037 // The first conversion is actually a user-defined conversion whose 6038 // first conversion is ObjectInit's standard conversion (which is 6039 // effectively a reference binding). Record it as such. 6040 Candidate.Conversions[0].setUserDefined(); 6041 Candidate.Conversions[0].UserDefined.Before = ObjectInit.Standard; 6042 Candidate.Conversions[0].UserDefined.EllipsisConversion = false; 6043 Candidate.Conversions[0].UserDefined.HadMultipleCandidates = false; 6044 Candidate.Conversions[0].UserDefined.ConversionFunction = Conversion; 6045 Candidate.Conversions[0].UserDefined.FoundConversionFunction = FoundDecl; 6046 Candidate.Conversions[0].UserDefined.After 6047 = Candidate.Conversions[0].UserDefined.Before; 6048 Candidate.Conversions[0].UserDefined.After.setAsIdentityConversion(); 6049 6050 // Find the 6051 unsigned NumArgsInProto = Proto->getNumArgs(); 6052 6053 // (C++ 13.3.2p2): A candidate function having fewer than m 6054 // parameters is viable only if it has an ellipsis in its parameter 6055 // list (8.3.5). 6056 if (Args.size() > NumArgsInProto && !Proto->isVariadic()) { 6057 Candidate.Viable = false; 6058 Candidate.FailureKind = ovl_fail_too_many_arguments; 6059 return; 6060 } 6061 6062 // Function types don't have any default arguments, so just check if 6063 // we have enough arguments. 6064 if (Args.size() < NumArgsInProto) { 6065 // Not enough arguments. 6066 Candidate.Viable = false; 6067 Candidate.FailureKind = ovl_fail_too_few_arguments; 6068 return; 6069 } 6070 6071 // Determine the implicit conversion sequences for each of the 6072 // arguments. 6073 for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) { 6074 if (ArgIdx < NumArgsInProto) { 6075 // (C++ 13.3.2p3): for F to be a viable function, there shall 6076 // exist for each argument an implicit conversion sequence 6077 // (13.3.3.1) that converts that argument to the corresponding 6078 // parameter of F. 6079 QualType ParamType = Proto->getArgType(ArgIdx); 6080 Candidate.Conversions[ArgIdx + 1] 6081 = TryCopyInitialization(*this, Args[ArgIdx], ParamType, 6082 /*SuppressUserConversions=*/false, 6083 /*InOverloadResolution=*/false, 6084 /*AllowObjCWritebackConversion=*/ 6085 getLangOpts().ObjCAutoRefCount); 6086 if (Candidate.Conversions[ArgIdx + 1].isBad()) { 6087 Candidate.Viable = false; 6088 Candidate.FailureKind = ovl_fail_bad_conversion; 6089 break; 6090 } 6091 } else { 6092 // (C++ 13.3.2p2): For the purposes of overload resolution, any 6093 // argument for which there is no corresponding parameter is 6094 // considered to ""match the ellipsis" (C+ 13.3.3.1.3). 6095 Candidate.Conversions[ArgIdx + 1].setEllipsis(); 6096 } 6097 } 6098 } 6099 6100 /// \brief Add overload candidates for overloaded operators that are 6101 /// member functions. 6102 /// 6103 /// Add the overloaded operator candidates that are member functions 6104 /// for the operator Op that was used in an operator expression such 6105 /// as "x Op y". , Args/NumArgs provides the operator arguments, and 6106 /// CandidateSet will store the added overload candidates. (C++ 6107 /// [over.match.oper]). 6108 void Sema::AddMemberOperatorCandidates(OverloadedOperatorKind Op, 6109 SourceLocation OpLoc, 6110 ArrayRef<Expr *> Args, 6111 OverloadCandidateSet& CandidateSet, 6112 SourceRange OpRange) { 6113 DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op); 6114 6115 // C++ [over.match.oper]p3: 6116 // For a unary operator @ with an operand of a type whose 6117 // cv-unqualified version is T1, and for a binary operator @ with 6118 // a left operand of a type whose cv-unqualified version is T1 and 6119 // a right operand of a type whose cv-unqualified version is T2, 6120 // three sets of candidate functions, designated member 6121 // candidates, non-member candidates and built-in candidates, are 6122 // constructed as follows: 6123 QualType T1 = Args[0]->getType(); 6124 6125 // -- If T1 is a complete class type or a class currently being 6126 // defined, the set of member candidates is the result of the 6127 // qualified lookup of T1::operator@ (13.3.1.1.1); otherwise, 6128 // the set of member candidates is empty. 6129 if (const RecordType *T1Rec = T1->getAs<RecordType>()) { 6130 // Complete the type if it can be completed. 6131 RequireCompleteType(OpLoc, T1, 0); 6132 // If the type is neither complete nor being defined, bail out now. 6133 if (!T1Rec->getDecl()->getDefinition()) 6134 return; 6135 6136 LookupResult Operators(*this, OpName, OpLoc, LookupOrdinaryName); 6137 LookupQualifiedName(Operators, T1Rec->getDecl()); 6138 Operators.suppressDiagnostics(); 6139 6140 for (LookupResult::iterator Oper = Operators.begin(), 6141 OperEnd = Operators.end(); 6142 Oper != OperEnd; 6143 ++Oper) 6144 AddMethodCandidate(Oper.getPair(), Args[0]->getType(), 6145 Args[0]->Classify(Context), 6146 Args.slice(1), 6147 CandidateSet, 6148 /* SuppressUserConversions = */ false); 6149 } 6150 } 6151 6152 /// AddBuiltinCandidate - Add a candidate for a built-in 6153 /// operator. ResultTy and ParamTys are the result and parameter types 6154 /// of the built-in candidate, respectively. Args and NumArgs are the 6155 /// arguments being passed to the candidate. IsAssignmentOperator 6156 /// should be true when this built-in candidate is an assignment 6157 /// operator. NumContextualBoolArguments is the number of arguments 6158 /// (at the beginning of the argument list) that will be contextually 6159 /// converted to bool. 6160 void Sema::AddBuiltinCandidate(QualType ResultTy, QualType *ParamTys, 6161 ArrayRef<Expr *> Args, 6162 OverloadCandidateSet& CandidateSet, 6163 bool IsAssignmentOperator, 6164 unsigned NumContextualBoolArguments) { 6165 // Overload resolution is always an unevaluated context. 6166 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); 6167 6168 // Add this candidate 6169 OverloadCandidate &Candidate = CandidateSet.addCandidate(Args.size()); 6170 Candidate.FoundDecl = DeclAccessPair::make(0, AS_none); 6171 Candidate.Function = 0; 6172 Candidate.IsSurrogate = false; 6173 Candidate.IgnoreObjectArgument = false; 6174 Candidate.BuiltinTypes.ResultTy = ResultTy; 6175 for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) 6176 Candidate.BuiltinTypes.ParamTypes[ArgIdx] = ParamTys[ArgIdx]; 6177 6178 // Determine the implicit conversion sequences for each of the 6179 // arguments. 6180 Candidate.Viable = true; 6181 Candidate.ExplicitCallArguments = Args.size(); 6182 for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) { 6183 // C++ [over.match.oper]p4: 6184 // For the built-in assignment operators, conversions of the 6185 // left operand are restricted as follows: 6186 // -- no temporaries are introduced to hold the left operand, and 6187 // -- no user-defined conversions are applied to the left 6188 // operand to achieve a type match with the left-most 6189 // parameter of a built-in candidate. 6190 // 6191 // We block these conversions by turning off user-defined 6192 // conversions, since that is the only way that initialization of 6193 // a reference to a non-class type can occur from something that 6194 // is not of the same type. 6195 if (ArgIdx < NumContextualBoolArguments) { 6196 assert(ParamTys[ArgIdx] == Context.BoolTy && 6197 "Contextual conversion to bool requires bool type"); 6198 Candidate.Conversions[ArgIdx] 6199 = TryContextuallyConvertToBool(*this, Args[ArgIdx]); 6200 } else { 6201 Candidate.Conversions[ArgIdx] 6202 = TryCopyInitialization(*this, Args[ArgIdx], ParamTys[ArgIdx], 6203 ArgIdx == 0 && IsAssignmentOperator, 6204 /*InOverloadResolution=*/false, 6205 /*AllowObjCWritebackConversion=*/ 6206 getLangOpts().ObjCAutoRefCount); 6207 } 6208 if (Candidate.Conversions[ArgIdx].isBad()) { 6209 Candidate.Viable = false; 6210 Candidate.FailureKind = ovl_fail_bad_conversion; 6211 break; 6212 } 6213 } 6214 } 6215 6216 namespace { 6217 6218 /// BuiltinCandidateTypeSet - A set of types that will be used for the 6219 /// candidate operator functions for built-in operators (C++ 6220 /// [over.built]). The types are separated into pointer types and 6221 /// enumeration types. 6222 class BuiltinCandidateTypeSet { 6223 /// TypeSet - A set of types. 6224 typedef llvm::SmallPtrSet<QualType, 8> TypeSet; 6225 6226 /// PointerTypes - The set of pointer types that will be used in the 6227 /// built-in candidates. 6228 TypeSet PointerTypes; 6229 6230 /// MemberPointerTypes - The set of member pointer types that will be 6231 /// used in the built-in candidates. 6232 TypeSet MemberPointerTypes; 6233 6234 /// EnumerationTypes - The set of enumeration types that will be 6235 /// used in the built-in candidates. 6236 TypeSet EnumerationTypes; 6237 6238 /// \brief The set of vector types that will be used in the built-in 6239 /// candidates. 6240 TypeSet VectorTypes; 6241 6242 /// \brief A flag indicating non-record types are viable candidates 6243 bool HasNonRecordTypes; 6244 6245 /// \brief A flag indicating whether either arithmetic or enumeration types 6246 /// were present in the candidate set. 6247 bool HasArithmeticOrEnumeralTypes; 6248 6249 /// \brief A flag indicating whether the nullptr type was present in the 6250 /// candidate set. 6251 bool HasNullPtrType; 6252 6253 /// Sema - The semantic analysis instance where we are building the 6254 /// candidate type set. 6255 Sema &SemaRef; 6256 6257 /// Context - The AST context in which we will build the type sets. 6258 ASTContext &Context; 6259 6260 bool AddPointerWithMoreQualifiedTypeVariants(QualType Ty, 6261 const Qualifiers &VisibleQuals); 6262 bool AddMemberPointerWithMoreQualifiedTypeVariants(QualType Ty); 6263 6264 public: 6265 /// iterator - Iterates through the types that are part of the set. 6266 typedef TypeSet::iterator iterator; 6267 6268 BuiltinCandidateTypeSet(Sema &SemaRef) 6269 : HasNonRecordTypes(false), 6270 HasArithmeticOrEnumeralTypes(false), 6271 HasNullPtrType(false), 6272 SemaRef(SemaRef), 6273 Context(SemaRef.Context) { } 6274 6275 void AddTypesConvertedFrom(QualType Ty, 6276 SourceLocation Loc, 6277 bool AllowUserConversions, 6278 bool AllowExplicitConversions, 6279 const Qualifiers &VisibleTypeConversionsQuals); 6280 6281 /// pointer_begin - First pointer type found; 6282 iterator pointer_begin() { return PointerTypes.begin(); } 6283 6284 /// pointer_end - Past the last pointer type found; 6285 iterator pointer_end() { return PointerTypes.end(); } 6286 6287 /// member_pointer_begin - First member pointer type found; 6288 iterator member_pointer_begin() { return MemberPointerTypes.begin(); } 6289 6290 /// member_pointer_end - Past the last member pointer type found; 6291 iterator member_pointer_end() { return MemberPointerTypes.end(); } 6292 6293 /// enumeration_begin - First enumeration type found; 6294 iterator enumeration_begin() { return EnumerationTypes.begin(); } 6295 6296 /// enumeration_end - Past the last enumeration type found; 6297 iterator enumeration_end() { return EnumerationTypes.end(); } 6298 6299 iterator vector_begin() { return VectorTypes.begin(); } 6300 iterator vector_end() { return VectorTypes.end(); } 6301 6302 bool hasNonRecordTypes() { return HasNonRecordTypes; } 6303 bool hasArithmeticOrEnumeralTypes() { return HasArithmeticOrEnumeralTypes; } 6304 bool hasNullPtrType() const { return HasNullPtrType; } 6305 }; 6306 6307 } // end anonymous namespace 6308 6309 /// AddPointerWithMoreQualifiedTypeVariants - Add the pointer type @p Ty to 6310 /// the set of pointer types along with any more-qualified variants of 6311 /// that type. For example, if @p Ty is "int const *", this routine 6312 /// will add "int const *", "int const volatile *", "int const 6313 /// restrict *", and "int const volatile restrict *" to the set of 6314 /// pointer types. Returns true if the add of @p Ty itself succeeded, 6315 /// false otherwise. 6316 /// 6317 /// FIXME: what to do about extended qualifiers? 6318 bool 6319 BuiltinCandidateTypeSet::AddPointerWithMoreQualifiedTypeVariants(QualType Ty, 6320 const Qualifiers &VisibleQuals) { 6321 6322 // Insert this type. 6323 if (!PointerTypes.insert(Ty)) 6324 return false; 6325 6326 QualType PointeeTy; 6327 const PointerType *PointerTy = Ty->