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