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