Overload.h revision 7cc58b4c927fca539d43eaa58e00dca95946eb7c 
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 "llvm/ADT/SmallPtrSet.h"
26#include "llvm/ADT/SmallVector.h"
27
28namespace clang {
29  class ASTContext;
30  class CXXConstructorDecl;
31  class CXXConversionDecl;
32  class FunctionDecl;
33  class Sema;
34
35  /// OverloadingResult - Capture the result of performing overload
36  /// resolution.
37  enum OverloadingResult {
38    OR_Success,             ///< Overload resolution succeeded.
39    OR_No_Viable_Function,  ///< No viable function found.
40    OR_Ambiguous,           ///< Ambiguous candidates found.
41    OR_Deleted              ///< Succeeded, but refers to a deleted function.
42  };
43
44  enum OverloadCandidateDisplayKind {
45    /// Requests that all candidates be shown.  Viable candidates will
46    /// be printed first.
47    OCD_AllCandidates,
48
49    /// Requests that only viable candidates be shown.
50    OCD_ViableCandidates
51  };
52
53  /// ImplicitConversionKind - The kind of implicit conversion used to
54  /// convert an argument to a parameter's type. The enumerator values
55  /// match with Table 9 of (C++ 13.3.3.1.1) and are listed such that
56  /// better conversion kinds have smaller values.
57  enum ImplicitConversionKind {
58    ICK_Identity = 0,          ///< Identity conversion (no conversion)
59    ICK_Lvalue_To_Rvalue,      ///< Lvalue-to-rvalue conversion (C++ 4.1)
60    ICK_Array_To_Pointer,      ///< Array-to-pointer conversion (C++ 4.2)
61    ICK_Function_To_Pointer,   ///< Function-to-pointer (C++ 4.3)
62    ICK_NoReturn_Adjustment,   ///< Removal of noreturn from a type (Clang)
63    ICK_Qualification,         ///< Qualification conversions (C++ 4.4)
64    ICK_Integral_Promotion,    ///< Integral promotions (C++ 4.5)
65    ICK_Floating_Promotion,    ///< Floating point promotions (C++ 4.6)
66    ICK_Complex_Promotion,     ///< Complex promotions (Clang extension)
67    ICK_Integral_Conversion,   ///< Integral conversions (C++ 4.7)
68    ICK_Floating_Conversion,   ///< Floating point conversions (C++ 4.8)
69    ICK_Complex_Conversion,    ///< Complex conversions (C99 6.3.1.6)
70    ICK_Floating_Integral,     ///< Floating-integral conversions (C++ 4.9)
71    ICK_Pointer_Conversion,    ///< Pointer conversions (C++ 4.10)
72    ICK_Pointer_Member,        ///< Pointer-to-member conversions (C++ 4.11)
73    ICK_Boolean_Conversion,    ///< Boolean conversions (C++ 4.12)
74    ICK_Compatible_Conversion, ///< Conversions between compatible types in C99
75    ICK_Derived_To_Base,       ///< Derived-to-base (C++ [over.best.ics])
76    ICK_Vector_Conversion,     ///< Vector conversions
77    ICK_Vector_Splat,          ///< A vector splat from an arithmetic type
78    ICK_Complex_Real,          ///< Complex-real conversions (C99 6.3.1.7)
79    ICK_Block_Pointer_Conversion,    ///< Block Pointer conversions
80    ICK_TransparentUnionConversion, /// Transparent Union Conversions
81    ICK_Writeback_Conversion,  ///< Objective-C ARC writeback conversion
82    ICK_Num_Conversion_Kinds   ///< The number of conversion kinds
83  };
84
85  /// ImplicitConversionCategory - The category of an implicit
86  /// conversion kind. The enumerator values match with Table 9 of
87  /// (C++ 13.3.3.1.1) and are listed such that better conversion
88  /// categories have smaller values.
89  enum ImplicitConversionCategory {
90    ICC_Identity = 0,              ///< Identity
91    ICC_Lvalue_Transformation,     ///< Lvalue transformation
92    ICC_Qualification_Adjustment,  ///< Qualification adjustment
93    ICC_Promotion,                 ///< Promotion
94    ICC_Conversion                 ///< Conversion
95  };
96
97  ImplicitConversionCategory
98  GetConversionCategory(ImplicitConversionKind Kind);
99
100  /// ImplicitConversionRank - The rank of an implicit conversion
101  /// kind. The enumerator values match with Table 9 of (C++
102  /// 13.3.3.1.1) and are listed such that better conversion ranks
103  /// have smaller values.
104  enum ImplicitConversionRank {
105    ICR_Exact_Match = 0,         ///< Exact Match
106    ICR_Promotion,               ///< Promotion
107    ICR_Conversion,              ///< Conversion
108    ICR_Complex_Real_Conversion, ///< Complex <-> Real conversion
109    ICR_Writeback_Conversion     ///< ObjC ARC writeback conversion
110  };
111
112  ImplicitConversionRank GetConversionRank(ImplicitConversionKind Kind);
113
114  /// StandardConversionSequence - represents a standard conversion
115  /// sequence (C++ 13.3.3.1.1). A standard conversion sequence
116  /// contains between zero and three conversions. If a particular
117  /// conversion is not needed, it will be set to the identity conversion
118  /// (ICK_Identity). Note that the three conversions are
119  /// specified as separate members (rather than in an array) so that
120  /// we can keep the size of a standard conversion sequence to a
121  /// single word.
122  class StandardConversionSequence {
123  public:
124    /// First -- The first conversion can be an lvalue-to-rvalue
125    /// conversion, array-to-pointer conversion, or
126    /// function-to-pointer conversion.
127    ImplicitConversionKind First : 8;
128
129    /// Second - The second conversion can be an integral promotion,
130    /// floating point promotion, integral conversion, floating point
131    /// conversion, floating-integral conversion, pointer conversion,
132    /// pointer-to-member conversion, or boolean conversion.
133    ImplicitConversionKind Second : 8;
134
135    /// Third - The third conversion can be a qualification conversion.
136    ImplicitConversionKind Third : 8;
137
138    /// \brief Whether this is the deprecated conversion of a
139    /// string literal to a pointer to non-const character data
140    /// (C++ 4.2p2).
141    unsigned DeprecatedStringLiteralToCharPtr : 1;
142
143    /// \brief Whether the qualification conversion involves a change in the
144    /// Objective-C lifetime (for automatic reference counting).
145    unsigned QualificationIncludesObjCLifetime : 1;
146
147    /// IncompatibleObjC - Whether this is an Objective-C conversion
148    /// that we should warn about (if we actually use it).
149    unsigned IncompatibleObjC : 1;
150
151    /// ReferenceBinding - True when this is a reference binding
152    /// (C++ [over.ics.ref]).
153    unsigned ReferenceBinding : 1;
154
155    /// DirectBinding - True when this is a reference binding that is a
156    /// direct binding (C++ [dcl.init.ref]).
157    unsigned DirectBinding : 1;
158
159    /// \brief Whether this is an lvalue reference binding (otherwise, it's
160    /// an rvalue reference binding).
161    unsigned IsLvalueReference : 1;
162
163    /// \brief Whether we're binding to a function lvalue.
164    unsigned BindsToFunctionLvalue : 1;
165
166    /// \brief Whether we're binding to an rvalue.
167    unsigned BindsToRvalue : 1;
168
169    /// \brief Whether this binds an implicit object argument to a
170    /// non-static member function without a ref-qualifier.
171    unsigned BindsImplicitObjectArgumentWithoutRefQualifier : 1;
172
173    /// \brief Whether this binds a reference to an object with a different
174    /// Objective-C lifetime qualifier.
175    unsigned ObjCLifetimeConversionBinding : 1;
176
177    /// FromType - The type that this conversion is converting
178    /// from. This is an opaque pointer that can be translated into a
179    /// QualType.
180    void *FromTypePtr;
181
182    /// ToType - The types that this conversion is converting to in
183    /// each step. This is an opaque pointer that can be translated
184    /// into a QualType.
185    void *ToTypePtrs[3];
186
187    /// CopyConstructor - The copy constructor that is used to perform
188    /// this conversion, when the conversion is actually just the
189    /// initialization of an object via copy constructor. Such
190    /// conversions are either identity conversions or derived-to-base
191    /// conversions.
192    CXXConstructorDecl *CopyConstructor;
193
194    void setFromType(QualType T) { FromTypePtr = T.getAsOpaquePtr(); }
195    void setToType(unsigned Idx, QualType T) {
196      assert(Idx < 3 && "To type index is out of range");
197      ToTypePtrs[Idx] = T.getAsOpaquePtr();
198    }
199    void setAllToTypes(QualType T) {
200      ToTypePtrs[0] = T.getAsOpaquePtr();
201      ToTypePtrs[1] = ToTypePtrs[0];
202      ToTypePtrs[2] = ToTypePtrs[0];
203    }
204
205    QualType getFromType() const {
206      return QualType::getFromOpaquePtr(FromTypePtr);
207    }
208    QualType getToType(unsigned Idx) const {
209      assert(Idx < 3 && "To type index is out of range");
210      return QualType::getFromOpaquePtr(ToTypePtrs[Idx]);
211    }
212
213    void setAsIdentityConversion();
214
215    bool isIdentityConversion() const {
216      return Second == ICK_Identity && Third == ICK_Identity;
217    }
218
219    ImplicitConversionRank getRank() const;
220    bool isPointerConversionToBool() const;
221    bool isPointerConversionToVoidPointer(ASTContext& Context) const;
222    void DebugPrint() const;
223  };
224
225  /// UserDefinedConversionSequence - Represents a user-defined
226  /// conversion sequence (C++ 13.3.3.1.2).
227  struct UserDefinedConversionSequence {
228    /// Before - Represents the standard conversion that occurs before
229    /// the actual user-defined conversion. (C++ 13.3.3.1.2p1):
230    ///
231    ///   If the user-defined conversion is specified by a constructor
232    ///   (12.3.1), the initial standard conversion sequence converts
233    ///   the source type to the type required by the argument of the
234    ///   constructor. If the user-defined conversion is specified by
235    ///   a conversion function (12.3.2), the initial standard
236    ///   conversion sequence converts the source type to the implicit
237    ///   object parameter of the conversion function.
238    StandardConversionSequence Before;
239
240    /// EllipsisConversion - When this is true, it means user-defined
241    /// conversion sequence starts with a ... (elipsis) conversion, instead of
242    /// a standard conversion. In this case, 'Before' field must be ignored.
243    // FIXME. I much rather put this as the first field. But there seems to be
244    // a gcc code gen. bug which causes a crash in a test. Putting it here seems
245    // to work around the crash.
246    bool EllipsisConversion : 1;
247
248    /// HadMultipleCandidates - When this is true, it means that the
249    /// conversion function was resolved from an overloaded set having
250    /// size greater than 1.
251    bool HadMultipleCandidates : 1;
252
253    /// After - Represents the standard conversion that occurs after
254    /// the actual user-defined conversion.
255    StandardConversionSequence After;
256
257    /// ConversionFunction - The function that will perform the
258    /// user-defined conversion.
259    FunctionDecl* ConversionFunction;
260
261    /// \brief The declaration that we found via name lookup, which might be
262    /// the same as \c ConversionFunction or it might be a using declaration
263    /// that refers to \c ConversionFunction.
264    DeclAccessPair FoundConversionFunction;
265
266    void DebugPrint() const;
267  };
268
269  /// Represents an ambiguous user-defined conversion sequence.
270  struct AmbiguousConversionSequence {
271    typedef SmallVector<FunctionDecl*, 4> ConversionSet;
272
273    void *FromTypePtr;
274    void *ToTypePtr;
275    char Buffer[sizeof(ConversionSet)];
276
277    QualType getFromType() const {
278      return QualType::getFromOpaquePtr(FromTypePtr);
279    }
280    QualType getToType() const {
281      return QualType::getFromOpaquePtr(ToTypePtr);
282    }
283    void setFromType(QualType T) { FromTypePtr = T.getAsOpaquePtr(); }
284    void setToType(QualType T) { ToTypePtr = T.getAsOpaquePtr(); }
285
286    ConversionSet &conversions() {
287      return *reinterpret_cast<ConversionSet*>(Buffer);
288    }
289
290    const ConversionSet &conversions() const {
291      return *reinterpret_cast<const ConversionSet*>(Buffer);
292    }
293
294    void addConversion(FunctionDecl *D) {
295      conversions().push_back(D);
296    }
297
298    typedef ConversionSet::iterator iterator;
299    iterator begin() { return conversions().begin(); }
300    iterator end() { return conversions().end(); }
301
302    typedef ConversionSet::const_iterator const_iterator;
303    const_iterator begin() const { return conversions().begin(); }
304    const_iterator end() const { return conversions().end(); }
305
306    void construct();
307    void destruct();
308    void copyFrom(const AmbiguousConversionSequence &);
309  };
310
311  /// BadConversionSequence - Records information about an invalid
312  /// conversion sequence.
313  struct BadConversionSequence {
314    enum FailureKind {
315      no_conversion,
316      unrelated_class,
317      suppressed_user,
318      bad_qualifiers,
319      lvalue_ref_to_rvalue,
320      rvalue_ref_to_lvalue
321    };
322
323    // This can be null, e.g. for implicit object arguments.
324    Expr *FromExpr;
325
326    FailureKind Kind;
327
328  private:
329    // The type we're converting from (an opaque QualType).
330    void *FromTy;
331
332    // The type we're converting to (an opaque QualType).
333    void *ToTy;
334
335  public:
336    void init(FailureKind K, Expr *From, QualType To) {
337      init(K, From->getType(), To);
338      FromExpr = From;
339    }
340    void init(FailureKind K, QualType From, QualType To) {
341      Kind = K;
342      FromExpr = 0;
343      setFromType(From);
344      setToType(To);
345    }
346
347    QualType getFromType() const { return QualType::getFromOpaquePtr(FromTy); }
348    QualType getToType() const { return QualType::getFromOpaquePtr(ToTy); }
349
350    void setFromExpr(Expr *E) {
351      FromExpr = E;
352      setFromType(E->getType());
353    }
354    void setFromType(QualType T) { FromTy = T.getAsOpaquePtr(); }
355    void setToType(QualType T) { ToTy = T.getAsOpaquePtr(); }
356  };
357
358  /// ImplicitConversionSequence - Represents an implicit conversion
359  /// sequence, which may be a standard conversion sequence
360  /// (C++ 13.3.3.1.1), user-defined conversion sequence (C++ 13.3.3.1.2),
361  /// or an ellipsis conversion sequence (C++ 13.3.3.1.3).
362  class ImplicitConversionSequence {
363  public:
364    /// Kind - The kind of implicit conversion sequence. BadConversion
365    /// specifies that there is no conversion from the source type to
366    /// the target type.  AmbiguousConversion represents the unique
367    /// ambiguous conversion (C++0x [over.best.ics]p10).
368    enum Kind {
369      StandardConversion = 0,
370      UserDefinedConversion,
371      AmbiguousConversion,
372      EllipsisConversion,
373      BadConversion
374    };
375
376  private:
377    enum {
378      Uninitialized = BadConversion + 1
379    };
380
381    /// ConversionKind - The kind of implicit conversion sequence.
382    unsigned ConversionKind;
383
384    void setKind(Kind K) {
385      destruct();
386      ConversionKind = K;
387    }
388
389    void destruct() {
390      if (ConversionKind == AmbiguousConversion) Ambiguous.destruct();
391    }
392
393  public:
394    union {
395      /// When ConversionKind == StandardConversion, provides the
396      /// details of the standard conversion sequence.
397      StandardConversionSequence Standard;
398
399      /// When ConversionKind == UserDefinedConversion, provides the
400      /// details of the user-defined conversion sequence.
401      UserDefinedConversionSequence UserDefined;
402
403      /// When ConversionKind == AmbiguousConversion, provides the
404      /// details of the ambiguous conversion.
405      AmbiguousConversionSequence Ambiguous;
406
407      /// When ConversionKind == BadConversion, provides the details
408      /// of the bad conversion.
409      BadConversionSequence Bad;
410    };
411
412    ImplicitConversionSequence() : ConversionKind(Uninitialized) {}
413    ~ImplicitConversionSequence() {
414      destruct();
415    }
416    ImplicitConversionSequence(const ImplicitConversionSequence &Other)
417      : ConversionKind(Other.ConversionKind)
418    {
419      switch (ConversionKind) {
420      case Uninitialized: break;
421      case StandardConversion: Standard = Other.Standard; break;
422      case UserDefinedConversion: UserDefined = Other.UserDefined; break;
423      case AmbiguousConversion: Ambiguous.copyFrom(Other.Ambiguous); break;
424      case EllipsisConversion: break;
425      case BadConversion: Bad = Other.Bad; break;
426      }
427    }
428
429    ImplicitConversionSequence &
430        operator=(const ImplicitConversionSequence &Other) {
431      destruct();
432      new (this) ImplicitConversionSequence(Other);
433      return *this;
434    }
435
436    Kind getKind() const {
437      assert(isInitialized() && "querying uninitialized conversion");
438      return Kind(ConversionKind);
439    }
440
441    /// \brief Return a ranking of the implicit conversion sequence
442    /// kind, where smaller ranks represent better conversion
443    /// sequences.
444    ///
445    /// In particular, this routine gives user-defined conversion
446    /// sequences and ambiguous conversion sequences the same rank,
447    /// per C++ [over.best.ics]p10.
448    unsigned getKindRank() const {
449      switch (getKind()) {
450      case StandardConversion:
451        return 0;
452
453      case UserDefinedConversion:
454      case AmbiguousConversion:
455        return 1;
456
457      case EllipsisConversion:
458        return 2;
459
460      case BadConversion:
461        return 3;
462      }
463
464      return 3;
465    }
466
467    bool isBad() const { return getKind() == BadConversion; }
468    bool isStandard() const { return getKind() == StandardConversion; }
469    bool isEllipsis() const { return getKind() == EllipsisConversion; }
470    bool isAmbiguous() const { return getKind() == AmbiguousConversion; }
471    bool isUserDefined() const { return getKind() == UserDefinedConversion; }
472    bool isFailure() const { return isBad() || isAmbiguous(); }
473
474    /// Determines whether this conversion sequence has been
475    /// initialized.  Most operations should never need to query
476    /// uninitialized conversions and should assert as above.
477    bool isInitialized() const { return ConversionKind != Uninitialized; }
478
479    /// Sets this sequence as a bad conversion for an explicit argument.
480    void setBad(BadConversionSequence::FailureKind Failure,
481                Expr *FromExpr, QualType ToType) {
482      setKind(BadConversion);
483      Bad.init(Failure, FromExpr, ToType);
484    }
485
486    /// Sets this sequence as a bad conversion for an implicit argument.
487    void setBad(BadConversionSequence::FailureKind Failure,
488                QualType FromType, QualType ToType) {
489      setKind(BadConversion);
490      Bad.init(Failure, FromType, ToType);
491    }
492
493    void setStandard() { setKind(StandardConversion); }
494    void setEllipsis() { setKind(EllipsisConversion); }
495    void setUserDefined() { setKind(UserDefinedConversion); }
496    void setAmbiguous() {
497      if (ConversionKind == AmbiguousConversion) return;
498      ConversionKind = AmbiguousConversion;
499      Ambiguous.construct();
500    }
501
502    // The result of a comparison between implicit conversion
503    // sequences. Use Sema::CompareImplicitConversionSequences to
504    // actually perform the comparison.
505    enum CompareKind {
506      Better = -1,
507      Indistinguishable = 0,
508      Worse = 1
509    };
510
511    void DiagnoseAmbiguousConversion(Sema &S,
512                                     SourceLocation CaretLoc,
513                                     const PartialDiagnostic &PDiag) const;
514
515    void DebugPrint() const;
516  };
517
518  enum OverloadFailureKind {
519    ovl_fail_too_many_arguments,
520    ovl_fail_too_few_arguments,
521    ovl_fail_bad_conversion,
522    ovl_fail_bad_deduction,
523
524    /// This conversion candidate was not considered because it
525    /// duplicates the work of a trivial or derived-to-base
526    /// conversion.
527    ovl_fail_trivial_conversion,
528
529    /// This conversion candidate is not viable because its result
530    /// type is not implicitly convertible to the desired type.
531    ovl_fail_bad_final_conversion,
532
533    /// This conversion function template specialization candidate is not
534    /// viable because the final conversion was not an exact match.
535    ovl_fail_final_conversion_not_exact,
536
537    /// (CUDA) This candidate was not viable because the callee
538    /// was not accessible from the caller's target (i.e. host->device,
539    /// global->host, device->host).
540    ovl_fail_bad_target
541  };
542
543  /// OverloadCandidate - A single candidate in an overload set (C++ 13.3).
544  struct OverloadCandidate {
545    /// Function - The actual function that this candidate
546    /// represents. When NULL, this is a built-in candidate
547    /// (C++ [over.oper]) or a surrogate for a conversion to a
548    /// function pointer or reference (C++ [over.call.object]).
549    FunctionDecl *Function;
550
551    /// FoundDecl - The original declaration that was looked up /
552    /// invented / otherwise found, together with its access.
553    /// Might be a UsingShadowDecl or a FunctionTemplateDecl.
554    DeclAccessPair FoundDecl;
555
556    // BuiltinTypes - Provides the return and parameter types of a
557    // built-in overload candidate. Only valid when Function is NULL.
558    struct {
559      QualType ResultTy;
560      QualType ParamTypes[3];
561    } BuiltinTypes;
562
563    /// Surrogate - The conversion function for which this candidate
564    /// is a surrogate, but only if IsSurrogate is true.
565    CXXConversionDecl *Surrogate;
566
567    /// Conversions - The conversion sequences used to convert the
568    /// function arguments to the function parameters.
569    SmallVector<ImplicitConversionSequence, 4> Conversions;
570
571    /// The FixIt hints which can be used to fix the Bad candidate.
572    ConversionFixItGenerator Fix;
573
574    /// Viable - True to indicate that this overload candidate is viable.
575    bool Viable;
576
577    /// IsSurrogate - True to indicate that this candidate is a
578    /// surrogate for a conversion to a function pointer or reference
579    /// (C++ [over.call.object]).
580    bool IsSurrogate;
581
582    /// IgnoreObjectArgument - True to indicate that the first
583    /// argument's conversion, which for this function represents the
584    /// implicit object argument, should be ignored. This will be true
585    /// when the candidate is a static member function (where the
586    /// implicit object argument is just a placeholder) or a
587    /// non-static member function when the call doesn't have an
588    /// object argument.
589    bool IgnoreObjectArgument;
590
591    /// FailureKind - The reason why this candidate is not viable.
592    /// Actually an OverloadFailureKind.
593    unsigned char FailureKind;
594
595    /// \brief The number of call arguments that were explicitly provided,
596    /// to be used while performing partial ordering of function templates.
597    unsigned ExplicitCallArguments;
598
599    /// A structure used to record information about a failed
600    /// template argument deduction.
601    struct DeductionFailureInfo {
602      // A Sema::TemplateDeductionResult.
603      unsigned Result;
604
605      /// \brief Opaque pointer containing additional data about
606      /// this deduction failure.
607      void *Data;
608
609      /// \brief Retrieve the template parameter this deduction failure
610      /// refers to, if any.
611      TemplateParameter getTemplateParameter();
612
613      /// \brief Retrieve the template argument list associated with this
614      /// deduction failure, if any.
615      TemplateArgumentList *getTemplateArgumentList();
616
617      /// \brief Return the first template argument this deduction failure
618      /// refers to, if any.
619      const TemplateArgument *getFirstArg();
620
621      /// \brief Return the second template argument this deduction failure
622      /// refers to, if any.
623      const TemplateArgument *getSecondArg();
624
625      /// \brief Free any memory associated with this deduction failure.
626      void Destroy();
627    };
628
629    union {
630      DeductionFailureInfo DeductionFailure;
631
632      /// FinalConversion - For a conversion function (where Function is
633      /// a CXXConversionDecl), the standard conversion that occurs
634      /// after the call to the overload candidate to convert the result
635      /// of calling the conversion function to the required type.
636      StandardConversionSequence FinalConversion;
637    };
638
639    /// hasAmbiguousConversion - Returns whether this overload
640    /// candidate requires an ambiguous conversion or not.
641    bool hasAmbiguousConversion() const {
642      for (SmallVectorImpl<ImplicitConversionSequence>::const_iterator
643             I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
644        if (!I->isInitialized()) return false;
645        if (I->isAmbiguous()) return true;
646      }
647      return false;
648    }
649
650    bool TryToFixBadConversion(unsigned Idx, Sema &S) {
651      bool CanFix = Fix.tryToFixConversion(
652                      Conversions[Idx].Bad.FromExpr,
653                      Conversions[Idx].Bad.getFromType(),
654                      Conversions[Idx].Bad.getToType(), S);
655
656      // If at least one conversion fails, the candidate cannot be fixed.
657      if (!CanFix)
658        Fix.clear();
659
660      return CanFix;
661    }
662  };
663
664  /// OverloadCandidateSet - A set of overload candidates, used in C++
665  /// overload resolution (C++ 13.3).
666  class OverloadCandidateSet : public SmallVector<OverloadCandidate, 16> {
667    typedef SmallVector<OverloadCandidate, 16> inherited;
668    llvm::SmallPtrSet<Decl *, 16> Functions;
669
670    SourceLocation Loc;
671
672    OverloadCandidateSet(const OverloadCandidateSet &);
673    OverloadCandidateSet &operator=(const OverloadCandidateSet &);
674
675  public:
676    OverloadCandidateSet(SourceLocation Loc) : Loc(Loc) {}
677
678    SourceLocation getLocation() const { return Loc; }
679
680    /// \brief Determine when this overload candidate will be new to the
681    /// overload set.
682    bool isNewCandidate(Decl *F) {
683      return Functions.insert(F->getCanonicalDecl());
684    }
685
686    /// \brief Clear out all of the candidates.
687    void clear();
688
689    /// Find the best viable function on this overload set, if it exists.
690    OverloadingResult BestViableFunction(Sema &S, SourceLocation Loc,
691                                         OverloadCandidateSet::iterator& Best,
692                                         bool UserDefinedConversion = false);
693
694    void NoteCandidates(Sema &S,
695                        OverloadCandidateDisplayKind OCD,
696                        Expr **Args, unsigned NumArgs,
697                        const char *Opc = 0,
698                        SourceLocation Loc = SourceLocation());
699  };
700
701  bool isBetterOverloadCandidate(Sema &S,
702                                 const OverloadCandidate& Cand1,
703                                 const OverloadCandidate& Cand2,
704                                 SourceLocation Loc,
705                                 bool UserDefinedConversion = false);
706} // end namespace clang
707
708#endif // LLVM_CLANG_SEMA_OVERLOAD_H
709