contrib/llvm/tools/clang/include/clang/Sema/Overload.h

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