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