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
31namespace 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
890