1 //===- Overload.h - C++ Overloading -----------------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file defines the data structures and types used in C++ 10 // overload resolution. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_CLANG_SEMA_OVERLOAD_H 15 #define LLVM_CLANG_SEMA_OVERLOAD_H 16 17 #include "clang/AST/Decl.h" 18 #include "clang/AST/DeclAccessPair.h" 19 #include "clang/AST/DeclBase.h" 20 #include "clang/AST/DeclCXX.h" 21 #include "clang/AST/DeclTemplate.h" 22 #include "clang/AST/Expr.h" 23 #include "clang/AST/Type.h" 24 #include "clang/Basic/LLVM.h" 25 #include "clang/Basic/SourceLocation.h" 26 #include "clang/Sema/SemaFixItUtils.h" 27 #include "clang/Sema/TemplateDeduction.h" 28 #include "llvm/ADT/ArrayRef.h" 29 #include "llvm/ADT/None.h" 30 #include "llvm/ADT/STLExtras.h" 31 #include "llvm/ADT/SmallPtrSet.h" 32 #include "llvm/ADT/SmallVector.h" 33 #include "llvm/ADT/StringRef.h" 34 #include "llvm/Support/AlignOf.h" 35 #include "llvm/Support/Allocator.h" 36 #include "llvm/Support/Casting.h" 37 #include "llvm/Support/ErrorHandling.h" 38 #include <cassert> 39 #include <cstddef> 40 #include <cstdint> 41 #include <utility> 42 43 namespace clang { 44 45 class APValue; 46 class ASTContext; 47 class Sema; 48 49 /// OverloadingResult - Capture the result of performing overload 50 /// resolution. 51 enum OverloadingResult { 52 /// Overload resolution succeeded. 53 OR_Success, 54 55 /// No viable function found. 56 OR_No_Viable_Function, 57 58 /// Ambiguous candidates found. 59 OR_Ambiguous, 60 61 /// Succeeded, but refers to a deleted function. 62 OR_Deleted 63 }; 64 65 enum OverloadCandidateDisplayKind { 66 /// Requests that all candidates be shown. Viable candidates will 67 /// be printed first. 68 OCD_AllCandidates, 69 70 /// Requests that only viable candidates be shown. 71 OCD_ViableCandidates, 72 73 /// Requests that only tied-for-best candidates be shown. 74 OCD_AmbiguousCandidates 75 }; 76 77 /// The parameter ordering that will be used for the candidate. This is 78 /// used to represent C++20 binary operator rewrites that reverse the order 79 /// of the arguments. If the parameter ordering is Reversed, the Args list is 80 /// reversed (but obviously the ParamDecls for the function are not). 81 /// 82 /// After forming an OverloadCandidate with reversed parameters, the list 83 /// of conversions will (as always) be indexed by argument, so will be 84 /// in reverse parameter order. 85 enum class OverloadCandidateParamOrder : char { Normal, Reversed }; 86 87 /// The kinds of rewrite we perform on overload candidates. Note that the 88 /// values here are chosen to serve as both bitflags and as a rank (lower 89 /// values are preferred by overload resolution). 90 enum OverloadCandidateRewriteKind : unsigned { 91 /// Candidate is not a rewritten candidate. 92 CRK_None = 0x0, 93 94 /// Candidate is a rewritten candidate with a different operator name. 95 CRK_DifferentOperator = 0x1, 96 97 /// Candidate is a rewritten candidate with a reversed order of parameters. 98 CRK_Reversed = 0x2, 99 }; 100 101 /// ImplicitConversionKind - The kind of implicit conversion used to 102 /// convert an argument to a parameter's type. The enumerator values 103 /// match with the table titled 'Conversions' in [over.ics.scs] and are listed 104 /// such that better conversion kinds have smaller values. 105 enum ImplicitConversionKind { 106 /// Identity conversion (no conversion) 107 ICK_Identity = 0, 108 109 /// Lvalue-to-rvalue conversion (C++ [conv.lval]) 110 ICK_Lvalue_To_Rvalue, 111 112 /// Array-to-pointer conversion (C++ [conv.array]) 113 ICK_Array_To_Pointer, 114 115 /// Function-to-pointer (C++ [conv.array]) 116 ICK_Function_To_Pointer, 117 118 /// Function pointer conversion (C++17 [conv.fctptr]) 119 ICK_Function_Conversion, 120 121 /// Qualification conversions (C++ [conv.qual]) 122 ICK_Qualification, 123 124 /// Integral promotions (C++ [conv.prom]) 125 ICK_Integral_Promotion, 126 127 /// Floating point promotions (C++ [conv.fpprom]) 128 ICK_Floating_Promotion, 129 130 /// Complex promotions (Clang extension) 131 ICK_Complex_Promotion, 132 133 /// Integral conversions (C++ [conv.integral]) 134 ICK_Integral_Conversion, 135 136 /// Floating point conversions (C++ [conv.double] 137 ICK_Floating_Conversion, 138 139 /// Complex conversions (C99 6.3.1.6) 140 ICK_Complex_Conversion, 141 142 /// Floating-integral conversions (C++ [conv.fpint]) 143 ICK_Floating_Integral, 144 145 /// Pointer conversions (C++ [conv.ptr]) 146 ICK_Pointer_Conversion, 147 148 /// Pointer-to-member conversions (C++ [conv.mem]) 149 ICK_Pointer_Member, 150 151 /// Boolean conversions (C++ [conv.bool]) 152 ICK_Boolean_Conversion, 153 154 /// Conversions between compatible types in C99 155 ICK_Compatible_Conversion, 156 157 /// Derived-to-base (C++ [over.best.ics]) 158 ICK_Derived_To_Base, 159 160 /// Vector conversions 161 ICK_Vector_Conversion, 162 163 /// A vector splat from an arithmetic type 164 ICK_Vector_Splat, 165 166 /// Complex-real conversions (C99 6.3.1.7) 167 ICK_Complex_Real, 168 169 /// Block Pointer conversions 170 ICK_Block_Pointer_Conversion, 171 172 /// Transparent Union Conversions 173 ICK_TransparentUnionConversion, 174 175 /// Objective-C ARC writeback conversion 176 ICK_Writeback_Conversion, 177 178 /// Zero constant to event (OpenCL1.2 6.12.10) 179 ICK_Zero_Event_Conversion, 180 181 /// Zero constant to queue 182 ICK_Zero_Queue_Conversion, 183 184 /// Conversions allowed in C, but not C++ 185 ICK_C_Only_Conversion, 186 187 /// C-only conversion between pointers with incompatible types 188 ICK_Incompatible_Pointer_Conversion, 189 190 /// The number of conversion kinds 191 ICK_Num_Conversion_Kinds, 192 }; 193 194 /// ImplicitConversionRank - The rank of an implicit conversion 195 /// kind. The enumerator values match with Table 9 of (C++ 196 /// 13.3.3.1.1) and are listed such that better conversion ranks 197 /// have smaller values. 198 enum ImplicitConversionRank { 199 /// Exact Match 200 ICR_Exact_Match = 0, 201 202 /// Promotion 203 ICR_Promotion, 204 205 /// Conversion 206 ICR_Conversion, 207 208 /// OpenCL Scalar Widening 209 ICR_OCL_Scalar_Widening, 210 211 /// Complex <-> Real conversion 212 ICR_Complex_Real_Conversion, 213 214 /// ObjC ARC writeback conversion 215 ICR_Writeback_Conversion, 216 217 /// Conversion only allowed in the C standard (e.g. void* to char*). 218 ICR_C_Conversion, 219 220 /// Conversion not allowed by the C standard, but that we accept as an 221 /// extension anyway. 222 ICR_C_Conversion_Extension 223 }; 224 225 ImplicitConversionRank GetConversionRank(ImplicitConversionKind Kind); 226 227 /// NarrowingKind - The kind of narrowing conversion being performed by a 228 /// standard conversion sequence according to C++11 [dcl.init.list]p7. 229 enum NarrowingKind { 230 /// Not a narrowing conversion. 231 NK_Not_Narrowing, 232 233 /// A narrowing conversion by virtue of the source and destination types. 234 NK_Type_Narrowing, 235 236 /// A narrowing conversion, because a constant expression got narrowed. 237 NK_Constant_Narrowing, 238 239 /// A narrowing conversion, because a non-constant-expression variable might 240 /// have got narrowed. 241 NK_Variable_Narrowing, 242 243 /// Cannot tell whether this is a narrowing conversion because the 244 /// expression is value-dependent. 245 NK_Dependent_Narrowing, 246 }; 247 248 /// StandardConversionSequence - represents a standard conversion 249 /// sequence (C++ 13.3.3.1.1). A standard conversion sequence 250 /// contains between zero and three conversions. If a particular 251 /// conversion is not needed, it will be set to the identity conversion 252 /// (ICK_Identity). Note that the three conversions are 253 /// specified as separate members (rather than in an array) so that 254 /// we can keep the size of a standard conversion sequence to a 255 /// single word. 256 class StandardConversionSequence { 257 public: 258 /// First -- The first conversion can be an lvalue-to-rvalue 259 /// conversion, array-to-pointer conversion, or 260 /// function-to-pointer conversion. 261 ImplicitConversionKind First : 8; 262 263 /// Second - The second conversion can be an integral promotion, 264 /// floating point promotion, integral conversion, floating point 265 /// conversion, floating-integral conversion, pointer conversion, 266 /// pointer-to-member conversion, or boolean conversion. 267 ImplicitConversionKind Second : 8; 268 269 /// Third - The third conversion can be a qualification conversion 270 /// or a function conversion. 271 ImplicitConversionKind Third : 8; 272 273 /// Whether this is the deprecated conversion of a 274 /// string literal to a pointer to non-const character data 275 /// (C++ 4.2p2). 276 unsigned DeprecatedStringLiteralToCharPtr : 1; 277 278 /// Whether the qualification conversion involves a change in the 279 /// Objective-C lifetime (for automatic reference counting). 280 unsigned QualificationIncludesObjCLifetime : 1; 281 282 /// IncompatibleObjC - Whether this is an Objective-C conversion 283 /// that we should warn about (if we actually use it). 284 unsigned IncompatibleObjC : 1; 285 286 /// ReferenceBinding - True when this is a reference binding 287 /// (C++ [over.ics.ref]). 288 unsigned ReferenceBinding : 1; 289 290 /// DirectBinding - True when this is a reference binding that is a 291 /// direct binding (C++ [dcl.init.ref]). 292 unsigned DirectBinding : 1; 293 294 /// Whether this is an lvalue reference binding (otherwise, it's 295 /// an rvalue reference binding). 296 unsigned IsLvalueReference : 1; 297 298 /// Whether we're binding to a function lvalue. 299 unsigned BindsToFunctionLvalue : 1; 300 301 /// Whether we're binding to an rvalue. 302 unsigned BindsToRvalue : 1; 303 304 /// Whether this binds an implicit object argument to a 305 /// non-static member function without a ref-qualifier. 306 unsigned BindsImplicitObjectArgumentWithoutRefQualifier : 1; 307 308 /// Whether this binds a reference to an object with a different 309 /// Objective-C lifetime qualifier. 310 unsigned ObjCLifetimeConversionBinding : 1; 311 312 /// FromType - The type that this conversion is converting 313 /// from. This is an opaque pointer that can be translated into a 314 /// QualType. 315 void *FromTypePtr; 316 317 /// ToType - The types that this conversion is converting to in 318 /// each step. This is an opaque pointer that can be translated 319 /// into a QualType. 320 void *ToTypePtrs[3]; 321 322 /// CopyConstructor - The copy constructor that is used to perform 323 /// this conversion, when the conversion is actually just the 324 /// initialization of an object via copy constructor. Such 325 /// conversions are either identity conversions or derived-to-base 326 /// conversions. 327 CXXConstructorDecl *CopyConstructor; 328 DeclAccessPair FoundCopyConstructor; 329 setFromType(QualType T)330 void setFromType(QualType T) { FromTypePtr = T.getAsOpaquePtr(); } 331 setToType(unsigned Idx,QualType T)332 void setToType(unsigned Idx, QualType T) { 333 assert(Idx < 3 && "To type index is out of range"); 334 ToTypePtrs[Idx] = T.getAsOpaquePtr(); 335 } 336 setAllToTypes(QualType T)337 void setAllToTypes(QualType T) { 338 ToTypePtrs[0] = T.getAsOpaquePtr(); 339 ToTypePtrs[1] = ToTypePtrs[0]; 340 ToTypePtrs[2] = ToTypePtrs[0]; 341 } 342 getFromType()343 QualType getFromType() const { 344 return QualType::getFromOpaquePtr(FromTypePtr); 345 } 346 getToType(unsigned Idx)347 QualType getToType(unsigned Idx) const { 348 assert(Idx < 3 && "To type index is out of range"); 349 return QualType::getFromOpaquePtr(ToTypePtrs[Idx]); 350 } 351 352 void setAsIdentityConversion(); 353 isIdentityConversion()354 bool isIdentityConversion() const { 355 return Second == ICK_Identity && Third == ICK_Identity; 356 } 357 358 ImplicitConversionRank getRank() const; 359 NarrowingKind 360 getNarrowingKind(ASTContext &Context, const Expr *Converted, 361 APValue &ConstantValue, QualType &ConstantType, 362 bool IgnoreFloatToIntegralConversion = false) const; 363 bool isPointerConversionToBool() const; 364 bool isPointerConversionToVoidPointer(ASTContext& Context) const; 365 void dump() const; 366 }; 367 368 /// UserDefinedConversionSequence - Represents a user-defined 369 /// conversion sequence (C++ 13.3.3.1.2). 370 struct UserDefinedConversionSequence { 371 /// Represents the standard conversion that occurs before 372 /// the actual user-defined conversion. 373 /// 374 /// C++11 13.3.3.1.2p1: 375 /// If the user-defined conversion is specified by a constructor 376 /// (12.3.1), the initial standard conversion sequence converts 377 /// the source type to the type required by the argument of the 378 /// constructor. If the user-defined conversion is specified by 379 /// a conversion function (12.3.2), the initial standard 380 /// conversion sequence converts the source type to the implicit 381 /// object parameter of the conversion function. 382 StandardConversionSequence Before; 383 384 /// EllipsisConversion - When this is true, it means user-defined 385 /// conversion sequence starts with a ... (ellipsis) conversion, instead of 386 /// a standard conversion. In this case, 'Before' field must be ignored. 387 // FIXME. I much rather put this as the first field. But there seems to be 388 // a gcc code gen. bug which causes a crash in a test. Putting it here seems 389 // to work around the crash. 390 bool EllipsisConversion : 1; 391 392 /// HadMultipleCandidates - When this is true, it means that the 393 /// conversion function was resolved from an overloaded set having 394 /// size greater than 1. 395 bool HadMultipleCandidates : 1; 396 397 /// After - Represents the standard conversion that occurs after 398 /// the actual user-defined conversion. 399 StandardConversionSequence After; 400 401 /// ConversionFunction - The function that will perform the 402 /// user-defined conversion. Null if the conversion is an 403 /// aggregate initialization from an initializer list. 404 FunctionDecl* ConversionFunction; 405 406 /// The declaration that we found via name lookup, which might be 407 /// the same as \c ConversionFunction or it might be a using declaration 408 /// that refers to \c ConversionFunction. 409 DeclAccessPair FoundConversionFunction; 410 411 void dump() const; 412 }; 413 414 /// Represents an ambiguous user-defined conversion sequence. 415 struct AmbiguousConversionSequence { 416 using ConversionSet = 417 SmallVector<std::pair<NamedDecl *, FunctionDecl *>, 4>; 418 419 void *FromTypePtr; 420 void *ToTypePtr; 421 char Buffer[sizeof(ConversionSet)]; 422 getFromTypeAmbiguousConversionSequence423 QualType getFromType() const { 424 return QualType::getFromOpaquePtr(FromTypePtr); 425 } 426 getToTypeAmbiguousConversionSequence427 QualType getToType() const { 428 return QualType::getFromOpaquePtr(ToTypePtr); 429 } 430 setFromTypeAmbiguousConversionSequence431 void setFromType(QualType T) { FromTypePtr = T.getAsOpaquePtr(); } setToTypeAmbiguousConversionSequence432 void setToType(QualType T) { ToTypePtr = T.getAsOpaquePtr(); } 433 conversionsAmbiguousConversionSequence434 ConversionSet &conversions() { 435 return *reinterpret_cast<ConversionSet*>(Buffer); 436 } 437 conversionsAmbiguousConversionSequence438 const ConversionSet &conversions() const { 439 return *reinterpret_cast<const ConversionSet*>(Buffer); 440 } 441 addConversionAmbiguousConversionSequence442 void addConversion(NamedDecl *Found, FunctionDecl *D) { 443 conversions().push_back(std::make_pair(Found, D)); 444 } 445 446 using iterator = ConversionSet::iterator; 447 beginAmbiguousConversionSequence448 iterator begin() { return conversions().begin(); } endAmbiguousConversionSequence449 iterator end() { return conversions().end(); } 450 451 using const_iterator = ConversionSet::const_iterator; 452 beginAmbiguousConversionSequence453 const_iterator begin() const { return conversions().begin(); } endAmbiguousConversionSequence454 const_iterator end() const { return conversions().end(); } 455 456 void construct(); 457 void destruct(); 458 void copyFrom(const AmbiguousConversionSequence &); 459 }; 460 461 /// BadConversionSequence - Records information about an invalid 462 /// conversion sequence. 463 struct BadConversionSequence { 464 enum FailureKind { 465 no_conversion, 466 unrelated_class, 467 bad_qualifiers, 468 lvalue_ref_to_rvalue, 469 rvalue_ref_to_lvalue 470 }; 471 472 // This can be null, e.g. for implicit object arguments. 473 Expr *FromExpr; 474 475 FailureKind Kind; 476 477 private: 478 // The type we're converting from (an opaque QualType). 479 void *FromTy; 480 481 // The type we're converting to (an opaque QualType). 482 void *ToTy; 483 484 public: initBadConversionSequence485 void init(FailureKind K, Expr *From, QualType To) { 486 init(K, From->getType(), To); 487 FromExpr = From; 488 } 489 initBadConversionSequence490 void init(FailureKind K, QualType From, QualType To) { 491 Kind = K; 492 FromExpr = nullptr; 493 setFromType(From); 494 setToType(To); 495 } 496 getFromTypeBadConversionSequence497 QualType getFromType() const { return QualType::getFromOpaquePtr(FromTy); } getToTypeBadConversionSequence498 QualType getToType() const { return QualType::getFromOpaquePtr(ToTy); } 499 setFromExprBadConversionSequence500 void setFromExpr(Expr *E) { 501 FromExpr = E; 502 setFromType(E->getType()); 503 } 504 setFromTypeBadConversionSequence505 void setFromType(QualType T) { FromTy = T.getAsOpaquePtr(); } setToTypeBadConversionSequence506 void setToType(QualType T) { ToTy = T.getAsOpaquePtr(); } 507 }; 508 509 /// ImplicitConversionSequence - Represents an implicit conversion 510 /// sequence, which may be a standard conversion sequence 511 /// (C++ 13.3.3.1.1), user-defined conversion sequence (C++ 13.3.3.1.2), 512 /// or an ellipsis conversion sequence (C++ 13.3.3.1.3). 513 class ImplicitConversionSequence { 514 public: 515 /// Kind - The kind of implicit conversion sequence. BadConversion 516 /// specifies that there is no conversion from the source type to 517 /// the target type. AmbiguousConversion represents the unique 518 /// ambiguous conversion (C++0x [over.best.ics]p10). 519 enum Kind { 520 StandardConversion = 0, 521 UserDefinedConversion, 522 AmbiguousConversion, 523 EllipsisConversion, 524 BadConversion 525 }; 526 527 enum SetKindAction { 528 MemsetToZero, 529 KeepState, 530 }; 531 532 private: 533 enum { 534 Uninitialized = BadConversion + 1 535 }; 536 537 /// ConversionKind - The kind of implicit conversion sequence. 538 unsigned ConversionKind : 30; 539 540 /// Whether the target is really a std::initializer_list, and the 541 /// sequence only represents the worst element conversion. 542 unsigned StdInitializerListElement : 1; 543 setKind(Kind K)544 void setKind(Kind K) { 545 destruct(); 546 ConversionKind = K; 547 } 548 destruct()549 void destruct() { 550 if (ConversionKind == AmbiguousConversion) Ambiguous.destruct(); 551 } 552 553 public: 554 union { 555 /// When ConversionKind == StandardConversion, provides the 556 /// details of the standard conversion sequence. 557 StandardConversionSequence Standard; 558 559 /// When ConversionKind == UserDefinedConversion, provides the 560 /// details of the user-defined conversion sequence. 561 UserDefinedConversionSequence UserDefined; 562 563 /// When ConversionKind == AmbiguousConversion, provides the 564 /// details of the ambiguous conversion. 565 AmbiguousConversionSequence Ambiguous; 566 567 /// When ConversionKind == BadConversion, provides the details 568 /// of the bad conversion. 569 BadConversionSequence Bad; 570 }; 571 ImplicitConversionSequence()572 ImplicitConversionSequence() 573 : ConversionKind(Uninitialized), StdInitializerListElement(false) { 574 Standard.setAsIdentityConversion(); 575 } 576 ImplicitConversionSequence(const ImplicitConversionSequence & Other)577 ImplicitConversionSequence(const ImplicitConversionSequence &Other) 578 : ConversionKind(Other.ConversionKind), 579 StdInitializerListElement(Other.StdInitializerListElement) { 580 switch (ConversionKind) { 581 case Uninitialized: break; 582 case StandardConversion: Standard = Other.Standard; break; 583 case UserDefinedConversion: UserDefined = Other.UserDefined; break; 584 case AmbiguousConversion: Ambiguous.copyFrom(Other.Ambiguous); break; 585 case EllipsisConversion: break; 586 case BadConversion: Bad = Other.Bad; break; 587 } 588 } 589 590 ImplicitConversionSequence & 591 operator=(const ImplicitConversionSequence &Other) { 592 destruct(); 593 new (this) ImplicitConversionSequence(Other); 594 return *this; 595 } 596 ~ImplicitConversionSequence()597 ~ImplicitConversionSequence() { 598 destruct(); 599 } 600 getKind()601 Kind getKind() const { 602 assert(isInitialized() && "querying uninitialized conversion"); 603 return Kind(ConversionKind); 604 } 605 606 /// Return a ranking of the implicit conversion sequence 607 /// kind, where smaller ranks represent better conversion 608 /// sequences. 609 /// 610 /// In particular, this routine gives user-defined conversion 611 /// sequences and ambiguous conversion sequences the same rank, 612 /// per C++ [over.best.ics]p10. getKindRank()613 unsigned getKindRank() const { 614 switch (getKind()) { 615 case StandardConversion: 616 return 0; 617 618 case UserDefinedConversion: 619 case AmbiguousConversion: 620 return 1; 621 622 case EllipsisConversion: 623 return 2; 624 625 case BadConversion: 626 return 3; 627 } 628 629 llvm_unreachable("Invalid ImplicitConversionSequence::Kind!"); 630 } 631 isBad()632 bool isBad() const { return getKind() == BadConversion; } isStandard()633 bool isStandard() const { return getKind() == StandardConversion; } isEllipsis()634 bool isEllipsis() const { return getKind() == EllipsisConversion; } isAmbiguous()635 bool isAmbiguous() const { return getKind() == AmbiguousConversion; } isUserDefined()636 bool isUserDefined() const { return getKind() == UserDefinedConversion; } isFailure()637 bool isFailure() const { return isBad() || isAmbiguous(); } 638 639 /// Determines whether this conversion sequence has been 640 /// initialized. Most operations should never need to query 641 /// uninitialized conversions and should assert as above. isInitialized()642 bool isInitialized() const { return ConversionKind != Uninitialized; } 643 644 /// Sets this sequence as a bad conversion for an explicit argument. setBad(BadConversionSequence::FailureKind Failure,Expr * FromExpr,QualType ToType)645 void setBad(BadConversionSequence::FailureKind Failure, 646 Expr *FromExpr, QualType ToType) { 647 setKind(BadConversion); 648 Bad.init(Failure, FromExpr, ToType); 649 } 650 651 /// Sets this sequence as a bad conversion for an implicit argument. setBad(BadConversionSequence::FailureKind Failure,QualType FromType,QualType ToType)652 void setBad(BadConversionSequence::FailureKind Failure, 653 QualType FromType, QualType ToType) { 654 setKind(BadConversion); 655 Bad.init(Failure, FromType, ToType); 656 } 657 setStandard(SetKindAction Action)658 void setStandard(SetKindAction Action) { 659 setKind(StandardConversion); 660 if (Action == MemsetToZero) 661 memset(&Standard, 0, sizeof(Standard)); 662 } setStandard(const StandardConversionSequence & NewSeq)663 void setStandard(const StandardConversionSequence& NewSeq) { 664 setKind(StandardConversion); 665 Standard = NewSeq; 666 } setEllipsis()667 void setEllipsis() { setKind(EllipsisConversion); } setUserDefined()668 void setUserDefined() { setKind(UserDefinedConversion); } 669 setAmbiguous()670 void setAmbiguous() { 671 if (ConversionKind == AmbiguousConversion) return; 672 ConversionKind = AmbiguousConversion; 673 Ambiguous.construct(); 674 } 675 setAsIdentityConversion(QualType T)676 void setAsIdentityConversion(QualType T) { 677 setStandard(MemsetToZero); // XXXAR: not sure this is correct 678 Standard.setAsIdentityConversion(); 679 Standard.setFromType(T); 680 Standard.setAllToTypes(T); 681 } 682 683 /// Whether the target is really a std::initializer_list, and the 684 /// sequence only represents the worst element conversion. isStdInitializerListElement()685 bool isStdInitializerListElement() const { 686 return StdInitializerListElement; 687 } 688 689 void setStdInitializerListElement(bool V = true) { 690 StdInitializerListElement = V; 691 } 692 693 /// Form an "implicit" conversion sequence from nullptr_t to bool, for a 694 /// direct-initialization of a bool object from nullptr_t. getNullptrToBool(QualType SourceType,QualType DestType,bool NeedLValToRVal)695 static ImplicitConversionSequence getNullptrToBool(QualType SourceType, 696 QualType DestType, 697 bool NeedLValToRVal) { 698 ImplicitConversionSequence ICS; 699 ICS.setStandard(MemsetToZero); 700 ICS.Standard.setAsIdentityConversion(); 701 ICS.Standard.setFromType(SourceType); 702 if (NeedLValToRVal) 703 ICS.Standard.First = ICK_Lvalue_To_Rvalue; 704 ICS.Standard.setToType(0, SourceType); 705 ICS.Standard.Second = ICK_Boolean_Conversion; 706 ICS.Standard.setToType(1, DestType); 707 ICS.Standard.setToType(2, DestType); 708 return ICS; 709 } 710 711 // The result of a comparison between implicit conversion 712 // sequences. Use Sema::CompareImplicitConversionSequences to 713 // actually perform the comparison. 714 enum CompareKind { 715 Better = -1, 716 Indistinguishable = 0, 717 Worse = 1 718 }; 719 720 void DiagnoseAmbiguousConversion(Sema &S, 721 SourceLocation CaretLoc, 722 const PartialDiagnostic &PDiag) const; 723 724 void dump() const; 725 }; 726 727 enum OverloadFailureKind { 728 ovl_fail_too_many_arguments, 729 ovl_fail_too_few_arguments, 730 ovl_fail_bad_conversion, 731 ovl_fail_bad_deduction, 732 733 /// This conversion candidate was not considered because it 734 /// duplicates the work of a trivial or derived-to-base 735 /// conversion. 736 ovl_fail_trivial_conversion, 737 738 /// This conversion candidate was not considered because it is 739 /// an illegal instantiation of a constructor temploid: it is 740 /// callable with one argument, we only have one argument, and 741 /// its first parameter type is exactly the type of the class. 742 /// 743 /// Defining such a constructor directly is illegal, and 744 /// template-argument deduction is supposed to ignore such 745 /// instantiations, but we can still get one with the right 746 /// kind of implicit instantiation. 747 ovl_fail_illegal_constructor, 748 749 /// This conversion candidate is not viable because its result 750 /// type is not implicitly convertible to the desired type. 751 ovl_fail_bad_final_conversion, 752 753 /// This conversion function template specialization candidate is not 754 /// viable because the final conversion was not an exact match. 755 ovl_fail_final_conversion_not_exact, 756 757 /// (CUDA) This candidate was not viable because the callee 758 /// was not accessible from the caller's target (i.e. host->device, 759 /// global->host, device->host). 760 ovl_fail_bad_target, 761 762 /// This candidate function was not viable because an enable_if 763 /// attribute disabled it. 764 ovl_fail_enable_if, 765 766 /// This candidate constructor or conversion function is explicit but 767 /// the context doesn't permit explicit functions. 768 ovl_fail_explicit, 769 770 /// This candidate was not viable because its address could not be taken. 771 ovl_fail_addr_not_available, 772 773 /// This candidate was not viable because its OpenCL extension is disabled. 774 ovl_fail_ext_disabled, 775 776 /// This inherited constructor is not viable because it would slice the 777 /// argument. 778 ovl_fail_inhctor_slice, 779 780 /// This candidate was not viable because it is a non-default multiversioned 781 /// function. 782 ovl_non_default_multiversion_function, 783 784 /// This constructor/conversion candidate fail due to an address space 785 /// mismatch between the object being constructed and the overload 786 /// candidate. 787 ovl_fail_object_addrspace_mismatch, 788 789 /// This candidate was not viable because its associated constraints were 790 /// not satisfied. 791 ovl_fail_constraints_not_satisfied, 792 }; 793 794 /// A list of implicit conversion sequences for the arguments of an 795 /// OverloadCandidate. 796 using ConversionSequenceList = 797 llvm::MutableArrayRef<ImplicitConversionSequence>; 798 799 /// OverloadCandidate - A single candidate in an overload set (C++ 13.3). 800 struct OverloadCandidate { 801 /// Function - The actual function that this candidate 802 /// represents. When NULL, this is a built-in candidate 803 /// (C++ [over.oper]) or a surrogate for a conversion to a 804 /// function pointer or reference (C++ [over.call.object]). 805 FunctionDecl *Function; 806 807 /// FoundDecl - The original declaration that was looked up / 808 /// invented / otherwise found, together with its access. 809 /// Might be a UsingShadowDecl or a FunctionTemplateDecl. 810 DeclAccessPair FoundDecl; 811 812 /// BuiltinParamTypes - Provides the parameter types of a built-in overload 813 /// candidate. Only valid when Function is NULL. 814 QualType BuiltinParamTypes[3]; 815 816 /// Surrogate - The conversion function for which this candidate 817 /// is a surrogate, but only if IsSurrogate is true. 818 CXXConversionDecl *Surrogate; 819 820 /// The conversion sequences used to convert the function arguments 821 /// to the function parameters. Note that these are indexed by argument, 822 /// so may not match the parameter order of Function. 823 ConversionSequenceList Conversions; 824 825 /// The FixIt hints which can be used to fix the Bad candidate. 826 ConversionFixItGenerator Fix; 827 828 /// Viable - True to indicate that this overload candidate is viable. 829 bool Viable : 1; 830 831 /// Whether this candidate is the best viable function, or tied for being 832 /// the best viable function. 833 /// 834 /// For an ambiguous overload resolution, indicates whether this candidate 835 /// was part of the ambiguity kernel: the minimal non-empty set of viable 836 /// candidates such that all elements of the ambiguity kernel are better 837 /// than all viable candidates not in the ambiguity kernel. 838 bool Best : 1; 839 840 /// IsSurrogate - True to indicate that this candidate is a 841 /// surrogate for a conversion to a function pointer or reference 842 /// (C++ [over.call.object]). 843 bool IsSurrogate : 1; 844 845 /// IgnoreObjectArgument - True to indicate that the first 846 /// argument's conversion, which for this function represents the 847 /// implicit object argument, should be ignored. This will be true 848 /// when the candidate is a static member function (where the 849 /// implicit object argument is just a placeholder) or a 850 /// non-static member function when the call doesn't have an 851 /// object argument. 852 bool IgnoreObjectArgument : 1; 853 854 /// True if the candidate was found using ADL. 855 CallExpr::ADLCallKind IsADLCandidate : 1; 856 857 /// Whether this is a rewritten candidate, and if so, of what kind? 858 unsigned RewriteKind : 2; 859 860 /// FailureKind - The reason why this candidate is not viable. 861 /// Actually an OverloadFailureKind. 862 unsigned char FailureKind; 863 864 /// The number of call arguments that were explicitly provided, 865 /// to be used while performing partial ordering of function templates. 866 unsigned ExplicitCallArguments; 867 868 union { 869 DeductionFailureInfo DeductionFailure; 870 871 /// FinalConversion - For a conversion function (where Function is 872 /// a CXXConversionDecl), the standard conversion that occurs 873 /// after the call to the overload candidate to convert the result 874 /// of calling the conversion function to the required type. 875 StandardConversionSequence FinalConversion; 876 }; 877 878 /// Get RewriteKind value in OverloadCandidateRewriteKind type (This 879 /// function is to workaround the spurious GCC bitfield enum warning) getRewriteKindOverloadCandidate880 OverloadCandidateRewriteKind getRewriteKind() const { 881 return static_cast<OverloadCandidateRewriteKind>(RewriteKind); 882 } 883 isReversedOverloadCandidate884 bool isReversed() const { return getRewriteKind() & CRK_Reversed; } 885 886 /// hasAmbiguousConversion - Returns whether this overload 887 /// candidate requires an ambiguous conversion or not. hasAmbiguousConversionOverloadCandidate888 bool hasAmbiguousConversion() const { 889 for (auto &C : Conversions) { 890 if (!C.isInitialized()) return false; 891 if (C.isAmbiguous()) return true; 892 } 893 return false; 894 } 895 TryToFixBadConversionOverloadCandidate896 bool TryToFixBadConversion(unsigned Idx, Sema &S) { 897 bool CanFix = Fix.tryToFixConversion( 898 Conversions[Idx].Bad.FromExpr, 899 Conversions[Idx].Bad.getFromType(), 900 Conversions[Idx].Bad.getToType(), S); 901 902 // If at least one conversion fails, the candidate cannot be fixed. 903 if (!CanFix) 904 Fix.clear(); 905 906 return CanFix; 907 } 908 getNumParamsOverloadCandidate909 unsigned getNumParams() const { 910 if (IsSurrogate) { 911 QualType STy = Surrogate->getConversionType(); 912 while (STy->isPointerType() || STy->isReferenceType()) 913 STy = STy->getPointeeType(); 914 return STy->castAs<FunctionProtoType>()->getNumParams(); 915 } 916 if (Function) 917 return Function->getNumParams(); 918 return ExplicitCallArguments; 919 } 920 921 private: 922 friend class OverloadCandidateSet; OverloadCandidateOverloadCandidate923 OverloadCandidate() 924 : IsSurrogate(false), IsADLCandidate(CallExpr::NotADL), RewriteKind(CRK_None) {} 925 }; 926 927 /// OverloadCandidateSet - A set of overload candidates, used in C++ 928 /// overload resolution (C++ 13.3). 929 class OverloadCandidateSet { 930 public: 931 enum CandidateSetKind { 932 /// Normal lookup. 933 CSK_Normal, 934 935 /// C++ [over.match.oper]: 936 /// Lookup of operator function candidates in a call using operator 937 /// syntax. Candidates that have no parameters of class type will be 938 /// skipped unless there is a parameter of (reference to) enum type and 939 /// the corresponding argument is of the same enum type. 940 CSK_Operator, 941 942 /// C++ [over.match.copy]: 943 /// Copy-initialization of an object of class type by user-defined 944 /// conversion. 945 CSK_InitByUserDefinedConversion, 946 947 /// C++ [over.match.ctor], [over.match.list] 948 /// Initialization of an object of class type by constructor, 949 /// using either a parenthesized or braced list of arguments. 950 CSK_InitByConstructor, 951 }; 952 953 /// Information about operator rewrites to consider when adding operator 954 /// functions to a candidate set. 955 struct OperatorRewriteInfo { OperatorRewriteInfoOperatorRewriteInfo956 OperatorRewriteInfo() 957 : OriginalOperator(OO_None), AllowRewrittenCandidates(false) {} OperatorRewriteInfoOperatorRewriteInfo958 OperatorRewriteInfo(OverloadedOperatorKind Op, bool AllowRewritten) 959 : OriginalOperator(Op), AllowRewrittenCandidates(AllowRewritten) {} 960 961 /// The original operator as written in the source. 962 OverloadedOperatorKind OriginalOperator; 963 /// Whether we should include rewritten candidates in the overload set. 964 bool AllowRewrittenCandidates; 965 966 /// Would use of this function result in a rewrite using a different 967 /// operator? isRewrittenOperatorOperatorRewriteInfo968 bool isRewrittenOperator(const FunctionDecl *FD) { 969 return OriginalOperator && 970 FD->getDeclName().getCXXOverloadedOperator() != OriginalOperator; 971 } 972 isAcceptableCandidateOperatorRewriteInfo973 bool isAcceptableCandidate(const FunctionDecl *FD) { 974 if (!OriginalOperator) 975 return true; 976 977 // For an overloaded operator, we can have candidates with a different 978 // name in our unqualified lookup set. Make sure we only consider the 979 // ones we're supposed to. 980 OverloadedOperatorKind OO = 981 FD->getDeclName().getCXXOverloadedOperator(); 982 return OO && (OO == OriginalOperator || 983 (AllowRewrittenCandidates && 984 OO == getRewrittenOverloadedOperator(OriginalOperator))); 985 } 986 987 /// Determine the kind of rewrite that should be performed for this 988 /// candidate. 989 OverloadCandidateRewriteKind getRewriteKindOperatorRewriteInfo990 getRewriteKind(const FunctionDecl *FD, OverloadCandidateParamOrder PO) { 991 OverloadCandidateRewriteKind CRK = CRK_None; 992 if (isRewrittenOperator(FD)) 993 CRK = OverloadCandidateRewriteKind(CRK | CRK_DifferentOperator); 994 if (PO == OverloadCandidateParamOrder::Reversed) 995 CRK = OverloadCandidateRewriteKind(CRK | CRK_Reversed); 996 return CRK; 997 } 998 999 /// Determines whether this operator could be implemented by a function 1000 /// with reversed parameter order. isReversibleOperatorRewriteInfo1001 bool isReversible() { 1002 return AllowRewrittenCandidates && OriginalOperator && 1003 (getRewrittenOverloadedOperator(OriginalOperator) != OO_None || 1004 shouldAddReversed(OriginalOperator)); 1005 } 1006 1007 /// Determine whether we should consider looking for and adding reversed 1008 /// candidates for operator Op. 1009 bool shouldAddReversed(OverloadedOperatorKind Op); 1010 1011 /// Determine whether we should add a rewritten candidate for \p FD with 1012 /// reversed parameter order. 1013 bool shouldAddReversed(ASTContext &Ctx, const FunctionDecl *FD); 1014 }; 1015 1016 private: 1017 SmallVector<OverloadCandidate, 16> Candidates; 1018 llvm::SmallPtrSet<uintptr_t, 16> Functions; 1019 1020 // Allocator for ConversionSequenceLists. We store the first few of these 1021 // inline to avoid allocation for small sets. 1022 llvm::BumpPtrAllocator SlabAllocator; 1023 1024 SourceLocation Loc; 1025 CandidateSetKind Kind; 1026 OperatorRewriteInfo RewriteInfo; 1027 1028 constexpr static unsigned NumInlineBytes = 1029 24 * sizeof(ImplicitConversionSequence); 1030 unsigned NumInlineBytesUsed = 0; 1031 alignas(void *) char InlineSpace[NumInlineBytes]; 1032 1033 // Address space of the object being constructed. 1034 LangAS DestAS = LangAS::Default; 1035 1036 /// If we have space, allocates from inline storage. Otherwise, allocates 1037 /// from the slab allocator. 1038 /// FIXME: It would probably be nice to have a SmallBumpPtrAllocator 1039 /// instead. 1040 /// FIXME: Now that this only allocates ImplicitConversionSequences, do we 1041 /// want to un-generalize this? 1042 template <typename T> slabAllocate(unsigned N)1043 T *slabAllocate(unsigned N) { 1044 // It's simpler if this doesn't need to consider alignment. 1045 static_assert(alignof(T) == alignof(void *), 1046 "Only works for pointer-aligned types."); 1047 static_assert(std::is_trivial<T>::value || 1048 std::is_same<ImplicitConversionSequence, T>::value, 1049 "Add destruction logic to OverloadCandidateSet::clear()."); 1050 1051 unsigned NBytes = sizeof(T) * N; 1052 if (NBytes > NumInlineBytes - NumInlineBytesUsed) 1053 return SlabAllocator.Allocate<T>(N); 1054 char *FreeSpaceStart = InlineSpace + NumInlineBytesUsed; 1055 assert(uintptr_t(FreeSpaceStart) % alignof(void *) == 0 && 1056 "Misaligned storage!"); 1057 1058 NumInlineBytesUsed += NBytes; 1059 return reinterpret_cast<T *>(FreeSpaceStart); 1060 } 1061 1062 void destroyCandidates(); 1063 1064 public: 1065 OverloadCandidateSet(SourceLocation Loc, CandidateSetKind CSK, 1066 OperatorRewriteInfo RewriteInfo = {}) Loc(Loc)1067 : Loc(Loc), Kind(CSK), RewriteInfo(RewriteInfo) {} 1068 OverloadCandidateSet(const OverloadCandidateSet &) = delete; 1069 OverloadCandidateSet &operator=(const OverloadCandidateSet &) = delete; ~OverloadCandidateSet()1070 ~OverloadCandidateSet() { destroyCandidates(); } 1071 getLocation()1072 SourceLocation getLocation() const { return Loc; } getKind()1073 CandidateSetKind getKind() const { return Kind; } getRewriteInfo()1074 OperatorRewriteInfo getRewriteInfo() const { return RewriteInfo; } 1075 1076 /// Determine when this overload candidate will be new to the 1077 /// overload set. 1078 bool isNewCandidate(Decl *F, OverloadCandidateParamOrder PO = 1079 OverloadCandidateParamOrder::Normal) { 1080 uintptr_t Key = reinterpret_cast<uintptr_t>(F->getCanonicalDecl()); 1081 Key |= static_cast<uintptr_t>(PO); 1082 return Functions.insert(Key).second; 1083 } 1084 1085 /// Exclude a function from being considered by overload resolution. exclude(Decl * F)1086 void exclude(Decl *F) { 1087 isNewCandidate(F, OverloadCandidateParamOrder::Normal); 1088 isNewCandidate(F, OverloadCandidateParamOrder::Reversed); 1089 } 1090 1091 /// Clear out all of the candidates. 1092 void clear(CandidateSetKind CSK); 1093 1094 using iterator = SmallVectorImpl<OverloadCandidate>::iterator; 1095 begin()1096 iterator begin() { return Candidates.begin(); } end()1097 iterator end() { return Candidates.end(); } 1098 size()1099 size_t size() const { return Candidates.size(); } empty()1100 bool empty() const { return Candidates.empty(); } 1101 1102 /// Allocate storage for conversion sequences for NumConversions 1103 /// conversions. 1104 ConversionSequenceList allocateConversionSequences(unsigned NumConversions)1105 allocateConversionSequences(unsigned NumConversions) { 1106 ImplicitConversionSequence *Conversions = 1107 slabAllocate<ImplicitConversionSequence>(NumConversions); 1108 1109 // Construct the new objects. 1110 for (unsigned I = 0; I != NumConversions; ++I) 1111 new (&Conversions[I]) ImplicitConversionSequence(); 1112 1113 return ConversionSequenceList(Conversions, NumConversions); 1114 } 1115 1116 /// Add a new candidate with NumConversions conversion sequence slots 1117 /// to the overload set. 1118 OverloadCandidate &addCandidate(unsigned NumConversions = 0, 1119 ConversionSequenceList Conversions = None) { 1120 assert((Conversions.empty() || Conversions.size() == NumConversions) && 1121 "preallocated conversion sequence has wrong length"); 1122 1123 Candidates.push_back(OverloadCandidate()); 1124 OverloadCandidate &C = Candidates.back(); 1125 C.Conversions = Conversions.empty() 1126 ? allocateConversionSequences(NumConversions) 1127 : Conversions; 1128 return C; 1129 } 1130 1131 /// Find the best viable function on this overload set, if it exists. 1132 OverloadingResult BestViableFunction(Sema &S, SourceLocation Loc, 1133 OverloadCandidateSet::iterator& Best); 1134 1135 SmallVector<OverloadCandidate *, 32> CompleteCandidates( 1136 Sema &S, OverloadCandidateDisplayKind OCD, ArrayRef<Expr *> Args, 1137 SourceLocation OpLoc = SourceLocation(), 1138 llvm::function_ref<bool(OverloadCandidate &)> Filter = 1139 [](OverloadCandidate &) { return true; }); 1140 1141 void NoteCandidates( 1142 PartialDiagnosticAt PA, Sema &S, OverloadCandidateDisplayKind OCD, 1143 ArrayRef<Expr *> Args, StringRef Opc = "", 1144 SourceLocation Loc = SourceLocation(), 1145 llvm::function_ref<bool(OverloadCandidate &)> Filter = 1146 [](OverloadCandidate &) { return true; }); 1147 1148 void NoteCandidates(Sema &S, ArrayRef<Expr *> Args, 1149 ArrayRef<OverloadCandidate *> Cands, 1150 StringRef Opc = "", 1151 SourceLocation OpLoc = SourceLocation()); 1152 getDestAS()1153 LangAS getDestAS() { return DestAS; } 1154 setDestAS(LangAS AS)1155 void setDestAS(LangAS AS) { 1156 assert((Kind == CSK_InitByConstructor || 1157 Kind == CSK_InitByUserDefinedConversion) && 1158 "can't set the destination address space when not constructing an " 1159 "object"); 1160 DestAS = AS; 1161 } 1162 1163 }; 1164 1165 bool isBetterOverloadCandidate(Sema &S, 1166 const OverloadCandidate &Cand1, 1167 const OverloadCandidate &Cand2, 1168 SourceLocation Loc, 1169 OverloadCandidateSet::CandidateSetKind Kind); 1170 1171 struct ConstructorInfo { 1172 DeclAccessPair FoundDecl; 1173 CXXConstructorDecl *Constructor; 1174 FunctionTemplateDecl *ConstructorTmpl; 1175 1176 explicit operator bool() const { return Constructor; } 1177 }; 1178 1179 // FIXME: Add an AddOverloadCandidate / AddTemplateOverloadCandidate overload 1180 // that takes one of these. getConstructorInfo(NamedDecl * ND)1181 inline ConstructorInfo getConstructorInfo(NamedDecl *ND) { 1182 if (isa<UsingDecl>(ND)) 1183 return ConstructorInfo{}; 1184 1185 // For constructors, the access check is performed against the underlying 1186 // declaration, not the found declaration. 1187 auto *D = ND->getUnderlyingDecl(); 1188 ConstructorInfo Info = {DeclAccessPair::make(ND, D->getAccess()), nullptr, 1189 nullptr}; 1190 Info.ConstructorTmpl = dyn_cast<FunctionTemplateDecl>(D); 1191 if (Info.ConstructorTmpl) 1192 D = Info.ConstructorTmpl->getTemplatedDecl(); 1193 Info.Constructor = dyn_cast<CXXConstructorDecl>(D); 1194 return Info; 1195 } 1196 1197 } // namespace clang 1198 1199 #endif // LLVM_CLANG_SEMA_OVERLOAD_H 1200