Home | History | Annotate | Download | only in Sema 
      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_NoReturn_Adjustment,   ///< Removal of noreturn from a type (Clang)
     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_Num_Conversion_Kinds   ///< The number of conversion kinds
     87   };
     88 
     89   /// ImplicitConversionRank - The rank of an implicit conversion
     90   /// kind. The enumerator values match with Table 9 of (C++
     91   /// 13.3.3.1.1) and are listed such that better conversion ranks
     92   /// have smaller values.
     93   enum ImplicitConversionRank {
     94     ICR_Exact_Match = 0,         ///< Exact Match
     95     ICR_Promotion,               ///< Promotion
     96     ICR_Conversion,              ///< Conversion
     97     ICR_Complex_Real_Conversion, ///< Complex <-> Real conversion
     98     ICR_Writeback_Conversion     ///< ObjC ARC writeback conversion
     99   };
    100 
    101   ImplicitConversionRank GetConversionRank(ImplicitConversionKind Kind);
    102 
    103   /// NarrowingKind - The kind of narrowing conversion being performed by a
    104   /// standard conversion sequence according to C++11 [dcl.init.list]p7.
    105   enum NarrowingKind {
    106     /// Not a narrowing conversion.
    107     NK_Not_Narrowing,
    108 
    109     /// A narrowing conversion by virtue of the source and destination types.
    110     NK_Type_Narrowing,
    111 
    112     /// A narrowing conversion, because a constant expression got narrowed.
    113     NK_Constant_Narrowing,
    114 
    115     /// A narrowing conversion, because a non-constant-expression variable might
    116     /// have got narrowed.
    117     NK_Variable_Narrowing
    118   };
    119 
    120   /// StandardConversionSequence - represents a standard conversion
    121   /// sequence (C++ 13.3.3.1.1). A standard conversion sequence
    122   /// contains between zero and three conversions. If a particular
    123   /// conversion is not needed, it will be set to the identity conversion
    124   /// (ICK_Identity). Note that the three conversions are
    125   /// specified as separate members (rather than in an array) so that
    126   /// we can keep the size of a standard conversion sequence to a
    127   /// single word.
    128   class StandardConversionSequence {
    129   public:
    130     /// First -- The first conversion can be an lvalue-to-rvalue
    131     /// conversion, array-to-pointer conversion, or
    132     /// function-to-pointer conversion.
    133     ImplicitConversionKind First : 8;
    134 
    135     /// Second - The second conversion can be an integral promotion,
    136     /// floating point promotion, integral conversion, floating point
    137     /// conversion, floating-integral conversion, pointer conversion,
    138     /// pointer-to-member conversion, or boolean conversion.
    139     ImplicitConversionKind Second : 8;
    140 
    141     /// Third - The third conversion can be a qualification conversion.
    142     ImplicitConversionKind Third : 8;
    143 
    144     /// \brief Whether this is the deprecated conversion of a
    145     /// string literal to a pointer to non-const character data
    146     /// (C++ 4.2p2).
    147     unsigned DeprecatedStringLiteralToCharPtr : 1;
    148 
    149     /// \brief Whether the qualification conversion involves a change in the
    150     /// Objective-C lifetime (for automatic reference counting).
    151     unsigned QualificationIncludesObjCLifetime : 1;
    152 
    153     /// IncompatibleObjC - Whether this is an Objective-C conversion
    154     /// that we should warn about (if we actually use it).
    155     unsigned IncompatibleObjC : 1;
    156 
    157     /// ReferenceBinding - True when this is a reference binding
    158     /// (C++ [over.ics.ref]).
    159     unsigned ReferenceBinding : 1;
    160 
    161     /// DirectBinding - True when this is a reference binding that is a
    162     /// direct binding (C++ [dcl.init.ref]).
    163     unsigned DirectBinding : 1;
    164 
    165     /// \brief Whether this is an lvalue reference binding (otherwise, it's
    166     /// an rvalue reference binding).
    167     unsigned IsLvalueReference : 1;
    168 
    169     /// \brief Whether we're binding to a function lvalue.
    170     unsigned BindsToFunctionLvalue : 1;
    171 
    172     /// \brief Whether we're binding to an rvalue.
    173     unsigned BindsToRvalue : 1;
    174 
    175     /// \brief Whether this binds an implicit object argument to a
    176     /// non-static member function without a ref-qualifier.
    177     unsigned BindsImplicitObjectArgumentWithoutRefQualifier : 1;
    178 
    179     /// \brief Whether this binds a reference to an object with a different
    180     /// Objective-C lifetime qualifier.
    181     unsigned ObjCLifetimeConversionBinding : 1;
    182 
    183     /// FromType - The type that this conversion is converting
    184     /// from. This is an opaque pointer that can be translated into a
    185     /// QualType.
    186     void *FromTypePtr;
    187 
    188     /// ToType - The types that this conversion is converting to in
    189     /// each step. This is an opaque pointer that can be translated
    190     /// into a QualType.
    191     void *ToTypePtrs[3];
    192 
    193     /// CopyConstructor - The copy constructor that is used to perform
    194     /// this conversion, when the conversion is actually just the
    195     /// initialization of an object via copy constructor. Such
    196     /// conversions are either identity conversions or derived-to-base
    197     /// conversions.
    198     CXXConstructorDecl *CopyConstructor;
    199 
    200     void setFromType(QualType T) { FromTypePtr = T.getAsOpaquePtr(); }
    201     void setToType(unsigned Idx, QualType T) {
    202       assert(Idx < 3 && "To type index is out of range");
    203       ToTypePtrs[Idx] = T.getAsOpaquePtr();
    204     }
    205     void setAllToTypes(QualType T) {
    206       ToTypePtrs[0] = T.getAsOpaquePtr();
    207       ToTypePtrs[1] = ToTypePtrs[0];
    208       ToTypePtrs[2] = ToTypePtrs[0];
    209     }
    210 
    211     QualType getFromType() const {
    212       return QualType::getFromOpaquePtr(FromTypePtr);
    213     }
    214     QualType getToType(unsigned Idx) const {
    215       assert(Idx < 3 && "To type index is out of range");
    216       return QualType::getFromOpaquePtr(ToTypePtrs[Idx]);
    217     }
    218 
    219     void setAsIdentityConversion();
    220 
    221     bool isIdentityConversion() const {
    222       return Second == ICK_Identity && Third == ICK_Identity;
    223     }
    224 
    225     ImplicitConversionRank getRank() const;
    226     NarrowingKind getNarrowingKind(ASTContext &Context, const Expr *Converted,
    227                                    APValue &ConstantValue,
    228                                    QualType &ConstantType) const;
    229     bool isPointerConversionToBool() const;
    230     bool isPointerConversionToVoidPointer(ASTContext& Context) const;
    231     void dump() const;
    232   };
    233 
    234   /// UserDefinedConversionSequence - Represents a user-defined
    235   /// conversion sequence (C++ 13.3.3.1.2).
    236   struct UserDefinedConversionSequence {
    237     /// \brief Represents the standard conversion that occurs before
    238     /// the actual user-defined conversion.
    239     ///
    240     /// C++11 13.3.3.1.2p1:
    241     ///   If the user-defined conversion is specified by a constructor
    242     ///   (12.3.1), the initial standard conversion sequence converts
    243     ///   the source type to the type required by the argument of the
    244     ///   constructor. If the user-defined conversion is specified by
    245     ///   a conversion function (12.3.2), the initial standard
    246     ///   conversion sequence converts the source type to the implicit
    247     ///   object parameter of the conversion function.
    248     StandardConversionSequence Before;
    249 
    250     /// EllipsisConversion - When this is true, it means user-defined
    251     /// conversion sequence starts with a ... (ellipsis) conversion, instead of
    252     /// a standard conversion. In this case, 'Before' field must be ignored.
    253     // FIXME. I much rather put this as the first field. But there seems to be
    254     // a gcc code gen. bug which causes a crash in a test. Putting it here seems
    255     // to work around the crash.
    256     bool EllipsisConversion : 1;
    257 
    258     /// HadMultipleCandidates - When this is true, it means that the
    259     /// conversion function was resolved from an overloaded set having
    260     /// size greater than 1.
    261     bool HadMultipleCandidates : 1;
    262 
    263     /// After - Represents the standard conversion that occurs after
    264     /// the actual user-defined conversion.
    265     StandardConversionSequence After;
    266 
    267     /// ConversionFunction - The function that will perform the
    268     /// user-defined conversion. Null if the conversion is an
    269     /// aggregate initialization from an initializer list.
    270     FunctionDecl* ConversionFunction;
    271 
    272     /// \brief The declaration that we found via name lookup, which might be
    273     /// the same as \c ConversionFunction or it might be a using declaration
    274     /// that refers to \c ConversionFunction.
    275     DeclAccessPair FoundConversionFunction;
    276 
    277     void dump() const;
    278   };
    279 
    280   /// Represents an ambiguous user-defined conversion sequence.
    281   struct AmbiguousConversionSequence {
    282     typedef SmallVector<FunctionDecl*, 4> ConversionSet;
    283 
    284     void *FromTypePtr;
    285     void *ToTypePtr;
    286     char Buffer[sizeof(ConversionSet)];
    287 
    288     QualType getFromType() const {
    289       return QualType::getFromOpaquePtr(FromTypePtr);
    290     }
    291     QualType getToType() const {
    292       return QualType::getFromOpaquePtr(ToTypePtr);
    293     }
    294     void setFromType(QualType T) { FromTypePtr = T.getAsOpaquePtr(); }
    295     void setToType(QualType T) { ToTypePtr = T.getAsOpaquePtr(); }
    296 
    297     ConversionSet &conversions() {
    298       return *reinterpret_cast<ConversionSet*>(Buffer);
    299     }
    300 
    301     const ConversionSet &conversions() const {
    302       return *reinterpret_cast<const ConversionSet*>(Buffer);
    303     }
    304 
    305     void addConversion(FunctionDecl *D) {
    306       conversions().push_back(D);
    307     }
    308 
    309     typedef ConversionSet::iterator iterator;
    310     iterator begin() { return conversions().begin(); }
    311     iterator end() { return conversions().end(); }
    312 
    313     typedef ConversionSet::const_iterator const_iterator;
    314     const_iterator begin() const { return conversions().begin(); }
    315     const_iterator end() const { return conversions().end(); }
    316 
    317     void construct();
    318     void destruct();
    319     void copyFrom(const AmbiguousConversionSequence &);
    320   };
    321 
    322   /// BadConversionSequence - Records information about an invalid
    323   /// conversion sequence.
    324   struct BadConversionSequence {
    325     enum FailureKind {
    326       no_conversion,
    327       unrelated_class,
    328       bad_qualifiers,
    329       lvalue_ref_to_rvalue,
    330       rvalue_ref_to_lvalue
    331     };
    332 
    333     // This can be null, e.g. for implicit object arguments.
    334     Expr *FromExpr;
    335 
    336     FailureKind Kind;
    337 
    338   private:
    339     // The type we're converting from (an opaque QualType).
    340     void *FromTy;
    341 
    342     // The type we're converting to (an opaque QualType).
    343     void *ToTy;
    344 
    345   public:
    346     void init(FailureKind K, Expr *From, QualType To) {
    347       init(K, From->getType(), To);
    348       FromExpr = From;
    349     }
    350     void init(FailureKind K, QualType From, QualType To) {
    351       Kind = K;
    352       FromExpr = nullptr;
    353       setFromType(From);
    354       setToType(To);
    355     }
    356 
    357     QualType getFromType() const { return QualType::getFromOpaquePtr(FromTy); }
    358     QualType getToType() const { return QualType::getFromOpaquePtr(ToTy); }
    359 
    360     void setFromExpr(Expr *E) {
    361       FromExpr = E;
    362       setFromType(E->getType());
    363     }
    364     void setFromType(QualType T) { FromTy = T.getAsOpaquePtr(); }
    365     void setToType(QualType T) { ToTy = T.getAsOpaquePtr(); }
    366   };
    367 
    368   /// ImplicitConversionSequence - Represents an implicit conversion
    369   /// sequence, which may be a standard conversion sequence
    370   /// (C++ 13.3.3.1.1), user-defined conversion sequence (C++ 13.3.3.1.2),
    371   /// or an ellipsis conversion sequence (C++ 13.3.3.1.3).
    372   class ImplicitConversionSequence {
    373   public:
    374     /// Kind - The kind of implicit conversion sequence. BadConversion
    375     /// specifies that there is no conversion from the source type to
    376     /// the target type.  AmbiguousConversion represents the unique
    377     /// ambiguous conversion (C++0x [over.best.ics]p10).
    378     enum Kind {
    379       StandardConversion = 0,
    380       UserDefinedConversion,
    381       AmbiguousConversion,
    382       EllipsisConversion,
    383       BadConversion
    384     };
    385 
    386   private:
    387     enum {
    388       Uninitialized = BadConversion + 1
    389     };
    390 
    391     /// ConversionKind - The kind of implicit conversion sequence.
    392     unsigned ConversionKind : 30;
    393 
    394     /// \brief Whether the target is really a std::initializer_list, and the
    395     /// sequence only represents the worst element conversion.
    396     bool StdInitializerListElement : 1;
    397 
    398     void setKind(Kind K) {
    399       destruct();
    400       ConversionKind = K;
    401     }
    402 
    403     void destruct() {
    404       if (ConversionKind == AmbiguousConversion) Ambiguous.destruct();
    405     }
    406 
    407   public:
    408     union {
    409       /// When ConversionKind == StandardConversion, provides the
    410       /// details of the standard conversion sequence.
    411       StandardConversionSequence Standard;
    412 
    413       /// When ConversionKind == UserDefinedConversion, provides the
    414       /// details of the user-defined conversion sequence.
    415       UserDefinedConversionSequence UserDefined;
    416 
    417       /// When ConversionKind == AmbiguousConversion, provides the
    418       /// details of the ambiguous conversion.
    419       AmbiguousConversionSequence Ambiguous;
    420 
    421       /// When ConversionKind == BadConversion, provides the details
    422       /// of the bad conversion.
    423       BadConversionSequence Bad;
    424     };
    425 
    426     ImplicitConversionSequence()
    427       : ConversionKind(Uninitialized), StdInitializerListElement(false)
    428     {}
    429     ~ImplicitConversionSequence() {
    430       destruct();
    431     }
    432     ImplicitConversionSequence(const ImplicitConversionSequence &Other)
    433       : ConversionKind(Other.ConversionKind),
    434         StdInitializerListElement(Other.StdInitializerListElement)
    435     {
    436       switch (ConversionKind) {
    437       case Uninitialized: break;
    438       case StandardConversion: Standard = Other.Standard; break;
    439       case UserDefinedConversion: UserDefined = Other.UserDefined; break;
    440       case AmbiguousConversion: Ambiguous.copyFrom(Other.Ambiguous); break;
    441       case EllipsisConversion: break;
    442       case BadConversion: Bad = Other.Bad; break;
    443       }
    444     }
    445 
    446     ImplicitConversionSequence &
    447         operator=(const ImplicitConversionSequence &Other) {
    448       destruct();
    449       new (this) ImplicitConversionSequence(Other);
    450       return *this;
    451     }
    452 
    453     Kind getKind() const {
    454       assert(isInitialized() && "querying uninitialized conversion");
    455       return Kind(ConversionKind);
    456     }
    457 
    458     /// \brief Return a ranking of the implicit conversion sequence
    459     /// kind, where smaller ranks represent better conversion
    460     /// sequences.
    461     ///
    462     /// In particular, this routine gives user-defined conversion
    463     /// sequences and ambiguous conversion sequences the same rank,
    464     /// per C++ [over.best.ics]p10.
    465     unsigned getKindRank() const {
    466       switch (getKind()) {
    467       case StandardConversion:
    468         return 0;
    469 
    470       case UserDefinedConversion:
    471       case AmbiguousConversion:
    472         return 1;
    473 
    474       case EllipsisConversion:
    475         return 2;
    476 
    477       case BadConversion:
    478         return 3;
    479       }
    480 
    481       llvm_unreachable("Invalid ImplicitConversionSequence::Kind!");
    482     }
    483 
    484     bool isBad() const { return getKind() == BadConversion; }
    485     bool isStandard() const { return getKind() == StandardConversion; }
    486     bool isEllipsis() const { return getKind() == EllipsisConversion; }
    487     bool isAmbiguous() const { return getKind() == AmbiguousConversion; }
    488     bool isUserDefined() const { return getKind() == UserDefinedConversion; }
    489     bool isFailure() const { return isBad() || isAmbiguous(); }
    490 
    491     /// Determines whether this conversion sequence has been
    492     /// initialized.  Most operations should never need to query
    493     /// uninitialized conversions and should assert as above.
    494     bool isInitialized() const { return ConversionKind != Uninitialized; }
    495 
    496     /// Sets this sequence as a bad conversion for an explicit argument.
    497     void setBad(BadConversionSequence::FailureKind Failure,
    498                 Expr *FromExpr, QualType ToType) {
    499       setKind(BadConversion);
    500       Bad.init(Failure, FromExpr, ToType);
    501     }
    502 
    503     /// Sets this sequence as a bad conversion for an implicit argument.
    504     void setBad(BadConversionSequence::FailureKind Failure,
    505                 QualType FromType, QualType ToType) {
    506       setKind(BadConversion);
    507       Bad.init(Failure, FromType, ToType);
    508     }
    509 
    510     void setStandard() { setKind(StandardConversion); }
    511     void setEllipsis() { setKind(EllipsisConversion); }
    512     void setUserDefined() { setKind(UserDefinedConversion); }
    513     void setAmbiguous() {
    514       if (ConversionKind == AmbiguousConversion) return;
    515       ConversionKind = AmbiguousConversion;
    516       Ambiguous.construct();
    517     }
    518 
    519     /// \brief Whether the target is really a std::initializer_list, and the
    520     /// sequence only represents the worst element conversion.
    521     bool isStdInitializerListElement() const {
    522       return StdInitializerListElement;
    523     }
    524 
    525     void setStdInitializerListElement(bool V = true) {
    526       StdInitializerListElement = V;
    527     }
    528 
    529     // The result of a comparison between implicit conversion
    530     // sequences. Use Sema::CompareImplicitConversionSequences to
    531     // actually perform the comparison.
    532     enum CompareKind {
    533       Better = -1,
    534       Indistinguishable = 0,
    535       Worse = 1
    536     };
    537 
    538     void DiagnoseAmbiguousConversion(Sema &S,
    539                                      SourceLocation CaretLoc,
    540                                      const PartialDiagnostic &PDiag) const;
    541 
    542     void dump() const;
    543   };
    544 
    545   enum OverloadFailureKind {
    546     ovl_fail_too_many_arguments,
    547     ovl_fail_too_few_arguments,
    548     ovl_fail_bad_conversion,
    549     ovl_fail_bad_deduction,
    550 
    551     /// This conversion candidate was not considered because it
    552     /// duplicates the work of a trivial or derived-to-base
    553     /// conversion.
    554     ovl_fail_trivial_conversion,
    555 
    556     /// This conversion candidate was not considered because it is
    557     /// an illegal instantiation of a constructor temploid: it is
    558     /// callable with one argument, we only have one argument, and
    559     /// its first parameter type is exactly the type of the class.
    560     ///
    561     /// Defining such a constructor directly is illegal, and
    562     /// template-argument deduction is supposed to ignore such
    563     /// instantiations, but we can still get one with the right
    564     /// kind of implicit instantiation.
    565     ovl_fail_illegal_constructor,
    566 
    567     /// This conversion candidate is not viable because its result
    568     /// type is not implicitly convertible to the desired type.
    569     ovl_fail_bad_final_conversion,
    570 
    571     /// This conversion function template specialization candidate is not
    572     /// viable because the final conversion was not an exact match.
    573     ovl_fail_final_conversion_not_exact,
    574 
    575     /// (CUDA) This candidate was not viable because the callee
    576     /// was not accessible from the caller's target (i.e. host->device,
    577     /// global->host, device->host).
    578     ovl_fail_bad_target,
    579 
    580     /// This candidate function was not viable because an enable_if
    581     /// attribute disabled it.
    582     ovl_fail_enable_if
    583   };
    584 
    585   /// OverloadCandidate - A single candidate in an overload set (C++ 13.3).
    586   struct OverloadCandidate {
    587     /// Function - The actual function that this candidate
    588     /// represents. When NULL, this is a built-in candidate
    589     /// (C++ [over.oper]) or a surrogate for a conversion to a
    590     /// function pointer or reference (C++ [over.call.object]).
    591     FunctionDecl *Function;
    592 
    593     /// FoundDecl - The original declaration that was looked up /
    594     /// invented / otherwise found, together with its access.
    595     /// Might be a UsingShadowDecl or a FunctionTemplateDecl.
    596     DeclAccessPair FoundDecl;
    597 
    598     // BuiltinTypes - Provides the return and parameter types of a
    599     // built-in overload candidate. Only valid when Function is NULL.
    600     struct {
    601       QualType ResultTy;
    602       QualType ParamTypes[3];
    603     } BuiltinTypes;
    604 
    605     /// Surrogate - The conversion function for which this candidate
    606     /// is a surrogate, but only if IsSurrogate is true.
    607     CXXConversionDecl *Surrogate;
    608 
    609     /// Conversions - The conversion sequences used to convert the
    610     /// function arguments to the function parameters, the pointer points to a
    611     /// fixed size array with NumConversions elements. The memory is owned by
    612     /// the OverloadCandidateSet.
    613     ImplicitConversionSequence *Conversions;
    614 
    615     /// The FixIt hints which can be used to fix the Bad candidate.
    616     ConversionFixItGenerator Fix;
    617 
    618     /// NumConversions - The number of elements in the Conversions array.
    619     unsigned NumConversions;
    620 
    621     /// Viable - True to indicate that this overload candidate is viable.
    622     bool Viable;
    623 
    624     /// IsSurrogate - True to indicate that this candidate is a
    625     /// surrogate for a conversion to a function pointer or reference
    626     /// (C++ [over.call.object]).
    627     bool IsSurrogate;
    628 
    629     /// IgnoreObjectArgument - True to indicate that the first
    630     /// argument's conversion, which for this function represents the
    631     /// implicit object argument, should be ignored. This will be true
    632     /// when the candidate is a static member function (where the
    633     /// implicit object argument is just a placeholder) or a
    634     /// non-static member function when the call doesn't have an
    635     /// object argument.
    636     bool IgnoreObjectArgument;
    637 
    638     /// FailureKind - The reason why this candidate is not viable.
    639     /// Actually an OverloadFailureKind.
    640     unsigned char FailureKind;
    641 
    642     /// \brief The number of call arguments that were explicitly provided,
    643     /// to be used while performing partial ordering of function templates.
    644     unsigned ExplicitCallArguments;
    645 
    646     union {
    647       DeductionFailureInfo DeductionFailure;
    648 
    649       /// FinalConversion - For a conversion function (where Function is
    650       /// a CXXConversionDecl), the standard conversion that occurs
    651       /// after the call to the overload candidate to convert the result
    652       /// of calling the conversion function to the required type.
    653       StandardConversionSequence FinalConversion;
    654     };
    655 
    656     /// hasAmbiguousConversion - Returns whether this overload
    657     /// candidate requires an ambiguous conversion or not.
    658     bool hasAmbiguousConversion() const {
    659       for (unsigned i = 0, e = NumConversions; i != e; ++i) {
    660         if (!Conversions[i].isInitialized()) return false;
    661         if (Conversions[i].isAmbiguous()) return true;
    662       }
    663       return false;
    664     }
    665 
    666     bool TryToFixBadConversion(unsigned Idx, Sema &S) {
    667       bool CanFix = Fix.tryToFixConversion(
    668                       Conversions[Idx].Bad.FromExpr,
    669                       Conversions[Idx].Bad.getFromType(),
    670                       Conversions[Idx].Bad.getToType(), S);
    671 
    672       // If at least one conversion fails, the candidate cannot be fixed.
    673       if (!CanFix)
    674         Fix.clear();
    675 
    676       return CanFix;
    677     }
    678 
    679     unsigned getNumParams() const {
    680       if (IsSurrogate) {
    681         auto STy = Surrogate->getConversionType();
    682         while (STy->isPointerType() || STy->isReferenceType())
    683           STy = STy->getPointeeType();
    684         return STy->getAs<FunctionProtoType>()->getNumParams();
    685       }
    686       if (Function)
    687         return Function->getNumParams();
    688       return ExplicitCallArguments;
    689     }
    690   };
    691 
    692   /// OverloadCandidateSet - A set of overload candidates, used in C++
    693   /// overload resolution (C++ 13.3).
    694   class OverloadCandidateSet {
    695   public:
    696     enum CandidateSetKind {
    697       /// Normal lookup.
    698       CSK_Normal,
    699       /// Lookup for candidates for a call using operator syntax. Candidates
    700       /// that have no parameters of class type will be skipped unless there
    701       /// is a parameter of (reference to) enum type and the corresponding
    702       /// argument is of the same enum type.
    703       CSK_Operator
    704     };
    705 
    706   private:
    707     SmallVector<OverloadCandidate, 16> Candidates;
    708     llvm::SmallPtrSet<Decl *, 16> Functions;
    709 
    710     // Allocator for OverloadCandidate::Conversions. We store the first few
    711     // elements inline to avoid allocation for small sets.
    712     llvm::BumpPtrAllocator ConversionSequenceAllocator;
    713 
    714     SourceLocation Loc;
    715     CandidateSetKind Kind;
    716 
    717     unsigned NumInlineSequences;
    718     llvm::AlignedCharArray<llvm::AlignOf<ImplicitConversionSequence>::Alignment,
    719                            16 * sizeof(ImplicitConversionSequence)> InlineSpace;
    720 
    721     OverloadCandidateSet(const OverloadCandidateSet &) = delete;
    722     void operator=(const OverloadCandidateSet &) = delete;
    723 
    724     void destroyCandidates();
    725 
    726   public:
    727     OverloadCandidateSet(SourceLocation Loc, CandidateSetKind CSK)
    728         : Loc(Loc), Kind(CSK), NumInlineSequences(0) {}
    729     ~OverloadCandidateSet() { destroyCandidates(); }
    730 
    731     SourceLocation getLocation() const { return Loc; }
    732     CandidateSetKind getKind() const { return Kind; }
    733 
    734     /// \brief Determine when this overload candidate will be new to the
    735     /// overload set.
    736     bool isNewCandidate(Decl *F) {
    737       return Functions.insert(F->getCanonicalDecl()).second;
    738     }
    739 
    740     /// \brief Clear out all of the candidates.
    741     void clear();
    742 
    743     typedef SmallVectorImpl<OverloadCandidate>::iterator iterator;
    744     iterator begin() { return Candidates.begin(); }
    745     iterator end() { return Candidates.end(); }
    746 
    747     size_t size() const { return Candidates.size(); }
    748     bool empty() const { return Candidates.empty(); }
    749 
    750     /// \brief Add a new candidate with NumConversions conversion sequence slots
    751     /// to the overload set.
    752     OverloadCandidate &addCandidate(unsigned NumConversions = 0) {
    753       Candidates.push_back(OverloadCandidate());
    754       OverloadCandidate &C = Candidates.back();
    755 
    756       // Assign space from the inline array if there are enough free slots
    757       // available.
    758       if (NumConversions + NumInlineSequences <= 16) {
    759         ImplicitConversionSequence *I =
    760             (ImplicitConversionSequence *)InlineSpace.buffer;
    761         C.Conversions = &I[NumInlineSequences];
    762         NumInlineSequences += NumConversions;
    763       } else {
    764         // Otherwise get memory from the allocator.
    765         C.Conversions = ConversionSequenceAllocator
    766                           .Allocate<ImplicitConversionSequence>(NumConversions);
    767       }
    768 
    769       // Construct the new objects.
    770       for (unsigned i = 0; i != NumConversions; ++i)
    771         new (&C.Conversions[i]) ImplicitConversionSequence();
    772 
    773       C.NumConversions = NumConversions;
    774       return C;
    775     }
    776 
    777     /// Find the best viable function on this overload set, if it exists.
    778     OverloadingResult BestViableFunction(Sema &S, SourceLocation Loc,
    779                                          OverloadCandidateSet::iterator& Best,
    780                                          bool UserDefinedConversion = false);
    781 
    782     void NoteCandidates(Sema &S,
    783                         OverloadCandidateDisplayKind OCD,
    784                         ArrayRef<Expr *> Args,
    785                         StringRef Opc = "",
    786                         SourceLocation Loc = SourceLocation());
    787   };
    788 
    789   bool isBetterOverloadCandidate(Sema &S,
    790                                  const OverloadCandidate& Cand1,
    791                                  const OverloadCandidate& Cand2,
    792                                  SourceLocation Loc,
    793                                  bool UserDefinedConversion = false);
    794 } // end namespace clang
    795 
    796 #endif // LLVM_CLANG_SEMA_OVERLOAD_H
    797