clang  3.8.0
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"
19 #include "clang/AST/DeclTemplate.h"
20 #include "clang/AST/Expr.h"
21 #include "clang/AST/TemplateBase.h"
22 #include "clang/AST/Type.h"
26 #include "llvm/ADT/SmallPtrSet.h"
27 #include "llvm/ADT/SmallVector.h"
28 #include "llvm/Support/AlignOf.h"
29 #include "llvm/Support/Allocator.h"
30 
31 namespace clang {
32  class ASTContext;
33  class CXXConstructorDecl;
34  class CXXConversionDecl;
35  class FunctionDecl;
36  class Sema;
37 
38  /// OverloadingResult - Capture the result of performing overload
39  /// resolution.
41  OR_Success, ///< Overload resolution succeeded.
42  OR_No_Viable_Function, ///< No viable function found.
43  OR_Ambiguous, ///< Ambiguous candidates found.
44  OR_Deleted ///< Succeeded, but refers to a deleted function.
45  };
46 
48  /// Requests that all candidates be shown. Viable candidates will
49  /// be printed first.
51 
52  /// Requests that only viable candidates be shown.
54  };
55 
56  /// ImplicitConversionKind - The kind of implicit conversion used to
57  /// convert an argument to a parameter's type. The enumerator values
58  /// match with Table 9 of (C++ 13.3.3.1.1) and are listed such that
59  /// better conversion kinds have smaller values.
61  ICK_Identity = 0, ///< Identity conversion (no conversion)
62  ICK_Lvalue_To_Rvalue, ///< Lvalue-to-rvalue conversion (C++ 4.1)
63  ICK_Array_To_Pointer, ///< Array-to-pointer conversion (C++ 4.2)
64  ICK_Function_To_Pointer, ///< Function-to-pointer (C++ 4.3)
65  ICK_NoReturn_Adjustment, ///< Removal of noreturn from a type (Clang)
66  ICK_Qualification, ///< Qualification conversions (C++ 4.4)
67  ICK_Integral_Promotion, ///< Integral promotions (C++ 4.5)
68  ICK_Floating_Promotion, ///< Floating point promotions (C++ 4.6)
69  ICK_Complex_Promotion, ///< Complex promotions (Clang extension)
70  ICK_Integral_Conversion, ///< Integral conversions (C++ 4.7)
71  ICK_Floating_Conversion, ///< Floating point conversions (C++ 4.8)
72  ICK_Complex_Conversion, ///< Complex conversions (C99 6.3.1.6)
73  ICK_Floating_Integral, ///< Floating-integral conversions (C++ 4.9)
74  ICK_Pointer_Conversion, ///< Pointer conversions (C++ 4.10)
75  ICK_Pointer_Member, ///< Pointer-to-member conversions (C++ 4.11)
76  ICK_Boolean_Conversion, ///< Boolean conversions (C++ 4.12)
77  ICK_Compatible_Conversion, ///< Conversions between compatible types in C99
78  ICK_Derived_To_Base, ///< Derived-to-base (C++ [over.best.ics])
79  ICK_Vector_Conversion, ///< Vector conversions
80  ICK_Vector_Splat, ///< A vector splat from an arithmetic type
81  ICK_Complex_Real, ///< Complex-real conversions (C99 6.3.1.7)
82  ICK_Block_Pointer_Conversion, ///< Block Pointer conversions
83  ICK_TransparentUnionConversion, ///< Transparent Union Conversions
84  ICK_Writeback_Conversion, ///< Objective-C ARC writeback conversion
85  ICK_Zero_Event_Conversion, ///< Zero constant to event (OpenCL1.2 6.12.10)
86  ICK_C_Only_Conversion, ///< Conversions allowed in C, but not C++
87  ICK_Num_Conversion_Kinds, ///< The number of conversion kinds
88  };
89 
90  /// ImplicitConversionRank - The rank of an implicit conversion
91  /// kind. The enumerator values match with Table 9 of (C++
92  /// 13.3.3.1.1) and are listed such that better conversion ranks
93  /// have smaller values.
95  ICR_Exact_Match = 0, ///< Exact Match
96  ICR_Promotion, ///< Promotion
97  ICR_Conversion, ///< Conversion
98  ICR_Complex_Real_Conversion, ///< Complex <-> Real conversion
99  ICR_Writeback_Conversion, ///< ObjC ARC writeback conversion
100  ICR_C_Conversion ///< Conversion only allowed in the C standard.
101  /// (e.g. void* to char*)
102  };
103 
105 
106  /// NarrowingKind - The kind of narrowing conversion being performed by a
107  /// standard conversion sequence according to C++11 [dcl.init.list]p7.
109  /// Not a narrowing conversion.
111 
112  /// A narrowing conversion by virtue of the source and destination types.
114 
115  /// A narrowing conversion, because a constant expression got narrowed.
117 
118  /// A narrowing conversion, because a non-constant-expression variable might
119  /// have got narrowed.
121  };
122 
123  /// StandardConversionSequence - represents a standard conversion
124  /// sequence (C++ 13.3.3.1.1). A standard conversion sequence
125  /// contains between zero and three conversions. If a particular
126  /// conversion is not needed, it will be set to the identity conversion
127  /// (ICK_Identity). Note that the three conversions are
128  /// specified as separate members (rather than in an array) so that
129  /// we can keep the size of a standard conversion sequence to a
130  /// single word.
132  public:
133  /// First -- The first conversion can be an lvalue-to-rvalue
134  /// conversion, array-to-pointer conversion, or
135  /// function-to-pointer conversion.
137 
138  /// Second - The second conversion can be an integral promotion,
139  /// floating point promotion, integral conversion, floating point
140  /// conversion, floating-integral conversion, pointer conversion,
141  /// pointer-to-member conversion, or boolean conversion.
143 
144  /// Third - The third conversion can be a qualification conversion.
146 
147  /// \brief Whether this is the deprecated conversion of a
148  /// string literal to a pointer to non-const character data
149  /// (C++ 4.2p2).
151 
152  /// \brief Whether the qualification conversion involves a change in the
153  /// Objective-C lifetime (for automatic reference counting).
155 
156  /// IncompatibleObjC - Whether this is an Objective-C conversion
157  /// that we should warn about (if we actually use it).
158  unsigned IncompatibleObjC : 1;
159 
160  /// ReferenceBinding - True when this is a reference binding
161  /// (C++ [over.ics.ref]).
162  unsigned ReferenceBinding : 1;
163 
164  /// DirectBinding - True when this is a reference binding that is a
165  /// direct binding (C++ [dcl.init.ref]).
166  unsigned DirectBinding : 1;
167 
168  /// \brief Whether this is an lvalue reference binding (otherwise, it's
169  /// an rvalue reference binding).
170  unsigned IsLvalueReference : 1;
171 
172  /// \brief Whether we're binding to a function lvalue.
173  unsigned BindsToFunctionLvalue : 1;
174 
175  /// \brief Whether we're binding to an rvalue.
176  unsigned BindsToRvalue : 1;
177 
178  /// \brief Whether this binds an implicit object argument to a
179  /// non-static member function without a ref-qualifier.
181 
182  /// \brief Whether this binds a reference to an object with a different
183  /// Objective-C lifetime qualifier.
185 
186  /// FromType - The type that this conversion is converting
187  /// from. This is an opaque pointer that can be translated into a
188  /// QualType.
189  void *FromTypePtr;
190 
191  /// ToType - The types that this conversion is converting to in
192  /// each step. This is an opaque pointer that can be translated
193  /// into a QualType.
194  void *ToTypePtrs[3];
195 
196  /// CopyConstructor - The copy constructor that is used to perform
197  /// this conversion, when the conversion is actually just the
198  /// initialization of an object via copy constructor. Such
199  /// conversions are either identity conversions or derived-to-base
200  /// conversions.
202 
204  void setToType(unsigned Idx, QualType T) {
205  assert(Idx < 3 && "To type index is out of range");
206  ToTypePtrs[Idx] = T.getAsOpaquePtr();
207  }
209  ToTypePtrs[0] = T.getAsOpaquePtr();
210  ToTypePtrs[1] = ToTypePtrs[0];
211  ToTypePtrs[2] = ToTypePtrs[0];
212  }
213 
216  }
217  QualType getToType(unsigned Idx) const {
218  assert(Idx < 3 && "To type index is out of range");
220  }
221 
223 
224  bool isIdentityConversion() const {
225  return Second == ICK_Identity && Third == ICK_Identity;
226  }
227 
230  APValue &ConstantValue,
231  QualType &ConstantType) const;
232  bool isPointerConversionToBool() const;
234  void dump() const;
235  };
236 
237  /// UserDefinedConversionSequence - Represents a user-defined
238  /// conversion sequence (C++ 13.3.3.1.2).
240  /// \brief Represents the standard conversion that occurs before
241  /// the actual user-defined conversion.
242  ///
243  /// C++11 13.3.3.1.2p1:
244  /// If the user-defined conversion is specified by a constructor
245  /// (12.3.1), the initial standard conversion sequence converts
246  /// the source type to the type required by the argument of the
247  /// constructor. If the user-defined conversion is specified by
248  /// a conversion function (12.3.2), the initial standard
249  /// conversion sequence converts the source type to the implicit
250  /// object parameter of the conversion function.
252 
253  /// EllipsisConversion - When this is true, it means user-defined
254  /// conversion sequence starts with a ... (ellipsis) conversion, instead of
255  /// a standard conversion. In this case, 'Before' field must be ignored.
256  // FIXME. I much rather put this as the first field. But there seems to be
257  // a gcc code gen. bug which causes a crash in a test. Putting it here seems
258  // to work around the crash.
260 
261  /// HadMultipleCandidates - When this is true, it means that the
262  /// conversion function was resolved from an overloaded set having
263  /// size greater than 1.
265 
266  /// After - Represents the standard conversion that occurs after
267  /// the actual user-defined conversion.
269 
270  /// ConversionFunction - The function that will perform the
271  /// user-defined conversion. Null if the conversion is an
272  /// aggregate initialization from an initializer list.
274 
275  /// \brief The declaration that we found via name lookup, which might be
276  /// the same as \c ConversionFunction or it might be a using declaration
277  /// that refers to \c ConversionFunction.
279 
280  void dump() const;
281  };
282 
283  /// Represents an ambiguous user-defined conversion sequence.
286 
287  void *FromTypePtr;
288  void *ToTypePtr;
289  char Buffer[sizeof(ConversionSet)];
290 
293  }
294  QualType getToType() const {
296  }
299 
301  return *reinterpret_cast<ConversionSet*>(Buffer);
302  }
303 
304  const ConversionSet &conversions() const {
305  return *reinterpret_cast<const ConversionSet*>(Buffer);
306  }
307 
309  conversions().push_back(D);
310  }
311 
313  iterator begin() { return conversions().begin(); }
314  iterator end() { return conversions().end(); }
315 
316  typedef ConversionSet::const_iterator const_iterator;
317  const_iterator begin() const { return conversions().begin(); }
318  const_iterator end() const { return conversions().end(); }
319 
320  void construct();
321  void destruct();
323  };
324 
325  /// BadConversionSequence - Records information about an invalid
326  /// conversion sequence.
328  enum FailureKind {
334  };
335 
336  // This can be null, e.g. for implicit object arguments.
338 
340 
341  private:
342  // The type we're converting from (an opaque QualType).
343  void *FromTy;
344 
345  // The type we're converting to (an opaque QualType).
346  void *ToTy;
347 
348  public:
349  void init(FailureKind K, Expr *From, QualType To) {
350  init(K, From->getType(), To);
351  FromExpr = From;
352  }
353  void init(FailureKind K, QualType From, QualType To) {
354  Kind = K;
355  FromExpr = nullptr;
356  setFromType(From);
357  setToType(To);
358  }
359 
360  QualType getFromType() const { return QualType::getFromOpaquePtr(FromTy); }
362 
363  void setFromExpr(Expr *E) {
364  FromExpr = E;
365  setFromType(E->getType());
366  }
367  void setFromType(QualType T) { FromTy = T.getAsOpaquePtr(); }
368  void setToType(QualType T) { ToTy = T.getAsOpaquePtr(); }
369  };
370 
371  /// ImplicitConversionSequence - Represents an implicit conversion
372  /// sequence, which may be a standard conversion sequence
373  /// (C++ 13.3.3.1.1), user-defined conversion sequence (C++ 13.3.3.1.2),
374  /// or an ellipsis conversion sequence (C++ 13.3.3.1.3).
376  public:
377  /// Kind - The kind of implicit conversion sequence. BadConversion
378  /// specifies that there is no conversion from the source type to
379  /// the target type. AmbiguousConversion represents the unique
380  /// ambiguous conversion (C++0x [over.best.ics]p10).
381  enum Kind {
387  };
388 
389  private:
390  enum {
391  Uninitialized = BadConversion + 1
392  };
393 
394  /// ConversionKind - The kind of implicit conversion sequence.
395  unsigned ConversionKind : 30;
396 
397  /// \brief Whether the target is really a std::initializer_list, and the
398  /// sequence only represents the worst element conversion.
399  bool StdInitializerListElement : 1;
400 
401  void setKind(Kind K) {
402  destruct();
403  ConversionKind = K;
404  }
405 
406  void destruct() {
407  if (ConversionKind == AmbiguousConversion) Ambiguous.destruct();
408  }
409 
410  public:
411  union {
412  /// When ConversionKind == StandardConversion, provides the
413  /// details of the standard conversion sequence.
415 
416  /// When ConversionKind == UserDefinedConversion, provides the
417  /// details of the user-defined conversion sequence.
419 
420  /// When ConversionKind == AmbiguousConversion, provides the
421  /// details of the ambiguous conversion.
423 
424  /// When ConversionKind == BadConversion, provides the details
425  /// of the bad conversion.
427  };
428 
430  : ConversionKind(Uninitialized), StdInitializerListElement(false)
431  {}
433  destruct();
434  }
436  : ConversionKind(Other.ConversionKind),
437  StdInitializerListElement(Other.StdInitializerListElement)
438  {
439  switch (ConversionKind) {
440  case Uninitialized: break;
441  case StandardConversion: Standard = Other.Standard; break;
442  case UserDefinedConversion: UserDefined = Other.UserDefined; break;
443  case AmbiguousConversion: Ambiguous.copyFrom(Other.Ambiguous); break;
444  case EllipsisConversion: break;
445  case BadConversion: Bad = Other.Bad; break;
446  }
447  }
448 
451  destruct();
452  new (this) ImplicitConversionSequence(Other);
453  return *this;
454  }
455 
456  Kind getKind() const {
457  assert(isInitialized() && "querying uninitialized conversion");
458  return Kind(ConversionKind);
459  }
460 
461  /// \brief Return a ranking of the implicit conversion sequence
462  /// kind, where smaller ranks represent better conversion
463  /// sequences.
464  ///
465  /// In particular, this routine gives user-defined conversion
466  /// sequences and ambiguous conversion sequences the same rank,
467  /// per C++ [over.best.ics]p10.
468  unsigned getKindRank() const {
469  switch (getKind()) {
470  case StandardConversion:
471  return 0;
472 
474  case AmbiguousConversion:
475  return 1;
476 
477  case EllipsisConversion:
478  return 2;
479 
480  case BadConversion:
481  return 3;
482  }
483 
484  llvm_unreachable("Invalid ImplicitConversionSequence::Kind!");
485  }
486 
487  bool isBad() const { return getKind() == BadConversion; }
488  bool isStandard() const { return getKind() == StandardConversion; }
489  bool isEllipsis() const { return getKind() == EllipsisConversion; }
490  bool isAmbiguous() const { return getKind() == AmbiguousConversion; }
491  bool isUserDefined() const { return getKind() == UserDefinedConversion; }
492  bool isFailure() const { return isBad() || isAmbiguous(); }
493 
494  /// Determines whether this conversion sequence has been
495  /// initialized. Most operations should never need to query
496  /// uninitialized conversions and should assert as above.
497  bool isInitialized() const { return ConversionKind != Uninitialized; }
498 
499  /// Sets this sequence as a bad conversion for an explicit argument.
501  Expr *FromExpr, QualType ToType) {
502  setKind(BadConversion);
503  Bad.init(Failure, FromExpr, ToType);
504  }
505 
506  /// Sets this sequence as a bad conversion for an implicit argument.
508  QualType FromType, QualType ToType) {
509  setKind(BadConversion);
510  Bad.init(Failure, FromType, ToType);
511  }
512 
513  void setStandard() { setKind(StandardConversion); }
514  void setEllipsis() { setKind(EllipsisConversion); }
516  void setAmbiguous() {
517  if (ConversionKind == AmbiguousConversion) return;
518  ConversionKind = AmbiguousConversion;
520  }
521 
522  /// \brief Whether the target is really a std::initializer_list, and the
523  /// sequence only represents the worst element conversion.
525  return StdInitializerListElement;
526  }
527 
528  void setStdInitializerListElement(bool V = true) {
529  StdInitializerListElement = V;
530  }
531 
532  // The result of a comparison between implicit conversion
533  // sequences. Use Sema::CompareImplicitConversionSequences to
534  // actually perform the comparison.
535  enum CompareKind {
536  Better = -1,
538  Worse = 1
539  };
540 
542  SourceLocation CaretLoc,
543  const PartialDiagnostic &PDiag) const;
544 
545  void dump() const;
546  };
547 
553 
554  /// This conversion candidate was not considered because it
555  /// duplicates the work of a trivial or derived-to-base
556  /// conversion.
558 
559  /// This conversion candidate was not considered because it is
560  /// an illegal instantiation of a constructor temploid: it is
561  /// callable with one argument, we only have one argument, and
562  /// its first parameter type is exactly the type of the class.
563  ///
564  /// Defining such a constructor directly is illegal, and
565  /// template-argument deduction is supposed to ignore such
566  /// instantiations, but we can still get one with the right
567  /// kind of implicit instantiation.
569 
570  /// This conversion candidate is not viable because its result
571  /// type is not implicitly convertible to the desired type.
573 
574  /// This conversion function template specialization candidate is not
575  /// viable because the final conversion was not an exact match.
577 
578  /// (CUDA) This candidate was not viable because the callee
579  /// was not accessible from the caller's target (i.e. host->device,
580  /// global->host, device->host).
582 
583  /// This candidate function was not viable because an enable_if
584  /// attribute disabled it.
586 
587  /// This candidate was not viable because its address could not be taken.
589  };
590 
591  /// OverloadCandidate - A single candidate in an overload set (C++ 13.3).
593  /// Function - The actual function that this candidate
594  /// represents. When NULL, this is a built-in candidate
595  /// (C++ [over.oper]) or a surrogate for a conversion to a
596  /// function pointer or reference (C++ [over.call.object]).
598 
599  /// FoundDecl - The original declaration that was looked up /
600  /// invented / otherwise found, together with its access.
601  /// Might be a UsingShadowDecl or a FunctionTemplateDecl.
603 
604  // BuiltinTypes - Provides the return and parameter types of a
605  // built-in overload candidate. Only valid when Function is NULL.
606  struct {
609  } BuiltinTypes;
610 
611  /// Surrogate - The conversion function for which this candidate
612  /// is a surrogate, but only if IsSurrogate is true.
614 
615  /// Conversions - The conversion sequences used to convert the
616  /// function arguments to the function parameters, the pointer points to a
617  /// fixed size array with NumConversions elements. The memory is owned by
618  /// the OverloadCandidateSet.
620 
621  /// The FixIt hints which can be used to fix the Bad candidate.
623 
624  /// NumConversions - The number of elements in the Conversions array.
625  unsigned NumConversions;
626 
627  /// Viable - True to indicate that this overload candidate is viable.
628  bool Viable;
629 
630  /// IsSurrogate - True to indicate that this candidate is a
631  /// surrogate for a conversion to a function pointer or reference
632  /// (C++ [over.call.object]).
634 
635  /// IgnoreObjectArgument - True to indicate that the first
636  /// argument's conversion, which for this function represents the
637  /// implicit object argument, should be ignored. This will be true
638  /// when the candidate is a static member function (where the
639  /// implicit object argument is just a placeholder) or a
640  /// non-static member function when the call doesn't have an
641  /// object argument.
643 
644  /// FailureKind - The reason why this candidate is not viable.
645  /// Actually an OverloadFailureKind.
646  unsigned char FailureKind;
647 
648  /// \brief The number of call arguments that were explicitly provided,
649  /// to be used while performing partial ordering of function templates.
651 
652  union {
654 
655  /// FinalConversion - For a conversion function (where Function is
656  /// a CXXConversionDecl), the standard conversion that occurs
657  /// after the call to the overload candidate to convert the result
658  /// of calling the conversion function to the required type.
660  };
661 
662  /// hasAmbiguousConversion - Returns whether this overload
663  /// candidate requires an ambiguous conversion or not.
664  bool hasAmbiguousConversion() const {
665  for (unsigned i = 0, e = NumConversions; i != e; ++i) {
666  if (!Conversions[i].isInitialized()) return false;
667  if (Conversions[i].isAmbiguous()) return true;
668  }
669  return false;
670  }
671 
672  bool TryToFixBadConversion(unsigned Idx, Sema &S) {
673  bool CanFix = Fix.tryToFixConversion(
674  Conversions[Idx].Bad.FromExpr,
675  Conversions[Idx].Bad.getFromType(),
676  Conversions[Idx].Bad.getToType(), S);
677 
678  // If at least one conversion fails, the candidate cannot be fixed.
679  if (!CanFix)
680  Fix.clear();
681 
682  return CanFix;
683  }
684 
685  unsigned getNumParams() const {
686  if (IsSurrogate) {
687  auto STy = Surrogate->getConversionType();
688  while (STy->isPointerType() || STy->isReferenceType())
689  STy = STy->getPointeeType();
690  return STy->getAs<FunctionProtoType>()->getNumParams();
691  }
692  if (Function)
693  return Function->getNumParams();
694  return ExplicitCallArguments;
695  }
696  };
697 
698  /// OverloadCandidateSet - A set of overload candidates, used in C++
699  /// overload resolution (C++ 13.3).
701  public:
703  /// Normal lookup.
705  /// Lookup for candidates for a call using operator syntax. Candidates
706  /// that have no parameters of class type will be skipped unless there
707  /// is a parameter of (reference to) enum type and the corresponding
708  /// argument is of the same enum type.
710  };
711 
712  private:
714  llvm::SmallPtrSet<Decl *, 16> Functions;
715 
716  // Allocator for OverloadCandidate::Conversions. We store the first few
717  // elements inline to avoid allocation for small sets.
718  llvm::BumpPtrAllocator ConversionSequenceAllocator;
719 
720  SourceLocation Loc;
722 
723  unsigned NumInlineSequences;
724  llvm::AlignedCharArray<llvm::AlignOf<ImplicitConversionSequence>::Alignment,
725  16 * sizeof(ImplicitConversionSequence)> InlineSpace;
726 
727  OverloadCandidateSet(const OverloadCandidateSet &) = delete;
728  void operator=(const OverloadCandidateSet &) = delete;
729 
730  void destroyCandidates();
731 
732  public:
734  : Loc(Loc), Kind(CSK), NumInlineSequences(0) {}
735  ~OverloadCandidateSet() { destroyCandidates(); }
736 
737  SourceLocation getLocation() const { return Loc; }
738  CandidateSetKind getKind() const { return Kind; }
739 
740  /// \brief Determine when this overload candidate will be new to the
741  /// overload set.
742  bool isNewCandidate(Decl *F) {
743  return Functions.insert(F->getCanonicalDecl()).second;
744  }
745 
746  /// \brief Clear out all of the candidates.
747  void clear();
748 
750  iterator begin() { return Candidates.begin(); }
751  iterator end() { return Candidates.end(); }
752 
753  size_t size() const { return Candidates.size(); }
754  bool empty() const { return Candidates.empty(); }
755 
756  /// \brief Add a new candidate with NumConversions conversion sequence slots
757  /// to the overload set.
758  OverloadCandidate &addCandidate(unsigned NumConversions = 0) {
759  Candidates.push_back(OverloadCandidate());
760  OverloadCandidate &C = Candidates.back();
761 
762  // Assign space from the inline array if there are enough free slots
763  // available.
764  if (NumConversions + NumInlineSequences <= 16) {
766  (ImplicitConversionSequence *)InlineSpace.buffer;
767  C.Conversions = &I[NumInlineSequences];
768  NumInlineSequences += NumConversions;
769  } else {
770  // Otherwise get memory from the allocator.
771  C.Conversions = ConversionSequenceAllocator
772  .Allocate<ImplicitConversionSequence>(NumConversions);
773  }
774 
775  // Construct the new objects.
776  for (unsigned i = 0; i != NumConversions; ++i)
778 
779  C.NumConversions = NumConversions;
780  return C;
781  }
782 
783  /// Find the best viable function on this overload set, if it exists.
786  bool UserDefinedConversion = false);
787 
788  void NoteCandidates(Sema &S,
790  ArrayRef<Expr *> Args,
791  StringRef Opc = "",
793  };
794 
795  bool isBetterOverloadCandidate(Sema &S,
796  const OverloadCandidate& Cand1,
797  const OverloadCandidate& Cand2,
798  SourceLocation Loc,
799  bool UserDefinedConversion = false);
800 } // end namespace clang
801 
802 #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:650
DeclAccessPair FoundConversionFunction
The declaration that we found via name lookup, which might be the same as ConversionFunction or it mi...
Definition: Overload.h:278
unsigned DeprecatedStringLiteralToCharPtr
Whether this is the deprecated conversion of a string literal to a pointer to non-const character dat...
Definition: Overload.h:150
(CUDA) This candidate was not viable because the callee was not accessible from the caller's target (...
Definition: Overload.h:581
void setFromType(QualType T)
Definition: Overload.h:367
FunctionDecl - An instance of this class is created to represent a function declaration or definition...
Definition: Decl.h:1483
char Buffer[sizeof(ConversionSet)]
Definition: Overload.h:289
void setStdInitializerListElement(bool V=true)
Definition: Overload.h:528
bool EllipsisConversion
EllipsisConversion - When this is true, it means user-defined conversion sequence starts with a ...
Definition: Overload.h:259
A (possibly-)qualified type.
Definition: Type.h:575
ImplicitConversionKind
ImplicitConversionKind - The kind of implicit conversion used to convert an argument to a parameter's...
Definition: Overload.h:60
void setFromType(QualType T)
Definition: Overload.h:203
QualType getConversionType() const
Returns the type that this conversion function is converting to.
Definition: DeclCXX.h:2432
A structure used to record information about a failed template argument deduction, for diagnosis.
Vector conversions.
Definition: Overload.h:79
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.
Complex conversions (C99 6.3.1.6)
Definition: Overload.h:72
UserDefinedConversionSequence UserDefined
When ConversionKind == UserDefinedConversion, provides the details of the user-defined conversion seq...
Definition: Overload.h:418
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:77
Defines the C++ template declaration subclasses.
Not a narrowing conversion.
Definition: Overload.h:110
ImplicitConversionRank
ImplicitConversionRank - The rank of an implicit conversion kind.
Definition: Overload.h:94
unsigned IncompatibleObjC
IncompatibleObjC - Whether this is an Objective-C conversion that we should warn about (if we actuall...
Definition: Overload.h:158
Ambiguous candidates found.
Definition: Overload.h:43
Conversions between compatible types in C99.
Definition: Overload.h:77
bool IgnoreObjectArgument
IgnoreObjectArgument - True to indicate that the first argument's conversion, which for this function...
Definition: Overload.h:642
ConversionSet::iterator iterator
Definition: Overload.h:312
unsigned DirectBinding
DirectBinding - True when this is a reference binding that is a direct binding (C++ [dcl...
Definition: Overload.h:166
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2134
void * getAsOpaquePtr() const
Definition: Type.h:623
Exact Match.
Definition: Overload.h:95
SmallVector< FunctionDecl *, 4 > ConversionSet
Definition: Overload.h:285
bool IsSurrogate
IsSurrogate - True to indicate that this candidate is a surrogate for a conversion to a function poin...
Definition: Overload.h:633
bool HadMultipleCandidates
HadMultipleCandidates - When this is true, it means that the conversion function was resolved from an...
Definition: Overload.h:264
Removal of noreturn from a type (Clang)
Definition: Overload.h:65
Conversion.
Definition: Overload.h:97
void * ToTypePtrs[3]
ToType - The types that this conversion is converting to in each step.
Definition: Overload.h:194
ImplicitConversionSequence(const ImplicitConversionSequence &Other)
Definition: Overload.h:435
Boolean conversions (C++ 4.12)
Definition: Overload.h:76
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:91
OverloadCandidate & addCandidate(unsigned NumConversions=0)
Add a new candidate with NumConversions conversion sequence slots to the overload set...
Definition: Overload.h:758
ImplicitConversionSequence * Conversions
Conversions - The conversion sequences used to convert the function arguments to the function paramet...
Definition: Overload.h:619
unsigned BindsToFunctionLvalue
Whether we're binding to a function lvalue.
Definition: Overload.h:173
BadConversionSequence Bad
When ConversionKind == BadConversion, provides the details of the bad conversion. ...
Definition: Overload.h:426
Identity conversion (no conversion)
Definition: Overload.h:61
Kind
Kind - The kind of implicit conversion sequence.
Definition: Overload.h:381
ConversionSet & conversions()
Definition: Overload.h:300
BadConversionSequence - Records information about an invalid conversion sequence. ...
Definition: Overload.h:327
QualType getToType() const
Definition: Overload.h:361
Floating point conversions (C++ 4.8)
Definition: Overload.h:71
const_iterator end() const
Definition: Overload.h:318
struct clang::OverloadCandidate::@201 BuiltinTypes
OverloadCandidateDisplayKind
Definition: Overload.h:47
Floating point promotions (C++ 4.6)
Definition: Overload.h:68
ImplicitConversionRank getRank() const
getRank - Retrieve the rank of this standard conversion sequence (C++ 13.3.3.1.1p3).
unsigned BindsToRvalue
Whether we're binding to an rvalue.
Definition: Overload.h:176
Succeeded, but refers to a deleted function.
Definition: Overload.h:44
ImplicitConversionSequence & operator=(const ImplicitConversionSequence &Other)
Definition: Overload.h:450
unsigned QualificationIncludesObjCLifetime
Whether the qualification conversion involves a change in the Objective-C lifetime (for automatic ref...
Definition: Overload.h:154
This candidate function was not viable because an enable_if attribute disabled it.
Definition: Overload.h:585
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:142
A narrowing conversion, because a constant expression got narrowed.
Definition: Overload.h:116
unsigned IsLvalueReference
Whether this is an lvalue reference binding (otherwise, it's an rvalue reference binding).
Definition: Overload.h:170
NarrowingKind
NarrowingKind - The kind of narrowing conversion being performed by a standard conversion sequence ac...
Definition: Overload.h:108
Qualification conversions (C++ 4.4)
Definition: Overload.h:66
NarrowingKind getNarrowingKind(ASTContext &Context, const Expr *Converted, APValue &ConstantValue, QualType &ConstantType) const
Check if this standard conversion sequence represents a narrowing conversion, according to C++11 [dcl...
The number of conversion kinds.
Definition: Overload.h:87
ImplicitConversionKind Third
Third - The third conversion can be a qualification conversion.
Definition: Overload.h:145
detail::InMemoryDirectory::const_iterator I
Complex <-> Real conversion.
Definition: Overload.h:98
bool Viable
Viable - True to indicate that this overload candidate is viable.
Definition: Overload.h:628
Integral promotions (C++ 4.5)
Definition: Overload.h:67
This conversion function template specialization candidate is not viable because the final conversion...
Definition: Overload.h:576
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:753
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:259
bool isBetterOverloadCandidate(Sema &S, const OverloadCandidate &Cand1, const OverloadCandidate &Cand2, SourceLocation Loc, bool UserDefinedConversion=false)
isBetterOverloadCandidate - Determines whether the first overload candidate is a better candidate tha...
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3041
Transparent Union Conversions.
Definition: Overload.h:83
ASTContext * Context
This conversion candidate was not considered because it duplicates the work of a trivial or derived-t...
Definition: Overload.h:557
bool isNewCandidate(Decl *F)
Determine when this overload candidate will be new to the overload set.
Definition: Overload.h:742
A narrowing conversion by virtue of the source and destination types.
Definition: Overload.h:113
Promotion.
Definition: Overload.h:96
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:659
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:415
ObjC ARC writeback conversion.
Definition: Overload.h:99
bool hasAmbiguousConversion() const
hasAmbiguousConversion - Returns whether this overload candidate requires an ambiguous conversion or ...
Definition: Overload.h:664
friend class ASTContext
Definition: Type.h:4012
void dump() const
dump - Print this user-defined conversion sequence to standard error.
Expr - This represents one expression.
Definition: Expr.h:104
Represents an ambiguous user-defined conversion sequence.
Definition: Overload.h:284
void dump() const
dump - Print this standard conversion sequence to standard error.
StandardConversionSequence After
After - Represents the standard conversion that occurs after the actual user-defined conversion...
Definition: Overload.h:268
SmallVectorImpl< OverloadCandidate >::iterator iterator
Definition: Overload.h:749
void copyFrom(const AmbiguousConversionSequence &)
CXXConstructorDecl * CopyConstructor
CopyConstructor - The copy constructor that is used to perform this conversion, when the conversion i...
Definition: Overload.h:201
QualType ParamTypes[3]
Definition: Overload.h:608
void addConversion(FunctionDecl *D)
Definition: Overload.h:308
Overload resolution succeeded.
Definition: Overload.h:41
unsigned ReferenceBinding
ReferenceBinding - True when this is a reference binding (C++ [over.ics.ref]).
Definition: Overload.h:162
QualType getFromType() const
Definition: Overload.h:360
Floating-integral conversions (C++ 4.9)
Definition: Overload.h:73
void init(FailureKind K, Expr *From, QualType To)
Definition: Overload.h:349
This conversion candidate was not considered because it is an illegal instantiation of a constructor ...
Definition: Overload.h:568
bool TryToFixBadConversion(unsigned Idx, Sema &S)
Definition: Overload.h:672
QualType getFromType() const
Definition: Overload.h:214
CXXConversionDecl * Surrogate
Surrogate - The conversion function for which this candidate is a surrogate, but only if IsSurrogate ...
Definition: Overload.h:613
UserDefinedConversionSequence - Represents a user-defined conversion sequence (C++ 13...
Definition: Overload.h:239
This candidate was not viable because its address could not be taken.
Definition: Overload.h:588
void NoteCandidates(Sema &S, OverloadCandidateDisplayKind OCD, ArrayRef< Expr * > Args, StringRef Opc="", SourceLocation Loc=SourceLocation())
PrintOverloadCandidates - When overload resolution fails, prints diagnostic messages containing the c...
StandardConversionSequence Standard
When ConversionKind == StandardConversion, provides the details of the standard conversion sequence...
Definition: Overload.h:414
Represents a C++ conversion function within a class.
Definition: DeclCXX.h:2392
A narrowing conversion, because a non-constant-expression variable might have got narrowed...
Definition: Overload.h:120
Lvalue-to-rvalue conversion (C++ 4.1)
Definition: Overload.h:62
OverloadFailureKind
Definition: Overload.h:548
unsigned ObjCLifetimeConversionBinding
Whether this binds a reference to an object with a different Objective-C lifetime qualifier...
Definition: Overload.h:184
unsigned NumConversions
NumConversions - The number of elements in the Conversions array.
Definition: Overload.h:625
bool isIdentityConversion() const
Definition: Overload.h:224
QualType getFromType() const
Definition: Overload.h:291
Integral conversions (C++ 4.7)
Definition: Overload.h:70
Complex promotions (Clang extension)
Definition: Overload.h:69
#define false
Definition: stdbool.h:33
Kind
ImplicitConversionSequence - Represents an implicit conversion sequence, which may be a standard conv...
Definition: Overload.h:375
bool isInitialized() const
Determines whether this conversion sequence has been initialized.
Definition: Overload.h:497
OverloadCandidate - A single candidate in an overload set (C++ 13.3).
Definition: Overload.h:592
Encodes a location in the source.
unsigned getNumParams() const
getNumParams - Return the number of parameters this function must have based on its FunctionType...
Definition: Decl.cpp:2743
const TemplateArgument * iterator
Definition: Type.h:4070
A vector splat from an arithmetic type.
Definition: Overload.h:80
OverloadingResult
OverloadingResult - Capture the result of performing overload resolution.
Definition: Overload.h:40
Objective-C ARC writeback conversion.
Definition: Overload.h:84
void init(FailureKind K, QualType From, QualType To)
Definition: Overload.h:353
void dump() const
dump - Print this implicit conversion sequence to standard error.
bool isStdInitializerListElement() const
Whether the target is really a std::initializer_list, and the sequence only represents the worst elem...
Definition: Overload.h:524
void setAsIdentityConversion()
StandardConversionSequence - Set the standard conversion sequence to the identity conversion...
Pointer conversions (C++ 4.10)
Definition: Overload.h:74
Lookup for candidates for a call using operator syntax.
Definition: Overload.h:709
CandidateSetKind getKind() const
Definition: Overload.h:738
QualType getToType(unsigned Idx) const
Definition: Overload.h:217
Requests that all candidates be shown.
Definition: Overload.h:50
Derived-to-base (C++ [over.best.ics])
Definition: Overload.h:78
Complex-real conversions (C99 6.3.1.7)
Definition: Overload.h:81
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13...
Definition: Overload.h:700
void setBad(BadConversionSequence::FailureKind Failure, Expr *FromExpr, QualType ToType)
Sets this sequence as a bad conversion for an explicit argument.
Definition: Overload.h:500
static QualType getFromOpaquePtr(const void *Ptr)
Definition: Type.h:624
void setFromExpr(Expr *E)
Definition: Overload.h:363
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...
QualType getType() const
Definition: Expr.h:125
void DiagnoseAmbiguousConversion(Sema &S, SourceLocation CaretLoc, const PartialDiagnostic &PDiag) const
Diagnoses an ambiguous conversion.
OverloadCandidateSet(SourceLocation Loc, CandidateSetKind CSK)
Definition: Overload.h:733
ConversionSet::const_iterator const_iterator
Definition: Overload.h:316
const ConversionSet & conversions() const
Definition: Overload.h:304
Conversions allowed in C, but not C++.
Definition: Overload.h:86
Array-to-pointer conversion (C++ 4.2)
Definition: Overload.h:63
StandardConversionSequence Before
Represents the standard conversion that occurs before the actual user-defined conversion.
Definition: Overload.h:251
Requests that only viable candidates be shown.
Definition: Overload.h:53
detail::InMemoryDirectory::const_iterator E
FunctionDecl * Function
Function - The actual function that this candidate represents.
Definition: Overload.h:597
unsigned getNumParams() const
Definition: Overload.h:685
bool isPointerConversionToBool() const
isPointerConversionToBool - Determines whether this conversion is a conversion of a pointer or pointe...
FunctionDecl * ConversionFunction
ConversionFunction - The function that will perform the user-defined conversion.
Definition: Overload.h:273
Conversion only allowed in the C standard.
Definition: Overload.h:100
void setToType(QualType T)
Definition: Overload.h:368
void setAllToTypes(QualType T)
Definition: Overload.h:208
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:5675
unsigned getKindRank() const
Return a ranking of the implicit conversion sequence kind, where smaller ranks represent better conve...
Definition: Overload.h:468
unsigned BindsImplicitObjectArgumentWithoutRefQualifier
Whether this binds an implicit object argument to a non-static member function without a ref-qualifie...
Definition: Overload.h:180
unsigned char FailureKind
FailureKind - The reason why this candidate is not viable.
Definition: Overload.h:646
void setBad(BadConversionSequence::FailureKind Failure, QualType FromType, QualType ToType)
Sets this sequence as a bad conversion for an implicit argument.
Definition: Overload.h:507
DeclAccessPair FoundDecl
FoundDecl - The original declaration that was looked up / invented / otherwise found, together with its access.
Definition: Overload.h:602
Block Pointer conversions.
Definition: Overload.h:82
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:622
AmbiguousConversionSequence Ambiguous
When ConversionKind == AmbiguousConversion, provides the details of the ambiguous conversion...
Definition: Overload.h:422
const_iterator begin() const
Definition: Overload.h:317
Function-to-pointer (C++ 4.3)
Definition: Overload.h:64
void * FromTypePtr
FromType - The type that this conversion is converting from.
Definition: Overload.h:189
OverloadingResult BestViableFunction(Sema &S, SourceLocation Loc, OverloadCandidateSet::iterator &Best, bool UserDefinedConversion=false)
Find the best viable function on this overload set, if it exists.
The class facilities generation and storage of conversion FixIts.
Zero constant to event (OpenCL1.2 6.12.10)
Definition: Overload.h:85
void clear()
Clear out all of the candidates.
ImplicitConversionKind First
First – The first conversion can be an lvalue-to-rvalue conversion, array-to-pointer conversion...
Definition: Overload.h:136
No viable function found.
Definition: Overload.h:42
DeductionFailureInfo DeductionFailure
Definition: Overload.h:653
size_t size() const
Definition: Overload.h:753
Pointer-to-member conversions (C++ 4.11)
Definition: Overload.h:75
void setToType(unsigned Idx, QualType T)
Definition: Overload.h:204
bool isPointerConversionToVoidPointer(ASTContext &Context) const
isPointerConversionToVoidPointer - Determines whether this conversion is a conversion of a pointer to...
This conversion candidate is not viable because its result type is not implicitly convertible to the ...
Definition: Overload.h:572
SourceLocation getLocation() const
Definition: Overload.h:737
StandardConversionSequence - represents a standard conversion sequence (C++ 13.3.3.1.1).
Definition: Overload.h:131