1 //===--- Overload.h - C++ Overloading ---------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the data structures and types used in C++
11 // overload resolution.
13 //===----------------------------------------------------------------------===//
15 #ifndef LLVM_CLANG_SEMA_OVERLOAD_H
16 #define LLVM_CLANG_SEMA_OVERLOAD_H
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"
33 class CXXConstructorDecl;
34 class CXXConversionDecl;
38 /// OverloadingResult - Capture the result of performing overload
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.
47 enum OverloadCandidateDisplayKind {
48 /// Requests that all candidates be shown. Viable candidates will
52 /// Requests that only viable candidates be shown.
56 /// ImplicitConversionKind - The kind of implicit conversion used to
57 /// convert an argument to a parameter's type. The enumerator values
58 /// match with Table 9 of (C++ 13.3.3.1.1) and are listed such that
59 /// better conversion kinds have smaller values.
60 enum ImplicitConversionKind {
61 ICK_Identity = 0, ///< Identity conversion (no conversion)
62 ICK_Lvalue_To_Rvalue, ///< Lvalue-to-rvalue conversion (C++ 4.1)
63 ICK_Array_To_Pointer, ///< Array-to-pointer conversion (C++ 4.2)
64 ICK_Function_To_Pointer, ///< Function-to-pointer (C++ 4.3)
65 ICK_NoReturn_Adjustment, ///< Removal of noreturn from a type (Clang)
66 ICK_Qualification, ///< Qualification conversions (C++ 4.4)
67 ICK_Integral_Promotion, ///< Integral promotions (C++ 4.5)
68 ICK_Floating_Promotion, ///< Floating point promotions (C++ 4.6)
69 ICK_Complex_Promotion, ///< Complex promotions (Clang extension)
70 ICK_Integral_Conversion, ///< Integral conversions (C++ 4.7)
71 ICK_Floating_Conversion, ///< Floating point conversions (C++ 4.8)
72 ICK_Complex_Conversion, ///< Complex conversions (C99 6.3.1.6)
73 ICK_Floating_Integral, ///< Floating-integral conversions (C++ 4.9)
74 ICK_Pointer_Conversion, ///< Pointer conversions (C++ 4.10)
75 ICK_Pointer_Member, ///< Pointer-to-member conversions (C++ 4.11)
76 ICK_Boolean_Conversion, ///< Boolean conversions (C++ 4.12)
77 ICK_Compatible_Conversion, ///< Conversions between compatible types in C99
78 ICK_Derived_To_Base, ///< Derived-to-base (C++ [over.best.ics])
79 ICK_Vector_Conversion, ///< Vector conversions
80 ICK_Vector_Splat, ///< A vector splat from an arithmetic type
81 ICK_Complex_Real, ///< Complex-real conversions (C99 6.3.1.7)
82 ICK_Block_Pointer_Conversion, ///< Block Pointer conversions
83 ICK_TransparentUnionConversion, ///< Transparent Union Conversions
84 ICK_Writeback_Conversion, ///< Objective-C ARC writeback conversion
85 ICK_Zero_Event_Conversion, ///< Zero constant to event (OpenCL1.2 6.12.10)
86 ICK_C_Only_Conversion, ///< Conversions allowed in C, but not C++
87 ICK_Num_Conversion_Kinds, ///< The number of conversion kinds
90 /// ImplicitConversionRank - The rank of an implicit conversion
91 /// kind. The enumerator values match with Table 9 of (C++
92 /// 13.3.3.1.1) and are listed such that better conversion ranks
93 /// have smaller values.
94 enum ImplicitConversionRank {
95 ICR_Exact_Match = 0, ///< Exact Match
96 ICR_Promotion, ///< Promotion
97 ICR_Conversion, ///< Conversion
98 ICR_Complex_Real_Conversion, ///< Complex <-> Real conversion
99 ICR_Writeback_Conversion, ///< ObjC ARC writeback conversion
100 ICR_C_Conversion ///< Conversion only allowed in the C standard.
101 /// (e.g. void* to char*)
104 ImplicitConversionRank GetConversionRank(ImplicitConversionKind Kind);
106 /// NarrowingKind - The kind of narrowing conversion being performed by a
107 /// standard conversion sequence according to C++11 [dcl.init.list]p7.
109 /// Not a narrowing conversion.
112 /// A narrowing conversion by virtue of the source and destination types.
115 /// A narrowing conversion, because a constant expression got narrowed.
116 NK_Constant_Narrowing,
118 /// A narrowing conversion, because a non-constant-expression variable might
119 /// have got narrowed.
120 NK_Variable_Narrowing
123 /// StandardConversionSequence - represents a standard conversion
124 /// sequence (C++ 13.3.3.1.1). A standard conversion sequence
125 /// contains between zero and three conversions. If a particular
126 /// conversion is not needed, it will be set to the identity conversion
127 /// (ICK_Identity). Note that the three conversions are
128 /// specified as separate members (rather than in an array) so that
129 /// we can keep the size of a standard conversion sequence to a
131 class StandardConversionSequence {
133 /// First -- The first conversion can be an lvalue-to-rvalue
134 /// conversion, array-to-pointer conversion, or
135 /// function-to-pointer conversion.
136 ImplicitConversionKind First : 8;
138 /// Second - The second conversion can be an integral promotion,
139 /// floating point promotion, integral conversion, floating point
140 /// conversion, floating-integral conversion, pointer conversion,
141 /// pointer-to-member conversion, or boolean conversion.
142 ImplicitConversionKind Second : 8;
144 /// Third - The third conversion can be a qualification conversion.
145 ImplicitConversionKind Third : 8;
147 /// \brief Whether this is the deprecated conversion of a
148 /// string literal to a pointer to non-const character data
150 unsigned DeprecatedStringLiteralToCharPtr : 1;
152 /// \brief Whether the qualification conversion involves a change in the
153 /// Objective-C lifetime (for automatic reference counting).
154 unsigned QualificationIncludesObjCLifetime : 1;
156 /// IncompatibleObjC - Whether this is an Objective-C conversion
157 /// that we should warn about (if we actually use it).
158 unsigned IncompatibleObjC : 1;
160 /// ReferenceBinding - True when this is a reference binding
161 /// (C++ [over.ics.ref]).
162 unsigned ReferenceBinding : 1;
164 /// DirectBinding - True when this is a reference binding that is a
165 /// direct binding (C++ [dcl.init.ref]).
166 unsigned DirectBinding : 1;
168 /// \brief Whether this is an lvalue reference binding (otherwise, it's
169 /// an rvalue reference binding).
170 unsigned IsLvalueReference : 1;
172 /// \brief Whether we're binding to a function lvalue.
173 unsigned BindsToFunctionLvalue : 1;
175 /// \brief Whether we're binding to an rvalue.
176 unsigned BindsToRvalue : 1;
178 /// \brief Whether this binds an implicit object argument to a
179 /// non-static member function without a ref-qualifier.
180 unsigned BindsImplicitObjectArgumentWithoutRefQualifier : 1;
182 /// \brief Whether this binds a reference to an object with a different
183 /// Objective-C lifetime qualifier.
184 unsigned ObjCLifetimeConversionBinding : 1;
186 /// FromType - The type that this conversion is converting
187 /// from. This is an opaque pointer that can be translated into a
191 /// ToType - The types that this conversion is converting to in
192 /// each step. This is an opaque pointer that can be translated
196 /// CopyConstructor - The copy constructor that is used to perform
197 /// this conversion, when the conversion is actually just the
198 /// initialization of an object via copy constructor. Such
199 /// conversions are either identity conversions or derived-to-base
201 CXXConstructorDecl *CopyConstructor;
202 DeclAccessPair FoundCopyConstructor;
204 void setFromType(QualType T) { FromTypePtr = T.getAsOpaquePtr(); }
205 void setToType(unsigned Idx, QualType T) {
206 assert(Idx < 3 && "To type index is out of range");
207 ToTypePtrs[Idx] = T.getAsOpaquePtr();
209 void setAllToTypes(QualType T) {
210 ToTypePtrs[0] = T.getAsOpaquePtr();
211 ToTypePtrs[1] = ToTypePtrs[0];
212 ToTypePtrs[2] = ToTypePtrs[0];
215 QualType getFromType() const {
216 return QualType::getFromOpaquePtr(FromTypePtr);
218 QualType getToType(unsigned Idx) const {
219 assert(Idx < 3 && "To type index is out of range");
220 return QualType::getFromOpaquePtr(ToTypePtrs[Idx]);
223 void setAsIdentityConversion();
225 bool isIdentityConversion() const {
226 return Second == ICK_Identity && Third == ICK_Identity;
229 ImplicitConversionRank getRank() const;
230 NarrowingKind getNarrowingKind(ASTContext &Context, const Expr *Converted,
231 APValue &ConstantValue,
232 QualType &ConstantType) const;
233 bool isPointerConversionToBool() const;
234 bool isPointerConversionToVoidPointer(ASTContext& Context) const;
238 /// UserDefinedConversionSequence - Represents a user-defined
239 /// conversion sequence (C++ 13.3.3.1.2).
240 struct UserDefinedConversionSequence {
241 /// \brief Represents the standard conversion that occurs before
242 /// the actual user-defined conversion.
244 /// C++11 13.3.3.1.2p1:
245 /// If the user-defined conversion is specified by a constructor
246 /// (12.3.1), the initial standard conversion sequence converts
247 /// the source type to the type required by the argument of the
248 /// constructor. If the user-defined conversion is specified by
249 /// a conversion function (12.3.2), the initial standard
250 /// conversion sequence converts the source type to the implicit
251 /// object parameter of the conversion function.
252 StandardConversionSequence Before;
254 /// EllipsisConversion - When this is true, it means user-defined
255 /// conversion sequence starts with a ... (ellipsis) conversion, instead of
256 /// a standard conversion. In this case, 'Before' field must be ignored.
257 // FIXME. I much rather put this as the first field. But there seems to be
258 // a gcc code gen. bug which causes a crash in a test. Putting it here seems
259 // to work around the crash.
260 bool EllipsisConversion : 1;
262 /// HadMultipleCandidates - When this is true, it means that the
263 /// conversion function was resolved from an overloaded set having
264 /// size greater than 1.
265 bool HadMultipleCandidates : 1;
267 /// After - Represents the standard conversion that occurs after
268 /// the actual user-defined conversion.
269 StandardConversionSequence After;
271 /// ConversionFunction - The function that will perform the
272 /// user-defined conversion. Null if the conversion is an
273 /// aggregate initialization from an initializer list.
274 FunctionDecl* ConversionFunction;
276 /// \brief The declaration that we found via name lookup, which might be
277 /// the same as \c ConversionFunction or it might be a using declaration
278 /// that refers to \c ConversionFunction.
279 DeclAccessPair FoundConversionFunction;
284 /// Represents an ambiguous user-defined conversion sequence.
285 struct AmbiguousConversionSequence {
286 typedef SmallVector<std::pair<NamedDecl*, FunctionDecl*>, 4> ConversionSet;
290 char Buffer[sizeof(ConversionSet)];
292 QualType getFromType() const {
293 return QualType::getFromOpaquePtr(FromTypePtr);
295 QualType getToType() const {
296 return QualType::getFromOpaquePtr(ToTypePtr);
298 void setFromType(QualType T) { FromTypePtr = T.getAsOpaquePtr(); }
299 void setToType(QualType T) { ToTypePtr = T.getAsOpaquePtr(); }
301 ConversionSet &conversions() {
302 return *reinterpret_cast<ConversionSet*>(Buffer);
305 const ConversionSet &conversions() const {
306 return *reinterpret_cast<const ConversionSet*>(Buffer);
309 void addConversion(NamedDecl *Found, FunctionDecl *D) {
310 conversions().push_back(std::make_pair(Found, D));
313 typedef ConversionSet::iterator iterator;
314 iterator begin() { return conversions().begin(); }
315 iterator end() { return conversions().end(); }
317 typedef ConversionSet::const_iterator const_iterator;
318 const_iterator begin() const { return conversions().begin(); }
319 const_iterator end() const { return conversions().end(); }
323 void copyFrom(const AmbiguousConversionSequence &);
326 /// BadConversionSequence - Records information about an invalid
327 /// conversion sequence.
328 struct BadConversionSequence {
333 lvalue_ref_to_rvalue,
337 // This can be null, e.g. for implicit object arguments.
343 // The type we're converting from (an opaque QualType).
346 // The type we're converting to (an opaque QualType).
350 void init(FailureKind K, Expr *From, QualType To) {
351 init(K, From->getType(), To);
354 void init(FailureKind K, QualType From, QualType To) {
361 QualType getFromType() const { return QualType::getFromOpaquePtr(FromTy); }
362 QualType getToType() const { return QualType::getFromOpaquePtr(ToTy); }
364 void setFromExpr(Expr *E) {
366 setFromType(E->getType());
368 void setFromType(QualType T) { FromTy = T.getAsOpaquePtr(); }
369 void setToType(QualType T) { ToTy = T.getAsOpaquePtr(); }
372 /// ImplicitConversionSequence - Represents an implicit conversion
373 /// sequence, which may be a standard conversion sequence
374 /// (C++ 13.3.3.1.1), user-defined conversion sequence (C++ 13.3.3.1.2),
375 /// or an ellipsis conversion sequence (C++ 13.3.3.1.3).
376 class ImplicitConversionSequence {
378 /// Kind - The kind of implicit conversion sequence. BadConversion
379 /// specifies that there is no conversion from the source type to
380 /// the target type. AmbiguousConversion represents the unique
381 /// ambiguous conversion (C++0x [over.best.ics]p10).
383 StandardConversion = 0,
384 UserDefinedConversion,
392 Uninitialized = BadConversion + 1
395 /// ConversionKind - The kind of implicit conversion sequence.
396 unsigned ConversionKind : 30;
398 /// \brief Whether the target is really a std::initializer_list, and the
399 /// sequence only represents the worst element conversion.
400 unsigned StdInitializerListElement : 1;
402 void setKind(Kind K) {
408 if (ConversionKind == AmbiguousConversion) Ambiguous.destruct();
413 /// When ConversionKind == StandardConversion, provides the
414 /// details of the standard conversion sequence.
415 StandardConversionSequence Standard;
417 /// When ConversionKind == UserDefinedConversion, provides the
418 /// details of the user-defined conversion sequence.
419 UserDefinedConversionSequence UserDefined;
421 /// When ConversionKind == AmbiguousConversion, provides the
422 /// details of the ambiguous conversion.
423 AmbiguousConversionSequence Ambiguous;
425 /// When ConversionKind == BadConversion, provides the details
426 /// of the bad conversion.
427 BadConversionSequence Bad;
430 ImplicitConversionSequence()
431 : ConversionKind(Uninitialized), StdInitializerListElement(false)
433 ~ImplicitConversionSequence() {
436 ImplicitConversionSequence(const ImplicitConversionSequence &Other)
437 : ConversionKind(Other.ConversionKind),
438 StdInitializerListElement(Other.StdInitializerListElement)
440 switch (ConversionKind) {
441 case Uninitialized: break;
442 case StandardConversion: Standard = Other.Standard; break;
443 case UserDefinedConversion: UserDefined = Other.UserDefined; break;
444 case AmbiguousConversion: Ambiguous.copyFrom(Other.Ambiguous); break;
445 case EllipsisConversion: break;
446 case BadConversion: Bad = Other.Bad; break;
450 ImplicitConversionSequence &
451 operator=(const ImplicitConversionSequence &Other) {
453 new (this) ImplicitConversionSequence(Other);
457 Kind getKind() const {
458 assert(isInitialized() && "querying uninitialized conversion");
459 return Kind(ConversionKind);
462 /// \brief Return a ranking of the implicit conversion sequence
463 /// kind, where smaller ranks represent better conversion
466 /// In particular, this routine gives user-defined conversion
467 /// sequences and ambiguous conversion sequences the same rank,
468 /// per C++ [over.best.ics]p10.
469 unsigned getKindRank() const {
471 case StandardConversion:
474 case UserDefinedConversion:
475 case AmbiguousConversion:
478 case EllipsisConversion:
485 llvm_unreachable("Invalid ImplicitConversionSequence::Kind!");
488 bool isBad() const { return getKind() == BadConversion; }
489 bool isStandard() const { return getKind() == StandardConversion; }
490 bool isEllipsis() const { return getKind() == EllipsisConversion; }
491 bool isAmbiguous() const { return getKind() == AmbiguousConversion; }
492 bool isUserDefined() const { return getKind() == UserDefinedConversion; }
493 bool isFailure() const { return isBad() || isAmbiguous(); }
495 /// Determines whether this conversion sequence has been
496 /// initialized. Most operations should never need to query
497 /// uninitialized conversions and should assert as above.
498 bool isInitialized() const { return ConversionKind != Uninitialized; }
500 /// Sets this sequence as a bad conversion for an explicit argument.
501 void setBad(BadConversionSequence::FailureKind Failure,
502 Expr *FromExpr, QualType ToType) {
503 setKind(BadConversion);
504 Bad.init(Failure, FromExpr, ToType);
507 /// Sets this sequence as a bad conversion for an implicit argument.
508 void setBad(BadConversionSequence::FailureKind Failure,
509 QualType FromType, QualType ToType) {
510 setKind(BadConversion);
511 Bad.init(Failure, FromType, ToType);
514 void setStandard() { setKind(StandardConversion); }
515 void setEllipsis() { setKind(EllipsisConversion); }
516 void setUserDefined() { setKind(UserDefinedConversion); }
517 void setAmbiguous() {
518 if (ConversionKind == AmbiguousConversion) return;
519 ConversionKind = AmbiguousConversion;
520 Ambiguous.construct();
523 /// \brief Whether the target is really a std::initializer_list, and the
524 /// sequence only represents the worst element conversion.
525 bool isStdInitializerListElement() const {
526 return StdInitializerListElement;
529 void setStdInitializerListElement(bool V = true) {
530 StdInitializerListElement = V;
533 // The result of a comparison between implicit conversion
534 // sequences. Use Sema::CompareImplicitConversionSequences to
535 // actually perform the comparison.
538 Indistinguishable = 0,
542 void DiagnoseAmbiguousConversion(Sema &S,
543 SourceLocation CaretLoc,
544 const PartialDiagnostic &PDiag) const;
549 enum OverloadFailureKind {
550 ovl_fail_too_many_arguments,
551 ovl_fail_too_few_arguments,
552 ovl_fail_bad_conversion,
553 ovl_fail_bad_deduction,
555 /// This conversion candidate was not considered because it
556 /// duplicates the work of a trivial or derived-to-base
558 ovl_fail_trivial_conversion,
560 /// This conversion candidate was not considered because it is
561 /// an illegal instantiation of a constructor temploid: it is
562 /// callable with one argument, we only have one argument, and
563 /// its first parameter type is exactly the type of the class.
565 /// Defining such a constructor directly is illegal, and
566 /// template-argument deduction is supposed to ignore such
567 /// instantiations, but we can still get one with the right
568 /// kind of implicit instantiation.
569 ovl_fail_illegal_constructor,
571 /// This conversion candidate is not viable because its result
572 /// type is not implicitly convertible to the desired type.
573 ovl_fail_bad_final_conversion,
575 /// This conversion function template specialization candidate is not
576 /// viable because the final conversion was not an exact match.
577 ovl_fail_final_conversion_not_exact,
579 /// (CUDA) This candidate was not viable because the callee
580 /// was not accessible from the caller's target (i.e. host->device,
581 /// global->host, device->host).
584 /// This candidate function was not viable because an enable_if
585 /// attribute disabled it.
588 /// This candidate was not viable because its address could not be taken.
589 ovl_fail_addr_not_available
592 /// OverloadCandidate - A single candidate in an overload set (C++ 13.3).
593 struct OverloadCandidate {
594 /// Function - The actual function that this candidate
595 /// represents. When NULL, this is a built-in candidate
596 /// (C++ [over.oper]) or a surrogate for a conversion to a
597 /// function pointer or reference (C++ [over.call.object]).
598 FunctionDecl *Function;
600 /// FoundDecl - The original declaration that was looked up /
601 /// invented / otherwise found, together with its access.
602 /// Might be a UsingShadowDecl or a FunctionTemplateDecl.
603 DeclAccessPair FoundDecl;
605 // BuiltinTypes - Provides the return and parameter types of a
606 // built-in overload candidate. Only valid when Function is NULL.
609 QualType ParamTypes[3];
612 /// Surrogate - The conversion function for which this candidate
613 /// is a surrogate, but only if IsSurrogate is true.
614 CXXConversionDecl *Surrogate;
616 /// Conversions - The conversion sequences used to convert the
617 /// function arguments to the function parameters, the pointer points to a
618 /// fixed size array with NumConversions elements. The memory is owned by
619 /// the OverloadCandidateSet.
620 ImplicitConversionSequence *Conversions;
622 /// The FixIt hints which can be used to fix the Bad candidate.
623 ConversionFixItGenerator Fix;
625 /// NumConversions - The number of elements in the Conversions array.
626 unsigned NumConversions;
628 /// Viable - True to indicate that this overload candidate is viable.
631 /// IsSurrogate - True to indicate that this candidate is a
632 /// surrogate for a conversion to a function pointer or reference
633 /// (C++ [over.call.object]).
636 /// IgnoreObjectArgument - True to indicate that the first
637 /// argument's conversion, which for this function represents the
638 /// implicit object argument, should be ignored. This will be true
639 /// when the candidate is a static member function (where the
640 /// implicit object argument is just a placeholder) or a
641 /// non-static member function when the call doesn't have an
643 bool IgnoreObjectArgument;
645 /// FailureKind - The reason why this candidate is not viable.
646 /// Actually an OverloadFailureKind.
647 unsigned char FailureKind;
649 /// \brief The number of call arguments that were explicitly provided,
650 /// to be used while performing partial ordering of function templates.
651 unsigned ExplicitCallArguments;
654 DeductionFailureInfo DeductionFailure;
656 /// FinalConversion - For a conversion function (where Function is
657 /// a CXXConversionDecl), the standard conversion that occurs
658 /// after the call to the overload candidate to convert the result
659 /// of calling the conversion function to the required type.
660 StandardConversionSequence FinalConversion;
663 /// hasAmbiguousConversion - Returns whether this overload
664 /// candidate requires an ambiguous conversion or not.
665 bool hasAmbiguousConversion() const {
666 for (unsigned i = 0, e = NumConversions; i != e; ++i) {
667 if (!Conversions[i].isInitialized()) return false;
668 if (Conversions[i].isAmbiguous()) return true;
673 bool TryToFixBadConversion(unsigned Idx, Sema &S) {
674 bool CanFix = Fix.tryToFixConversion(
675 Conversions[Idx].Bad.FromExpr,
676 Conversions[Idx].Bad.getFromType(),
677 Conversions[Idx].Bad.getToType(), S);
679 // If at least one conversion fails, the candidate cannot be fixed.
686 unsigned getNumParams() const {
688 auto STy = Surrogate->getConversionType();
689 while (STy->isPointerType() || STy->isReferenceType())
690 STy = STy->getPointeeType();
691 return STy->getAs<FunctionProtoType>()->getNumParams();
694 return Function->getNumParams();
695 return ExplicitCallArguments;
699 /// OverloadCandidateSet - A set of overload candidates, used in C++
700 /// overload resolution (C++ 13.3).
701 class OverloadCandidateSet {
703 enum CandidateSetKind {
706 /// Lookup for candidates for a call using operator syntax. Candidates
707 /// that have no parameters of class type will be skipped unless there
708 /// is a parameter of (reference to) enum type and the corresponding
709 /// argument is of the same enum type.
714 SmallVector<OverloadCandidate, 16> Candidates;
715 llvm::SmallPtrSet<Decl *, 16> Functions;
717 // Allocator for OverloadCandidate::Conversions. We store the first few
718 // elements inline to avoid allocation for small sets.
719 llvm::BumpPtrAllocator ConversionSequenceAllocator;
722 CandidateSetKind Kind;
724 unsigned NumInlineSequences;
725 llvm::AlignedCharArray<llvm::AlignOf<ImplicitConversionSequence>::Alignment,
726 16 * sizeof(ImplicitConversionSequence)> InlineSpace;
728 OverloadCandidateSet(const OverloadCandidateSet &) = delete;
729 void operator=(const OverloadCandidateSet &) = delete;
731 void destroyCandidates();
734 OverloadCandidateSet(SourceLocation Loc, CandidateSetKind CSK)
735 : Loc(Loc), Kind(CSK), NumInlineSequences(0) {}
736 ~OverloadCandidateSet() { destroyCandidates(); }
738 SourceLocation getLocation() const { return Loc; }
739 CandidateSetKind getKind() const { return Kind; }
741 /// \brief Determine when this overload candidate will be new to the
743 bool isNewCandidate(Decl *F) {
744 return Functions.insert(F->getCanonicalDecl()).second;
747 /// \brief Clear out all of the candidates.
750 typedef SmallVectorImpl<OverloadCandidate>::iterator iterator;
751 iterator begin() { return Candidates.begin(); }
752 iterator end() { return Candidates.end(); }
754 size_t size() const { return Candidates.size(); }
755 bool empty() const { return Candidates.empty(); }
757 /// \brief Add a new candidate with NumConversions conversion sequence slots
758 /// to the overload set.
759 OverloadCandidate &addCandidate(unsigned NumConversions = 0) {
760 Candidates.push_back(OverloadCandidate());
761 OverloadCandidate &C = Candidates.back();
763 // Assign space from the inline array if there are enough free slots
765 if (NumConversions + NumInlineSequences <= 16) {
766 ImplicitConversionSequence *I =
767 (ImplicitConversionSequence *)InlineSpace.buffer;
768 C.Conversions = &I[NumInlineSequences];
769 NumInlineSequences += NumConversions;
771 // Otherwise get memory from the allocator.
772 C.Conversions = ConversionSequenceAllocator
773 .Allocate<ImplicitConversionSequence>(NumConversions);
776 // Construct the new objects.
777 for (unsigned i = 0; i != NumConversions; ++i)
778 new (&C.Conversions[i]) ImplicitConversionSequence();
780 C.NumConversions = NumConversions;
784 /// Find the best viable function on this overload set, if it exists.
785 OverloadingResult BestViableFunction(Sema &S, SourceLocation Loc,
786 OverloadCandidateSet::iterator& Best,
787 bool UserDefinedConversion = false);
789 void NoteCandidates(Sema &S,
790 OverloadCandidateDisplayKind OCD,
791 ArrayRef<Expr *> Args,
793 SourceLocation Loc = SourceLocation());
796 bool isBetterOverloadCandidate(Sema &S,
797 const OverloadCandidate& Cand1,
798 const OverloadCandidate& Cand2,
800 bool UserDefinedConversion = false);
802 struct ConstructorInfo {
803 DeclAccessPair FoundDecl;
804 CXXConstructorDecl *Constructor;
805 FunctionTemplateDecl *ConstructorTmpl;
806 explicit operator bool() const { return Constructor; }
808 // FIXME: Add an AddOverloadCandidate / AddTemplateOverloadCandidate overload
809 // that takes one of these.
810 inline ConstructorInfo getConstructorInfo(NamedDecl *ND) {
811 if (isa<UsingDecl>(ND))
812 return ConstructorInfo{};
814 // For constructors, the access check is performed against the underlying
815 // declaration, not the found declaration.
816 auto *D = ND->getUnderlyingDecl();
817 ConstructorInfo Info = {DeclAccessPair::make(ND, D->getAccess()), nullptr,
819 Info.ConstructorTmpl = dyn_cast<FunctionTemplateDecl>(D);
820 if (Info.ConstructorTmpl)
821 D = Info.ConstructorTmpl->getTemplatedDecl();
822 Info.Constructor = dyn_cast<CXXConstructorDecl>(D);
825 } // end namespace clang
827 #endif // LLVM_CLANG_SEMA_OVERLOAD_H