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