contrib/llvm/tools/clang/include/clang/Sema/Overload.h

   1 //===--- Overload.h - C++ Overloading ---------------------------*- C++ -*-===//
   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 defines the data structures and types used in C++
  11 // overload resolution.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_CLANG_SEMA_OVERLOAD_H
  16 #define LLVM_CLANG_SEMA_OVERLOAD_H
  17
  18 #include "clang/AST/Decl.h"
  19 #include "clang/AST/DeclTemplate.h"
  20 #include "clang/AST/Expr.h"
  21 #include "clang/AST/TemplateBase.h"
  22 #include "clang/AST/Type.h"
  23 #include "clang/AST/UnresolvedSet.h"
  24 #include "clang/Sema/SemaFixItUtils.h"
  25 #include "clang/Sema/TemplateDeduction.h"
  26 #include "llvm/ADT/SmallPtrSet.h"
  27 #include "llvm/ADT/SmallVector.h"
  28 #include "llvm/Support/AlignOf.h"
  29 #include "llvm/Support/Allocator.h"
  30
  31 namespace clang {
  32   class ASTContext;
  33   class CXXConstructorDecl;
  34   class CXXConversionDecl;
  35   class FunctionDecl;
  36   class Sema;
  37
  38   /// OverloadingResult - Capture the result of performing overload
  39   /// resolution.
  40   enum OverloadingResult {
  41     OR_Success,             ///< Overload resolution succeeded.
  42     OR_No_Viable_Function,  ///< No viable function found.
  43     OR_Ambiguous,           ///< Ambiguous candidates found.
  44     OR_Deleted              ///< Succeeded, but refers to a deleted function.
  45   };
  46
  47   enum OverloadCandidateDisplayKind {
  48     /// Requests that all candidates be shown.  Viable candidates will
  49     /// be printed first.
  50     OCD_AllCandidates,
  51
  52     /// Requests that only viable candidates be shown.
  53     OCD_ViableCandidates
  54   };
  55
  56   /// ImplicitConversionKind - The kind of implicit conversion used to
  57   /// convert an argument to a parameter's type. The enumerator values
  58   /// match with Table 9 of (C++ 13.3.3.1.1) and are listed such that
  59   /// better conversion kinds have smaller values.
  60   enum ImplicitConversionKind {
  61     ICK_Identity = 0,          ///< Identity conversion (no conversion)
  62     ICK_Lvalue_To_Rvalue,      ///< Lvalue-to-rvalue conversion (C++ 4.1)
  63     ICK_Array_To_Pointer,      ///< Array-to-pointer conversion (C++ 4.2)
  64     ICK_Function_To_Pointer,   ///< Function-to-pointer (C++ 4.3)
  65     ICK_Function_Conversion,   ///< Function pointer conversion (C++17 4.13)
  66     ICK_Qualification,         ///< Qualification conversions (C++ 4.4)
  67     ICK_Integral_Promotion,    ///< Integral promotions (C++ 4.5)
  68     ICK_Floating_Promotion,    ///< Floating point promotions (C++ 4.6)
  69     ICK_Complex_Promotion,     ///< Complex promotions (Clang extension)
  70     ICK_Integral_Conversion,   ///< Integral conversions (C++ 4.7)
  71     ICK_Floating_Conversion,   ///< Floating point conversions (C++ 4.8)
  72     ICK_Complex_Conversion,    ///< Complex conversions (C99 6.3.1.6)
  73     ICK_Floating_Integral,     ///< Floating-integral conversions (C++ 4.9)
  74     ICK_Pointer_Conversion,    ///< Pointer conversions (C++ 4.10)
  75     ICK_Pointer_Member,        ///< Pointer-to-member conversions (C++ 4.11)
  76     ICK_Boolean_Conversion,    ///< Boolean conversions (C++ 4.12)
  77     ICK_Compatible_Conversion, ///< Conversions between compatible types in C99
  78     ICK_Derived_To_Base,       ///< Derived-to-base (C++ [over.best.ics])
  79     ICK_Vector_Conversion,     ///< Vector conversions
  80     ICK_Vector_Splat,          ///< A vector splat from an arithmetic type
  81     ICK_Complex_Real,          ///< Complex-real conversions (C99 6.3.1.7)
  82     ICK_Block_Pointer_Conversion,    ///< Block Pointer conversions
  83     ICK_TransparentUnionConversion, ///< Transparent Union Conversions
  84     ICK_Writeback_Conversion,  ///< Objective-C ARC writeback conversion
  85     ICK_Zero_Event_Conversion, ///< Zero constant to event (OpenCL1.2 6.12.10)
  86     ICK_Zero_Queue_Conversion, ///< Zero constant to queue
  87     ICK_C_Only_Conversion,     ///< Conversions allowed in C, but not C++
  88     ICK_Incompatible_Pointer_Conversion, ///< C-only conversion between pointers
  89                                          ///  with incompatible types
  90     ICK_Num_Conversion_Kinds,  ///< The number of conversion kinds
  91   };
  92
  93   /// ImplicitConversionRank - The rank of an implicit conversion
  94   /// kind. The enumerator values match with Table 9 of (C++
  95   /// 13.3.3.1.1) and are listed such that better conversion ranks
  96   /// have smaller values.
  97   enum ImplicitConversionRank {
  98     ICR_Exact_Match = 0,         ///< Exact Match
  99     ICR_Promotion,               ///< Promotion
 100     ICR_Conversion,              ///< Conversion
 101     ICR_OCL_Scalar_Widening,     ///< OpenCL Scalar Widening
 102     ICR_Complex_Real_Conversion, ///< Complex <-> Real conversion
 103     ICR_Writeback_Conversion,    ///< ObjC ARC writeback conversion
 104     ICR_C_Conversion,            ///< Conversion only allowed in the C standard.
 105                                  ///  (e.g. void* to char*)
 106     ICR_C_Conversion_Extension   ///< Conversion not allowed by the C standard,
 107                                  ///  but that we accept as an extension anyway.
 108   };
 109
 110   ImplicitConversionRank GetConversionRank(ImplicitConversionKind Kind);
 111
 112   /// NarrowingKind - The kind of narrowing conversion being performed by a
 113   /// standard conversion sequence according to C++11 [dcl.init.list]p7.
 114   enum NarrowingKind {
 115     /// Not a narrowing conversion.
 116     NK_Not_Narrowing,
 117
 118     /// A narrowing conversion by virtue of the source and destination types.
 119     NK_Type_Narrowing,
 120
 121     /// A narrowing conversion, because a constant expression got narrowed.
 122     NK_Constant_Narrowing,
 123
 124     /// A narrowing conversion, because a non-constant-expression variable might
 125     /// have got narrowed.
 126     NK_Variable_Narrowing,
 127
 128     /// Cannot tell whether this is a narrowing conversion because the
 129     /// expression is value-dependent.
 130     NK_Dependent_Narrowing,
 131   };
 132
 133   /// StandardConversionSequence - represents a standard conversion
 134   /// sequence (C++ 13.3.3.1.1). A standard conversion sequence
 135   /// contains between zero and three conversions. If a particular
 136   /// conversion is not needed, it will be set to the identity conversion
 137   /// (ICK_Identity). Note that the three conversions are
 138   /// specified as separate members (rather than in an array) so that
 139   /// we can keep the size of a standard conversion sequence to a
 140   /// single word.
 141   class StandardConversionSequence {
 142   public:
 143     /// First -- The first conversion can be an lvalue-to-rvalue
 144     /// conversion, array-to-pointer conversion, or
 145     /// function-to-pointer conversion.
 146     ImplicitConversionKind First : 8;
 147
 148     /// Second - The second conversion can be an integral promotion,
 149     /// floating point promotion, integral conversion, floating point
 150     /// conversion, floating-integral conversion, pointer conversion,
 151     /// pointer-to-member conversion, or boolean conversion.
 152     ImplicitConversionKind Second : 8;
 153
 154     /// Third - The third conversion can be a qualification conversion
 155     /// or a function conversion.
 156     ImplicitConversionKind Third : 8;
 157
 158     /// \brief Whether this is the deprecated conversion of a
 159     /// string literal to a pointer to non-const character data
 160     /// (C++ 4.2p2).
 161     unsigned DeprecatedStringLiteralToCharPtr : 1;
 162
 163     /// \brief Whether the qualification conversion involves a change in the
 164     /// Objective-C lifetime (for automatic reference counting).
 165     unsigned QualificationIncludesObjCLifetime : 1;
 166
 167     /// IncompatibleObjC - Whether this is an Objective-C conversion
 168     /// that we should warn about (if we actually use it).
 169     unsigned IncompatibleObjC : 1;
 170
 171     /// ReferenceBinding - True when this is a reference binding
 172     /// (C++ [over.ics.ref]).
 173     unsigned ReferenceBinding : 1;
 174
 175     /// DirectBinding - True when this is a reference binding that is a
 176     /// direct binding (C++ [dcl.init.ref]).
 177     unsigned DirectBinding : 1;
 178
 179     /// \brief Whether this is an lvalue reference binding (otherwise, it's
 180     /// an rvalue reference binding).
 181     unsigned IsLvalueReference : 1;
 182
 183     /// \brief Whether we're binding to a function lvalue.
 184     unsigned BindsToFunctionLvalue : 1;
 185
 186     /// \brief Whether we're binding to an rvalue.
 187     unsigned BindsToRvalue : 1;
 188
 189     /// \brief Whether this binds an implicit object argument to a
 190     /// non-static member function without a ref-qualifier.
 191     unsigned BindsImplicitObjectArgumentWithoutRefQualifier : 1;
 192
 193     /// \brief Whether this binds a reference to an object with a different
 194     /// Objective-C lifetime qualifier.
 195     unsigned ObjCLifetimeConversionBinding : 1;
 196
 197     /// FromType - The type that this conversion is converting
 198     /// from. This is an opaque pointer that can be translated into a
 199     /// QualType.
 200     void *FromTypePtr;
 201
 202     /// ToType - The types that this conversion is converting to in
 203     /// each step. This is an opaque pointer that can be translated
 204     /// into a QualType.
 205     void *ToTypePtrs[3];
 206
 207     /// CopyConstructor - The copy constructor that is used to perform
 208     /// this conversion, when the conversion is actually just the
 209     /// initialization of an object via copy constructor. Such
 210     /// conversions are either identity conversions or derived-to-base
 211     /// conversions.
 212     CXXConstructorDecl *CopyConstructor;
 213     DeclAccessPair FoundCopyConstructor;
 214
 215     void setFromType(QualType T) { FromTypePtr = T.getAsOpaquePtr(); }
 216     void setToType(unsigned Idx, QualType T) {
 217       assert(Idx < 3 && "To type index is out of range");
 218       ToTypePtrs[Idx] = T.getAsOpaquePtr();
 219     }
 220     void setAllToTypes(QualType T) {
 221       ToTypePtrs[0] = T.getAsOpaquePtr();
 222       ToTypePtrs[1] = ToTypePtrs[0];
 223       ToTypePtrs[2] = ToTypePtrs[0];
 224     }
 225
 226     QualType getFromType() const {
 227       return QualType::getFromOpaquePtr(FromTypePtr);
 228     }
 229     QualType getToType(unsigned Idx) const {
 230       assert(Idx < 3 && "To type index is out of range");
 231       return QualType::getFromOpaquePtr(ToTypePtrs[Idx]);
 232     }
 233
 234     void setAsIdentityConversion();
 235
 236     bool isIdentityConversion() const {
 237       return Second == ICK_Identity && Third == ICK_Identity;
 238     }
 239
 240     ImplicitConversionRank getRank() const;
 241     NarrowingKind getNarrowingKind(ASTContext &Context, const Expr *Converted,
 242                                    APValue &ConstantValue,
 243                                    QualType &ConstantType) const;
 244     bool isPointerConversionToBool() const;
 245     bool isPointerConversionToVoidPointer(ASTContext& Context) const;
 246     void dump() const;
 247   };
 248
 249   /// UserDefinedConversionSequence - Represents a user-defined
 250   /// conversion sequence (C++ 13.3.3.1.2).
 251   struct UserDefinedConversionSequence {
 252     /// \brief Represents the standard conversion that occurs before
 253     /// the actual user-defined conversion.
 254     ///
 255     /// C++11 13.3.3.1.2p1:
 256     ///   If the user-defined conversion is specified by a constructor
 257     ///   (12.3.1), the initial standard conversion sequence converts
 258     ///   the source type to the type required by the argument of the
 259     ///   constructor. If the user-defined conversion is specified by
 260     ///   a conversion function (12.3.2), the initial standard
 261     ///   conversion sequence converts the source type to the implicit
 262     ///   object parameter of the conversion function.
 263     StandardConversionSequence Before;
 264
 265     /// EllipsisConversion - When this is true, it means user-defined
 266     /// conversion sequence starts with a ... (ellipsis) conversion, instead of
 267     /// a standard conversion. In this case, 'Before' field must be ignored.
 268     // FIXME. I much rather put this as the first field. But there seems to be
 269     // a gcc code gen. bug which causes a crash in a test. Putting it here seems
 270     // to work around the crash.
 271     bool EllipsisConversion : 1;
 272
 273     /// HadMultipleCandidates - When this is true, it means that the
 274     /// conversion function was resolved from an overloaded set having
 275     /// size greater than 1.
 276     bool HadMultipleCandidates : 1;
 277
 278     /// After - Represents the standard conversion that occurs after
 279     /// the actual user-defined conversion.
 280     StandardConversionSequence After;
 281
 282     /// ConversionFunction - The function that will perform the
 283     /// user-defined conversion. Null if the conversion is an
 284     /// aggregate initialization from an initializer list.
 285     FunctionDecl* ConversionFunction;
 286
 287     /// \brief The declaration that we found via name lookup, which might be
 288     /// the same as \c ConversionFunction or it might be a using declaration
 289     /// that refers to \c ConversionFunction.
 290     DeclAccessPair FoundConversionFunction;
 291
 292     void dump() const;
 293   };
 294
 295   /// Represents an ambiguous user-defined conversion sequence.
 296   struct AmbiguousConversionSequence {
 297     typedef SmallVector<std::pair<NamedDecl*, FunctionDecl*>, 4> ConversionSet;
 298
 299     void *FromTypePtr;
 300     void *ToTypePtr;
 301     char Buffer[sizeof(ConversionSet)];
 302
 303     QualType getFromType() const {
 304       return QualType::getFromOpaquePtr(FromTypePtr);
 305     }
 306     QualType getToType() const {
 307       return QualType::getFromOpaquePtr(ToTypePtr);
 308     }
 309     void setFromType(QualType T) { FromTypePtr = T.getAsOpaquePtr(); }
 310     void setToType(QualType T) { ToTypePtr = T.getAsOpaquePtr(); }
 311
 312     ConversionSet &conversions() {
 313       return *reinterpret_cast<ConversionSet*>(Buffer);
 314     }
 315
 316     const ConversionSet &conversions() const {
 317       return *reinterpret_cast<const ConversionSet*>(Buffer);
 318     }
 319
 320     void addConversion(NamedDecl *Found, FunctionDecl *D) {
 321       conversions().push_back(std::make_pair(Found, D));
 322     }
 323
 324     typedef ConversionSet::iterator iterator;
 325     iterator begin() { return conversions().begin(); }
 326     iterator end() { return conversions().end(); }
 327
 328     typedef ConversionSet::const_iterator const_iterator;
 329     const_iterator begin() const { return conversions().begin(); }
 330     const_iterator end() const { return conversions().end(); }
 331
 332     void construct();
 333     void destruct();
 334     void copyFrom(const AmbiguousConversionSequence &);
 335   };
 336
 337   /// BadConversionSequence - Records information about an invalid
 338   /// conversion sequence.
 339   struct BadConversionSequence {
 340     enum FailureKind {
 341       no_conversion,
 342       unrelated_class,
 343       bad_qualifiers,
 344       lvalue_ref_to_rvalue,
 345       rvalue_ref_to_lvalue
 346     };
 347
 348     // This can be null, e.g. for implicit object arguments.
 349     Expr *FromExpr;
 350
 351     FailureKind Kind;
 352
 353   private:
 354     // The type we're converting from (an opaque QualType).
 355     void *FromTy;
 356
 357     // The type we're converting to (an opaque QualType).
 358     void *ToTy;
 359
 360   public:
 361     void init(FailureKind K, Expr *From, QualType To) {
 362       init(K, From->getType(), To);
 363       FromExpr = From;
 364     }
 365     void init(FailureKind K, QualType From, QualType To) {
 366       Kind = K;
 367       FromExpr = nullptr;
 368       setFromType(From);
 369       setToType(To);
 370     }
 371
 372     QualType getFromType() const { return QualType::getFromOpaquePtr(FromTy); }
 373     QualType getToType() const { return QualType::getFromOpaquePtr(ToTy); }
 374
 375     void setFromExpr(Expr *E) {
 376       FromExpr = E;
 377       setFromType(E->getType());
 378     }
 379     void setFromType(QualType T) { FromTy = T.getAsOpaquePtr(); }
 380     void setToType(QualType T) { ToTy = T.getAsOpaquePtr(); }
 381   };
 382
 383   /// ImplicitConversionSequence - Represents an implicit conversion
 384   /// sequence, which may be a standard conversion sequence
 385   /// (C++ 13.3.3.1.1), user-defined conversion sequence (C++ 13.3.3.1.2),
 386   /// or an ellipsis conversion sequence (C++ 13.3.3.1.3).
 387   class ImplicitConversionSequence {
 388   public:
 389     /// Kind - The kind of implicit conversion sequence. BadConversion
 390     /// specifies that there is no conversion from the source type to
 391     /// the target type.  AmbiguousConversion represents the unique
 392     /// ambiguous conversion (C++0x [over.best.ics]p10).
 393     enum Kind {
 394       StandardConversion = 0,
 395       UserDefinedConversion,
 396       AmbiguousConversion,
 397       EllipsisConversion,
 398       BadConversion
 399     };
 400
 401   private:
 402     enum {
 403       Uninitialized = BadConversion + 1
 404     };
 405
 406     /// ConversionKind - The kind of implicit conversion sequence.
 407     unsigned ConversionKind : 30;
 408
 409     /// \brief Whether the target is really a std::initializer_list, and the
 410     /// sequence only represents the worst element conversion.
 411     unsigned StdInitializerListElement : 1;
 412
 413     void setKind(Kind K) {
 414       destruct();
 415       ConversionKind = K;
 416     }
 417
 418     void destruct() {
 419       if (ConversionKind == AmbiguousConversion) Ambiguous.destruct();
 420     }
 421
 422   public:
 423     union {
 424       /// When ConversionKind == StandardConversion, provides the
 425       /// details of the standard conversion sequence.
 426       StandardConversionSequence Standard;
 427
 428       /// When ConversionKind == UserDefinedConversion, provides the
 429       /// details of the user-defined conversion sequence.
 430       UserDefinedConversionSequence UserDefined;
 431
 432       /// When ConversionKind == AmbiguousConversion, provides the
 433       /// details of the ambiguous conversion.
 434       AmbiguousConversionSequence Ambiguous;
 435
 436       /// When ConversionKind == BadConversion, provides the details
 437       /// of the bad conversion.
 438       BadConversionSequence Bad;
 439     };
 440
 441     ImplicitConversionSequence()
 442         : ConversionKind(Uninitialized), StdInitializerListElement(false) {
 443       Standard.setAsIdentityConversion();
 444     }
 445     ~ImplicitConversionSequence() {
 446       destruct();
 447     }
 448     ImplicitConversionSequence(const ImplicitConversionSequence &Other)
 449       : ConversionKind(Other.ConversionKind),
 450         StdInitializerListElement(Other.StdInitializerListElement)
 451     {
 452       switch (ConversionKind) {
 453       case Uninitialized: break;
 454       case StandardConversion: Standard = Other.Standard; break;
 455       case UserDefinedConversion: UserDefined = Other.UserDefined; break;
 456       case AmbiguousConversion: Ambiguous.copyFrom(Other.Ambiguous); break;
 457       case EllipsisConversion: break;
 458       case BadConversion: Bad = Other.Bad; break;
 459       }
 460     }
 461
 462     ImplicitConversionSequence &
 463         operator=(const ImplicitConversionSequence &Other) {
 464       destruct();
 465       new (this) ImplicitConversionSequence(Other);
 466       return *this;
 467     }
 468
 469     Kind getKind() const {
 470       assert(isInitialized() && "querying uninitialized conversion");
 471       return Kind(ConversionKind);
 472     }
 473
 474     /// \brief Return a ranking of the implicit conversion sequence
 475     /// kind, where smaller ranks represent better conversion
 476     /// sequences.
 477     ///
 478     /// In particular, this routine gives user-defined conversion
 479     /// sequences and ambiguous conversion sequences the same rank,
 480     /// per C++ [over.best.ics]p10.
 481     unsigned getKindRank() const {
 482       switch (getKind()) {
 483       case StandardConversion:
 484         return 0;
 485
 486       case UserDefinedConversion:
 487       case AmbiguousConversion:
 488         return 1;
 489
 490       case EllipsisConversion:
 491         return 2;
 492
 493       case BadConversion:
 494         return 3;
 495       }
 496
 497       llvm_unreachable("Invalid ImplicitConversionSequence::Kind!");
 498     }
 499
 500     bool isBad() const { return getKind() == BadConversion; }
 501     bool isStandard() const { return getKind() == StandardConversion; }
 502     bool isEllipsis() const { return getKind() == EllipsisConversion; }
 503     bool isAmbiguous() const { return getKind() == AmbiguousConversion; }
 504     bool isUserDefined() const { return getKind() == UserDefinedConversion; }
 505     bool isFailure() const { return isBad() || isAmbiguous(); }
 506
 507     /// Determines whether this conversion sequence has been
 508     /// initialized.  Most operations should never need to query
 509     /// uninitialized conversions and should assert as above.
 510     bool isInitialized() const { return ConversionKind != Uninitialized; }
 511
 512     /// Sets this sequence as a bad conversion for an explicit argument.
 513     void setBad(BadConversionSequence::FailureKind Failure,
 514                 Expr *FromExpr, QualType ToType) {
 515       setKind(BadConversion);
 516       Bad.init(Failure, FromExpr, ToType);
 517     }
 518
 519     /// Sets this sequence as a bad conversion for an implicit argument.
 520     void setBad(BadConversionSequence::FailureKind Failure,
 521                 QualType FromType, QualType ToType) {
 522       setKind(BadConversion);
 523       Bad.init(Failure, FromType, ToType);
 524     }
 525
 526     void setStandard() { setKind(StandardConversion); }
 527     void setEllipsis() { setKind(EllipsisConversion); }
 528     void setUserDefined() { setKind(UserDefinedConversion); }
 529     void setAmbiguous() {
 530       if (ConversionKind == AmbiguousConversion) return;
 531       ConversionKind = AmbiguousConversion;
 532       Ambiguous.construct();
 533     }
 534
 535     void setAsIdentityConversion(QualType T) {
 536       setStandard();
 537       Standard.setAsIdentityConversion();
 538       Standard.setFromType(T);
 539       Standard.setAllToTypes(T);
 540     }
 541
 542     /// \brief Whether the target is really a std::initializer_list, and the
 543     /// sequence only represents the worst element conversion.
 544     bool isStdInitializerListElement() const {
 545       return StdInitializerListElement;
 546     }
 547
 548     void setStdInitializerListElement(bool V = true) {
 549       StdInitializerListElement = V;
 550     }
 551
 552     // The result of a comparison between implicit conversion
 553     // sequences. Use Sema::CompareImplicitConversionSequences to
 554     // actually perform the comparison.
 555     enum CompareKind {
 556       Better = -1,
 557       Indistinguishable = 0,
 558       Worse = 1
 559     };
 560
 561     void DiagnoseAmbiguousConversion(Sema &S,
 562                                      SourceLocation CaretLoc,
 563                                      const PartialDiagnostic &PDiag) const;
 564
 565     void dump() const;
 566   };
 567
 568   enum OverloadFailureKind {
 569     ovl_fail_too_many_arguments,
 570     ovl_fail_too_few_arguments,
 571     ovl_fail_bad_conversion,
 572     ovl_fail_bad_deduction,
 573
 574     /// This conversion candidate was not considered because it
 575     /// duplicates the work of a trivial or derived-to-base
 576     /// conversion.
 577     ovl_fail_trivial_conversion,
 578
 579     /// This conversion candidate was not considered because it is
 580     /// an illegal instantiation of a constructor temploid: it is
 581     /// callable with one argument, we only have one argument, and
 582     /// its first parameter type is exactly the type of the class.
 583     ///
 584     /// Defining such a constructor directly is illegal, and
 585     /// template-argument deduction is supposed to ignore such
 586     /// instantiations, but we can still get one with the right
 587     /// kind of implicit instantiation.
 588     ovl_fail_illegal_constructor,
 589
 590     /// This conversion candidate is not viable because its result
 591     /// type is not implicitly convertible to the desired type.
 592     ovl_fail_bad_final_conversion,
 593
 594     /// This conversion function template specialization candidate is not
 595     /// viable because the final conversion was not an exact match.
 596     ovl_fail_final_conversion_not_exact,
 597
 598     /// (CUDA) This candidate was not viable because the callee
 599     /// was not accessible from the caller's target (i.e. host->device,
 600     /// global->host, device->host).
 601     ovl_fail_bad_target,
 602
 603     /// This candidate function was not viable because an enable_if
 604     /// attribute disabled it.
 605     ovl_fail_enable_if,
 606
 607     /// This candidate was not viable because its address could not be taken.
 608     ovl_fail_addr_not_available,
 609
 610     /// This candidate was not viable because its OpenCL extension is disabled.
 611     ovl_fail_ext_disabled,
 612
 613     /// This inherited constructor is not viable because it would slice the
 614     /// argument.
 615     ovl_fail_inhctor_slice,
 616   };
 617
 618   /// A list of implicit conversion sequences for the arguments of an
 619   /// OverloadCandidate.
 620   typedef llvm::MutableArrayRef<ImplicitConversionSequence>
 621       ConversionSequenceList;
 622
 623   /// OverloadCandidate - A single candidate in an overload set (C++ 13.3).
 624   struct OverloadCandidate {
 625     /// Function - The actual function that this candidate
 626     /// represents. When NULL, this is a built-in candidate
 627     /// (C++ [over.oper]) or a surrogate for a conversion to a
 628     /// function pointer or reference (C++ [over.call.object]).
 629     FunctionDecl *Function;
 630
 631     /// FoundDecl - The original declaration that was looked up /
 632     /// invented / otherwise found, together with its access.
 633     /// Might be a UsingShadowDecl or a FunctionTemplateDecl.
 634     DeclAccessPair FoundDecl;
 635
 636     /// BuiltinParamTypes - Provides the parameter types of a built-in overload
 637     /// candidate. Only valid when Function is NULL.
 638     QualType BuiltinParamTypes[3];
 639
 640     /// Surrogate - The conversion function for which this candidate
 641     /// is a surrogate, but only if IsSurrogate is true.
 642     CXXConversionDecl *Surrogate;
 643
 644     /// The conversion sequences used to convert the function arguments
 645     /// to the function parameters.
 646     ConversionSequenceList Conversions;
 647
 648     /// The FixIt hints which can be used to fix the Bad candidate.
 649     ConversionFixItGenerator Fix;
 650
 651     /// Viable - True to indicate that this overload candidate is viable.
 652     bool Viable;
 653
 654     /// IsSurrogate - True to indicate that this candidate is a
 655     /// surrogate for a conversion to a function pointer or reference
 656     /// (C++ [over.call.object]).
 657     bool IsSurrogate;
 658
 659     /// IgnoreObjectArgument - True to indicate that the first
 660     /// argument's conversion, which for this function represents the
 661     /// implicit object argument, should be ignored. This will be true
 662     /// when the candidate is a static member function (where the
 663     /// implicit object argument is just a placeholder) or a
 664     /// non-static member function when the call doesn't have an
 665     /// object argument.
 666     bool IgnoreObjectArgument;
 667
 668     /// FailureKind - The reason why this candidate is not viable.
 669     /// Actually an OverloadFailureKind.
 670     unsigned char FailureKind;
 671
 672     /// \brief The number of call arguments that were explicitly provided,
 673     /// to be used while performing partial ordering of function templates.
 674     unsigned ExplicitCallArguments;
 675
 676     union {
 677       DeductionFailureInfo DeductionFailure;
 678
 679       /// FinalConversion - For a conversion function (where Function is
 680       /// a CXXConversionDecl), the standard conversion that occurs
 681       /// after the call to the overload candidate to convert the result
 682       /// of calling the conversion function to the required type.
 683       StandardConversionSequence FinalConversion;
 684     };
 685
 686     /// hasAmbiguousConversion - Returns whether this overload
 687     /// candidate requires an ambiguous conversion or not.
 688     bool hasAmbiguousConversion() const {
 689       for (auto &C : Conversions) {
 690         if (!C.isInitialized()) return false;
 691         if (C.isAmbiguous()) return true;
 692       }
 693       return false;
 694     }
 695
 696     bool TryToFixBadConversion(unsigned Idx, Sema &S) {
 697       bool CanFix = Fix.tryToFixConversion(
 698                       Conversions[Idx].Bad.FromExpr,
 699                       Conversions[Idx].Bad.getFromType(),
 700                       Conversions[Idx].Bad.getToType(), S);
 701
 702       // If at least one conversion fails, the candidate cannot be fixed.
 703       if (!CanFix)
 704         Fix.clear();
 705
 706       return CanFix;
 707     }
 708
 709     unsigned getNumParams() const {
 710       if (IsSurrogate) {
 711         auto STy = Surrogate->getConversionType();
 712         while (STy->isPointerType() || STy->isReferenceType())
 713           STy = STy->getPointeeType();
 714         return STy->getAs<FunctionProtoType>()->getNumParams();
 715       }
 716       if (Function)
 717         return Function->getNumParams();
 718       return ExplicitCallArguments;
 719     }
 720   };
 721
 722   /// OverloadCandidateSet - A set of overload candidates, used in C++
 723   /// overload resolution (C++ 13.3).
 724   class OverloadCandidateSet {
 725   public:
 726     enum CandidateSetKind {
 727       /// Normal lookup.
 728       CSK_Normal,
 729       /// C++ [over.match.oper]:
 730       /// Lookup of operator function candidates in a call using operator
 731       /// syntax. Candidates that have no parameters of class type will be
 732       /// skipped unless there is a parameter of (reference to) enum type and
 733       /// the corresponding argument is of the same enum type.
 734       CSK_Operator,
 735       /// C++ [over.match.copy]:
 736       /// Copy-initialization of an object of class type by user-defined
 737       /// conversion.
 738       CSK_InitByUserDefinedConversion,
 739       /// C++ [over.match.ctor], [over.match.list]
 740       /// Initialization of an object of class type by constructor,
 741       /// using either a parenthesized or braced list of arguments.
 742       CSK_InitByConstructor,
 743     };
 744
 745   private:
 746     SmallVector<OverloadCandidate, 16> Candidates;
 747     llvm::SmallPtrSet<Decl *, 16> Functions;
 748
 749     // Allocator for ConversionSequenceLists. We store the first few of these
 750     // inline to avoid allocation for small sets.
 751     llvm::BumpPtrAllocator SlabAllocator;
 752
 753     SourceLocation Loc;
 754     CandidateSetKind Kind;
 755
 756     constexpr static unsigned NumInlineBytes =
 757         24 * sizeof(ImplicitConversionSequence);
 758     unsigned NumInlineBytesUsed;
 759     llvm::AlignedCharArray<alignof(void *), NumInlineBytes> InlineSpace;
 760
 761     /// If we have space, allocates from inline storage. Otherwise, allocates
 762     /// from the slab allocator.
 763     /// FIXME: It would probably be nice to have a SmallBumpPtrAllocator
 764     /// instead.
 765     /// FIXME: Now that this only allocates ImplicitConversionSequences, do we
 766     /// want to un-generalize this?
 767     template <typename T>
 768     T *slabAllocate(unsigned N) {
 769       // It's simpler if this doesn't need to consider alignment.
 770       static_assert(alignof(T) == alignof(void *),
 771                     "Only works for pointer-aligned types.");
 772       static_assert(std::is_trivial<T>::value ||
 773                         std::is_same<ImplicitConversionSequence, T>::value,
 774                     "Add destruction logic to OverloadCandidateSet::clear().");
 775
 776       unsigned NBytes = sizeof(T) * N;
 777       if (NBytes > NumInlineBytes - NumInlineBytesUsed)
 778         return SlabAllocator.Allocate<T>(N);
 779       char *FreeSpaceStart = InlineSpace.buffer + NumInlineBytesUsed;
 780       assert(uintptr_t(FreeSpaceStart) % alignof(void *) == 0 &&
 781              "Misaligned storage!");
 782
 783       NumInlineBytesUsed += NBytes;
 784       return reinterpret_cast<T *>(FreeSpaceStart);
 785     }
 786
 787     OverloadCandidateSet(const OverloadCandidateSet &) = delete;
 788     void operator=(const OverloadCandidateSet &) = delete;
 789
 790     void destroyCandidates();
 791
 792   public:
 793     OverloadCandidateSet(SourceLocation Loc, CandidateSetKind CSK)
 794         : Loc(Loc), Kind(CSK), NumInlineBytesUsed(0) {}
 795     ~OverloadCandidateSet() { destroyCandidates(); }
 796
 797     SourceLocation getLocation() const { return Loc; }
 798     CandidateSetKind getKind() const { return Kind; }
 799
 800     /// \brief Determine when this overload candidate will be new to the
 801     /// overload set.
 802     bool isNewCandidate(Decl *F) {
 803       return Functions.insert(F->getCanonicalDecl()).second;
 804     }
 805
 806     /// \brief Clear out all of the candidates.
 807     void clear(CandidateSetKind CSK);
 808
 809     typedef SmallVectorImpl<OverloadCandidate>::iterator iterator;
 810     iterator begin() { return Candidates.begin(); }
 811     iterator end() { return Candidates.end(); }
 812
 813     size_t size() const { return Candidates.size(); }
 814     bool empty() const { return Candidates.empty(); }
 815
 816     /// \brief Allocate storage for conversion sequences for NumConversions
 817     /// conversions.
 818     ConversionSequenceList
 819     allocateConversionSequences(unsigned NumConversions) {
 820       ImplicitConversionSequence *Conversions =
 821           slabAllocate<ImplicitConversionSequence>(NumConversions);
 822
 823       // Construct the new objects.
 824       for (unsigned I = 0; I != NumConversions; ++I)
 825         new (&Conversions[I]) ImplicitConversionSequence();
 826
 827       return ConversionSequenceList(Conversions, NumConversions);
 828     }
 829
 830     /// \brief Add a new candidate with NumConversions conversion sequence slots
 831     /// to the overload set.
 832     OverloadCandidate &addCandidate(unsigned NumConversions = 0,
 833                                     ConversionSequenceList Conversions = None) {
 834       assert((Conversions.empty() || Conversions.size() == NumConversions) &&
 835              "preallocated conversion sequence has wrong length");
 836
 837       Candidates.push_back(OverloadCandidate());
 838       OverloadCandidate &C = Candidates.back();
 839       C.Conversions = Conversions.empty()
 840                           ? allocateConversionSequences(NumConversions)
 841                           : Conversions;
 842       return C;
 843     }
 844
 845     /// Find the best viable function on this overload set, if it exists.
 846     OverloadingResult BestViableFunction(Sema &S, SourceLocation Loc,
 847                                          OverloadCandidateSet::iterator& Best);
 848
 849     void NoteCandidates(Sema &S,
 850                         OverloadCandidateDisplayKind OCD,
 851                         ArrayRef<Expr *> Args,
 852                         StringRef Opc = "",
 853                         SourceLocation Loc = SourceLocation(),
 854                         llvm::function_ref<bool(OverloadCandidate&)> Filter =
 855                           [](OverloadCandidate&) { return true; });
 856   };
 857
 858   bool isBetterOverloadCandidate(Sema &S,
 859                                  const OverloadCandidate &Cand1,
 860                                  const OverloadCandidate &Cand2,
 861                                  SourceLocation Loc,
 862                                  OverloadCandidateSet::CandidateSetKind Kind);
 863
 864   struct ConstructorInfo {
 865     DeclAccessPair FoundDecl;
 866     CXXConstructorDecl *Constructor;
 867     FunctionTemplateDecl *ConstructorTmpl;
 868     explicit operator bool() const { return Constructor; }
 869   };
 870   // FIXME: Add an AddOverloadCandidate / AddTemplateOverloadCandidate overload
 871   // that takes one of these.
 872   inline ConstructorInfo getConstructorInfo(NamedDecl *ND) {
 873     if (isa<UsingDecl>(ND))
 874       return ConstructorInfo{};
 875
 876     // For constructors, the access check is performed against the underlying
 877     // declaration, not the found declaration.
 878     auto *D = ND->getUnderlyingDecl();
 879     ConstructorInfo Info = {DeclAccessPair::make(ND, D->getAccess()), nullptr,
 880                             nullptr};
 881     Info.ConstructorTmpl = dyn_cast<FunctionTemplateDecl>(D);
 882     if (Info.ConstructorTmpl)
 883       D = Info.ConstructorTmpl->getTemplatedDecl();
 884     Info.Constructor = dyn_cast<CXXConstructorDecl>(D);
 885     return Info;
 886   }
 887 } // end namespace clang
 888
 889 #endif // LLVM_CLANG_SEMA_OVERLOAD_H