1//===--- SemaOverload.cpp - C++ Overloading -------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file provides Sema routines for C++ overloading.
10//
11//===----------------------------------------------------------------------===//
12
13#include "clang/AST/ASTContext.h"
14#include "clang/AST/ASTLambda.h"
15#include "clang/AST/CXXInheritance.h"
16#include "clang/AST/DeclCXX.h"
17#include "clang/AST/DeclObjC.h"
18#include "clang/AST/DependenceFlags.h"
19#include "clang/AST/Expr.h"
20#include "clang/AST/ExprCXX.h"
21#include "clang/AST/ExprObjC.h"
22#include "clang/AST/Type.h"
23#include "clang/AST/TypeOrdering.h"
24#include "clang/Basic/Diagnostic.h"
25#include "clang/Basic/DiagnosticOptions.h"
26#include "clang/Basic/OperatorKinds.h"
27#include "clang/Basic/PartialDiagnostic.h"
28#include "clang/Basic/SourceManager.h"
29#include "clang/Basic/TargetInfo.h"
30#include "clang/Sema/EnterExpressionEvaluationContext.h"
31#include "clang/Sema/Initialization.h"
32#include "clang/Sema/Lookup.h"
33#include "clang/Sema/Overload.h"
34#include "clang/Sema/SemaInternal.h"
35#include "clang/Sema/Template.h"
36#include "clang/Sema/TemplateDeduction.h"
37#include "llvm/ADT/DenseSet.h"
38#include "llvm/ADT/STLExtras.h"
39#include "llvm/ADT/SmallPtrSet.h"
40#include "llvm/ADT/SmallString.h"
41#include "llvm/ADT/SmallVector.h"
42#include "llvm/Support/Casting.h"
43#include <algorithm>
44#include <cstddef>
45#include <cstdlib>
46#include <optional>
47
48using namespace clang;
49using namespace sema;
50
51using AllowedExplicit = Sema::AllowedExplicit;
52
53static bool functionHasPassObjectSizeParams(const FunctionDecl *FD) {
54  return llvm::any_of(FD->parameters(), [](const ParmVarDecl *P) {
55    return P->hasAttr<PassObjectSizeAttr>();
56  });
57}
58
59/// A convenience routine for creating a decayed reference to a function.
60static ExprResult CreateFunctionRefExpr(
61    Sema &S, FunctionDecl *Fn, NamedDecl *FoundDecl, const Expr *Base,
62    bool HadMultipleCandidates, SourceLocation Loc = SourceLocation(),
63    const DeclarationNameLoc &LocInfo = DeclarationNameLoc()) {
64  if (S.DiagnoseUseOfDecl(FoundDecl, Loc))
65    return ExprError();
66  // If FoundDecl is different from Fn (such as if one is a template
67  // and the other a specialization), make sure DiagnoseUseOfDecl is
68  // called on both.
69  // FIXME: This would be more comprehensively addressed by modifying
70  // DiagnoseUseOfDecl to accept both the FoundDecl and the decl
71  // being used.
72  if (FoundDecl != Fn && S.DiagnoseUseOfDecl(Fn, Loc))
73    return ExprError();
74  DeclRefExpr *DRE = new (S.Context)
75      DeclRefExpr(S.Context, Fn, false, Fn->getType(), VK_LValue, Loc, LocInfo);
76  if (HadMultipleCandidates)
77    DRE->setHadMultipleCandidates(true);
78
79  S.MarkDeclRefReferenced(DRE, Base);
80  if (auto *FPT = DRE->getType()->getAs<FunctionProtoType>()) {
81    if (isUnresolvedExceptionSpec(FPT->getExceptionSpecType())) {
82      S.ResolveExceptionSpec(Loc, FPT);
83      DRE->setType(Fn->getType());
84    }
85  }
86  return S.ImpCastExprToType(DRE, S.Context.getPointerType(DRE->getType()),
87                             CK_FunctionToPointerDecay);
88}
89
90static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
91                                 bool InOverloadResolution,
92                                 StandardConversionSequence &SCS,
93                                 bool CStyle,
94                                 bool AllowObjCWritebackConversion);
95
96static bool IsTransparentUnionStandardConversion(Sema &S, Expr* From,
97                                                 QualType &ToType,
98                                                 bool InOverloadResolution,
99                                                 StandardConversionSequence &SCS,
100                                                 bool CStyle);
101static OverloadingResult
102IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
103                        UserDefinedConversionSequence& User,
104                        OverloadCandidateSet& Conversions,
105                        AllowedExplicit AllowExplicit,
106                        bool AllowObjCConversionOnExplicit);
107
108static ImplicitConversionSequence::CompareKind
109CompareStandardConversionSequences(Sema &S, SourceLocation Loc,
110                                   const StandardConversionSequence& SCS1,
111                                   const StandardConversionSequence& SCS2);
112
113static ImplicitConversionSequence::CompareKind
114CompareQualificationConversions(Sema &S,
115                                const StandardConversionSequence& SCS1,
116                                const StandardConversionSequence& SCS2);
117
118static ImplicitConversionSequence::CompareKind
119CompareDerivedToBaseConversions(Sema &S, SourceLocation Loc,
120                                const StandardConversionSequence& SCS1,
121                                const StandardConversionSequence& SCS2);
122
123/// GetConversionRank - Retrieve the implicit conversion rank
124/// corresponding to the given implicit conversion kind.
125ImplicitConversionRank clang::GetConversionRank(ImplicitConversionKind Kind) {
126  static const ImplicitConversionRank
127    Rank[] = {
128    ICR_Exact_Match,
129    ICR_Exact_Match,
130    ICR_Exact_Match,
131    ICR_Exact_Match,
132    ICR_Exact_Match,
133    ICR_Exact_Match,
134    ICR_Promotion,
135    ICR_Promotion,
136    ICR_Promotion,
137    ICR_Conversion,
138    ICR_Conversion,
139    ICR_Conversion,
140    ICR_Conversion,
141    ICR_Conversion,
142    ICR_Conversion,
143    ICR_Conversion,
144    ICR_Conversion,
145    ICR_Conversion,
146    ICR_Conversion,
147    ICR_Conversion,
148    ICR_Conversion,
149    ICR_OCL_Scalar_Widening,
150    ICR_Complex_Real_Conversion,
151    ICR_Conversion,
152    ICR_Conversion,
153    ICR_Writeback_Conversion,
154    ICR_Exact_Match, // NOTE(gbiv): This may not be completely right --
155                     // it was omitted by the patch that added
156                     // ICK_Zero_Event_Conversion
157    ICR_Exact_Match, // NOTE(ctopper): This may not be completely right --
158                     // it was omitted by the patch that added
159                     // ICK_Zero_Queue_Conversion
160    ICR_C_Conversion,
161    ICR_C_Conversion_Extension,
162    ICR_Conversion,
163  };
164  static_assert(std::size(Rank) == (int)ICK_Num_Conversion_Kinds);
165  return Rank[(int)Kind];
166}
167
168/// GetImplicitConversionName - Return the name of this kind of
169/// implicit conversion.
170static const char* GetImplicitConversionName(ImplicitConversionKind Kind) {
171  static const char* const Name[] = {
172    "No conversion",
173    "Lvalue-to-rvalue",
174    "Array-to-pointer",
175    "Function-to-pointer",
176    "Function pointer conversion",
177    "Qualification",
178    "Integral promotion",
179    "Floating point promotion",
180    "Complex promotion",
181    "Integral conversion",
182    "Floating conversion",
183    "Complex conversion",
184    "Floating-integral conversion",
185    "Pointer conversion",
186    "Pointer-to-member conversion",
187    "Boolean conversion",
188    "Compatible-types conversion",
189    "Derived-to-base conversion",
190    "Vector conversion",
191    "SVE Vector conversion",
192    "RVV Vector conversion",
193    "Vector splat",
194    "Complex-real conversion",
195    "Block Pointer conversion",
196    "Transparent Union Conversion",
197    "Writeback conversion",
198    "OpenCL Zero Event Conversion",
199    "OpenCL Zero Queue Conversion",
200    "C specific type conversion",
201    "Incompatible pointer conversion",
202    "Fixed point conversion",
203  };
204  static_assert(std::size(Name) == (int)ICK_Num_Conversion_Kinds);
205  return Name[Kind];
206}
207
208/// StandardConversionSequence - Set the standard conversion
209/// sequence to the identity conversion.
210void StandardConversionSequence::setAsIdentityConversion() {
211  First = ICK_Identity;
212  Second = ICK_Identity;
213  Third = ICK_Identity;
214  DeprecatedStringLiteralToCharPtr = false;
215  QualificationIncludesObjCLifetime = false;
216  ReferenceBinding = false;
217  DirectBinding = false;
218  IsLvalueReference = true;
219  BindsToFunctionLvalue = false;
220  BindsToRvalue = false;
221  BindsImplicitObjectArgumentWithoutRefQualifier = false;
222  ObjCLifetimeConversionBinding = false;
223  CopyConstructor = nullptr;
224}
225
226/// getRank - Retrieve the rank of this standard conversion sequence
227/// (C++ 13.3.3.1.1p3). The rank is the largest rank of each of the
228/// implicit conversions.
229ImplicitConversionRank StandardConversionSequence::getRank() const {
230  ImplicitConversionRank Rank = ICR_Exact_Match;
231  if  (GetConversionRank(First) > Rank)
232    Rank = GetConversionRank(First);
233  if  (GetConversionRank(Second) > Rank)
234    Rank = GetConversionRank(Second);
235  if  (GetConversionRank(Third) > Rank)
236    Rank = GetConversionRank(Third);
237  return Rank;
238}
239
240/// isPointerConversionToBool - Determines whether this conversion is
241/// a conversion of a pointer or pointer-to-member to bool. This is
242/// used as part of the ranking of standard conversion sequences
243/// (C++ 13.3.3.2p4).
244bool StandardConversionSequence::isPointerConversionToBool() const {
245  // Note that FromType has not necessarily been transformed by the
246  // array-to-pointer or function-to-pointer implicit conversions, so
247  // check for their presence as well as checking whether FromType is
248  // a pointer.
249  if (getToType(1)->isBooleanType() &&
250      (getFromType()->isPointerType() ||
251       getFromType()->isMemberPointerType() ||
252       getFromType()->isObjCObjectPointerType() ||
253       getFromType()->isBlockPointerType() ||
254       First == ICK_Array_To_Pointer || First == ICK_Function_To_Pointer))
255    return true;
256
257  return false;
258}
259
260/// isPointerConversionToVoidPointer - Determines whether this
261/// conversion is a conversion of a pointer to a void pointer. This is
262/// used as part of the ranking of standard conversion sequences (C++
263/// 13.3.3.2p4).
264bool
265StandardConversionSequence::
266isPointerConversionToVoidPointer(ASTContext& Context) const {
267  QualType FromType = getFromType();
268  QualType ToType = getToType(1);
269
270  // Note that FromType has not necessarily been transformed by the
271  // array-to-pointer implicit conversion, so check for its presence
272  // and redo the conversion to get a pointer.
273  if (First == ICK_Array_To_Pointer)
274    FromType = Context.getArrayDecayedType(FromType);
275
276  if (Second == ICK_Pointer_Conversion && FromType->isAnyPointerType())
277    if (const PointerType* ToPtrType = ToType->getAs<PointerType>())
278      return ToPtrType->getPointeeType()->isVoidType();
279
280  return false;
281}
282
283/// Skip any implicit casts which could be either part of a narrowing conversion
284/// or after one in an implicit conversion.
285static const Expr *IgnoreNarrowingConversion(ASTContext &Ctx,
286                                             const Expr *Converted) {
287  // We can have cleanups wrapping the converted expression; these need to be
288  // preserved so that destructors run if necessary.
289  if (auto *EWC = dyn_cast<ExprWithCleanups>(Converted)) {
290    Expr *Inner =
291        const_cast<Expr *>(IgnoreNarrowingConversion(Ctx, EWC->getSubExpr()));
292    return ExprWithCleanups::Create(Ctx, Inner, EWC->cleanupsHaveSideEffects(),
293                                    EWC->getObjects());
294  }
295
296  while (auto *ICE = dyn_cast<ImplicitCastExpr>(Converted)) {
297    switch (ICE->getCastKind()) {
298    case CK_NoOp:
299    case CK_IntegralCast:
300    case CK_IntegralToBoolean:
301    case CK_IntegralToFloating:
302    case CK_BooleanToSignedIntegral:
303    case CK_FloatingToIntegral:
304    case CK_FloatingToBoolean:
305    case CK_FloatingCast:
306      Converted = ICE->getSubExpr();
307      continue;
308
309    default:
310      return Converted;
311    }
312  }
313
314  return Converted;
315}
316
317/// Check if this standard conversion sequence represents a narrowing
318/// conversion, according to C++11 [dcl.init.list]p7.
319///
320/// \param Ctx  The AST context.
321/// \param Converted  The result of applying this standard conversion sequence.
322/// \param ConstantValue  If this is an NK_Constant_Narrowing conversion, the
323///        value of the expression prior to the narrowing conversion.
324/// \param ConstantType  If this is an NK_Constant_Narrowing conversion, the
325///        type of the expression prior to the narrowing conversion.
326/// \param IgnoreFloatToIntegralConversion If true type-narrowing conversions
327///        from floating point types to integral types should be ignored.
328NarrowingKind StandardConversionSequence::getNarrowingKind(
329    ASTContext &Ctx, const Expr *Converted, APValue &ConstantValue,
330    QualType &ConstantType, bool IgnoreFloatToIntegralConversion) const {
331  assert(Ctx.getLangOpts().CPlusPlus && "narrowing check outside C++");
332
333  // C++11 [dcl.init.list]p7:
334  //   A narrowing conversion is an implicit conversion ...
335  QualType FromType = getToType(0);
336  QualType ToType = getToType(1);
337
338  // A conversion to an enumeration type is narrowing if the conversion to
339  // the underlying type is narrowing. This only arises for expressions of
340  // the form 'Enum{init}'.
341  if (auto *ET = ToType->getAs<EnumType>())
342    ToType = ET->getDecl()->getIntegerType();
343
344  switch (Second) {
345  // 'bool' is an integral type; dispatch to the right place to handle it.
346  case ICK_Boolean_Conversion:
347    if (FromType->isRealFloatingType())
348      goto FloatingIntegralConversion;
349    if (FromType->isIntegralOrUnscopedEnumerationType())
350      goto IntegralConversion;
351    // -- from a pointer type or pointer-to-member type to bool, or
352    return NK_Type_Narrowing;
353
354  // -- from a floating-point type to an integer type, or
355  //
356  // -- from an integer type or unscoped enumeration type to a floating-point
357  //    type, except where the source is a constant expression and the actual
358  //    value after conversion will fit into the target type and will produce
359  //    the original value when converted back to the original type, or
360  case ICK_Floating_Integral:
361  FloatingIntegralConversion:
362    if (FromType->isRealFloatingType() && ToType->isIntegralType(Ctx)) {
363      return NK_Type_Narrowing;
364    } else if (FromType->isIntegralOrUnscopedEnumerationType() &&
365               ToType->isRealFloatingType()) {
366      if (IgnoreFloatToIntegralConversion)
367        return NK_Not_Narrowing;
368      const Expr *Initializer = IgnoreNarrowingConversion(Ctx, Converted);
369      assert(Initializer && "Unknown conversion expression");
370
371      // If it's value-dependent, we can't tell whether it's narrowing.
372      if (Initializer->isValueDependent())
373        return NK_Dependent_Narrowing;
374
375      if (std::optional<llvm::APSInt> IntConstantValue =
376              Initializer->getIntegerConstantExpr(Ctx)) {
377        // Convert the integer to the floating type.
378        llvm::APFloat Result(Ctx.getFloatTypeSemantics(ToType));
379        Result.convertFromAPInt(*IntConstantValue, IntConstantValue->isSigned(),
380                                llvm::APFloat::rmNearestTiesToEven);
381        // And back.
382        llvm::APSInt ConvertedValue = *IntConstantValue;
383        bool ignored;
384        Result.convertToInteger(ConvertedValue,
385                                llvm::APFloat::rmTowardZero, &ignored);
386        // If the resulting value is different, this was a narrowing conversion.
387        if (*IntConstantValue != ConvertedValue) {
388          ConstantValue = APValue(*IntConstantValue);
389          ConstantType = Initializer->getType();
390          return NK_Constant_Narrowing;
391        }
392      } else {
393        // Variables are always narrowings.
394        return NK_Variable_Narrowing;
395      }
396    }
397    return NK_Not_Narrowing;
398
399  // -- from long double to double or float, or from double to float, except
400  //    where the source is a constant expression and the actual value after
401  //    conversion is within the range of values that can be represented (even
402  //    if it cannot be represented exactly), or
403  case ICK_Floating_Conversion:
404    if (FromType->isRealFloatingType() && ToType->isRealFloatingType() &&
405        Ctx.getFloatingTypeOrder(FromType, ToType) == 1) {
406      // FromType is larger than ToType.
407      const Expr *Initializer = IgnoreNarrowingConversion(Ctx, Converted);
408
409      // If it's value-dependent, we can't tell whether it's narrowing.
410      if (Initializer->isValueDependent())
411        return NK_Dependent_Narrowing;
412
413      if (Initializer->isCXX11ConstantExpr(Ctx, &ConstantValue)) {
414        // Constant!
415        assert(ConstantValue.isFloat());
416        llvm::APFloat FloatVal = ConstantValue.getFloat();
417        // Convert the source value into the target type.
418        bool ignored;
419        llvm::APFloat::opStatus ConvertStatus = FloatVal.convert(
420          Ctx.getFloatTypeSemantics(ToType),
421          llvm::APFloat::rmNearestTiesToEven, &ignored);
422        // If there was no overflow, the source value is within the range of
423        // values that can be represented.
424        if (ConvertStatus & llvm::APFloat::opOverflow) {
425          ConstantType = Initializer->getType();
426          return NK_Constant_Narrowing;
427        }
428      } else {
429        return NK_Variable_Narrowing;
430      }
431    }
432    return NK_Not_Narrowing;
433
434  // -- from an integer type or unscoped enumeration type to an integer type
435  //    that cannot represent all the values of the original type, except where
436  //    the source is a constant expression and the actual value after
437  //    conversion will fit into the target type and will produce the original
438  //    value when converted back to the original type.
439  case ICK_Integral_Conversion:
440  IntegralConversion: {
441    assert(FromType->isIntegralOrUnscopedEnumerationType());
442    assert(ToType->isIntegralOrUnscopedEnumerationType());
443    const bool FromSigned = FromType->isSignedIntegerOrEnumerationType();
444    const unsigned FromWidth = Ctx.getIntWidth(FromType);
445    const bool ToSigned = ToType->isSignedIntegerOrEnumerationType();
446    const unsigned ToWidth = Ctx.getIntWidth(ToType);
447
448    if (FromWidth > ToWidth ||
449        (FromWidth == ToWidth && FromSigned != ToSigned) ||
450        (FromSigned && !ToSigned)) {
451      // Not all values of FromType can be represented in ToType.
452      const Expr *Initializer = IgnoreNarrowingConversion(Ctx, Converted);
453
454      // If it's value-dependent, we can't tell whether it's narrowing.
455      if (Initializer->isValueDependent())
456        return NK_Dependent_Narrowing;
457
458      std::optional<llvm::APSInt> OptInitializerValue;
459      if (!(OptInitializerValue = Initializer->getIntegerConstantExpr(Ctx))) {
460        // Such conversions on variables are always narrowing.
461        return NK_Variable_Narrowing;
462      }
463      llvm::APSInt &InitializerValue = *OptInitializerValue;
464      bool Narrowing = false;
465      if (FromWidth < ToWidth) {
466        // Negative -> unsigned is narrowing. Otherwise, more bits is never
467        // narrowing.
468        if (InitializerValue.isSigned() && InitializerValue.isNegative())
469          Narrowing = true;
470      } else {
471        // Add a bit to the InitializerValue so we don't have to worry about
472        // signed vs. unsigned comparisons.
473        InitializerValue = InitializerValue.extend(
474          InitializerValue.getBitWidth() + 1);
475        // Convert the initializer to and from the target width and signed-ness.
476        llvm::APSInt ConvertedValue = InitializerValue;
477        ConvertedValue = ConvertedValue.trunc(ToWidth);
478        ConvertedValue.setIsSigned(ToSigned);
479        ConvertedValue = ConvertedValue.extend(InitializerValue.getBitWidth());
480        ConvertedValue.setIsSigned(InitializerValue.isSigned());
481        // If the result is different, this was a narrowing conversion.
482        if (ConvertedValue != InitializerValue)
483          Narrowing = true;
484      }
485      if (Narrowing) {
486        ConstantType = Initializer->getType();
487        ConstantValue = APValue(InitializerValue);
488        return NK_Constant_Narrowing;
489      }
490    }
491    return NK_Not_Narrowing;
492  }
493
494  default:
495    // Other kinds of conversions are not narrowings.
496    return NK_Not_Narrowing;
497  }
498}
499
500/// dump - Print this standard conversion sequence to standard
501/// error. Useful for debugging overloading issues.
502LLVM_DUMP_METHOD void StandardConversionSequence::dump() const {
503  raw_ostream &OS = llvm::errs();
504  bool PrintedSomething = false;
505  if (First != ICK_Identity) {
506    OS << GetImplicitConversionName(First);
507    PrintedSomething = true;
508  }
509
510  if (Second != ICK_Identity) {
511    if (PrintedSomething) {
512      OS << " -> ";
513    }
514    OS << GetImplicitConversionName(Second);
515
516    if (CopyConstructor) {
517      OS << " (by copy constructor)";
518    } else if (DirectBinding) {
519      OS << " (direct reference binding)";
520    } else if (ReferenceBinding) {
521      OS << " (reference binding)";
522    }
523    PrintedSomething = true;
524  }
525
526  if (Third != ICK_Identity) {
527    if (PrintedSomething) {
528      OS << " -> ";
529    }
530    OS << GetImplicitConversionName(Third);
531    PrintedSomething = true;
532  }
533
534  if (!PrintedSomething) {
535    OS << "No conversions required";
536  }
537}
538
539/// dump - Print this user-defined conversion sequence to standard
540/// error. Useful for debugging overloading issues.
541void UserDefinedConversionSequence::dump() const {
542  raw_ostream &OS = llvm::errs();
543  if (Before.First || Before.Second || Before.Third) {
544    Before.dump();
545    OS << " -> ";
546  }
547  if (ConversionFunction)
548    OS << '\'' << *ConversionFunction << '\'';
549  else
550    OS << "aggregate initialization";
551  if (After.First || After.Second || After.Third) {
552    OS << " -> ";
553    After.dump();
554  }
555}
556
557/// dump - Print this implicit conversion sequence to standard
558/// error. Useful for debugging overloading issues.
559void ImplicitConversionSequence::dump() const {
560  raw_ostream &OS = llvm::errs();
561  if (hasInitializerListContainerType())
562    OS << "Worst list element conversion: ";
563  switch (ConversionKind) {
564  case StandardConversion:
565    OS << "Standard conversion: ";
566    Standard.dump();
567    break;
568  case UserDefinedConversion:
569    OS << "User-defined conversion: ";
570    UserDefined.dump();
571    break;
572  case EllipsisConversion:
573    OS << "Ellipsis conversion";
574    break;
575  case AmbiguousConversion:
576    OS << "Ambiguous conversion";
577    break;
578  case BadConversion:
579    OS << "Bad conversion";
580    break;
581  }
582
583  OS << "\n";
584}
585
586void AmbiguousConversionSequence::construct() {
587  new (&conversions()) ConversionSet();
588}
589
590void AmbiguousConversionSequence::destruct() {
591  conversions().~ConversionSet();
592}
593
594void
595AmbiguousConversionSequence::copyFrom(const AmbiguousConversionSequence &O) {
596  FromTypePtr = O.FromTypePtr;
597  ToTypePtr = O.ToTypePtr;
598  new (&conversions()) ConversionSet(O.conversions());
599}
600
601namespace {
602  // Structure used by DeductionFailureInfo to store
603  // template argument information.
604  struct DFIArguments {
605    TemplateArgument FirstArg;
606    TemplateArgument SecondArg;
607  };
608  // Structure used by DeductionFailureInfo to store
609  // template parameter and template argument information.
610  struct DFIParamWithArguments : DFIArguments {
611    TemplateParameter Param;
612  };
613  // Structure used by DeductionFailureInfo to store template argument
614  // information and the index of the problematic call argument.
615  struct DFIDeducedMismatchArgs : DFIArguments {
616    TemplateArgumentList *TemplateArgs;
617    unsigned CallArgIndex;
618  };
619  // Structure used by DeductionFailureInfo to store information about
620  // unsatisfied constraints.
621  struct CNSInfo {
622    TemplateArgumentList *TemplateArgs;
623    ConstraintSatisfaction Satisfaction;
624  };
625}
626
627/// Convert from Sema's representation of template deduction information
628/// to the form used in overload-candidate information.
629DeductionFailureInfo
630clang::MakeDeductionFailureInfo(ASTContext &Context,
631                                Sema::TemplateDeductionResult TDK,
632                                TemplateDeductionInfo &Info) {
633  DeductionFailureInfo Result;
634  Result.Result = static_cast<unsigned>(TDK);
635  Result.HasDiagnostic = false;
636  switch (TDK) {
637  case Sema::TDK_Invalid:
638  case Sema::TDK_InstantiationDepth:
639  case Sema::TDK_TooManyArguments:
640  case Sema::TDK_TooFewArguments:
641  case Sema::TDK_MiscellaneousDeductionFailure:
642  case Sema::TDK_CUDATargetMismatch:
643    Result.Data = nullptr;
644    break;
645
646  case Sema::TDK_Incomplete:
647  case Sema::TDK_InvalidExplicitArguments:
648    Result.Data = Info.Param.getOpaqueValue();
649    break;
650
651  case Sema::TDK_DeducedMismatch:
652  case Sema::TDK_DeducedMismatchNested: {
653    // FIXME: Should allocate from normal heap so that we can free this later.
654    auto *Saved = new (Context) DFIDeducedMismatchArgs;
655    Saved->FirstArg = Info.FirstArg;
656    Saved->SecondArg = Info.SecondArg;
657    Saved->TemplateArgs = Info.takeSugared();
658    Saved->CallArgIndex = Info.CallArgIndex;
659    Result.Data = Saved;
660    break;
661  }
662
663  case Sema::TDK_NonDeducedMismatch: {
664    // FIXME: Should allocate from normal heap so that we can free this later.
665    DFIArguments *Saved = new (Context) DFIArguments;
666    Saved->FirstArg = Info.FirstArg;
667    Saved->SecondArg = Info.SecondArg;
668    Result.Data = Saved;
669    break;
670  }
671
672  case Sema::TDK_IncompletePack:
673    // FIXME: It's slightly wasteful to allocate two TemplateArguments for this.
674  case Sema::TDK_Inconsistent:
675  case Sema::TDK_Underqualified: {
676    // FIXME: Should allocate from normal heap so that we can free this later.
677    DFIParamWithArguments *Saved = new (Context) DFIParamWithArguments;
678    Saved->Param = Info.Param;
679    Saved->FirstArg = Info.FirstArg;
680    Saved->SecondArg = Info.SecondArg;
681    Result.Data = Saved;
682    break;
683  }
684
685  case Sema::TDK_SubstitutionFailure:
686    Result.Data = Info.takeSugared();
687    if (Info.hasSFINAEDiagnostic()) {
688      PartialDiagnosticAt *Diag = new (Result.Diagnostic) PartialDiagnosticAt(
689          SourceLocation(), PartialDiagnostic::NullDiagnostic());
690      Info.takeSFINAEDiagnostic(*Diag);
691      Result.HasDiagnostic = true;
692    }
693    break;
694
695  case Sema::TDK_ConstraintsNotSatisfied: {
696    CNSInfo *Saved = new (Context) CNSInfo;
697    Saved->TemplateArgs = Info.takeSugared();
698    Saved->Satisfaction = Info.AssociatedConstraintsSatisfaction;
699    Result.Data = Saved;
700    break;
701  }
702
703  case Sema::TDK_Success:
704  case Sema::TDK_NonDependentConversionFailure:
705  case Sema::TDK_AlreadyDiagnosed:
706    llvm_unreachable("not a deduction failure");
707  }
708
709  return Result;
710}
711
712void DeductionFailureInfo::Destroy() {
713  switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
714  case Sema::TDK_Success:
715  case Sema::TDK_Invalid:
716  case Sema::TDK_InstantiationDepth:
717  case Sema::TDK_Incomplete:
718  case Sema::TDK_TooManyArguments:
719  case Sema::TDK_TooFewArguments:
720  case Sema::TDK_InvalidExplicitArguments:
721  case Sema::TDK_CUDATargetMismatch:
722  case Sema::TDK_NonDependentConversionFailure:
723    break;
724
725  case Sema::TDK_IncompletePack:
726  case Sema::TDK_Inconsistent:
727  case Sema::TDK_Underqualified:
728  case Sema::TDK_DeducedMismatch:
729  case Sema::TDK_DeducedMismatchNested:
730  case Sema::TDK_NonDeducedMismatch:
731    // FIXME: Destroy the data?
732    Data = nullptr;
733    break;
734
735  case Sema::TDK_SubstitutionFailure:
736    // FIXME: Destroy the template argument list?
737    Data = nullptr;
738    if (PartialDiagnosticAt *Diag = getSFINAEDiagnostic()) {
739      Diag->~PartialDiagnosticAt();
740      HasDiagnostic = false;
741    }
742    break;
743
744  case Sema::TDK_ConstraintsNotSatisfied:
745    // FIXME: Destroy the template argument list?
746    Data = nullptr;
747    if (PartialDiagnosticAt *Diag = getSFINAEDiagnostic()) {
748      Diag->~PartialDiagnosticAt();
749      HasDiagnostic = false;
750    }
751    break;
752
753  // Unhandled
754  case Sema::TDK_MiscellaneousDeductionFailure:
755  case Sema::TDK_AlreadyDiagnosed:
756    break;
757  }
758}
759
760PartialDiagnosticAt *DeductionFailureInfo::getSFINAEDiagnostic() {
761  if (HasDiagnostic)
762    return static_cast<PartialDiagnosticAt*>(static_cast<void*>(Diagnostic));
763  return nullptr;
764}
765
766TemplateParameter DeductionFailureInfo::getTemplateParameter() {
767  switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
768  case Sema::TDK_Success:
769  case Sema::TDK_Invalid:
770  case Sema::TDK_InstantiationDepth:
771  case Sema::TDK_TooManyArguments:
772  case Sema::TDK_TooFewArguments:
773  case Sema::TDK_SubstitutionFailure:
774  case Sema::TDK_DeducedMismatch:
775  case Sema::TDK_DeducedMismatchNested:
776  case Sema::TDK_NonDeducedMismatch:
777  case Sema::TDK_CUDATargetMismatch:
778  case Sema::TDK_NonDependentConversionFailure:
779  case Sema::TDK_ConstraintsNotSatisfied:
780    return TemplateParameter();
781
782  case Sema::TDK_Incomplete:
783  case Sema::TDK_InvalidExplicitArguments:
784    return TemplateParameter::getFromOpaqueValue(Data);
785
786  case Sema::TDK_IncompletePack:
787  case Sema::TDK_Inconsistent:
788  case Sema::TDK_Underqualified:
789    return static_cast<DFIParamWithArguments*>(Data)->Param;
790
791  // Unhandled
792  case Sema::TDK_MiscellaneousDeductionFailure:
793  case Sema::TDK_AlreadyDiagnosed:
794    break;
795  }
796
797  return TemplateParameter();
798}
799
800TemplateArgumentList *DeductionFailureInfo::getTemplateArgumentList() {
801  switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
802  case Sema::TDK_Success:
803  case Sema::TDK_Invalid:
804  case Sema::TDK_InstantiationDepth:
805  case Sema::TDK_TooManyArguments:
806  case Sema::TDK_TooFewArguments:
807  case Sema::TDK_Incomplete:
808  case Sema::TDK_IncompletePack:
809  case Sema::TDK_InvalidExplicitArguments:
810  case Sema::TDK_Inconsistent:
811  case Sema::TDK_Underqualified:
812  case Sema::TDK_NonDeducedMismatch:
813  case Sema::TDK_CUDATargetMismatch:
814  case Sema::TDK_NonDependentConversionFailure:
815    return nullptr;
816
817  case Sema::TDK_DeducedMismatch:
818  case Sema::TDK_DeducedMismatchNested:
819    return static_cast<DFIDeducedMismatchArgs*>(Data)->TemplateArgs;
820
821  case Sema::TDK_SubstitutionFailure:
822    return static_cast<TemplateArgumentList*>(Data);
823
824  case Sema::TDK_ConstraintsNotSatisfied:
825    return static_cast<CNSInfo*>(Data)->TemplateArgs;
826
827  // Unhandled
828  case Sema::TDK_MiscellaneousDeductionFailure:
829  case Sema::TDK_AlreadyDiagnosed:
830    break;
831  }
832
833  return nullptr;
834}
835
836const TemplateArgument *DeductionFailureInfo::getFirstArg() {
837  switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
838  case Sema::TDK_Success:
839  case Sema::TDK_Invalid:
840  case Sema::TDK_InstantiationDepth:
841  case Sema::TDK_Incomplete:
842  case Sema::TDK_TooManyArguments:
843  case Sema::TDK_TooFewArguments:
844  case Sema::TDK_InvalidExplicitArguments:
845  case Sema::TDK_SubstitutionFailure:
846  case Sema::TDK_CUDATargetMismatch:
847  case Sema::TDK_NonDependentConversionFailure:
848  case Sema::TDK_ConstraintsNotSatisfied:
849    return nullptr;
850
851  case Sema::TDK_IncompletePack:
852  case Sema::TDK_Inconsistent:
853  case Sema::TDK_Underqualified:
854  case Sema::TDK_DeducedMismatch:
855  case Sema::TDK_DeducedMismatchNested:
856  case Sema::TDK_NonDeducedMismatch:
857    return &static_cast<DFIArguments*>(Data)->FirstArg;
858
859  // Unhandled
860  case Sema::TDK_MiscellaneousDeductionFailure:
861  case Sema::TDK_AlreadyDiagnosed:
862    break;
863  }
864
865  return nullptr;
866}
867
868const TemplateArgument *DeductionFailureInfo::getSecondArg() {
869  switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
870  case Sema::TDK_Success:
871  case Sema::TDK_Invalid:
872  case Sema::TDK_InstantiationDepth:
873  case Sema::TDK_Incomplete:
874  case Sema::TDK_IncompletePack:
875  case Sema::TDK_TooManyArguments:
876  case Sema::TDK_TooFewArguments:
877  case Sema::TDK_InvalidExplicitArguments:
878  case Sema::TDK_SubstitutionFailure:
879  case Sema::TDK_CUDATargetMismatch:
880  case Sema::TDK_NonDependentConversionFailure:
881  case Sema::TDK_ConstraintsNotSatisfied:
882    return nullptr;
883
884  case Sema::TDK_Inconsistent:
885  case Sema::TDK_Underqualified:
886  case Sema::TDK_DeducedMismatch:
887  case Sema::TDK_DeducedMismatchNested:
888  case Sema::TDK_NonDeducedMismatch:
889    return &static_cast<DFIArguments*>(Data)->SecondArg;
890
891  // Unhandled
892  case Sema::TDK_MiscellaneousDeductionFailure:
893  case Sema::TDK_AlreadyDiagnosed:
894    break;
895  }
896
897  return nullptr;
898}
899
900std::optional<unsigned> DeductionFailureInfo::getCallArgIndex() {
901  switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
902  case Sema::TDK_DeducedMismatch:
903  case Sema::TDK_DeducedMismatchNested:
904    return static_cast<DFIDeducedMismatchArgs*>(Data)->CallArgIndex;
905
906  default:
907    return std::nullopt;
908  }
909}
910
911static bool FunctionsCorrespond(ASTContext &Ctx, const FunctionDecl *X,
912                                const FunctionDecl *Y) {
913  if (!X || !Y)
914    return false;
915  if (X->getNumParams() != Y->getNumParams())
916    return false;
917  // FIXME: when do rewritten comparison operators
918  // with explicit object parameters correspond?
919  // https://cplusplus.github.io/CWG/issues/2797.html
920  for (unsigned I = 0; I < X->getNumParams(); ++I)
921    if (!Ctx.hasSameUnqualifiedType(X->getParamDecl(I)->getType(),
922                                    Y->getParamDecl(I)->getType()))
923      return false;
924  if (auto *FTX = X->getDescribedFunctionTemplate()) {
925    auto *FTY = Y->getDescribedFunctionTemplate();
926    if (!FTY)
927      return false;
928    if (!Ctx.isSameTemplateParameterList(FTX->getTemplateParameters(),
929                                         FTY->getTemplateParameters()))
930      return false;
931  }
932  return true;
933}
934
935static bool shouldAddReversedEqEq(Sema &S, SourceLocation OpLoc,
936                                  Expr *FirstOperand, FunctionDecl *EqFD) {
937  assert(EqFD->getOverloadedOperator() ==
938         OverloadedOperatorKind::OO_EqualEqual);
939  // C++2a [over.match.oper]p4:
940  // A non-template function or function template F named operator== is a
941  // rewrite target with first operand o unless a search for the name operator!=
942  // in the scope S from the instantiation context of the operator expression
943  // finds a function or function template that would correspond
944  // ([basic.scope.scope]) to F if its name were operator==, where S is the
945  // scope of the class type of o if F is a class member, and the namespace
946  // scope of which F is a member otherwise. A function template specialization
947  // named operator== is a rewrite target if its function template is a rewrite
948  // target.
949  DeclarationName NotEqOp = S.Context.DeclarationNames.getCXXOperatorName(
950      OverloadedOperatorKind::OO_ExclaimEqual);
951  if (isa<CXXMethodDecl>(EqFD)) {
952    // If F is a class member, search scope is class type of first operand.
953    QualType RHS = FirstOperand->getType();
954    auto *RHSRec = RHS->getAs<RecordType>();
955    if (!RHSRec)
956      return true;
957    LookupResult Members(S, NotEqOp, OpLoc,
958                         Sema::LookupNameKind::LookupMemberName);
959    S.LookupQualifiedName(Members, RHSRec->getDecl());
960    Members.suppressAccessDiagnostics();
961    for (NamedDecl *Op : Members)
962      if (FunctionsCorrespond(S.Context, EqFD, Op->getAsFunction()))
963        return false;
964    return true;
965  }
966  // Otherwise the search scope is the namespace scope of which F is a member.
967  for (NamedDecl *Op : EqFD->getEnclosingNamespaceContext()->lookup(NotEqOp)) {
968    auto *NotEqFD = Op->getAsFunction();
969    if (auto *UD = dyn_cast<UsingShadowDecl>(Op))
970      NotEqFD = UD->getUnderlyingDecl()->getAsFunction();
971    if (FunctionsCorrespond(S.Context, EqFD, NotEqFD) && S.isVisible(NotEqFD) &&
972        declaresSameEntity(cast<Decl>(EqFD->getEnclosingNamespaceContext()),
973                           cast<Decl>(Op->getLexicalDeclContext())))
974      return false;
975  }
976  return true;
977}
978
979bool OverloadCandidateSet::OperatorRewriteInfo::allowsReversed(
980    OverloadedOperatorKind Op) {
981  if (!AllowRewrittenCandidates)
982    return false;
983  return Op == OO_EqualEqual || Op == OO_Spaceship;
984}
985
986bool OverloadCandidateSet::OperatorRewriteInfo::shouldAddReversed(
987    Sema &S, ArrayRef<Expr *> OriginalArgs, FunctionDecl *FD) {
988  auto Op = FD->getOverloadedOperator();
989  if (!allowsReversed(Op))
990    return false;
991  if (Op == OverloadedOperatorKind::OO_EqualEqual) {
992    assert(OriginalArgs.size() == 2);
993    if (!shouldAddReversedEqEq(
994            S, OpLoc, /*FirstOperand in reversed args*/ OriginalArgs[1], FD))
995      return false;
996  }
997  // Don't bother adding a reversed candidate that can never be a better
998  // match than the non-reversed version.
999  return FD->getNumNonObjectParams() != 2 ||
1000         !S.Context.hasSameUnqualifiedType(FD->getParamDecl(0)->getType(),
1001                                           FD->getParamDecl(1)->getType()) ||
1002         FD->hasAttr<EnableIfAttr>();
1003}
1004
1005void OverloadCandidateSet::destroyCandidates() {
1006  for (iterator i = begin(), e = end(); i != e; ++i) {
1007    for (auto &C : i->Conversions)
1008      C.~ImplicitConversionSequence();
1009    if (!i->Viable && i->FailureKind == ovl_fail_bad_deduction)
1010      i->DeductionFailure.Destroy();
1011  }
1012}
1013
1014void OverloadCandidateSet::clear(CandidateSetKind CSK) {
1015  destroyCandidates();
1016  SlabAllocator.Reset();
1017  NumInlineBytesUsed = 0;
1018  Candidates.clear();
1019  Functions.clear();
1020  Kind = CSK;
1021}
1022
1023namespace {
1024  class UnbridgedCastsSet {
1025    struct Entry {
1026      Expr **Addr;
1027      Expr *Saved;
1028    };
1029    SmallVector<Entry, 2> Entries;
1030
1031  public:
1032    void save(Sema &S, Expr *&E) {
1033      assert(E->hasPlaceholderType(BuiltinType::ARCUnbridgedCast));
1034      Entry entry = { &E, E };
1035      Entries.push_back(entry);
1036      E = S.stripARCUnbridgedCast(E);
1037    }
1038
1039    void restore() {
1040      for (SmallVectorImpl<Entry>::iterator
1041             i = Entries.begin(), e = Entries.end(); i != e; ++i)
1042        *i->Addr = i->Saved;
1043    }
1044  };
1045}
1046
1047/// checkPlaceholderForOverload - Do any interesting placeholder-like
1048/// preprocessing on the given expression.
1049///
1050/// \param unbridgedCasts a collection to which to add unbridged casts;
1051///   without this, they will be immediately diagnosed as errors
1052///
1053/// Return true on unrecoverable error.
1054static bool
1055checkPlaceholderForOverload(Sema &S, Expr *&E,
1056                            UnbridgedCastsSet *unbridgedCasts = nullptr) {
1057  if (const BuiltinType *placeholder =  E->getType()->getAsPlaceholderType()) {
1058    // We can't handle overloaded expressions here because overload
1059    // resolution might reasonably tweak them.
1060    if (placeholder->getKind() == BuiltinType::Overload) return false;
1061
1062    // If the context potentially accepts unbridged ARC casts, strip
1063    // the unbridged cast and add it to the collection for later restoration.
1064    if (placeholder->getKind() == BuiltinType::ARCUnbridgedCast &&
1065        unbridgedCasts) {
1066      unbridgedCasts->save(S, E);
1067      return false;
1068    }
1069
1070    // Go ahead and check everything else.
1071    ExprResult result = S.CheckPlaceholderExpr(E);
1072    if (result.isInvalid())
1073      return true;
1074
1075    E = result.get();
1076    return false;
1077  }
1078
1079  // Nothing to do.
1080  return false;
1081}
1082
1083/// checkArgPlaceholdersForOverload - Check a set of call operands for
1084/// placeholders.
1085static bool checkArgPlaceholdersForOverload(Sema &S, MultiExprArg Args,
1086                                            UnbridgedCastsSet &unbridged) {
1087  for (unsigned i = 0, e = Args.size(); i != e; ++i)
1088    if (checkPlaceholderForOverload(S, Args[i], &unbridged))
1089      return true;
1090
1091  return false;
1092}
1093
1094/// Determine whether the given New declaration is an overload of the
1095/// declarations in Old. This routine returns Ovl_Match or Ovl_NonFunction if
1096/// New and Old cannot be overloaded, e.g., if New has the same signature as
1097/// some function in Old (C++ 1.3.10) or if the Old declarations aren't
1098/// functions (or function templates) at all. When it does return Ovl_Match or
1099/// Ovl_NonFunction, MatchedDecl will point to the decl that New cannot be
1100/// overloaded with. This decl may be a UsingShadowDecl on top of the underlying
1101/// declaration.
1102///
1103/// Example: Given the following input:
1104///
1105///   void f(int, float); // #1
1106///   void f(int, int); // #2
1107///   int f(int, int); // #3
1108///
1109/// When we process #1, there is no previous declaration of "f", so IsOverload
1110/// will not be used.
1111///
1112/// When we process #2, Old contains only the FunctionDecl for #1. By comparing
1113/// the parameter types, we see that #1 and #2 are overloaded (since they have
1114/// different signatures), so this routine returns Ovl_Overload; MatchedDecl is
1115/// unchanged.
1116///
1117/// When we process #3, Old is an overload set containing #1 and #2. We compare
1118/// the signatures of #3 to #1 (they're overloaded, so we do nothing) and then
1119/// #3 to #2. Since the signatures of #3 and #2 are identical (return types of
1120/// functions are not part of the signature), IsOverload returns Ovl_Match and
1121/// MatchedDecl will be set to point to the FunctionDecl for #2.
1122///
1123/// 'NewIsUsingShadowDecl' indicates that 'New' is being introduced into a class
1124/// by a using declaration. The rules for whether to hide shadow declarations
1125/// ignore some properties which otherwise figure into a function template's
1126/// signature.
1127Sema::OverloadKind
1128Sema::CheckOverload(Scope *S, FunctionDecl *New, const LookupResult &Old,
1129                    NamedDecl *&Match, bool NewIsUsingDecl) {
1130  for (LookupResult::iterator I = Old.begin(), E = Old.end();
1131         I != E; ++I) {
1132    NamedDecl *OldD = *I;
1133
1134    bool OldIsUsingDecl = false;
1135    if (isa<UsingShadowDecl>(OldD)) {
1136      OldIsUsingDecl = true;
1137
1138      // We can always introduce two using declarations into the same
1139      // context, even if they have identical signatures.
1140      if (NewIsUsingDecl) continue;
1141
1142      OldD = cast<UsingShadowDecl>(OldD)->getTargetDecl();
1143    }
1144
1145    // A using-declaration does not conflict with another declaration
1146    // if one of them is hidden.
1147    if ((OldIsUsingDecl || NewIsUsingDecl) && !isVisible(*I))
1148      continue;
1149
1150    // If either declaration was introduced by a using declaration,
1151    // we'll need to use slightly different rules for matching.
1152    // Essentially, these rules are the normal rules, except that
1153    // function templates hide function templates with different
1154    // return types or template parameter lists.
1155    bool UseMemberUsingDeclRules =
1156      (OldIsUsingDecl || NewIsUsingDecl) && CurContext->isRecord() &&
1157      !New->getFriendObjectKind();
1158
1159    if (FunctionDecl *OldF = OldD->getAsFunction()) {
1160      if (!IsOverload(New, OldF, UseMemberUsingDeclRules)) {
1161        if (UseMemberUsingDeclRules && OldIsUsingDecl) {
1162          HideUsingShadowDecl(S, cast<UsingShadowDecl>(*I));
1163          continue;
1164        }
1165
1166        if (!isa<FunctionTemplateDecl>(OldD) &&
1167            !shouldLinkPossiblyHiddenDecl(*I, New))
1168          continue;
1169
1170        Match = *I;
1171        return Ovl_Match;
1172      }
1173
1174      // Builtins that have custom typechecking or have a reference should
1175      // not be overloadable or redeclarable.
1176      if (!getASTContext().canBuiltinBeRedeclared(OldF)) {
1177        Match = *I;
1178        return Ovl_NonFunction;
1179      }
1180    } else if (isa<UsingDecl>(OldD) || isa<UsingPackDecl>(OldD)) {
1181      // We can overload with these, which can show up when doing
1182      // redeclaration checks for UsingDecls.
1183      assert(Old.getLookupKind() == LookupUsingDeclName);
1184    } else if (isa<TagDecl>(OldD)) {
1185      // We can always overload with tags by hiding them.
1186    } else if (auto *UUD = dyn_cast<UnresolvedUsingValueDecl>(OldD)) {
1187      // Optimistically assume that an unresolved using decl will
1188      // overload; if it doesn't, we'll have to diagnose during
1189      // template instantiation.
1190      //
1191      // Exception: if the scope is dependent and this is not a class
1192      // member, the using declaration can only introduce an enumerator.
1193      if (UUD->getQualifier()->isDependent() && !UUD->isCXXClassMember()) {
1194        Match = *I;
1195        return Ovl_NonFunction;
1196      }
1197    } else {
1198      // (C++ 13p1):
1199      //   Only function declarations can be overloaded; object and type
1200      //   declarations cannot be overloaded.
1201      Match = *I;
1202      return Ovl_NonFunction;
1203    }
1204  }
1205
1206  // C++ [temp.friend]p1:
1207  //   For a friend function declaration that is not a template declaration:
1208  //    -- if the name of the friend is a qualified or unqualified template-id,
1209  //       [...], otherwise
1210  //    -- if the name of the friend is a qualified-id and a matching
1211  //       non-template function is found in the specified class or namespace,
1212  //       the friend declaration refers to that function, otherwise,
1213  //    -- if the name of the friend is a qualified-id and a matching function
1214  //       template is found in the specified class or namespace, the friend
1215  //       declaration refers to the deduced specialization of that function
1216  //       template, otherwise
1217  //    -- the name shall be an unqualified-id [...]
1218  // If we get here for a qualified friend declaration, we've just reached the
1219  // third bullet. If the type of the friend is dependent, skip this lookup
1220  // until instantiation.
1221  if (New->getFriendObjectKind() && New->getQualifier() &&
1222      !New->getDescribedFunctionTemplate() &&
1223      !New->getDependentSpecializationInfo() &&
1224      !New->getType()->isDependentType()) {
1225    LookupResult TemplateSpecResult(LookupResult::Temporary, Old);
1226    TemplateSpecResult.addAllDecls(Old);
1227    if (CheckFunctionTemplateSpecialization(New, nullptr, TemplateSpecResult,
1228                                            /*QualifiedFriend*/true)) {
1229      New->setInvalidDecl();
1230      return Ovl_Overload;
1231    }
1232
1233    Match = TemplateSpecResult.getAsSingle<FunctionDecl>();
1234    return Ovl_Match;
1235  }
1236
1237  return Ovl_Overload;
1238}
1239
1240static bool IsOverloadOrOverrideImpl(Sema &SemaRef, FunctionDecl *New,
1241                                     FunctionDecl *Old,
1242                                     bool UseMemberUsingDeclRules,
1243                                     bool ConsiderCudaAttrs,
1244                                     bool UseOverrideRules = false) {
1245  // C++ [basic.start.main]p2: This function shall not be overloaded.
1246  if (New->isMain())
1247    return false;
1248
1249  // MSVCRT user defined entry points cannot be overloaded.
1250  if (New->isMSVCRTEntryPoint())
1251    return false;
1252
1253  FunctionTemplateDecl *OldTemplate = Old->getDescribedFunctionTemplate();
1254  FunctionTemplateDecl *NewTemplate = New->getDescribedFunctionTemplate();
1255
1256  // C++ [temp.fct]p2:
1257  //   A function template can be overloaded with other function templates
1258  //   and with normal (non-template) functions.
1259  if ((OldTemplate == nullptr) != (NewTemplate == nullptr))
1260    return true;
1261
1262  // Is the function New an overload of the function Old?
1263  QualType OldQType = SemaRef.Context.getCanonicalType(Old->getType());
1264  QualType NewQType = SemaRef.Context.getCanonicalType(New->getType());
1265
1266  // Compare the signatures (C++ 1.3.10) of the two functions to
1267  // determine whether they are overloads. If we find any mismatch
1268  // in the signature, they are overloads.
1269
1270  // If either of these functions is a K&R-style function (no
1271  // prototype), then we consider them to have matching signatures.
1272  if (isa<FunctionNoProtoType>(OldQType.getTypePtr()) ||
1273      isa<FunctionNoProtoType>(NewQType.getTypePtr()))
1274    return false;
1275
1276  const auto *OldType = cast<FunctionProtoType>(OldQType);
1277  const auto *NewType = cast<FunctionProtoType>(NewQType);
1278
1279  // The signature of a function includes the types of its
1280  // parameters (C++ 1.3.10), which includes the presence or absence
1281  // of the ellipsis; see C++ DR 357).
1282  if (OldQType != NewQType && OldType->isVariadic() != NewType->isVariadic())
1283    return true;
1284
1285  // For member-like friends, the enclosing class is part of the signature.
1286  if ((New->isMemberLikeConstrainedFriend() ||
1287       Old->isMemberLikeConstrainedFriend()) &&
1288      !New->getLexicalDeclContext()->Equals(Old->getLexicalDeclContext()))
1289    return true;
1290
1291  // Compare the parameter lists.
1292  // This can only be done once we have establish that friend functions
1293  // inhabit the same context, otherwise we might tried to instantiate
1294  // references to non-instantiated entities during constraint substitution.
1295  // GH78101.
1296  if (NewTemplate) {
1297    // C++ [temp.over.link]p4:
1298    //   The signature of a function template consists of its function
1299    //   signature, its return type and its template parameter list. The names
1300    //   of the template parameters are significant only for establishing the
1301    //   relationship between the template parameters and the rest of the
1302    //   signature.
1303    //
1304    // We check the return type and template parameter lists for function
1305    // templates first; the remaining checks follow.
1306    bool SameTemplateParameterList = SemaRef.TemplateParameterListsAreEqual(
1307        NewTemplate, NewTemplate->getTemplateParameters(), OldTemplate,
1308        OldTemplate->getTemplateParameters(), false, Sema::TPL_TemplateMatch);
1309    bool SameReturnType = SemaRef.Context.hasSameType(
1310        Old->getDeclaredReturnType(), New->getDeclaredReturnType());
1311    // FIXME(GH58571): Match template parameter list even for non-constrained
1312    // template heads. This currently ensures that the code prior to C++20 is
1313    // not newly broken.
1314    bool ConstraintsInTemplateHead =
1315        NewTemplate->getTemplateParameters()->hasAssociatedConstraints() ||
1316        OldTemplate->getTemplateParameters()->hasAssociatedConstraints();
1317    // C++ [namespace.udecl]p11:
1318    //   The set of declarations named by a using-declarator that inhabits a
1319    //   class C does not include member functions and member function
1320    //   templates of a base class that "correspond" to (and thus would
1321    //   conflict with) a declaration of a function or function template in
1322    //   C.
1323    // Comparing return types is not required for the "correspond" check to
1324    // decide whether a member introduced by a shadow declaration is hidden.
1325    if (UseMemberUsingDeclRules && ConstraintsInTemplateHead &&
1326        !SameTemplateParameterList)
1327      return true;
1328    if (!UseMemberUsingDeclRules &&
1329        (!SameTemplateParameterList || !SameReturnType))
1330      return true;
1331  }
1332
1333  const auto *OldMethod = dyn_cast<CXXMethodDecl>(Old);
1334  const auto *NewMethod = dyn_cast<CXXMethodDecl>(New);
1335
1336  int OldParamsOffset = 0;
1337  int NewParamsOffset = 0;
1338
1339  // When determining if a method is an overload from a base class, act as if
1340  // the implicit object parameter are of the same type.
1341
1342  auto NormalizeQualifiers = [&](const CXXMethodDecl *M, Qualifiers Q) {
1343    if (M->isExplicitObjectMemberFunction())
1344      return Q;
1345
1346    // We do not allow overloading based off of '__restrict'.
1347    Q.removeRestrict();
1348
1349    // We may not have applied the implicit const for a constexpr member
1350    // function yet (because we haven't yet resolved whether this is a static
1351    // or non-static member function). Add it now, on the assumption that this
1352    // is a redeclaration of OldMethod.
1353    if (!SemaRef.getLangOpts().CPlusPlus14 &&
1354        (M->isConstexpr() || M->isConsteval()) &&
1355        !isa<CXXConstructorDecl>(NewMethod))
1356      Q.addConst();
1357    return Q;
1358  };
1359
1360  auto CompareType = [&](QualType Base, QualType D) {
1361    auto BS = Base.getNonReferenceType().getCanonicalType().split();
1362    BS.Quals = NormalizeQualifiers(OldMethod, BS.Quals);
1363
1364    auto DS = D.getNonReferenceType().getCanonicalType().split();
1365    DS.Quals = NormalizeQualifiers(NewMethod, DS.Quals);
1366
1367    if (BS.Quals != DS.Quals)
1368      return false;
1369
1370    if (OldMethod->isImplicitObjectMemberFunction() &&
1371        OldMethod->getParent() != NewMethod->getParent()) {
1372      QualType ParentType =
1373          SemaRef.Context.getTypeDeclType(OldMethod->getParent())
1374              .getCanonicalType();
1375      if (ParentType.getTypePtr() != BS.Ty)
1376        return false;
1377      BS.Ty = DS.Ty;
1378    }
1379
1380    // FIXME: should we ignore some type attributes here?
1381    if (BS.Ty != DS.Ty)
1382      return false;
1383
1384    if (Base->isLValueReferenceType())
1385      return D->isLValueReferenceType();
1386    return Base->isRValueReferenceType() == D->isRValueReferenceType();
1387  };
1388
1389  // If the function is a class member, its signature includes the
1390  // cv-qualifiers (if any) and ref-qualifier (if any) on the function itself.
1391  auto DiagnoseInconsistentRefQualifiers = [&]() {
1392    if (SemaRef.LangOpts.CPlusPlus23)
1393      return false;
1394    if (OldMethod->getRefQualifier() == NewMethod->getRefQualifier())
1395      return false;
1396    if (OldMethod->isExplicitObjectMemberFunction() ||
1397        NewMethod->isExplicitObjectMemberFunction())
1398      return false;
1399    if (!UseMemberUsingDeclRules && (OldMethod->getRefQualifier() == RQ_None ||
1400                                     NewMethod->getRefQualifier() == RQ_None)) {
1401      SemaRef.Diag(NewMethod->getLocation(), diag::err_ref_qualifier_overload)
1402          << NewMethod->getRefQualifier() << OldMethod->getRefQualifier();
1403      SemaRef.Diag(OldMethod->getLocation(), diag::note_previous_declaration);
1404      return true;
1405    }
1406    return false;
1407  };
1408
1409  if (OldMethod && OldMethod->isExplicitObjectMemberFunction())
1410    OldParamsOffset++;
1411  if (NewMethod && NewMethod->isExplicitObjectMemberFunction())
1412    NewParamsOffset++;
1413
1414  if (OldType->getNumParams() - OldParamsOffset !=
1415          NewType->getNumParams() - NewParamsOffset ||
1416      !SemaRef.FunctionParamTypesAreEqual(
1417          {OldType->param_type_begin() + OldParamsOffset,
1418           OldType->param_type_end()},
1419          {NewType->param_type_begin() + NewParamsOffset,
1420           NewType->param_type_end()},
1421          nullptr)) {
1422    return true;
1423  }
1424
1425  if (OldMethod && NewMethod && !OldMethod->isStatic() &&
1426      !OldMethod->isStatic()) {
1427    bool HaveCorrespondingObjectParameters = [&](const CXXMethodDecl *Old,
1428                                                 const CXXMethodDecl *New) {
1429      auto NewObjectType = New->getFunctionObjectParameterReferenceType();
1430      auto OldObjectType = Old->getFunctionObjectParameterReferenceType();
1431
1432      auto IsImplicitWithNoRefQual = [](const CXXMethodDecl *F) {
1433        return F->getRefQualifier() == RQ_None &&
1434               !F->isExplicitObjectMemberFunction();
1435      };
1436
1437      if (IsImplicitWithNoRefQual(Old) != IsImplicitWithNoRefQual(New) &&
1438          CompareType(OldObjectType.getNonReferenceType(),
1439                      NewObjectType.getNonReferenceType()))
1440        return true;
1441      return CompareType(OldObjectType, NewObjectType);
1442    }(OldMethod, NewMethod);
1443
1444    if (!HaveCorrespondingObjectParameters) {
1445      if (DiagnoseInconsistentRefQualifiers())
1446        return true;
1447      // CWG2554
1448      // and, if at least one is an explicit object member function, ignoring
1449      // object parameters
1450      if (!UseOverrideRules || (!NewMethod->isExplicitObjectMemberFunction() &&
1451                                !OldMethod->isExplicitObjectMemberFunction()))
1452        return true;
1453    }
1454  }
1455
1456  if (!UseOverrideRules) {
1457    Expr *NewRC = New->getTrailingRequiresClause(),
1458         *OldRC = Old->getTrailingRequiresClause();
1459    if ((NewRC != nullptr) != (OldRC != nullptr))
1460      return true;
1461
1462    if (NewRC && !SemaRef.AreConstraintExpressionsEqual(Old, OldRC, New, NewRC))
1463      return true;
1464  }
1465
1466  if (NewMethod && OldMethod && OldMethod->isImplicitObjectMemberFunction() &&
1467      NewMethod->isImplicitObjectMemberFunction()) {
1468    if (DiagnoseInconsistentRefQualifiers())
1469      return true;
1470  }
1471
1472  // Though pass_object_size is placed on parameters and takes an argument, we
1473  // consider it to be a function-level modifier for the sake of function
1474  // identity. Either the function has one or more parameters with
1475  // pass_object_size or it doesn't.
1476  if (functionHasPassObjectSizeParams(New) !=
1477      functionHasPassObjectSizeParams(Old))
1478    return true;
1479
1480  // enable_if attributes are an order-sensitive part of the signature.
1481  for (specific_attr_iterator<EnableIfAttr>
1482         NewI = New->specific_attr_begin<EnableIfAttr>(),
1483         NewE = New->specific_attr_end<EnableIfAttr>(),
1484         OldI = Old->specific_attr_begin<EnableIfAttr>(),
1485         OldE = Old->specific_attr_end<EnableIfAttr>();
1486       NewI != NewE || OldI != OldE; ++NewI, ++OldI) {
1487    if (NewI == NewE || OldI == OldE)
1488      return true;
1489    llvm::FoldingSetNodeID NewID, OldID;
1490    NewI->getCond()->Profile(NewID, SemaRef.Context, true);
1491    OldI->getCond()->Profile(OldID, SemaRef.Context, true);
1492    if (NewID != OldID)
1493      return true;
1494  }
1495
1496  if (SemaRef.getLangOpts().CUDA && ConsiderCudaAttrs) {
1497    // Don't allow overloading of destructors.  (In theory we could, but it
1498    // would be a giant change to clang.)
1499    if (!isa<CXXDestructorDecl>(New)) {
1500      Sema::CUDAFunctionTarget NewTarget = SemaRef.IdentifyCUDATarget(New),
1501                               OldTarget = SemaRef.IdentifyCUDATarget(Old);
1502      if (NewTarget != Sema::CFT_InvalidTarget) {
1503        assert((OldTarget != Sema::CFT_InvalidTarget) &&
1504               "Unexpected invalid target.");
1505
1506        // Allow overloading of functions with same signature and different CUDA
1507        // target attributes.
1508        if (NewTarget != OldTarget)
1509          return true;
1510      }
1511    }
1512  }
1513
1514  // The signatures match; this is not an overload.
1515  return false;
1516}
1517
1518bool Sema::IsOverload(FunctionDecl *New, FunctionDecl *Old,
1519                      bool UseMemberUsingDeclRules, bool ConsiderCudaAttrs) {
1520  return IsOverloadOrOverrideImpl(*this, New, Old, UseMemberUsingDeclRules,
1521                                  ConsiderCudaAttrs);
1522}
1523
1524bool Sema::IsOverride(FunctionDecl *MD, FunctionDecl *BaseMD,
1525                      bool UseMemberUsingDeclRules, bool ConsiderCudaAttrs) {
1526  return IsOverloadOrOverrideImpl(*this, MD, BaseMD,
1527                                  /*UseMemberUsingDeclRules=*/false,
1528                                  /*ConsiderCudaAttrs=*/true,
1529                                  /*UseOverrideRules=*/true);
1530}
1531
1532/// Tries a user-defined conversion from From to ToType.
1533///
1534/// Produces an implicit conversion sequence for when a standard conversion
1535/// is not an option. See TryImplicitConversion for more information.
1536static ImplicitConversionSequence
1537TryUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
1538                         bool SuppressUserConversions,
1539                         AllowedExplicit AllowExplicit,
1540                         bool InOverloadResolution,
1541                         bool CStyle,
1542                         bool AllowObjCWritebackConversion,
1543                         bool AllowObjCConversionOnExplicit) {
1544  ImplicitConversionSequence ICS;
1545
1546  if (SuppressUserConversions) {
1547    // We're not in the case above, so there is no conversion that
1548    // we can perform.
1549    ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1550    return ICS;
1551  }
1552
1553  // Attempt user-defined conversion.
1554  OverloadCandidateSet Conversions(From->getExprLoc(),
1555                                   OverloadCandidateSet::CSK_Normal);
1556  switch (IsUserDefinedConversion(S, From, ToType, ICS.UserDefined,
1557                                  Conversions, AllowExplicit,
1558                                  AllowObjCConversionOnExplicit)) {
1559  case OR_Success:
1560  case OR_Deleted:
1561    ICS.setUserDefined();
1562    // C++ [over.ics.user]p4:
1563    //   A conversion of an expression of class type to the same class
1564    //   type is given Exact Match rank, and a conversion of an
1565    //   expression of class type to a base class of that type is
1566    //   given Conversion rank, in spite of the fact that a copy
1567    //   constructor (i.e., a user-defined conversion function) is
1568    //   called for those cases.
1569    if (CXXConstructorDecl *Constructor
1570          = dyn_cast<CXXConstructorDecl>(ICS.UserDefined.ConversionFunction)) {
1571      QualType FromCanon
1572        = S.Context.getCanonicalType(From->getType().getUnqualifiedType());
1573      QualType ToCanon
1574        = S.Context.getCanonicalType(ToType).getUnqualifiedType();
1575      if (Constructor->isCopyConstructor() &&
1576          (FromCanon == ToCanon ||
1577           S.IsDerivedFrom(From->getBeginLoc(), FromCanon, ToCanon))) {
1578        // Turn this into a "standard" conversion sequence, so that it
1579        // gets ranked with standard conversion sequences.
1580        DeclAccessPair Found = ICS.UserDefined.FoundConversionFunction;
1581        ICS.setStandard();
1582        ICS.Standard.setAsIdentityConversion();
1583        ICS.Standard.setFromType(From->getType());
1584        ICS.Standard.setAllToTypes(ToType);
1585        ICS.Standard.CopyConstructor = Constructor;
1586        ICS.Standard.FoundCopyConstructor = Found;
1587        if (ToCanon != FromCanon)
1588          ICS.Standard.Second = ICK_Derived_To_Base;
1589      }
1590    }
1591    break;
1592
1593  case OR_Ambiguous:
1594    ICS.setAmbiguous();
1595    ICS.Ambiguous.setFromType(From->getType());
1596    ICS.Ambiguous.setToType(ToType);
1597    for (OverloadCandidateSet::iterator Cand = Conversions.begin();
1598         Cand != Conversions.end(); ++Cand)
1599      if (Cand->Best)
1600        ICS.Ambiguous.addConversion(Cand->FoundDecl, Cand->Function);
1601    break;
1602
1603    // Fall through.
1604  case OR_No_Viable_Function:
1605    ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1606    break;
1607  }
1608
1609  return ICS;
1610}
1611
1612/// TryImplicitConversion - Attempt to perform an implicit conversion
1613/// from the given expression (Expr) to the given type (ToType). This
1614/// function returns an implicit conversion sequence that can be used
1615/// to perform the initialization. Given
1616///
1617///   void f(float f);
1618///   void g(int i) { f(i); }
1619///
1620/// this routine would produce an implicit conversion sequence to
1621/// describe the initialization of f from i, which will be a standard
1622/// conversion sequence containing an lvalue-to-rvalue conversion (C++
1623/// 4.1) followed by a floating-integral conversion (C++ 4.9).
1624//
1625/// Note that this routine only determines how the conversion can be
1626/// performed; it does not actually perform the conversion. As such,
1627/// it will not produce any diagnostics if no conversion is available,
1628/// but will instead return an implicit conversion sequence of kind
1629/// "BadConversion".
1630///
1631/// If @p SuppressUserConversions, then user-defined conversions are
1632/// not permitted.
1633/// If @p AllowExplicit, then explicit user-defined conversions are
1634/// permitted.
1635///
1636/// \param AllowObjCWritebackConversion Whether we allow the Objective-C
1637/// writeback conversion, which allows __autoreleasing id* parameters to
1638/// be initialized with __strong id* or __weak id* arguments.
1639static ImplicitConversionSequence
1640TryImplicitConversion(Sema &S, Expr *From, QualType ToType,
1641                      bool SuppressUserConversions,
1642                      AllowedExplicit AllowExplicit,
1643                      bool InOverloadResolution,
1644                      bool CStyle,
1645                      bool AllowObjCWritebackConversion,
1646                      bool AllowObjCConversionOnExplicit) {
1647  ImplicitConversionSequence ICS;
1648  if (IsStandardConversion(S, From, ToType, InOverloadResolution,
1649                           ICS.Standard, CStyle, AllowObjCWritebackConversion)){
1650    ICS.setStandard();
1651    return ICS;
1652  }
1653
1654  if (!S.getLangOpts().CPlusPlus) {
1655    ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1656    return ICS;
1657  }
1658
1659  // C++ [over.ics.user]p4:
1660  //   A conversion of an expression of class type to the same class
1661  //   type is given Exact Match rank, and a conversion of an
1662  //   expression of class type to a base class of that type is
1663  //   given Conversion rank, in spite of the fact that a copy/move
1664  //   constructor (i.e., a user-defined conversion function) is
1665  //   called for those cases.
1666  QualType FromType = From->getType();
1667  if (ToType->getAs<RecordType>() && FromType->getAs<RecordType>() &&
1668      (S.Context.hasSameUnqualifiedType(FromType, ToType) ||
1669       S.IsDerivedFrom(From->getBeginLoc(), FromType, ToType))) {
1670    ICS.setStandard();
1671    ICS.Standard.setAsIdentityConversion();
1672    ICS.Standard.setFromType(FromType);
1673    ICS.Standard.setAllToTypes(ToType);
1674
1675    // We don't actually check at this point whether there is a valid
1676    // copy/move constructor, since overloading just assumes that it
1677    // exists. When we actually perform initialization, we'll find the
1678    // appropriate constructor to copy the returned object, if needed.
1679    ICS.Standard.CopyConstructor = nullptr;
1680
1681    // Determine whether this is considered a derived-to-base conversion.
1682    if (!S.Context.hasSameUnqualifiedType(FromType, ToType))
1683      ICS.Standard.Second = ICK_Derived_To_Base;
1684
1685    return ICS;
1686  }
1687
1688  return TryUserDefinedConversion(S, From, ToType, SuppressUserConversions,
1689                                  AllowExplicit, InOverloadResolution, CStyle,
1690                                  AllowObjCWritebackConversion,
1691                                  AllowObjCConversionOnExplicit);
1692}
1693
1694ImplicitConversionSequence
1695Sema::TryImplicitConversion(Expr *From, QualType ToType,
1696                            bool SuppressUserConversions,
1697                            AllowedExplicit AllowExplicit,
1698                            bool InOverloadResolution,
1699                            bool CStyle,
1700                            bool AllowObjCWritebackConversion) {
1701  return ::TryImplicitConversion(*this, From, ToType, SuppressUserConversions,
1702                                 AllowExplicit, InOverloadResolution, CStyle,
1703                                 AllowObjCWritebackConversion,
1704                                 /*AllowObjCConversionOnExplicit=*/false);
1705}
1706
1707/// PerformImplicitConversion - Perform an implicit conversion of the
1708/// expression From to the type ToType. Returns the
1709/// converted expression. Flavor is the kind of conversion we're
1710/// performing, used in the error message. If @p AllowExplicit,
1711/// explicit user-defined conversions are permitted.
1712ExprResult Sema::PerformImplicitConversion(Expr *From, QualType ToType,
1713                                           AssignmentAction Action,
1714                                           bool AllowExplicit) {
1715  if (checkPlaceholderForOverload(*this, From))
1716    return ExprError();
1717
1718  // Objective-C ARC: Determine whether we will allow the writeback conversion.
1719  bool AllowObjCWritebackConversion
1720    = getLangOpts().ObjCAutoRefCount &&
1721      (Action == AA_Passing || Action == AA_Sending);
1722  if (getLangOpts().ObjC)
1723    CheckObjCBridgeRelatedConversions(From->getBeginLoc(), ToType,
1724                                      From->getType(), From);
1725  ImplicitConversionSequence ICS = ::TryImplicitConversion(
1726      *this, From, ToType,
1727      /*SuppressUserConversions=*/false,
1728      AllowExplicit ? AllowedExplicit::All : AllowedExplicit::None,
1729      /*InOverloadResolution=*/false,
1730      /*CStyle=*/false, AllowObjCWritebackConversion,
1731      /*AllowObjCConversionOnExplicit=*/false);
1732  return PerformImplicitConversion(From, ToType, ICS, Action);
1733}
1734
1735/// Determine whether the conversion from FromType to ToType is a valid
1736/// conversion that strips "noexcept" or "noreturn" off the nested function
1737/// type.
1738bool Sema::IsFunctionConversion(QualType FromType, QualType ToType,
1739                                QualType &ResultTy) {
1740  if (Context.hasSameUnqualifiedType(FromType, ToType))
1741    return false;
1742
1743  // Permit the conversion F(t __attribute__((noreturn))) -> F(t)
1744  //                    or F(t noexcept) -> F(t)
1745  // where F adds one of the following at most once:
1746  //   - a pointer
1747  //   - a member pointer
1748  //   - a block pointer
1749  // Changes here need matching changes in FindCompositePointerType.
1750  CanQualType CanTo = Context.getCanonicalType(ToType);
1751  CanQualType CanFrom = Context.getCanonicalType(FromType);
1752  Type::TypeClass TyClass = CanTo->getTypeClass();
1753  if (TyClass != CanFrom->getTypeClass()) return false;
1754  if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto) {
1755    if (TyClass == Type::Pointer) {
1756      CanTo = CanTo.castAs<PointerType>()->getPointeeType();
1757      CanFrom = CanFrom.castAs<PointerType>()->getPointeeType();
1758    } else if (TyClass == Type::BlockPointer) {
1759      CanTo = CanTo.castAs<BlockPointerType>()->getPointeeType();
1760      CanFrom = CanFrom.castAs<BlockPointerType>()->getPointeeType();
1761    } else if (TyClass == Type::MemberPointer) {
1762      auto ToMPT = CanTo.castAs<MemberPointerType>();
1763      auto FromMPT = CanFrom.castAs<MemberPointerType>();
1764      // A function pointer conversion cannot change the class of the function.
1765      if (ToMPT->getClass() != FromMPT->getClass())
1766        return false;
1767      CanTo = ToMPT->getPointeeType();
1768      CanFrom = FromMPT->getPointeeType();
1769    } else {
1770      return false;
1771    }
1772
1773    TyClass = CanTo->getTypeClass();
1774    if (TyClass != CanFrom->getTypeClass()) return false;
1775    if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto)
1776      return false;
1777  }
1778
1779  const auto *FromFn = cast<FunctionType>(CanFrom);
1780  FunctionType::ExtInfo FromEInfo = FromFn->getExtInfo();
1781
1782  const auto *ToFn = cast<FunctionType>(CanTo);
1783  FunctionType::ExtInfo ToEInfo = ToFn->getExtInfo();
1784
1785  bool Changed = false;
1786
1787  // Drop 'noreturn' if not present in target type.
1788  if (FromEInfo.getNoReturn() && !ToEInfo.getNoReturn()) {
1789    FromFn = Context.adjustFunctionType(FromFn, FromEInfo.withNoReturn(false));
1790    Changed = true;
1791  }
1792
1793  // Drop 'noexcept' if not present in target type.
1794  if (const auto *FromFPT = dyn_cast<FunctionProtoType>(FromFn)) {
1795    const auto *ToFPT = cast<FunctionProtoType>(ToFn);
1796    if (FromFPT->isNothrow() && !ToFPT->isNothrow()) {
1797      FromFn = cast<FunctionType>(
1798          Context.getFunctionTypeWithExceptionSpec(QualType(FromFPT, 0),
1799                                                   EST_None)
1800                 .getTypePtr());
1801      Changed = true;
1802    }
1803
1804    // Convert FromFPT's ExtParameterInfo if necessary. The conversion is valid
1805    // only if the ExtParameterInfo lists of the two function prototypes can be
1806    // merged and the merged list is identical to ToFPT's ExtParameterInfo list.
1807    SmallVector<FunctionProtoType::ExtParameterInfo, 4> NewParamInfos;
1808    bool CanUseToFPT, CanUseFromFPT;
1809    if (Context.mergeExtParameterInfo(ToFPT, FromFPT, CanUseToFPT,
1810                                      CanUseFromFPT, NewParamInfos) &&
1811        CanUseToFPT && !CanUseFromFPT) {
1812      FunctionProtoType::ExtProtoInfo ExtInfo = FromFPT->getExtProtoInfo();
1813      ExtInfo.ExtParameterInfos =
1814          NewParamInfos.empty() ? nullptr : NewParamInfos.data();
1815      QualType QT = Context.getFunctionType(FromFPT->getReturnType(),
1816                                            FromFPT->getParamTypes(), ExtInfo);
1817      FromFn = QT->getAs<FunctionType>();
1818      Changed = true;
1819    }
1820  }
1821
1822  if (!Changed)
1823    return false;
1824
1825  assert(QualType(FromFn, 0).isCanonical());
1826  if (QualType(FromFn, 0) != CanTo) return false;
1827
1828  ResultTy = ToType;
1829  return true;
1830}
1831
1832/// Determine whether the conversion from FromType to ToType is a valid
1833/// vector conversion.
1834///
1835/// \param ICK Will be set to the vector conversion kind, if this is a vector
1836/// conversion.
1837static bool IsVectorConversion(Sema &S, QualType FromType, QualType ToType,
1838                               ImplicitConversionKind &ICK, Expr *From,
1839                               bool InOverloadResolution, bool CStyle) {
1840  // We need at least one of these types to be a vector type to have a vector
1841  // conversion.
1842  if (!ToType->isVectorType() && !FromType->isVectorType())
1843    return false;
1844
1845  // Identical types require no conversions.
1846  if (S.Context.hasSameUnqualifiedType(FromType, ToType))
1847    return false;
1848
1849  // There are no conversions between extended vector types, only identity.
1850  if (ToType->isExtVectorType()) {
1851    // There are no conversions between extended vector types other than the
1852    // identity conversion.
1853    if (FromType->isExtVectorType())
1854      return false;
1855
1856    // Vector splat from any arithmetic type to a vector.
1857    if (FromType->isArithmeticType()) {
1858      ICK = ICK_Vector_Splat;
1859      return true;
1860    }
1861  }
1862
1863  if (ToType->isSVESizelessBuiltinType() ||
1864      FromType->isSVESizelessBuiltinType())
1865    if (S.Context.areCompatibleSveTypes(FromType, ToType) ||
1866        S.Context.areLaxCompatibleSveTypes(FromType, ToType)) {
1867      ICK = ICK_SVE_Vector_Conversion;
1868      return true;
1869    }
1870
1871  if (ToType->isRVVSizelessBuiltinType() ||
1872      FromType->isRVVSizelessBuiltinType())
1873    if (S.Context.areCompatibleRVVTypes(FromType, ToType) ||
1874        S.Context.areLaxCompatibleRVVTypes(FromType, ToType)) {
1875      ICK = ICK_RVV_Vector_Conversion;
1876      return true;
1877    }
1878
1879  // We can perform the conversion between vector types in the following cases:
1880  // 1)vector types are equivalent AltiVec and GCC vector types
1881  // 2)lax vector conversions are permitted and the vector types are of the
1882  //   same size
1883  // 3)the destination type does not have the ARM MVE strict-polymorphism
1884  //   attribute, which inhibits lax vector conversion for overload resolution
1885  //   only
1886  if (ToType->isVectorType() && FromType->isVectorType()) {
1887    if (S.Context.areCompatibleVectorTypes(FromType, ToType) ||
1888        (S.isLaxVectorConversion(FromType, ToType) &&
1889         !ToType->hasAttr(attr::ArmMveStrictPolymorphism))) {
1890      if (S.getASTContext().getTargetInfo().getTriple().isPPC() &&
1891          S.isLaxVectorConversion(FromType, ToType) &&
1892          S.anyAltivecTypes(FromType, ToType) &&
1893          !S.Context.areCompatibleVectorTypes(FromType, ToType) &&
1894          !InOverloadResolution && !CStyle) {
1895        S.Diag(From->getBeginLoc(), diag::warn_deprecated_lax_vec_conv_all)
1896            << FromType << ToType;
1897      }
1898      ICK = ICK_Vector_Conversion;
1899      return true;
1900    }
1901  }
1902
1903  return false;
1904}
1905
1906static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType,
1907                                bool InOverloadResolution,
1908                                StandardConversionSequence &SCS,
1909                                bool CStyle);
1910
1911/// IsStandardConversion - Determines whether there is a standard
1912/// conversion sequence (C++ [conv], C++ [over.ics.scs]) from the
1913/// expression From to the type ToType. Standard conversion sequences
1914/// only consider non-class types; for conversions that involve class
1915/// types, use TryImplicitConversion. If a conversion exists, SCS will
1916/// contain the standard conversion sequence required to perform this
1917/// conversion and this routine will return true. Otherwise, this
1918/// routine will return false and the value of SCS is unspecified.
1919static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
1920                                 bool InOverloadResolution,
1921                                 StandardConversionSequence &SCS,
1922                                 bool CStyle,
1923                                 bool AllowObjCWritebackConversion) {
1924  QualType FromType = From->getType();
1925
1926  // Standard conversions (C++ [conv])
1927  SCS.setAsIdentityConversion();
1928  SCS.IncompatibleObjC = false;
1929  SCS.setFromType(FromType);
1930  SCS.CopyConstructor = nullptr;
1931
1932  // There are no standard conversions for class types in C++, so
1933  // abort early. When overloading in C, however, we do permit them.
1934  if (S.getLangOpts().CPlusPlus &&
1935      (FromType->isRecordType() || ToType->isRecordType()))
1936    return false;
1937
1938  // The first conversion can be an lvalue-to-rvalue conversion,
1939  // array-to-pointer conversion, or function-to-pointer conversion
1940  // (C++ 4p1).
1941
1942  if (FromType == S.Context.OverloadTy) {
1943    DeclAccessPair AccessPair;
1944    if (FunctionDecl *Fn
1945          = S.ResolveAddressOfOverloadedFunction(From, ToType, false,
1946                                                 AccessPair)) {
1947      // We were able to resolve the address of the overloaded function,
1948      // so we can convert to the type of that function.
1949      FromType = Fn->getType();
1950      SCS.setFromType(FromType);
1951
1952      // we can sometimes resolve &foo<int> regardless of ToType, so check
1953      // if the type matches (identity) or we are converting to bool
1954      if (!S.Context.hasSameUnqualifiedType(
1955                      S.ExtractUnqualifiedFunctionType(ToType), FromType)) {
1956        QualType resultTy;
1957        // if the function type matches except for [[noreturn]], it's ok
1958        if (!S.IsFunctionConversion(FromType,
1959              S.ExtractUnqualifiedFunctionType(ToType), resultTy))
1960          // otherwise, only a boolean conversion is standard
1961          if (!ToType->isBooleanType())
1962            return false;
1963      }
1964
1965      // Check if the "from" expression is taking the address of an overloaded
1966      // function and recompute the FromType accordingly. Take advantage of the
1967      // fact that non-static member functions *must* have such an address-of
1968      // expression.
1969      CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn);
1970      if (Method && !Method->isStatic() &&
1971          !Method->isExplicitObjectMemberFunction()) {
1972        assert(isa<UnaryOperator>(From->IgnoreParens()) &&
1973               "Non-unary operator on non-static member address");
1974        assert(cast<UnaryOperator>(From->IgnoreParens())->getOpcode()
1975               == UO_AddrOf &&
1976               "Non-address-of operator on non-static member address");
1977        const Type *ClassType
1978          = S.Context.getTypeDeclType(Method->getParent()).getTypePtr();
1979        FromType = S.Context.getMemberPointerType(FromType, ClassType);
1980      } else if (isa<UnaryOperator>(From->IgnoreParens())) {
1981        assert(cast<UnaryOperator>(From->IgnoreParens())->getOpcode() ==
1982               UO_AddrOf &&
1983               "Non-address-of operator for overloaded function expression");
1984        FromType = S.Context.getPointerType(FromType);
1985      }
1986    } else {
1987      return false;
1988    }
1989  }
1990  // Lvalue-to-rvalue conversion (C++11 4.1):
1991  //   A glvalue (3.10) of a non-function, non-array type T can
1992  //   be converted to a prvalue.
1993  bool argIsLValue = From->isGLValue();
1994  if (argIsLValue &&
1995      !FromType->isFunctionType() && !FromType->isArrayType() &&
1996      S.Context.getCanonicalType(FromType) != S.Context.OverloadTy) {
1997    SCS.First = ICK_Lvalue_To_Rvalue;
1998
1999    // C11 6.3.2.1p2:
2000    //   ... if the lvalue has atomic type, the value has the non-atomic version
2001    //   of the type of the lvalue ...
2002    if (const AtomicType *Atomic = FromType->getAs<AtomicType>())
2003      FromType = Atomic->getValueType();
2004
2005    // If T is a non-class type, the type of the rvalue is the
2006    // cv-unqualified version of T. Otherwise, the type of the rvalue
2007    // is T (C++ 4.1p1). C++ can't get here with class types; in C, we
2008    // just strip the qualifiers because they don't matter.
2009    FromType = FromType.getUnqualifiedType();
2010  } else if (FromType->isArrayType()) {
2011    // Array-to-pointer conversion (C++ 4.2)
2012    SCS.First = ICK_Array_To_Pointer;
2013
2014    // An lvalue or rvalue of type "array of N T" or "array of unknown
2015    // bound of T" can be converted to an rvalue of type "pointer to
2016    // T" (C++ 4.2p1).
2017    FromType = S.Context.getArrayDecayedType(FromType);
2018
2019    if (S.IsStringLiteralToNonConstPointerConversion(From, ToType)) {
2020      // This conversion is deprecated in C++03 (D.4)
2021      SCS.DeprecatedStringLiteralToCharPtr = true;
2022
2023      // For the purpose of ranking in overload resolution
2024      // (13.3.3.1.1), this conversion is considered an
2025      // array-to-pointer conversion followed by a qualification
2026      // conversion (4.4). (C++ 4.2p2)
2027      SCS.Second = ICK_Identity;
2028      SCS.Third = ICK_Qualification;
2029      SCS.QualificationIncludesObjCLifetime = false;
2030      SCS.setAllToTypes(FromType);
2031      return true;
2032    }
2033  } else if (FromType->isFunctionType() && argIsLValue) {
2034    // Function-to-pointer conversion (C++ 4.3).
2035    SCS.First = ICK_Function_To_Pointer;
2036
2037    if (auto *DRE = dyn_cast<DeclRefExpr>(From->IgnoreParenCasts()))
2038      if (auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl()))
2039        if (!S.checkAddressOfFunctionIsAvailable(FD))
2040          return false;
2041
2042    // An lvalue of function type T can be converted to an rvalue of
2043    // type "pointer to T." The result is a pointer to the
2044    // function. (C++ 4.3p1).
2045    FromType = S.Context.getPointerType(FromType);
2046  } else {
2047    // We don't require any conversions for the first step.
2048    SCS.First = ICK_Identity;
2049  }
2050  SCS.setToType(0, FromType);
2051
2052  // The second conversion can be an integral promotion, floating
2053  // point promotion, integral conversion, floating point conversion,
2054  // floating-integral conversion, pointer conversion,
2055  // pointer-to-member conversion, or boolean conversion (C++ 4p1).
2056  // For overloading in C, this can also be a "compatible-type"
2057  // conversion.
2058  bool IncompatibleObjC = false;
2059  ImplicitConversionKind SecondICK = ICK_Identity;
2060  if (S.Context.hasSameUnqualifiedType(FromType, ToType)) {
2061    // The unqualified versions of the types are the same: there's no
2062    // conversion to do.
2063    SCS.Second = ICK_Identity;
2064  } else if (S.IsIntegralPromotion(From, FromType, ToType)) {
2065    // Integral promotion (C++ 4.5).
2066    SCS.Second = ICK_Integral_Promotion;
2067    FromType = ToType.getUnqualifiedType();
2068  } else if (S.IsFloatingPointPromotion(FromType, ToType)) {
2069    // Floating point promotion (C++ 4.6).
2070    SCS.Second = ICK_Floating_Promotion;
2071    FromType = ToType.getUnqualifiedType();
2072  } else if (S.IsComplexPromotion(FromType, ToType)) {
2073    // Complex promotion (Clang extension)
2074    SCS.Second = ICK_Complex_Promotion;
2075    FromType = ToType.getUnqualifiedType();
2076  } else if (ToType->isBooleanType() &&
2077             (FromType->isArithmeticType() ||
2078              FromType->isAnyPointerType() ||
2079              FromType->isBlockPointerType() ||
2080              FromType->isMemberPointerType())) {
2081    // Boolean conversions (C++ 4.12).
2082    SCS.Second = ICK_Boolean_Conversion;
2083    FromType = S.Context.BoolTy;
2084  } else if (FromType->isIntegralOrUnscopedEnumerationType() &&
2085             ToType->isIntegralType(S.Context)) {
2086    // Integral conversions (C++ 4.7).
2087    SCS.Second = ICK_Integral_Conversion;
2088    FromType = ToType.getUnqualifiedType();
2089  } else if (FromType->isAnyComplexType() && ToType->isAnyComplexType()) {
2090    // Complex conversions (C99 6.3.1.6)
2091    SCS.Second = ICK_Complex_Conversion;
2092    FromType = ToType.getUnqualifiedType();
2093  } else if ((FromType->isAnyComplexType() && ToType->isArithmeticType()) ||
2094             (ToType->isAnyComplexType() && FromType->isArithmeticType())) {
2095    // Complex-real conversions (C99 6.3.1.7)
2096    SCS.Second = ICK_Complex_Real;
2097    FromType = ToType.getUnqualifiedType();
2098  } else if (FromType->isRealFloatingType() && ToType->isRealFloatingType()) {
2099    // FIXME: disable conversions between long double, __ibm128 and __float128
2100    // if their representation is different until there is back end support
2101    // We of course allow this conversion if long double is really double.
2102
2103    // Conversions between bfloat16 and float16 are currently not supported.
2104    if ((FromType->isBFloat16Type() &&
2105         (ToType->isFloat16Type() || ToType->isHalfType())) ||
2106        (ToType->isBFloat16Type() &&
2107         (FromType->isFloat16Type() || FromType->isHalfType())))
2108      return false;
2109
2110    // Conversions between IEEE-quad and IBM-extended semantics are not
2111    // permitted.
2112    const llvm::fltSemantics &FromSem =
2113        S.Context.getFloatTypeSemantics(FromType);
2114    const llvm::fltSemantics &ToSem = S.Context.getFloatTypeSemantics(ToType);
2115    if ((&FromSem == &llvm::APFloat::PPCDoubleDouble() &&
2116         &ToSem == &llvm::APFloat::IEEEquad()) ||
2117        (&FromSem == &llvm::APFloat::IEEEquad() &&
2118         &ToSem == &llvm::APFloat::PPCDoubleDouble()))
2119      return false;
2120
2121    // Floating point conversions (C++ 4.8).
2122    SCS.Second = ICK_Floating_Conversion;
2123    FromType = ToType.getUnqualifiedType();
2124  } else if ((FromType->isRealFloatingType() &&
2125              ToType->isIntegralType(S.Context)) ||
2126             (FromType->isIntegralOrUnscopedEnumerationType() &&
2127              ToType->isRealFloatingType())) {
2128
2129    // Floating-integral conversions (C++ 4.9).
2130    SCS.Second = ICK_Floating_Integral;
2131    FromType = ToType.getUnqualifiedType();
2132  } else if (S.IsBlockPointerConversion(FromType, ToType, FromType)) {
2133    SCS.Second = ICK_Block_Pointer_Conversion;
2134  } else if (AllowObjCWritebackConversion &&
2135             S.isObjCWritebackConversion(FromType, ToType, FromType)) {
2136    SCS.Second = ICK_Writeback_Conversion;
2137  } else if (S.IsPointerConversion(From, FromType, ToType, InOverloadResolution,
2138                                   FromType, IncompatibleObjC)) {
2139    // Pointer conversions (C++ 4.10).
2140    SCS.Second = ICK_Pointer_Conversion;
2141    SCS.IncompatibleObjC = IncompatibleObjC;
2142    FromType = FromType.getUnqualifiedType();
2143  } else if (S.IsMemberPointerConversion(From, FromType, ToType,
2144                                         InOverloadResolution, FromType)) {
2145    // Pointer to member conversions (4.11).
2146    SCS.Second = ICK_Pointer_Member;
2147  } else if (IsVectorConversion(S, FromType, ToType, SecondICK, From,
2148                                InOverloadResolution, CStyle)) {
2149    SCS.Second = SecondICK;
2150    FromType = ToType.getUnqualifiedType();
2151  } else if (!S.getLangOpts().CPlusPlus &&
2152             S.Context.typesAreCompatible(ToType, FromType)) {
2153    // Compatible conversions (Clang extension for C function overloading)
2154    SCS.Second = ICK_Compatible_Conversion;
2155    FromType = ToType.getUnqualifiedType();
2156  } else if (IsTransparentUnionStandardConversion(S, From, ToType,
2157                                             InOverloadResolution,
2158                                             SCS, CStyle)) {
2159    SCS.Second = ICK_TransparentUnionConversion;
2160    FromType = ToType;
2161  } else if (tryAtomicConversion(S, From, ToType, InOverloadResolution, SCS,
2162                                 CStyle)) {
2163    // tryAtomicConversion has updated the standard conversion sequence
2164    // appropriately.
2165    return true;
2166  } else if (ToType->isEventT() &&
2167             From->isIntegerConstantExpr(S.getASTContext()) &&
2168             From->EvaluateKnownConstInt(S.getASTContext()) == 0) {
2169    SCS.Second = ICK_Zero_Event_Conversion;
2170    FromType = ToType;
2171  } else if (ToType->isQueueT() &&
2172             From->isIntegerConstantExpr(S.getASTContext()) &&
2173             (From->EvaluateKnownConstInt(S.getASTContext()) == 0)) {
2174    SCS.Second = ICK_Zero_Queue_Conversion;
2175    FromType = ToType;
2176  } else if (ToType->isSamplerT() &&
2177             From->isIntegerConstantExpr(S.getASTContext())) {
2178    SCS.Second = ICK_Compatible_Conversion;
2179    FromType = ToType;
2180  } else if (ToType->isFixedPointType() || FromType->isFixedPointType()) {
2181    SCS.Second = ICK_Fixed_Point_Conversion;
2182    FromType = ToType;
2183  } else {
2184    // No second conversion required.
2185    SCS.Second = ICK_Identity;
2186  }
2187  SCS.setToType(1, FromType);
2188
2189  // The third conversion can be a function pointer conversion or a
2190  // qualification conversion (C++ [conv.fctptr], [conv.qual]).
2191  bool ObjCLifetimeConversion;
2192  if (S.IsFunctionConversion(FromType, ToType, FromType)) {
2193    // Function pointer conversions (removing 'noexcept') including removal of
2194    // 'noreturn' (Clang extension).
2195    SCS.Third = ICK_Function_Conversion;
2196  } else if (S.IsQualificationConversion(FromType, ToType, CStyle,
2197                                         ObjCLifetimeConversion)) {
2198    SCS.Third = ICK_Qualification;
2199    SCS.QualificationIncludesObjCLifetime = ObjCLifetimeConversion;
2200    FromType = ToType;
2201  } else {
2202    // No conversion required
2203    SCS.Third = ICK_Identity;
2204  }
2205
2206  // C++ [over.best.ics]p6:
2207  //   [...] Any difference in top-level cv-qualification is
2208  //   subsumed by the initialization itself and does not constitute
2209  //   a conversion. [...]
2210  QualType CanonFrom = S.Context.getCanonicalType(FromType);
2211  QualType CanonTo = S.Context.getCanonicalType(ToType);
2212  if (CanonFrom.getLocalUnqualifiedType()
2213                                     == CanonTo.getLocalUnqualifiedType() &&
2214      CanonFrom.getLocalQualifiers() != CanonTo.getLocalQualifiers()) {
2215    FromType = ToType;
2216    CanonFrom = CanonTo;
2217  }
2218
2219  SCS.setToType(2, FromType);
2220
2221  if (CanonFrom == CanonTo)
2222    return true;
2223
2224  // If we have not converted the argument type to the parameter type,
2225  // this is a bad conversion sequence, unless we're resolving an overload in C.
2226  if (S.getLangOpts().CPlusPlus || !InOverloadResolution)
2227    return false;
2228
2229  ExprResult ER = ExprResult{From};
2230  Sema::AssignConvertType Conv =
2231      S.CheckSingleAssignmentConstraints(ToType, ER,
2232                                         /*Diagnose=*/false,
2233                                         /*DiagnoseCFAudited=*/false,
2234                                         /*ConvertRHS=*/false);
2235  ImplicitConversionKind SecondConv;
2236  switch (Conv) {
2237  case Sema::Compatible:
2238    SecondConv = ICK_C_Only_Conversion;
2239    break;
2240  // For our purposes, discarding qualifiers is just as bad as using an
2241  // incompatible pointer. Note that an IncompatiblePointer conversion can drop
2242  // qualifiers, as well.
2243  case Sema::CompatiblePointerDiscardsQualifiers:
2244  case Sema::IncompatiblePointer:
2245  case Sema::IncompatiblePointerSign:
2246    SecondConv = ICK_Incompatible_Pointer_Conversion;
2247    break;
2248  default:
2249    return false;
2250  }
2251
2252  // First can only be an lvalue conversion, so we pretend that this was the
2253  // second conversion. First should already be valid from earlier in the
2254  // function.
2255  SCS.Second = SecondConv;
2256  SCS.setToType(1, ToType);
2257
2258  // Third is Identity, because Second should rank us worse than any other
2259  // conversion. This could also be ICK_Qualification, but it's simpler to just
2260  // lump everything in with the second conversion, and we don't gain anything
2261  // from making this ICK_Qualification.
2262  SCS.Third = ICK_Identity;
2263  SCS.setToType(2, ToType);
2264  return true;
2265}
2266
2267static bool
2268IsTransparentUnionStandardConversion(Sema &S, Expr* From,
2269                                     QualType &ToType,
2270                                     bool InOverloadResolution,
2271                                     StandardConversionSequence &SCS,
2272                                     bool CStyle) {
2273
2274  const RecordType *UT = ToType->getAsUnionType();
2275  if (!UT || !UT->getDecl()->hasAttr<TransparentUnionAttr>())
2276    return false;
2277  // The field to initialize within the transparent union.
2278  RecordDecl *UD = UT->getDecl();
2279  // It's compatible if the expression matches any of the fields.
2280  for (const auto *it : UD->fields()) {
2281    if (IsStandardConversion(S, From, it->getType(), InOverloadResolution, SCS,
2282                             CStyle, /*AllowObjCWritebackConversion=*/false)) {
2283      ToType = it->getType();
2284      return true;
2285    }
2286  }
2287  return false;
2288}
2289
2290/// IsIntegralPromotion - Determines whether the conversion from the
2291/// expression From (whose potentially-adjusted type is FromType) to
2292/// ToType is an integral promotion (C++ 4.5). If so, returns true and
2293/// sets PromotedType to the promoted type.
2294bool Sema::IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType) {
2295  const BuiltinType *To = ToType->getAs<BuiltinType>();
2296  // All integers are built-in.
2297  if (!To) {
2298    return false;
2299  }
2300
2301  // An rvalue of type char, signed char, unsigned char, short int, or
2302  // unsigned short int can be converted to an rvalue of type int if
2303  // int can represent all the values of the source type; otherwise,
2304  // the source rvalue can be converted to an rvalue of type unsigned
2305  // int (C++ 4.5p1).
2306  if (Context.isPromotableIntegerType(FromType) && !FromType->isBooleanType() &&
2307      !FromType->isEnumeralType()) {
2308    if ( // We can promote any signed, promotable integer type to an int
2309        (FromType->isSignedIntegerType() ||
2310         // We can promote any unsigned integer type whose size is
2311         // less than int to an int.
2312         Context.getTypeSize(FromType) < Context.getTypeSize(ToType))) {
2313      return To->getKind() == BuiltinType::Int;
2314    }
2315
2316    return To->getKind() == BuiltinType::UInt;
2317  }
2318
2319  // C++11 [conv.prom]p3:
2320  //   A prvalue of an unscoped enumeration type whose underlying type is not
2321  //   fixed (7.2) can be converted to an rvalue a prvalue of the first of the
2322  //   following types that can represent all the values of the enumeration
2323  //   (i.e., the values in the range bmin to bmax as described in 7.2): int,
2324  //   unsigned int, long int, unsigned long int, long long int, or unsigned
2325  //   long long int. If none of the types in that list can represent all the
2326  //   values of the enumeration, an rvalue a prvalue of an unscoped enumeration
2327  //   type can be converted to an rvalue a prvalue of the extended integer type
2328  //   with lowest integer conversion rank (4.13) greater than the rank of long
2329  //   long in which all the values of the enumeration can be represented. If
2330  //   there are two such extended types, the signed one is chosen.
2331  // C++11 [conv.prom]p4:
2332  //   A prvalue of an unscoped enumeration type whose underlying type is fixed
2333  //   can be converted to a prvalue of its underlying type. Moreover, if
2334  //   integral promotion can be applied to its underlying type, a prvalue of an
2335  //   unscoped enumeration type whose underlying type is fixed can also be
2336  //   converted to a prvalue of the promoted underlying type.
2337  if (const EnumType *FromEnumType = FromType->getAs<EnumType>()) {
2338    // C++0x 7.2p9: Note that this implicit enum to int conversion is not
2339    // provided for a scoped enumeration.
2340    if (FromEnumType->getDecl()->isScoped())
2341      return false;
2342
2343    // We can perform an integral promotion to the underlying type of the enum,
2344    // even if that's not the promoted type. Note that the check for promoting
2345    // the underlying type is based on the type alone, and does not consider
2346    // the bitfield-ness of the actual source expression.
2347    if (FromEnumType->getDecl()->isFixed()) {
2348      QualType Underlying = FromEnumType->getDecl()->getIntegerType();
2349      return Context.hasSameUnqualifiedType(Underlying, ToType) ||
2350             IsIntegralPromotion(nullptr, Underlying, ToType);
2351    }
2352
2353    // We have already pre-calculated the promotion type, so this is trivial.
2354    if (ToType->isIntegerType() &&
2355        isCompleteType(From->getBeginLoc(), FromType))
2356      return Context.hasSameUnqualifiedType(
2357          ToType, FromEnumType->getDecl()->getPromotionType());
2358
2359    // C++ [conv.prom]p5:
2360    //   If the bit-field has an enumerated type, it is treated as any other
2361    //   value of that type for promotion purposes.
2362    //
2363    // ... so do not fall through into the bit-field checks below in C++.
2364    if (getLangOpts().CPlusPlus)
2365      return false;
2366  }
2367
2368  // C++0x [conv.prom]p2:
2369  //   A prvalue of type char16_t, char32_t, or wchar_t (3.9.1) can be converted
2370  //   to an rvalue a prvalue of the first of the following types that can
2371  //   represent all the values of its underlying type: int, unsigned int,
2372  //   long int, unsigned long int, long long int, or unsigned long long int.
2373  //   If none of the types in that list can represent all the values of its
2374  //   underlying type, an rvalue a prvalue of type char16_t, char32_t,
2375  //   or wchar_t can be converted to an rvalue a prvalue of its underlying
2376  //   type.
2377  if (FromType->isAnyCharacterType() && !FromType->isCharType() &&
2378      ToType->isIntegerType()) {
2379    // Determine whether the type we're converting from is signed or
2380    // unsigned.
2381    bool FromIsSigned = FromType->isSignedIntegerType();
2382    uint64_t FromSize = Context.getTypeSize(FromType);
2383
2384    // The types we'll try to promote to, in the appropriate
2385    // order. Try each of these types.
2386    QualType PromoteTypes[6] = {
2387      Context.IntTy, Context.UnsignedIntTy,
2388      Context.LongTy, Context.UnsignedLongTy ,
2389      Context.LongLongTy, Context.UnsignedLongLongTy
2390    };
2391    for (int Idx = 0; Idx < 6; ++Idx) {
2392      uint64_t ToSize = Context.getTypeSize(PromoteTypes[Idx]);
2393      if (FromSize < ToSize ||
2394          (FromSize == ToSize &&
2395           FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType())) {
2396        // We found the type that we can promote to. If this is the
2397        // type we wanted, we have a promotion. Otherwise, no
2398        // promotion.
2399        return Context.hasSameUnqualifiedType(ToType, PromoteTypes[Idx]);
2400      }
2401    }
2402  }
2403
2404  // An rvalue for an integral bit-field (9.6) can be converted to an
2405  // rvalue of type int if int can represent all the values of the
2406  // bit-field; otherwise, it can be converted to unsigned int if
2407  // unsigned int can represent all the values of the bit-field. If
2408  // the bit-field is larger yet, no integral promotion applies to
2409  // it. If the bit-field has an enumerated type, it is treated as any
2410  // other value of that type for promotion purposes (C++ 4.5p3).
2411  // FIXME: We should delay checking of bit-fields until we actually perform the
2412  // conversion.
2413  //
2414  // FIXME: In C, only bit-fields of types _Bool, int, or unsigned int may be
2415  // promoted, per C11 6.3.1.1/2. We promote all bit-fields (including enum
2416  // bit-fields and those whose underlying type is larger than int) for GCC
2417  // compatibility.
2418  if (From) {
2419    if (FieldDecl *MemberDecl = From->getSourceBitField()) {
2420      std::optional<llvm::APSInt> BitWidth;
2421      if (FromType->isIntegralType(Context) &&
2422          (BitWidth =
2423               MemberDecl->getBitWidth()->getIntegerConstantExpr(Context))) {
2424        llvm::APSInt ToSize(BitWidth->getBitWidth(), BitWidth->isUnsigned());
2425        ToSize = Context.getTypeSize(ToType);
2426
2427        // Are we promoting to an int from a bitfield that fits in an int?
2428        if (*BitWidth < ToSize ||
2429            (FromType->isSignedIntegerType() && *BitWidth <= ToSize)) {
2430          return To->getKind() == BuiltinType::Int;
2431        }
2432
2433        // Are we promoting to an unsigned int from an unsigned bitfield
2434        // that fits into an unsigned int?
2435        if (FromType->isUnsignedIntegerType() && *BitWidth <= ToSize) {
2436          return To->getKind() == BuiltinType::UInt;
2437        }
2438
2439        return false;
2440      }
2441    }
2442  }
2443
2444  // An rvalue of type bool can be converted to an rvalue of type int,
2445  // with false becoming zero and true becoming one (C++ 4.5p4).
2446  if (FromType->isBooleanType() && To->getKind() == BuiltinType::Int) {
2447    return true;
2448  }
2449
2450  return false;
2451}
2452
2453/// IsFloatingPointPromotion - Determines whether the conversion from
2454/// FromType to ToType is a floating point promotion (C++ 4.6). If so,
2455/// returns true and sets PromotedType to the promoted type.
2456bool Sema::IsFloatingPointPromotion(QualType FromType, QualType ToType) {
2457  if (const BuiltinType *FromBuiltin = FromType->getAs<BuiltinType>())
2458    if (const BuiltinType *ToBuiltin = ToType->getAs<BuiltinType>()) {
2459      /// An rvalue of type float can be converted to an rvalue of type
2460      /// double. (C++ 4.6p1).
2461      if (FromBuiltin->getKind() == BuiltinType::Float &&
2462          ToBuiltin->getKind() == BuiltinType::Double)
2463        return true;
2464
2465      // C99 6.3.1.5p1:
2466      //   When a float is promoted to double or long double, or a
2467      //   double is promoted to long double [...].
2468      if (!getLangOpts().CPlusPlus &&
2469          (FromBuiltin->getKind() == BuiltinType::Float ||
2470           FromBuiltin->getKind() == BuiltinType::Double) &&
2471          (ToBuiltin->getKind() == BuiltinType::LongDouble ||
2472           ToBuiltin->getKind() == BuiltinType::Float128 ||
2473           ToBuiltin->getKind() == BuiltinType::Ibm128))
2474        return true;
2475
2476      // Half can be promoted to float.
2477      if (!getLangOpts().NativeHalfType &&
2478           FromBuiltin->getKind() == BuiltinType::Half &&
2479          ToBuiltin->getKind() == BuiltinType::Float)
2480        return true;
2481    }
2482
2483  return false;
2484}
2485
2486/// Determine if a conversion is a complex promotion.
2487///
2488/// A complex promotion is defined as a complex -> complex conversion
2489/// where the conversion between the underlying real types is a
2490/// floating-point or integral promotion.
2491bool Sema::IsComplexPromotion(QualType FromType, QualType ToType) {
2492  const ComplexType *FromComplex = FromType->getAs<ComplexType>();
2493  if (!FromComplex)
2494    return false;
2495
2496  const ComplexType *ToComplex = ToType->getAs<ComplexType>();
2497  if (!ToComplex)
2498    return false;
2499
2500  return IsFloatingPointPromotion(FromComplex->getElementType(),
2501                                  ToComplex->getElementType()) ||
2502    IsIntegralPromotion(nullptr, FromComplex->getElementType(),
2503                        ToComplex->getElementType());
2504}
2505
2506/// BuildSimilarlyQualifiedPointerType - In a pointer conversion from
2507/// the pointer type FromPtr to a pointer to type ToPointee, with the
2508/// same type qualifiers as FromPtr has on its pointee type. ToType,
2509/// if non-empty, will be a pointer to ToType that may or may not have
2510/// the right set of qualifiers on its pointee.
2511///
2512static QualType
2513BuildSimilarlyQualifiedPointerType(const Type *FromPtr,
2514                                   QualType ToPointee, QualType ToType,
2515                                   ASTContext &Context,
2516                                   bool StripObjCLifetime = false) {
2517  assert((FromPtr->getTypeClass() == Type::Pointer ||
2518          FromPtr->getTypeClass() == Type::ObjCObjectPointer) &&
2519         "Invalid similarly-qualified pointer type");
2520
2521  /// Conversions to 'id' subsume cv-qualifier conversions.
2522  if (ToType->isObjCIdType() || ToType->isObjCQualifiedIdType())
2523    return ToType.getUnqualifiedType();
2524
2525  QualType CanonFromPointee
2526    = Context.getCanonicalType(FromPtr->getPointeeType());
2527  QualType CanonToPointee = Context.getCanonicalType(ToPointee);
2528  Qualifiers Quals = CanonFromPointee.getQualifiers();
2529
2530  if (StripObjCLifetime)
2531    Quals.removeObjCLifetime();
2532
2533  // Exact qualifier match -> return the pointer type we're converting to.
2534  if (CanonToPointee.getLocalQualifiers() == Quals) {
2535    // ToType is exactly what we need. Return it.
2536    if (!ToType.isNull())
2537      return ToType.getUnqualifiedType();
2538
2539    // Build a pointer to ToPointee. It has the right qualifiers
2540    // already.
2541    if (isa<ObjCObjectPointerType>(ToType))
2542      return Context.getObjCObjectPointerType(ToPointee);
2543    return Context.getPointerType(ToPointee);
2544  }
2545
2546  // Just build a canonical type that has the right qualifiers.
2547  QualType QualifiedCanonToPointee
2548    = Context.getQualifiedType(CanonToPointee.getLocalUnqualifiedType(), Quals);
2549
2550  if (isa<ObjCObjectPointerType>(ToType))
2551    return Context.getObjCObjectPointerType(QualifiedCanonToPointee);
2552  return Context.getPointerType(QualifiedCanonToPointee);
2553}
2554
2555static bool isNullPointerConstantForConversion(Expr *Expr,
2556                                               bool InOverloadResolution,
2557                                               ASTContext &Context) {
2558  // Handle value-dependent integral null pointer constants correctly.
2559  // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#903
2560  if (Expr->isValueDependent() && !Expr->isTypeDependent() &&
2561      Expr->getType()->isIntegerType() && !Expr->getType()->isEnumeralType())
2562    return !InOverloadResolution;
2563
2564  return Expr->isNullPointerConstant(Context,
2565                    InOverloadResolution? Expr::NPC_ValueDependentIsNotNull
2566                                        : Expr::NPC_ValueDependentIsNull);
2567}
2568
2569/// IsPointerConversion - Determines whether the conversion of the
2570/// expression From, which has the (possibly adjusted) type FromType,
2571/// can be converted to the type ToType via a pointer conversion (C++
2572/// 4.10). If so, returns true and places the converted type (that
2573/// might differ from ToType in its cv-qualifiers at some level) into
2574/// ConvertedType.
2575///
2576/// This routine also supports conversions to and from block pointers
2577/// and conversions with Objective-C's 'id', 'id<protocols...>', and
2578/// pointers to interfaces. FIXME: Once we've determined the
2579/// appropriate overloading rules for Objective-C, we may want to
2580/// split the Objective-C checks into a different routine; however,
2581/// GCC seems to consider all of these conversions to be pointer
2582/// conversions, so for now they live here. IncompatibleObjC will be
2583/// set if the conversion is an allowed Objective-C conversion that
2584/// should result in a warning.
2585bool Sema::IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
2586                               bool InOverloadResolution,
2587                               QualType& ConvertedType,
2588                               bool &IncompatibleObjC) {
2589  IncompatibleObjC = false;
2590  if (isObjCPointerConversion(FromType, ToType, ConvertedType,
2591                              IncompatibleObjC))
2592    return true;
2593
2594  // Conversion from a null pointer constant to any Objective-C pointer type.
2595  if (ToType->isObjCObjectPointerType() &&
2596      isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
2597    ConvertedType = ToType;
2598    return true;
2599  }
2600
2601  // Blocks: Block pointers can be converted to void*.
2602  if (FromType->isBlockPointerType() && ToType->isPointerType() &&
2603      ToType->castAs<PointerType>()->getPointeeType()->isVoidType()) {
2604    ConvertedType = ToType;
2605    return true;
2606  }
2607  // Blocks: A null pointer constant can be converted to a block
2608  // pointer type.
2609  if (ToType->isBlockPointerType() &&
2610      isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
2611    ConvertedType = ToType;
2612    return true;
2613  }
2614
2615  // If the left-hand-side is nullptr_t, the right side can be a null
2616  // pointer constant.
2617  if (ToType->isNullPtrType() &&
2618      isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
2619    ConvertedType = ToType;
2620    return true;
2621  }
2622
2623  const PointerType* ToTypePtr = ToType->getAs<PointerType>();
2624  if (!ToTypePtr)
2625    return false;
2626
2627  // A null pointer constant can be converted to a pointer type (C++ 4.10p1).
2628  if (isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
2629    ConvertedType = ToType;
2630    return true;
2631  }
2632
2633  // Beyond this point, both types need to be pointers
2634  // , including objective-c pointers.
2635  QualType ToPointeeType = ToTypePtr->getPointeeType();
2636  if (FromType->isObjCObjectPointerType() && ToPointeeType->isVoidType() &&
2637      !getLangOpts().ObjCAutoRefCount) {
2638    ConvertedType = BuildSimilarlyQualifiedPointerType(
2639        FromType->castAs<ObjCObjectPointerType>(), ToPointeeType, ToType,
2640        Context);
2641    return true;
2642  }
2643  const PointerType *FromTypePtr = FromType->getAs<PointerType>();
2644  if (!FromTypePtr)
2645    return false;
2646
2647  QualType FromPointeeType = FromTypePtr->getPointeeType();
2648
2649  // If the unqualified pointee types are the same, this can't be a
2650  // pointer conversion, so don't do all of the work below.
2651  if (Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType))
2652    return false;
2653
2654  // An rvalue of type "pointer to cv T," where T is an object type,
2655  // can be converted to an rvalue of type "pointer to cv void" (C++
2656  // 4.10p2).
2657  if (FromPointeeType->isIncompleteOrObjectType() &&
2658      ToPointeeType->isVoidType()) {
2659    ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2660                                                       ToPointeeType,
2661                                                       ToType, Context,
2662                                                   /*StripObjCLifetime=*/true);
2663    return true;
2664  }
2665
2666  // MSVC allows implicit function to void* type conversion.
2667  if (getLangOpts().MSVCCompat && FromPointeeType->isFunctionType() &&
2668      ToPointeeType->isVoidType()) {
2669    ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2670                                                       ToPointeeType,
2671                                                       ToType, Context);
2672    return true;
2673  }
2674
2675  // When we're overloading in C, we allow a special kind of pointer
2676  // conversion for compatible-but-not-identical pointee types.
2677  if (!getLangOpts().CPlusPlus &&
2678      Context.typesAreCompatible(FromPointeeType, ToPointeeType)) {
2679    ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2680                                                       ToPointeeType,
2681                                                       ToType, Context);
2682    return true;
2683  }
2684
2685  // C++ [conv.ptr]p3:
2686  //
2687  //   An rvalue of type "pointer to cv D," where D is a class type,
2688  //   can be converted to an rvalue of type "pointer to cv B," where
2689  //   B is a base class (clause 10) of D. If B is an inaccessible
2690  //   (clause 11) or ambiguous (10.2) base class of D, a program that
2691  //   necessitates this conversion is ill-formed. The result of the
2692  //   conversion is a pointer to the base class sub-object of the
2693  //   derived class object. The null pointer value is converted to
2694  //   the null pointer value of the destination type.
2695  //
2696  // Note that we do not check for ambiguity or inaccessibility
2697  // here. That is handled by CheckPointerConversion.
2698  if (getLangOpts().CPlusPlus && FromPointeeType->isRecordType() &&
2699      ToPointeeType->isRecordType() &&
2700      !Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType) &&
2701      IsDerivedFrom(From->getBeginLoc(), FromPointeeType, ToPointeeType)) {
2702    ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2703                                                       ToPointeeType,
2704                                                       ToType, Context);
2705    return true;
2706  }
2707
2708  if (FromPointeeType->isVectorType() && ToPointeeType->isVectorType() &&
2709      Context.areCompatibleVectorTypes(FromPointeeType, ToPointeeType)) {
2710    ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2711                                                       ToPointeeType,
2712                                                       ToType, Context);
2713    return true;
2714  }
2715
2716  return false;
2717}
2718
2719/// Adopt the given qualifiers for the given type.
2720static QualType AdoptQualifiers(ASTContext &Context, QualType T, Qualifiers Qs){
2721  Qualifiers TQs = T.getQualifiers();
2722
2723  // Check whether qualifiers already match.
2724  if (TQs == Qs)
2725    return T;
2726
2727  if (Qs.compatiblyIncludes(TQs))
2728    return Context.getQualifiedType(T, Qs);
2729
2730  return Context.getQualifiedType(T.getUnqualifiedType(), Qs);
2731}
2732
2733/// isObjCPointerConversion - Determines whether this is an
2734/// Objective-C pointer conversion. Subroutine of IsPointerConversion,
2735/// with the same arguments and return values.
2736bool Sema::isObjCPointerConversion(QualType FromType, QualType ToType,
2737                                   QualType& ConvertedType,
2738                                   bool &IncompatibleObjC) {
2739  if (!getLangOpts().ObjC)
2740    return false;
2741
2742  // The set of qualifiers on the type we're converting from.
2743  Qualifiers FromQualifiers = FromType.getQualifiers();
2744
2745  // First, we handle all conversions on ObjC object pointer types.
2746  const ObjCObjectPointerType* ToObjCPtr =
2747    ToType->getAs<ObjCObjectPointerType>();
2748  const ObjCObjectPointerType *FromObjCPtr =
2749    FromType->getAs<ObjCObjectPointerType>();
2750
2751  if (ToObjCPtr && FromObjCPtr) {
2752    // If the pointee types are the same (ignoring qualifications),
2753    // then this is not a pointer conversion.
2754    if (Context.hasSameUnqualifiedType(ToObjCPtr->getPointeeType(),
2755                                       FromObjCPtr->getPointeeType()))
2756      return false;
2757
2758    // Conversion between Objective-C pointers.
2759    if (Context.canAssignObjCInterfaces(ToObjCPtr, FromObjCPtr)) {
2760      const ObjCInterfaceType* LHS = ToObjCPtr->getInterfaceType();
2761      const ObjCInterfaceType* RHS = FromObjCPtr->getInterfaceType();
2762      if (getLangOpts().CPlusPlus && LHS && RHS &&
2763          !ToObjCPtr->getPointeeType().isAtLeastAsQualifiedAs(
2764                                                FromObjCPtr->getPointeeType()))
2765        return false;
2766      ConvertedType = BuildSimilarlyQualifiedPointerType(FromObjCPtr,
2767                                                   ToObjCPtr->getPointeeType(),
2768                                                         ToType, Context);
2769      ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2770      return true;
2771    }
2772
2773    if (Context.canAssignObjCInterfaces(FromObjCPtr, ToObjCPtr)) {
2774      // Okay: this is some kind of implicit downcast of Objective-C
2775      // interfaces, which is permitted. However, we're going to
2776      // complain about it.
2777      IncompatibleObjC = true;
2778      ConvertedType = BuildSimilarlyQualifiedPointerType(FromObjCPtr,
2779                                                   ToObjCPtr->getPointeeType(),
2780                                                         ToType, Context);
2781      ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2782      return true;
2783    }
2784  }
2785  // Beyond this point, both types need to be C pointers or block pointers.
2786  QualType ToPointeeType;
2787  if (const PointerType *ToCPtr = ToType->getAs<PointerType>())
2788    ToPointeeType = ToCPtr->getPointeeType();
2789  else if (const BlockPointerType *ToBlockPtr =
2790            ToType->getAs<BlockPointerType>()) {
2791    // Objective C++: We're able to convert from a pointer to any object
2792    // to a block pointer type.
2793    if (FromObjCPtr && FromObjCPtr->isObjCBuiltinType()) {
2794      ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2795      return true;
2796    }
2797    ToPointeeType = ToBlockPtr->getPointeeType();
2798  }
2799  else if (FromType->getAs<BlockPointerType>() &&
2800           ToObjCPtr && ToObjCPtr->isObjCBuiltinType()) {
2801    // Objective C++: We're able to convert from a block pointer type to a
2802    // pointer to any object.
2803    ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2804    return true;
2805  }
2806  else
2807    return false;
2808
2809  QualType FromPointeeType;
2810  if (const PointerType *FromCPtr = FromType->getAs<PointerType>())
2811    FromPointeeType = FromCPtr->getPointeeType();
2812  else if (const BlockPointerType *FromBlockPtr =
2813           FromType->getAs<BlockPointerType>())
2814    FromPointeeType = FromBlockPtr->getPointeeType();
2815  else
2816    return false;
2817
2818  // If we have pointers to pointers, recursively check whether this
2819  // is an Objective-C conversion.
2820  if (FromPointeeType->isPointerType() && ToPointeeType->isPointerType() &&
2821      isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType,
2822                              IncompatibleObjC)) {
2823    // We always complain about this conversion.
2824    IncompatibleObjC = true;
2825    ConvertedType = Context.getPointerType(ConvertedType);
2826    ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2827    return true;
2828  }
2829  // Allow conversion of pointee being objective-c pointer to another one;
2830  // as in I* to id.
2831  if (FromPointeeType->getAs<ObjCObjectPointerType>() &&
2832      ToPointeeType->getAs<ObjCObjectPointerType>() &&
2833      isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType,
2834                              IncompatibleObjC)) {
2835
2836    ConvertedType = Context.getPointerType(ConvertedType);
2837    ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2838    return true;
2839  }
2840
2841  // If we have pointers to functions or blocks, check whether the only
2842  // differences in the argument and result types are in Objective-C
2843  // pointer conversions. If so, we permit the conversion (but
2844  // complain about it).
2845  const FunctionProtoType *FromFunctionType
2846    = FromPointeeType->getAs<FunctionProtoType>();
2847  const FunctionProtoType *ToFunctionType
2848    = ToPointeeType->getAs<FunctionProtoType>();
2849  if (FromFunctionType && ToFunctionType) {
2850    // If the function types are exactly the same, this isn't an
2851    // Objective-C pointer conversion.
2852    if (Context.getCanonicalType(FromPointeeType)
2853          == Context.getCanonicalType(ToPointeeType))
2854      return false;
2855
2856    // Perform the quick checks that will tell us whether these
2857    // function types are obviously different.
2858    if (FromFunctionType->getNumParams() != ToFunctionType->getNumParams() ||
2859        FromFunctionType->isVariadic() != ToFunctionType->isVariadic() ||
2860        FromFunctionType->getMethodQuals() != ToFunctionType->getMethodQuals())
2861      return false;
2862
2863    bool HasObjCConversion = false;
2864    if (Context.getCanonicalType(FromFunctionType->getReturnType()) ==
2865        Context.getCanonicalType(ToFunctionType->getReturnType())) {
2866      // Okay, the types match exactly. Nothing to do.
2867    } else if (isObjCPointerConversion(FromFunctionType->getReturnType(),
2868                                       ToFunctionType->getReturnType(),
2869                                       ConvertedType, IncompatibleObjC)) {
2870      // Okay, we have an Objective-C pointer conversion.
2871      HasObjCConversion = true;
2872    } else {
2873      // Function types are too different. Abort.
2874      return false;
2875    }
2876
2877    // Check argument types.
2878    for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumParams();
2879         ArgIdx != NumArgs; ++ArgIdx) {
2880      QualType FromArgType = FromFunctionType->getParamType(ArgIdx);
2881      QualType ToArgType = ToFunctionType->getParamType(ArgIdx);
2882      if (Context.getCanonicalType(FromArgType)
2883            == Context.getCanonicalType(ToArgType)) {
2884        // Okay, the types match exactly. Nothing to do.
2885      } else if (isObjCPointerConversion(FromArgType, ToArgType,
2886                                         ConvertedType, IncompatibleObjC)) {
2887        // Okay, we have an Objective-C pointer conversion.
2888        HasObjCConversion = true;
2889      } else {
2890        // Argument types are too different. Abort.
2891        return false;
2892      }
2893    }
2894
2895    if (HasObjCConversion) {
2896      // We had an Objective-C conversion. Allow this pointer
2897      // conversion, but complain about it.
2898      ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2899      IncompatibleObjC = true;
2900      return true;
2901    }
2902  }
2903
2904  return false;
2905}
2906
2907/// Determine whether this is an Objective-C writeback conversion,
2908/// used for parameter passing when performing automatic reference counting.
2909///
2910/// \param FromType The type we're converting form.
2911///
2912/// \param ToType The type we're converting to.
2913///
2914/// \param ConvertedType The type that will be produced after applying
2915/// this conversion.
2916bool Sema::isObjCWritebackConversion(QualType FromType, QualType ToType,
2917                                     QualType &ConvertedType) {
2918  if (!getLangOpts().ObjCAutoRefCount ||
2919      Context.hasSameUnqualifiedType(FromType, ToType))
2920    return false;
2921
2922  // Parameter must be a pointer to __autoreleasing (with no other qualifiers).
2923  QualType ToPointee;
2924  if (const PointerType *ToPointer = ToType->getAs<PointerType>())
2925    ToPointee = ToPointer->getPointeeType();
2926  else
2927    return false;
2928
2929  Qualifiers ToQuals = ToPointee.getQualifiers();
2930  if (!ToPointee->isObjCLifetimeType() ||
2931      ToQuals.getObjCLifetime() != Qualifiers::OCL_Autoreleasing ||
2932      !ToQuals.withoutObjCLifetime().empty())
2933    return false;
2934
2935  // Argument must be a pointer to __strong to __weak.
2936  QualType FromPointee;
2937  if (const PointerType *FromPointer = FromType->getAs<PointerType>())
2938    FromPointee = FromPointer->getPointeeType();
2939  else
2940    return false;
2941
2942  Qualifiers FromQuals = FromPointee.getQualifiers();
2943  if (!FromPointee->isObjCLifetimeType() ||
2944      (FromQuals.getObjCLifetime() != Qualifiers::OCL_Strong &&
2945       FromQuals.getObjCLifetime() != Qualifiers::OCL_Weak))
2946    return false;
2947
2948  // Make sure that we have compatible qualifiers.
2949  FromQuals.setObjCLifetime(Qualifiers::OCL_Autoreleasing);
2950  if (!ToQuals.compatiblyIncludes(FromQuals))
2951    return false;
2952
2953  // Remove qualifiers from the pointee type we're converting from; they
2954  // aren't used in the compatibility check belong, and we'll be adding back
2955  // qualifiers (with __autoreleasing) if the compatibility check succeeds.
2956  FromPointee = FromPointee.getUnqualifiedType();
2957
2958  // The unqualified form of the pointee types must be compatible.
2959  ToPointee = ToPointee.getUnqualifiedType();
2960  bool IncompatibleObjC;
2961  if (Context.typesAreCompatible(FromPointee, ToPointee))
2962    FromPointee = ToPointee;
2963  else if (!isObjCPointerConversion(FromPointee, ToPointee, FromPointee,
2964                                    IncompatibleObjC))
2965    return false;
2966
2967  /// Construct the type we're converting to, which is a pointer to
2968  /// __autoreleasing pointee.
2969  FromPointee = Context.getQualifiedType(FromPointee, FromQuals);
2970  ConvertedType = Context.getPointerType(FromPointee);
2971  return true;
2972}
2973
2974bool Sema::IsBlockPointerConversion(QualType FromType, QualType ToType,
2975                                    QualType& ConvertedType) {
2976  QualType ToPointeeType;
2977  if (const BlockPointerType *ToBlockPtr =
2978        ToType->getAs<BlockPointerType>())
2979    ToPointeeType = ToBlockPtr->getPointeeType();
2980  else
2981    return false;
2982
2983  QualType FromPointeeType;
2984  if (const BlockPointerType *FromBlockPtr =
2985      FromType->getAs<BlockPointerType>())
2986    FromPointeeType = FromBlockPtr->getPointeeType();
2987  else
2988    return false;
2989  // We have pointer to blocks, check whether the only
2990  // differences in the argument and result types are in Objective-C
2991  // pointer conversions. If so, we permit the conversion.
2992
2993  const FunctionProtoType *FromFunctionType
2994    = FromPointeeType->getAs<FunctionProtoType>();
2995  const FunctionProtoType *ToFunctionType
2996    = ToPointeeType->getAs<FunctionProtoType>();
2997
2998  if (!FromFunctionType || !ToFunctionType)
2999    return false;
3000
3001  if (Context.hasSameType(FromPointeeType, ToPointeeType))
3002    return true;
3003
3004  // Perform the quick checks that will tell us whether these
3005  // function types are obviously different.
3006  if (FromFunctionType->getNumParams() != ToFunctionType->getNumParams() ||
3007      FromFunctionType->isVariadic() != ToFunctionType->isVariadic())
3008    return false;
3009
3010  FunctionType::ExtInfo FromEInfo = FromFunctionType->getExtInfo();
3011  FunctionType::ExtInfo ToEInfo = ToFunctionType->getExtInfo();
3012  if (FromEInfo != ToEInfo)
3013    return false;
3014
3015  bool IncompatibleObjC = false;
3016  if (Context.hasSameType(FromFunctionType->getReturnType(),
3017                          ToFunctionType->getReturnType())) {
3018    // Okay, the types match exactly. Nothing to do.
3019  } else {
3020    QualType RHS = FromFunctionType->getReturnType();
3021    QualType LHS = ToFunctionType->getReturnType();
3022    if ((!getLangOpts().CPlusPlus || !RHS->isRecordType()) &&
3023        !RHS.hasQualifiers() && LHS.hasQualifiers())
3024       LHS = LHS.getUnqualifiedType();
3025
3026     if (Context.hasSameType(RHS,LHS)) {
3027       // OK exact match.
3028     } else if (isObjCPointerConversion(RHS, LHS,
3029                                        ConvertedType, IncompatibleObjC)) {
3030     if (IncompatibleObjC)
3031       return false;
3032     // Okay, we have an Objective-C pointer conversion.
3033     }
3034     else
3035       return false;
3036   }
3037
3038   // Check argument types.
3039   for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumParams();
3040        ArgIdx != NumArgs; ++ArgIdx) {
3041     IncompatibleObjC = false;
3042     QualType FromArgType = FromFunctionType->getParamType(ArgIdx);
3043     QualType ToArgType = ToFunctionType->getParamType(ArgIdx);
3044     if (Context.hasSameType(FromArgType, ToArgType)) {
3045       // Okay, the types match exactly. Nothing to do.
3046     } else if (isObjCPointerConversion(ToArgType, FromArgType,
3047                                        ConvertedType, IncompatibleObjC)) {
3048       if (IncompatibleObjC)
3049         return false;
3050       // Okay, we have an Objective-C pointer conversion.
3051     } else
3052       // Argument types are too different. Abort.
3053       return false;
3054   }
3055
3056   SmallVector<FunctionProtoType::ExtParameterInfo, 4> NewParamInfos;
3057   bool CanUseToFPT, CanUseFromFPT;
3058   if (!Context.mergeExtParameterInfo(ToFunctionType, FromFunctionType,
3059                                      CanUseToFPT, CanUseFromFPT,
3060                                      NewParamInfos))
3061     return false;
3062
3063   ConvertedType = ToType;
3064   return true;
3065}
3066
3067enum {
3068  ft_default,
3069  ft_different_class,
3070  ft_parameter_arity,
3071  ft_parameter_mismatch,
3072  ft_return_type,
3073  ft_qualifer_mismatch,
3074  ft_noexcept
3075};
3076
3077/// Attempts to get the FunctionProtoType from a Type. Handles
3078/// MemberFunctionPointers properly.
3079static const FunctionProtoType *tryGetFunctionProtoType(QualType FromType) {
3080  if (auto *FPT = FromType->getAs<FunctionProtoType>())
3081    return FPT;
3082
3083  if (auto *MPT = FromType->getAs<MemberPointerType>())
3084    return MPT->getPointeeType()->getAs<FunctionProtoType>();
3085
3086  return nullptr;
3087}
3088
3089/// HandleFunctionTypeMismatch - Gives diagnostic information for differeing
3090/// function types.  Catches different number of parameter, mismatch in
3091/// parameter types, and different return types.
3092void Sema::HandleFunctionTypeMismatch(PartialDiagnostic &PDiag,
3093                                      QualType FromType, QualType ToType) {
3094  // If either type is not valid, include no extra info.
3095  if (FromType.isNull() || ToType.isNull()) {
3096    PDiag << ft_default;
3097    return;
3098  }
3099
3100  // Get the function type from the pointers.
3101  if (FromType->isMemberPointerType() && ToType->isMemberPointerType()) {
3102    const auto *FromMember = FromType->castAs<MemberPointerType>(),
3103               *ToMember = ToType->castAs<MemberPointerType>();
3104    if (!Context.hasSameType(FromMember->getClass(), ToMember->getClass())) {
3105      PDiag << ft_different_class << QualType(ToMember->getClass(), 0)
3106            << QualType(FromMember->getClass(), 0);
3107      return;
3108    }
3109    FromType = FromMember->getPointeeType();
3110    ToType = ToMember->getPointeeType();
3111  }
3112
3113  if (FromType->isPointerType())
3114    FromType = FromType->getPointeeType();
3115  if (ToType->isPointerType())
3116    ToType = ToType->getPointeeType();
3117
3118  // Remove references.
3119  FromType = FromType.getNonReferenceType();
3120  ToType = ToType.getNonReferenceType();
3121
3122  // Don't print extra info for non-specialized template functions.
3123  if (FromType->isInstantiationDependentType() &&
3124      !FromType->getAs<TemplateSpecializationType>()) {
3125    PDiag << ft_default;
3126    return;
3127  }
3128
3129  // No extra info for same types.
3130  if (Context.hasSameType(FromType, ToType)) {
3131    PDiag << ft_default;
3132    return;
3133  }
3134
3135  const FunctionProtoType *FromFunction = tryGetFunctionProtoType(FromType),
3136                          *ToFunction = tryGetFunctionProtoType(ToType);
3137
3138  // Both types need to be function types.
3139  if (!FromFunction || !ToFunction) {
3140    PDiag << ft_default;
3141    return;
3142  }
3143
3144  if (FromFunction->getNumParams() != ToFunction->getNumParams()) {
3145    PDiag << ft_parameter_arity << ToFunction->getNumParams()
3146          << FromFunction->getNumParams();
3147    return;
3148  }
3149
3150  // Handle different parameter types.
3151  unsigned ArgPos;
3152  if (!FunctionParamTypesAreEqual(FromFunction, ToFunction, &ArgPos)) {
3153    PDiag << ft_parameter_mismatch << ArgPos + 1
3154          << ToFunction->getParamType(ArgPos)
3155          << FromFunction->getParamType(ArgPos);
3156    return;
3157  }
3158
3159  // Handle different return type.
3160  if (!Context.hasSameType(FromFunction->getReturnType(),
3161                           ToFunction->getReturnType())) {
3162    PDiag << ft_return_type << ToFunction->getReturnType()
3163          << FromFunction->getReturnType();
3164    return;
3165  }
3166
3167  if (FromFunction->getMethodQuals() != ToFunction->getMethodQuals()) {
3168    PDiag << ft_qualifer_mismatch << ToFunction->getMethodQuals()
3169          << FromFunction->getMethodQuals();
3170    return;
3171  }
3172
3173  // Handle exception specification differences on canonical type (in C++17
3174  // onwards).
3175  if (cast<FunctionProtoType>(FromFunction->getCanonicalTypeUnqualified())
3176          ->isNothrow() !=
3177      cast<FunctionProtoType>(ToFunction->getCanonicalTypeUnqualified())
3178          ->isNothrow()) {
3179    PDiag << ft_noexcept;
3180    return;
3181  }
3182
3183  // Unable to find a difference, so add no extra info.
3184  PDiag << ft_default;
3185}
3186
3187/// FunctionParamTypesAreEqual - This routine checks two function proto types
3188/// for equality of their parameter types. Caller has already checked that
3189/// they have same number of parameters.  If the parameters are different,
3190/// ArgPos will have the parameter index of the first different parameter.
3191/// If `Reversed` is true, the parameters of `NewType` will be compared in
3192/// reverse order. That's useful if one of the functions is being used as a C++20
3193/// synthesized operator overload with a reversed parameter order.
3194bool Sema::FunctionParamTypesAreEqual(ArrayRef<QualType> Old,
3195                                      ArrayRef<QualType> New, unsigned *ArgPos,
3196                                      bool Reversed) {
3197  assert(llvm::size(Old) == llvm::size(New) &&
3198         "Can't compare parameters of functions with different number of "
3199         "parameters!");
3200
3201  for (auto &&[Idx, Type] : llvm::enumerate(Old)) {
3202    // Reverse iterate over the parameters of `OldType` if `Reversed` is true.
3203    size_t J = Reversed ? (llvm::size(New) - Idx - 1) : Idx;
3204
3205    // Ignore address spaces in pointee type. This is to disallow overloading
3206    // on __ptr32/__ptr64 address spaces.
3207    QualType OldType =
3208        Context.removePtrSizeAddrSpace(Type.getUnqualifiedType());
3209    QualType NewType =
3210        Context.removePtrSizeAddrSpace((New.begin() + J)->getUnqualifiedType());
3211
3212    if (!Context.hasSameType(OldType, NewType)) {
3213      if (ArgPos)
3214        *ArgPos = Idx;
3215      return false;
3216    }
3217  }
3218  return true;
3219}
3220
3221bool Sema::FunctionParamTypesAreEqual(const FunctionProtoType *OldType,
3222                                      const FunctionProtoType *NewType,
3223                                      unsigned *ArgPos, bool Reversed) {
3224  return FunctionParamTypesAreEqual(OldType->param_types(),
3225                                    NewType->param_types(), ArgPos, Reversed);
3226}
3227
3228bool Sema::FunctionNonObjectParamTypesAreEqual(const FunctionDecl *OldFunction,
3229                                               const FunctionDecl *NewFunction,
3230                                               unsigned *ArgPos,
3231                                               bool Reversed) {
3232
3233  if (OldFunction->getNumNonObjectParams() !=
3234      NewFunction->getNumNonObjectParams())
3235    return false;
3236
3237  unsigned OldIgnore =
3238      unsigned(OldFunction->hasCXXExplicitFunctionObjectParameter());
3239  unsigned NewIgnore =
3240      unsigned(NewFunction->hasCXXExplicitFunctionObjectParameter());
3241
3242  auto *OldPT = cast<FunctionProtoType>(OldFunction->getFunctionType());
3243  auto *NewPT = cast<FunctionProtoType>(NewFunction->getFunctionType());
3244
3245  return FunctionParamTypesAreEqual(OldPT->param_types().slice(OldIgnore),
3246                                    NewPT->param_types().slice(NewIgnore),
3247                                    ArgPos, Reversed);
3248}
3249
3250/// CheckPointerConversion - Check the pointer conversion from the
3251/// expression From to the type ToType. This routine checks for
3252/// ambiguous or inaccessible derived-to-base pointer
3253/// conversions for which IsPointerConversion has already returned
3254/// true. It returns true and produces a diagnostic if there was an
3255/// error, or returns false otherwise.
3256bool Sema::CheckPointerConversion(Expr *From, QualType ToType,
3257                                  CastKind &Kind,
3258                                  CXXCastPath& BasePath,
3259                                  bool IgnoreBaseAccess,
3260                                  bool Diagnose) {
3261  QualType FromType = From->getType();
3262  bool IsCStyleOrFunctionalCast = IgnoreBaseAccess;
3263
3264  Kind = CK_BitCast;
3265
3266  if (Diagnose && !IsCStyleOrFunctionalCast && !FromType->isAnyPointerType() &&
3267      From->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNotNull) ==
3268          Expr::NPCK_ZeroExpression) {
3269    if (Context.hasSameUnqualifiedType(From->getType(), Context.BoolTy))
3270      DiagRuntimeBehavior(From->getExprLoc(), From,
3271                          PDiag(diag::warn_impcast_bool_to_null_pointer)
3272                            << ToType << From->getSourceRange());
3273    else if (!isUnevaluatedContext())
3274      Diag(From->getExprLoc(), diag::warn_non_literal_null_pointer)
3275        << ToType << From->getSourceRange();
3276  }
3277  if (const PointerType *ToPtrType = ToType->getAs<PointerType>()) {
3278    if (const PointerType *FromPtrType = FromType->getAs<PointerType>()) {
3279      QualType FromPointeeType = FromPtrType->getPointeeType(),
3280               ToPointeeType   = ToPtrType->getPointeeType();
3281
3282      if (FromPointeeType->isRecordType() && ToPointeeType->isRecordType() &&
3283          !Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType)) {
3284        // We must have a derived-to-base conversion. Check an
3285        // ambiguous or inaccessible conversion.
3286        unsigned InaccessibleID = 0;
3287        unsigned AmbiguousID = 0;
3288        if (Diagnose) {
3289          InaccessibleID = diag::err_upcast_to_inaccessible_base;
3290          AmbiguousID = diag::err_ambiguous_derived_to_base_conv;
3291        }
3292        if (CheckDerivedToBaseConversion(
3293                FromPointeeType, ToPointeeType, InaccessibleID, AmbiguousID,
3294                From->getExprLoc(), From->getSourceRange(), DeclarationName(),
3295                &BasePath, IgnoreBaseAccess))
3296          return true;
3297
3298        // The conversion was successful.
3299        Kind = CK_DerivedToBase;
3300      }
3301
3302      if (Diagnose && !IsCStyleOrFunctionalCast &&
3303          FromPointeeType->isFunctionType() && ToPointeeType->isVoidType()) {
3304        assert(getLangOpts().MSVCCompat &&
3305               "this should only be possible with MSVCCompat!");
3306        Diag(From->getExprLoc(), diag::ext_ms_impcast_fn_obj)
3307            << From->getSourceRange();
3308      }
3309    }
3310  } else if (const ObjCObjectPointerType *ToPtrType =
3311               ToType->getAs<ObjCObjectPointerType>()) {
3312    if (const ObjCObjectPointerType *FromPtrType =
3313          FromType->getAs<ObjCObjectPointerType>()) {
3314      // Objective-C++ conversions are always okay.
3315      // FIXME: We should have a different class of conversions for the
3316      // Objective-C++ implicit conversions.
3317      if (FromPtrType->isObjCBuiltinType() || ToPtrType->isObjCBuiltinType())
3318        return false;
3319    } else if (FromType->isBlockPointerType()) {
3320      Kind = CK_BlockPointerToObjCPointerCast;
3321    } else {
3322      Kind = CK_CPointerToObjCPointerCast;
3323    }
3324  } else if (ToType->isBlockPointerType()) {
3325    if (!FromType->isBlockPointerType())
3326      Kind = CK_AnyPointerToBlockPointerCast;
3327  }
3328
3329  // We shouldn't fall into this case unless it's valid for other
3330  // reasons.
3331  if (From->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull))
3332    Kind = CK_NullToPointer;
3333
3334  return false;
3335}
3336
3337/// IsMemberPointerConversion - Determines whether the conversion of the
3338/// expression From, which has the (possibly adjusted) type FromType, can be
3339/// converted to the type ToType via a member pointer conversion (C++ 4.11).
3340/// If so, returns true and places the converted type (that might differ from
3341/// ToType in its cv-qualifiers at some level) into ConvertedType.
3342bool Sema::IsMemberPointerConversion(Expr *From, QualType FromType,
3343                                     QualType ToType,
3344                                     bool InOverloadResolution,
3345                                     QualType &ConvertedType) {
3346  const MemberPointerType *ToTypePtr = ToType->getAs<MemberPointerType>();
3347  if (!ToTypePtr)
3348    return false;
3349
3350  // A null pointer constant can be converted to a member pointer (C++ 4.11p1)
3351  if (From->isNullPointerConstant(Context,
3352                    InOverloadResolution? Expr::NPC_ValueDependentIsNotNull
3353                                        : Expr::NPC_ValueDependentIsNull)) {
3354    ConvertedType = ToType;
3355    return true;
3356  }
3357
3358  // Otherwise, both types have to be member pointers.
3359  const MemberPointerType *FromTypePtr = FromType->getAs<MemberPointerType>();
3360  if (!FromTypePtr)
3361    return false;
3362
3363  // A pointer to member of B can be converted to a pointer to member of D,
3364  // where D is derived from B (C++ 4.11p2).
3365  QualType FromClass(FromTypePtr->getClass(), 0);
3366  QualType ToClass(ToTypePtr->getClass(), 0);
3367
3368  if (!Context.hasSameUnqualifiedType(FromClass, ToClass) &&
3369      IsDerivedFrom(From->getBeginLoc(), ToClass, FromClass)) {
3370    ConvertedType = Context.getMemberPointerType(FromTypePtr->getPointeeType(),
3371                                                 ToClass.getTypePtr());
3372    return true;
3373  }
3374
3375  return false;
3376}
3377
3378/// CheckMemberPointerConversion - Check the member pointer conversion from the
3379/// expression From to the type ToType. This routine checks for ambiguous or
3380/// virtual or inaccessible base-to-derived member pointer conversions
3381/// for which IsMemberPointerConversion has already returned true. It returns
3382/// true and produces a diagnostic if there was an error, or returns false
3383/// otherwise.
3384bool Sema::CheckMemberPointerConversion(Expr *From, QualType ToType,
3385                                        CastKind &Kind,
3386                                        CXXCastPath &BasePath,
3387                                        bool IgnoreBaseAccess) {
3388  QualType FromType = From->getType();
3389  const MemberPointerType *FromPtrType = FromType->getAs<MemberPointerType>();
3390  if (!FromPtrType) {
3391    // This must be a null pointer to member pointer conversion
3392    assert(From->isNullPointerConstant(Context,
3393                                       Expr::NPC_ValueDependentIsNull) &&
3394           "Expr must be null pointer constant!");
3395    Kind = CK_NullToMemberPointer;
3396    return false;
3397  }
3398
3399  const MemberPointerType *ToPtrType = ToType->getAs<MemberPointerType>();
3400  assert(ToPtrType && "No member pointer cast has a target type "
3401                      "that is not a member pointer.");
3402
3403  QualType FromClass = QualType(FromPtrType->getClass(), 0);
3404  QualType ToClass   = QualType(ToPtrType->getClass(), 0);
3405
3406  // FIXME: What about dependent types?
3407  assert(FromClass->isRecordType() && "Pointer into non-class.");
3408  assert(ToClass->isRecordType() && "Pointer into non-class.");
3409
3410  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
3411                     /*DetectVirtual=*/true);
3412  bool DerivationOkay =
3413      IsDerivedFrom(From->getBeginLoc(), ToClass, FromClass, Paths);
3414  assert(DerivationOkay &&
3415         "Should not have been called if derivation isn't OK.");
3416  (void)DerivationOkay;
3417
3418  if (Paths.isAmbiguous(Context.getCanonicalType(FromClass).
3419                                  getUnqualifiedType())) {
3420    std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
3421    Diag(From->getExprLoc(), diag::err_ambiguous_memptr_conv)
3422      << 0 << FromClass << ToClass << PathDisplayStr << From->getSourceRange();
3423    return true;
3424  }
3425
3426  if (const RecordType *VBase = Paths.getDetectedVirtual()) {
3427    Diag(From->getExprLoc(), diag::err_memptr_conv_via_virtual)
3428      << FromClass << ToClass << QualType(VBase, 0)
3429      << From->getSourceRange();
3430    return true;
3431  }
3432
3433  if (!IgnoreBaseAccess)
3434    CheckBaseClassAccess(From->getExprLoc(), FromClass, ToClass,
3435                         Paths.front(),
3436                         diag::err_downcast_from_inaccessible_base);
3437
3438  // Must be a base to derived member conversion.
3439  BuildBasePathArray(Paths, BasePath);
3440  Kind = CK_BaseToDerivedMemberPointer;
3441  return false;
3442}
3443
3444/// Determine whether the lifetime conversion between the two given
3445/// qualifiers sets is nontrivial.
3446static bool isNonTrivialObjCLifetimeConversion(Qualifiers FromQuals,
3447                                               Qualifiers ToQuals) {
3448  // Converting anything to const __unsafe_unretained is trivial.
3449  if (ToQuals.hasConst() &&
3450      ToQuals.getObjCLifetime() == Qualifiers::OCL_ExplicitNone)
3451    return false;
3452
3453  return true;
3454}
3455
3456/// Perform a single iteration of the loop for checking if a qualification
3457/// conversion is valid.
3458///
3459/// Specifically, check whether any change between the qualifiers of \p
3460/// FromType and \p ToType is permissible, given knowledge about whether every
3461/// outer layer is const-qualified.
3462static bool isQualificationConversionStep(QualType FromType, QualType ToType,
3463                                          bool CStyle, bool IsTopLevel,
3464                                          bool &PreviousToQualsIncludeConst,
3465                                          bool &ObjCLifetimeConversion) {
3466  Qualifiers FromQuals = FromType.getQualifiers();
3467  Qualifiers ToQuals = ToType.getQualifiers();
3468
3469  // Ignore __unaligned qualifier.
3470  FromQuals.removeUnaligned();
3471
3472  // Objective-C ARC:
3473  //   Check Objective-C lifetime conversions.
3474  if (FromQuals.getObjCLifetime() != ToQuals.getObjCLifetime()) {
3475    if (ToQuals.compatiblyIncludesObjCLifetime(FromQuals)) {
3476      if (isNonTrivialObjCLifetimeConversion(FromQuals, ToQuals))
3477        ObjCLifetimeConversion = true;
3478      FromQuals.removeObjCLifetime();
3479      ToQuals.removeObjCLifetime();
3480    } else {
3481      // Qualification conversions cannot cast between different
3482      // Objective-C lifetime qualifiers.
3483      return false;
3484    }
3485  }
3486
3487  // Allow addition/removal of GC attributes but not changing GC attributes.
3488  if (FromQuals.getObjCGCAttr() != ToQuals.getObjCGCAttr() &&
3489      (!FromQuals.hasObjCGCAttr() || !ToQuals.hasObjCGCAttr())) {
3490    FromQuals.removeObjCGCAttr();
3491    ToQuals.removeObjCGCAttr();
3492  }
3493
3494  //   -- for every j > 0, if const is in cv 1,j then const is in cv
3495  //      2,j, and similarly for volatile.
3496  if (!CStyle && !ToQuals.compatiblyIncludes(FromQuals))
3497    return false;
3498
3499  // If address spaces mismatch:
3500  //  - in top level it is only valid to convert to addr space that is a
3501  //    superset in all cases apart from C-style casts where we allow
3502  //    conversions between overlapping address spaces.
3503  //  - in non-top levels it is not a valid conversion.
3504  if (ToQuals.getAddressSpace() != FromQuals.getAddressSpace() &&
3505      (!IsTopLevel ||
3506       !(ToQuals.isAddressSpaceSupersetOf(FromQuals) ||
3507         (CStyle && FromQuals.isAddressSpaceSupersetOf(ToQuals)))))
3508    return false;
3509
3510  //   -- if the cv 1,j and cv 2,j are different, then const is in
3511  //      every cv for 0 < k < j.
3512  if (!CStyle && FromQuals.getCVRQualifiers() != ToQuals.getCVRQualifiers() &&
3513      !PreviousToQualsIncludeConst)
3514    return false;
3515
3516  // The following wording is from C++20, where the result of the conversion
3517  // is T3, not T2.
3518  //   -- if [...] P1,i [...] is "array of unknown bound of", P3,i is
3519  //      "array of unknown bound of"
3520  if (FromType->isIncompleteArrayType() && !ToType->isIncompleteArrayType())
3521    return false;
3522
3523  //   -- if the resulting P3,i is different from P1,i [...], then const is
3524  //      added to every cv 3_k for 0 < k < i.
3525  if (!CStyle && FromType->isConstantArrayType() &&
3526      ToType->isIncompleteArrayType() && !PreviousToQualsIncludeConst)
3527    return false;
3528
3529  // Keep track of whether all prior cv-qualifiers in the "to" type
3530  // include const.
3531  PreviousToQualsIncludeConst =
3532      PreviousToQualsIncludeConst && ToQuals.hasConst();
3533  return true;
3534}
3535
3536/// IsQualificationConversion - Determines whether the conversion from
3537/// an rvalue of type FromType to ToType is a qualification conversion
3538/// (C++ 4.4).
3539///
3540/// \param ObjCLifetimeConversion Output parameter that will be set to indicate
3541/// when the qualification conversion involves a change in the Objective-C
3542/// object lifetime.
3543bool
3544Sema::IsQualificationConversion(QualType FromType, QualType ToType,
3545                                bool CStyle, bool &ObjCLifetimeConversion) {
3546  FromType = Context.getCanonicalType(FromType);
3547  ToType = Context.getCanonicalType(ToType);
3548  ObjCLifetimeConversion = false;
3549
3550  // If FromType and ToType are the same type, this is not a
3551  // qualification conversion.
3552  if (FromType.getUnqualifiedType() == ToType.getUnqualifiedType())
3553    return false;
3554
3555  // (C++ 4.4p4):
3556  //   A conversion can add cv-qualifiers at levels other than the first
3557  //   in multi-level pointers, subject to the following rules: [...]
3558  bool PreviousToQualsIncludeConst = true;
3559  bool UnwrappedAnyPointer = false;
3560  while (Context.UnwrapSimilarTypes(FromType, ToType)) {
3561    if (!isQualificationConversionStep(
3562            FromType, ToType, CStyle, !UnwrappedAnyPointer,
3563            PreviousToQualsIncludeConst, ObjCLifetimeConversion))
3564      return false;
3565    UnwrappedAnyPointer = true;
3566  }
3567
3568  // We are left with FromType and ToType being the pointee types
3569  // after unwrapping the original FromType and ToType the same number
3570  // of times. If we unwrapped any pointers, and if FromType and
3571  // ToType have the same unqualified type (since we checked
3572  // qualifiers above), then this is a qualification conversion.
3573  return UnwrappedAnyPointer && Context.hasSameUnqualifiedType(FromType,ToType);
3574}
3575
3576/// - Determine whether this is a conversion from a scalar type to an
3577/// atomic type.
3578///
3579/// If successful, updates \c SCS's second and third steps in the conversion
3580/// sequence to finish the conversion.
3581static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType,
3582                                bool InOverloadResolution,
3583                                StandardConversionSequence &SCS,
3584                                bool CStyle) {
3585  const AtomicType *ToAtomic = ToType->getAs<AtomicType>();
3586  if (!ToAtomic)
3587    return false;
3588
3589  StandardConversionSequence InnerSCS;
3590  if (!IsStandardConversion(S, From, ToAtomic->getValueType(),
3591                            InOverloadResolution, InnerSCS,
3592                            CStyle, /*AllowObjCWritebackConversion=*/false))
3593    return false;
3594
3595  SCS.Second = InnerSCS.Second;
3596  SCS.setToType(1, InnerSCS.getToType(1));
3597  SCS.Third = InnerSCS.Third;
3598  SCS.QualificationIncludesObjCLifetime
3599    = InnerSCS.QualificationIncludesObjCLifetime;
3600  SCS.setToType(2, InnerSCS.getToType(2));
3601  return true;
3602}
3603
3604static bool isFirstArgumentCompatibleWithType(ASTContext &Context,
3605                                              CXXConstructorDecl *Constructor,
3606                                              QualType Type) {
3607  const auto *CtorType = Constructor->getType()->castAs<FunctionProtoType>();
3608  if (CtorType->getNumParams() > 0) {
3609    QualType FirstArg = CtorType->getParamType(0);
3610    if (Context.hasSameUnqualifiedType(Type, FirstArg.getNonReferenceType()))
3611      return true;
3612  }
3613  return false;
3614}
3615
3616static OverloadingResult
3617IsInitializerListConstructorConversion(Sema &S, Expr *From, QualType ToType,
3618                                       CXXRecordDecl *To,
3619                                       UserDefinedConversionSequence &User,
3620                                       OverloadCandidateSet &CandidateSet,
3621                                       bool AllowExplicit) {
3622  CandidateSet.clear(OverloadCandidateSet::CSK_InitByUserDefinedConversion);
3623  for (auto *D : S.LookupConstructors(To)) {
3624    auto Info = getConstructorInfo(D);
3625    if (!Info)
3626      continue;
3627
3628    bool Usable = !Info.Constructor->isInvalidDecl() &&
3629                  S.isInitListConstructor(Info.Constructor);
3630    if (Usable) {
3631      bool SuppressUserConversions = false;
3632      if (Info.ConstructorTmpl)
3633        S.AddTemplateOverloadCandidate(Info.ConstructorTmpl, Info.FoundDecl,
3634                                       /*ExplicitArgs*/ nullptr, From,
3635                                       CandidateSet, SuppressUserConversions,
3636                                       /*PartialOverloading*/ false,
3637                                       AllowExplicit);
3638      else
3639        S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl, From,
3640                               CandidateSet, SuppressUserConversions,
3641                               /*PartialOverloading*/ false, AllowExplicit);
3642    }
3643  }
3644
3645  bool HadMultipleCandidates = (CandidateSet.size() > 1);
3646
3647  OverloadCandidateSet::iterator Best;
3648  switch (auto Result =
3649              CandidateSet.BestViableFunction(S, From->getBeginLoc(), Best)) {
3650  case OR_Deleted:
3651  case OR_Success: {
3652    // Record the standard conversion we used and the conversion function.
3653    CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function);
3654    QualType ThisType = Constructor->getFunctionObjectParameterType();
3655    // Initializer lists don't have conversions as such.
3656    User.Before.setAsIdentityConversion();
3657    User.HadMultipleCandidates = HadMultipleCandidates;
3658    User.ConversionFunction = Constructor;
3659    User.FoundConversionFunction = Best->FoundDecl;
3660    User.After.setAsIdentityConversion();
3661    User.After.setFromType(ThisType);
3662    User.After.setAllToTypes(ToType);
3663    return Result;
3664  }
3665
3666  case OR_No_Viable_Function:
3667    return OR_No_Viable_Function;
3668  case OR_Ambiguous:
3669    return OR_Ambiguous;
3670  }
3671
3672  llvm_unreachable("Invalid OverloadResult!");
3673}
3674
3675/// Determines whether there is a user-defined conversion sequence
3676/// (C++ [over.ics.user]) that converts expression From to the type
3677/// ToType. If such a conversion exists, User will contain the
3678/// user-defined conversion sequence that performs such a conversion
3679/// and this routine will return true. Otherwise, this routine returns
3680/// false and User is unspecified.
3681///
3682/// \param AllowExplicit  true if the conversion should consider C++0x
3683/// "explicit" conversion functions as well as non-explicit conversion
3684/// functions (C++0x [class.conv.fct]p2).
3685///
3686/// \param AllowObjCConversionOnExplicit true if the conversion should
3687/// allow an extra Objective-C pointer conversion on uses of explicit
3688/// constructors. Requires \c AllowExplicit to also be set.
3689static OverloadingResult
3690IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
3691                        UserDefinedConversionSequence &User,
3692                        OverloadCandidateSet &CandidateSet,
3693                        AllowedExplicit AllowExplicit,
3694                        bool AllowObjCConversionOnExplicit) {
3695  assert(AllowExplicit != AllowedExplicit::None ||
3696         !AllowObjCConversionOnExplicit);
3697  CandidateSet.clear(OverloadCandidateSet::CSK_InitByUserDefinedConversion);
3698
3699  // Whether we will only visit constructors.
3700  bool ConstructorsOnly = false;
3701
3702  // If the type we are conversion to is a class type, enumerate its
3703  // constructors.
3704  if (const RecordType *ToRecordType = ToType->getAs<RecordType>()) {
3705    // C++ [over.match.ctor]p1:
3706    //   When objects of class type are direct-initialized (8.5), or
3707    //   copy-initialized from an expression of the same or a
3708    //   derived class type (8.5), overload resolution selects the
3709    //   constructor. [...] For copy-initialization, the candidate
3710    //   functions are all the converting constructors (12.3.1) of
3711    //   that class. The argument list is the expression-list within
3712    //   the parentheses of the initializer.
3713    if (S.Context.hasSameUnqualifiedType(ToType, From->getType()) ||
3714        (From->getType()->getAs<RecordType>() &&
3715         S.IsDerivedFrom(From->getBeginLoc(), From->getType(), ToType)))
3716      ConstructorsOnly = true;
3717
3718    if (!S.isCompleteType(From->getExprLoc(), ToType)) {
3719      // We're not going to find any constructors.
3720    } else if (CXXRecordDecl *ToRecordDecl
3721                 = dyn_cast<CXXRecordDecl>(ToRecordType->getDecl())) {
3722
3723      Expr **Args = &From;
3724      unsigned NumArgs = 1;
3725      bool ListInitializing = false;
3726      if (InitListExpr *InitList = dyn_cast<InitListExpr>(From)) {
3727        // But first, see if there is an init-list-constructor that will work.
3728        OverloadingResult Result = IsInitializerListConstructorConversion(
3729            S, From, ToType, ToRecordDecl, User, CandidateSet,
3730            AllowExplicit == AllowedExplicit::All);
3731        if (Result != OR_No_Viable_Function)
3732          return Result;
3733        // Never mind.
3734        CandidateSet.clear(
3735            OverloadCandidateSet::CSK_InitByUserDefinedConversion);
3736
3737        // If we're list-initializing, we pass the individual elements as
3738        // arguments, not the entire list.
3739        Args = InitList->getInits();
3740        NumArgs = InitList->getNumInits();
3741        ListInitializing = true;
3742      }
3743
3744      for (auto *D : S.LookupConstructors(ToRecordDecl)) {
3745        auto Info = getConstructorInfo(D);
3746        if (!Info)
3747          continue;
3748
3749        bool Usable = !Info.Constructor->isInvalidDecl();
3750        if (!ListInitializing)
3751          Usable = Usable && Info.Constructor->isConvertingConstructor(
3752                                 /*AllowExplicit*/ true);
3753        if (Usable) {
3754          bool SuppressUserConversions = !ConstructorsOnly;
3755          // C++20 [over.best.ics.general]/4.5:
3756          //   if the target is the first parameter of a constructor [of class
3757          //   X] and the constructor [...] is a candidate by [...] the second
3758          //   phase of [over.match.list] when the initializer list has exactly
3759          //   one element that is itself an initializer list, [...] and the
3760          //   conversion is to X or reference to cv X, user-defined conversion
3761          //   sequences are not cnosidered.
3762          if (SuppressUserConversions && ListInitializing) {
3763            SuppressUserConversions =
3764                NumArgs == 1 && isa<InitListExpr>(Args[0]) &&
3765                isFirstArgumentCompatibleWithType(S.Context, Info.Constructor,
3766                                                  ToType);
3767          }
3768          if (Info.ConstructorTmpl)
3769            S.AddTemplateOverloadCandidate(
3770                Info.ConstructorTmpl, Info.FoundDecl,
3771                /*ExplicitArgs*/ nullptr, llvm::ArrayRef(Args, NumArgs),
3772                CandidateSet, SuppressUserConversions,
3773                /*PartialOverloading*/ false,
3774                AllowExplicit == AllowedExplicit::All);
3775          else
3776            // Allow one user-defined conversion when user specifies a
3777            // From->ToType conversion via an static cast (c-style, etc).
3778            S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl,
3779                                   llvm::ArrayRef(Args, NumArgs), CandidateSet,
3780                                   SuppressUserConversions,
3781                                   /*PartialOverloading*/ false,
3782                                   AllowExplicit == AllowedExplicit::All);
3783        }
3784      }
3785    }
3786  }
3787
3788  // Enumerate conversion functions, if we're allowed to.
3789  if (ConstructorsOnly || isa<InitListExpr>(From)) {
3790  } else if (!S.isCompleteType(From->getBeginLoc(), From->getType())) {
3791    // No conversion functions from incomplete types.
3792  } else if (const RecordType *FromRecordType =
3793                 From->getType()->getAs<RecordType>()) {
3794    if (CXXRecordDecl *FromRecordDecl
3795         = dyn_cast<CXXRecordDecl>(FromRecordType->getDecl())) {
3796      // Add all of the conversion functions as candidates.
3797      const auto &Conversions = FromRecordDecl->getVisibleConversionFunctions();
3798      for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
3799        DeclAccessPair FoundDecl = I.getPair();
3800        NamedDecl *D = FoundDecl.getDecl();
3801        CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext());
3802        if (isa<UsingShadowDecl>(D))
3803          D = cast<UsingShadowDecl>(D)->getTargetDecl();
3804
3805        CXXConversionDecl *Conv;
3806        FunctionTemplateDecl *ConvTemplate;
3807        if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D)))
3808          Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
3809        else
3810          Conv = cast<CXXConversionDecl>(D);
3811
3812        if (ConvTemplate)
3813          S.AddTemplateConversionCandidate(
3814              ConvTemplate, FoundDecl, ActingContext, From, ToType,
3815              CandidateSet, AllowObjCConversionOnExplicit,
3816              AllowExplicit != AllowedExplicit::None);
3817        else
3818          S.AddConversionCandidate(Conv, FoundDecl, ActingContext, From, ToType,
3819                                   CandidateSet, AllowObjCConversionOnExplicit,
3820                                   AllowExplicit != AllowedExplicit::None);
3821      }
3822    }
3823  }
3824
3825  bool HadMultipleCandidates = (CandidateSet.size() > 1);
3826
3827  OverloadCandidateSet::iterator Best;
3828  switch (auto Result =
3829              CandidateSet.BestViableFunction(S, From->getBeginLoc(), Best)) {
3830  case OR_Success:
3831  case OR_Deleted:
3832    // Record the standard conversion we used and the conversion function.
3833    if (CXXConstructorDecl *Constructor
3834          = dyn_cast<CXXConstructorDecl>(Best->Function)) {
3835      // C++ [over.ics.user]p1:
3836      //   If the user-defined conversion is specified by a
3837      //   constructor (12.3.1), the initial standard conversion
3838      //   sequence converts the source type to the type required by
3839      //   the argument of the constructor.
3840      //
3841      if (isa<InitListExpr>(From)) {
3842        // Initializer lists don't have conversions as such.
3843        User.Before.setAsIdentityConversion();
3844      } else {
3845        if (Best->Conversions[0].isEllipsis())
3846          User.EllipsisConversion = true;
3847        else {
3848          User.Before = Best->Conversions[0].Standard;
3849          User.EllipsisConversion = false;
3850        }
3851      }
3852      User.HadMultipleCandidates = HadMultipleCandidates;
3853      User.ConversionFunction = Constructor;
3854      User.FoundConversionFunction = Best->FoundDecl;
3855      User.After.setAsIdentityConversion();
3856      User.After.setFromType(Constructor->getFunctionObjectParameterType());
3857      User.After.setAllToTypes(ToType);
3858      return Result;
3859    }
3860    if (CXXConversionDecl *Conversion
3861                 = dyn_cast<CXXConversionDecl>(Best->Function)) {
3862      // C++ [over.ics.user]p1:
3863      //
3864      //   [...] If the user-defined conversion is specified by a
3865      //   conversion function (12.3.2), the initial standard
3866      //   conversion sequence converts the source type to the
3867      //   implicit object parameter of the conversion function.
3868      User.Before = Best->Conversions[0].Standard;
3869      User.HadMultipleCandidates = HadMultipleCandidates;
3870      User.ConversionFunction = Conversion;
3871      User.FoundConversionFunction = Best->FoundDecl;
3872      User.EllipsisConversion = false;
3873
3874      // C++ [over.ics.user]p2:
3875      //   The second standard conversion sequence converts the
3876      //   result of the user-defined conversion to the target type
3877      //   for the sequence. Since an implicit conversion sequence
3878      //   is an initialization, the special rules for
3879      //   initialization by user-defined conversion apply when
3880      //   selecting the best user-defined conversion for a
3881      //   user-defined conversion sequence (see 13.3.3 and
3882      //   13.3.3.1).
3883      User.After = Best->FinalConversion;
3884      return Result;
3885    }
3886    llvm_unreachable("Not a constructor or conversion function?");
3887
3888  case OR_No_Viable_Function:
3889    return OR_No_Viable_Function;
3890
3891  case OR_Ambiguous:
3892    return OR_Ambiguous;
3893  }
3894
3895  llvm_unreachable("Invalid OverloadResult!");
3896}
3897
3898bool
3899Sema::DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType) {
3900  ImplicitConversionSequence ICS;
3901  OverloadCandidateSet CandidateSet(From->getExprLoc(),
3902                                    OverloadCandidateSet::CSK_Normal);
3903  OverloadingResult OvResult =
3904    IsUserDefinedConversion(*this, From, ToType, ICS.UserDefined,
3905                            CandidateSet, AllowedExplicit::None, false);
3906
3907  if (!(OvResult == OR_Ambiguous ||
3908        (OvResult == OR_No_Viable_Function && !CandidateSet.empty())))
3909    return false;
3910
3911  auto Cands = CandidateSet.CompleteCandidates(
3912      *this,
3913      OvResult == OR_Ambiguous ? OCD_AmbiguousCandidates : OCD_AllCandidates,
3914      From);
3915  if (OvResult == OR_Ambiguous)
3916    Diag(From->getBeginLoc(), diag::err_typecheck_ambiguous_condition)
3917        << From->getType() << ToType << From->getSourceRange();
3918  else { // OR_No_Viable_Function && !CandidateSet.empty()
3919    if (!RequireCompleteType(From->getBeginLoc(), ToType,
3920                             diag::err_typecheck_nonviable_condition_incomplete,
3921                             From->getType(), From->getSourceRange()))
3922      Diag(From->getBeginLoc(), diag::err_typecheck_nonviable_condition)
3923          << false << From->getType() << From->getSourceRange() << ToType;
3924  }
3925
3926  CandidateSet.NoteCandidates(
3927                              *this, From, Cands);
3928  return true;
3929}
3930
3931// Helper for compareConversionFunctions that gets the FunctionType that the
3932// conversion-operator return  value 'points' to, or nullptr.
3933static const FunctionType *
3934getConversionOpReturnTyAsFunction(CXXConversionDecl *Conv) {
3935  const FunctionType *ConvFuncTy = Conv->getType()->castAs<FunctionType>();
3936  const PointerType *RetPtrTy =
3937      ConvFuncTy->getReturnType()->getAs<PointerType>();
3938
3939  if (!RetPtrTy)
3940    return nullptr;
3941
3942  return RetPtrTy->getPointeeType()->getAs<FunctionType>();
3943}
3944
3945/// Compare the user-defined conversion functions or constructors
3946/// of two user-defined conversion sequences to determine whether any ordering
3947/// is possible.
3948static ImplicitConversionSequence::CompareKind
3949compareConversionFunctions(Sema &S, FunctionDecl *Function1,
3950                           FunctionDecl *Function2) {
3951  CXXConversionDecl *Conv1 = dyn_cast_or_null<CXXConversionDecl>(Function1);
3952  CXXConversionDecl *Conv2 = dyn_cast_or_null<CXXConversionDecl>(Function2);
3953  if (!Conv1 || !Conv2)
3954    return ImplicitConversionSequence::Indistinguishable;
3955
3956  if (!Conv1->getParent()->isLambda() || !Conv2->getParent()->isLambda())
3957    return ImplicitConversionSequence::Indistinguishable;
3958
3959  // Objective-C++:
3960  //   If both conversion functions are implicitly-declared conversions from
3961  //   a lambda closure type to a function pointer and a block pointer,
3962  //   respectively, always prefer the conversion to a function pointer,
3963  //   because the function pointer is more lightweight and is more likely
3964  //   to keep code working.
3965  if (S.getLangOpts().ObjC && S.getLangOpts().CPlusPlus11) {
3966    bool Block1 = Conv1->getConversionType()->isBlockPointerType();
3967    bool Block2 = Conv2->getConversionType()->isBlockPointerType();
3968    if (Block1 != Block2)
3969      return Block1 ? ImplicitConversionSequence::Worse
3970                    : ImplicitConversionSequence::Better;
3971  }
3972
3973  // In order to support multiple calling conventions for the lambda conversion
3974  // operator (such as when the free and member function calling convention is
3975  // different), prefer the 'free' mechanism, followed by the calling-convention
3976  // of operator(). The latter is in place to support the MSVC-like solution of
3977  // defining ALL of the possible conversions in regards to calling-convention.
3978  const FunctionType *Conv1FuncRet = getConversionOpReturnTyAsFunction(Conv1);
3979  const FunctionType *Conv2FuncRet = getConversionOpReturnTyAsFunction(Conv2);
3980
3981  if (Conv1FuncRet && Conv2FuncRet &&
3982      Conv1FuncRet->getCallConv() != Conv2FuncRet->getCallConv()) {
3983    CallingConv Conv1CC = Conv1FuncRet->getCallConv();
3984    CallingConv Conv2CC = Conv2FuncRet->getCallConv();
3985
3986    CXXMethodDecl *CallOp = Conv2->getParent()->getLambdaCallOperator();
3987    const auto *CallOpProto = CallOp->getType()->castAs<FunctionProtoType>();
3988
3989    CallingConv CallOpCC =
3990        CallOp->getType()->castAs<FunctionType>()->getCallConv();
3991    CallingConv DefaultFree = S.Context.getDefaultCallingConvention(
3992        CallOpProto->isVariadic(), /*IsCXXMethod=*/false);
3993    CallingConv DefaultMember = S.Context.getDefaultCallingConvention(
3994        CallOpProto->isVariadic(), /*IsCXXMethod=*/true);
3995
3996    CallingConv PrefOrder[] = {DefaultFree, DefaultMember, CallOpCC};
3997    for (CallingConv CC : PrefOrder) {
3998      if (Conv1CC == CC)
3999        return ImplicitConversionSequence::Better;
4000      if (Conv2CC == CC)
4001        return ImplicitConversionSequence::Worse;
4002    }
4003  }
4004
4005  return ImplicitConversionSequence::Indistinguishable;
4006}
4007
4008static bool hasDeprecatedStringLiteralToCharPtrConversion(
4009    const ImplicitConversionSequence &ICS) {
4010  return (ICS.isStandard() && ICS.Standard.DeprecatedStringLiteralToCharPtr) ||
4011         (ICS.isUserDefined() &&
4012          ICS.UserDefined.Before.DeprecatedStringLiteralToCharPtr);
4013}
4014
4015/// CompareImplicitConversionSequences - Compare two implicit
4016/// conversion sequences to determine whether one is better than the
4017/// other or if they are indistinguishable (C++ 13.3.3.2).
4018static ImplicitConversionSequence::CompareKind
4019CompareImplicitConversionSequences(Sema &S, SourceLocation Loc,
4020                                   const ImplicitConversionSequence& ICS1,
4021                                   const ImplicitConversionSequence& ICS2)
4022{
4023  // (C++ 13.3.3.2p2): When comparing the basic forms of implicit
4024  // conversion sequences (as defined in 13.3.3.1)
4025  //   -- a standard conversion sequence (13.3.3.1.1) is a better
4026  //      conversion sequence than a user-defined conversion sequence or
4027  //      an ellipsis conversion sequence, and
4028  //   -- a user-defined conversion sequence (13.3.3.1.2) is a better
4029  //      conversion sequence than an ellipsis conversion sequence
4030  //      (13.3.3.1.3).
4031  //
4032  // C++0x [over.best.ics]p10:
4033  //   For the purpose of ranking implicit conversion sequences as
4034  //   described in 13.3.3.2, the ambiguous conversion sequence is
4035  //   treated as a user-defined sequence that is indistinguishable
4036  //   from any other user-defined conversion sequence.
4037
4038  // String literal to 'char *' conversion has been deprecated in C++03. It has
4039  // been removed from C++11. We still accept this conversion, if it happens at
4040  // the best viable function. Otherwise, this conversion is considered worse
4041  // than ellipsis conversion. Consider this as an extension; this is not in the
4042  // standard. For example:
4043  //
4044  // int &f(...);    // #1
4045  // void f(char*);  // #2
4046  // void g() { int &r = f("foo"); }
4047  //
4048  // In C++03, we pick #2 as the best viable function.
4049  // In C++11, we pick #1 as the best viable function, because ellipsis
4050  // conversion is better than string-literal to char* conversion (since there
4051  // is no such conversion in C++11). If there was no #1 at all or #1 couldn't
4052  // convert arguments, #2 would be the best viable function in C++11.
4053  // If the best viable function has this conversion, a warning will be issued
4054  // in C++03, or an ExtWarn (+SFINAE failure) will be issued in C++11.
4055
4056  if (S.getLangOpts().CPlusPlus11 && !S.getLangOpts().WritableStrings &&
4057      hasDeprecatedStringLiteralToCharPtrConversion(ICS1) !=
4058          hasDeprecatedStringLiteralToCharPtrConversion(ICS2) &&
4059      // Ill-formedness must not differ
4060      ICS1.isBad() == ICS2.isBad())
4061    return hasDeprecatedStringLiteralToCharPtrConversion(ICS1)
4062               ? ImplicitConversionSequence::Worse
4063               : ImplicitConversionSequence::Better;
4064
4065  if (ICS1.getKindRank() < ICS2.getKindRank())
4066    return ImplicitConversionSequence::Better;
4067  if (ICS2.getKindRank() < ICS1.getKindRank())
4068    return ImplicitConversionSequence::Worse;
4069
4070  // The following checks require both conversion sequences to be of
4071  // the same kind.
4072  if (ICS1.getKind() != ICS2.getKind())
4073    return ImplicitConversionSequence::Indistinguishable;
4074
4075  ImplicitConversionSequence::CompareKind Result =
4076      ImplicitConversionSequence::Indistinguishable;
4077
4078  // Two implicit conversion sequences of the same form are
4079  // indistinguishable conversion sequences unless one of the
4080  // following rules apply: (C++ 13.3.3.2p3):
4081
4082  // List-initialization sequence L1 is a better conversion sequence than
4083  // list-initialization sequence L2 if:
4084  // - L1 converts to std::initializer_list<X> for some X and L2 does not, or,
4085  //   if not that,
4086  // ��� L1 and L2 convert to arrays of the same element type, and either the
4087  //   number of elements n_1 initialized by L1 is less than the number of
4088  //   elements n_2 initialized by L2, or (C++20) n_1 = n_2 and L2 converts to
4089  //   an array of unknown bound and L1 does not,
4090  // even if one of the other rules in this paragraph would otherwise apply.
4091  if (!ICS1.isBad()) {
4092    bool StdInit1 = false, StdInit2 = false;
4093    if (ICS1.hasInitializerListContainerType())
4094      StdInit1 = S.isStdInitializerList(ICS1.getInitializerListContainerType(),
4095                                        nullptr);
4096    if (ICS2.hasInitializerListContainerType())
4097      StdInit2 = S.isStdInitializerList(ICS2.getInitializerListContainerType(),
4098                                        nullptr);
4099    if (StdInit1 != StdInit2)
4100      return StdInit1 ? ImplicitConversionSequence::Better
4101                      : ImplicitConversionSequence::Worse;
4102
4103    if (ICS1.hasInitializerListContainerType() &&
4104        ICS2.hasInitializerListContainerType())
4105      if (auto *CAT1 = S.Context.getAsConstantArrayType(
4106              ICS1.getInitializerListContainerType()))
4107        if (auto *CAT2 = S.Context.getAsConstantArrayType(
4108                ICS2.getInitializerListContainerType())) {
4109          if (S.Context.hasSameUnqualifiedType(CAT1->getElementType(),
4110                                               CAT2->getElementType())) {
4111            // Both to arrays of the same element type
4112            if (CAT1->getSize() != CAT2->getSize())
4113              // Different sized, the smaller wins
4114              return CAT1->getSize().ult(CAT2->getSize())
4115                         ? ImplicitConversionSequence::Better
4116                         : ImplicitConversionSequence::Worse;
4117            if (ICS1.isInitializerListOfIncompleteArray() !=
4118                ICS2.isInitializerListOfIncompleteArray())
4119              // One is incomplete, it loses
4120              return ICS2.isInitializerListOfIncompleteArray()
4121                         ? ImplicitConversionSequence::Better
4122                         : ImplicitConversionSequence::Worse;
4123          }
4124        }
4125  }
4126
4127  if (ICS1.isStandard())
4128    // Standard conversion sequence S1 is a better conversion sequence than
4129    // standard conversion sequence S2 if [...]
4130    Result = CompareStandardConversionSequences(S, Loc,
4131                                                ICS1.Standard, ICS2.Standard);
4132  else if (ICS1.isUserDefined()) {
4133    // User-defined conversion sequence U1 is a better conversion
4134    // sequence than another user-defined conversion sequence U2 if
4135    // they contain the same user-defined conversion function or
4136    // constructor and if the second standard conversion sequence of
4137    // U1 is better than the second standard conversion sequence of
4138    // U2 (C++ 13.3.3.2p3).
4139    if (ICS1.UserDefined.ConversionFunction ==
4140          ICS2.UserDefined.ConversionFunction)
4141      Result = CompareStandardConversionSequences(S, Loc,
4142                                                  ICS1.UserDefined.After,
4143                                                  ICS2.UserDefined.After);
4144    else
4145      Result = compareConversionFunctions(S,
4146                                          ICS1.UserDefined.ConversionFunction,
4147                                          ICS2.UserDefined.ConversionFunction);
4148  }
4149
4150  return Result;
4151}
4152
4153// Per 13.3.3.2p3, compare the given standard conversion sequences to
4154// determine if one is a proper subset of the other.
4155static ImplicitConversionSequence::CompareKind
4156compareStandardConversionSubsets(ASTContext &Context,
4157                                 const StandardConversionSequence& SCS1,
4158                                 const StandardConversionSequence& SCS2) {
4159  ImplicitConversionSequence::CompareKind Result
4160    = ImplicitConversionSequence::Indistinguishable;
4161
4162  // the identity conversion sequence is considered to be a subsequence of
4163  // any non-identity conversion sequence
4164  if (SCS1.isIdentityConversion() && !SCS2.isIdentityConversion())
4165    return ImplicitConversionSequence::Better;
4166  else if (!SCS1.isIdentityConversion() && SCS2.isIdentityConversion())
4167    return ImplicitConversionSequence::Worse;
4168
4169  if (SCS1.Second != SCS2.Second) {
4170    if (SCS1.Second == ICK_Identity)
4171      Result = ImplicitConversionSequence::Better;
4172    else if (SCS2.Second == ICK_Identity)
4173      Result = ImplicitConversionSequence::Worse;
4174    else
4175      return ImplicitConversionSequence::Indistinguishable;
4176  } else if (!Context.hasSimilarType(SCS1.getToType(1), SCS2.getToType(1)))
4177    return ImplicitConversionSequence::Indistinguishable;
4178
4179  if (SCS1.Third == SCS2.Third) {
4180    return Context.hasSameType(SCS1.getToType(2), SCS2.getToType(2))? Result
4181                             : ImplicitConversionSequence::Indistinguishable;
4182  }
4183
4184  if (SCS1.Third == ICK_Identity)
4185    return Result == ImplicitConversionSequence::Worse
4186             ? ImplicitConversionSequence::Indistinguishable
4187             : ImplicitConversionSequence::Better;
4188
4189  if (SCS2.Third == ICK_Identity)
4190    return Result == ImplicitConversionSequence::Better
4191             ? ImplicitConversionSequence::Indistinguishable
4192             : ImplicitConversionSequence::Worse;
4193
4194  return ImplicitConversionSequence::Indistinguishable;
4195}
4196
4197/// Determine whether one of the given reference bindings is better
4198/// than the other based on what kind of bindings they are.
4199static bool
4200isBetterReferenceBindingKind(const StandardConversionSequence &SCS1,
4201                             const StandardConversionSequence &SCS2) {
4202  // C++0x [over.ics.rank]p3b4:
4203  //   -- S1 and S2 are reference bindings (8.5.3) and neither refers to an
4204  //      implicit object parameter of a non-static member function declared
4205  //      without a ref-qualifier, and *either* S1 binds an rvalue reference
4206  //      to an rvalue and S2 binds an lvalue reference *or S1 binds an
4207  //      lvalue reference to a function lvalue and S2 binds an rvalue
4208  //      reference*.
4209  //
4210  // FIXME: Rvalue references. We're going rogue with the above edits,
4211  // because the semantics in the current C++0x working paper (N3225 at the
4212  // time of this writing) break the standard definition of std::forward
4213  // and std::reference_wrapper when dealing with references to functions.
4214  // Proposed wording changes submitted to CWG for consideration.
4215  if (SCS1.BindsImplicitObjectArgumentWithoutRefQualifier ||
4216      SCS2.BindsImplicitObjectArgumentWithoutRefQualifier)
4217    return false;
4218
4219  return (!SCS1.IsLvalueReference && SCS1.BindsToRvalue &&
4220          SCS2.IsLvalueReference) ||
4221         (SCS1.IsLvalueReference && SCS1.BindsToFunctionLvalue &&
4222          !SCS2.IsLvalueReference && SCS2.BindsToFunctionLvalue);
4223}
4224
4225enum class FixedEnumPromotion {
4226  None,
4227  ToUnderlyingType,
4228  ToPromotedUnderlyingType
4229};
4230
4231/// Returns kind of fixed enum promotion the \a SCS uses.
4232static FixedEnumPromotion
4233getFixedEnumPromtion(Sema &S, const StandardConversionSequence &SCS) {
4234
4235  if (SCS.Second != ICK_Integral_Promotion)
4236    return FixedEnumPromotion::None;
4237
4238  QualType FromType = SCS.getFromType();
4239  if (!FromType->isEnumeralType())
4240    return FixedEnumPromotion::None;
4241
4242  EnumDecl *Enum = FromType->castAs<EnumType>()->getDecl();
4243  if (!Enum->isFixed())
4244    return FixedEnumPromotion::None;
4245
4246  QualType UnderlyingType = Enum->getIntegerType();
4247  if (S.Context.hasSameType(SCS.getToType(1), UnderlyingType))
4248    return FixedEnumPromotion::ToUnderlyingType;
4249
4250  return FixedEnumPromotion::ToPromotedUnderlyingType;
4251}
4252
4253/// CompareStandardConversionSequences - Compare two standard
4254/// conversion sequences to determine whether one is better than the
4255/// other or if they are indistinguishable (C++ 13.3.3.2p3).
4256static ImplicitConversionSequence::CompareKind
4257CompareStandardConversionSequences(Sema &S, SourceLocation Loc,
4258                                   const StandardConversionSequence& SCS1,
4259                                   const StandardConversionSequence& SCS2)
4260{
4261  // Standard conversion sequence S1 is a better conversion sequence
4262  // than standard conversion sequence S2 if (C++ 13.3.3.2p3):
4263
4264  //  -- S1 is a proper subsequence of S2 (comparing the conversion
4265  //     sequences in the canonical form defined by 13.3.3.1.1,
4266  //     excluding any Lvalue Transformation; the identity conversion
4267  //     sequence is considered to be a subsequence of any
4268  //     non-identity conversion sequence) or, if not that,
4269  if (ImplicitConversionSequence::CompareKind CK
4270        = compareStandardConversionSubsets(S.Context, SCS1, SCS2))
4271    return CK;
4272
4273  //  -- the rank of S1 is better than the rank of S2 (by the rules
4274  //     defined below), or, if not that,
4275  ImplicitConversionRank Rank1 = SCS1.getRank();
4276  ImplicitConversionRank Rank2 = SCS2.getRank();
4277  if (Rank1 < Rank2)
4278    return ImplicitConversionSequence::Better;
4279  else if (Rank2 < Rank1)
4280    return ImplicitConversionSequence::Worse;
4281
4282  // (C++ 13.3.3.2p4): Two conversion sequences with the same rank
4283  // are indistinguishable unless one of the following rules
4284  // applies:
4285
4286  //   A conversion that is not a conversion of a pointer, or
4287  //   pointer to member, to bool is better than another conversion
4288  //   that is such a conversion.
4289  if (SCS1.isPointerConversionToBool() != SCS2.isPointerConversionToBool())
4290    return SCS2.isPointerConversionToBool()
4291             ? ImplicitConversionSequence::Better
4292             : ImplicitConversionSequence::Worse;
4293
4294  // C++14 [over.ics.rank]p4b2:
4295  // This is retroactively applied to C++11 by CWG 1601.
4296  //
4297  //   A conversion that promotes an enumeration whose underlying type is fixed
4298  //   to its underlying type is better than one that promotes to the promoted
4299  //   underlying type, if the two are different.
4300  FixedEnumPromotion FEP1 = getFixedEnumPromtion(S, SCS1);
4301  FixedEnumPromotion FEP2 = getFixedEnumPromtion(S, SCS2);
4302  if (FEP1 != FixedEnumPromotion::None && FEP2 != FixedEnumPromotion::None &&
4303      FEP1 != FEP2)
4304    return FEP1 == FixedEnumPromotion::ToUnderlyingType
4305               ? ImplicitConversionSequence::Better
4306               : ImplicitConversionSequence::Worse;
4307
4308  // C++ [over.ics.rank]p4b2:
4309  //
4310  //   If class B is derived directly or indirectly from class A,
4311  //   conversion of B* to A* is better than conversion of B* to
4312  //   void*, and conversion of A* to void* is better than conversion
4313  //   of B* to void*.
4314  bool SCS1ConvertsToVoid
4315    = SCS1.isPointerConversionToVoidPointer(S.Context);
4316  bool SCS2ConvertsToVoid
4317    = SCS2.isPointerConversionToVoidPointer(S.Context);
4318  if (SCS1ConvertsToVoid != SCS2ConvertsToVoid) {
4319    // Exactly one of the conversion sequences is a conversion to
4320    // a void pointer; it's the worse conversion.
4321    return SCS2ConvertsToVoid ? ImplicitConversionSequence::Better
4322                              : ImplicitConversionSequence::Worse;
4323  } else if (!SCS1ConvertsToVoid && !SCS2ConvertsToVoid) {
4324    // Neither conversion sequence converts to a void pointer; compare
4325    // their derived-to-base conversions.
4326    if (ImplicitConversionSequence::CompareKind DerivedCK
4327          = CompareDerivedToBaseConversions(S, Loc, SCS1, SCS2))
4328      return DerivedCK;
4329  } else if (SCS1ConvertsToVoid && SCS2ConvertsToVoid &&
4330             !S.Context.hasSameType(SCS1.getFromType(), SCS2.getFromType())) {
4331    // Both conversion sequences are conversions to void
4332    // pointers. Compare the source types to determine if there's an
4333    // inheritance relationship in their sources.
4334    QualType FromType1 = SCS1.getFromType();
4335    QualType FromType2 = SCS2.getFromType();
4336
4337    // Adjust the types we're converting from via the array-to-pointer
4338    // conversion, if we need to.
4339    if (SCS1.First == ICK_Array_To_Pointer)
4340      FromType1 = S.Context.getArrayDecayedType(FromType1);
4341    if (SCS2.First == ICK_Array_To_Pointer)
4342      FromType2 = S.Context.getArrayDecayedType(FromType2);
4343
4344    QualType FromPointee1 = FromType1->getPointeeType().getUnqualifiedType();
4345    QualType FromPointee2 = FromType2->getPointeeType().getUnqualifiedType();
4346
4347    if (S.IsDerivedFrom(Loc, FromPointee2, FromPointee1))
4348      return ImplicitConversionSequence::Better;
4349    else if (S.IsDerivedFrom(Loc, FromPointee1, FromPointee2))
4350      return ImplicitConversionSequence::Worse;
4351
4352    // Objective-C++: If one interface is more specific than the
4353    // other, it is the better one.
4354    const ObjCObjectPointerType* FromObjCPtr1
4355      = FromType1->getAs<ObjCObjectPointerType>();
4356    const ObjCObjectPointerType* FromObjCPtr2
4357      = FromType2->getAs<ObjCObjectPointerType>();
4358    if (FromObjCPtr1 && FromObjCPtr2) {
4359      bool AssignLeft = S.Context.canAssignObjCInterfaces(FromObjCPtr1,
4360                                                          FromObjCPtr2);
4361      bool AssignRight = S.Context.canAssignObjCInterfaces(FromObjCPtr2,
4362                                                           FromObjCPtr1);
4363      if (AssignLeft != AssignRight) {
4364        return AssignLeft? ImplicitConversionSequence::Better
4365                         : ImplicitConversionSequence::Worse;
4366      }
4367    }
4368  }
4369
4370  if (SCS1.ReferenceBinding && SCS2.ReferenceBinding) {
4371    // Check for a better reference binding based on the kind of bindings.
4372    if (isBetterReferenceBindingKind(SCS1, SCS2))
4373      return ImplicitConversionSequence::Better;
4374    else if (isBetterReferenceBindingKind(SCS2, SCS1))
4375      return ImplicitConversionSequence::Worse;
4376  }
4377
4378  // Compare based on qualification conversions (C++ 13.3.3.2p3,
4379  // bullet 3).
4380  if (ImplicitConversionSequence::CompareKind QualCK
4381        = CompareQualificationConversions(S, SCS1, SCS2))
4382    return QualCK;
4383
4384  if (SCS1.ReferenceBinding && SCS2.ReferenceBinding) {
4385    // C++ [over.ics.rank]p3b4:
4386    //   -- S1 and S2 are reference bindings (8.5.3), and the types to
4387    //      which the references refer are the same type except for
4388    //      top-level cv-qualifiers, and the type to which the reference
4389    //      initialized by S2 refers is more cv-qualified than the type
4390    //      to which the reference initialized by S1 refers.
4391    QualType T1 = SCS1.getToType(2);
4392    QualType T2 = SCS2.getToType(2);
4393    T1 = S.Context.getCanonicalType(T1);
4394    T2 = S.Context.getCanonicalType(T2);
4395    Qualifiers T1Quals, T2Quals;
4396    QualType UnqualT1 = S.Context.getUnqualifiedArrayType(T1, T1Quals);
4397    QualType UnqualT2 = S.Context.getUnqualifiedArrayType(T2, T2Quals);
4398    if (UnqualT1 == UnqualT2) {
4399      // Objective-C++ ARC: If the references refer to objects with different
4400      // lifetimes, prefer bindings that don't change lifetime.
4401      if (SCS1.ObjCLifetimeConversionBinding !=
4402                                          SCS2.ObjCLifetimeConversionBinding) {
4403        return SCS1.ObjCLifetimeConversionBinding
4404                                           ? ImplicitConversionSequence::Worse
4405                                           : ImplicitConversionSequence::Better;
4406      }
4407
4408      // If the type is an array type, promote the element qualifiers to the
4409      // type for comparison.
4410      if (isa<ArrayType>(T1) && T1Quals)
4411        T1 = S.Context.getQualifiedType(UnqualT1, T1Quals);
4412      if (isa<ArrayType>(T2) && T2Quals)
4413        T2 = S.Context.getQualifiedType(UnqualT2, T2Quals);
4414      if (T2.isMoreQualifiedThan(T1))
4415        return ImplicitConversionSequence::Better;
4416      if (T1.isMoreQualifiedThan(T2))
4417        return ImplicitConversionSequence::Worse;
4418    }
4419  }
4420
4421  // In Microsoft mode (below 19.28), prefer an integral conversion to a
4422  // floating-to-integral conversion if the integral conversion
4423  // is between types of the same size.
4424  // For example:
4425  // void f(float);
4426  // void f(int);
4427  // int main {
4428  //    long a;
4429  //    f(a);
4430  // }
4431  // Here, MSVC will call f(int) instead of generating a compile error
4432  // as clang will do in standard mode.
4433  if (S.getLangOpts().MSVCCompat &&
4434      !S.getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2019_8) &&
4435      SCS1.Second == ICK_Integral_Conversion &&
4436      SCS2.Second == ICK_Floating_Integral &&
4437      S.Context.getTypeSize(SCS1.getFromType()) ==
4438          S.Context.getTypeSize(SCS1.getToType(2)))
4439    return ImplicitConversionSequence::Better;
4440
4441  // Prefer a compatible vector conversion over a lax vector conversion
4442  // For example:
4443  //
4444  // typedef float __v4sf __attribute__((__vector_size__(16)));
4445  // void f(vector float);
4446  // void f(vector signed int);
4447  // int main() {
4448  //   __v4sf a;
4449  //   f(a);
4450  // }
4451  // Here, we'd like to choose f(vector float) and not
4452  // report an ambiguous call error
4453  if (SCS1.Second == ICK_Vector_Conversion &&
4454      SCS2.Second == ICK_Vector_Conversion) {
4455    bool SCS1IsCompatibleVectorConversion = S.Context.areCompatibleVectorTypes(
4456        SCS1.getFromType(), SCS1.getToType(2));
4457    bool SCS2IsCompatibleVectorConversion = S.Context.areCompatibleVectorTypes(
4458        SCS2.getFromType(), SCS2.getToType(2));
4459
4460    if (SCS1IsCompatibleVectorConversion != SCS2IsCompatibleVectorConversion)
4461      return SCS1IsCompatibleVectorConversion
4462                 ? ImplicitConversionSequence::Better
4463                 : ImplicitConversionSequence::Worse;
4464  }
4465
4466  if (SCS1.Second == ICK_SVE_Vector_Conversion &&
4467      SCS2.Second == ICK_SVE_Vector_Conversion) {
4468    bool SCS1IsCompatibleSVEVectorConversion =
4469        S.Context.areCompatibleSveTypes(SCS1.getFromType(), SCS1.getToType(2));
4470    bool SCS2IsCompatibleSVEVectorConversion =
4471        S.Context.areCompatibleSveTypes(SCS2.getFromType(), SCS2.getToType(2));
4472
4473    if (SCS1IsCompatibleSVEVectorConversion !=
4474        SCS2IsCompatibleSVEVectorConversion)
4475      return SCS1IsCompatibleSVEVectorConversion
4476                 ? ImplicitConversionSequence::Better
4477                 : ImplicitConversionSequence::Worse;
4478  }
4479
4480  if (SCS1.Second == ICK_RVV_Vector_Conversion &&
4481      SCS2.Second == ICK_RVV_Vector_Conversion) {
4482    bool SCS1IsCompatibleRVVVectorConversion =
4483        S.Context.areCompatibleRVVTypes(SCS1.getFromType(), SCS1.getToType(2));
4484    bool SCS2IsCompatibleRVVVectorConversion =
4485        S.Context.areCompatibleRVVTypes(SCS2.getFromType(), SCS2.getToType(2));
4486
4487    if (SCS1IsCompatibleRVVVectorConversion !=
4488        SCS2IsCompatibleRVVVectorConversion)
4489      return SCS1IsCompatibleRVVVectorConversion
4490                 ? ImplicitConversionSequence::Better
4491                 : ImplicitConversionSequence::Worse;
4492  }
4493
4494  return ImplicitConversionSequence::Indistinguishable;
4495}
4496
4497/// CompareQualificationConversions - Compares two standard conversion
4498/// sequences to determine whether they can be ranked based on their
4499/// qualification conversions (C++ 13.3.3.2p3 bullet 3).
4500static ImplicitConversionSequence::CompareKind
4501CompareQualificationConversions(Sema &S,
4502                                const StandardConversionSequence& SCS1,
4503                                const StandardConversionSequence& SCS2) {
4504  // C++ [over.ics.rank]p3:
4505  //  -- S1 and S2 differ only in their qualification conversion and
4506  //     yield similar types T1 and T2 (C++ 4.4), respectively, [...]
4507  // [C++98]
4508  //     [...] and the cv-qualification signature of type T1 is a proper subset
4509  //     of the cv-qualification signature of type T2, and S1 is not the
4510  //     deprecated string literal array-to-pointer conversion (4.2).
4511  // [C++2a]
4512  //     [...] where T1 can be converted to T2 by a qualification conversion.
4513  if (SCS1.First != SCS2.First || SCS1.Second != SCS2.Second ||
4514      SCS1.Third != SCS2.Third || SCS1.Third != ICK_Qualification)
4515    return ImplicitConversionSequence::Indistinguishable;
4516
4517  // FIXME: the example in the standard doesn't use a qualification
4518  // conversion (!)
4519  QualType T1 = SCS1.getToType(2);
4520  QualType T2 = SCS2.getToType(2);
4521  T1 = S.Context.getCanonicalType(T1);
4522  T2 = S.Context.getCanonicalType(T2);
4523  assert(!T1->isReferenceType() && !T2->isReferenceType());
4524  Qualifiers T1Quals, T2Quals;
4525  QualType UnqualT1 = S.Context.getUnqualifiedArrayType(T1, T1Quals);
4526  QualType UnqualT2 = S.Context.getUnqualifiedArrayType(T2, T2Quals);
4527
4528  // If the types are the same, we won't learn anything by unwrapping
4529  // them.
4530  if (UnqualT1 == UnqualT2)
4531    return ImplicitConversionSequence::Indistinguishable;
4532
4533  // Don't ever prefer a standard conversion sequence that uses the deprecated
4534  // string literal array to pointer conversion.
4535  bool CanPick1 = !SCS1.DeprecatedStringLiteralToCharPtr;
4536  bool CanPick2 = !SCS2.DeprecatedStringLiteralToCharPtr;
4537
4538  // Objective-C++ ARC:
4539  //   Prefer qualification conversions not involving a change in lifetime
4540  //   to qualification conversions that do change lifetime.
4541  if (SCS1.QualificationIncludesObjCLifetime &&
4542      !SCS2.QualificationIncludesObjCLifetime)
4543    CanPick1 = false;
4544  if (SCS2.QualificationIncludesObjCLifetime &&
4545      !SCS1.QualificationIncludesObjCLifetime)
4546    CanPick2 = false;
4547
4548  bool ObjCLifetimeConversion;
4549  if (CanPick1 &&
4550      !S.IsQualificationConversion(T1, T2, false, ObjCLifetimeConversion))
4551    CanPick1 = false;
4552  // FIXME: In Objective-C ARC, we can have qualification conversions in both
4553  // directions, so we can't short-cut this second check in general.
4554  if (CanPick2 &&
4555      !S.IsQualificationConversion(T2, T1, false, ObjCLifetimeConversion))
4556    CanPick2 = false;
4557
4558  if (CanPick1 != CanPick2)
4559    return CanPick1 ? ImplicitConversionSequence::Better
4560                    : ImplicitConversionSequence::Worse;
4561  return ImplicitConversionSequence::Indistinguishable;
4562}
4563
4564/// CompareDerivedToBaseConversions - Compares two standard conversion
4565/// sequences to determine whether they can be ranked based on their
4566/// various kinds of derived-to-base conversions (C++
4567/// [over.ics.rank]p4b3).  As part of these checks, we also look at
4568/// conversions between Objective-C interface types.
4569static ImplicitConversionSequence::CompareKind
4570CompareDerivedToBaseConversions(Sema &S, SourceLocation Loc,
4571                                const StandardConversionSequence& SCS1,
4572                                const StandardConversionSequence& SCS2) {
4573  QualType FromType1 = SCS1.getFromType();
4574  QualType ToType1 = SCS1.getToType(1);
4575  QualType FromType2 = SCS2.getFromType();
4576  QualType ToType2 = SCS2.getToType(1);
4577
4578  // Adjust the types we're converting from via the array-to-pointer
4579  // conversion, if we need to.
4580  if (SCS1.First == ICK_Array_To_Pointer)
4581    FromType1 = S.Context.getArrayDecayedType(FromType1);
4582  if (SCS2.First == ICK_Array_To_Pointer)
4583    FromType2 = S.Context.getArrayDecayedType(FromType2);
4584
4585  // Canonicalize all of the types.
4586  FromType1 = S.Context.getCanonicalType(FromType1);
4587  ToType1 = S.Context.getCanonicalType(ToType1);
4588  FromType2 = S.Context.getCanonicalType(FromType2);
4589  ToType2 = S.Context.getCanonicalType(ToType2);
4590
4591  // C++ [over.ics.rank]p4b3:
4592  //
4593  //   If class B is derived directly or indirectly from class A and
4594  //   class C is derived directly or indirectly from B,
4595  //
4596  // Compare based on pointer conversions.
4597  if (SCS1.Second == ICK_Pointer_Conversion &&
4598      SCS2.Second == ICK_Pointer_Conversion &&
4599      /*FIXME: Remove if Objective-C id conversions get their own rank*/
4600      FromType1->isPointerType() && FromType2->isPointerType() &&
4601      ToType1->isPointerType() && ToType2->isPointerType()) {
4602    QualType FromPointee1 =
4603        FromType1->castAs<PointerType>()->getPointeeType().getUnqualifiedType();
4604    QualType ToPointee1 =
4605        ToType1->castAs<PointerType>()->getPointeeType().getUnqualifiedType();
4606    QualType FromPointee2 =
4607        FromType2->castAs<PointerType>()->getPointeeType().getUnqualifiedType();
4608    QualType ToPointee2 =
4609        ToType2->castAs<PointerType>()->getPointeeType().getUnqualifiedType();
4610
4611    //   -- conversion of C* to B* is better than conversion of C* to A*,
4612    if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
4613      if (S.IsDerivedFrom(Loc, ToPointee1, ToPointee2))
4614        return ImplicitConversionSequence::Better;
4615      else if (S.IsDerivedFrom(Loc, ToPointee2, ToPointee1))
4616        return ImplicitConversionSequence::Worse;
4617    }
4618
4619    //   -- conversion of B* to A* is better than conversion of C* to A*,
4620    if (FromPointee1 != FromPointee2 && ToPointee1 == ToPointee2) {
4621      if (S.IsDerivedFrom(Loc, FromPointee2, FromPointee1))
4622        return ImplicitConversionSequence::Better;
4623      else if (S.IsDerivedFrom(Loc, FromPointee1, FromPointee2))
4624        return ImplicitConversionSequence::Worse;
4625    }
4626  } else if (SCS1.Second == ICK_Pointer_Conversion &&
4627             SCS2.Second == ICK_Pointer_Conversion) {
4628    const ObjCObjectPointerType *FromPtr1
4629      = FromType1->getAs<ObjCObjectPointerType>();
4630    const ObjCObjectPointerType *FromPtr2
4631      = FromType2->getAs<ObjCObjectPointerType>();
4632    const ObjCObjectPointerType *ToPtr1
4633      = ToType1->getAs<ObjCObjectPointerType>();
4634    const ObjCObjectPointerType *ToPtr2
4635      = ToType2->getAs<ObjCObjectPointerType>();
4636
4637    if (FromPtr1 && FromPtr2 && ToPtr1 && ToPtr2) {
4638      // Apply the same conversion ranking rules for Objective-C pointer types
4639      // that we do for C++ pointers to class types. However, we employ the
4640      // Objective-C pseudo-subtyping relationship used for assignment of
4641      // Objective-C pointer types.
4642      bool FromAssignLeft
4643        = S.Context.canAssignObjCInterfaces(FromPtr1, FromPtr2);
4644      bool FromAssignRight
4645        = S.Context.canAssignObjCInterfaces(FromPtr2, FromPtr1);
4646      bool ToAssignLeft
4647        = S.Context.canAssignObjCInterfaces(ToPtr1, ToPtr2);
4648      bool ToAssignRight
4649        = S.Context.canAssignObjCInterfaces(ToPtr2, ToPtr1);
4650
4651      // A conversion to an a non-id object pointer type or qualified 'id'
4652      // type is better than a conversion to 'id'.
4653      if (ToPtr1->isObjCIdType() &&
4654          (ToPtr2->isObjCQualifiedIdType() || ToPtr2->getInterfaceDecl()))
4655        return ImplicitConversionSequence::Worse;
4656      if (ToPtr2->isObjCIdType() &&
4657          (ToPtr1->isObjCQualifiedIdType() || ToPtr1->getInterfaceDecl()))
4658        return ImplicitConversionSequence::Better;
4659
4660      // A conversion to a non-id object pointer type is better than a
4661      // conversion to a qualified 'id' type
4662      if (ToPtr1->isObjCQualifiedIdType() && ToPtr2->getInterfaceDecl())
4663        return ImplicitConversionSequence::Worse;
4664      if (ToPtr2->isObjCQualifiedIdType() && ToPtr1->getInterfaceDecl())
4665        return ImplicitConversionSequence::Better;
4666
4667      // A conversion to an a non-Class object pointer type or qualified 'Class'
4668      // type is better than a conversion to 'Class'.
4669      if (ToPtr1->isObjCClassType() &&
4670          (ToPtr2->isObjCQualifiedClassType() || ToPtr2->getInterfaceDecl()))
4671        return ImplicitConversionSequence::Worse;
4672      if (ToPtr2->isObjCClassType() &&
4673          (ToPtr1->isObjCQualifiedClassType() || ToPtr1->getInterfaceDecl()))
4674        return ImplicitConversionSequence::Better;
4675
4676      // A conversion to a non-Class object pointer type is better than a
4677      // conversion to a qualified 'Class' type.
4678      if (ToPtr1->isObjCQualifiedClassType() && ToPtr2->getInterfaceDecl())
4679        return ImplicitConversionSequence::Worse;
4680      if (ToPtr2->isObjCQualifiedClassType() && ToPtr1->getInterfaceDecl())
4681        return ImplicitConversionSequence::Better;
4682
4683      //   -- "conversion of C* to B* is better than conversion of C* to A*,"
4684      if (S.Context.hasSameType(FromType1, FromType2) &&
4685          !FromPtr1->isObjCIdType() && !FromPtr1->isObjCClassType() &&
4686          (ToAssignLeft != ToAssignRight)) {
4687        if (FromPtr1->isSpecialized()) {
4688          // "conversion of B<A> * to B * is better than conversion of B * to
4689          // C *.
4690          bool IsFirstSame =
4691              FromPtr1->getInterfaceDecl() == ToPtr1->getInterfaceDecl();
4692          bool IsSecondSame =
4693              FromPtr1->getInterfaceDecl() == ToPtr2->getInterfaceDecl();
4694          if (IsFirstSame) {
4695            if (!IsSecondSame)
4696              return ImplicitConversionSequence::Better;
4697          } else if (IsSecondSame)
4698            return ImplicitConversionSequence::Worse;
4699        }
4700        return ToAssignLeft? ImplicitConversionSequence::Worse
4701                           : ImplicitConversionSequence::Better;
4702      }
4703
4704      //   -- "conversion of B* to A* is better than conversion of C* to A*,"
4705      if (S.Context.hasSameUnqualifiedType(ToType1, ToType2) &&
4706          (FromAssignLeft != FromAssignRight))
4707        return FromAssignLeft? ImplicitConversionSequence::Better
4708        : ImplicitConversionSequence::Worse;
4709    }
4710  }
4711
4712  // Ranking of member-pointer types.
4713  if (SCS1.Second == ICK_Pointer_Member && SCS2.Second == ICK_Pointer_Member &&
4714      FromType1->isMemberPointerType() && FromType2->isMemberPointerType() &&
4715      ToType1->isMemberPointerType() && ToType2->isMemberPointerType()) {
4716    const auto *FromMemPointer1 = FromType1->castAs<MemberPointerType>();
4717    const auto *ToMemPointer1 = ToType1->castAs<MemberPointerType>();
4718    const auto *FromMemPointer2 = FromType2->castAs<MemberPointerType>();
4719    const auto *ToMemPointer2 = ToType2->castAs<MemberPointerType>();
4720    const Type *FromPointeeType1 = FromMemPointer1->getClass();
4721    const Type *ToPointeeType1 = ToMemPointer1->getClass();
4722    const Type *FromPointeeType2 = FromMemPointer2->getClass();
4723    const Type *ToPointeeType2 = ToMemPointer2->getClass();
4724    QualType FromPointee1 = QualType(FromPointeeType1, 0).getUnqualifiedType();
4725    QualType ToPointee1 = QualType(ToPointeeType1, 0).getUnqualifiedType();
4726    QualType FromPointee2 = QualType(FromPointeeType2, 0).getUnqualifiedType();
4727    QualType ToPointee2 = QualType(ToPointeeType2, 0).getUnqualifiedType();
4728    // conversion of A::* to B::* is better than conversion of A::* to C::*,
4729    if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
4730      if (S.IsDerivedFrom(Loc, ToPointee1, ToPointee2))
4731        return ImplicitConversionSequence::Worse;
4732      else if (S.IsDerivedFrom(Loc, ToPointee2, ToPointee1))
4733        return ImplicitConversionSequence::Better;
4734    }
4735    // conversion of B::* to C::* is better than conversion of A::* to C::*
4736    if (ToPointee1 == ToPointee2 && FromPointee1 != FromPointee2) {
4737      if (S.IsDerivedFrom(Loc, FromPointee1, FromPointee2))
4738        return ImplicitConversionSequence::Better;
4739      else if (S.IsDerivedFrom(Loc, FromPointee2, FromPointee1))
4740        return ImplicitConversionSequence::Worse;
4741    }
4742  }
4743
4744  if (SCS1.Second == ICK_Derived_To_Base) {
4745    //   -- conversion of C to B is better than conversion of C to A,
4746    //   -- binding of an expression of type C to a reference of type
4747    //      B& is better than binding an expression of type C to a
4748    //      reference of type A&,
4749    if (S.Context.hasSameUnqualifiedType(FromType1, FromType2) &&
4750        !S.Context.hasSameUnqualifiedType(ToType1, ToType2)) {
4751      if (S.IsDerivedFrom(Loc, ToType1, ToType2))
4752        return ImplicitConversionSequence::Better;
4753      else if (S.IsDerivedFrom(Loc, ToType2, ToType1))
4754        return ImplicitConversionSequence::Worse;
4755    }
4756
4757    //   -- conversion of B to A is better than conversion of C to A.
4758    //   -- binding of an expression of type B to a reference of type
4759    //      A& is better than binding an expression of type C to a
4760    //      reference of type A&,
4761    if (!S.Context.hasSameUnqualifiedType(FromType1, FromType2) &&
4762        S.Context.hasSameUnqualifiedType(ToType1, ToType2)) {
4763      if (S.IsDerivedFrom(Loc, FromType2, FromType1))
4764        return ImplicitConversionSequence::Better;
4765      else if (S.IsDerivedFrom(Loc, FromType1, FromType2))
4766        return ImplicitConversionSequence::Worse;
4767    }
4768  }
4769
4770  return ImplicitConversionSequence::Indistinguishable;
4771}
4772
4773static QualType withoutUnaligned(ASTContext &Ctx, QualType T) {
4774  if (!T.getQualifiers().hasUnaligned())
4775    return T;
4776
4777  Qualifiers Q;
4778  T = Ctx.getUnqualifiedArrayType(T, Q);
4779  Q.removeUnaligned();
4780  return Ctx.getQualifiedType(T, Q);
4781}
4782
4783/// CompareReferenceRelationship - Compare the two types T1 and T2 to
4784/// determine whether they are reference-compatible,
4785/// reference-related, or incompatible, for use in C++ initialization by
4786/// reference (C++ [dcl.ref.init]p4). Neither type can be a reference
4787/// type, and the first type (T1) is the pointee type of the reference
4788/// type being initialized.
4789Sema::ReferenceCompareResult
4790Sema::CompareReferenceRelationship(SourceLocation Loc,
4791                                   QualType OrigT1, QualType OrigT2,
4792                                   ReferenceConversions *ConvOut) {
4793  assert(!OrigT1->isReferenceType() &&
4794    "T1 must be the pointee type of the reference type");
4795  assert(!OrigT2->isReferenceType() && "T2 cannot be a reference type");
4796
4797  QualType T1 = Context.getCanonicalType(OrigT1);
4798  QualType T2 = Context.getCanonicalType(OrigT2);
4799  Qualifiers T1Quals, T2Quals;
4800  QualType UnqualT1 = Context.getUnqualifiedArrayType(T1, T1Quals);
4801  QualType UnqualT2 = Context.getUnqualifiedArrayType(T2, T2Quals);
4802
4803  ReferenceConversions ConvTmp;
4804  ReferenceConversions &Conv = ConvOut ? *ConvOut : ConvTmp;
4805  Conv = ReferenceConversions();
4806
4807  // C++2a [dcl.init.ref]p4:
4808  //   Given types "cv1 T1" and "cv2 T2," "cv1 T1" is
4809  //   reference-related to "cv2 T2" if T1 is similar to T2, or
4810  //   T1 is a base class of T2.
4811  //   "cv1 T1" is reference-compatible with "cv2 T2" if
4812  //   a prvalue of type "pointer to cv2 T2" can be converted to the type
4813  //   "pointer to cv1 T1" via a standard conversion sequence.
4814
4815  // Check for standard conversions we can apply to pointers: derived-to-base
4816  // conversions, ObjC pointer conversions, and function pointer conversions.
4817  // (Qualification conversions are checked last.)
4818  QualType ConvertedT2;
4819  if (UnqualT1 == UnqualT2) {
4820    // Nothing to do.
4821  } else if (isCompleteType(Loc, OrigT2) &&
4822             IsDerivedFrom(Loc, UnqualT2, UnqualT1))
4823    Conv |= ReferenceConversions::DerivedToBase;
4824  else if (UnqualT1->isObjCObjectOrInterfaceType() &&
4825           UnqualT2->isObjCObjectOrInterfaceType() &&
4826           Context.canBindObjCObjectType(UnqualT1, UnqualT2))
4827    Conv |= ReferenceConversions::ObjC;
4828  else if (UnqualT2->isFunctionType() &&
4829           IsFunctionConversion(UnqualT2, UnqualT1, ConvertedT2)) {
4830    Conv |= ReferenceConversions::Function;
4831    // No need to check qualifiers; function types don't have them.
4832    return Ref_Compatible;
4833  }
4834  bool ConvertedReferent = Conv != 0;
4835
4836  // We can have a qualification conversion. Compute whether the types are
4837  // similar at the same time.
4838  bool PreviousToQualsIncludeConst = true;
4839  bool TopLevel = true;
4840  do {
4841    if (T1 == T2)
4842      break;
4843
4844    // We will need a qualification conversion.
4845    Conv |= ReferenceConversions::Qualification;
4846
4847    // Track whether we performed a qualification conversion anywhere other
4848    // than the top level. This matters for ranking reference bindings in
4849    // overload resolution.
4850    if (!TopLevel)
4851      Conv |= ReferenceConversions::NestedQualification;
4852
4853    // MS compiler ignores __unaligned qualifier for references; do the same.
4854    T1 = withoutUnaligned(Context, T1);
4855    T2 = withoutUnaligned(Context, T2);
4856
4857    // If we find a qualifier mismatch, the types are not reference-compatible,
4858    // but are still be reference-related if they're similar.
4859    bool ObjCLifetimeConversion = false;
4860    if (!isQualificationConversionStep(T2, T1, /*CStyle=*/false, TopLevel,
4861                                       PreviousToQualsIncludeConst,
4862                                       ObjCLifetimeConversion))
4863      return (ConvertedReferent || Context.hasSimilarType(T1, T2))
4864                 ? Ref_Related
4865                 : Ref_Incompatible;
4866
4867    // FIXME: Should we track this for any level other than the first?
4868    if (ObjCLifetimeConversion)
4869      Conv |= ReferenceConversions::ObjCLifetime;
4870
4871    TopLevel = false;
4872  } while (Context.UnwrapSimilarTypes(T1, T2));
4873
4874  // At this point, if the types are reference-related, we must either have the
4875  // same inner type (ignoring qualifiers), or must have already worked out how
4876  // to convert the referent.
4877  return (ConvertedReferent || Context.hasSameUnqualifiedType(T1, T2))
4878             ? Ref_Compatible
4879             : Ref_Incompatible;
4880}
4881
4882/// Look for a user-defined conversion to a value reference-compatible
4883///        with DeclType. Return true if something definite is found.
4884static bool
4885FindConversionForRefInit(Sema &S, ImplicitConversionSequence &ICS,
4886                         QualType DeclType, SourceLocation DeclLoc,
4887                         Expr *Init, QualType T2, bool AllowRvalues,
4888                         bool AllowExplicit) {
4889  assert(T2->isRecordType() && "Can only find conversions of record types.");
4890  auto *T2RecordDecl = cast<CXXRecordDecl>(T2->castAs<RecordType>()->getDecl());
4891
4892  OverloadCandidateSet CandidateSet(
4893      DeclLoc, OverloadCandidateSet::CSK_InitByUserDefinedConversion);
4894  const auto &Conversions = T2RecordDecl->getVisibleConversionFunctions();
4895  for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
4896    NamedDecl *D = *I;
4897    CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
4898    if (isa<UsingShadowDecl>(D))
4899      D = cast<UsingShadowDecl>(D)->getTargetDecl();
4900
4901    FunctionTemplateDecl *ConvTemplate
4902      = dyn_cast<FunctionTemplateDecl>(D);
4903    CXXConversionDecl *Conv;
4904    if (ConvTemplate)
4905      Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
4906    else
4907      Conv = cast<CXXConversionDecl>(D);
4908
4909    if (AllowRvalues) {
4910      // If we are initializing an rvalue reference, don't permit conversion
4911      // functions that return lvalues.
4912      if (!ConvTemplate && DeclType->isRValueReferenceType()) {
4913        const ReferenceType *RefType
4914          = Conv->getConversionType()->getAs<LValueReferenceType>();
4915        if (RefType && !RefType->getPointeeType()->isFunctionType())
4916          continue;
4917      }
4918
4919      if (!ConvTemplate &&
4920          S.CompareReferenceRelationship(
4921              DeclLoc,
4922              Conv->getConversionType()
4923                  .getNonReferenceType()
4924                  .getUnqualifiedType(),
4925              DeclType.getNonReferenceType().getUnqualifiedType()) ==
4926              Sema::Ref_Incompatible)
4927        continue;
4928    } else {
4929      // If the conversion function doesn't return a reference type,
4930      // it can't be considered for this conversion. An rvalue reference
4931      // is only acceptable if its referencee is a function type.
4932
4933      const ReferenceType *RefType =
4934        Conv->getConversionType()->getAs<ReferenceType>();
4935      if (!RefType ||
4936          (!RefType->isLValueReferenceType() &&
4937           !RefType->getPointeeType()->isFunctionType()))
4938        continue;
4939    }
4940
4941    if (ConvTemplate)
4942      S.AddTemplateConversionCandidate(
4943          ConvTemplate, I.getPair(), ActingDC, Init, DeclType, CandidateSet,
4944          /*AllowObjCConversionOnExplicit=*/false, AllowExplicit);
4945    else
4946      S.AddConversionCandidate(
4947          Conv, I.getPair(), ActingDC, Init, DeclType, CandidateSet,
4948          /*AllowObjCConversionOnExplicit=*/false, AllowExplicit);
4949  }
4950
4951  bool HadMultipleCandidates = (CandidateSet.size() > 1);
4952
4953  OverloadCandidateSet::iterator Best;
4954  switch (CandidateSet.BestViableFunction(S, DeclLoc, Best)) {
4955  case OR_Success:
4956    // C++ [over.ics.ref]p1:
4957    //
4958    //   [...] If the parameter binds directly to the result of
4959    //   applying a conversion function to the argument
4960    //   expression, the implicit conversion sequence is a
4961    //   user-defined conversion sequence (13.3.3.1.2), with the
4962    //   second standard conversion sequence either an identity
4963    //   conversion or, if the conversion function returns an
4964    //   entity of a type that is a derived class of the parameter
4965    //   type, a derived-to-base Conversion.
4966    if (!Best->FinalConversion.DirectBinding)
4967      return false;
4968
4969    ICS.setUserDefined();
4970    ICS.UserDefined.Before = Best->Conversions[0].Standard;
4971    ICS.UserDefined.After = Best->FinalConversion;
4972    ICS.UserDefined.HadMultipleCandidates = HadMultipleCandidates;
4973    ICS.UserDefined.ConversionFunction = Best->Function;
4974    ICS.UserDefined.FoundConversionFunction = Best->FoundDecl;
4975    ICS.UserDefined.EllipsisConversion = false;
4976    assert(ICS.UserDefined.After.ReferenceBinding &&
4977           ICS.UserDefined.After.DirectBinding &&
4978           "Expected a direct reference binding!");
4979    return true;
4980
4981  case OR_Ambiguous:
4982    ICS.setAmbiguous();
4983    for (OverloadCandidateSet::iterator Cand = CandidateSet.begin();
4984         Cand != CandidateSet.end(); ++Cand)
4985      if (Cand->Best)
4986        ICS.Ambiguous.addConversion(Cand->FoundDecl, Cand->Function);
4987    return true;
4988
4989  case OR_No_Viable_Function:
4990  case OR_Deleted:
4991    // There was no suitable conversion, or we found a deleted
4992    // conversion; continue with other checks.
4993    return false;
4994  }
4995
4996  llvm_unreachable("Invalid OverloadResult!");
4997}
4998
4999/// Compute an implicit conversion sequence for reference
5000/// initialization.
5001static ImplicitConversionSequence
5002TryReferenceInit(Sema &S, Expr *Init, QualType DeclType,
5003                 SourceLocation DeclLoc,
5004                 bool SuppressUserConversions,
5005                 bool AllowExplicit) {
5006  assert(DeclType->isReferenceType() && "Reference init needs a reference");
5007
5008  // Most paths end in a failed conversion.
5009  ImplicitConversionSequence ICS;
5010  ICS.setBad(BadConversionSequence::no_conversion, Init, DeclType);
5011
5012  QualType T1 = DeclType->castAs<ReferenceType>()->getPointeeType();
5013  QualType T2 = Init->getType();
5014
5015  // If the initializer is the address of an overloaded function, try
5016  // to resolve the overloaded function. If all goes well, T2 is the
5017  // type of the resulting function.
5018  if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) {
5019    DeclAccessPair Found;
5020    if (FunctionDecl *Fn = S.ResolveAddressOfOverloadedFunction(Init, DeclType,
5021                                                                false, Found))
5022      T2 = Fn->getType();
5023  }
5024
5025  // Compute some basic properties of the types and the initializer.
5026  bool isRValRef = DeclType->isRValueReferenceType();
5027  Expr::Classification InitCategory = Init->Classify(S.Context);
5028
5029  Sema::ReferenceConversions RefConv;
5030  Sema::ReferenceCompareResult RefRelationship =
5031      S.CompareReferenceRelationship(DeclLoc, T1, T2, &RefConv);
5032
5033  auto SetAsReferenceBinding = [&](bool BindsDirectly) {
5034    ICS.setStandard();
5035    ICS.Standard.First = ICK_Identity;
5036    // FIXME: A reference binding can be a function conversion too. We should
5037    // consider that when ordering reference-to-function bindings.
5038    ICS.Standard.Second = (RefConv & Sema::ReferenceConversions::DerivedToBase)
5039                              ? ICK_Derived_To_Base
5040                              : (RefConv & Sema::ReferenceConversions::ObjC)
5041                                    ? ICK_Compatible_Conversion
5042                                    : ICK_Identity;
5043    // FIXME: As a speculative fix to a defect introduced by CWG2352, we rank
5044    // a reference binding that performs a non-top-level qualification
5045    // conversion as a qualification conversion, not as an identity conversion.
5046    ICS.Standard.Third = (RefConv &
5047                              Sema::ReferenceConversions::NestedQualification)
5048                             ? ICK_Qualification
5049                             : ICK_Identity;
5050    ICS.Standard.setFromType(T2);
5051    ICS.Standard.setToType(0, T2);
5052    ICS.Standard.setToType(1, T1);
5053    ICS.Standard.setToType(2, T1);
5054    ICS.Standard.ReferenceBinding = true;
5055    ICS.Standard.DirectBinding = BindsDirectly;
5056    ICS.Standard.IsLvalueReference = !isRValRef;
5057    ICS.Standard.BindsToFunctionLvalue = T2->isFunctionType();
5058    ICS.Standard.BindsToRvalue = InitCategory.isRValue();
5059    ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false;
5060    ICS.Standard.ObjCLifetimeConversionBinding =
5061        (RefConv & Sema::ReferenceConversions::ObjCLifetime) != 0;
5062    ICS.Standard.CopyConstructor = nullptr;
5063    ICS.Standard.DeprecatedStringLiteralToCharPtr = false;
5064  };
5065
5066  // C++0x [dcl.init.ref]p5:
5067  //   A reference to type "cv1 T1" is initialized by an expression
5068  //   of type "cv2 T2" as follows:
5069
5070  //     -- If reference is an lvalue reference and the initializer expression
5071  if (!isRValRef) {
5072    //     -- is an lvalue (but is not a bit-field), and "cv1 T1" is
5073    //        reference-compatible with "cv2 T2," or
5074    //
5075    // Per C++ [over.ics.ref]p4, we don't check the bit-field property here.
5076    if (InitCategory.isLValue() && RefRelationship == Sema::Ref_Compatible) {
5077      // C++ [over.ics.ref]p1:
5078      //   When a parameter of reference type binds directly (8.5.3)
5079      //   to an argument expression, the implicit conversion sequence
5080      //   is the identity conversion, unless the argument expression
5081      //   has a type that is a derived class of the parameter type,
5082      //   in which case the implicit conversion sequence is a
5083      //   derived-to-base Conversion (13.3.3.1).
5084      SetAsReferenceBinding(/*BindsDirectly=*/true);
5085
5086      // Nothing more to do: the inaccessibility/ambiguity check for
5087      // derived-to-base conversions is suppressed when we're
5088      // computing the implicit conversion sequence (C++
5089      // [over.best.ics]p2).
5090      return ICS;
5091    }
5092
5093    //       -- has a class type (i.e., T2 is a class type), where T1 is
5094    //          not reference-related to T2, and can be implicitly
5095    //          converted to an lvalue of type "cv3 T3," where "cv1 T1"
5096    //          is reference-compatible with "cv3 T3" 92) (this
5097    //          conversion is selected by enumerating the applicable
5098    //          conversion functions (13.3.1.6) and choosing the best
5099    //          one through overload resolution (13.3)),
5100    if (!SuppressUserConversions && T2->isRecordType() &&
5101        S.isCompleteType(DeclLoc, T2) &&
5102        RefRelationship == Sema::Ref_Incompatible) {
5103      if (FindConversionForRefInit(S, ICS, DeclType, DeclLoc,
5104                                   Init, T2, /*AllowRvalues=*/false,
5105                                   AllowExplicit))
5106        return ICS;
5107    }
5108  }
5109
5110  //     -- Otherwise, the reference shall be an lvalue reference to a
5111  //        non-volatile const type (i.e., cv1 shall be const), or the reference
5112  //        shall be an rvalue reference.
5113  if (!isRValRef && (!T1.isConstQualified() || T1.isVolatileQualified())) {
5114    if (InitCategory.isRValue() && RefRelationship != Sema::Ref_Incompatible)
5115      ICS.setBad(BadConversionSequence::lvalue_ref_to_rvalue, Init, DeclType);
5116    return ICS;
5117  }
5118
5119  //       -- If the initializer expression
5120  //
5121  //            -- is an xvalue, class prvalue, array prvalue or function
5122  //               lvalue and "cv1 T1" is reference-compatible with "cv2 T2", or
5123  if (RefRelationship == Sema::Ref_Compatible &&
5124      (InitCategory.isXValue() ||
5125       (InitCategory.isPRValue() &&
5126          (T2->isRecordType() || T2->isArrayType())) ||
5127       (InitCategory.isLValue() && T2->isFunctionType()))) {
5128    // In C++11, this is always a direct binding. In C++98/03, it's a direct
5129    // binding unless we're binding to a class prvalue.
5130    // Note: Although xvalues wouldn't normally show up in C++98/03 code, we
5131    // allow the use of rvalue references in C++98/03 for the benefit of
5132    // standard library implementors; therefore, we need the xvalue check here.
5133    SetAsReferenceBinding(/*BindsDirectly=*/S.getLangOpts().CPlusPlus11 ||
5134                          !(InitCategory.isPRValue() || T2->isRecordType()));
5135    return ICS;
5136  }
5137
5138  //            -- has a class type (i.e., T2 is a class type), where T1 is not
5139  //               reference-related to T2, and can be implicitly converted to
5140  //               an xvalue, class prvalue, or function lvalue of type
5141  //               "cv3 T3", where "cv1 T1" is reference-compatible with
5142  //               "cv3 T3",
5143  //
5144  //          then the reference is bound to the value of the initializer
5145  //          expression in the first case and to the result of the conversion
5146  //          in the second case (or, in either case, to an appropriate base
5147  //          class subobject).
5148  if (!SuppressUserConversions && RefRelationship == Sema::Ref_Incompatible &&
5149      T2->isRecordType() && S.isCompleteType(DeclLoc, T2) &&
5150      FindConversionForRefInit(S, ICS, DeclType, DeclLoc,
5151                               Init, T2, /*AllowRvalues=*/true,
5152                               AllowExplicit)) {
5153    // In the second case, if the reference is an rvalue reference
5154    // and the second standard conversion sequence of the
5155    // user-defined conversion sequence includes an lvalue-to-rvalue
5156    // conversion, the program is ill-formed.
5157    if (ICS.isUserDefined() && isRValRef &&
5158        ICS.UserDefined.After.First == ICK_Lvalue_To_Rvalue)
5159      ICS.setBad(BadConversionSequence::no_conversion, Init, DeclType);
5160
5161    return ICS;
5162  }
5163
5164  // A temporary of function type cannot be created; don't even try.
5165  if (T1->isFunctionType())
5166    return ICS;
5167
5168  //       -- Otherwise, a temporary of type "cv1 T1" is created and
5169  //          initialized from the initializer expression using the
5170  //          rules for a non-reference copy initialization (8.5). The
5171  //          reference is then bound to the temporary. If T1 is
5172  //          reference-related to T2, cv1 must be the same
5173  //          cv-qualification as, or greater cv-qualification than,
5174  //          cv2; otherwise, the program is ill-formed.
5175  if (RefRelationship == Sema::Ref_Related) {
5176    // If cv1 == cv2 or cv1 is a greater cv-qualified than cv2, then
5177    // we would be reference-compatible or reference-compatible with
5178    // added qualification. But that wasn't the case, so the reference
5179    // initialization fails.
5180    //
5181    // Note that we only want to check address spaces and cvr-qualifiers here.
5182    // ObjC GC, lifetime and unaligned qualifiers aren't important.
5183    Qualifiers T1Quals = T1.getQualifiers();
5184    Qualifiers T2Quals = T2.getQualifiers();
5185    T1Quals.removeObjCGCAttr();
5186    T1Quals.removeObjCLifetime();
5187    T2Quals.removeObjCGCAttr();
5188    T2Quals.removeObjCLifetime();
5189    // MS compiler ignores __unaligned qualifier for references; do the same.
5190    T1Quals.removeUnaligned();
5191    T2Quals.removeUnaligned();
5192    if (!T1Quals.compatiblyIncludes(T2Quals))
5193      return ICS;
5194  }
5195
5196  // If at least one of the types is a class type, the types are not
5197  // related, and we aren't allowed any user conversions, the
5198  // reference binding fails. This case is important for breaking
5199  // recursion, since TryImplicitConversion below will attempt to
5200  // create a temporary through the use of a copy constructor.
5201  if (SuppressUserConversions && RefRelationship == Sema::Ref_Incompatible &&
5202      (T1->isRecordType() || T2->isRecordType()))
5203    return ICS;
5204
5205  // If T1 is reference-related to T2 and the reference is an rvalue
5206  // reference, the initializer expression shall not be an lvalue.
5207  if (RefRelationship >= Sema::Ref_Related && isRValRef &&
5208      Init->Classify(S.Context).isLValue()) {
5209    ICS.setBad(BadConversionSequence::rvalue_ref_to_lvalue, Init, DeclType);
5210    return ICS;
5211  }
5212
5213  // C++ [over.ics.ref]p2:
5214  //   When a parameter of reference type is not bound directly to
5215  //   an argument expression, the conversion sequence is the one
5216  //   required to convert the argument expression to the
5217  //   underlying type of the reference according to
5218  //   13.3.3.1. Conceptually, this conversion sequence corresponds
5219  //   to copy-initializing a temporary of the underlying type with
5220  //   the argument expression. Any difference in top-level
5221  //   cv-qualification is subsumed by the initialization itself
5222  //   and does not constitute a conversion.
5223  ICS = TryImplicitConversion(S, Init, T1, SuppressUserConversions,
5224                              AllowedExplicit::None,
5225                              /*InOverloadResolution=*/false,
5226                              /*CStyle=*/false,
5227                              /*AllowObjCWritebackConversion=*/false,
5228                              /*AllowObjCConversionOnExplicit=*/false);
5229
5230  // Of course, that's still a reference binding.
5231  if (ICS.isStandard()) {
5232    ICS.Standard.ReferenceBinding = true;
5233    ICS.Standard.IsLvalueReference = !isRValRef;
5234    ICS.Standard.BindsToFunctionLvalue = false;
5235    ICS.Standard.BindsToRvalue = true;
5236    ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false;
5237    ICS.Standard.ObjCLifetimeConversionBinding = false;
5238  } else if (ICS.isUserDefined()) {
5239    const ReferenceType *LValRefType =
5240        ICS.UserDefined.ConversionFunction->getReturnType()
5241            ->getAs<LValueReferenceType>();
5242
5243    // C++ [over.ics.ref]p3:
5244    //   Except for an implicit object parameter, for which see 13.3.1, a
5245    //   standard conversion sequence cannot be formed if it requires [...]
5246    //   binding an rvalue reference to an lvalue other than a function
5247    //   lvalue.
5248    // Note that the function case is not possible here.
5249    if (isRValRef && LValRefType) {
5250      ICS.setBad(BadConversionSequence::no_conversion, Init, DeclType);
5251      return ICS;
5252    }
5253
5254    ICS.UserDefined.After.ReferenceBinding = true;
5255    ICS.UserDefined.After.IsLvalueReference = !isRValRef;
5256    ICS.UserDefined.After.BindsToFunctionLvalue = false;
5257    ICS.UserDefined.After.BindsToRvalue = !LValRefType;
5258    ICS.UserDefined.After.BindsImplicitObjectArgumentWithoutRefQualifier = false;
5259    ICS.UserDefined.After.ObjCLifetimeConversionBinding = false;
5260  }
5261
5262  return ICS;
5263}
5264
5265static ImplicitConversionSequence
5266TryCopyInitialization(Sema &S, Expr *From, QualType ToType,
5267                      bool SuppressUserConversions,
5268                      bool InOverloadResolution,
5269                      bool AllowObjCWritebackConversion,
5270                      bool AllowExplicit = false);
5271
5272/// TryListConversion - Try to copy-initialize a value of type ToType from the
5273/// initializer list From.
5274static ImplicitConversionSequence
5275TryListConversion(Sema &S, InitListExpr *From, QualType ToType,
5276                  bool SuppressUserConversions,
5277                  bool InOverloadResolution,
5278                  bool AllowObjCWritebackConversion) {
5279  // C++11 [over.ics.list]p1:
5280  //   When an argument is an initializer list, it is not an expression and
5281  //   special rules apply for converting it to a parameter type.
5282
5283  ImplicitConversionSequence Result;
5284  Result.setBad(BadConversionSequence::no_conversion, From, ToType);
5285
5286  // We need a complete type for what follows.  With one C++20 exception,
5287  // incomplete types can never be initialized from init lists.
5288  QualType InitTy = ToType;
5289  const ArrayType *AT = S.Context.getAsArrayType(ToType);
5290  if (AT && S.getLangOpts().CPlusPlus20)
5291    if (const auto *IAT = dyn_cast<IncompleteArrayType>(AT))
5292      // C++20 allows list initialization of an incomplete array type.
5293      InitTy = IAT->getElementType();
5294  if (!S.isCompleteType(From->getBeginLoc(), InitTy))
5295    return Result;
5296
5297  // C++20 [over.ics.list]/2:
5298  //   If the initializer list is a designated-initializer-list, a conversion
5299  //   is only possible if the parameter has an aggregate type
5300  //
5301  // FIXME: The exception for reference initialization here is not part of the
5302  // language rules, but follow other compilers in adding it as a tentative DR
5303  // resolution.
5304  bool IsDesignatedInit = From->hasDesignatedInit();
5305  if (!ToType->isAggregateType() && !ToType->isReferenceType() &&
5306      IsDesignatedInit)
5307    return Result;
5308
5309  // Per DR1467:
5310  //   If the parameter type is a class X and the initializer list has a single
5311  //   element of type cv U, where U is X or a class derived from X, the
5312  //   implicit conversion sequence is the one required to convert the element
5313  //   to the parameter type.
5314  //
5315  //   Otherwise, if the parameter type is a character array [... ]
5316  //   and the initializer list has a single element that is an
5317  //   appropriately-typed string literal (8.5.2 [dcl.init.string]), the
5318  //   implicit conversion sequence is the identity conversion.
5319  if (From->getNumInits() == 1 && !IsDesignatedInit) {
5320    if (ToType->isRecordType()) {
5321      QualType InitType = From->getInit(0)->getType();
5322      if (S.Context.hasSameUnqualifiedType(InitType, ToType) ||
5323          S.IsDerivedFrom(From->getBeginLoc(), InitType, ToType))
5324        return TryCopyInitialization(S, From->getInit(0), ToType,
5325                                     SuppressUserConversions,
5326                                     InOverloadResolution,
5327                                     AllowObjCWritebackConversion);
5328    }
5329
5330    if (AT && S.IsStringInit(From->getInit(0), AT)) {
5331      InitializedEntity Entity =
5332          InitializedEntity::InitializeParameter(S.Context, ToType,
5333                                                 /*Consumed=*/false);
5334      if (S.CanPerformCopyInitialization(Entity, From)) {
5335        Result.setStandard();
5336        Result.Standard.setAsIdentityConversion();
5337        Result.Standard.setFromType(ToType);
5338        Result.Standard.setAllToTypes(ToType);
5339        return Result;
5340      }
5341    }
5342  }
5343
5344  // C++14 [over.ics.list]p2: Otherwise, if the parameter type [...] (below).
5345  // C++11 [over.ics.list]p2:
5346  //   If the parameter type is std::initializer_list<X> or "array of X" and
5347  //   all the elements can be implicitly converted to X, the implicit
5348  //   conversion sequence is the worst conversion necessary to convert an
5349  //   element of the list to X.
5350  //
5351  // C++14 [over.ics.list]p3:
5352  //   Otherwise, if the parameter type is "array of N X", if the initializer
5353  //   list has exactly N elements or if it has fewer than N elements and X is
5354  //   default-constructible, and if all the elements of the initializer list
5355  //   can be implicitly converted to X, the implicit conversion sequence is
5356  //   the worst conversion necessary to convert an element of the list to X.
5357  if ((AT || S.isStdInitializerList(ToType, &InitTy)) && !IsDesignatedInit) {
5358    unsigned e = From->getNumInits();
5359    ImplicitConversionSequence DfltElt;
5360    DfltElt.setBad(BadConversionSequence::no_conversion, QualType(),
5361                   QualType());
5362    QualType ContTy = ToType;
5363    bool IsUnbounded = false;
5364    if (AT) {
5365      InitTy = AT->getElementType();
5366      if (ConstantArrayType const *CT = dyn_cast<ConstantArrayType>(AT)) {
5367        if (CT->getSize().ult(e)) {
5368          // Too many inits, fatally bad
5369          Result.setBad(BadConversionSequence::too_many_initializers, From,
5370                        ToType);
5371          Result.setInitializerListContainerType(ContTy, IsUnbounded);
5372          return Result;
5373        }
5374        if (CT->getSize().ugt(e)) {
5375          // Need an init from empty {}, is there one?
5376          InitListExpr EmptyList(S.Context, From->getEndLoc(), std::nullopt,
5377                                 From->getEndLoc());
5378          EmptyList.setType(S.Context.VoidTy);
5379          DfltElt = TryListConversion(
5380              S, &EmptyList, InitTy, SuppressUserConversions,
5381              InOverloadResolution, AllowObjCWritebackConversion);
5382          if (DfltElt.isBad()) {
5383            // No {} init, fatally bad
5384            Result.setBad(BadConversionSequence::too_few_initializers, From,
5385                          ToType);
5386            Result.setInitializerListContainerType(ContTy, IsUnbounded);
5387            return Result;
5388          }
5389        }
5390      } else {
5391        assert(isa<IncompleteArrayType>(AT) && "Expected incomplete array");
5392        IsUnbounded = true;
5393        if (!e) {
5394          // Cannot convert to zero-sized.
5395          Result.setBad(BadConversionSequence::too_few_initializers, From,
5396                        ToType);
5397          Result.setInitializerListContainerType(ContTy, IsUnbounded);
5398          return Result;
5399        }
5400        llvm::APInt Size(S.Context.getTypeSize(S.Context.getSizeType()), e);
5401        ContTy = S.Context.getConstantArrayType(InitTy, Size, nullptr,
5402                                                ArraySizeModifier::Normal, 0);
5403      }
5404    }
5405
5406    Result.setStandard();
5407    Result.Standard.setAsIdentityConversion();
5408    Result.Standard.setFromType(InitTy);
5409    Result.Standard.setAllToTypes(InitTy);
5410    for (unsigned i = 0; i < e; ++i) {
5411      Expr *Init = From->getInit(i);
5412      ImplicitConversionSequence ICS = TryCopyInitialization(
5413          S, Init, InitTy, SuppressUserConversions, InOverloadResolution,
5414          AllowObjCWritebackConversion);
5415
5416      // Keep the worse conversion seen so far.
5417      // FIXME: Sequences are not totally ordered, so 'worse' can be
5418      // ambiguous. CWG has been informed.
5419      if (CompareImplicitConversionSequences(S, From->getBeginLoc(), ICS,
5420                                             Result) ==
5421          ImplicitConversionSequence::Worse) {
5422        Result = ICS;
5423        // Bail as soon as we find something unconvertible.
5424        if (Result.isBad()) {
5425          Result.setInitializerListContainerType(ContTy, IsUnbounded);
5426          return Result;
5427        }
5428      }
5429    }
5430
5431    // If we needed any implicit {} initialization, compare that now.
5432    // over.ics.list/6 indicates we should compare that conversion.  Again CWG
5433    // has been informed that this might not be the best thing.
5434    if (!DfltElt.isBad() && CompareImplicitConversionSequences(
5435                                S, From->getEndLoc(), DfltElt, Result) ==
5436                                ImplicitConversionSequence::Worse)
5437      Result = DfltElt;
5438    // Record the type being initialized so that we may compare sequences
5439    Result.setInitializerListContainerType(ContTy, IsUnbounded);
5440    return Result;
5441  }
5442
5443  // C++14 [over.ics.list]p4:
5444  // C++11 [over.ics.list]p3:
5445  //   Otherwise, if the parameter is a non-aggregate class X and overload
5446  //   resolution chooses a single best constructor [...] the implicit
5447  //   conversion sequence is a user-defined conversion sequence. If multiple
5448  //   constructors are viable but none is better than the others, the
5449  //   implicit conversion sequence is a user-defined conversion sequence.
5450  if (ToType->isRecordType() && !ToType->isAggregateType()) {
5451    // This function can deal with initializer lists.
5452    return TryUserDefinedConversion(S, From, ToType, SuppressUserConversions,
5453                                    AllowedExplicit::None,
5454                                    InOverloadResolution, /*CStyle=*/false,
5455                                    AllowObjCWritebackConversion,
5456                                    /*AllowObjCConversionOnExplicit=*/false);
5457  }
5458
5459  // C++14 [over.ics.list]p5:
5460  // C++11 [over.ics.list]p4:
5461  //   Otherwise, if the parameter has an aggregate type which can be
5462  //   initialized from the initializer list [...] the implicit conversion
5463  //   sequence is a user-defined conversion sequence.
5464  if (ToType->isAggregateType()) {
5465    // Type is an aggregate, argument is an init list. At this point it comes
5466    // down to checking whether the initialization works.
5467    // FIXME: Find out whether this parameter is consumed or not.
5468    InitializedEntity Entity =
5469        InitializedEntity::InitializeParameter(S.Context, ToType,
5470                                               /*Consumed=*/false);
5471    if (S.CanPerformAggregateInitializationForOverloadResolution(Entity,
5472                                                                 From)) {
5473      Result.setUserDefined();
5474      Result.UserDefined.Before.setAsIdentityConversion();
5475      // Initializer lists don't have a type.
5476      Result.UserDefined.Before.setFromType(QualType());
5477      Result.UserDefined.Before.setAllToTypes(QualType());
5478
5479      Result.UserDefined.After.setAsIdentityConversion();
5480      Result.UserDefined.After.setFromType(ToType);
5481      Result.UserDefined.After.setAllToTypes(ToType);
5482      Result.UserDefined.ConversionFunction = nullptr;
5483    }
5484    return Result;
5485  }
5486
5487  // C++14 [over.ics.list]p6:
5488  // C++11 [over.ics.list]p5:
5489  //   Otherwise, if the parameter is a reference, see 13.3.3.1.4.
5490  if (ToType->isReferenceType()) {
5491    // The standard is notoriously unclear here, since 13.3.3.1.4 doesn't
5492    // mention initializer lists in any way. So we go by what list-
5493    // initialization would do and try to extrapolate from that.
5494
5495    QualType T1 = ToType->castAs<ReferenceType>()->getPointeeType();
5496
5497    // If the initializer list has a single element that is reference-related
5498    // to the parameter type, we initialize the reference from that.
5499    if (From->getNumInits() == 1 && !IsDesignatedInit) {
5500      Expr *Init = From->getInit(0);
5501
5502      QualType T2 = Init->getType();
5503
5504      // If the initializer is the address of an overloaded function, try
5505      // to resolve the overloaded function. If all goes well, T2 is the
5506      // type of the resulting function.
5507      if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) {
5508        DeclAccessPair Found;
5509        if (FunctionDecl *Fn = S.ResolveAddressOfOverloadedFunction(
5510                                   Init, ToType, false, Found))
5511          T2 = Fn->getType();
5512      }
5513
5514      // Compute some basic properties of the types and the initializer.
5515      Sema::ReferenceCompareResult RefRelationship =
5516          S.CompareReferenceRelationship(From->getBeginLoc(), T1, T2);
5517
5518      if (RefRelationship >= Sema::Ref_Related) {
5519        return TryReferenceInit(S, Init, ToType, /*FIXME*/ From->getBeginLoc(),
5520                                SuppressUserConversions,
5521                                /*AllowExplicit=*/false);
5522      }
5523    }
5524
5525    // Otherwise, we bind the reference to a temporary created from the
5526    // initializer list.
5527    Result = TryListConversion(S, From, T1, SuppressUserConversions,
5528                               InOverloadResolution,
5529                               AllowObjCWritebackConversion);
5530    if (Result.isFailure())
5531      return Result;
5532    assert(!Result.isEllipsis() &&
5533           "Sub-initialization cannot result in ellipsis conversion.");
5534
5535    // Can we even bind to a temporary?
5536    if (ToType->isRValueReferenceType() ||
5537        (T1.isConstQualified() && !T1.isVolatileQualified())) {
5538      StandardConversionSequence &SCS = Result.isStandard() ? Result.Standard :
5539                                            Result.UserDefined.After;
5540      SCS.ReferenceBinding = true;
5541      SCS.IsLvalueReference = ToType->isLValueReferenceType();
5542      SCS.BindsToRvalue = true;
5543      SCS.BindsToFunctionLvalue = false;
5544      SCS.BindsImplicitObjectArgumentWithoutRefQualifier = false;
5545      SCS.ObjCLifetimeConversionBinding = false;
5546    } else
5547      Result.setBad(BadConversionSequence::lvalue_ref_to_rvalue,
5548                    From, ToType);
5549    return Result;
5550  }
5551
5552  // C++14 [over.ics.list]p7:
5553  // C++11 [over.ics.list]p6:
5554  //   Otherwise, if the parameter type is not a class:
5555  if (!ToType->isRecordType()) {
5556    //    - if the initializer list has one element that is not itself an
5557    //      initializer list, the implicit conversion sequence is the one
5558    //      required to convert the element to the parameter type.
5559    unsigned NumInits = From->getNumInits();
5560    if (NumInits == 1 && !isa<InitListExpr>(From->getInit(0)))
5561      Result = TryCopyInitialization(S, From->getInit(0), ToType,
5562                                     SuppressUserConversions,
5563                                     InOverloadResolution,
5564                                     AllowObjCWritebackConversion);
5565    //    - if the initializer list has no elements, the implicit conversion
5566    //      sequence is the identity conversion.
5567    else if (NumInits == 0) {
5568      Result.setStandard();
5569      Result.Standard.setAsIdentityConversion();
5570      Result.Standard.setFromType(ToType);
5571      Result.Standard.setAllToTypes(ToType);
5572    }
5573    return Result;
5574  }
5575
5576  // C++14 [over.ics.list]p8:
5577  // C++11 [over.ics.list]p7:
5578  //   In all cases other than those enumerated above, no conversion is possible
5579  return Result;
5580}
5581
5582/// TryCopyInitialization - Try to copy-initialize a value of type
5583/// ToType from the expression From. Return the implicit conversion
5584/// sequence required to pass this argument, which may be a bad
5585/// conversion sequence (meaning that the argument cannot be passed to
5586/// a parameter of this type). If @p SuppressUserConversions, then we
5587/// do not permit any user-defined conversion sequences.
5588static ImplicitConversionSequence
5589TryCopyInitialization(Sema &S, Expr *From, QualType ToType,
5590                      bool SuppressUserConversions,
5591                      bool InOverloadResolution,
5592                      bool AllowObjCWritebackConversion,
5593                      bool AllowExplicit) {
5594  if (InitListExpr *FromInitList = dyn_cast<InitListExpr>(From))
5595    return TryListConversion(S, FromInitList, ToType, SuppressUserConversions,
5596                             InOverloadResolution,AllowObjCWritebackConversion);
5597
5598  if (ToType->isReferenceType())
5599    return TryReferenceInit(S, From, ToType,
5600                            /*FIXME:*/ From->getBeginLoc(),
5601                            SuppressUserConversions, AllowExplicit);
5602
5603  return TryImplicitConversion(S, From, ToType,
5604                               SuppressUserConversions,
5605                               AllowedExplicit::None,
5606                               InOverloadResolution,
5607                               /*CStyle=*/false,
5608                               AllowObjCWritebackConversion,
5609                               /*AllowObjCConversionOnExplicit=*/false);
5610}
5611
5612static bool TryCopyInitialization(const CanQualType FromQTy,
5613                                  const CanQualType ToQTy,
5614                                  Sema &S,
5615                                  SourceLocation Loc,
5616                                  ExprValueKind FromVK) {
5617  OpaqueValueExpr TmpExpr(Loc, FromQTy, FromVK);
5618  ImplicitConversionSequence ICS =
5619    TryCopyInitialization(S, &TmpExpr, ToQTy, true, true, false);
5620
5621  return !ICS.isBad();
5622}
5623
5624/// TryObjectArgumentInitialization - Try to initialize the object
5625/// parameter of the given member function (@c Method) from the
5626/// expression @p From.
5627static ImplicitConversionSequence TryObjectArgumentInitialization(
5628    Sema &S, SourceLocation Loc, QualType FromType,
5629    Expr::Classification FromClassification, CXXMethodDecl *Method,
5630    const CXXRecordDecl *ActingContext, bool InOverloadResolution = false,
5631    QualType ExplicitParameterType = QualType(),
5632    bool SuppressUserConversion = false) {
5633
5634  // We need to have an object of class type.
5635  if (const auto *PT = FromType->getAs<PointerType>()) {
5636    FromType = PT->getPointeeType();
5637
5638    // When we had a pointer, it's implicitly dereferenced, so we
5639    // better have an lvalue.
5640    assert(FromClassification.isLValue());
5641  }
5642
5643  auto ValueKindFromClassification = [](Expr::Classification C) {
5644    if (C.isPRValue())
5645      return clang::VK_PRValue;
5646    if (C.isXValue())
5647      return VK_XValue;
5648    return clang::VK_LValue;
5649  };
5650
5651  if (Method->isExplicitObjectMemberFunction()) {
5652    if (ExplicitParameterType.isNull())
5653      ExplicitParameterType = Method->getFunctionObjectParameterReferenceType();
5654    OpaqueValueExpr TmpExpr(Loc, FromType.getNonReferenceType(),
5655                            ValueKindFromClassification(FromClassification));
5656    ImplicitConversionSequence ICS = TryCopyInitialization(
5657        S, &TmpExpr, ExplicitParameterType, SuppressUserConversion,
5658        /*InOverloadResolution=*/true, false);
5659    if (ICS.isBad())
5660      ICS.Bad.FromExpr = nullptr;
5661    return ICS;
5662  }
5663
5664  assert(FromType->isRecordType());
5665
5666  QualType ClassType = S.Context.getTypeDeclType(ActingContext);
5667  // C++98 [class.dtor]p2:
5668  //   A destructor can be invoked for a const, volatile or const volatile
5669  //   object.
5670  // C++98 [over.match.funcs]p4:
5671  //   For static member functions, the implicit object parameter is considered
5672  //   to match any object (since if the function is selected, the object is
5673  //   discarded).
5674  Qualifiers Quals = Method->getMethodQualifiers();
5675  if (isa<CXXDestructorDecl>(Method) || Method->isStatic()) {
5676    Quals.addConst();
5677    Quals.addVolatile();
5678  }
5679
5680  QualType ImplicitParamType = S.Context.getQualifiedType(ClassType, Quals);
5681
5682  // Set up the conversion sequence as a "bad" conversion, to allow us
5683  // to exit early.
5684  ImplicitConversionSequence ICS;
5685
5686  // C++0x [over.match.funcs]p4:
5687  //   For non-static member functions, the type of the implicit object
5688  //   parameter is
5689  //
5690  //     - "lvalue reference to cv X" for functions declared without a
5691  //        ref-qualifier or with the & ref-qualifier
5692  //     - "rvalue reference to cv X" for functions declared with the &&
5693  //        ref-qualifier
5694  //
5695  // where X is the class of which the function is a member and cv is the
5696  // cv-qualification on the member function declaration.
5697  //
5698  // However, when finding an implicit conversion sequence for the argument, we
5699  // are not allowed to perform user-defined conversions
5700  // (C++ [over.match.funcs]p5). We perform a simplified version of
5701  // reference binding here, that allows class rvalues to bind to
5702  // non-constant references.
5703
5704  // First check the qualifiers.
5705  QualType FromTypeCanon = S.Context.getCanonicalType(FromType);
5706  // MSVC ignores __unaligned qualifier for overload candidates; do the same.
5707  if (ImplicitParamType.getCVRQualifiers() !=
5708          FromTypeCanon.getLocalCVRQualifiers() &&
5709      !ImplicitParamType.isAtLeastAsQualifiedAs(
5710          withoutUnaligned(S.Context, FromTypeCanon))) {
5711    ICS.setBad(BadConversionSequence::bad_qualifiers,
5712               FromType, ImplicitParamType);
5713    return ICS;
5714  }
5715
5716  if (FromTypeCanon.hasAddressSpace()) {
5717    Qualifiers QualsImplicitParamType = ImplicitParamType.getQualifiers();
5718    Qualifiers QualsFromType = FromTypeCanon.getQualifiers();
5719    if (!QualsImplicitParamType.isAddressSpaceSupersetOf(QualsFromType)) {
5720      ICS.setBad(BadConversionSequence::bad_qualifiers,
5721                 FromType, ImplicitParamType);
5722      return ICS;
5723    }
5724  }
5725
5726  // Check that we have either the same type or a derived type. It
5727  // affects the conversion rank.
5728  QualType ClassTypeCanon = S.Context.getCanonicalType(ClassType);
5729  ImplicitConversionKind SecondKind;
5730  if (ClassTypeCanon == FromTypeCanon.getLocalUnqualifiedType()) {
5731    SecondKind = ICK_Identity;
5732  } else if (S.IsDerivedFrom(Loc, FromType, ClassType)) {
5733    SecondKind = ICK_Derived_To_Base;
5734  } else if (!Method->isExplicitObjectMemberFunction()) {
5735    ICS.setBad(BadConversionSequence::unrelated_class,
5736               FromType, ImplicitParamType);
5737    return ICS;
5738  }
5739
5740  // Check the ref-qualifier.
5741  switch (Method->getRefQualifier()) {
5742  case RQ_None:
5743    // Do nothing; we don't care about lvalueness or rvalueness.
5744    break;
5745
5746  case RQ_LValue:
5747    if (!FromClassification.isLValue() && !Quals.hasOnlyConst()) {
5748      // non-const lvalue reference cannot bind to an rvalue
5749      ICS.setBad(BadConversionSequence::lvalue_ref_to_rvalue, FromType,
5750                 ImplicitParamType);
5751      return ICS;
5752    }
5753    break;
5754
5755  case RQ_RValue:
5756    if (!FromClassification.isRValue()) {
5757      // rvalue reference cannot bind to an lvalue
5758      ICS.setBad(BadConversionSequence::rvalue_ref_to_lvalue, FromType,
5759                 ImplicitParamType);
5760      return ICS;
5761    }
5762    break;
5763  }
5764
5765  // Success. Mark this as a reference binding.
5766  ICS.setStandard();
5767  ICS.Standard.setAsIdentityConversion();
5768  ICS.Standard.Second = SecondKind;
5769  ICS.Standard.setFromType(FromType);
5770  ICS.Standard.setAllToTypes(ImplicitParamType);
5771  ICS.Standard.ReferenceBinding = true;
5772  ICS.Standard.DirectBinding = true;
5773  ICS.Standard.IsLvalueReference = Method->getRefQualifier() != RQ_RValue;
5774  ICS.Standard.BindsToFunctionLvalue = false;
5775  ICS.Standard.BindsToRvalue = FromClassification.isRValue();
5776  ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier
5777    = (Method->getRefQualifier() == RQ_None);
5778  return ICS;
5779}
5780
5781/// PerformObjectArgumentInitialization - Perform initialization of
5782/// the implicit object parameter for the given Method with the given
5783/// expression.
5784ExprResult Sema::PerformImplicitObjectArgumentInitialization(
5785    Expr *From, NestedNameSpecifier *Qualifier, NamedDecl *FoundDecl,
5786    CXXMethodDecl *Method) {
5787  QualType FromRecordType, DestType;
5788  QualType ImplicitParamRecordType = Method->getFunctionObjectParameterType();
5789
5790  Expr::Classification FromClassification;
5791  if (const PointerType *PT = From->getType()->getAs<PointerType>()) {
5792    FromRecordType = PT->getPointeeType();
5793    DestType = Method->getThisType();
5794    FromClassification = Expr::Classification::makeSimpleLValue();
5795  } else {
5796    FromRecordType = From->getType();
5797    DestType = ImplicitParamRecordType;
5798    FromClassification = From->Classify(Context);
5799
5800    // When performing member access on a prvalue, materialize a temporary.
5801    if (From->isPRValue()) {
5802      From = CreateMaterializeTemporaryExpr(FromRecordType, From,
5803                                            Method->getRefQualifier() !=
5804                                                RefQualifierKind::RQ_RValue);
5805    }
5806  }
5807
5808  // Note that we always use the true parent context when performing
5809  // the actual argument initialization.
5810  ImplicitConversionSequence ICS = TryObjectArgumentInitialization(
5811      *this, From->getBeginLoc(), From->getType(), FromClassification, Method,
5812      Method->getParent());
5813  if (ICS.isBad()) {
5814    switch (ICS.Bad.Kind) {
5815    case BadConversionSequence::bad_qualifiers: {
5816      Qualifiers FromQs = FromRecordType.getQualifiers();
5817      Qualifiers ToQs = DestType.getQualifiers();
5818      unsigned CVR = FromQs.getCVRQualifiers() & ~ToQs.getCVRQualifiers();
5819      if (CVR) {
5820        Diag(From->getBeginLoc(), diag::err_member_function_call_bad_cvr)
5821            << Method->getDeclName() << FromRecordType << (CVR - 1)
5822            << From->getSourceRange();
5823        Diag(Method->getLocation(), diag::note_previous_decl)
5824          << Method->getDeclName();
5825        return ExprError();
5826      }
5827      break;
5828    }
5829
5830    case BadConversionSequence::lvalue_ref_to_rvalue:
5831    case BadConversionSequence::rvalue_ref_to_lvalue: {
5832      bool IsRValueQualified =
5833        Method->getRefQualifier() == RefQualifierKind::RQ_RValue;
5834      Diag(From->getBeginLoc(), diag::err_member_function_call_bad_ref)
5835          << Method->getDeclName() << FromClassification.isRValue()
5836          << IsRValueQualified;
5837      Diag(Method->getLocation(), diag::note_previous_decl)
5838        << Method->getDeclName();
5839      return ExprError();
5840    }
5841
5842    case BadConversionSequence::no_conversion:
5843    case BadConversionSequence::unrelated_class:
5844      break;
5845
5846    case BadConversionSequence::too_few_initializers:
5847    case BadConversionSequence::too_many_initializers:
5848      llvm_unreachable("Lists are not objects");
5849    }
5850
5851    return Diag(From->getBeginLoc(), diag::err_member_function_call_bad_type)
5852           << ImplicitParamRecordType << FromRecordType
5853           << From->getSourceRange();
5854  }
5855
5856  if (ICS.Standard.Second == ICK_Derived_To_Base) {
5857    ExprResult FromRes =
5858      PerformObjectMemberConversion(From, Qualifier, FoundDecl, Method);
5859    if (FromRes.isInvalid())
5860      return ExprError();
5861    From = FromRes.get();
5862  }
5863
5864  if (!Context.hasSameType(From->getType(), DestType)) {
5865    CastKind CK;
5866    QualType PteeTy = DestType->getPointeeType();
5867    LangAS DestAS =
5868        PteeTy.isNull() ? DestType.getAddressSpace() : PteeTy.getAddressSpace();
5869    if (FromRecordType.getAddressSpace() != DestAS)
5870      CK = CK_AddressSpaceConversion;
5871    else
5872      CK = CK_NoOp;
5873    From = ImpCastExprToType(From, DestType, CK, From->getValueKind()).get();
5874  }
5875  return From;
5876}
5877
5878/// TryContextuallyConvertToBool - Attempt to contextually convert the
5879/// expression From to bool (C++0x [conv]p3).
5880static ImplicitConversionSequence
5881TryContextuallyConvertToBool(Sema &S, Expr *From) {
5882  // C++ [dcl.init]/17.8:
5883  //   - Otherwise, if the initialization is direct-initialization, the source
5884  //     type is std::nullptr_t, and the destination type is bool, the initial
5885  //     value of the object being initialized is false.
5886  if (From->getType()->isNullPtrType())
5887    return ImplicitConversionSequence::getNullptrToBool(From->getType(),
5888                                                        S.Context.BoolTy,
5889                                                        From->isGLValue());
5890
5891  // All other direct-initialization of bool is equivalent to an implicit
5892  // conversion to bool in which explicit conversions are permitted.
5893  return TryImplicitConversion(S, From, S.Context.BoolTy,
5894                               /*SuppressUserConversions=*/false,
5895                               AllowedExplicit::Conversions,
5896                               /*InOverloadResolution=*/false,
5897                               /*CStyle=*/false,
5898                               /*AllowObjCWritebackConversion=*/false,
5899                               /*AllowObjCConversionOnExplicit=*/false);
5900}
5901
5902/// PerformContextuallyConvertToBool - Perform a contextual conversion
5903/// of the expression From to bool (C++0x [conv]p3).
5904ExprResult Sema::PerformContextuallyConvertToBool(Expr *From) {
5905  if (checkPlaceholderForOverload(*this, From))
5906    return ExprError();
5907
5908  ImplicitConversionSequence ICS = TryContextuallyConvertToBool(*this, From);
5909  if (!ICS.isBad())
5910    return PerformImplicitConversion(From, Context.BoolTy, ICS, AA_Converting);
5911
5912  if (!DiagnoseMultipleUserDefinedConversion(From, Context.BoolTy))
5913    return Diag(From->getBeginLoc(), diag::err_typecheck_bool_condition)
5914           << From->getType() << From->getSourceRange();
5915  return ExprError();
5916}
5917
5918/// Check that the specified conversion is permitted in a converted constant
5919/// expression, according to C++11 [expr.const]p3. Return true if the conversion
5920/// is acceptable.
5921static bool CheckConvertedConstantConversions(Sema &S,
5922                                              StandardConversionSequence &SCS) {
5923  // Since we know that the target type is an integral or unscoped enumeration
5924  // type, most conversion kinds are impossible. All possible First and Third
5925  // conversions are fine.
5926  switch (SCS.Second) {
5927  case ICK_Identity:
5928  case ICK_Integral_Promotion:
5929  case ICK_Integral_Conversion: // Narrowing conversions are checked elsewhere.
5930  case ICK_Zero_Queue_Conversion:
5931    return true;
5932
5933  case ICK_Boolean_Conversion:
5934    // Conversion from an integral or unscoped enumeration type to bool is
5935    // classified as ICK_Boolean_Conversion, but it's also arguably an integral
5936    // conversion, so we allow it in a converted constant expression.
5937    //
5938    // FIXME: Per core issue 1407, we should not allow this, but that breaks
5939    // a lot of popular code. We should at least add a warning for this
5940    // (non-conforming) extension.
5941    return SCS.getFromType()->isIntegralOrUnscopedEnumerationType() &&
5942           SCS.getToType(2)->isBooleanType();
5943
5944  case ICK_Pointer_Conversion:
5945  case ICK_Pointer_Member:
5946    // C++1z: null pointer conversions and null member pointer conversions are
5947    // only permitted if the source type is std::nullptr_t.
5948    return SCS.getFromType()->isNullPtrType();
5949
5950  case ICK_Floating_Promotion:
5951  case ICK_Complex_Promotion:
5952  case ICK_Floating_Conversion:
5953  case ICK_Complex_Conversion:
5954  case ICK_Floating_Integral:
5955  case ICK_Compatible_Conversion:
5956  case ICK_Derived_To_Base:
5957  case ICK_Vector_Conversion:
5958  case ICK_SVE_Vector_Conversion:
5959  case ICK_RVV_Vector_Conversion:
5960  case ICK_Vector_Splat:
5961  case ICK_Complex_Real:
5962  case ICK_Block_Pointer_Conversion:
5963  case ICK_TransparentUnionConversion:
5964  case ICK_Writeback_Conversion:
5965  case ICK_Zero_Event_Conversion:
5966  case ICK_C_Only_Conversion:
5967  case ICK_Incompatible_Pointer_Conversion:
5968  case ICK_Fixed_Point_Conversion:
5969    return false;
5970
5971  case ICK_Lvalue_To_Rvalue:
5972  case ICK_Array_To_Pointer:
5973  case ICK_Function_To_Pointer:
5974    llvm_unreachable("found a first conversion kind in Second");
5975
5976  case ICK_Function_Conversion:
5977  case ICK_Qualification:
5978    llvm_unreachable("found a third conversion kind in Second");
5979
5980  case ICK_Num_Conversion_Kinds:
5981    break;
5982  }
5983
5984  llvm_unreachable("unknown conversion kind");
5985}
5986
5987/// BuildConvertedConstantExpression - Check that the expression From is a
5988/// converted constant expression of type T, perform the conversion but
5989/// does not evaluate the expression
5990static ExprResult BuildConvertedConstantExpression(Sema &S, Expr *From,
5991                                                   QualType T,
5992                                                   Sema::CCEKind CCE,
5993                                                   NamedDecl *Dest,
5994                                                   APValue &PreNarrowingValue) {
5995  assert(S.getLangOpts().CPlusPlus11 &&
5996         "converted constant expression outside C++11");
5997
5998  if (checkPlaceholderForOverload(S, From))
5999    return ExprError();
6000
6001  // C++1z [expr.const]p3:
6002  //  A converted constant expression of type T is an expression,
6003  //  implicitly converted to type T, where the converted
6004  //  expression is a constant expression and the implicit conversion
6005  //  sequence contains only [... list of conversions ...].
6006  ImplicitConversionSequence ICS =
6007      (CCE == Sema::CCEK_ExplicitBool || CCE == Sema::CCEK_Noexcept)
6008          ? TryContextuallyConvertToBool(S, From)
6009          : TryCopyInitialization(S, From, T,
6010                                  /*SuppressUserConversions=*/false,
6011                                  /*InOverloadResolution=*/false,
6012                                  /*AllowObjCWritebackConversion=*/false,
6013                                  /*AllowExplicit=*/false);
6014  StandardConversionSequence *SCS = nullptr;
6015  switch (ICS.getKind()) {
6016  case ImplicitConversionSequence::StandardConversion:
6017    SCS = &ICS.Standard;
6018    break;
6019  case ImplicitConversionSequence::UserDefinedConversion:
6020    if (T->isRecordType())
6021      SCS = &ICS.UserDefined.Before;
6022    else
6023      SCS = &ICS.UserDefined.After;
6024    break;
6025  case ImplicitConversionSequence::AmbiguousConversion:
6026  case ImplicitConversionSequence::BadConversion:
6027    if (!S.DiagnoseMultipleUserDefinedConversion(From, T))
6028      return S.Diag(From->getBeginLoc(),
6029                    diag::err_typecheck_converted_constant_expression)
6030             << From->getType() << From->getSourceRange() << T;
6031    return ExprError();
6032
6033  case ImplicitConversionSequence::EllipsisConversion:
6034  case ImplicitConversionSequence::StaticObjectArgumentConversion:
6035    llvm_unreachable("bad conversion in converted constant expression");
6036  }
6037
6038  // Check that we would only use permitted conversions.
6039  if (!CheckConvertedConstantConversions(S, *SCS)) {
6040    return S.Diag(From->getBeginLoc(),
6041                  diag::err_typecheck_converted_constant_expression_disallowed)
6042           << From->getType() << From->getSourceRange() << T;
6043  }
6044  // [...] and where the reference binding (if any) binds directly.
6045  if (SCS->ReferenceBinding && !SCS->DirectBinding) {
6046    return S.Diag(From->getBeginLoc(),
6047                  diag::err_typecheck_converted_constant_expression_indirect)
6048           << From->getType() << From->getSourceRange() << T;
6049  }
6050  // 'TryCopyInitialization' returns incorrect info for attempts to bind
6051  // a reference to a bit-field due to C++ [over.ics.ref]p4. Namely,
6052  // 'SCS->DirectBinding' occurs to be set to 'true' despite it is not
6053  // the direct binding according to C++ [dcl.init.ref]p5. Hence, check this
6054  // case explicitly.
6055  if (From->refersToBitField() && T.getTypePtr()->isReferenceType()) {
6056    return S.Diag(From->getBeginLoc(),
6057                  diag::err_reference_bind_to_bitfield_in_cce)
6058           << From->getSourceRange();
6059  }
6060
6061  // Usually we can simply apply the ImplicitConversionSequence we formed
6062  // earlier, but that's not guaranteed to work when initializing an object of
6063  // class type.
6064  ExprResult Result;
6065  if (T->isRecordType()) {
6066    assert(CCE == Sema::CCEK_TemplateArg &&
6067           "unexpected class type converted constant expr");
6068    Result = S.PerformCopyInitialization(
6069        InitializedEntity::InitializeTemplateParameter(
6070            T, cast<NonTypeTemplateParmDecl>(Dest)),
6071        SourceLocation(), From);
6072  } else {
6073    Result = S.PerformImplicitConversion(From, T, ICS, Sema::AA_Converting);
6074  }
6075  if (Result.isInvalid())
6076    return Result;
6077
6078  // C++2a [intro.execution]p5:
6079  //   A full-expression is [...] a constant-expression [...]
6080  Result = S.ActOnFinishFullExpr(Result.get(), From->getExprLoc(),
6081                                 /*DiscardedValue=*/false, /*IsConstexpr=*/true,
6082                                 CCE == Sema::CCEKind::CCEK_TemplateArg);
6083  if (Result.isInvalid())
6084    return Result;
6085
6086  // Check for a narrowing implicit conversion.
6087  bool ReturnPreNarrowingValue = false;
6088  QualType PreNarrowingType;
6089  switch (SCS->getNarrowingKind(S.Context, Result.get(), PreNarrowingValue,
6090                                PreNarrowingType)) {
6091  case NK_Dependent_Narrowing:
6092    // Implicit conversion to a narrower type, but the expression is
6093    // value-dependent so we can't tell whether it's actually narrowing.
6094  case NK_Variable_Narrowing:
6095    // Implicit conversion to a narrower type, and the value is not a constant
6096    // expression. We'll diagnose this in a moment.
6097  case NK_Not_Narrowing:
6098    break;
6099
6100  case NK_Constant_Narrowing:
6101    if (CCE == Sema::CCEK_ArrayBound &&
6102        PreNarrowingType->isIntegralOrEnumerationType() &&
6103        PreNarrowingValue.isInt()) {
6104      // Don't diagnose array bound narrowing here; we produce more precise
6105      // errors by allowing the un-narrowed value through.
6106      ReturnPreNarrowingValue = true;
6107      break;
6108    }
6109    S.Diag(From->getBeginLoc(), diag::ext_cce_narrowing)
6110        << CCE << /*Constant*/ 1
6111        << PreNarrowingValue.getAsString(S.Context, PreNarrowingType) << T;
6112    break;
6113
6114  case NK_Type_Narrowing:
6115    // FIXME: It would be better to diagnose that the expression is not a
6116    // constant expression.
6117    S.Diag(From->getBeginLoc(), diag::ext_cce_narrowing)
6118        << CCE << /*Constant*/ 0 << From->getType() << T;
6119    break;
6120  }
6121  if (!ReturnPreNarrowingValue)
6122    PreNarrowingValue = {};
6123
6124  return Result;
6125}
6126
6127/// CheckConvertedConstantExpression - Check that the expression From is a
6128/// converted constant expression of type T, perform the conversion and produce
6129/// the converted expression, per C++11 [expr.const]p3.
6130static ExprResult CheckConvertedConstantExpression(Sema &S, Expr *From,
6131                                                   QualType T, APValue &Value,
6132                                                   Sema::CCEKind CCE,
6133                                                   bool RequireInt,
6134                                                   NamedDecl *Dest) {
6135
6136  APValue PreNarrowingValue;
6137  ExprResult Result = BuildConvertedConstantExpression(S, From, T, CCE, Dest,
6138                                                       PreNarrowingValue);
6139  if (Result.isInvalid() || Result.get()->isValueDependent()) {
6140    Value = APValue();
6141    return Result;
6142  }
6143  return S.EvaluateConvertedConstantExpression(Result.get(), T, Value, CCE,
6144                                               RequireInt, PreNarrowingValue);
6145}
6146
6147ExprResult Sema::BuildConvertedConstantExpression(Expr *From, QualType T,
6148                                                  CCEKind CCE,
6149                                                  NamedDecl *Dest) {
6150  APValue PreNarrowingValue;
6151  return ::BuildConvertedConstantExpression(*this, From, T, CCE, Dest,
6152                                            PreNarrowingValue);
6153}
6154
6155ExprResult Sema::CheckConvertedConstantExpression(Expr *From, QualType T,
6156                                                  APValue &Value, CCEKind CCE,
6157                                                  NamedDecl *Dest) {
6158  return ::CheckConvertedConstantExpression(*this, From, T, Value, CCE, false,
6159                                            Dest);
6160}
6161
6162ExprResult Sema::CheckConvertedConstantExpression(Expr *From, QualType T,
6163                                                  llvm::APSInt &Value,
6164                                                  CCEKind CCE) {
6165  assert(T->isIntegralOrEnumerationType() && "unexpected converted const type");
6166
6167  APValue V;
6168  auto R = ::CheckConvertedConstantExpression(*this, From, T, V, CCE, true,
6169                                              /*Dest=*/nullptr);
6170  if (!R.isInvalid() && !R.get()->isValueDependent())
6171    Value = V.getInt();
6172  return R;
6173}
6174
6175/// EvaluateConvertedConstantExpression - Evaluate an Expression
6176/// That is a converted constant expression
6177/// (which was built with BuildConvertedConstantExpression)
6178ExprResult
6179Sema::EvaluateConvertedConstantExpression(Expr *E, QualType T, APValue &Value,
6180                                          Sema::CCEKind CCE, bool RequireInt,
6181                                          const APValue &PreNarrowingValue) {
6182
6183  ExprResult Result = E;
6184  // Check the expression is a constant expression.
6185  SmallVector<PartialDiagnosticAt, 8> Notes;
6186  Expr::EvalResult Eval;
6187  Eval.Diag = &Notes;
6188
6189  ConstantExprKind Kind;
6190  if (CCE == Sema::CCEK_TemplateArg && T->isRecordType())
6191    Kind = ConstantExprKind::ClassTemplateArgument;
6192  else if (CCE == Sema::CCEK_TemplateArg)
6193    Kind = ConstantExprKind::NonClassTemplateArgument;
6194  else
6195    Kind = ConstantExprKind::Normal;
6196
6197  if (!E->EvaluateAsConstantExpr(Eval, Context, Kind) ||
6198      (RequireInt && !Eval.Val.isInt())) {
6199    // The expression can't be folded, so we can't keep it at this position in
6200    // the AST.
6201    Result = ExprError();
6202  } else {
6203    Value = Eval.Val;
6204
6205    if (Notes.empty()) {
6206      // It's a constant expression.
6207      Expr *E = Result.get();
6208      if (const auto *CE = dyn_cast<ConstantExpr>(E)) {
6209        // We expect a ConstantExpr to have a value associated with it
6210        // by this point.
6211        assert(CE->getResultStorageKind() != ConstantResultStorageKind::None &&
6212               "ConstantExpr has no value associated with it");
6213      } else {
6214        E = ConstantExpr::Create(Context, Result.get(), Value);
6215      }
6216      if (!PreNarrowingValue.isAbsent())
6217        Value = std::move(PreNarrowingValue);
6218      return E;
6219    }
6220  }
6221
6222  // It's not a constant expression. Produce an appropriate diagnostic.
6223  if (Notes.size() == 1 &&
6224      Notes[0].second.getDiagID() == diag::note_invalid_subexpr_in_const_expr) {
6225    Diag(Notes[0].first, diag::err_expr_not_cce) << CCE;
6226  } else if (!Notes.empty() && Notes[0].second.getDiagID() ==
6227                                   diag::note_constexpr_invalid_template_arg) {
6228    Notes[0].second.setDiagID(diag::err_constexpr_invalid_template_arg);
6229    for (unsigned I = 0; I < Notes.size(); ++I)
6230      Diag(Notes[I].first, Notes[I].second);
6231  } else {
6232    Diag(E->getBeginLoc(), diag::err_expr_not_cce)
6233        << CCE << E->getSourceRange();
6234    for (unsigned I = 0; I < Notes.size(); ++I)
6235      Diag(Notes[I].first, Notes[I].second);
6236  }
6237  return ExprError();
6238}
6239
6240/// dropPointerConversions - If the given standard conversion sequence
6241/// involves any pointer conversions, remove them.  This may change
6242/// the result type of the conversion sequence.
6243static void dropPointerConversion(StandardConversionSequence &SCS) {
6244  if (SCS.Second == ICK_Pointer_Conversion) {
6245    SCS.Second = ICK_Identity;
6246    SCS.Third = ICK_Identity;
6247    SCS.ToTypePtrs[2] = SCS.ToTypePtrs[1] = SCS.ToTypePtrs[0];
6248  }
6249}
6250
6251/// TryContextuallyConvertToObjCPointer - Attempt to contextually
6252/// convert the expression From to an Objective-C pointer type.
6253static ImplicitConversionSequence
6254TryContextuallyConvertToObjCPointer(Sema &S, Expr *From) {
6255  // Do an implicit conversion to 'id'.
6256  QualType Ty = S.Context.getObjCIdType();
6257  ImplicitConversionSequence ICS
6258    = TryImplicitConversion(S, From, Ty,
6259                            // FIXME: Are these flags correct?
6260                            /*SuppressUserConversions=*/false,
6261                            AllowedExplicit::Conversions,
6262                            /*InOverloadResolution=*/false,
6263                            /*CStyle=*/false,
6264                            /*AllowObjCWritebackConversion=*/false,
6265                            /*AllowObjCConversionOnExplicit=*/true);
6266
6267  // Strip off any final conversions to 'id'.
6268  switch (ICS.getKind()) {
6269  case ImplicitConversionSequence::BadConversion:
6270  case ImplicitConversionSequence::AmbiguousConversion:
6271  case ImplicitConversionSequence::EllipsisConversion:
6272  case ImplicitConversionSequence::StaticObjectArgumentConversion:
6273    break;
6274
6275  case ImplicitConversionSequence::UserDefinedConversion:
6276    dropPointerConversion(ICS.UserDefined.After);
6277    break;
6278
6279  case ImplicitConversionSequence::StandardConversion:
6280    dropPointerConversion(ICS.Standard);
6281    break;
6282  }
6283
6284  return ICS;
6285}
6286
6287/// PerformContextuallyConvertToObjCPointer - Perform a contextual
6288/// conversion of the expression From to an Objective-C pointer type.
6289/// Returns a valid but null ExprResult if no conversion sequence exists.
6290ExprResult Sema::PerformContextuallyConvertToObjCPointer(Expr *From) {
6291  if (checkPlaceholderForOverload(*this, From))
6292    return ExprError();
6293
6294  QualType Ty = Context.getObjCIdType();
6295  ImplicitConversionSequence ICS =
6296    TryContextuallyConvertToObjCPointer(*this, From);
6297  if (!ICS.isBad())
6298    return PerformImplicitConversion(From, Ty, ICS, AA_Converting);
6299  return ExprResult();
6300}
6301
6302static QualType GetExplicitObjectType(Sema &S, const Expr *MemExprE) {
6303  const Expr *Base = nullptr;
6304  assert((isa<UnresolvedMemberExpr, MemberExpr>(MemExprE)) &&
6305         "expected a member expression");
6306
6307  if (const auto M = dyn_cast<UnresolvedMemberExpr>(MemExprE);
6308      M && !M->isImplicitAccess())
6309    Base = M->getBase();
6310  else if (const auto M = dyn_cast<MemberExpr>(MemExprE);
6311           M && !M->isImplicitAccess())
6312    Base = M->getBase();
6313
6314  QualType T = Base ? Base->getType() : S.getCurrentThisType();
6315
6316  if (T->isPointerType())
6317    T = T->getPointeeType();
6318
6319  return T;
6320}
6321
6322static Expr *GetExplicitObjectExpr(Sema &S, Expr *Obj,
6323                                   const FunctionDecl *Fun) {
6324  QualType ObjType = Obj->getType();
6325  if (ObjType->isPointerType()) {
6326    ObjType = ObjType->getPointeeType();
6327    Obj = UnaryOperator::Create(S.getASTContext(), Obj, UO_Deref, ObjType,
6328                                VK_LValue, OK_Ordinary, SourceLocation(),
6329                                /*CanOverflow=*/false, FPOptionsOverride());
6330  }
6331  if (Obj->Classify(S.getASTContext()).isPRValue()) {
6332    Obj = S.CreateMaterializeTemporaryExpr(
6333        ObjType, Obj,
6334        !Fun->getParamDecl(0)->getType()->isRValueReferenceType());
6335  }
6336  return Obj;
6337}
6338
6339ExprResult Sema::InitializeExplicitObjectArgument(Sema &S, Expr *Obj,
6340                                                  FunctionDecl *Fun) {
6341  Obj = GetExplicitObjectExpr(S, Obj, Fun);
6342  return S.PerformCopyInitialization(
6343      InitializedEntity::InitializeParameter(S.Context, Fun->getParamDecl(0)),
6344      Obj->getExprLoc(), Obj);
6345}
6346
6347static void PrepareExplicitObjectArgument(Sema &S, CXXMethodDecl *Method,
6348                                          Expr *Object, MultiExprArg &Args,
6349                                          SmallVectorImpl<Expr *> &NewArgs) {
6350  assert(Method->isExplicitObjectMemberFunction() &&
6351         "Method is not an explicit member function");
6352  assert(NewArgs.empty() && "NewArgs should be empty");
6353  NewArgs.reserve(Args.size() + 1);
6354  Expr *This = GetExplicitObjectExpr(S, Object, Method);
6355  NewArgs.push_back(This);
6356  NewArgs.append(Args.begin(), Args.end());
6357  Args = NewArgs;
6358}
6359
6360/// Determine whether the provided type is an integral type, or an enumeration
6361/// type of a permitted flavor.
6362bool Sema::ICEConvertDiagnoser::match(QualType T) {
6363  return AllowScopedEnumerations ? T->isIntegralOrEnumerationType()
6364                                 : T->isIntegralOrUnscopedEnumerationType();
6365}
6366
6367static ExprResult
6368diagnoseAmbiguousConversion(Sema &SemaRef, SourceLocation Loc, Expr *From,
6369                            Sema::ContextualImplicitConverter &Converter,
6370                            QualType T, UnresolvedSetImpl &ViableConversions) {
6371
6372  if (Converter.Suppress)
6373    return ExprError();
6374
6375  Converter.diagnoseAmbiguous(SemaRef, Loc, T) << From->getSourceRange();
6376  for (unsigned I = 0, N = ViableConversions.size(); I != N; ++I) {
6377    CXXConversionDecl *Conv =
6378        cast<CXXConversionDecl>(ViableConversions[I]->getUnderlyingDecl());
6379    QualType ConvTy = Conv->getConversionType().getNonReferenceType();
6380    Converter.noteAmbiguous(SemaRef, Conv, ConvTy);
6381  }
6382  return From;
6383}
6384
6385static bool
6386diagnoseNoViableConversion(Sema &SemaRef, SourceLocation Loc, Expr *&From,
6387                           Sema::ContextualImplicitConverter &Converter,
6388                           QualType T, bool HadMultipleCandidates,
6389                           UnresolvedSetImpl &ExplicitConversions) {
6390  if (ExplicitConversions.size() == 1 && !Converter.Suppress) {
6391    DeclAccessPair Found = ExplicitConversions[0];
6392    CXXConversionDecl *Conversion =
6393        cast<CXXConversionDecl>(Found->getUnderlyingDecl());
6394
6395    // The user probably meant to invoke the given explicit
6396    // conversion; use it.
6397    QualType ConvTy = Conversion->getConversionType().getNonReferenceType();
6398    std::string TypeStr;
6399    ConvTy.getAsStringInternal(TypeStr, SemaRef.getPrintingPolicy());
6400
6401    Converter.diagnoseExplicitConv(SemaRef, Loc, T, ConvTy)
6402        << FixItHint::CreateInsertion(From->getBeginLoc(),
6403                                      "static_cast<" + TypeStr + ">(")
6404        << FixItHint::CreateInsertion(
6405               SemaRef.getLocForEndOfToken(From->getEndLoc()), ")");
6406    Converter.noteExplicitConv(SemaRef, Conversion, ConvTy);
6407
6408    // If we aren't in a SFINAE context, build a call to the
6409    // explicit conversion function.
6410    if (SemaRef.isSFINAEContext())
6411      return true;
6412
6413    SemaRef.CheckMemberOperatorAccess(From->getExprLoc(), From, nullptr, Found);
6414    ExprResult Result = SemaRef.BuildCXXMemberCallExpr(From, Found, Conversion,
6415                                                       HadMultipleCandidates);
6416    if (Result.isInvalid())
6417      return true;
6418    // Record usage of conversion in an implicit cast.
6419    From = ImplicitCastExpr::Create(SemaRef.Context, Result.get()->getType(),
6420                                    CK_UserDefinedConversion, Result.get(),
6421                                    nullptr, Result.get()->getValueKind(),
6422                                    SemaRef.CurFPFeatureOverrides());
6423  }
6424  return false;
6425}
6426
6427static bool recordConversion(Sema &SemaRef, SourceLocation Loc, Expr *&From,
6428                             Sema::ContextualImplicitConverter &Converter,
6429                             QualType T, bool HadMultipleCandidates,
6430                             DeclAccessPair &Found) {
6431  CXXConversionDecl *Conversion =
6432      cast<CXXConversionDecl>(Found->getUnderlyingDecl());
6433  SemaRef.CheckMemberOperatorAccess(From->getExprLoc(), From, nullptr, Found);
6434
6435  QualType ToType = Conversion->getConversionType().getNonReferenceType();
6436  if (!Converter.SuppressConversion) {
6437    if (SemaRef.isSFINAEContext())
6438      return true;
6439
6440    Converter.diagnoseConversion(SemaRef, Loc, T, ToType)
6441        << From->getSourceRange();
6442  }
6443
6444  ExprResult Result = SemaRef.BuildCXXMemberCallExpr(From, Found, Conversion,
6445                                                     HadMultipleCandidates);
6446  if (Result.isInvalid())
6447    return true;
6448  // Record usage of conversion in an implicit cast.
6449  From = ImplicitCastExpr::Create(SemaRef.Context, Result.get()->getType(),
6450                                  CK_UserDefinedConversion, Result.get(),
6451                                  nullptr, Result.get()->getValueKind(),
6452                                  SemaRef.CurFPFeatureOverrides());
6453  return false;
6454}
6455
6456static ExprResult finishContextualImplicitConversion(
6457    Sema &SemaRef, SourceLocation Loc, Expr *From,
6458    Sema::ContextualImplicitConverter &Converter) {
6459  if (!Converter.match(From->getType()) && !Converter.Suppress)
6460    Converter.diagnoseNoMatch(SemaRef, Loc, From->getType())
6461        << From->getSourceRange();
6462
6463  return SemaRef.DefaultLvalueConversion(From);
6464}
6465
6466static void
6467collectViableConversionCandidates(Sema &SemaRef, Expr *From, QualType ToType,
6468                                  UnresolvedSetImpl &ViableConversions,
6469                                  OverloadCandidateSet &CandidateSet) {
6470  for (unsigned I = 0, N = ViableConversions.size(); I != N; ++I) {
6471    DeclAccessPair FoundDecl = ViableConversions[I];
6472    NamedDecl *D = FoundDecl.getDecl();
6473    CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext());
6474    if (isa<UsingShadowDecl>(D))
6475      D = cast<UsingShadowDecl>(D)->getTargetDecl();
6476
6477    CXXConversionDecl *Conv;
6478    FunctionTemplateDecl *ConvTemplate;
6479    if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D)))
6480      Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
6481    else
6482      Conv = cast<CXXConversionDecl>(D);
6483
6484    if (ConvTemplate)
6485      SemaRef.AddTemplateConversionCandidate(
6486          ConvTemplate, FoundDecl, ActingContext, From, ToType, CandidateSet,
6487          /*AllowObjCConversionOnExplicit=*/false, /*AllowExplicit*/ true);
6488    else
6489      SemaRef.AddConversionCandidate(Conv, FoundDecl, ActingContext, From,
6490                                     ToType, CandidateSet,
6491                                     /*AllowObjCConversionOnExplicit=*/false,
6492                                     /*AllowExplicit*/ true);
6493  }
6494}
6495
6496/// Attempt to convert the given expression to a type which is accepted
6497/// by the given converter.
6498///
6499/// This routine will attempt to convert an expression of class type to a
6500/// type accepted by the specified converter. In C++11 and before, the class
6501/// must have a single non-explicit conversion function converting to a matching
6502/// type. In C++1y, there can be multiple such conversion functions, but only
6503/// one target type.
6504///
6505/// \param Loc The source location of the construct that requires the
6506/// conversion.
6507///
6508/// \param From The expression we're converting from.
6509///
6510/// \param Converter Used to control and diagnose the conversion process.
6511///
6512/// \returns The expression, converted to an integral or enumeration type if
6513/// successful.
6514ExprResult Sema::PerformContextualImplicitConversion(
6515    SourceLocation Loc, Expr *From, ContextualImplicitConverter &Converter) {
6516  // We can't perform any more checking for type-dependent expressions.
6517  if (From->isTypeDependent())
6518    return From;
6519
6520  // Process placeholders immediately.
6521  if (From->hasPlaceholderType()) {
6522    ExprResult result = CheckPlaceholderExpr(From);
6523    if (result.isInvalid())
6524      return result;
6525    From = result.get();
6526  }
6527
6528  // Try converting the expression to an Lvalue first, to get rid of qualifiers.
6529  ExprResult Converted = DefaultLvalueConversion(From);
6530  QualType T = Converted.isUsable() ? Converted.get()->getType() : QualType();
6531  // If the expression already has a matching type, we're golden.
6532  if (Converter.match(T))
6533    return Converted;
6534
6535  // FIXME: Check for missing '()' if T is a function type?
6536
6537  // We can only perform contextual implicit conversions on objects of class
6538  // type.
6539  const RecordType *RecordTy = T->getAs<RecordType>();
6540  if (!RecordTy || !getLangOpts().CPlusPlus) {
6541    if (!Converter.Suppress)
6542      Converter.diagnoseNoMatch(*this, Loc, T) << From->getSourceRange();
6543    return From;
6544  }
6545
6546  // We must have a complete class type.
6547  struct TypeDiagnoserPartialDiag : TypeDiagnoser {
6548    ContextualImplicitConverter &Converter;
6549    Expr *From;
6550
6551    TypeDiagnoserPartialDiag(ContextualImplicitConverter &Converter, Expr *From)
6552        : Converter(Converter), From(From) {}
6553
6554    void diagnose(Sema &S, SourceLocation Loc, QualType T) override {
6555      Converter.diagnoseIncomplete(S, Loc, T) << From->getSourceRange();
6556    }
6557  } IncompleteDiagnoser(Converter, From);
6558
6559  if (Converter.Suppress ? !isCompleteType(Loc, T)
6560                         : RequireCompleteType(Loc, T, IncompleteDiagnoser))
6561    return From;
6562
6563  // Look for a conversion to an integral or enumeration type.
6564  UnresolvedSet<4>
6565      ViableConversions; // These are *potentially* viable in C++1y.
6566  UnresolvedSet<4> ExplicitConversions;
6567  const auto &Conversions =
6568      cast<CXXRecordDecl>(RecordTy->getDecl())->getVisibleConversionFunctions();
6569
6570  bool HadMultipleCandidates =
6571      (std::distance(Conversions.begin(), Conversions.end()) > 1);
6572
6573  // To check that there is only one target type, in C++1y:
6574  QualType ToType;
6575  bool HasUniqueTargetType = true;
6576
6577  // Collect explicit or viable (potentially in C++1y) conversions.
6578  for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
6579    NamedDecl *D = (*I)->getUnderlyingDecl();
6580    CXXConversionDecl *Conversion;
6581    FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
6582    if (ConvTemplate) {
6583      if (getLangOpts().CPlusPlus14)
6584        Conversion = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
6585      else
6586        continue; // C++11 does not consider conversion operator templates(?).
6587    } else
6588      Conversion = cast<CXXConversionDecl>(D);
6589
6590    assert((!ConvTemplate || getLangOpts().CPlusPlus14) &&
6591           "Conversion operator templates are considered potentially "
6592           "viable in C++1y");
6593
6594    QualType CurToType = Conversion->getConversionType().getNonReferenceType();
6595    if (Converter.match(CurToType) || ConvTemplate) {
6596
6597      if (Conversion->isExplicit()) {
6598        // FIXME: For C++1y, do we need this restriction?
6599        // cf. diagnoseNoViableConversion()
6600        if (!ConvTemplate)
6601          ExplicitConversions.addDecl(I.getDecl(), I.getAccess());
6602      } else {
6603        if (!ConvTemplate && getLangOpts().CPlusPlus14) {
6604          if (ToType.isNull())
6605            ToType = CurToType.getUnqualifiedType();
6606          else if (HasUniqueTargetType &&
6607                   (CurToType.getUnqualifiedType() != ToType))
6608            HasUniqueTargetType = false;
6609        }
6610        ViableConversions.addDecl(I.getDecl(), I.getAccess());
6611      }
6612    }
6613  }
6614
6615  if (getLangOpts().CPlusPlus14) {
6616    // C++1y [conv]p6:
6617    // ... An expression e of class type E appearing in such a context
6618    // is said to be contextually implicitly converted to a specified
6619    // type T and is well-formed if and only if e can be implicitly
6620    // converted to a type T that is determined as follows: E is searched
6621    // for conversion functions whose return type is cv T or reference to
6622    // cv T such that T is allowed by the context. There shall be
6623    // exactly one such T.
6624
6625    // If no unique T is found:
6626    if (ToType.isNull()) {
6627      if (diagnoseNoViableConversion(*this, Loc, From, Converter, T,
6628                                     HadMultipleCandidates,
6629                                     ExplicitConversions))
6630        return ExprError();
6631      return finishContextualImplicitConversion(*this, Loc, From, Converter);
6632    }
6633
6634    // If more than one unique Ts are found:
6635    if (!HasUniqueTargetType)
6636      return diagnoseAmbiguousConversion(*this, Loc, From, Converter, T,
6637                                         ViableConversions);
6638
6639    // If one unique T is found:
6640    // First, build a candidate set from the previously recorded
6641    // potentially viable conversions.
6642    OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
6643    collectViableConversionCandidates(*this, From, ToType, ViableConversions,
6644                                      CandidateSet);
6645
6646    // Then, perform overload resolution over the candidate set.
6647    OverloadCandidateSet::iterator Best;
6648    switch (CandidateSet.BestViableFunction(*this, Loc, Best)) {
6649    case OR_Success: {
6650      // Apply this conversion.
6651      DeclAccessPair Found =
6652          DeclAccessPair::make(Best->Function, Best->FoundDecl.getAccess());
6653      if (recordConversion(*this, Loc, From, Converter, T,
6654                           HadMultipleCandidates, Found))
6655        return ExprError();
6656      break;
6657    }
6658    case OR_Ambiguous:
6659      return diagnoseAmbiguousConversion(*this, Loc, From, Converter, T,
6660                                         ViableConversions);
6661    case OR_No_Viable_Function:
6662      if (diagnoseNoViableConversion(*this, Loc, From, Converter, T,
6663                                     HadMultipleCandidates,
6664                                     ExplicitConversions))
6665        return ExprError();
6666      [[fallthrough]];
6667    case OR_Deleted:
6668      // We'll complain below about a non-integral condition type.
6669      break;
6670    }
6671  } else {
6672    switch (ViableConversions.size()) {
6673    case 0: {
6674      if (diagnoseNoViableConversion(*this, Loc, From, Converter, T,
6675                                     HadMultipleCandidates,
6676                                     ExplicitConversions))
6677        return ExprError();
6678
6679      // We'll complain below about a non-integral condition type.
6680      break;
6681    }
6682    case 1: {
6683      // Apply this conversion.
6684      DeclAccessPair Found = ViableConversions[0];
6685      if (recordConversion(*this, Loc, From, Converter, T,
6686                           HadMultipleCandidates, Found))
6687        return ExprError();
6688      break;
6689    }
6690    default:
6691      return diagnoseAmbiguousConversion(*this, Loc, From, Converter, T,
6692                                         ViableConversions);
6693    }
6694  }
6695
6696  return finishContextualImplicitConversion(*this, Loc, From, Converter);
6697}
6698
6699/// IsAcceptableNonMemberOperatorCandidate - Determine whether Fn is
6700/// an acceptable non-member overloaded operator for a call whose
6701/// arguments have types T1 (and, if non-empty, T2). This routine
6702/// implements the check in C++ [over.match.oper]p3b2 concerning
6703/// enumeration types.
6704static bool IsAcceptableNonMemberOperatorCandidate(ASTContext &Context,
6705                                                   FunctionDecl *Fn,
6706                                                   ArrayRef<Expr *> Args) {
6707  QualType T1 = Args[0]->getType();
6708  QualType T2 = Args.size() > 1 ? Args[1]->getType() : QualType();
6709
6710  if (T1->isDependentType() || (!T2.isNull() && T2->isDependentType()))
6711    return true;
6712
6713  if (T1->isRecordType() || (!T2.isNull() && T2->isRecordType()))
6714    return true;
6715
6716  const auto *Proto = Fn->getType()->castAs<FunctionProtoType>();
6717  if (Proto->getNumParams() < 1)
6718    return false;
6719
6720  if (T1->isEnumeralType()) {
6721    QualType ArgType = Proto->getParamType(0).getNonReferenceType();
6722    if (Context.hasSameUnqualifiedType(T1, ArgType))
6723      return true;
6724  }
6725
6726  if (Proto->getNumParams() < 2)
6727    return false;
6728
6729  if (!T2.isNull() && T2->isEnumeralType()) {
6730    QualType ArgType = Proto->getParamType(1).getNonReferenceType();
6731    if (Context.hasSameUnqualifiedType(T2, ArgType))
6732      return true;
6733  }
6734
6735  return false;
6736}
6737
6738/// AddOverloadCandidate - Adds the given function to the set of
6739/// candidate functions, using the given function call arguments.  If
6740/// @p SuppressUserConversions, then don't allow user-defined
6741/// conversions via constructors or conversion operators.
6742///
6743/// \param PartialOverloading true if we are performing "partial" overloading
6744/// based on an incomplete set of function arguments. This feature is used by
6745/// code completion.
6746void Sema::AddOverloadCandidate(
6747    FunctionDecl *Function, DeclAccessPair FoundDecl, ArrayRef<Expr *> Args,
6748    OverloadCandidateSet &CandidateSet, bool SuppressUserConversions,
6749    bool PartialOverloading, bool AllowExplicit, bool AllowExplicitConversions,
6750    ADLCallKind IsADLCandidate, ConversionSequenceList EarlyConversions,
6751    OverloadCandidateParamOrder PO, bool AggregateCandidateDeduction) {
6752  const FunctionProtoType *Proto
6753    = dyn_cast<FunctionProtoType>(Function->getType()->getAs<FunctionType>());
6754  assert(Proto && "Functions without a prototype cannot be overloaded");
6755  assert(!Function->getDescribedFunctionTemplate() &&
6756         "Use AddTemplateOverloadCandidate for function templates");
6757
6758  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Function)) {
6759    if (!isa<CXXConstructorDecl>(Method)) {
6760      // If we get here, it's because we're calling a member function
6761      // that is named without a member access expression (e.g.,
6762      // "this->f") that was either written explicitly or created
6763      // implicitly. This can happen with a qualified call to a member
6764      // function, e.g., X::f(). We use an empty type for the implied
6765      // object argument (C++ [over.call.func]p3), and the acting context
6766      // is irrelevant.
6767      AddMethodCandidate(Method, FoundDecl, Method->getParent(), QualType(),
6768                         Expr::Classification::makeSimpleLValue(), Args,
6769                         CandidateSet, SuppressUserConversions,
6770                         PartialOverloading, EarlyConversions, PO);
6771      return;
6772    }
6773    // We treat a constructor like a non-member function, since its object
6774    // argument doesn't participate in overload resolution.
6775  }
6776
6777  if (!CandidateSet.isNewCandidate(Function, PO))
6778    return;
6779
6780  // C++11 [class.copy]p11: [DR1402]
6781  //   A defaulted move constructor that is defined as deleted is ignored by
6782  //   overload resolution.
6783  CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Function);
6784  if (Constructor && Constructor->isDefaulted() && Constructor->isDeleted() &&
6785      Constructor->isMoveConstructor())
6786    return;
6787
6788  // Overload resolution is always an unevaluated context.
6789  EnterExpressionEvaluationContext Unevaluated(
6790      *this, Sema::ExpressionEvaluationContext::Unevaluated);
6791
6792  // C++ [over.match.oper]p3:
6793  //   if no operand has a class type, only those non-member functions in the
6794  //   lookup set that have a first parameter of type T1 or "reference to
6795  //   (possibly cv-qualified) T1", when T1 is an enumeration type, or (if there
6796  //   is a right operand) a second parameter of type T2 or "reference to
6797  //   (possibly cv-qualified) T2", when T2 is an enumeration type, are
6798  //   candidate functions.
6799  if (CandidateSet.getKind() == OverloadCandidateSet::CSK_Operator &&
6800      !IsAcceptableNonMemberOperatorCandidate(Context, Function, Args))
6801    return;
6802
6803  // Add this candidate
6804  OverloadCandidate &Candidate =
6805      CandidateSet.addCandidate(Args.size(), EarlyConversions);
6806  Candidate.FoundDecl = FoundDecl;
6807  Candidate.Function = Function;
6808  Candidate.Viable = true;
6809  Candidate.RewriteKind =
6810      CandidateSet.getRewriteInfo().getRewriteKind(Function, PO);
6811  Candidate.IsSurrogate = false;
6812  Candidate.IsADLCandidate = IsADLCandidate;
6813  Candidate.IgnoreObjectArgument = false;
6814  Candidate.ExplicitCallArguments = Args.size();
6815
6816  // Explicit functions are not actually candidates at all if we're not
6817  // allowing them in this context, but keep them around so we can point
6818  // to them in diagnostics.
6819  if (!AllowExplicit && ExplicitSpecifier::getFromDecl(Function).isExplicit()) {
6820    Candidate.Viable = false;
6821    Candidate.FailureKind = ovl_fail_explicit;
6822    return;
6823  }
6824
6825  // Functions with internal linkage are only viable in the same module unit.
6826  if (getLangOpts().CPlusPlusModules && Function->isInAnotherModuleUnit()) {
6827    /// FIXME: Currently, the semantics of linkage in clang is slightly
6828    /// different from the semantics in C++ spec. In C++ spec, only names
6829    /// have linkage. So that all entities of the same should share one
6830    /// linkage. But in clang, different entities of the same could have
6831    /// different linkage.
6832    NamedDecl *ND = Function;
6833    if (auto *SpecInfo = Function->getTemplateSpecializationInfo())
6834      ND = SpecInfo->getTemplate();
6835
6836    if (ND->getFormalLinkage() == Linkage::Internal) {
6837      Candidate.Viable = false;
6838      Candidate.FailureKind = ovl_fail_module_mismatched;
6839      return;
6840    }
6841  }
6842
6843  if (Function->isMultiVersion() &&
6844      ((Function->hasAttr<TargetAttr>() &&
6845        !Function->getAttr<TargetAttr>()->isDefaultVersion()) ||
6846       (Function->hasAttr<TargetVersionAttr>() &&
6847        !Function->getAttr<TargetVersionAttr>()->isDefaultVersion()))) {
6848    Candidate.Viable = false;
6849    Candidate.FailureKind = ovl_non_default_multiversion_function;
6850    return;
6851  }
6852
6853  if (Constructor) {
6854    // C++ [class.copy]p3:
6855    //   A member function template is never instantiated to perform the copy
6856    //   of a class object to an object of its class type.
6857    QualType ClassType = Context.getTypeDeclType(Constructor->getParent());
6858    if (Args.size() == 1 && Constructor->isSpecializationCopyingObject() &&
6859        (Context.hasSameUnqualifiedType(ClassType, Args[0]->getType()) ||
6860         IsDerivedFrom(Args[0]->getBeginLoc(), Args[0]->getType(),
6861                       ClassType))) {
6862      Candidate.Viable = false;
6863      Candidate.FailureKind = ovl_fail_illegal_constructor;
6864      return;
6865    }
6866
6867    // C++ [over.match.funcs]p8: (proposed DR resolution)
6868    //   A constructor inherited from class type C that has a first parameter
6869    //   of type "reference to P" (including such a constructor instantiated
6870    //   from a template) is excluded from the set of candidate functions when
6871    //   constructing an object of type cv D if the argument list has exactly
6872    //   one argument and D is reference-related to P and P is reference-related
6873    //   to C.
6874    auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(FoundDecl.getDecl());
6875    if (Shadow && Args.size() == 1 && Constructor->getNumParams() >= 1 &&
6876        Constructor->getParamDecl(0)->getType()->isReferenceType()) {
6877      QualType P = Constructor->getParamDecl(0)->getType()->getPointeeType();
6878      QualType C = Context.getRecordType(Constructor->getParent());
6879      QualType D = Context.getRecordType(Shadow->getParent());
6880      SourceLocation Loc = Args.front()->getExprLoc();
6881      if ((Context.hasSameUnqualifiedType(P, C) || IsDerivedFrom(Loc, P, C)) &&
6882          (Context.hasSameUnqualifiedType(D, P) || IsDerivedFrom(Loc, D, P))) {
6883        Candidate.Viable = false;
6884        Candidate.FailureKind = ovl_fail_inhctor_slice;
6885        return;
6886      }
6887    }
6888
6889    // Check that the constructor is capable of constructing an object in the
6890    // destination address space.
6891    if (!Qualifiers::isAddressSpaceSupersetOf(
6892            Constructor->getMethodQualifiers().getAddressSpace(),
6893            CandidateSet.getDestAS())) {
6894      Candidate.Viable = false;
6895      Candidate.FailureKind = ovl_fail_object_addrspace_mismatch;
6896    }
6897  }
6898
6899  unsigned NumParams = Proto->getNumParams();
6900
6901  // (C++ 13.3.2p2): A candidate function having fewer than m
6902  // parameters is viable only if it has an ellipsis in its parameter
6903  // list (8.3.5).
6904  if (TooManyArguments(NumParams, Args.size(), PartialOverloading) &&
6905      !Proto->isVariadic() &&
6906      shouldEnforceArgLimit(PartialOverloading, Function)) {
6907    Candidate.Viable = false;
6908    Candidate.FailureKind = ovl_fail_too_many_arguments;
6909    return;
6910  }
6911
6912  // (C++ 13.3.2p2): A candidate function having more than m parameters
6913  // is viable only if the (m+1)st parameter has a default argument
6914  // (8.3.6). For the purposes of overload resolution, the
6915  // parameter list is truncated on the right, so that there are
6916  // exactly m parameters.
6917  unsigned MinRequiredArgs = Function->getMinRequiredArguments();
6918  if (!AggregateCandidateDeduction && Args.size() < MinRequiredArgs &&
6919      !PartialOverloading) {
6920    // Not enough arguments.
6921    Candidate.Viable = false;
6922    Candidate.FailureKind = ovl_fail_too_few_arguments;
6923    return;
6924  }
6925
6926  // (CUDA B.1): Check for invalid calls between targets.
6927  if (getLangOpts().CUDA) {
6928    const FunctionDecl *Caller = getCurFunctionDecl(/*AllowLambda=*/true);
6929    // Skip the check for callers that are implicit members, because in this
6930    // case we may not yet know what the member's target is; the target is
6931    // inferred for the member automatically, based on the bases and fields of
6932    // the class.
6933    if (!(Caller && Caller->isImplicit()) &&
6934        !IsAllowedCUDACall(Caller, Function)) {
6935      Candidate.Viable = false;
6936      Candidate.FailureKind = ovl_fail_bad_target;
6937      return;
6938    }
6939  }
6940
6941  if (Function->getTrailingRequiresClause()) {
6942    ConstraintSatisfaction Satisfaction;
6943    if (CheckFunctionConstraints(Function, Satisfaction, /*Loc*/ {},
6944                                 /*ForOverloadResolution*/ true) ||
6945        !Satisfaction.IsSatisfied) {
6946      Candidate.Viable = false;
6947      Candidate.FailureKind = ovl_fail_constraints_not_satisfied;
6948      return;
6949    }
6950  }
6951
6952  // Determine the implicit conversion sequences for each of the
6953  // arguments.
6954  for (unsigned ArgIdx = 0; ArgIdx < Args.size(); ++ArgIdx) {
6955    unsigned ConvIdx =
6956        PO == OverloadCandidateParamOrder::Reversed ? 1 - ArgIdx : ArgIdx;
6957    if (Candidate.Conversions[ConvIdx].isInitialized()) {
6958      // We already formed a conversion sequence for this parameter during
6959      // template argument deduction.
6960    } else if (ArgIdx < NumParams) {
6961      // (C++ 13.3.2p3): for F to be a viable function, there shall
6962      // exist for each argument an implicit conversion sequence
6963      // (13.3.3.1) that converts that argument to the corresponding
6964      // parameter of F.
6965      QualType ParamType = Proto->getParamType(ArgIdx);
6966      Candidate.Conversions[ConvIdx] = TryCopyInitialization(
6967          *this, Args[ArgIdx], ParamType, SuppressUserConversions,
6968          /*InOverloadResolution=*/true,
6969          /*AllowObjCWritebackConversion=*/
6970          getLangOpts().ObjCAutoRefCount, AllowExplicitConversions);
6971      if (Candidate.Conversions[ConvIdx].isBad()) {
6972        Candidate.Viable = false;
6973        Candidate.FailureKind = ovl_fail_bad_conversion;
6974        return;
6975      }
6976    } else {
6977      // (C++ 13.3.2p2): For the purposes of overload resolution, any
6978      // argument for which there is no corresponding parameter is
6979      // considered to ""match the ellipsis" (C+ 13.3.3.1.3).
6980      Candidate.Conversions[ConvIdx].setEllipsis();
6981    }
6982  }
6983
6984  if (EnableIfAttr *FailedAttr =
6985          CheckEnableIf(Function, CandidateSet.getLocation(), Args)) {
6986    Candidate.Viable = false;
6987    Candidate.FailureKind = ovl_fail_enable_if;
6988    Candidate.DeductionFailure.Data = FailedAttr;
6989    return;
6990  }
6991}
6992
6993ObjCMethodDecl *
6994Sema::SelectBestMethod(Selector Sel, MultiExprArg Args, bool IsInstance,
6995                       SmallVectorImpl<ObjCMethodDecl *> &Methods) {
6996  if (Methods.size() <= 1)
6997    return nullptr;
6998
6999  for (unsigned b = 0, e = Methods.size(); b < e; b++) {
7000    bool Match = true;
7001    ObjCMethodDecl *Method = Methods[b];
7002    unsigned NumNamedArgs = Sel.getNumArgs();
7003    // Method might have more arguments than selector indicates. This is due
7004    // to addition of c-style arguments in method.
7005    if (Method->param_size() > NumNamedArgs)
7006      NumNamedArgs = Method->param_size();
7007    if (Args.size() < NumNamedArgs)
7008      continue;
7009
7010    for (unsigned i = 0; i < NumNamedArgs; i++) {
7011      // We can't do any type-checking on a type-dependent argument.
7012      if (Args[i]->isTypeDependent()) {
7013        Match = false;
7014        break;
7015      }
7016
7017      ParmVarDecl *param = Method->parameters()[i];
7018      Expr *argExpr = Args[i];
7019      assert(argExpr && "SelectBestMethod(): missing expression");
7020
7021      // Strip the unbridged-cast placeholder expression off unless it's
7022      // a consumed argument.
7023      if (argExpr->hasPlaceholderType(BuiltinType::ARCUnbridgedCast) &&
7024          !param->hasAttr<CFConsumedAttr>())
7025        argExpr = stripARCUnbridgedCast(argExpr);
7026
7027      // If the parameter is __unknown_anytype, move on to the next method.
7028      if (param->getType() == Context.UnknownAnyTy) {
7029        Match = false;
7030        break;
7031      }
7032
7033      ImplicitConversionSequence ConversionState
7034        = TryCopyInitialization(*this, argExpr, param->getType(),
7035                                /*SuppressUserConversions*/false,
7036                                /*InOverloadResolution=*/true,
7037                                /*AllowObjCWritebackConversion=*/
7038                                getLangOpts().ObjCAutoRefCount,
7039                                /*AllowExplicit*/false);
7040      // This function looks for a reasonably-exact match, so we consider
7041      // incompatible pointer conversions to be a failure here.
7042      if (ConversionState.isBad() ||
7043          (ConversionState.isStandard() &&
7044           ConversionState.Standard.Second ==
7045               ICK_Incompatible_Pointer_Conversion)) {
7046        Match = false;
7047        break;
7048      }
7049    }
7050    // Promote additional arguments to variadic methods.
7051    if (Match && Method->isVariadic()) {
7052      for (unsigned i = NumNamedArgs, e = Args.size(); i < e; ++i) {
7053        if (Args[i]->isTypeDependent()) {
7054          Match = false;
7055          break;
7056        }
7057        ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], VariadicMethod,
7058                                                          nullptr);
7059        if (Arg.isInvalid()) {
7060          Match = false;
7061          break;
7062        }
7063      }
7064    } else {
7065      // Check for extra arguments to non-variadic methods.
7066      if (Args.size() != NumNamedArgs)
7067        Match = false;
7068      else if (Match && NumNamedArgs == 0 && Methods.size() > 1) {
7069        // Special case when selectors have no argument. In this case, select
7070        // one with the most general result type of 'id'.
7071        for (unsigned b = 0, e = Methods.size(); b < e; b++) {
7072          QualType ReturnT = Methods[b]->getReturnType();
7073          if (ReturnT->isObjCIdType())
7074            return Methods[b];
7075        }
7076      }
7077    }
7078
7079    if (Match)
7080      return Method;
7081  }
7082  return nullptr;
7083}
7084
7085static bool convertArgsForAvailabilityChecks(
7086    Sema &S, FunctionDecl *Function, Expr *ThisArg, SourceLocation CallLoc,
7087    ArrayRef<Expr *> Args, Sema::SFINAETrap &Trap, bool MissingImplicitThis,
7088    Expr *&ConvertedThis, SmallVectorImpl<Expr *> &ConvertedArgs) {
7089  if (ThisArg) {
7090    CXXMethodDecl *Method = cast<CXXMethodDecl>(Function);
7091    assert(!isa<CXXConstructorDecl>(Method) &&
7092           "Shouldn't have `this` for ctors!");
7093    assert(!Method->isStatic() && "Shouldn't have `this` for static methods!");
7094    ExprResult R = S.PerformImplicitObjectArgumentInitialization(
7095        ThisArg, /*Qualifier=*/nullptr, Method, Method);
7096    if (R.isInvalid())
7097      return false;
7098    ConvertedThis = R.get();
7099  } else {
7100    if (auto *MD = dyn_cast<CXXMethodDecl>(Function)) {
7101      (void)MD;
7102      assert((MissingImplicitThis || MD->isStatic() ||
7103              isa<CXXConstructorDecl>(MD)) &&
7104             "Expected `this` for non-ctor instance methods");
7105    }
7106    ConvertedThis = nullptr;
7107  }
7108
7109  // Ignore any variadic arguments. Converting them is pointless, since the
7110  // user can't refer to them in the function condition.
7111  unsigned ArgSizeNoVarargs = std::min(Function->param_size(), Args.size());
7112
7113  // Convert the arguments.
7114  for (unsigned I = 0; I != ArgSizeNoVarargs; ++I) {
7115    ExprResult R;
7116    R = S.PerformCopyInitialization(InitializedEntity::InitializeParameter(
7117                                        S.Context, Function->getParamDecl(I)),
7118                                    SourceLocation(), Args[I]);
7119
7120    if (R.isInvalid())
7121      return false;
7122
7123    ConvertedArgs.push_back(R.get());
7124  }
7125
7126  if (Trap.hasErrorOccurred())
7127    return false;
7128
7129  // Push default arguments if needed.
7130  if (!Function->isVariadic() && Args.size() < Function->getNumParams()) {
7131    for (unsigned i = Args.size(), e = Function->getNumParams(); i != e; ++i) {
7132      ParmVarDecl *P = Function->getParamDecl(i);
7133      if (!P->hasDefaultArg())
7134        return false;
7135      ExprResult R = S.BuildCXXDefaultArgExpr(CallLoc, Function, P);
7136      if (R.isInvalid())
7137        return false;
7138      ConvertedArgs.push_back(R.get());
7139    }
7140
7141    if (Trap.hasErrorOccurred())
7142      return false;
7143  }
7144  return true;
7145}
7146
7147EnableIfAttr *Sema::CheckEnableIf(FunctionDecl *Function,
7148                                  SourceLocation CallLoc,
7149                                  ArrayRef<Expr *> Args,
7150                                  bool MissingImplicitThis) {
7151  auto EnableIfAttrs = Function->specific_attrs<EnableIfAttr>();
7152  if (EnableIfAttrs.begin() == EnableIfAttrs.end())
7153    return nullptr;
7154
7155  SFINAETrap Trap(*this);
7156  SmallVector<Expr *, 16> ConvertedArgs;
7157  // FIXME: We should look into making enable_if late-parsed.
7158  Expr *DiscardedThis;
7159  if (!convertArgsForAvailabilityChecks(
7160          *this, Function, /*ThisArg=*/nullptr, CallLoc, Args, Trap,
7161          /*MissingImplicitThis=*/true, DiscardedThis, ConvertedArgs))
7162    return *EnableIfAttrs.begin();
7163
7164  for (auto *EIA : EnableIfAttrs) {
7165    APValue Result;
7166    // FIXME: This doesn't consider value-dependent cases, because doing so is
7167    // very difficult. Ideally, we should handle them more gracefully.
7168    if (EIA->getCond()->isValueDependent() ||
7169        !EIA->getCond()->EvaluateWithSubstitution(
7170            Result, Context, Function, llvm::ArrayRef(ConvertedArgs)))
7171      return EIA;
7172
7173    if (!Result.isInt() || !Result.getInt().getBoolValue())
7174      return EIA;
7175  }
7176  return nullptr;
7177}
7178
7179template <typename CheckFn>
7180static bool diagnoseDiagnoseIfAttrsWith(Sema &S, const NamedDecl *ND,
7181                                        bool ArgDependent, SourceLocation Loc,
7182                                        CheckFn &&IsSuccessful) {
7183  SmallVector<const DiagnoseIfAttr *, 8> Attrs;
7184  for (const auto *DIA : ND->specific_attrs<DiagnoseIfAttr>()) {
7185    if (ArgDependent == DIA->getArgDependent())
7186      Attrs.push_back(DIA);
7187  }
7188
7189  // Common case: No diagnose_if attributes, so we can quit early.
7190  if (Attrs.empty())
7191    return false;
7192
7193  auto WarningBegin = std::stable_partition(
7194      Attrs.begin(), Attrs.end(),
7195      [](const DiagnoseIfAttr *DIA) { return DIA->isError(); });
7196
7197  // Note that diagnose_if attributes are late-parsed, so they appear in the
7198  // correct order (unlike enable_if attributes).
7199  auto ErrAttr = llvm::find_if(llvm::make_range(Attrs.begin(), WarningBegin),
7200                               IsSuccessful);
7201  if (ErrAttr != WarningBegin) {
7202    const DiagnoseIfAttr *DIA = *ErrAttr;
7203    S.Diag(Loc, diag::err_diagnose_if_succeeded) << DIA->getMessage();
7204    S.Diag(DIA->getLocation(), diag::note_from_diagnose_if)
7205        << DIA->getParent() << DIA->getCond()->getSourceRange();
7206    return true;
7207  }
7208
7209  for (const auto *DIA : llvm::make_range(WarningBegin, Attrs.end()))
7210    if (IsSuccessful(DIA)) {
7211      S.Diag(Loc, diag::warn_diagnose_if_succeeded) << DIA->getMessage();
7212      S.Diag(DIA->getLocation(), diag::note_from_diagnose_if)
7213          << DIA->getParent() << DIA->getCond()->getSourceRange();
7214    }
7215
7216  return false;
7217}
7218
7219bool Sema::diagnoseArgDependentDiagnoseIfAttrs(const FunctionDecl *Function,
7220                                               const Expr *ThisArg,
7221                                               ArrayRef<const Expr *> Args,
7222                                               SourceLocation Loc) {
7223  return diagnoseDiagnoseIfAttrsWith(
7224      *this, Function, /*ArgDependent=*/true, Loc,
7225      [&](const DiagnoseIfAttr *DIA) {
7226        APValue Result;
7227        // It's sane to use the same Args for any redecl of this function, since
7228        // EvaluateWithSubstitution only cares about the position of each
7229        // argument in the arg list, not the ParmVarDecl* it maps to.
7230        if (!DIA->getCond()->EvaluateWithSubstitution(
7231                Result, Context, cast<FunctionDecl>(DIA->getParent()), Args, ThisArg))
7232          return false;
7233        return Result.isInt() && Result.getInt().getBoolValue();
7234      });
7235}
7236
7237bool Sema::diagnoseArgIndependentDiagnoseIfAttrs(const NamedDecl *ND,
7238                                                 SourceLocation Loc) {
7239  return diagnoseDiagnoseIfAttrsWith(
7240      *this, ND, /*ArgDependent=*/false, Loc,
7241      [&](const DiagnoseIfAttr *DIA) {
7242        bool Result;
7243        return DIA->getCond()->EvaluateAsBooleanCondition(Result, Context) &&
7244               Result;
7245      });
7246}
7247
7248/// Add all of the function declarations in the given function set to
7249/// the overload candidate set.
7250void Sema::AddFunctionCandidates(const UnresolvedSetImpl &Fns,
7251                                 ArrayRef<Expr *> Args,
7252                                 OverloadCandidateSet &CandidateSet,
7253                                 TemplateArgumentListInfo *ExplicitTemplateArgs,
7254                                 bool SuppressUserConversions,
7255                                 bool PartialOverloading,
7256                                 bool FirstArgumentIsBase) {
7257  for (UnresolvedSetIterator F = Fns.begin(), E = Fns.end(); F != E; ++F) {
7258    NamedDecl *D = F.getDecl()->getUnderlyingDecl();
7259    ArrayRef<Expr *> FunctionArgs = Args;
7260
7261    FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D);
7262    FunctionDecl *FD =
7263        FunTmpl ? FunTmpl->getTemplatedDecl() : cast<FunctionDecl>(D);
7264
7265    if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic()) {
7266      QualType ObjectType;
7267      Expr::Classification ObjectClassification;
7268      if (Args.size() > 0) {
7269        if (Expr *E = Args[0]) {
7270          // Use the explicit base to restrict the lookup:
7271          ObjectType = E->getType();
7272          // Pointers in the object arguments are implicitly dereferenced, so we
7273          // always classify them as l-values.
7274          if (!ObjectType.isNull() && ObjectType->isPointerType())
7275            ObjectClassification = Expr::Classification::makeSimpleLValue();
7276          else
7277            ObjectClassification = E->Classify(Context);
7278        } // .. else there is an implicit base.
7279        FunctionArgs = Args.slice(1);
7280      }
7281      if (FunTmpl) {
7282        AddMethodTemplateCandidate(
7283            FunTmpl, F.getPair(),
7284            cast<CXXRecordDecl>(FunTmpl->getDeclContext()),
7285            ExplicitTemplateArgs, ObjectType, ObjectClassification,
7286            FunctionArgs, CandidateSet, SuppressUserConversions,
7287            PartialOverloading);
7288      } else {
7289        AddMethodCandidate(cast<CXXMethodDecl>(FD), F.getPair(),
7290                           cast<CXXMethodDecl>(FD)->getParent(), ObjectType,
7291                           ObjectClassification, FunctionArgs, CandidateSet,
7292                           SuppressUserConversions, PartialOverloading);
7293      }
7294    } else {
7295      // This branch handles both standalone functions and static methods.
7296
7297      // Slice the first argument (which is the base) when we access
7298      // static method as non-static.
7299      if (Args.size() > 0 &&
7300          (!Args[0] || (FirstArgumentIsBase && isa<CXXMethodDecl>(FD) &&
7301                        !isa<CXXConstructorDecl>(FD)))) {
7302        assert(cast<CXXMethodDecl>(FD)->isStatic());
7303        FunctionArgs = Args.slice(1);
7304      }
7305      if (FunTmpl) {
7306        AddTemplateOverloadCandidate(FunTmpl, F.getPair(),
7307                                     ExplicitTemplateArgs, FunctionArgs,
7308                                     CandidateSet, SuppressUserConversions,
7309                                     PartialOverloading);
7310      } else {
7311        AddOverloadCandidate(FD, F.getPair(), FunctionArgs, CandidateSet,
7312                             SuppressUserConversions, PartialOverloading);
7313      }
7314    }
7315  }
7316}
7317
7318/// AddMethodCandidate - Adds a named decl (which is some kind of
7319/// method) as a method candidate to the given overload set.
7320void Sema::AddMethodCandidate(DeclAccessPair FoundDecl, QualType ObjectType,
7321                              Expr::Classification ObjectClassification,
7322                              ArrayRef<Expr *> Args,
7323                              OverloadCandidateSet &CandidateSet,
7324                              bool SuppressUserConversions,
7325                              OverloadCandidateParamOrder PO) {
7326  NamedDecl *Decl = FoundDecl.getDecl();
7327  CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(Decl->getDeclContext());
7328
7329  if (isa<UsingShadowDecl>(Decl))
7330    Decl = cast<UsingShadowDecl>(Decl)->getTargetDecl();
7331
7332  if (FunctionTemplateDecl *TD = dyn_cast<FunctionTemplateDecl>(Decl)) {
7333    assert(isa<CXXMethodDecl>(TD->getTemplatedDecl()) &&
7334           "Expected a member function template");
7335    AddMethodTemplateCandidate(TD, FoundDecl, ActingContext,
7336                               /*ExplicitArgs*/ nullptr, ObjectType,
7337                               ObjectClassification, Args, CandidateSet,
7338                               SuppressUserConversions, false, PO);
7339  } else {
7340    AddMethodCandidate(cast<CXXMethodDecl>(Decl), FoundDecl, ActingContext,
7341                       ObjectType, ObjectClassification, Args, CandidateSet,
7342                       SuppressUserConversions, false, std::nullopt, PO);
7343  }
7344}
7345
7346/// AddMethodCandidate - Adds the given C++ member function to the set
7347/// of candidate functions, using the given function call arguments
7348/// and the object argument (@c Object). For example, in a call
7349/// @c o.f(a1,a2), @c Object will contain @c o and @c Args will contain
7350/// both @c a1 and @c a2. If @p SuppressUserConversions, then don't
7351/// allow user-defined conversions via constructors or conversion
7352/// operators.
7353void
7354Sema::AddMethodCandidate(CXXMethodDecl *Method, DeclAccessPair FoundDecl,
7355                         CXXRecordDecl *ActingContext, QualType ObjectType,
7356                         Expr::Classification ObjectClassification,
7357                         ArrayRef<Expr *> Args,
7358                         OverloadCandidateSet &CandidateSet,
7359                         bool SuppressUserConversions,
7360                         bool PartialOverloading,
7361                         ConversionSequenceList EarlyConversions,
7362                         OverloadCandidateParamOrder PO) {
7363  const FunctionProtoType *Proto
7364    = dyn_cast<FunctionProtoType>(Method->getType()->getAs<FunctionType>());
7365  assert(Proto && "Methods without a prototype cannot be overloaded");
7366  assert(!isa<CXXConstructorDecl>(Method) &&
7367         "Use AddOverloadCandidate for constructors");
7368
7369  if (!CandidateSet.isNewCandidate(Method, PO))
7370    return;
7371
7372  // C++11 [class.copy]p23: [DR1402]
7373  //   A defaulted move assignment operator that is defined as deleted is
7374  //   ignored by overload resolution.
7375  if (Method->isDefaulted() && Method->isDeleted() &&
7376      Method->isMoveAssignmentOperator())
7377    return;
7378
7379  // Overload resolution is always an unevaluated context.
7380  EnterExpressionEvaluationContext Unevaluated(
7381      *this, Sema::ExpressionEvaluationContext::Unevaluated);
7382
7383  // Add this candidate
7384  OverloadCandidate &Candidate =
7385      CandidateSet.addCandidate(Args.size() + 1, EarlyConversions);
7386  Candidate.FoundDecl = FoundDecl;
7387  Candidate.Function = Method;
7388  Candidate.RewriteKind =
7389      CandidateSet.getRewriteInfo().getRewriteKind(Method, PO);
7390  Candidate.IsSurrogate = false;
7391  Candidate.IgnoreObjectArgument = false;
7392  Candidate.ExplicitCallArguments = Args.size();
7393
7394  unsigned NumParams = Method->getNumExplicitParams();
7395  unsigned ExplicitOffset = Method->isExplicitObjectMemberFunction() ? 1 : 0;
7396
7397  // (C++ 13.3.2p2): A candidate function having fewer than m
7398  // parameters is viable only if it has an ellipsis in its parameter
7399  // list (8.3.5).
7400  if (TooManyArguments(NumParams, Args.size(), PartialOverloading) &&
7401      !Proto->isVariadic() &&
7402      shouldEnforceArgLimit(PartialOverloading, Method)) {
7403    Candidate.Viable = false;
7404    Candidate.FailureKind = ovl_fail_too_many_arguments;
7405    return;
7406  }
7407
7408  // (C++ 13.3.2p2): A candidate function having more than m parameters
7409  // is viable only if the (m+1)st parameter has a default argument
7410  // (8.3.6). For the purposes of overload resolution, the
7411  // parameter list is truncated on the right, so that there are
7412  // exactly m parameters.
7413  unsigned MinRequiredArgs = Method->getMinRequiredExplicitArguments();
7414  if (Args.size() < MinRequiredArgs && !PartialOverloading) {
7415    // Not enough arguments.
7416    Candidate.Viable = false;
7417    Candidate.FailureKind = ovl_fail_too_few_arguments;
7418    return;
7419  }
7420
7421  Candidate.Viable = true;
7422
7423  unsigned FirstConvIdx = PO == OverloadCandidateParamOrder::Reversed ? 1 : 0;
7424  if (ObjectType.isNull())
7425    Candidate.IgnoreObjectArgument = true;
7426  else if (Method->isStatic()) {
7427    // [over.best.ics.general]p8
7428    // When the parameter is the implicit object parameter of a static member
7429    // function, the implicit conversion sequence is a standard conversion
7430    // sequence that is neither better nor worse than any other standard
7431    // conversion sequence.
7432    //
7433    // This is a rule that was introduced in C++23 to support static lambdas. We
7434    // apply it retroactively because we want to support static lambdas as an
7435    // extension and it doesn't hurt previous code.
7436    Candidate.Conversions[FirstConvIdx].setStaticObjectArgument();
7437  } else {
7438    // Determine the implicit conversion sequence for the object
7439    // parameter.
7440    Candidate.Conversions[FirstConvIdx] = TryObjectArgumentInitialization(
7441        *this, CandidateSet.getLocation(), ObjectType, ObjectClassification,
7442        Method, ActingContext, /*InOverloadResolution=*/true);
7443    if (Candidate.Conversions[FirstConvIdx].isBad()) {
7444      Candidate.Viable = false;
7445      Candidate.FailureKind = ovl_fail_bad_conversion;
7446      return;
7447    }
7448  }
7449
7450  // (CUDA B.1): Check for invalid calls between targets.
7451  if (getLangOpts().CUDA)
7452    if (!IsAllowedCUDACall(getCurFunctionDecl(/*AllowLambda=*/true), Method)) {
7453      Candidate.Viable = false;
7454      Candidate.FailureKind = ovl_fail_bad_target;
7455      return;
7456    }
7457
7458  if (Method->getTrailingRequiresClause()) {
7459    ConstraintSatisfaction Satisfaction;
7460    if (CheckFunctionConstraints(Method, Satisfaction, /*Loc*/ {},
7461                                 /*ForOverloadResolution*/ true) ||
7462        !Satisfaction.IsSatisfied) {
7463      Candidate.Viable = false;
7464      Candidate.FailureKind = ovl_fail_constraints_not_satisfied;
7465      return;
7466    }
7467  }
7468
7469  // Determine the implicit conversion sequences for each of the
7470  // arguments.
7471  for (unsigned ArgIdx = 0; ArgIdx < Args.size(); ++ArgIdx) {
7472    unsigned ConvIdx =
7473        PO == OverloadCandidateParamOrder::Reversed ? 0 : (ArgIdx + 1);
7474    if (Candidate.Conversions[ConvIdx].isInitialized()) {
7475      // We already formed a conversion sequence for this parameter during
7476      // template argument deduction.
7477    } else if (ArgIdx < NumParams) {
7478      // (C++ 13.3.2p3): for F to be a viable function, there shall
7479      // exist for each argument an implicit conversion sequence
7480      // (13.3.3.1) that converts that argument to the corresponding
7481      // parameter of F.
7482      QualType ParamType = Proto->getParamType(ArgIdx + ExplicitOffset);
7483      Candidate.Conversions[ConvIdx]
7484        = TryCopyInitialization(*this, Args[ArgIdx], ParamType,
7485                                SuppressUserConversions,
7486                                /*InOverloadResolution=*/true,
7487                                /*AllowObjCWritebackConversion=*/
7488                                  getLangOpts().ObjCAutoRefCount);
7489      if (Candidate.Conversions[ConvIdx].isBad()) {
7490        Candidate.Viable = false;
7491        Candidate.FailureKind = ovl_fail_bad_conversion;
7492        return;
7493      }
7494    } else {
7495      // (C++ 13.3.2p2): For the purposes of overload resolution, any
7496      // argument for which there is no corresponding parameter is
7497      // considered to "match the ellipsis" (C+ 13.3.3.1.3).
7498      Candidate.Conversions[ConvIdx].setEllipsis();
7499    }
7500  }
7501
7502  if (EnableIfAttr *FailedAttr =
7503          CheckEnableIf(Method, CandidateSet.getLocation(), Args, true)) {
7504    Candidate.Viable = false;
7505    Candidate.FailureKind = ovl_fail_enable_if;
7506    Candidate.DeductionFailure.Data = FailedAttr;
7507    return;
7508  }
7509
7510  if (Method->isMultiVersion() &&
7511      ((Method->hasAttr<TargetAttr>() &&
7512        !Method->getAttr<TargetAttr>()->isDefaultVersion()) ||
7513       (Method->hasAttr<TargetVersionAttr>() &&
7514        !Method->getAttr<TargetVersionAttr>()->isDefaultVersion()))) {
7515    Candidate.Viable = false;
7516    Candidate.FailureKind = ovl_non_default_multiversion_function;
7517  }
7518}
7519
7520/// Add a C++ member function template as a candidate to the candidate
7521/// set, using template argument deduction to produce an appropriate member
7522/// function template specialization.
7523void Sema::AddMethodTemplateCandidate(
7524    FunctionTemplateDecl *MethodTmpl, DeclAccessPair FoundDecl,
7525    CXXRecordDecl *ActingContext,
7526    TemplateArgumentListInfo *ExplicitTemplateArgs, QualType ObjectType,
7527    Expr::Classification ObjectClassification, ArrayRef<Expr *> Args,
7528    OverloadCandidateSet &CandidateSet, bool SuppressUserConversions,
7529    bool PartialOverloading, OverloadCandidateParamOrder PO) {
7530  if (!CandidateSet.isNewCandidate(MethodTmpl, PO))
7531    return;
7532
7533  // C++ [over.match.funcs]p7:
7534  //   In each case where a candidate is a function template, candidate
7535  //   function template specializations are generated using template argument
7536  //   deduction (14.8.3, 14.8.2). Those candidates are then handled as
7537  //   candidate functions in the usual way.113) A given name can refer to one
7538  //   or more function templates and also to a set of overloaded non-template
7539  //   functions. In such a case, the candidate functions generated from each
7540  //   function template are combined with the set of non-template candidate
7541  //   functions.
7542  TemplateDeductionInfo Info(CandidateSet.getLocation());
7543  FunctionDecl *Specialization = nullptr;
7544  ConversionSequenceList Conversions;
7545  if (TemplateDeductionResult Result = DeduceTemplateArguments(
7546          MethodTmpl, ExplicitTemplateArgs, Args, Specialization, Info,
7547          PartialOverloading, /*AggregateDeductionCandidate=*/false, ObjectType,
7548          ObjectClassification, [&](ArrayRef<QualType> ParamTypes) {
7549            return CheckNonDependentConversions(
7550                MethodTmpl, ParamTypes, Args, CandidateSet, Conversions,
7551                SuppressUserConversions, ActingContext, ObjectType,
7552                ObjectClassification, PO);
7553          })) {
7554    OverloadCandidate &Candidate =
7555        CandidateSet.addCandidate(Conversions.size(), Conversions);
7556    Candidate.FoundDecl = FoundDecl;
7557    Candidate.Function = MethodTmpl->getTemplatedDecl();
7558    Candidate.Viable = false;
7559    Candidate.RewriteKind =
7560      CandidateSet.getRewriteInfo().getRewriteKind(Candidate.Function, PO);
7561    Candidate.IsSurrogate = false;
7562    Candidate.IgnoreObjectArgument =
7563        cast<CXXMethodDecl>(Candidate.Function)->isStatic() ||
7564        ObjectType.isNull();
7565    Candidate.ExplicitCallArguments = Args.size();
7566    if (Result == TDK_NonDependentConversionFailure)
7567      Candidate.FailureKind = ovl_fail_bad_conversion;
7568    else {
7569      Candidate.FailureKind = ovl_fail_bad_deduction;
7570      Candidate.DeductionFailure = MakeDeductionFailureInfo(Context, Result,
7571                                                            Info);
7572    }
7573    return;
7574  }
7575
7576  // Add the function template specialization produced by template argument
7577  // deduction as a candidate.
7578  assert(Specialization && "Missing member function template specialization?");
7579  assert(isa<CXXMethodDecl>(Specialization) &&
7580         "Specialization is not a member function?");
7581  AddMethodCandidate(cast<CXXMethodDecl>(Specialization), FoundDecl,
7582                     ActingContext, ObjectType, ObjectClassification, Args,
7583                     CandidateSet, SuppressUserConversions, PartialOverloading,
7584                     Conversions, PO);
7585}
7586
7587/// Determine whether a given function template has a simple explicit specifier
7588/// or a non-value-dependent explicit-specification that evaluates to true.
7589static bool isNonDependentlyExplicit(FunctionTemplateDecl *FTD) {
7590  return ExplicitSpecifier::getFromDecl(FTD->getTemplatedDecl()).isExplicit();
7591}
7592
7593/// Add a C++ function template specialization as a candidate
7594/// in the candidate set, using template argument deduction to produce
7595/// an appropriate function template specialization.
7596void Sema::AddTemplateOverloadCandidate(
7597    FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl,
7598    TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,
7599    OverloadCandidateSet &CandidateSet, bool SuppressUserConversions,
7600    bool PartialOverloading, bool AllowExplicit, ADLCallKind IsADLCandidate,
7601    OverloadCandidateParamOrder PO, bool AggregateCandidateDeduction) {
7602  if (!CandidateSet.isNewCandidate(FunctionTemplate, PO))
7603    return;
7604
7605  // If the function template has a non-dependent explicit specification,
7606  // exclude it now if appropriate; we are not permitted to perform deduction
7607  // and substitution in this case.
7608  if (!AllowExplicit && isNonDependentlyExplicit(FunctionTemplate)) {
7609    OverloadCandidate &Candidate = CandidateSet.addCandidate();
7610    Candidate.FoundDecl = FoundDecl;
7611    Candidate.Function = FunctionTemplate->getTemplatedDecl();
7612    Candidate.Viable = false;
7613    Candidate.FailureKind = ovl_fail_explicit;
7614    return;
7615  }
7616
7617  // C++ [over.match.funcs]p7:
7618  //   In each case where a candidate is a function template, candidate
7619  //   function template specializations are generated using template argument
7620  //   deduction (14.8.3, 14.8.2). Those candidates are then handled as
7621  //   candidate functions in the usual way.113) A given name can refer to one
7622  //   or more function templates and also to a set of overloaded non-template
7623  //   functions. In such a case, the candidate functions generated from each
7624  //   function template are combined with the set of non-template candidate
7625  //   functions.
7626  TemplateDeductionInfo Info(CandidateSet.getLocation());
7627  FunctionDecl *Specialization = nullptr;
7628  ConversionSequenceList Conversions;
7629  if (TemplateDeductionResult Result = DeduceTemplateArguments(
7630          FunctionTemplate, ExplicitTemplateArgs, Args, Specialization, Info,
7631          PartialOverloading, AggregateCandidateDeduction,
7632          /*ObjectType=*/QualType(),
7633          /*ObjectClassification=*/Expr::Classification(),
7634          [&](ArrayRef<QualType> ParamTypes) {
7635            return CheckNonDependentConversions(
7636                FunctionTemplate, ParamTypes, Args, CandidateSet, Conversions,
7637                SuppressUserConversions, nullptr, QualType(), {}, PO);
7638          })) {
7639    OverloadCandidate &Candidate =
7640        CandidateSet.addCandidate(Conversions.size(), Conversions);
7641    Candidate.FoundDecl = FoundDecl;
7642    Candidate.Function = FunctionTemplate->getTemplatedDecl();
7643    Candidate.Viable = false;
7644    Candidate.RewriteKind =
7645      CandidateSet.getRewriteInfo().getRewriteKind(Candidate.Function, PO);
7646    Candidate.IsSurrogate = false;
7647    Candidate.IsADLCandidate = IsADLCandidate;
7648    // Ignore the object argument if there is one, since we don't have an object
7649    // type.
7650    Candidate.IgnoreObjectArgument =
7651        isa<CXXMethodDecl>(Candidate.Function) &&
7652        !isa<CXXConstructorDecl>(Candidate.Function);
7653    Candidate.ExplicitCallArguments = Args.size();
7654    if (Result == TDK_NonDependentConversionFailure)
7655      Candidate.FailureKind = ovl_fail_bad_conversion;
7656    else {
7657      Candidate.FailureKind = ovl_fail_bad_deduction;
7658      Candidate.DeductionFailure = MakeDeductionFailureInfo(Context, Result,
7659                                                            Info);
7660    }
7661    return;
7662  }
7663
7664  // Add the function template specialization produced by template argument
7665  // deduction as a candidate.
7666  assert(Specialization && "Missing function template specialization?");
7667  AddOverloadCandidate(
7668      Specialization, FoundDecl, Args, CandidateSet, SuppressUserConversions,
7669      PartialOverloading, AllowExplicit,
7670      /*AllowExplicitConversions=*/false, IsADLCandidate, Conversions, PO,
7671      Info.AggregateDeductionCandidateHasMismatchedArity);
7672}
7673
7674/// Check that implicit conversion sequences can be formed for each argument
7675/// whose corresponding parameter has a non-dependent type, per DR1391's
7676/// [temp.deduct.call]p10.
7677bool Sema::CheckNonDependentConversions(
7678    FunctionTemplateDecl *FunctionTemplate, ArrayRef<QualType> ParamTypes,
7679    ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet,
7680    ConversionSequenceList &Conversions, bool SuppressUserConversions,
7681    CXXRecordDecl *ActingContext, QualType ObjectType,
7682    Expr::Classification ObjectClassification, OverloadCandidateParamOrder PO) {
7683  // FIXME: The cases in which we allow explicit conversions for constructor
7684  // arguments never consider calling a constructor template. It's not clear
7685  // that is correct.
7686  const bool AllowExplicit = false;
7687
7688  auto *FD = FunctionTemplate->getTemplatedDecl();
7689  auto *Method = dyn_cast<CXXMethodDecl>(FD);
7690  bool HasThisConversion = Method && !isa<CXXConstructorDecl>(Method);
7691  unsigned ThisConversions = HasThisConversion ? 1 : 0;
7692
7693  Conversions =
7694      CandidateSet.allocateConversionSequences(ThisConversions + Args.size());
7695
7696  // Overload resolution is always an unevaluated context.
7697  EnterExpressionEvaluationContext Unevaluated(
7698      *this, Sema::ExpressionEvaluationContext::Unevaluated);
7699
7700  // For a method call, check the 'this' conversion here too. DR1391 doesn't
7701  // require that, but this check should never result in a hard error, and
7702  // overload resolution is permitted to sidestep instantiations.
7703  if (HasThisConversion && !cast<CXXMethodDecl>(FD)->isStatic() &&
7704      !ObjectType.isNull()) {
7705    unsigned ConvIdx = PO == OverloadCandidateParamOrder::Reversed ? 1 : 0;
7706    if (!FD->hasCXXExplicitFunctionObjectParameter() ||
7707        !ParamTypes[0]->isDependentType()) {
7708      Conversions[ConvIdx] = TryObjectArgumentInitialization(
7709          *this, CandidateSet.getLocation(), ObjectType, ObjectClassification,
7710          Method, ActingContext, /*InOverloadResolution=*/true,
7711          FD->hasCXXExplicitFunctionObjectParameter() ? ParamTypes[0]
7712                                                      : QualType());
7713      if (Conversions[ConvIdx].isBad())
7714        return true;
7715    }
7716  }
7717
7718  unsigned Offset =
7719      Method && Method->hasCXXExplicitFunctionObjectParameter() ? 1 : 0;
7720
7721  for (unsigned I = 0, N = std::min(ParamTypes.size(), Args.size()); I != N;
7722       ++I) {
7723    QualType ParamType = ParamTypes[I + Offset];
7724    if (!ParamType->isDependentType()) {
7725      unsigned ConvIdx;
7726      if (PO == OverloadCandidateParamOrder::Reversed) {
7727        ConvIdx = Args.size() - 1 - I;
7728        assert(Args.size() + ThisConversions == 2 &&
7729               "number of args (including 'this') must be exactly 2 for "
7730               "reversed order");
7731        // For members, there would be only one arg 'Args[0]' whose ConvIdx
7732        // would also be 0. 'this' got ConvIdx = 1 previously.
7733        assert(!HasThisConversion || (ConvIdx == 0 && I == 0));
7734      } else {
7735        // For members, 'this' got ConvIdx = 0 previously.
7736        ConvIdx = ThisConversions + I;
7737      }
7738      Conversions[ConvIdx]
7739        = TryCopyInitialization(*this, Args[I], ParamType,
7740                                SuppressUserConversions,
7741                                /*InOverloadResolution=*/true,
7742                                /*AllowObjCWritebackConversion=*/
7743                                  getLangOpts().ObjCAutoRefCount,
7744                                AllowExplicit);
7745      if (Conversions[ConvIdx].isBad())
7746        return true;
7747    }
7748  }
7749
7750  return false;
7751}
7752
7753/// Determine whether this is an allowable conversion from the result
7754/// of an explicit conversion operator to the expected type, per C++
7755/// [over.match.conv]p1 and [over.match.ref]p1.
7756///
7757/// \param ConvType The return type of the conversion function.
7758///
7759/// \param ToType The type we are converting to.
7760///
7761/// \param AllowObjCPointerConversion Allow a conversion from one
7762/// Objective-C pointer to another.
7763///
7764/// \returns true if the conversion is allowable, false otherwise.
7765static bool isAllowableExplicitConversion(Sema &S,
7766                                          QualType ConvType, QualType ToType,
7767                                          bool AllowObjCPointerConversion) {
7768  QualType ToNonRefType = ToType.getNonReferenceType();
7769
7770  // Easy case: the types are the same.
7771  if (S.Context.hasSameUnqualifiedType(ConvType, ToNonRefType))
7772    return true;
7773
7774  // Allow qualification conversions.
7775  bool ObjCLifetimeConversion;
7776  if (S.IsQualificationConversion(ConvType, ToNonRefType, /*CStyle*/false,
7777                                  ObjCLifetimeConversion))
7778    return true;
7779
7780  // If we're not allowed to consider Objective-C pointer conversions,
7781  // we're done.
7782  if (!AllowObjCPointerConversion)
7783    return false;
7784
7785  // Is this an Objective-C pointer conversion?
7786  bool IncompatibleObjC = false;
7787  QualType ConvertedType;
7788  return S.isObjCPointerConversion(ConvType, ToNonRefType, ConvertedType,
7789                                   IncompatibleObjC);
7790}
7791
7792/// AddConversionCandidate - Add a C++ conversion function as a
7793/// candidate in the candidate set (C++ [over.match.conv],
7794/// C++ [over.match.copy]). From is the expression we're converting from,
7795/// and ToType is the type that we're eventually trying to convert to
7796/// (which may or may not be the same type as the type that the
7797/// conversion function produces).
7798void Sema::AddConversionCandidate(
7799    CXXConversionDecl *Conversion, DeclAccessPair FoundDecl,
7800    CXXRecordDecl *ActingContext, Expr *From, QualType ToType,
7801    OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit,
7802    bool AllowExplicit, bool AllowResultConversion) {
7803  assert(!Conversion->getDescribedFunctionTemplate() &&
7804         "Conversion function templates use AddTemplateConversionCandidate");
7805  QualType ConvType = Conversion->getConversionType().getNonReferenceType();
7806  if (!CandidateSet.isNewCandidate(Conversion))
7807    return;
7808
7809  // If the conversion function has an undeduced return type, trigger its
7810  // deduction now.
7811  if (getLangOpts().CPlusPlus14 && ConvType->isUndeducedType()) {
7812    if (DeduceReturnType(Conversion, From->getExprLoc()))
7813      return;
7814    ConvType = Conversion->getConversionType().getNonReferenceType();
7815  }
7816
7817  // If we don't allow any conversion of the result type, ignore conversion
7818  // functions that don't convert to exactly (possibly cv-qualified) T.
7819  if (!AllowResultConversion &&
7820      !Context.hasSameUnqualifiedType(Conversion->getConversionType(), ToType))
7821    return;
7822
7823  // Per C++ [over.match.conv]p1, [over.match.ref]p1, an explicit conversion
7824  // operator is only a candidate if its return type is the target type or
7825  // can be converted to the target type with a qualification conversion.
7826  //
7827  // FIXME: Include such functions in the candidate list and explain why we
7828  // can't select them.
7829  if (Conversion->isExplicit() &&
7830      !isAllowableExplicitConversion(*this, ConvType, ToType,
7831                                     AllowObjCConversionOnExplicit))
7832    return;
7833
7834  // Overload resolution is always an unevaluated context.
7835  EnterExpressionEvaluationContext Unevaluated(
7836      *this, Sema::ExpressionEvaluationContext::Unevaluated);
7837
7838  // Add this candidate
7839  OverloadCandidate &Candidate = CandidateSet.addCandidate(1);
7840  Candidate.FoundDecl = FoundDecl;
7841  Candidate.Function = Conversion;
7842  Candidate.IsSurrogate = false;
7843  Candidate.IgnoreObjectArgument = false;
7844  Candidate.FinalConversion.setAsIdentityConversion();
7845  Candidate.FinalConversion.setFromType(ConvType);
7846  Candidate.FinalConversion.setAllToTypes(ToType);
7847  Candidate.Viable = true;
7848  Candidate.ExplicitCallArguments = 1;
7849
7850  // Explicit functions are not actually candidates at all if we're not
7851  // allowing them in this context, but keep them around so we can point
7852  // to them in diagnostics.
7853  if (!AllowExplicit && Conversion->isExplicit()) {
7854    Candidate.Viable = false;
7855    Candidate.FailureKind = ovl_fail_explicit;
7856    return;
7857  }
7858
7859  // C++ [over.match.funcs]p4:
7860  //   For conversion functions, the function is considered to be a member of
7861  //   the class of the implicit implied object argument for the purpose of
7862  //   defining the type of the implicit object parameter.
7863  //
7864  // Determine the implicit conversion sequence for the implicit
7865  // object parameter.
7866  QualType ObjectType = From->getType();
7867  if (const auto *FromPtrType = ObjectType->getAs<PointerType>())
7868    ObjectType = FromPtrType->getPointeeType();
7869  const auto *ConversionContext =
7870      cast<CXXRecordDecl>(ObjectType->castAs<RecordType>()->getDecl());
7871
7872  // C++23 [over.best.ics.general]
7873  // However, if the target is [...]
7874  // - the object parameter of a user-defined conversion function
7875  // [...] user-defined conversion sequences are not considered.
7876  Candidate.Conversions[0] = TryObjectArgumentInitialization(
7877      *this, CandidateSet.getLocation(), From->getType(),
7878      From->Classify(Context), Conversion, ConversionContext,
7879      /*InOverloadResolution*/ false, /*ExplicitParameterType=*/QualType(),
7880      /*SuppressUserConversion*/ true);
7881
7882  if (Candidate.Conversions[0].isBad()) {
7883    Candidate.Viable = false;
7884    Candidate.FailureKind = ovl_fail_bad_conversion;
7885    return;
7886  }
7887
7888  if (Conversion->getTrailingRequiresClause()) {
7889    ConstraintSatisfaction Satisfaction;
7890    if (CheckFunctionConstraints(Conversion, Satisfaction) ||
7891        !Satisfaction.IsSatisfied) {
7892      Candidate.Viable = false;
7893      Candidate.FailureKind = ovl_fail_constraints_not_satisfied;
7894      return;
7895    }
7896  }
7897
7898  // We won't go through a user-defined type conversion function to convert a
7899  // derived to base as such conversions are given Conversion Rank. They only
7900  // go through a copy constructor. 13.3.3.1.2-p4 [over.ics.user]
7901  QualType FromCanon
7902    = Context.getCanonicalType(From->getType().getUnqualifiedType());
7903  QualType ToCanon = Context.getCanonicalType(ToType).getUnqualifiedType();
7904  if (FromCanon == ToCanon ||
7905      IsDerivedFrom(CandidateSet.getLocation(), FromCanon, ToCanon)) {
7906    Candidate.Viable = false;
7907    Candidate.FailureKind = ovl_fail_trivial_conversion;
7908    return;
7909  }
7910
7911  // To determine what the conversion from the result of calling the
7912  // conversion function to the type we're eventually trying to
7913  // convert to (ToType), we need to synthesize a call to the
7914  // conversion function and attempt copy initialization from it. This
7915  // makes sure that we get the right semantics with respect to
7916  // lvalues/rvalues and the type. Fortunately, we can allocate this
7917  // call on the stack and we don't need its arguments to be
7918  // well-formed.
7919  DeclRefExpr ConversionRef(Context, Conversion, false, Conversion->getType(),
7920                            VK_LValue, From->getBeginLoc());
7921  ImplicitCastExpr ConversionFn(ImplicitCastExpr::OnStack,
7922                                Context.getPointerType(Conversion->getType()),
7923                                CK_FunctionToPointerDecay, &ConversionRef,
7924                                VK_PRValue, FPOptionsOverride());
7925
7926  QualType ConversionType = Conversion->getConversionType();
7927  if (!isCompleteType(From->getBeginLoc(), ConversionType)) {
7928    Candidate.Viable = false;
7929    Candidate.FailureKind = ovl_fail_bad_final_conversion;
7930    return;
7931  }
7932
7933  ExprValueKind VK = Expr::getValueKindForType(ConversionType);
7934
7935  // Note that it is safe to allocate CallExpr on the stack here because
7936  // there are 0 arguments (i.e., nothing is allocated using ASTContext's
7937  // allocator).
7938  QualType CallResultType = ConversionType.getNonLValueExprType(Context);
7939
7940  alignas(CallExpr) char Buffer[sizeof(CallExpr) + sizeof(Stmt *)];
7941  CallExpr *TheTemporaryCall = CallExpr::CreateTemporary(
7942      Buffer, &ConversionFn, CallResultType, VK, From->getBeginLoc());
7943
7944  ImplicitConversionSequence ICS =
7945      TryCopyInitialization(*this, TheTemporaryCall, ToType,
7946                            /*SuppressUserConversions=*/true,
7947                            /*InOverloadResolution=*/false,
7948                            /*AllowObjCWritebackConversion=*/false);
7949
7950  switch (ICS.getKind()) {
7951  case ImplicitConversionSequence::StandardConversion:
7952    Candidate.FinalConversion = ICS.Standard;
7953
7954    // C++ [over.ics.user]p3:
7955    //   If the user-defined conversion is specified by a specialization of a
7956    //   conversion function template, the second standard conversion sequence
7957    //   shall have exact match rank.
7958    if (Conversion->getPrimaryTemplate() &&
7959        GetConversionRank(ICS.Standard.Second) != ICR_Exact_Match) {
7960      Candidate.Viable = false;
7961      Candidate.FailureKind = ovl_fail_final_conversion_not_exact;
7962      return;
7963    }
7964
7965    // C++0x [dcl.init.ref]p5:
7966    //    In the second case, if the reference is an rvalue reference and
7967    //    the second standard conversion sequence of the user-defined
7968    //    conversion sequence includes an lvalue-to-rvalue conversion, the
7969    //    program is ill-formed.
7970    if (ToType->isRValueReferenceType() &&
7971        ICS.Standard.First == ICK_Lvalue_To_Rvalue) {
7972      Candidate.Viable = false;
7973      Candidate.FailureKind = ovl_fail_bad_final_conversion;
7974      return;
7975    }
7976    break;
7977
7978  case ImplicitConversionSequence::BadConversion:
7979    Candidate.Viable = false;
7980    Candidate.FailureKind = ovl_fail_bad_final_conversion;
7981    return;
7982
7983  default:
7984    llvm_unreachable(
7985           "Can only end up with a standard conversion sequence or failure");
7986  }
7987
7988  if (EnableIfAttr *FailedAttr =
7989          CheckEnableIf(Conversion, CandidateSet.getLocation(), std::nullopt)) {
7990    Candidate.Viable = false;
7991    Candidate.FailureKind = ovl_fail_enable_if;
7992    Candidate.DeductionFailure.Data = FailedAttr;
7993    return;
7994  }
7995
7996  if (Conversion->isMultiVersion() &&
7997      ((Conversion->hasAttr<TargetAttr>() &&
7998        !Conversion->getAttr<TargetAttr>()->isDefaultVersion()) ||
7999       (Conversion->hasAttr<TargetVersionAttr>() &&
8000        !Conversion->getAttr<TargetVersionAttr>()->isDefaultVersion()))) {
8001    Candidate.Viable = false;
8002    Candidate.FailureKind = ovl_non_default_multiversion_function;
8003  }
8004}
8005
8006/// Adds a conversion function template specialization
8007/// candidate to the overload set, using template argument deduction
8008/// to deduce the template arguments of the conversion function
8009/// template from the type that we are converting to (C++
8010/// [temp.deduct.conv]).
8011void Sema::AddTemplateConversionCandidate(
8012    FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl,
8013    CXXRecordDecl *ActingDC, Expr *From, QualType ToType,
8014    OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit,
8015    bool AllowExplicit, bool AllowResultConversion) {
8016  assert(isa<CXXConversionDecl>(FunctionTemplate->getTemplatedDecl()) &&
8017         "Only conversion function templates permitted here");
8018
8019  if (!CandidateSet.isNewCandidate(FunctionTemplate))
8020    return;
8021
8022  // If the function template has a non-dependent explicit specification,
8023  // exclude it now if appropriate; we are not permitted to perform deduction
8024  // and substitution in this case.
8025  if (!AllowExplicit && isNonDependentlyExplicit(FunctionTemplate)) {
8026    OverloadCandidate &Candidate = CandidateSet.addCandidate();
8027    Candidate.FoundDecl = FoundDecl;
8028    Candidate.Function = FunctionTemplate->getTemplatedDecl();
8029    Candidate.Viable = false;
8030    Candidate.FailureKind = ovl_fail_explicit;
8031    return;
8032  }
8033
8034  QualType ObjectType = From->getType();
8035  Expr::Classification ObjectClassification = From->Classify(getASTContext());
8036
8037  TemplateDeductionInfo Info(CandidateSet.getLocation());
8038  CXXConversionDecl *Specialization = nullptr;
8039  if (TemplateDeductionResult Result = DeduceTemplateArguments(
8040          FunctionTemplate, ObjectType, ObjectClassification, ToType,
8041          Specialization, Info)) {
8042    OverloadCandidate &Candidate = CandidateSet.addCandidate();
8043    Candidate.FoundDecl = FoundDecl;
8044    Candidate.Function = FunctionTemplate->getTemplatedDecl();
8045    Candidate.Viable = false;
8046    Candidate.FailureKind = ovl_fail_bad_deduction;
8047    Candidate.IsSurrogate = false;
8048    Candidate.IgnoreObjectArgument = false;
8049    Candidate.ExplicitCallArguments = 1;
8050    Candidate.DeductionFailure = MakeDeductionFailureInfo(Context, Result,
8051                                                          Info);
8052    return;
8053  }
8054
8055  // Add the conversion function template specialization produced by
8056  // template argument deduction as a candidate.
8057  assert(Specialization && "Missing function template specialization?");
8058  AddConversionCandidate(Specialization, FoundDecl, ActingDC, From, ToType,
8059                         CandidateSet, AllowObjCConversionOnExplicit,
8060                         AllowExplicit, AllowResultConversion);
8061}
8062
8063/// AddSurrogateCandidate - Adds a "surrogate" candidate function that
8064/// converts the given @c Object to a function pointer via the
8065/// conversion function @c Conversion, and then attempts to call it
8066/// with the given arguments (C++ [over.call.object]p2-4). Proto is
8067/// the type of function that we'll eventually be calling.
8068void Sema::AddSurrogateCandidate(CXXConversionDecl *Conversion,
8069                                 DeclAccessPair FoundDecl,
8070                                 CXXRecordDecl *ActingContext,
8071                                 const FunctionProtoType *Proto,
8072                                 Expr *Object,
8073                                 ArrayRef<Expr *> Args,
8074                                 OverloadCandidateSet& CandidateSet) {
8075  if (!CandidateSet.isNewCandidate(Conversion))
8076    return;
8077
8078  // Overload resolution is always an unevaluated context.
8079  EnterExpressionEvaluationContext Unevaluated(
8080      *this, Sema::ExpressionEvaluationContext::Unevaluated);
8081
8082  OverloadCandidate &Candidate = CandidateSet.addCandidate(Args.size() + 1);
8083  Candidate.FoundDecl = FoundDecl;
8084  Candidate.Function = nullptr;
8085  Candidate.Surrogate = Conversion;
8086  Candidate.Viable = true;
8087  Candidate.IsSurrogate = true;
8088  Candidate.IgnoreObjectArgument = false;
8089  Candidate.ExplicitCallArguments = Args.size();
8090
8091  // Determine the implicit conversion sequence for the implicit
8092  // object parameter.
8093  ImplicitConversionSequence ObjectInit;
8094  if (Conversion->hasCXXExplicitFunctionObjectParameter()) {
8095    ObjectInit = TryCopyInitialization(*this, Object,
8096                                       Conversion->getParamDecl(0)->getType(),
8097                                       /*SuppressUserConversions=*/false,
8098                                       /*InOverloadResolution=*/true, false);
8099  } else {
8100    ObjectInit = TryObjectArgumentInitialization(
8101        *this, CandidateSet.getLocation(), Object->getType(),
8102        Object->Classify(Context), Conversion, ActingContext);
8103  }
8104
8105  if (ObjectInit.isBad()) {
8106    Candidate.Viable = false;
8107    Candidate.FailureKind = ovl_fail_bad_conversion;
8108    Candidate.Conversions[0] = ObjectInit;
8109    return;
8110  }
8111
8112  // The first conversion is actually a user-defined conversion whose
8113  // first conversion is ObjectInit's standard conversion (which is
8114  // effectively a reference binding). Record it as such.
8115  Candidate.Conversions[0].setUserDefined();
8116  Candidate.Conversions[0].UserDefined.Before = ObjectInit.Standard;
8117  Candidate.Conversions[0].UserDefined.EllipsisConversion = false;
8118  Candidate.Conversions[0].UserDefined.HadMultipleCandidates = false;
8119  Candidate.Conversions[0].UserDefined.ConversionFunction = Conversion;
8120  Candidate.Conversions[0].UserDefined.FoundConversionFunction = FoundDecl;
8121  Candidate.Conversions[0].UserDefined.After
8122    = Candidate.Conversions[0].UserDefined.Before;
8123  Candidate.Conversions[0].UserDefined.After.setAsIdentityConversion();
8124
8125  // Find the
8126  unsigned NumParams = Proto->getNumParams();
8127
8128  // (C++ 13.3.2p2): A candidate function having fewer than m
8129  // parameters is viable only if it has an ellipsis in its parameter
8130  // list (8.3.5).
8131  if (Args.size() > NumParams && !Proto->isVariadic()) {
8132    Candidate.Viable = false;
8133    Candidate.FailureKind = ovl_fail_too_many_arguments;
8134    return;
8135  }
8136
8137  // Function types don't have any default arguments, so just check if
8138  // we have enough arguments.
8139  if (Args.size() < NumParams) {
8140    // Not enough arguments.
8141    Candidate.Viable = false;
8142    Candidate.FailureKind = ovl_fail_too_few_arguments;
8143    return;
8144  }
8145
8146  // Determine the implicit conversion sequences for each of the
8147  // arguments.
8148  for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
8149    if (ArgIdx < NumParams) {
8150      // (C++ 13.3.2p3): for F to be a viable function, there shall
8151      // exist for each argument an implicit conversion sequence
8152      // (13.3.3.1) that converts that argument to the corresponding
8153      // parameter of F.
8154      QualType ParamType = Proto->getParamType(ArgIdx);
8155      Candidate.Conversions[ArgIdx + 1]
8156        = TryCopyInitialization(*this, Args[ArgIdx], ParamType,
8157                                /*SuppressUserConversions=*/false,
8158                                /*InOverloadResolution=*/false,
8159                                /*AllowObjCWritebackConversion=*/
8160                                  getLangOpts().ObjCAutoRefCount);
8161      if (Candidate.Conversions[ArgIdx + 1].isBad()) {
8162        Candidate.Viable = false;
8163        Candidate.FailureKind = ovl_fail_bad_conversion;
8164        return;
8165      }
8166    } else {
8167      // (C++ 13.3.2p2): For the purposes of overload resolution, any
8168      // argument for which there is no corresponding parameter is
8169      // considered to ""match the ellipsis" (C+ 13.3.3.1.3).
8170      Candidate.Conversions[ArgIdx + 1].setEllipsis();
8171    }
8172  }
8173
8174  if (Conversion->getTrailingRequiresClause()) {
8175    ConstraintSatisfaction Satisfaction;
8176    if (CheckFunctionConstraints(Conversion, Satisfaction, /*Loc*/ {},
8177                                 /*ForOverloadResolution*/ true) ||
8178        !Satisfaction.IsSatisfied) {
8179      Candidate.Viable = false;
8180      Candidate.FailureKind = ovl_fail_constraints_not_satisfied;
8181      return;
8182    }
8183  }
8184
8185  if (EnableIfAttr *FailedAttr =
8186          CheckEnableIf(Conversion, CandidateSet.getLocation(), std::nullopt)) {
8187    Candidate.Viable = false;
8188    Candidate.FailureKind = ovl_fail_enable_if;
8189    Candidate.DeductionFailure.Data = FailedAttr;
8190    return;
8191  }
8192}
8193
8194/// Add all of the non-member operator function declarations in the given
8195/// function set to the overload candidate set.
8196void Sema::AddNonMemberOperatorCandidates(
8197    const UnresolvedSetImpl &Fns, ArrayRef<Expr *> Args,
8198    OverloadCandidateSet &CandidateSet,
8199    TemplateArgumentListInfo *ExplicitTemplateArgs) {
8200  for (UnresolvedSetIterator F = Fns.begin(), E = Fns.end(); F != E; ++F) {
8201    NamedDecl *D = F.getDecl()->getUnderlyingDecl();
8202    ArrayRef<Expr *> FunctionArgs = Args;
8203
8204    FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D);
8205    FunctionDecl *FD =
8206        FunTmpl ? FunTmpl->getTemplatedDecl() : cast<FunctionDecl>(D);
8207
8208    // Don't consider rewritten functions if we're not rewriting.
8209    if (!CandidateSet.getRewriteInfo().isAcceptableCandidate(FD))
8210      continue;
8211
8212    assert(!isa<CXXMethodDecl>(FD) &&
8213           "unqualified operator lookup found a member function");
8214
8215    if (FunTmpl) {
8216      AddTemplateOverloadCandidate(FunTmpl, F.getPair(), ExplicitTemplateArgs,
8217                                   FunctionArgs, CandidateSet);
8218      if (CandidateSet.getRewriteInfo().shouldAddReversed(*this, Args, FD))
8219        AddTemplateOverloadCandidate(
8220            FunTmpl, F.getPair(), ExplicitTemplateArgs,
8221            {FunctionArgs[1], FunctionArgs[0]}, CandidateSet, false, false,
8222            true, ADLCallKind::NotADL, OverloadCandidateParamOrder::Reversed);
8223    } else {
8224      if (ExplicitTemplateArgs)
8225        continue;
8226      AddOverloadCandidate(FD, F.getPair(), FunctionArgs, CandidateSet);
8227      if (CandidateSet.getRewriteInfo().shouldAddReversed(*this, Args, FD))
8228        AddOverloadCandidate(
8229            FD, F.getPair(), {FunctionArgs[1], FunctionArgs[0]}, CandidateSet,
8230            false, false, true, false, ADLCallKind::NotADL, std::nullopt,
8231            OverloadCandidateParamOrder::Reversed);
8232    }
8233  }
8234}
8235
8236/// Add overload candidates for overloaded operators that are
8237/// member functions.
8238///
8239/// Add the overloaded operator candidates that are member functions
8240/// for the operator Op that was used in an operator expression such
8241/// as "x Op y". , Args/NumArgs provides the operator arguments, and
8242/// CandidateSet will store the added overload candidates. (C++
8243/// [over.match.oper]).
8244void Sema::AddMemberOperatorCandidates(OverloadedOperatorKind Op,
8245                                       SourceLocation OpLoc,
8246                                       ArrayRef<Expr *> Args,
8247                                       OverloadCandidateSet &CandidateSet,
8248                                       OverloadCandidateParamOrder PO) {
8249  DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op);
8250
8251  // C++ [over.match.oper]p3:
8252  //   For a unary operator @ with an operand of a type whose
8253  //   cv-unqualified version is T1, and for a binary operator @ with
8254  //   a left operand of a type whose cv-unqualified version is T1 and
8255  //   a right operand of a type whose cv-unqualified version is T2,
8256  //   three sets of candidate functions, designated member
8257  //   candidates, non-member candidates and built-in candidates, are
8258  //   constructed as follows:
8259  QualType T1 = Args[0]->getType();
8260
8261  //     -- If T1 is a complete class type or a class currently being
8262  //        defined, the set of member candidates is the result of the
8263  //        qualified lookup of T1::operator@ (13.3.1.1.1); otherwise,
8264  //        the set of member candidates is empty.
8265  if (const RecordType *T1Rec = T1->getAs<RecordType>()) {
8266    // Complete the type if it can be completed.
8267    if (!isCompleteType(OpLoc, T1) && !T1Rec->isBeingDefined())
8268      return;
8269    // If the type is neither complete nor being defined, bail out now.
8270    if (!T1Rec->getDecl()->getDefinition())
8271      return;
8272
8273    LookupResult Operators(*this, OpName, OpLoc, LookupOrdinaryName);
8274    LookupQualifiedName(Operators, T1Rec->getDecl());
8275    Operators.suppressAccessDiagnostics();
8276
8277    for (LookupResult::iterator Oper = Operators.begin(),
8278                                OperEnd = Operators.end();
8279         Oper != OperEnd; ++Oper) {
8280      if (Oper->getAsFunction() &&
8281          PO == OverloadCandidateParamOrder::Reversed &&
8282          !CandidateSet.getRewriteInfo().shouldAddReversed(
8283              *this, {Args[1], Args[0]}, Oper->getAsFunction()))
8284        continue;
8285      AddMethodCandidate(Oper.getPair(), Args[0]->getType(),
8286                         Args[0]->Classify(Context), Args.slice(1),
8287                         CandidateSet, /*SuppressUserConversion=*/false, PO);
8288    }
8289  }
8290}
8291
8292/// AddBuiltinCandidate - Add a candidate for a built-in
8293/// operator. ResultTy and ParamTys are the result and parameter types
8294/// of the built-in candidate, respectively. Args and NumArgs are the
8295/// arguments being passed to the candidate. IsAssignmentOperator
8296/// should be true when this built-in candidate is an assignment
8297/// operator. NumContextualBoolArguments is the number of arguments
8298/// (at the beginning of the argument list) that will be contextually
8299/// converted to bool.
8300void Sema::AddBuiltinCandidate(QualType *ParamTys, ArrayRef<Expr *> Args,
8301                               OverloadCandidateSet& CandidateSet,
8302                               bool IsAssignmentOperator,
8303                               unsigned NumContextualBoolArguments) {
8304  // Overload resolution is always an unevaluated context.
8305  EnterExpressionEvaluationContext Unevaluated(
8306      *this, Sema::ExpressionEvaluationContext::Unevaluated);
8307
8308  // Add this candidate
8309  OverloadCandidate &Candidate = CandidateSet.addCandidate(Args.size());
8310  Candidate.FoundDecl = DeclAccessPair::make(nullptr, AS_none);
8311  Candidate.Function = nullptr;
8312  Candidate.IsSurrogate = false;
8313  Candidate.IgnoreObjectArgument = false;
8314  std::copy(ParamTys, ParamTys + Args.size(), Candidate.BuiltinParamTypes);
8315
8316  // Determine the implicit conversion sequences for each of the
8317  // arguments.
8318  Candidate.Viable = true;
8319  Candidate.ExplicitCallArguments = Args.size();
8320  for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
8321    // C++ [over.match.oper]p4:
8322    //   For the built-in assignment operators, conversions of the
8323    //   left operand are restricted as follows:
8324    //     -- no temporaries are introduced to hold the left operand, and
8325    //     -- no user-defined conversions are applied to the left
8326    //        operand to achieve a type match with the left-most
8327    //        parameter of a built-in candidate.
8328    //
8329    // We block these conversions by turning off user-defined
8330    // conversions, since that is the only way that initialization of
8331    // a reference to a non-class type can occur from something that
8332    // is not of the same type.
8333    if (ArgIdx < NumContextualBoolArguments) {
8334      assert(ParamTys[ArgIdx] == Context.BoolTy &&
8335             "Contextual conversion to bool requires bool type");
8336      Candidate.Conversions[ArgIdx]
8337        = TryContextuallyConvertToBool(*this, Args[ArgIdx]);
8338    } else {
8339      Candidate.Conversions[ArgIdx]
8340        = TryCopyInitialization(*this, Args[ArgIdx], ParamTys[ArgIdx],
8341                                ArgIdx == 0 && IsAssignmentOperator,
8342                                /*InOverloadResolution=*/false,
8343                                /*AllowObjCWritebackConversion=*/
8344                                  getLangOpts().ObjCAutoRefCount);
8345    }
8346    if (Candidate.Conversions[ArgIdx].isBad()) {
8347      Candidate.Viable = false;
8348      Candidate.FailureKind = ovl_fail_bad_conversion;
8349      break;
8350    }
8351  }
8352}
8353
8354namespace {
8355
8356/// BuiltinCandidateTypeSet - A set of types that will be used for the
8357/// candidate operator functions for built-in operators (C++
8358/// [over.built]). The types are separated into pointer types and
8359/// enumeration types.
8360class BuiltinCandidateTypeSet  {
8361  /// TypeSet - A set of types.
8362  typedef llvm::SmallSetVector<QualType, 8> TypeSet;
8363
8364  /// PointerTypes - The set of pointer types that will be used in the
8365  /// built-in candidates.
8366  TypeSet PointerTypes;
8367
8368  /// MemberPointerTypes - The set of member pointer types that will be
8369  /// used in the built-in candidates.
8370  TypeSet MemberPointerTypes;
8371
8372  /// EnumerationTypes - The set of enumeration types that will be
8373  /// used in the built-in candidates.
8374  TypeSet EnumerationTypes;
8375
8376  /// The set of vector types that will be used in the built-in
8377  /// candidates.
8378  TypeSet VectorTypes;
8379
8380  /// The set of matrix types that will be used in the built-in
8381  /// candidates.
8382  TypeSet MatrixTypes;
8383
8384  /// A flag indicating non-record types are viable candidates
8385  bool HasNonRecordTypes;
8386
8387  /// A flag indicating whether either arithmetic or enumeration types
8388  /// were present in the candidate set.
8389  bool HasArithmeticOrEnumeralTypes;
8390
8391  /// A flag indicating whether the nullptr type was present in the
8392  /// candidate set.
8393  bool HasNullPtrType;
8394
8395  /// Sema - The semantic analysis instance where we are building the
8396  /// candidate type set.
8397  Sema &SemaRef;
8398
8399  /// Context - The AST context in which we will build the type sets.
8400  ASTContext &Context;
8401
8402  bool AddPointerWithMoreQualifiedTypeVariants(QualType Ty,
8403                                               const Qualifiers &VisibleQuals);
8404  bool AddMemberPointerWithMoreQualifiedTypeVariants(QualType Ty);
8405
8406public:
8407  /// iterator - Iterates through the types that are part of the set.
8408  typedef TypeSet::iterator iterator;
8409
8410  BuiltinCandidateTypeSet(Sema &SemaRef)
8411    : HasNonRecordTypes(false),
8412      HasArithmeticOrEnumeralTypes(false),
8413      HasNullPtrType(false),
8414      SemaRef(SemaRef),
8415      Context(SemaRef.Context) { }
8416
8417  void AddTypesConvertedFrom(QualType Ty,
8418                             SourceLocation Loc,
8419                             bool AllowUserConversions,
8420                             bool AllowExplicitConversions,
8421                             const Qualifiers &VisibleTypeConversionsQuals);
8422
8423  llvm::iterator_range<iterator> pointer_types() { return PointerTypes; }
8424  llvm::iterator_range<iterator> member_pointer_types() {
8425    return MemberPointerTypes;
8426  }
8427  llvm::iterator_range<iterator> enumeration_types() {
8428    return EnumerationTypes;
8429  }
8430  llvm::iterator_range<iterator> vector_types() { return VectorTypes; }
8431  llvm::iterator_range<iterator> matrix_types() { return MatrixTypes; }
8432
8433  bool containsMatrixType(QualType Ty) const { return MatrixTypes.count(Ty); }
8434  bool hasNonRecordTypes() { return HasNonRecordTypes; }
8435  bool hasArithmeticOrEnumeralTypes() { return HasArithmeticOrEnumeralTypes; }
8436  bool hasNullPtrType() const { return HasNullPtrType; }
8437};
8438
8439} // end anonymous namespace
8440
8441/// AddPointerWithMoreQualifiedTypeVariants - Add the pointer type @p Ty to
8442/// the set of pointer types along with any more-qualified variants of
8443/// that type. For example, if @p Ty is "int const *", this routine
8444/// will add "int const *", "int const volatile *", "int const
8445/// restrict *", and "int const volatile restrict *" to the set of
8446/// pointer types. Returns true if the add of @p Ty itself succeeded,
8447/// false otherwise.
8448///
8449/// FIXME: what to do about extended qualifiers?
8450bool
8451BuiltinCandidateTypeSet::AddPointerWithMoreQualifiedTypeVariants(QualType Ty,
8452                                             const Qualifiers &VisibleQuals) {
8453
8454  // Insert this type.
8455  if (!PointerTypes.insert(Ty))
8456    return false;
8457
8458  QualType PointeeTy;
8459  const PointerType *PointerTy = Ty->getAs<PointerType>();
8460  bool buildObjCPtr = false;
8461  if (!PointerTy) {
8462    const ObjCObjectPointerType *PTy = Ty->castAs<ObjCObjectPointerType>();
8463    PointeeTy = PTy->getPointeeType();
8464    buildObjCPtr = true;
8465  } else {
8466    PointeeTy = PointerTy->getPointeeType();
8467  }
8468
8469  // Don't add qualified variants of arrays. For one, they're not allowed
8470  // (the qualifier would sink to the element type), and for another, the
8471  // only overload situation where it matters is subscript or pointer +- int,
8472  // and those shouldn't have qualifier variants anyway.
8473  if (PointeeTy->isArrayType())
8474    return true;
8475
8476  unsigned BaseCVR = PointeeTy.getCVRQualifiers();
8477  bool hasVolatile = VisibleQuals.hasVolatile();
8478  bool hasRestrict = VisibleQuals.hasRestrict();
8479
8480  // Iterate through all strict supersets of BaseCVR.
8481  for (unsigned CVR = BaseCVR+1; CVR <= Qualifiers::CVRMask; ++CVR) {
8482    if ((CVR | BaseCVR) != CVR) continue;
8483    // Skip over volatile if no volatile found anywhere in the types.
8484    if ((CVR & Qualifiers::Volatile) && !hasVolatile) continue;
8485
8486    // Skip over restrict if no restrict found anywhere in the types, or if
8487    // the type cannot be restrict-qualified.
8488    if ((CVR & Qualifiers::Restrict) &&
8489        (!hasRestrict ||
8490         (!(PointeeTy->isAnyPointerType() || PointeeTy->isReferenceType()))))
8491      continue;
8492
8493    // Build qualified pointee type.
8494    QualType QPointeeTy = Context.getCVRQualifiedType(PointeeTy, CVR);
8495
8496    // Build qualified pointer type.
8497    QualType QPointerTy;
8498    if (!buildObjCPtr)
8499      QPointerTy = Context.getPointerType(QPointeeTy);
8500    else
8501      QPointerTy = Context.getObjCObjectPointerType(QPointeeTy);
8502
8503    // Insert qualified pointer type.
8504    PointerTypes.insert(QPointerTy);
8505  }
8506
8507  return true;
8508}
8509
8510/// AddMemberPointerWithMoreQualifiedTypeVariants - Add the pointer type @p Ty
8511/// to the set of pointer types along with any more-qualified variants of
8512/// that type. For example, if @p Ty is "int const *", this routine
8513/// will add "int const *", "int const volatile *", "int const
8514/// restrict *", and "int const volatile restrict *" to the set of
8515/// pointer types. Returns true if the add of @p Ty itself succeeded,
8516/// false otherwise.
8517///
8518/// FIXME: what to do about extended qualifiers?
8519bool
8520BuiltinCandidateTypeSet::AddMemberPointerWithMoreQualifiedTypeVariants(
8521    QualType Ty) {
8522  // Insert this type.
8523  if (!MemberPointerTypes.insert(Ty))
8524    return false;
8525
8526  const MemberPointerType *PointerTy = Ty->getAs<MemberPointerType>();
8527  assert(PointerTy && "type was not a member pointer type!");
8528
8529  QualType PointeeTy = PointerTy->getPointeeType();
8530  // Don't add qualified variants of arrays. For one, they're not allowed
8531  // (the qualifier would sink to the element type), and for another, the
8532  // only overload situation where it matters is subscript or pointer +- int,
8533  // and those shouldn't have qualifier variants anyway.
8534  if (PointeeTy->isArrayType())
8535    return true;
8536  const Type *ClassTy = PointerTy->getClass();
8537
8538  // Iterate through all strict supersets of the pointee type's CVR
8539  // qualifiers.
8540  unsigned BaseCVR = PointeeTy.getCVRQualifiers();
8541  for (unsigned CVR = BaseCVR+1; CVR <= Qualifiers::CVRMask; ++CVR) {
8542    if ((CVR | BaseCVR) != CVR) continue;
8543
8544    QualType QPointeeTy = Context.getCVRQualifiedType(PointeeTy, CVR);
8545    MemberPointerTypes.insert(
8546      Context.getMemberPointerType(QPointeeTy, ClassTy));
8547  }
8548
8549  return true;
8550}
8551
8552/// AddTypesConvertedFrom - Add each of the types to which the type @p
8553/// Ty can be implicit converted to the given set of @p Types. We're
8554/// primarily interested in pointer types and enumeration types. We also
8555/// take member pointer types, for the conditional operator.
8556/// AllowUserConversions is true if we should look at the conversion
8557/// functions of a class type, and AllowExplicitConversions if we
8558/// should also include the explicit conversion functions of a class
8559/// type.
8560void
8561BuiltinCandidateTypeSet::AddTypesConvertedFrom(QualType Ty,
8562                                               SourceLocation Loc,
8563                                               bool AllowUserConversions,
8564                                               bool AllowExplicitConversions,
8565                                               const Qualifiers &VisibleQuals) {
8566  // Only deal with canonical types.
8567  Ty = Context.getCanonicalType(Ty);
8568
8569  // Look through reference types; they aren't part of the type of an
8570  // expression for the purposes of conversions.
8571  if (const ReferenceType *RefTy = Ty->getAs<ReferenceType>())
8572    Ty = RefTy->getPointeeType();
8573
8574  // If we're dealing with an array type, decay to the pointer.
8575  if (Ty->isArrayType())
8576    Ty = SemaRef.Context.getArrayDecayedType(Ty);
8577
8578  // Otherwise, we don't care about qualifiers on the type.
8579  Ty = Ty.getLocalUnqualifiedType();
8580
8581  // Flag if we ever add a non-record type.
8582  const RecordType *TyRec = Ty->getAs<RecordType>();
8583  HasNonRecordTypes = HasNonRecordTypes || !TyRec;
8584
8585  // Flag if we encounter an arithmetic type.
8586  HasArithmeticOrEnumeralTypes =
8587    HasArithmeticOrEnumeralTypes || Ty->isArithmeticType();
8588
8589  if (Ty->isObjCIdType() || Ty->isObjCClassType())
8590    PointerTypes.insert(Ty);
8591  else if (Ty->getAs<PointerType>() || Ty->getAs<ObjCObjectPointerType>()) {
8592    // Insert our type, and its more-qualified variants, into the set
8593    // of types.
8594    if (!AddPointerWithMoreQualifiedTypeVariants(Ty, VisibleQuals))
8595      return;
8596  } else if (Ty->isMemberPointerType()) {
8597    // Member pointers are far easier, since the pointee can't be converted.
8598    if (!AddMemberPointerWithMoreQualifiedTypeVariants(Ty))
8599      return;
8600  } else if (Ty->isEnumeralType()) {
8601    HasArithmeticOrEnumeralTypes = true;
8602    EnumerationTypes.insert(Ty);
8603  } else if (Ty->isVectorType()) {
8604    // We treat vector types as arithmetic types in many contexts as an
8605    // extension.
8606    HasArithmeticOrEnumeralTypes = true;
8607    VectorTypes.insert(Ty);
8608  } else if (Ty->isMatrixType()) {
8609    // Similar to vector types, we treat vector types as arithmetic types in
8610    // many contexts as an extension.
8611    HasArithmeticOrEnumeralTypes = true;
8612    MatrixTypes.insert(Ty);
8613  } else if (Ty->isNullPtrType()) {
8614    HasNullPtrType = true;
8615  } else if (AllowUserConversions && TyRec) {
8616    // No conversion functions in incomplete types.
8617    if (!SemaRef.isCompleteType(Loc, Ty))
8618      return;
8619
8620    CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(TyRec->getDecl());
8621    for (NamedDecl *D : ClassDecl->getVisibleConversionFunctions()) {
8622      if (isa<UsingShadowDecl>(D))
8623        D = cast<UsingShadowDecl>(D)->getTargetDecl();
8624
8625      // Skip conversion function templates; they don't tell us anything
8626      // about which builtin types we can convert to.
8627      if (isa<FunctionTemplateDecl>(D))
8628        continue;
8629
8630      CXXConversionDecl *Conv = cast<CXXConversionDecl>(D);
8631      if (AllowExplicitConversions || !Conv->isExplicit()) {
8632        AddTypesConvertedFrom(Conv->getConversionType(), Loc, false, false,
8633                              VisibleQuals);
8634      }
8635    }
8636  }
8637}
8638/// Helper function for adjusting address spaces for the pointer or reference
8639/// operands of builtin operators depending on the argument.
8640static QualType AdjustAddressSpaceForBuiltinOperandType(Sema &S, QualType T,
8641                                                        Expr *Arg) {
8642  return S.Context.getAddrSpaceQualType(T, Arg->getType().getAddressSpace());
8643}
8644
8645/// Helper function for AddBuiltinOperatorCandidates() that adds
8646/// the volatile- and non-volatile-qualified assignment operators for the
8647/// given type to the candidate set.
8648static void AddBuiltinAssignmentOperatorCandidates(Sema &S,
8649                                                   QualType T,
8650                                                   ArrayRef<Expr *> Args,
8651                                    OverloadCandidateSet &CandidateSet) {
8652  QualType ParamTypes[2];
8653
8654  // T& operator=(T&, T)
8655  ParamTypes[0] = S.Context.getLValueReferenceType(
8656      AdjustAddressSpaceForBuiltinOperandType(S, T, Args[0]));
8657  ParamTypes[1] = T;
8658  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8659                        /*IsAssignmentOperator=*/true);
8660
8661  if (!S.Context.getCanonicalType(T).isVolatileQualified()) {
8662    // volatile T& operator=(volatile T&, T)
8663    ParamTypes[0] = S.Context.getLValueReferenceType(
8664        AdjustAddressSpaceForBuiltinOperandType(S, S.Context.getVolatileType(T),
8665                                                Args[0]));
8666    ParamTypes[1] = T;
8667    S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8668                          /*IsAssignmentOperator=*/true);
8669  }
8670}
8671
8672/// CollectVRQualifiers - This routine returns Volatile/Restrict qualifiers,
8673/// if any, found in visible type conversion functions found in ArgExpr's type.
8674static  Qualifiers CollectVRQualifiers(ASTContext &Context, Expr* ArgExpr) {
8675    Qualifiers VRQuals;
8676    const RecordType *TyRec;
8677    if (const MemberPointerType *RHSMPType =
8678        ArgExpr->getType()->getAs<MemberPointerType>())
8679      TyRec = RHSMPType->getClass()->getAs<RecordType>();
8680    else
8681      TyRec = ArgExpr->getType()->getAs<RecordType>();
8682    if (!TyRec) {
8683      // Just to be safe, assume the worst case.
8684      VRQuals.addVolatile();
8685      VRQuals.addRestrict();
8686      return VRQuals;
8687    }
8688
8689    CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(TyRec->getDecl());
8690    if (!ClassDecl->hasDefinition())
8691      return VRQuals;
8692
8693    for (NamedDecl *D : ClassDecl->getVisibleConversionFunctions()) {
8694      if (isa<UsingShadowDecl>(D))
8695        D = cast<UsingShadowDecl>(D)->getTargetDecl();
8696      if (CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(D)) {
8697        QualType CanTy = Context.getCanonicalType(Conv->getConversionType());
8698        if (const ReferenceType *ResTypeRef = CanTy->getAs<ReferenceType>())
8699          CanTy = ResTypeRef->getPointeeType();
8700        // Need to go down the pointer/mempointer chain and add qualifiers
8701        // as see them.
8702        bool done = false;
8703        while (!done) {
8704          if (CanTy.isRestrictQualified())
8705            VRQuals.addRestrict();
8706          if (const PointerType *ResTypePtr = CanTy->getAs<PointerType>())
8707            CanTy = ResTypePtr->getPointeeType();
8708          else if (const MemberPointerType *ResTypeMPtr =
8709                CanTy->getAs<MemberPointerType>())
8710            CanTy = ResTypeMPtr->getPointeeType();
8711          else
8712            done = true;
8713          if (CanTy.isVolatileQualified())
8714            VRQuals.addVolatile();
8715          if (VRQuals.hasRestrict() && VRQuals.hasVolatile())
8716            return VRQuals;
8717        }
8718      }
8719    }
8720    return VRQuals;
8721}
8722
8723// Note: We're currently only handling qualifiers that are meaningful for the
8724// LHS of compound assignment overloading.
8725static void forAllQualifierCombinationsImpl(
8726    QualifiersAndAtomic Available, QualifiersAndAtomic Applied,
8727    llvm::function_ref<void(QualifiersAndAtomic)> Callback) {
8728  // _Atomic
8729  if (Available.hasAtomic()) {
8730    Available.removeAtomic();
8731    forAllQualifierCombinationsImpl(Available, Applied.withAtomic(), Callback);
8732    forAllQualifierCombinationsImpl(Available, Applied, Callback);
8733    return;
8734  }
8735
8736  // volatile
8737  if (Available.hasVolatile()) {
8738    Available.removeVolatile();
8739    assert(!Applied.hasVolatile());
8740    forAllQualifierCombinationsImpl(Available, Applied.withVolatile(),
8741                                    Callback);
8742    forAllQualifierCombinationsImpl(Available, Applied, Callback);
8743    return;
8744  }
8745
8746  Callback(Applied);
8747}
8748
8749static void forAllQualifierCombinations(
8750    QualifiersAndAtomic Quals,
8751    llvm::function_ref<void(QualifiersAndAtomic)> Callback) {
8752  return forAllQualifierCombinationsImpl(Quals, QualifiersAndAtomic(),
8753                                         Callback);
8754}
8755
8756static QualType makeQualifiedLValueReferenceType(QualType Base,
8757                                                 QualifiersAndAtomic Quals,
8758                                                 Sema &S) {
8759  if (Quals.hasAtomic())
8760    Base = S.Context.getAtomicType(Base);
8761  if (Quals.hasVolatile())
8762    Base = S.Context.getVolatileType(Base);
8763  return S.Context.getLValueReferenceType(Base);
8764}
8765
8766namespace {
8767
8768/// Helper class to manage the addition of builtin operator overload
8769/// candidates. It provides shared state and utility methods used throughout
8770/// the process, as well as a helper method to add each group of builtin
8771/// operator overloads from the standard to a candidate set.
8772class BuiltinOperatorOverloadBuilder {
8773  // Common instance state available to all overload candidate addition methods.
8774  Sema &S;
8775  ArrayRef<Expr *> Args;
8776  QualifiersAndAtomic VisibleTypeConversionsQuals;
8777  bool HasArithmeticOrEnumeralCandidateType;
8778  SmallVectorImpl<BuiltinCandidateTypeSet> &CandidateTypes;
8779  OverloadCandidateSet &CandidateSet;
8780
8781  static constexpr int ArithmeticTypesCap = 24;
8782  SmallVector<CanQualType, ArithmeticTypesCap> ArithmeticTypes;
8783
8784  // Define some indices used to iterate over the arithmetic types in
8785  // ArithmeticTypes.  The "promoted arithmetic types" are the arithmetic
8786  // types are that preserved by promotion (C++ [over.built]p2).
8787  unsigned FirstIntegralType,
8788           LastIntegralType;
8789  unsigned FirstPromotedIntegralType,
8790           LastPromotedIntegralType;
8791  unsigned FirstPromotedArithmeticType,
8792           LastPromotedArithmeticType;
8793  unsigned NumArithmeticTypes;
8794
8795  void InitArithmeticTypes() {
8796    // Start of promoted types.
8797    FirstPromotedArithmeticType = 0;
8798    ArithmeticTypes.push_back(S.Context.FloatTy);
8799    ArithmeticTypes.push_back(S.Context.DoubleTy);
8800    ArithmeticTypes.push_back(S.Context.LongDoubleTy);
8801    if (S.Context.getTargetInfo().hasFloat128Type())
8802      ArithmeticTypes.push_back(S.Context.Float128Ty);
8803    if (S.Context.getTargetInfo().hasIbm128Type())
8804      ArithmeticTypes.push_back(S.Context.Ibm128Ty);
8805
8806    // Start of integral types.
8807    FirstIntegralType = ArithmeticTypes.size();
8808    FirstPromotedIntegralType = ArithmeticTypes.size();
8809    ArithmeticTypes.push_back(S.Context.IntTy);
8810    ArithmeticTypes.push_back(S.Context.LongTy);
8811    ArithmeticTypes.push_back(S.Context.LongLongTy);
8812    if (S.Context.getTargetInfo().hasInt128Type() ||
8813        (S.Context.getAuxTargetInfo() &&
8814         S.Context.getAuxTargetInfo()->hasInt128Type()))
8815      ArithmeticTypes.push_back(S.Context.Int128Ty);
8816    ArithmeticTypes.push_back(S.Context.UnsignedIntTy);
8817    ArithmeticTypes.push_back(S.Context.UnsignedLongTy);
8818    ArithmeticTypes.push_back(S.Context.UnsignedLongLongTy);
8819    if (S.Context.getTargetInfo().hasInt128Type() ||
8820        (S.Context.getAuxTargetInfo() &&
8821         S.Context.getAuxTargetInfo()->hasInt128Type()))
8822      ArithmeticTypes.push_back(S.Context.UnsignedInt128Ty);
8823    LastPromotedIntegralType = ArithmeticTypes.size();
8824    LastPromotedArithmeticType = ArithmeticTypes.size();
8825    // End of promoted types.
8826
8827    ArithmeticTypes.push_back(S.Context.BoolTy);
8828    ArithmeticTypes.push_back(S.Context.CharTy);
8829    ArithmeticTypes.push_back(S.Context.WCharTy);
8830    if (S.Context.getLangOpts().Char8)
8831      ArithmeticTypes.push_back(S.Context.Char8Ty);
8832    ArithmeticTypes.push_back(S.Context.Char16Ty);
8833    ArithmeticTypes.push_back(S.Context.Char32Ty);
8834    ArithmeticTypes.push_back(S.Context.SignedCharTy);
8835    ArithmeticTypes.push_back(S.Context.ShortTy);
8836    ArithmeticTypes.push_back(S.Context.UnsignedCharTy);
8837    ArithmeticTypes.push_back(S.Context.UnsignedShortTy);
8838    LastIntegralType = ArithmeticTypes.size();
8839    NumArithmeticTypes = ArithmeticTypes.size();
8840    // End of integral types.
8841    // FIXME: What about complex? What about half?
8842
8843    assert(ArithmeticTypes.size() <= ArithmeticTypesCap &&
8844           "Enough inline storage for all arithmetic types.");
8845  }
8846
8847  /// Helper method to factor out the common pattern of adding overloads
8848  /// for '++' and '--' builtin operators.
8849  void addPlusPlusMinusMinusStyleOverloads(QualType CandidateTy,
8850                                           bool HasVolatile,
8851                                           bool HasRestrict) {
8852    QualType ParamTypes[2] = {
8853      S.Context.getLValueReferenceType(CandidateTy),
8854      S.Context.IntTy
8855    };
8856
8857    // Non-volatile version.
8858    S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8859
8860    // Use a heuristic to reduce number of builtin candidates in the set:
8861    // add volatile version only if there are conversions to a volatile type.
8862    if (HasVolatile) {
8863      ParamTypes[0] =
8864        S.Context.getLValueReferenceType(
8865          S.Context.getVolatileType(CandidateTy));
8866      S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8867    }
8868
8869    // Add restrict version only if there are conversions to a restrict type
8870    // and our candidate type is a non-restrict-qualified pointer.
8871    if (HasRestrict && CandidateTy->isAnyPointerType() &&
8872        !CandidateTy.isRestrictQualified()) {
8873      ParamTypes[0]
8874        = S.Context.getLValueReferenceType(
8875            S.Context.getCVRQualifiedType(CandidateTy, Qualifiers::Restrict));
8876      S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8877
8878      if (HasVolatile) {
8879        ParamTypes[0]
8880          = S.Context.getLValueReferenceType(
8881              S.Context.getCVRQualifiedType(CandidateTy,
8882                                            (Qualifiers::Volatile |
8883                                             Qualifiers::Restrict)));
8884        S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8885      }
8886    }
8887
8888  }
8889
8890  /// Helper to add an overload candidate for a binary builtin with types \p L
8891  /// and \p R.
8892  void AddCandidate(QualType L, QualType R) {
8893    QualType LandR[2] = {L, R};
8894    S.AddBuiltinCandidate(LandR, Args, CandidateSet);
8895  }
8896
8897public:
8898  BuiltinOperatorOverloadBuilder(
8899    Sema &S, ArrayRef<Expr *> Args,
8900    QualifiersAndAtomic VisibleTypeConversionsQuals,
8901    bool HasArithmeticOrEnumeralCandidateType,
8902    SmallVectorImpl<BuiltinCandidateTypeSet> &CandidateTypes,
8903    OverloadCandidateSet &CandidateSet)
8904    : S(S), Args(Args),
8905      VisibleTypeConversionsQuals(VisibleTypeConversionsQuals),
8906      HasArithmeticOrEnumeralCandidateType(
8907        HasArithmeticOrEnumeralCandidateType),
8908      CandidateTypes(CandidateTypes),
8909      CandidateSet(CandidateSet) {
8910
8911    InitArithmeticTypes();
8912  }
8913
8914  // Increment is deprecated for bool since C++17.
8915  //
8916  // C++ [over.built]p3:
8917  //
8918  //   For every pair (T, VQ), where T is an arithmetic type other
8919  //   than bool, and VQ is either volatile or empty, there exist
8920  //   candidate operator functions of the form
8921  //
8922  //       VQ T&      operator++(VQ T&);
8923  //       T          operator++(VQ T&, int);
8924  //
8925  // C++ [over.built]p4:
8926  //
8927  //   For every pair (T, VQ), where T is an arithmetic type other
8928  //   than bool, and VQ is either volatile or empty, there exist
8929  //   candidate operator functions of the form
8930  //
8931  //       VQ T&      operator--(VQ T&);
8932  //       T          operator--(VQ T&, int);
8933  void addPlusPlusMinusMinusArithmeticOverloads(OverloadedOperatorKind Op) {
8934    if (!HasArithmeticOrEnumeralCandidateType)
8935      return;
8936
8937    for (unsigned Arith = 0; Arith < NumArithmeticTypes; ++Arith) {
8938      const auto TypeOfT = ArithmeticTypes[Arith];
8939      if (TypeOfT == S.Context.BoolTy) {
8940        if (Op == OO_MinusMinus)
8941          continue;
8942        if (Op == OO_PlusPlus && S.getLangOpts().CPlusPlus17)
8943          continue;
8944      }
8945      addPlusPlusMinusMinusStyleOverloads(
8946        TypeOfT,
8947        VisibleTypeConversionsQuals.hasVolatile(),
8948        VisibleTypeConversionsQuals.hasRestrict());
8949    }
8950  }
8951
8952  // C++ [over.built]p5:
8953  //
8954  //   For every pair (T, VQ), where T is a cv-qualified or
8955  //   cv-unqualified object type, and VQ is either volatile or
8956  //   empty, there exist candidate operator functions of the form
8957  //
8958  //       T*VQ&      operator++(T*VQ&);
8959  //       T*VQ&      operator--(T*VQ&);
8960  //       T*         operator++(T*VQ&, int);
8961  //       T*         operator--(T*VQ&, int);
8962  void addPlusPlusMinusMinusPointerOverloads() {
8963    for (QualType PtrTy : CandidateTypes[0].pointer_types()) {
8964      // Skip pointer types that aren't pointers to object types.
8965      if (!PtrTy->getPointeeType()->isObjectType())
8966        continue;
8967
8968      addPlusPlusMinusMinusStyleOverloads(
8969          PtrTy,
8970          (!PtrTy.isVolatileQualified() &&
8971           VisibleTypeConversionsQuals.hasVolatile()),
8972          (!PtrTy.isRestrictQualified() &&
8973           VisibleTypeConversionsQuals.hasRestrict()));
8974    }
8975  }
8976
8977  // C++ [over.built]p6:
8978  //   For every cv-qualified or cv-unqualified object type T, there
8979  //   exist candidate operator functions of the form
8980  //
8981  //       T&         operator*(T*);
8982  //
8983  // C++ [over.built]p7:
8984  //   For every function type T that does not have cv-qualifiers or a
8985  //   ref-qualifier, there exist candidate operator functions of the form
8986  //       T&         operator*(T*);
8987  void addUnaryStarPointerOverloads() {
8988    for (QualType ParamTy : CandidateTypes[0].pointer_types()) {
8989      QualType PointeeTy = ParamTy->getPointeeType();
8990      if (!PointeeTy->isObjectType() && !PointeeTy->isFunctionType())
8991        continue;
8992
8993      if (const FunctionProtoType *Proto =PointeeTy->getAs<FunctionProtoType>())
8994        if (Proto->getMethodQuals() || Proto->getRefQualifier())
8995          continue;
8996
8997      S.AddBuiltinCandidate(&ParamTy, Args, CandidateSet);
8998    }
8999  }
9000
9001  // C++ [over.built]p9:
9002  //  For every promoted arithmetic type T, there exist candidate
9003  //  operator functions of the form
9004  //
9005  //       T         operator+(T);
9006  //       T         operator-(T);
9007  void addUnaryPlusOrMinusArithmeticOverloads() {
9008    if (!HasArithmeticOrEnumeralCandidateType)
9009      return;
9010
9011    for (unsigned Arith = FirstPromotedArithmeticType;
9012         Arith < LastPromotedArithmeticType; ++Arith) {
9013      QualType ArithTy = ArithmeticTypes[Arith];
9014      S.AddBuiltinCandidate(&ArithTy, Args, CandidateSet);
9015    }
9016
9017    // Extension: We also add these operators for vector types.
9018    for (QualType VecTy : CandidateTypes[0].vector_types())
9019      S.AddBuiltinCandidate(&VecTy, Args, CandidateSet);
9020  }
9021
9022  // C++ [over.built]p8:
9023  //   For every type T, there exist candidate operator functions of
9024  //   the form
9025  //
9026  //       T*         operator+(T*);
9027  void addUnaryPlusPointerOverloads() {
9028    for (QualType ParamTy : CandidateTypes[0].pointer_types())
9029      S.AddBuiltinCandidate(&ParamTy, Args, CandidateSet);
9030  }
9031
9032  // C++ [over.built]p10:
9033  //   For every promoted integral type T, there exist candidate
9034  //   operator functions of the form
9035  //
9036  //        T         operator~(T);
9037  void addUnaryTildePromotedIntegralOverloads() {
9038    if (!HasArithmeticOrEnumeralCandidateType)
9039      return;
9040
9041    for (unsigned Int = FirstPromotedIntegralType;
9042         Int < LastPromotedIntegralType; ++Int) {
9043      QualType IntTy = ArithmeticTypes[Int];
9044      S.AddBuiltinCandidate(&IntTy, Args, CandidateSet);
9045    }
9046
9047    // Extension: We also add this operator for vector types.
9048    for (QualType VecTy : CandidateTypes[0].vector_types())
9049      S.AddBuiltinCandidate(&VecTy, Args, CandidateSet);
9050  }
9051
9052  // C++ [over.match.oper]p16:
9053  //   For every pointer to member type T or type std::nullptr_t, there
9054  //   exist candidate operator functions of the form
9055  //
9056  //        bool operator==(T,T);
9057  //        bool operator!=(T,T);
9058  void addEqualEqualOrNotEqualMemberPointerOrNullptrOverloads() {
9059    /// Set of (canonical) types that we've already handled.
9060    llvm::SmallPtrSet<QualType, 8> AddedTypes;
9061
9062    for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
9063      for (QualType MemPtrTy : CandidateTypes[ArgIdx].member_pointer_types()) {
9064        // Don't add the same builtin candidate twice.
9065        if (!AddedTypes.insert(S.Context.getCanonicalType(MemPtrTy)).second)
9066          continue;
9067
9068        QualType ParamTypes[2] = {MemPtrTy, MemPtrTy};
9069        S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
9070      }
9071
9072      if (CandidateTypes[ArgIdx].hasNullPtrType()) {
9073        CanQualType NullPtrTy = S.Context.getCanonicalType(S.Context.NullPtrTy);
9074        if (AddedTypes.insert(NullPtrTy).second) {
9075          QualType ParamTypes[2] = { NullPtrTy, NullPtrTy };
9076          S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
9077        }
9078      }
9079    }
9080  }
9081
9082  // C++ [over.built]p15:
9083  //
9084  //   For every T, where T is an enumeration type or a pointer type,
9085  //   there exist candidate operator functions of the form
9086  //
9087  //        bool       operator<(T, T);
9088  //        bool       operator>(T, T);
9089  //        bool       operator<=(T, T);
9090  //        bool       operator>=(T, T);
9091  //        bool       operator==(T, T);
9092  //        bool       operator!=(T, T);
9093  //           R       operator<=>(T, T)
9094  void addGenericBinaryPointerOrEnumeralOverloads(bool IsSpaceship) {
9095    // C++ [over.match.oper]p3:
9096    //   [...]the built-in candidates include all of the candidate operator
9097    //   functions defined in 13.6 that, compared to the given operator, [...]
9098    //   do not have the same parameter-type-list as any non-template non-member
9099    //   candidate.
9100    //
9101    // Note that in practice, this only affects enumeration types because there
9102    // aren't any built-in candidates of record type, and a user-defined operator
9103    // must have an operand of record or enumeration type. Also, the only other
9104    // overloaded operator with enumeration arguments, operator=,
9105    // cannot be overloaded for enumeration types, so this is the only place
9106    // where we must suppress candidates like this.
9107    llvm::DenseSet<std::pair<CanQualType, CanQualType> >
9108      UserDefinedBinaryOperators;
9109
9110    for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
9111      if (!CandidateTypes[ArgIdx].enumeration_types().empty()) {
9112        for (OverloadCandidateSet::iterator C = CandidateSet.begin(),
9113                                         CEnd = CandidateSet.end();
9114             C != CEnd; ++C) {
9115          if (!C->Viable || !C->Function || C->Function->getNumParams() != 2)
9116            continue;
9117
9118          if (C->Function->isFunctionTemplateSpecialization())
9119            continue;
9120
9121          // We interpret "same parameter-type-list" as applying to the
9122          // "synthesized candidate, with the order of the two parameters
9123          // reversed", not to the original function.
9124          bool Reversed = C->isReversed();
9125          QualType FirstParamType = C->Function->getParamDecl(Reversed ? 1 : 0)
9126                                        ->getType()
9127                                        .getUnqualifiedType();
9128          QualType SecondParamType = C->Function->getParamDecl(Reversed ? 0 : 1)
9129                                         ->getType()
9130                                         .getUnqualifiedType();
9131
9132          // Skip if either parameter isn't of enumeral type.
9133          if (!FirstParamType->isEnumeralType() ||
9134              !SecondParamType->isEnumeralType())
9135            continue;
9136
9137          // Add this operator to the set of known user-defined operators.
9138          UserDefinedBinaryOperators.insert(
9139            std::make_pair(S.Context.getCanonicalType(FirstParamType),
9140                           S.Context.getCanonicalType(SecondParamType)));
9141        }
9142      }
9143    }
9144
9145    /// Set of (canonical) types that we've already handled.
9146    llvm::SmallPtrSet<QualType, 8> AddedTypes;
9147
9148    for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
9149      for (QualType PtrTy : CandidateTypes[ArgIdx].pointer_types()) {
9150        // Don't add the same builtin candidate twice.
9151        if (!AddedTypes.insert(S.Context.getCanonicalType(PtrTy)).second)
9152          continue;
9153        if (IsSpaceship && PtrTy->isFunctionPointerType())
9154          continue;
9155
9156        QualType ParamTypes[2] = {PtrTy, PtrTy};
9157        S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
9158      }
9159      for (QualType EnumTy : CandidateTypes[ArgIdx].enumeration_types()) {
9160        CanQualType CanonType = S.Context.getCanonicalType(EnumTy);
9161
9162        // Don't add the same builtin candidate twice, or if a user defined
9163        // candidate exists.
9164        if (!AddedTypes.insert(CanonType).second ||
9165            UserDefinedBinaryOperators.count(std::make_pair(CanonType,
9166                                                            CanonType)))
9167          continue;
9168        QualType ParamTypes[2] = {EnumTy, EnumTy};
9169        S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
9170      }
9171    }
9172  }
9173
9174  // C++ [over.built]p13:
9175  //
9176  //   For every cv-qualified or cv-unqualified object type T
9177  //   there exist candidate operator functions of the form
9178  //
9179  //      T*         operator+(T*, ptrdiff_t);
9180  //      T&         operator[](T*, ptrdiff_t);    [BELOW]
9181  //      T*         operator-(T*, ptrdiff_t);
9182  //      T*         operator+(ptrdiff_t, T*);
9183  //      T&         operator[](ptrdiff_t, T*);    [BELOW]
9184  //
9185  // C++ [over.built]p14:
9186  //
9187  //   For every T, where T is a pointer to object type, there
9188  //   exist candidate operator functions of the form
9189  //
9190  //      ptrdiff_t  operator-(T, T);
9191  void addBinaryPlusOrMinusPointerOverloads(OverloadedOperatorKind Op) {
9192    /// Set of (canonical) types that we've already handled.
9193    llvm::SmallPtrSet<QualType, 8> AddedTypes;
9194
9195    for (int Arg = 0; Arg < 2; ++Arg) {
9196      QualType AsymmetricParamTypes[2] = {
9197        S.Context.getPointerDiffType(),
9198        S.Context.getPointerDiffType(),
9199      };
9200      for (QualType PtrTy : CandidateTypes[Arg].pointer_types()) {
9201        QualType PointeeTy = PtrTy->getPointeeType();
9202        if (!PointeeTy->isObjectType())
9203          continue;
9204
9205        AsymmetricParamTypes[Arg] = PtrTy;
9206        if (Arg == 0 || Op == OO_Plus) {
9207          // operator+(T*, ptrdiff_t) or operator-(T*, ptrdiff_t)
9208          // T* operator+(ptrdiff_t, T*);
9209          S.AddBuiltinCandidate(AsymmetricParamTypes, Args, CandidateSet);
9210        }
9211        if (Op == OO_Minus) {
9212          // ptrdiff_t operator-(T, T);
9213          if (!AddedTypes.insert(S.Context.getCanonicalType(PtrTy)).second)
9214            continue;
9215
9216          QualType ParamTypes[2] = {PtrTy, PtrTy};
9217          S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
9218        }
9219      }
9220    }
9221  }
9222
9223  // C++ [over.built]p12:
9224  //
9225  //   For every pair of promoted arithmetic types L and R, there
9226  //   exist candidate operator functions of the form
9227  //
9228  //        LR         operator*(L, R);
9229  //        LR         operator/(L, R);
9230  //        LR         operator+(L, R);
9231  //        LR         operator-(L, R);
9232  //        bool       operator<(L, R);
9233  //        bool       operator>(L, R);
9234  //        bool       operator<=(L, R);
9235  //        bool       operator>=(L, R);
9236  //        bool       operator==(L, R);
9237  //        bool       operator!=(L, R);
9238  //
9239  //   where LR is the result of the usual arithmetic conversions
9240  //   between types L and R.
9241  //
9242  // C++ [over.built]p24:
9243  //
9244  //   For every pair of promoted arithmetic types L and R, there exist
9245  //   candidate operator functions of the form
9246  //
9247  //        LR       operator?(bool, L, R);
9248  //
9249  //   where LR is the result of the usual arithmetic conversions
9250  //   between types L and R.
9251  // Our candidates ignore the first parameter.
9252  void addGenericBinaryArithmeticOverloads() {
9253    if (!HasArithmeticOrEnumeralCandidateType)
9254      return;
9255
9256    for (unsigned Left = FirstPromotedArithmeticType;
9257         Left < LastPromotedArithmeticType; ++Left) {
9258      for (unsigned Right = FirstPromotedArithmeticType;
9259           Right < LastPromotedArithmeticType; ++Right) {
9260        QualType LandR[2] = { ArithmeticTypes[Left],
9261                              ArithmeticTypes[Right] };
9262        S.AddBuiltinCandidate(LandR, Args, CandidateSet);
9263      }
9264    }
9265
9266    // Extension: Add the binary operators ==, !=, <, <=, >=, >, *, /, and the
9267    // conditional operator for vector types.
9268    for (QualType Vec1Ty : CandidateTypes[0].vector_types())
9269      for (QualType Vec2Ty : CandidateTypes[1].vector_types()) {
9270        QualType LandR[2] = {Vec1Ty, Vec2Ty};
9271        S.AddBuiltinCandidate(LandR, Args, CandidateSet);
9272      }
9273  }
9274
9275  /// Add binary operator overloads for each candidate matrix type M1, M2:
9276  ///  * (M1, M1) -> M1
9277  ///  * (M1, M1.getElementType()) -> M1
9278  ///  * (M2.getElementType(), M2) -> M2
9279  ///  * (M2, M2) -> M2 // Only if M2 is not part of CandidateTypes[0].
9280  void addMatrixBinaryArithmeticOverloads() {
9281    if (!HasArithmeticOrEnumeralCandidateType)
9282      return;
9283
9284    for (QualType M1 : CandidateTypes[0].matrix_types()) {
9285      AddCandidate(M1, cast<MatrixType>(M1)->getElementType());
9286      AddCandidate(M1, M1);
9287    }
9288
9289    for (QualType M2 : CandidateTypes[1].matrix_types()) {
9290      AddCandidate(cast<MatrixType>(M2)->getElementType(), M2);
9291      if (!CandidateTypes[0].containsMatrixType(M2))
9292        AddCandidate(M2, M2);
9293    }
9294  }
9295
9296  // C++2a [over.built]p14:
9297  //
9298  //   For every integral type T there exists a candidate operator function
9299  //   of the form
9300  //
9301  //        std::strong_ordering operator<=>(T, T)
9302  //
9303  // C++2a [over.built]p15:
9304  //
9305  //   For every pair of floating-point types L and R, there exists a candidate
9306  //   operator function of the form
9307  //
9308  //       std::partial_ordering operator<=>(L, R);
9309  //
9310  // FIXME: The current specification for integral types doesn't play nice with
9311  // the direction of p0946r0, which allows mixed integral and unscoped-enum
9312  // comparisons. Under the current spec this can lead to ambiguity during
9313  // overload resolution. For example:
9314  //
9315  //   enum A : int {a};
9316  //   auto x = (a <=> (long)42);
9317  //
9318  //   error: call is ambiguous for arguments 'A' and 'long'.
9319  //   note: candidate operator<=>(int, int)
9320  //   note: candidate operator<=>(long, long)
9321  //
9322  // To avoid this error, this function deviates from the specification and adds
9323  // the mixed overloads `operator<=>(L, R)` where L and R are promoted
9324  // arithmetic types (the same as the generic relational overloads).
9325  //
9326  // For now this function acts as a placeholder.
9327  void addThreeWayArithmeticOverloads() {
9328    addGenericBinaryArithmeticOverloads();
9329  }
9330
9331  // C++ [over.built]p17:
9332  //
9333  //   For every pair of promoted integral types L and R, there
9334  //   exist candidate operator functions of the form
9335  //
9336  //      LR         operator%(L, R);
9337  //      LR         operator&(L, R);
9338  //      LR         operator^(L, R);
9339  //      LR         operator|(L, R);
9340  //      L          operator<<(L, R);
9341  //      L          operator>>(L, R);
9342  //
9343  //   where LR is the result of the usual arithmetic conversions
9344  //   between types L and R.
9345  void addBinaryBitwiseArithmeticOverloads() {
9346    if (!HasArithmeticOrEnumeralCandidateType)
9347      return;
9348
9349    for (unsigned Left = FirstPromotedIntegralType;
9350         Left < LastPromotedIntegralType; ++Left) {
9351      for (unsigned Right = FirstPromotedIntegralType;
9352           Right < LastPromotedIntegralType; ++Right) {
9353        QualType LandR[2] = { ArithmeticTypes[Left],
9354                              ArithmeticTypes[Right] };
9355        S.AddBuiltinCandidate(LandR, Args, CandidateSet);
9356      }
9357    }
9358  }
9359
9360  // C++ [over.built]p20:
9361  //
9362  //   For every pair (T, VQ), where T is an enumeration or
9363  //   pointer to member type and VQ is either volatile or
9364  //   empty, there exist candidate operator functions of the form
9365  //
9366  //        VQ T&      operator=(VQ T&, T);
9367  void addAssignmentMemberPointerOrEnumeralOverloads() {
9368    /// Set of (canonical) types that we've already handled.
9369    llvm::SmallPtrSet<QualType, 8> AddedTypes;
9370
9371    for (unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) {
9372      for (QualType EnumTy : CandidateTypes[ArgIdx].enumeration_types()) {
9373        if (!AddedTypes.insert(S.Context.getCanonicalType(EnumTy)).second)
9374          continue;
9375
9376        AddBuiltinAssignmentOperatorCandidates(S, EnumTy, Args, CandidateSet);
9377      }
9378
9379      for (QualType MemPtrTy : CandidateTypes[ArgIdx].member_pointer_types()) {
9380        if (!AddedTypes.insert(S.Context.getCanonicalType(MemPtrTy)).second)
9381          continue;
9382
9383        AddBuiltinAssignmentOperatorCandidates(S, MemPtrTy, Args, CandidateSet);
9384      }
9385    }
9386  }
9387
9388  // C++ [over.built]p19:
9389  //
9390  //   For every pair (T, VQ), where T is any type and VQ is either
9391  //   volatile or empty, there exist candidate operator functions
9392  //   of the form
9393  //
9394  //        T*VQ&      operator=(T*VQ&, T*);
9395  //
9396  // C++ [over.built]p21:
9397  //
9398  //   For every pair (T, VQ), where T is a cv-qualified or
9399  //   cv-unqualified object type and VQ is either volatile or
9400  //   empty, there exist candidate operator functions of the form
9401  //
9402  //        T*VQ&      operator+=(T*VQ&, ptrdiff_t);
9403  //        T*VQ&      operator-=(T*VQ&, ptrdiff_t);
9404  void addAssignmentPointerOverloads(bool isEqualOp) {
9405    /// Set of (canonical) types that we've already handled.
9406    llvm::SmallPtrSet<QualType, 8> AddedTypes;
9407
9408    for (QualType PtrTy : CandidateTypes[0].pointer_types()) {
9409      // If this is operator=, keep track of the builtin candidates we added.
9410      if (isEqualOp)
9411        AddedTypes.insert(S.Context.getCanonicalType(PtrTy));
9412      else if (!PtrTy->getPointeeType()->isObjectType())
9413        continue;
9414
9415      // non-volatile version
9416      QualType ParamTypes[2] = {
9417          S.Context.getLValueReferenceType(PtrTy),
9418          isEqualOp ? PtrTy : S.Context.getPointerDiffType(),
9419      };
9420      S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
9421                            /*IsAssignmentOperator=*/ isEqualOp);
9422
9423      bool NeedVolatile = !PtrTy.isVolatileQualified() &&
9424                          VisibleTypeConversionsQuals.hasVolatile();
9425      if (NeedVolatile) {
9426        // volatile version
9427        ParamTypes[0] =
9428            S.Context.getLValueReferenceType(S.Context.getVolatileType(PtrTy));
9429        S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
9430                              /*IsAssignmentOperator=*/isEqualOp);
9431      }
9432
9433      if (!PtrTy.isRestrictQualified() &&
9434          VisibleTypeConversionsQuals.hasRestrict()) {
9435        // restrict version
9436        ParamTypes[0] =
9437            S.Context.getLValueReferenceType(S.Context.getRestrictType(PtrTy));
9438        S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
9439                              /*IsAssignmentOperator=*/isEqualOp);
9440
9441        if (NeedVolatile) {
9442          // volatile restrict version
9443          ParamTypes[0] =
9444              S.Context.getLValueReferenceType(S.Context.getCVRQualifiedType(
9445                  PtrTy, (Qualifiers::Volatile | Qualifiers::Restrict)));
9446          S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
9447                                /*IsAssignmentOperator=*/isEqualOp);
9448        }
9449      }
9450    }
9451
9452    if (isEqualOp) {
9453      for (QualType PtrTy : CandidateTypes[1].pointer_types()) {
9454        // Make sure we don't add the same candidate twice.
9455        if (!AddedTypes.insert(S.Context.getCanonicalType(PtrTy)).second)
9456          continue;
9457
9458        QualType ParamTypes[2] = {
9459            S.Context.getLValueReferenceType(PtrTy),
9460            PtrTy,
9461        };
9462
9463        // non-volatile version
9464        S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
9465                              /*IsAssignmentOperator=*/true);
9466
9467        bool NeedVolatile = !PtrTy.isVolatileQualified() &&
9468                            VisibleTypeConversionsQuals.hasVolatile();
9469        if (NeedVolatile) {
9470          // volatile version
9471          ParamTypes[0] = S.Context.getLValueReferenceType(
9472              S.Context.getVolatileType(PtrTy));
9473          S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
9474                                /*IsAssignmentOperator=*/true);
9475        }
9476
9477        if (!PtrTy.isRestrictQualified() &&
9478            VisibleTypeConversionsQuals.hasRestrict()) {
9479          // restrict version
9480          ParamTypes[0] = S.Context.getLValueReferenceType(
9481              S.Context.getRestrictType(PtrTy));
9482          S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
9483                                /*IsAssignmentOperator=*/true);
9484
9485          if (NeedVolatile) {
9486            // volatile restrict version
9487            ParamTypes[0] =
9488                S.Context.getLValueReferenceType(S.Context.getCVRQualifiedType(
9489                    PtrTy, (Qualifiers::Volatile | Qualifiers::Restrict)));
9490            S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
9491                                  /*IsAssignmentOperator=*/true);
9492          }
9493        }
9494      }
9495    }
9496  }
9497
9498  // C++ [over.built]p18:
9499  //
9500  //   For every triple (L, VQ, R), where L is an arithmetic type,
9501  //   VQ is either volatile or empty, and R is a promoted
9502  //   arithmetic type, there exist candidate operator functions of
9503  //   the form
9504  //
9505  //        VQ L&      operator=(VQ L&, R);
9506  //        VQ L&      operator*=(VQ L&, R);
9507  //        VQ L&      operator/=(VQ L&, R);
9508  //        VQ L&      operator+=(VQ L&, R);
9509  //        VQ L&      operator-=(VQ L&, R);
9510  void addAssignmentArithmeticOverloads(bool isEqualOp) {
9511    if (!HasArithmeticOrEnumeralCandidateType)
9512      return;
9513
9514    for (unsigned Left = 0; Left < NumArithmeticTypes; ++Left) {
9515      for (unsigned Right = FirstPromotedArithmeticType;
9516           Right < LastPromotedArithmeticType; ++Right) {
9517        QualType ParamTypes[2];
9518        ParamTypes[1] = ArithmeticTypes[Right];
9519        auto LeftBaseTy = AdjustAddressSpaceForBuiltinOperandType(
9520            S, ArithmeticTypes[Left], Args[0]);
9521
9522        forAllQualifierCombinations(
9523            VisibleTypeConversionsQuals, [&](QualifiersAndAtomic Quals) {
9524              ParamTypes[0] =
9525                  makeQualifiedLValueReferenceType(LeftBaseTy, Quals, S);
9526              S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
9527                                    /*IsAssignmentOperator=*/isEqualOp);
9528            });
9529      }
9530    }
9531
9532    // Extension: Add the binary operators =, +=, -=, *=, /= for vector types.
9533    for (QualType Vec1Ty : CandidateTypes[0].vector_types())
9534      for (QualType Vec2Ty : CandidateTypes[0].vector_types()) {
9535        QualType ParamTypes[2];
9536        ParamTypes[1] = Vec2Ty;
9537        // Add this built-in operator as a candidate (VQ is empty).
9538        ParamTypes[0] = S.Context.getLValueReferenceType(Vec1Ty);
9539        S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
9540                              /*IsAssignmentOperator=*/isEqualOp);
9541
9542        // Add this built-in operator as a candidate (VQ is 'volatile').
9543        if (VisibleTypeConversionsQuals.hasVolatile()) {
9544          ParamTypes[0] = S.Context.getVolatileType(Vec1Ty);
9545          ParamTypes[0] = S.Context.getLValueReferenceType(ParamTypes[0]);
9546          S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
9547                                /*IsAssignmentOperator=*/isEqualOp);
9548        }
9549      }
9550  }
9551
9552  // C++ [over.built]p22:
9553  //
9554  //   For every triple (L, VQ, R), where L is an integral type, VQ
9555  //   is either volatile or empty, and R is a promoted integral
9556  //   type, there exist candidate operator functions of the form
9557  //
9558  //        VQ L&       operator%=(VQ L&, R);
9559  //        VQ L&       operator<<=(VQ L&, R);
9560  //        VQ L&       operator>>=(VQ L&, R);
9561  //        VQ L&       operator&=(VQ L&, R);
9562  //        VQ L&       operator^=(VQ L&, R);
9563  //        VQ L&       operator|=(VQ L&, R);
9564  void addAssignmentIntegralOverloads() {
9565    if (!HasArithmeticOrEnumeralCandidateType)
9566      return;
9567
9568    for (unsigned Left = FirstIntegralType; Left < LastIntegralType; ++Left) {
9569      for (unsigned Right = FirstPromotedIntegralType;
9570           Right < LastPromotedIntegralType; ++Right) {
9571        QualType ParamTypes[2];
9572        ParamTypes[1] = ArithmeticTypes[Right];
9573        auto LeftBaseTy = AdjustAddressSpaceForBuiltinOperandType(
9574            S, ArithmeticTypes[Left], Args[0]);
9575
9576        forAllQualifierCombinations(
9577            VisibleTypeConversionsQuals, [&](QualifiersAndAtomic Quals) {
9578              ParamTypes[0] =
9579                  makeQualifiedLValueReferenceType(LeftBaseTy, Quals, S);
9580              S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
9581            });
9582      }
9583    }
9584  }
9585
9586  // C++ [over.operator]p23:
9587  //
9588  //   There also exist candidate operator functions of the form
9589  //
9590  //        bool        operator!(bool);
9591  //        bool        operator&&(bool, bool);
9592  //        bool        operator||(bool, bool);
9593  void addExclaimOverload() {
9594    QualType ParamTy = S.Context.BoolTy;
9595    S.AddBuiltinCandidate(&ParamTy, Args, CandidateSet,
9596                          /*IsAssignmentOperator=*/false,
9597                          /*NumContextualBoolArguments=*/1);
9598  }
9599  void addAmpAmpOrPipePipeOverload() {
9600    QualType ParamTypes[2] = { S.Context.BoolTy, S.Context.BoolTy };
9601    S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
9602                          /*IsAssignmentOperator=*/false,
9603                          /*NumContextualBoolArguments=*/2);
9604  }
9605
9606  // C++ [over.built]p13:
9607  //
9608  //   For every cv-qualified or cv-unqualified object type T there
9609  //   exist candidate operator functions of the form
9610  //
9611  //        T*         operator+(T*, ptrdiff_t);     [ABOVE]
9612  //        T&         operator[](T*, ptrdiff_t);
9613  //        T*         operator-(T*, ptrdiff_t);     [ABOVE]
9614  //        T*         operator+(ptrdiff_t, T*);     [ABOVE]
9615  //        T&         operator[](ptrdiff_t, T*);
9616  void addSubscriptOverloads() {
9617    for (QualType PtrTy : CandidateTypes[0].pointer_types()) {
9618      QualType ParamTypes[2] = {PtrTy, S.Context.getPointerDiffType()};
9619      QualType PointeeType = PtrTy->getPointeeType();
9620      if (!PointeeType->isObjectType())
9621        continue;
9622
9623      // T& operator[](T*, ptrdiff_t)
9624      S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
9625    }
9626
9627    for (QualType PtrTy : CandidateTypes[1].pointer_types()) {
9628      QualType ParamTypes[2] = {S.Context.getPointerDiffType(), PtrTy};
9629      QualType PointeeType = PtrTy->getPointeeType();
9630      if (!PointeeType->isObjectType())
9631        continue;
9632
9633      // T& operator[](ptrdiff_t, T*)
9634      S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
9635    }
9636  }
9637
9638  // C++ [over.built]p11:
9639  //    For every quintuple (C1, C2, T, CV1, CV2), where C2 is a class type,
9640  //    C1 is the same type as C2 or is a derived class of C2, T is an object
9641  //    type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
9642  //    there exist candidate operator functions of the form
9643  //
9644  //      CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
9645  //
9646  //    where CV12 is the union of CV1 and CV2.
9647  void addArrowStarOverloads() {
9648    for (QualType PtrTy : CandidateTypes[0].pointer_types()) {
9649      QualType C1Ty = PtrTy;
9650      QualType C1;
9651      QualifierCollector Q1;
9652      C1 = QualType(Q1.strip(C1Ty->getPointeeType()), 0);
9653      if (!isa<RecordType>(C1))
9654        continue;
9655      // heuristic to reduce number of builtin candidates in the set.
9656      // Add volatile/restrict version only if there are conversions to a
9657      // volatile/restrict type.
9658      if (!VisibleTypeConversionsQuals.hasVolatile() && Q1.hasVolatile())
9659        continue;
9660      if (!VisibleTypeConversionsQuals.hasRestrict() && Q1.hasRestrict())
9661        continue;
9662      for (QualType MemPtrTy : CandidateTypes[1].member_pointer_types()) {
9663        const MemberPointerType *mptr = cast<MemberPointerType>(MemPtrTy);
9664        QualType C2 = QualType(mptr->getClass(), 0);
9665        C2 = C2.getUnqualifiedType();
9666        if (C1 != C2 && !S.IsDerivedFrom(CandidateSet.getLocation(), C1, C2))
9667          break;
9668        QualType ParamTypes[2] = {PtrTy, MemPtrTy};
9669        // build CV12 T&
9670        QualType T = mptr->getPointeeType();
9671        if (!VisibleTypeConversionsQuals.hasVolatile() &&
9672            T.isVolatileQualified())
9673          continue;
9674        if (!VisibleTypeConversionsQuals.hasRestrict() &&
9675            T.isRestrictQualified())
9676          continue;
9677        T = Q1.apply(S.Context, T);
9678        S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
9679      }
9680    }
9681  }
9682
9683  // Note that we don't consider the first argument, since it has been
9684  // contextually converted to bool long ago. The candidates below are
9685  // therefore added as binary.
9686  //
9687  // C++ [over.built]p25:
9688  //   For every type T, where T is a pointer, pointer-to-member, or scoped
9689  //   enumeration type, there exist candidate operator functions of the form
9690  //
9691  //        T        operator?(bool, T, T);
9692  //
9693  void addConditionalOperatorOverloads() {
9694    /// Set of (canonical) types that we've already handled.
9695    llvm::SmallPtrSet<QualType, 8> AddedTypes;
9696
9697    for (unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) {
9698      for (QualType PtrTy : CandidateTypes[ArgIdx].pointer_types()) {
9699        if (!AddedTypes.insert(S.Context.getCanonicalType(PtrTy)).second)
9700          continue;
9701
9702        QualType ParamTypes[2] = {PtrTy, PtrTy};
9703        S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
9704      }
9705
9706      for (QualType MemPtrTy : CandidateTypes[ArgIdx].member_pointer_types()) {
9707        if (!AddedTypes.insert(S.Context.getCanonicalType(MemPtrTy)).second)
9708          continue;
9709
9710        QualType ParamTypes[2] = {MemPtrTy, MemPtrTy};
9711        S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
9712      }
9713
9714      if (S.getLangOpts().CPlusPlus11) {
9715        for (QualType EnumTy : CandidateTypes[ArgIdx].enumeration_types()) {
9716          if (!EnumTy->castAs<EnumType>()->getDecl()->isScoped())
9717            continue;
9718
9719          if (!AddedTypes.insert(S.Context.getCanonicalType(EnumTy)).second)
9720            continue;
9721
9722          QualType ParamTypes[2] = {EnumTy, EnumTy};
9723          S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
9724        }
9725      }
9726    }
9727  }
9728};
9729
9730} // end anonymous namespace
9731
9732/// AddBuiltinOperatorCandidates - Add the appropriate built-in
9733/// operator overloads to the candidate set (C++ [over.built]), based
9734/// on the operator @p Op and the arguments given. For example, if the
9735/// operator is a binary '+', this routine might add "int
9736/// operator+(int, int)" to cover integer addition.
9737void Sema::AddBuiltinOperatorCandidates(OverloadedOperatorKind Op,
9738                                        SourceLocation OpLoc,
9739                                        ArrayRef<Expr *> Args,
9740                                        OverloadCandidateSet &CandidateSet) {
9741  // Find all of the types that the arguments can convert to, but only
9742  // if the operator we're looking at has built-in operator candidates
9743  // that make use of these types. Also record whether we encounter non-record
9744  // candidate types or either arithmetic or enumeral candidate types.
9745  QualifiersAndAtomic VisibleTypeConversionsQuals;
9746  VisibleTypeConversionsQuals.addConst();
9747  for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
9748    VisibleTypeConversionsQuals += CollectVRQualifiers(Context, Args[ArgIdx]);
9749    if (Args[ArgIdx]->getType()->isAtomicType())
9750      VisibleTypeConversionsQuals.addAtomic();
9751  }
9752
9753  bool HasNonRecordCandidateType = false;
9754  bool HasArithmeticOrEnumeralCandidateType = false;
9755  SmallVector<BuiltinCandidateTypeSet, 2> CandidateTypes;
9756  for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
9757    CandidateTypes.emplace_back(*this);
9758    CandidateTypes[ArgIdx].AddTypesConvertedFrom(Args[ArgIdx]->getType(),
9759                                                 OpLoc,
9760                                                 true,
9761                                                 (Op == OO_Exclaim ||
9762                                                  Op == OO_AmpAmp ||
9763                                                  Op == OO_PipePipe),
9764                                                 VisibleTypeConversionsQuals);
9765    HasNonRecordCandidateType = HasNonRecordCandidateType ||
9766        CandidateTypes[ArgIdx].hasNonRecordTypes();
9767    HasArithmeticOrEnumeralCandidateType =
9768        HasArithmeticOrEnumeralCandidateType ||
9769        CandidateTypes[ArgIdx].hasArithmeticOrEnumeralTypes();
9770  }
9771
9772  // Exit early when no non-record types have been added to the candidate set
9773  // for any of the arguments to the operator.
9774  //
9775  // We can't exit early for !, ||, or &&, since there we have always have
9776  // 'bool' overloads.
9777  if (!HasNonRecordCandidateType &&
9778      !(Op == OO_Exclaim || Op == OO_AmpAmp || Op == OO_PipePipe))
9779    return;
9780
9781  // Setup an object to manage the common state for building overloads.
9782  BuiltinOperatorOverloadBuilder OpBuilder(*this, Args,
9783                                           VisibleTypeConversionsQuals,
9784                                           HasArithmeticOrEnumeralCandidateType,
9785                                           CandidateTypes, CandidateSet);
9786
9787  // Dispatch over the operation to add in only those overloads which apply.
9788  switch (Op) {
9789  case OO_None:
9790  case NUM_OVERLOADED_OPERATORS:
9791    llvm_unreachable("Expected an overloaded operator");
9792
9793  case OO_New:
9794  case OO_Delete:
9795  case OO_Array_New:
9796  case OO_Array_Delete:
9797  case OO_Call:
9798    llvm_unreachable(
9799                    "Special operators don't use AddBuiltinOperatorCandidates");
9800
9801  case OO_Comma:
9802  case OO_Arrow:
9803  case OO_Coawait:
9804    // C++ [over.match.oper]p3:
9805    //   -- For the operator ',', the unary operator '&', the
9806    //      operator '->', or the operator 'co_await', the
9807    //      built-in candidates set is empty.
9808    break;
9809
9810  case OO_Plus: // '+' is either unary or binary
9811    if (Args.size() == 1)
9812      OpBuilder.addUnaryPlusPointerOverloads();
9813    [[fallthrough]];
9814
9815  case OO_Minus: // '-' is either unary or binary
9816    if (Args.size() == 1) {
9817      OpBuilder.addUnaryPlusOrMinusArithmeticOverloads();
9818    } else {
9819      OpBuilder.addBinaryPlusOrMinusPointerOverloads(Op);
9820      OpBuilder.addGenericBinaryArithmeticOverloads();
9821      OpBuilder.addMatrixBinaryArithmeticOverloads();
9822    }
9823    break;
9824
9825  case OO_Star: // '*' is either unary or binary
9826    if (Args.size() == 1)
9827      OpBuilder.addUnaryStarPointerOverloads();
9828    else {
9829      OpBuilder.addGenericBinaryArithmeticOverloads();
9830      OpBuilder.addMatrixBinaryArithmeticOverloads();
9831    }
9832    break;
9833
9834  case OO_Slash:
9835    OpBuilder.addGenericBinaryArithmeticOverloads();
9836    break;
9837
9838  case OO_PlusPlus:
9839  case OO_MinusMinus:
9840    OpBuilder.addPlusPlusMinusMinusArithmeticOverloads(Op);
9841    OpBuilder.addPlusPlusMinusMinusPointerOverloads();
9842    break;
9843
9844  case OO_EqualEqual:
9845  case OO_ExclaimEqual:
9846    OpBuilder.addEqualEqualOrNotEqualMemberPointerOrNullptrOverloads();
9847    OpBuilder.addGenericBinaryPointerOrEnumeralOverloads(/*IsSpaceship=*/false);
9848    OpBuilder.addGenericBinaryArithmeticOverloads();
9849    break;
9850
9851  case OO_Less:
9852  case OO_Greater:
9853  case OO_LessEqual:
9854  case OO_GreaterEqual:
9855    OpBuilder.addGenericBinaryPointerOrEnumeralOverloads(/*IsSpaceship=*/false);
9856    OpBuilder.addGenericBinaryArithmeticOverloads();
9857    break;
9858
9859  case OO_Spaceship:
9860    OpBuilder.addGenericBinaryPointerOrEnumeralOverloads(/*IsSpaceship=*/true);
9861    OpBuilder.addThreeWayArithmeticOverloads();
9862    break;
9863
9864  case OO_Percent:
9865  case OO_Caret:
9866  case OO_Pipe:
9867  case OO_LessLess:
9868  case OO_GreaterGreater:
9869    OpBuilder.addBinaryBitwiseArithmeticOverloads();
9870    break;
9871
9872  case OO_Amp: // '&' is either unary or binary
9873    if (Args.size() == 1)
9874      // C++ [over.match.oper]p3:
9875      //   -- For the operator ',', the unary operator '&', or the
9876      //      operator '->', the built-in candidates set is empty.
9877      break;
9878
9879    OpBuilder.addBinaryBitwiseArithmeticOverloads();
9880    break;
9881
9882  case OO_Tilde:
9883    OpBuilder.addUnaryTildePromotedIntegralOverloads();
9884    break;
9885
9886  case OO_Equal:
9887    OpBuilder.addAssignmentMemberPointerOrEnumeralOverloads();
9888    [[fallthrough]];
9889
9890  case OO_PlusEqual:
9891  case OO_MinusEqual:
9892    OpBuilder.addAssignmentPointerOverloads(Op == OO_Equal);
9893    [[fallthrough]];
9894
9895  case OO_StarEqual:
9896  case OO_SlashEqual:
9897    OpBuilder.addAssignmentArithmeticOverloads(Op == OO_Equal);
9898    break;
9899
9900  case OO_PercentEqual:
9901  case OO_LessLessEqual:
9902  case OO_GreaterGreaterEqual:
9903  case OO_AmpEqual:
9904  case OO_CaretEqual:
9905  case OO_PipeEqual:
9906    OpBuilder.addAssignmentIntegralOverloads();
9907    break;
9908
9909  case OO_Exclaim:
9910    OpBuilder.addExclaimOverload();
9911    break;
9912
9913  case OO_AmpAmp:
9914  case OO_PipePipe:
9915    OpBuilder.addAmpAmpOrPipePipeOverload();
9916    break;
9917
9918  case OO_Subscript:
9919    if (Args.size() == 2)
9920      OpBuilder.addSubscriptOverloads();
9921    break;
9922
9923  case OO_ArrowStar:
9924    OpBuilder.addArrowStarOverloads();
9925    break;
9926
9927  case OO_Conditional:
9928    OpBuilder.addConditionalOperatorOverloads();
9929    OpBuilder.addGenericBinaryArithmeticOverloads();
9930    break;
9931  }
9932}
9933
9934/// Add function candidates found via argument-dependent lookup
9935/// to the set of overloading candidates.
9936///
9937/// This routine performs argument-dependent name lookup based on the
9938/// given function name (which may also be an operator name) and adds
9939/// all of the overload candidates found by ADL to the overload
9940/// candidate set (C++ [basic.lookup.argdep]).
9941void
9942Sema::AddArgumentDependentLookupCandidates(DeclarationName Name,
9943                                           SourceLocation Loc,
9944                                           ArrayRef<Expr *> Args,
9945                                 TemplateArgumentListInfo *ExplicitTemplateArgs,
9946                                           OverloadCandidateSet& CandidateSet,
9947                                           bool PartialOverloading) {
9948  ADLResult Fns;
9949
9950  // FIXME: This approach for uniquing ADL results (and removing
9951  // redundant candidates from the set) relies on pointer-equality,
9952  // which means we need to key off the canonical decl.  However,
9953  // always going back to the canonical decl might not get us the
9954  // right set of default arguments.  What default arguments are
9955  // we supposed to consider on ADL candidates, anyway?
9956
9957  // FIXME: Pass in the explicit template arguments?
9958  ArgumentDependentLookup(Name, Loc, Args, Fns);
9959
9960  // Erase all of the candidates we already knew about.
9961  for (OverloadCandidateSet::iterator Cand = CandidateSet.begin(),
9962                                   CandEnd = CandidateSet.end();
9963       Cand != CandEnd; ++Cand)
9964    if (Cand->Function) {
9965      Fns.erase(Cand->Function);
9966      if (FunctionTemplateDecl *FunTmpl = Cand->Function->getPrimaryTemplate())
9967        Fns.erase(FunTmpl);
9968    }
9969
9970  // For each of the ADL candidates we found, add it to the overload
9971  // set.
9972  for (ADLResult::iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) {
9973    DeclAccessPair FoundDecl = DeclAccessPair::make(*I, AS_none);
9974
9975    if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
9976      if (ExplicitTemplateArgs)
9977        continue;
9978
9979      AddOverloadCandidate(
9980          FD, FoundDecl, Args, CandidateSet, /*SuppressUserConversions=*/false,
9981          PartialOverloading, /*AllowExplicit=*/true,
9982          /*AllowExplicitConversion=*/false, ADLCallKind::UsesADL);
9983      if (CandidateSet.getRewriteInfo().shouldAddReversed(*this, Args, FD)) {
9984        AddOverloadCandidate(
9985            FD, FoundDecl, {Args[1], Args[0]}, CandidateSet,
9986            /*SuppressUserConversions=*/false, PartialOverloading,
9987            /*AllowExplicit=*/true, /*AllowExplicitConversion=*/false,
9988            ADLCallKind::UsesADL, std::nullopt,
9989            OverloadCandidateParamOrder::Reversed);
9990      }
9991    } else {
9992      auto *FTD = cast<FunctionTemplateDecl>(*I);
9993      AddTemplateOverloadCandidate(
9994          FTD, FoundDecl, ExplicitTemplateArgs, Args, CandidateSet,
9995          /*SuppressUserConversions=*/false, PartialOverloading,
9996          /*AllowExplicit=*/true, ADLCallKind::UsesADL);
9997      if (CandidateSet.getRewriteInfo().shouldAddReversed(
9998              *this, Args, FTD->getTemplatedDecl())) {
9999        AddTemplateOverloadCandidate(
10000            FTD, FoundDecl, ExplicitTemplateArgs, {Args[1], Args[0]},
10001            CandidateSet, /*SuppressUserConversions=*/false, PartialOverloading,
10002            /*AllowExplicit=*/true, ADLCallKind::UsesADL,
10003            OverloadCandidateParamOrder::Reversed);
10004      }
10005    }
10006  }
10007}
10008
10009namespace {
10010enum class Comparison { Equal, Better, Worse };
10011}
10012
10013/// Compares the enable_if attributes of two FunctionDecls, for the purposes of
10014/// overload resolution.
10015///
10016/// Cand1's set of enable_if attributes are said to be "better" than Cand2's iff
10017/// Cand1's first N enable_if attributes have precisely the same conditions as
10018/// Cand2's first N enable_if attributes (where N = the number of enable_if
10019/// attributes on Cand2), and Cand1 has more than N enable_if attributes.
10020///
10021/// Note that you can have a pair of candidates such that Cand1's enable_if
10022/// attributes are worse than Cand2's, and Cand2's enable_if attributes are
10023/// worse than Cand1's.
10024static Comparison compareEnableIfAttrs(const Sema &S, const FunctionDecl *Cand1,
10025                                       const FunctionDecl *Cand2) {
10026  // Common case: One (or both) decls don't have enable_if attrs.
10027  bool Cand1Attr = Cand1->hasAttr<EnableIfAttr>();
10028  bool Cand2Attr = Cand2->hasAttr<EnableIfAttr>();
10029  if (!Cand1Attr || !Cand2Attr) {
10030    if (Cand1Attr == Cand2Attr)
10031      return Comparison::Equal;
10032    return Cand1Attr ? Comparison::Better : Comparison::Worse;
10033  }
10034
10035  auto Cand1Attrs = Cand1->specific_attrs<EnableIfAttr>();
10036  auto Cand2Attrs = Cand2->specific_attrs<EnableIfAttr>();
10037
10038  llvm::FoldingSetNodeID Cand1ID, Cand2ID;
10039  for (auto Pair : zip_longest(Cand1Attrs, Cand2Attrs)) {
10040    std::optional<EnableIfAttr *> Cand1A = std::get<0>(Pair);
10041    std::optional<EnableIfAttr *> Cand2A = std::get<1>(Pair);
10042
10043    // It's impossible for Cand1 to be better than (or equal to) Cand2 if Cand1
10044    // has fewer enable_if attributes than Cand2, and vice versa.
10045    if (!Cand1A)
10046      return Comparison::Worse;
10047    if (!Cand2A)
10048      return Comparison::Better;
10049
10050    Cand1ID.clear();
10051    Cand2ID.clear();
10052
10053    (*Cand1A)->getCond()->Profile(Cand1ID, S.getASTContext(), true);
10054    (*Cand2A)->getCond()->Profile(Cand2ID, S.getASTContext(), true);
10055    if (Cand1ID != Cand2ID)
10056      return Comparison::Worse;
10057  }
10058
10059  return Comparison::Equal;
10060}
10061
10062static Comparison
10063isBetterMultiversionCandidate(const OverloadCandidate &Cand1,
10064                              const OverloadCandidate &Cand2) {
10065  if (!Cand1.Function || !Cand1.Function->isMultiVersion() || !Cand2.Function ||
10066      !Cand2.Function->isMultiVersion())
10067    return Comparison::Equal;
10068
10069  // If both are invalid, they are equal. If one of them is invalid, the other
10070  // is better.
10071  if (Cand1.Function->isInvalidDecl()) {
10072    if (Cand2.Function->isInvalidDecl())
10073      return Comparison::Equal;
10074    return Comparison::Worse;
10075  }
10076  if (Cand2.Function->isInvalidDecl())
10077    return Comparison::Better;
10078
10079  // If this is a cpu_dispatch/cpu_specific multiversion situation, prefer
10080  // cpu_dispatch, else arbitrarily based on the identifiers.
10081  bool Cand1CPUDisp = Cand1.Function->hasAttr<CPUDispatchAttr>();
10082  bool Cand2CPUDisp = Cand2.Function->hasAttr<CPUDispatchAttr>();
10083  const auto *Cand1CPUSpec = Cand1.Function->getAttr<CPUSpecificAttr>();
10084  const auto *Cand2CPUSpec = Cand2.Function->getAttr<CPUSpecificAttr>();
10085
10086  if (!Cand1CPUDisp && !Cand2CPUDisp && !Cand1CPUSpec && !Cand2CPUSpec)
10087    return Comparison::Equal;
10088
10089  if (Cand1CPUDisp && !Cand2CPUDisp)
10090    return Comparison::Better;
10091  if (Cand2CPUDisp && !Cand1CPUDisp)
10092    return Comparison::Worse;
10093
10094  if (Cand1CPUSpec && Cand2CPUSpec) {
10095    if (Cand1CPUSpec->cpus_size() != Cand2CPUSpec->cpus_size())
10096      return Cand1CPUSpec->cpus_size() < Cand2CPUSpec->cpus_size()
10097                 ? Comparison::Better
10098                 : Comparison::Worse;
10099
10100    std::pair<CPUSpecificAttr::cpus_iterator, CPUSpecificAttr::cpus_iterator>
10101        FirstDiff = std::mismatch(
10102            Cand1CPUSpec->cpus_begin(), Cand1CPUSpec->cpus_end(),
10103            Cand2CPUSpec->cpus_begin(),
10104            [](const IdentifierInfo *LHS, const IdentifierInfo *RHS) {
10105              return LHS->getName() == RHS->getName();
10106            });
10107
10108    assert(FirstDiff.first != Cand1CPUSpec->cpus_end() &&
10109           "Two different cpu-specific versions should not have the same "
10110           "identifier list, otherwise they'd be the same decl!");
10111    return (*FirstDiff.first)->getName() < (*FirstDiff.second)->getName()
10112               ? Comparison::Better
10113               : Comparison::Worse;
10114  }
10115  llvm_unreachable("No way to get here unless both had cpu_dispatch");
10116}
10117
10118/// Compute the type of the implicit object parameter for the given function,
10119/// if any. Returns std::nullopt if there is no implicit object parameter, and a
10120/// null QualType if there is a 'matches anything' implicit object parameter.
10121static std::optional<QualType>
10122getImplicitObjectParamType(ASTContext &Context, const FunctionDecl *F) {
10123  if (!isa<CXXMethodDecl>(F) || isa<CXXConstructorDecl>(F))
10124    return std::nullopt;
10125
10126  auto *M = cast<CXXMethodDecl>(F);
10127  // Static member functions' object parameters match all types.
10128  if (M->isStatic())
10129    return QualType();
10130  return M->getFunctionObjectParameterReferenceType();
10131}
10132
10133// As a Clang extension, allow ambiguity among F1 and F2 if they represent
10134// represent the same entity.
10135static bool allowAmbiguity(ASTContext &Context, const FunctionDecl *F1,
10136                           const FunctionDecl *F2) {
10137  if (declaresSameEntity(F1, F2))
10138    return true;
10139  auto PT1 = F1->getPrimaryTemplate();
10140  auto PT2 = F2->getPrimaryTemplate();
10141  if (PT1 && PT2) {
10142    if (declaresSameEntity(PT1, PT2) ||
10143        declaresSameEntity(PT1->getInstantiatedFromMemberTemplate(),
10144                           PT2->getInstantiatedFromMemberTemplate()))
10145      return true;
10146  }
10147  // TODO: It is not clear whether comparing parameters is necessary (i.e.
10148  // different functions with same params). Consider removing this (as no test
10149  // fail w/o it).
10150  auto NextParam = [&](const FunctionDecl *F, unsigned &I, bool First) {
10151    if (First) {
10152      if (std::optional<QualType> T = getImplicitObjectParamType(Context, F))
10153        return *T;
10154    }
10155    assert(I < F->getNumParams());
10156    return F->getParamDecl(I++)->getType();
10157  };
10158
10159  unsigned F1NumParams = F1->getNumParams() + isa<CXXMethodDecl>(F1);
10160  unsigned F2NumParams = F2->getNumParams() + isa<CXXMethodDecl>(F2);
10161
10162  if (F1NumParams != F2NumParams)
10163    return false;
10164
10165  unsigned I1 = 0, I2 = 0;
10166  for (unsigned I = 0; I != F1NumParams; ++I) {
10167    QualType T1 = NextParam(F1, I1, I == 0);
10168    QualType T2 = NextParam(F2, I2, I == 0);
10169    assert(!T1.isNull() && !T2.isNull() && "Unexpected null param types");
10170    if (!Context.hasSameUnqualifiedType(T1, T2))
10171      return false;
10172  }
10173  return true;
10174}
10175
10176/// We're allowed to use constraints partial ordering only if the candidates
10177/// have the same parameter types:
10178/// [over.match.best.general]p2.6
10179/// F1 and F2 are non-template functions with the same
10180/// non-object-parameter-type-lists, and F1 is more constrained than F2 [...]
10181static bool sameFunctionParameterTypeLists(Sema &S,
10182                                           const OverloadCandidate &Cand1,
10183                                           const OverloadCandidate &Cand2) {
10184  if (!Cand1.Function || !Cand2.Function)
10185    return false;
10186
10187  FunctionDecl *Fn1 = Cand1.Function;
10188  FunctionDecl *Fn2 = Cand2.Function;
10189
10190  if (Fn1->isVariadic() != Fn1->isVariadic())
10191    return false;
10192
10193  if (!S.FunctionNonObjectParamTypesAreEqual(
10194          Fn1, Fn2, nullptr, Cand1.isReversed() ^ Cand2.isReversed()))
10195    return false;
10196
10197  auto *Mem1 = dyn_cast<CXXMethodDecl>(Fn1);
10198  auto *Mem2 = dyn_cast<CXXMethodDecl>(Fn2);
10199  if (Mem1 && Mem2) {
10200    // if they are member functions, both are direct members of the same class,
10201    // and
10202    if (Mem1->getParent() != Mem2->getParent())
10203      return false;
10204    // if both are non-static member functions, they have the same types for
10205    // their object parameters
10206    if (Mem1->isInstance() && Mem2->isInstance() &&
10207        !S.getASTContext().hasSameType(
10208            Mem1->getFunctionObjectParameterReferenceType(),
10209            Mem1->getFunctionObjectParameterReferenceType()))
10210      return false;
10211  }
10212  return true;
10213}
10214
10215/// isBetterOverloadCandidate - Determines whether the first overload
10216/// candidate is a better candidate than the second (C++ 13.3.3p1).
10217bool clang::isBetterOverloadCandidate(
10218    Sema &S, const OverloadCandidate &Cand1, const OverloadCandidate &Cand2,
10219    SourceLocation Loc, OverloadCandidateSet::CandidateSetKind Kind) {
10220  // Define viable functions to be better candidates than non-viable
10221  // functions.
10222  if (!Cand2.Viable)
10223    return Cand1.Viable;
10224  else if (!Cand1.Viable)
10225    return false;
10226
10227  // [CUDA] A function with 'never' preference is marked not viable, therefore
10228  // is never shown up here. The worst preference shown up here is 'wrong side',
10229  // e.g. an H function called by a HD function in device compilation. This is
10230  // valid AST as long as the HD function is not emitted, e.g. it is an inline
10231  // function which is called only by an H function. A deferred diagnostic will
10232  // be triggered if it is emitted. However a wrong-sided function is still
10233  // a viable candidate here.
10234  //
10235  // If Cand1 can be emitted and Cand2 cannot be emitted in the current
10236  // context, Cand1 is better than Cand2. If Cand1 can not be emitted and Cand2
10237  // can be emitted, Cand1 is not better than Cand2. This rule should have
10238  // precedence over other rules.
10239  //
10240  // If both Cand1 and Cand2 can be emitted, or neither can be emitted, then
10241  // other rules should be used to determine which is better. This is because
10242  // host/device based overloading resolution is mostly for determining
10243  // viability of a function. If two functions are both viable, other factors
10244  // should take precedence in preference, e.g. the standard-defined preferences
10245  // like argument conversion ranks or enable_if partial-ordering. The
10246  // preference for pass-object-size parameters is probably most similar to a
10247  // type-based-overloading decision and so should take priority.
10248  //
10249  // If other rules cannot determine which is better, CUDA preference will be
10250  // used again to determine which is better.
10251  //
10252  // TODO: Currently IdentifyCUDAPreference does not return correct values
10253  // for functions called in global variable initializers due to missing
10254  // correct context about device/host. Therefore we can only enforce this
10255  // rule when there is a caller. We should enforce this rule for functions
10256  // in global variable initializers once proper context is added.
10257  //
10258  // TODO: We can only enable the hostness based overloading resolution when
10259  // -fgpu-exclude-wrong-side-overloads is on since this requires deferring
10260  // overloading resolution diagnostics.
10261  if (S.getLangOpts().CUDA && Cand1.Function && Cand2.Function &&
10262      S.getLangOpts().GPUExcludeWrongSideOverloads) {
10263    if (FunctionDecl *Caller = S.getCurFunctionDecl(/*AllowLambda=*/true)) {
10264      bool IsCallerImplicitHD = Sema::isCUDAImplicitHostDeviceFunction(Caller);
10265      bool IsCand1ImplicitHD =
10266          Sema::isCUDAImplicitHostDeviceFunction(Cand1.Function);
10267      bool IsCand2ImplicitHD =
10268          Sema::isCUDAImplicitHostDeviceFunction(Cand2.Function);
10269      auto P1 = S.IdentifyCUDAPreference(Caller, Cand1.Function);
10270      auto P2 = S.IdentifyCUDAPreference(Caller, Cand2.Function);
10271      assert(P1 != Sema::CFP_Never && P2 != Sema::CFP_Never);
10272      // The implicit HD function may be a function in a system header which
10273      // is forced by pragma. In device compilation, if we prefer HD candidates
10274      // over wrong-sided candidates, overloading resolution may change, which
10275      // may result in non-deferrable diagnostics. As a workaround, we let
10276      // implicit HD candidates take equal preference as wrong-sided candidates.
10277      // This will preserve the overloading resolution.
10278      // TODO: We still need special handling of implicit HD functions since
10279      // they may incur other diagnostics to be deferred. We should make all
10280      // host/device related diagnostics deferrable and remove special handling
10281      // of implicit HD functions.
10282      auto EmitThreshold =
10283          (S.getLangOpts().CUDAIsDevice && IsCallerImplicitHD &&
10284           (IsCand1ImplicitHD || IsCand2ImplicitHD))
10285              ? Sema::CFP_Never
10286              : Sema::CFP_WrongSide;
10287      auto Cand1Emittable = P1 > EmitThreshold;
10288      auto Cand2Emittable = P2 > EmitThreshold;
10289      if (Cand1Emittable && !Cand2Emittable)
10290        return true;
10291      if (!Cand1Emittable && Cand2Emittable)
10292        return false;
10293    }
10294  }
10295
10296  // C++ [over.match.best]p1: (Changed in C++23)
10297  //
10298  //   -- if F is a static member function, ICS1(F) is defined such
10299  //      that ICS1(F) is neither better nor worse than ICS1(G) for
10300  //      any function G, and, symmetrically, ICS1(G) is neither
10301  //      better nor worse than ICS1(F).
10302  unsigned StartArg = 0;
10303  if (Cand1.IgnoreObjectArgument || Cand2.IgnoreObjectArgument)
10304    StartArg = 1;
10305
10306  auto IsIllFormedConversion = [&](const ImplicitConversionSequence &ICS) {
10307    // We don't allow incompatible pointer conversions in C++.
10308    if (!S.getLangOpts().CPlusPlus)
10309      return ICS.isStandard() &&
10310             ICS.Standard.Second == ICK_Incompatible_Pointer_Conversion;
10311
10312    // The only ill-formed conversion we allow in C++ is the string literal to
10313    // char* conversion, which is only considered ill-formed after C++11.
10314    return S.getLangOpts().CPlusPlus11 && !S.getLangOpts().WritableStrings &&
10315           hasDeprecatedStringLiteralToCharPtrConversion(ICS);
10316  };
10317
10318  // Define functions that don't require ill-formed conversions for a given
10319  // argument to be better candidates than functions that do.
10320  unsigned NumArgs = Cand1.Conversions.size();
10321  assert(Cand2.Conversions.size() == NumArgs && "Overload candidate mismatch");
10322  bool HasBetterConversion = false;
10323  for (unsigned ArgIdx = StartArg; ArgIdx < NumArgs; ++ArgIdx) {
10324    bool Cand1Bad = IsIllFormedConversion(Cand1.Conversions[ArgIdx]);
10325    bool Cand2Bad = IsIllFormedConversion(Cand2.Conversions[ArgIdx]);
10326    if (Cand1Bad != Cand2Bad) {
10327      if (Cand1Bad)
10328        return false;
10329      HasBetterConversion = true;
10330    }
10331  }
10332
10333  if (HasBetterConversion)
10334    return true;
10335
10336  // C++ [over.match.best]p1:
10337  //   A viable function F1 is defined to be a better function than another
10338  //   viable function F2 if for all arguments i, ICSi(F1) is not a worse
10339  //   conversion sequence than ICSi(F2), and then...
10340  bool HasWorseConversion = false;
10341  for (unsigned ArgIdx = StartArg; ArgIdx < NumArgs; ++ArgIdx) {
10342    switch (CompareImplicitConversionSequences(S, Loc,
10343                                               Cand1.Conversions[ArgIdx],
10344                                               Cand2.Conversions[ArgIdx])) {
10345    case ImplicitConversionSequence::Better:
10346      // Cand1 has a better conversion sequence.
10347      HasBetterConversion = true;
10348      break;
10349
10350    case ImplicitConversionSequence::Worse:
10351      if (Cand1.Function && Cand2.Function &&
10352          Cand1.isReversed() != Cand2.isReversed() &&
10353          allowAmbiguity(S.Context, Cand1.Function, Cand2.Function)) {
10354        // Work around large-scale breakage caused by considering reversed
10355        // forms of operator== in C++20:
10356        //
10357        // When comparing a function against a reversed function, if we have a
10358        // better conversion for one argument and a worse conversion for the
10359        // other, the implicit conversion sequences are treated as being equally
10360        // good.
10361        //
10362        // This prevents a comparison function from being considered ambiguous
10363        // with a reversed form that is written in the same way.
10364        //
10365        // We diagnose this as an extension from CreateOverloadedBinOp.
10366        HasWorseConversion = true;
10367        break;
10368      }
10369
10370      // Cand1 can't be better than Cand2.
10371      return false;
10372
10373    case ImplicitConversionSequence::Indistinguishable:
10374      // Do nothing.
10375      break;
10376    }
10377  }
10378
10379  //    -- for some argument j, ICSj(F1) is a better conversion sequence than
10380  //       ICSj(F2), or, if not that,
10381  if (HasBetterConversion && !HasWorseConversion)
10382    return true;
10383
10384  //   -- the context is an initialization by user-defined conversion
10385  //      (see 8.5, 13.3.1.5) and the standard conversion sequence
10386  //      from the return type of F1 to the destination type (i.e.,
10387  //      the type of the entity being initialized) is a better
10388  //      conversion sequence than the standard conversion sequence
10389  //      from the return type of F2 to the destination type.
10390  if (Kind == OverloadCandidateSet::CSK_InitByUserDefinedConversion &&
10391      Cand1.Function && Cand2.Function &&
10392      isa<CXXConversionDecl>(Cand1.Function) &&
10393      isa<CXXConversionDecl>(Cand2.Function)) {
10394    // First check whether we prefer one of the conversion functions over the
10395    // other. This only distinguishes the results in non-standard, extension
10396    // cases such as the conversion from a lambda closure type to a function
10397    // pointer or block.
10398    ImplicitConversionSequence::CompareKind Result =
10399        compareConversionFunctions(S, Cand1.Function, Cand2.Function);
10400    if (Result == ImplicitConversionSequence::Indistinguishable)
10401      Result = CompareStandardConversionSequences(S, Loc,
10402                                                  Cand1.FinalConversion,
10403                                                  Cand2.FinalConversion);
10404
10405    if (Result != ImplicitConversionSequence::Indistinguishable)
10406      return Result == ImplicitConversionSequence::Better;
10407
10408    // FIXME: Compare kind of reference binding if conversion functions
10409    // convert to a reference type used in direct reference binding, per
10410    // C++14 [over.match.best]p1 section 2 bullet 3.
10411  }
10412
10413  // FIXME: Work around a defect in the C++17 guaranteed copy elision wording,
10414  // as combined with the resolution to CWG issue 243.
10415  //
10416  // When the context is initialization by constructor ([over.match.ctor] or
10417  // either phase of [over.match.list]), a constructor is preferred over
10418  // a conversion function.
10419  if (Kind == OverloadCandidateSet::CSK_InitByConstructor && NumArgs == 1 &&
10420      Cand1.Function && Cand2.Function &&
10421      isa<CXXConstructorDecl>(Cand1.Function) !=
10422          isa<CXXConstructorDecl>(Cand2.Function))
10423    return isa<CXXConstructorDecl>(Cand1.Function);
10424
10425  //    -- F1 is a non-template function and F2 is a function template
10426  //       specialization, or, if not that,
10427  bool Cand1IsSpecialization = Cand1.Function &&
10428                               Cand1.Function->getPrimaryTemplate();
10429  bool Cand2IsSpecialization = Cand2.Function &&
10430                               Cand2.Function->getPrimaryTemplate();
10431  if (Cand1IsSpecialization != Cand2IsSpecialization)
10432    return Cand2IsSpecialization;
10433
10434  //   -- F1 and F2 are function template specializations, and the function
10435  //      template for F1 is more specialized than the template for F2
10436  //      according to the partial ordering rules described in 14.5.5.2, or,
10437  //      if not that,
10438  if (Cand1IsSpecialization && Cand2IsSpecialization) {
10439    if (FunctionTemplateDecl *BetterTemplate = S.getMoreSpecializedTemplate(
10440            Cand1.Function->getPrimaryTemplate(),
10441            Cand2.Function->getPrimaryTemplate(), Loc,
10442            isa<CXXConversionDecl>(Cand1.Function) ? TPOC_Conversion
10443                                                   : TPOC_Call,
10444            Cand1.ExplicitCallArguments, Cand2.ExplicitCallArguments,
10445            Cand1.isReversed() ^ Cand2.isReversed()))
10446      return BetterTemplate == Cand1.Function->getPrimaryTemplate();
10447  }
10448
10449  //   -��� F1 and F2 are non-template functions with the same
10450  //      parameter-type-lists, and F1 is more constrained than F2 [...],
10451  if (!Cand1IsSpecialization && !Cand2IsSpecialization &&
10452      sameFunctionParameterTypeLists(S, Cand1, Cand2)) {
10453    FunctionDecl *Function1 = Cand1.Function;
10454    FunctionDecl *Function2 = Cand2.Function;
10455    if (FunctionDecl *MF = Function1->getInstantiatedFromMemberFunction())
10456      Function1 = MF;
10457    if (FunctionDecl *MF = Function2->getInstantiatedFromMemberFunction())
10458      Function2 = MF;
10459
10460    const Expr *RC1 = Function1->getTrailingRequiresClause();
10461    const Expr *RC2 = Function2->getTrailingRequiresClause();
10462    if (RC1 && RC2) {
10463      bool AtLeastAsConstrained1, AtLeastAsConstrained2;
10464      if (S.IsAtLeastAsConstrained(Function1, RC1, Function2, RC2,
10465                                   AtLeastAsConstrained1) ||
10466          S.IsAtLeastAsConstrained(Function2, RC2, Function1, RC1,
10467                                   AtLeastAsConstrained2))
10468        return false;
10469      if (AtLeastAsConstrained1 != AtLeastAsConstrained2)
10470        return AtLeastAsConstrained1;
10471    } else if (RC1 || RC2) {
10472      return RC1 != nullptr;
10473    }
10474  }
10475
10476  //   -- F1 is a constructor for a class D, F2 is a constructor for a base
10477  //      class B of D, and for all arguments the corresponding parameters of
10478  //      F1 and F2 have the same type.
10479  // FIXME: Implement the "all parameters have the same type" check.
10480  bool Cand1IsInherited =
10481      isa_and_nonnull<ConstructorUsingShadowDecl>(Cand1.FoundDecl.getDecl());
10482  bool Cand2IsInherited =
10483      isa_and_nonnull<ConstructorUsingShadowDecl>(Cand2.FoundDecl.getDecl());
10484  if (Cand1IsInherited != Cand2IsInherited)
10485    return Cand2IsInherited;
10486  else if (Cand1IsInherited) {
10487    assert(Cand2IsInherited);
10488    auto *Cand1Class = cast<CXXRecordDecl>(Cand1.Function->getDeclContext());
10489    auto *Cand2Class = cast<CXXRecordDecl>(Cand2.Function->getDeclContext());
10490    if (Cand1Class->isDerivedFrom(Cand2Class))
10491      return true;
10492    if (Cand2Class->isDerivedFrom(Cand1Class))
10493      return false;
10494    // Inherited from sibling base classes: still ambiguous.
10495  }
10496
10497  //   -- F2 is a rewritten candidate (12.4.1.2) and F1 is not
10498  //   -- F1 and F2 are rewritten candidates, and F2 is a synthesized candidate
10499  //      with reversed order of parameters and F1 is not
10500  //
10501  // We rank reversed + different operator as worse than just reversed, but
10502  // that comparison can never happen, because we only consider reversing for
10503  // the maximally-rewritten operator (== or <=>).
10504  if (Cand1.RewriteKind != Cand2.RewriteKind)
10505    return Cand1.RewriteKind < Cand2.RewriteKind;
10506
10507  // Check C++17 tie-breakers for deduction guides.
10508  {
10509    auto *Guide1 = dyn_cast_or_null<CXXDeductionGuideDecl>(Cand1.Function);
10510    auto *Guide2 = dyn_cast_or_null<CXXDeductionGuideDecl>(Cand2.Function);
10511    if (Guide1 && Guide2) {
10512      //  -- F1 is generated from a deduction-guide and F2 is not
10513      if (Guide1->isImplicit() != Guide2->isImplicit())
10514        return Guide2->isImplicit();
10515
10516      //  -- F1 is the copy deduction candidate(16.3.1.8) and F2 is not
10517      if (Guide1->getDeductionCandidateKind() == DeductionCandidate::Copy)
10518        return true;
10519      if (Guide2->getDeductionCandidateKind() == DeductionCandidate::Copy)
10520        return false;
10521
10522      //  --F1 is generated from a non-template constructor and F2 is generated
10523      //  from a constructor template
10524      const auto *Constructor1 = Guide1->getCorrespondingConstructor();
10525      const auto *Constructor2 = Guide2->getCorrespondingConstructor();
10526      if (Constructor1 && Constructor2) {
10527        bool isC1Templated = Constructor1->getTemplatedKind() !=
10528                             FunctionDecl::TemplatedKind::TK_NonTemplate;
10529        bool isC2Templated = Constructor2->getTemplatedKind() !=
10530                             FunctionDecl::TemplatedKind::TK_NonTemplate;
10531        if (isC1Templated != isC2Templated)
10532          return isC2Templated;
10533      }
10534    }
10535  }
10536
10537  // Check for enable_if value-based overload resolution.
10538  if (Cand1.Function && Cand2.Function) {
10539    Comparison Cmp = compareEnableIfAttrs(S, Cand1.Function, Cand2.Function);
10540    if (Cmp != Comparison::Equal)
10541      return Cmp == Comparison::Better;
10542  }
10543
10544  bool HasPS1 = Cand1.Function != nullptr &&
10545                functionHasPassObjectSizeParams(Cand1.Function);
10546  bool HasPS2 = Cand2.Function != nullptr &&
10547                functionHasPassObjectSizeParams(Cand2.Function);
10548  if (HasPS1 != HasPS2 && HasPS1)
10549    return true;
10550
10551  auto MV = isBetterMultiversionCandidate(Cand1, Cand2);
10552  if (MV == Comparison::Better)
10553    return true;
10554  if (MV == Comparison::Worse)
10555    return false;
10556
10557  // If other rules cannot determine which is better, CUDA preference is used
10558  // to determine which is better.
10559  if (S.getLangOpts().CUDA && Cand1.Function && Cand2.Function) {
10560    FunctionDecl *Caller = S.getCurFunctionDecl(/*AllowLambda=*/true);
10561    return S.IdentifyCUDAPreference(Caller, Cand1.Function) >
10562           S.IdentifyCUDAPreference(Caller, Cand2.Function);
10563  }
10564
10565  // General member function overloading is handled above, so this only handles
10566  // constructors with address spaces.
10567  // This only handles address spaces since C++ has no other
10568  // qualifier that can be used with constructors.
10569  const auto *CD1 = dyn_cast_or_null<CXXConstructorDecl>(Cand1.Function);
10570  const auto *CD2 = dyn_cast_or_null<CXXConstructorDecl>(Cand2.Function);
10571  if (CD1 && CD2) {
10572    LangAS AS1 = CD1->getMethodQualifiers().getAddressSpace();
10573    LangAS AS2 = CD2->getMethodQualifiers().getAddressSpace();
10574    if (AS1 != AS2) {
10575      if (Qualifiers::isAddressSpaceSupersetOf(AS2, AS1))
10576        return true;
10577      if (Qualifiers::isAddressSpaceSupersetOf(AS1, AS2))
10578        return false;
10579    }
10580  }
10581
10582  return false;
10583}
10584
10585/// Determine whether two declarations are "equivalent" for the purposes of
10586/// name lookup and overload resolution. This applies when the same internal/no
10587/// linkage entity is defined by two modules (probably by textually including
10588/// the same header). In such a case, we don't consider the declarations to
10589/// declare the same entity, but we also don't want lookups with both
10590/// declarations visible to be ambiguous in some cases (this happens when using
10591/// a modularized libstdc++).
10592bool Sema::isEquivalentInternalLinkageDeclaration(const NamedDecl *A,
10593                                                  const NamedDecl *B) {
10594  auto *VA = dyn_cast_or_null<ValueDecl>(A);
10595  auto *VB = dyn_cast_or_null<ValueDecl>(B);
10596  if (!VA || !VB)
10597    return false;
10598
10599  // The declarations must be declaring the same name as an internal linkage
10600  // entity in different modules.
10601  if (!VA->getDeclContext()->getRedeclContext()->Equals(
10602          VB->getDeclContext()->getRedeclContext()) ||
10603      getOwningModule(VA) == getOwningModule(VB) ||
10604      VA->isExternallyVisible() || VB->isExternallyVisible())
10605    return false;
10606
10607  // Check that the declarations appear to be equivalent.
10608  //
10609  // FIXME: Checking the type isn't really enough to resolve the ambiguity.
10610  // For constants and functions, we should check the initializer or body is
10611  // the same. For non-constant variables, we shouldn't allow it at all.
10612  if (Context.hasSameType(VA->getType(), VB->getType()))
10613    return true;
10614
10615  // Enum constants within unnamed enumerations will have different types, but
10616  // may still be similar enough to be interchangeable for our purposes.
10617  if (auto *EA = dyn_cast<EnumConstantDecl>(VA)) {
10618    if (auto *EB = dyn_cast<EnumConstantDecl>(VB)) {
10619      // Only handle anonymous enums. If the enumerations were named and
10620      // equivalent, they would have been merged to the same type.
10621      auto *EnumA = cast<EnumDecl>(EA->getDeclContext());
10622      auto *EnumB = cast<EnumDecl>(EB->getDeclContext());
10623      if (EnumA->hasNameForLinkage() || EnumB->hasNameForLinkage() ||
10624          !Context.hasSameType(EnumA->getIntegerType(),
10625                               EnumB->getIntegerType()))
10626        return false;
10627      // Allow this only if the value is the same for both enumerators.
10628      return llvm::APSInt::isSameValue(EA->getInitVal(), EB->getInitVal());
10629    }
10630  }
10631
10632  // Nothing else is sufficiently similar.
10633  return false;
10634}
10635
10636void Sema::diagnoseEquivalentInternalLinkageDeclarations(
10637    SourceLocation Loc, const NamedDecl *D, ArrayRef<const NamedDecl *> Equiv) {
10638  assert(D && "Unknown declaration");
10639  Diag(Loc, diag::ext_equivalent_internal_linkage_decl_in_modules) << D;
10640
10641  Module *M = getOwningModule(D);
10642  Diag(D->getLocation(), diag::note_equivalent_internal_linkage_decl)
10643      << !M << (M ? M->getFullModuleName() : "");
10644
10645  for (auto *E : Equiv) {
10646    Module *M = getOwningModule(E);
10647    Diag(E->getLocation(), diag::note_equivalent_internal_linkage_decl)
10648        << !M << (M ? M->getFullModuleName() : "");
10649  }
10650}
10651
10652bool OverloadCandidate::NotValidBecauseConstraintExprHasError() const {
10653  return FailureKind == ovl_fail_bad_deduction &&
10654         DeductionFailure.Result == Sema::TDK_ConstraintsNotSatisfied &&
10655         static_cast<CNSInfo *>(DeductionFailure.Data)
10656             ->Satisfaction.ContainsErrors;
10657}
10658
10659/// Computes the best viable function (C++ 13.3.3)
10660/// within an overload candidate set.
10661///
10662/// \param Loc The location of the function name (or operator symbol) for
10663/// which overload resolution occurs.
10664///
10665/// \param Best If overload resolution was successful or found a deleted
10666/// function, \p Best points to the candidate function found.
10667///
10668/// \returns The result of overload resolution.
10669OverloadingResult
10670OverloadCandidateSet::BestViableFunction(Sema &S, SourceLocation Loc,
10671                                         iterator &Best) {
10672  llvm::SmallVector<OverloadCandidate *, 16> Candidates;
10673  std::transform(begin(), end(), std::back_inserter(Candidates),
10674                 [](OverloadCandidate &Cand) { return &Cand; });
10675
10676  // [CUDA] HD->H or HD->D calls are technically not allowed by CUDA but
10677  // are accepted by both clang and NVCC. However, during a particular
10678  // compilation mode only one call variant is viable. We need to
10679  // exclude non-viable overload candidates from consideration based
10680  // only on their host/device attributes. Specifically, if one
10681  // candidate call is WrongSide and the other is SameSide, we ignore
10682  // the WrongSide candidate.
10683  // We only need to remove wrong-sided candidates here if
10684  // -fgpu-exclude-wrong-side-overloads is off. When
10685  // -fgpu-exclude-wrong-side-overloads is on, all candidates are compared
10686  // uniformly in isBetterOverloadCandidate.
10687  if (S.getLangOpts().CUDA && !S.getLangOpts().GPUExcludeWrongSideOverloads) {
10688    const FunctionDecl *Caller = S.getCurFunctionDecl(/*AllowLambda=*/true);
10689    bool ContainsSameSideCandidate =
10690        llvm::any_of(Candidates, [&](OverloadCandidate *Cand) {
10691          // Check viable function only.
10692          return Cand->Viable && Cand->Function &&
10693                 S.IdentifyCUDAPreference(Caller, Cand->Function) ==
10694                     Sema::CFP_SameSide;
10695        });
10696    if (ContainsSameSideCandidate) {
10697      auto IsWrongSideCandidate = [&](OverloadCandidate *Cand) {
10698        // Check viable function only to avoid unnecessary data copying/moving.
10699        return Cand->Viable && Cand->Function &&
10700               S.IdentifyCUDAPreference(Caller, Cand->Function) ==
10701                   Sema::CFP_WrongSide;
10702      };
10703      llvm::erase_if(Candidates, IsWrongSideCandidate);
10704    }
10705  }
10706
10707  // Find the best viable function.
10708  Best = end();
10709  for (auto *Cand : Candidates) {
10710    Cand->Best = false;
10711    if (Cand->Viable) {
10712      if (Best == end() ||
10713          isBetterOverloadCandidate(S, *Cand, *Best, Loc, Kind))
10714        Best = Cand;
10715    } else if (Cand->NotValidBecauseConstraintExprHasError()) {
10716      // This candidate has constraint that we were unable to evaluate because
10717      // it referenced an expression that contained an error. Rather than fall
10718      // back onto a potentially unintended candidate (made worse by
10719      // subsuming constraints), treat this as 'no viable candidate'.
10720      Best = end();
10721      return OR_No_Viable_Function;
10722    }
10723  }
10724
10725  // If we didn't find any viable functions, abort.
10726  if (Best == end())
10727    return OR_No_Viable_Function;
10728
10729  llvm::SmallVector<const NamedDecl *, 4> EquivalentCands;
10730
10731  llvm::SmallVector<OverloadCandidate*, 4> PendingBest;
10732  PendingBest.push_back(&*Best);
10733  Best->Best = true;
10734
10735  // Make sure that this function is better than every other viable
10736  // function. If not, we have an ambiguity.
10737  while (!PendingBest.empty()) {
10738    auto *Curr = PendingBest.pop_back_val();
10739    for (auto *Cand : Candidates) {
10740      if (Cand->Viable && !Cand->Best &&
10741          !isBetterOverloadCandidate(S, *Curr, *Cand, Loc, Kind)) {
10742        PendingBest.push_back(Cand);
10743        Cand->Best = true;
10744
10745        if (S.isEquivalentInternalLinkageDeclaration(Cand->Function,
10746                                                     Curr->Function))
10747          EquivalentCands.push_back(Cand->Function);
10748        else
10749          Best = end();
10750      }
10751    }
10752  }
10753
10754  // If we found more than one best candidate, this is ambiguous.
10755  if (Best == end())
10756    return OR_Ambiguous;
10757
10758  // Best is the best viable function.
10759  if (Best->Function && Best->Function->isDeleted())
10760    return OR_Deleted;
10761
10762  if (!EquivalentCands.empty())
10763    S.diagnoseEquivalentInternalLinkageDeclarations(Loc, Best->Function,
10764                                                    EquivalentCands);
10765
10766  return OR_Success;
10767}
10768
10769namespace {
10770
10771enum OverloadCandidateKind {
10772  oc_function,
10773  oc_method,
10774  oc_reversed_binary_operator,
10775  oc_constructor,
10776  oc_implicit_default_constructor,
10777  oc_implicit_copy_constructor,
10778  oc_implicit_move_constructor,
10779  oc_implicit_copy_assignment,
10780  oc_implicit_move_assignment,
10781  oc_implicit_equality_comparison,
10782  oc_inherited_constructor
10783};
10784
10785enum OverloadCandidateSelect {
10786  ocs_non_template,
10787  ocs_template,
10788  ocs_described_template,
10789};
10790
10791static std::pair<OverloadCandidateKind, OverloadCandidateSelect>
10792ClassifyOverloadCandidate(Sema &S, const NamedDecl *Found,
10793                          const FunctionDecl *Fn,
10794                          OverloadCandidateRewriteKind CRK,
10795                          std::string &Description) {
10796
10797  bool isTemplate = Fn->isTemplateDecl() || Found->isTemplateDecl();
10798  if (FunctionTemplateDecl *FunTmpl = Fn->getPrimaryTemplate()) {
10799    isTemplate = true;
10800    Description = S.getTemplateArgumentBindingsText(
10801        FunTmpl->getTemplateParameters(), *Fn->getTemplateSpecializationArgs());
10802  }
10803
10804  OverloadCandidateSelect Select = [&]() {
10805    if (!Description.empty())
10806      return ocs_described_template;
10807    return isTemplate ? ocs_template : ocs_non_template;
10808  }();
10809
10810  OverloadCandidateKind Kind = [&]() {
10811    if (Fn->isImplicit() && Fn->getOverloadedOperator() == OO_EqualEqual)
10812      return oc_implicit_equality_comparison;
10813
10814    if (CRK & CRK_Reversed)
10815      return oc_reversed_binary_operator;
10816
10817    if (const auto *Ctor = dyn_cast<CXXConstructorDecl>(Fn)) {
10818      if (!Ctor->isImplicit()) {
10819        if (isa<ConstructorUsingShadowDecl>(Found))
10820          return oc_inherited_constructor;
10821        else
10822          return oc_constructor;
10823      }
10824
10825      if (Ctor->isDefaultConstructor())
10826        return oc_implicit_default_constructor;
10827
10828      if (Ctor->isMoveConstructor())
10829        return oc_implicit_move_constructor;
10830
10831      assert(Ctor->isCopyConstructor() &&
10832             "unexpected sort of implicit constructor");
10833      return oc_implicit_copy_constructor;
10834    }
10835
10836    if (const auto *Meth = dyn_cast<CXXMethodDecl>(Fn)) {
10837      // This actually gets spelled 'candidate function' for now, but
10838      // it doesn't hurt to split it out.
10839      if (!Meth->isImplicit())
10840        return oc_method;
10841
10842      if (Meth->isMoveAssignmentOperator())
10843        return oc_implicit_move_assignment;
10844
10845      if (Meth->isCopyAssignmentOperator())
10846        return oc_implicit_copy_assignment;
10847
10848      assert(isa<CXXConversionDecl>(Meth) && "expected conversion");
10849      return oc_method;
10850    }
10851
10852    return oc_function;
10853  }();
10854
10855  return std::make_pair(Kind, Select);
10856}
10857
10858void MaybeEmitInheritedConstructorNote(Sema &S, const Decl *FoundDecl) {
10859  // FIXME: It'd be nice to only emit a note once per using-decl per overload
10860  // set.
10861  if (const auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(FoundDecl))
10862    S.Diag(FoundDecl->getLocation(),
10863           diag::note_ovl_candidate_inherited_constructor)
10864      << Shadow->getNominatedBaseClass();
10865}
10866
10867} // end anonymous namespace
10868
10869static bool isFunctionAlwaysEnabled(const ASTContext &Ctx,
10870                                    const FunctionDecl *FD) {
10871  for (auto *EnableIf : FD->specific_attrs<EnableIfAttr>()) {
10872    bool AlwaysTrue;
10873    if (EnableIf->getCond()->isValueDependent() ||
10874        !EnableIf->getCond()->EvaluateAsBooleanCondition(AlwaysTrue, Ctx))
10875      return false;
10876    if (!AlwaysTrue)
10877      return false;
10878  }
10879  return true;
10880}
10881
10882/// Returns true if we can take the address of the function.
10883///
10884/// \param Complain - If true, we'll emit a diagnostic
10885/// \param InOverloadResolution - For the purposes of emitting a diagnostic, are
10886///   we in overload resolution?
10887/// \param Loc - The location of the statement we're complaining about. Ignored
10888///   if we're not complaining, or if we're in overload resolution.
10889static bool checkAddressOfFunctionIsAvailable(Sema &S, const FunctionDecl *FD,
10890                                              bool Complain,
10891                                              bool InOverloadResolution,
10892                                              SourceLocation Loc) {
10893  if (!isFunctionAlwaysEnabled(S.Context, FD)) {
10894    if (Complain) {
10895      if (InOverloadResolution)
10896        S.Diag(FD->getBeginLoc(),
10897               diag::note_addrof_ovl_candidate_disabled_by_enable_if_attr);
10898      else
10899        S.Diag(Loc, diag::err_addrof_function_disabled_by_enable_if_attr) << FD;
10900    }
10901    return false;
10902  }
10903
10904  if (FD->getTrailingRequiresClause()) {
10905    ConstraintSatisfaction Satisfaction;
10906    if (S.CheckFunctionConstraints(FD, Satisfaction, Loc))
10907      return false;
10908    if (!Satisfaction.IsSatisfied) {
10909      if (Complain) {
10910        if (InOverloadResolution) {
10911          SmallString<128> TemplateArgString;
10912          if (FunctionTemplateDecl *FunTmpl = FD->getPrimaryTemplate()) {
10913            TemplateArgString += " ";
10914            TemplateArgString += S.getTemplateArgumentBindingsText(
10915                FunTmpl->getTemplateParameters(),
10916                *FD->getTemplateSpecializationArgs());
10917          }
10918
10919          S.Diag(FD->getBeginLoc(),
10920                 diag::note_ovl_candidate_unsatisfied_constraints)
10921              << TemplateArgString;
10922        } else
10923          S.Diag(Loc, diag::err_addrof_function_constraints_not_satisfied)
10924              << FD;
10925        S.DiagnoseUnsatisfiedConstraint(Satisfaction);
10926      }
10927      return false;
10928    }
10929  }
10930
10931  auto I = llvm::find_if(FD->parameters(), [](const ParmVarDecl *P) {
10932    return P->hasAttr<PassObjectSizeAttr>();
10933  });
10934  if (I == FD->param_end())
10935    return true;
10936
10937  if (Complain) {
10938    // Add one to ParamNo because it's user-facing
10939    unsigned ParamNo = std::distance(FD->param_begin(), I) + 1;
10940    if (InOverloadResolution)
10941      S.Diag(FD->getLocation(),
10942             diag::note_ovl_candidate_has_pass_object_size_params)
10943          << ParamNo;
10944    else
10945      S.Diag(Loc, diag::err_address_of_function_with_pass_object_size_params)
10946          << FD << ParamNo;
10947  }
10948  return false;
10949}
10950
10951static bool checkAddressOfCandidateIsAvailable(Sema &S,
10952                                               const FunctionDecl *FD) {
10953  return checkAddressOfFunctionIsAvailable(S, FD, /*Complain=*/true,
10954                                           /*InOverloadResolution=*/true,
10955                                           /*Loc=*/SourceLocation());
10956}
10957
10958bool Sema::checkAddressOfFunctionIsAvailable(const FunctionDecl *Function,
10959                                             bool Complain,
10960                                             SourceLocation Loc) {
10961  return ::checkAddressOfFunctionIsAvailable(*this, Function, Complain,
10962                                             /*InOverloadResolution=*/false,
10963                                             Loc);
10964}
10965
10966// Don't print candidates other than the one that matches the calling
10967// convention of the call operator, since that is guaranteed to exist.
10968static bool shouldSkipNotingLambdaConversionDecl(const FunctionDecl *Fn) {
10969  const auto *ConvD = dyn_cast<CXXConversionDecl>(Fn);
10970
10971  if (!ConvD)
10972    return false;
10973  const auto *RD = cast<CXXRecordDecl>(Fn->getParent());
10974  if (!RD->isLambda())
10975    return false;
10976
10977  CXXMethodDecl *CallOp = RD->getLambdaCallOperator();
10978  CallingConv CallOpCC =
10979      CallOp->getType()->castAs<FunctionType>()->getCallConv();
10980  QualType ConvRTy = ConvD->getType()->castAs<FunctionType>()->getReturnType();
10981  CallingConv ConvToCC =
10982      ConvRTy->getPointeeType()->castAs<FunctionType>()->getCallConv();
10983
10984  return ConvToCC != CallOpCC;
10985}
10986
10987// Notes the location of an overload candidate.
10988void Sema::NoteOverloadCandidate(const NamedDecl *Found, const FunctionDecl *Fn,
10989                                 OverloadCandidateRewriteKind RewriteKind,
10990                                 QualType DestType, bool TakingAddress) {
10991  if (TakingAddress && !checkAddressOfCandidateIsAvailable(*this, Fn))
10992    return;
10993  if (Fn->isMultiVersion() && Fn->hasAttr<TargetAttr>() &&
10994      !Fn->getAttr<TargetAttr>()->isDefaultVersion())
10995    return;
10996  if (Fn->isMultiVersion() && Fn->hasAttr<TargetVersionAttr>() &&
10997      !Fn->getAttr<TargetVersionAttr>()->isDefaultVersion())
10998    return;
10999  if (shouldSkipNotingLambdaConversionDecl(Fn))
11000    return;
11001
11002  std::string FnDesc;
11003  std::pair<OverloadCandidateKind, OverloadCandidateSelect> KSPair =
11004      ClassifyOverloadCandidate(*this, Found, Fn, RewriteKind, FnDesc);
11005  PartialDiagnostic PD = PDiag(diag::note_ovl_candidate)
11006                         << (unsigned)KSPair.first << (unsigned)KSPair.second
11007                         << Fn << FnDesc;
11008
11009  HandleFunctionTypeMismatch(PD, Fn->getType(), DestType);
11010  Diag(Fn->getLocation(), PD);
11011  MaybeEmitInheritedConstructorNote(*this, Found);
11012}
11013
11014static void
11015MaybeDiagnoseAmbiguousConstraints(Sema &S, ArrayRef<OverloadCandidate> Cands) {
11016  // Perhaps the ambiguity was caused by two atomic constraints that are
11017  // 'identical' but not equivalent:
11018  //
11019  // void foo() requires (sizeof(T) > 4) { } // #1
11020  // void foo() requires (sizeof(T) > 4) && T::value { } // #2
11021  //
11022  // The 'sizeof(T) > 4' constraints are seemingly equivalent and should cause
11023  // #2 to subsume #1, but these constraint are not considered equivalent
11024  // according to the subsumption rules because they are not the same
11025  // source-level construct. This behavior is quite confusing and we should try
11026  // to help the user figure out what happened.
11027
11028  SmallVector<const Expr *, 3> FirstAC, SecondAC;
11029  FunctionDecl *FirstCand = nullptr, *SecondCand = nullptr;
11030  for (auto I = Cands.begin(), E = Cands.end(); I != E; ++I) {
11031    if (!I->Function)
11032      continue;
11033    SmallVector<const Expr *, 3> AC;
11034    if (auto *Template = I->Function->getPrimaryTemplate())
11035      Template->getAssociatedConstraints(AC);
11036    else
11037      I->Function->getAssociatedConstraints(AC);
11038    if (AC.empty())
11039      continue;
11040    if (FirstCand == nullptr) {
11041      FirstCand = I->Function;
11042      FirstAC = AC;
11043    } else if (SecondCand == nullptr) {
11044      SecondCand = I->Function;
11045      SecondAC = AC;
11046    } else {
11047      // We have more than one pair of constrained functions - this check is
11048      // expensive and we'd rather not try to diagnose it.
11049      return;
11050    }
11051  }
11052  if (!SecondCand)
11053    return;
11054  // The diagnostic can only happen if there are associated constraints on
11055  // both sides (there needs to be some identical atomic constraint).
11056  if (S.MaybeEmitAmbiguousAtomicConstraintsDiagnostic(FirstCand, FirstAC,
11057                                                      SecondCand, SecondAC))
11058    // Just show the user one diagnostic, they'll probably figure it out
11059    // from here.
11060    return;
11061}
11062
11063// Notes the location of all overload candidates designated through
11064// OverloadedExpr
11065void Sema::NoteAllOverloadCandidates(Expr *OverloadedExpr, QualType DestType,
11066                                     bool TakingAddress) {
11067  assert(OverloadedExpr->getType() == Context.OverloadTy);
11068
11069  OverloadExpr::FindResult Ovl = OverloadExpr::find(OverloadedExpr);
11070  OverloadExpr *OvlExpr = Ovl.Expression;
11071
11072  for (UnresolvedSetIterator I = OvlExpr->decls_begin(),
11073                            IEnd = OvlExpr->decls_end();
11074       I != IEnd; ++I) {
11075    if (FunctionTemplateDecl *FunTmpl =
11076                dyn_cast<FunctionTemplateDecl>((*I)->getUnderlyingDecl()) ) {
11077      NoteOverloadCandidate(*I, FunTmpl->getTemplatedDecl(), CRK_None, DestType,
11078                            TakingAddress);
11079    } else if (FunctionDecl *Fun
11080                      = dyn_cast<FunctionDecl>((*I)->getUnderlyingDecl()) ) {
11081      NoteOverloadCandidate(*I, Fun, CRK_None, DestType, TakingAddress);
11082    }
11083  }
11084}
11085
11086/// Diagnoses an ambiguous conversion.  The partial diagnostic is the
11087/// "lead" diagnostic; it will be given two arguments, the source and
11088/// target types of the conversion.
11089void ImplicitConversionSequence::DiagnoseAmbiguousConversion(
11090                                 Sema &S,
11091                                 SourceLocation CaretLoc,
11092                                 const PartialDiagnostic &PDiag) const {
11093  S.Diag(CaretLoc, PDiag)
11094    << Ambiguous.getFromType() << Ambiguous.getToType();
11095  unsigned CandsShown = 0;
11096  AmbiguousConversionSequence::const_iterator I, E;
11097  for (I = Ambiguous.begin(), E = Ambiguous.end(); I != E; ++I) {
11098    if (CandsShown >= S.Diags.getNumOverloadCandidatesToShow())
11099      break;
11100    ++CandsShown;
11101    S.NoteOverloadCandidate(I->first, I->second);
11102  }
11103  S.Diags.overloadCandidatesShown(CandsShown);
11104  if (I != E)
11105    S.Diag(SourceLocation(), diag::note_ovl_too_many_candidates) << int(E - I);
11106}
11107
11108static void DiagnoseBadConversion(Sema &S, OverloadCandidate *Cand,
11109                                  unsigned I, bool TakingCandidateAddress) {
11110  const ImplicitConversionSequence &Conv = Cand->Conversions[I];
11111  assert(Conv.isBad());
11112  assert(Cand->Function && "for now, candidate must be a function");
11113  FunctionDecl *Fn = Cand->Function;
11114
11115  // There's a conversion slot for the object argument if this is a
11116  // non-constructor method.  Note that 'I' corresponds the
11117  // conversion-slot index.
11118  bool isObjectArgument = false;
11119  if (isa<CXXMethodDecl>(Fn) && !isa<CXXConstructorDecl>(Fn)) {
11120    if (I == 0)
11121      isObjectArgument = true;
11122    else
11123      I--;
11124  }
11125
11126  std::string FnDesc;
11127  std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
11128      ClassifyOverloadCandidate(S, Cand->FoundDecl, Fn, Cand->getRewriteKind(),
11129                                FnDesc);
11130
11131  Expr *FromExpr = Conv.Bad.FromExpr;
11132  QualType FromTy = Conv.Bad.getFromType();
11133  QualType ToTy = Conv.Bad.getToType();
11134  SourceRange ToParamRange =
11135      !isObjectArgument ? Fn->getParamDecl(I)->getSourceRange() : SourceRange();
11136
11137  if (FromTy == S.Context.OverloadTy) {
11138    assert(FromExpr && "overload set argument came from implicit argument?");
11139    Expr *E = FromExpr->IgnoreParens();
11140    if (isa<UnaryOperator>(E))
11141      E = cast<UnaryOperator>(E)->getSubExpr()->IgnoreParens();
11142    DeclarationName Name = cast<OverloadExpr>(E)->getName();
11143
11144    S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_overload)
11145        << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
11146        << ToParamRange << ToTy << Name << I + 1;
11147    MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
11148    return;
11149  }
11150
11151  // Do some hand-waving analysis to see if the non-viability is due
11152  // to a qualifier mismatch.
11153  CanQualType CFromTy = S.Context.getCanonicalType(FromTy);
11154  CanQualType CToTy = S.Context.getCanonicalType(ToTy);
11155  if (CanQual<ReferenceType> RT = CToTy->getAs<ReferenceType>())
11156    CToTy = RT->getPointeeType();
11157  else {
11158    // TODO: detect and diagnose the full richness of const mismatches.
11159    if (CanQual<PointerType> FromPT = CFromTy->getAs<PointerType>())
11160      if (CanQual<PointerType> ToPT = CToTy->getAs<PointerType>()) {
11161        CFromTy = FromPT->getPointeeType();
11162        CToTy = ToPT->getPointeeType();
11163      }
11164  }
11165
11166  if (CToTy.getUnqualifiedType() == CFromTy.getUnqualifiedType() &&
11167      !CToTy.isAtLeastAsQualifiedAs(CFromTy)) {
11168    Qualifiers FromQs = CFromTy.getQualifiers();
11169    Qualifiers ToQs = CToTy.getQualifiers();
11170
11171    if (FromQs.getAddressSpace() != ToQs.getAddressSpace()) {
11172      if (isObjectArgument)
11173        S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_addrspace_this)
11174            << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second
11175            << FnDesc << FromQs.getAddressSpace() << ToQs.getAddressSpace();
11176      else
11177        S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_addrspace)
11178            << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second
11179            << FnDesc << ToParamRange << FromQs.getAddressSpace()
11180            << ToQs.getAddressSpace() << ToTy->isReferenceType() << I + 1;
11181      MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
11182      return;
11183    }
11184
11185    if (FromQs.getObjCLifetime() != ToQs.getObjCLifetime()) {
11186      S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_ownership)
11187          << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
11188          << ToParamRange << FromTy << FromQs.getObjCLifetime()
11189          << ToQs.getObjCLifetime() << (unsigned)isObjectArgument << I + 1;
11190      MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
11191      return;
11192    }
11193
11194    if (FromQs.getObjCGCAttr() != ToQs.getObjCGCAttr()) {
11195      S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_gc)
11196          << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
11197          << ToParamRange << FromTy << FromQs.getObjCGCAttr()
11198          << ToQs.getObjCGCAttr() << (unsigned)isObjectArgument << I + 1;
11199      MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
11200      return;
11201    }
11202
11203    unsigned CVR = FromQs.getCVRQualifiers() & ~ToQs.getCVRQualifiers();
11204    assert(CVR && "expected qualifiers mismatch");
11205
11206    if (isObjectArgument) {
11207      S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_cvr_this)
11208          << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
11209          << FromTy << (CVR - 1);
11210    } else {
11211      S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_cvr)
11212          << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
11213          << ToParamRange << FromTy << (CVR - 1) << I + 1;
11214    }
11215    MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
11216    return;
11217  }
11218
11219  if (Conv.Bad.Kind == BadConversionSequence::lvalue_ref_to_rvalue ||
11220      Conv.Bad.Kind == BadConversionSequence::rvalue_ref_to_lvalue) {
11221    S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_value_category)
11222        << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
11223        << (unsigned)isObjectArgument << I + 1
11224        << (Conv.Bad.Kind == BadConversionSequence::rvalue_ref_to_lvalue)
11225        << ToParamRange;
11226    MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
11227    return;
11228  }
11229
11230  // Special diagnostic for failure to convert an initializer list, since
11231  // telling the user that it has type void is not useful.
11232  if (FromExpr && isa<InitListExpr>(FromExpr)) {
11233    S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_list_argument)
11234        << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
11235        << ToParamRange << FromTy << ToTy << (unsigned)isObjectArgument << I + 1
11236        << (Conv.Bad.Kind == BadConversionSequence::too_few_initializers ? 1
11237            : Conv.Bad.Kind == BadConversionSequence::too_many_initializers
11238                ? 2
11239                : 0);
11240    MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
11241    return;
11242  }
11243
11244  // Diagnose references or pointers to incomplete types differently,
11245  // since it's far from impossible that the incompleteness triggered
11246  // the failure.
11247  QualType TempFromTy = FromTy.getNonReferenceType();
11248  if (const PointerType *PTy = TempFromTy->getAs<PointerType>())
11249    TempFromTy = PTy->getPointeeType();
11250  if (TempFromTy->isIncompleteType()) {
11251    // Emit the generic diagnostic and, optionally, add the hints to it.
11252    S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_conv_incomplete)
11253        << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
11254        << ToParamRange << FromTy << ToTy << (unsigned)isObjectArgument << I + 1
11255        << (unsigned)(Cand->Fix.Kind);
11256
11257    MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
11258    return;
11259  }
11260
11261  // Diagnose base -> derived pointer conversions.
11262  unsigned BaseToDerivedConversion = 0;
11263  if (const PointerType *FromPtrTy = FromTy->getAs<PointerType>()) {
11264    if (const PointerType *ToPtrTy = ToTy->getAs<PointerType>()) {
11265      if (ToPtrTy->getPointeeType().isAtLeastAsQualifiedAs(
11266                                               FromPtrTy->getPointeeType()) &&
11267          !FromPtrTy->getPointeeType()->isIncompleteType() &&
11268          !ToPtrTy->getPointeeType()->isIncompleteType() &&
11269          S.IsDerivedFrom(SourceLocation(), ToPtrTy->getPointeeType(),
11270                          FromPtrTy->getPointeeType()))
11271        BaseToDerivedConversion = 1;
11272    }
11273  } else if (const ObjCObjectPointerType *FromPtrTy
11274                                    = FromTy->getAs<ObjCObjectPointerType>()) {
11275    if (const ObjCObjectPointerType *ToPtrTy
11276                                        = ToTy->getAs<ObjCObjectPointerType>())
11277      if (const ObjCInterfaceDecl *FromIface = FromPtrTy->getInterfaceDecl())
11278        if (const ObjCInterfaceDecl *ToIface = ToPtrTy->getInterfaceDecl())
11279          if (ToPtrTy->getPointeeType().isAtLeastAsQualifiedAs(
11280                                                FromPtrTy->getPointeeType()) &&
11281              FromIface->isSuperClassOf(ToIface))
11282            BaseToDerivedConversion = 2;
11283  } else if (const ReferenceType *ToRefTy = ToTy->getAs<ReferenceType>()) {
11284    if (ToRefTy->getPointeeType().isAtLeastAsQualifiedAs(FromTy) &&
11285        !FromTy->isIncompleteType() &&
11286        !ToRefTy->getPointeeType()->isIncompleteType() &&
11287        S.IsDerivedFrom(SourceLocation(), ToRefTy->getPointeeType(), FromTy)) {
11288      BaseToDerivedConversion = 3;
11289    }
11290  }
11291
11292  if (BaseToDerivedConversion) {
11293    S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_base_to_derived_conv)
11294        << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
11295        << ToParamRange << (BaseToDerivedConversion - 1) << FromTy << ToTy
11296        << I + 1;
11297    MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
11298    return;
11299  }
11300
11301  if (isa<ObjCObjectPointerType>(CFromTy) &&
11302      isa<PointerType>(CToTy)) {
11303    Qualifiers FromQs = CFromTy.getQualifiers();
11304    Qualifiers ToQs = CToTy.getQualifiers();
11305    if (FromQs.getObjCLifetime() != ToQs.getObjCLifetime()) {
11306      S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_arc_conv)
11307          << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
11308          << ToParamRange << FromTy << ToTy << (unsigned)isObjectArgument
11309          << I + 1;
11310      MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
11311      return;
11312    }
11313  }
11314
11315  if (TakingCandidateAddress &&
11316      !checkAddressOfCandidateIsAvailable(S, Cand->Function))
11317    return;
11318
11319  // Emit the generic diagnostic and, optionally, add the hints to it.
11320  PartialDiagnostic FDiag = S.PDiag(diag::note_ovl_candidate_bad_conv);
11321  FDiag << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
11322        << ToParamRange << FromTy << ToTy << (unsigned)isObjectArgument << I + 1
11323        << (unsigned)(Cand->Fix.Kind);
11324
11325  // Check that location of Fn is not in system header.
11326  if (!S.SourceMgr.isInSystemHeader(Fn->getLocation())) {
11327    // If we can fix the conversion, suggest the FixIts.
11328    for (const FixItHint &HI : Cand->Fix.Hints)
11329        FDiag << HI;
11330  }
11331
11332  S.Diag(Fn->getLocation(), FDiag);
11333
11334  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
11335}
11336
11337/// Additional arity mismatch diagnosis specific to a function overload
11338/// candidates. This is not covered by the more general DiagnoseArityMismatch()
11339/// over a candidate in any candidate set.
11340static bool CheckArityMismatch(Sema &S, OverloadCandidate *Cand,
11341                               unsigned NumArgs) {
11342  FunctionDecl *Fn = Cand->Function;
11343  unsigned MinParams = Fn->getMinRequiredArguments();
11344
11345  // With invalid overloaded operators, it's possible that we think we
11346  // have an arity mismatch when in fact it looks like we have the
11347  // right number of arguments, because only overloaded operators have
11348  // the weird behavior of overloading member and non-member functions.
11349  // Just don't report anything.
11350  if (Fn->isInvalidDecl() &&
11351      Fn->getDeclName().getNameKind() == DeclarationName::CXXOperatorName)
11352    return true;
11353
11354  if (NumArgs < MinParams) {
11355    assert((Cand->FailureKind == ovl_fail_too_few_arguments) ||
11356           (Cand->FailureKind == ovl_fail_bad_deduction &&
11357            Cand->DeductionFailure.Result == Sema::TDK_TooFewArguments));
11358  } else {
11359    assert((Cand->FailureKind == ovl_fail_too_many_arguments) ||
11360           (Cand->FailureKind == ovl_fail_bad_deduction &&
11361            Cand->DeductionFailure.Result == Sema::TDK_TooManyArguments));
11362  }
11363
11364  return false;
11365}
11366
11367/// General arity mismatch diagnosis over a candidate in a candidate set.
11368static void DiagnoseArityMismatch(Sema &S, NamedDecl *Found, Decl *D,
11369                                  unsigned NumFormalArgs) {
11370  assert(isa<FunctionDecl>(D) &&
11371      "The templated declaration should at least be a function"
11372      " when diagnosing bad template argument deduction due to too many"
11373      " or too few arguments");
11374
11375  FunctionDecl *Fn = cast<FunctionDecl>(D);
11376
11377  // TODO: treat calls to a missing default constructor as a special case
11378  const auto *FnTy = Fn->getType()->castAs<FunctionProtoType>();
11379  unsigned MinParams = Fn->getMinRequiredExplicitArguments();
11380
11381  // at least / at most / exactly
11382  bool HasExplicitObjectParam = Fn->hasCXXExplicitFunctionObjectParameter();
11383  unsigned ParamCount = FnTy->getNumParams() - (HasExplicitObjectParam ? 1 : 0);
11384  unsigned mode, modeCount;
11385  if (NumFormalArgs < MinParams) {
11386    if (MinParams != ParamCount || FnTy->isVariadic() ||
11387        FnTy->isTemplateVariadic())
11388      mode = 0; // "at least"
11389    else
11390      mode = 2; // "exactly"
11391    modeCount = MinParams;
11392  } else {
11393    if (MinParams != ParamCount)
11394      mode = 1; // "at most"
11395    else
11396      mode = 2; // "exactly"
11397    modeCount = ParamCount;
11398  }
11399
11400  std::string Description;
11401  std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
11402      ClassifyOverloadCandidate(S, Found, Fn, CRK_None, Description);
11403
11404  if (modeCount == 1 &&
11405      Fn->getParamDecl(HasExplicitObjectParam ? 1 : 0)->getDeclName())
11406    S.Diag(Fn->getLocation(), diag::note_ovl_candidate_arity_one)
11407        << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second
11408        << Description << mode
11409        << Fn->getParamDecl(HasExplicitObjectParam ? 1 : 0) << NumFormalArgs
11410        << HasExplicitObjectParam << Fn->getParametersSourceRange();
11411  else
11412    S.Diag(Fn->getLocation(), diag::note_ovl_candidate_arity)
11413        << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second
11414        << Description << mode << modeCount << NumFormalArgs
11415        << HasExplicitObjectParam << Fn->getParametersSourceRange();
11416
11417  MaybeEmitInheritedConstructorNote(S, Found);
11418}
11419
11420/// Arity mismatch diagnosis specific to a function overload candidate.
11421static void DiagnoseArityMismatch(Sema &S, OverloadCandidate *Cand,
11422                                  unsigned NumFormalArgs) {
11423  if (!CheckArityMismatch(S, Cand, NumFormalArgs))
11424    DiagnoseArityMismatch(S, Cand->FoundDecl, Cand->Function, NumFormalArgs);
11425}
11426
11427static TemplateDecl *getDescribedTemplate(Decl *Templated) {
11428  if (TemplateDecl *TD = Templated->getDescribedTemplate())
11429    return TD;
11430  llvm_unreachable("Unsupported: Getting the described template declaration"
11431                   " for bad deduction diagnosis");
11432}
11433
11434/// Diagnose a failed template-argument deduction.
11435static void DiagnoseBadDeduction(Sema &S, NamedDecl *Found, Decl *Templated,
11436                                 DeductionFailureInfo &DeductionFailure,
11437                                 unsigned NumArgs,
11438                                 bool TakingCandidateAddress) {
11439  TemplateParameter Param = DeductionFailure.getTemplateParameter();
11440  NamedDecl *ParamD;
11441  (ParamD = Param.dyn_cast<TemplateTypeParmDecl*>()) ||
11442  (ParamD = Param.dyn_cast<NonTypeTemplateParmDecl*>()) ||
11443  (ParamD = Param.dyn_cast<TemplateTemplateParmDecl*>());
11444  switch (DeductionFailure.Result) {
11445  case Sema::TDK_Success:
11446    llvm_unreachable("TDK_success while diagnosing bad deduction");
11447
11448  case Sema::TDK_Incomplete: {
11449    assert(ParamD && "no parameter found for incomplete deduction result");
11450    S.Diag(Templated->getLocation(),
11451           diag::note_ovl_candidate_incomplete_deduction)
11452        << ParamD->getDeclName();
11453    MaybeEmitInheritedConstructorNote(S, Found);
11454    return;
11455  }
11456
11457  case Sema::TDK_IncompletePack: {
11458    assert(ParamD && "no parameter found for incomplete deduction result");
11459    S.Diag(Templated->getLocation(),
11460           diag::note_ovl_candidate_incomplete_deduction_pack)
11461        << ParamD->getDeclName()
11462        << (DeductionFailure.getFirstArg()->pack_size() + 1)
11463        << *DeductionFailure.getFirstArg();
11464    MaybeEmitInheritedConstructorNote(S, Found);
11465    return;
11466  }
11467
11468  case Sema::TDK_Underqualified: {
11469    assert(ParamD && "no parameter found for bad qualifiers deduction result");
11470    TemplateTypeParmDecl *TParam = cast<TemplateTypeParmDecl>(ParamD);
11471
11472    QualType Param = DeductionFailure.getFirstArg()->getAsType();
11473
11474    // Param will have been canonicalized, but it should just be a
11475    // qualified version of ParamD, so move the qualifiers to that.
11476    QualifierCollector Qs;
11477    Qs.strip(Param);
11478    QualType NonCanonParam = Qs.apply(S.Context, TParam->getTypeForDecl());
11479    assert(S.Context.hasSameType(Param, NonCanonParam));
11480
11481    // Arg has also been canonicalized, but there's nothing we can do
11482    // about that.  It also doesn't matter as much, because it won't
11483    // have any template parameters in it (because deduction isn't
11484    // done on dependent types).
11485    QualType Arg = DeductionFailure.getSecondArg()->getAsType();
11486
11487    S.Diag(Templated->getLocation(), diag::note_ovl_candidate_underqualified)
11488        << ParamD->getDeclName() << Arg << NonCanonParam;
11489    MaybeEmitInheritedConstructorNote(S, Found);
11490    return;
11491  }
11492
11493  case Sema::TDK_Inconsistent: {
11494    assert(ParamD && "no parameter found for inconsistent deduction result");
11495    int which = 0;
11496    if (isa<TemplateTypeParmDecl>(ParamD))
11497      which = 0;
11498    else if (isa<NonTypeTemplateParmDecl>(ParamD)) {
11499      // Deduction might have failed because we deduced arguments of two
11500      // different types for a non-type template parameter.
11501      // FIXME: Use a different TDK value for this.
11502      QualType T1 =
11503          DeductionFailure.getFirstArg()->getNonTypeTemplateArgumentType();
11504      QualType T2 =
11505          DeductionFailure.getSecondArg()->getNonTypeTemplateArgumentType();
11506      if (!T1.isNull() && !T2.isNull() && !S.Context.hasSameType(T1, T2)) {
11507        S.Diag(Templated->getLocation(),
11508               diag::note_ovl_candidate_inconsistent_deduction_types)
11509          << ParamD->getDeclName() << *DeductionFailure.getFirstArg() << T1
11510          << *DeductionFailure.getSecondArg() << T2;
11511        MaybeEmitInheritedConstructorNote(S, Found);
11512        return;
11513      }
11514
11515      which = 1;
11516    } else {
11517      which = 2;
11518    }
11519
11520    // Tweak the diagnostic if the problem is that we deduced packs of
11521    // different arities. We'll print the actual packs anyway in case that
11522    // includes additional useful information.
11523    if (DeductionFailure.getFirstArg()->getKind() == TemplateArgument::Pack &&
11524        DeductionFailure.getSecondArg()->getKind() == TemplateArgument::Pack &&
11525        DeductionFailure.getFirstArg()->pack_size() !=
11526            DeductionFailure.getSecondArg()->pack_size()) {
11527      which = 3;
11528    }
11529
11530    S.Diag(Templated->getLocation(),
11531           diag::note_ovl_candidate_inconsistent_deduction)
11532        << which << ParamD->getDeclName() << *DeductionFailure.getFirstArg()
11533        << *DeductionFailure.getSecondArg();
11534    MaybeEmitInheritedConstructorNote(S, Found);
11535    return;
11536  }
11537
11538  case Sema::TDK_InvalidExplicitArguments:
11539    assert(ParamD && "no parameter found for invalid explicit arguments");
11540    if (ParamD->getDeclName())
11541      S.Diag(Templated->getLocation(),
11542             diag::note_ovl_candidate_explicit_arg_mismatch_named)
11543          << ParamD->getDeclName();
11544    else {
11545      int index = 0;
11546      if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ParamD))
11547        index = TTP->getIndex();
11548      else if (NonTypeTemplateParmDecl *NTTP
11549                                  = dyn_cast<NonTypeTemplateParmDecl>(ParamD))
11550        index = NTTP->getIndex();
11551      else
11552        index = cast<TemplateTemplateParmDecl>(ParamD)->getIndex();
11553      S.Diag(Templated->getLocation(),
11554             diag::note_ovl_candidate_explicit_arg_mismatch_unnamed)
11555          << (index + 1);
11556    }
11557    MaybeEmitInheritedConstructorNote(S, Found);
11558    return;
11559
11560  case Sema::TDK_ConstraintsNotSatisfied: {
11561    // Format the template argument list into the argument string.
11562    SmallString<128> TemplateArgString;
11563    TemplateArgumentList *Args = DeductionFailure.getTemplateArgumentList();
11564    TemplateArgString = " ";
11565    TemplateArgString += S.getTemplateArgumentBindingsText(
11566        getDescribedTemplate(Templated)->getTemplateParameters(), *Args);
11567    if (TemplateArgString.size() == 1)
11568      TemplateArgString.clear();
11569    S.Diag(Templated->getLocation(),
11570           diag::note_ovl_candidate_unsatisfied_constraints)
11571        << TemplateArgString;
11572
11573    S.DiagnoseUnsatisfiedConstraint(
11574        static_cast<CNSInfo*>(DeductionFailure.Data)->Satisfaction);
11575    return;
11576  }
11577  case Sema::TDK_TooManyArguments:
11578  case Sema::TDK_TooFewArguments:
11579    DiagnoseArityMismatch(S, Found, Templated, NumArgs);
11580    return;
11581
11582  case Sema::TDK_InstantiationDepth:
11583    S.Diag(Templated->getLocation(),
11584           diag::note_ovl_candidate_instantiation_depth);
11585    MaybeEmitInheritedConstructorNote(S, Found);
11586    return;
11587
11588  case Sema::TDK_SubstitutionFailure: {
11589    // Format the template argument list into the argument string.
11590    SmallString<128> TemplateArgString;
11591    if (TemplateArgumentList *Args =
11592            DeductionFailure.getTemplateArgumentList()) {
11593      TemplateArgString = " ";
11594      TemplateArgString += S.getTemplateArgumentBindingsText(
11595          getDescribedTemplate(Templated)->getTemplateParameters(), *Args);
11596      if (TemplateArgString.size() == 1)
11597        TemplateArgString.clear();
11598    }
11599
11600    // If this candidate was disabled by enable_if, say so.
11601    PartialDiagnosticAt *PDiag = DeductionFailure.getSFINAEDiagnostic();
11602    if (PDiag && PDiag->second.getDiagID() ==
11603          diag::err_typename_nested_not_found_enable_if) {
11604      // FIXME: Use the source range of the condition, and the fully-qualified
11605      //        name of the enable_if template. These are both present in PDiag.
11606      S.Diag(PDiag->first, diag::note_ovl_candidate_disabled_by_enable_if)
11607        << "'enable_if'" << TemplateArgString;
11608      return;
11609    }
11610
11611    // We found a specific requirement that disabled the enable_if.
11612    if (PDiag && PDiag->second.getDiagID() ==
11613        diag::err_typename_nested_not_found_requirement) {
11614      S.Diag(Templated->getLocation(),
11615             diag::note_ovl_candidate_disabled_by_requirement)
11616        << PDiag->second.getStringArg(0) << TemplateArgString;
11617      return;
11618    }
11619
11620    // Format the SFINAE diagnostic into the argument string.
11621    // FIXME: Add a general mechanism to include a PartialDiagnostic *'s
11622    //        formatted message in another diagnostic.
11623    SmallString<128> SFINAEArgString;
11624    SourceRange R;
11625    if (PDiag) {
11626      SFINAEArgString = ": ";
11627      R = SourceRange(PDiag->first, PDiag->first);
11628      PDiag->second.EmitToString(S.getDiagnostics(), SFINAEArgString);
11629    }
11630
11631    S.Diag(Templated->getLocation(),
11632           diag::note_ovl_candidate_substitution_failure)
11633        << TemplateArgString << SFINAEArgString << R;
11634    MaybeEmitInheritedConstructorNote(S, Found);
11635    return;
11636  }
11637
11638  case Sema::TDK_DeducedMismatch:
11639  case Sema::TDK_DeducedMismatchNested: {
11640    // Format the template argument list into the argument string.
11641    SmallString<128> TemplateArgString;
11642    if (TemplateArgumentList *Args =
11643            DeductionFailure.getTemplateArgumentList()) {
11644      TemplateArgString = " ";
11645      TemplateArgString += S.getTemplateArgumentBindingsText(
11646          getDescribedTemplate(Templated)->getTemplateParameters(), *Args);
11647      if (TemplateArgString.size() == 1)
11648        TemplateArgString.clear();
11649    }
11650
11651    S.Diag(Templated->getLocation(), diag::note_ovl_candidate_deduced_mismatch)
11652        << (*DeductionFailure.getCallArgIndex() + 1)
11653        << *DeductionFailure.getFirstArg() << *DeductionFailure.getSecondArg()
11654        << TemplateArgString
11655        << (DeductionFailure.Result == Sema::TDK_DeducedMismatchNested);
11656    break;
11657  }
11658
11659  case Sema::TDK_NonDeducedMismatch: {
11660    // FIXME: Provide a source location to indicate what we couldn't match.
11661    TemplateArgument FirstTA = *DeductionFailure.getFirstArg();
11662    TemplateArgument SecondTA = *DeductionFailure.getSecondArg();
11663    if (FirstTA.getKind() == TemplateArgument::Template &&
11664        SecondTA.getKind() == TemplateArgument::Template) {
11665      TemplateName FirstTN = FirstTA.getAsTemplate();
11666      TemplateName SecondTN = SecondTA.getAsTemplate();
11667      if (FirstTN.getKind() == TemplateName::Template &&
11668          SecondTN.getKind() == TemplateName::Template) {
11669        if (FirstTN.getAsTemplateDecl()->getName() ==
11670            SecondTN.getAsTemplateDecl()->getName()) {
11671          // FIXME: This fixes a bad diagnostic where both templates are named
11672          // the same.  This particular case is a bit difficult since:
11673          // 1) It is passed as a string to the diagnostic printer.
11674          // 2) The diagnostic printer only attempts to find a better
11675          //    name for types, not decls.
11676          // Ideally, this should folded into the diagnostic printer.
11677          S.Diag(Templated->getLocation(),
11678                 diag::note_ovl_candidate_non_deduced_mismatch_qualified)
11679              << FirstTN.getAsTemplateDecl() << SecondTN.getAsTemplateDecl();
11680          return;
11681        }
11682      }
11683    }
11684
11685    if (TakingCandidateAddress && isa<FunctionDecl>(Templated) &&
11686        !checkAddressOfCandidateIsAvailable(S, cast<FunctionDecl>(Templated)))
11687      return;
11688
11689    // FIXME: For generic lambda parameters, check if the function is a lambda
11690    // call operator, and if so, emit a prettier and more informative
11691    // diagnostic that mentions 'auto' and lambda in addition to
11692    // (or instead of?) the canonical template type parameters.
11693    S.Diag(Templated->getLocation(),
11694           diag::note_ovl_candidate_non_deduced_mismatch)
11695        << FirstTA << SecondTA;
11696    return;
11697  }
11698  // TODO: diagnose these individually, then kill off
11699  // note_ovl_candidate_bad_deduction, which is uselessly vague.
11700  case Sema::TDK_MiscellaneousDeductionFailure:
11701    S.Diag(Templated->getLocation(), diag::note_ovl_candidate_bad_deduction);
11702    MaybeEmitInheritedConstructorNote(S, Found);
11703    return;
11704  case Sema::TDK_CUDATargetMismatch:
11705    S.Diag(Templated->getLocation(),
11706           diag::note_cuda_ovl_candidate_target_mismatch);
11707    return;
11708  }
11709}
11710
11711/// Diagnose a failed template-argument deduction, for function calls.
11712static void DiagnoseBadDeduction(Sema &S, OverloadCandidate *Cand,
11713                                 unsigned NumArgs,
11714                                 bool TakingCandidateAddress) {
11715  unsigned TDK = Cand->DeductionFailure.Result;
11716  if (TDK == Sema::TDK_TooFewArguments || TDK == Sema::TDK_TooManyArguments) {
11717    if (CheckArityMismatch(S, Cand, NumArgs))
11718      return;
11719  }
11720  DiagnoseBadDeduction(S, Cand->FoundDecl, Cand->Function, // pattern
11721                       Cand->DeductionFailure, NumArgs, TakingCandidateAddress);
11722}
11723
11724/// CUDA: diagnose an invalid call across targets.
11725static void DiagnoseBadTarget(Sema &S, OverloadCandidate *Cand) {
11726  FunctionDecl *Caller = S.getCurFunctionDecl(/*AllowLambda=*/true);
11727  FunctionDecl *Callee = Cand->Function;
11728
11729  Sema::CUDAFunctionTarget CallerTarget = S.IdentifyCUDATarget(Caller),
11730                           CalleeTarget = S.IdentifyCUDATarget(Callee);
11731
11732  std::string FnDesc;
11733  std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
11734      ClassifyOverloadCandidate(S, Cand->FoundDecl, Callee,
11735                                Cand->getRewriteKind(), FnDesc);
11736
11737  S.Diag(Callee->getLocation(), diag::note_ovl_candidate_bad_target)
11738      << (unsigned)FnKindPair.first << (unsigned)ocs_non_template
11739      << FnDesc /* Ignored */
11740      << CalleeTarget << CallerTarget;
11741
11742  // This could be an implicit constructor for which we could not infer the
11743  // target due to a collsion. Diagnose that case.
11744  CXXMethodDecl *Meth = dyn_cast<CXXMethodDecl>(Callee);
11745  if (Meth != nullptr && Meth->isImplicit()) {
11746    CXXRecordDecl *ParentClass = Meth->getParent();
11747    Sema::CXXSpecialMember CSM;
11748
11749    switch (FnKindPair.first) {
11750    default:
11751      return;
11752    case oc_implicit_default_constructor:
11753      CSM = Sema::CXXDefaultConstructor;
11754      break;
11755    case oc_implicit_copy_constructor:
11756      CSM = Sema::CXXCopyConstructor;
11757      break;
11758    case oc_implicit_move_constructor:
11759      CSM = Sema::CXXMoveConstructor;
11760      break;
11761    case oc_implicit_copy_assignment:
11762      CSM = Sema::CXXCopyAssignment;
11763      break;
11764    case oc_implicit_move_assignment:
11765      CSM = Sema::CXXMoveAssignment;
11766      break;
11767    };
11768
11769    bool ConstRHS = false;
11770    if (Meth->getNumParams()) {
11771      if (const ReferenceType *RT =
11772              Meth->getParamDecl(0)->getType()->getAs<ReferenceType>()) {
11773        ConstRHS = RT->getPointeeType().isConstQualified();
11774      }
11775    }
11776
11777    S.inferCUDATargetForImplicitSpecialMember(ParentClass, CSM, Meth,
11778                                              /* ConstRHS */ ConstRHS,
11779                                              /* Diagnose */ true);
11780  }
11781}
11782
11783static void DiagnoseFailedEnableIfAttr(Sema &S, OverloadCandidate *Cand) {
11784  FunctionDecl *Callee = Cand->Function;
11785  EnableIfAttr *Attr = static_cast<EnableIfAttr*>(Cand->DeductionFailure.Data);
11786
11787  S.Diag(Callee->getLocation(),
11788         diag::note_ovl_candidate_disabled_by_function_cond_attr)
11789      << Attr->getCond()->getSourceRange() << Attr->getMessage();
11790}
11791
11792static void DiagnoseFailedExplicitSpec(Sema &S, OverloadCandidate *Cand) {
11793  ExplicitSpecifier ES = ExplicitSpecifier::getFromDecl(Cand->Function);
11794  assert(ES.isExplicit() && "not an explicit candidate");
11795
11796  unsigned Kind;
11797  switch (Cand->Function->getDeclKind()) {
11798  case Decl::Kind::CXXConstructor:
11799    Kind = 0;
11800    break;
11801  case Decl::Kind::CXXConversion:
11802    Kind = 1;
11803    break;
11804  case Decl::Kind::CXXDeductionGuide:
11805    Kind = Cand->Function->isImplicit() ? 0 : 2;
11806    break;
11807  default:
11808    llvm_unreachable("invalid Decl");
11809  }
11810
11811  // Note the location of the first (in-class) declaration; a redeclaration
11812  // (particularly an out-of-class definition) will typically lack the
11813  // 'explicit' specifier.
11814  // FIXME: This is probably a good thing to do for all 'candidate' notes.
11815  FunctionDecl *First = Cand->Function->getFirstDecl();
11816  if (FunctionDecl *Pattern = First->getTemplateInstantiationPattern())
11817    First = Pattern->getFirstDecl();
11818
11819  S.Diag(First->getLocation(),
11820         diag::note_ovl_candidate_explicit)
11821      << Kind << (ES.getExpr() ? 1 : 0)
11822      << (ES.getExpr() ? ES.getExpr()->getSourceRange() : SourceRange());
11823}
11824
11825/// Generates a 'note' diagnostic for an overload candidate.  We've
11826/// already generated a primary error at the call site.
11827///
11828/// It really does need to be a single diagnostic with its caret
11829/// pointed at the candidate declaration.  Yes, this creates some
11830/// major challenges of technical writing.  Yes, this makes pointing
11831/// out problems with specific arguments quite awkward.  It's still
11832/// better than generating twenty screens of text for every failed
11833/// overload.
11834///
11835/// It would be great to be able to express per-candidate problems
11836/// more richly for those diagnostic clients that cared, but we'd
11837/// still have to be just as careful with the default diagnostics.
11838/// \param CtorDestAS Addr space of object being constructed (for ctor
11839/// candidates only).
11840static void NoteFunctionCandidate(Sema &S, OverloadCandidate *Cand,
11841                                  unsigned NumArgs,
11842                                  bool TakingCandidateAddress,
11843                                  LangAS CtorDestAS = LangAS::Default) {
11844  FunctionDecl *Fn = Cand->Function;
11845  if (shouldSkipNotingLambdaConversionDecl(Fn))
11846    return;
11847
11848  // There is no physical candidate declaration to point to for OpenCL builtins.
11849  // Except for failed conversions, the notes are identical for each candidate,
11850  // so do not generate such notes.
11851  if (S.getLangOpts().OpenCL && Fn->isImplicit() &&
11852      Cand->FailureKind != ovl_fail_bad_conversion)
11853    return;
11854
11855  // Note deleted candidates, but only if they're viable.
11856  if (Cand->Viable) {
11857    if (Fn->isDeleted()) {
11858      std::string FnDesc;
11859      std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
11860          ClassifyOverloadCandidate(S, Cand->FoundDecl, Fn,
11861                                    Cand->getRewriteKind(), FnDesc);
11862
11863      S.Diag(Fn->getLocation(), diag::note_ovl_candidate_deleted)
11864          << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
11865          << (Fn->isDeleted() ? (Fn->isDeletedAsWritten() ? 1 : 2) : 0);
11866      MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
11867      return;
11868    }
11869
11870    // We don't really have anything else to say about viable candidates.
11871    S.NoteOverloadCandidate(Cand->FoundDecl, Fn, Cand->getRewriteKind());
11872    return;
11873  }
11874
11875  switch (Cand->FailureKind) {
11876  case ovl_fail_too_many_arguments:
11877  case ovl_fail_too_few_arguments:
11878    return DiagnoseArityMismatch(S, Cand, NumArgs);
11879
11880  case ovl_fail_bad_deduction:
11881    return DiagnoseBadDeduction(S, Cand, NumArgs,
11882                                TakingCandidateAddress);
11883
11884  case ovl_fail_illegal_constructor: {
11885    S.Diag(Fn->getLocation(), diag::note_ovl_candidate_illegal_constructor)
11886      << (Fn->getPrimaryTemplate() ? 1 : 0);
11887    MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
11888    return;
11889  }
11890
11891  case ovl_fail_object_addrspace_mismatch: {
11892    Qualifiers QualsForPrinting;
11893    QualsForPrinting.setAddressSpace(CtorDestAS);
11894    S.Diag(Fn->getLocation(),
11895           diag::note_ovl_candidate_illegal_constructor_adrspace_mismatch)
11896        << QualsForPrinting;
11897    MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
11898    return;
11899  }
11900
11901  case ovl_fail_trivial_conversion:
11902  case ovl_fail_bad_final_conversion:
11903  case ovl_fail_final_conversion_not_exact:
11904    return S.NoteOverloadCandidate(Cand->FoundDecl, Fn, Cand->getRewriteKind());
11905
11906  case ovl_fail_bad_conversion: {
11907    unsigned I = (Cand->IgnoreObjectArgument ? 1 : 0);
11908    for (unsigned N = Cand->Conversions.size(); I != N; ++I)
11909      if (Cand->Conversions[I].isBad())
11910        return DiagnoseBadConversion(S, Cand, I, TakingCandidateAddress);
11911
11912    // FIXME: this currently happens when we're called from SemaInit
11913    // when user-conversion overload fails.  Figure out how to handle
11914    // those conditions and diagnose them well.
11915    return S.NoteOverloadCandidate(Cand->FoundDecl, Fn, Cand->getRewriteKind());
11916  }
11917
11918  case ovl_fail_bad_target:
11919    return DiagnoseBadTarget(S, Cand);
11920
11921  case ovl_fail_enable_if:
11922    return DiagnoseFailedEnableIfAttr(S, Cand);
11923
11924  case ovl_fail_explicit:
11925    return DiagnoseFailedExplicitSpec(S, Cand);
11926
11927  case ovl_fail_inhctor_slice:
11928    // It's generally not interesting to note copy/move constructors here.
11929    if (cast<CXXConstructorDecl>(Fn)->isCopyOrMoveConstructor())
11930      return;
11931    S.Diag(Fn->getLocation(),
11932           diag::note_ovl_candidate_inherited_constructor_slice)
11933      << (Fn->getPrimaryTemplate() ? 1 : 0)
11934      << Fn->getParamDecl(0)->getType()->isRValueReferenceType();
11935    MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
11936    return;
11937
11938  case ovl_fail_addr_not_available: {
11939    bool Available = checkAddressOfCandidateIsAvailable(S, Cand->Function);
11940    (void)Available;
11941    assert(!Available);
11942    break;
11943  }
11944  case ovl_non_default_multiversion_function:
11945    // Do nothing, these should simply be ignored.
11946    break;
11947
11948  case ovl_fail_constraints_not_satisfied: {
11949    std::string FnDesc;
11950    std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
11951        ClassifyOverloadCandidate(S, Cand->FoundDecl, Fn,
11952                                  Cand->getRewriteKind(), FnDesc);
11953
11954    S.Diag(Fn->getLocation(),
11955           diag::note_ovl_candidate_constraints_not_satisfied)
11956        << (unsigned)FnKindPair.first << (unsigned)ocs_non_template
11957        << FnDesc /* Ignored */;
11958    ConstraintSatisfaction Satisfaction;
11959    if (S.CheckFunctionConstraints(Fn, Satisfaction))
11960      break;
11961    S.DiagnoseUnsatisfiedConstraint(Satisfaction);
11962  }
11963  }
11964}
11965
11966static void NoteSurrogateCandidate(Sema &S, OverloadCandidate *Cand) {
11967  if (shouldSkipNotingLambdaConversionDecl(Cand->Surrogate))
11968    return;
11969
11970  // Desugar the type of the surrogate down to a function type,
11971  // retaining as many typedefs as possible while still showing
11972  // the function type (and, therefore, its parameter types).
11973  QualType FnType = Cand->Surrogate->getConversionType();
11974  bool isLValueReference = false;
11975  bool isRValueReference = false;
11976  bool isPointer = false;
11977  if (const LValueReferenceType *FnTypeRef =
11978        FnType->getAs<LValueReferenceType>()) {
11979    FnType = FnTypeRef->getPointeeType();
11980    isLValueReference = true;
11981  } else if (const RValueReferenceType *FnTypeRef =
11982               FnType->getAs<RValueReferenceType>()) {
11983    FnType = FnTypeRef->getPointeeType();
11984    isRValueReference = true;
11985  }
11986  if (const PointerType *FnTypePtr = FnType->getAs<PointerType>()) {
11987    FnType = FnTypePtr->getPointeeType();
11988    isPointer = true;
11989  }
11990  // Desugar down to a function type.
11991  FnType = QualType(FnType->getAs<FunctionType>(), 0);
11992  // Reconstruct the pointer/reference as appropriate.
11993  if (isPointer) FnType = S.Context.getPointerType(FnType);
11994  if (isRValueReference) FnType = S.Context.getRValueReferenceType(FnType);
11995  if (isLValueReference) FnType = S.Context.getLValueReferenceType(FnType);
11996
11997  if (!Cand->Viable &&
11998      Cand->FailureKind == ovl_fail_constraints_not_satisfied) {
11999    S.Diag(Cand->Surrogate->getLocation(),
12000           diag::note_ovl_surrogate_constraints_not_satisfied)
12001        << Cand->Surrogate;
12002    ConstraintSatisfaction Satisfaction;
12003    if (S.CheckFunctionConstraints(Cand->Surrogate, Satisfaction))
12004      S.DiagnoseUnsatisfiedConstraint(Satisfaction);
12005  } else {
12006    S.Diag(Cand->Surrogate->getLocation(), diag::note_ovl_surrogate_cand)
12007        << FnType;
12008  }
12009}
12010
12011static void NoteBuiltinOperatorCandidate(Sema &S, StringRef Opc,
12012                                         SourceLocation OpLoc,
12013                                         OverloadCandidate *Cand) {
12014  assert(Cand->Conversions.size() <= 2 && "builtin operator is not binary");
12015  std::string TypeStr("operator");
12016  TypeStr += Opc;
12017  TypeStr += "(";
12018  TypeStr += Cand->BuiltinParamTypes[0].getAsString();
12019  if (Cand->Conversions.size() == 1) {
12020    TypeStr += ")";
12021    S.Diag(OpLoc, diag::note_ovl_builtin_candidate) << TypeStr;
12022  } else {
12023    TypeStr += ", ";
12024    TypeStr += Cand->BuiltinParamTypes[1].getAsString();
12025    TypeStr += ")";
12026    S.Diag(OpLoc, diag::note_ovl_builtin_candidate) << TypeStr;
12027  }
12028}
12029
12030static void NoteAmbiguousUserConversions(Sema &S, SourceLocation OpLoc,
12031                                         OverloadCandidate *Cand) {
12032  for (const ImplicitConversionSequence &ICS : Cand->Conversions) {
12033    if (ICS.isBad()) break; // all meaningless after first invalid
12034    if (!ICS.isAmbiguous()) continue;
12035
12036    ICS.DiagnoseAmbiguousConversion(
12037        S, OpLoc, S.PDiag(diag::note_ambiguous_type_conversion));
12038  }
12039}
12040
12041static SourceLocation GetLocationForCandidate(const OverloadCandidate *Cand) {
12042  if (Cand->Function)
12043    return Cand->Function->getLocation();
12044  if (Cand->IsSurrogate)
12045    return Cand->Surrogate->getLocation();
12046  return SourceLocation();
12047}
12048
12049static unsigned RankDeductionFailure(const DeductionFailureInfo &DFI) {
12050  switch ((Sema::TemplateDeductionResult)DFI.Result) {
12051  case Sema::TDK_Success:
12052  case Sema::TDK_NonDependentConversionFailure:
12053  case Sema::TDK_AlreadyDiagnosed:
12054    llvm_unreachable("non-deduction failure while diagnosing bad deduction");
12055
12056  case Sema::TDK_Invalid:
12057  case Sema::TDK_Incomplete:
12058  case Sema::TDK_IncompletePack:
12059    return 1;
12060
12061  case Sema::TDK_Underqualified:
12062  case Sema::TDK_Inconsistent:
12063    return 2;
12064
12065  case Sema::TDK_SubstitutionFailure:
12066  case Sema::TDK_DeducedMismatch:
12067  case Sema::TDK_ConstraintsNotSatisfied:
12068  case Sema::TDK_DeducedMismatchNested:
12069  case Sema::TDK_NonDeducedMismatch:
12070  case Sema::TDK_MiscellaneousDeductionFailure:
12071  case Sema::TDK_CUDATargetMismatch:
12072    return 3;
12073
12074  case Sema::TDK_InstantiationDepth:
12075    return 4;
12076
12077  case Sema::TDK_InvalidExplicitArguments:
12078    return 5;
12079
12080  case Sema::TDK_TooManyArguments:
12081  case Sema::TDK_TooFewArguments:
12082    return 6;
12083  }
12084  llvm_unreachable("Unhandled deduction result");
12085}
12086
12087namespace {
12088
12089struct CompareOverloadCandidatesForDisplay {
12090  Sema &S;
12091  SourceLocation Loc;
12092  size_t NumArgs;
12093  OverloadCandidateSet::CandidateSetKind CSK;
12094
12095  CompareOverloadCandidatesForDisplay(
12096      Sema &S, SourceLocation Loc, size_t NArgs,
12097      OverloadCandidateSet::CandidateSetKind CSK)
12098      : S(S), NumArgs(NArgs), CSK(CSK) {}
12099
12100  OverloadFailureKind EffectiveFailureKind(const OverloadCandidate *C) const {
12101    // If there are too many or too few arguments, that's the high-order bit we
12102    // want to sort by, even if the immediate failure kind was something else.
12103    if (C->FailureKind == ovl_fail_too_many_arguments ||
12104        C->FailureKind == ovl_fail_too_few_arguments)
12105      return static_cast<OverloadFailureKind>(C->FailureKind);
12106
12107    if (C->Function) {
12108      if (NumArgs > C->Function->getNumParams() && !C->Function->isVariadic())
12109        return ovl_fail_too_many_arguments;
12110      if (NumArgs < C->Function->getMinRequiredArguments())
12111        return ovl_fail_too_few_arguments;
12112    }
12113
12114    return static_cast<OverloadFailureKind>(C->FailureKind);
12115  }
12116
12117  bool operator()(const OverloadCandidate *L,
12118                  const OverloadCandidate *R) {
12119    // Fast-path this check.
12120    if (L == R) return false;
12121
12122    // Order first by viability.
12123    if (L->Viable) {
12124      if (!R->Viable) return true;
12125
12126      if (int Ord = CompareConversions(*L, *R))
12127        return Ord < 0;
12128      // Use other tie breakers.
12129    } else if (R->Viable)
12130      return false;
12131
12132    assert(L->Viable == R->Viable);
12133
12134    // Criteria by which we can sort non-viable candidates:
12135    if (!L->Viable) {
12136      OverloadFailureKind LFailureKind = EffectiveFailureKind(L);
12137      OverloadFailureKind RFailureKind = EffectiveFailureKind(R);
12138
12139      // 1. Arity mismatches come after other candidates.
12140      if (LFailureKind == ovl_fail_too_many_arguments ||
12141          LFailureKind == ovl_fail_too_few_arguments) {
12142        if (RFailureKind == ovl_fail_too_many_arguments ||
12143            RFailureKind == ovl_fail_too_few_arguments) {
12144          int LDist = std::abs((int)L->getNumParams() - (int)NumArgs);
12145          int RDist = std::abs((int)R->getNumParams() - (int)NumArgs);
12146          if (LDist == RDist) {
12147            if (LFailureKind == RFailureKind)
12148              // Sort non-surrogates before surrogates.
12149              return !L->IsSurrogate && R->IsSurrogate;
12150            // Sort candidates requiring fewer parameters than there were
12151            // arguments given after candidates requiring more parameters
12152            // than there were arguments given.
12153            return LFailureKind == ovl_fail_too_many_arguments;
12154          }
12155          return LDist < RDist;
12156        }
12157        return false;
12158      }
12159      if (RFailureKind == ovl_fail_too_many_arguments ||
12160          RFailureKind == ovl_fail_too_few_arguments)
12161        return true;
12162
12163      // 2. Bad conversions come first and are ordered by the number
12164      // of bad conversions and quality of good conversions.
12165      if (LFailureKind == ovl_fail_bad_conversion) {
12166        if (RFailureKind != ovl_fail_bad_conversion)
12167          return true;
12168
12169        // The conversion that can be fixed with a smaller number of changes,
12170        // comes first.
12171        unsigned numLFixes = L->Fix.NumConversionsFixed;
12172        unsigned numRFixes = R->Fix.NumConversionsFixed;
12173        numLFixes = (numLFixes == 0) ? UINT_MAX : numLFixes;
12174        numRFixes = (numRFixes == 0) ? UINT_MAX : numRFixes;
12175        if (numLFixes != numRFixes) {
12176          return numLFixes < numRFixes;
12177        }
12178
12179        // If there's any ordering between the defined conversions...
12180        if (int Ord = CompareConversions(*L, *R))
12181          return Ord < 0;
12182      } else if (RFailureKind == ovl_fail_bad_conversion)
12183        return false;
12184
12185      if (LFailureKind == ovl_fail_bad_deduction) {
12186        if (RFailureKind != ovl_fail_bad_deduction)
12187          return true;
12188
12189        if (L->DeductionFailure.Result != R->DeductionFailure.Result) {
12190          unsigned LRank = RankDeductionFailure(L->DeductionFailure);
12191          unsigned RRank = RankDeductionFailure(R->DeductionFailure);
12192          if (LRank != RRank)
12193            return LRank < RRank;
12194        }
12195      } else if (RFailureKind == ovl_fail_bad_deduction)
12196        return false;
12197
12198      // TODO: others?
12199    }
12200
12201    // Sort everything else by location.
12202    SourceLocation LLoc = GetLocationForCandidate(L);
12203    SourceLocation RLoc = GetLocationForCandidate(R);
12204
12205    // Put candidates without locations (e.g. builtins) at the end.
12206    if (LLoc.isValid() && RLoc.isValid())
12207      return S.SourceMgr.isBeforeInTranslationUnit(LLoc, RLoc);
12208    if (LLoc.isValid() && !RLoc.isValid())
12209      return true;
12210    if (RLoc.isValid() && !LLoc.isValid())
12211      return false;
12212    assert(!LLoc.isValid() && !RLoc.isValid());
12213    // For builtins and other functions without locations, fallback to the order
12214    // in which they were added into the candidate set.
12215    return L < R;
12216  }
12217
12218private:
12219  struct ConversionSignals {
12220    unsigned KindRank = 0;
12221    ImplicitConversionRank Rank = ICR_Exact_Match;
12222
12223    static ConversionSignals ForSequence(ImplicitConversionSequence &Seq) {
12224      ConversionSignals Sig;
12225      Sig.KindRank = Seq.getKindRank();
12226      if (Seq.isStandard())
12227        Sig.Rank = Seq.Standard.getRank();
12228      else if (Seq.isUserDefined())
12229        Sig.Rank = Seq.UserDefined.After.getRank();
12230      // We intend StaticObjectArgumentConversion to compare the same as
12231      // StandardConversion with ICR_ExactMatch rank.
12232      return Sig;
12233    }
12234
12235    static ConversionSignals ForObjectArgument() {
12236      // We intend StaticObjectArgumentConversion to compare the same as
12237      // StandardConversion with ICR_ExactMatch rank. Default give us that.
12238      return {};
12239    }
12240  };
12241
12242  // Returns -1 if conversions in L are considered better.
12243  //          0 if they are considered indistinguishable.
12244  //          1 if conversions in R are better.
12245  int CompareConversions(const OverloadCandidate &L,
12246                         const OverloadCandidate &R) {
12247    // We cannot use `isBetterOverloadCandidate` because it is defined
12248    // according to the C++ standard and provides a partial order, but we need
12249    // a total order as this function is used in sort.
12250    assert(L.Conversions.size() == R.Conversions.size());
12251    for (unsigned I = 0, N = L.Conversions.size(); I != N; ++I) {
12252      auto LS = L.IgnoreObjectArgument && I == 0
12253                    ? ConversionSignals::ForObjectArgument()
12254                    : ConversionSignals::ForSequence(L.Conversions[I]);
12255      auto RS = R.IgnoreObjectArgument
12256                    ? ConversionSignals::ForObjectArgument()
12257                    : ConversionSignals::ForSequence(R.Conversions[I]);
12258      if (std::tie(LS.KindRank, LS.Rank) != std::tie(RS.KindRank, RS.Rank))
12259        return std::tie(LS.KindRank, LS.Rank) < std::tie(RS.KindRank, RS.Rank)
12260                   ? -1
12261                   : 1;
12262    }
12263    // FIXME: find a way to compare templates for being more or less
12264    // specialized that provides a strict weak ordering.
12265    return 0;
12266  }
12267};
12268}
12269
12270/// CompleteNonViableCandidate - Normally, overload resolution only
12271/// computes up to the first bad conversion. Produces the FixIt set if
12272/// possible.
12273static void
12274CompleteNonViableCandidate(Sema &S, OverloadCandidate *Cand,
12275                           ArrayRef<Expr *> Args,
12276                           OverloadCandidateSet::CandidateSetKind CSK) {
12277  assert(!Cand->Viable);
12278
12279  // Don't do anything on failures other than bad conversion.
12280  if (Cand->FailureKind != ovl_fail_bad_conversion)
12281    return;
12282
12283  // We only want the FixIts if all the arguments can be corrected.
12284  bool Unfixable = false;
12285  // Use a implicit copy initialization to check conversion fixes.
12286  Cand->Fix.setConversionChecker(TryCopyInitialization);
12287
12288  // Attempt to fix the bad conversion.
12289  unsigned ConvCount = Cand->Conversions.size();
12290  for (unsigned ConvIdx = (Cand->IgnoreObjectArgument ? 1 : 0); /**/;
12291       ++ConvIdx) {
12292    assert(ConvIdx != ConvCount && "no bad conversion in candidate");
12293    if (Cand->Conversions[ConvIdx].isInitialized() &&
12294        Cand->Conversions[ConvIdx].isBad()) {
12295      Unfixable = !Cand->TryToFixBadConversion(ConvIdx, S);
12296      break;
12297    }
12298  }
12299
12300  // FIXME: this should probably be preserved from the overload
12301  // operation somehow.
12302  bool SuppressUserConversions = false;
12303
12304  unsigned ConvIdx = 0;
12305  unsigned ArgIdx = 0;
12306  ArrayRef<QualType> ParamTypes;
12307  bool Reversed = Cand->isReversed();
12308
12309  if (Cand->IsSurrogate) {
12310    QualType ConvType
12311      = Cand->Surrogate->getConversionType().getNonReferenceType();
12312    if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>())
12313      ConvType = ConvPtrType->getPointeeType();
12314    ParamTypes = ConvType->castAs<FunctionProtoType>()->getParamTypes();
12315    // Conversion 0 is 'this', which doesn't have a corresponding parameter.
12316    ConvIdx = 1;
12317  } else if (Cand->Function) {
12318    ParamTypes =
12319        Cand->Function->getType()->castAs<FunctionProtoType>()->getParamTypes();
12320    if (isa<CXXMethodDecl>(Cand->Function) &&
12321        !isa<CXXConstructorDecl>(Cand->Function) && !Reversed) {
12322      // Conversion 0 is 'this', which doesn't have a corresponding parameter.
12323      ConvIdx = 1;
12324      if (CSK == OverloadCandidateSet::CSK_Operator &&
12325          Cand->Function->getDeclName().getCXXOverloadedOperator() != OO_Call &&
12326          Cand->Function->getDeclName().getCXXOverloadedOperator() !=
12327              OO_Subscript)
12328        // Argument 0 is 'this', which doesn't have a corresponding parameter.
12329        ArgIdx = 1;
12330    }
12331  } else {
12332    // Builtin operator.
12333    assert(ConvCount <= 3);
12334    ParamTypes = Cand->BuiltinParamTypes;
12335  }
12336
12337  // Fill in the rest of the conversions.
12338  for (unsigned ParamIdx = Reversed ? ParamTypes.size() - 1 : 0;
12339       ConvIdx != ConvCount;
12340       ++ConvIdx, ++ArgIdx, ParamIdx += (Reversed ? -1 : 1)) {
12341    assert(ArgIdx < Args.size() && "no argument for this arg conversion");
12342    if (Cand->Conversions[ConvIdx].isInitialized()) {
12343      // We've already checked this conversion.
12344    } else if (ParamIdx < ParamTypes.size()) {
12345      if (ParamTypes[ParamIdx]->isDependentType())
12346        Cand->Conversions[ConvIdx].setAsIdentityConversion(
12347            Args[ArgIdx]->getType());
12348      else {
12349        Cand->Conversions[ConvIdx] =
12350            TryCopyInitialization(S, Args[ArgIdx], ParamTypes[ParamIdx],
12351                                  SuppressUserConversions,
12352                                  /*InOverloadResolution=*/true,
12353                                  /*AllowObjCWritebackConversion=*/
12354                                  S.getLangOpts().ObjCAutoRefCount);
12355        // Store the FixIt in the candidate if it exists.
12356        if (!Unfixable && Cand->Conversions[ConvIdx].isBad())
12357          Unfixable = !Cand->TryToFixBadConversion(ConvIdx, S);
12358      }
12359    } else
12360      Cand->Conversions[ConvIdx].setEllipsis();
12361  }
12362}
12363
12364SmallVector<OverloadCandidate *, 32> OverloadCandidateSet::CompleteCandidates(
12365    Sema &S, OverloadCandidateDisplayKind OCD, ArrayRef<Expr *> Args,
12366    SourceLocation OpLoc,
12367    llvm::function_ref<bool(OverloadCandidate &)> Filter) {
12368  // Sort the candidates by viability and position.  Sorting directly would
12369  // be prohibitive, so we make a set of pointers and sort those.
12370  SmallVector<OverloadCandidate*, 32> Cands;
12371  if (OCD == OCD_AllCandidates) Cands.reserve(size());
12372  for (iterator Cand = begin(), LastCand = end(); Cand != LastCand; ++Cand) {
12373    if (!Filter(*Cand))
12374      continue;
12375    switch (OCD) {
12376    case OCD_AllCandidates:
12377      if (!Cand->Viable) {
12378        if (!Cand->Function && !Cand->IsSurrogate) {
12379          // This a non-viable builtin candidate.  We do not, in general,
12380          // want to list every possible builtin candidate.
12381          continue;
12382        }
12383        CompleteNonViableCandidate(S, Cand, Args, Kind);
12384      }
12385      break;
12386
12387    case OCD_ViableCandidates:
12388      if (!Cand->Viable)
12389        continue;
12390      break;
12391
12392    case OCD_AmbiguousCandidates:
12393      if (!Cand->Best)
12394        continue;
12395      break;
12396    }
12397
12398    Cands.push_back(Cand);
12399  }
12400
12401  llvm::stable_sort(
12402      Cands, CompareOverloadCandidatesForDisplay(S, OpLoc, Args.size(), Kind));
12403
12404  return Cands;
12405}
12406
12407bool OverloadCandidateSet::shouldDeferDiags(Sema &S, ArrayRef<Expr *> Args,
12408                                            SourceLocation OpLoc) {
12409  bool DeferHint = false;
12410  if (S.getLangOpts().CUDA && S.getLangOpts().GPUDeferDiag) {
12411    // Defer diagnostic for CUDA/HIP if there are wrong-sided candidates or
12412    // host device candidates.
12413    auto WrongSidedCands =
12414        CompleteCandidates(S, OCD_AllCandidates, Args, OpLoc, [](auto &Cand) {
12415          return (Cand.Viable == false &&
12416                  Cand.FailureKind == ovl_fail_bad_target) ||
12417                 (Cand.Function &&
12418                  Cand.Function->template hasAttr<CUDAHostAttr>() &&
12419                  Cand.Function->template hasAttr<CUDADeviceAttr>());
12420        });
12421    DeferHint = !WrongSidedCands.empty();
12422  }
12423  return DeferHint;
12424}
12425
12426/// When overload resolution fails, prints diagnostic messages containing the
12427/// candidates in the candidate set.
12428void OverloadCandidateSet::NoteCandidates(
12429    PartialDiagnosticAt PD, Sema &S, OverloadCandidateDisplayKind OCD,
12430    ArrayRef<Expr *> Args, StringRef Opc, SourceLocation OpLoc,
12431    llvm::function_ref<bool(OverloadCandidate &)> Filter) {
12432
12433  auto Cands = CompleteCandidates(S, OCD, Args, OpLoc, Filter);
12434
12435  S.Diag(PD.first, PD.second, shouldDeferDiags(S, Args, OpLoc));
12436
12437  // In WebAssembly we don't want to emit further diagnostics if a table is
12438  // passed as an argument to a function.
12439  bool NoteCands = true;
12440  for (const Expr *Arg : Args) {
12441    if (Arg->getType()->isWebAssemblyTableType())
12442      NoteCands = false;
12443  }
12444
12445  if (NoteCands)
12446    NoteCandidates(S, Args, Cands, Opc, OpLoc);
12447
12448  if (OCD == OCD_AmbiguousCandidates)
12449    MaybeDiagnoseAmbiguousConstraints(S, {begin(), end()});
12450}
12451
12452void OverloadCandidateSet::NoteCandidates(Sema &S, ArrayRef<Expr *> Args,
12453                                          ArrayRef<OverloadCandidate *> Cands,
12454                                          StringRef Opc, SourceLocation OpLoc) {
12455  bool ReportedAmbiguousConversions = false;
12456
12457  const OverloadsShown ShowOverloads = S.Diags.getShowOverloads();
12458  unsigned CandsShown = 0;
12459  auto I = Cands.begin(), E = Cands.end();
12460  for (; I != E; ++I) {
12461    OverloadCandidate *Cand = *I;
12462
12463    if (CandsShown >= S.Diags.getNumOverloadCandidatesToShow() &&
12464        ShowOverloads == Ovl_Best) {
12465      break;
12466    }
12467    ++CandsShown;
12468
12469    if (Cand->Function)
12470      NoteFunctionCandidate(S, Cand, Args.size(),
12471                            /*TakingCandidateAddress=*/false, DestAS);
12472    else if (Cand->IsSurrogate)
12473      NoteSurrogateCandidate(S, Cand);
12474    else {
12475      assert(Cand->Viable &&
12476             "Non-viable built-in candidates are not added to Cands.");
12477      // Generally we only see ambiguities including viable builtin
12478      // operators if overload resolution got screwed up by an
12479      // ambiguous user-defined conversion.
12480      //
12481      // FIXME: It's quite possible for different conversions to see
12482      // different ambiguities, though.
12483      if (!ReportedAmbiguousConversions) {
12484        NoteAmbiguousUserConversions(S, OpLoc, Cand);
12485        ReportedAmbiguousConversions = true;
12486      }
12487
12488      // If this is a viable builtin, print it.
12489      NoteBuiltinOperatorCandidate(S, Opc, OpLoc, Cand);
12490    }
12491  }
12492
12493  // Inform S.Diags that we've shown an overload set with N elements.  This may
12494  // inform the future value of S.Diags.getNumOverloadCandidatesToShow().
12495  S.Diags.overloadCandidatesShown(CandsShown);
12496
12497  if (I != E)
12498    S.Diag(OpLoc, diag::note_ovl_too_many_candidates,
12499           shouldDeferDiags(S, Args, OpLoc))
12500        << int(E - I);
12501}
12502
12503static SourceLocation
12504GetLocationForCandidate(const TemplateSpecCandidate *Cand) {
12505  return Cand->Specialization ? Cand->Specialization->getLocation()
12506                              : SourceLocation();
12507}
12508
12509namespace {
12510struct CompareTemplateSpecCandidatesForDisplay {
12511  Sema &S;
12512  CompareTemplateSpecCandidatesForDisplay(Sema &S) : S(S) {}
12513
12514  bool operator()(const TemplateSpecCandidate *L,
12515                  const TemplateSpecCandidate *R) {
12516    // Fast-path this check.
12517    if (L == R)
12518      return false;
12519
12520    // Assuming that both candidates are not matches...
12521
12522    // Sort by the ranking of deduction failures.
12523    if (L->DeductionFailure.Result != R->DeductionFailure.Result)
12524      return RankDeductionFailure(L->DeductionFailure) <
12525             RankDeductionFailure(R->DeductionFailure);
12526
12527    // Sort everything else by location.
12528    SourceLocation LLoc = GetLocationForCandidate(L);
12529    SourceLocation RLoc = GetLocationForCandidate(R);
12530
12531    // Put candidates without locations (e.g. builtins) at the end.
12532    if (LLoc.isInvalid())
12533      return false;
12534    if (RLoc.isInvalid())
12535      return true;
12536
12537    return S.SourceMgr.isBeforeInTranslationUnit(LLoc, RLoc);
12538  }
12539};
12540}
12541
12542/// Diagnose a template argument deduction failure.
12543/// We are treating these failures as overload failures due to bad
12544/// deductions.
12545void TemplateSpecCandidate::NoteDeductionFailure(Sema &S,
12546                                                 bool ForTakingAddress) {
12547  DiagnoseBadDeduction(S, FoundDecl, Specialization, // pattern
12548                       DeductionFailure, /*NumArgs=*/0, ForTakingAddress);
12549}
12550
12551void TemplateSpecCandidateSet::destroyCandidates() {
12552  for (iterator i = begin(), e = end(); i != e; ++i) {
12553    i->DeductionFailure.Destroy();
12554  }
12555}
12556
12557void TemplateSpecCandidateSet::clear() {
12558  destroyCandidates();
12559  Candidates.clear();
12560}
12561
12562/// NoteCandidates - When no template specialization match is found, prints
12563/// diagnostic messages containing the non-matching specializations that form
12564/// the candidate set.
12565/// This is analoguous to OverloadCandidateSet::NoteCandidates() with
12566/// OCD == OCD_AllCandidates and Cand->Viable == false.
12567void TemplateSpecCandidateSet::NoteCandidates(Sema &S, SourceLocation Loc) {
12568  // Sort the candidates by position (assuming no candidate is a match).
12569  // Sorting directly would be prohibitive, so we make a set of pointers
12570  // and sort those.
12571  SmallVector<TemplateSpecCandidate *, 32> Cands;
12572  Cands.reserve(size());
12573  for (iterator Cand = begin(), LastCand = end(); Cand != LastCand; ++Cand) {
12574    if (Cand->Specialization)
12575      Cands.push_back(Cand);
12576    // Otherwise, this is a non-matching builtin candidate.  We do not,
12577    // in general, want to list every possible builtin candidate.
12578  }
12579
12580  llvm::sort(Cands, CompareTemplateSpecCandidatesForDisplay(S));
12581
12582  // FIXME: Perhaps rename OverloadsShown and getShowOverloads()
12583  // for generalization purposes (?).
12584  const OverloadsShown ShowOverloads = S.Diags.getShowOverloads();
12585
12586  SmallVectorImpl<TemplateSpecCandidate *>::iterator I, E;
12587  unsigned CandsShown = 0;
12588  for (I = Cands.begin(), E = Cands.end(); I != E; ++I) {
12589    TemplateSpecCandidate *Cand = *I;
12590
12591    // Set an arbitrary limit on the number of candidates we'll spam
12592    // the user with.  FIXME: This limit should depend on details of the
12593    // candidate list.
12594    if (CandsShown >= 4 && ShowOverloads == Ovl_Best)
12595      break;
12596    ++CandsShown;
12597
12598    assert(Cand->Specialization &&
12599           "Non-matching built-in candidates are not added to Cands.");
12600    Cand->NoteDeductionFailure(S, ForTakingAddress);
12601  }
12602
12603  if (I != E)
12604    S.Diag(Loc, diag::note_ovl_too_many_candidates) << int(E - I);
12605}
12606
12607// [PossiblyAFunctionType]  -->   [Return]
12608// NonFunctionType --> NonFunctionType
12609// R (A) --> R(A)
12610// R (*)(A) --> R (A)
12611// R (&)(A) --> R (A)
12612// R (S::*)(A) --> R (A)
12613QualType Sema::ExtractUnqualifiedFunctionType(QualType PossiblyAFunctionType) {
12614  QualType Ret = PossiblyAFunctionType;
12615  if (const PointerType *ToTypePtr =
12616    PossiblyAFunctionType->getAs<PointerType>())
12617    Ret = ToTypePtr->getPointeeType();
12618  else if (const ReferenceType *ToTypeRef =
12619    PossiblyAFunctionType->getAs<ReferenceType>())
12620    Ret = ToTypeRef->getPointeeType();
12621  else if (const MemberPointerType *MemTypePtr =
12622    PossiblyAFunctionType->getAs<MemberPointerType>())
12623    Ret = MemTypePtr->getPointeeType();
12624  Ret =
12625    Context.getCanonicalType(Ret).getUnqualifiedType();
12626  return Ret;
12627}
12628
12629static bool completeFunctionType(Sema &S, FunctionDecl *FD, SourceLocation Loc,
12630                                 bool Complain = true) {
12631  if (S.getLangOpts().CPlusPlus14 && FD->getReturnType()->isUndeducedType() &&
12632      S.DeduceReturnType(FD, Loc, Complain))
12633    return true;
12634
12635  auto *FPT = FD->getType()->castAs<FunctionProtoType>();
12636  if (S.getLangOpts().CPlusPlus17 &&
12637      isUnresolvedExceptionSpec(FPT->getExceptionSpecType()) &&
12638      !S.ResolveExceptionSpec(Loc, FPT))
12639    return true;
12640
12641  return false;
12642}
12643
12644namespace {
12645// A helper class to help with address of function resolution
12646// - allows us to avoid passing around all those ugly parameters
12647class AddressOfFunctionResolver {
12648  Sema& S;
12649  Expr* SourceExpr;
12650  const QualType& TargetType;
12651  QualType TargetFunctionType; // Extracted function type from target type
12652
12653  bool Complain;
12654  //DeclAccessPair& ResultFunctionAccessPair;
12655  ASTContext& Context;
12656
12657  bool TargetTypeIsNonStaticMemberFunction;
12658  bool FoundNonTemplateFunction;
12659  bool StaticMemberFunctionFromBoundPointer;
12660  bool HasComplained;
12661
12662  OverloadExpr::FindResult OvlExprInfo;
12663  OverloadExpr *OvlExpr;
12664  TemplateArgumentListInfo OvlExplicitTemplateArgs;
12665  SmallVector<std::pair<DeclAccessPair, FunctionDecl*>, 4> Matches;
12666  TemplateSpecCandidateSet FailedCandidates;
12667
12668public:
12669  AddressOfFunctionResolver(Sema &S, Expr *SourceExpr,
12670                            const QualType &TargetType, bool Complain)
12671      : S(S), SourceExpr(SourceExpr), TargetType(TargetType),
12672        Complain(Complain), Context(S.getASTContext()),
12673        TargetTypeIsNonStaticMemberFunction(
12674            !!TargetType->getAs<MemberPointerType>()),
12675        FoundNonTemplateFunction(false),
12676        StaticMemberFunctionFromBoundPointer(false),
12677        HasComplained(false),
12678        OvlExprInfo(OverloadExpr::find(SourceExpr)),
12679        OvlExpr(OvlExprInfo.Expression),
12680        FailedCandidates(OvlExpr->getNameLoc(), /*ForTakingAddress=*/true) {
12681    ExtractUnqualifiedFunctionTypeFromTargetType();
12682
12683    if (TargetFunctionType->isFunctionType()) {
12684      if (UnresolvedMemberExpr *UME = dyn_cast<UnresolvedMemberExpr>(OvlExpr))
12685        if (!UME->isImplicitAccess() &&
12686            !S.ResolveSingleFunctionTemplateSpecialization(UME))
12687          StaticMemberFunctionFromBoundPointer = true;
12688    } else if (OvlExpr->hasExplicitTemplateArgs()) {
12689      DeclAccessPair dap;
12690      if (FunctionDecl *Fn = S.ResolveSingleFunctionTemplateSpecialization(
12691              OvlExpr, false, &dap)) {
12692        if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn))
12693          if (!Method->isStatic()) {
12694            // If the target type is a non-function type and the function found
12695            // is a non-static member function, pretend as if that was the
12696            // target, it's the only possible type to end up with.
12697            TargetTypeIsNonStaticMemberFunction = true;
12698
12699            // And skip adding the function if its not in the proper form.
12700            // We'll diagnose this due to an empty set of functions.
12701            if (!OvlExprInfo.HasFormOfMemberPointer)
12702              return;
12703          }
12704
12705        Matches.push_back(std::make_pair(dap, Fn));
12706      }
12707      return;
12708    }
12709
12710    if (OvlExpr->hasExplicitTemplateArgs())
12711      OvlExpr->copyTemplateArgumentsInto(OvlExplicitTemplateArgs);
12712
12713    if (FindAllFunctionsThatMatchTargetTypeExactly()) {
12714      // C++ [over.over]p4:
12715      //   If more than one function is selected, [...]
12716      if (Matches.size() > 1 && !eliminiateSuboptimalOverloadCandidates()) {
12717        if (FoundNonTemplateFunction)
12718          EliminateAllTemplateMatches();
12719        else
12720          EliminateAllExceptMostSpecializedTemplate();
12721      }
12722    }
12723
12724    if (S.getLangOpts().CUDA && Matches.size() > 1)
12725      EliminateSuboptimalCudaMatches();
12726  }
12727
12728  bool hasComplained() const { return HasComplained; }
12729
12730private:
12731  bool candidateHasExactlyCorrectType(const FunctionDecl *FD) {
12732    QualType Discard;
12733    return Context.hasSameUnqualifiedType(TargetFunctionType, FD->getType()) ||
12734           S.IsFunctionConversion(FD->getType(), TargetFunctionType, Discard);
12735  }
12736
12737  /// \return true if A is considered a better overload candidate for the
12738  /// desired type than B.
12739  bool isBetterCandidate(const FunctionDecl *A, const FunctionDecl *B) {
12740    // If A doesn't have exactly the correct type, we don't want to classify it
12741    // as "better" than anything else. This way, the user is required to
12742    // disambiguate for us if there are multiple candidates and no exact match.
12743    return candidateHasExactlyCorrectType(A) &&
12744           (!candidateHasExactlyCorrectType(B) ||
12745            compareEnableIfAttrs(S, A, B) == Comparison::Better);
12746  }
12747
12748  /// \return true if we were able to eliminate all but one overload candidate,
12749  /// false otherwise.
12750  bool eliminiateSuboptimalOverloadCandidates() {
12751    // Same algorithm as overload resolution -- one pass to pick the "best",
12752    // another pass to be sure that nothing is better than the best.
12753    auto Best = Matches.begin();
12754    for (auto I = Matches.begin()+1, E = Matches.end(); I != E; ++I)
12755      if (isBetterCandidate(I->second, Best->second))
12756        Best = I;
12757
12758    const FunctionDecl *BestFn = Best->second;
12759    auto IsBestOrInferiorToBest = [this, BestFn](
12760        const std::pair<DeclAccessPair, FunctionDecl *> &Pair) {
12761      return BestFn == Pair.second || isBetterCandidate(BestFn, Pair.second);
12762    };
12763
12764    // Note: We explicitly leave Matches unmodified if there isn't a clear best
12765    // option, so we can potentially give the user a better error
12766    if (!llvm::all_of(Matches, IsBestOrInferiorToBest))
12767      return false;
12768    Matches[0] = *Best;
12769    Matches.resize(1);
12770    return true;
12771  }
12772
12773  bool isTargetTypeAFunction() const {
12774    return TargetFunctionType->isFunctionType();
12775  }
12776
12777  // [ToType]     [Return]
12778
12779  // R (*)(A) --> R (A), IsNonStaticMemberFunction = false
12780  // R (&)(A) --> R (A), IsNonStaticMemberFunction = false
12781  // R (S::*)(A) --> R (A), IsNonStaticMemberFunction = true
12782  void inline ExtractUnqualifiedFunctionTypeFromTargetType() {
12783    TargetFunctionType = S.ExtractUnqualifiedFunctionType(TargetType);
12784  }
12785
12786  // return true if any matching specializations were found
12787  bool AddMatchingTemplateFunction(FunctionTemplateDecl* FunctionTemplate,
12788                                   const DeclAccessPair& CurAccessFunPair) {
12789    if (CXXMethodDecl *Method
12790              = dyn_cast<CXXMethodDecl>(FunctionTemplate->getTemplatedDecl())) {
12791      // Skip non-static function templates when converting to pointer, and
12792      // static when converting to member pointer.
12793      bool CanConvertToFunctionPointer =
12794          Method->isStatic() || Method->isExplicitObjectMemberFunction();
12795      if (CanConvertToFunctionPointer == TargetTypeIsNonStaticMemberFunction)
12796        return false;
12797    }
12798    else if (TargetTypeIsNonStaticMemberFunction)
12799      return false;
12800
12801    // C++ [over.over]p2:
12802    //   If the name is a function template, template argument deduction is
12803    //   done (14.8.2.2), and if the argument deduction succeeds, the
12804    //   resulting template argument list is used to generate a single
12805    //   function template specialization, which is added to the set of
12806    //   overloaded functions considered.
12807    FunctionDecl *Specialization = nullptr;
12808    TemplateDeductionInfo Info(FailedCandidates.getLocation());
12809    if (Sema::TemplateDeductionResult Result
12810          = S.DeduceTemplateArguments(FunctionTemplate,
12811                                      &OvlExplicitTemplateArgs,
12812                                      TargetFunctionType, Specialization,
12813                                      Info, /*IsAddressOfFunction*/true)) {
12814      // Make a note of the failed deduction for diagnostics.
12815      FailedCandidates.addCandidate()
12816          .set(CurAccessFunPair, FunctionTemplate->getTemplatedDecl(),
12817               MakeDeductionFailureInfo(Context, Result, Info));
12818      return false;
12819    }
12820
12821    // Template argument deduction ensures that we have an exact match or
12822    // compatible pointer-to-function arguments that would be adjusted by ICS.
12823    // This function template specicalization works.
12824    assert(S.isSameOrCompatibleFunctionType(
12825              Context.getCanonicalType(Specialization->getType()),
12826              Context.getCanonicalType(TargetFunctionType)));
12827
12828    if (!S.checkAddressOfFunctionIsAvailable(Specialization))
12829      return false;
12830
12831    Matches.push_back(std::make_pair(CurAccessFunPair, Specialization));
12832    return true;
12833  }
12834
12835  bool AddMatchingNonTemplateFunction(NamedDecl* Fn,
12836                                      const DeclAccessPair& CurAccessFunPair) {
12837    if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) {
12838      // Skip non-static functions when converting to pointer, and static
12839      // when converting to member pointer.
12840      bool CanConvertToFunctionPointer =
12841          Method->isStatic() || Method->isExplicitObjectMemberFunction();
12842      if (CanConvertToFunctionPointer == TargetTypeIsNonStaticMemberFunction)
12843        return false;
12844    }
12845    else if (TargetTypeIsNonStaticMemberFunction)
12846      return false;
12847
12848    if (FunctionDecl *FunDecl = dyn_cast<FunctionDecl>(Fn)) {
12849      if (S.getLangOpts().CUDA) {
12850        FunctionDecl *Caller = S.getCurFunctionDecl(/*AllowLambda=*/true);
12851        if (!(Caller && Caller->isImplicit()) &&
12852            !S.IsAllowedCUDACall(Caller, FunDecl))
12853          return false;
12854      }
12855      if (FunDecl->isMultiVersion()) {
12856        const auto *TA = FunDecl->getAttr<TargetAttr>();
12857        if (TA && !TA->isDefaultVersion())
12858          return false;
12859        const auto *TVA = FunDecl->getAttr<TargetVersionAttr>();
12860        if (TVA && !TVA->isDefaultVersion())
12861          return false;
12862      }
12863
12864      // If any candidate has a placeholder return type, trigger its deduction
12865      // now.
12866      if (completeFunctionType(S, FunDecl, SourceExpr->getBeginLoc(),
12867                               Complain)) {
12868        HasComplained |= Complain;
12869        return false;
12870      }
12871
12872      if (!S.checkAddressOfFunctionIsAvailable(FunDecl))
12873        return false;
12874
12875      // If we're in C, we need to support types that aren't exactly identical.
12876      if (!S.getLangOpts().CPlusPlus ||
12877          candidateHasExactlyCorrectType(FunDecl)) {
12878        Matches.push_back(std::make_pair(
12879            CurAccessFunPair, cast<FunctionDecl>(FunDecl->getCanonicalDecl())));
12880        FoundNonTemplateFunction = true;
12881        return true;
12882      }
12883    }
12884
12885    return false;
12886  }
12887
12888  bool FindAllFunctionsThatMatchTargetTypeExactly() {
12889    bool Ret = false;
12890
12891    // If the overload expression doesn't have the form of a pointer to
12892    // member, don't try to convert it to a pointer-to-member type.
12893    if (IsInvalidFormOfPointerToMemberFunction())
12894      return false;
12895
12896    for (UnresolvedSetIterator I = OvlExpr->decls_begin(),
12897                               E = OvlExpr->decls_end();
12898         I != E; ++I) {
12899      // Look through any using declarations to find the underlying function.
12900      NamedDecl *Fn = (*I)->getUnderlyingDecl();
12901
12902      // C++ [over.over]p3:
12903      //   Non-member functions and static member functions match
12904      //   targets of type "pointer-to-function" or "reference-to-function."
12905      //   Nonstatic member functions match targets of
12906      //   type "pointer-to-member-function."
12907      // Note that according to DR 247, the containing class does not matter.
12908      if (FunctionTemplateDecl *FunctionTemplate
12909                                        = dyn_cast<FunctionTemplateDecl>(Fn)) {
12910        if (AddMatchingTemplateFunction(FunctionTemplate, I.getPair()))
12911          Ret = true;
12912      }
12913      // If we have explicit template arguments supplied, skip non-templates.
12914      else if (!OvlExpr->hasExplicitTemplateArgs() &&
12915               AddMatchingNonTemplateFunction(Fn, I.getPair()))
12916        Ret = true;
12917    }
12918    assert(Ret || Matches.empty());
12919    return Ret;
12920  }
12921
12922  void EliminateAllExceptMostSpecializedTemplate() {
12923    //   [...] and any given function template specialization F1 is
12924    //   eliminated if the set contains a second function template
12925    //   specialization whose function template is more specialized
12926    //   than the function template of F1 according to the partial
12927    //   ordering rules of 14.5.5.2.
12928
12929    // The algorithm specified above is quadratic. We instead use a
12930    // two-pass algorithm (similar to the one used to identify the
12931    // best viable function in an overload set) that identifies the
12932    // best function template (if it exists).
12933
12934    UnresolvedSet<4> MatchesCopy; // TODO: avoid!
12935    for (unsigned I = 0, E = Matches.size(); I != E; ++I)
12936      MatchesCopy.addDecl(Matches[I].second, Matches[I].first.getAccess());
12937
12938    // TODO: It looks like FailedCandidates does not serve much purpose
12939    // here, since the no_viable diagnostic has index 0.
12940    UnresolvedSetIterator Result = S.getMostSpecialized(
12941        MatchesCopy.begin(), MatchesCopy.end(), FailedCandidates,
12942        SourceExpr->getBeginLoc(), S.PDiag(),
12943        S.PDiag(diag::err_addr_ovl_ambiguous)
12944            << Matches[0].second->getDeclName(),
12945        S.PDiag(diag::note_ovl_candidate)
12946            << (unsigned)oc_function << (unsigned)ocs_described_template,
12947        Complain, TargetFunctionType);
12948
12949    if (Result != MatchesCopy.end()) {
12950      // Make it the first and only element
12951      Matches[0].first = Matches[Result - MatchesCopy.begin()].first;
12952      Matches[0].second = cast<FunctionDecl>(*Result);
12953      Matches.resize(1);
12954    } else
12955      HasComplained |= Complain;
12956  }
12957
12958  void EliminateAllTemplateMatches() {
12959    //   [...] any function template specializations in the set are
12960    //   eliminated if the set also contains a non-template function, [...]
12961    for (unsigned I = 0, N = Matches.size(); I != N; ) {
12962      if (Matches[I].second->getPrimaryTemplate() == nullptr)
12963        ++I;
12964      else {
12965        Matches[I] = Matches[--N];
12966        Matches.resize(N);
12967      }
12968    }
12969  }
12970
12971  void EliminateSuboptimalCudaMatches() {
12972    S.EraseUnwantedCUDAMatches(S.getCurFunctionDecl(/*AllowLambda=*/true),
12973                               Matches);
12974  }
12975
12976public:
12977  void ComplainNoMatchesFound() const {
12978    assert(Matches.empty());
12979    S.Diag(OvlExpr->getBeginLoc(), diag::err_addr_ovl_no_viable)
12980        << OvlExpr->getName() << TargetFunctionType
12981        << OvlExpr->getSourceRange();
12982    if (FailedCandidates.empty())
12983      S.NoteAllOverloadCandidates(OvlExpr, TargetFunctionType,
12984                                  /*TakingAddress=*/true);
12985    else {
12986      // We have some deduction failure messages. Use them to diagnose
12987      // the function templates, and diagnose the non-template candidates
12988      // normally.
12989      for (UnresolvedSetIterator I = OvlExpr->decls_begin(),
12990                                 IEnd = OvlExpr->decls_end();
12991           I != IEnd; ++I)
12992        if (FunctionDecl *Fun =
12993                dyn_cast<FunctionDecl>((*I)->getUnderlyingDecl()))
12994          if (!functionHasPassObjectSizeParams(Fun))
12995            S.NoteOverloadCandidate(*I, Fun, CRK_None, TargetFunctionType,
12996                                    /*TakingAddress=*/true);
12997      FailedCandidates.NoteCandidates(S, OvlExpr->getBeginLoc());
12998    }
12999  }
13000
13001  bool IsInvalidFormOfPointerToMemberFunction() const {
13002    return TargetTypeIsNonStaticMemberFunction &&
13003      !OvlExprInfo.HasFormOfMemberPointer;
13004  }
13005
13006  void ComplainIsInvalidFormOfPointerToMemberFunction() const {
13007      // TODO: Should we condition this on whether any functions might
13008      // have matched, or is it more appropriate to do that in callers?
13009      // TODO: a fixit wouldn't hurt.
13010      S.Diag(OvlExpr->getNameLoc(), diag::err_addr_ovl_no_qualifier)
13011        << TargetType << OvlExpr->getSourceRange();
13012  }
13013
13014  bool IsStaticMemberFunctionFromBoundPointer() const {
13015    return StaticMemberFunctionFromBoundPointer;
13016  }
13017
13018  void ComplainIsStaticMemberFunctionFromBoundPointer() const {
13019    S.Diag(OvlExpr->getBeginLoc(),
13020           diag::err_invalid_form_pointer_member_function)
13021        << OvlExpr->getSourceRange();
13022  }
13023
13024  void ComplainOfInvalidConversion() const {
13025    S.Diag(OvlExpr->getBeginLoc(), diag::err_addr_ovl_not_func_ptrref)
13026        << OvlExpr->getName() << TargetType;
13027  }
13028
13029  void ComplainMultipleMatchesFound() const {
13030    assert(Matches.size() > 1);
13031    S.Diag(OvlExpr->getBeginLoc(), diag::err_addr_ovl_ambiguous)
13032        << OvlExpr->getName() << OvlExpr->getSourceRange();
13033    S.NoteAllOverloadCandidates(OvlExpr, TargetFunctionType,
13034                                /*TakingAddress=*/true);
13035  }
13036
13037  bool hadMultipleCandidates() const { return (OvlExpr->getNumDecls() > 1); }
13038
13039  int getNumMatches() const { return Matches.size(); }
13040
13041  FunctionDecl* getMatchingFunctionDecl() const {
13042    if (Matches.size() != 1) return nullptr;
13043    return Matches[0].second;
13044  }
13045
13046  const DeclAccessPair* getMatchingFunctionAccessPair() const {
13047    if (Matches.size() != 1) return nullptr;
13048    return &Matches[0].first;
13049  }
13050};
13051}
13052
13053/// ResolveAddressOfOverloadedFunction - Try to resolve the address of
13054/// an overloaded function (C++ [over.over]), where @p From is an
13055/// expression with overloaded function type and @p ToType is the type
13056/// we're trying to resolve to. For example:
13057///
13058/// @code
13059/// int f(double);
13060/// int f(int);
13061///
13062/// int (*pfd)(double) = f; // selects f(double)
13063/// @endcode
13064///
13065/// This routine returns the resulting FunctionDecl if it could be
13066/// resolved, and NULL otherwise. When @p Complain is true, this
13067/// routine will emit diagnostics if there is an error.
13068FunctionDecl *
13069Sema::ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr,
13070                                         QualType TargetType,
13071                                         bool Complain,
13072                                         DeclAccessPair &FoundResult,
13073                                         bool *pHadMultipleCandidates) {
13074  assert(AddressOfExpr->getType() == Context.OverloadTy);
13075
13076  AddressOfFunctionResolver Resolver(*this, AddressOfExpr, TargetType,
13077                                     Complain);
13078  int NumMatches = Resolver.getNumMatches();
13079  FunctionDecl *Fn = nullptr;
13080  bool ShouldComplain = Complain && !Resolver.hasComplained();
13081  if (NumMatches == 0 && ShouldComplain) {
13082    if (Resolver.IsInvalidFormOfPointerToMemberFunction())
13083      Resolver.ComplainIsInvalidFormOfPointerToMemberFunction();
13084    else
13085      Resolver.ComplainNoMatchesFound();
13086  }
13087  else if (NumMatches > 1 && ShouldComplain)
13088    Resolver.ComplainMultipleMatchesFound();
13089  else if (NumMatches == 1) {
13090    Fn = Resolver.getMatchingFunctionDecl();
13091    assert(Fn);
13092    if (auto *FPT = Fn->getType()->getAs<FunctionProtoType>())
13093      ResolveExceptionSpec(AddressOfExpr->getExprLoc(), FPT);
13094    FoundResult = *Resolver.getMatchingFunctionAccessPair();
13095    if (Complain) {
13096      if (Resolver.IsStaticMemberFunctionFromBoundPointer())
13097        Resolver.ComplainIsStaticMemberFunctionFromBoundPointer();
13098      else
13099        CheckAddressOfMemberAccess(AddressOfExpr, FoundResult);
13100    }
13101  }
13102
13103  if (pHadMultipleCandidates)
13104    *pHadMultipleCandidates = Resolver.hadMultipleCandidates();
13105  return Fn;
13106}
13107
13108/// Given an expression that refers to an overloaded function, try to
13109/// resolve that function to a single function that can have its address taken.
13110/// This will modify `Pair` iff it returns non-null.
13111///
13112/// This routine can only succeed if from all of the candidates in the overload
13113/// set for SrcExpr that can have their addresses taken, there is one candidate
13114/// that is more constrained than the rest.
13115FunctionDecl *
13116Sema::resolveAddressOfSingleOverloadCandidate(Expr *E, DeclAccessPair &Pair) {
13117  OverloadExpr::FindResult R = OverloadExpr::find(E);
13118  OverloadExpr *Ovl = R.Expression;
13119  bool IsResultAmbiguous = false;
13120  FunctionDecl *Result = nullptr;
13121  DeclAccessPair DAP;
13122  SmallVector<FunctionDecl *, 2> AmbiguousDecls;
13123
13124  // Return positive for better, negative for worse, 0 for equal preference.
13125  auto CheckCUDAPreference = [&](FunctionDecl *FD1, FunctionDecl *FD2) {
13126    FunctionDecl *Caller = getCurFunctionDecl(/*AllowLambda=*/true);
13127    return static_cast<int>(IdentifyCUDAPreference(Caller, FD1)) -
13128           static_cast<int>(IdentifyCUDAPreference(Caller, FD2));
13129  };
13130
13131  auto CheckMoreConstrained = [&](FunctionDecl *FD1,
13132                                  FunctionDecl *FD2) -> std::optional<bool> {
13133    if (FunctionDecl *MF = FD1->getInstantiatedFromMemberFunction())
13134      FD1 = MF;
13135    if (FunctionDecl *MF = FD2->getInstantiatedFromMemberFunction())
13136      FD2 = MF;
13137    SmallVector<const Expr *, 1> AC1, AC2;
13138    FD1->getAssociatedConstraints(AC1);
13139    FD2->getAssociatedConstraints(AC2);
13140    bool AtLeastAsConstrained1, AtLeastAsConstrained2;
13141    if (IsAtLeastAsConstrained(FD1, AC1, FD2, AC2, AtLeastAsConstrained1))
13142      return std::nullopt;
13143    if (IsAtLeastAsConstrained(FD2, AC2, FD1, AC1, AtLeastAsConstrained2))
13144      return std::nullopt;
13145    if (AtLeastAsConstrained1 == AtLeastAsConstrained2)
13146      return std::nullopt;
13147    return AtLeastAsConstrained1;
13148  };
13149
13150  // Don't use the AddressOfResolver because we're specifically looking for
13151  // cases where we have one overload candidate that lacks
13152  // enable_if/pass_object_size/...
13153  for (auto I = Ovl->decls_begin(), E = Ovl->decls_end(); I != E; ++I) {
13154    auto *FD = dyn_cast<FunctionDecl>(I->getUnderlyingDecl());
13155    if (!FD)
13156      return nullptr;
13157
13158    if (!checkAddressOfFunctionIsAvailable(FD))
13159      continue;
13160
13161    // If we found a better result, update Result.
13162    auto FoundBetter = [&]() {
13163      IsResultAmbiguous = false;
13164      DAP = I.getPair();
13165      Result = FD;
13166    };
13167
13168    // We have more than one result - see if it is more constrained than the
13169    // previous one.
13170    if (Result) {
13171      // Check CUDA preference first. If the candidates have differennt CUDA
13172      // preference, choose the one with higher CUDA preference. Otherwise,
13173      // choose the one with more constraints.
13174      if (getLangOpts().CUDA) {
13175        int PreferenceByCUDA = CheckCUDAPreference(FD, Result);
13176        // FD has different preference than Result.
13177        if (PreferenceByCUDA != 0) {
13178          // FD is more preferable than Result.
13179          if (PreferenceByCUDA > 0)
13180            FoundBetter();
13181          continue;
13182        }
13183      }
13184      // FD has the same CUDA prefernece than Result. Continue check
13185      // constraints.
13186      std::optional<bool> MoreConstrainedThanPrevious =
13187          CheckMoreConstrained(FD, Result);
13188      if (!MoreConstrainedThanPrevious) {
13189        IsResultAmbiguous = true;
13190        AmbiguousDecls.push_back(FD);
13191        continue;
13192      }
13193      if (!*MoreConstrainedThanPrevious)
13194        continue;
13195      // FD is more constrained - replace Result with it.
13196    }
13197    FoundBetter();
13198  }
13199
13200  if (IsResultAmbiguous)
13201    return nullptr;
13202
13203  if (Result) {
13204    SmallVector<const Expr *, 1> ResultAC;
13205    // We skipped over some ambiguous declarations which might be ambiguous with
13206    // the selected result.
13207    for (FunctionDecl *Skipped : AmbiguousDecls) {
13208      // If skipped candidate has different CUDA preference than the result,
13209      // there is no ambiguity. Otherwise check whether they have different
13210      // constraints.
13211      if (getLangOpts().CUDA && CheckCUDAPreference(Skipped, Result) != 0)
13212        continue;
13213      if (!CheckMoreConstrained(Skipped, Result))
13214        return nullptr;
13215    }
13216    Pair = DAP;
13217  }
13218  return Result;
13219}
13220
13221/// Given an overloaded function, tries to turn it into a non-overloaded
13222/// function reference using resolveAddressOfSingleOverloadCandidate. This
13223/// will perform access checks, diagnose the use of the resultant decl, and, if
13224/// requested, potentially perform a function-to-pointer decay.
13225///
13226/// Returns false if resolveAddressOfSingleOverloadCandidate fails.
13227/// Otherwise, returns true. This may emit diagnostics and return true.
13228bool Sema::resolveAndFixAddressOfSingleOverloadCandidate(
13229    ExprResult &SrcExpr, bool DoFunctionPointerConversion) {
13230  Expr *E = SrcExpr.get();
13231  assert(E->getType() == Context.OverloadTy && "SrcExpr must be an overload");
13232
13233  DeclAccessPair DAP;
13234  FunctionDecl *Found = resolveAddressOfSingleOverloadCandidate(E, DAP);
13235  if (!Found || Found->isCPUDispatchMultiVersion() ||
13236      Found->isCPUSpecificMultiVersion())
13237    return false;
13238
13239  // Emitting multiple diagnostics for a function that is both inaccessible and
13240  // unavailable is consistent with our behavior elsewhere. So, always check
13241  // for both.
13242  DiagnoseUseOfDecl(Found, E->getExprLoc());
13243  CheckAddressOfMemberAccess(E, DAP);
13244  ExprResult Res = FixOverloadedFunctionReference(E, DAP, Found);
13245  if (Res.isInvalid())
13246    return false;
13247  Expr *Fixed = Res.get();
13248  if (DoFunctionPointerConversion && Fixed->getType()->isFunctionType())
13249    SrcExpr = DefaultFunctionArrayConversion(Fixed, /*Diagnose=*/false);
13250  else
13251    SrcExpr = Fixed;
13252  return true;
13253}
13254
13255/// Given an expression that refers to an overloaded function, try to
13256/// resolve that overloaded function expression down to a single function.
13257///
13258/// This routine can only resolve template-ids that refer to a single function
13259/// template, where that template-id refers to a single template whose template
13260/// arguments are either provided by the template-id or have defaults,
13261/// as described in C++0x [temp.arg.explicit]p3.
13262///
13263/// If no template-ids are found, no diagnostics are emitted and NULL is
13264/// returned.
13265FunctionDecl *Sema::ResolveSingleFunctionTemplateSpecialization(
13266    OverloadExpr *ovl, bool Complain, DeclAccessPair *FoundResult,
13267    TemplateSpecCandidateSet *FailedTSC) {
13268  // C++ [over.over]p1:
13269  //   [...] [Note: any redundant set of parentheses surrounding the
13270  //   overloaded function name is ignored (5.1). ]
13271  // C++ [over.over]p1:
13272  //   [...] The overloaded function name can be preceded by the &
13273  //   operator.
13274
13275  // If we didn't actually find any template-ids, we're done.
13276  if (!ovl->hasExplicitTemplateArgs())
13277    return nullptr;
13278
13279  TemplateArgumentListInfo ExplicitTemplateArgs;
13280  ovl->copyTemplateArgumentsInto(ExplicitTemplateArgs);
13281
13282  // Look through all of the overloaded functions, searching for one
13283  // whose type matches exactly.
13284  FunctionDecl *Matched = nullptr;
13285  for (UnresolvedSetIterator I = ovl->decls_begin(),
13286         E = ovl->decls_end(); I != E; ++I) {
13287    // C++0x [temp.arg.explicit]p3:
13288    //   [...] In contexts where deduction is done and fails, or in contexts
13289    //   where deduction is not done, if a template argument list is
13290    //   specified and it, along with any default template arguments,
13291    //   identifies a single function template specialization, then the
13292    //   template-id is an lvalue for the function template specialization.
13293    FunctionTemplateDecl *FunctionTemplate
13294      = cast<FunctionTemplateDecl>((*I)->getUnderlyingDecl());
13295
13296    // C++ [over.over]p2:
13297    //   If the name is a function template, template argument deduction is
13298    //   done (14.8.2.2), and if the argument deduction succeeds, the
13299    //   resulting template argument list is used to generate a single
13300    //   function template specialization, which is added to the set of
13301    //   overloaded functions considered.
13302    FunctionDecl *Specialization = nullptr;
13303    TemplateDeductionInfo Info(ovl->getNameLoc());
13304    if (TemplateDeductionResult Result
13305          = DeduceTemplateArguments(FunctionTemplate, &ExplicitTemplateArgs,
13306                                    Specialization, Info,
13307                                    /*IsAddressOfFunction*/true)) {
13308      // Make a note of the failed deduction for diagnostics.
13309      if (FailedTSC)
13310        FailedTSC->addCandidate().set(
13311            I.getPair(), FunctionTemplate->getTemplatedDecl(),
13312            MakeDeductionFailureInfo(Context, Result, Info));
13313      continue;
13314    }
13315
13316    assert(Specialization && "no specialization and no error?");
13317
13318    // Multiple matches; we can't resolve to a single declaration.
13319    if (Matched) {
13320      if (Complain) {
13321        Diag(ovl->getExprLoc(), diag::err_addr_ovl_ambiguous)
13322          << ovl->getName();
13323        NoteAllOverloadCandidates(ovl);
13324      }
13325      return nullptr;
13326    }
13327
13328    Matched = Specialization;
13329    if (FoundResult) *FoundResult = I.getPair();
13330  }
13331
13332  if (Matched &&
13333      completeFunctionType(*this, Matched, ovl->getExprLoc(), Complain))
13334    return nullptr;
13335
13336  return Matched;
13337}
13338
13339// Resolve and fix an overloaded expression that can be resolved
13340// because it identifies a single function template specialization.
13341//
13342// Last three arguments should only be supplied if Complain = true
13343//
13344// Return true if it was logically possible to so resolve the
13345// expression, regardless of whether or not it succeeded.  Always
13346// returns true if 'complain' is set.
13347bool Sema::ResolveAndFixSingleFunctionTemplateSpecialization(
13348    ExprResult &SrcExpr, bool doFunctionPointerConversion, bool complain,
13349    SourceRange OpRangeForComplaining, QualType DestTypeForComplaining,
13350    unsigned DiagIDForComplaining) {
13351  assert(SrcExpr.get()->getType() == Context.OverloadTy);
13352
13353  OverloadExpr::FindResult ovl = OverloadExpr::find(SrcExpr.get());
13354
13355  DeclAccessPair found;
13356  ExprResult SingleFunctionExpression;
13357  if (FunctionDecl *fn = ResolveSingleFunctionTemplateSpecialization(
13358                           ovl.Expression, /*complain*/ false, &found)) {
13359    if (DiagnoseUseOfDecl(fn, SrcExpr.get()->getBeginLoc())) {
13360      SrcExpr = ExprError();
13361      return true;
13362    }
13363
13364    // It is only correct to resolve to an instance method if we're
13365    // resolving a form that's permitted to be a pointer to member.
13366    // Otherwise we'll end up making a bound member expression, which
13367    // is illegal in all the contexts we resolve like this.
13368    if (!ovl.HasFormOfMemberPointer &&
13369        isa<CXXMethodDecl>(fn) &&
13370        cast<CXXMethodDecl>(fn)->isInstance()) {
13371      if (!complain) return false;
13372
13373      Diag(ovl.Expression->getExprLoc(),
13374           diag::err_bound_member_function)
13375        << 0 << ovl.Expression->getSourceRange();
13376
13377      // TODO: I believe we only end up here if there's a mix of
13378      // static and non-static candidates (otherwise the expression
13379      // would have 'bound member' type, not 'overload' type).
13380      // Ideally we would note which candidate was chosen and why
13381      // the static candidates were rejected.
13382      SrcExpr = ExprError();
13383      return true;
13384    }
13385
13386    // Fix the expression to refer to 'fn'.
13387    SingleFunctionExpression =
13388        FixOverloadedFunctionReference(SrcExpr.get(), found, fn);
13389
13390    // If desired, do function-to-pointer decay.
13391    if (doFunctionPointerConversion) {
13392      SingleFunctionExpression =
13393        DefaultFunctionArrayLvalueConversion(SingleFunctionExpression.get());
13394      if (SingleFunctionExpression.isInvalid()) {
13395        SrcExpr = ExprError();
13396        return true;
13397      }
13398    }
13399  }
13400
13401  if (!SingleFunctionExpression.isUsable()) {
13402    if (complain) {
13403      Diag(OpRangeForComplaining.getBegin(), DiagIDForComplaining)
13404        << ovl.Expression->getName()
13405        << DestTypeForComplaining
13406        << OpRangeForComplaining
13407        << ovl.Expression->getQualifierLoc().getSourceRange();
13408      NoteAllOverloadCandidates(SrcExpr.get());
13409
13410      SrcExpr = ExprError();
13411      return true;
13412    }
13413
13414    return false;
13415  }
13416
13417  SrcExpr = SingleFunctionExpression;
13418  return true;
13419}
13420
13421/// Add a single candidate to the overload set.
13422static void AddOverloadedCallCandidate(Sema &S,
13423                                       DeclAccessPair FoundDecl,
13424                                 TemplateArgumentListInfo *ExplicitTemplateArgs,
13425                                       ArrayRef<Expr *> Args,
13426                                       OverloadCandidateSet &CandidateSet,
13427                                       bool PartialOverloading,
13428                                       bool KnownValid) {
13429  NamedDecl *Callee = FoundDecl.getDecl();
13430  if (isa<UsingShadowDecl>(Callee))
13431    Callee = cast<UsingShadowDecl>(Callee)->getTargetDecl();
13432
13433  if (FunctionDecl *Func = dyn_cast<FunctionDecl>(Callee)) {
13434    if (ExplicitTemplateArgs) {
13435      assert(!KnownValid && "Explicit template arguments?");
13436      return;
13437    }
13438    // Prevent ill-formed function decls to be added as overload candidates.
13439    if (!isa<FunctionProtoType>(Func->getType()->getAs<FunctionType>()))
13440      return;
13441
13442    S.AddOverloadCandidate(Func, FoundDecl, Args, CandidateSet,
13443                           /*SuppressUserConversions=*/false,
13444                           PartialOverloading);
13445    return;
13446  }
13447
13448  if (FunctionTemplateDecl *FuncTemplate
13449      = dyn_cast<FunctionTemplateDecl>(Callee)) {
13450    S.AddTemplateOverloadCandidate(FuncTemplate, FoundDecl,
13451                                   ExplicitTemplateArgs, Args, CandidateSet,
13452                                   /*SuppressUserConversions=*/false,
13453                                   PartialOverloading);
13454    return;
13455  }
13456
13457  assert(!KnownValid && "unhandled case in overloaded call candidate");
13458}
13459
13460/// Add the overload candidates named by callee and/or found by argument
13461/// dependent lookup to the given overload set.
13462void Sema::AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE,
13463                                       ArrayRef<Expr *> Args,
13464                                       OverloadCandidateSet &CandidateSet,
13465                                       bool PartialOverloading) {
13466
13467#ifndef NDEBUG
13468  // Verify that ArgumentDependentLookup is consistent with the rules
13469  // in C++0x [basic.lookup.argdep]p3:
13470  //
13471  //   Let X be the lookup set produced by unqualified lookup (3.4.1)
13472  //   and let Y be the lookup set produced by argument dependent
13473  //   lookup (defined as follows). If X contains
13474  //
13475  //     -- a declaration of a class member, or
13476  //
13477  //     -- a block-scope function declaration that is not a
13478  //        using-declaration, or
13479  //
13480  //     -- a declaration that is neither a function or a function
13481  //        template
13482  //
13483  //   then Y is empty.
13484
13485  if (ULE->requiresADL()) {
13486    for (UnresolvedLookupExpr::decls_iterator I = ULE->decls_begin(),
13487           E = ULE->decls_end(); I != E; ++I) {
13488      assert(!(*I)->getDeclContext()->isRecord());
13489      assert(isa<UsingShadowDecl>(*I) ||
13490             !(*I)->getDeclContext()->isFunctionOrMethod());
13491      assert((*I)->getUnderlyingDecl()->isFunctionOrFunctionTemplate());
13492    }
13493  }
13494#endif
13495
13496  // It would be nice to avoid this copy.
13497  TemplateArgumentListInfo TABuffer;
13498  TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr;
13499  if (ULE->hasExplicitTemplateArgs()) {
13500    ULE->copyTemplateArgumentsInto(TABuffer);
13501    ExplicitTemplateArgs = &TABuffer;
13502  }
13503
13504  for (UnresolvedLookupExpr::decls_iterator I = ULE->decls_begin(),
13505         E = ULE->decls_end(); I != E; ++I)
13506    AddOverloadedCallCandidate(*this, I.getPair(), ExplicitTemplateArgs, Args,
13507                               CandidateSet, PartialOverloading,
13508                               /*KnownValid*/ true);
13509
13510  if (ULE->requiresADL())
13511    AddArgumentDependentLookupCandidates(ULE->getName(), ULE->getExprLoc(),
13512                                         Args, ExplicitTemplateArgs,
13513                                         CandidateSet, PartialOverloading);
13514}
13515
13516/// Add the call candidates from the given set of lookup results to the given
13517/// overload set. Non-function lookup results are ignored.
13518void Sema::AddOverloadedCallCandidates(
13519    LookupResult &R, TemplateArgumentListInfo *ExplicitTemplateArgs,
13520    ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet) {
13521  for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I)
13522    AddOverloadedCallCandidate(*this, I.getPair(), ExplicitTemplateArgs, Args,
13523                               CandidateSet, false, /*KnownValid*/ false);
13524}
13525
13526/// Determine whether a declaration with the specified name could be moved into
13527/// a different namespace.
13528static bool canBeDeclaredInNamespace(const DeclarationName &Name) {
13529  switch (Name.getCXXOverloadedOperator()) {
13530  case OO_New: case OO_Array_New:
13531  case OO_Delete: case OO_Array_Delete:
13532    return false;
13533
13534  default:
13535    return true;
13536  }
13537}
13538
13539/// Attempt to recover from an ill-formed use of a non-dependent name in a
13540/// template, where the non-dependent name was declared after the template
13541/// was defined. This is common in code written for a compilers which do not
13542/// correctly implement two-stage name lookup.
13543///
13544/// Returns true if a viable candidate was found and a diagnostic was issued.
13545static bool DiagnoseTwoPhaseLookup(
13546    Sema &SemaRef, SourceLocation FnLoc, const CXXScopeSpec &SS,
13547    LookupResult &R, OverloadCandidateSet::CandidateSetKind CSK,
13548    TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,
13549    CXXRecordDecl **FoundInClass = nullptr) {
13550  if (!SemaRef.inTemplateInstantiation() || !SS.isEmpty())
13551    return false;
13552
13553  for (DeclContext *DC = SemaRef.CurContext; DC; DC = DC->getParent()) {
13554    if (DC->isTransparentContext())
13555      continue;
13556
13557    SemaRef.LookupQualifiedName(R, DC);
13558
13559    if (!R.empty()) {
13560      R.suppressDiagnostics();
13561
13562      OverloadCandidateSet Candidates(FnLoc, CSK);
13563      SemaRef.AddOverloadedCallCandidates(R, ExplicitTemplateArgs, Args,
13564                                          Candidates);
13565
13566      OverloadCandidateSet::iterator Best;
13567      OverloadingResult OR =
13568          Candidates.BestViableFunction(SemaRef, FnLoc, Best);
13569
13570      if (auto *RD = dyn_cast<CXXRecordDecl>(DC)) {
13571        // We either found non-function declarations or a best viable function
13572        // at class scope. A class-scope lookup result disables ADL. Don't
13573        // look past this, but let the caller know that we found something that
13574        // either is, or might be, usable in this class.
13575        if (FoundInClass) {
13576          *FoundInClass = RD;
13577          if (OR == OR_Success) {
13578            R.clear();
13579            R.addDecl(Best->FoundDecl.getDecl(), Best->FoundDecl.getAccess());
13580            R.resolveKind();
13581          }
13582        }
13583        return false;
13584      }
13585
13586      if (OR != OR_Success) {
13587        // There wasn't a unique best function or function template.
13588        return false;
13589      }
13590
13591      // Find the namespaces where ADL would have looked, and suggest
13592      // declaring the function there instead.
13593      Sema::AssociatedNamespaceSet AssociatedNamespaces;
13594      Sema::AssociatedClassSet AssociatedClasses;
13595      SemaRef.FindAssociatedClassesAndNamespaces(FnLoc, Args,
13596                                                 AssociatedNamespaces,
13597                                                 AssociatedClasses);
13598      Sema::AssociatedNamespaceSet SuggestedNamespaces;
13599      if (canBeDeclaredInNamespace(R.getLookupName())) {
13600        DeclContext *Std = SemaRef.getStdNamespace();
13601        for (Sema::AssociatedNamespaceSet::iterator
13602               it = AssociatedNamespaces.begin(),
13603               end = AssociatedNamespaces.end(); it != end; ++it) {
13604          // Never suggest declaring a function within namespace 'std'.
13605          if (Std && Std->Encloses(*it))
13606            continue;
13607
13608          // Never suggest declaring a function within a namespace with a
13609          // reserved name, like __gnu_cxx.
13610          NamespaceDecl *NS = dyn_cast<NamespaceDecl>(*it);
13611          if (NS &&
13612              NS->getQualifiedNameAsString().find("__") != std::string::npos)
13613            continue;
13614
13615          SuggestedNamespaces.insert(*it);
13616        }
13617      }
13618
13619      SemaRef.Diag(R.getNameLoc(), diag::err_not_found_by_two_phase_lookup)
13620        << R.getLookupName();
13621      if (SuggestedNamespaces.empty()) {
13622        SemaRef.Diag(Best->Function->getLocation(),
13623                     diag::note_not_found_by_two_phase_lookup)
13624          << R.getLookupName() << 0;
13625      } else if (SuggestedNamespaces.size() == 1) {
13626        SemaRef.Diag(Best->Function->getLocation(),
13627                     diag::note_not_found_by_two_phase_lookup)
13628          << R.getLookupName() << 1 << *SuggestedNamespaces.begin();
13629      } else {
13630        // FIXME: It would be useful to list the associated namespaces here,
13631        // but the diagnostics infrastructure doesn't provide a way to produce
13632        // a localized representation of a list of items.
13633        SemaRef.Diag(Best->Function->getLocation(),
13634                     diag::note_not_found_by_two_phase_lookup)
13635          << R.getLookupName() << 2;
13636      }
13637
13638      // Try to recover by calling this function.
13639      return true;
13640    }
13641
13642    R.clear();
13643  }
13644
13645  return false;
13646}
13647
13648/// Attempt to recover from ill-formed use of a non-dependent operator in a
13649/// template, where the non-dependent operator was declared after the template
13650/// was defined.
13651///
13652/// Returns true if a viable candidate was found and a diagnostic was issued.
13653static bool
13654DiagnoseTwoPhaseOperatorLookup(Sema &SemaRef, OverloadedOperatorKind Op,
13655                               SourceLocation OpLoc,
13656                               ArrayRef<Expr *> Args) {
13657  DeclarationName OpName =
13658    SemaRef.Context.DeclarationNames.getCXXOperatorName(Op);
13659  LookupResult R(SemaRef, OpName, OpLoc, Sema::LookupOperatorName);
13660  return DiagnoseTwoPhaseLookup(SemaRef, OpLoc, CXXScopeSpec(), R,
13661                                OverloadCandidateSet::CSK_Operator,
13662                                /*ExplicitTemplateArgs=*/nullptr, Args);
13663}
13664
13665namespace {
13666class BuildRecoveryCallExprRAII {
13667  Sema &SemaRef;
13668  Sema::SatisfactionStackResetRAII SatStack;
13669
13670public:
13671  BuildRecoveryCallExprRAII(Sema &S) : SemaRef(S), SatStack(S) {
13672    assert(SemaRef.IsBuildingRecoveryCallExpr == false);
13673    SemaRef.IsBuildingRecoveryCallExpr = true;
13674  }
13675
13676  ~BuildRecoveryCallExprRAII() { SemaRef.IsBuildingRecoveryCallExpr = false; }
13677};
13678}
13679
13680/// Attempts to recover from a call where no functions were found.
13681///
13682/// This function will do one of three things:
13683///  * Diagnose, recover, and return a recovery expression.
13684///  * Diagnose, fail to recover, and return ExprError().
13685///  * Do not diagnose, do not recover, and return ExprResult(). The caller is
13686///    expected to diagnose as appropriate.
13687static ExprResult
13688BuildRecoveryCallExpr(Sema &SemaRef, Scope *S, Expr *Fn,
13689                      UnresolvedLookupExpr *ULE,
13690                      SourceLocation LParenLoc,
13691                      MutableArrayRef<Expr *> Args,
13692                      SourceLocation RParenLoc,
13693                      bool EmptyLookup, bool AllowTypoCorrection) {
13694  // Do not try to recover if it is already building a recovery call.
13695  // This stops infinite loops for template instantiations like
13696  //
13697  // template <typename T> auto foo(T t) -> decltype(foo(t)) {}
13698  // template <typename T> auto foo(T t) -> decltype(foo(&t)) {}
13699  if (SemaRef.IsBuildingRecoveryCallExpr)
13700    return ExprResult();
13701  BuildRecoveryCallExprRAII RCE(SemaRef);
13702
13703  CXXScopeSpec SS;
13704  SS.Adopt(ULE->getQualifierLoc());
13705  SourceLocation TemplateKWLoc = ULE->getTemplateKeywordLoc();
13706
13707  TemplateArgumentListInfo TABuffer;
13708  TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr;
13709  if (ULE->hasExplicitTemplateArgs()) {
13710    ULE->copyTemplateArgumentsInto(TABuffer);
13711    ExplicitTemplateArgs = &TABuffer;
13712  }
13713
13714  LookupResult R(SemaRef, ULE->getName(), ULE->getNameLoc(),
13715                 Sema::LookupOrdinaryName);
13716  CXXRecordDecl *FoundInClass = nullptr;
13717  if (DiagnoseTwoPhaseLookup(SemaRef, Fn->getExprLoc(), SS, R,
13718                             OverloadCandidateSet::CSK_Normal,
13719                             ExplicitTemplateArgs, Args, &FoundInClass)) {
13720    // OK, diagnosed a two-phase lookup issue.
13721  } else if (EmptyLookup) {
13722    // Try to recover from an empty lookup with typo correction.
13723    R.clear();
13724    NoTypoCorrectionCCC NoTypoValidator{};
13725    FunctionCallFilterCCC FunctionCallValidator(SemaRef, Args.size(),
13726                                                ExplicitTemplateArgs != nullptr,
13727                                                dyn_cast<MemberExpr>(Fn));
13728    CorrectionCandidateCallback &Validator =
13729        AllowTypoCorrection
13730            ? static_cast<CorrectionCandidateCallback &>(FunctionCallValidator)
13731            : static_cast<CorrectionCandidateCallback &>(NoTypoValidator);
13732    if (SemaRef.DiagnoseEmptyLookup(S, SS, R, Validator, ExplicitTemplateArgs,
13733                                    Args))
13734      return ExprError();
13735  } else if (FoundInClass && SemaRef.getLangOpts().MSVCCompat) {
13736    // We found a usable declaration of the name in a dependent base of some
13737    // enclosing class.
13738    // FIXME: We should also explain why the candidates found by name lookup
13739    // were not viable.
13740    if (SemaRef.DiagnoseDependentMemberLookup(R))
13741      return ExprError();
13742  } else {
13743    // We had viable candidates and couldn't recover; let the caller diagnose
13744    // this.
13745    return ExprResult();
13746  }
13747
13748  // If we get here, we should have issued a diagnostic and formed a recovery
13749  // lookup result.
13750  assert(!R.empty() && "lookup results empty despite recovery");
13751
13752  // If recovery created an ambiguity, just bail out.
13753  if (R.isAmbiguous()) {
13754    R.suppressDiagnostics();
13755    return ExprError();
13756  }
13757
13758  // Build an implicit member call if appropriate.  Just drop the
13759  // casts and such from the call, we don't really care.
13760  ExprResult NewFn = ExprError();
13761  if ((*R.begin())->isCXXClassMember())
13762    NewFn = SemaRef.BuildPossibleImplicitMemberExpr(SS, TemplateKWLoc, R,
13763                                                    ExplicitTemplateArgs, S);
13764  else if (ExplicitTemplateArgs || TemplateKWLoc.isValid())
13765    NewFn = SemaRef.BuildTemplateIdExpr(SS, TemplateKWLoc, R, false,
13766                                        ExplicitTemplateArgs);
13767  else
13768    NewFn = SemaRef.BuildDeclarationNameExpr(SS, R, false);
13769
13770  if (NewFn.isInvalid())
13771    return ExprError();
13772
13773  // This shouldn't cause an infinite loop because we're giving it
13774  // an expression with viable lookup results, which should never
13775  // end up here.
13776  return SemaRef.BuildCallExpr(/*Scope*/ nullptr, NewFn.get(), LParenLoc,
13777                               MultiExprArg(Args.data(), Args.size()),
13778                               RParenLoc);
13779}
13780
13781/// Constructs and populates an OverloadedCandidateSet from
13782/// the given function.
13783/// \returns true when an the ExprResult output parameter has been set.
13784bool Sema::buildOverloadedCallSet(Scope *S, Expr *Fn,
13785                                  UnresolvedLookupExpr *ULE,
13786                                  MultiExprArg Args,
13787                                  SourceLocation RParenLoc,
13788                                  OverloadCandidateSet *CandidateSet,
13789                                  ExprResult *Result) {
13790#ifndef NDEBUG
13791  if (ULE->requiresADL()) {
13792    // To do ADL, we must have found an unqualified name.
13793    assert(!ULE->getQualifier() && "qualified name with ADL");
13794
13795    // We don't perform ADL for implicit declarations of builtins.
13796    // Verify that this was correctly set up.
13797    FunctionDecl *F;
13798    if (ULE->decls_begin() != ULE->decls_end() &&
13799        ULE->decls_begin() + 1 == ULE->decls_end() &&
13800        (F = dyn_cast<FunctionDecl>(*ULE->decls_begin())) &&
13801        F->getBuiltinID() && F->isImplicit())
13802      llvm_unreachable("performing ADL for builtin");
13803
13804    // We don't perform ADL in C.
13805    assert(getLangOpts().CPlusPlus && "ADL enabled in C");
13806  }
13807#endif
13808
13809  UnbridgedCastsSet UnbridgedCasts;
13810  if (checkArgPlaceholdersForOverload(*this, Args, UnbridgedCasts)) {
13811    *Result = ExprError();
13812    return true;
13813  }
13814
13815  // Add the functions denoted by the callee to the set of candidate
13816  // functions, including those from argument-dependent lookup.
13817  AddOverloadedCallCandidates(ULE, Args, *CandidateSet);
13818
13819  if (getLangOpts().MSVCCompat &&
13820      CurContext->isDependentContext() && !isSFINAEContext() &&
13821      (isa<FunctionDecl>(CurContext) || isa<CXXRecordDecl>(CurContext))) {
13822
13823    OverloadCandidateSet::iterator Best;
13824    if (CandidateSet->empty() ||
13825        CandidateSet->BestViableFunction(*this, Fn->getBeginLoc(), Best) ==
13826            OR_No_Viable_Function) {
13827      // In Microsoft mode, if we are inside a template class member function
13828      // then create a type dependent CallExpr. The goal is to postpone name
13829      // lookup to instantiation time to be able to search into type dependent
13830      // base classes.
13831      CallExpr *CE =
13832          CallExpr::Create(Context, Fn, Args, Context.DependentTy, VK_PRValue,
13833                           RParenLoc, CurFPFeatureOverrides());
13834      CE->markDependentForPostponedNameLookup();
13835      *Result = CE;
13836      return true;
13837    }
13838  }
13839
13840  if (CandidateSet->empty())
13841    return false;
13842
13843  UnbridgedCasts.restore();
13844  return false;
13845}
13846
13847// Guess at what the return type for an unresolvable overload should be.
13848static QualType chooseRecoveryType(OverloadCandidateSet &CS,
13849                                   OverloadCandidateSet::iterator *Best) {
13850  std::optional<QualType> Result;
13851  // Adjust Type after seeing a candidate.
13852  auto ConsiderCandidate = [&](const OverloadCandidate &Candidate) {
13853    if (!Candidate.Function)
13854      return;
13855    if (Candidate.Function->isInvalidDecl())
13856      return;
13857    QualType T = Candidate.Function->getReturnType();
13858    if (T.isNull())
13859      return;
13860    if (!Result)
13861      Result = T;
13862    else if (Result != T)
13863      Result = QualType();
13864  };
13865
13866  // Look for an unambiguous type from a progressively larger subset.
13867  // e.g. if types disagree, but all *viable* overloads return int, choose int.
13868  //
13869  // First, consider only the best candidate.
13870  if (Best && *Best != CS.end())
13871    ConsiderCandidate(**Best);
13872  // Next, consider only viable candidates.
13873  if (!Result)
13874    for (const auto &C : CS)
13875      if (C.Viable)
13876        ConsiderCandidate(C);
13877  // Finally, consider all candidates.
13878  if (!Result)
13879    for (const auto &C : CS)
13880      ConsiderCandidate(C);
13881
13882  if (!Result)
13883    return QualType();
13884  auto Value = *Result;
13885  if (Value.isNull() || Value->isUndeducedType())
13886    return QualType();
13887  return Value;
13888}
13889
13890/// FinishOverloadedCallExpr - given an OverloadCandidateSet, builds and returns
13891/// the completed call expression. If overload resolution fails, emits
13892/// diagnostics and returns ExprError()
13893static ExprResult FinishOverloadedCallExpr(Sema &SemaRef, Scope *S, Expr *Fn,
13894                                           UnresolvedLookupExpr *ULE,
13895                                           SourceLocation LParenLoc,
13896                                           MultiExprArg Args,
13897                                           SourceLocation RParenLoc,
13898                                           Expr *ExecConfig,
13899                                           OverloadCandidateSet *CandidateSet,
13900                                           OverloadCandidateSet::iterator *Best,
13901                                           OverloadingResult OverloadResult,
13902                                           bool AllowTypoCorrection) {
13903  switch (OverloadResult) {
13904  case OR_Success: {
13905    FunctionDecl *FDecl = (*Best)->Function;
13906    SemaRef.CheckUnresolvedLookupAccess(ULE, (*Best)->FoundDecl);
13907    if (SemaRef.DiagnoseUseOfDecl(FDecl, ULE->getNameLoc()))
13908      return ExprError();
13909    ExprResult Res =
13910        SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl);
13911    if (Res.isInvalid())
13912      return ExprError();
13913    return SemaRef.BuildResolvedCallExpr(
13914        Res.get(), FDecl, LParenLoc, Args, RParenLoc, ExecConfig,
13915        /*IsExecConfig=*/false, (*Best)->IsADLCandidate);
13916  }
13917
13918  case OR_No_Viable_Function: {
13919    // Try to recover by looking for viable functions which the user might
13920    // have meant to call.
13921    ExprResult Recovery = BuildRecoveryCallExpr(SemaRef, S, Fn, ULE, LParenLoc,
13922                                                Args, RParenLoc,
13923                                                CandidateSet->empty(),
13924                                                AllowTypoCorrection);
13925    if (Recovery.isInvalid() || Recovery.isUsable())
13926      return Recovery;
13927
13928    // If the user passes in a function that we can't take the address of, we
13929    // generally end up emitting really bad error messages. Here, we attempt to
13930    // emit better ones.
13931    for (const Expr *Arg : Args) {
13932      if (!Arg->getType()->isFunctionType())
13933        continue;
13934      if (auto *DRE = dyn_cast<DeclRefExpr>(Arg->IgnoreParenImpCasts())) {
13935        auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl());
13936        if (FD &&
13937            !SemaRef.checkAddressOfFunctionIsAvailable(FD, /*Complain=*/true,
13938                                                       Arg->getExprLoc()))
13939          return ExprError();
13940      }
13941    }
13942
13943    CandidateSet->NoteCandidates(
13944        PartialDiagnosticAt(
13945            Fn->getBeginLoc(),
13946            SemaRef.PDiag(diag::err_ovl_no_viable_function_in_call)
13947                << ULE->getName() << Fn->getSourceRange()),
13948        SemaRef, OCD_AllCandidates, Args);
13949    break;
13950  }
13951
13952  case OR_Ambiguous:
13953    CandidateSet->NoteCandidates(
13954        PartialDiagnosticAt(Fn->getBeginLoc(),
13955                            SemaRef.PDiag(diag::err_ovl_ambiguous_call)
13956                                << ULE->getName() << Fn->getSourceRange()),
13957        SemaRef, OCD_AmbiguousCandidates, Args);
13958    break;
13959
13960  case OR_Deleted: {
13961    CandidateSet->NoteCandidates(
13962        PartialDiagnosticAt(Fn->getBeginLoc(),
13963                            SemaRef.PDiag(diag::err_ovl_deleted_call)
13964                                << ULE->getName() << Fn->getSourceRange()),
13965        SemaRef, OCD_AllCandidates, Args);
13966
13967    // We emitted an error for the unavailable/deleted function call but keep
13968    // the call in the AST.
13969    FunctionDecl *FDecl = (*Best)->Function;
13970    ExprResult Res =
13971        SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl);
13972    if (Res.isInvalid())
13973      return ExprError();
13974    return SemaRef.BuildResolvedCallExpr(
13975        Res.get(), FDecl, LParenLoc, Args, RParenLoc, ExecConfig,
13976        /*IsExecConfig=*/false, (*Best)->IsADLCandidate);
13977  }
13978  }
13979
13980  // Overload resolution failed, try to recover.
13981  SmallVector<Expr *, 8> SubExprs = {Fn};
13982  SubExprs.append(Args.begin(), Args.end());
13983  return SemaRef.CreateRecoveryExpr(Fn->getBeginLoc(), RParenLoc, SubExprs,
13984                                    chooseRecoveryType(*CandidateSet, Best));
13985}
13986
13987static void markUnaddressableCandidatesUnviable(Sema &S,
13988                                                OverloadCandidateSet &CS) {
13989  for (auto I = CS.begin(), E = CS.end(); I != E; ++I) {
13990    if (I->Viable &&
13991        !S.checkAddressOfFunctionIsAvailable(I->Function, /*Complain=*/false)) {
13992      I->Viable = false;
13993      I->FailureKind = ovl_fail_addr_not_available;
13994    }
13995  }
13996}
13997
13998/// BuildOverloadedCallExpr - Given the call expression that calls Fn
13999/// (which eventually refers to the declaration Func) and the call
14000/// arguments Args/NumArgs, attempt to resolve the function call down
14001/// to a specific function. If overload resolution succeeds, returns
14002/// the call expression produced by overload resolution.
14003/// Otherwise, emits diagnostics and returns ExprError.
14004ExprResult Sema::BuildOverloadedCallExpr(Scope *S, Expr *Fn,
14005                                         UnresolvedLookupExpr *ULE,
14006                                         SourceLocation LParenLoc,
14007                                         MultiExprArg Args,
14008                                         SourceLocation RParenLoc,
14009                                         Expr *ExecConfig,
14010                                         bool AllowTypoCorrection,
14011                                         bool CalleesAddressIsTaken) {
14012  OverloadCandidateSet CandidateSet(Fn->getExprLoc(),
14013                                    OverloadCandidateSet::CSK_Normal);
14014  ExprResult result;
14015
14016  if (buildOverloadedCallSet(S, Fn, ULE, Args, LParenLoc, &CandidateSet,
14017                             &result))
14018    return result;
14019
14020  // If the user handed us something like `(&Foo)(Bar)`, we need to ensure that
14021  // functions that aren't addressible are considered unviable.
14022  if (CalleesAddressIsTaken)
14023    markUnaddressableCandidatesUnviable(*this, CandidateSet);
14024
14025  OverloadCandidateSet::iterator Best;
14026  OverloadingResult OverloadResult =
14027      CandidateSet.BestViableFunction(*this, Fn->getBeginLoc(), Best);
14028
14029  // Model the case with a call to a templated function whose definition
14030  // encloses the call and whose return type contains a placeholder type as if
14031  // the UnresolvedLookupExpr was type-dependent.
14032  if (OverloadResult == OR_Success) {
14033    const FunctionDecl *FDecl = Best->Function;
14034    if (FDecl && FDecl->isTemplateInstantiation() &&
14035        FDecl->getReturnType()->isUndeducedType()) {
14036      if (const auto *TP =
14037              FDecl->getTemplateInstantiationPattern(/*ForDefinition=*/false);
14038          TP && TP->willHaveBody()) {
14039        return CallExpr::Create(Context, Fn, Args, Context.DependentTy,
14040                                VK_PRValue, RParenLoc, CurFPFeatureOverrides());
14041      }
14042    }
14043  }
14044
14045  return FinishOverloadedCallExpr(*this, S, Fn, ULE, LParenLoc, Args, RParenLoc,
14046                                  ExecConfig, &CandidateSet, &Best,
14047                                  OverloadResult, AllowTypoCorrection);
14048}
14049
14050static bool IsOverloaded(const UnresolvedSetImpl &Functions) {
14051  return Functions.size() > 1 ||
14052         (Functions.size() == 1 &&
14053          isa<FunctionTemplateDecl>((*Functions.begin())->getUnderlyingDecl()));
14054}
14055
14056ExprResult Sema::CreateUnresolvedLookupExpr(CXXRecordDecl *NamingClass,
14057                                            NestedNameSpecifierLoc NNSLoc,
14058                                            DeclarationNameInfo DNI,
14059                                            const UnresolvedSetImpl &Fns,
14060                                            bool PerformADL) {
14061  return UnresolvedLookupExpr::Create(Context, NamingClass, NNSLoc, DNI,
14062                                      PerformADL, IsOverloaded(Fns),
14063                                      Fns.begin(), Fns.end());
14064}
14065
14066ExprResult Sema::BuildCXXMemberCallExpr(Expr *E, NamedDecl *FoundDecl,
14067                                        CXXConversionDecl *Method,
14068                                        bool HadMultipleCandidates) {
14069  // Convert the expression to match the conversion function's implicit object
14070  // parameter.
14071  ExprResult Exp;
14072  if (Method->isExplicitObjectMemberFunction())
14073    Exp = InitializeExplicitObjectArgument(*this, E, Method);
14074  else
14075    Exp = PerformImplicitObjectArgumentInitialization(E, /*Qualifier=*/nullptr,
14076                                                      FoundDecl, Method);
14077  if (Exp.isInvalid())
14078    return true;
14079
14080  if (Method->getParent()->isLambda() &&
14081      Method->getConversionType()->isBlockPointerType()) {
14082    // This is a lambda conversion to block pointer; check if the argument
14083    // was a LambdaExpr.
14084    Expr *SubE = E;
14085    auto *CE = dyn_cast<CastExpr>(SubE);
14086    if (CE && CE->getCastKind() == CK_NoOp)
14087      SubE = CE->getSubExpr();
14088    SubE = SubE->IgnoreParens();
14089    if (auto *BE = dyn_cast<CXXBindTemporaryExpr>(SubE))
14090      SubE = BE->getSubExpr();
14091    if (isa<LambdaExpr>(SubE)) {
14092      // For the conversion to block pointer on a lambda expression, we
14093      // construct a special BlockLiteral instead; this doesn't really make
14094      // a difference in ARC, but outside of ARC the resulting block literal
14095      // follows the normal lifetime rules for block literals instead of being
14096      // autoreleased.
14097      PushExpressionEvaluationContext(
14098          ExpressionEvaluationContext::PotentiallyEvaluated);
14099      ExprResult BlockExp = BuildBlockForLambdaConversion(
14100          Exp.get()->getExprLoc(), Exp.get()->getExprLoc(), Method, Exp.get());
14101      PopExpressionEvaluationContext();
14102
14103      // FIXME: This note should be produced by a CodeSynthesisContext.
14104      if (BlockExp.isInvalid())
14105        Diag(Exp.get()->getExprLoc(), diag::note_lambda_to_block_conv);
14106      return BlockExp;
14107    }
14108  }
14109  CallExpr *CE;
14110  QualType ResultType = Method->getReturnType();
14111  ExprValueKind VK = Expr::getValueKindForType(ResultType);
14112  ResultType = ResultType.getNonLValueExprType(Context);
14113  if (Method->isExplicitObjectMemberFunction()) {
14114    ExprResult FnExpr =
14115        CreateFunctionRefExpr(*this, Method, FoundDecl, Exp.get(),
14116                              HadMultipleCandidates, E->getBeginLoc());
14117    if (FnExpr.isInvalid())
14118      return ExprError();
14119    Expr *ObjectParam = Exp.get();
14120    CE = CallExpr::Create(Context, FnExpr.get(), MultiExprArg(&ObjectParam, 1),
14121                          ResultType, VK, Exp.get()->getEndLoc(),
14122                          CurFPFeatureOverrides());
14123  } else {
14124    MemberExpr *ME =
14125        BuildMemberExpr(Exp.get(), /*IsArrow=*/false, SourceLocation(),
14126                        NestedNameSpecifierLoc(), SourceLocation(), Method,
14127                        DeclAccessPair::make(FoundDecl, FoundDecl->getAccess()),
14128                        HadMultipleCandidates, DeclarationNameInfo(),
14129                        Context.BoundMemberTy, VK_PRValue, OK_Ordinary);
14130
14131    CE = CXXMemberCallExpr::Create(Context, ME, /*Args=*/{}, ResultType, VK,
14132                                   Exp.get()->getEndLoc(),
14133                                   CurFPFeatureOverrides());
14134  }
14135
14136  if (CheckFunctionCall(Method, CE,
14137                        Method->getType()->castAs<FunctionProtoType>()))
14138    return ExprError();
14139
14140  return CheckForImmediateInvocation(CE, CE->getDirectCallee());
14141}
14142
14143/// Create a unary operation that may resolve to an overloaded
14144/// operator.
14145///
14146/// \param OpLoc The location of the operator itself (e.g., '*').
14147///
14148/// \param Opc The UnaryOperatorKind that describes this operator.
14149///
14150/// \param Fns The set of non-member functions that will be
14151/// considered by overload resolution. The caller needs to build this
14152/// set based on the context using, e.g.,
14153/// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This
14154/// set should not contain any member functions; those will be added
14155/// by CreateOverloadedUnaryOp().
14156///
14157/// \param Input The input argument.
14158ExprResult
14159Sema::CreateOverloadedUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc,
14160                              const UnresolvedSetImpl &Fns,
14161                              Expr *Input, bool PerformADL) {
14162  OverloadedOperatorKind Op = UnaryOperator::getOverloadedOperator(Opc);
14163  assert(Op != OO_None && "Invalid opcode for overloaded unary operator");
14164  DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op);
14165  // TODO: provide better source location info.
14166  DeclarationNameInfo OpNameInfo(OpName, OpLoc);
14167
14168  if (checkPlaceholderForOverload(*this, Input))
14169    return ExprError();
14170
14171  Expr *Args[2] = { Input, nullptr };
14172  unsigned NumArgs = 1;
14173
14174  // For post-increment and post-decrement, add the implicit '0' as
14175  // the second argument, so that we know this is a post-increment or
14176  // post-decrement.
14177  if (Opc == UO_PostInc || Opc == UO_PostDec) {
14178    llvm::APSInt Zero(Context.getTypeSize(Context.IntTy), false);
14179    Args[1] = IntegerLiteral::Create(Context, Zero, Context.IntTy,
14180                                     SourceLocation());
14181    NumArgs = 2;
14182  }
14183
14184  ArrayRef<Expr *> ArgsArray(Args, NumArgs);
14185
14186  if (Input->isTypeDependent()) {
14187    if (Fns.empty())
14188      return UnaryOperator::Create(Context, Input, Opc, Context.DependentTy,
14189                                   VK_PRValue, OK_Ordinary, OpLoc, false,
14190                                   CurFPFeatureOverrides());
14191
14192    CXXRecordDecl *NamingClass = nullptr; // lookup ignores member operators
14193    ExprResult Fn = CreateUnresolvedLookupExpr(
14194        NamingClass, NestedNameSpecifierLoc(), OpNameInfo, Fns);
14195    if (Fn.isInvalid())
14196      return ExprError();
14197    return CXXOperatorCallExpr::Create(Context, Op, Fn.get(), ArgsArray,
14198                                       Context.DependentTy, VK_PRValue, OpLoc,
14199                                       CurFPFeatureOverrides());
14200  }
14201
14202  // Build an empty overload set.
14203  OverloadCandidateSet CandidateSet(OpLoc, OverloadCandidateSet::CSK_Operator);
14204
14205  // Add the candidates from the given function set.
14206  AddNonMemberOperatorCandidates(Fns, ArgsArray, CandidateSet);
14207
14208  // Add operator candidates that are member functions.
14209  AddMemberOperatorCandidates(Op, OpLoc, ArgsArray, CandidateSet);
14210
14211  // Add candidates from ADL.
14212  if (PerformADL) {
14213    AddArgumentDependentLookupCandidates(OpName, OpLoc, ArgsArray,
14214                                         /*ExplicitTemplateArgs*/nullptr,
14215                                         CandidateSet);
14216  }
14217
14218  // Add builtin operator candidates.
14219  AddBuiltinOperatorCandidates(Op, OpLoc, ArgsArray, CandidateSet);
14220
14221  bool HadMultipleCandidates = (CandidateSet.size() > 1);
14222
14223  // Perform overload resolution.
14224  OverloadCandidateSet::iterator Best;
14225  switch (CandidateSet.BestViableFunction(*this, OpLoc, Best)) {
14226  case OR_Success: {
14227    // We found a built-in operator or an overloaded operator.
14228    FunctionDecl *FnDecl = Best->Function;
14229
14230    if (FnDecl) {
14231      Expr *Base = nullptr;
14232      // We matched an overloaded operator. Build a call to that
14233      // operator.
14234
14235      // Convert the arguments.
14236      if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) {
14237        CheckMemberOperatorAccess(OpLoc, Input, nullptr, Best->FoundDecl);
14238
14239        ExprResult InputInit;
14240        if (Method->isExplicitObjectMemberFunction())
14241          InputInit = InitializeExplicitObjectArgument(*this, Input, Method);
14242        else
14243          InputInit = PerformImplicitObjectArgumentInitialization(
14244              Input, /*Qualifier=*/nullptr, Best->FoundDecl, Method);
14245        if (InputInit.isInvalid())
14246          return ExprError();
14247        Base = Input = InputInit.get();
14248      } else {
14249        // Convert the arguments.
14250        ExprResult InputInit
14251          = PerformCopyInitialization(InitializedEntity::InitializeParameter(
14252                                                      Context,
14253                                                      FnDecl->getParamDecl(0)),
14254                                      SourceLocation(),
14255                                      Input);
14256        if (InputInit.isInvalid())
14257          return ExprError();
14258        Input = InputInit.get();
14259      }
14260
14261      // Build the actual expression node.
14262      ExprResult FnExpr = CreateFunctionRefExpr(*this, FnDecl, Best->FoundDecl,
14263                                                Base, HadMultipleCandidates,
14264                                                OpLoc);
14265      if (FnExpr.isInvalid())
14266        return ExprError();
14267
14268      // Determine the result type.
14269      QualType ResultTy = FnDecl->getReturnType();
14270      ExprValueKind VK = Expr::getValueKindForType(ResultTy);
14271      ResultTy = ResultTy.getNonLValueExprType(Context);
14272
14273      Args[0] = Input;
14274      CallExpr *TheCall = CXXOperatorCallExpr::Create(
14275          Context, Op, FnExpr.get(), ArgsArray, ResultTy, VK, OpLoc,
14276          CurFPFeatureOverrides(), Best->IsADLCandidate);
14277
14278      if (CheckCallReturnType(FnDecl->getReturnType(), OpLoc, TheCall, FnDecl))
14279        return ExprError();
14280
14281      if (CheckFunctionCall(FnDecl, TheCall,
14282                            FnDecl->getType()->castAs<FunctionProtoType>()))
14283        return ExprError();
14284      return CheckForImmediateInvocation(MaybeBindToTemporary(TheCall), FnDecl);
14285    } else {
14286      // We matched a built-in operator. Convert the arguments, then
14287      // break out so that we will build the appropriate built-in
14288      // operator node.
14289      ExprResult InputRes = PerformImplicitConversion(
14290          Input, Best->BuiltinParamTypes[0], Best->Conversions[0], AA_Passing,
14291          CCK_ForBuiltinOverloadedOp);
14292      if (InputRes.isInvalid())
14293        return ExprError();
14294      Input = InputRes.get();
14295      break;
14296    }
14297  }
14298
14299  case OR_No_Viable_Function:
14300    // This is an erroneous use of an operator which can be overloaded by
14301    // a non-member function. Check for non-member operators which were
14302    // defined too late to be candidates.
14303    if (DiagnoseTwoPhaseOperatorLookup(*this, Op, OpLoc, ArgsArray))
14304      // FIXME: Recover by calling the found function.
14305      return ExprError();
14306
14307    // No viable function; fall through to handling this as a
14308    // built-in operator, which will produce an error message for us.
14309    break;
14310
14311  case OR_Ambiguous:
14312    CandidateSet.NoteCandidates(
14313        PartialDiagnosticAt(OpLoc,
14314                            PDiag(diag::err_ovl_ambiguous_oper_unary)
14315                                << UnaryOperator::getOpcodeStr(Opc)
14316                                << Input->getType() << Input->getSourceRange()),
14317        *this, OCD_AmbiguousCandidates, ArgsArray,
14318        UnaryOperator::getOpcodeStr(Opc), OpLoc);
14319    return ExprError();
14320
14321  case OR_Deleted:
14322    // CreateOverloadedUnaryOp fills the first element of ArgsArray with the
14323    // object whose method was called. Later in NoteCandidates size of ArgsArray
14324    // is passed further and it eventually ends up compared to number of
14325    // function candidate parameters which never includes the object parameter,
14326    // so slice ArgsArray to make sure apples are compared to apples.
14327    CandidateSet.NoteCandidates(
14328        PartialDiagnosticAt(OpLoc, PDiag(diag::err_ovl_deleted_oper)
14329                                       << UnaryOperator::getOpcodeStr(Opc)
14330                                       << Input->getSourceRange()),
14331        *this, OCD_AllCandidates, ArgsArray.drop_front(),
14332        UnaryOperator::getOpcodeStr(Opc), OpLoc);
14333    return ExprError();
14334  }
14335
14336  // Either we found no viable overloaded operator or we matched a
14337  // built-in operator. In either case, fall through to trying to
14338  // build a built-in operation.
14339  return CreateBuiltinUnaryOp(OpLoc, Opc, Input);
14340}
14341
14342/// Perform lookup for an overloaded binary operator.
14343void Sema::LookupOverloadedBinOp(OverloadCandidateSet &CandidateSet,
14344                                 OverloadedOperatorKind Op,
14345                                 const UnresolvedSetImpl &Fns,
14346                                 ArrayRef<Expr *> Args, bool PerformADL) {
14347  SourceLocation OpLoc = CandidateSet.getLocation();
14348
14349  OverloadedOperatorKind ExtraOp =
14350      CandidateSet.getRewriteInfo().AllowRewrittenCandidates
14351          ? getRewrittenOverloadedOperator(Op)
14352          : OO_None;
14353
14354  // Add the candidates from the given function set. This also adds the
14355  // rewritten candidates using these functions if necessary.
14356  AddNonMemberOperatorCandidates(Fns, Args, CandidateSet);
14357
14358  // Add operator candidates that are member functions.
14359  AddMemberOperatorCandidates(Op, OpLoc, Args, CandidateSet);
14360  if (CandidateSet.getRewriteInfo().allowsReversed(Op))
14361    AddMemberOperatorCandidates(Op, OpLoc, {Args[1], Args[0]}, CandidateSet,
14362                                OverloadCandidateParamOrder::Reversed);
14363
14364  // In C++20, also add any rewritten member candidates.
14365  if (ExtraOp) {
14366    AddMemberOperatorCandidates(ExtraOp, OpLoc, Args, CandidateSet);
14367    if (CandidateSet.getRewriteInfo().allowsReversed(ExtraOp))
14368      AddMemberOperatorCandidates(ExtraOp, OpLoc, {Args[1], Args[0]},
14369                                  CandidateSet,
14370                                  OverloadCandidateParamOrder::Reversed);
14371  }
14372
14373  // Add candidates from ADL. Per [over.match.oper]p2, this lookup is not
14374  // performed for an assignment operator (nor for operator[] nor operator->,
14375  // which don't get here).
14376  if (Op != OO_Equal && PerformADL) {
14377    DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op);
14378    AddArgumentDependentLookupCandidates(OpName, OpLoc, Args,
14379                                         /*ExplicitTemplateArgs*/ nullptr,
14380                                         CandidateSet);
14381    if (ExtraOp) {
14382      DeclarationName ExtraOpName =
14383          Context.DeclarationNames.getCXXOperatorName(ExtraOp);
14384      AddArgumentDependentLookupCandidates(ExtraOpName, OpLoc, Args,
14385                                           /*ExplicitTemplateArgs*/ nullptr,
14386                                           CandidateSet);
14387    }
14388  }
14389
14390  // Add builtin operator candidates.
14391  //
14392  // FIXME: We don't add any rewritten candidates here. This is strictly
14393  // incorrect; a builtin candidate could be hidden by a non-viable candidate,
14394  // resulting in our selecting a rewritten builtin candidate. For example:
14395  //
14396  //   enum class E { e };
14397  //   bool operator!=(E, E) requires false;
14398  //   bool k = E::e != E::e;
14399  //
14400  // ... should select the rewritten builtin candidate 'operator==(E, E)'. But
14401  // it seems unreasonable to consider rewritten builtin candidates. A core
14402  // issue has been filed proposing to removed this requirement.
14403  AddBuiltinOperatorCandidates(Op, OpLoc, Args, CandidateSet);
14404}
14405
14406/// Create a binary operation that may resolve to an overloaded
14407/// operator.
14408///
14409/// \param OpLoc The location of the operator itself (e.g., '+').
14410///
14411/// \param Opc The BinaryOperatorKind that describes this operator.
14412///
14413/// \param Fns The set of non-member functions that will be
14414/// considered by overload resolution. The caller needs to build this
14415/// set based on the context using, e.g.,
14416/// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This
14417/// set should not contain any member functions; those will be added
14418/// by CreateOverloadedBinOp().
14419///
14420/// \param LHS Left-hand argument.
14421/// \param RHS Right-hand argument.
14422/// \param PerformADL Whether to consider operator candidates found by ADL.
14423/// \param AllowRewrittenCandidates Whether to consider candidates found by
14424///        C++20 operator rewrites.
14425/// \param DefaultedFn If we are synthesizing a defaulted operator function,
14426///        the function in question. Such a function is never a candidate in
14427///        our overload resolution. This also enables synthesizing a three-way
14428///        comparison from < and == as described in C++20 [class.spaceship]p1.
14429ExprResult Sema::CreateOverloadedBinOp(SourceLocation OpLoc,
14430                                       BinaryOperatorKind Opc,
14431                                       const UnresolvedSetImpl &Fns, Expr *LHS,
14432                                       Expr *RHS, bool PerformADL,
14433                                       bool AllowRewrittenCandidates,
14434                                       FunctionDecl *DefaultedFn) {
14435  Expr *Args[2] = { LHS, RHS };
14436  LHS=RHS=nullptr; // Please use only Args instead of LHS/RHS couple
14437
14438  if (!getLangOpts().CPlusPlus20)
14439    AllowRewrittenCandidates = false;
14440
14441  OverloadedOperatorKind Op = BinaryOperator::getOverloadedOperator(Opc);
14442
14443  // If either side is type-dependent, create an appropriate dependent
14444  // expression.
14445  if (Args[0]->isTypeDependent() || Args[1]->isTypeDependent()) {
14446    if (Fns.empty()) {
14447      // If there are no functions to store, just build a dependent
14448      // BinaryOperator or CompoundAssignment.
14449      if (BinaryOperator::isCompoundAssignmentOp(Opc))
14450        return CompoundAssignOperator::Create(
14451            Context, Args[0], Args[1], Opc, Context.DependentTy, VK_LValue,
14452            OK_Ordinary, OpLoc, CurFPFeatureOverrides(), Context.DependentTy,
14453            Context.DependentTy);
14454      return BinaryOperator::Create(
14455          Context, Args[0], Args[1], Opc, Context.DependentTy, VK_PRValue,
14456          OK_Ordinary, OpLoc, CurFPFeatureOverrides());
14457    }
14458
14459    // FIXME: save results of ADL from here?
14460    CXXRecordDecl *NamingClass = nullptr; // lookup ignores member operators
14461    // TODO: provide better source location info in DNLoc component.
14462    DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op);
14463    DeclarationNameInfo OpNameInfo(OpName, OpLoc);
14464    ExprResult Fn = CreateUnresolvedLookupExpr(
14465        NamingClass, NestedNameSpecifierLoc(), OpNameInfo, Fns, PerformADL);
14466    if (Fn.isInvalid())
14467      return ExprError();
14468    return CXXOperatorCallExpr::Create(Context, Op, Fn.get(), Args,
14469                                       Context.DependentTy, VK_PRValue, OpLoc,
14470                                       CurFPFeatureOverrides());
14471  }
14472
14473  // If this is the .* operator, which is not overloadable, just
14474  // create a built-in binary operator.
14475  if (Opc == BO_PtrMemD) {
14476    auto CheckPlaceholder = [&](Expr *&Arg) {
14477      ExprResult Res = CheckPlaceholderExpr(Arg);
14478      if (Res.isUsable())
14479        Arg = Res.get();
14480      return !Res.isUsable();
14481    };
14482
14483    // CreateBuiltinBinOp() doesn't like it if we tell it to create a '.*'
14484    // expression that contains placeholders (in either the LHS or RHS).
14485    if (CheckPlaceholder(Args[0]) || CheckPlaceholder(Args[1]))
14486      return ExprError();
14487    return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
14488  }
14489
14490  // Always do placeholder-like conversions on the RHS.
14491  if (checkPlaceholderForOverload(*this, Args[1]))
14492    return ExprError();
14493
14494  // Do placeholder-like conversion on the LHS; note that we should
14495  // not get here with a PseudoObject LHS.
14496  assert(Args[0]->getObjectKind() != OK_ObjCProperty);
14497  if (checkPlaceholderForOverload(*this, Args[0]))
14498    return ExprError();
14499
14500  // If this is the assignment operator, we only perform overload resolution
14501  // if the left-hand side is a class or enumeration type. This is actually
14502  // a hack. The standard requires that we do overload resolution between the
14503  // various built-in candidates, but as DR507 points out, this can lead to
14504  // problems. So we do it this way, which pretty much follows what GCC does.
14505  // Note that we go the traditional code path for compound assignment forms.
14506  if (Opc == BO_Assign && !Args[0]->getType()->isOverloadableType())
14507    return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
14508
14509  // Build the overload set.
14510  OverloadCandidateSet CandidateSet(OpLoc, OverloadCandidateSet::CSK_Operator,
14511                                    OverloadCandidateSet::OperatorRewriteInfo(
14512                                        Op, OpLoc, AllowRewrittenCandidates));
14513  if (DefaultedFn)
14514    CandidateSet.exclude(DefaultedFn);
14515  LookupOverloadedBinOp(CandidateSet, Op, Fns, Args, PerformADL);
14516
14517  bool HadMultipleCandidates = (CandidateSet.size() > 1);
14518
14519  // Perform overload resolution.
14520  OverloadCandidateSet::iterator Best;
14521  switch (CandidateSet.BestViableFunction(*this, OpLoc, Best)) {
14522    case OR_Success: {
14523      // We found a built-in operator or an overloaded operator.
14524      FunctionDecl *FnDecl = Best->Function;
14525
14526      bool IsReversed = Best->isReversed();
14527      if (IsReversed)
14528        std::swap(Args[0], Args[1]);
14529
14530      if (FnDecl) {
14531
14532        if (FnDecl->isInvalidDecl())
14533          return ExprError();
14534
14535        Expr *Base = nullptr;
14536        // We matched an overloaded operator. Build a call to that
14537        // operator.
14538
14539        OverloadedOperatorKind ChosenOp =
14540            FnDecl->getDeclName().getCXXOverloadedOperator();
14541
14542        // C++2a [over.match.oper]p9:
14543        //   If a rewritten operator== candidate is selected by overload
14544        //   resolution for an operator@, its return type shall be cv bool
14545        if (Best->RewriteKind && ChosenOp == OO_EqualEqual &&
14546            !FnDecl->getReturnType()->isBooleanType()) {
14547          bool IsExtension =
14548              FnDecl->getReturnType()->isIntegralOrUnscopedEnumerationType();
14549          Diag(OpLoc, IsExtension ? diag::ext_ovl_rewrite_equalequal_not_bool
14550                                  : diag::err_ovl_rewrite_equalequal_not_bool)
14551              << FnDecl->getReturnType() << BinaryOperator::getOpcodeStr(Opc)
14552              << Args[0]->getSourceRange() << Args[1]->getSourceRange();
14553          Diag(FnDecl->getLocation(), diag::note_declared_at);
14554          if (!IsExtension)
14555            return ExprError();
14556        }
14557
14558        if (AllowRewrittenCandidates && !IsReversed &&
14559            CandidateSet.getRewriteInfo().isReversible()) {
14560          // We could have reversed this operator, but didn't. Check if some
14561          // reversed form was a viable candidate, and if so, if it had a
14562          // better conversion for either parameter. If so, this call is
14563          // formally ambiguous, and allowing it is an extension.
14564          llvm::SmallVector<FunctionDecl*, 4> AmbiguousWith;
14565          for (OverloadCandidate &Cand : CandidateSet) {
14566            if (Cand.Viable && Cand.Function && Cand.isReversed() &&
14567                allowAmbiguity(Context, Cand.Function, FnDecl)) {
14568              for (unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) {
14569                if (CompareImplicitConversionSequences(
14570                        *this, OpLoc, Cand.Conversions[ArgIdx],
14571                        Best->Conversions[ArgIdx]) ==
14572                    ImplicitConversionSequence::Better) {
14573                  AmbiguousWith.push_back(Cand.Function);
14574                  break;
14575                }
14576              }
14577            }
14578          }
14579
14580          if (!AmbiguousWith.empty()) {
14581            bool AmbiguousWithSelf =
14582                AmbiguousWith.size() == 1 &&
14583                declaresSameEntity(AmbiguousWith.front(), FnDecl);
14584            Diag(OpLoc, diag::ext_ovl_ambiguous_oper_binary_reversed)
14585                << BinaryOperator::getOpcodeStr(Opc)
14586                << Args[0]->getType() << Args[1]->getType() << AmbiguousWithSelf
14587                << Args[0]->getSourceRange() << Args[1]->getSourceRange();
14588            if (AmbiguousWithSelf) {
14589              Diag(FnDecl->getLocation(),
14590                   diag::note_ovl_ambiguous_oper_binary_reversed_self);
14591              // Mark member== const or provide matching != to disallow reversed
14592              // args. Eg.
14593              // struct S { bool operator==(const S&); };
14594              // S()==S();
14595              if (auto *MD = dyn_cast<CXXMethodDecl>(FnDecl))
14596                if (Op == OverloadedOperatorKind::OO_EqualEqual &&
14597                    !MD->isConst() &&
14598                    !MD->hasCXXExplicitFunctionObjectParameter() &&
14599                    Context.hasSameUnqualifiedType(
14600                        MD->getFunctionObjectParameterType(),
14601                        MD->getParamDecl(0)->getType().getNonReferenceType()) &&
14602                    Context.hasSameUnqualifiedType(
14603                        MD->getFunctionObjectParameterType(),
14604                        Args[0]->getType()) &&
14605                    Context.hasSameUnqualifiedType(
14606                        MD->getFunctionObjectParameterType(),
14607                        Args[1]->getType()))
14608                  Diag(FnDecl->getLocation(),
14609                       diag::note_ovl_ambiguous_eqeq_reversed_self_non_const);
14610            } else {
14611              Diag(FnDecl->getLocation(),
14612                   diag::note_ovl_ambiguous_oper_binary_selected_candidate);
14613              for (auto *F : AmbiguousWith)
14614                Diag(F->getLocation(),
14615                     diag::note_ovl_ambiguous_oper_binary_reversed_candidate);
14616            }
14617          }
14618        }
14619
14620        // Convert the arguments.
14621        if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) {
14622          // Best->Access is only meaningful for class members.
14623          CheckMemberOperatorAccess(OpLoc, Args[0], Args[1], Best->FoundDecl);
14624
14625          ExprResult Arg0, Arg1;
14626          unsigned ParamIdx = 0;
14627          if (Method->isExplicitObjectMemberFunction()) {
14628            Arg0 = InitializeExplicitObjectArgument(*this, Args[0], FnDecl);
14629            ParamIdx = 1;
14630          } else {
14631            Arg0 = PerformImplicitObjectArgumentInitialization(
14632                Args[0], /*Qualifier=*/nullptr, Best->FoundDecl, Method);
14633          }
14634          Arg1 = PerformCopyInitialization(
14635              InitializedEntity::InitializeParameter(
14636                  Context, FnDecl->getParamDecl(ParamIdx)),
14637              SourceLocation(), Args[1]);
14638          if (Arg0.isInvalid() || Arg1.isInvalid())
14639            return ExprError();
14640
14641          Base = Args[0] = Arg0.getAs<Expr>();
14642          Args[1] = RHS = Arg1.getAs<Expr>();
14643        } else {
14644          // Convert the arguments.
14645          ExprResult Arg0 = PerformCopyInitialization(
14646            InitializedEntity::InitializeParameter(Context,
14647                                                   FnDecl->getParamDecl(0)),
14648            SourceLocation(), Args[0]);
14649          if (Arg0.isInvalid())
14650            return ExprError();
14651
14652          ExprResult Arg1 =
14653            PerformCopyInitialization(
14654              InitializedEntity::InitializeParameter(Context,
14655                                                     FnDecl->getParamDecl(1)),
14656              SourceLocation(), Args[1]);
14657          if (Arg1.isInvalid())
14658            return ExprError();
14659          Args[0] = LHS = Arg0.getAs<Expr>();
14660          Args[1] = RHS = Arg1.getAs<Expr>();
14661        }
14662
14663        // Build the actual expression node.
14664        ExprResult FnExpr = CreateFunctionRefExpr(*this, FnDecl,
14665                                                  Best->FoundDecl, Base,
14666                                                  HadMultipleCandidates, OpLoc);
14667        if (FnExpr.isInvalid())
14668          return ExprError();
14669
14670        // Determine the result type.
14671        QualType ResultTy = FnDecl->getReturnType();
14672        ExprValueKind VK = Expr::getValueKindForType(ResultTy);
14673        ResultTy = ResultTy.getNonLValueExprType(Context);
14674
14675        CallExpr *TheCall;
14676        ArrayRef<const Expr *> ArgsArray(Args, 2);
14677        const Expr *ImplicitThis = nullptr;
14678
14679        // We always create a CXXOperatorCallExpr, even for explicit object
14680        // members; CodeGen should take care not to emit the this pointer.
14681        TheCall = CXXOperatorCallExpr::Create(
14682            Context, ChosenOp, FnExpr.get(), Args, ResultTy, VK, OpLoc,
14683            CurFPFeatureOverrides(), Best->IsADLCandidate);
14684
14685        if (const auto *Method = dyn_cast<CXXMethodDecl>(FnDecl);
14686            Method && Method->isImplicitObjectMemberFunction()) {
14687          // Cut off the implicit 'this'.
14688          ImplicitThis = ArgsArray[0];
14689          ArgsArray = ArgsArray.slice(1);
14690        }
14691
14692        if (CheckCallReturnType(FnDecl->getReturnType(), OpLoc, TheCall,
14693                                FnDecl))
14694          return ExprError();
14695
14696        // Check for a self move.
14697        if (Op == OO_Equal)
14698          DiagnoseSelfMove(Args[0], Args[1], OpLoc);
14699
14700        if (ImplicitThis) {
14701          QualType ThisType = Context.getPointerType(ImplicitThis->getType());
14702          QualType ThisTypeFromDecl = Context.getPointerType(
14703              cast<CXXMethodDecl>(FnDecl)->getFunctionObjectParameterType());
14704
14705          CheckArgAlignment(OpLoc, FnDecl, "'this'", ThisType,
14706                            ThisTypeFromDecl);
14707        }
14708
14709        checkCall(FnDecl, nullptr, ImplicitThis, ArgsArray,
14710                  isa<CXXMethodDecl>(FnDecl), OpLoc, TheCall->getSourceRange(),
14711                  VariadicDoesNotApply);
14712
14713        ExprResult R = MaybeBindToTemporary(TheCall);
14714        if (R.isInvalid())
14715          return ExprError();
14716
14717        R = CheckForImmediateInvocation(R, FnDecl);
14718        if (R.isInvalid())
14719          return ExprError();
14720
14721        // For a rewritten candidate, we've already reversed the arguments
14722        // if needed. Perform the rest of the rewrite now.
14723        if ((Best->RewriteKind & CRK_DifferentOperator) ||
14724            (Op == OO_Spaceship && IsReversed)) {
14725          if (Op == OO_ExclaimEqual) {
14726            assert(ChosenOp == OO_EqualEqual && "unexpected operator name");
14727            R = CreateBuiltinUnaryOp(OpLoc, UO_LNot, R.get());
14728          } else {
14729            assert(ChosenOp == OO_Spaceship && "unexpected operator name");
14730            llvm::APSInt Zero(Context.getTypeSize(Context.IntTy), false);
14731            Expr *ZeroLiteral =
14732                IntegerLiteral::Create(Context, Zero, Context.IntTy, OpLoc);
14733
14734            Sema::CodeSynthesisContext Ctx;
14735            Ctx.Kind = Sema::CodeSynthesisContext::RewritingOperatorAsSpaceship;
14736            Ctx.Entity = FnDecl;
14737            pushCodeSynthesisContext(Ctx);
14738
14739            R = CreateOverloadedBinOp(
14740                OpLoc, Opc, Fns, IsReversed ? ZeroLiteral : R.get(),
14741                IsReversed ? R.get() : ZeroLiteral, /*PerformADL=*/true,
14742                /*AllowRewrittenCandidates=*/false);
14743
14744            popCodeSynthesisContext();
14745          }
14746          if (R.isInvalid())
14747            return ExprError();
14748        } else {
14749          assert(ChosenOp == Op && "unexpected operator name");
14750        }
14751
14752        // Make a note in the AST if we did any rewriting.
14753        if (Best->RewriteKind != CRK_None)
14754          R = new (Context) CXXRewrittenBinaryOperator(R.get(), IsReversed);
14755
14756        return R;
14757      } else {
14758        // We matched a built-in operator. Convert the arguments, then
14759        // break out so that we will build the appropriate built-in
14760        // operator node.
14761        ExprResult ArgsRes0 = PerformImplicitConversion(
14762            Args[0], Best->BuiltinParamTypes[0], Best->Conversions[0],
14763            AA_Passing, CCK_ForBuiltinOverloadedOp);
14764        if (ArgsRes0.isInvalid())
14765          return ExprError();
14766        Args[0] = ArgsRes0.get();
14767
14768        ExprResult ArgsRes1 = PerformImplicitConversion(
14769            Args[1], Best->BuiltinParamTypes[1], Best->Conversions[1],
14770            AA_Passing, CCK_ForBuiltinOverloadedOp);
14771        if (ArgsRes1.isInvalid())
14772          return ExprError();
14773        Args[1] = ArgsRes1.get();
14774        break;
14775      }
14776    }
14777
14778    case OR_No_Viable_Function: {
14779      // C++ [over.match.oper]p9:
14780      //   If the operator is the operator , [...] and there are no
14781      //   viable functions, then the operator is assumed to be the
14782      //   built-in operator and interpreted according to clause 5.
14783      if (Opc == BO_Comma)
14784        break;
14785
14786      // When defaulting an 'operator<=>', we can try to synthesize a three-way
14787      // compare result using '==' and '<'.
14788      if (DefaultedFn && Opc == BO_Cmp) {
14789        ExprResult E = BuildSynthesizedThreeWayComparison(OpLoc, Fns, Args[0],
14790                                                          Args[1], DefaultedFn);
14791        if (E.isInvalid() || E.isUsable())
14792          return E;
14793      }
14794
14795      // For class as left operand for assignment or compound assignment
14796      // operator do not fall through to handling in built-in, but report that
14797      // no overloaded assignment operator found
14798      ExprResult Result = ExprError();
14799      StringRef OpcStr = BinaryOperator::getOpcodeStr(Opc);
14800      auto Cands = CandidateSet.CompleteCandidates(*this, OCD_AllCandidates,
14801                                                   Args, OpLoc);
14802      DeferDiagsRAII DDR(*this,
14803                         CandidateSet.shouldDeferDiags(*this, Args, OpLoc));
14804      if (Args[0]->getType()->isRecordType() &&
14805          Opc >= BO_Assign && Opc <= BO_OrAssign) {
14806        Diag(OpLoc,  diag::err_ovl_no_viable_oper)
14807             << BinaryOperator::getOpcodeStr(Opc)
14808             << Args[0]->getSourceRange() << Args[1]->getSourceRange();
14809        if (Args[0]->getType()->isIncompleteType()) {
14810          Diag(OpLoc, diag::note_assign_lhs_incomplete)
14811            << Args[0]->getType()
14812            << Args[0]->getSourceRange() << Args[1]->getSourceRange();
14813        }
14814      } else {
14815        // This is an erroneous use of an operator which can be overloaded by
14816        // a non-member function. Check for non-member operators which were
14817        // defined too late to be candidates.
14818        if (DiagnoseTwoPhaseOperatorLookup(*this, Op, OpLoc, Args))
14819          // FIXME: Recover by calling the found function.
14820          return ExprError();
14821
14822        // No viable function; try to create a built-in operation, which will
14823        // produce an error. Then, show the non-viable candidates.
14824        Result = CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
14825      }
14826      assert(Result.isInvalid() &&
14827             "C++ binary operator overloading is missing candidates!");
14828      CandidateSet.NoteCandidates(*this, Args, Cands, OpcStr, OpLoc);
14829      return Result;
14830    }
14831
14832    case OR_Ambiguous:
14833      CandidateSet.NoteCandidates(
14834          PartialDiagnosticAt(OpLoc, PDiag(diag::err_ovl_ambiguous_oper_binary)
14835                                         << BinaryOperator::getOpcodeStr(Opc)
14836                                         << Args[0]->getType()
14837                                         << Args[1]->getType()
14838                                         << Args[0]->getSourceRange()
14839                                         << Args[1]->getSourceRange()),
14840          *this, OCD_AmbiguousCandidates, Args, BinaryOperator::getOpcodeStr(Opc),
14841          OpLoc);
14842      return ExprError();
14843
14844    case OR_Deleted:
14845      if (isImplicitlyDeleted(Best->Function)) {
14846        FunctionDecl *DeletedFD = Best->Function;
14847        DefaultedFunctionKind DFK = getDefaultedFunctionKind(DeletedFD);
14848        if (DFK.isSpecialMember()) {
14849          Diag(OpLoc, diag::err_ovl_deleted_special_oper)
14850            << Args[0]->getType() << DFK.asSpecialMember();
14851        } else {
14852          assert(DFK.isComparison());
14853          Diag(OpLoc, diag::err_ovl_deleted_comparison)
14854            << Args[0]->getType() << DeletedFD;
14855        }
14856
14857        // The user probably meant to call this special member. Just
14858        // explain why it's deleted.
14859        NoteDeletedFunction(DeletedFD);
14860        return ExprError();
14861      }
14862      CandidateSet.NoteCandidates(
14863          PartialDiagnosticAt(
14864              OpLoc, PDiag(diag::err_ovl_deleted_oper)
14865                         << getOperatorSpelling(Best->Function->getDeclName()
14866                                                    .getCXXOverloadedOperator())
14867                         << Args[0]->getSourceRange()
14868                         << Args[1]->getSourceRange()),
14869          *this, OCD_AllCandidates, Args, BinaryOperator::getOpcodeStr(Opc),
14870          OpLoc);
14871      return ExprError();
14872  }
14873
14874  // We matched a built-in operator; build it.
14875  return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
14876}
14877
14878ExprResult Sema::BuildSynthesizedThreeWayComparison(
14879    SourceLocation OpLoc, const UnresolvedSetImpl &Fns, Expr *LHS, Expr *RHS,
14880    FunctionDecl *DefaultedFn) {
14881  const ComparisonCategoryInfo *Info =
14882      Context.CompCategories.lookupInfoForType(DefaultedFn->getReturnType());
14883  // If we're not producing a known comparison category type, we can't
14884  // synthesize a three-way comparison. Let the caller diagnose this.
14885  if (!Info)
14886    return ExprResult((Expr*)nullptr);
14887
14888  // If we ever want to perform this synthesis more generally, we will need to
14889  // apply the temporary materialization conversion to the operands.
14890  assert(LHS->isGLValue() && RHS->isGLValue() &&
14891         "cannot use prvalue expressions more than once");
14892  Expr *OrigLHS = LHS;
14893  Expr *OrigRHS = RHS;
14894
14895  // Replace the LHS and RHS with OpaqueValueExprs; we're going to refer to
14896  // each of them multiple times below.
14897  LHS = new (Context)
14898      OpaqueValueExpr(LHS->getExprLoc(), LHS->getType(), LHS->getValueKind(),
14899                      LHS->getObjectKind(), LHS);
14900  RHS = new (Context)
14901      OpaqueValueExpr(RHS->getExprLoc(), RHS->getType(), RHS->getValueKind(),
14902                      RHS->getObjectKind(), RHS);
14903
14904  ExprResult Eq = CreateOverloadedBinOp(OpLoc, BO_EQ, Fns, LHS, RHS, true, true,
14905                                        DefaultedFn);
14906  if (Eq.isInvalid())
14907    return ExprError();
14908
14909  ExprResult Less = CreateOverloadedBinOp(OpLoc, BO_LT, Fns, LHS, RHS, true,
14910                                          true, DefaultedFn);
14911  if (Less.isInvalid())
14912    return ExprError();
14913
14914  ExprResult Greater;
14915  if (Info->isPartial()) {
14916    Greater = CreateOverloadedBinOp(OpLoc, BO_LT, Fns, RHS, LHS, true, true,
14917                                    DefaultedFn);
14918    if (Greater.isInvalid())
14919      return ExprError();
14920  }
14921
14922  // Form the list of comparisons we're going to perform.
14923  struct Comparison {
14924    ExprResult Cmp;
14925    ComparisonCategoryResult Result;
14926  } Comparisons[4] =
14927  { {Eq, Info->isStrong() ? ComparisonCategoryResult::Equal
14928                          : ComparisonCategoryResult::Equivalent},
14929    {Less, ComparisonCategoryResult::Less},
14930    {Greater, ComparisonCategoryResult::Greater},
14931    {ExprResult(), ComparisonCategoryResult::Unordered},
14932  };
14933
14934  int I = Info->isPartial() ? 3 : 2;
14935
14936  // Combine the comparisons with suitable conditional expressions.
14937  ExprResult Result;
14938  for (; I >= 0; --I) {
14939    // Build a reference to the comparison category constant.
14940    auto *VI = Info->lookupValueInfo(Comparisons[I].Result);
14941    // FIXME: Missing a constant for a comparison category. Diagnose this?
14942    if (!VI)
14943      return ExprResult((Expr*)nullptr);
14944    ExprResult ThisResult =
14945        BuildDeclarationNameExpr(CXXScopeSpec(), DeclarationNameInfo(), VI->VD);
14946    if (ThisResult.isInvalid())
14947      return ExprError();
14948
14949    // Build a conditional unless this is the final case.
14950    if (Result.get()) {
14951      Result = ActOnConditionalOp(OpLoc, OpLoc, Comparisons[I].Cmp.get(),
14952                                  ThisResult.get(), Result.get());
14953      if (Result.isInvalid())
14954        return ExprError();
14955    } else {
14956      Result = ThisResult;
14957    }
14958  }
14959
14960  // Build a PseudoObjectExpr to model the rewriting of an <=> operator, and to
14961  // bind the OpaqueValueExprs before they're (repeatedly) used.
14962  Expr *SyntacticForm = BinaryOperator::Create(
14963      Context, OrigLHS, OrigRHS, BO_Cmp, Result.get()->getType(),
14964      Result.get()->getValueKind(), Result.get()->getObjectKind(), OpLoc,
14965      CurFPFeatureOverrides());
14966  Expr *SemanticForm[] = {LHS, RHS, Result.get()};
14967  return PseudoObjectExpr::Create(Context, SyntacticForm, SemanticForm, 2);
14968}
14969
14970static bool PrepareArgumentsForCallToObjectOfClassType(
14971    Sema &S, SmallVectorImpl<Expr *> &MethodArgs, CXXMethodDecl *Method,
14972    MultiExprArg Args, SourceLocation LParenLoc) {
14973
14974  const auto *Proto = Method->getType()->castAs<FunctionProtoType>();
14975  unsigned NumParams = Proto->getNumParams();
14976  unsigned NumArgsSlots =
14977      MethodArgs.size() + std::max<unsigned>(Args.size(), NumParams);
14978  // Build the full argument list for the method call (the implicit object
14979  // parameter is placed at the beginning of the list).
14980  MethodArgs.reserve(MethodArgs.size() + NumArgsSlots);
14981  bool IsError = false;
14982  // Initialize the implicit object parameter.
14983  // Check the argument types.
14984  for (unsigned i = 0; i != NumParams; i++) {
14985    Expr *Arg;
14986    if (i < Args.size()) {
14987      Arg = Args[i];
14988      ExprResult InputInit =
14989          S.PerformCopyInitialization(InitializedEntity::InitializeParameter(
14990                                          S.Context, Method->getParamDecl(i)),
14991                                      SourceLocation(), Arg);
14992      IsError |= InputInit.isInvalid();
14993      Arg = InputInit.getAs<Expr>();
14994    } else {
14995      ExprResult DefArg =
14996          S.BuildCXXDefaultArgExpr(LParenLoc, Method, Method->getParamDecl(i));
14997      if (DefArg.isInvalid()) {
14998        IsError = true;
14999        break;
15000      }
15001      Arg = DefArg.getAs<Expr>();
15002    }
15003
15004    MethodArgs.push_back(Arg);
15005  }
15006  return IsError;
15007}
15008
15009ExprResult Sema::CreateOverloadedArraySubscriptExpr(SourceLocation LLoc,
15010                                                    SourceLocation RLoc,
15011                                                    Expr *Base,
15012                                                    MultiExprArg ArgExpr) {
15013  SmallVector<Expr *, 2> Args;
15014  Args.push_back(Base);
15015  for (auto *e : ArgExpr) {
15016    Args.push_back(e);
15017  }
15018  DeclarationName OpName =
15019      Context.DeclarationNames.getCXXOperatorName(OO_Subscript);
15020
15021  SourceRange Range = ArgExpr.empty()
15022                          ? SourceRange{}
15023                          : SourceRange(ArgExpr.front()->getBeginLoc(),
15024                                        ArgExpr.back()->getEndLoc());
15025
15026  // If either side is type-dependent, create an appropriate dependent
15027  // expression.
15028  if (Expr::hasAnyTypeDependentArguments(Args)) {
15029
15030    CXXRecordDecl *NamingClass = nullptr; // lookup ignores member operators
15031    // CHECKME: no 'operator' keyword?
15032    DeclarationNameInfo OpNameInfo(OpName, LLoc);
15033    OpNameInfo.setCXXOperatorNameRange(SourceRange(LLoc, RLoc));
15034    ExprResult Fn = CreateUnresolvedLookupExpr(
15035        NamingClass, NestedNameSpecifierLoc(), OpNameInfo, UnresolvedSet<0>());
15036    if (Fn.isInvalid())
15037      return ExprError();
15038    // Can't add any actual overloads yet
15039
15040    return CXXOperatorCallExpr::Create(Context, OO_Subscript, Fn.get(), Args,
15041                                       Context.DependentTy, VK_PRValue, RLoc,
15042                                       CurFPFeatureOverrides());
15043  }
15044
15045  // Handle placeholders
15046  UnbridgedCastsSet UnbridgedCasts;
15047  if (checkArgPlaceholdersForOverload(*this, Args, UnbridgedCasts)) {
15048    return ExprError();
15049  }
15050  // Build an empty overload set.
15051  OverloadCandidateSet CandidateSet(LLoc, OverloadCandidateSet::CSK_Operator);
15052
15053  // Subscript can only be overloaded as a member function.
15054
15055  // Add operator candidates that are member functions.
15056  AddMemberOperatorCandidates(OO_Subscript, LLoc, Args, CandidateSet);
15057
15058  // Add builtin operator candidates.
15059  if (Args.size() == 2)
15060    AddBuiltinOperatorCandidates(OO_Subscript, LLoc, Args, CandidateSet);
15061
15062  bool HadMultipleCandidates = (CandidateSet.size() > 1);
15063
15064  // Perform overload resolution.
15065  OverloadCandidateSet::iterator Best;
15066  switch (CandidateSet.BestViableFunction(*this, LLoc, Best)) {
15067    case OR_Success: {
15068      // We found a built-in operator or an overloaded operator.
15069      FunctionDecl *FnDecl = Best->Function;
15070
15071      if (FnDecl) {
15072        // We matched an overloaded operator. Build a call to that
15073        // operator.
15074
15075        CheckMemberOperatorAccess(LLoc, Args[0], ArgExpr, Best->FoundDecl);
15076
15077        // Convert the arguments.
15078        CXXMethodDecl *Method = cast<CXXMethodDecl>(FnDecl);
15079        SmallVector<Expr *, 2> MethodArgs;
15080
15081        // Initialize the object parameter.
15082        if (Method->isExplicitObjectMemberFunction()) {
15083          ExprResult Res =
15084              InitializeExplicitObjectArgument(*this, Args[0], Method);
15085          if (Res.isInvalid())
15086            return ExprError();
15087          Args[0] = Res.get();
15088          ArgExpr = Args;
15089        } else {
15090          ExprResult Arg0 = PerformImplicitObjectArgumentInitialization(
15091              Args[0], /*Qualifier=*/nullptr, Best->FoundDecl, Method);
15092          if (Arg0.isInvalid())
15093            return ExprError();
15094
15095          MethodArgs.push_back(Arg0.get());
15096        }
15097
15098        bool IsError = PrepareArgumentsForCallToObjectOfClassType(
15099            *this, MethodArgs, Method, ArgExpr, LLoc);
15100        if (IsError)
15101          return ExprError();
15102
15103        // Build the actual expression node.
15104        DeclarationNameInfo OpLocInfo(OpName, LLoc);
15105        OpLocInfo.setCXXOperatorNameRange(SourceRange(LLoc, RLoc));
15106        ExprResult FnExpr = CreateFunctionRefExpr(
15107            *this, FnDecl, Best->FoundDecl, Base, HadMultipleCandidates,
15108            OpLocInfo.getLoc(), OpLocInfo.getInfo());
15109        if (FnExpr.isInvalid())
15110          return ExprError();
15111
15112        // Determine the result type
15113        QualType ResultTy = FnDecl->getReturnType();
15114        ExprValueKind VK = Expr::getValueKindForType(ResultTy);
15115        ResultTy = ResultTy.getNonLValueExprType(Context);
15116
15117        CallExpr *TheCall = CXXOperatorCallExpr::Create(
15118            Context, OO_Subscript, FnExpr.get(), MethodArgs, ResultTy, VK, RLoc,
15119            CurFPFeatureOverrides());
15120
15121        if (CheckCallReturnType(FnDecl->getReturnType(), LLoc, TheCall, FnDecl))
15122          return ExprError();
15123
15124        if (CheckFunctionCall(Method, TheCall,
15125                              Method->getType()->castAs<FunctionProtoType>()))
15126          return ExprError();
15127
15128        return CheckForImmediateInvocation(MaybeBindToTemporary(TheCall),
15129                                           FnDecl);
15130      } else {
15131        // We matched a built-in operator. Convert the arguments, then
15132        // break out so that we will build the appropriate built-in
15133        // operator node.
15134        ExprResult ArgsRes0 = PerformImplicitConversion(
15135            Args[0], Best->BuiltinParamTypes[0], Best->Conversions[0],
15136            AA_Passing, CCK_ForBuiltinOverloadedOp);
15137        if (ArgsRes0.isInvalid())
15138          return ExprError();
15139        Args[0] = ArgsRes0.get();
15140
15141        ExprResult ArgsRes1 = PerformImplicitConversion(
15142            Args[1], Best->BuiltinParamTypes[1], Best->Conversions[1],
15143            AA_Passing, CCK_ForBuiltinOverloadedOp);
15144        if (ArgsRes1.isInvalid())
15145          return ExprError();
15146        Args[1] = ArgsRes1.get();
15147
15148        break;
15149      }
15150    }
15151
15152    case OR_No_Viable_Function: {
15153      PartialDiagnostic PD =
15154          CandidateSet.empty()
15155              ? (PDiag(diag::err_ovl_no_oper)
15156                 << Args[0]->getType() << /*subscript*/ 0
15157                 << Args[0]->getSourceRange() << Range)
15158              : (PDiag(diag::err_ovl_no_viable_subscript)
15159                 << Args[0]->getType() << Args[0]->getSourceRange() << Range);
15160      CandidateSet.NoteCandidates(PartialDiagnosticAt(LLoc, PD), *this,
15161                                  OCD_AllCandidates, ArgExpr, "[]", LLoc);
15162      return ExprError();
15163    }
15164
15165    case OR_Ambiguous:
15166      if (Args.size() == 2) {
15167        CandidateSet.NoteCandidates(
15168            PartialDiagnosticAt(
15169                LLoc, PDiag(diag::err_ovl_ambiguous_oper_binary)
15170                          << "[]" << Args[0]->getType() << Args[1]->getType()
15171                          << Args[0]->getSourceRange() << Range),
15172            *this, OCD_AmbiguousCandidates, Args, "[]", LLoc);
15173      } else {
15174        CandidateSet.NoteCandidates(
15175            PartialDiagnosticAt(LLoc,
15176                                PDiag(diag::err_ovl_ambiguous_subscript_call)
15177                                    << Args[0]->getType()
15178                                    << Args[0]->getSourceRange() << Range),
15179            *this, OCD_AmbiguousCandidates, Args, "[]", LLoc);
15180      }
15181      return ExprError();
15182
15183    case OR_Deleted:
15184      CandidateSet.NoteCandidates(
15185          PartialDiagnosticAt(LLoc, PDiag(diag::err_ovl_deleted_oper)
15186                                        << "[]" << Args[0]->getSourceRange()
15187                                        << Range),
15188          *this, OCD_AllCandidates, Args, "[]", LLoc);
15189      return ExprError();
15190    }
15191
15192  // We matched a built-in operator; build it.
15193  return CreateBuiltinArraySubscriptExpr(Args[0], LLoc, Args[1], RLoc);
15194}
15195
15196/// BuildCallToMemberFunction - Build a call to a member
15197/// function. MemExpr is the expression that refers to the member
15198/// function (and includes the object parameter), Args/NumArgs are the
15199/// arguments to the function call (not including the object
15200/// parameter). The caller needs to validate that the member
15201/// expression refers to a non-static member function or an overloaded
15202/// member function.
15203ExprResult Sema::BuildCallToMemberFunction(Scope *S, Expr *MemExprE,
15204                                           SourceLocation LParenLoc,
15205                                           MultiExprArg Args,
15206                                           SourceLocation RParenLoc,
15207                                           Expr *ExecConfig, bool IsExecConfig,
15208                                           bool AllowRecovery) {
15209  assert(MemExprE->getType() == Context.BoundMemberTy ||
15210         MemExprE->getType() == Context.OverloadTy);
15211
15212  // Dig out the member expression. This holds both the object
15213  // argument and the member function we're referring to.
15214  Expr *NakedMemExpr = MemExprE->IgnoreParens();
15215
15216  // Determine whether this is a call to a pointer-to-member function.
15217  if (BinaryOperator *op = dyn_cast<BinaryOperator>(NakedMemExpr)) {
15218    assert(op->getType() == Context.BoundMemberTy);
15219    assert(op->getOpcode() == BO_PtrMemD || op->getOpcode() == BO_PtrMemI);
15220
15221    QualType fnType =
15222      op->getRHS()->getType()->castAs<MemberPointerType>()->getPointeeType();
15223
15224    const FunctionProtoType *proto = fnType->castAs<FunctionProtoType>();
15225    QualType resultType = proto->getCallResultType(Context);
15226    ExprValueKind valueKind = Expr::getValueKindForType(proto->getReturnType());
15227
15228    // Check that the object type isn't more qualified than the
15229    // member function we're calling.
15230    Qualifiers funcQuals = proto->getMethodQuals();
15231
15232    QualType objectType = op->getLHS()->getType();
15233    if (op->getOpcode() == BO_PtrMemI)
15234      objectType = objectType->castAs<PointerType>()->getPointeeType();
15235    Qualifiers objectQuals = objectType.getQualifiers();
15236
15237    Qualifiers difference = objectQuals - funcQuals;
15238    difference.removeObjCGCAttr();
15239    difference.removeAddressSpace();
15240    if (difference) {
15241      std::string qualsString = difference.getAsString();
15242      Diag(LParenLoc, diag::err_pointer_to_member_call_drops_quals)
15243        << fnType.getUnqualifiedType()
15244        << qualsString
15245        << (qualsString.find(' ') == std::string::npos ? 1 : 2);
15246    }
15247
15248    CXXMemberCallExpr *call = CXXMemberCallExpr::Create(
15249        Context, MemExprE, Args, resultType, valueKind, RParenLoc,
15250        CurFPFeatureOverrides(), proto->getNumParams());
15251
15252    if (CheckCallReturnType(proto->getReturnType(), op->getRHS()->getBeginLoc(),
15253                            call, nullptr))
15254      return ExprError();
15255
15256    if (ConvertArgumentsForCall(call, op, nullptr, proto, Args, RParenLoc))
15257      return ExprError();
15258
15259    if (CheckOtherCall(call, proto))
15260      return ExprError();
15261
15262    return MaybeBindToTemporary(call);
15263  }
15264
15265  // We only try to build a recovery expr at this level if we can preserve
15266  // the return type, otherwise we return ExprError() and let the caller
15267  // recover.
15268  auto BuildRecoveryExpr = [&](QualType Type) {
15269    if (!AllowRecovery)
15270      return ExprError();
15271    std::vector<Expr *> SubExprs = {MemExprE};
15272    llvm::append_range(SubExprs, Args);
15273    return CreateRecoveryExpr(MemExprE->getBeginLoc(), RParenLoc, SubExprs,
15274                              Type);
15275  };
15276  if (isa<CXXPseudoDestructorExpr>(NakedMemExpr))
15277    return CallExpr::Create(Context, MemExprE, Args, Context.VoidTy, VK_PRValue,
15278                            RParenLoc, CurFPFeatureOverrides());
15279
15280  UnbridgedCastsSet UnbridgedCasts;
15281  if (checkArgPlaceholdersForOverload(*this, Args, UnbridgedCasts))
15282    return ExprError();
15283
15284  MemberExpr *MemExpr;
15285  CXXMethodDecl *Method = nullptr;
15286  bool HadMultipleCandidates = false;
15287  DeclAccessPair FoundDecl = DeclAccessPair::make(nullptr, AS_public);
15288  NestedNameSpecifier *Qualifier = nullptr;
15289  if (isa<MemberExpr>(NakedMemExpr)) {
15290    MemExpr = cast<MemberExpr>(NakedMemExpr);
15291    Method = cast<CXXMethodDecl>(MemExpr->getMemberDecl());
15292    FoundDecl = MemExpr->getFoundDecl();
15293    Qualifier = MemExpr->getQualifier();
15294    UnbridgedCasts.restore();
15295  } else {
15296    UnresolvedMemberExpr *UnresExpr = cast<UnresolvedMemberExpr>(NakedMemExpr);
15297    Qualifier = UnresExpr->getQualifier();
15298
15299    QualType ObjectType = UnresExpr->getBaseType();
15300    Expr::Classification ObjectClassification
15301      = UnresExpr->isArrow()? Expr::Classification::makeSimpleLValue()
15302                            : UnresExpr->getBase()->Classify(Context);
15303
15304    // Add overload candidates
15305    OverloadCandidateSet CandidateSet(UnresExpr->getMemberLoc(),
15306                                      OverloadCandidateSet::CSK_Normal);
15307
15308    // FIXME: avoid copy.
15309    TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
15310    if (UnresExpr->hasExplicitTemplateArgs()) {
15311      UnresExpr->copyTemplateArgumentsInto(TemplateArgsBuffer);
15312      TemplateArgs = &TemplateArgsBuffer;
15313    }
15314
15315    for (UnresolvedMemberExpr::decls_iterator I = UnresExpr->decls_begin(),
15316           E = UnresExpr->decls_end(); I != E; ++I) {
15317
15318      QualType ExplicitObjectType = ObjectType;
15319
15320      NamedDecl *Func = *I;
15321      CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(Func->getDeclContext());
15322      if (isa<UsingShadowDecl>(Func))
15323        Func = cast<UsingShadowDecl>(Func)->getTargetDecl();
15324
15325      bool HasExplicitParameter = false;
15326      if (const auto *M = dyn_cast<FunctionDecl>(Func);
15327          M && M->hasCXXExplicitFunctionObjectParameter())
15328        HasExplicitParameter = true;
15329      else if (const auto *M = dyn_cast<FunctionTemplateDecl>(Func);
15330               M &&
15331               M->getTemplatedDecl()->hasCXXExplicitFunctionObjectParameter())
15332        HasExplicitParameter = true;
15333
15334      if (HasExplicitParameter)
15335        ExplicitObjectType = GetExplicitObjectType(*this, UnresExpr);
15336
15337      // Microsoft supports direct constructor calls.
15338      if (getLangOpts().MicrosoftExt && isa<CXXConstructorDecl>(Func)) {
15339        AddOverloadCandidate(cast<CXXConstructorDecl>(Func), I.getPair(), Args,
15340                             CandidateSet,
15341                             /*SuppressUserConversions*/ false);
15342      } else if ((Method = dyn_cast<CXXMethodDecl>(Func))) {
15343        // If explicit template arguments were provided, we can't call a
15344        // non-template member function.
15345        if (TemplateArgs)
15346          continue;
15347
15348        AddMethodCandidate(Method, I.getPair(), ActingDC, ExplicitObjectType,
15349                           ObjectClassification, Args, CandidateSet,
15350                           /*SuppressUserConversions=*/false);
15351      } else {
15352        AddMethodTemplateCandidate(cast<FunctionTemplateDecl>(Func),
15353                                   I.getPair(), ActingDC, TemplateArgs,
15354                                   ExplicitObjectType, ObjectClassification,
15355                                   Args, CandidateSet,
15356                                   /*SuppressUserConversions=*/false);
15357      }
15358    }
15359
15360    HadMultipleCandidates = (CandidateSet.size() > 1);
15361
15362    DeclarationName DeclName = UnresExpr->getMemberName();
15363
15364    UnbridgedCasts.restore();
15365
15366    OverloadCandidateSet::iterator Best;
15367    bool Succeeded = false;
15368    switch (CandidateSet.BestViableFunction(*this, UnresExpr->getBeginLoc(),
15369                                            Best)) {
15370    case OR_Success:
15371      Method = cast<CXXMethodDecl>(Best->Function);
15372      FoundDecl = Best->FoundDecl;
15373      CheckUnresolvedMemberAccess(UnresExpr, Best->FoundDecl);
15374      if (DiagnoseUseOfOverloadedDecl(Best->FoundDecl, UnresExpr->getNameLoc()))
15375        break;
15376      // If FoundDecl is different from Method (such as if one is a template
15377      // and the other a specialization), make sure DiagnoseUseOfDecl is
15378      // called on both.
15379      // FIXME: This would be more comprehensively addressed by modifying
15380      // DiagnoseUseOfDecl to accept both the FoundDecl and the decl
15381      // being used.
15382      if (Method != FoundDecl.getDecl() &&
15383          DiagnoseUseOfOverloadedDecl(Method, UnresExpr->getNameLoc()))
15384        break;
15385      Succeeded = true;
15386      break;
15387
15388    case OR_No_Viable_Function:
15389      CandidateSet.NoteCandidates(
15390          PartialDiagnosticAt(
15391              UnresExpr->getMemberLoc(),
15392              PDiag(diag::err_ovl_no_viable_member_function_in_call)
15393                  << DeclName << MemExprE->getSourceRange()),
15394          *this, OCD_AllCandidates, Args);
15395      break;
15396    case OR_Ambiguous:
15397      CandidateSet.NoteCandidates(
15398          PartialDiagnosticAt(UnresExpr->getMemberLoc(),
15399                              PDiag(diag::err_ovl_ambiguous_member_call)
15400                                  << DeclName << MemExprE->getSourceRange()),
15401          *this, OCD_AmbiguousCandidates, Args);
15402      break;
15403    case OR_Deleted:
15404      CandidateSet.NoteCandidates(
15405          PartialDiagnosticAt(UnresExpr->getMemberLoc(),
15406                              PDiag(diag::err_ovl_deleted_member_call)
15407                                  << DeclName << MemExprE->getSourceRange()),
15408          *this, OCD_AllCandidates, Args);
15409      break;
15410    }
15411    // Overload resolution fails, try to recover.
15412    if (!Succeeded)
15413      return BuildRecoveryExpr(chooseRecoveryType(CandidateSet, &Best));
15414
15415    ExprResult Res =
15416        FixOverloadedFunctionReference(MemExprE, FoundDecl, Method);
15417    if (Res.isInvalid())
15418      return ExprError();
15419    MemExprE = Res.get();
15420
15421    // If overload resolution picked a static member
15422    // build a non-member call based on that function.
15423    if (Method->isStatic()) {
15424      return BuildResolvedCallExpr(MemExprE, Method, LParenLoc, Args, RParenLoc,
15425                                   ExecConfig, IsExecConfig);
15426    }
15427
15428    MemExpr = cast<MemberExpr>(MemExprE->IgnoreParens());
15429  }
15430
15431  QualType ResultType = Method->getReturnType();
15432  ExprValueKind VK = Expr::getValueKindForType(ResultType);
15433  ResultType = ResultType.getNonLValueExprType(Context);
15434
15435  assert(Method && "Member call to something that isn't a method?");
15436  const auto *Proto = Method->getType()->castAs<FunctionProtoType>();
15437
15438  CallExpr *TheCall = nullptr;
15439  llvm::SmallVector<Expr *, 8> NewArgs;
15440  if (Method->isExplicitObjectMemberFunction()) {
15441    PrepareExplicitObjectArgument(*this, Method, MemExpr->getBase(), Args,
15442                                  NewArgs);
15443    // Build the actual expression node.
15444    ExprResult FnExpr =
15445        CreateFunctionRefExpr(*this, Method, FoundDecl, MemExpr,
15446                              HadMultipleCandidates, MemExpr->getExprLoc());
15447    if (FnExpr.isInvalid())
15448      return ExprError();
15449
15450    TheCall =
15451        CallExpr::Create(Context, FnExpr.get(), Args, ResultType, VK, RParenLoc,
15452                         CurFPFeatureOverrides(), Proto->getNumParams());
15453  } else {
15454    // Convert the object argument (for a non-static member function call).
15455    // We only need to do this if there was actually an overload; otherwise
15456    // it was done at lookup.
15457    ExprResult ObjectArg = PerformImplicitObjectArgumentInitialization(
15458        MemExpr->getBase(), Qualifier, FoundDecl, Method);
15459    if (ObjectArg.isInvalid())
15460      return ExprError();
15461    MemExpr->setBase(ObjectArg.get());
15462    TheCall = CXXMemberCallExpr::Create(Context, MemExprE, Args, ResultType, VK,
15463                                        RParenLoc, CurFPFeatureOverrides(),
15464                                        Proto->getNumParams());
15465  }
15466
15467  // Check for a valid return type.
15468  if (CheckCallReturnType(Method->getReturnType(), MemExpr->getMemberLoc(),
15469                          TheCall, Method))
15470    return BuildRecoveryExpr(ResultType);
15471
15472  // Convert the rest of the arguments
15473  if (ConvertArgumentsForCall(TheCall, MemExpr, Method, Proto, Args,
15474                              RParenLoc))
15475    return BuildRecoveryExpr(ResultType);
15476
15477  DiagnoseSentinelCalls(Method, LParenLoc, Args);
15478
15479  if (CheckFunctionCall(Method, TheCall, Proto))
15480    return ExprError();
15481
15482  // In the case the method to call was not selected by the overloading
15483  // resolution process, we still need to handle the enable_if attribute. Do
15484  // that here, so it will not hide previous -- and more relevant -- errors.
15485  if (auto *MemE = dyn_cast<MemberExpr>(NakedMemExpr)) {
15486    if (const EnableIfAttr *Attr =
15487            CheckEnableIf(Method, LParenLoc, Args, true)) {
15488      Diag(MemE->getMemberLoc(),
15489           diag::err_ovl_no_viable_member_function_in_call)
15490          << Method << Method->getSourceRange();
15491      Diag(Method->getLocation(),
15492           diag::note_ovl_candidate_disabled_by_function_cond_attr)
15493          << Attr->getCond()->getSourceRange() << Attr->getMessage();
15494      return ExprError();
15495    }
15496  }
15497
15498  if (isa<CXXConstructorDecl, CXXDestructorDecl>(CurContext) &&
15499      TheCall->getDirectCallee()->isPureVirtual()) {
15500    const FunctionDecl *MD = TheCall->getDirectCallee();
15501
15502    if (isa<CXXThisExpr>(MemExpr->getBase()->IgnoreParenCasts()) &&
15503        MemExpr->performsVirtualDispatch(getLangOpts())) {
15504      Diag(MemExpr->getBeginLoc(),
15505           diag::warn_call_to_pure_virtual_member_function_from_ctor_dtor)
15506          << MD->getDeclName() << isa<CXXDestructorDecl>(CurContext)
15507          << MD->getParent();
15508
15509      Diag(MD->getBeginLoc(), diag::note_previous_decl) << MD->getDeclName();
15510      if (getLangOpts().AppleKext)
15511        Diag(MemExpr->getBeginLoc(), diag::note_pure_qualified_call_kext)
15512            << MD->getParent() << MD->getDeclName();
15513    }
15514  }
15515
15516  if (auto *DD = dyn_cast<CXXDestructorDecl>(TheCall->getDirectCallee())) {
15517    // a->A::f() doesn't go through the vtable, except in AppleKext mode.
15518    bool CallCanBeVirtual = !MemExpr->hasQualifier() || getLangOpts().AppleKext;
15519    CheckVirtualDtorCall(DD, MemExpr->getBeginLoc(), /*IsDelete=*/false,
15520                         CallCanBeVirtual, /*WarnOnNonAbstractTypes=*/true,
15521                         MemExpr->getMemberLoc());
15522  }
15523
15524  return CheckForImmediateInvocation(MaybeBindToTemporary(TheCall),
15525                                     TheCall->getDirectCallee());
15526}
15527
15528/// BuildCallToObjectOfClassType - Build a call to an object of class
15529/// type (C++ [over.call.object]), which can end up invoking an
15530/// overloaded function call operator (@c operator()) or performing a
15531/// user-defined conversion on the object argument.
15532ExprResult
15533Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Obj,
15534                                   SourceLocation LParenLoc,
15535                                   MultiExprArg Args,
15536                                   SourceLocation RParenLoc) {
15537  if (checkPlaceholderForOverload(*this, Obj))
15538    return ExprError();
15539  ExprResult Object = Obj;
15540
15541  UnbridgedCastsSet UnbridgedCasts;
15542  if (checkArgPlaceholdersForOverload(*this, Args, UnbridgedCasts))
15543    return ExprError();
15544
15545  assert(Object.get()->getType()->isRecordType() &&
15546         "Requires object type argument");
15547
15548  // C++ [over.call.object]p1:
15549  //  If the primary-expression E in the function call syntax
15550  //  evaluates to a class object of type "cv T", then the set of
15551  //  candidate functions includes at least the function call
15552  //  operators of T. The function call operators of T are obtained by
15553  //  ordinary lookup of the name operator() in the context of
15554  //  (E).operator().
15555  OverloadCandidateSet CandidateSet(LParenLoc,
15556                                    OverloadCandidateSet::CSK_Operator);
15557  DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(OO_Call);
15558
15559  if (RequireCompleteType(LParenLoc, Object.get()->getType(),
15560                          diag::err_incomplete_object_call, Object.get()))
15561    return true;
15562
15563  const auto *Record = Object.get()->getType()->castAs<RecordType>();
15564  LookupResult R(*this, OpName, LParenLoc, LookupOrdinaryName);
15565  LookupQualifiedName(R, Record->getDecl());
15566  R.suppressAccessDiagnostics();
15567
15568  for (LookupResult::iterator Oper = R.begin(), OperEnd = R.end();
15569       Oper != OperEnd; ++Oper) {
15570    AddMethodCandidate(Oper.getPair(), Object.get()->getType(),
15571                       Object.get()->Classify(Context), Args, CandidateSet,
15572                       /*SuppressUserConversion=*/false);
15573  }
15574
15575  // When calling a lambda, both the call operator, and
15576  // the conversion operator to function pointer
15577  // are considered. But when constraint checking
15578  // on the call operator fails, it will also fail on the
15579  // conversion operator as the constraints are always the same.
15580  // As the user probably does not intend to perform a surrogate call,
15581  // we filter them out to produce better error diagnostics, ie to avoid
15582  // showing 2 failed overloads instead of one.
15583  bool IgnoreSurrogateFunctions = false;
15584  if (CandidateSet.size() == 1 && Record->getAsCXXRecordDecl()->isLambda()) {
15585    const OverloadCandidate &Candidate = *CandidateSet.begin();
15586    if (!Candidate.Viable &&
15587        Candidate.FailureKind == ovl_fail_constraints_not_satisfied)
15588      IgnoreSurrogateFunctions = true;
15589  }
15590
15591  // C++ [over.call.object]p2:
15592  //   In addition, for each (non-explicit in C++0x) conversion function
15593  //   declared in T of the form
15594  //
15595  //        operator conversion-type-id () cv-qualifier;
15596  //
15597  //   where cv-qualifier is the same cv-qualification as, or a
15598  //   greater cv-qualification than, cv, and where conversion-type-id
15599  //   denotes the type "pointer to function of (P1,...,Pn) returning
15600  //   R", or the type "reference to pointer to function of
15601  //   (P1,...,Pn) returning R", or the type "reference to function
15602  //   of (P1,...,Pn) returning R", a surrogate call function [...]
15603  //   is also considered as a candidate function. Similarly,
15604  //   surrogate call functions are added to the set of candidate
15605  //   functions for each conversion function declared in an
15606  //   accessible base class provided the function is not hidden
15607  //   within T by another intervening declaration.
15608  const auto &Conversions =
15609      cast<CXXRecordDecl>(Record->getDecl())->getVisibleConversionFunctions();
15610  for (auto I = Conversions.begin(), E = Conversions.end();
15611       !IgnoreSurrogateFunctions && I != E; ++I) {
15612    NamedDecl *D = *I;
15613    CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext());
15614    if (isa<UsingShadowDecl>(D))
15615      D = cast<UsingShadowDecl>(D)->getTargetDecl();
15616
15617    // Skip over templated conversion functions; they aren't
15618    // surrogates.
15619    if (isa<FunctionTemplateDecl>(D))
15620      continue;
15621
15622    CXXConversionDecl *Conv = cast<CXXConversionDecl>(D);
15623    if (!Conv->isExplicit()) {
15624      // Strip the reference type (if any) and then the pointer type (if
15625      // any) to get down to what might be a function type.
15626      QualType ConvType = Conv->getConversionType().getNonReferenceType();
15627      if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>())
15628        ConvType = ConvPtrType->getPointeeType();
15629
15630      if (const FunctionProtoType *Proto = ConvType->getAs<FunctionProtoType>())
15631      {
15632        AddSurrogateCandidate(Conv, I.getPair(), ActingContext, Proto,
15633                              Object.get(), Args, CandidateSet);
15634      }
15635    }
15636  }
15637
15638  bool HadMultipleCandidates = (CandidateSet.size() > 1);
15639
15640  // Perform overload resolution.
15641  OverloadCandidateSet::iterator Best;
15642  switch (CandidateSet.BestViableFunction(*this, Object.get()->getBeginLoc(),
15643                                          Best)) {
15644  case OR_Success:
15645    // Overload resolution succeeded; we'll build the appropriate call
15646    // below.
15647    break;
15648
15649  case OR_No_Viable_Function: {
15650    PartialDiagnostic PD =
15651        CandidateSet.empty()
15652            ? (PDiag(diag::err_ovl_no_oper)
15653               << Object.get()->getType() << /*call*/ 1
15654               << Object.get()->getSourceRange())
15655            : (PDiag(diag::err_ovl_no_viable_object_call)
15656               << Object.get()->getType() << Object.get()->getSourceRange());
15657    CandidateSet.NoteCandidates(
15658        PartialDiagnosticAt(Object.get()->getBeginLoc(), PD), *this,
15659        OCD_AllCandidates, Args);
15660    break;
15661  }
15662  case OR_Ambiguous:
15663    if (!R.isAmbiguous())
15664      CandidateSet.NoteCandidates(
15665          PartialDiagnosticAt(Object.get()->getBeginLoc(),
15666                              PDiag(diag::err_ovl_ambiguous_object_call)
15667                                  << Object.get()->getType()
15668                                  << Object.get()->getSourceRange()),
15669          *this, OCD_AmbiguousCandidates, Args);
15670    break;
15671
15672  case OR_Deleted:
15673    CandidateSet.NoteCandidates(
15674        PartialDiagnosticAt(Object.get()->getBeginLoc(),
15675                            PDiag(diag::err_ovl_deleted_object_call)
15676                                << Object.get()->getType()
15677                                << Object.get()->getSourceRange()),
15678        *this, OCD_AllCandidates, Args);
15679    break;
15680  }
15681
15682  if (Best == CandidateSet.end())
15683    return true;
15684
15685  UnbridgedCasts.restore();
15686
15687  if (Best->Function == nullptr) {
15688    // Since there is no function declaration, this is one of the
15689    // surrogate candidates. Dig out the conversion function.
15690    CXXConversionDecl *Conv
15691      = cast<CXXConversionDecl>(
15692                         Best->Conversions[0].UserDefined.ConversionFunction);
15693
15694    CheckMemberOperatorAccess(LParenLoc, Object.get(), nullptr,
15695                              Best->FoundDecl);
15696    if (DiagnoseUseOfDecl(Best->FoundDecl, LParenLoc))
15697      return ExprError();
15698    assert(Conv == Best->FoundDecl.getDecl() &&
15699             "Found Decl & conversion-to-functionptr should be same, right?!");
15700    // We selected one of the surrogate functions that converts the
15701    // object parameter to a function pointer. Perform the conversion
15702    // on the object argument, then let BuildCallExpr finish the job.
15703
15704    // Create an implicit member expr to refer to the conversion operator.
15705    // and then call it.
15706    ExprResult Call = BuildCXXMemberCallExpr(Object.get(), Best->FoundDecl,
15707                                             Conv, HadMultipleCandidates);
15708    if (Call.isInvalid())
15709      return ExprError();
15710    // Record usage of conversion in an implicit cast.
15711    Call = ImplicitCastExpr::Create(
15712        Context, Call.get()->getType(), CK_UserDefinedConversion, Call.get(),
15713        nullptr, VK_PRValue, CurFPFeatureOverrides());
15714
15715    return BuildCallExpr(S, Call.get(), LParenLoc, Args, RParenLoc);
15716  }
15717
15718  CheckMemberOperatorAccess(LParenLoc, Object.get(), nullptr, Best->FoundDecl);
15719
15720  // We found an overloaded operator(). Build a CXXOperatorCallExpr
15721  // that calls this method, using Object for the implicit object
15722  // parameter and passing along the remaining arguments.
15723  CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
15724
15725  // An error diagnostic has already been printed when parsing the declaration.
15726  if (Method->isInvalidDecl())
15727    return ExprError();
15728
15729  const auto *Proto = Method->getType()->castAs<FunctionProtoType>();
15730  unsigned NumParams = Proto->getNumParams();
15731
15732  DeclarationNameInfo OpLocInfo(
15733               Context.DeclarationNames.getCXXOperatorName(OO_Call), LParenLoc);
15734  OpLocInfo.setCXXOperatorNameRange(SourceRange(LParenLoc, RParenLoc));
15735  ExprResult NewFn = CreateFunctionRefExpr(*this, Method, Best->FoundDecl,
15736                                           Obj, HadMultipleCandidates,
15737                                           OpLocInfo.getLoc(),
15738                                           OpLocInfo.getInfo());
15739  if (NewFn.isInvalid())
15740    return true;
15741
15742  SmallVector<Expr *, 8> MethodArgs;
15743  MethodArgs.reserve(NumParams + 1);
15744
15745  bool IsError = false;
15746
15747  // Initialize the object parameter.
15748  llvm::SmallVector<Expr *, 8> NewArgs;
15749  if (Method->isExplicitObjectMemberFunction()) {
15750    // FIXME: we should do that during the definition of the lambda when we can.
15751    DiagnoseInvalidExplicitObjectParameterInLambda(Method);
15752    PrepareExplicitObjectArgument(*this, Method, Obj, Args, NewArgs);
15753  } else {
15754    ExprResult ObjRes = PerformImplicitObjectArgumentInitialization(
15755        Object.get(), /*Qualifier=*/nullptr, Best->FoundDecl, Method);
15756    if (ObjRes.isInvalid())
15757      IsError = true;
15758    else
15759      Object = ObjRes;
15760    MethodArgs.push_back(Object.get());
15761  }
15762
15763  IsError |= PrepareArgumentsForCallToObjectOfClassType(
15764      *this, MethodArgs, Method, Args, LParenLoc);
15765
15766  // If this is a variadic call, handle args passed through "...".
15767  if (Proto->isVariadic()) {
15768    // Promote the arguments (C99 6.5.2.2p7).
15769    for (unsigned i = NumParams, e = Args.size(); i < e; i++) {
15770      ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], VariadicMethod,
15771                                                        nullptr);
15772      IsError |= Arg.isInvalid();
15773      MethodArgs.push_back(Arg.get());
15774    }
15775  }
15776
15777  if (IsError)
15778    return true;
15779
15780  DiagnoseSentinelCalls(Method, LParenLoc, Args);
15781
15782  // Once we've built TheCall, all of the expressions are properly owned.
15783  QualType ResultTy = Method->getReturnType();
15784  ExprValueKind VK = Expr::getValueKindForType(ResultTy);
15785  ResultTy = ResultTy.getNonLValueExprType(Context);
15786
15787  CallExpr *TheCall = CXXOperatorCallExpr::Create(
15788      Context, OO_Call, NewFn.get(), MethodArgs, ResultTy, VK, RParenLoc,
15789      CurFPFeatureOverrides());
15790
15791  if (CheckCallReturnType(Method->getReturnType(), LParenLoc, TheCall, Method))
15792    return true;
15793
15794  if (CheckFunctionCall(Method, TheCall, Proto))
15795    return true;
15796
15797  return CheckForImmediateInvocation(MaybeBindToTemporary(TheCall), Method);
15798}
15799
15800/// BuildOverloadedArrowExpr - Build a call to an overloaded @c operator->
15801///  (if one exists), where @c Base is an expression of class type and
15802/// @c Member is the name of the member we're trying to find.
15803ExprResult
15804Sema::BuildOverloadedArrowExpr(Scope *S, Expr *Base, SourceLocation OpLoc,
15805                               bool *NoArrowOperatorFound) {
15806  assert(Base->getType()->isRecordType() &&
15807         "left-hand side must have class type");
15808
15809  if (checkPlaceholderForOverload(*this, Base))
15810    return ExprError();
15811
15812  SourceLocation Loc = Base->getExprLoc();
15813
15814  // C++ [over.ref]p1:
15815  //
15816  //   [...] An expression x->m is interpreted as (x.operator->())->m
15817  //   for a class object x of type T if T::operator->() exists and if
15818  //   the operator is selected as the best match function by the
15819  //   overload resolution mechanism (13.3).
15820  DeclarationName OpName =
15821    Context.DeclarationNames.getCXXOperatorName(OO_Arrow);
15822  OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Operator);
15823
15824  if (RequireCompleteType(Loc, Base->getType(),
15825                          diag::err_typecheck_incomplete_tag, Base))
15826    return ExprError();
15827
15828  LookupResult R(*this, OpName, OpLoc, LookupOrdinaryName);
15829  LookupQualifiedName(R, Base->getType()->castAs<RecordType>()->getDecl());
15830  R.suppressAccessDiagnostics();
15831
15832  for (LookupResult::iterator Oper = R.begin(), OperEnd = R.end();
15833       Oper != OperEnd; ++Oper) {
15834    AddMethodCandidate(Oper.getPair(), Base->getType(), Base->Classify(Context),
15835                       std::nullopt, CandidateSet,
15836                       /*SuppressUserConversion=*/false);
15837  }
15838
15839  bool HadMultipleCandidates = (CandidateSet.size() > 1);
15840
15841  // Perform overload resolution.
15842  OverloadCandidateSet::iterator Best;
15843  switch (CandidateSet.BestViableFunction(*this, OpLoc, Best)) {
15844  case OR_Success:
15845    // Overload resolution succeeded; we'll build the call below.
15846    break;
15847
15848  case OR_No_Viable_Function: {
15849    auto Cands = CandidateSet.CompleteCandidates(*this, OCD_AllCandidates, Base);
15850    if (CandidateSet.empty()) {
15851      QualType BaseType = Base->getType();
15852      if (NoArrowOperatorFound) {
15853        // Report this specific error to the caller instead of emitting a
15854        // diagnostic, as requested.
15855        *NoArrowOperatorFound = true;
15856        return ExprError();
15857      }
15858      Diag(OpLoc, diag::err_typecheck_member_reference_arrow)
15859        << BaseType << Base->getSourceRange();
15860      if (BaseType->isRecordType() && !BaseType->isPointerType()) {
15861        Diag(OpLoc, diag::note_typecheck_member_reference_suggestion)
15862          << FixItHint::CreateReplacement(OpLoc, ".");
15863      }
15864    } else
15865      Diag(OpLoc, diag::err_ovl_no_viable_oper)
15866        << "operator->" << Base->getSourceRange();
15867    CandidateSet.NoteCandidates(*this, Base, Cands);
15868    return ExprError();
15869  }
15870  case OR_Ambiguous:
15871    if (!R.isAmbiguous())
15872      CandidateSet.NoteCandidates(
15873          PartialDiagnosticAt(OpLoc, PDiag(diag::err_ovl_ambiguous_oper_unary)
15874                                         << "->" << Base->getType()
15875                                         << Base->getSourceRange()),
15876          *this, OCD_AmbiguousCandidates, Base);
15877    return ExprError();
15878
15879  case OR_Deleted:
15880    CandidateSet.NoteCandidates(
15881        PartialDiagnosticAt(OpLoc, PDiag(diag::err_ovl_deleted_oper)
15882                                       << "->" << Base->getSourceRange()),
15883        *this, OCD_AllCandidates, Base);
15884    return ExprError();
15885  }
15886
15887  CheckMemberOperatorAccess(OpLoc, Base, nullptr, Best->FoundDecl);
15888
15889  // Convert the object parameter.
15890  CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
15891
15892  if (Method->isExplicitObjectMemberFunction()) {
15893    ExprResult R = InitializeExplicitObjectArgument(*this, Base, Method);
15894    if (R.isInvalid())
15895      return ExprError();
15896    Base = R.get();
15897  } else {
15898    ExprResult BaseResult = PerformImplicitObjectArgumentInitialization(
15899        Base, /*Qualifier=*/nullptr, Best->FoundDecl, Method);
15900    if (BaseResult.isInvalid())
15901      return ExprError();
15902    Base = BaseResult.get();
15903  }
15904
15905  // Build the operator call.
15906  ExprResult FnExpr = CreateFunctionRefExpr(*this, Method, Best->FoundDecl,
15907                                            Base, HadMultipleCandidates, OpLoc);
15908  if (FnExpr.isInvalid())
15909    return ExprError();
15910
15911  QualType ResultTy = Method->getReturnType();
15912  ExprValueKind VK = Expr::getValueKindForType(ResultTy);
15913  ResultTy = ResultTy.getNonLValueExprType(Context);
15914
15915  CallExpr *TheCall =
15916      CXXOperatorCallExpr::Create(Context, OO_Arrow, FnExpr.get(), Base,
15917                                  ResultTy, VK, OpLoc, CurFPFeatureOverrides());
15918
15919  if (CheckCallReturnType(Method->getReturnType(), OpLoc, TheCall, Method))
15920    return ExprError();
15921
15922  if (CheckFunctionCall(Method, TheCall,
15923                        Method->getType()->castAs<FunctionProtoType>()))
15924    return ExprError();
15925
15926  return CheckForImmediateInvocation(MaybeBindToTemporary(TheCall), Method);
15927}
15928
15929/// BuildLiteralOperatorCall - Build a UserDefinedLiteral by creating a call to
15930/// a literal operator described by the provided lookup results.
15931ExprResult Sema::BuildLiteralOperatorCall(LookupResult &R,
15932                                          DeclarationNameInfo &SuffixInfo,
15933                                          ArrayRef<Expr*> Args,
15934                                          SourceLocation LitEndLoc,
15935                                       TemplateArgumentListInfo *TemplateArgs) {
15936  SourceLocation UDSuffixLoc = SuffixInfo.getCXXLiteralOperatorNameLoc();
15937
15938  OverloadCandidateSet CandidateSet(UDSuffixLoc,
15939                                    OverloadCandidateSet::CSK_Normal);
15940  AddNonMemberOperatorCandidates(R.asUnresolvedSet(), Args, CandidateSet,
15941                                 TemplateArgs);
15942
15943  bool HadMultipleCandidates = (CandidateSet.size() > 1);
15944
15945  // Perform overload resolution. This will usually be trivial, but might need
15946  // to perform substitutions for a literal operator template.
15947  OverloadCandidateSet::iterator Best;
15948  switch (CandidateSet.BestViableFunction(*this, UDSuffixLoc, Best)) {
15949  case OR_Success:
15950  case OR_Deleted:
15951    break;
15952
15953  case OR_No_Viable_Function:
15954    CandidateSet.NoteCandidates(
15955        PartialDiagnosticAt(UDSuffixLoc,
15956                            PDiag(diag::err_ovl_no_viable_function_in_call)
15957                                << R.getLookupName()),
15958        *this, OCD_AllCandidates, Args);
15959    return ExprError();
15960
15961  case OR_Ambiguous:
15962    CandidateSet.NoteCandidates(
15963        PartialDiagnosticAt(R.getNameLoc(), PDiag(diag::err_ovl_ambiguous_call)
15964                                                << R.getLookupName()),
15965        *this, OCD_AmbiguousCandidates, Args);
15966    return ExprError();
15967  }
15968
15969  FunctionDecl *FD = Best->Function;
15970  ExprResult Fn = CreateFunctionRefExpr(*this, FD, Best->FoundDecl,
15971                                        nullptr, HadMultipleCandidates,
15972                                        SuffixInfo.getLoc(),
15973                                        SuffixInfo.getInfo());
15974  if (Fn.isInvalid())
15975    return true;
15976
15977  // Check the argument types. This should almost always be a no-op, except
15978  // that array-to-pointer decay is applied to string literals.
15979  Expr *ConvArgs[2];
15980  for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
15981    ExprResult InputInit = PerformCopyInitialization(
15982      InitializedEntity::InitializeParameter(Context, FD->getParamDecl(ArgIdx)),
15983      SourceLocation(), Args[ArgIdx]);
15984    if (InputInit.isInvalid())
15985      return true;
15986    ConvArgs[ArgIdx] = InputInit.get();
15987  }
15988
15989  QualType ResultTy = FD->getReturnType();
15990  ExprValueKind VK = Expr::getValueKindForType(ResultTy);
15991  ResultTy = ResultTy.getNonLValueExprType(Context);
15992
15993  UserDefinedLiteral *UDL = UserDefinedLiteral::Create(
15994      Context, Fn.get(), llvm::ArrayRef(ConvArgs, Args.size()), ResultTy, VK,
15995      LitEndLoc, UDSuffixLoc, CurFPFeatureOverrides());
15996
15997  if (CheckCallReturnType(FD->getReturnType(), UDSuffixLoc, UDL, FD))
15998    return ExprError();
15999
16000  if (CheckFunctionCall(FD, UDL, nullptr))
16001    return ExprError();
16002
16003  return CheckForImmediateInvocation(MaybeBindToTemporary(UDL), FD);
16004}
16005
16006/// Build a call to 'begin' or 'end' for a C++11 for-range statement. If the
16007/// given LookupResult is non-empty, it is assumed to describe a member which
16008/// will be invoked. Otherwise, the function will be found via argument
16009/// dependent lookup.
16010/// CallExpr is set to a valid expression and FRS_Success returned on success,
16011/// otherwise CallExpr is set to ExprError() and some non-success value
16012/// is returned.
16013Sema::ForRangeStatus
16014Sema::BuildForRangeBeginEndCall(SourceLocation Loc,
16015                                SourceLocation RangeLoc,
16016                                const DeclarationNameInfo &NameInfo,
16017                                LookupResult &MemberLookup,
16018                                OverloadCandidateSet *CandidateSet,
16019                                Expr *Range, ExprResult *CallExpr) {
16020  Scope *S = nullptr;
16021
16022  CandidateSet->clear(OverloadCandidateSet::CSK_Normal);
16023  if (!MemberLookup.empty()) {
16024    ExprResult MemberRef =
16025        BuildMemberReferenceExpr(Range, Range->getType(), Loc,
16026                                 /*IsPtr=*/false, CXXScopeSpec(),
16027                                 /*TemplateKWLoc=*/SourceLocation(),
16028                                 /*FirstQualifierInScope=*/nullptr,
16029                                 MemberLookup,
16030                                 /*TemplateArgs=*/nullptr, S);
16031    if (MemberRef.isInvalid()) {
16032      *CallExpr = ExprError();
16033      return FRS_DiagnosticIssued;
16034    }
16035    *CallExpr =
16036        BuildCallExpr(S, MemberRef.get(), Loc, std::nullopt, Loc, nullptr);
16037    if (CallExpr->isInvalid()) {
16038      *CallExpr = ExprError();
16039      return FRS_DiagnosticIssued;
16040    }
16041  } else {
16042    ExprResult FnR = CreateUnresolvedLookupExpr(/*NamingClass=*/nullptr,
16043                                                NestedNameSpecifierLoc(),
16044                                                NameInfo, UnresolvedSet<0>());
16045    if (FnR.isInvalid())
16046      return FRS_DiagnosticIssued;
16047    UnresolvedLookupExpr *Fn = cast<UnresolvedLookupExpr>(FnR.get());
16048
16049    bool CandidateSetError = buildOverloadedCallSet(S, Fn, Fn, Range, Loc,
16050                                                    CandidateSet, CallExpr);
16051    if (CandidateSet->empty() || CandidateSetError) {
16052      *CallExpr = ExprError();
16053      return FRS_NoViableFunction;
16054    }
16055    OverloadCandidateSet::iterator Best;
16056    OverloadingResult OverloadResult =
16057        CandidateSet->BestViableFunction(*this, Fn->getBeginLoc(), Best);
16058
16059    if (OverloadResult == OR_No_Viable_Function) {
16060      *CallExpr = ExprError();
16061      return FRS_NoViableFunction;
16062    }
16063    *CallExpr = FinishOverloadedCallExpr(*this, S, Fn, Fn, Loc, Range,
16064                                         Loc, nullptr, CandidateSet, &Best,
16065                                         OverloadResult,
16066                                         /*AllowTypoCorrection=*/false);
16067    if (CallExpr->isInvalid() || OverloadResult != OR_Success) {
16068      *CallExpr = ExprError();
16069      return FRS_DiagnosticIssued;
16070    }
16071  }
16072  return FRS_Success;
16073}
16074
16075
16076/// FixOverloadedFunctionReference - E is an expression that refers to
16077/// a C++ overloaded function (possibly with some parentheses and
16078/// perhaps a '&' around it). We have resolved the overloaded function
16079/// to the function declaration Fn, so patch up the expression E to
16080/// refer (possibly indirectly) to Fn. Returns the new expr.
16081ExprResult Sema::FixOverloadedFunctionReference(Expr *E, DeclAccessPair Found,
16082                                                FunctionDecl *Fn) {
16083  if (ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
16084    ExprResult SubExpr =
16085        FixOverloadedFunctionReference(PE->getSubExpr(), Found, Fn);
16086    if (SubExpr.isInvalid())
16087      return ExprError();
16088    if (SubExpr.get() == PE->getSubExpr())
16089      return PE;
16090
16091    return new (Context)
16092        ParenExpr(PE->getLParen(), PE->getRParen(), SubExpr.get());
16093  }
16094
16095  if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
16096    ExprResult SubExpr =
16097        FixOverloadedFunctionReference(ICE->getSubExpr(), Found, Fn);
16098    if (SubExpr.isInvalid())
16099      return ExprError();
16100    assert(Context.hasSameType(ICE->getSubExpr()->getType(),
16101                               SubExpr.get()->getType()) &&
16102           "Implicit cast type cannot be determined from overload");
16103    assert(ICE->path_empty() && "fixing up hierarchy conversion?");
16104    if (SubExpr.get() == ICE->getSubExpr())
16105      return ICE;
16106
16107    return ImplicitCastExpr::Create(Context, ICE->getType(), ICE->getCastKind(),
16108                                    SubExpr.get(), nullptr, ICE->getValueKind(),
16109                                    CurFPFeatureOverrides());
16110  }
16111
16112  if (auto *GSE = dyn_cast<GenericSelectionExpr>(E)) {
16113    if (!GSE->isResultDependent()) {
16114      ExprResult SubExpr =
16115          FixOverloadedFunctionReference(GSE->getResultExpr(), Found, Fn);
16116      if (SubExpr.isInvalid())
16117        return ExprError();
16118      if (SubExpr.get() == GSE->getResultExpr())
16119        return GSE;
16120
16121      // Replace the resulting type information before rebuilding the generic
16122      // selection expression.
16123      ArrayRef<Expr *> A = GSE->getAssocExprs();
16124      SmallVector<Expr *, 4> AssocExprs(A.begin(), A.end());
16125      unsigned ResultIdx = GSE->getResultIndex();
16126      AssocExprs[ResultIdx] = SubExpr.get();
16127
16128      if (GSE->isExprPredicate())
16129        return GenericSelectionExpr::Create(
16130            Context, GSE->getGenericLoc(), GSE->getControllingExpr(),
16131            GSE->getAssocTypeSourceInfos(), AssocExprs, GSE->getDefaultLoc(),
16132            GSE->getRParenLoc(), GSE->containsUnexpandedParameterPack(),
16133            ResultIdx);
16134      return GenericSelectionExpr::Create(
16135          Context, GSE->getGenericLoc(), GSE->getControllingType(),
16136          GSE->getAssocTypeSourceInfos(), AssocExprs, GSE->getDefaultLoc(),
16137          GSE->getRParenLoc(), GSE->containsUnexpandedParameterPack(),
16138          ResultIdx);
16139    }
16140    // Rather than fall through to the unreachable, return the original generic
16141    // selection expression.
16142    return GSE;
16143  }
16144
16145  if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(E)) {
16146    assert(UnOp->getOpcode() == UO_AddrOf &&
16147           "Can only take the address of an overloaded function");
16148    if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) {
16149      if (Method->isStatic()) {
16150        // Do nothing: static member functions aren't any different
16151        // from non-member functions.
16152      } else {
16153        // Fix the subexpression, which really has to be an
16154        // UnresolvedLookupExpr holding an overloaded member function
16155        // or template.
16156        ExprResult SubExpr =
16157            FixOverloadedFunctionReference(UnOp->getSubExpr(), Found, Fn);
16158        if (SubExpr.isInvalid())
16159          return ExprError();
16160        if (SubExpr.get() == UnOp->getSubExpr())
16161          return UnOp;
16162
16163        if (CheckUseOfCXXMethodAsAddressOfOperand(UnOp->getBeginLoc(),
16164                                                  SubExpr.get(), Method))
16165          return ExprError();
16166
16167        assert(isa<DeclRefExpr>(SubExpr.get()) &&
16168               "fixed to something other than a decl ref");
16169        assert(cast<DeclRefExpr>(SubExpr.get())->getQualifier() &&
16170               "fixed to a member ref with no nested name qualifier");
16171
16172        // We have taken the address of a pointer to member
16173        // function. Perform the computation here so that we get the
16174        // appropriate pointer to member type.
16175        QualType ClassType
16176          = Context.getTypeDeclType(cast<RecordDecl>(Method->getDeclContext()));
16177        QualType MemPtrType
16178          = Context.getMemberPointerType(Fn->getType(), ClassType.getTypePtr());
16179        // Under the MS ABI, lock down the inheritance model now.
16180        if (Context.getTargetInfo().getCXXABI().isMicrosoft())
16181          (void)isCompleteType(UnOp->getOperatorLoc(), MemPtrType);
16182
16183        return UnaryOperator::Create(Context, SubExpr.get(), UO_AddrOf,
16184                                     MemPtrType, VK_PRValue, OK_Ordinary,
16185                                     UnOp->getOperatorLoc(), false,
16186                                     CurFPFeatureOverrides());
16187      }
16188    }
16189    ExprResult SubExpr =
16190        FixOverloadedFunctionReference(UnOp->getSubExpr(), Found, Fn);
16191    if (SubExpr.isInvalid())
16192      return ExprError();
16193    if (SubExpr.get() == UnOp->getSubExpr())
16194      return UnOp;
16195
16196    return CreateBuiltinUnaryOp(UnOp->getOperatorLoc(), UO_AddrOf,
16197                                SubExpr.get());
16198  }
16199
16200  if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
16201    // FIXME: avoid copy.
16202    TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
16203    if (ULE->hasExplicitTemplateArgs()) {
16204      ULE->copyTemplateArgumentsInto(TemplateArgsBuffer);
16205      TemplateArgs = &TemplateArgsBuffer;
16206    }
16207
16208    QualType Type = Fn->getType();
16209    ExprValueKind ValueKind = getLangOpts().CPlusPlus ? VK_LValue : VK_PRValue;
16210
16211    // FIXME: Duplicated from BuildDeclarationNameExpr.
16212    if (unsigned BID = Fn->getBuiltinID()) {
16213      if (!Context.BuiltinInfo.isDirectlyAddressable(BID)) {
16214        Type = Context.BuiltinFnTy;
16215        ValueKind = VK_PRValue;
16216      }
16217    }
16218
16219    DeclRefExpr *DRE = BuildDeclRefExpr(
16220        Fn, Type, ValueKind, ULE->getNameInfo(), ULE->getQualifierLoc(),
16221        Found.getDecl(), ULE->getTemplateKeywordLoc(), TemplateArgs);
16222    DRE->setHadMultipleCandidates(ULE->getNumDecls() > 1);
16223    return DRE;
16224  }
16225
16226  if (UnresolvedMemberExpr *MemExpr = dyn_cast<UnresolvedMemberExpr>(E)) {
16227    // FIXME: avoid copy.
16228    TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
16229    if (MemExpr->hasExplicitTemplateArgs()) {
16230      MemExpr->copyTemplateArgumentsInto(TemplateArgsBuffer);
16231      TemplateArgs = &TemplateArgsBuffer;
16232    }
16233
16234    Expr *Base;
16235
16236    // If we're filling in a static method where we used to have an
16237    // implicit member access, rewrite to a simple decl ref.
16238    if (MemExpr->isImplicitAccess()) {
16239      if (cast<CXXMethodDecl>(Fn)->isStatic()) {
16240        DeclRefExpr *DRE = BuildDeclRefExpr(
16241            Fn, Fn->getType(), VK_LValue, MemExpr->getNameInfo(),
16242            MemExpr->getQualifierLoc(), Found.getDecl(),
16243            MemExpr->getTemplateKeywordLoc(), TemplateArgs);
16244        DRE->setHadMultipleCandidates(MemExpr->getNumDecls() > 1);
16245        return DRE;
16246      } else {
16247        SourceLocation Loc = MemExpr->getMemberLoc();
16248        if (MemExpr->getQualifier())
16249          Loc = MemExpr->getQualifierLoc().getBeginLoc();
16250        Base =
16251            BuildCXXThisExpr(Loc, MemExpr->getBaseType(), /*IsImplicit=*/true);
16252      }
16253    } else
16254      Base = MemExpr->getBase();
16255
16256    ExprValueKind valueKind;
16257    QualType type;
16258    if (cast<CXXMethodDecl>(Fn)->isStatic()) {
16259      valueKind = VK_LValue;
16260      type = Fn->getType();
16261    } else {
16262      valueKind = VK_PRValue;
16263      type = Context.BoundMemberTy;
16264    }
16265
16266    return BuildMemberExpr(
16267        Base, MemExpr->isArrow(), MemExpr->getOperatorLoc(),
16268        MemExpr->getQualifierLoc(), MemExpr->getTemplateKeywordLoc(), Fn, Found,
16269        /*HadMultipleCandidates=*/true, MemExpr->getMemberNameInfo(),
16270        type, valueKind, OK_Ordinary, TemplateArgs);
16271  }
16272
16273  llvm_unreachable("Invalid reference to overloaded function");
16274}
16275
16276ExprResult Sema::FixOverloadedFunctionReference(ExprResult E,
16277                                                DeclAccessPair Found,
16278                                                FunctionDecl *Fn) {
16279  return FixOverloadedFunctionReference(E.get(), Found, Fn);
16280}
16281
16282bool clang::shouldEnforceArgLimit(bool PartialOverloading,
16283                                  FunctionDecl *Function) {
16284  if (!PartialOverloading || !Function)
16285    return true;
16286  if (Function->isVariadic())
16287    return false;
16288  if (const auto *Proto =
16289          dyn_cast<FunctionProtoType>(Function->getFunctionType()))
16290    if (Proto->isTemplateVariadic())
16291      return false;
16292  if (auto *Pattern = Function->getTemplateInstantiationPattern())
16293    if (const auto *Proto =
16294            dyn_cast<FunctionProtoType>(Pattern->getFunctionType()))
16295      if (Proto->isTemplateVariadic())
16296        return false;
16297  return true;
16298}
16299