clang  8.0.0svn
Overload.h
Go to the documentation of this file.
1 //===- Overload.h - C++ Overloading -----------------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines the data structures and types used in C++
11 // overload resolution.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_CLANG_SEMA_OVERLOAD_H
16 #define LLVM_CLANG_SEMA_OVERLOAD_H
17 
18 #include "clang/AST/Decl.h"
20 #include "clang/AST/DeclBase.h"
21 #include "clang/AST/DeclCXX.h"
22 #include "clang/AST/DeclTemplate.h"
23 #include "clang/AST/Expr.h"
24 #include "clang/AST/Type.h"
25 #include "clang/Basic/LLVM.h"
29 #include "llvm/ADT/ArrayRef.h"
30 #include "llvm/ADT/None.h"
31 #include "llvm/ADT/STLExtras.h"
32 #include "llvm/ADT/SmallPtrSet.h"
33 #include "llvm/ADT/SmallVector.h"
34 #include "llvm/ADT/StringRef.h"
35 #include "llvm/Support/AlignOf.h"
36 #include "llvm/Support/Allocator.h"
37 #include "llvm/Support/Casting.h"
38 #include "llvm/Support/ErrorHandling.h"
39 #include <cassert>
40 #include <cstddef>
41 #include <cstdint>
42 #include <utility>
43 
44 namespace clang {
45 
46 class APValue;
47 class ASTContext;
48 class Sema;
49 
50  /// OverloadingResult - Capture the result of performing overload
51  /// resolution.
53  /// Overload resolution succeeded.
55 
56  /// No viable function found.
58 
59  /// Ambiguous candidates found.
61 
62  /// Succeeded, but refers to a deleted function.
64  };
65 
67  /// Requests that all candidates be shown. Viable candidates will
68  /// be printed first.
70 
71  /// Requests that only viable candidates be shown.
73  };
74 
75  /// ImplicitConversionKind - The kind of implicit conversion used to
76  /// convert an argument to a parameter's type. The enumerator values
77  /// match with the table titled 'Conversions' in [over.ics.scs] and are listed
78  /// such that better conversion kinds have smaller values.
80  /// Identity conversion (no conversion)
82 
83  /// Lvalue-to-rvalue conversion (C++ [conv.lval])
85 
86  /// Array-to-pointer conversion (C++ [conv.array])
88 
89  /// Function-to-pointer (C++ [conv.array])
91 
92  /// Function pointer conversion (C++17 [conv.fctptr])
94 
95  /// Qualification conversions (C++ [conv.qual])
97 
98  /// Integral promotions (C++ [conv.prom])
100 
101  /// Floating point promotions (C++ [conv.fpprom])
103 
104  /// Complex promotions (Clang extension)
106 
107  /// Integral conversions (C++ [conv.integral])
109 
110  /// Floating point conversions (C++ [conv.double]
112 
113  /// Complex conversions (C99 6.3.1.6)
115 
116  /// Floating-integral conversions (C++ [conv.fpint])
118 
119  /// Pointer conversions (C++ [conv.ptr])
121 
122  /// Pointer-to-member conversions (C++ [conv.mem])
124 
125  /// Boolean conversions (C++ [conv.bool])
127 
128  /// Conversions between compatible types in C99
130 
131  /// Derived-to-base (C++ [over.best.ics])
133 
134  /// Vector conversions
136 
137  /// A vector splat from an arithmetic type
139 
140  /// Complex-real conversions (C99 6.3.1.7)
142 
143  /// Block Pointer conversions
145 
146  /// Transparent Union Conversions
148 
149  /// Objective-C ARC writeback conversion
151 
152  /// Zero constant to event (OpenCL1.2 6.12.10)
154 
155  /// Zero constant to queue
157 
158  /// Conversions allowed in C, but not C++
160 
161  /// C-only conversion between pointers with incompatible types
163 
164  /// The number of conversion kinds
166  };
167 
168  /// ImplicitConversionRank - The rank of an implicit conversion
169  /// kind. The enumerator values match with Table 9 of (C++
170  /// 13.3.3.1.1) and are listed such that better conversion ranks
171  /// have smaller values.
173  /// Exact Match
175 
176  /// Promotion
178 
179  /// Conversion
181 
182  /// OpenCL Scalar Widening
184 
185  /// Complex <-> Real conversion
187 
188  /// ObjC ARC writeback conversion
190 
191  /// Conversion only allowed in the C standard (e.g. void* to char*).
193 
194  /// Conversion not allowed by the C standard, but that we accept as an
195  /// extension anyway.
197  };
198 
200 
201  /// NarrowingKind - The kind of narrowing conversion being performed by a
202  /// standard conversion sequence according to C++11 [dcl.init.list]p7.
204  /// Not a narrowing conversion.
206 
207  /// A narrowing conversion by virtue of the source and destination types.
209 
210  /// A narrowing conversion, because a constant expression got narrowed.
212 
213  /// A narrowing conversion, because a non-constant-expression variable might
214  /// have got narrowed.
216 
217  /// Cannot tell whether this is a narrowing conversion because the
218  /// expression is value-dependent.
220  };
221 
222  /// StandardConversionSequence - represents a standard conversion
223  /// sequence (C++ 13.3.3.1.1). A standard conversion sequence
224  /// contains between zero and three conversions. If a particular
225  /// conversion is not needed, it will be set to the identity conversion
226  /// (ICK_Identity). Note that the three conversions are
227  /// specified as separate members (rather than in an array) so that
228  /// we can keep the size of a standard conversion sequence to a
229  /// single word.
231  public:
232  /// First -- The first conversion can be an lvalue-to-rvalue
233  /// conversion, array-to-pointer conversion, or
234  /// function-to-pointer conversion.
236 
237  /// Second - The second conversion can be an integral promotion,
238  /// floating point promotion, integral conversion, floating point
239  /// conversion, floating-integral conversion, pointer conversion,
240  /// pointer-to-member conversion, or boolean conversion.
242 
243  /// Third - The third conversion can be a qualification conversion
244  /// or a function conversion.
246 
247  /// Whether this is the deprecated conversion of a
248  /// string literal to a pointer to non-const character data
249  /// (C++ 4.2p2).
251 
252  /// Whether the qualification conversion involves a change in the
253  /// Objective-C lifetime (for automatic reference counting).
255 
256  /// IncompatibleObjC - Whether this is an Objective-C conversion
257  /// that we should warn about (if we actually use it).
258  unsigned IncompatibleObjC : 1;
259 
260  /// ReferenceBinding - True when this is a reference binding
261  /// (C++ [over.ics.ref]).
262  unsigned ReferenceBinding : 1;
263 
264  /// DirectBinding - True when this is a reference binding that is a
265  /// direct binding (C++ [dcl.init.ref]).
266  unsigned DirectBinding : 1;
267 
268  /// Whether this is an lvalue reference binding (otherwise, it's
269  /// an rvalue reference binding).
270  unsigned IsLvalueReference : 1;
271 
272  /// Whether we're binding to a function lvalue.
273  unsigned BindsToFunctionLvalue : 1;
274 
275  /// Whether we're binding to an rvalue.
276  unsigned BindsToRvalue : 1;
277 
278  /// Whether this binds an implicit object argument to a
279  /// non-static member function without a ref-qualifier.
281 
282  /// Whether this binds a reference to an object with a different
283  /// Objective-C lifetime qualifier.
285 
286  /// FromType - The type that this conversion is converting
287  /// from. This is an opaque pointer that can be translated into a
288  /// QualType.
289  void *FromTypePtr;
290 
291  /// ToType - The types that this conversion is converting to in
292  /// each step. This is an opaque pointer that can be translated
293  /// into a QualType.
294  void *ToTypePtrs[3];
295 
296  /// CopyConstructor - The copy constructor that is used to perform
297  /// this conversion, when the conversion is actually just the
298  /// initialization of an object via copy constructor. Such
299  /// conversions are either identity conversions or derived-to-base
300  /// conversions.
303 
304  void setFromType(QualType T) { FromTypePtr = T.getAsOpaquePtr(); }
305 
306  void setToType(unsigned Idx, QualType T) {
307  assert(Idx < 3 && "To type index is out of range");
308  ToTypePtrs[Idx] = T.getAsOpaquePtr();
309  }
310 
312  ToTypePtrs[0] = T.getAsOpaquePtr();
313  ToTypePtrs[1] = ToTypePtrs[0];
314  ToTypePtrs[2] = ToTypePtrs[0];
315  }
316 
318  return QualType::getFromOpaquePtr(FromTypePtr);
319  }
320 
321  QualType getToType(unsigned Idx) const {
322  assert(Idx < 3 && "To type index is out of range");
323  return QualType::getFromOpaquePtr(ToTypePtrs[Idx]);
324  }
325 
327 
328  bool isIdentityConversion() const {
329  return Second == ICK_Identity && Third == ICK_Identity;
330  }
331 
334  getNarrowingKind(ASTContext &Context, const Expr *Converted,
335  APValue &ConstantValue, QualType &ConstantType,
336  bool IgnoreFloatToIntegralConversion = false) const;
337  bool isPointerConversionToBool() const;
338  bool isPointerConversionToVoidPointer(ASTContext& Context) const;
339  void dump() const;
340  };
341 
342  /// UserDefinedConversionSequence - Represents a user-defined
343  /// conversion sequence (C++ 13.3.3.1.2).
345  /// Represents the standard conversion that occurs before
346  /// the actual user-defined conversion.
347  ///
348  /// C++11 13.3.3.1.2p1:
349  /// If the user-defined conversion is specified by a constructor
350  /// (12.3.1), the initial standard conversion sequence converts
351  /// the source type to the type required by the argument of the
352  /// constructor. If the user-defined conversion is specified by
353  /// a conversion function (12.3.2), the initial standard
354  /// conversion sequence converts the source type to the implicit
355  /// object parameter of the conversion function.
357 
358  /// EllipsisConversion - When this is true, it means user-defined
359  /// conversion sequence starts with a ... (ellipsis) conversion, instead of
360  /// a standard conversion. In this case, 'Before' field must be ignored.
361  // FIXME. I much rather put this as the first field. But there seems to be
362  // a gcc code gen. bug which causes a crash in a test. Putting it here seems
363  // to work around the crash.
365 
366  /// HadMultipleCandidates - When this is true, it means that the
367  /// conversion function was resolved from an overloaded set having
368  /// size greater than 1.
370 
371  /// After - Represents the standard conversion that occurs after
372  /// the actual user-defined conversion.
374 
375  /// ConversionFunction - The function that will perform the
376  /// user-defined conversion. Null if the conversion is an
377  /// aggregate initialization from an initializer list.
379 
380  /// The declaration that we found via name lookup, which might be
381  /// the same as \c ConversionFunction or it might be a using declaration
382  /// that refers to \c ConversionFunction.
384 
385  void dump() const;
386  };
387 
388  /// Represents an ambiguous user-defined conversion sequence.
390  using ConversionSet =
392 
393  void *FromTypePtr;
394  void *ToTypePtr;
395  char Buffer[sizeof(ConversionSet)];
396 
398  return QualType::getFromOpaquePtr(FromTypePtr);
399  }
400 
401  QualType getToType() const {
402  return QualType::getFromOpaquePtr(ToTypePtr);
403  }
404 
405  void setFromType(QualType T) { FromTypePtr = T.getAsOpaquePtr(); }
406  void setToType(QualType T) { ToTypePtr = T.getAsOpaquePtr(); }
407 
409  return *reinterpret_cast<ConversionSet*>(Buffer);
410  }
411 
412  const ConversionSet &conversions() const {
413  return *reinterpret_cast<const ConversionSet*>(Buffer);
414  }
415 
417  conversions().push_back(std::make_pair(Found, D));
418  }
419 
420  using iterator = ConversionSet::iterator;
421 
422  iterator begin() { return conversions().begin(); }
423  iterator end() { return conversions().end(); }
424 
425  using const_iterator = ConversionSet::const_iterator;
426 
427  const_iterator begin() const { return conversions().begin(); }
428  const_iterator end() const { return conversions().end(); }
429 
430  void construct();
431  void destruct();
432  void copyFrom(const AmbiguousConversionSequence &);
433  };
434 
435  /// BadConversionSequence - Records information about an invalid
436  /// conversion sequence.
438  enum FailureKind {
443  rvalue_ref_to_lvalue
444  };
445 
446  // This can be null, e.g. for implicit object arguments.
448 
450 
451  private:
452  // The type we're converting from (an opaque QualType).
453  void *FromTy;
454 
455  // The type we're converting to (an opaque QualType).
456  void *ToTy;
457 
458  public:
459  void init(FailureKind K, Expr *From, QualType To) {
460  init(K, From->getType(), To);
461  FromExpr = From;
462  }
463 
464  void init(FailureKind K, QualType From, QualType To) {
465  Kind = K;
466  FromExpr = nullptr;
467  setFromType(From);
468  setToType(To);
469  }
470 
471  QualType getFromType() const { return QualType::getFromOpaquePtr(FromTy); }
473 
474  void setFromExpr(Expr *E) {
475  FromExpr = E;
476  setFromType(E->getType());
477  }
478 
479  void setFromType(QualType T) { FromTy = T.getAsOpaquePtr(); }
480  void setToType(QualType T) { ToTy = T.getAsOpaquePtr(); }
481  };
482 
483  /// ImplicitConversionSequence - Represents an implicit conversion
484  /// sequence, which may be a standard conversion sequence
485  /// (C++ 13.3.3.1.1), user-defined conversion sequence (C++ 13.3.3.1.2),
486  /// or an ellipsis conversion sequence (C++ 13.3.3.1.3).
488  public:
489  /// Kind - The kind of implicit conversion sequence. BadConversion
490  /// specifies that there is no conversion from the source type to
491  /// the target type. AmbiguousConversion represents the unique
492  /// ambiguous conversion (C++0x [over.best.ics]p10).
493  enum Kind {
494  StandardConversion = 0,
498  BadConversion
499  };
500 
501  private:
502  enum {
503  Uninitialized = BadConversion + 1
504  };
505 
506  /// ConversionKind - The kind of implicit conversion sequence.
507  unsigned ConversionKind : 30;
508 
509  /// Whether the target is really a std::initializer_list, and the
510  /// sequence only represents the worst element conversion.
511  unsigned StdInitializerListElement : 1;
512 
513  void setKind(Kind K) {
514  destruct();
515  ConversionKind = K;
516  }
517 
518  void destruct() {
519  if (ConversionKind == AmbiguousConversion) Ambiguous.destruct();
520  }
521 
522  public:
523  union {
524  /// When ConversionKind == StandardConversion, provides the
525  /// details of the standard conversion sequence.
527 
528  /// When ConversionKind == UserDefinedConversion, provides the
529  /// details of the user-defined conversion sequence.
531 
532  /// When ConversionKind == AmbiguousConversion, provides the
533  /// details of the ambiguous conversion.
535 
536  /// When ConversionKind == BadConversion, provides the details
537  /// of the bad conversion.
539  };
540 
542  : ConversionKind(Uninitialized), StdInitializerListElement(false) {
543  Standard.setAsIdentityConversion();
544  }
545 
547  : ConversionKind(Other.ConversionKind),
548  StdInitializerListElement(Other.StdInitializerListElement) {
549  switch (ConversionKind) {
550  case Uninitialized: break;
551  case StandardConversion: Standard = Other.Standard; break;
552  case UserDefinedConversion: UserDefined = Other.UserDefined; break;
553  case AmbiguousConversion: Ambiguous.copyFrom(Other.Ambiguous); break;
554  case EllipsisConversion: break;
555  case BadConversion: Bad = Other.Bad; break;
556  }
557  }
558 
561  destruct();
562  new (this) ImplicitConversionSequence(Other);
563  return *this;
564  }
565 
567  destruct();
568  }
569 
570  Kind getKind() const {
571  assert(isInitialized() && "querying uninitialized conversion");
572  return Kind(ConversionKind);
573  }
574 
575  /// Return a ranking of the implicit conversion sequence
576  /// kind, where smaller ranks represent better conversion
577  /// sequences.
578  ///
579  /// In particular, this routine gives user-defined conversion
580  /// sequences and ambiguous conversion sequences the same rank,
581  /// per C++ [over.best.ics]p10.
582  unsigned getKindRank() const {
583  switch (getKind()) {
584  case StandardConversion:
585  return 0;
586 
587  case UserDefinedConversion:
588  case AmbiguousConversion:
589  return 1;
590 
591  case EllipsisConversion:
592  return 2;
593 
594  case BadConversion:
595  return 3;
596  }
597 
598  llvm_unreachable("Invalid ImplicitConversionSequence::Kind!");
599  }
600 
601  bool isBad() const { return getKind() == BadConversion; }
602  bool isStandard() const { return getKind() == StandardConversion; }
603  bool isEllipsis() const { return getKind() == EllipsisConversion; }
604  bool isAmbiguous() const { return getKind() == AmbiguousConversion; }
605  bool isUserDefined() const { return getKind() == UserDefinedConversion; }
606  bool isFailure() const { return isBad() || isAmbiguous(); }
607 
608  /// Determines whether this conversion sequence has been
609  /// initialized. Most operations should never need to query
610  /// uninitialized conversions and should assert as above.
611  bool isInitialized() const { return ConversionKind != Uninitialized; }
612 
613  /// Sets this sequence as a bad conversion for an explicit argument.
615  Expr *FromExpr, QualType ToType) {
616  setKind(BadConversion);
617  Bad.init(Failure, FromExpr, ToType);
618  }
619 
620  /// Sets this sequence as a bad conversion for an implicit argument.
622  QualType FromType, QualType ToType) {
623  setKind(BadConversion);
624  Bad.init(Failure, FromType, ToType);
625  }
626 
627  void setStandard() { setKind(StandardConversion); }
628  void setEllipsis() { setKind(EllipsisConversion); }
629  void setUserDefined() { setKind(UserDefinedConversion); }
630 
631  void setAmbiguous() {
632  if (ConversionKind == AmbiguousConversion) return;
633  ConversionKind = AmbiguousConversion;
634  Ambiguous.construct();
635  }
636 
638  setStandard();
639  Standard.setAsIdentityConversion();
640  Standard.setFromType(T);
641  Standard.setAllToTypes(T);
642  }
643 
644  /// Whether the target is really a std::initializer_list, and the
645  /// sequence only represents the worst element conversion.
647  return StdInitializerListElement;
648  }
649 
650  void setStdInitializerListElement(bool V = true) {
651  StdInitializerListElement = V;
652  }
653 
654  // The result of a comparison between implicit conversion
655  // sequences. Use Sema::CompareImplicitConversionSequences to
656  // actually perform the comparison.
657  enum CompareKind {
658  Better = -1,
659  Indistinguishable = 0,
660  Worse = 1
661  };
662 
663  void DiagnoseAmbiguousConversion(Sema &S,
664  SourceLocation CaretLoc,
665  const PartialDiagnostic &PDiag) const;
666 
667  void dump() const;
668  };
669 
675 
676  /// This conversion candidate was not considered because it
677  /// duplicates the work of a trivial or derived-to-base
678  /// conversion.
680 
681  /// This conversion candidate was not considered because it is
682  /// an illegal instantiation of a constructor temploid: it is
683  /// callable with one argument, we only have one argument, and
684  /// its first parameter type is exactly the type of the class.
685  ///
686  /// Defining such a constructor directly is illegal, and
687  /// template-argument deduction is supposed to ignore such
688  /// instantiations, but we can still get one with the right
689  /// kind of implicit instantiation.
691 
692  /// This conversion candidate is not viable because its result
693  /// type is not implicitly convertible to the desired type.
695 
696  /// This conversion function template specialization candidate is not
697  /// viable because the final conversion was not an exact match.
699 
700  /// (CUDA) This candidate was not viable because the callee
701  /// was not accessible from the caller's target (i.e. host->device,
702  /// global->host, device->host).
704 
705  /// This candidate function was not viable because an enable_if
706  /// attribute disabled it.
708 
709  /// This candidate was not viable because its address could not be taken.
711 
712  /// This candidate was not viable because its OpenCL extension is disabled.
714 
715  /// This inherited constructor is not viable because it would slice the
716  /// argument.
718 
719  /// This candidate was not viable because it is a non-default multiversioned
720  /// function.
722  };
723 
724  /// A list of implicit conversion sequences for the arguments of an
725  /// OverloadCandidate.
726  using ConversionSequenceList =
728 
729  /// OverloadCandidate - A single candidate in an overload set (C++ 13.3).
731  /// Function - The actual function that this candidate
732  /// represents. When NULL, this is a built-in candidate
733  /// (C++ [over.oper]) or a surrogate for a conversion to a
734  /// function pointer or reference (C++ [over.call.object]).
736 
737  /// FoundDecl - The original declaration that was looked up /
738  /// invented / otherwise found, together with its access.
739  /// Might be a UsingShadowDecl or a FunctionTemplateDecl.
741 
742  /// BuiltinParamTypes - Provides the parameter types of a built-in overload
743  /// candidate. Only valid when Function is NULL.
744  QualType BuiltinParamTypes[3];
745 
746  /// Surrogate - The conversion function for which this candidate
747  /// is a surrogate, but only if IsSurrogate is true.
749 
750  /// The conversion sequences used to convert the function arguments
751  /// to the function parameters.
753 
754  /// The FixIt hints which can be used to fix the Bad candidate.
756 
757  /// Viable - True to indicate that this overload candidate is viable.
758  bool Viable;
759 
760  /// IsSurrogate - True to indicate that this candidate is a
761  /// surrogate for a conversion to a function pointer or reference
762  /// (C++ [over.call.object]).
764 
765  /// IgnoreObjectArgument - True to indicate that the first
766  /// argument's conversion, which for this function represents the
767  /// implicit object argument, should be ignored. This will be true
768  /// when the candidate is a static member function (where the
769  /// implicit object argument is just a placeholder) or a
770  /// non-static member function when the call doesn't have an
771  /// object argument.
773 
774  /// FailureKind - The reason why this candidate is not viable.
775  /// Actually an OverloadFailureKind.
776  unsigned char FailureKind;
777 
778  /// The number of call arguments that were explicitly provided,
779  /// to be used while performing partial ordering of function templates.
781 
782  union {
784 
785  /// FinalConversion - For a conversion function (where Function is
786  /// a CXXConversionDecl), the standard conversion that occurs
787  /// after the call to the overload candidate to convert the result
788  /// of calling the conversion function to the required type.
790  };
791 
792  /// hasAmbiguousConversion - Returns whether this overload
793  /// candidate requires an ambiguous conversion or not.
794  bool hasAmbiguousConversion() const {
795  for (auto &C : Conversions) {
796  if (!C.isInitialized()) return false;
797  if (C.isAmbiguous()) return true;
798  }
799  return false;
800  }
801 
802  bool TryToFixBadConversion(unsigned Idx, Sema &S) {
803  bool CanFix = Fix.tryToFixConversion(
804  Conversions[Idx].Bad.FromExpr,
805  Conversions[Idx].Bad.getFromType(),
806  Conversions[Idx].Bad.getToType(), S);
807 
808  // If at least one conversion fails, the candidate cannot be fixed.
809  if (!CanFix)
810  Fix.clear();
811 
812  return CanFix;
813  }
814 
815  unsigned getNumParams() const {
816  if (IsSurrogate) {
817  auto STy = Surrogate->getConversionType();
818  while (STy->isPointerType() || STy->isReferenceType())
819  STy = STy->getPointeeType();
820  return STy->getAs<FunctionProtoType>()->getNumParams();
821  }
822  if (Function)
823  return Function->getNumParams();
824  return ExplicitCallArguments;
825  }
826  };
827 
828  /// OverloadCandidateSet - A set of overload candidates, used in C++
829  /// overload resolution (C++ 13.3).
831  public:
833  /// Normal lookup.
835 
836  /// C++ [over.match.oper]:
837  /// Lookup of operator function candidates in a call using operator
838  /// syntax. Candidates that have no parameters of class type will be
839  /// skipped unless there is a parameter of (reference to) enum type and
840  /// the corresponding argument is of the same enum type.
842 
843  /// C++ [over.match.copy]:
844  /// Copy-initialization of an object of class type by user-defined
845  /// conversion.
847 
848  /// C++ [over.match.ctor], [over.match.list]
849  /// Initialization of an object of class type by constructor,
850  /// using either a parenthesized or braced list of arguments.
852  };
853 
854  private:
856  llvm::SmallPtrSet<Decl *, 16> Functions;
857 
858  // Allocator for ConversionSequenceLists. We store the first few of these
859  // inline to avoid allocation for small sets.
860  llvm::BumpPtrAllocator SlabAllocator;
861 
862  SourceLocation Loc;
864 
865  constexpr static unsigned NumInlineBytes =
866  24 * sizeof(ImplicitConversionSequence);
867  unsigned NumInlineBytesUsed = 0;
868  llvm::AlignedCharArray<alignof(void *), NumInlineBytes> InlineSpace;
869 
870  /// If we have space, allocates from inline storage. Otherwise, allocates
871  /// from the slab allocator.
872  /// FIXME: It would probably be nice to have a SmallBumpPtrAllocator
873  /// instead.
874  /// FIXME: Now that this only allocates ImplicitConversionSequences, do we
875  /// want to un-generalize this?
876  template <typename T>
877  T *slabAllocate(unsigned N) {
878  // It's simpler if this doesn't need to consider alignment.
879  static_assert(alignof(T) == alignof(void *),
880  "Only works for pointer-aligned types.");
881  static_assert(std::is_trivial<T>::value ||
882  std::is_same<ImplicitConversionSequence, T>::value,
883  "Add destruction logic to OverloadCandidateSet::clear().");
884 
885  unsigned NBytes = sizeof(T) * N;
886  if (NBytes > NumInlineBytes - NumInlineBytesUsed)
887  return SlabAllocator.Allocate<T>(N);
888  char *FreeSpaceStart = InlineSpace.buffer + NumInlineBytesUsed;
889  assert(uintptr_t(FreeSpaceStart) % alignof(void *) == 0 &&
890  "Misaligned storage!");
891 
892  NumInlineBytesUsed += NBytes;
893  return reinterpret_cast<T *>(FreeSpaceStart);
894  }
895 
896  void destroyCandidates();
897 
898  public:
900  : Loc(Loc), Kind(CSK) {}
901  OverloadCandidateSet(const OverloadCandidateSet &) = delete;
902  OverloadCandidateSet &operator=(const OverloadCandidateSet &) = delete;
903  ~OverloadCandidateSet() { destroyCandidates(); }
904 
905  SourceLocation getLocation() const { return Loc; }
906  CandidateSetKind getKind() const { return Kind; }
907 
908  /// Determine when this overload candidate will be new to the
909  /// overload set.
910  bool isNewCandidate(Decl *F) {
911  return Functions.insert(F->getCanonicalDecl()).second;
912  }
913 
914  /// Clear out all of the candidates.
915  void clear(CandidateSetKind CSK);
916 
918 
919  iterator begin() { return Candidates.begin(); }
920  iterator end() { return Candidates.end(); }
921 
922  size_t size() const { return Candidates.size(); }
923  bool empty() const { return Candidates.empty(); }
924 
925  /// Allocate storage for conversion sequences for NumConversions
926  /// conversions.
928  allocateConversionSequences(unsigned NumConversions) {
929  ImplicitConversionSequence *Conversions =
930  slabAllocate<ImplicitConversionSequence>(NumConversions);
931 
932  // Construct the new objects.
933  for (unsigned I = 0; I != NumConversions; ++I)
934  new (&Conversions[I]) ImplicitConversionSequence();
935 
936  return ConversionSequenceList(Conversions, NumConversions);
937  }
938 
939  /// Add a new candidate with NumConversions conversion sequence slots
940  /// to the overload set.
941  OverloadCandidate &addCandidate(unsigned NumConversions = 0,
942  ConversionSequenceList Conversions = None) {
943  assert((Conversions.empty() || Conversions.size() == NumConversions) &&
944  "preallocated conversion sequence has wrong length");
945 
946  Candidates.push_back(OverloadCandidate());
947  OverloadCandidate &C = Candidates.back();
948  C.Conversions = Conversions.empty()
949  ? allocateConversionSequences(NumConversions)
950  : Conversions;
951  return C;
952  }
953 
954  /// Find the best viable function on this overload set, if it exists.
955  OverloadingResult BestViableFunction(Sema &S, SourceLocation Loc,
957 
958  void NoteCandidates(Sema &S,
960  ArrayRef<Expr *> Args,
961  StringRef Opc = "",
963  llvm::function_ref<bool(OverloadCandidate&)> Filter =
964  [](OverloadCandidate&) { return true; });
965  };
966 
968  const OverloadCandidate &Cand1,
969  const OverloadCandidate &Cand2,
970  SourceLocation Loc,
972 
977 
978  explicit operator bool() const { return Constructor; }
979  };
980 
981  // FIXME: Add an AddOverloadCandidate / AddTemplateOverloadCandidate overload
982  // that takes one of these.
984  if (isa<UsingDecl>(ND))
985  return ConstructorInfo{};
986 
987  // For constructors, the access check is performed against the underlying
988  // declaration, not the found declaration.
989  auto *D = ND->getUnderlyingDecl();
990  ConstructorInfo Info = {DeclAccessPair::make(ND, D->getAccess()), nullptr,
991  nullptr};
992  Info.ConstructorTmpl = dyn_cast<FunctionTemplateDecl>(D);
993  if (Info.ConstructorTmpl)
994  D = Info.ConstructorTmpl->getTemplatedDecl();
995  Info.Constructor = dyn_cast<CXXConstructorDecl>(D);
996  return Info;
997  }
998 
999 } // namespace clang
1000 
1001 #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:780
DeclAccessPair FoundConversionFunction
The declaration that we found via name lookup, which might be the same as ConversionFunction or it mi...
Definition: Overload.h:383
Function pointer conversion (C++17 [conv.fctptr])
Definition: Overload.h:93
unsigned DeprecatedStringLiteralToCharPtr
Whether this is the deprecated conversion of a string literal to a pointer to non-const character dat...
Definition: Overload.h:250
(CUDA) This candidate was not viable because the callee was not accessible from the caller&#39;s target (...
Definition: Overload.h:703
void setFromType(QualType T)
Definition: Overload.h:479
Represents a function declaration or definition.
Definition: Decl.h:1732
void setStdInitializerListElement(bool V=true)
Definition: Overload.h:650
bool EllipsisConversion
EllipsisConversion - When this is true, it means user-defined conversion sequence starts with a ...
Definition: Overload.h:364
A (possibly-)qualified type.
Definition: Type.h:642
ImplicitConversionKind
ImplicitConversionKind - The kind of implicit conversion used to convert an argument to a parameter&#39;s...
Definition: Overload.h:79
void setFromType(QualType T)
Definition: Overload.h:304
Conversion not allowed by the C standard, but that we accept as an extension anyway.
Definition: Overload.h:196
llvm::MutableArrayRef< ImplicitConversionSequence > ConversionSequenceList
A list of implicit conversion sequences for the arguments of an OverloadCandidate.
Definition: Overload.h:727
A structure used to record information about a failed template argument deduction, for diagnosis.
Cannot tell whether this is a narrowing conversion because the expression is value-dependent.
Definition: Overload.h:219
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:497
Vector conversions.
Definition: Overload.h:135
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:425
Complex conversions (C99 6.3.1.6)
Definition: Overload.h:114
UserDefinedConversionSequence UserDefined
When ConversionKind == UserDefinedConversion, provides the details of the user-defined conversion seq...
Definition: Overload.h:530
ConstructorInfo getConstructorInfo(NamedDecl *ND)
Definition: Overload.h:983
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:87
Defines the C++ template declaration subclasses.
Not a narrowing conversion.
Definition: Overload.h:205
ImplicitConversionRank
ImplicitConversionRank - The rank of an implicit conversion kind.
Definition: Overload.h:172
unsigned IncompatibleObjC
IncompatibleObjC - Whether this is an Objective-C conversion that we should warn about (if we actuall...
Definition: Overload.h:258
virtual void clear()
Ambiguous candidates found.
Definition: Overload.h:60
Conversions between compatible types in C99.
Definition: Overload.h:129
bool IgnoreObjectArgument
IgnoreObjectArgument - True to indicate that the first argument&#39;s conversion, which for this function...
Definition: Overload.h:772
QualType getConversionType() const
Returns the type that this conversion function is converting to.
Definition: DeclCXX.h:2794
unsigned DirectBinding
DirectBinding - True when this is a reference binding that is a direct binding (C++ [dcl...
Definition: Overload.h:266
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2478
Exact Match.
Definition: Overload.h:174
bool hasAmbiguousConversion() const
hasAmbiguousConversion - Returns whether this overload candidate requires an ambiguous conversion or ...
Definition: Overload.h:794
QualType getFromType() const
Definition: Overload.h:317
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6683
bool IsSurrogate
IsSurrogate - True to indicate that this candidate is a surrogate for a conversion to a function poin...
Definition: Overload.h:763
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:431
bool HadMultipleCandidates
HadMultipleCandidates - When this is true, it means that the conversion function was resolved from an...
Definition: Overload.h:369
Conversion.
Definition: Overload.h:180
void * ToTypePtrs[3]
ToType - The types that this conversion is converting to in each step.
Definition: Overload.h:294
OverloadCandidate & addCandidate(unsigned NumConversions=0, ConversionSequenceList Conversions=None)
Add a new candidate with NumConversions conversion sequence slots to the overload set...
Definition: Overload.h:941
ImplicitConversionSequence(const ImplicitConversionSequence &Other)
Definition: Overload.h:546
Boolean conversions (C++ [conv.bool])
Definition: Overload.h:126
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:154
unsigned BindsToFunctionLvalue
Whether we&#39;re binding to a function lvalue.
Definition: Overload.h:273
C++ [over.match.copy]: Copy-initialization of an object of class type by user-defined conversion...
Definition: Overload.h:846
BadConversionSequence Bad
When ConversionKind == BadConversion, provides the details of the bad conversion. ...
Definition: Overload.h:538
Identity conversion (no conversion)
Definition: Overload.h:81
bool isStdInitializerListElement() const
Whether the target is really a std::initializer_list, and the sequence only represents the worst elem...
Definition: Overload.h:646
Kind
Kind - The kind of implicit conversion sequence.
Definition: Overload.h:493
ConversionSet & conversions()
Definition: Overload.h:408
BadConversionSequence - Records information about an invalid conversion sequence. ...
Definition: Overload.h:437
Floating point conversions (C++ [conv.double].
Definition: Overload.h:111
ConversionSequenceList allocateConversionSequences(unsigned NumConversions)
Allocate storage for conversion sequences for NumConversions conversions.
Definition: Overload.h:928
OverloadCandidateDisplayKind
Definition: Overload.h:66
Floating point promotions (C++ [conv.fpprom])
Definition: Overload.h:102
bool isInitialized() const
Determines whether this conversion sequence has been initialized.
Definition: Overload.h:611
unsigned BindsToRvalue
Whether we&#39;re binding to an rvalue.
Definition: Overload.h:276
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
Succeeded, but refers to a deleted function.
Definition: Overload.h:63
ImplicitConversionSequence & operator=(const ImplicitConversionSequence &Other)
Definition: Overload.h:560
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:254
QualType getToType(unsigned Idx) const
Definition: Overload.h:321
This candidate function was not viable because an enable_if attribute disabled it.
Definition: Overload.h:707
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:241
A narrowing conversion, because a constant expression got narrowed.
Definition: Overload.h:211
unsigned IsLvalueReference
Whether this is an lvalue reference binding (otherwise, it&#39;s an rvalue reference binding).
Definition: Overload.h:270
NarrowingKind
NarrowingKind - The kind of narrowing conversion being performed by a standard conversion sequence ac...
Definition: Overload.h:203
Qualification conversions (C++ [conv.qual])
Definition: Overload.h:96
void * getAsOpaquePtr() const
Definition: Type.h:687
The number of conversion kinds.
Definition: Overload.h:165
ImplicitConversionKind Third
Third - The third conversion can be a qualification conversion or a function conversion.
Definition: Overload.h:245
Complex <-> Real conversion.
Definition: Overload.h:186
bool Viable
Viable - True to indicate that this overload candidate is viable.
Definition: Overload.h:758
ConversionSequenceList Conversions
The conversion sequences used to convert the function arguments to the function parameters.
Definition: Overload.h:752
Integral promotions (C++ [conv.prom])
Definition: Overload.h:99
This conversion function template specialization candidate is not viable because the final conversion...
Definition: Overload.h:698
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:870
void setAsIdentityConversion(QualType T)
Definition: Overload.h:637
C-only conversion between pointers with incompatible types.
Definition: Overload.h:162
DeclAccessPair FoundDecl
Definition: Overload.h:974
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:278
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3676
Transparent Union Conversions.
Definition: Overload.h:147
This conversion candidate was not considered because it duplicates the work of a trivial or derived-t...
Definition: Overload.h:679
CandidateSetKind getKind() const
Definition: Overload.h:906
bool isNewCandidate(Decl *F)
Determine when this overload candidate will be new to the overload set.
Definition: Overload.h:910
A narrowing conversion by virtue of the source and destination types.
Definition: Overload.h:208
Promotion.
Definition: Overload.h:177
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:789
ObjC ARC writeback conversion.
Definition: Overload.h:189
OpenCL Scalar Widening.
Definition: Overload.h:183
This represents one expression.
Definition: Expr.h:105
Represents an ambiguous user-defined conversion sequence.
Definition: Overload.h:389
This candidate was not viable because it is a non-default multiversioned function.
Definition: Overload.h:721
This inherited constructor is not viable because it would slice the argument.
Definition: Overload.h:717
SourceLocation getLocation() const
Definition: Overload.h:905
StandardConversionSequence After
After - Represents the standard conversion that occurs after the actual user-defined conversion...
Definition: Overload.h:373
Zero constant to queue.
Definition: Overload.h:156
#define bool
Definition: stdbool.h:31
CXXConstructorDecl * CopyConstructor
CopyConstructor - The copy constructor that is used to perform this conversion, when the conversion i...
Definition: Overload.h:301
Overload resolution succeeded.
Definition: Overload.h:54
unsigned ReferenceBinding
ReferenceBinding - True when this is a reference binding (C++ [over.ics.ref]).
Definition: Overload.h:262
Floating-integral conversions (C++ [conv.fpint])
Definition: Overload.h:117
void init(FailureKind K, Expr *From, QualType To)
Definition: Overload.h:459
This conversion candidate was not considered because it is an illegal instantiation of a constructor ...
Definition: Overload.h:690
bool TryToFixBadConversion(unsigned Idx, Sema &S)
Definition: Overload.h:802
QualType getType() const
Definition: Expr.h:127
CXXConversionDecl * Surrogate
Surrogate - The conversion function for which this candidate is a surrogate, but only if IsSurrogate ...
Definition: Overload.h:748
UserDefinedConversionSequence - Represents a user-defined conversion sequence (C++ 13...
Definition: Overload.h:344
This candidate was not viable because its address could not be taken.
Definition: Overload.h:710
const ConversionSet & conversions() const
Definition: Overload.h:412
StandardConversionSequence Standard
When ConversionKind == StandardConversion, provides the details of the standard conversion sequence...
Definition: Overload.h:526
Represents a C++ conversion function within a class.
Definition: DeclCXX.h:2762
__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.h:82
A narrowing conversion, because a non-constant-expression variable might have got narrowed...
Definition: Overload.h:215
QualType getFromType() const
Definition: Overload.h:471
Lvalue-to-rvalue conversion (C++ [conv.lval])
Definition: Overload.h:84
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...
OverloadFailureKind
Definition: Overload.h:670
unsigned ObjCLifetimeConversionBinding
Whether this binds a reference to an object with a different Objective-C lifetime qualifier...
Definition: Overload.h:284
CXXConstructorDecl * Constructor
Definition: Overload.h:975
Integral conversions (C++ [conv.integral])
Definition: Overload.h:108
SmallVectorImpl< OverloadCandidate >::iterator iterator
Definition: Overload.h:917
Complex promotions (Clang extension)
Definition: Overload.h:105
#define false
Definition: stdbool.h:33
Kind
ImplicitConversionSequence - Represents an implicit conversion sequence, which may be a standard conv...
Definition: Overload.h:487
bool isPointerConversionToVoidPointer(ASTContext &Context) const
isPointerConversionToVoidPointer - Determines whether this conversion is a conversion of a pointer to...
OverloadCandidate - A single candidate in an overload set (C++ 13.3).
Definition: Overload.h:730
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:851
ConversionSet::iterator iterator
Definition: Overload.h:420
A vector splat from an arithmetic type.
Definition: Overload.h:138
OverloadingResult
OverloadingResult - Capture the result of performing overload resolution.
Definition: Overload.h:52
Objective-C ARC writeback conversion.
Definition: Overload.h:150
void init(FailureKind K, QualType From, QualType To)
Definition: Overload.h:464
void setAsIdentityConversion()
StandardConversionSequence - Set the standard conversion sequence to the identity conversion...
Pointer conversions (C++ [conv.ptr])
Definition: Overload.h:120
C++ [over.match.oper]: Lookup of operator function candidates in a call using operator syntax...
Definition: Overload.h:841
Requests that all candidates be shown.
Definition: Overload.h:69
Derived-to-base (C++ [over.best.ics])
Definition: Overload.h:132
Complex-real conversions (C99 6.3.1.7)
Definition: Overload.h:141
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13...
Definition: Overload.h:830
void setBad(BadConversionSequence::FailureKind Failure, Expr *FromExpr, QualType ToType)
Sets this sequence as a bad conversion for an explicit argument.
Definition: Overload.h:614
static QualType getFromOpaquePtr(const void *Ptr)
Definition: Type.h:689
void setFromExpr(Expr *E)
Definition: Overload.h:474
unsigned getNumParams() const
Definition: Overload.h:815
bool isPointerConversionToBool() const
isPointerConversionToBool - Determines whether this conversion is a conversion of a pointer or pointe...
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:302
OverloadCandidateSet(SourceLocation Loc, CandidateSetKind CSK)
Definition: Overload.h:899
Dataflow Directional Tag Classes.
AccessSpecifier getAccess() const
Definition: DeclBase.h:462
Conversions allowed in C, but not C++.
Definition: Overload.h:159
Array-to-pointer conversion (C++ [conv.array])
Definition: Overload.h:87
StandardConversionSequence Before
Represents the standard conversion that occurs before the actual user-defined conversion.
Definition: Overload.h:356
Requests that only viable candidates be shown.
Definition: Overload.h:72
FunctionDecl * Function
Function - The actual function that this candidate represents.
Definition: Overload.h:735
FunctionDecl * ConversionFunction
ConversionFunction - The function that will perform the user-defined conversion.
Definition: Overload.h:378
Conversion only allowed in the C standard (e.g. void* to char*).
Definition: Overload.h:192
void setToType(QualType T)
Definition: Overload.h:480
void setAllToTypes(QualType T)
Definition: Overload.h:311
unsigned getKindRank() const
Return a ranking of the implicit conversion sequence kind, where smaller ranks represent better conve...
Definition: Overload.h:582
This candidate was not viable because its OpenCL extension is disabled.
Definition: Overload.h:713
unsigned BindsImplicitObjectArgumentWithoutRefQualifier
Whether this binds an implicit object argument to a non-static member function without a ref-qualifie...
Definition: Overload.h:280
unsigned char FailureKind
FailureKind - The reason why this candidate is not viable.
Definition: Overload.h:776
void setBad(BadConversionSequence::FailureKind Failure, QualType FromType, QualType ToType)
Sets this sequence as a bad conversion for an implicit argument.
Definition: Overload.h:621
DeclAccessPair FoundDecl
FoundDecl - The original declaration that was looked up / invented / otherwise found, together with its access.
Definition: Overload.h:740
Block Pointer conversions.
Definition: Overload.h:144
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat]...
Definition: APValue.h:38
ConversionFixItGenerator Fix
The FixIt hints which can be used to fix the Bad candidate.
Definition: Overload.h:755
AmbiguousConversionSequence Ambiguous
When ConversionKind == AmbiguousConversion, provides the details of the ambiguous conversion...
Definition: Overload.h:534
void addConversion(NamedDecl *Found, FunctionDecl *D)
Definition: Overload.h:416
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:90
Defines the clang::SourceLocation class and associated facilities.
QualType getToType() const
Definition: Overload.h:472
FunctionTemplateDecl * ConstructorTmpl
Definition: Overload.h:976
const_iterator begin() const
Definition: Overload.h:427
void * FromTypePtr
FromType - The type that this conversion is converting from.
Definition: Overload.h:289
ImplicitConversionRank getRank() const
getRank - Retrieve the rank of this standard conversion sequence (C++ 13.3.3.1.1p3).
static Decl::Kind getKind(const Decl *D)
Definition: DeclBase.cpp:954
The class facilities generation and storage of conversion FixIts.
Zero constant to event (OpenCL1.2 6.12.10)
Definition: Overload.h:153
ImplicitConversionKind First
First – The first conversion can be an lvalue-to-rvalue conversion, array-to-pointer conversion...
Definition: Overload.h:235
No viable function found.
Definition: Overload.h:57
DeductionFailureInfo DeductionFailure
Definition: Overload.h:783
This represents a decl that may have a name.
Definition: Decl.h:248
void dump() const
dump - Print this standard conversion sequence to standard error.
Pointer-to-member conversions (C++ [conv.mem])
Definition: Overload.h:123
void setToType(unsigned Idx, QualType T)
Definition: Overload.h:306
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
Definition: Decl.cpp:3037
This conversion candidate is not viable because its result type is not implicitly convertible to the ...
Definition: Overload.h:694
const_iterator end() const
Definition: Overload.h:428
Declaration of a template function.
Definition: DeclTemplate.h:968
StandardConversionSequence - represents a standard conversion sequence (C++ 13.3.3.1.1).
Definition: Overload.h:230