clang  6.0.0
SemaOverload.cpp
Go to the documentation of this file.
1 //===--- SemaOverload.cpp - C++ Overloading -------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file provides Sema routines for C++ overloading.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/Sema/Overload.h"
15 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/DeclObjC.h"
18 #include "clang/AST/Expr.h"
19 #include "clang/AST/ExprCXX.h"
20 #include "clang/AST/ExprObjC.h"
21 #include "clang/AST/TypeOrdering.h"
22 #include "clang/Basic/Diagnostic.h"
25 #include "clang/Basic/TargetInfo.h"
27 #include "clang/Sema/Lookup.h"
29 #include "clang/Sema/Template.h"
31 #include "llvm/ADT/DenseSet.h"
32 #include "llvm/ADT/Optional.h"
33 #include "llvm/ADT/STLExtras.h"
34 #include "llvm/ADT/SmallPtrSet.h"
35 #include "llvm/ADT/SmallString.h"
36 #include <algorithm>
37 #include <cstdlib>
38 
39 using namespace clang;
40 using namespace sema;
41 
43  return llvm::any_of(FD->parameters(), [](const ParmVarDecl *P) {
44  return P->hasAttr<PassObjectSizeAttr>();
45  });
46 }
47 
48 /// A convenience routine for creating a decayed reference to a function.
49 static ExprResult
51  const Expr *Base, bool HadMultipleCandidates,
53  const DeclarationNameLoc &LocInfo = DeclarationNameLoc()){
54  if (S.DiagnoseUseOfDecl(FoundDecl, Loc))
55  return ExprError();
56  // If FoundDecl is different from Fn (such as if one is a template
57  // and the other a specialization), make sure DiagnoseUseOfDecl is
58  // called on both.
59  // FIXME: This would be more comprehensively addressed by modifying
60  // DiagnoseUseOfDecl to accept both the FoundDecl and the decl
61  // being used.
62  if (FoundDecl != Fn && S.DiagnoseUseOfDecl(Fn, Loc))
63  return ExprError();
64  if (auto *FPT = Fn->getType()->getAs<FunctionProtoType>())
65  S.ResolveExceptionSpec(Loc, FPT);
66  DeclRefExpr *DRE = new (S.Context) DeclRefExpr(Fn, false, Fn->getType(),
67  VK_LValue, Loc, LocInfo);
68  if (HadMultipleCandidates)
69  DRE->setHadMultipleCandidates(true);
70 
71  S.MarkDeclRefReferenced(DRE, Base);
72  return S.ImpCastExprToType(DRE, S.Context.getPointerType(DRE->getType()),
73  CK_FunctionToPointerDecay);
74 }
75 
76 static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
77  bool InOverloadResolution,
79  bool CStyle,
80  bool AllowObjCWritebackConversion);
81 
82 static bool IsTransparentUnionStandardConversion(Sema &S, Expr* From,
83  QualType &ToType,
84  bool InOverloadResolution,
86  bool CStyle);
87 static OverloadingResult
88 IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
90  OverloadCandidateSet& Conversions,
91  bool AllowExplicit,
92  bool AllowObjCConversionOnExplicit);
93 
94 
97  const StandardConversionSequence& SCS1,
98  const StandardConversionSequence& SCS2);
99 
102  const StandardConversionSequence& SCS1,
103  const StandardConversionSequence& SCS2);
104 
107  const StandardConversionSequence& SCS1,
108  const StandardConversionSequence& SCS2);
109 
110 /// GetConversionRank - Retrieve the implicit conversion rank
111 /// corresponding to the given implicit conversion kind.
113  static const ImplicitConversionRank
114  Rank[(int)ICK_Num_Conversion_Kinds] = {
139  ICR_Exact_Match, // NOTE(gbiv): This may not be completely right --
140  // it was omitted by the patch that added
141  // ICK_Zero_Event_Conversion
144  };
145  return Rank[(int)Kind];
146 }
147 
148 /// GetImplicitConversionName - Return the name of this kind of
149 /// implicit conversion.
151  static const char* const Name[(int)ICK_Num_Conversion_Kinds] = {
152  "No conversion",
153  "Lvalue-to-rvalue",
154  "Array-to-pointer",
155  "Function-to-pointer",
156  "Function pointer conversion",
157  "Qualification",
158  "Integral promotion",
159  "Floating point promotion",
160  "Complex promotion",
161  "Integral conversion",
162  "Floating conversion",
163  "Complex conversion",
164  "Floating-integral conversion",
165  "Pointer conversion",
166  "Pointer-to-member conversion",
167  "Boolean conversion",
168  "Compatible-types conversion",
169  "Derived-to-base conversion",
170  "Vector conversion",
171  "Vector splat",
172  "Complex-real conversion",
173  "Block Pointer conversion",
174  "Transparent Union Conversion",
175  "Writeback conversion",
176  "OpenCL Zero Event Conversion",
177  "C specific type conversion",
178  "Incompatible pointer conversion"
179  };
180  return Name[Kind];
181 }
182 
183 /// StandardConversionSequence - Set the standard conversion
184 /// sequence to the identity conversion.
186  First = ICK_Identity;
187  Second = ICK_Identity;
188  Third = ICK_Identity;
189  DeprecatedStringLiteralToCharPtr = false;
190  QualificationIncludesObjCLifetime = false;
191  ReferenceBinding = false;
192  DirectBinding = false;
193  IsLvalueReference = true;
194  BindsToFunctionLvalue = false;
195  BindsToRvalue = false;
196  BindsImplicitObjectArgumentWithoutRefQualifier = false;
197  ObjCLifetimeConversionBinding = false;
198  CopyConstructor = nullptr;
199 }
200 
201 /// getRank - Retrieve the rank of this standard conversion sequence
202 /// (C++ 13.3.3.1.1p3). The rank is the largest rank of each of the
203 /// implicit conversions.
206  if (GetConversionRank(First) > Rank)
207  Rank = GetConversionRank(First);
208  if (GetConversionRank(Second) > Rank)
209  Rank = GetConversionRank(Second);
210  if (GetConversionRank(Third) > Rank)
211  Rank = GetConversionRank(Third);
212  return Rank;
213 }
214 
215 /// isPointerConversionToBool - Determines whether this conversion is
216 /// a conversion of a pointer or pointer-to-member to bool. This is
217 /// used as part of the ranking of standard conversion sequences
218 /// (C++ 13.3.3.2p4).
220  // Note that FromType has not necessarily been transformed by the
221  // array-to-pointer or function-to-pointer implicit conversions, so
222  // check for their presence as well as checking whether FromType is
223  // a pointer.
224  if (getToType(1)->isBooleanType() &&
225  (getFromType()->isPointerType() ||
226  getFromType()->isObjCObjectPointerType() ||
227  getFromType()->isBlockPointerType() ||
228  getFromType()->isNullPtrType() ||
229  First == ICK_Array_To_Pointer || First == ICK_Function_To_Pointer))
230  return true;
231 
232  return false;
233 }
234 
235 /// isPointerConversionToVoidPointer - Determines whether this
236 /// conversion is a conversion of a pointer to a void pointer. This is
237 /// used as part of the ranking of standard conversion sequences (C++
238 /// 13.3.3.2p4).
239 bool
242  QualType FromType = getFromType();
243  QualType ToType = getToType(1);
244 
245  // Note that FromType has not necessarily been transformed by the
246  // array-to-pointer implicit conversion, so check for its presence
247  // and redo the conversion to get a pointer.
248  if (First == ICK_Array_To_Pointer)
249  FromType = Context.getArrayDecayedType(FromType);
250 
251  if (Second == ICK_Pointer_Conversion && FromType->isAnyPointerType())
252  if (const PointerType* ToPtrType = ToType->getAs<PointerType>())
253  return ToPtrType->getPointeeType()->isVoidType();
254 
255  return false;
256 }
257 
258 /// Skip any implicit casts which could be either part of a narrowing conversion
259 /// or after one in an implicit conversion.
260 static const Expr *IgnoreNarrowingConversion(const Expr *Converted) {
261  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Converted)) {
262  switch (ICE->getCastKind()) {
263  case CK_NoOp:
264  case CK_IntegralCast:
265  case CK_IntegralToBoolean:
266  case CK_IntegralToFloating:
267  case CK_BooleanToSignedIntegral:
268  case CK_FloatingToIntegral:
269  case CK_FloatingToBoolean:
270  case CK_FloatingCast:
271  Converted = ICE->getSubExpr();
272  continue;
273 
274  default:
275  return Converted;
276  }
277  }
278 
279  return Converted;
280 }
281 
282 /// Check if this standard conversion sequence represents a narrowing
283 /// conversion, according to C++11 [dcl.init.list]p7.
284 ///
285 /// \param Ctx The AST context.
286 /// \param Converted The result of applying this standard conversion sequence.
287 /// \param ConstantValue If this is an NK_Constant_Narrowing conversion, the
288 /// value of the expression prior to the narrowing conversion.
289 /// \param ConstantType If this is an NK_Constant_Narrowing conversion, the
290 /// type of the expression prior to the narrowing conversion.
293  const Expr *Converted,
294  APValue &ConstantValue,
295  QualType &ConstantType) const {
296  assert(Ctx.getLangOpts().CPlusPlus && "narrowing check outside C++");
297 
298  // C++11 [dcl.init.list]p7:
299  // A narrowing conversion is an implicit conversion ...
300  QualType FromType = getToType(0);
301  QualType ToType = getToType(1);
302 
303  // A conversion to an enumeration type is narrowing if the conversion to
304  // the underlying type is narrowing. This only arises for expressions of
305  // the form 'Enum{init}'.
306  if (auto *ET = ToType->getAs<EnumType>())
307  ToType = ET->getDecl()->getIntegerType();
308 
309  switch (Second) {
310  // 'bool' is an integral type; dispatch to the right place to handle it.
312  if (FromType->isRealFloatingType())
313  goto FloatingIntegralConversion;
314  if (FromType->isIntegralOrUnscopedEnumerationType())
315  goto IntegralConversion;
316  // Boolean conversions can be from pointers and pointers to members
317  // [conv.bool], and those aren't considered narrowing conversions.
318  return NK_Not_Narrowing;
319 
320  // -- from a floating-point type to an integer type, or
321  //
322  // -- from an integer type or unscoped enumeration type to a floating-point
323  // type, except where the source is a constant expression and the actual
324  // value after conversion will fit into the target type and will produce
325  // the original value when converted back to the original type, or
327  FloatingIntegralConversion:
328  if (FromType->isRealFloatingType() && ToType->isIntegralType(Ctx)) {
329  return NK_Type_Narrowing;
330  } else if (FromType->isIntegralType(Ctx) && ToType->isRealFloatingType()) {
331  llvm::APSInt IntConstantValue;
332  const Expr *Initializer = IgnoreNarrowingConversion(Converted);
333  assert(Initializer && "Unknown conversion expression");
334 
335  // If it's value-dependent, we can't tell whether it's narrowing.
336  if (Initializer->isValueDependent())
337  return NK_Dependent_Narrowing;
338 
339  if (Initializer->isIntegerConstantExpr(IntConstantValue, Ctx)) {
340  // Convert the integer to the floating type.
341  llvm::APFloat Result(Ctx.getFloatTypeSemantics(ToType));
342  Result.convertFromAPInt(IntConstantValue, IntConstantValue.isSigned(),
343  llvm::APFloat::rmNearestTiesToEven);
344  // And back.
345  llvm::APSInt ConvertedValue = IntConstantValue;
346  bool ignored;
347  Result.convertToInteger(ConvertedValue,
348  llvm::APFloat::rmTowardZero, &ignored);
349  // If the resulting value is different, this was a narrowing conversion.
350  if (IntConstantValue != ConvertedValue) {
351  ConstantValue = APValue(IntConstantValue);
352  ConstantType = Initializer->getType();
353  return NK_Constant_Narrowing;
354  }
355  } else {
356  // Variables are always narrowings.
357  return NK_Variable_Narrowing;
358  }
359  }
360  return NK_Not_Narrowing;
361 
362  // -- from long double to double or float, or from double to float, except
363  // where the source is a constant expression and the actual value after
364  // conversion is within the range of values that can be represented (even
365  // if it cannot be represented exactly), or
367  if (FromType->isRealFloatingType() && ToType->isRealFloatingType() &&
368  Ctx.getFloatingTypeOrder(FromType, ToType) == 1) {
369  // FromType is larger than ToType.
370  const Expr *Initializer = IgnoreNarrowingConversion(Converted);
371 
372  // If it's value-dependent, we can't tell whether it's narrowing.
373  if (Initializer->isValueDependent())
374  return NK_Dependent_Narrowing;
375 
376  if (Initializer->isCXX11ConstantExpr(Ctx, &ConstantValue)) {
377  // Constant!
378  assert(ConstantValue.isFloat());
379  llvm::APFloat FloatVal = ConstantValue.getFloat();
380  // Convert the source value into the target type.
381  bool ignored;
382  llvm::APFloat::opStatus ConvertStatus = FloatVal.convert(
383  Ctx.getFloatTypeSemantics(ToType),
384  llvm::APFloat::rmNearestTiesToEven, &ignored);
385  // If there was no overflow, the source value is within the range of
386  // values that can be represented.
387  if (ConvertStatus & llvm::APFloat::opOverflow) {
388  ConstantType = Initializer->getType();
389  return NK_Constant_Narrowing;
390  }
391  } else {
392  return NK_Variable_Narrowing;
393  }
394  }
395  return NK_Not_Narrowing;
396 
397  // -- from an integer type or unscoped enumeration type to an integer type
398  // that cannot represent all the values of the original type, except where
399  // the source is a constant expression and the actual value after
400  // conversion will fit into the target type and will produce the original
401  // value when converted back to the original type.
403  IntegralConversion: {
404  assert(FromType->isIntegralOrUnscopedEnumerationType());
405  assert(ToType->isIntegralOrUnscopedEnumerationType());
406  const bool FromSigned = FromType->isSignedIntegerOrEnumerationType();
407  const unsigned FromWidth = Ctx.getIntWidth(FromType);
408  const bool ToSigned = ToType->isSignedIntegerOrEnumerationType();
409  const unsigned ToWidth = Ctx.getIntWidth(ToType);
410 
411  if (FromWidth > ToWidth ||
412  (FromWidth == ToWidth && FromSigned != ToSigned) ||
413  (FromSigned && !ToSigned)) {
414  // Not all values of FromType can be represented in ToType.
415  llvm::APSInt InitializerValue;
416  const Expr *Initializer = IgnoreNarrowingConversion(Converted);
417 
418  // If it's value-dependent, we can't tell whether it's narrowing.
419  if (Initializer->isValueDependent())
420  return NK_Dependent_Narrowing;
421 
422  if (!Initializer->isIntegerConstantExpr(InitializerValue, Ctx)) {
423  // Such conversions on variables are always narrowing.
424  return NK_Variable_Narrowing;
425  }
426  bool Narrowing = false;
427  if (FromWidth < ToWidth) {
428  // Negative -> unsigned is narrowing. Otherwise, more bits is never
429  // narrowing.
430  if (InitializerValue.isSigned() && InitializerValue.isNegative())
431  Narrowing = true;
432  } else {
433  // Add a bit to the InitializerValue so we don't have to worry about
434  // signed vs. unsigned comparisons.
435  InitializerValue = InitializerValue.extend(
436  InitializerValue.getBitWidth() + 1);
437  // Convert the initializer to and from the target width and signed-ness.
438  llvm::APSInt ConvertedValue = InitializerValue;
439  ConvertedValue = ConvertedValue.trunc(ToWidth);
440  ConvertedValue.setIsSigned(ToSigned);
441  ConvertedValue = ConvertedValue.extend(InitializerValue.getBitWidth());
442  ConvertedValue.setIsSigned(InitializerValue.isSigned());
443  // If the result is different, this was a narrowing conversion.
444  if (ConvertedValue != InitializerValue)
445  Narrowing = true;
446  }
447  if (Narrowing) {
448  ConstantType = Initializer->getType();
449  ConstantValue = APValue(InitializerValue);
450  return NK_Constant_Narrowing;
451  }
452  }
453  return NK_Not_Narrowing;
454  }
455 
456  default:
457  // Other kinds of conversions are not narrowings.
458  return NK_Not_Narrowing;
459  }
460 }
461 
462 /// dump - Print this standard conversion sequence to standard
463 /// error. Useful for debugging overloading issues.
464 LLVM_DUMP_METHOD void StandardConversionSequence::dump() const {
465  raw_ostream &OS = llvm::errs();
466  bool PrintedSomething = false;
467  if (First != ICK_Identity) {
468  OS << GetImplicitConversionName(First);
469  PrintedSomething = true;
470  }
471 
472  if (Second != ICK_Identity) {
473  if (PrintedSomething) {
474  OS << " -> ";
475  }
476  OS << GetImplicitConversionName(Second);
477 
478  if (CopyConstructor) {
479  OS << " (by copy constructor)";
480  } else if (DirectBinding) {
481  OS << " (direct reference binding)";
482  } else if (ReferenceBinding) {
483  OS << " (reference binding)";
484  }
485  PrintedSomething = true;
486  }
487 
488  if (Third != ICK_Identity) {
489  if (PrintedSomething) {
490  OS << " -> ";
491  }
492  OS << GetImplicitConversionName(Third);
493  PrintedSomething = true;
494  }
495 
496  if (!PrintedSomething) {
497  OS << "No conversions required";
498  }
499 }
500 
501 /// dump - Print this user-defined conversion sequence to standard
502 /// error. Useful for debugging overloading issues.
504  raw_ostream &OS = llvm::errs();
505  if (Before.First || Before.Second || Before.Third) {
506  Before.dump();
507  OS << " -> ";
508  }
509  if (ConversionFunction)
510  OS << '\'' << *ConversionFunction << '\'';
511  else
512  OS << "aggregate initialization";
513  if (After.First || After.Second || After.Third) {
514  OS << " -> ";
515  After.dump();
516  }
517 }
518 
519 /// dump - Print this implicit conversion sequence to standard
520 /// error. Useful for debugging overloading issues.
522  raw_ostream &OS = llvm::errs();
523  if (isStdInitializerListElement())
524  OS << "Worst std::initializer_list element conversion: ";
525  switch (ConversionKind) {
526  case StandardConversion:
527  OS << "Standard conversion: ";
528  Standard.dump();
529  break;
530  case UserDefinedConversion:
531  OS << "User-defined conversion: ";
532  UserDefined.dump();
533  break;
534  case EllipsisConversion:
535  OS << "Ellipsis conversion";
536  break;
537  case AmbiguousConversion:
538  OS << "Ambiguous conversion";
539  break;
540  case BadConversion:
541  OS << "Bad conversion";
542  break;
543  }
544 
545  OS << "\n";
546 }
547 
549  new (&conversions()) ConversionSet();
550 }
551 
553  conversions().~ConversionSet();
554 }
555 
556 void
558  FromTypePtr = O.FromTypePtr;
559  ToTypePtr = O.ToTypePtr;
560  new (&conversions()) ConversionSet(O.conversions());
561 }
562 
563 namespace {
564  // Structure used by DeductionFailureInfo to store
565  // template argument information.
566  struct DFIArguments {
567  TemplateArgument FirstArg;
568  TemplateArgument SecondArg;
569  };
570  // Structure used by DeductionFailureInfo to store
571  // template parameter and template argument information.
572  struct DFIParamWithArguments : DFIArguments {
573  TemplateParameter Param;
574  };
575  // Structure used by DeductionFailureInfo to store template argument
576  // information and the index of the problematic call argument.
577  struct DFIDeducedMismatchArgs : DFIArguments {
578  TemplateArgumentList *TemplateArgs;
579  unsigned CallArgIndex;
580  };
581 }
582 
583 /// \brief Convert from Sema's representation of template deduction information
584 /// to the form used in overload-candidate information.
588  TemplateDeductionInfo &Info) {
589  DeductionFailureInfo Result;
590  Result.Result = static_cast<unsigned>(TDK);
591  Result.HasDiagnostic = false;
592  switch (TDK) {
593  case Sema::TDK_Invalid:
599  Result.Data = nullptr;
600  break;
601 
604  Result.Data = Info.Param.getOpaqueValue();
605  break;
606 
609  // FIXME: Should allocate from normal heap so that we can free this later.
610  auto *Saved = new (Context) DFIDeducedMismatchArgs;
611  Saved->FirstArg = Info.FirstArg;
612  Saved->SecondArg = Info.SecondArg;
613  Saved->TemplateArgs = Info.take();
614  Saved->CallArgIndex = Info.CallArgIndex;
615  Result.Data = Saved;
616  break;
617  }
618 
620  // FIXME: Should allocate from normal heap so that we can free this later.
621  DFIArguments *Saved = new (Context) DFIArguments;
622  Saved->FirstArg = Info.FirstArg;
623  Saved->SecondArg = Info.SecondArg;
624  Result.Data = Saved;
625  break;
626  }
627 
630  // FIXME: Should allocate from normal heap so that we can free this later.
631  DFIParamWithArguments *Saved = new (Context) DFIParamWithArguments;
632  Saved->Param = Info.Param;
633  Saved->FirstArg = Info.FirstArg;
634  Saved->SecondArg = Info.SecondArg;
635  Result.Data = Saved;
636  break;
637  }
638 
640  Result.Data = Info.take();
641  if (Info.hasSFINAEDiagnostic()) {
644  Info.takeSFINAEDiagnostic(*Diag);
645  Result.HasDiagnostic = true;
646  }
647  break;
648 
649  case Sema::TDK_Success:
651  llvm_unreachable("not a deduction failure");
652  }
653 
654  return Result;
655 }
656 
658  switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
659  case Sema::TDK_Success:
660  case Sema::TDK_Invalid:
668  break;
669 
675  // FIXME: Destroy the data?
676  Data = nullptr;
677  break;
678 
680  // FIXME: Destroy the template argument list?
681  Data = nullptr;
682  if (PartialDiagnosticAt *Diag = getSFINAEDiagnostic()) {
683  Diag->~PartialDiagnosticAt();
684  HasDiagnostic = false;
685  }
686  break;
687 
688  // Unhandled
690  break;
691  }
692 }
693 
695  if (HasDiagnostic)
696  return static_cast<PartialDiagnosticAt*>(static_cast<void*>(Diagnostic));
697  return nullptr;
698 }
699 
701  switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
702  case Sema::TDK_Success:
703  case Sema::TDK_Invalid:
713  return TemplateParameter();
714 
717  return TemplateParameter::getFromOpaqueValue(Data);
718 
721  return static_cast<DFIParamWithArguments*>(Data)->Param;
722 
723  // Unhandled
725  break;
726  }
727 
728  return TemplateParameter();
729 }
730 
732  switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
733  case Sema::TDK_Success:
734  case Sema::TDK_Invalid:
745  return nullptr;
746 
749  return static_cast<DFIDeducedMismatchArgs*>(Data)->TemplateArgs;
750 
752  return static_cast<TemplateArgumentList*>(Data);
753 
754  // Unhandled
756  break;
757  }
758 
759  return nullptr;
760 }
761 
763  switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
764  case Sema::TDK_Success:
765  case Sema::TDK_Invalid:
774  return nullptr;
775 
781  return &static_cast<DFIArguments*>(Data)->FirstArg;
782 
783  // Unhandled
785  break;
786  }
787 
788  return nullptr;
789 }
790 
792  switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
793  case Sema::TDK_Success:
794  case Sema::TDK_Invalid:
803  return nullptr;
804 
810  return &static_cast<DFIArguments*>(Data)->SecondArg;
811 
812  // Unhandled
814  break;
815  }
816 
817  return nullptr;
818 }
819 
821  switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
824  return static_cast<DFIDeducedMismatchArgs*>(Data)->CallArgIndex;
825 
826  default:
827  return llvm::None;
828  }
829 }
830 
831 void OverloadCandidateSet::destroyCandidates() {
832  for (iterator i = begin(), e = end(); i != e; ++i) {
833  for (auto &C : i->Conversions)
834  C.~ImplicitConversionSequence();
835  if (!i->Viable && i->FailureKind == ovl_fail_bad_deduction)
836  i->DeductionFailure.Destroy();
837  }
838 }
839 
841  destroyCandidates();
842  SlabAllocator.Reset();
843  NumInlineBytesUsed = 0;
844  Candidates.clear();
845  Functions.clear();
846  Kind = CSK;
847 }
848 
849 namespace {
850  class UnbridgedCastsSet {
851  struct Entry {
852  Expr **Addr;
853  Expr *Saved;
854  };
855  SmallVector<Entry, 2> Entries;
856 
857  public:
858  void save(Sema &S, Expr *&E) {
859  assert(E->hasPlaceholderType(BuiltinType::ARCUnbridgedCast));
860  Entry entry = { &E, E };
861  Entries.push_back(entry);
862  E = S.stripARCUnbridgedCast(E);
863  }
864 
865  void restore() {
867  i = Entries.begin(), e = Entries.end(); i != e; ++i)
868  *i->Addr = i->Saved;
869  }
870  };
871 }
872 
873 /// checkPlaceholderForOverload - Do any interesting placeholder-like
874 /// preprocessing on the given expression.
875 ///
876 /// \param unbridgedCasts a collection to which to add unbridged casts;
877 /// without this, they will be immediately diagnosed as errors
878 ///
879 /// Return true on unrecoverable error.
880 static bool
882  UnbridgedCastsSet *unbridgedCasts = nullptr) {
883  if (const BuiltinType *placeholder = E->getType()->getAsPlaceholderType()) {
884  // We can't handle overloaded expressions here because overload
885  // resolution might reasonably tweak them.
886  if (placeholder->getKind() == BuiltinType::Overload) return false;
887 
888  // If the context potentially accepts unbridged ARC casts, strip
889  // the unbridged cast and add it to the collection for later restoration.
890  if (placeholder->getKind() == BuiltinType::ARCUnbridgedCast &&
891  unbridgedCasts) {
892  unbridgedCasts->save(S, E);
893  return false;
894  }
895 
896  // Go ahead and check everything else.
897  ExprResult result = S.CheckPlaceholderExpr(E);
898  if (result.isInvalid())
899  return true;
900 
901  E = result.get();
902  return false;
903  }
904 
905  // Nothing to do.
906  return false;
907 }
908 
909 /// checkArgPlaceholdersForOverload - Check a set of call operands for
910 /// placeholders.
912  MultiExprArg Args,
913  UnbridgedCastsSet &unbridged) {
914  for (unsigned i = 0, e = Args.size(); i != e; ++i)
915  if (checkPlaceholderForOverload(S, Args[i], &unbridged))
916  return true;
917 
918  return false;
919 }
920 
921 /// Determine whether the given New declaration is an overload of the
922 /// declarations in Old. This routine returns Ovl_Match or Ovl_NonFunction if
923 /// New and Old cannot be overloaded, e.g., if New has the same signature as
924 /// some function in Old (C++ 1.3.10) or if the Old declarations aren't
925 /// functions (or function templates) at all. When it does return Ovl_Match or
926 /// Ovl_NonFunction, MatchedDecl will point to the decl that New cannot be
927 /// overloaded with. This decl may be a UsingShadowDecl on top of the underlying
928 /// declaration.
929 ///
930 /// Example: Given the following input:
931 ///
932 /// void f(int, float); // #1
933 /// void f(int, int); // #2
934 /// int f(int, int); // #3
935 ///
936 /// When we process #1, there is no previous declaration of "f", so IsOverload
937 /// will not be used.
938 ///
939 /// When we process #2, Old contains only the FunctionDecl for #1. By comparing
940 /// the parameter types, we see that #1 and #2 are overloaded (since they have
941 /// different signatures), so this routine returns Ovl_Overload; MatchedDecl is
942 /// unchanged.
943 ///
944 /// When we process #3, Old is an overload set containing #1 and #2. We compare
945 /// the signatures of #3 to #1 (they're overloaded, so we do nothing) and then
946 /// #3 to #2. Since the signatures of #3 and #2 are identical (return types of
947 /// functions are not part of the signature), IsOverload returns Ovl_Match and
948 /// MatchedDecl will be set to point to the FunctionDecl for #2.
949 ///
950 /// 'NewIsUsingShadowDecl' indicates that 'New' is being introduced into a class
951 /// by a using declaration. The rules for whether to hide shadow declarations
952 /// ignore some properties which otherwise figure into a function template's
953 /// signature.
956  NamedDecl *&Match, bool NewIsUsingDecl) {
957  for (LookupResult::iterator I = Old.begin(), E = Old.end();
958  I != E; ++I) {
959  NamedDecl *OldD = *I;
960 
961  bool OldIsUsingDecl = false;
962  if (isa<UsingShadowDecl>(OldD)) {
963  OldIsUsingDecl = true;
964 
965  // We can always introduce two using declarations into the same
966  // context, even if they have identical signatures.
967  if (NewIsUsingDecl) continue;
968 
969  OldD = cast<UsingShadowDecl>(OldD)->getTargetDecl();
970  }
971 
972  // A using-declaration does not conflict with another declaration
973  // if one of them is hidden.
974  if ((OldIsUsingDecl || NewIsUsingDecl) && !isVisible(*I))
975  continue;
976 
977  // If either declaration was introduced by a using declaration,
978  // we'll need to use slightly different rules for matching.
979  // Essentially, these rules are the normal rules, except that
980  // function templates hide function templates with different
981  // return types or template parameter lists.
982  bool UseMemberUsingDeclRules =
983  (OldIsUsingDecl || NewIsUsingDecl) && CurContext->isRecord() &&
984  !New->getFriendObjectKind();
985 
986  if (FunctionDecl *OldF = OldD->getAsFunction()) {
987  if (!IsOverload(New, OldF, UseMemberUsingDeclRules)) {
988  if (UseMemberUsingDeclRules && OldIsUsingDecl) {
989  HideUsingShadowDecl(S, cast<UsingShadowDecl>(*I));
990  continue;
991  }
992 
993  if (!isa<FunctionTemplateDecl>(OldD) &&
994  !shouldLinkPossiblyHiddenDecl(*I, New))
995  continue;
996 
997  Match = *I;
998  return Ovl_Match;
999  }
1000  } else if (isa<UsingDecl>(OldD) || isa<UsingPackDecl>(OldD)) {
1001  // We can overload with these, which can show up when doing
1002  // redeclaration checks for UsingDecls.
1003  assert(Old.getLookupKind() == LookupUsingDeclName);
1004  } else if (isa<TagDecl>(OldD)) {
1005  // We can always overload with tags by hiding them.
1006  } else if (auto *UUD = dyn_cast<UnresolvedUsingValueDecl>(OldD)) {
1007  // Optimistically assume that an unresolved using decl will
1008  // overload; if it doesn't, we'll have to diagnose during
1009  // template instantiation.
1010  //
1011  // Exception: if the scope is dependent and this is not a class
1012  // member, the using declaration can only introduce an enumerator.
1013  if (UUD->getQualifier()->isDependent() && !UUD->isCXXClassMember()) {
1014  Match = *I;
1015  return Ovl_NonFunction;
1016  }
1017  } else {
1018  // (C++ 13p1):
1019  // Only function declarations can be overloaded; object and type
1020  // declarations cannot be overloaded.
1021  Match = *I;
1022  return Ovl_NonFunction;
1023  }
1024  }
1025 
1026  return Ovl_Overload;
1027 }
1028 
1030  bool UseMemberUsingDeclRules, bool ConsiderCudaAttrs) {
1031  // C++ [basic.start.main]p2: This function shall not be overloaded.
1032  if (New->isMain())
1033  return false;
1034 
1035  // MSVCRT user defined entry points cannot be overloaded.
1036  if (New->isMSVCRTEntryPoint())
1037  return false;
1038 
1039  FunctionTemplateDecl *OldTemplate = Old->getDescribedFunctionTemplate();
1040  FunctionTemplateDecl *NewTemplate = New->getDescribedFunctionTemplate();
1041 
1042  // C++ [temp.fct]p2:
1043  // A function template can be overloaded with other function templates
1044  // and with normal (non-template) functions.
1045  if ((OldTemplate == nullptr) != (NewTemplate == nullptr))
1046  return true;
1047 
1048  // Is the function New an overload of the function Old?
1049  QualType OldQType = Context.getCanonicalType(Old->getType());
1050  QualType NewQType = Context.getCanonicalType(New->getType());
1051 
1052  // Compare the signatures (C++ 1.3.10) of the two functions to
1053  // determine whether they are overloads. If we find any mismatch
1054  // in the signature, they are overloads.
1055 
1056  // If either of these functions is a K&R-style function (no
1057  // prototype), then we consider them to have matching signatures.
1058  if (isa<FunctionNoProtoType>(OldQType.getTypePtr()) ||
1059  isa<FunctionNoProtoType>(NewQType.getTypePtr()))
1060  return false;
1061 
1062  const FunctionProtoType *OldType = cast<FunctionProtoType>(OldQType);
1063  const FunctionProtoType *NewType = cast<FunctionProtoType>(NewQType);
1064 
1065  // The signature of a function includes the types of its
1066  // parameters (C++ 1.3.10), which includes the presence or absence
1067  // of the ellipsis; see C++ DR 357).
1068  if (OldQType != NewQType &&
1069  (OldType->getNumParams() != NewType->getNumParams() ||
1070  OldType->isVariadic() != NewType->isVariadic() ||
1071  !FunctionParamTypesAreEqual(OldType, NewType)))
1072  return true;
1073 
1074  // C++ [temp.over.link]p4:
1075  // The signature of a function template consists of its function
1076  // signature, its return type and its template parameter list. The names
1077  // of the template parameters are significant only for establishing the
1078  // relationship between the template parameters and the rest of the
1079  // signature.
1080  //
1081  // We check the return type and template parameter lists for function
1082  // templates first; the remaining checks follow.
1083  //
1084  // However, we don't consider either of these when deciding whether
1085  // a member introduced by a shadow declaration is hidden.
1086  if (!UseMemberUsingDeclRules && NewTemplate &&
1087  (!TemplateParameterListsAreEqual(NewTemplate->getTemplateParameters(),
1088  OldTemplate->getTemplateParameters(),
1089  false, TPL_TemplateMatch) ||
1090  OldType->getReturnType() != NewType->getReturnType()))
1091  return true;
1092 
1093  // If the function is a class member, its signature includes the
1094  // cv-qualifiers (if any) and ref-qualifier (if any) on the function itself.
1095  //
1096  // As part of this, also check whether one of the member functions
1097  // is static, in which case they are not overloads (C++
1098  // 13.1p2). While not part of the definition of the signature,
1099  // this check is important to determine whether these functions
1100  // can be overloaded.
1101  CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old);
1102  CXXMethodDecl *NewMethod = dyn_cast<CXXMethodDecl>(New);
1103  if (OldMethod && NewMethod &&
1104  !OldMethod->isStatic() && !NewMethod->isStatic()) {
1105  if (OldMethod->getRefQualifier() != NewMethod->getRefQualifier()) {
1106  if (!UseMemberUsingDeclRules &&
1107  (OldMethod->getRefQualifier() == RQ_None ||
1108  NewMethod->getRefQualifier() == RQ_None)) {
1109  // C++0x [over.load]p2:
1110  // - Member function declarations with the same name and the same
1111  // parameter-type-list as well as member function template
1112  // declarations with the same name, the same parameter-type-list, and
1113  // the same template parameter lists cannot be overloaded if any of
1114  // them, but not all, have a ref-qualifier (8.3.5).
1115  Diag(NewMethod->getLocation(), diag::err_ref_qualifier_overload)
1116  << NewMethod->getRefQualifier() << OldMethod->getRefQualifier();
1117  Diag(OldMethod->getLocation(), diag::note_previous_declaration);
1118  }
1119  return true;
1120  }
1121 
1122  // We may not have applied the implicit const for a constexpr member
1123  // function yet (because we haven't yet resolved whether this is a static
1124  // or non-static member function). Add it now, on the assumption that this
1125  // is a redeclaration of OldMethod.
1126  unsigned OldQuals = OldMethod->getTypeQualifiers();
1127  unsigned NewQuals = NewMethod->getTypeQualifiers();
1128  if (!getLangOpts().CPlusPlus14 && NewMethod->isConstexpr() &&
1129  !isa<CXXConstructorDecl>(NewMethod))
1130  NewQuals |= Qualifiers::Const;
1131 
1132  // We do not allow overloading based off of '__restrict'.
1133  OldQuals &= ~Qualifiers::Restrict;
1134  NewQuals &= ~Qualifiers::Restrict;
1135  if (OldQuals != NewQuals)
1136  return true;
1137  }
1138 
1139  // Though pass_object_size is placed on parameters and takes an argument, we
1140  // consider it to be a function-level modifier for the sake of function
1141  // identity. Either the function has one or more parameters with
1142  // pass_object_size or it doesn't.
1145  return true;
1146 
1147  // enable_if attributes are an order-sensitive part of the signature.
1149  NewI = New->specific_attr_begin<EnableIfAttr>(),
1150  NewE = New->specific_attr_end<EnableIfAttr>(),
1151  OldI = Old->specific_attr_begin<EnableIfAttr>(),
1152  OldE = Old->specific_attr_end<EnableIfAttr>();
1153  NewI != NewE || OldI != OldE; ++NewI, ++OldI) {
1154  if (NewI == NewE || OldI == OldE)
1155  return true;
1156  llvm::FoldingSetNodeID NewID, OldID;
1157  NewI->getCond()->Profile(NewID, Context, true);
1158  OldI->getCond()->Profile(OldID, Context, true);
1159  if (NewID != OldID)
1160  return true;
1161  }
1162 
1163  if (getLangOpts().CUDA && ConsiderCudaAttrs) {
1164  // Don't allow overloading of destructors. (In theory we could, but it
1165  // would be a giant change to clang.)
1166  if (isa<CXXDestructorDecl>(New))
1167  return false;
1168 
1169  CUDAFunctionTarget NewTarget = IdentifyCUDATarget(New),
1170  OldTarget = IdentifyCUDATarget(Old);
1171  if (NewTarget == CFT_InvalidTarget)
1172  return false;
1173 
1174  assert((OldTarget != CFT_InvalidTarget) && "Unexpected invalid target.");
1175 
1176  // Allow overloading of functions with same signature and different CUDA
1177  // target attributes.
1178  return NewTarget != OldTarget;
1179  }
1180 
1181  // The signatures match; this is not an overload.
1182  return false;
1183 }
1184 
1185 /// \brief Checks availability of the function depending on the current
1186 /// function context. Inside an unavailable function, unavailability is ignored.
1187 ///
1188 /// \returns true if \arg FD is unavailable and current context is inside
1189 /// an available function, false otherwise.
1191  if (!FD->isUnavailable())
1192  return false;
1193 
1194  // Walk up the context of the caller.
1195  Decl *C = cast<Decl>(CurContext);
1196  do {
1197  if (C->isUnavailable())
1198  return false;
1199  } while ((C = cast_or_null<Decl>(C->getDeclContext())));
1200  return true;
1201 }
1202 
1203 /// \brief Tries a user-defined conversion from From to ToType.
1204 ///
1205 /// Produces an implicit conversion sequence for when a standard conversion
1206 /// is not an option. See TryImplicitConversion for more information.
1209  bool SuppressUserConversions,
1210  bool AllowExplicit,
1211  bool InOverloadResolution,
1212  bool CStyle,
1213  bool AllowObjCWritebackConversion,
1214  bool AllowObjCConversionOnExplicit) {
1216 
1217  if (SuppressUserConversions) {
1218  // We're not in the case above, so there is no conversion that
1219  // we can perform.
1220  ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1221  return ICS;
1222  }
1223 
1224  // Attempt user-defined conversion.
1225  OverloadCandidateSet Conversions(From->getExprLoc(),
1227  switch (IsUserDefinedConversion(S, From, ToType, ICS.UserDefined,
1228  Conversions, AllowExplicit,
1229  AllowObjCConversionOnExplicit)) {
1230  case OR_Success:
1231  case OR_Deleted:
1232  ICS.setUserDefined();
1233  // C++ [over.ics.user]p4:
1234  // A conversion of an expression of class type to the same class
1235  // type is given Exact Match rank, and a conversion of an
1236  // expression of class type to a base class of that type is
1237  // given Conversion rank, in spite of the fact that a copy
1238  // constructor (i.e., a user-defined conversion function) is
1239  // called for those cases.
1240  if (CXXConstructorDecl *Constructor
1241  = dyn_cast<CXXConstructorDecl>(ICS.UserDefined.ConversionFunction)) {
1242  QualType FromCanon
1244  QualType ToCanon
1246  if (Constructor->isCopyConstructor() &&
1247  (FromCanon == ToCanon ||
1248  S.IsDerivedFrom(From->getLocStart(), FromCanon, ToCanon))) {
1249  // Turn this into a "standard" conversion sequence, so that it
1250  // gets ranked with standard conversion sequences.
1252  ICS.setStandard();
1254  ICS.Standard.setFromType(From->getType());
1255  ICS.Standard.setAllToTypes(ToType);
1256  ICS.Standard.CopyConstructor = Constructor;
1257  ICS.Standard.FoundCopyConstructor = Found;
1258  if (ToCanon != FromCanon)
1260  }
1261  }
1262  break;
1263 
1264  case OR_Ambiguous:
1265  ICS.setAmbiguous();
1266  ICS.Ambiguous.setFromType(From->getType());
1267  ICS.Ambiguous.setToType(ToType);
1268  for (OverloadCandidateSet::iterator Cand = Conversions.begin();
1269  Cand != Conversions.end(); ++Cand)
1270  if (Cand->Viable)
1271  ICS.Ambiguous.addConversion(Cand->FoundDecl, Cand->Function);
1272  break;
1273 
1274  // Fall through.
1275  case OR_No_Viable_Function:
1276  ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1277  break;
1278  }
1279 
1280  return ICS;
1281 }
1282 
1283 /// TryImplicitConversion - Attempt to perform an implicit conversion
1284 /// from the given expression (Expr) to the given type (ToType). This
1285 /// function returns an implicit conversion sequence that can be used
1286 /// to perform the initialization. Given
1287 ///
1288 /// void f(float f);
1289 /// void g(int i) { f(i); }
1290 ///
1291 /// this routine would produce an implicit conversion sequence to
1292 /// describe the initialization of f from i, which will be a standard
1293 /// conversion sequence containing an lvalue-to-rvalue conversion (C++
1294 /// 4.1) followed by a floating-integral conversion (C++ 4.9).
1295 //
1296 /// Note that this routine only determines how the conversion can be
1297 /// performed; it does not actually perform the conversion. As such,
1298 /// it will not produce any diagnostics if no conversion is available,
1299 /// but will instead return an implicit conversion sequence of kind
1300 /// "BadConversion".
1301 ///
1302 /// If @p SuppressUserConversions, then user-defined conversions are
1303 /// not permitted.
1304 /// If @p AllowExplicit, then explicit user-defined conversions are
1305 /// permitted.
1306 ///
1307 /// \param AllowObjCWritebackConversion Whether we allow the Objective-C
1308 /// writeback conversion, which allows __autoreleasing id* parameters to
1309 /// be initialized with __strong id* or __weak id* arguments.
1312  bool SuppressUserConversions,
1313  bool AllowExplicit,
1314  bool InOverloadResolution,
1315  bool CStyle,
1316  bool AllowObjCWritebackConversion,
1317  bool AllowObjCConversionOnExplicit) {
1319  if (IsStandardConversion(S, From, ToType, InOverloadResolution,
1320  ICS.Standard, CStyle, AllowObjCWritebackConversion)){
1321  ICS.setStandard();
1322  return ICS;
1323  }
1324 
1325  if (!S.getLangOpts().CPlusPlus) {
1326  ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1327  return ICS;
1328  }
1329 
1330  // C++ [over.ics.user]p4:
1331  // A conversion of an expression of class type to the same class
1332  // type is given Exact Match rank, and a conversion of an
1333  // expression of class type to a base class of that type is
1334  // given Conversion rank, in spite of the fact that a copy/move
1335  // constructor (i.e., a user-defined conversion function) is
1336  // called for those cases.
1337  QualType FromType = From->getType();
1338  if (ToType->getAs<RecordType>() && FromType->getAs<RecordType>() &&
1339  (S.Context.hasSameUnqualifiedType(FromType, ToType) ||
1340  S.IsDerivedFrom(From->getLocStart(), FromType, ToType))) {
1341  ICS.setStandard();
1343  ICS.Standard.setFromType(FromType);
1344  ICS.Standard.setAllToTypes(ToType);
1345 
1346  // We don't actually check at this point whether there is a valid
1347  // copy/move constructor, since overloading just assumes that it
1348  // exists. When we actually perform initialization, we'll find the
1349  // appropriate constructor to copy the returned object, if needed.
1350  ICS.Standard.CopyConstructor = nullptr;
1351 
1352  // Determine whether this is considered a derived-to-base conversion.
1353  if (!S.Context.hasSameUnqualifiedType(FromType, ToType))
1355 
1356  return ICS;
1357  }
1358 
1359  return TryUserDefinedConversion(S, From, ToType, SuppressUserConversions,
1360  AllowExplicit, InOverloadResolution, CStyle,
1361  AllowObjCWritebackConversion,
1362  AllowObjCConversionOnExplicit);
1363 }
1364 
1367  bool SuppressUserConversions,
1368  bool AllowExplicit,
1369  bool InOverloadResolution,
1370  bool CStyle,
1371  bool AllowObjCWritebackConversion) {
1372  return ::TryImplicitConversion(*this, From, ToType,
1373  SuppressUserConversions, AllowExplicit,
1374  InOverloadResolution, CStyle,
1375  AllowObjCWritebackConversion,
1376  /*AllowObjCConversionOnExplicit=*/false);
1377 }
1378 
1379 /// PerformImplicitConversion - Perform an implicit conversion of the
1380 /// expression From to the type ToType. Returns the
1381 /// converted expression. Flavor is the kind of conversion we're
1382 /// performing, used in the error message. If @p AllowExplicit,
1383 /// explicit user-defined conversions are permitted.
1384 ExprResult
1386  AssignmentAction Action, bool AllowExplicit) {
1388  return PerformImplicitConversion(From, ToType, Action, AllowExplicit, ICS);
1389 }
1390 
1391 ExprResult
1393  AssignmentAction Action, bool AllowExplicit,
1395  if (checkPlaceholderForOverload(*this, From))
1396  return ExprError();
1397 
1398  // Objective-C ARC: Determine whether we will allow the writeback conversion.
1399  bool AllowObjCWritebackConversion
1400  = getLangOpts().ObjCAutoRefCount &&
1401  (Action == AA_Passing || Action == AA_Sending);
1402  if (getLangOpts().ObjC1)
1403  CheckObjCBridgeRelatedConversions(From->getLocStart(),
1404  ToType, From->getType(), From);
1405  ICS = ::TryImplicitConversion(*this, From, ToType,
1406  /*SuppressUserConversions=*/false,
1407  AllowExplicit,
1408  /*InOverloadResolution=*/false,
1409  /*CStyle=*/false,
1410  AllowObjCWritebackConversion,
1411  /*AllowObjCConversionOnExplicit=*/false);
1412  return PerformImplicitConversion(From, ToType, ICS, Action);
1413 }
1414 
1415 /// \brief Determine whether the conversion from FromType to ToType is a valid
1416 /// conversion that strips "noexcept" or "noreturn" off the nested function
1417 /// type.
1419  QualType &ResultTy) {
1420  if (Context.hasSameUnqualifiedType(FromType, ToType))
1421  return false;
1422 
1423  // Permit the conversion F(t __attribute__((noreturn))) -> F(t)
1424  // or F(t noexcept) -> F(t)
1425  // where F adds one of the following at most once:
1426  // - a pointer
1427  // - a member pointer
1428  // - a block pointer
1429  // Changes here need matching changes in FindCompositePointerType.
1430  CanQualType CanTo = Context.getCanonicalType(ToType);
1431  CanQualType CanFrom = Context.getCanonicalType(FromType);
1432  Type::TypeClass TyClass = CanTo->getTypeClass();
1433  if (TyClass != CanFrom->getTypeClass()) return false;
1434  if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto) {
1435  if (TyClass == Type::Pointer) {
1436  CanTo = CanTo.getAs<PointerType>()->getPointeeType();
1437  CanFrom = CanFrom.getAs<PointerType>()->getPointeeType();
1438  } else if (TyClass == Type::BlockPointer) {
1439  CanTo = CanTo.getAs<BlockPointerType>()->getPointeeType();
1440  CanFrom = CanFrom.getAs<BlockPointerType>()->getPointeeType();
1441  } else if (TyClass == Type::MemberPointer) {
1442  auto ToMPT = CanTo.getAs<MemberPointerType>();
1443  auto FromMPT = CanFrom.getAs<MemberPointerType>();
1444  // A function pointer conversion cannot change the class of the function.
1445  if (ToMPT->getClass() != FromMPT->getClass())
1446  return false;
1447  CanTo = ToMPT->getPointeeType();
1448  CanFrom = FromMPT->getPointeeType();
1449  } else {
1450  return false;
1451  }
1452 
1453  TyClass = CanTo->getTypeClass();
1454  if (TyClass != CanFrom->getTypeClass()) return false;
1455  if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto)
1456  return false;
1457  }
1458 
1459  const auto *FromFn = cast<FunctionType>(CanFrom);
1460  FunctionType::ExtInfo FromEInfo = FromFn->getExtInfo();
1461 
1462  const auto *ToFn = cast<FunctionType>(CanTo);
1463  FunctionType::ExtInfo ToEInfo = ToFn->getExtInfo();
1464 
1465  bool Changed = false;
1466 
1467  // Drop 'noreturn' if not present in target type.
1468  if (FromEInfo.getNoReturn() && !ToEInfo.getNoReturn()) {
1469  FromFn = Context.adjustFunctionType(FromFn, FromEInfo.withNoReturn(false));
1470  Changed = true;
1471  }
1472 
1473  // Drop 'noexcept' if not present in target type.
1474  if (const auto *FromFPT = dyn_cast<FunctionProtoType>(FromFn)) {
1475  const auto *ToFPT = cast<FunctionProtoType>(ToFn);
1476  if (FromFPT->isNothrow(Context) && !ToFPT->isNothrow(Context)) {
1477  FromFn = cast<FunctionType>(
1478  Context.getFunctionType(FromFPT->getReturnType(),
1479  FromFPT->getParamTypes(),
1480  FromFPT->getExtProtoInfo().withExceptionSpec(
1482  .getTypePtr());
1483  Changed = true;
1484  }
1485 
1486  // Convert FromFPT's ExtParameterInfo if necessary. The conversion is valid
1487  // only if the ExtParameterInfo lists of the two function prototypes can be
1488  // merged and the merged list is identical to ToFPT's ExtParameterInfo list.
1490  bool CanUseToFPT, CanUseFromFPT;
1491  if (Context.mergeExtParameterInfo(ToFPT, FromFPT, CanUseToFPT,
1492  CanUseFromFPT, NewParamInfos) &&
1493  CanUseToFPT && !CanUseFromFPT) {
1494  FunctionProtoType::ExtProtoInfo ExtInfo = FromFPT->getExtProtoInfo();
1495  ExtInfo.ExtParameterInfos =
1496  NewParamInfos.empty() ? nullptr : NewParamInfos.data();
1497  QualType QT = Context.getFunctionType(FromFPT->getReturnType(),
1498  FromFPT->getParamTypes(), ExtInfo);
1499  FromFn = QT->getAs<FunctionType>();
1500  Changed = true;
1501  }
1502  }
1503 
1504  if (!Changed)
1505  return false;
1506 
1507  assert(QualType(FromFn, 0).isCanonical());
1508  if (QualType(FromFn, 0) != CanTo) return false;
1509 
1510  ResultTy = ToType;
1511  return true;
1512 }
1513 
1514 /// \brief Determine whether the conversion from FromType to ToType is a valid
1515 /// vector conversion.
1516 ///
1517 /// \param ICK Will be set to the vector conversion kind, if this is a vector
1518 /// conversion.
1519 static bool IsVectorConversion(Sema &S, QualType FromType,
1520  QualType ToType, ImplicitConversionKind &ICK) {
1521  // We need at least one of these types to be a vector type to have a vector
1522  // conversion.
1523  if (!ToType->isVectorType() && !FromType->isVectorType())
1524  return false;
1525 
1526  // Identical types require no conversions.
1527  if (S.Context.hasSameUnqualifiedType(FromType, ToType))
1528  return false;
1529 
1530  // There are no conversions between extended vector types, only identity.
1531  if (ToType->isExtVectorType()) {
1532  // There are no conversions between extended vector types other than the
1533  // identity conversion.
1534  if (FromType->isExtVectorType())
1535  return false;
1536 
1537  // Vector splat from any arithmetic type to a vector.
1538  if (FromType->isArithmeticType()) {
1539  ICK = ICK_Vector_Splat;
1540  return true;
1541  }
1542  }
1543 
1544  // We can perform the conversion between vector types in the following cases:
1545  // 1)vector types are equivalent AltiVec and GCC vector types
1546  // 2)lax vector conversions are permitted and the vector types are of the
1547  // same size
1548  if (ToType->isVectorType() && FromType->isVectorType()) {
1549  if (S.Context.areCompatibleVectorTypes(FromType, ToType) ||
1550  S.isLaxVectorConversion(FromType, ToType)) {
1551  ICK = ICK_Vector_Conversion;
1552  return true;
1553  }
1554  }
1555 
1556  return false;
1557 }
1558 
1559 static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType,
1560  bool InOverloadResolution,
1562  bool CStyle);
1563 
1564 /// IsStandardConversion - Determines whether there is a standard
1565 /// conversion sequence (C++ [conv], C++ [over.ics.scs]) from the
1566 /// expression From to the type ToType. Standard conversion sequences
1567 /// only consider non-class types; for conversions that involve class
1568 /// types, use TryImplicitConversion. If a conversion exists, SCS will
1569 /// contain the standard conversion sequence required to perform this
1570 /// conversion and this routine will return true. Otherwise, this
1571 /// routine will return false and the value of SCS is unspecified.
1572 static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
1573  bool InOverloadResolution,
1575  bool CStyle,
1576  bool AllowObjCWritebackConversion) {
1577  QualType FromType = From->getType();
1578 
1579  // Standard conversions (C++ [conv])
1581  SCS.IncompatibleObjC = false;
1582  SCS.setFromType(FromType);
1583  SCS.CopyConstructor = nullptr;
1584 
1585  // There are no standard conversions for class types in C++, so
1586  // abort early. When overloading in C, however, we do permit them.
1587  if (S.getLangOpts().CPlusPlus &&
1588  (FromType->isRecordType() || ToType->isRecordType()))
1589  return false;
1590 
1591  // The first conversion can be an lvalue-to-rvalue conversion,
1592  // array-to-pointer conversion, or function-to-pointer conversion
1593  // (C++ 4p1).
1594 
1595  if (FromType == S.Context.OverloadTy) {
1596  DeclAccessPair AccessPair;
1597  if (FunctionDecl *Fn
1598  = S.ResolveAddressOfOverloadedFunction(From, ToType, false,
1599  AccessPair)) {
1600  // We were able to resolve the address of the overloaded function,
1601  // so we can convert to the type of that function.
1602  FromType = Fn->getType();
1603  SCS.setFromType(FromType);
1604 
1605  // we can sometimes resolve &foo<int> regardless of ToType, so check
1606  // if the type matches (identity) or we are converting to bool
1608  S.ExtractUnqualifiedFunctionType(ToType), FromType)) {
1609  QualType resultTy;
1610  // if the function type matches except for [[noreturn]], it's ok
1611  if (!S.IsFunctionConversion(FromType,
1612  S.ExtractUnqualifiedFunctionType(ToType), resultTy))
1613  // otherwise, only a boolean conversion is standard
1614  if (!ToType->isBooleanType())
1615  return false;
1616  }
1617 
1618  // Check if the "from" expression is taking the address of an overloaded
1619  // function and recompute the FromType accordingly. Take advantage of the
1620  // fact that non-static member functions *must* have such an address-of
1621  // expression.
1622  CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn);
1623  if (Method && !Method->isStatic()) {
1624  assert(isa<UnaryOperator>(From->IgnoreParens()) &&
1625  "Non-unary operator on non-static member address");
1626  assert(cast<UnaryOperator>(From->IgnoreParens())->getOpcode()
1627  == UO_AddrOf &&
1628  "Non-address-of operator on non-static member address");
1629  const Type *ClassType
1630  = S.Context.getTypeDeclType(Method->getParent()).getTypePtr();
1631  FromType = S.Context.getMemberPointerType(FromType, ClassType);
1632  } else if (isa<UnaryOperator>(From->IgnoreParens())) {
1633  assert(cast<UnaryOperator>(From->IgnoreParens())->getOpcode() ==
1634  UO_AddrOf &&
1635  "Non-address-of operator for overloaded function expression");
1636  FromType = S.Context.getPointerType(FromType);
1637  }
1638 
1639  // Check that we've computed the proper type after overload resolution.
1640  // FIXME: FixOverloadedFunctionReference has side-effects; we shouldn't
1641  // be calling it from within an NDEBUG block.
1642  assert(S.Context.hasSameType(
1643  FromType,
1644  S.FixOverloadedFunctionReference(From, AccessPair, Fn)->getType()));
1645  } else {
1646  return false;
1647  }
1648  }
1649  // Lvalue-to-rvalue conversion (C++11 4.1):
1650  // A glvalue (3.10) of a non-function, non-array type T can
1651  // be converted to a prvalue.
1652  bool argIsLValue = From->isGLValue();
1653  if (argIsLValue &&
1654  !FromType->isFunctionType() && !FromType->isArrayType() &&
1655  S.Context.getCanonicalType(FromType) != S.Context.OverloadTy) {
1657 
1658  // C11 6.3.2.1p2:
1659  // ... if the lvalue has atomic type, the value has the non-atomic version
1660  // of the type of the lvalue ...
1661  if (const AtomicType *Atomic = FromType->getAs<AtomicType>())
1662  FromType = Atomic->getValueType();
1663 
1664  // If T is a non-class type, the type of the rvalue is the
1665  // cv-unqualified version of T. Otherwise, the type of the rvalue
1666  // is T (C++ 4.1p1). C++ can't get here with class types; in C, we
1667  // just strip the qualifiers because they don't matter.
1668  FromType = FromType.getUnqualifiedType();
1669  } else if (FromType->isArrayType()) {
1670  // Array-to-pointer conversion (C++ 4.2)
1672 
1673  // An lvalue or rvalue of type "array of N T" or "array of unknown
1674  // bound of T" can be converted to an rvalue of type "pointer to
1675  // T" (C++ 4.2p1).
1676  FromType = S.Context.getArrayDecayedType(FromType);
1677 
1678  if (S.IsStringLiteralToNonConstPointerConversion(From, ToType)) {
1679  // This conversion is deprecated in C++03 (D.4)
1681 
1682  // For the purpose of ranking in overload resolution
1683  // (13.3.3.1.1), this conversion is considered an
1684  // array-to-pointer conversion followed by a qualification
1685  // conversion (4.4). (C++ 4.2p2)
1686  SCS.Second = ICK_Identity;
1687  SCS.Third = ICK_Qualification;
1689  SCS.setAllToTypes(FromType);
1690  return true;
1691  }
1692  } else if (FromType->isFunctionType() && argIsLValue) {
1693  // Function-to-pointer conversion (C++ 4.3).
1695 
1696  if (auto *DRE = dyn_cast<DeclRefExpr>(From->IgnoreParenCasts()))
1697  if (auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl()))
1699  return false;
1700 
1701  // An lvalue of function type T can be converted to an rvalue of
1702  // type "pointer to T." The result is a pointer to the
1703  // function. (C++ 4.3p1).
1704  FromType = S.Context.getPointerType(FromType);
1705  } else {
1706  // We don't require any conversions for the first step.
1707  SCS.First = ICK_Identity;
1708  }
1709  SCS.setToType(0, FromType);
1710 
1711  // The second conversion can be an integral promotion, floating
1712  // point promotion, integral conversion, floating point conversion,
1713  // floating-integral conversion, pointer conversion,
1714  // pointer-to-member conversion, or boolean conversion (C++ 4p1).
1715  // For overloading in C, this can also be a "compatible-type"
1716  // conversion.
1717  bool IncompatibleObjC = false;
1719  if (S.Context.hasSameUnqualifiedType(FromType, ToType)) {
1720  // The unqualified versions of the types are the same: there's no
1721  // conversion to do.
1722  SCS.Second = ICK_Identity;
1723  } else if (S.IsIntegralPromotion(From, FromType, ToType)) {
1724  // Integral promotion (C++ 4.5).
1726  FromType = ToType.getUnqualifiedType();
1727  } else if (S.IsFloatingPointPromotion(FromType, ToType)) {
1728  // Floating point promotion (C++ 4.6).
1730  FromType = ToType.getUnqualifiedType();
1731  } else if (S.IsComplexPromotion(FromType, ToType)) {
1732  // Complex promotion (Clang extension)
1734  FromType = ToType.getUnqualifiedType();
1735  } else if (ToType->isBooleanType() &&
1736  (FromType->isArithmeticType() ||
1737  FromType->isAnyPointerType() ||
1738  FromType->isBlockPointerType() ||
1739  FromType->isMemberPointerType() ||
1740  FromType->isNullPtrType())) {
1741  // Boolean conversions (C++ 4.12).
1743  FromType = S.Context.BoolTy;
1744  } else if (FromType->isIntegralOrUnscopedEnumerationType() &&
1745  ToType->isIntegralType(S.Context)) {
1746  // Integral conversions (C++ 4.7).
1748  FromType = ToType.getUnqualifiedType();
1749  } else if (FromType->isAnyComplexType() && ToType->isAnyComplexType()) {
1750  // Complex conversions (C99 6.3.1.6)
1752  FromType = ToType.getUnqualifiedType();
1753  } else if ((FromType->isAnyComplexType() && ToType->isArithmeticType()) ||
1754  (ToType->isAnyComplexType() && FromType->isArithmeticType())) {
1755  // Complex-real conversions (C99 6.3.1.7)
1756  SCS.Second = ICK_Complex_Real;
1757  FromType = ToType.getUnqualifiedType();
1758  } else if (FromType->isRealFloatingType() && ToType->isRealFloatingType()) {
1759  // FIXME: disable conversions between long double and __float128 if
1760  // their representation is different until there is back end support
1761  // We of course allow this conversion if long double is really double.
1762  if (&S.Context.getFloatTypeSemantics(FromType) !=
1763  &S.Context.getFloatTypeSemantics(ToType)) {
1764  bool Float128AndLongDouble = ((FromType == S.Context.Float128Ty &&
1765  ToType == S.Context.LongDoubleTy) ||
1766  (FromType == S.Context.LongDoubleTy &&
1767  ToType == S.Context.Float128Ty));
1768  if (Float128AndLongDouble &&
1770  &llvm::APFloat::IEEEdouble()))
1771  return false;
1772  }
1773  // Floating point conversions (C++ 4.8).
1775  FromType = ToType.getUnqualifiedType();
1776  } else if ((FromType->isRealFloatingType() &&
1777  ToType->isIntegralType(S.Context)) ||
1778  (FromType->isIntegralOrUnscopedEnumerationType() &&
1779  ToType->isRealFloatingType())) {
1780  // Floating-integral conversions (C++ 4.9).
1782  FromType = ToType.getUnqualifiedType();
1783  } else if (S.IsBlockPointerConversion(FromType, ToType, FromType)) {
1785  } else if (AllowObjCWritebackConversion &&
1786  S.isObjCWritebackConversion(FromType, ToType, FromType)) {
1788  } else if (S.IsPointerConversion(From, FromType, ToType, InOverloadResolution,
1789  FromType, IncompatibleObjC)) {
1790  // Pointer conversions (C++ 4.10).
1792  SCS.IncompatibleObjC = IncompatibleObjC;
1793  FromType = FromType.getUnqualifiedType();
1794  } else if (S.IsMemberPointerConversion(From, FromType, ToType,
1795  InOverloadResolution, FromType)) {
1796  // Pointer to member conversions (4.11).
1797  SCS.Second = ICK_Pointer_Member;
1798  } else if (IsVectorConversion(S, FromType, ToType, SecondICK)) {
1799  SCS.Second = SecondICK;
1800  FromType = ToType.getUnqualifiedType();
1801  } else if (!S.getLangOpts().CPlusPlus &&
1802  S.Context.typesAreCompatible(ToType, FromType)) {
1803  // Compatible conversions (Clang extension for C function overloading)
1805  FromType = ToType.getUnqualifiedType();
1806  } else if (IsTransparentUnionStandardConversion(S, From, ToType,
1807  InOverloadResolution,
1808  SCS, CStyle)) {
1810  FromType = ToType;
1811  } else if (tryAtomicConversion(S, From, ToType, InOverloadResolution, SCS,
1812  CStyle)) {
1813  // tryAtomicConversion has updated the standard conversion sequence
1814  // appropriately.
1815  return true;
1816  } else if (ToType->isEventT() &&
1817  From->isIntegerConstantExpr(S.getASTContext()) &&
1818  From->EvaluateKnownConstInt(S.getASTContext()) == 0) {
1820  FromType = ToType;
1821  } else if (ToType->isQueueT() &&
1822  From->isIntegerConstantExpr(S.getASTContext()) &&
1823  (From->EvaluateKnownConstInt(S.getASTContext()) == 0)) {
1825  FromType = ToType;
1826  } else {
1827  // No second conversion required.
1828  SCS.Second = ICK_Identity;
1829  }
1830  SCS.setToType(1, FromType);
1831 
1832  // The third conversion can be a function pointer conversion or a
1833  // qualification conversion (C++ [conv.fctptr], [conv.qual]).
1834  bool ObjCLifetimeConversion;
1835  if (S.IsFunctionConversion(FromType, ToType, FromType)) {
1836  // Function pointer conversions (removing 'noexcept') including removal of
1837  // 'noreturn' (Clang extension).
1839  } else if (S.IsQualificationConversion(FromType, ToType, CStyle,
1840  ObjCLifetimeConversion)) {
1841  SCS.Third = ICK_Qualification;
1842  SCS.QualificationIncludesObjCLifetime = ObjCLifetimeConversion;
1843  FromType = ToType;
1844  } else {
1845  // No conversion required
1846  SCS.Third = ICK_Identity;
1847  }
1848 
1849  // C++ [over.best.ics]p6:
1850  // [...] Any difference in top-level cv-qualification is
1851  // subsumed by the initialization itself and does not constitute
1852  // a conversion. [...]
1853  QualType CanonFrom = S.Context.getCanonicalType(FromType);
1854  QualType CanonTo = S.Context.getCanonicalType(ToType);
1855  if (CanonFrom.getLocalUnqualifiedType()
1856  == CanonTo.getLocalUnqualifiedType() &&
1857  CanonFrom.getLocalQualifiers() != CanonTo.getLocalQualifiers()) {
1858  FromType = ToType;
1859  CanonFrom = CanonTo;
1860  }
1861 
1862  SCS.setToType(2, FromType);
1863 
1864  if (CanonFrom == CanonTo)
1865  return true;
1866 
1867  // If we have not converted the argument type to the parameter type,
1868  // this is a bad conversion sequence, unless we're resolving an overload in C.
1869  if (S.getLangOpts().CPlusPlus || !InOverloadResolution)
1870  return false;
1871 
1872  ExprResult ER = ExprResult{From};
1874  S.CheckSingleAssignmentConstraints(ToType, ER,
1875  /*Diagnose=*/false,
1876  /*DiagnoseCFAudited=*/false,
1877  /*ConvertRHS=*/false);
1878  ImplicitConversionKind SecondConv;
1879  switch (Conv) {
1880  case Sema::Compatible:
1881  SecondConv = ICK_C_Only_Conversion;
1882  break;
1883  // For our purposes, discarding qualifiers is just as bad as using an
1884  // incompatible pointer. Note that an IncompatiblePointer conversion can drop
1885  // qualifiers, as well.
1890  break;
1891  default:
1892  return false;
1893  }
1894 
1895  // First can only be an lvalue conversion, so we pretend that this was the
1896  // second conversion. First should already be valid from earlier in the
1897  // function.
1898  SCS.Second = SecondConv;
1899  SCS.setToType(1, ToType);
1900 
1901  // Third is Identity, because Second should rank us worse than any other
1902  // conversion. This could also be ICK_Qualification, but it's simpler to just
1903  // lump everything in with the second conversion, and we don't gain anything
1904  // from making this ICK_Qualification.
1905  SCS.Third = ICK_Identity;
1906  SCS.setToType(2, ToType);
1907  return true;
1908 }
1909 
1910 static bool
1912  QualType &ToType,
1913  bool InOverloadResolution,
1915  bool CStyle) {
1916 
1917  const RecordType *UT = ToType->getAsUnionType();
1918  if (!UT || !UT->getDecl()->hasAttr<TransparentUnionAttr>())
1919  return false;
1920  // The field to initialize within the transparent union.
1921  RecordDecl *UD = UT->getDecl();
1922  // It's compatible if the expression matches any of the fields.
1923  for (const auto *it : UD->fields()) {
1924  if (IsStandardConversion(S, From, it->getType(), InOverloadResolution, SCS,
1925  CStyle, /*ObjCWritebackConversion=*/false)) {
1926  ToType = it->getType();
1927  return true;
1928  }
1929  }
1930  return false;
1931 }
1932 
1933 /// IsIntegralPromotion - Determines whether the conversion from the
1934 /// expression From (whose potentially-adjusted type is FromType) to
1935 /// ToType is an integral promotion (C++ 4.5). If so, returns true and
1936 /// sets PromotedType to the promoted type.
1937 bool Sema::IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType) {
1938  const BuiltinType *To = ToType->getAs<BuiltinType>();
1939  // All integers are built-in.
1940  if (!To) {
1941  return false;
1942  }
1943 
1944  // An rvalue of type char, signed char, unsigned char, short int, or
1945  // unsigned short int can be converted to an rvalue of type int if
1946  // int can represent all the values of the source type; otherwise,
1947  // the source rvalue can be converted to an rvalue of type unsigned
1948  // int (C++ 4.5p1).
1949  if (FromType->isPromotableIntegerType() && !FromType->isBooleanType() &&
1950  !FromType->isEnumeralType()) {
1951  if (// We can promote any signed, promotable integer type to an int
1952  (FromType->isSignedIntegerType() ||
1953  // We can promote any unsigned integer type whose size is
1954  // less than int to an int.
1955  Context.getTypeSize(FromType) < Context.getTypeSize(ToType))) {
1956  return To->getKind() == BuiltinType::Int;
1957  }
1958 
1959  return To->getKind() == BuiltinType::UInt;
1960  }
1961 
1962  // C++11 [conv.prom]p3:
1963  // A prvalue of an unscoped enumeration type whose underlying type is not
1964  // fixed (7.2) can be converted to an rvalue a prvalue of the first of the
1965  // following types that can represent all the values of the enumeration
1966  // (i.e., the values in the range bmin to bmax as described in 7.2): int,
1967  // unsigned int, long int, unsigned long int, long long int, or unsigned
1968  // long long int. If none of the types in that list can represent all the
1969  // values of the enumeration, an rvalue a prvalue of an unscoped enumeration
1970  // type can be converted to an rvalue a prvalue of the extended integer type
1971  // with lowest integer conversion rank (4.13) greater than the rank of long
1972  // long in which all the values of the enumeration can be represented. If
1973  // there are two such extended types, the signed one is chosen.
1974  // C++11 [conv.prom]p4:
1975  // A prvalue of an unscoped enumeration type whose underlying type is fixed
1976  // can be converted to a prvalue of its underlying type. Moreover, if
1977  // integral promotion can be applied to its underlying type, a prvalue of an
1978  // unscoped enumeration type whose underlying type is fixed can also be
1979  // converted to a prvalue of the promoted underlying type.
1980  if (const EnumType *FromEnumType = FromType->getAs<EnumType>()) {
1981  // C++0x 7.2p9: Note that this implicit enum to int conversion is not
1982  // provided for a scoped enumeration.
1983  if (FromEnumType->getDecl()->isScoped())
1984  return false;
1985 
1986  // We can perform an integral promotion to the underlying type of the enum,
1987  // even if that's not the promoted type. Note that the check for promoting
1988  // the underlying type is based on the type alone, and does not consider
1989  // the bitfield-ness of the actual source expression.
1990  if (FromEnumType->getDecl()->isFixed()) {
1991  QualType Underlying = FromEnumType->getDecl()->getIntegerType();
1992  return Context.hasSameUnqualifiedType(Underlying, ToType) ||
1993  IsIntegralPromotion(nullptr, Underlying, ToType);
1994  }
1995 
1996  // We have already pre-calculated the promotion type, so this is trivial.
1997  if (ToType->isIntegerType() &&
1998  isCompleteType(From->getLocStart(), FromType))
1999  return Context.hasSameUnqualifiedType(
2000  ToType, FromEnumType->getDecl()->getPromotionType());
2001  }
2002 
2003  // C++0x [conv.prom]p2:
2004  // A prvalue of type char16_t, char32_t, or wchar_t (3.9.1) can be converted
2005  // to an rvalue a prvalue of the first of the following types that can
2006  // represent all the values of its underlying type: int, unsigned int,
2007  // long int, unsigned long int, long long int, or unsigned long long int.
2008  // If none of the types in that list can represent all the values of its
2009  // underlying type, an rvalue a prvalue of type char16_t, char32_t,
2010  // or wchar_t can be converted to an rvalue a prvalue of its underlying
2011  // type.
2012  if (FromType->isAnyCharacterType() && !FromType->isCharType() &&
2013  ToType->isIntegerType()) {
2014  // Determine whether the type we're converting from is signed or
2015  // unsigned.
2016  bool FromIsSigned = FromType->isSignedIntegerType();
2017  uint64_t FromSize = Context.getTypeSize(FromType);
2018 
2019  // The types we'll try to promote to, in the appropriate
2020  // order. Try each of these types.
2021  QualType PromoteTypes[6] = {
2022  Context.IntTy, Context.UnsignedIntTy,
2023  Context.LongTy, Context.UnsignedLongTy ,
2024  Context.LongLongTy, Context.UnsignedLongLongTy
2025  };
2026  for (int Idx = 0; Idx < 6; ++Idx) {
2027  uint64_t ToSize = Context.getTypeSize(PromoteTypes[Idx]);
2028  if (FromSize < ToSize ||
2029  (FromSize == ToSize &&
2030  FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType())) {
2031  // We found the type that we can promote to. If this is the
2032  // type we wanted, we have a promotion. Otherwise, no
2033  // promotion.
2034  return Context.hasSameUnqualifiedType(ToType, PromoteTypes[Idx]);
2035  }
2036  }
2037  }
2038 
2039  // An rvalue for an integral bit-field (9.6) can be converted to an
2040  // rvalue of type int if int can represent all the values of the
2041  // bit-field; otherwise, it can be converted to unsigned int if
2042  // unsigned int can represent all the values of the bit-field. If
2043  // the bit-field is larger yet, no integral promotion applies to
2044  // it. If the bit-field has an enumerated type, it is treated as any
2045  // other value of that type for promotion purposes (C++ 4.5p3).
2046  // FIXME: We should delay checking of bit-fields until we actually perform the
2047  // conversion.
2048  if (From) {
2049  if (FieldDecl *MemberDecl = From->getSourceBitField()) {
2050  llvm::APSInt BitWidth;
2051  if (FromType->isIntegralType(Context) &&
2052  MemberDecl->getBitWidth()->isIntegerConstantExpr(BitWidth, Context)) {
2053  llvm::APSInt ToSize(BitWidth.getBitWidth(), BitWidth.isUnsigned());
2054  ToSize = Context.getTypeSize(ToType);
2055 
2056  // Are we promoting to an int from a bitfield that fits in an int?
2057  if (BitWidth < ToSize ||
2058  (FromType->isSignedIntegerType() && BitWidth <= ToSize)) {
2059  return To->getKind() == BuiltinType::Int;
2060  }
2061 
2062  // Are we promoting to an unsigned int from an unsigned bitfield
2063  // that fits into an unsigned int?
2064  if (FromType->isUnsignedIntegerType() && BitWidth <= ToSize) {
2065  return To->getKind() == BuiltinType::UInt;
2066  }
2067 
2068  return false;
2069  }
2070  }
2071  }
2072 
2073  // An rvalue of type bool can be converted to an rvalue of type int,
2074  // with false becoming zero and true becoming one (C++ 4.5p4).
2075  if (FromType->isBooleanType() && To->getKind() == BuiltinType::Int) {
2076  return true;
2077  }
2078 
2079  return false;
2080 }
2081 
2082 /// IsFloatingPointPromotion - Determines whether the conversion from
2083 /// FromType to ToType is a floating point promotion (C++ 4.6). If so,
2084 /// returns true and sets PromotedType to the promoted type.
2086  if (const BuiltinType *FromBuiltin = FromType->getAs<BuiltinType>())
2087  if (const BuiltinType *ToBuiltin = ToType->getAs<BuiltinType>()) {
2088  /// An rvalue of type float can be converted to an rvalue of type
2089  /// double. (C++ 4.6p1).
2090  if (FromBuiltin->getKind() == BuiltinType::Float &&
2091  ToBuiltin->getKind() == BuiltinType::Double)
2092  return true;
2093 
2094  // C99 6.3.1.5p1:
2095  // When a float is promoted to double or long double, or a
2096  // double is promoted to long double [...].
2097  if (!getLangOpts().CPlusPlus &&
2098  (FromBuiltin->getKind() == BuiltinType::Float ||
2099  FromBuiltin->getKind() == BuiltinType::Double) &&
2100  (ToBuiltin->getKind() == BuiltinType::LongDouble ||
2101  ToBuiltin->getKind() == BuiltinType::Float128))
2102  return true;
2103 
2104  // Half can be promoted to float.
2105  if (!getLangOpts().NativeHalfType &&
2106  FromBuiltin->getKind() == BuiltinType::Half &&
2107  ToBuiltin->getKind() == BuiltinType::Float)
2108  return true;
2109  }
2110 
2111  return false;
2112 }
2113 
2114 /// \brief Determine if a conversion is a complex promotion.
2115 ///
2116 /// A complex promotion is defined as a complex -> complex conversion
2117 /// where the conversion between the underlying real types is a
2118 /// floating-point or integral promotion.
2120  const ComplexType *FromComplex = FromType->getAs<ComplexType>();
2121  if (!FromComplex)
2122  return false;
2123 
2124  const ComplexType *ToComplex = ToType->getAs<ComplexType>();
2125  if (!ToComplex)
2126  return false;
2127 
2128  return IsFloatingPointPromotion(FromComplex->getElementType(),
2129  ToComplex->getElementType()) ||
2130  IsIntegralPromotion(nullptr, FromComplex->getElementType(),
2131  ToComplex->getElementType());
2132 }
2133 
2134 /// BuildSimilarlyQualifiedPointerType - In a pointer conversion from
2135 /// the pointer type FromPtr to a pointer to type ToPointee, with the
2136 /// same type qualifiers as FromPtr has on its pointee type. ToType,
2137 /// if non-empty, will be a pointer to ToType that may or may not have
2138 /// the right set of qualifiers on its pointee.
2139 ///
2140 static QualType
2142  QualType ToPointee, QualType ToType,
2143  ASTContext &Context,
2144  bool StripObjCLifetime = false) {
2145  assert((FromPtr->getTypeClass() == Type::Pointer ||
2146  FromPtr->getTypeClass() == Type::ObjCObjectPointer) &&
2147  "Invalid similarly-qualified pointer type");
2148 
2149  /// Conversions to 'id' subsume cv-qualifier conversions.
2150  if (ToType->isObjCIdType() || ToType->isObjCQualifiedIdType())
2151  return ToType.getUnqualifiedType();
2152 
2153  QualType CanonFromPointee
2154  = Context.getCanonicalType(FromPtr->getPointeeType());
2155  QualType CanonToPointee = Context.getCanonicalType(ToPointee);
2156  Qualifiers Quals = CanonFromPointee.getQualifiers();
2157 
2158  if (StripObjCLifetime)
2159  Quals.removeObjCLifetime();
2160 
2161  // Exact qualifier match -> return the pointer type we're converting to.
2162  if (CanonToPointee.getLocalQualifiers() == Quals) {
2163  // ToType is exactly what we need. Return it.
2164  if (!ToType.isNull())
2165  return ToType.getUnqualifiedType();
2166 
2167  // Build a pointer to ToPointee. It has the right qualifiers
2168  // already.
2169  if (isa<ObjCObjectPointerType>(ToType))
2170  return Context.getObjCObjectPointerType(ToPointee);
2171  return Context.getPointerType(ToPointee);
2172  }
2173 
2174  // Just build a canonical type that has the right qualifiers.
2175  QualType QualifiedCanonToPointee
2176  = Context.getQualifiedType(CanonToPointee.getLocalUnqualifiedType(), Quals);
2177 
2178  if (isa<ObjCObjectPointerType>(ToType))
2179  return Context.getObjCObjectPointerType(QualifiedCanonToPointee);
2180  return Context.getPointerType(QualifiedCanonToPointee);
2181 }
2182 
2184  bool InOverloadResolution,
2185  ASTContext &Context) {
2186  // Handle value-dependent integral null pointer constants correctly.
2187  // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#903
2188  if (Expr->isValueDependent() && !Expr->isTypeDependent() &&
2189  Expr->getType()->isIntegerType() && !Expr->getType()->isEnumeralType())
2190  return !InOverloadResolution;
2191 
2192  return Expr->isNullPointerConstant(Context,
2193  InOverloadResolution? Expr::NPC_ValueDependentIsNotNull
2195 }
2196 
2197 /// IsPointerConversion - Determines whether the conversion of the
2198 /// expression From, which has the (possibly adjusted) type FromType,
2199 /// can be converted to the type ToType via a pointer conversion (C++
2200 /// 4.10). If so, returns true and places the converted type (that
2201 /// might differ from ToType in its cv-qualifiers at some level) into
2202 /// ConvertedType.
2203 ///
2204 /// This routine also supports conversions to and from block pointers
2205 /// and conversions with Objective-C's 'id', 'id<protocols...>', and
2206 /// pointers to interfaces. FIXME: Once we've determined the
2207 /// appropriate overloading rules for Objective-C, we may want to
2208 /// split the Objective-C checks into a different routine; however,
2209 /// GCC seems to consider all of these conversions to be pointer
2210 /// conversions, so for now they live here. IncompatibleObjC will be
2211 /// set if the conversion is an allowed Objective-C conversion that
2212 /// should result in a warning.
2213 bool Sema::IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
2214  bool InOverloadResolution,
2215  QualType& ConvertedType,
2216  bool &IncompatibleObjC) {
2217  IncompatibleObjC = false;
2218  if (isObjCPointerConversion(FromType, ToType, ConvertedType,
2219  IncompatibleObjC))
2220  return true;
2221 
2222  // Conversion from a null pointer constant to any Objective-C pointer type.
2223  if (ToType->isObjCObjectPointerType() &&
2224  isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
2225  ConvertedType = ToType;
2226  return true;
2227  }
2228 
2229  // Blocks: Block pointers can be converted to void*.
2230  if (FromType->isBlockPointerType() && ToType->isPointerType() &&
2231  ToType->getAs<PointerType>()->getPointeeType()->isVoidType()) {
2232  ConvertedType = ToType;
2233  return true;
2234  }
2235  // Blocks: A null pointer constant can be converted to a block
2236  // pointer type.
2237  if (ToType->isBlockPointerType() &&
2238  isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
2239  ConvertedType = ToType;
2240  return true;
2241  }
2242 
2243  // If the left-hand-side is nullptr_t, the right side can be a null
2244  // pointer constant.
2245  if (ToType->isNullPtrType() &&
2246  isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
2247  ConvertedType = ToType;
2248  return true;
2249  }
2250 
2251  const PointerType* ToTypePtr = ToType->getAs<PointerType>();
2252  if (!ToTypePtr)
2253  return false;
2254 
2255  // A null pointer constant can be converted to a pointer type (C++ 4.10p1).
2256  if (isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
2257  ConvertedType = ToType;
2258  return true;
2259  }
2260 
2261  // Beyond this point, both types need to be pointers
2262  // , including objective-c pointers.
2263  QualType ToPointeeType = ToTypePtr->getPointeeType();
2264  if (FromType->isObjCObjectPointerType() && ToPointeeType->isVoidType() &&
2265  !getLangOpts().ObjCAutoRefCount) {
2266  ConvertedType = BuildSimilarlyQualifiedPointerType(
2267  FromType->getAs<ObjCObjectPointerType>(),
2268  ToPointeeType,
2269  ToType, Context);
2270  return true;
2271  }
2272  const PointerType *FromTypePtr = FromType->getAs<PointerType>();
2273  if (!FromTypePtr)
2274  return false;
2275 
2276  QualType FromPointeeType = FromTypePtr->getPointeeType();
2277 
2278  // If the unqualified pointee types are the same, this can't be a
2279  // pointer conversion, so don't do all of the work below.
2280  if (Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType))
2281  return false;
2282 
2283  // An rvalue of type "pointer to cv T," where T is an object type,
2284  // can be converted to an rvalue of type "pointer to cv void" (C++
2285  // 4.10p2).
2286  if (FromPointeeType->isIncompleteOrObjectType() &&
2287  ToPointeeType->isVoidType()) {
2288  ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2289  ToPointeeType,
2290  ToType, Context,
2291  /*StripObjCLifetime=*/true);
2292  return true;
2293  }
2294 
2295  // MSVC allows implicit function to void* type conversion.
2296  if (getLangOpts().MSVCCompat && FromPointeeType->isFunctionType() &&
2297  ToPointeeType->isVoidType()) {
2298  ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2299  ToPointeeType,
2300  ToType, Context);
2301  return true;
2302  }
2303 
2304  // When we're overloading in C, we allow a special kind of pointer
2305  // conversion for compatible-but-not-identical pointee types.
2306  if (!getLangOpts().CPlusPlus &&
2307  Context.typesAreCompatible(FromPointeeType, ToPointeeType)) {
2308  ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2309  ToPointeeType,
2310  ToType, Context);
2311  return true;
2312  }
2313 
2314  // C++ [conv.ptr]p3:
2315  //
2316  // An rvalue of type "pointer to cv D," where D is a class type,
2317  // can be converted to an rvalue of type "pointer to cv B," where
2318  // B is a base class (clause 10) of D. If B is an inaccessible
2319  // (clause 11) or ambiguous (10.2) base class of D, a program that
2320  // necessitates this conversion is ill-formed. The result of the
2321  // conversion is a pointer to the base class sub-object of the
2322  // derived class object. The null pointer value is converted to
2323  // the null pointer value of the destination type.
2324  //
2325  // Note that we do not check for ambiguity or inaccessibility
2326  // here. That is handled by CheckPointerConversion.
2327  if (getLangOpts().CPlusPlus &&
2328  FromPointeeType->isRecordType() && ToPointeeType->isRecordType() &&
2329  !Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType) &&
2330  IsDerivedFrom(From->getLocStart(), FromPointeeType, ToPointeeType)) {
2331  ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2332  ToPointeeType,
2333  ToType, Context);
2334  return true;
2335  }
2336 
2337  if (FromPointeeType->isVectorType() && ToPointeeType->isVectorType() &&
2338  Context.areCompatibleVectorTypes(FromPointeeType, ToPointeeType)) {
2339  ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2340  ToPointeeType,
2341  ToType, Context);
2342  return true;
2343  }
2344 
2345  return false;
2346 }
2347 
2348 /// \brief Adopt the given qualifiers for the given type.
2350  Qualifiers TQs = T.getQualifiers();
2351 
2352  // Check whether qualifiers already match.
2353  if (TQs == Qs)
2354  return T;
2355 
2356  if (Qs.compatiblyIncludes(TQs))
2357  return Context.getQualifiedType(T, Qs);
2358 
2359  return Context.getQualifiedType(T.getUnqualifiedType(), Qs);
2360 }
2361 
2362 /// isObjCPointerConversion - Determines whether this is an
2363 /// Objective-C pointer conversion. Subroutine of IsPointerConversion,
2364 /// with the same arguments and return values.
2366  QualType& ConvertedType,
2367  bool &IncompatibleObjC) {
2368  if (!getLangOpts().ObjC1)
2369  return false;
2370 
2371  // The set of qualifiers on the type we're converting from.
2372  Qualifiers FromQualifiers = FromType.getQualifiers();
2373 
2374  // First, we handle all conversions on ObjC object pointer types.
2375  const ObjCObjectPointerType* ToObjCPtr =
2376  ToType->getAs<ObjCObjectPointerType>();
2377  const ObjCObjectPointerType *FromObjCPtr =
2378  FromType->getAs<ObjCObjectPointerType>();
2379 
2380  if (ToObjCPtr && FromObjCPtr) {
2381  // If the pointee types are the same (ignoring qualifications),
2382  // then this is not a pointer conversion.
2383  if (Context.hasSameUnqualifiedType(ToObjCPtr->getPointeeType(),
2384  FromObjCPtr->getPointeeType()))
2385  return false;
2386 
2387  // Conversion between Objective-C pointers.
2388  if (Context.canAssignObjCInterfaces(ToObjCPtr, FromObjCPtr)) {
2389  const ObjCInterfaceType* LHS = ToObjCPtr->getInterfaceType();
2390  const ObjCInterfaceType* RHS = FromObjCPtr->getInterfaceType();
2391  if (getLangOpts().CPlusPlus && LHS && RHS &&
2392  !ToObjCPtr->getPointeeType().isAtLeastAsQualifiedAs(
2393  FromObjCPtr->getPointeeType()))
2394  return false;
2395  ConvertedType = BuildSimilarlyQualifiedPointerType(FromObjCPtr,
2396  ToObjCPtr->getPointeeType(),
2397  ToType, Context);
2398  ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2399  return true;
2400  }
2401 
2402  if (Context.canAssignObjCInterfaces(FromObjCPtr, ToObjCPtr)) {
2403  // Okay: this is some kind of implicit downcast of Objective-C
2404  // interfaces, which is permitted. However, we're going to
2405  // complain about it.
2406  IncompatibleObjC = true;
2407  ConvertedType = BuildSimilarlyQualifiedPointerType(FromObjCPtr,
2408  ToObjCPtr->getPointeeType(),
2409  ToType, Context);
2410  ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2411  return true;
2412  }
2413  }
2414  // Beyond this point, both types need to be C pointers or block pointers.
2415  QualType ToPointeeType;
2416  if (const PointerType *ToCPtr = ToType->getAs<PointerType>())
2417  ToPointeeType = ToCPtr->getPointeeType();
2418  else if (const BlockPointerType *ToBlockPtr =
2419  ToType->getAs<BlockPointerType>()) {
2420  // Objective C++: We're able to convert from a pointer to any object
2421  // to a block pointer type.
2422  if (FromObjCPtr && FromObjCPtr->isObjCBuiltinType()) {
2423  ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2424  return true;
2425  }
2426  ToPointeeType = ToBlockPtr->getPointeeType();
2427  }
2428  else if (FromType->getAs<BlockPointerType>() &&
2429  ToObjCPtr && ToObjCPtr->isObjCBuiltinType()) {
2430  // Objective C++: We're able to convert from a block pointer type to a
2431  // pointer to any object.
2432  ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2433  return true;
2434  }
2435  else
2436  return false;
2437 
2438  QualType FromPointeeType;
2439  if (const PointerType *FromCPtr = FromType->getAs<PointerType>())
2440  FromPointeeType = FromCPtr->getPointeeType();
2441  else if (const BlockPointerType *FromBlockPtr =
2442  FromType->getAs<BlockPointerType>())
2443  FromPointeeType = FromBlockPtr->getPointeeType();
2444  else
2445  return false;
2446 
2447  // If we have pointers to pointers, recursively check whether this
2448  // is an Objective-C conversion.
2449  if (FromPointeeType->isPointerType() && ToPointeeType->isPointerType() &&
2450  isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType,
2451  IncompatibleObjC)) {
2452  // We always complain about this conversion.
2453  IncompatibleObjC = true;
2454  ConvertedType = Context.getPointerType(ConvertedType);
2455  ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2456  return true;
2457  }
2458  // Allow conversion of pointee being objective-c pointer to another one;
2459  // as in I* to id.
2460  if (FromPointeeType->getAs<ObjCObjectPointerType>() &&
2461  ToPointeeType->getAs<ObjCObjectPointerType>() &&
2462  isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType,
2463  IncompatibleObjC)) {
2464 
2465  ConvertedType = Context.getPointerType(ConvertedType);
2466  ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2467  return true;
2468  }
2469 
2470  // If we have pointers to functions or blocks, check whether the only
2471  // differences in the argument and result types are in Objective-C
2472  // pointer conversions. If so, we permit the conversion (but
2473  // complain about it).
2474  const FunctionProtoType *FromFunctionType
2475  = FromPointeeType->getAs<FunctionProtoType>();
2476  const FunctionProtoType *ToFunctionType
2477  = ToPointeeType->getAs<FunctionProtoType>();
2478  if (FromFunctionType && ToFunctionType) {
2479  // If the function types are exactly the same, this isn't an
2480  // Objective-C pointer conversion.
2481  if (Context.getCanonicalType(FromPointeeType)
2482  == Context.getCanonicalType(ToPointeeType))
2483  return false;
2484 
2485  // Perform the quick checks that will tell us whether these
2486  // function types are obviously different.
2487  if (FromFunctionType->getNumParams() != ToFunctionType->getNumParams() ||
2488  FromFunctionType->isVariadic() != ToFunctionType->isVariadic() ||
2489  FromFunctionType->getTypeQuals() != ToFunctionType->getTypeQuals())
2490  return false;
2491 
2492  bool HasObjCConversion = false;
2493  if (Context.getCanonicalType(FromFunctionType->getReturnType()) ==
2494  Context.getCanonicalType(ToFunctionType->getReturnType())) {
2495  // Okay, the types match exactly. Nothing to do.
2496  } else if (isObjCPointerConversion(FromFunctionType->getReturnType(),
2497  ToFunctionType->getReturnType(),
2498  ConvertedType, IncompatibleObjC)) {
2499  // Okay, we have an Objective-C pointer conversion.
2500  HasObjCConversion = true;
2501  } else {
2502  // Function types are too different. Abort.
2503  return false;
2504  }
2505 
2506  // Check argument types.
2507  for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumParams();
2508  ArgIdx != NumArgs; ++ArgIdx) {
2509  QualType FromArgType = FromFunctionType->getParamType(ArgIdx);
2510  QualType ToArgType = ToFunctionType->getParamType(ArgIdx);
2511  if (Context.getCanonicalType(FromArgType)
2512  == Context.getCanonicalType(ToArgType)) {
2513  // Okay, the types match exactly. Nothing to do.
2514  } else if (isObjCPointerConversion(FromArgType, ToArgType,
2515  ConvertedType, IncompatibleObjC)) {
2516  // Okay, we have an Objective-C pointer conversion.
2517  HasObjCConversion = true;
2518  } else {
2519  // Argument types are too different. Abort.
2520  return false;
2521  }
2522  }
2523 
2524  if (HasObjCConversion) {
2525  // We had an Objective-C conversion. Allow this pointer
2526  // conversion, but complain about it.
2527  ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2528  IncompatibleObjC = true;
2529  return true;
2530  }
2531  }
2532 
2533  return false;
2534 }
2535 
2536 /// \brief Determine whether this is an Objective-C writeback conversion,
2537 /// used for parameter passing when performing automatic reference counting.
2538 ///
2539 /// \param FromType The type we're converting form.
2540 ///
2541 /// \param ToType The type we're converting to.
2542 ///
2543 /// \param ConvertedType The type that will be produced after applying
2544 /// this conversion.
2546  QualType &ConvertedType) {
2547  if (!getLangOpts().ObjCAutoRefCount ||
2548  Context.hasSameUnqualifiedType(FromType, ToType))
2549  return false;
2550 
2551  // Parameter must be a pointer to __autoreleasing (with no other qualifiers).
2552  QualType ToPointee;
2553  if (const PointerType *ToPointer = ToType->getAs<PointerType>())
2554  ToPointee = ToPointer->getPointeeType();
2555  else
2556  return false;
2557 
2558  Qualifiers ToQuals = ToPointee.getQualifiers();
2559  if (!ToPointee->isObjCLifetimeType() ||
2561  !ToQuals.withoutObjCLifetime().empty())
2562  return false;
2563 
2564  // Argument must be a pointer to __strong to __weak.
2565  QualType FromPointee;
2566  if (const PointerType *FromPointer = FromType->getAs<PointerType>())
2567  FromPointee = FromPointer->getPointeeType();
2568  else
2569  return false;
2570 
2571  Qualifiers FromQuals = FromPointee.getQualifiers();
2572  if (!FromPointee->isObjCLifetimeType() ||
2573  (FromQuals.getObjCLifetime() != Qualifiers::OCL_Strong &&
2574  FromQuals.getObjCLifetime() != Qualifiers::OCL_Weak))
2575  return false;
2576 
2577  // Make sure that we have compatible qualifiers.
2579  if (!ToQuals.compatiblyIncludes(FromQuals))
2580  return false;
2581 
2582  // Remove qualifiers from the pointee type we're converting from; they
2583  // aren't used in the compatibility check belong, and we'll be adding back
2584  // qualifiers (with __autoreleasing) if the compatibility check succeeds.
2585  FromPointee = FromPointee.getUnqualifiedType();
2586 
2587  // The unqualified form of the pointee types must be compatible.
2588  ToPointee = ToPointee.getUnqualifiedType();
2589  bool IncompatibleObjC;
2590  if (Context.typesAreCompatible(FromPointee, ToPointee))
2591  FromPointee = ToPointee;
2592  else if (!isObjCPointerConversion(FromPointee, ToPointee, FromPointee,
2593  IncompatibleObjC))
2594  return false;
2595 
2596  /// \brief Construct the type we're converting to, which is a pointer to
2597  /// __autoreleasing pointee.
2598  FromPointee = Context.getQualifiedType(FromPointee, FromQuals);
2599  ConvertedType = Context.getPointerType(FromPointee);
2600  return true;
2601 }
2602 
2604  QualType& ConvertedType) {
2605  QualType ToPointeeType;
2606  if (const BlockPointerType *ToBlockPtr =
2607  ToType->getAs<BlockPointerType>())
2608  ToPointeeType = ToBlockPtr->getPointeeType();
2609  else
2610  return false;
2611 
2612  QualType FromPointeeType;
2613  if (const BlockPointerType *FromBlockPtr =
2614  FromType->getAs<BlockPointerType>())
2615  FromPointeeType = FromBlockPtr->getPointeeType();
2616  else
2617  return false;
2618  // We have pointer to blocks, check whether the only
2619  // differences in the argument and result types are in Objective-C
2620  // pointer conversions. If so, we permit the conversion.
2621 
2622  const FunctionProtoType *FromFunctionType
2623  = FromPointeeType->getAs<FunctionProtoType>();
2624  const FunctionProtoType *ToFunctionType
2625  = ToPointeeType->getAs<FunctionProtoType>();
2626 
2627  if (!FromFunctionType || !ToFunctionType)
2628  return false;
2629 
2630  if (Context.hasSameType(FromPointeeType, ToPointeeType))
2631  return true;
2632 
2633  // Perform the quick checks that will tell us whether these
2634  // function types are obviously different.
2635  if (FromFunctionType->getNumParams() != ToFunctionType->getNumParams() ||
2636  FromFunctionType->isVariadic() != ToFunctionType->isVariadic())
2637  return false;
2638 
2639  FunctionType::ExtInfo FromEInfo = FromFunctionType->getExtInfo();
2640  FunctionType::ExtInfo ToEInfo = ToFunctionType->getExtInfo();
2641  if (FromEInfo != ToEInfo)
2642  return false;
2643 
2644  bool IncompatibleObjC = false;
2645  if (Context.hasSameType(FromFunctionType->getReturnType(),
2646  ToFunctionType->getReturnType())) {
2647  // Okay, the types match exactly. Nothing to do.
2648  } else {
2649  QualType RHS = FromFunctionType->getReturnType();
2650  QualType LHS = ToFunctionType->getReturnType();
2651  if ((!getLangOpts().CPlusPlus || !RHS->isRecordType()) &&
2652  !RHS.hasQualifiers() && LHS.hasQualifiers())
2653  LHS = LHS.getUnqualifiedType();
2654 
2655  if (Context.hasSameType(RHS,LHS)) {
2656  // OK exact match.
2657  } else if (isObjCPointerConversion(RHS, LHS,
2658  ConvertedType, IncompatibleObjC)) {
2659  if (IncompatibleObjC)
2660  return false;
2661  // Okay, we have an Objective-C pointer conversion.
2662  }
2663  else
2664  return false;
2665  }
2666 
2667  // Check argument types.
2668  for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumParams();
2669  ArgIdx != NumArgs; ++ArgIdx) {
2670  IncompatibleObjC = false;
2671  QualType FromArgType = FromFunctionType->getParamType(ArgIdx);
2672  QualType ToArgType = ToFunctionType->getParamType(ArgIdx);
2673  if (Context.hasSameType(FromArgType, ToArgType)) {
2674  // Okay, the types match exactly. Nothing to do.
2675  } else if (isObjCPointerConversion(ToArgType, FromArgType,
2676  ConvertedType, IncompatibleObjC)) {
2677  if (IncompatibleObjC)
2678  return false;
2679  // Okay, we have an Objective-C pointer conversion.
2680  } else
2681  // Argument types are too different. Abort.
2682  return false;
2683  }
2684 
2686  bool CanUseToFPT, CanUseFromFPT;
2687  if (!Context.mergeExtParameterInfo(ToFunctionType, FromFunctionType,
2688  CanUseToFPT, CanUseFromFPT,
2689  NewParamInfos))
2690  return false;
2691 
2692  ConvertedType = ToType;
2693  return true;
2694 }
2695 
2696 enum {
2704 };
2705 
2706 /// Attempts to get the FunctionProtoType from a Type. Handles
2707 /// MemberFunctionPointers properly.
2709  if (auto *FPT = FromType->getAs<FunctionProtoType>())
2710  return FPT;
2711 
2712  if (auto *MPT = FromType->getAs<MemberPointerType>())
2713  return MPT->getPointeeType()->getAs<FunctionProtoType>();
2714 
2715  return nullptr;
2716 }
2717 
2718 /// HandleFunctionTypeMismatch - Gives diagnostic information for differeing
2719 /// function types. Catches different number of parameter, mismatch in
2720 /// parameter types, and different return types.
2722  QualType FromType, QualType ToType) {
2723  // If either type is not valid, include no extra info.
2724  if (FromType.isNull() || ToType.isNull()) {
2725  PDiag << ft_default;
2726  return;
2727  }
2728 
2729  // Get the function type from the pointers.
2730  if (FromType->isMemberPointerType() && ToType->isMemberPointerType()) {
2731  const MemberPointerType *FromMember = FromType->getAs<MemberPointerType>(),
2732  *ToMember = ToType->getAs<MemberPointerType>();
2733  if (!Context.hasSameType(FromMember->getClass(), ToMember->getClass())) {
2734  PDiag << ft_different_class << QualType(ToMember->getClass(), 0)
2735  << QualType(FromMember->getClass(), 0);
2736  return;
2737  }
2738  FromType = FromMember->getPointeeType();
2739  ToType = ToMember->getPointeeType();
2740  }
2741 
2742  if (FromType->isPointerType())
2743  FromType = FromType->getPointeeType();
2744  if (ToType->isPointerType())
2745  ToType = ToType->getPointeeType();
2746 
2747  // Remove references.
2748  FromType = FromType.getNonReferenceType();
2749  ToType = ToType.getNonReferenceType();
2750 
2751  // Don't print extra info for non-specialized template functions.
2752  if (FromType->isInstantiationDependentType() &&
2753  !FromType->getAs<TemplateSpecializationType>()) {
2754  PDiag << ft_default;
2755  return;
2756  }
2757 
2758  // No extra info for same types.
2759  if (Context.hasSameType(FromType, ToType)) {
2760  PDiag << ft_default;
2761  return;
2762  }
2763 
2764  const FunctionProtoType *FromFunction = tryGetFunctionProtoType(FromType),
2765  *ToFunction = tryGetFunctionProtoType(ToType);
2766 
2767  // Both types need to be function types.
2768  if (!FromFunction || !ToFunction) {
2769  PDiag << ft_default;
2770  return;
2771  }
2772 
2773  if (FromFunction->getNumParams() != ToFunction->getNumParams()) {
2774  PDiag << ft_parameter_arity << ToFunction->getNumParams()
2775  << FromFunction->getNumParams();
2776  return;
2777  }
2778 
2779  // Handle different parameter types.
2780  unsigned ArgPos;
2781  if (!FunctionParamTypesAreEqual(FromFunction, ToFunction, &ArgPos)) {
2782  PDiag << ft_parameter_mismatch << ArgPos + 1
2783  << ToFunction->getParamType(ArgPos)
2784  << FromFunction->getParamType(ArgPos);
2785  return;
2786  }
2787 
2788  // Handle different return type.
2789  if (!Context.hasSameType(FromFunction->getReturnType(),
2790  ToFunction->getReturnType())) {
2791  PDiag << ft_return_type << ToFunction->getReturnType()
2792  << FromFunction->getReturnType();
2793  return;
2794  }
2795 
2796  unsigned FromQuals = FromFunction->getTypeQuals(),
2797  ToQuals = ToFunction->getTypeQuals();
2798  if (FromQuals != ToQuals) {
2799  PDiag << ft_qualifer_mismatch << ToQuals << FromQuals;
2800  return;
2801  }
2802 
2803  // Handle exception specification differences on canonical type (in C++17
2804  // onwards).
2805  if (cast<FunctionProtoType>(FromFunction->getCanonicalTypeUnqualified())
2806  ->isNothrow(Context) !=
2807  cast<FunctionProtoType>(ToFunction->getCanonicalTypeUnqualified())
2808  ->isNothrow(Context)) {
2809  PDiag << ft_noexcept;
2810  return;
2811  }
2812 
2813  // Unable to find a difference, so add no extra info.
2814  PDiag << ft_default;
2815 }
2816 
2817 /// FunctionParamTypesAreEqual - This routine checks two function proto types
2818 /// for equality of their argument types. Caller has already checked that
2819 /// they have same number of arguments. If the parameters are different,
2820 /// ArgPos will have the parameter index of the first different parameter.
2822  const FunctionProtoType *NewType,
2823  unsigned *ArgPos) {
2825  N = NewType->param_type_begin(),
2826  E = OldType->param_type_end();
2827  O && (O != E); ++O, ++N) {
2828  if (!Context.hasSameType(O->getUnqualifiedType(),
2829  N->getUnqualifiedType())) {
2830  if (ArgPos)
2831  *ArgPos = O - OldType->param_type_begin();
2832  return false;
2833  }
2834  }
2835  return true;
2836 }
2837 
2838 /// CheckPointerConversion - Check the pointer conversion from the
2839 /// expression From to the type ToType. This routine checks for
2840 /// ambiguous or inaccessible derived-to-base pointer
2841 /// conversions for which IsPointerConversion has already returned
2842 /// true. It returns true and produces a diagnostic if there was an
2843 /// error, or returns false otherwise.
2845  CastKind &Kind,
2846  CXXCastPath& BasePath,
2847  bool IgnoreBaseAccess,
2848  bool Diagnose) {
2849  QualType FromType = From->getType();
2850  bool IsCStyleOrFunctionalCast = IgnoreBaseAccess;
2851 
2852  Kind = CK_BitCast;
2853 
2854  if (Diagnose && !IsCStyleOrFunctionalCast && !FromType->isAnyPointerType() &&
2857  if (Context.hasSameUnqualifiedType(From->getType(), Context.BoolTy))
2858  DiagRuntimeBehavior(From->getExprLoc(), From,
2859  PDiag(diag::warn_impcast_bool_to_null_pointer)
2860  << ToType << From->getSourceRange());
2861  else if (!isUnevaluatedContext())
2862  Diag(From->getExprLoc(), diag::warn_non_literal_null_pointer)
2863  << ToType << From->getSourceRange();
2864  }
2865  if (const PointerType *ToPtrType = ToType->getAs<PointerType>()) {
2866  if (const PointerType *FromPtrType = FromType->getAs<PointerType>()) {
2867  QualType FromPointeeType = FromPtrType->getPointeeType(),
2868  ToPointeeType = ToPtrType->getPointeeType();
2869 
2870  if (FromPointeeType->isRecordType() && ToPointeeType->isRecordType() &&
2871  !Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType)) {
2872  // We must have a derived-to-base conversion. Check an
2873  // ambiguous or inaccessible conversion.
2874  unsigned InaccessibleID = 0;
2875  unsigned AmbigiousID = 0;
2876  if (Diagnose) {
2877  InaccessibleID = diag::err_upcast_to_inaccessible_base;
2878  AmbigiousID = diag::err_ambiguous_derived_to_base_conv;
2879  }
2880  if (CheckDerivedToBaseConversion(
2881  FromPointeeType, ToPointeeType, InaccessibleID, AmbigiousID,
2882  From->getExprLoc(), From->getSourceRange(), DeclarationName(),
2883  &BasePath, IgnoreBaseAccess))
2884  return true;
2885 
2886  // The conversion was successful.
2887  Kind = CK_DerivedToBase;
2888  }
2889 
2890  if (Diagnose && !IsCStyleOrFunctionalCast &&
2891  FromPointeeType->isFunctionType() && ToPointeeType->isVoidType()) {
2892  assert(getLangOpts().MSVCCompat &&
2893  "this should only be possible with MSVCCompat!");
2894  Diag(From->getExprLoc(), diag::ext_ms_impcast_fn_obj)
2895  << From->getSourceRange();
2896  }
2897  }
2898  } else if (const ObjCObjectPointerType *ToPtrType =
2899  ToType->getAs<ObjCObjectPointerType>()) {
2900  if (const ObjCObjectPointerType *FromPtrType =
2901  FromType->getAs<ObjCObjectPointerType>()) {
2902  // Objective-C++ conversions are always okay.
2903  // FIXME: We should have a different class of conversions for the
2904  // Objective-C++ implicit conversions.
2905  if (FromPtrType->isObjCBuiltinType() || ToPtrType->isObjCBuiltinType())
2906  return false;
2907  } else if (FromType->isBlockPointerType()) {
2908  Kind = CK_BlockPointerToObjCPointerCast;
2909  } else {
2910  Kind = CK_CPointerToObjCPointerCast;
2911  }
2912  } else if (ToType->isBlockPointerType()) {
2913  if (!FromType->isBlockPointerType())
2914  Kind = CK_AnyPointerToBlockPointerCast;
2915  }
2916 
2917  // We shouldn't fall into this case unless it's valid for other
2918  // reasons.
2920  Kind = CK_NullToPointer;
2921 
2922  return false;
2923 }
2924 
2925 /// IsMemberPointerConversion - Determines whether the conversion of the
2926 /// expression From, which has the (possibly adjusted) type FromType, can be
2927 /// converted to the type ToType via a member pointer conversion (C++ 4.11).
2928 /// If so, returns true and places the converted type (that might differ from
2929 /// ToType in its cv-qualifiers at some level) into ConvertedType.
2931  QualType ToType,
2932  bool InOverloadResolution,
2933  QualType &ConvertedType) {
2934  const MemberPointerType *ToTypePtr = ToType->getAs<MemberPointerType>();
2935  if (!ToTypePtr)
2936  return false;
2937 
2938  // A null pointer constant can be converted to a member pointer (C++ 4.11p1)
2939  if (From->isNullPointerConstant(Context,
2940  InOverloadResolution? Expr::NPC_ValueDependentIsNotNull
2942  ConvertedType = ToType;
2943  return true;
2944  }
2945 
2946  // Otherwise, both types have to be member pointers.
2947  const MemberPointerType *FromTypePtr = FromType->getAs<MemberPointerType>();
2948  if (!FromTypePtr)
2949  return false;
2950 
2951  // A pointer to member of B can be converted to a pointer to member of D,
2952  // where D is derived from B (C++ 4.11p2).
2953  QualType FromClass(FromTypePtr->getClass(), 0);
2954  QualType ToClass(ToTypePtr->getClass(), 0);
2955 
2956  if (!Context.hasSameUnqualifiedType(FromClass, ToClass) &&
2957  IsDerivedFrom(From->getLocStart(), ToClass, FromClass)) {
2958  ConvertedType = Context.getMemberPointerType(FromTypePtr->getPointeeType(),
2959  ToClass.getTypePtr());
2960  return true;
2961  }
2962 
2963  return false;
2964 }
2965 
2966 /// CheckMemberPointerConversion - Check the member pointer conversion from the
2967 /// expression From to the type ToType. This routine checks for ambiguous or
2968 /// virtual or inaccessible base-to-derived member pointer conversions
2969 /// for which IsMemberPointerConversion has already returned true. It returns
2970 /// true and produces a diagnostic if there was an error, or returns false
2971 /// otherwise.
2973  CastKind &Kind,
2974  CXXCastPath &BasePath,
2975  bool IgnoreBaseAccess) {
2976  QualType FromType = From->getType();
2977  const MemberPointerType *FromPtrType = FromType->getAs<MemberPointerType>();
2978  if (!FromPtrType) {
2979  // This must be a null pointer to member pointer conversion
2980  assert(From->isNullPointerConstant(Context,
2982  "Expr must be null pointer constant!");
2983  Kind = CK_NullToMemberPointer;
2984  return false;
2985  }
2986 
2987  const MemberPointerType *ToPtrType = ToType->getAs<MemberPointerType>();
2988  assert(ToPtrType && "No member pointer cast has a target type "
2989  "that is not a member pointer.");
2990 
2991  QualType FromClass = QualType(FromPtrType->getClass(), 0);
2992  QualType ToClass = QualType(ToPtrType->getClass(), 0);
2993 
2994  // FIXME: What about dependent types?
2995  assert(FromClass->isRecordType() && "Pointer into non-class.");
2996  assert(ToClass->isRecordType() && "Pointer into non-class.");
2997 
2998  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
2999  /*DetectVirtual=*/true);
3000  bool DerivationOkay =
3001  IsDerivedFrom(From->getLocStart(), ToClass, FromClass, Paths);
3002  assert(DerivationOkay &&
3003  "Should not have been called if derivation isn't OK.");
3004  (void)DerivationOkay;
3005 
3006  if (Paths.isAmbiguous(Context.getCanonicalType(FromClass).
3007  getUnqualifiedType())) {
3008  std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
3009  Diag(From->getExprLoc(), diag::err_ambiguous_memptr_conv)
3010  << 0 << FromClass << ToClass << PathDisplayStr << From->getSourceRange();
3011  return true;
3012  }
3013 
3014  if (const RecordType *VBase = Paths.getDetectedVirtual()) {
3015  Diag(From->getExprLoc(), diag::err_memptr_conv_via_virtual)
3016  << FromClass << ToClass << QualType(VBase, 0)
3017  << From->getSourceRange();
3018  return true;
3019  }
3020 
3021  if (!IgnoreBaseAccess)
3022  CheckBaseClassAccess(From->getExprLoc(), FromClass, ToClass,
3023  Paths.front(),
3024  diag::err_downcast_from_inaccessible_base);
3025 
3026  // Must be a base to derived member conversion.
3027  BuildBasePathArray(Paths, BasePath);
3028  Kind = CK_BaseToDerivedMemberPointer;
3029  return false;
3030 }
3031 
3032 /// Determine whether the lifetime conversion between the two given
3033 /// qualifiers sets is nontrivial.
3035  Qualifiers ToQuals) {
3036  // Converting anything to const __unsafe_unretained is trivial.
3037  if (ToQuals.hasConst() &&
3039  return false;
3040 
3041  return true;
3042 }
3043 
3044 /// IsQualificationConversion - Determines whether the conversion from
3045 /// an rvalue of type FromType to ToType is a qualification conversion
3046 /// (C++ 4.4).
3047 ///
3048 /// \param ObjCLifetimeConversion Output parameter that will be set to indicate
3049 /// when the qualification conversion involves a change in the Objective-C
3050 /// object lifetime.
3051 bool
3053  bool CStyle, bool &ObjCLifetimeConversion) {
3054  FromType = Context.getCanonicalType(FromType);
3055  ToType = Context.getCanonicalType(ToType);
3056  ObjCLifetimeConversion = false;
3057 
3058  // If FromType and ToType are the same type, this is not a
3059  // qualification conversion.
3060  if (FromType.getUnqualifiedType() == ToType.getUnqualifiedType())
3061  return false;
3062 
3063  // (C++ 4.4p4):
3064  // A conversion can add cv-qualifiers at levels other than the first
3065  // in multi-level pointers, subject to the following rules: [...]
3066  bool PreviousToQualsIncludeConst = true;
3067  bool UnwrappedAnyPointer = false;
3068  while (Context.UnwrapSimilarPointerTypes(FromType, ToType)) {
3069  // Within each iteration of the loop, we check the qualifiers to
3070  // determine if this still looks like a qualification
3071  // conversion. Then, if all is well, we unwrap one more level of
3072  // pointers or pointers-to-members and do it all again
3073  // until there are no more pointers or pointers-to-members left to
3074  // unwrap.
3075  UnwrappedAnyPointer = true;
3076 
3077  Qualifiers FromQuals = FromType.getQualifiers();
3078  Qualifiers ToQuals = ToType.getQualifiers();
3079 
3080  // Ignore __unaligned qualifier if this type is void.
3081  if (ToType.getUnqualifiedType()->isVoidType())
3082  FromQuals.removeUnaligned();
3083 
3084  // Objective-C ARC:
3085  // Check Objective-C lifetime conversions.
3086  if (FromQuals.getObjCLifetime() != ToQuals.getObjCLifetime() &&
3087  UnwrappedAnyPointer) {
3088  if (ToQuals.compatiblyIncludesObjCLifetime(FromQuals)) {
3089  if (isNonTrivialObjCLifetimeConversion(FromQuals, ToQuals))
3090  ObjCLifetimeConversion = true;
3091  FromQuals.removeObjCLifetime();
3092  ToQuals.removeObjCLifetime();
3093  } else {
3094  // Qualification conversions cannot cast between different
3095  // Objective-C lifetime qualifiers.
3096  return false;
3097  }
3098  }
3099 
3100  // Allow addition/removal of GC attributes but not changing GC attributes.
3101  if (FromQuals.getObjCGCAttr() != ToQuals.getObjCGCAttr() &&
3102  (!FromQuals.hasObjCGCAttr() || !ToQuals.hasObjCGCAttr())) {
3103  FromQuals.removeObjCGCAttr();
3104  ToQuals.removeObjCGCAttr();
3105  }
3106 
3107  // -- for every j > 0, if const is in cv 1,j then const is in cv
3108  // 2,j, and similarly for volatile.
3109  if (!CStyle && !ToQuals.compatiblyIncludes(FromQuals))
3110  return false;
3111 
3112  // -- if the cv 1,j and cv 2,j are different, then const is in
3113  // every cv for 0 < k < j.
3114  if (!CStyle && FromQuals.getCVRQualifiers() != ToQuals.getCVRQualifiers()
3115  && !PreviousToQualsIncludeConst)
3116  return false;
3117 
3118  // Keep track of whether all prior cv-qualifiers in the "to" type
3119  // include const.
3120  PreviousToQualsIncludeConst
3121  = PreviousToQualsIncludeConst && ToQuals.hasConst();
3122  }
3123 
3124  // We are left with FromType and ToType being the pointee types
3125  // after unwrapping the original FromType and ToType the same number
3126  // of types. If we unwrapped any pointers, and if FromType and
3127  // ToType have the same unqualified type (since we checked
3128  // qualifiers above), then this is a qualification conversion.
3129  return UnwrappedAnyPointer && Context.hasSameUnqualifiedType(FromType,ToType);
3130 }
3131 
3132 /// \brief - Determine whether this is a conversion from a scalar type to an
3133 /// atomic type.
3134 ///
3135 /// If successful, updates \c SCS's second and third steps in the conversion
3136 /// sequence to finish the conversion.
3137 static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType,
3138  bool InOverloadResolution,
3140  bool CStyle) {
3141  const AtomicType *ToAtomic = ToType->getAs<AtomicType>();
3142  if (!ToAtomic)
3143  return false;
3144 
3145  StandardConversionSequence InnerSCS;
3146  if (!IsStandardConversion(S, From, ToAtomic->getValueType(),
3147  InOverloadResolution, InnerSCS,
3148  CStyle, /*AllowObjCWritebackConversion=*/false))
3149  return false;
3150 
3151  SCS.Second = InnerSCS.Second;
3152  SCS.setToType(1, InnerSCS.getToType(1));
3153  SCS.Third = InnerSCS.Third;
3155  = InnerSCS.QualificationIncludesObjCLifetime;
3156  SCS.setToType(2, InnerSCS.getToType(2));
3157  return true;
3158 }
3159 
3161  CXXConstructorDecl *Constructor,
3162  QualType Type) {
3163  const FunctionProtoType *CtorType =
3164  Constructor->getType()->getAs<FunctionProtoType>();
3165  if (CtorType->getNumParams() > 0) {
3166  QualType FirstArg = CtorType->getParamType(0);
3167  if (Context.hasSameUnqualifiedType(Type, FirstArg.getNonReferenceType()))
3168  return true;
3169  }
3170  return false;
3171 }
3172 
3173 static OverloadingResult
3175  CXXRecordDecl *To,
3177  OverloadCandidateSet &CandidateSet,
3178  bool AllowExplicit) {
3180  for (auto *D : S.LookupConstructors(To)) {
3181  auto Info = getConstructorInfo(D);
3182  if (!Info)
3183  continue;
3184 
3185  bool Usable = !Info.Constructor->isInvalidDecl() &&
3186  S.isInitListConstructor(Info.Constructor) &&
3187  (AllowExplicit || !Info.Constructor->isExplicit());
3188  if (Usable) {
3189  // If the first argument is (a reference to) the target type,
3190  // suppress conversions.
3191  bool SuppressUserConversions = isFirstArgumentCompatibleWithType(
3192  S.Context, Info.Constructor, ToType);
3193  if (Info.ConstructorTmpl)
3194  S.AddTemplateOverloadCandidate(Info.ConstructorTmpl, Info.FoundDecl,
3195  /*ExplicitArgs*/ nullptr, From,
3196  CandidateSet, SuppressUserConversions);
3197  else
3198  S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl, From,
3199  CandidateSet, SuppressUserConversions);
3200  }
3201  }
3202 
3203  bool HadMultipleCandidates = (CandidateSet.size() > 1);
3204 
3206  switch (auto Result =
3207  CandidateSet.BestViableFunction(S, From->getLocStart(),
3208  Best)) {
3209  case OR_Deleted:
3210  case OR_Success: {
3211  // Record the standard conversion we used and the conversion function.
3212  CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function);
3213  QualType ThisType = Constructor->getThisType(S.Context);
3214  // Initializer lists don't have conversions as such.
3216  User.HadMultipleCandidates = HadMultipleCandidates;
3217  User.ConversionFunction = Constructor;
3218  User.FoundConversionFunction = Best->FoundDecl;
3220  User.After.setFromType(ThisType->getAs<PointerType>()->getPointeeType());
3221  User.After.setAllToTypes(ToType);
3222  return Result;
3223  }
3224 
3225  case OR_No_Viable_Function:
3226  return OR_No_Viable_Function;
3227  case OR_Ambiguous:
3228  return OR_Ambiguous;
3229  }
3230 
3231  llvm_unreachable("Invalid OverloadResult!");
3232 }
3233 
3234 /// Determines whether there is a user-defined conversion sequence
3235 /// (C++ [over.ics.user]) that converts expression From to the type
3236 /// ToType. If such a conversion exists, User will contain the
3237 /// user-defined conversion sequence that performs such a conversion
3238 /// and this routine will return true. Otherwise, this routine returns
3239 /// false and User is unspecified.
3240 ///
3241 /// \param AllowExplicit true if the conversion should consider C++0x
3242 /// "explicit" conversion functions as well as non-explicit conversion
3243 /// functions (C++0x [class.conv.fct]p2).
3244 ///
3245 /// \param AllowObjCConversionOnExplicit true if the conversion should
3246 /// allow an extra Objective-C pointer conversion on uses of explicit
3247 /// constructors. Requires \c AllowExplicit to also be set.
3248 static OverloadingResult
3251  OverloadCandidateSet &CandidateSet,
3252  bool AllowExplicit,
3253  bool AllowObjCConversionOnExplicit) {
3254  assert(AllowExplicit || !AllowObjCConversionOnExplicit);
3256 
3257  // Whether we will only visit constructors.
3258  bool ConstructorsOnly = false;
3259 
3260  // If the type we are conversion to is a class type, enumerate its
3261  // constructors.
3262  if (const RecordType *ToRecordType = ToType->getAs<RecordType>()) {
3263  // C++ [over.match.ctor]p1:
3264  // When objects of class type are direct-initialized (8.5), or
3265  // copy-initialized from an expression of the same or a
3266  // derived class type (8.5), overload resolution selects the
3267  // constructor. [...] For copy-initialization, the candidate
3268  // functions are all the converting constructors (12.3.1) of
3269  // that class. The argument list is the expression-list within
3270  // the parentheses of the initializer.
3271  if (S.Context.hasSameUnqualifiedType(ToType, From->getType()) ||
3272  (From->getType()->getAs<RecordType>() &&
3273  S.IsDerivedFrom(From->getLocStart(), From->getType(), ToType)))
3274  ConstructorsOnly = true;
3275 
3276  if (!S.isCompleteType(From->getExprLoc(), ToType)) {
3277  // We're not going to find any constructors.
3278  } else if (CXXRecordDecl *ToRecordDecl
3279  = dyn_cast<CXXRecordDecl>(ToRecordType->getDecl())) {
3280 
3281  Expr **Args = &From;
3282  unsigned NumArgs = 1;
3283  bool ListInitializing = false;
3284  if (InitListExpr *InitList = dyn_cast<InitListExpr>(From)) {
3285  // But first, see if there is an init-list-constructor that will work.
3287  S, From, ToType, ToRecordDecl, User, CandidateSet, AllowExplicit);
3288  if (Result != OR_No_Viable_Function)
3289  return Result;
3290  // Never mind.
3291  CandidateSet.clear(
3293 
3294  // If we're list-initializing, we pass the individual elements as
3295  // arguments, not the entire list.
3296  Args = InitList->getInits();
3297  NumArgs = InitList->getNumInits();
3298  ListInitializing = true;
3299  }
3300 
3301  for (auto *D : S.LookupConstructors(ToRecordDecl)) {
3302  auto Info = getConstructorInfo(D);
3303  if (!Info)
3304  continue;
3305 
3306  bool Usable = !Info.Constructor->isInvalidDecl();
3307  if (ListInitializing)
3308  Usable = Usable && (AllowExplicit || !Info.Constructor->isExplicit());
3309  else
3310  Usable = Usable &&
3311  Info.Constructor->isConvertingConstructor(AllowExplicit);
3312  if (Usable) {
3313  bool SuppressUserConversions = !ConstructorsOnly;
3314  if (SuppressUserConversions && ListInitializing) {
3315  SuppressUserConversions = false;
3316  if (NumArgs == 1) {
3317  // If the first argument is (a reference to) the target type,
3318  // suppress conversions.
3319  SuppressUserConversions = isFirstArgumentCompatibleWithType(
3320  S.Context, Info.Constructor, ToType);
3321  }
3322  }
3323  if (Info.ConstructorTmpl)
3325  Info.ConstructorTmpl, Info.FoundDecl,
3326  /*ExplicitArgs*/ nullptr, llvm::makeArrayRef(Args, NumArgs),
3327  CandidateSet, SuppressUserConversions);
3328  else
3329  // Allow one user-defined conversion when user specifies a
3330  // From->ToType conversion via an static cast (c-style, etc).
3331  S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl,
3332  llvm::makeArrayRef(Args, NumArgs),
3333  CandidateSet, SuppressUserConversions);
3334  }
3335  }
3336  }
3337  }
3338 
3339  // Enumerate conversion functions, if we're allowed to.
3340  if (ConstructorsOnly || isa<InitListExpr>(From)) {
3341  } else if (!S.isCompleteType(From->getLocStart(), From->getType())) {
3342  // No conversion functions from incomplete types.
3343  } else if (const RecordType *FromRecordType
3344  = From->getType()->getAs<RecordType>()) {
3345  if (CXXRecordDecl *FromRecordDecl
3346  = dyn_cast<CXXRecordDecl>(FromRecordType->getDecl())) {
3347  // Add all of the conversion functions as candidates.
3348  const auto &Conversions = FromRecordDecl->getVisibleConversionFunctions();
3349  for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
3350  DeclAccessPair FoundDecl = I.getPair();
3351  NamedDecl *D = FoundDecl.getDecl();
3352  CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext());
3353  if (isa<UsingShadowDecl>(D))
3354  D = cast<UsingShadowDecl>(D)->getTargetDecl();
3355 
3356  CXXConversionDecl *Conv;
3357  FunctionTemplateDecl *ConvTemplate;
3358  if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D)))
3359  Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
3360  else
3361  Conv = cast<CXXConversionDecl>(D);
3362 
3363  if (AllowExplicit || !Conv->isExplicit()) {
3364  if (ConvTemplate)
3365  S.AddTemplateConversionCandidate(ConvTemplate, FoundDecl,
3366  ActingContext, From, ToType,
3367  CandidateSet,
3368  AllowObjCConversionOnExplicit);
3369  else
3370  S.AddConversionCandidate(Conv, FoundDecl, ActingContext,
3371  From, ToType, CandidateSet,
3372  AllowObjCConversionOnExplicit);
3373  }
3374  }
3375  }
3376  }
3377 
3378  bool HadMultipleCandidates = (CandidateSet.size() > 1);
3379 
3381  switch (auto Result = CandidateSet.BestViableFunction(S, From->getLocStart(),
3382  Best)) {
3383  case OR_Success:
3384  case OR_Deleted:
3385  // Record the standard conversion we used and the conversion function.
3386  if (CXXConstructorDecl *Constructor
3387  = dyn_cast<CXXConstructorDecl>(Best->Function)) {
3388  // C++ [over.ics.user]p1:
3389  // If the user-defined conversion is specified by a
3390  // constructor (12.3.1), the initial standard conversion
3391  // sequence converts the source type to the type required by
3392  // the argument of the constructor.
3393  //
3394  QualType ThisType = Constructor->getThisType(S.Context);
3395  if (isa<InitListExpr>(From)) {
3396  // Initializer lists don't have conversions as such.
3398  } else {
3399  if (Best->Conversions[0].isEllipsis())
3400  User.EllipsisConversion = true;
3401  else {
3402  User.Before = Best->Conversions[0].Standard;
3403  User.EllipsisConversion = false;
3404  }
3405  }
3406  User.HadMultipleCandidates = HadMultipleCandidates;
3407  User.ConversionFunction = Constructor;
3408  User.FoundConversionFunction = Best->FoundDecl;
3410  User.After.setFromType(ThisType->getAs<PointerType>()->getPointeeType());
3411  User.After.setAllToTypes(ToType);
3412  return Result;
3413  }
3414  if (CXXConversionDecl *Conversion
3415  = dyn_cast<CXXConversionDecl>(Best->Function)) {
3416  // C++ [over.ics.user]p1:
3417  //
3418  // [...] If the user-defined conversion is specified by a
3419  // conversion function (12.3.2), the initial standard
3420  // conversion sequence converts the source type to the
3421  // implicit object parameter of the conversion function.
3422  User.Before = Best->Conversions[0].Standard;
3423  User.HadMultipleCandidates = HadMultipleCandidates;
3424  User.ConversionFunction = Conversion;
3425  User.FoundConversionFunction = Best->FoundDecl;
3426  User.EllipsisConversion = false;
3427 
3428  // C++ [over.ics.user]p2:
3429  // The second standard conversion sequence converts the
3430  // result of the user-defined conversion to the target type
3431  // for the sequence. Since an implicit conversion sequence
3432  // is an initialization, the special rules for
3433  // initialization by user-defined conversion apply when
3434  // selecting the best user-defined conversion for a
3435  // user-defined conversion sequence (see 13.3.3 and
3436  // 13.3.3.1).
3437  User.After = Best->FinalConversion;
3438  return Result;
3439  }
3440  llvm_unreachable("Not a constructor or conversion function?");
3441 
3442  case OR_No_Viable_Function:
3443  return OR_No_Viable_Function;
3444 
3445  case OR_Ambiguous:
3446  return OR_Ambiguous;
3447  }
3448 
3449  llvm_unreachable("Invalid OverloadResult!");
3450 }
3451 
3452 bool
3455  OverloadCandidateSet CandidateSet(From->getExprLoc(),
3457  OverloadingResult OvResult =
3458  IsUserDefinedConversion(*this, From, ToType, ICS.UserDefined,
3459  CandidateSet, false, false);
3460  if (OvResult == OR_Ambiguous)
3461  Diag(From->getLocStart(), diag::err_typecheck_ambiguous_condition)
3462  << From->getType() << ToType << From->getSourceRange();
3463  else if (OvResult == OR_No_Viable_Function && !CandidateSet.empty()) {
3464  if (!RequireCompleteType(From->getLocStart(), ToType,
3465  diag::err_typecheck_nonviable_condition_incomplete,
3466  From->getType(), From->getSourceRange()))
3467  Diag(From->getLocStart(), diag::err_typecheck_nonviable_condition)
3468  << false << From->getType() << From->getSourceRange() << ToType;
3469  } else
3470  return false;
3471  CandidateSet.NoteCandidates(*this, OCD_AllCandidates, From);
3472  return true;
3473 }
3474 
3475 /// \brief Compare the user-defined conversion functions or constructors
3476 /// of two user-defined conversion sequences to determine whether any ordering
3477 /// is possible.
3480  FunctionDecl *Function2) {
3481  if (!S.getLangOpts().ObjC1 || !S.getLangOpts().CPlusPlus11)
3483 
3484  // Objective-C++:
3485  // If both conversion functions are implicitly-declared conversions from
3486  // a lambda closure type to a function pointer and a block pointer,
3487  // respectively, always prefer the conversion to a function pointer,
3488  // because the function pointer is more lightweight and is more likely
3489  // to keep code working.
3490  CXXConversionDecl *Conv1 = dyn_cast_or_null<CXXConversionDecl>(Function1);
3491  if (!Conv1)
3493 
3494  CXXConversionDecl *Conv2 = dyn_cast<CXXConversionDecl>(Function2);
3495  if (!Conv2)
3497 
3498  if (Conv1->getParent()->isLambda() && Conv2->getParent()->isLambda()) {
3499  bool Block1 = Conv1->getConversionType()->isBlockPointerType();
3500  bool Block2 = Conv2->getConversionType()->isBlockPointerType();
3501  if (Block1 != Block2)
3502  return Block1 ? ImplicitConversionSequence::Worse
3504  }
3505 
3507 }
3508 
3510  const ImplicitConversionSequence &ICS) {
3511  return (ICS.isStandard() && ICS.Standard.DeprecatedStringLiteralToCharPtr) ||
3512  (ICS.isUserDefined() &&
3514 }
3515 
3516 /// CompareImplicitConversionSequences - Compare two implicit
3517 /// conversion sequences to determine whether one is better than the
3518 /// other or if they are indistinguishable (C++ 13.3.3.2).
3521  const ImplicitConversionSequence& ICS1,
3522  const ImplicitConversionSequence& ICS2)
3523 {
3524  // (C++ 13.3.3.2p2): When comparing the basic forms of implicit
3525  // conversion sequences (as defined in 13.3.3.1)
3526  // -- a standard conversion sequence (13.3.3.1.1) is a better
3527  // conversion sequence than a user-defined conversion sequence or
3528  // an ellipsis conversion sequence, and
3529  // -- a user-defined conversion sequence (13.3.3.1.2) is a better
3530  // conversion sequence than an ellipsis conversion sequence
3531  // (13.3.3.1.3).
3532  //
3533  // C++0x [over.best.ics]p10:
3534  // For the purpose of ranking implicit conversion sequences as
3535  // described in 13.3.3.2, the ambiguous conversion sequence is
3536  // treated as a user-defined sequence that is indistinguishable
3537  // from any other user-defined conversion sequence.
3538 
3539  // String literal to 'char *' conversion has been deprecated in C++03. It has
3540  // been removed from C++11. We still accept this conversion, if it happens at
3541  // the best viable function. Otherwise, this conversion is considered worse
3542  // than ellipsis conversion. Consider this as an extension; this is not in the
3543  // standard. For example:
3544  //
3545  // int &f(...); // #1
3546  // void f(char*); // #2
3547  // void g() { int &r = f("foo"); }
3548  //
3549  // In C++03, we pick #2 as the best viable function.
3550  // In C++11, we pick #1 as the best viable function, because ellipsis
3551  // conversion is better than string-literal to char* conversion (since there
3552  // is no such conversion in C++11). If there was no #1 at all or #1 couldn't
3553  // convert arguments, #2 would be the best viable function in C++11.
3554  // If the best viable function has this conversion, a warning will be issued
3555  // in C++03, or an ExtWarn (+SFINAE failure) will be issued in C++11.
3556 
3557  if (S.getLangOpts().CPlusPlus11 && !S.getLangOpts().WritableStrings &&
3563 
3564  if (ICS1.getKindRank() < ICS2.getKindRank())
3566  if (ICS2.getKindRank() < ICS1.getKindRank())
3568 
3569  // The following checks require both conversion sequences to be of
3570  // the same kind.
3571  if (ICS1.getKind() != ICS2.getKind())
3573 
3576 
3577  // Two implicit conversion sequences of the same form are
3578  // indistinguishable conversion sequences unless one of the
3579  // following rules apply: (C++ 13.3.3.2p3):
3580 
3581  // List-initialization sequence L1 is a better conversion sequence than
3582  // list-initialization sequence L2 if:
3583  // - L1 converts to std::initializer_list<X> for some X and L2 does not, or,
3584  // if not that,
3585  // - L1 converts to type "array of N1 T", L2 converts to type "array of N2 T",
3586  // and N1 is smaller than N2.,
3587  // even if one of the other rules in this paragraph would otherwise apply.
3588  if (!ICS1.isBad()) {
3589  if (ICS1.isStdInitializerListElement() &&
3592  if (!ICS1.isStdInitializerListElement() &&
3595  }
3596 
3597  if (ICS1.isStandard())
3598  // Standard conversion sequence S1 is a better conversion sequence than
3599  // standard conversion sequence S2 if [...]
3600  Result = CompareStandardConversionSequences(S, Loc,
3601  ICS1.Standard, ICS2.Standard);
3602  else if (ICS1.isUserDefined()) {
3603  // User-defined conversion sequence U1 is a better conversion
3604  // sequence than another user-defined conversion sequence U2 if
3605  // they contain the same user-defined conversion function or
3606  // constructor and if the second standard conversion sequence of
3607  // U1 is better than the second standard conversion sequence of
3608  // U2 (C++ 13.3.3.2p3).
3609  if (ICS1.UserDefined.ConversionFunction ==
3611  Result = CompareStandardConversionSequences(S, Loc,
3612  ICS1.UserDefined.After,
3613  ICS2.UserDefined.After);
3614  else
3615  Result = compareConversionFunctions(S,
3618  }
3619 
3620  return Result;
3621 }
3622 
3623 static bool hasSimilarType(ASTContext &Context, QualType T1, QualType T2) {
3624  while (Context.UnwrapSimilarPointerTypes(T1, T2)) {
3625  Qualifiers Quals;
3626  T1 = Context.getUnqualifiedArrayType(T1, Quals);
3627  T2 = Context.getUnqualifiedArrayType(T2, Quals);
3628  }
3629 
3630  return Context.hasSameUnqualifiedType(T1, T2);
3631 }
3632 
3633 // Per 13.3.3.2p3, compare the given standard conversion sequences to
3634 // determine if one is a proper subset of the other.
3637  const StandardConversionSequence& SCS1,
3638  const StandardConversionSequence& SCS2) {
3641 
3642  // the identity conversion sequence is considered to be a subsequence of
3643  // any non-identity conversion sequence
3644  if (SCS1.isIdentityConversion() && !SCS2.isIdentityConversion())
3646  else if (!SCS1.isIdentityConversion() && SCS2.isIdentityConversion())
3648 
3649  if (SCS1.Second != SCS2.Second) {
3650  if (SCS1.Second == ICK_Identity)
3652  else if (SCS2.Second == ICK_Identity)
3654  else
3656  } else if (!hasSimilarType(Context, SCS1.getToType(1), SCS2.getToType(1)))
3658 
3659  if (SCS1.Third == SCS2.Third) {
3660  return Context.hasSameType(SCS1.getToType(2), SCS2.getToType(2))? Result
3662  }
3663 
3664  if (SCS1.Third == ICK_Identity)
3665  return Result == ImplicitConversionSequence::Worse
3668 
3669  if (SCS2.Third == ICK_Identity)
3670  return Result == ImplicitConversionSequence::Better
3673 
3675 }
3676 
3677 /// \brief Determine whether one of the given reference bindings is better
3678 /// than the other based on what kind of bindings they are.
3679 static bool
3681  const StandardConversionSequence &SCS2) {
3682  // C++0x [over.ics.rank]p3b4:
3683  // -- S1 and S2 are reference bindings (8.5.3) and neither refers to an
3684  // implicit object parameter of a non-static member function declared
3685  // without a ref-qualifier, and *either* S1 binds an rvalue reference
3686  // to an rvalue and S2 binds an lvalue reference *or S1 binds an
3687  // lvalue reference to a function lvalue and S2 binds an rvalue
3688  // reference*.
3689  //
3690  // FIXME: Rvalue references. We're going rogue with the above edits,
3691  // because the semantics in the current C++0x working paper (N3225 at the
3692  // time of this writing) break the standard definition of std::forward
3693  // and std::reference_wrapper when dealing with references to functions.
3694  // Proposed wording changes submitted to CWG for consideration.
3697  return false;
3698 
3699  return (!SCS1.IsLvalueReference && SCS1.BindsToRvalue &&
3700  SCS2.IsLvalueReference) ||
3701  (SCS1.IsLvalueReference && SCS1.BindsToFunctionLvalue &&
3703 }
3704 
3705 /// CompareStandardConversionSequences - Compare two standard
3706 /// conversion sequences to determine whether one is better than the
3707 /// other or if they are indistinguishable (C++ 13.3.3.2p3).
3710  const StandardConversionSequence& SCS1,
3711  const StandardConversionSequence& SCS2)
3712 {
3713  // Standard conversion sequence S1 is a better conversion sequence
3714  // than standard conversion sequence S2 if (C++ 13.3.3.2p3):
3715 
3716  // -- S1 is a proper subsequence of S2 (comparing the conversion
3717  // sequences in the canonical form defined by 13.3.3.1.1,
3718  // excluding any Lvalue Transformation; the identity conversion
3719  // sequence is considered to be a subsequence of any
3720  // non-identity conversion sequence) or, if not that,
3722  = compareStandardConversionSubsets(S.Context, SCS1, SCS2))
3723  return CK;
3724 
3725  // -- the rank of S1 is better than the rank of S2 (by the rules
3726  // defined below), or, if not that,
3727  ImplicitConversionRank Rank1 = SCS1.getRank();
3728  ImplicitConversionRank Rank2 = SCS2.getRank();
3729  if (Rank1 < Rank2)
3731  else if (Rank2 < Rank1)
3733 
3734  // (C++ 13.3.3.2p4): Two conversion sequences with the same rank
3735  // are indistinguishable unless one of the following rules
3736  // applies:
3737 
3738  // A conversion that is not a conversion of a pointer, or
3739  // pointer to member, to bool is better than another conversion
3740  // that is such a conversion.
3742  return SCS2.isPointerConversionToBool()
3745 
3746  // C++ [over.ics.rank]p4b2:
3747  //
3748  // If class B is derived directly or indirectly from class A,
3749  // conversion of B* to A* is better than conversion of B* to
3750  // void*, and conversion of A* to void* is better than conversion
3751  // of B* to void*.
3752  bool SCS1ConvertsToVoid
3754  bool SCS2ConvertsToVoid
3756  if (SCS1ConvertsToVoid != SCS2ConvertsToVoid) {
3757  // Exactly one of the conversion sequences is a conversion to
3758  // a void pointer; it's the worse conversion.
3759  return SCS2ConvertsToVoid ? ImplicitConversionSequence::Better
3761  } else if (!SCS1ConvertsToVoid && !SCS2ConvertsToVoid) {
3762  // Neither conversion sequence converts to a void pointer; compare
3763  // their derived-to-base conversions.
3765  = CompareDerivedToBaseConversions(S, Loc, SCS1, SCS2))
3766  return DerivedCK;
3767  } else if (SCS1ConvertsToVoid && SCS2ConvertsToVoid &&
3768  !S.Context.hasSameType(SCS1.getFromType(), SCS2.getFromType())) {
3769  // Both conversion sequences are conversions to void
3770  // pointers. Compare the source types to determine if there's an
3771  // inheritance relationship in their sources.
3772  QualType FromType1 = SCS1.getFromType();
3773  QualType FromType2 = SCS2.getFromType();
3774 
3775  // Adjust the types we're converting from via the array-to-pointer
3776  // conversion, if we need to.
3777  if (SCS1.First == ICK_Array_To_Pointer)
3778  FromType1 = S.Context.getArrayDecayedType(FromType1);
3779  if (SCS2.First == ICK_Array_To_Pointer)
3780  FromType2 = S.Context.getArrayDecayedType(FromType2);
3781 
3782  QualType FromPointee1 = FromType1->getPointeeType().getUnqualifiedType();
3783  QualType FromPointee2 = FromType2->getPointeeType().getUnqualifiedType();
3784 
3785  if (S.IsDerivedFrom(Loc, FromPointee2, FromPointee1))
3787  else if (S.IsDerivedFrom(Loc, FromPointee1, FromPointee2))
3789 
3790  // Objective-C++: If one interface is more specific than the
3791  // other, it is the better one.
3792  const ObjCObjectPointerType* FromObjCPtr1
3793  = FromType1->getAs<ObjCObjectPointerType>();
3794  const ObjCObjectPointerType* FromObjCPtr2
3795  = FromType2->getAs<ObjCObjectPointerType>();
3796  if (FromObjCPtr1 && FromObjCPtr2) {
3797  bool AssignLeft = S.Context.canAssignObjCInterfaces(FromObjCPtr1,
3798  FromObjCPtr2);
3799  bool AssignRight = S.Context.canAssignObjCInterfaces(FromObjCPtr2,
3800  FromObjCPtr1);
3801  if (AssignLeft != AssignRight) {
3802  return AssignLeft? ImplicitConversionSequence::Better
3804  }
3805  }
3806  }
3807 
3808  // Compare based on qualification conversions (C++ 13.3.3.2p3,
3809  // bullet 3).
3811  = CompareQualificationConversions(S, SCS1, SCS2))
3812  return QualCK;
3813 
3814  if (SCS1.ReferenceBinding && SCS2.ReferenceBinding) {
3815  // Check for a better reference binding based on the kind of bindings.
3816  if (isBetterReferenceBindingKind(SCS1, SCS2))
3818  else if (isBetterReferenceBindingKind(SCS2, SCS1))
3820 
3821  // C++ [over.ics.rank]p3b4:
3822  // -- S1 and S2 are reference bindings (8.5.3), and the types to
3823  // which the references refer are the same type except for
3824  // top-level cv-qualifiers, and the type to which the reference
3825  // initialized by S2 refers is more cv-qualified than the type
3826  // to which the reference initialized by S1 refers.
3827  QualType T1 = SCS1.getToType(2);
3828  QualType T2 = SCS2.getToType(2);
3829  T1 = S.Context.getCanonicalType(T1);
3830  T2 = S.Context.getCanonicalType(T2);
3831  Qualifiers T1Quals, T2Quals;
3832  QualType UnqualT1 = S.Context.getUnqualifiedArrayType(T1, T1Quals);
3833  QualType UnqualT2 = S.Context.getUnqualifiedArrayType(T2, T2Quals);
3834  if (UnqualT1 == UnqualT2) {
3835  // Objective-C++ ARC: If the references refer to objects with different
3836  // lifetimes, prefer bindings that don't change lifetime.
3837  if (SCS1.ObjCLifetimeConversionBinding !=
3839  return SCS1.ObjCLifetimeConversionBinding
3842  }
3843 
3844  // If the type is an array type, promote the element qualifiers to the
3845  // type for comparison.
3846  if (isa<ArrayType>(T1) && T1Quals)
3847  T1 = S.Context.getQualifiedType(UnqualT1, T1Quals);
3848  if (isa<ArrayType>(T2) && T2Quals)
3849  T2 = S.Context.getQualifiedType(UnqualT2, T2Quals);
3850  if (T2.isMoreQualifiedThan(T1))
3852  else if (T1.isMoreQualifiedThan(T2))
3854  }
3855  }
3856 
3857  // In Microsoft mode, prefer an integral conversion to a
3858  // floating-to-integral conversion if the integral conversion
3859  // is between types of the same size.
3860  // For example:
3861  // void f(float);
3862  // void f(int);
3863  // int main {
3864  // long a;
3865  // f(a);
3866  // }
3867  // Here, MSVC will call f(int) instead of generating a compile error
3868  // as clang will do in standard mode.
3869  if (S.getLangOpts().MSVCCompat && SCS1.Second == ICK_Integral_Conversion &&
3870  SCS2.Second == ICK_Floating_Integral &&
3871  S.Context.getTypeSize(SCS1.getFromType()) ==
3872  S.Context.getTypeSize(SCS1.getToType(2)))
3874 
3876 }
3877 
3878 /// CompareQualificationConversions - Compares two standard conversion
3879 /// sequences to determine whether they can be ranked based on their
3880 /// qualification conversions (C++ 13.3.3.2p3 bullet 3).
3883  const StandardConversionSequence& SCS1,
3884  const StandardConversionSequence& SCS2) {
3885  // C++ 13.3.3.2p3:
3886  // -- S1 and S2 differ only in their qualification conversion and
3887  // yield similar types T1 and T2 (C++ 4.4), respectively, and the
3888  // cv-qualification signature of type T1 is a proper subset of
3889  // the cv-qualification signature of type T2, and S1 is not the
3890  // deprecated string literal array-to-pointer conversion (4.2).
3891  if (SCS1.First != SCS2.First || SCS1.Second != SCS2.Second ||
3892  SCS1.Third != SCS2.Third || SCS1.Third != ICK_Qualification)
3894 
3895  // FIXME: the example in the standard doesn't use a qualification
3896  // conversion (!)
3897  QualType T1 = SCS1.getToType(2);
3898  QualType T2 = SCS2.getToType(2);
3899  T1 = S.Context.getCanonicalType(T1);
3900  T2 = S.Context.getCanonicalType(T2);
3901  Qualifiers T1Quals, T2Quals;
3902  QualType UnqualT1 = S.Context.getUnqualifiedArrayType(T1, T1Quals);
3903  QualType UnqualT2 = S.Context.getUnqualifiedArrayType(T2, T2Quals);
3904 
3905  // If the types are the same, we won't learn anything by unwrapped
3906  // them.
3907  if (UnqualT1 == UnqualT2)
3909 
3910  // If the type is an array type, promote the element qualifiers to the type
3911  // for comparison.
3912  if (isa<ArrayType>(T1) && T1Quals)
3913  T1 = S.Context.getQualifiedType(UnqualT1, T1Quals);
3914  if (isa<ArrayType>(T2) && T2Quals)
3915  T2 = S.Context.getQualifiedType(UnqualT2, T2Quals);
3916 
3919 
3920  // Objective-C++ ARC:
3921  // Prefer qualification conversions not involving a change in lifetime
3922  // to qualification conversions that do not change lifetime.
3925  Result = SCS1.QualificationIncludesObjCLifetime
3928  }
3929 
3930  while (S.Context.UnwrapSimilarPointerTypes(T1, T2)) {
3931  // Within each iteration of the loop, we check the qualifiers to
3932  // determine if this still looks like a qualification
3933  // conversion. Then, if all is well, we unwrap one more level of
3934  // pointers or pointers-to-members and do it all again
3935  // until there are no more pointers or pointers-to-members left
3936  // to unwrap. This essentially mimics what
3937  // IsQualificationConversion does, but here we're checking for a
3938  // strict subset of qualifiers.
3939  if (T1.getCVRQualifiers() == T2.getCVRQualifiers())
3940  // The qualifiers are the same, so this doesn't tell us anything
3941  // about how the sequences rank.
3942  ;
3943  else if (T2.isMoreQualifiedThan(T1)) {
3944  // T1 has fewer qualifiers, so it could be the better sequence.
3945  if (Result == ImplicitConversionSequence::Worse)
3946  // Neither has qualifiers that are a subset of the other's
3947  // qualifiers.
3949 
3951  } else if (T1.isMoreQualifiedThan(T2)) {
3952  // T2 has fewer qualifiers, so it could be the better sequence.
3953  if (Result == ImplicitConversionSequence::Better)
3954  // Neither has qualifiers that are a subset of the other's
3955  // qualifiers.
3957 
3959  } else {
3960  // Qualifiers are disjoint.
3962  }
3963 
3964  // If the types after this point are equivalent, we're done.
3965  if (S.Context.hasSameUnqualifiedType(T1, T2))
3966  break;
3967  }
3968 
3969  // Check that the winning standard conversion sequence isn't using
3970  // the deprecated string literal array to pointer conversion.
3971  switch (Result) {
3975  break;
3976 
3978  break;
3979 
3983  break;
3984  }
3985 
3986  return Result;
3987 }
3988 
3989 /// CompareDerivedToBaseConversions - Compares two standard conversion
3990 /// sequences to determine whether they can be ranked based on their
3991 /// various kinds of derived-to-base conversions (C++
3992 /// [over.ics.rank]p4b3). As part of these checks, we also look at
3993 /// conversions between Objective-C interface types.
3996  const StandardConversionSequence& SCS1,
3997  const StandardConversionSequence& SCS2) {
3998  QualType FromType1 = SCS1.getFromType();
3999  QualType ToType1 = SCS1.getToType(1);
4000  QualType FromType2 = SCS2.getFromType();
4001  QualType ToType2 = SCS2.getToType(1);
4002 
4003  // Adjust the types we're converting from via the array-to-pointer
4004  // conversion, if we need to.
4005  if (SCS1.First == ICK_Array_To_Pointer)
4006  FromType1 = S.Context.getArrayDecayedType(FromType1);
4007  if (SCS2.First == ICK_Array_To_Pointer)
4008  FromType2 = S.Context.getArrayDecayedType(FromType2);
4009 
4010  // Canonicalize all of the types.
4011  FromType1 = S.Context.getCanonicalType(FromType1);
4012  ToType1 = S.Context.getCanonicalType(ToType1);
4013  FromType2 = S.Context.getCanonicalType(FromType2);
4014  ToType2 = S.Context.getCanonicalType(ToType2);
4015 
4016  // C++ [over.ics.rank]p4b3:
4017  //
4018  // If class B is derived directly or indirectly from class A and
4019  // class C is derived directly or indirectly from B,
4020  //
4021  // Compare based on pointer conversions.
4022  if (SCS1.Second == ICK_Pointer_Conversion &&
4023  SCS2.Second == ICK_Pointer_Conversion &&
4024  /*FIXME: Remove if Objective-C id conversions get their own rank*/
4025  FromType1->isPointerType() && FromType2->isPointerType() &&
4026  ToType1->isPointerType() && ToType2->isPointerType()) {
4027  QualType FromPointee1
4028  = FromType1->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
4029  QualType ToPointee1
4030  = ToType1->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
4031  QualType FromPointee2
4032  = FromType2->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
4033  QualType ToPointee2
4034  = ToType2->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
4035 
4036  // -- conversion of C* to B* is better than conversion of C* to A*,
4037  if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
4038  if (S.IsDerivedFrom(Loc, ToPointee1, ToPointee2))
4040  else if (S.IsDerivedFrom(Loc, ToPointee2, ToPointee1))
4042  }
4043 
4044  // -- conversion of B* to A* is better than conversion of C* to A*,
4045  if (FromPointee1 != FromPointee2 && ToPointee1 == ToPointee2) {
4046  if (S.IsDerivedFrom(Loc, FromPointee2, FromPointee1))
4048  else if (S.IsDerivedFrom(Loc, FromPointee1, FromPointee2))
4050  }
4051  } else if (SCS1.Second == ICK_Pointer_Conversion &&
4052  SCS2.Second == ICK_Pointer_Conversion) {
4053  const ObjCObjectPointerType *FromPtr1
4054  = FromType1->getAs<ObjCObjectPointerType>();
4055  const ObjCObjectPointerType *FromPtr2
4056  = FromType2->getAs<ObjCObjectPointerType>();
4057  const ObjCObjectPointerType *ToPtr1
4058  = ToType1->getAs<ObjCObjectPointerType>();
4059  const ObjCObjectPointerType *ToPtr2
4060  = ToType2->getAs<ObjCObjectPointerType>();
4061 
4062  if (FromPtr1 && FromPtr2 && ToPtr1 && ToPtr2) {
4063  // Apply the same conversion ranking rules for Objective-C pointer types
4064  // that we do for C++ pointers to class types. However, we employ the
4065  // Objective-C pseudo-subtyping relationship used for assignment of
4066  // Objective-C pointer types.
4067  bool FromAssignLeft
4068  = S.Context.canAssignObjCInterfaces(FromPtr1, FromPtr2);
4069  bool FromAssignRight
4070  = S.Context.canAssignObjCInterfaces(FromPtr2, FromPtr1);
4071  bool ToAssignLeft
4072  = S.Context.canAssignObjCInterfaces(ToPtr1, ToPtr2);
4073  bool ToAssignRight
4074  = S.Context.canAssignObjCInterfaces(ToPtr2, ToPtr1);
4075 
4076  // A conversion to an a non-id object pointer type or qualified 'id'
4077  // type is better than a conversion to 'id'.
4078  if (ToPtr1->isObjCIdType() &&
4079  (ToPtr2->isObjCQualifiedIdType() || ToPtr2->getInterfaceDecl()))
4081  if (ToPtr2->isObjCIdType() &&
4082  (ToPtr1->isObjCQualifiedIdType() || ToPtr1->getInterfaceDecl()))
4084 
4085  // A conversion to a non-id object pointer type is better than a
4086  // conversion to a qualified 'id' type
4087  if (ToPtr1->isObjCQualifiedIdType() && ToPtr2->getInterfaceDecl())
4089  if (ToPtr2->isObjCQualifiedIdType() && ToPtr1->getInterfaceDecl())
4091 
4092  // A conversion to an a non-Class object pointer type or qualified 'Class'
4093  // type is better than a conversion to 'Class'.
4094  if (ToPtr1->isObjCClassType() &&
4095  (ToPtr2->isObjCQualifiedClassType() || ToPtr2->getInterfaceDecl()))
4097  if (ToPtr2->isObjCClassType() &&
4098  (ToPtr1->isObjCQualifiedClassType() || ToPtr1->getInterfaceDecl()))
4100 
4101  // A conversion to a non-Class object pointer type is better than a
4102  // conversion to a qualified 'Class' type.
4103  if (ToPtr1->isObjCQualifiedClassType() && ToPtr2->getInterfaceDecl())
4105  if (ToPtr2->isObjCQualifiedClassType() && ToPtr1->getInterfaceDecl())
4107 
4108  // -- "conversion of C* to B* is better than conversion of C* to A*,"
4109  if (S.Context.hasSameType(FromType1, FromType2) &&
4110  !FromPtr1->isObjCIdType() && !FromPtr1->isObjCClassType() &&
4111  (ToAssignLeft != ToAssignRight)) {
4112  if (FromPtr1->isSpecialized()) {
4113  // "conversion of B<A> * to B * is better than conversion of B * to
4114  // C *.
4115  bool IsFirstSame =
4116  FromPtr1->getInterfaceDecl() == ToPtr1->getInterfaceDecl();
4117  bool IsSecondSame =
4118  FromPtr1->getInterfaceDecl() == ToPtr2->getInterfaceDecl();
4119  if (IsFirstSame) {
4120  if (!IsSecondSame)
4122  } else if (IsSecondSame)
4124  }
4125  return ToAssignLeft? ImplicitConversionSequence::Worse
4127  }
4128 
4129  // -- "conversion of B* to A* is better than conversion of C* to A*,"
4130  if (S.Context.hasSameUnqualifiedType(ToType1, ToType2) &&
4131  (FromAssignLeft != FromAssignRight))
4132  return FromAssignLeft? ImplicitConversionSequence::Better
4134  }
4135  }
4136 
4137  // Ranking of member-pointer types.
4138  if (SCS1.Second == ICK_Pointer_Member && SCS2.Second == ICK_Pointer_Member &&
4139  FromType1->isMemberPointerType() && FromType2->isMemberPointerType() &&
4140  ToType1->isMemberPointerType() && ToType2->isMemberPointerType()) {
4141  const MemberPointerType * FromMemPointer1 =
4142  FromType1->getAs<MemberPointerType>();
4143  const MemberPointerType * ToMemPointer1 =
4144  ToType1->getAs<MemberPointerType>();
4145  const MemberPointerType * FromMemPointer2 =
4146  FromType2->getAs<MemberPointerType>();
4147  const MemberPointerType * ToMemPointer2 =
4148  ToType2->getAs<MemberPointerType>();
4149  const Type *FromPointeeType1 = FromMemPointer1->getClass();
4150  const Type *ToPointeeType1 = ToMemPointer1->getClass();
4151  const Type *FromPointeeType2 = FromMemPointer2->getClass();
4152  const Type *ToPointeeType2 = ToMemPointer2->getClass();
4153  QualType FromPointee1 = QualType(FromPointeeType1, 0).getUnqualifiedType();
4154  QualType ToPointee1 = QualType(ToPointeeType1, 0).getUnqualifiedType();
4155  QualType FromPointee2 = QualType(FromPointeeType2, 0).getUnqualifiedType();
4156  QualType ToPointee2 = QualType(ToPointeeType2, 0).getUnqualifiedType();
4157  // conversion of A::* to B::* is better than conversion of A::* to C::*,
4158  if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
4159  if (S.IsDerivedFrom(Loc, ToPointee1, ToPointee2))
4161  else if (S.IsDerivedFrom(Loc, ToPointee2, ToPointee1))
4163  }
4164  // conversion of B::* to C::* is better than conversion of A::* to C::*
4165  if (ToPointee1 == ToPointee2 && FromPointee1 != FromPointee2) {
4166  if (S.IsDerivedFrom(Loc, FromPointee1, FromPointee2))
4168  else if (S.IsDerivedFrom(Loc, FromPointee2, FromPointee1))
4170  }
4171  }
4172 
4173  if (SCS1.Second == ICK_Derived_To_Base) {
4174  // -- conversion of C to B is better than conversion of C to A,
4175  // -- binding of an expression of type C to a reference of type
4176  // B& is better than binding an expression of type C to a
4177  // reference of type A&,
4178  if (S.Context.hasSameUnqualifiedType(FromType1, FromType2) &&
4179  !S.Context.hasSameUnqualifiedType(ToType1, ToType2)) {
4180  if (S.IsDerivedFrom(Loc, ToType1, ToType2))
4182  else if (S.IsDerivedFrom(Loc, ToType2, ToType1))
4184  }
4185 
4186  // -- conversion of B to A is better than conversion of C to A.
4187  // -- binding of an expression of type B to a reference of type
4188  // A& is better than binding an expression of type C to a
4189  // reference of type A&,
4190  if (!S.Context.hasSameUnqualifiedType(FromType1, FromType2) &&
4191  S.Context.hasSameUnqualifiedType(ToType1, ToType2)) {
4192  if (S.IsDerivedFrom(Loc, FromType2, FromType1))
4194  else if (S.IsDerivedFrom(Loc, FromType1, FromType2))
4196  }
4197  }
4198 
4200 }
4201 
4202 /// \brief Determine whether the given type is valid, e.g., it is not an invalid
4203 /// C++ class.
4204 static bool isTypeValid(QualType T) {
4205  if (CXXRecordDecl *Record = T->getAsCXXRecordDecl())
4206  return !Record->isInvalidDecl();
4207 
4208  return true;
4209 }
4210 
4211 /// CompareReferenceRelationship - Compare the two types T1 and T2 to
4212 /// determine whether they are reference-related,
4213 /// reference-compatible, reference-compatible with added
4214 /// qualification, or incompatible, for use in C++ initialization by
4215 /// reference (C++ [dcl.ref.init]p4). Neither type can be a reference
4216 /// type, and the first type (T1) is the pointee type of the reference
4217 /// type being initialized.
4220  QualType OrigT1, QualType OrigT2,
4221  bool &DerivedToBase,
4222  bool &ObjCConversion,
4223  bool &ObjCLifetimeConversion) {
4224  assert(!OrigT1->isReferenceType() &&
4225  "T1 must be the pointee type of the reference type");
4226  assert(!OrigT2->isReferenceType() && "T2 cannot be a reference type");
4227 
4228  QualType T1 = Context.getCanonicalType(OrigT1);
4229  QualType T2 = Context.getCanonicalType(OrigT2);
4230  Qualifiers T1Quals, T2Quals;
4231  QualType UnqualT1 = Context.getUnqualifiedArrayType(T1, T1Quals);
4232  QualType UnqualT2 = Context.getUnqualifiedArrayType(T2, T2Quals);
4233 
4234  // C++ [dcl.init.ref]p4:
4235  // Given types "cv1 T1" and "cv2 T2," "cv1 T1" is
4236  // reference-related to "cv2 T2" if T1 is the same type as T2, or
4237  // T1 is a base class of T2.
4238  DerivedToBase = false;
4239  ObjCConversion = false;
4240  ObjCLifetimeConversion = false;
4241  QualType ConvertedT2;
4242  if (UnqualT1 == UnqualT2) {
4243  // Nothing to do.
4244  } else if (isCompleteType(Loc, OrigT2) &&
4245  isTypeValid(UnqualT1) && isTypeValid(UnqualT2) &&
4246  IsDerivedFrom(Loc, UnqualT2, UnqualT1))
4247  DerivedToBase = true;
4248  else if (UnqualT1->isObjCObjectOrInterfaceType() &&
4249  UnqualT2->isObjCObjectOrInterfaceType() &&
4250  Context.canBindObjCObjectType(UnqualT1, UnqualT2))
4251  ObjCConversion = true;
4252  else if (UnqualT2->isFunctionType() &&
4253  IsFunctionConversion(UnqualT2, UnqualT1, ConvertedT2))
4254  // C++1z [dcl.init.ref]p4:
4255  // cv1 T1" is reference-compatible with "cv2 T2" if [...] T2 is "noexcept
4256  // function" and T1 is "function"
4257  //
4258  // We extend this to also apply to 'noreturn', so allow any function
4259  // conversion between function types.
4260  return Ref_Compatible;
4261  else
4262  return Ref_Incompatible;
4263 
4264  // At this point, we know that T1 and T2 are reference-related (at
4265  // least).
4266 
4267  // If the type is an array type, promote the element qualifiers to the type
4268  // for comparison.
4269  if (isa<ArrayType>(T1) && T1Quals)
4270  T1 = Context.getQualifiedType(UnqualT1, T1Quals);
4271  if (isa<ArrayType>(T2) && T2Quals)
4272  T2 = Context.getQualifiedType(UnqualT2, T2Quals);
4273 
4274  // C++ [dcl.init.ref]p4:
4275  // "cv1 T1" is reference-compatible with "cv2 T2" if T1 is
4276  // reference-related to T2 and cv1 is the same cv-qualification
4277  // as, or greater cv-qualification than, cv2. For purposes of
4278  // overload resolution, cases for which cv1 is greater
4279  // cv-qualification than cv2 are identified as
4280  // reference-compatible with added qualification (see 13.3.3.2).
4281  //
4282  // Note that we also require equivalence of Objective-C GC and address-space
4283  // qualifiers when performing these computations, so that e.g., an int in
4284  // address space 1 is not reference-compatible with an int in address
4285  // space 2.
4286  if (T1Quals.getObjCLifetime() != T2Quals.getObjCLifetime() &&
4287  T1Quals.compatiblyIncludesObjCLifetime(T2Quals)) {
4288  if (isNonTrivialObjCLifetimeConversion(T2Quals, T1Quals))
4289  ObjCLifetimeConversion = true;
4290 
4291  T1Quals.removeObjCLifetime();
4292  T2Quals.removeObjCLifetime();
4293  }
4294 
4295  // MS compiler ignores __unaligned qualifier for references; do the same.
4296  T1Quals.removeUnaligned();
4297  T2Quals.removeUnaligned();
4298 
4299  if (T1Quals.compatiblyIncludes(T2Quals))
4300  return Ref_Compatible;
4301  else
4302  return Ref_Related;
4303 }
4304 
4305 /// \brief Look for a user-defined conversion to a value reference-compatible
4306 /// with DeclType. Return true if something definite is found.
4307 static bool
4309  QualType DeclType, SourceLocation DeclLoc,
4310  Expr *Init, QualType T2, bool AllowRvalues,
4311  bool AllowExplicit) {
4312  assert(T2->isRecordType() && "Can only find conversions of record types.");
4313  CXXRecordDecl *T2RecordDecl
4314  = dyn_cast<CXXRecordDecl>(T2->getAs<RecordType>()->getDecl());
4315 
4316  OverloadCandidateSet CandidateSet(
4318  const auto &Conversions = T2RecordDecl->getVisibleConversionFunctions();
4319  for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
4320  NamedDecl *D = *I;
4321  CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
4322  if (isa<UsingShadowDecl>(D))
4323  D = cast<UsingShadowDecl>(D)->getTargetDecl();
4324 
4325  FunctionTemplateDecl *ConvTemplate
4326  = dyn_cast<FunctionTemplateDecl>(D);
4327  CXXConversionDecl *Conv;
4328  if (ConvTemplate)
4329  Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
4330  else
4331  Conv = cast<CXXConversionDecl>(D);
4332 
4333  // If this is an explicit conversion, and we're not allowed to consider
4334  // explicit conversions, skip it.
4335  if (!AllowExplicit && Conv->isExplicit())
4336  continue;
4337 
4338  if (AllowRvalues) {
4339  bool DerivedToBase = false;
4340  bool ObjCConversion = false;
4341  bool ObjCLifetimeConversion = false;
4342 
4343  // If we are initializing an rvalue reference, don't permit conversion
4344  // functions that return lvalues.
4345  if (!ConvTemplate && DeclType->isRValueReferenceType()) {
4346  const ReferenceType *RefType
4347  = Conv->getConversionType()->getAs<LValueReferenceType>();
4348  if (RefType && !RefType->getPointeeType()->isFunctionType())
4349  continue;
4350  }
4351 
4352  if (!ConvTemplate &&
4354  DeclLoc,
4355  Conv->getConversionType().getNonReferenceType()
4356  .getUnqualifiedType(),
4358  DerivedToBase, ObjCConversion, ObjCLifetimeConversion) ==
4360  continue;
4361  } else {
4362  // If the conversion function doesn't return a reference type,
4363  // it can't be considered for this conversion. An rvalue reference
4364  // is only acceptable if its referencee is a function type.
4365 
4366  const ReferenceType *RefType =
4367  Conv->getConversionType()->getAs<ReferenceType>();
4368  if (!RefType ||
4369  (!RefType->isLValueReferenceType() &&
4370  !RefType->getPointeeType()->isFunctionType()))
4371  continue;
4372  }
4373 
4374  if (ConvTemplate)
4375  S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(), ActingDC,
4376  Init, DeclType, CandidateSet,
4377  /*AllowObjCConversionOnExplicit=*/false);
4378  else
4379  S.AddConversionCandidate(Conv, I.getPair(), ActingDC, Init,
4380  DeclType, CandidateSet,
4381  /*AllowObjCConversionOnExplicit=*/false);
4382  }
4383 
4384  bool HadMultipleCandidates = (CandidateSet.size() > 1);
4385 
4387  switch (CandidateSet.BestViableFunction(S, DeclLoc, Best)) {
4388  case OR_Success:
4389  // C++ [over.ics.ref]p1:
4390  //
4391  // [...] If the parameter binds directly to the result of
4392  // applying a conversion function to the argument
4393  // expression, the implicit conversion sequence is a
4394  // user-defined conversion sequence (13.3.3.1.2), with the
4395  // second standard conversion sequence either an identity
4396  // conversion or, if the conversion function returns an
4397  // entity of a type that is a derived class of the parameter
4398  // type, a derived-to-base Conversion.
4399  if (!Best->FinalConversion.DirectBinding)
4400  return false;
4401 
4402  ICS.setUserDefined();
4403  ICS.UserDefined.Before = Best->Conversions[0].Standard;
4404  ICS.UserDefined.After = Best->FinalConversion;
4405  ICS.UserDefined.HadMultipleCandidates = HadMultipleCandidates;
4406  ICS.UserDefined.ConversionFunction = Best->Function;
4407  ICS.UserDefined.FoundConversionFunction = Best->FoundDecl;
4408  ICS.UserDefined.EllipsisConversion = false;
4409  assert(ICS.UserDefined.After.ReferenceBinding &&
4411  "Expected a direct reference binding!");
4412  return true;
4413 
4414  case OR_Ambiguous:
4415  ICS.setAmbiguous();
4416  for (OverloadCandidateSet::iterator Cand = CandidateSet.begin();
4417  Cand != CandidateSet.end(); ++Cand)
4418  if (Cand->Viable)
4419  ICS.Ambiguous.addConversion(Cand->FoundDecl, Cand->Function);
4420  return true;
4421 
4422  case OR_No_Viable_Function:
4423  case OR_Deleted:
4424  // There was no suitable conversion, or we found a deleted
4425  // conversion; continue with other checks.
4426  return false;
4427  }
4428 
4429  llvm_unreachable("Invalid OverloadResult!");
4430 }
4431 
4432 /// \brief Compute an implicit conversion sequence for reference
4433 /// initialization.
4435 TryReferenceInit(Sema &S, Expr *Init, QualType DeclType,
4436  SourceLocation DeclLoc,
4437  bool SuppressUserConversions,
4438  bool AllowExplicit) {
4439  assert(DeclType->isReferenceType() && "Reference init needs a reference");
4440 
4441  // Most paths end in a failed conversion.
4443  ICS.setBad(BadConversionSequence::no_conversion, Init, DeclType);
4444 
4445  QualType T1 = DeclType->getAs<ReferenceType>()->getPointeeType();
4446  QualType T2 = Init->getType();
4447 
4448  // If the initializer is the address of an overloaded function, try
4449  // to resolve the overloaded function. If all goes well, T2 is the
4450  // type of the resulting function.
4451  if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) {
4452  DeclAccessPair Found;
4453  if (FunctionDecl *Fn = S.ResolveAddressOfOverloadedFunction(Init, DeclType,
4454  false, Found))
4455  T2 = Fn->getType();
4456  }
4457 
4458  // Compute some basic properties of the types and the initializer.
4459  bool isRValRef = DeclType->isRValueReferenceType();
4460  bool DerivedToBase = false;
4461  bool ObjCConversion = false;
4462  bool ObjCLifetimeConversion = false;
4463  Expr::Classification InitCategory = Init->Classify(S.Context);
4464  Sema::ReferenceCompareResult RefRelationship
4465  = S.CompareReferenceRelationship(DeclLoc, T1, T2, DerivedToBase,
4466  ObjCConversion, ObjCLifetimeConversion);
4467 
4468 
4469  // C++0x [dcl.init.ref]p5:
4470  // A reference to type "cv1 T1" is initialized by an expression
4471  // of type "cv2 T2" as follows:
4472 
4473  // -- If reference is an lvalue reference and the initializer expression
4474  if (!isRValRef) {
4475  // -- is an lvalue (but is not a bit-field), and "cv1 T1" is
4476  // reference-compatible with "cv2 T2," or
4477  //
4478  // Per C++ [over.ics.ref]p4, we don't check the bit-field property here.
4479  if (InitCategory.isLValue() && RefRelationship == Sema::Ref_Compatible) {
4480  // C++ [over.ics.ref]p1:
4481  // When a parameter of reference type binds directly (8.5.3)
4482  // to an argument expression, the implicit conversion sequence
4483  // is the identity conversion, unless the argument expression
4484  // has a type that is a derived class of the parameter type,
4485  // in which case the implicit conversion sequence is a
4486  // derived-to-base Conversion (13.3.3.1).
4487  ICS.setStandard();
4488  ICS.Standard.First = ICK_Identity;
4489  ICS.Standard.Second = DerivedToBase? ICK_Derived_To_Base
4490  : ObjCConversion? ICK_Compatible_Conversion
4491  : ICK_Identity;
4492  ICS.Standard.Third = ICK_Identity;
4493  ICS.Standard.FromTypePtr = T2.getAsOpaquePtr();
4494  ICS.Standard.setToType(0, T2);
4495  ICS.Standard.setToType(1, T1);
4496  ICS.Standard.setToType(2, T1);
4497  ICS.Standard.ReferenceBinding = true;
4498  ICS.Standard.DirectBinding = true;
4499  ICS.Standard.IsLvalueReference = !isRValRef;
4500  ICS.Standard.BindsToFunctionLvalue = T2->isFunctionType();
4501  ICS.Standard.BindsToRvalue = false;
4502  ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false;
4503  ICS.Standard.ObjCLifetimeConversionBinding = ObjCLifetimeConversion;
4504  ICS.Standard.CopyConstructor = nullptr;
4505  ICS.Standard.DeprecatedStringLiteralToCharPtr = false;
4506 
4507  // Nothing more to do: the inaccessibility/ambiguity check for
4508  // derived-to-base conversions is suppressed when we're
4509  // computing the implicit conversion sequence (C++
4510  // [over.best.ics]p2).
4511  return ICS;
4512  }
4513 
4514  // -- has a class type (i.e., T2 is a class type), where T1 is
4515  // not reference-related to T2, and can be implicitly
4516  // converted to an lvalue of type "cv3 T3," where "cv1 T1"
4517  // is reference-compatible with "cv3 T3" 92) (this
4518  // conversion is selected by enumerating the applicable
4519  // conversion functions (13.3.1.6) and choosing the best
4520  // one through overload resolution (13.3)),
4521  if (!SuppressUserConversions && T2->isRecordType() &&
4522  S.isCompleteType(DeclLoc, T2) &&
4523  RefRelationship == Sema::Ref_Incompatible) {
4524  if (FindConversionForRefInit(S, ICS, DeclType, DeclLoc,
4525  Init, T2, /*AllowRvalues=*/false,
4526  AllowExplicit))
4527  return ICS;
4528  }
4529  }
4530 
4531  // -- Otherwise, the reference shall be an lvalue reference to a
4532  // non-volatile const type (i.e., cv1 shall be const), or the reference
4533  // shall be an rvalue reference.
4534  if (!isRValRef && (!T1.isConstQualified() || T1.isVolatileQualified()))
4535  return ICS;
4536 
4537  // -- If the initializer expression
4538  //
4539  // -- is an xvalue, class prvalue, array prvalue or function
4540  // lvalue and "cv1 T1" is reference-compatible with "cv2 T2", or
4541  if (RefRelationship == Sema::Ref_Compatible &&
4542  (InitCategory.isXValue() ||
4543  (InitCategory.isPRValue() && (T2->isRecordType() || T2->isArrayType())) ||
4544  (InitCategory.isLValue() && T2->isFunctionType()))) {
4545  ICS.setStandard();
4546  ICS.Standard.First = ICK_Identity;
4547  ICS.Standard.Second = DerivedToBase? ICK_Derived_To_Base
4548  : ObjCConversion? ICK_Compatible_Conversion
4549  : ICK_Identity;
4550  ICS.Standard.Third = ICK_Identity;
4551  ICS.Standard.FromTypePtr = T2.getAsOpaquePtr();
4552  ICS.Standard.setToType(0, T2);
4553  ICS.Standard.setToType(1, T1);
4554  ICS.Standard.setToType(2, T1);
4555  ICS.Standard.ReferenceBinding = true;
4556  // In C++0x, this is always a direct binding. In C++98/03, it's a direct
4557  // binding unless we're binding to a class prvalue.
4558  // Note: Although xvalues wouldn't normally show up in C++98/03 code, we
4559  // allow the use of rvalue references in C++98/03 for the benefit of
4560  // standard library implementors; therefore, we need the xvalue check here.
4561  ICS.Standard.DirectBinding =
4562  S.getLangOpts().CPlusPlus11 ||
4563  !(InitCategory.isPRValue() || T2->isRecordType());
4564  ICS.Standard.IsLvalueReference = !isRValRef;
4565  ICS.Standard.BindsToFunctionLvalue = T2->isFunctionType();
4566  ICS.Standard.BindsToRvalue = InitCategory.isRValue();
4567  ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false;
4568  ICS.Standard.ObjCLifetimeConversionBinding = ObjCLifetimeConversion;
4569  ICS.Standard.CopyConstructor = nullptr;
4570  ICS.Standard.DeprecatedStringLiteralToCharPtr = false;
4571  return ICS;
4572  }
4573 
4574  // -- has a class type (i.e., T2 is a class type), where T1 is not
4575  // reference-related to T2, and can be implicitly converted to
4576  // an xvalue, class prvalue, or function lvalue of type
4577  // "cv3 T3", where "cv1 T1" is reference-compatible with
4578  // "cv3 T3",
4579  //
4580  // then the reference is bound to the value of the initializer
4581  // expression in the first case and to the result of the conversion
4582  // in the second case (or, in either case, to an appropriate base
4583  // class subobject).
4584  if (!SuppressUserConversions && RefRelationship == Sema::Ref_Incompatible &&
4585  T2->isRecordType() && S.isCompleteType(DeclLoc, T2) &&
4586  FindConversionForRefInit(S, ICS, DeclType, DeclLoc,
4587  Init, T2, /*AllowRvalues=*/true,
4588  AllowExplicit)) {
4589  // In the second case, if the reference is an rvalue reference
4590  // and the second standard conversion sequence of the
4591  // user-defined conversion sequence includes an lvalue-to-rvalue
4592  // conversion, the program is ill-formed.
4593  if (ICS.isUserDefined() && isRValRef &&
4594  ICS.UserDefined.After.First == ICK_Lvalue_To_Rvalue)
4595  ICS.setBad(BadConversionSequence::no_conversion, Init, DeclType);
4596 
4597  return ICS;
4598  }
4599 
4600  // A temporary of function type cannot be created; don't even try.
4601  if (T1->isFunctionType())
4602  return ICS;
4603 
4604  // -- Otherwise, a temporary of type "cv1 T1" is created and
4605  // initialized from the initializer expression using the
4606  // rules for a non-reference copy initialization (8.5). The
4607  // reference is then bound to the temporary. If T1 is
4608  // reference-related to T2, cv1 must be the same
4609  // cv-qualification as, or greater cv-qualification than,
4610  // cv2; otherwise, the program is ill-formed.
4611  if (RefRelationship == Sema::Ref_Related) {
4612  // If cv1 == cv2 or cv1 is a greater cv-qualified than cv2, then
4613  // we would be reference-compatible or reference-compatible with
4614  // added qualification. But that wasn't the case, so the reference
4615  // initialization fails.
4616  //
4617  // Note that we only want to check address spaces and cvr-qualifiers here.
4618  // ObjC GC, lifetime and unaligned qualifiers aren't important.
4619  Qualifiers T1Quals = T1.getQualifiers();
4620  Qualifiers T2Quals = T2.getQualifiers();
4621  T1Quals.removeObjCGCAttr();
4622  T1Quals.removeObjCLifetime();
4623  T2Quals.removeObjCGCAttr();
4624  T2Quals.removeObjCLifetime();
4625  // MS compiler ignores __unaligned qualifier for references; do the same.
4626  T1Quals.removeUnaligned();
4627  T2Quals.removeUnaligned();
4628  if (!T1Quals.compatiblyIncludes(T2Quals))
4629  return ICS;
4630  }
4631 
4632  // If at least one of the types is a class type, the types are not
4633  // related, and we aren't allowed any user conversions, the
4634  // reference binding fails. This case is important for breaking
4635  // recursion, since TryImplicitConversion below will attempt to
4636  // create a temporary through the use of a copy constructor.
4637  if (SuppressUserConversions && RefRelationship == Sema::Ref_Incompatible &&
4638  (T1->isRecordType() || T2->isRecordType()))
4639  return ICS;
4640 
4641  // If T1 is reference-related to T2 and the reference is an rvalue
4642  // reference, the initializer expression shall not be an lvalue.
4643  if (RefRelationship >= Sema::Ref_Related &&
4644  isRValRef && Init->Classify(S.Context).isLValue())
4645  return ICS;
4646 
4647  // C++ [over.ics.ref]p2:
4648  // When a parameter of reference type is not bound directly to
4649  // an argument expression, the conversion sequence is the one
4650  // required to convert the argument expression to the
4651  // underlying type of the reference according to
4652  // 13.3.3.1. Conceptually, this conversion sequence corresponds
4653  // to copy-initializing a temporary of the underlying type with
4654  // the argument expression. Any difference in top-level
4655  // cv-qualification is subsumed by the initialization itself
4656  // and does not constitute a conversion.
4657  ICS = TryImplicitConversion(S, Init, T1, SuppressUserConversions,
4658  /*AllowExplicit=*/false,
4659  /*InOverloadResolution=*/false,
4660  /*CStyle=*/false,
4661  /*AllowObjCWritebackConversion=*/false,
4662  /*AllowObjCConversionOnExplicit=*/false);
4663 
4664  // Of course, that's still a reference binding.
4665  if (ICS.isStandard()) {
4666  ICS.Standard.ReferenceBinding = true;
4667  ICS.Standard.IsLvalueReference = !isRValRef;
4668  ICS.Standard.BindsToFunctionLvalue = false;
4669  ICS.Standard.BindsToRvalue = true;
4670  ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false;
4671  ICS.Standard.ObjCLifetimeConversionBinding = false;
4672  } else if (ICS.isUserDefined()) {
4673  const ReferenceType *LValRefType =
4674  ICS.UserDefined.ConversionFunction->getReturnType()
4676 
4677  // C++ [over.ics.ref]p3:
4678  // Except for an implicit object parameter, for which see 13.3.1, a
4679  // standard conversion sequence cannot be formed if it requires [...]
4680  // binding an rvalue reference to an lvalue other than a function
4681  // lvalue.
4682  // Note that the function case is not possible here.
4683  if (DeclType->isRValueReferenceType() && LValRefType) {
4684  // FIXME: This is the wrong BadConversionSequence. The problem is binding
4685  // an rvalue reference to a (non-function) lvalue, not binding an lvalue
4686  // reference to an rvalue!
4687  ICS.setBad(BadConversionSequence::lvalue_ref_to_rvalue, Init, DeclType);
4688  return ICS;
4689  }
4690 
4691  ICS.UserDefined.After.ReferenceBinding = true;
4692  ICS.UserDefined.After.IsLvalueReference = !isRValRef;
4693  ICS.UserDefined.After.BindsToFunctionLvalue = false;
4694  ICS.UserDefined.After.BindsToRvalue = !LValRefType;
4695  ICS.UserDefined.After.BindsImplicitObjectArgumentWithoutRefQualifier = false;
4696  ICS.UserDefined.After.ObjCLifetimeConversionBinding = false;
4697  }
4698 
4699  return ICS;
4700 }
4701 
4703 TryCopyInitialization(Sema &S, Expr *From, QualType ToType,
4704  bool SuppressUserConversions,
4705  bool InOverloadResolution,
4706  bool AllowObjCWritebackConversion,
4707  bool AllowExplicit = false);
4708 
4709 /// TryListConversion - Try to copy-initialize a value of type ToType from the
4710 /// initializer list From.
4713  bool SuppressUserConversions,
4714  bool InOverloadResolution,
4715  bool AllowObjCWritebackConversion) {
4716  // C++11 [over.ics.list]p1:
4717  // When an argument is an initializer list, it is not an expression and
4718  // special rules apply for converting it to a parameter type.
4719 
4721  Result.setBad(BadConversionSequence::no_conversion, From, ToType);
4722 
4723  // We need a complete type for what follows. Incomplete types can never be
4724  // initialized from init lists.
4725  if (!S.isCompleteType(From->getLocStart(), ToType))
4726  return Result;
4727 
4728  // Per DR1467:
4729  // If the parameter type is a class X and the initializer list has a single
4730  // element of type cv U, where U is X or a class derived from X, the
4731  // implicit conversion sequence is the one required to convert the element
4732  // to the parameter type.
4733  //
4734  // Otherwise, if the parameter type is a character array [... ]
4735  // and the initializer list has a single element that is an
4736  // appropriately-typed string literal (8.5.2 [dcl.init.string]), the
4737  // implicit conversion sequence is the identity conversion.
4738  if (From->getNumInits() == 1) {
4739  if (ToType->isRecordType()) {
4740  QualType InitType = From->getInit(0)->getType();
4741  if (S.Context.hasSameUnqualifiedType(InitType, ToType) ||
4742  S.IsDerivedFrom(From->getLocStart(), InitType, ToType))
4743  return TryCopyInitialization(S, From->getInit(0), ToType,
4744  SuppressUserConversions,
4745  InOverloadResolution,
4746  AllowObjCWritebackConversion);
4747  }
4748  // FIXME: Check the other conditions here: array of character type,
4749  // initializer is a string literal.
4750  if (ToType->isArrayType()) {
4751  InitializedEntity Entity =
4753  /*Consumed=*/false);
4754  if (S.CanPerformCopyInitialization(Entity, From)) {
4755  Result.setStandard();
4757  Result.Standard.setFromType(ToType);
4758  Result.Standard.setAllToTypes(ToType);
4759  return Result;
4760  }
4761  }
4762  }
4763 
4764  // C++14 [over.ics.list]p2: Otherwise, if the parameter type [...] (below).
4765  // C++11 [over.ics.list]p2:
4766  // If the parameter type is std::initializer_list<X> or "array of X" and
4767  // all the elements can be implicitly converted to X, the implicit
4768  // conversion sequence is the worst conversion necessary to convert an
4769  // element of the list to X.
4770  //
4771  // C++14 [over.ics.list]p3:
4772  // Otherwise, if the parameter type is "array of N X", if the initializer
4773  // list has exactly N elements or if it has fewer than N elements and X is
4774  // default-constructible, and if all the elements of the initializer list
4775  // can be implicitly converted to X, the implicit conversion sequence is
4776  // the worst conversion necessary to convert an element of the list to X.
4777  //
4778  // FIXME: We're missing a lot of these checks.
4779  bool toStdInitializerList = false;
4780  QualType X;
4781  if (ToType->isArrayType())
4782  X = S.Context.getAsArrayType(ToType)->getElementType();
4783  else
4784  toStdInitializerList = S.isStdInitializerList(ToType, &X);
4785  if (!X.isNull()) {
4786  for (unsigned i = 0, e = From->getNumInits(); i < e; ++i) {
4787  Expr *Init = From->getInit(i);
4789  TryCopyInitialization(S, Init, X, SuppressUserConversions,
4790  InOverloadResolution,
4791  AllowObjCWritebackConversion);
4792  // If a single element isn't convertible, fail.
4793  if (ICS.isBad()) {
4794  Result = ICS;
4795  break;
4796  }
4797  // Otherwise, look for the worst conversion.
4798  if (Result.isBad() ||
4800  Result) ==
4802  Result = ICS;
4803  }
4804 
4805  // For an empty list, we won't have computed any conversion sequence.
4806  // Introduce the identity conversion sequence.
4807  if (From->getNumInits() == 0) {
4808  Result.setStandard();
4810  Result.Standard.setFromType(ToType);
4811  Result.Standard.setAllToTypes(ToType);
4812  }
4813 
4814  Result.setStdInitializerListElement(toStdInitializerList);
4815  return Result;
4816  }
4817 
4818  // C++14 [over.ics.list]p4:
4819  // C++11 [over.ics.list]p3:
4820  // Otherwise, if the parameter is a non-aggregate class X and overload
4821  // resolution chooses a single best constructor [...] the implicit
4822  // conversion sequence is a user-defined conversion sequence. If multiple
4823  // constructors are viable but none is better than the others, the
4824  // implicit conversion sequence is a user-defined conversion sequence.
4825  if (ToType->isRecordType() && !ToType->isAggregateType()) {
4826  // This function can deal with initializer lists.
4827  return TryUserDefinedConversion(S, From, ToType, SuppressUserConversions,
4828  /*AllowExplicit=*/false,
4829  InOverloadResolution, /*CStyle=*/false,
4830  AllowObjCWritebackConversion,
4831  /*AllowObjCConversionOnExplicit=*/false);
4832  }
4833 
4834  // C++14 [over.ics.list]p5:
4835  // C++11 [over.ics.list]p4:
4836  // Otherwise, if the parameter has an aggregate type which can be
4837  // initialized from the initializer list [...] the implicit conversion
4838  // sequence is a user-defined conversion sequence.
4839  if (ToType->isAggregateType()) {
4840  // Type is an aggregate, argument is an init list. At this point it comes
4841  // down to checking whether the initialization works.
4842  // FIXME: Find out whether this parameter is consumed or not.
4843  // FIXME: Expose SemaInit's aggregate initialization code so that we don't
4844  // need to call into the initialization code here; overload resolution
4845  // should not be doing that.
4846  InitializedEntity Entity =
4848  /*Consumed=*/false);
4849  if (S.CanPerformCopyInitialization(Entity, From)) {
4850  Result.setUserDefined();
4852  // Initializer lists don't have a type.
4855 
4857  Result.UserDefined.After.setFromType(ToType);
4858  Result.UserDefined.After.setAllToTypes(ToType);
4859  Result.UserDefined.ConversionFunction = nullptr;
4860  }
4861  return Result;
4862  }
4863 
4864  // C++14 [over.ics.list]p6:
4865  // C++11 [over.ics.list]p5:
4866  // Otherwise, if the parameter is a reference, see 13.3.3.1.4.
4867  if (ToType->isReferenceType()) {
4868  // The standard is notoriously unclear here, since 13.3.3.1.4 doesn't
4869  // mention initializer lists in any way. So we go by what list-
4870  // initialization would do and try to extrapolate from that.
4871 
4872  QualType T1 = ToType->getAs<ReferenceType>()->getPointeeType();
4873 
4874  // If the initializer list has a single element that is reference-related
4875  // to the parameter type, we initialize the reference from that.
4876  if (From->getNumInits() == 1) {
4877  Expr *Init = From->getInit(0);
4878 
4879  QualType T2 = Init->getType();
4880 
4881  // If the initializer is the address of an overloaded function, try
4882  // to resolve the overloaded function. If all goes well, T2 is the
4883  // type of the resulting function.
4884  if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) {
4885  DeclAccessPair Found;
4887  Init, ToType, false, Found))
4888  T2 = Fn->getType();
4889  }
4890 
4891  // Compute some basic properties of the types and the initializer.
4892  bool dummy1 = false;
4893  bool dummy2 = false;
4894  bool dummy3 = false;
4895  Sema::ReferenceCompareResult RefRelationship
4896  = S.CompareReferenceRelationship(From->getLocStart(), T1, T2, dummy1,
4897  dummy2, dummy3);
4898 
4899  if (RefRelationship >= Sema::Ref_Related) {
4900  return TryReferenceInit(S, Init, ToType, /*FIXME*/From->getLocStart(),
4901  SuppressUserConversions,
4902  /*AllowExplicit=*/false);
4903  }
4904  }
4905 
4906  // Otherwise, we bind the reference to a temporary created from the
4907  // initializer list.
4908  Result = TryListConversion(S, From, T1, SuppressUserConversions,
4909  InOverloadResolution,
4910  AllowObjCWritebackConversion);
4911  if (Result.isFailure())
4912  return Result;
4913  assert(!Result.isEllipsis() &&
4914  "Sub-initialization cannot result in ellipsis conversion.");
4915 
4916  // Can we even bind to a temporary?
4917  if (ToType->isRValueReferenceType() ||
4918  (T1.isConstQualified() && !T1.isVolatileQualified())) {
4919  StandardConversionSequence &SCS = Result.isStandard() ? Result.Standard :
4920  Result.UserDefined.After;
4921  SCS.ReferenceBinding = true;
4922  SCS.IsLvalueReference = ToType->isLValueReferenceType();
4923  SCS.BindsToRvalue = true;
4924  SCS.BindsToFunctionLvalue = false;
4926  SCS.ObjCLifetimeConversionBinding = false;
4927  } else
4929  From, ToType);
4930  return Result;
4931  }
4932 
4933  // C++14 [over.ics.list]p7:
4934  // C++11 [over.ics.list]p6:
4935  // Otherwise, if the parameter type is not a class:
4936  if (!ToType->isRecordType()) {
4937  // - if the initializer list has one element that is not itself an
4938  // initializer list, the implicit conversion sequence is the one
4939  // required to convert the element to the parameter type.
4940  unsigned NumInits = From->getNumInits();
4941  if (NumInits == 1 && !isa<InitListExpr>(From->getInit(0)))
4942  Result = TryCopyInitialization(S, From->getInit(0), ToType,
4943  SuppressUserConversions,
4944  InOverloadResolution,
4945  AllowObjCWritebackConversion);
4946  // - if the initializer list has no elements, the implicit conversion
4947  // sequence is the identity conversion.
4948  else if (NumInits == 0) {
4949  Result.setStandard();
4951  Result.Standard.setFromType(ToType);
4952  Result.Standard.setAllToTypes(ToType);
4953  }
4954  return Result;
4955  }
4956 
4957  // C++14 [over.ics.list]p8:
4958  // C++11 [over.ics.list]p7:
4959  // In all cases other than those enumerated above, no conversion is possible
4960  return Result;
4961 }
4962 
4963 /// TryCopyInitialization - Try to copy-initialize a value of type
4964 /// ToType from the expression From. Return the implicit conversion
4965 /// sequence required to pass this argument, which may be a bad
4966 /// conversion sequence (meaning that the argument cannot be passed to
4967 /// a parameter of this type). If @p SuppressUserConversions, then we
4968 /// do not permit any user-defined conversion sequences.
4971  bool SuppressUserConversions,
4972  bool InOverloadResolution,
4973  bool AllowObjCWritebackConversion,
4974  bool AllowExplicit) {
4975  if (InitListExpr *FromInitList = dyn_cast<InitListExpr>(From))
4976  return TryListConversion(S, FromInitList, ToType, SuppressUserConversions,
4977  InOverloadResolution,AllowObjCWritebackConversion);
4978 
4979  if (ToType->isReferenceType())
4980  return TryReferenceInit(S, From, ToType,
4981  /*FIXME:*/From->getLocStart(),
4982  SuppressUserConversions,
4983  AllowExplicit);
4984 
4985  return TryImplicitConversion(S, From, ToType,
4986  SuppressUserConversions,
4987  /*AllowExplicit=*/false,
4988  InOverloadResolution,
4989  /*CStyle=*/false,
4990  AllowObjCWritebackConversion,
4991  /*AllowObjCConversionOnExplicit=*/false);
4992 }
4993 
4994 static bool TryCopyInitialization(const CanQualType FromQTy,
4995  const CanQualType ToQTy,
4996  Sema &S,
4997  SourceLocation Loc,
4998  ExprValueKind FromVK) {
4999  OpaqueValueExpr TmpExpr(Loc, FromQTy, FromVK);
5001  TryCopyInitialization(S, &TmpExpr, ToQTy, true, true, false);
5002 
5003  return !ICS.isBad();
5004 }
5005 
5006 /// TryObjectArgumentInitialization - Try to initialize the object
5007 /// parameter of the given member function (@c Method) from the
5008 /// expression @p From.
5011  Expr::Classification FromClassification,
5012  CXXMethodDecl *Method,
5013  CXXRecordDecl *ActingContext) {
5014  QualType ClassType = S.Context.getTypeDeclType(ActingContext);
5015  // [class.dtor]p2: A destructor can be invoked for a const, volatile or
5016  // const volatile object.
5017  unsigned Quals = isa<CXXDestructorDecl>(Method) ?
5019  QualType ImplicitParamType = S.Context.getCVRQualifiedType(ClassType, Quals);
5020 
5021  // Set up the conversion sequence as a "bad" conversion, to allow us
5022  // to exit early.
5024 
5025  // We need to have an object of class type.
5026  if (const PointerType *PT = FromType->getAs<PointerType>()) {
5027  FromType = PT->getPointeeType();
5028 
5029  // When we had a pointer, it's implicitly dereferenced, so we
5030  // better have an lvalue.
5031  assert(FromClassification.isLValue());
5032  }
5033 
5034  assert(FromType->isRecordType());
5035 
5036  // C++0x [over.match.funcs]p4:
5037  // For non-static member functions, the type of the implicit object
5038  // parameter is
5039  //
5040  // - "lvalue reference to cv X" for functions declared without a
5041  // ref-qualifier or with the & ref-qualifier
5042  // - "rvalue reference to cv X" for functions declared with the &&
5043  // ref-qualifier
5044  //
5045  // where X is the class of which the function is a member and cv is the
5046  // cv-qualification on the member function declaration.
5047  //
5048  // However, when finding an implicit conversion sequence for the argument, we
5049  // are not allowed to perform user-defined conversions
5050  // (C++ [over.match.funcs]p5). We perform a simplified version of
5051  // reference binding here, that allows class rvalues to bind to
5052  // non-constant references.
5053 
5054  // First check the qualifiers.
5055  QualType FromTypeCanon = S.Context.getCanonicalType(FromType);
5056  if (ImplicitParamType.getCVRQualifiers()
5057  != FromTypeCanon.getLocalCVRQualifiers() &&
5058  !ImplicitParamType.isAtLeastAsQualifiedAs(FromTypeCanon)) {
5060  FromType, ImplicitParamType);
5061  return ICS;
5062  }
5063 
5064  // Check that we have either the same type or a derived type. It
5065  // affects the conversion rank.
5066  QualType ClassTypeCanon = S.Context.getCanonicalType(ClassType);
5067  ImplicitConversionKind SecondKind;
5068  if (ClassTypeCanon == FromTypeCanon.getLocalUnqualifiedType()) {
5069  SecondKind = ICK_Identity;
5070  } else if (S.IsDerivedFrom(Loc, FromType, ClassType))
5071  SecondKind = ICK_Derived_To_Base;
5072  else {
5074  FromType, ImplicitParamType);
5075  return ICS;
5076  }
5077 
5078  // Check the ref-qualifier.
5079  switch (Method->getRefQualifier()) {
5080  case RQ_None:
5081  // Do nothing; we don't care about lvalueness or rvalueness.
5082  break;
5083 
5084  case RQ_LValue:
5085  if (!FromClassification.isLValue() && Quals != Qualifiers::Const) {
5086  // non-const lvalue reference cannot bind to an rvalue
5088  ImplicitParamType);
5089  return ICS;
5090  }
5091  break;
5092 
5093  case RQ_RValue:
5094  if (!FromClassification.isRValue()) {
5095  // rvalue reference cannot bind to an lvalue
5097  ImplicitParamType);
5098  return ICS;
5099  }
5100  break;
5101  }
5102 
5103  // Success. Mark this as a reference binding.
5104  ICS.setStandard();
5106  ICS.Standard.Second = SecondKind;
5107  ICS.Standard.setFromType(FromType);
5108  ICS.Standard.setAllToTypes(ImplicitParamType);
5109  ICS.Standard.ReferenceBinding = true;
5110  ICS.Standard.DirectBinding = true;
5112  ICS.Standard.BindsToFunctionLvalue = false;
5113  ICS.Standard.BindsToRvalue = FromClassification.isRValue();
5115  = (Method->getRefQualifier() == RQ_None);
5116  return ICS;
5117 }
5118 
5119 /// PerformObjectArgumentInitialization - Perform initialization of
5120 /// the implicit object parameter for the given Method with the given
5121 /// expression.
5122 ExprResult
5124  NestedNameSpecifier *Qualifier,
5125  NamedDecl *FoundDecl,
5126  CXXMethodDecl *Method) {
5127  QualType FromRecordType, DestType;
5128  QualType ImplicitParamRecordType =
5129  Method->getThisType(Context)->getAs<PointerType>()->getPointeeType();
5130 
5131  Expr::Classification FromClassification;
5132  if (const PointerType *PT = From->getType()->getAs<PointerType>()) {
5133  FromRecordType = PT->getPointeeType();
5134  DestType = Method->getThisType(Context);
5135  FromClassification = Expr::Classification::makeSimpleLValue();
5136  } else {
5137  FromRecordType = From->getType();
5138  DestType = ImplicitParamRecordType;
5139  FromClassification = From->Classify(Context);
5140  }
5141 
5142  // Note that we always use the true parent context when performing
5143  // the actual argument initialization.
5145  *this, From->getLocStart(), From->getType(), FromClassification, Method,
5146  Method->getParent());
5147  if (ICS.isBad()) {
5148  switch (ICS.Bad.Kind) {
5150  Qualifiers FromQs = FromRecordType.getQualifiers();
5151  Qualifiers ToQs = DestType.getQualifiers();
5152  unsigned CVR = FromQs.getCVRQualifiers() & ~ToQs.getCVRQualifiers();
5153  if (CVR) {
5154  Diag(From->getLocStart(),
5155  diag::err_member_function_call_bad_cvr)
5156  << Method->getDeclName() << FromRecordType << (CVR - 1)
5157  << From->getSourceRange();
5158  Diag(Method->getLocation(), diag::note_previous_decl)
5159  << Method->getDeclName();
5160  return ExprError();
5161  }
5162  break;
5163  }
5164 
5167  bool IsRValueQualified =
5168  Method->getRefQualifier() == RefQualifierKind::RQ_RValue;
5169  Diag(From->getLocStart(), diag::err_member_function_call_bad_ref)
5170  << Method->getDeclName() << FromClassification.isRValue()
5171  << IsRValueQualified;
5172  Diag(Method->getLocation(), diag::note_previous_decl)
5173  << Method->getDeclName();
5174  return ExprError();
5175  }
5176 
5179  break;
5180  }
5181 
5182  return Diag(From->getLocStart(),
5183  diag::err_member_function_call_bad_type)
5184  << ImplicitParamRecordType << FromRecordType << From->getSourceRange();
5185  }
5186 
5187  if (ICS.Standard.Second == ICK_Derived_To_Base) {
5188  ExprResult FromRes =
5189  PerformObjectMemberConversion(From, Qualifier, FoundDecl, Method);
5190  if (FromRes.isInvalid())
5191  return ExprError();
5192  From = FromRes.get();
5193  }
5194 
5195  if (!Context.hasSameType(From->getType(), DestType))
5196  From = ImpCastExprToType(From, DestType, CK_NoOp,
5197  From->getValueKind()).get();
5198  return From;
5199 }
5200 
5201 /// TryContextuallyConvertToBool - Attempt to contextually convert the
5202 /// expression From to bool (C++0x [conv]p3).
5205  return TryImplicitConversion(S, From, S.Context.BoolTy,
5206  /*SuppressUserConversions=*/false,
5207  /*AllowExplicit=*/true,
5208  /*InOverloadResolution=*/false,
5209  /*CStyle=*/false,
5210  /*AllowObjCWritebackConversion=*/false,
5211  /*AllowObjCConversionOnExplicit=*/false);
5212 }
5213 
5214 /// PerformContextuallyConvertToBool - Perform a contextual conversion
5215 /// of the expression From to bool (C++0x [conv]p3).
5217  if (checkPlaceholderForOverload(*this, From))
5218  return ExprError();
5219 
5221  if (!ICS.isBad())
5222  return PerformImplicitConversion(From, Context.BoolTy, ICS, AA_Converting);
5223 
5224  if (!DiagnoseMultipleUserDefinedConversion(From, Context.BoolTy))
5225  return Diag(From->getLocStart(),
5226  diag::err_typecheck_bool_condition)
5227  << From->getType() << From->getSourceRange();
5228  return ExprError();
5229 }
5230 
5231 /// Check that the specified conversion is permitted in a converted constant
5232 /// expression, according to C++11 [expr.const]p3. Return true if the conversion
5233 /// is acceptable.
5236  // Since we know that the target type is an integral or unscoped enumeration
5237  // type, most conversion kinds are impossible. All possible First and Third
5238  // conversions are fine.
5239  switch (SCS.Second) {
5240  case ICK_Identity:
5243  case ICK_Integral_Conversion: // Narrowing conversions are checked elsewhere.
5245  return true;
5246 
5248  // Conversion from an integral or unscoped enumeration type to bool is
5249  // classified as ICK_Boolean_Conversion, but it's also arguably an integral
5250  // conversion, so we allow it in a converted constant expression.
5251  //
5252  // FIXME: Per core issue 1407, we should not allow this, but that breaks
5253  // a lot of popular code. We should at least add a warning for this
5254  // (non-conforming) extension.
5256  SCS.getToType(2)->isBooleanType();
5257 
5259  case ICK_Pointer_Member:
5260  // C++1z: null pointer conversions and null member pointer conversions are
5261  // only permitted if the source type is std::nullptr_t.
5262  return SCS.getFromType()->isNullPtrType();
5263 
5265  case ICK_Complex_Promotion:
5268  case ICK_Floating_Integral:
5270  case ICK_Derived_To_Base:
5271  case ICK_Vector_Conversion:
5272  case ICK_Vector_Splat:
5273  case ICK_Complex_Real:
5278  case ICK_C_Only_Conversion:
5280  return false;
5281 
5282  case ICK_Lvalue_To_Rvalue:
5283  case ICK_Array_To_Pointer:
5285  llvm_unreachable("found a first conversion kind in Second");
5286 
5287  case ICK_Qualification:
5288  llvm_unreachable("found a third conversion kind in Second");
5289 
5291  break;
5292  }
5293 
5294  llvm_unreachable("unknown conversion kind");
5295 }
5296 
5297 /// CheckConvertedConstantExpression - Check that the expression From is a
5298 /// converted constant expression of type T, perform the conversion and produce
5299 /// the converted expression, per C++11 [expr.const]p3.
5301  QualType T, APValue &Value,
5302  Sema::CCEKind CCE,
5303  bool RequireInt) {
5304  assert(S.getLangOpts().CPlusPlus11 &&
5305  "converted constant expression outside C++11");
5306 
5307  if (checkPlaceholderForOverload(S, From))
5308  return ExprError();
5309 
5310  // C++1z [expr.const]p3:
5311  // A converted constant expression of type T is an expression,
5312  // implicitly converted to type T, where the converted
5313  // expression is a constant expression and the implicit conversion
5314  // sequence contains only [... list of conversions ...].
5315  // C++1z [stmt.if]p2:
5316  // If the if statement is of the form if constexpr, the value of the
5317  // condition shall be a contextually converted constant expression of type
5318  // bool.
5320  CCE == Sema::CCEK_ConstexprIf
5321  ? TryContextuallyConvertToBool(S, From)
5322  : TryCopyInitialization(S, From, T,
5323  /*SuppressUserConversions=*/false,
5324  /*InOverloadResolution=*/false,
5325  /*AllowObjcWritebackConversion=*/false,
5326  /*AllowExplicit=*/false);
5327  StandardConversionSequence *SCS = nullptr;
5328  switch (ICS.getKind()) {
5330  SCS = &ICS.Standard;
5331  break;
5333  // We are converting to a non-class type, so the Before sequence
5334  // must be trivial.
5335  SCS = &ICS.UserDefined.After;
5336  break;
5339  if (!S.DiagnoseMultipleUserDefinedConversion(From, T))
5340  return S.Diag(From->getLocStart(),
5341  diag::err_typecheck_converted_constant_expression)
5342  << From->getType() << From->getSourceRange() << T;
5343  return ExprError();
5344 
5346  llvm_unreachable("ellipsis conversion in converted constant expression");
5347  }
5348 
5349  // Check that we would only use permitted conversions.
5350  if (!CheckConvertedConstantConversions(S, *SCS)) {
5351  return S.Diag(From->getLocStart(),
5352  diag::err_typecheck_converted_constant_expression_disallowed)
5353  << From->getType() << From->getSourceRange() << T;
5354  }
5355  // [...] and where the reference binding (if any) binds directly.
5356  if (SCS->ReferenceBinding && !SCS->DirectBinding) {
5357  return S.Diag(From->getLocStart(),
5358  diag::err_typecheck_converted_constant_expression_indirect)
5359  << From->getType() << From->getSourceRange() << T;
5360  }
5361 
5362  ExprResult Result =
5364  if (Result.isInvalid())
5365  return Result;
5366 
5367  // Check for a narrowing implicit conversion.
5368  APValue PreNarrowingValue;
5369  QualType PreNarrowingType;
5370  switch (SCS->getNarrowingKind(S.Context, Result.get(), PreNarrowingValue,
5371  PreNarrowingType)) {
5373  // Implicit conversion to a narrower type, but the expression is
5374  // value-dependent so we can't tell whether it's actually narrowing.
5375  case NK_Variable_Narrowing:
5376  // Implicit conversion to a narrower type, and the value is not a constant
5377  // expression. We'll diagnose this in a moment.
5378  case NK_Not_Narrowing:
5379  break;
5380 
5381  case NK_Constant_Narrowing:
5382  S.Diag(From->getLocStart(), diag::ext_cce_narrowing)
5383  << CCE << /*Constant*/1
5384  << PreNarrowingValue.getAsString(S.Context, PreNarrowingType) << T;
5385  break;
5386 
5387  case NK_Type_Narrowing:
5388  S.Diag(From->getLocStart(), diag::ext_cce_narrowing)
5389  << CCE << /*Constant*/0 << From->getType() << T;
5390  break;
5391  }
5392 
5393  if (Result.get()->isValueDependent()) {
5394  Value = APValue();
5395  return Result;
5396  }
5397 
5398  // Check the expression is a constant expression.
5400  Expr::EvalResult Eval;
5401  Eval.Diag = &Notes;
5402 
5403  if ((T->isReferenceType()
5404  ? !Result.get()->EvaluateAsLValue(Eval, S.Context)
5405  : !Result.get()->EvaluateAsRValue(Eval, S.Context)) ||
5406  (RequireInt && !Eval.Val.isInt())) {
5407  // The expression can't be folded, so we can't keep it at this position in
5408  // the AST.
5409  Result = ExprError();
5410  } else {
5411  Value = Eval.Val;
5412 
5413  if (Notes.empty()) {
5414  // It's a constant expression.
5415  return Result;
5416  }
5417  }
5418 
5419  // It's not a constant expression. Produce an appropriate diagnostic.
5420  if (Notes.size() == 1 &&
5421  Notes[0].second.getDiagID() == diag::note_invalid_subexpr_in_const_expr)
5422  S.Diag(Notes[0].first, diag::err_expr_not_cce) << CCE;
5423  else {
5424  S.Diag(From->getLocStart(), diag::err_expr_not_cce)
5425  << CCE << From->getSourceRange();
5426  for (unsigned I = 0; I < Notes.size(); ++I)
5427  S.Diag(Notes[I].first, Notes[I].second);
5428  }
5429  return ExprError();
5430 }
5431 
5433  APValue &Value, CCEKind CCE) {
5434  return ::CheckConvertedConstantExpression(*this, From, T, Value, CCE, false);
5435 }
5436 
5438  llvm::APSInt &Value,
5439  CCEKind CCE) {
5440  assert(T->isIntegralOrEnumerationType() && "unexpected converted const type");
5441 
5442  APValue V;
5443  auto R = ::CheckConvertedConstantExpression(*this, From, T, V, CCE, true);
5444  if (!R.isInvalid() && !R.get()->isValueDependent())
5445  Value = V.getInt();
5446  return R;
5447 }
5448 
5449 
5450 /// dropPointerConversions - If the given standard conversion sequence
5451 /// involves any pointer conversions, remove them. This may change
5452 /// the result type of the conversion sequence.
5454  if (SCS.Second == ICK_Pointer_Conversion) {
5455  SCS.Second = ICK_Identity;
5456  SCS.Third = ICK_Identity;
5457  SCS.ToTypePtrs[2] = SCS.ToTypePtrs[1] = SCS.ToTypePtrs[0];
5458  }
5459 }
5460 
5461 /// TryContextuallyConvertToObjCPointer - Attempt to contextually
5462 /// convert the expression From to an Objective-C pointer type.
5465  // Do an implicit conversion to 'id'.
5466  QualType Ty = S.Context.getObjCIdType();
5468  = TryImplicitConversion(S, From, Ty,
5469  // FIXME: Are these flags correct?
5470  /*SuppressUserConversions=*/false,
5471  /*AllowExplicit=*/true,
5472  /*InOverloadResolution=*/false,
5473  /*CStyle=*/false,
5474  /*AllowObjCWritebackConversion=*/false,
5475  /*AllowObjCConversionOnExplicit=*/true);
5476 
5477  // Strip off any final conversions to 'id'.
5478  switch (ICS.getKind()) {
5482  break;
5483 
5486  break;
5487 
5490  break;
5491  }
5492 
5493  return ICS;
5494 }
5495 
5496 /// PerformContextuallyConvertToObjCPointer - Perform a contextual
5497 /// conversion of the expression From to an Objective-C pointer type.
5498 /// Returns a valid but null ExprResult if no conversion sequence exists.
5500  if (checkPlaceholderForOverload(*this, From))
5501  return ExprError();
5502 
5503  QualType Ty = Context.getObjCIdType();
5506  if (!ICS.isBad())
5507  return PerformImplicitConversion(From, Ty, ICS, AA_Converting);
5508  return ExprResult();
5509 }
5510 
5511 /// Determine whether the provided type is an integral type, or an enumeration
5512 /// type of a permitted flavor.
5514  return AllowScopedEnumerations ? T->isIntegralOrEnumerationType()
5516 }
5517 
5518 static ExprResult
5521  QualType T, UnresolvedSetImpl &ViableConversions) {
5522 
5523  if (Converter.Suppress)
5524  return ExprError();
5525 
5526  Converter.diagnoseAmbiguous(SemaRef, Loc, T) << From->getSourceRange();
5527  for (unsigned I = 0, N = ViableConversions.size(); I != N; ++I) {
5528  CXXConversionDecl *Conv =
5529  cast<CXXConversionDecl>(ViableConversions[I]->getUnderlyingDecl());
5530  QualType ConvTy = Conv->getConversionType().getNonReferenceType();
5531  Converter.noteAmbiguous(SemaRef, Conv, ConvTy);
5532  }
5533  return From;
5534 }
5535 
5536 static bool
5539  QualType T, bool HadMultipleCandidates,
5540  UnresolvedSetImpl &ExplicitConversions) {
5541  if (ExplicitConversions.size() == 1 && !Converter.Suppress) {
5542  DeclAccessPair Found = ExplicitConversions[0];
5543  CXXConversionDecl *Conversion =
5544  cast<CXXConversionDecl>(Found->getUnderlyingDecl());
5545 
5546  // The user probably meant to invoke the given explicit
5547  // conversion; use it.
5548  QualType ConvTy = Conversion->getConversionType().getNonReferenceType();
5549  std::string TypeStr;
5550  ConvTy.getAsStringInternal(TypeStr, SemaRef.getPrintingPolicy());
5551 
5552  Converter.diagnoseExplicitConv(SemaRef, Loc, T, ConvTy)
5554  "static_cast<" + TypeStr + ">(")
5556  SemaRef.getLocForEndOfToken(From->getLocEnd()), ")");
5557  Converter.noteExplicitConv(SemaRef, Conversion, ConvTy);
5558 
5559  // If we aren't in a SFINAE context, build a call to the
5560  // explicit conversion function.
5561  if (SemaRef.isSFINAEContext())
5562  return true;
5563 
5564  SemaRef.CheckMemberOperatorAccess(From->getExprLoc(), From, nullptr, Found);
5565  ExprResult Result = SemaRef.BuildCXXMemberCallExpr(From, Found, Conversion,
5566  HadMultipleCandidates);
5567  if (Result.isInvalid())
5568  return true;
5569  // Record usage of conversion in an implicit cast.
5570  From = ImplicitCastExpr::Create(SemaRef.Context, Result.get()->getType(),
5571  CK_UserDefinedConversion, Result.get(),
5572  nullptr, Result.get()->getValueKind());
5573  }
5574  return false;
5575 }
5576 
5577 static bool recordConversion(Sema &SemaRef, SourceLocation Loc, Expr *&From,
5579  QualType T, bool HadMultipleCandidates,
5580  DeclAccessPair &Found) {
5581  CXXConversionDecl *Conversion =
5582  cast<CXXConversionDecl>(Found->getUnderlyingDecl());
5583  SemaRef.CheckMemberOperatorAccess(From->getExprLoc(), From, nullptr, Found);
5584 
5585  QualType ToType = Conversion->getConversionType().getNonReferenceType();
5586  if (!Converter.SuppressConversion) {
5587  if (SemaRef.isSFINAEContext())
5588  return true;
5589 
5590  Converter.diagnoseConversion(SemaRef, Loc, T, ToType)
5591  << From->getSourceRange();
5592  }
5593 
5594  ExprResult Result = SemaRef.BuildCXXMemberCallExpr(From, Found, Conversion,
5595  HadMultipleCandidates);
5596  if (Result.isInvalid())
5597  return true;
5598  // Record usage of conversion in an implicit cast.
5599  From = ImplicitCastExpr::Create(SemaRef.Context, Result.get()->getType(),
5600  CK_UserDefinedConversion, Result.get(),
5601  nullptr, Result.get()->getValueKind());
5602  return false;
5603 }
5604 
5606  Sema &SemaRef, SourceLocation Loc, Expr *From,
5607  Sema::ContextualImplicitConverter &Converter) {
5608  if (!Converter.match(From->getType()) && !Converter.Suppress)
5609  Converter.diagnoseNoMatch(SemaRef, Loc, From->getType())
5610  << From->getSourceRange();
5611 
5612  return SemaRef.DefaultLvalueConversion(From);
5613 }
5614 
5615 static void
5617  UnresolvedSetImpl &ViableConversions,
5618  OverloadCandidateSet &CandidateSet) {
5619  for (unsigned I = 0, N = ViableConversions.size(); I != N; ++I) {
5620  DeclAccessPair FoundDecl = ViableConversions[I];
5621  NamedDecl *D = FoundDecl.getDecl();
5622  CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext());
5623  if (isa<UsingShadowDecl>(D))
5624  D = cast<UsingShadowDecl>(D)->getTargetDecl();
5625 
5626  CXXConversionDecl *Conv;
5627  FunctionTemplateDecl *ConvTemplate;
5628  if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D)))
5629  Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
5630  else
5631  Conv = cast<CXXConversionDecl>(D);
5632 
5633  if (ConvTemplate)
5635  ConvTemplate, FoundDecl, ActingContext, From, ToType, CandidateSet,
5636  /*AllowObjCConversionOnExplicit=*/false);
5637  else
5638  SemaRef.AddConversionCandidate(Conv, FoundDecl, ActingContext, From,
5639  ToType, CandidateSet,
5640  /*AllowObjCConversionOnExplicit=*/false);
5641  }
5642 }
5643 
5644 /// \brief Attempt to convert the given expression to a type which is accepted
5645 /// by the given converter.
5646 ///
5647 /// This routine will attempt to convert an expression of class type to a
5648 /// type accepted by the specified converter. In C++11 and before, the class
5649 /// must have a single non-explicit conversion function converting to a matching
5650 /// type. In C++1y, there can be multiple such conversion functions, but only
5651 /// one target type.
5652 ///
5653 /// \param Loc The source location of the construct that requires the
5654 /// conversion.
5655 ///
5656 /// \param From The expression we're converting from.
5657 ///
5658 /// \param Converter Used to control and diagnose the conversion process.
5659 ///
5660 /// \returns The expression, converted to an integral or enumeration type if
5661 /// successful.
5663  SourceLocation Loc, Expr *From, ContextualImplicitConverter &Converter) {
5664  // We can't perform any more checking for type-dependent expressions.
5665  if (From->isTypeDependent())
5666  return From;
5667 
5668  // Process placeholders immediately.
5669  if (From->hasPlaceholderType()) {
5670  ExprResult result = CheckPlaceholderExpr(From);
5671  if (result.isInvalid())
5672  return result;
5673  From = result.get();
5674  }
5675 
5676  // If the expression already has a matching type, we're golden.
5677  QualType T = From->getType();
5678  if (Converter.match(T))
5679  return DefaultLvalueConversion(From);
5680 
5681  // FIXME: Check for missing '()' if T is a function type?
5682 
5683  // We can only perform contextual implicit conversions on objects of class
5684  // type.
5685  const RecordType *RecordTy = T->getAs<RecordType>();
5686  if (!RecordTy || !getLangOpts().CPlusPlus) {
5687  if (!Converter.Suppress)
5688  Converter.diagnoseNoMatch(*this, Loc, T) << From->getSourceRange();
5689  return From;
5690  }
5691 
5692  // We must have a complete class type.
5693  struct TypeDiagnoserPartialDiag : TypeDiagnoser {
5694  ContextualImplicitConverter &Converter;
5695  Expr *From;
5696 
5697  TypeDiagnoserPartialDiag(ContextualImplicitConverter &Converter, Expr *From)
5698  : Converter(Converter), From(From) {}
5699 
5700  void diagnose(Sema &S, SourceLocation Loc, QualType T) override {
5701  Converter.diagnoseIncomplete(S, Loc, T) << From->getSourceRange();
5702  }
5703  } IncompleteDiagnoser(Converter, From);
5704 
5705  if (Converter.Suppress ? !isCompleteType(Loc, T)
5706  : RequireCompleteType(Loc, T, IncompleteDiagnoser))
5707  return From;
5708 
5709  // Look for a conversion to an integral or enumeration type.
5711  ViableConversions; // These are *potentially* viable in C++1y.
5712  UnresolvedSet<4> ExplicitConversions;
5713  const auto &Conversions =
5714  cast<CXXRecordDecl>(RecordTy->getDecl())->getVisibleConversionFunctions();
5715 
5716  bool HadMultipleCandidates =
5717  (std::distance(Conversions.begin(), Conversions.end()) > 1);
5718 
5719  // To check that there is only one target type, in C++1y:
5720  QualType ToType;
5721  bool HasUniqueTargetType = true;
5722 
5723  // Collect explicit or viable (potentially in C++1y) conversions.
5724  for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
5725  NamedDecl *D = (*I)->getUnderlyingDecl();
5726  CXXConversionDecl *Conversion;
5727  FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
5728  if (ConvTemplate) {
5729  if (getLangOpts().CPlusPlus14)
5730  Conversion = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
5731  else
5732  continue; // C++11 does not consider conversion operator templates(?).
5733  } else
5734  Conversion = cast<CXXConversionDecl>(D);
5735 
5736  assert((!ConvTemplate || getLangOpts().CPlusPlus14) &&
5737  "Conversion operator templates are considered potentially "
5738  "viable in C++1y");
5739 
5740  QualType CurToType = Conversion->getConversionType().getNonReferenceType();
5741  if (Converter.match(CurToType) || ConvTemplate) {
5742 
5743  if (Conversion->isExplicit()) {
5744  // FIXME: For C++1y, do we need this restriction?
5745  // cf. diagnoseNoViableConversion()
5746  if (!ConvTemplate)
5747  ExplicitConversions.addDecl(I.getDecl(), I.getAccess());
5748  } else {
5749  if (!ConvTemplate && getLangOpts().CPlusPlus14) {
5750  if (ToType.isNull())
5751  ToType = CurToType.getUnqualifiedType();
5752  else if (HasUniqueTargetType &&
5753  (CurToType.getUnqualifiedType() != ToType))
5754  HasUniqueTargetType = false;
5755  }
5756  ViableConversions.addDecl(I.getDecl(), I.getAccess());
5757  }
5758  }
5759  }
5760 
5761  if (getLangOpts().CPlusPlus14) {
5762  // C++1y [conv]p6:
5763  // ... An expression e of class type E appearing in such a context
5764  // is said to be contextually implicitly converted to a specified
5765  // type T and is well-formed if and only if e can be implicitly
5766  // converted to a type T that is determined as follows: E is searched
5767  // for conversion functions whose return type is cv T or reference to
5768  // cv T such that T is allowed by the context. There shall be
5769  // exactly one such T.
5770 
5771  // If no unique T is found:
5772  if (ToType.isNull()) {
5773  if (diagnoseNoViableConversion(*this, Loc, From, Converter, T,
5774  HadMultipleCandidates,
5775  ExplicitConversions))
5776  return ExprError();
5777  return finishContextualImplicitConversion(*this, Loc, From, Converter);
5778  }
5779 
5780  // If more than one unique Ts are found:
5781  if (!HasUniqueTargetType)
5782  return diagnoseAmbiguousConversion(*this, Loc, From, Converter, T,
5783  ViableConversions);
5784 
5785  // If one unique T is found:
5786  // First, build a candidate set from the previously recorded
5787  // potentially viable conversions.
5789  collectViableConversionCandidates(*this, From, ToType, ViableConversions,
5790  CandidateSet);
5791 
5792  // Then, perform overload resolution over the candidate set.
5794  switch (CandidateSet.BestViableFunction(*this, Loc, Best)) {
5795  case OR_Success: {
5796  // Apply this conversion.
5797  DeclAccessPair Found =
5798  DeclAccessPair::make(Best->Function, Best->FoundDecl.getAccess());
5799  if (recordConversion(*this, Loc, From, Converter, T,
5800  HadMultipleCandidates, Found))
5801  return ExprError();
5802  break;
5803  }
5804  case OR_Ambiguous:
5805  return diagnoseAmbiguousConversion(*this, Loc, From, Converter, T,
5806  ViableConversions);
5807  case OR_No_Viable_Function:
5808  if (diagnoseNoViableConversion(*this, Loc, From, Converter, T,
5809  HadMultipleCandidates,
5810  ExplicitConversions))
5811  return ExprError();
5812  LLVM_FALLTHROUGH;
5813  case OR_Deleted:
5814  // We'll complain below about a non-integral condition type.
5815  break;
5816  }
5817  } else {
5818  switch (ViableConversions.size()) {
5819  case 0: {
5820  if (diagnoseNoViableConversion(*this, Loc, From, Converter, T,
5821  HadMultipleCandidates,
5822  ExplicitConversions))
5823  return ExprError();
5824 
5825  // We'll complain below about a non-integral condition type.
5826  break;
5827  }
5828  case 1: {
5829  // Apply this conversion.
5830  DeclAccessPair Found = ViableConversions[0];
5831  if (recordConversion(*this, Loc, From, Converter, T,
5832  HadMultipleCandidates, Found))
5833  return ExprError();
5834  break;
5835  }
5836  default:
5837  return diagnoseAmbiguousConversion(*this, Loc, From, Converter, T,
5838  ViableConversions);
5839  }
5840  }
5841 
5842  return finishContextualImplicitConversion(*this, Loc, From, Converter);
5843 }
5844 
5845 /// IsAcceptableNonMemberOperatorCandidate - Determine whether Fn is
5846 /// an acceptable non-member overloaded operator for a call whose
5847 /// arguments have types T1 (and, if non-empty, T2). This routine
5848 /// implements the check in C++ [over.match.oper]p3b2 concerning
5849 /// enumeration types.
5851  FunctionDecl *Fn,
5852  ArrayRef<Expr *> Args) {
5853  QualType T1 = Args[0]->getType();
5854  QualType T2 = Args.size() > 1 ? Args[1]->getType() : QualType();
5855 
5856  if (T1->isDependentType() || (!T2.isNull() && T2->isDependentType()))
5857  return true;
5858 
5859  if (T1->isRecordType() || (!T2.isNull() && T2->isRecordType()))
5860  return true;
5861 
5862  const FunctionProtoType *Proto = Fn->getType()->getAs<FunctionProtoType>();
5863  if (Proto->getNumParams() < 1)
5864  return false;
5865 
5866  if (T1->isEnumeralType()) {
5867  QualType ArgType = Proto->getParamType(0).getNonReferenceType();
5868  if (Context.hasSameUnqualifiedType(T1, ArgType))
5869  return true;
5870  }
5871 
5872  if (Proto->getNumParams() < 2)
5873  return false;
5874 
5875  if (!T2.isNull() && T2->isEnumeralType()) {
5876  QualType ArgType = Proto->getParamType(1).getNonReferenceType();
5877  if (Context.hasSameUnqualifiedType(T2, ArgType))
5878  return true;
5879  }
5880 
5881  return false;
5882 }
5883 
5884 /// AddOverloadCandidate - Adds the given function to the set of
5885 /// candidate functions, using the given function call arguments. If
5886 /// @p SuppressUserConversions, then don't allow user-defined
5887 /// conversions via constructors or conversion operators.
5888 ///
5889 /// \param PartialOverloading true if we are performing "partial" overloading
5890 /// based on an incomplete set of function arguments. This feature is used by
5891 /// code completion.
5892 void
5894  DeclAccessPair FoundDecl,
5895  ArrayRef<Expr *> Args,
5896  OverloadCandidateSet &CandidateSet,
5897  bool SuppressUserConversions,
5898  bool PartialOverloading,
5899  bool AllowExplicit,
5900  ConversionSequenceList EarlyConversions) {
5901  const FunctionProtoType *Proto
5902  = dyn_cast<FunctionProtoType>(Function->getType()->getAs<FunctionType>());
5903  assert(Proto && "Functions without a prototype cannot be overloaded");
5904  assert(!Function->getDescribedFunctionTemplate() &&
5905  "Use AddTemplateOverloadCandidate for function templates");
5906 
5907  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Function)) {
5908  if (!isa<CXXConstructorDecl>(Method)) {
5909  // If we get here, it's because we're calling a member function
5910  // that is named without a member access expression (e.g.,
5911  // "this->f") that was either written explicitly or created
5912  // implicitly. This can happen with a qualified call to a member
5913  // function, e.g., X::f(). We use an empty type for the implied
5914  // object argument (C++ [over.call.func]p3), and the acting context
5915  // is irrelevant.
5916  AddMethodCandidate(Method, FoundDecl, Method->getParent(), QualType(),
5918  CandidateSet, SuppressUserConversions,
5919  PartialOverloading, EarlyConversions);
5920  return;
5921  }
5922  // We treat a constructor like a non-member function, since its object
5923  // argument doesn't participate in overload resolution.
5924  }
5925 
5926  if (!CandidateSet.isNewCandidate(Function))
5927  return;
5928 
5929  // C++ [over.match.oper]p3:
5930  // if no operand has a class type, only those non-member functions in the
5931  // lookup set that have a first parameter of type T1 or "reference to
5932  // (possibly cv-qualified) T1", when T1 is an enumeration type, or (if there
5933  // is a right operand) a second parameter of type T2 or "reference to
5934  // (possibly cv-qualified) T2", when T2 is an enumeration type, are
5935  // candidate functions.
5936  if (CandidateSet.getKind() == OverloadCandidateSet::CSK_Operator &&
5937  !IsAcceptableNonMemberOperatorCandidate(Context, Function, Args))
5938  return;
5939 
5940  // C++11 [class.copy]p11: [DR1402]
5941  // A defaulted move constructor that is defined as deleted is ignored by
5942  // overload resolution.
5943  CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Function);
5944  if (Constructor && Constructor->isDefaulted() && Constructor->isDeleted() &&
5945  Constructor->isMoveConstructor())
5946  return;
5947 
5948  // Overload resolution is always an unevaluated context.
5951 
5952  // Add this candidate
5953  OverloadCandidate &Candidate =
5954  CandidateSet.addCandidate(Args.size(), EarlyConversions);
5955  Candidate.FoundDecl = FoundDecl;
5956  Candidate.Function = Function;
5957  Candidate.Viable = true;
5958  Candidate.IsSurrogate = false;
5959  Candidate.IgnoreObjectArgument = false;
5960  Candidate.ExplicitCallArguments = Args.size();
5961 
5962  if (Constructor) {
5963  // C++ [class.copy]p3:
5964  // A member function template is never instantiated to perform the copy
5965  // of a class object to an object of its class type.
5966  QualType ClassType = Context.getTypeDeclType(Constructor->getParent());
5967  if (Args.size() == 1 && Constructor->isSpecializationCopyingObject() &&
5968  (Context.hasSameUnqualifiedType(ClassType, Args[0]->getType()) ||
5969  IsDerivedFrom(Args[0]->getLocStart(), Args[0]->getType(),
5970  ClassType))) {
5971  Candidate.Viable = false;
5973  return;
5974  }
5975 
5976  // C++ [over.match.funcs]p8: (proposed DR resolution)
5977  // A constructor inherited from class type C that has a first parameter
5978  // of type "reference to P" (including such a constructor instantiated
5979  // from a template) is excluded from the set of candidate functions when
5980  // constructing an object of type cv D if the argument list has exactly
5981  // one argument and D is reference-related to P and P is reference-related
5982  // to C.
5983  auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(FoundDecl.getDecl());
5984  if (Shadow && Args.size() == 1 && Constructor->getNumParams() >= 1 &&
5985  Constructor->getParamDecl(0)->getType()->isReferenceType()) {
5986  QualType P = Constructor->getParamDecl(0)->getType()->getPointeeType();
5987  QualType C = Context.getRecordType(Constructor->getParent());
5988  QualType D = Context.getRecordType(Shadow->getParent());
5989  SourceLocation Loc = Args.front()->getExprLoc();
5990  if ((Context.hasSameUnqualifiedType(P, C) || IsDerivedFrom(Loc, P, C)) &&
5991  (Context.hasSameUnqualifiedType(D, P) || IsDerivedFrom(Loc, D, P))) {
5992  Candidate.Viable = false;
5993  Candidate.FailureKind = ovl_fail_inhctor_slice;
5994  return;
5995  }
5996  }
5997  }
5998 
5999  unsigned NumParams = Proto->getNumParams();
6000 
6001  // (C++ 13.3.2p2): A candidate function having fewer than m
6002  // parameters is viable only if it has an ellipsis in its parameter
6003  // list (8.3.5).
6004  if (TooManyArguments(NumParams, Args.size(), PartialOverloading) &&
6005  !Proto->isVariadic()) {
6006  Candidate.Viable = false;
6008  return;
6009  }
6010 
6011  // (C++ 13.3.2p2): A candidate function having more than m parameters
6012  // is viable only if the (m+1)st parameter has a default argument
6013  // (8.3.6). For the purposes of overload resolution, the
6014  // parameter list is truncated on the right, so that there are
6015  // exactly m parameters.
6016  unsigned MinRequiredArgs = Function->getMinRequiredArguments();
6017  if (Args.size() < MinRequiredArgs && !PartialOverloading) {
6018  // Not enough arguments.
6019  Candidate.Viable = false;
6021  return;
6022  }
6023 
6024  // (CUDA B.1): Check for invalid calls between targets.
6025  if (getLangOpts().CUDA)
6026  if (const FunctionDecl *Caller = dyn_cast<FunctionDecl>(CurContext))
6027  // Skip the check for callers that are implicit members, because in this
6028  // case we may not yet know what the member's target is; the target is
6029  // inferred for the member automatically, based on the bases and fields of
6030  // the class.
6031  if (!Caller->isImplicit() && !IsAllowedCUDACall(Caller, Function)) {
6032  Candidate.Viable = false;
6033  Candidate.FailureKind = ovl_fail_bad_target;
6034  return;
6035  }
6036 
6037  // Determine the implicit conversion sequences for each of the
6038  // arguments.
6039  for (unsigned ArgIdx = 0; ArgIdx < Args.size(); ++ArgIdx) {
6040  if (Candidate.Conversions[ArgIdx].isInitialized()) {
6041  // We already formed a conversion sequence for this parameter during
6042  // template argument deduction.
6043  } else if (ArgIdx < NumParams) {
6044  // (C++ 13.3.2p3): for F to be a viable function, there shall
6045  // exist for each argument an implicit conversion sequence
6046  // (13.3.3.1) that converts that argument to the corresponding
6047  // parameter of F.
6048  QualType ParamType = Proto->getParamType(ArgIdx);
6049  Candidate.Conversions[ArgIdx]
6050  = TryCopyInitialization(*this, Args[ArgIdx], ParamType,
6051  SuppressUserConversions,
6052  /*InOverloadResolution=*/true,
6053  /*AllowObjCWritebackConversion=*/
6054  getLangOpts().ObjCAutoRefCount,
6055  AllowExplicit);
6056  if (Candidate.Conversions[ArgIdx].isBad()) {
6057  Candidate.Viable = false;
6059  return;
6060  }
6061  } else {
6062  // (C++ 13.3.2p2): For the purposes of overload resolution, any
6063  // argument for which there is no corresponding parameter is
6064  // considered to ""match the ellipsis" (C+ 13.3.3.1.3).
6065  Candidate.Conversions[ArgIdx].setEllipsis();
6066  }
6067  }
6068 
6069  if (EnableIfAttr *FailedAttr = CheckEnableIf(Function, Args)) {
6070  Candidate.Viable = false;
6071  Candidate.FailureKind = ovl_fail_enable_if;
6072  Candidate.DeductionFailure.Data = FailedAttr;
6073  return;
6074  }
6075 
6076  if (LangOpts.OpenCL && isOpenCLDisabledDecl(Function)) {
6077  Candidate.Viable = false;
6078  Candidate.FailureKind = ovl_fail_ext_disabled;
6079  return;
6080  }
6081 }
6082 
6084 Sema::SelectBestMethod(Selector Sel, MultiExprArg Args, bool IsInstance,
6086  if (Methods.size() <= 1)
6087  return nullptr;
6088 
6089  for (unsigned b = 0, e = Methods.size(); b < e; b++) {
6090  bool Match = true;
6091  ObjCMethodDecl *Method = Methods[b];
6092  unsigned NumNamedArgs = Sel.getNumArgs();
6093  // Method might have more arguments than selector indicates. This is due
6094  // to addition of c-style arguments in method.
6095  if (Method->param_size() > NumNamedArgs)
6096  NumNamedArgs = Method->param_size();
6097  if (Args.size() < NumNamedArgs)
6098  continue;
6099 
6100  for (unsigned i = 0; i < NumNamedArgs; i++) {
6101  // We can't do any type-checking on a type-dependent argument.
6102  if (Args[i]->isTypeDependent()) {
6103  Match = false;
6104  break;
6105  }
6106 
6107  ParmVarDecl *param = Method->parameters()[i];
6108  Expr *argExpr = Args[i];
6109  assert(argExpr && "SelectBestMethod(): missing expression");
6110 
6111  // Strip the unbridged-cast placeholder expression off unless it's
6112  // a consumed argument.
6113  if (argExpr->hasPlaceholderType(BuiltinType::ARCUnbridgedCast) &&
6114  !param->hasAttr<CFConsumedAttr>())
6115  argExpr = stripARCUnbridgedCast(argExpr);
6116 
6117  // If the parameter is __unknown_anytype, move on to the next method.
6118  if (param->getType() == Context.UnknownAnyTy) {
6119  Match = false;
6120  break;
6121  }
6122 
6123  ImplicitConversionSequence ConversionState
6124  = TryCopyInitialization(*this, argExpr, param->getType(),
6125  /*SuppressUserConversions*/false,
6126  /*InOverloadResolution=*/true,
6127  /*AllowObjCWritebackConversion=*/
6128  getLangOpts().ObjCAutoRefCount,
6129  /*AllowExplicit*/false);
6130  // This function looks for a reasonably-exact match, so we consider
6131  // incompatible pointer conversions to be a failure here.
6132  if (ConversionState.isBad() ||
6133  (ConversionState.isStandard() &&
6134  ConversionState.Standard.Second ==
6136  Match = false;
6137  break;
6138  }
6139  }
6140  // Promote additional arguments to variadic methods.
6141  if (Match && Method->isVariadic()) {
6142  for (unsigned i = NumNamedArgs, e = Args.size(); i < e; ++i) {
6143  if (Args[i]->isTypeDependent()) {
6144  Match = false;
6145  break;
6146  }
6147  ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], VariadicMethod,
6148  nullptr);
6149  if (Arg.isInvalid()) {
6150  Match = false;
6151  break;
6152  }
6153  }
6154  } else {
6155  // Check for extra arguments to non-variadic methods.
6156  if (Args.size() != NumNamedArgs)
6157  Match = false;
6158  else if (Match && NumNamedArgs == 0 && Methods.size() > 1) {
6159  // Special case when selectors have no argument. In this case, select
6160  // one with the most general result type of 'id'.
6161  for (unsigned b = 0, e = Methods.size(); b < e; b++) {
6162  QualType ReturnT = Methods[b]->getReturnType();
6163  if (ReturnT->isObjCIdType())
6164  return Methods[b];
6165  }
6166  }
6167  }
6168 
6169  if (Match)
6170  return Method;
6171  }
6172  return nullptr;
6173 }
6174 
6175 // specific_attr_iterator iterates over enable_if attributes in reverse, and
6176 // enable_if is order-sensitive. As a result, we need to reverse things
6177 // sometimes. Size of 4 elements is arbitrary.
6181  if (!Function->hasAttrs())
6182  return Result;
6183 
6184  const auto &FuncAttrs = Function->getAttrs();
6185  for (Attr *Attr : FuncAttrs)
6186  if (auto *EnableIf = dyn_cast<EnableIfAttr>(Attr))
6187  Result.push_back(EnableIf);
6188 
6189  std::reverse(Result.begin(), Result.end());
6190  return Result;
6191 }
6192 
6193 static bool
6195  ArrayRef<Expr *> Args, Sema::SFINAETrap &Trap,
6196  bool MissingImplicitThis, Expr *&ConvertedThis,
6197  SmallVectorImpl<Expr *> &ConvertedArgs) {
6198  if (ThisArg) {
6199  CXXMethodDecl *Method = cast<CXXMethodDecl>(Function);
6200  assert(!isa<CXXConstructorDecl>(Method) &&
6201  "Shouldn't have `this` for ctors!");
6202  assert(!Method->isStatic() && "Shouldn't have `this` for static methods!");
6204  ThisArg, /*Qualifier=*/nullptr, Method, Method);
6205  if (R.isInvalid())
6206  return false;
6207  ConvertedThis = R.get();
6208  } else {
6209  if (auto *MD = dyn_cast<CXXMethodDecl>(Function)) {
6210  (void)MD;
6211  assert((MissingImplicitThis || MD->isStatic() ||
6212  isa<CXXConstructorDecl>(MD)) &&
6213  "Expected `this` for non-ctor instance methods");
6214  }
6215  ConvertedThis = nullptr;
6216  }
6217 
6218  // Ignore any variadic arguments. Converting them is pointless, since the
6219  // user can't refer to them in the function condition.
6220  unsigned ArgSizeNoVarargs = std::min(Function->param_size(), Args.size());
6221 
6222  // Convert the arguments.
6223  for (unsigned I = 0; I != ArgSizeNoVarargs; ++I) {
6224  ExprResult R;
6226  S.Context, Function->getParamDecl(I)),
6227  SourceLocation(), Args[I]);
6228 
6229  if (R.isInvalid())
6230  return false;
6231 
6232  ConvertedArgs.push_back(R.get());
6233  }
6234 
6235  if (Trap.hasErrorOccurred())
6236  return false;
6237 
6238  // Push default arguments if needed.
6239  if (!Function->isVariadic() && Args.size() < Function->getNumParams()) {
6240  for (unsigned i = Args.size(), e = Function->getNumParams(); i != e; ++i) {
6241  ParmVarDecl *P = Function->getParamDecl(i);
6244  Function->getParamDecl(i)),
6245  SourceLocation(),
6247  : P->getDefaultArg());
6248  if (R.isInvalid())
6249  return false;
6250  ConvertedArgs.push_back(R.get());
6251  }
6252 
6253  if (Trap.hasErrorOccurred())
6254  return false;
6255  }
6256  return true;
6257 }
6258 
6259 EnableIfAttr *Sema::CheckEnableIf(FunctionDecl *Function, ArrayRef<Expr *> Args,
6260  bool MissingImplicitThis) {
6261  SmallVector<EnableIfAttr *, 4> EnableIfAttrs =
6262  getOrderedEnableIfAttrs(Function);
6263  if (EnableIfAttrs.empty())
6264  return nullptr;
6265 
6266  SFINAETrap Trap(*this);
6267  SmallVector<Expr *, 16> ConvertedArgs;
6268  // FIXME: We should look into making enable_if late-parsed.
6269  Expr *DiscardedThis;
6271  *this, Function, /*ThisArg=*/nullptr, Args, Trap,
6272  /*MissingImplicitThis=*/true, DiscardedThis, ConvertedArgs))
6273  return EnableIfAttrs[0];
6274 
6275  for (auto *EIA : EnableIfAttrs) {
6276  APValue Result;
6277  // FIXME: This doesn't consider value-dependent cases, because doing so is
6278  // very difficult. Ideally, we should handle them more gracefully.
6279  if (!EIA->getCond()->EvaluateWithSubstitution(
6280  Result, Context, Function, llvm::makeArrayRef(ConvertedArgs)))
6281  return EIA;
6282 
6283  if (!Result.isInt() || !Result.getInt().getBoolValue())
6284  return EIA;
6285  }
6286  return nullptr;
6287 }
6288 
6289 template <typename CheckFn>
6290 static bool diagnoseDiagnoseIfAttrsWith(Sema &S, const NamedDecl *ND,
6291  bool ArgDependent, SourceLocation Loc,
6292  CheckFn &&IsSuccessful) {
6294  for (const auto *DIA : ND->specific_attrs<DiagnoseIfAttr>()) {
6295  if (ArgDependent == DIA->getArgDependent())
6296  Attrs.push_back(DIA);
6297  }
6298 
6299  // Common case: No diagnose_if attributes, so we can quit early.
6300  if (Attrs.empty())
6301  return false;
6302 
6303  auto WarningBegin = std::stable_partition(
6304  Attrs.begin(), Attrs.end(),
6305  [](const DiagnoseIfAttr *DIA) { return DIA->isError(); });
6306 
6307  // Note that diagnose_if attributes are late-parsed, so they appear in the
6308  // correct order (unlike enable_if attributes).
6309  auto ErrAttr = llvm::find_if(llvm::make_range(Attrs.begin(), WarningBegin),
6310  IsSuccessful);
6311  if (ErrAttr != WarningBegin) {
6312  const DiagnoseIfAttr *DIA = *ErrAttr;
6313  S.Diag(Loc, diag::err_diagnose_if_succeeded) << DIA->getMessage();
6314  S.Diag(DIA->getLocation(), diag::note_from_diagnose_if)
6315  << DIA->getParent() << DIA->getCond()->getSourceRange();
6316  return true;
6317  }
6318 
6319  for (const auto *DIA : llvm::make_range(WarningBegin, Attrs.end()))
6320  if (IsSuccessful(DIA)) {
6321  S.Diag(Loc, diag::warn_diagnose_if_succeeded) << DIA->getMessage();
6322  S.Diag(DIA->getLocation(), diag::note_from_diagnose_if)
6323  << DIA->getParent() << DIA->getCond()->getSourceRange();
6324  }
6325 
6326  return false;
6327 }
6328 
6330  const Expr *ThisArg,
6332  SourceLocation Loc) {
6334  *this, Function, /*ArgDependent=*/true, Loc,
6335  [&](const DiagnoseIfAttr *DIA) {
6336  APValue Result;
6337  // It's sane to use the same Args for any redecl of this function, since
6338  // EvaluateWithSubstitution only cares about the position of each
6339  // argument in the arg list, not the ParmVarDecl* it maps to.
6340  if (!DIA->getCond()->EvaluateWithSubstitution(
6341  Result, Context, cast<FunctionDecl>(DIA->getParent()), Args, ThisArg))
6342  return false;
6343  return Result.isInt() && Result.getInt().getBoolValue();
6344  });
6345 }
6346 
6348  SourceLocation Loc) {
6350  *this, ND, /*ArgDependent=*/false, Loc,
6351  [&](const DiagnoseIfAttr *DIA) {
6352  bool Result;
6353  return DIA->getCond()->EvaluateAsBooleanCondition(Result, Context) &&
6354  Result;
6355  });
6356 }
6357 
6358 /// \brief Add all of the function declarations in the given function set to
6359 /// the overload candidate set.
6361  ArrayRef<Expr *> Args,
6362  OverloadCandidateSet& CandidateSet,
6363  TemplateArgumentListInfo *ExplicitTemplateArgs,
6364  bool SuppressUserConversions,
6365  bool PartialOverloading,
6366  bool FirstArgumentIsBase) {
6367  for (UnresolvedSetIterator F = Fns.begin(), E = Fns.end(); F != E; ++F) {
6368  NamedDecl *D = F.getDecl()->getUnderlyingDecl();
6369  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
6370  ArrayRef<Expr *> FunctionArgs = Args;
6371  if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic()) {
6372  QualType ObjectType;
6373  Expr::Classification ObjectClassification;
6374  if (Args.size() > 0) {
6375  if (Expr *E = Args[0]) {
6376  // Use the explit base to restrict the lookup:
6377  ObjectType = E->getType();
6378  ObjectClassification = E->Classify(Context);
6379  } // .. else there is an implit base.
6380  FunctionArgs = Args.slice(1);
6381  }
6382  AddMethodCandidate(cast<CXXMethodDecl>(FD), F.getPair(),
6383  cast<CXXMethodDecl>(FD)->getParent(), ObjectType,
6384  ObjectClassification, FunctionArgs, CandidateSet,
6385  SuppressUserConversions, PartialOverloading);
6386  } else {
6387  // Slice the first argument (which is the base) when we access
6388  // static method as non-static
6389  if (Args.size() > 0 && (!Args[0] || (FirstArgumentIsBase && isa<CXXMethodDecl>(FD) &&
6390  !isa<CXXConstructorDecl>(FD)))) {
6391  assert(cast<CXXMethodDecl>(FD)->isStatic());
6392  FunctionArgs = Args.slice(1);
6393  }
6394  AddOverloadCandidate(FD, F.getPair(), FunctionArgs, CandidateSet,
6395  SuppressUserConversions, PartialOverloading);
6396  }
6397  } else {
6398  FunctionTemplateDecl *FunTmpl = cast<FunctionTemplateDecl>(D);
6399  if (isa<CXXMethodDecl>(FunTmpl->getTemplatedDecl()) &&
6400  !cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl())->isStatic()) {
6401  QualType ObjectType;
6402  Expr::Classification ObjectClassification;
6403  if (Expr *E = Args[0]) {
6404  // Use the explit base to restrict the lookup:
6405  ObjectType = E->getType();
6406  ObjectClassification = E->Classify(Context);
6407  } // .. else there is an implit base.
6408  AddMethodTemplateCandidate(
6409  FunTmpl, F.getPair(),
6410  cast<CXXRecordDecl>(FunTmpl->getDeclContext()),
6411  ExplicitTemplateArgs, ObjectType, ObjectClassification,
6412  Args.slice(1), CandidateSet, SuppressUserConversions,
6413  PartialOverloading);
6414  } else {
6415  AddTemplateOverloadCandidate(FunTmpl, F.getPair(),
6416  ExplicitTemplateArgs, Args,
6417  CandidateSet, SuppressUserConversions,
6418  PartialOverloading);
6419  }
6420  }
6421  }
6422 }
6423 
6424 /// AddMethodCandidate - Adds a named decl (which is some kind of
6425 /// method) as a method candidate to the given overload set.
6427  QualType ObjectType,
6428  Expr::Classification ObjectClassification,
6429  ArrayRef<Expr *> Args,
6430  OverloadCandidateSet& CandidateSet,
6431  bool SuppressUserConversions) {
6432  NamedDecl *Decl = FoundDecl.getDecl();
6433  CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(Decl->getDeclContext());
6434 
6435  if (isa<UsingShadowDecl>(Decl))
6436  Decl = cast<UsingShadowDecl>(Decl)->getTargetDecl();
6437 
6438  if (FunctionTemplateDecl *TD = dyn_cast<FunctionTemplateDecl>(Decl)) {
6439  assert(isa<CXXMethodDecl>(TD->getTemplatedDecl()) &&
6440  "Expected a member function template");
6441  AddMethodTemplateCandidate(TD, FoundDecl, ActingContext,
6442  /*ExplicitArgs*/ nullptr, ObjectType,
6443  ObjectClassification, Args, CandidateSet,
6444  SuppressUserConversions);
6445  } else {
6446  AddMethodCandidate(cast<CXXMethodDecl>(Decl), FoundDecl, ActingContext,
6447  ObjectType, ObjectClassification, Args, CandidateSet,
6448  SuppressUserConversions);
6449  }
6450 }
6451 
6452 /// AddMethodCandidate - Adds the given C++ member function to the set
6453 /// of candidate functions, using the given function call arguments
6454 /// and the object argument (@c Object). For example, in a call
6455 /// @c o.f(a1,a2), @c Object will contain @c o and @c Args will contain
6456 /// both @c a1 and @c a2. If @p SuppressUserConversions, then don't
6457 /// allow user-defined conversions via constructors or conversion
6458 /// operators.
6459 void
6461  CXXRecordDecl *ActingContext, QualType ObjectType,
6462  Expr::Classification ObjectClassification,
6463  ArrayRef<Expr *> Args,
6464  OverloadCandidateSet &CandidateSet,
6465  bool SuppressUserConversions,
6466  bool PartialOverloading,
6467  ConversionSequenceList EarlyConversions) {
6468  const FunctionProtoType *Proto
6469  = dyn_cast<FunctionProtoType>(Method->getType()->getAs<FunctionType>());
6470  assert(Proto && "Methods without a prototype cannot be overloaded");
6471  assert(!isa<CXXConstructorDecl>(Method) &&
6472  "Use AddOverloadCandidate for constructors");
6473 
6474  if (!CandidateSet.isNewCandidate(Method))
6475  return;
6476 
6477  // C++11 [class.copy]p23: [DR1402]
6478  // A defaulted move assignment operator that is defined as deleted is
6479  // ignored by overload resolution.
6480  if (Method->isDefaulted() && Method->isDeleted() &&
6481  Method->isMoveAssignmentOperator())
6482  return;
6483 
6484  // Overload resolution is always an unevaluated context.
6487 
6488  // Add this candidate
6489  OverloadCandidate &Candidate =
6490  CandidateSet.addCandidate(Args.size() + 1, EarlyConversions);
6491  Candidate.FoundDecl = FoundDecl;
6492  Candidate.Function = Method;
6493  Candidate.IsSurrogate = false;
6494  Candidate.IgnoreObjectArgument = false;
6495  Candidate.ExplicitCallArguments = Args.size();
6496 
6497  unsigned NumParams = Proto->getNumParams();
6498 
6499  // (C++ 13.3.2p2): A candidate function having fewer than m
6500  // parameters is viable only if it has an ellipsis in its parameter
6501  // list (8.3.5).
6502  if (TooManyArguments(NumParams, Args.size(), PartialOverloading) &&
6503  !Proto->isVariadic()) {
6504  Candidate.Viable = false;
6506  return;
6507  }
6508 
6509  // (C++ 13.3.2p2): A candidate function having more than m parameters
6510  // is viable only if the (m+1)st parameter has a default argument
6511  // (8.3.6). For the purposes of overload resolution, the
6512  // parameter list is truncated on the right, so that there are
6513  // exactly m parameters.
6514  unsigned MinRequiredArgs = Method->getMinRequiredArguments();
6515  if (Args.size() < MinRequiredArgs && !PartialOverloading) {
6516  // Not enough arguments.
6517  Candidate.Viable = false;
6519  return;
6520  }
6521 
6522  Candidate.Viable = true;
6523 
6524  if (Method->isStatic() || ObjectType.isNull())
6525  // The implicit object argument is ignored.
6526  Candidate.IgnoreObjectArgument = true;
6527  else {
6528  // Determine the implicit conversion sequence for the object
6529  // parameter.
6531  *this, CandidateSet.getLocation(), ObjectType, ObjectClassification,
6532  Method, ActingContext);
6533  if (Candidate.Conversions[0].isBad()) {
6534  Candidate.Viable = false;
6536  return;
6537  }
6538  }
6539 
6540  // (CUDA B.1): Check for invalid calls between targets.
6541  if (getLangOpts().CUDA)
6542  if (const FunctionDecl *Caller = dyn_cast<FunctionDecl>(CurContext))
6543  if (!IsAllowedCUDACall(Caller, Method)) {
6544  Candidate.Viable = false;
6545  Candidate.FailureKind = ovl_fail_bad_target;
6546  return;
6547  }
6548 
6549  // Determine the implicit conversion sequences for each of the
6550  // arguments.
6551  for (unsigned ArgIdx = 0; ArgIdx < Args.size(); ++ArgIdx) {
6552  if (Candidate.Conversions[ArgIdx + 1].isInitialized()) {
6553  // We already formed a conversion sequence for this parameter during
6554  // template argument deduction.
6555  } else if (ArgIdx < NumParams) {
6556  // (C++ 13.3.2p3): for F to be a viable function, there shall
6557  // exist for each argument an implicit conversion sequence
6558  // (13.3.3.1) that converts that argument to the corresponding
6559  // parameter of F.
6560  QualType ParamType = Proto->getParamType(ArgIdx);
6561  Candidate.Conversions[ArgIdx + 1]
6562  = TryCopyInitialization(*this, Args[ArgIdx], ParamType,
6563  SuppressUserConversions,
6564  /*InOverloadResolution=*/true,
6565  /*AllowObjCWritebackConversion=*/
6566  getLangOpts().ObjCAutoRefCount);
6567  if (Candidate.Conversions[ArgIdx + 1].isBad()) {
6568  Candidate.Viable = false;
6569  Candidate.FailureKind = ovl_fail_bad_conversion;
6570  return;
6571  }
6572  } else {
6573  // (C++ 13.3.2p2): For the purposes of overload resolution, any
6574  // argument for which there is no corresponding parameter is
6575  // considered to "match the ellipsis" (C+ 13.3.3.1.3).
6576  Candidate.Conversions[ArgIdx + 1].setEllipsis();
6577  }
6578  }
6579 
6580  if (EnableIfAttr *FailedAttr = CheckEnableIf(Method, Args, true)) {
6581  Candidate.Viable = false;
6582  Candidate.FailureKind = ovl_fail_enable_if;
6583  Candidate.DeductionFailure.Data = FailedAttr;
6584  return;
6585  }
6586 }
6587 
6588 /// \brief Add a C++ member function template as a candidate to the candidate
6589 /// set, using template argument deduction to produce an appropriate member
6590 /// function template specialization.
6591 void
6593  DeclAccessPair FoundDecl,
6594  CXXRecordDecl *ActingContext,
6595  TemplateArgumentListInfo *ExplicitTemplateArgs,
6596  QualType ObjectType,
6597  Expr::Classification ObjectClassification,
6598  ArrayRef<Expr *> Args,
6599  OverloadCandidateSet& CandidateSet,
6600  bool SuppressUserConversions,
6601  bool PartialOverloading) {
6602  if (!CandidateSet.isNewCandidate(MethodTmpl))
6603  return;
6604 
6605  // C++ [over.match.funcs]p7:
6606  // In each case where a candidate is a function template, candidate
6607  // function template specializations are generated using template argument
6608  // deduction (14.8.3, 14.8.2). Those candidates are then handled as
6609  // candidate functions in the usual way.113) A given name can refer to one
6610  // or more function templates and also to a set of overloaded non-template
6611  // functions. In such a case, the candidate functions generated from each
6612  // function template are combined with the set of non-template candidate
6613  // functions.
6614  TemplateDeductionInfo Info(CandidateSet.getLocation());
6615  FunctionDecl *Specialization = nullptr;
6616  ConversionSequenceList Conversions;
6618  MethodTmpl, ExplicitTemplateArgs, Args, Specialization, Info,
6619  PartialOverloading, [&](ArrayRef<QualType> ParamTypes) {
6620  return CheckNonDependentConversions(
6621  MethodTmpl, ParamTypes, Args, CandidateSet, Conversions,
6622  SuppressUserConversions, ActingContext, ObjectType,
6623  ObjectClassification);
6624  })) {
6625  OverloadCandidate &Candidate =
6626  CandidateSet.addCandidate(Conversions.size(), Conversions);
6627  Candidate.FoundDecl = FoundDecl;
6628  Candidate.Function = MethodTmpl->getTemplatedDecl();
6629  Candidate.Viable = false;
6630  Candidate.IsSurrogate = false;
6631  Candidate.IgnoreObjectArgument =
6632  cast<CXXMethodDecl>(Candidate.Function)->isStatic() ||
6633  ObjectType.isNull();
6634  Candidate.ExplicitCallArguments = Args.size();
6635  if (Result == TDK_NonDependentConversionFailure)
6637  else {
6638  Candidate.FailureKind = ovl_fail_bad_deduction;
6639  Candidate.DeductionFailure = MakeDeductionFailureInfo(Context, Result,
6640  Info);
6641  }
6642  return;
6643  }
6644 
6645  // Add the function template specialization produced by template argument
6646  // deduction as a candidate.
6647  assert(Specialization && "Missing member function template specialization?");
6648  assert(isa<CXXMethodDecl>(Specialization) &&
6649  "Specialization is not a member function?");
6650  AddMethodCandidate(cast<CXXMethodDecl>(Specialization), FoundDecl,
6651  ActingContext, ObjectType, ObjectClassification, Args,
6652  CandidateSet, SuppressUserConversions, PartialOverloading,
6653  Conversions);
6654 }
6655 
6656 /// \brief Add a C++ function template specialization as a candidate
6657 /// in the candidate set, using template argument deduction to produce
6658 /// an appropriate function template specialization.
6659 void
6661  DeclAccessPair FoundDecl,
6662  TemplateArgumentListInfo *ExplicitTemplateArgs,
6663  ArrayRef<Expr *> Args,
6664  OverloadCandidateSet& CandidateSet,
6665  bool SuppressUserConversions,
6666  bool PartialOverloading) {
6667  if (!CandidateSet.isNewCandidate(FunctionTemplate))
6668  return;
6669 
6670  // C++ [over.match.funcs]p7:
6671  // In each case where a candidate is a function template, candidate
6672  // function template specializations are generated using template argument
6673  // deduction (14.8.3, 14.8.2). Those candidates are then handled as
6674  // candidate functions in the usual way.113) A given name can refer to one
6675  // or more function templates and also to a set of overloaded non-template
6676  // functions. In such a case, the candidate functions generated from each
6677  // function template are combined with the set of non-template candidate
6678  // functions.
6679  TemplateDeductionInfo Info(CandidateSet.getLocation());
6680  FunctionDecl *Specialization = nullptr;
6681  ConversionSequenceList Conversions;
6683  FunctionTemplate, ExplicitTemplateArgs, Args, Specialization, Info,
6684  PartialOverloading, [&](ArrayRef<QualType> ParamTypes) {
6685  return CheckNonDependentConversions(FunctionTemplate, ParamTypes,
6686  Args, CandidateSet, Conversions,
6687  SuppressUserConversions);
6688  })) {
6689  OverloadCandidate &Candidate =
6690  CandidateSet.addCandidate(Conversions.size(), Conversions);
6691  Candidate.FoundDecl = FoundDecl;
6692  Candidate.Function = FunctionTemplate->getTemplatedDecl();
6693  Candidate.Viable = false;
6694  Candidate.IsSurrogate = false;
6695  // Ignore the object argument if there is one, since we don't have an object
6696  // type.
6697  Candidate.IgnoreObjectArgument =
6698  isa<CXXMethodDecl>(Candidate.Function) &&
6699  !isa<CXXConstructorDecl>(Candidate.Function);
6700  Candidate.ExplicitCallArguments = Args.size();
6701  if (Result == TDK_NonDependentConversionFailure)
6703  else {
6704  Candidate.FailureKind = ovl_fail_bad_deduction;
6705  Candidate.DeductionFailure = MakeDeductionFailureInfo(Context, Result,
6706  Info);
6707  }
6708  return;
6709  }
6710 
6711  // Add the function template specialization produced by template argument
6712  // deduction as a candidate.
6713  assert(Specialization && "Missing function template specialization?");
6714  AddOverloadCandidate(Specialization, FoundDecl, Args, CandidateSet,
6715  SuppressUserConversions, PartialOverloading,
6716  /*AllowExplicit*/false, Conversions);
6717 }
6718 
6719 /// Check that implicit conversion sequences can be formed for each argument
6720 /// whose corresponding parameter has a non-dependent type, per DR1391's
6721 /// [temp.deduct.call]p10.
6723  FunctionTemplateDecl *FunctionTemplate, ArrayRef<QualType> ParamTypes,
6724  ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet,
6725  ConversionSequenceList &Conversions, bool SuppressUserConversions,
6726  CXXRecordDecl *ActingContext, QualType ObjectType,
6727  Expr::Classification ObjectClassification) {
6728  // FIXME: The cases in which we allow explicit conversions for constructor
6729  // arguments never consider calling a constructor template. It's not clear
6730  // that is correct.
6731  const bool AllowExplicit = false;
6732 
6733  auto *FD = FunctionTemplate->getTemplatedDecl();
6734  auto *Method = dyn_cast<CXXMethodDecl>(FD);
6735  bool HasThisConversion = Method && !isa<CXXConstructorDecl>(Method);
6736  unsigned ThisConversions = HasThisConversion ? 1 : 0;
6737 
6738  Conversions =
6739  CandidateSet.allocateConversionSequences(ThisConversions + Args.size());
6740 
6741  // Overload resolution is always an unevaluated context.
6744 
6745  // For a method call, check the 'this' conversion here too. DR1391 doesn't
6746  // require that, but this check should never result in a hard error, and
6747  // overload resolution is permitted to sidestep instantiations.
6748  if (HasThisConversion && !cast<CXXMethodDecl>(FD)->isStatic() &&
6749  !ObjectType.isNull()) {
6750  Conversions[0] = TryObjectArgumentInitialization(
6751  *this, CandidateSet.getLocation(), ObjectType, ObjectClassification,
6752  Method, ActingContext);
6753  if (Conversions[0].isBad())
6754  return true;
6755  }
6756 
6757  for (unsigned I = 0, N = std::min(ParamTypes.size(), Args.size()); I != N;
6758  ++I) {
6759  QualType ParamType = ParamTypes[I];
6760  if (!ParamType->isDependentType()) {
6761  Conversions[ThisConversions + I]
6762  = TryCopyInitialization(*this, Args[I], ParamType,
6763  SuppressUserConversions,
6764  /*InOverloadResolution=*/true,
6765  /*AllowObjCWritebackConversion=*/
6766  getLangOpts().ObjCAutoRefCount,
6767  AllowExplicit);
6768  if (Conversions[ThisConversions + I].isBad())
6769  return true;
6770  }
6771  }
6772 
6773  return false;
6774 }
6775 
6776 /// Determine whether this is an allowable conversion from the result
6777 /// of an explicit conversion operator to the expected type, per C++
6778 /// [over.match.conv]p1 and [over.match.ref]p1.
6779 ///
6780 /// \param ConvType The return type of the conversion function.
6781 ///
6782 /// \param ToType The type we are converting to.
6783 ///
6784 /// \param AllowObjCPointerConversion Allow a conversion from one
6785 /// Objective-C pointer to another.
6786 ///
6787 /// \returns true if the conversion is allowable, false otherwise.
6789  QualType ConvType, QualType ToType,
6790  bool AllowObjCPointerConversion) {
6791  QualType ToNonRefType = ToType.getNonReferenceType();
6792 
6793  // Easy case: the types are the same.
6794  if (S.Context.hasSameUnqualifiedType(ConvType, ToNonRefType))
6795  return true;
6796 
6797  // Allow qualification conversions.
6798  bool ObjCLifetimeConversion;
6799  if (S.IsQualificationConversion(ConvType, ToNonRefType, /*CStyle*/false,
6800  ObjCLifetimeConversion))
6801  return true;
6802 
6803  // If we're not allowed to consider Objective-C pointer conversions,
6804  // we're done.
6805  if (!AllowObjCPointerConversion)
6806  return false;
6807 
6808  // Is this an Objective-C pointer conversion?
6809  bool IncompatibleObjC = false;
6810  QualType ConvertedType;
6811  return S.isObjCPointerConversion(ConvType, ToNonRefType, ConvertedType,
6812  IncompatibleObjC);
6813 }
6814 
6815 /// AddConversionCandidate - Add a C++ conversion function as a
6816 /// candidate in the candidate set (C++ [over.match.conv],
6817 /// C++ [over.match.copy]). From is the expression we're converting from,
6818 /// and ToType is the type that we're eventually trying to convert to
6819 /// (which may or may not be the same type as the type that the
6820 /// conversion function produces).
6821 void
6823  DeclAccessPair FoundDecl,
6824  CXXRecordDecl *ActingContext,
6825  Expr *From, QualType ToType,
6826  OverloadCandidateSet& CandidateSet,
6827  bool AllowObjCConversionOnExplicit,
6828  bool AllowResultConversion) {
6829  assert(!Conversion->getDescribedFunctionTemplate() &&
6830  "Conversion function templates use AddTemplateConversionCandidate");
6831  QualType ConvType = Conversion->getConversionType().getNonReferenceType();
6832  if (!CandidateSet.isNewCandidate(Conversion))
6833  return;
6834 
6835  // If the conversion function has an undeduced return type, trigger its
6836  // deduction now.
6837  if (getLangOpts().CPlusPlus14 && ConvType->isUndeducedType()) {
6838  if (DeduceReturnType(Conversion, From->getExprLoc()))
6839  return;
6840  ConvType = Conversion->getConversionType().getNonReferenceType();
6841  }
6842 
6843  // If we don't allow any conversion of the result type, ignore conversion
6844  // functions that don't convert to exactly (possibly cv-qualified) T.
6845  if (!AllowResultConversion &&
6846  !Context.hasSameUnqualifiedType(Conversion->getConversionType(), ToType))
6847  return;
6848 
6849  // Per C++ [over.match.conv]p1, [over.match.ref]p1, an explicit conversion
6850  // operator is only a candidate if its return type is the target type or
6851  // can be converted to the target type with a qualification conversion.
6852  if (Conversion->isExplicit() &&
6853  !isAllowableExplicitConversion(*this, ConvType, ToType,
6854  AllowObjCConversionOnExplicit))
6855  return;
6856 
6857  // Overload resolution is always an unevaluated context.
6860 
6861  // Add this candidate
6862  OverloadCandidate &Candidate = CandidateSet.addCandidate(1);
6863  Candidate.FoundDecl = FoundDecl;
6864  Candidate.Function = Conversion;
6865  Candidate.IsSurrogate = false;
6866  Candidate.IgnoreObjectArgument = false;
6868  Candidate.FinalConversion.setFromType(ConvType);
6869  Candidate.FinalConversion.setAllToTypes(ToType);
6870  Candidate.Viable = true;
6871  Candidate.ExplicitCallArguments = 1;
6872 
6873  // C++ [over.match.funcs]p4:
6874  // For conversion functions, the function is considered to be a member of
6875  // the class of the implicit implied object argument for the purpose of
6876  // defining the type of the implicit object parameter.
6877  //
6878  // Determine the implicit conversion sequence for the implicit
6879  // object parameter.
6880  QualType ImplicitParamType = From->getType();
6881  if (const PointerType *FromPtrType = ImplicitParamType->getAs<PointerType>())
6882  ImplicitParamType = FromPtrType->getPointeeType();
6883  CXXRecordDecl *ConversionContext
6884  = cast<CXXRecordDecl>(ImplicitParamType->getAs<RecordType>()->getDecl());
6885 
6887  *this, CandidateSet.getLocation(), From->getType(),
6888  From->Classify(Context), Conversion, ConversionContext);
6889 
6890  if (Candidate.Conversions[0].isBad()) {
6891  Candidate.Viable = false;
6893  return;
6894  }
6895 
6896  // We won't go through a user-defined type conversion function to convert a
6897  // derived to base as such conversions are given Conversion Rank. They only
6898  // go through a copy constructor. 13.3.3.1.2-p4 [over.ics.user]
6899  QualType FromCanon
6900  = Context.getCanonicalType(From->getType().getUnqualifiedType());
6901  QualType ToCanon = Context.getCanonicalType(ToType).getUnqualifiedType();
6902  if (FromCanon == ToCanon ||
6903  IsDerivedFrom(CandidateSet.getLocation(), FromCanon, ToCanon)) {
6904  Candidate.Viable = false;
6906  return;
6907  }
6908 
6909  // To determine what the conversion from the result of calling the
6910  // conversion function to the type we're eventually trying to
6911  // convert to (ToType), we need to synthesize a call to the
6912  // conversion function and attempt copy initialization from it. This
6913  // makes sure that we get the right semantics with respect to
6914  // lvalues/rvalues and the type. Fortunately, we can allocate this
6915  // call on the stack and we don't need its arguments to be
6916  // well-formed.
6917  DeclRefExpr ConversionRef(Conversion, false, Conversion->getType(),
6918  VK_LValue, From->getLocStart());
6920  Context.getPointerType(Conversion->getType()),
6921  CK_FunctionToPointerDecay,
6922  &ConversionRef, VK_RValue);
6923 
6924  QualType ConversionType = Conversion->getConversionType();
6925  if (!isCompleteType(From->getLocStart(), ConversionType)) {
6926  Candidate.Viable = false;
6928  return;
6929  }
6930 
6931  ExprValueKind VK = Expr::getValueKindForType(ConversionType);
6932 
6933  // Note that it is safe to allocate CallExpr on the stack here because
6934  // there are 0 arguments (i.e., nothing is allocated using ASTContext's
6935  // allocator).
6936  QualType CallResultType = ConversionType.getNonLValueExprType(Context);
6937  CallExpr Call(Context, &ConversionFn, None, CallResultType, VK,
6938  From->getLocStart());
6940  TryCopyInitialization(*this, &Call, ToType,
6941  /*SuppressUserConversions=*/true,
6942  /*InOverloadResolution=*/false,
6943  /*AllowObjCWritebackConversion=*/false);
6944 
6945  switch (ICS.getKind()) {
6947  Candidate.FinalConversion = ICS.Standard;
6948 
6949  // C++ [over.ics.user]p3:
6950  // If the user-defined conversion is specified by a specialization of a
6951  // conversion function template, the second standard conversion sequence
6952  // shall have exact match rank.
6953  if (Conversion->getPrimaryTemplate() &&
6954  GetConversionRank(ICS.Standard.Second) != ICR_Exact_Match) {
6955  Candidate.Viable = false;
6957  return;
6958  }
6959 
6960  // C++0x [dcl.init.ref]p5:
6961  // In the second case, if the reference is an rvalue reference and
6962  // the second standard conversion sequence of the user-defined
6963  // conversion sequence includes an lvalue-to-rvalue conversion, the
6964  // program is ill-formed.
6965  if (ToType->isRValueReferenceType() &&
6966  ICS.Standard.First == ICK_Lvalue_To_Rvalue) {
6967  Candidate.Viable = false;
6969  return;
6970  }
6971  break;
6972 
6974  Candidate.Viable = false;
6976  return;
6977 
6978  default:
6979  llvm_unreachable(
6980  "Can only end up with a standard conversion sequence or failure");
6981  }
6982 
6983  if (EnableIfAttr *FailedAttr = CheckEnableIf(Conversion, None)) {
6984  Candidate.Viable = false;
6985  Candidate.FailureKind = ovl_fail_enable_if;
6986  Candidate.DeductionFailure.Data = FailedAttr;
6987  return;
6988  }
6989 }
6990 
6991 /// \brief Adds a conversion function template specialization
6992 /// candidate to the overload set, using template argument deduction
6993 /// to deduce the template arguments of the conversion function
6994 /// template from the type that we are converting to (C++
6995 /// [temp.deduct.conv]).
6996 void
6998  DeclAccessPair FoundDecl,
6999  CXXRecordDecl *ActingDC,
7000  Expr *From, QualType ToType,
7001  OverloadCandidateSet &CandidateSet,
7002  bool AllowObjCConversionOnExplicit,
7003  bool AllowResultConversion) {
7004  assert(isa<CXXConversionDecl>(FunctionTemplate->getTemplatedDecl()) &&
7005  "Only conversion function templates permitted here");
7006 
7007  if (!CandidateSet.isNewCandidate(FunctionTemplate))
7008  return;
7009 
7010  TemplateDeductionInfo Info(CandidateSet.getLocation());
7011  CXXConversionDecl *Specialization = nullptr;
7012  if (TemplateDeductionResult Result
7013  = DeduceTemplateArguments(FunctionTemplate, ToType,
7014  Specialization, Info)) {
7015  OverloadCandidate &Candidate = CandidateSet.addCandidate();
7016  Candidate.FoundDecl = FoundDecl;
7017  Candidate.Function = FunctionTemplate->getTemplatedDecl();
7018  Candidate.Viable = false;
7019  Candidate.FailureKind = ovl_fail_bad_deduction;
7020  Candidate.IsSurrogate = false;
7021  Candidate.IgnoreObjectArgument = false;
7022  Candidate.ExplicitCallArguments = 1;
7023  Candidate.DeductionFailure = MakeDeductionFailureInfo(Context, Result,
7024  Info);
7025  return;
7026  }
7027 
7028  // Add the conversion function template specialization produced by
7029  // template argument deduction as a candidate.
7030  assert(Specialization && "Missing function template specialization?");
7031  AddConversionCandidate(Specialization, FoundDecl, ActingDC, From, ToType,
7032  CandidateSet, AllowObjCConversionOnExplicit,
7033  AllowResultConversion);
7034 }
7035 
7036 /// AddSurrogateCandidate - Adds a "surrogate" candidate function that
7037 /// converts the given @c Object to a function pointer via the
7038 /// conversion function @c Conversion, and then attempts to call it
7039 /// with the given arguments (C++ [over.call.object]p2-4). Proto is
7040 /// the type of function that we'll eventually be calling.
7042  DeclAccessPair FoundDecl,
7043  CXXRecordDecl *ActingContext,
7044  const FunctionProtoType *Proto,
7045  Expr *Object,
7046  ArrayRef<Expr *> Args,
7047  OverloadCandidateSet& CandidateSet) {
7048  if (!CandidateSet.isNewCandidate(Conversion))
7049  return;
7050 
7051  // Overload resolution is always an unevaluated context.
7054 
7055  OverloadCandidate &Candidate = CandidateSet.addCandidate(Args.size() + 1);
7056  Candidate.FoundDecl = FoundDecl;
7057  Candidate.Function = nullptr;
7058  Candidate.Surrogate = Conversion;
7059  Candidate.Viable = true;
7060  Candidate.IsSurrogate = true;
7061  Candidate.IgnoreObjectArgument = false;
7062  Candidate.ExplicitCallArguments = Args.size();
7063 
7064  // Determine the implicit conversion sequence for the implicit
7065  // object parameter.
7067  *this, CandidateSet.getLocation(), Object->getType(),
7068  Object->Classify(Context), Conversion, ActingContext);
7069  if (ObjectInit.isBad()) {
7070  Candidate.Viable = false;
7072  Candidate.Conversions[0] = ObjectInit;
7073  return;
7074  }
7075 
7076  // The first conversion is actually a user-defined conversion whose
7077  // first conversion is ObjectInit's standard conversion (which is
7078  // effectively a reference binding). Record it as such.
7079  Candidate.Conversions[0].setUserDefined();
7080  Candidate.Conversions[0].UserDefined.Before = ObjectInit.Standard;
7081  Candidate.Conversions[0].UserDefined.EllipsisConversion = false;
7082  Candidate.Conversions[0].UserDefined.HadMultipleCandidates = false;
7083  Candidate.Conversions[0].UserDefined.ConversionFunction = Conversion;
7084  Candidate.Conversions[0].UserDefined.FoundConversionFunction = FoundDecl;
7085  Candidate.Conversions[0].UserDefined.After
7086  = Candidate.Conversions[0].UserDefined.Before;
7087  Candidate.Conversions[0].UserDefined.After.setAsIdentityConversion();
7088 
7089  // Find the
7090  unsigned NumParams = Proto->getNumParams();
7091 
7092  // (C++ 13.3.2p2): A candidate function having fewer than m
7093  // parameters is viable only if it has an ellipsis in its parameter
7094  // list (8.3.5).
7095  if (Args.size() > NumParams && !Proto->isVariadic()) {
7096  Candidate.Viable = false;
7098  return;
7099  }
7100 
7101  // Function types don't have any default arguments, so just check if
7102  // we have enough arguments.
7103  if (Args.size() < NumParams) {
7104  // Not enough arguments.
7105  Candidate.Viable = false;
7107  return;
7108  }
7109 
7110  // Determine the implicit conversion sequences for each of the
7111  // arguments.
7112  for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
7113  if (ArgIdx < NumParams) {
7114  // (C++ 13.3.2p3): for F to be a viable function, there shall
7115  // exist for each argument an implicit conversion sequence
7116  // (13.3.3.1) that converts that argument to the corresponding
7117  // parameter of F.
7118  QualType ParamType = Proto->getParamType(ArgIdx);
7119  Candidate.Conversions[ArgIdx + 1]
7120  = TryCopyInitialization(*this, Args[ArgIdx], ParamType,
7121  /*SuppressUserConversions=*/false,
7122  /*InOverloadResolution=*/false,
7123  /*AllowObjCWritebackConversion=*/
7124  getLangOpts().ObjCAutoRefCount);
7125  if (Candidate.Conversions[ArgIdx + 1].isBad()) {
7126  Candidate.Viable = false;
7128  return;
7129  }
7130  } else {
7131  // (C++ 13.3.2p2): For the purposes of overload resolution, any
7132  // argument for which there is no corresponding parameter is
7133  // considered to ""match the ellipsis" (C+ 13.3.3.1.3).
7134  Candidate.Conversions[ArgIdx + 1].setEllipsis();
7135  }
7136  }
7137 
7138  if (EnableIfAttr *FailedAttr = CheckEnableIf(Conversion, None)) {
7139  Candidate.Viable = false;
7140  Candidate.FailureKind = ovl_fail_enable_if;
7141  Candidate.DeductionFailure.Data = FailedAttr;
7142  return;
7143  }
7144 }
7145 
7146 /// \brief Add overload candidates for overloaded operators that are
7147 /// member functions.
7148 ///
7149 /// Add the overloaded operator candidates that are member functions
7150 /// for the operator Op that was used in an operator expression such
7151 /// as "x Op y". , Args/NumArgs provides the operator arguments, and
7152 /// CandidateSet will store the added overload candidates. (C++
7153 /// [over.match.oper]).
7155  SourceLocation OpLoc,
7156  ArrayRef<Expr *> Args,
7157  OverloadCandidateSet& CandidateSet,
7158  SourceRange OpRange) {
7160 
7161  // C++ [over.match.oper]p3:
7162  // For a unary operator @ with an operand of a type whose
7163  // cv-unqualified version is T1, and for a binary operator @ with
7164  // a left operand of a type whose cv-unqualified version is T1 and
7165  // a right operand of a type whose cv-unqualified version is T2,
7166  // three sets of candidate functions, designated member
7167  // candidates, non-member candidates and built-in candidates, are
7168  // constructed as follows:
7169  QualType T1 = Args[0]->getType();
7170 
7171  // -- If T1 is a complete class type or a class currently being
7172  // defined, the set of member candidates is the result of the
7173  // qualified lookup of T1::operator@ (13.3.1.1.1); otherwise,
7174  // the set of member candidates is empty.
7175  if (const RecordType *T1Rec = T1->getAs<RecordType>()) {
7176  // Complete the type if it can be completed.
7177  if (!isCompleteType(OpLoc, T1) && !T1Rec->isBeingDefined())
7178  return;
7179  // If the type is neither complete nor being defined, bail out now.
7180  if (!T1Rec->getDecl()->getDefinition())
7181  return;
7182 
7183  LookupResult Operators(*this, OpName, OpLoc, LookupOrdinaryName);
7184  LookupQualifiedName(Operators, T1Rec->getDecl());
7185  Operators.suppressDiagnostics();
7186 
7187  for (LookupResult::iterator Oper = Operators.begin(),
7188  OperEnd = Operators.end();
7189  Oper != OperEnd;
7190  ++Oper)
7191  AddMethodCandidate(Oper.getPair(), Args[0]->getType(),
7192  Args[0]->Classify(Context), Args.slice(1),
7193  CandidateSet, /*SuppressUserConversions=*/false);
7194  }
7195 }
7196 
7197 /// AddBuiltinCandidate - Add a candidate for a built-in
7198 /// operator. ResultTy and ParamTys are the result and parameter types
7199 /// of the built-in candidate, respectively. Args and NumArgs are the
7200 /// arguments being passed to the candidate. IsAssignmentOperator
7201 /// should be true when this built-in candidate is an assignment
7202 /// operator. NumContextualBoolArguments is the number of arguments
7203 /// (at the beginning of the argument list) that will be contextually
7204 /// converted to bool.
7206  OverloadCandidateSet& CandidateSet,
7207  bool IsAssignmentOperator,
7208  unsigned NumContextualBoolArguments) {
7209  // Overload resolution is always an unevaluated context.
7212 
7213  // Add this candidate
7214  OverloadCandidate &Candidate = CandidateSet.addCandidate(Args.size());
7215  Candidate.FoundDecl = DeclAccessPair::make(nullptr, AS_none);
7216  Candidate.Function = nullptr;
7217  Candidate.IsSurrogate = false;
7218  Candidate.IgnoreObjectArgument = false;
7219  std::copy(ParamTys, ParamTys + Args.size(), Candidate.BuiltinParamTypes);
7220 
7221  // Determine the implicit conversion sequences for each of the
7222  // arguments.
7223  Candidate.Viable = true;
7224  Candidate.ExplicitCallArguments = Args.size();
7225  for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
7226  // C++ [over.match.oper]p4:
7227  // For the built-in assignment operators, conversions of the
7228  // left operand are restricted as follows:
7229  // -- no temporaries are introduced to hold the left operand, and
7230  // -- no user-defined conversions are applied to the left
7231  // operand to achieve a type match with the left-most
7232  // parameter of a built-in candidate.
7233  //
7234  // We block these conversions by turning off user-defined
7235  // conversions, since that is the only way that initialization of
7236  // a reference to a non-class type can occur from something that
7237  // is not of the same type.
7238  if (ArgIdx < NumContextualBoolArguments) {
7239  assert(ParamTys[ArgIdx] == Context.BoolTy &&
7240  "Contextual conversion to bool requires bool type");
7241  Candidate.Conversions[ArgIdx]
7242  = TryContextuallyConvertToBool(*this, Args[ArgIdx]);
7243  } else {
7244  Candidate.Conversions[ArgIdx]
7245  = TryCopyInitialization(*this, Args[ArgIdx], ParamTys[ArgIdx],
7246  ArgIdx == 0 && IsAssignmentOperator,
7247  /*InOverloadResolution=*/false,
7248  /*AllowObjCWritebackConversion=*/
7249  getLangOpts().ObjCAutoRefCount);
7250  }
7251  if (Candidate.Conversions[ArgIdx].isBad()) {
7252  Candidate.Viable = false;
7254  break;
7255  }
7256  }
7257 }
7258 
7259 namespace {
7260 
7261 /// BuiltinCandidateTypeSet - A set of types that will be used for the
7262 /// candidate operator functions for built-in operators (C++
7263 /// [over.built]). The types are separated into pointer types and
7264 /// enumeration types.
7265 class BuiltinCandidateTypeSet {
7266  /// TypeSet - A set of types.
7267  typedef llvm::SetVector<QualType, SmallVector<QualType, 8>,
7268  llvm::SmallPtrSet<QualType, 8>> TypeSet;
7269 
7270  /// PointerTypes - The set of pointer types that will be used in the
7271  /// built-in candidates.
7272  TypeSet PointerTypes;
7273 
7274  /// MemberPointerTypes - The set of member pointer types that will be
7275  /// used in the built-in candidates.
7276  TypeSet MemberPointerTypes;
7277 
7278  /// EnumerationTypes - The set of enumeration types that will be
7279  /// used in the built-in candidates.
7280  TypeSet EnumerationTypes;
7281 
7282  /// \brief The set of vector types that will be used in the built-in
7283  /// candidates.
7284  TypeSet VectorTypes;
7285 
7286  /// \brief A flag indicating non-record types are viable candidates
7287  bool HasNonRecordTypes;
7288 
7289  /// \brief A flag indicating whether either arithmetic or enumeration types
7290  /// were present in the candidate set.
7291  bool HasArithmeticOrEnumeralTypes;
7292 
7293  /// \brief A flag indicating whether the nullptr type was present in the
7294  /// candidate set.
7295  bool HasNullPtrType;
7296 
7297  /// Sema - The semantic analysis instance where we are building the
7298  /// candidate type set.
7299  Sema &SemaRef;
7300 
7301  /// Context - The AST context in which we will build the type sets.
7302  ASTContext &Context;
7303 
7304  bool AddPointerWithMoreQualifiedTypeVariants(QualType Ty,
7305  const Qualifiers &VisibleQuals);
7306  bool AddMemberPointerWithMoreQualifiedTypeVariants(QualType Ty);
7307 
7308 public:
7309  /// iterator - Iterates through the types that are part of the set.
7310  typedef TypeSet::iterator iterator;
7311 
7312  BuiltinCandidateTypeSet(Sema &SemaRef)
7313  : HasNonRecordTypes(false),
7314  HasArithmeticOrEnumeralTypes(false),
7315  HasNullPtrType(false),
7316  SemaRef(SemaRef),
7317  Context(SemaRef.Context) { }
7318 
7319  void AddTypesConvertedFrom(QualType Ty,
7320  SourceLocation Loc,
7321  bool AllowUserConversions,
7322  bool AllowExplicitConversions,
7323  const Qualifiers &VisibleTypeConversionsQuals);
7324 
7325  /// pointer_begin - First pointer type found;
7326  iterator pointer_begin() { return PointerTypes.begin(); }
7327 
7328  /// pointer_end - Past the last pointer type found;
7329  iterator pointer_end() { return PointerTypes.end(); }
7330 
7331  /// member_pointer_begin - First member pointer type found;
7332  iterator member_pointer_begin() { return MemberPointerTypes.begin(); }
7333 
7334  /// member_pointer_end - Past the last member pointer type found;
7335  iterator member_pointer_end() { return MemberPointerTypes.end(); }
7336 
7337  /// enumeration_begin - First enumeration type found;
7338  iterator enumeration_begin() { return EnumerationTypes.begin(); }
7339 
7340  /// enumeration_end - Past the last enumeration type found;
7341  iterator enumeration_end() { return EnumerationTypes.end(); }
7342 
7343  iterator vector_begin() { return VectorTypes.begin(); }
7344  iterator vector_end() { return VectorTypes.end(); }
7345 
7346  bool hasNonRecordTypes() { return HasNonRecordTypes; }
7347  bool hasArithmeticOrEnumeralTypes() { return HasArithmeticOrEnumeralTypes; }
7348  bool hasNullPtrType() const { return HasNullPtrType; }
7349 };
7350 
7351 } // end anonymous namespace
7352 
7353 /// AddPointerWithMoreQualifiedTypeVariants - Add the pointer type @p Ty to
7354 /// the set of pointer types along with any more-qualified variants of
7355 /// that type. For example, if @p Ty is "int const *", this routine
7356 /// will add "int const *", "int const volatile *", "int const
7357 /// restrict *", and "int const volatile restrict *" to the set of
7358 /// pointer types. Returns true if the add of @p Ty itself succeeded,
7359 /// false otherwise.
7360 ///
7361 /// FIXME: what to do about extended qualifiers?
7362 bool
7363 BuiltinCandidateTypeSet::AddPointerWithMoreQualifiedTypeVariants(QualType Ty,
7364  const Qualifiers &VisibleQuals) {
7365 
7366  // Insert this type.
7367  if (!PointerTypes.insert(Ty))
7368  return false;
7369 
7370  QualType PointeeTy;
7371  const PointerType *PointerTy = Ty->getAs<PointerType>();
7372  bool buildObjCPtr = false;
7373  if (!PointerTy) {
7375  PointeeTy = PTy->getPointeeType();
7376  buildObjCPtr = true;
7377  } else {
7378  PointeeTy = PointerTy->getPointeeType();
7379  }
7380 
7381  // Don't add qualified variants of arrays. For one, they're not allowed
7382  // (the qualifier would sink to the element type), and for another, the
7383  // only overload situation where it matters is subscript or pointer +- int,
7384  // and those shouldn't have qualifier variants anyway.
7385  if (PointeeTy->isArrayType())
7386  return true;
7387 
7388  unsigned BaseCVR = PointeeTy.getCVRQualifiers();
7389  bool hasVolatile = VisibleQuals.hasVolatile();
7390  bool hasRestrict = VisibleQuals.hasRestrict();
7391 
7392  // Iterate through all strict supersets of BaseCVR.
7393  for (unsigned CVR = BaseCVR+1; CVR <= Qualifiers::CVRMask; ++CVR) {
7394  if ((CVR | BaseCVR) != CVR) continue;
7395  // Skip over volatile if no volatile found anywhere in the types.
7396  if ((CVR & Qualifiers::Volatile) && !hasVolatile) continue;
7397 
7398  // Skip over restrict if no restrict found anywhere in the types, or if
7399  // the type cannot be restrict-qualified.
7400  if ((CVR & Qualifiers::Restrict) &&
7401  (!hasRestrict ||
7402  (!(PointeeTy->isAnyPointerType() || PointeeTy->isReferenceType()))))
7403  continue;
7404 
7405  // Build qualified pointee type.
7406  QualType QPointeeTy = Context.getCVRQualifiedType(PointeeTy, CVR);
7407 
7408  // Build qualified pointer type.
7409  QualType QPointerTy;
7410  if (!buildObjCPtr)
7411  QPointerTy = Context.getPointerType(QPointeeTy);
7412  else
7413  QPointerTy = Context.getObjCObjectPointerType(QPointeeTy);
7414 
7415  // Insert qualified pointer type.
7416  PointerTypes.insert(QPointerTy);
7417  }
7418 
7419  return true;
7420 }
7421 
7422 /// AddMemberPointerWithMoreQualifiedTypeVariants - Add the pointer type @p Ty
7423 /// to the set of pointer types along with any more-qualified variants of
7424 /// that type. For example, if @p Ty is "int const *", this routine
7425 /// will add "int const *", "int const volatile *", "int const
7426 /// restrict *", and "int const volatile restrict *" to the set of
7427 /// pointer types. Returns true if the add of @p Ty itself succeeded,
7428 /// false otherwise.
7429 ///
7430 /// FIXME: what to do about extended qualifiers?
7431 bool
7432 BuiltinCandidateTypeSet::AddMemberPointerWithMoreQualifiedTypeVariants(
7433  QualType Ty) {
7434  // Insert this type.
7435  if (!MemberPointerTypes.insert(Ty))
7436  return false;
7437 
7438  const MemberPointerType *PointerTy = Ty->getAs<MemberPointerType>();
7439  assert(PointerTy && "type was not a member pointer type!");
7440 
7441  QualType PointeeTy = PointerTy->getPointeeType();
7442  // Don't add qualified variants of arrays. For one, they're not allowed
7443  // (the qualifier would sink to the element type), and for another, the
7444  // only overload situation where it matters is subscript or pointer +- int,
7445  // and those shouldn't have qualifier variants anyway.
7446  if (PointeeTy->isArrayType())
7447  return true;
7448  const Type *ClassTy = PointerTy->getClass();
7449 
7450  // Iterate through all strict supersets of the pointee type's CVR
7451  // qualifiers.
7452  unsigned BaseCVR = PointeeTy.getCVRQualifiers();
7453  for (unsigned CVR = BaseCVR+1; CVR <= Qualifiers::CVRMask; ++CVR) {
7454  if ((CVR | BaseCVR) != CVR) continue;
7455 
7456  QualType QPointeeTy = Context.getCVRQualifiedType(PointeeTy, CVR);
7457  MemberPointerTypes.insert(
7458  Context.getMemberPointerType(QPointeeTy, ClassTy));
7459  }
7460 
7461  return true;
7462 }
7463 
7464 /// AddTypesConvertedFrom - Add each of the types to which the type @p
7465 /// Ty can be implicit converted to the given set of @p Types. We're
7466 /// primarily interested in pointer types and enumeration types. We also
7467 /// take member pointer types, for the conditional operator.
7468 /// AllowUserConversions is true if we should look at the conversion
7469 /// functions of a class type, and AllowExplicitConversions if we
7470 /// should also include the explicit conversion functions of a class
7471 /// type.
7472 void
7473 BuiltinCandidateTypeSet::AddTypesConvertedFrom(QualType Ty,
7474  SourceLocation Loc,
7475  bool AllowUserConversions,
7476  bool AllowExplicitConversions,
7477  const Qualifiers &VisibleQuals) {
7478  // Only deal with canonical types.
7479  Ty = Context.getCanonicalType(Ty);
7480 
7481  // Look through reference types; they aren't part of the type of an
7482  // expression for the purposes of conversions.
7483  if (const ReferenceType *RefTy = Ty->getAs<ReferenceType>())
7484  Ty = RefTy->getPointeeType();
7485 
7486  // If we're dealing with an array type, decay to the pointer.
7487  if (Ty->isArrayType())
7488  Ty = SemaRef.Context.getArrayDecayedType(Ty);
7489 
7490  // Otherwise, we don't care about qualifiers on the type.
7491  Ty = Ty.getLocalUnqualifiedType();
7492 
7493  // Flag if we ever add a non-record type.
7494  const RecordType *TyRec = Ty->getAs<RecordType>();
7495  HasNonRecordTypes = HasNonRecordTypes || !TyRec;
7496 
7497  // Flag if we encounter an arithmetic type.
7498  HasArithmeticOrEnumeralTypes =
7499  HasArithmeticOrEnumeralTypes || Ty->isArithmeticType();
7500 
7501  if (Ty->isObjCIdType() || Ty->isObjCClassType())
7502  PointerTypes.insert(Ty);
7503  else if (Ty->getAs<PointerType>() || Ty->getAs<ObjCObjectPointerType>()) {
7504  // Insert our type, and its more-qualified variants, into the set
7505  // of types.
7506  if (!AddPointerWithMoreQualifiedTypeVariants(Ty, VisibleQuals))
7507  return;
7508  } else if (Ty->isMemberPointerType()) {
7509  // Member pointers are far easier, since the pointee can't be converted.
7510  if (!AddMemberPointerWithMoreQualifiedTypeVariants(Ty))
7511  return;
7512  } else if (Ty->isEnumeralType()) {
7513  HasArithmeticOrEnumeralTypes = true;
7514  EnumerationTypes.insert(Ty);
7515  } else if (Ty->isVectorType()) {
7516  // We treat vector types as arithmetic types in many contexts as an
7517  // extension.
7518  HasArithmeticOrEnumeralTypes = true;
7519  VectorTypes.insert(Ty);
7520  } else if (Ty->isNullPtrType()) {
7521  HasNullPtrType = true;
7522  } else if (AllowUserConversions && TyRec) {
7523  // No conversion functions in incomplete types.
7524  if (!SemaRef.isCompleteType(Loc, Ty))
7525  return;
7526 
7527  CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(TyRec->getDecl());
7528  for (NamedDecl *D : ClassDecl->getVisibleConversionFunctions()) {
7529  if (isa<UsingShadowDecl>(D))
7530  D = cast<UsingShadowDecl>(D)->getTargetDecl();
7531 
7532  // Skip conversion function templates; they don't tell us anything
7533  // about which builtin types we can convert to.
7534  if (isa<FunctionTemplateDecl>(D))
7535  continue;
7536 
7537  CXXConversionDecl *Conv = cast<CXXConversionDecl>(D);
7538  if (AllowExplicitConversions || !Conv->isExplicit()) {
7539  AddTypesConvertedFrom(Conv->getConversionType(), Loc, false, false,
7540  VisibleQuals);
7541  }
7542  }
7543  }
7544 }
7545 
7546 /// \brief Helper function for AddBuiltinOperatorCandidates() that adds
7547 /// the volatile- and non-volatile-qualified assignment operators for the
7548 /// given type to the candidate set.
7550  QualType T,
7551  ArrayRef<Expr *> Args,
7552  OverloadCandidateSet &CandidateSet) {
7553  QualType ParamTypes[2];
7554 
7555  // T& operator=(T&, T)
7556  ParamTypes[0] = S.Context.getLValueReferenceType(T);
7557  ParamTypes[1] = T;
7558  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
7559  /*IsAssignmentOperator=*/true);
7560 
7562  // volatile T& operator=(volatile T&, T)
7563  ParamTypes[0]
7565  ParamTypes[1] = T;
7566  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
7567  /*IsAssignmentOperator=*/true);
7568  }
7569 }
7570 
7571 /// CollectVRQualifiers - This routine returns Volatile/Restrict qualifiers,
7572 /// if any, found in visible type conversion functions found in ArgExpr's type.
7573 static Qualifiers CollectVRQualifiers(ASTContext &Context, Expr* ArgExpr) {
7574  Qualifiers VRQuals;
7575  const RecordType *TyRec;
7576  if (const MemberPointerType *RHSMPType =
7577  ArgExpr->getType()->getAs<MemberPointerType>())
7578  TyRec = RHSMPType->getClass()->getAs<RecordType>();
7579  else
7580  TyRec = ArgExpr->getType()->getAs<RecordType>();
7581  if (!TyRec) {
7582  // Just to be safe, assume the worst case.
7583  VRQuals.addVolatile();
7584  VRQuals.addRestrict();
7585  return VRQuals;
7586  }
7587 
7588  CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(TyRec->getDecl());
7589  if (!ClassDecl->hasDefinition())
7590  return VRQuals;
7591 
7592  for (NamedDecl *D : ClassDecl->getVisibleConversionFunctions()) {
7593  if (isa<UsingShadowDecl>(D))
7594  D = cast<UsingShadowDecl>(D)->getTargetDecl();
7595  if (CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(D)) {
7596  QualType CanTy = Context.getCanonicalType(Conv->getConversionType());
7597  if (const ReferenceType *ResTypeRef = CanTy->getAs<ReferenceType>())
7598  CanTy = ResTypeRef->getPointeeType();
7599  // Need to go down the pointer/mempointer chain and add qualifiers
7600  // as see them.
7601  bool done = false;
7602  while (!done) {
7603  if (CanTy.isRestrictQualified())
7604  VRQuals.addRestrict();
7605  if (const PointerType *ResTypePtr = CanTy->getAs<PointerType>())
7606  CanTy = ResTypePtr->getPointeeType();
7607  else if (const MemberPointerType *ResTypeMPtr =
7608  CanTy->getAs<MemberPointerType>())
7609  CanTy = ResTypeMPtr->getPointeeType();
7610  else
7611  done = true;
7612  if (CanTy.isVolatileQualified())
7613  VRQuals.addVolatile();
7614  if (VRQuals.hasRestrict() && VRQuals.hasVolatile())
7615  return VRQuals;
7616  }
7617  }
7618  }
7619  return VRQuals;
7620 }
7621 
7622 namespace {
7623 
7624 /// \brief Helper class to manage the addition of builtin operator overload
7625 /// candidates. It provides shared state and utility methods used throughout
7626 /// the process, as well as a helper method to add each group of builtin
7627 /// operator overloads from the standard to a candidate set.
7628 class BuiltinOperatorOverloadBuilder {
7629  // Common instance state available to all overload candidate addition methods.
7630  Sema &S;
7631  ArrayRef<Expr *> Args;
7632  Qualifiers VisibleTypeConversionsQuals;
7633  bool HasArithmeticOrEnumeralCandidateType;
7635  OverloadCandidateSet &CandidateSet;
7636 
7637  static constexpr int ArithmeticTypesCap = 24;
7639 
7640  // Define some indices used to iterate over the arithemetic types in
7641  // ArithmeticTypes. The "promoted arithmetic types" are the arithmetic
7642  // types are that preserved by promotion (C++ [over.built]p2).
7643  unsigned FirstIntegralType,
7644  LastIntegralType;
7645  unsigned FirstPromotedIntegralType,
7646  LastPromotedIntegralType;
7647  unsigned FirstPromotedArithmeticType,
7648  LastPromotedArithmeticType;
7649  unsigned NumArithmeticTypes;
7650 
7651  void InitArithmeticTypes() {
7652  // Start of promoted types.
7653  FirstPromotedArithmeticType = 0;
7654  ArithmeticTypes.push_back(S.Context.FloatTy);
7655  ArithmeticTypes.push_back(S.Context.DoubleTy);
7656  ArithmeticTypes.push_back(S.Context.LongDoubleTy);
7658  ArithmeticTypes.push_back(S.Context.Float128Ty);
7659 
7660  // Start of integral types.
7661  FirstIntegralType = ArithmeticTypes.size();
7662  FirstPromotedIntegralType = ArithmeticTypes.size();
7663  ArithmeticTypes.push_back(S.Context.IntTy);
7664  ArithmeticTypes.push_back(S.Context.LongTy);
7665  ArithmeticTypes.push_back(S.Context.LongLongTy);
7667  ArithmeticTypes.push_back(S.Context.Int128Ty);
7668  ArithmeticTypes.push_back(S.Context.UnsignedIntTy);
7669  ArithmeticTypes.push_back(S.Context.UnsignedLongTy);
7670  ArithmeticTypes.push_back(S.Context.UnsignedLongLongTy);
7672  ArithmeticTypes.push_back(S.Context.UnsignedInt128Ty);
7673  LastPromotedIntegralType = ArithmeticTypes.size();
7674  LastPromotedArithmeticType = ArithmeticTypes.size();
7675  // End of promoted types.
7676 
7677  ArithmeticTypes.push_back(S.Context.BoolTy);
7678  ArithmeticTypes.push_back(S.Context.CharTy);
7679  ArithmeticTypes.push_back(S.Context.WCharTy);
7680  ArithmeticTypes.push_back(S.Context.Char16Ty);
7681  ArithmeticTypes.push_back(S.Context.Char32Ty);
7682  ArithmeticTypes.push_back(S.Context.SignedCharTy);
7683  ArithmeticTypes.push_back(S.Context.ShortTy);
7684  ArithmeticTypes.push_back(S.Context.UnsignedCharTy);
7685  ArithmeticTypes.push_back(S.Context.UnsignedShortTy);
7686  LastIntegralType = ArithmeticTypes.size();
7687  NumArithmeticTypes = ArithmeticTypes.size();
7688  // End of integral types.
7689  // FIXME: What about complex? What about half?
7690 
7691  assert(ArithmeticTypes.size() <= ArithmeticTypesCap &&
7692  "Enough inline storage for all arithmetic types.");
7693  }
7694 
7695  /// \brief Helper method to factor out the common pattern of adding overloads
7696  /// for '++' and '--' builtin operators.
7697  void addPlusPlusMinusMinusStyleOverloads(QualType CandidateTy,
7698  bool HasVolatile,
7699  bool HasRestrict) {
7700  QualType ParamTypes[2] = {
7701  S.Context.getLValueReferenceType(CandidateTy),
7702  S.Context.IntTy
7703  };
7704 
7705  // Non-volatile version.
7706  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
7707 
7708  // Use a heuristic to reduce number of builtin candidates in the set:
7709  // add volatile version only if there are conversions to a volatile type.
7710  if (HasVolatile) {
7711  ParamTypes[0] =
7713  S.Context.getVolatileType(CandidateTy));
7714  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
7715  }
7716 
7717  // Add restrict version only if there are conversions to a restrict type
7718  // and our candidate type is a non-restrict-qualified pointer.
7719  if (HasRestrict && CandidateTy->isAnyPointerType() &&
7720  !CandidateTy.isRestrictQualified()) {
7721  ParamTypes[0]
7724  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
7725 
7726  if (HasVolatile) {
7727  ParamTypes[0]
7729  S.Context.getCVRQualifiedType(CandidateTy,
7732  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
7733  }
7734  }
7735 
7736  }
7737 
7738 public:
7739  BuiltinOperatorOverloadBuilder(
7740  Sema &S, ArrayRef<Expr *> Args,
7741  Qualifiers VisibleTypeConversionsQuals,
7742  bool HasArithmeticOrEnumeralCandidateType,
7744  OverloadCandidateSet &CandidateSet)
7745  : S(S), Args(Args),
7746  VisibleTypeConversionsQuals(VisibleTypeConversionsQuals),
7747  HasArithmeticOrEnumeralCandidateType(
7748  HasArithmeticOrEnumeralCandidateType),
7749  CandidateTypes(CandidateTypes),
7750  CandidateSet(CandidateSet) {
7751 
7752  InitArithmeticTypes();
7753  }
7754 
7755  // C++ [over.built]p3:
7756  //
7757  // For every pair (T, VQ), where T is an arithmetic type, and VQ
7758  // is either volatile or empty, there exist candidate operator
7759  // functions of the form
7760  //
7761  // VQ T& operator++(VQ T&);
7762  // T operator++(VQ T&, int);
7763  //
7764  // C++ [over.built]p4:
7765  //
7766  // For every pair (T, VQ), where T is an arithmetic type other
7767  // than bool, and VQ is either volatile or empty, there exist
7768  // candidate operator functions of the form
7769  //
7770  // VQ T& operator--(VQ T&);
7771  // T operator--(VQ T&, int);
7772  void addPlusPlusMinusMinusArithmeticOverloads(OverloadedOperatorKind Op) {
7773  if (!HasArithmeticOrEnumeralCandidateType)
7774  return;
7775 
7776  for (unsigned Arith = (Op == OO_PlusPlus? 0 : 1);
7777  Arith < NumArithmeticTypes; ++Arith) {
7778  addPlusPlusMinusMinusStyleOverloads(
7779  ArithmeticTypes[Arith],
7780  VisibleTypeConversionsQuals.hasVolatile(),
7781  VisibleTypeConversionsQuals.hasRestrict());
7782  }
7783  }
7784 
7785  // C++ [over.built]p5:
7786  //
7787  // For every pair (T, VQ), where T is a cv-qualified or
7788  // cv-unqualified object type, and VQ is either volatile or
7789  // empty, there exist candidate operator functions of the form
7790  //
7791  // T*VQ& operator++(T*VQ&);
7792  // T*VQ& operator--(T*VQ&);
7793  // T* operator++(T*VQ&, int);
7794  // T* operator--(T*VQ&, int);
7795  void addPlusPlusMinusMinusPointerOverloads() {
7796  for (BuiltinCandidateTypeSet::iterator
7797  Ptr = CandidateTypes[0].pointer_begin(),
7798  PtrEnd = CandidateTypes[0].pointer_end();
7799  Ptr != PtrEnd; ++Ptr) {
7800  // Skip pointer types that aren't pointers to object types.
7801  if (!(*Ptr)->getPointeeType()->isObjectType())
7802  continue;
7803 
7804  addPlusPlusMinusMinusStyleOverloads(*Ptr,
7805  (!(*Ptr).isVolatileQualified() &&
7806  VisibleTypeConversionsQuals.hasVolatile()),
7807  (!(*Ptr).isRestrictQualified() &&
7808  VisibleTypeConversionsQuals.hasRestrict()));
7809  }
7810  }
7811 
7812  // C++ [over.built]p6:
7813  // For every cv-qualified or cv-unqualified object type T, there
7814  // exist candidate operator functions of the form
7815  //
7816  // T& operator*(T*);
7817  //
7818  // C++ [over.built]p7:
7819  // For every function type T that does not have cv-qualifiers or a
7820  // ref-qualifier, there exist candidate operator functions of the form
7821  // T& operator*(T*);
7822  void addUnaryStarPointerOverloads() {
7823  for (BuiltinCandidateTypeSet::iterator
7824  Ptr = CandidateTypes[0].pointer_begin(),
7825  PtrEnd = CandidateTypes[0].pointer_end();
7826  Ptr != PtrEnd; ++Ptr) {
7827  QualType ParamTy = *Ptr;
7828  QualType PointeeTy = ParamTy->getPointeeType();
7829  if (!PointeeTy->isObjectType() && !PointeeTy->isFunctionType())
7830  continue;
7831 
7832  if (const FunctionProtoType *Proto =PointeeTy->getAs<FunctionProtoType>())
7833  if (Proto->getTypeQuals() || Proto->getRefQualifier())
7834  continue;
7835 
7836  S.AddBuiltinCandidate(&ParamTy, Args, CandidateSet);
7837  }
7838  }
7839 
7840  // C++ [over.built]p9:
7841  // For every promoted arithmetic type T, there exist candidate
7842  // operator functions of the form
7843  //
7844  // T operator+(T);
7845  // T operator-(T);
7846  void addUnaryPlusOrMinusArithmeticOverloads() {
7847  if (!HasArithmeticOrEnumeralCandidateType)
7848  return;
7849 
7850  for (unsigned Arith = FirstPromotedArithmeticType;
7851  Arith < LastPromotedArithmeticType; ++Arith) {
7852  QualType ArithTy = ArithmeticTypes[Arith];
7853  S.AddBuiltinCandidate(&ArithTy, Args, CandidateSet);
7854  }
7855 
7856  // Extension: We also add these operators for vector types.
7857  for (BuiltinCandidateTypeSet::iterator
7858  Vec = CandidateTypes[0].vector_begin(),
7859  VecEnd = CandidateTypes[0].vector_end();
7860  Vec != VecEnd; ++Vec) {
7861  QualType VecTy = *Vec;
7862  S.AddBuiltinCandidate(&VecTy, Args, CandidateSet);
7863  }
7864  }
7865 
7866  // C++ [over.built]p8:
7867  // For every type T, there exist candidate operator functions of
7868  // the form
7869  //
7870  // T* operator+(T*);
7871  void addUnaryPlusPointerOverloads() {
7872  for (BuiltinCandidateTypeSet::iterator
7873  Ptr = CandidateTypes[0].pointer_begin(),
7874  PtrEnd = CandidateTypes[0].pointer_end();
7875  Ptr != PtrEnd; ++Ptr) {
7876  QualType ParamTy = *Ptr;
7877  S.AddBuiltinCandidate(&ParamTy, Args, CandidateSet);
7878  }
7879  }
7880 
7881  // C++ [over.built]p10:
7882  // For every promoted integral type T, there exist candidate
7883  // operator functions of the form
7884  //
7885  // T operator~(T);
7886  void addUnaryTildePromotedIntegralOverloads() {
7887  if (!HasArithmeticOrEnumeralCandidateType)
7888  return;
7889 
7890  for (unsigned Int = FirstPromotedIntegralType;
7891  Int < LastPromotedIntegralType; ++Int) {
7892  QualType IntTy = ArithmeticTypes[Int];
7893  S.AddBuiltinCandidate(&IntTy, Args, CandidateSet);
7894  }
7895 
7896  // Extension: We also add this operator for vector types.
7897  for (BuiltinCandidateTypeSet::iterator
7898  Vec = CandidateTypes[0].vector_begin(),
7899  VecEnd = CandidateTypes[0].vector_end();
7900  Vec != VecEnd; ++Vec) {
7901  QualType VecTy = *Vec;
7902  S.AddBuiltinCandidate(&VecTy, Args, CandidateSet);
7903  }
7904  }
7905 
7906  // C++ [over.match.oper]p16:
7907  // For every pointer to member type T or type std::nullptr_t, there
7908  // exist candidate operator functions of the form
7909  //
7910  // bool operator==(T,T);
7911  // bool operator!=(T,T);
7912  void addEqualEqualOrNotEqualMemberPointerOrNullptrOverloads() {
7913  /// Set of (canonical) types that we've already handled.
7914  llvm::SmallPtrSet<QualType, 8> AddedTypes;
7915 
7916  for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
7917  for (BuiltinCandidateTypeSet::iterator
7918  MemPtr = CandidateTypes[ArgIdx].member_pointer_begin(),
7919  MemPtrEnd = CandidateTypes[ArgIdx].member_pointer_end();
7920  MemPtr != MemPtrEnd;
7921  ++MemPtr) {
7922  // Don't add the same builtin candidate twice.
7923  if (!AddedTypes.insert(S.Context.getCanonicalType(*MemPtr)).second)
7924  continue;
7925 
7926  QualType ParamTypes[2] = { *MemPtr, *MemPtr };
7927  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
7928  }
7929 
7930  if (CandidateTypes[ArgIdx].hasNullPtrType()) {
7932  if (AddedTypes.insert(NullPtrTy).second) {
7933  QualType ParamTypes[2] = { NullPtrTy, NullPtrTy };
7934  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
7935  }
7936  }
7937  }
7938  }
7939 
7940  // C++ [over.built]p15:
7941  //
7942  // For every T, where T is an enumeration type or a pointer type,
7943  // there exist candidate operator functions of the form
7944  //
7945  // bool operator<(T, T);
7946  // bool operator>(T, T);
7947  // bool operator<=(T, T);
7948  // bool operator>=(T, T);
7949  // bool operator==(T, T);
7950  // bool operator!=(T, T);
7951  void addRelationalPointerOrEnumeralOverloads() {
7952  // C++ [over.match.oper]p3:
7953  // [...]the built-in candidates include all of the candidate operator
7954  // functions defined in 13.6 that, compared to the given operator, [...]
7955  // do not have the same parameter-type-list as any non-template non-member
7956  // candidate.
7957  //
7958  // Note that in practice, this only affects enumeration types because there
7959  // aren't any built-in candidates of record type, and a user-defined operator
7960  // must have an operand of record or enumeration type. Also, the only other
7961  // overloaded operator with enumeration arguments, operator=,
7962  // cannot be overloaded for enumeration types, so this is the only place
7963  // where we must suppress candidates like this.
7965  UserDefinedBinaryOperators;
7966 
7967  for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
7968  if (CandidateTypes[ArgIdx].enumeration_begin() !=
7969  CandidateTypes[ArgIdx].enumeration_end()) {
7970  for (OverloadCandidateSet::iterator C = CandidateSet.begin(),
7971  CEnd = CandidateSet.end();
7972  C != CEnd; ++C) {
7973  if (!C->Viable || !C->Function || C->Function->getNumParams() != 2)
7974  continue;
7975 
7976  if (C->Function->isFunctionTemplateSpecialization())
7977  continue;
7978 
7979  QualType FirstParamType =
7980  C->Function->getParamDecl(0)->getType().getUnqualifiedType();
7981  QualType SecondParamType =
7982  C->Function->getParamDecl(1)->getType().getUnqualifiedType();
7983 
7984  // Skip if either parameter isn't of enumeral type.
7985  if (!FirstParamType->isEnumeralType() ||
7986  !SecondParamType->isEnumeralType())
7987  continue;
7988 
7989  // Add this operator to the set of known user-defined operators.
7990  UserDefinedBinaryOperators.insert(
7991  std::make_pair(S.Context.getCanonicalType(FirstParamType),
7992  S.Context.getCanonicalType(SecondParamType)));
7993  }
7994  }
7995  }
7996 
7997  /// Set of (canonical) types that we've already handled.
7998  llvm::SmallPtrSet<QualType, 8> AddedTypes;
7999 
8000  for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
8001  for (BuiltinCandidateTypeSet::iterator
8002  Ptr = CandidateTypes[ArgIdx].pointer_begin(),
8003  PtrEnd = CandidateTypes[ArgIdx].pointer_end();
8004  Ptr != PtrEnd; ++Ptr) {
8005  // Don't add the same builtin candidate twice.
8006  if (!AddedTypes.insert(S.Context.getCanonicalType(*Ptr)).second)
8007  continue;
8008 
8009  QualType ParamTypes[2] = { *Ptr, *Ptr };
8010  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8011  }
8012  for (BuiltinCandidateTypeSet::iterator
8013  Enum = CandidateTypes[ArgIdx].enumeration_begin(),
8014  EnumEnd = CandidateTypes[ArgIdx].enumeration_end();
8015  Enum != EnumEnd; ++Enum) {
8016  CanQualType CanonType = S.Context.getCanonicalType(*Enum);
8017 
8018  // Don't add the same builtin candidate twice, or if a user defined
8019  // candidate exists.
8020  if (!AddedTypes.insert(CanonType).second ||
8021  UserDefinedBinaryOperators.count(std::make_pair(CanonType,
8022  CanonType)))
8023  continue;
8024 
8025  QualType ParamTypes[2] = { *Enum, *Enum };
8026  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8027  }
8028  }
8029  }
8030 
8031  // C++ [over.built]p13:
8032  //
8033  // For every cv-qualified or cv-unqualified object type T
8034  // there exist candidate operator functions of the form
8035  //
8036  // T* operator+(T*, ptrdiff_t);
8037  // T& operator[](T*, ptrdiff_t); [BELOW]
8038  // T* operator-(T*, ptrdiff_t);
8039  // T* operator+(ptrdiff_t, T*);
8040  // T& operator[](ptrdiff_t, T*); [BELOW]
8041  //
8042  // C++ [over.built]p14:
8043  //
8044  // For every T, where T is a pointer to object type, there
8045  // exist candidate operator functions of the form
8046  //
8047  // ptrdiff_t operator-(T, T);
8048  void addBinaryPlusOrMinusPointerOverloads(OverloadedOperatorKind Op) {
8049  /// Set of (canonical) types that we've already handled.
8050  llvm::SmallPtrSet<QualType, 8> AddedTypes;
8051 
8052  for (int Arg = 0; Arg < 2; ++Arg) {
8053  QualType AsymmetricParamTypes[2] = {
8056  };
8057  for (BuiltinCandidateTypeSet::iterator
8058  Ptr = CandidateTypes[Arg].pointer_begin(),
8059  PtrEnd = CandidateTypes[Arg].pointer_end();
8060  Ptr != PtrEnd; ++Ptr) {
8061  QualType PointeeTy = (*Ptr)->getPointeeType();
8062  if (!PointeeTy->isObjectType())
8063  continue;
8064 
8065  AsymmetricParamTypes[Arg] = *Ptr;
8066  if (Arg == 0 || Op == OO_Plus) {
8067  // operator+(T*, ptrdiff_t) or operator-(T*, ptrdiff_t)
8068  // T* operator+(ptrdiff_t, T*);
8069  S.AddBuiltinCandidate(AsymmetricParamTypes, Args, CandidateSet);
8070  }
8071  if (Op == OO_Minus) {
8072  // ptrdiff_t operator-(T, T);
8073  if (!AddedTypes.insert(S.Context.getCanonicalType(*Ptr)).second)
8074  continue;
8075 
8076  QualType ParamTypes[2] = { *Ptr, *Ptr };
8077  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8078  }
8079  }
8080  }
8081  }
8082 
8083  // C++ [over.built]p12:
8084  //
8085  // For every pair of promoted arithmetic types L and R, there
8086  // exist candidate operator functions of the form
8087  //
8088  // LR operator*(L, R);
8089  // LR operator/(L, R);
8090  // LR operator+(L, R);
8091  // LR operator-(L, R);
8092  // bool operator<(L, R);
8093  // bool operator>(L, R);
8094  // bool operator<=(L, R);
8095  // bool operator>=(L, R);
8096  // bool operator==(L, R);
8097  // bool operator!=(L, R);
8098  //
8099  // where LR is the result of the usual arithmetic conversions
8100  // between types L and R.
8101  //
8102  // C++ [over.built]p24:
8103  //
8104  // For every pair of promoted arithmetic types L and R, there exist
8105  // candidate operator functions of the form
8106  //
8107  // LR operator?(bool, L, R);
8108  //
8109  // where LR is the result of the usual arithmetic conversions
8110  // between types L and R.
8111  // Our candidates ignore the first parameter.
8112  void addGenericBinaryArithmeticOverloads() {
8113  if (!HasArithmeticOrEnumeralCandidateType)
8114  return;
8115 
8116  for (unsigned Left = FirstPromotedArithmeticType;
8117  Left < LastPromotedArithmeticType; ++Left) {
8118  for (unsigned Right = FirstPromotedArithmeticType;
8119  Right < LastPromotedArithmeticType; ++Right) {
8120  QualType LandR[2] = { ArithmeticTypes[Left],
8121  ArithmeticTypes[Right] };
8122  S.AddBuiltinCandidate(LandR, Args, CandidateSet);
8123  }
8124  }
8125 
8126  // Extension: Add the binary operators ==, !=, <, <=, >=, >, *, /, and the
8127  // conditional operator for vector types.
8128  for (BuiltinCandidateTypeSet::iterator
8129  Vec1 = CandidateTypes[0].vector_begin(),
8130  Vec1End = CandidateTypes[0].vector_end();
8131  Vec1 != Vec1End; ++Vec1) {
8132  for (BuiltinCandidateTypeSet::iterator
8133  Vec2 = CandidateTypes[1].vector_begin(),
8134  Vec2End = CandidateTypes[1].vector_end();
8135  Vec2 != Vec2End; ++Vec2) {
8136  QualType LandR[2] = { *Vec1, *Vec2 };
8137  S.AddBuiltinCandidate(LandR, Args, CandidateSet);
8138  }
8139  }
8140  }
8141 
8142  // C++ [over.built]p17:
8143  //
8144  // For every pair of promoted integral types L and R, there
8145  // exist candidate operator functions of the form
8146  //
8147  // LR operator%(L, R);
8148  // LR operator&(L, R);
8149  // LR operator^(L, R);
8150  // LR operator|(L, R);
8151  // L operator<<(L, R);
8152  // L operator>>(L, R);
8153  //
8154  // where LR is the result of the usual arithmetic conversions
8155  // between types L and R.
8156  void addBinaryBitwiseArithmeticOverloads(OverloadedOperatorKind Op) {
8157  if (!HasArithmeticOrEnumeralCandidateType)
8158  return;
8159 
8160  for (unsigned Left = FirstPromotedIntegralType;
8161  Left < LastPromotedIntegralType; ++Left) {
8162  for (unsigned Right = FirstPromotedIntegralType;
8163  Right < LastPromotedIntegralType; ++Right) {
8164  QualType LandR[2] = { ArithmeticTypes[Left],
8165  ArithmeticTypes[Right] };
8166  S.AddBuiltinCandidate(LandR, Args, CandidateSet);
8167  }
8168  }
8169  }
8170 
8171  // C++ [over.built]p20:
8172  //
8173  // For every pair (T, VQ), where T is an enumeration or
8174  // pointer to member type and VQ is either volatile or
8175  // empty, there exist candidate operator functions of the form
8176  //
8177  // VQ T& operator=(VQ T&, T);
8178  void addAssignmentMemberPointerOrEnumeralOverloads() {
8179  /// Set of (canonical) types that we've already handled.
8180  llvm::SmallPtrSet<QualType, 8> AddedTypes;
8181 
8182  for (unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) {
8183  for (BuiltinCandidateTypeSet::iterator
8184  Enum = CandidateTypes[ArgIdx].enumeration_begin(),
8185  EnumEnd = CandidateTypes[ArgIdx].enumeration_end();
8186  Enum != EnumEnd; ++Enum) {
8187  if (!AddedTypes.insert(S.Context.getCanonicalType(*Enum)).second)
8188  continue;
8189 
8190  AddBuiltinAssignmentOperatorCandidates(S, *Enum, Args, CandidateSet);
8191  }
8192 
8193  for (BuiltinCandidateTypeSet::iterator
8194  MemPtr = CandidateTypes[ArgIdx].member_pointer_begin(),
8195  MemPtrEnd = CandidateTypes[ArgIdx].member_pointer_end();
8196  MemPtr != MemPtrEnd; ++MemPtr) {
8197  if (!AddedTypes.insert(S.Context.getCanonicalType(*MemPtr)).second)
8198  continue;
8199 
8200  AddBuiltinAssignmentOperatorCandidates(S, *MemPtr, Args, CandidateSet);
8201  }
8202  }
8203  }
8204 
8205  // C++ [over.built]p19:
8206  //
8207  // For every pair (T, VQ), where T is any type and VQ is either
8208  // volatile or empty, there exist candidate operator functions
8209  // of the form
8210  //
8211  // T*VQ& operator=(T*VQ&, T*);
8212  //
8213  // C++ [over.built]p21:
8214  //
8215  // For every pair (T, VQ), where T is a cv-qualified or
8216  // cv-unqualified object type and VQ is either volatile or
8217  // empty, there exist candidate operator functions of the form
8218  //
8219  // T*VQ& operator+=(T*VQ&, ptrdiff_t);
8220  // T*VQ& operator-=(T*VQ&, ptrdiff_t);
8221  void addAssignmentPointerOverloads(bool isEqualOp) {
8222  /// Set of (canonical) types that we've already handled.
8223  llvm::SmallPtrSet<QualType, 8> AddedTypes;
8224 
8225  for (BuiltinCandidateTypeSet::iterator
8226  Ptr = CandidateTypes[0].pointer_begin(),
8227  PtrEnd = CandidateTypes[0].pointer_end();
8228  Ptr != PtrEnd; ++Ptr) {
8229  // If this is operator=, keep track of the builtin candidates we added.
8230  if (isEqualOp)
8231  AddedTypes.insert(S.Context.getCanonicalType(*Ptr));
8232  else if (!(*Ptr)->getPointeeType()->isObjectType())
8233  continue;
8234 
8235  // non-volatile version
8236  QualType ParamTypes[2] = {
8238  isEqualOp ? *Ptr : S.Context.getPointerDiffType(),
8239  };
8240  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8241  /*IsAssigmentOperator=*/ isEqualOp);
8242 
8243  bool NeedVolatile = !(*Ptr).isVolatileQualified() &&
8244  VisibleTypeConversionsQuals.hasVolatile();
8245  if (NeedVolatile) {
8246  // volatile version
8247  ParamTypes[0] =
8249  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8250  /*IsAssigmentOperator=*/isEqualOp);
8251  }
8252 
8253  if (!(*Ptr).isRestrictQualified() &&
8254  VisibleTypeConversionsQuals.hasRestrict()) {
8255  // restrict version
8256  ParamTypes[0]
8258  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8259  /*IsAssigmentOperator=*/isEqualOp);
8260 
8261  if (NeedVolatile) {
8262  // volatile restrict version
8263  ParamTypes[0]
8268  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8269  /*IsAssigmentOperator=*/isEqualOp);
8270  }
8271  }
8272  }
8273 
8274  if (isEqualOp) {
8275  for (BuiltinCandidateTypeSet::iterator
8276  Ptr = CandidateTypes[1].pointer_begin(),
8277  PtrEnd = CandidateTypes[1].pointer_end();
8278  Ptr != PtrEnd; ++Ptr) {
8279  // Make sure we don't add the same candidate twice.
8280  if (!AddedTypes.insert(S.Context.getCanonicalType(*Ptr)).second)
8281  continue;
8282 
8283  QualType ParamTypes[2] = {
8285  *Ptr,
8286  };
8287 
8288  // non-volatile version
8289  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8290  /*IsAssigmentOperator=*/true);
8291 
8292  bool NeedVolatile = !(*Ptr).isVolatileQualified() &&
8293  VisibleTypeConversionsQuals.hasVolatile();
8294  if (NeedVolatile) {
8295  // volatile version
8296  ParamTypes[0] =
8298  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8299  /*IsAssigmentOperator=*/true);
8300  }
8301 
8302  if (!(*Ptr).isRestrictQualified() &&
8303  VisibleTypeConversionsQuals.hasRestrict()) {
8304  // restrict version
8305  ParamTypes[0]
8307  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8308  /*IsAssigmentOperator=*/true);
8309 
8310  if (NeedVolatile) {
8311  // volatile restrict version
8312  ParamTypes[0]
8317  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8318  /*IsAssigmentOperator=*/true);
8319  }
8320  }
8321  }
8322  }
8323  }
8324 
8325  // C++ [over.built]p18:
8326  //
8327  // For every triple (L, VQ, R), where L is an arithmetic type,
8328  // VQ is either volatile or empty, and R is a promoted
8329  // arithmetic type, there exist candidate operator functions of
8330  // the form
8331  //
8332  // VQ L& operator=(VQ L&, R);
8333  // VQ L& operator*=(VQ L&, R);
8334  // VQ L& operator/=(VQ L&, R);
8335  // VQ L& operator+=(VQ L&, R);
8336  // VQ L& operator-=(VQ L&, R);
8337  void addAssignmentArithmeticOverloads(bool isEqualOp) {
8338  if (!HasArithmeticOrEnumeralCandidateType)
8339  return;
8340 
8341  for (unsigned Left = 0; Left < NumArithmeticTypes; ++Left) {
8342  for (unsigned Right = FirstPromotedArithmeticType;
8343  Right < LastPromotedArithmeticType; ++Right) {
8344  QualType ParamTypes[2];
8345  ParamTypes[1] = ArithmeticTypes[Right];
8346 
8347  // Add this built-in operator as a candidate (VQ is empty).
8348  ParamTypes[0] =
8349  S.Context.getLValueReferenceType(ArithmeticTypes[Left]);
8350  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8351  /*IsAssigmentOperator=*/isEqualOp);
8352 
8353  // Add this built-in operator as a candidate (VQ is 'volatile').
8354  if (VisibleTypeConversionsQuals.hasVolatile()) {
8355  ParamTypes[0] =
8356  S.Context.getVolatileType(ArithmeticTypes[Left]);
8357  ParamTypes[0] = S.Context.getLValueReferenceType(ParamTypes[0]);
8358  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8359  /*IsAssigmentOperator=*/isEqualOp);
8360  }
8361  }
8362  }
8363 
8364  // Extension: Add the binary operators =, +=, -=, *=, /= for vector types.
8365  for (BuiltinCandidateTypeSet::iterator
8366  Vec1 = CandidateTypes[0].vector_begin(),
8367  Vec1End = CandidateTypes[0].vector_end();
8368  Vec1 != Vec1End; ++Vec1) {
8369  for (BuiltinCandidateTypeSet::iterator
8370  Vec2 = CandidateTypes[1].vector_begin(),
8371  Vec2End = CandidateTypes[1].vector_end();
8372  Vec2 != Vec2End; ++Vec2) {
8373  QualType ParamTypes[2];
8374  ParamTypes[1] = *Vec2;
8375  // Add this built-in operator as a candidate (VQ is empty).
8376  ParamTypes[0] = S.Context.getLValueReferenceType(*Vec1);
8377  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8378  /*IsAssigmentOperator=*/isEqualOp);
8379 
8380  // Add this built-in operator as a candidate (VQ is 'volatile').
8381  if (VisibleTypeConversionsQuals.hasVolatile()) {
8382  ParamTypes[0] = S.Context.getVolatileType(*Vec1);
8383  ParamTypes[0] = S.Context.getLValueReferenceType(ParamTypes[0]);
8384  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8385  /*IsAssigmentOperator=*/isEqualOp);
8386  }
8387  }
8388  }
8389  }
8390 
8391  // C++ [over.built]p22:
8392  //
8393  // For every triple (L, VQ, R), where L is an integral type, VQ
8394  // is either volatile or empty, and R is a promoted integral
8395  // type, there exist candidate operator functions of the form
8396  //
8397  // VQ L& operator%=(VQ L&, R);
8398  // VQ L& operator<<=(VQ L&, R);
8399  // VQ L& operator>>=(VQ L&, R);
8400  // VQ L& operator&=(VQ L&, R);
8401  // VQ L& operator^=(VQ L&, R);
8402  // VQ L& operator|=(VQ L&, R);
8403  void addAssignmentIntegralOverloads() {
8404  if (!HasArithmeticOrEnumeralCandidateType)
8405  return;
8406 
8407  for (unsigned Left = FirstIntegralType; Left < LastIntegralType; ++Left) {
8408  for (unsigned Right = FirstPromotedIntegralType;
8409  Right < LastPromotedIntegralType; ++Right) {
8410  QualType ParamTypes[2];
8411  ParamTypes[1] = ArithmeticTypes[Right];
8412 
8413  // Add this built-in operator as a candidate (VQ is empty).
8414  ParamTypes[0] =
8415  S.Context.getLValueReferenceType(ArithmeticTypes[Left]);
8416  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8417  if (VisibleTypeConversionsQuals.hasVolatile()) {
8418  // Add this built-in operator as a candidate (VQ is 'volatile').
8419  ParamTypes[0] = ArithmeticTypes[Left];
8420  ParamTypes[0] = S.Context.getVolatileType(ParamTypes[0]);
8421  ParamTypes[0] = S.Context.getLValueReferenceType(ParamTypes[0]);
8422  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8423  }
8424  }
8425  }
8426  }
8427 
8428  // C++ [over.operator]p23:
8429  //
8430  // There also exist candidate operator functions of the form
8431  //
8432  // bool operator!(bool);
8433  // bool operator&&(bool, bool);
8434  // bool operator||(bool, bool);
8435  void addExclaimOverload() {
8436  QualType ParamTy = S.Context.BoolTy;
8437  S.AddBuiltinCandidate(&ParamTy, Args, CandidateSet,
8438  /*IsAssignmentOperator=*/false,
8439  /*NumContextualBoolArguments=*/1);
8440  }
8441  void addAmpAmpOrPipePipeOverload() {
8442  QualType ParamTypes[2] = { S.Context.BoolTy, S.Context.BoolTy };
8443  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8444  /*IsAssignmentOperator=*/false,
8445  /*NumContextualBoolArguments=*/2);
8446  }
8447 
8448  // C++ [over.built]p13:
8449  //
8450  // For every cv-qualified or cv-unqualified object type T there
8451  // exist candidate operator functions of the form
8452  //
8453  // T* operator+(T*, ptrdiff_t); [ABOVE]
8454  // T& operator[](T*, ptrdiff_t);
8455  // T* operator-(T*, ptrdiff_t); [ABOVE]
8456  // T* operator+(ptrdiff_t, T*); [ABOVE]
8457  // T& operator[](ptrdiff_t, T*);
8458  void addSubscriptOverloads() {
8459  for (BuiltinCandidateTypeSet::iterator
8460  Ptr = CandidateTypes[0].pointer_begin(),
8461  PtrEnd = CandidateTypes[0].pointer_end();
8462  Ptr != PtrEnd; ++Ptr) {
8463  QualType ParamTypes[2] = { *Ptr, S.Context.getPointerDiffType() };
8464  QualType PointeeType = (*Ptr)->getPointeeType();
8465  if (!PointeeType->isObjectType())
8466  continue;
8467 
8468  // T& operator[](T*, ptrdiff_t)
8469  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8470  }
8471 
8472  for (BuiltinCandidateTypeSet::iterator
8473  Ptr = CandidateTypes[1].pointer_begin(),
8474  PtrEnd = CandidateTypes[1].pointer_end();
8475  Ptr != PtrEnd; ++Ptr) {
8476  QualType ParamTypes[2] = { S.Context.getPointerDiffType(), *Ptr };
8477  QualType PointeeType = (*Ptr)->getPointeeType();
8478  if (!PointeeType->isObjectType())
8479  continue;
8480 
8481  // T& operator[](ptrdiff_t, T*)
8482  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8483  }
8484  }
8485 
8486  // C++ [over.built]p11:
8487  // For every quintuple (C1, C2, T, CV1, CV2), where C2 is a class type,
8488  // C1 is the same type as C2 or is a derived class of C2, T is an object
8489  // type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
8490  // there exist candidate operator functions of the form
8491  //
8492  // CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
8493  //
8494  // where CV12 is the union of CV1 and CV2.
8495  void addArrowStarOverloads() {
8496  for (BuiltinCandidateTypeSet::iterator
8497  Ptr = CandidateTypes[0].pointer_begin(),
8498  PtrEnd = CandidateTypes[0].pointer_end();
8499  Ptr != PtrEnd; ++Ptr) {
8500  QualType C1Ty = (*Ptr);
8501  QualType C1;
8502  QualifierCollector Q1;
8503  C1 = QualType(Q1.strip(C1Ty->getPointeeType()), 0);
8504  if (!isa<RecordType>(C1))
8505  continue;
8506  // heuristic to reduce number of builtin candidates in the set.
8507  // Add volatile/restrict version only if there are conversions to a
8508  // volatile/restrict type.
8509  if (!VisibleTypeConversionsQuals.hasVolatile() && Q1.hasVolatile())
8510  continue;
8511  if (!VisibleTypeConversionsQuals.hasRestrict() && Q1.hasRestrict())
8512  continue;
8513  for (BuiltinCandidateTypeSet::iterator
8514  MemPtr = CandidateTypes[1].member_pointer_begin(),
8515  MemPtrEnd = CandidateTypes[1].member_pointer_end();
8516  MemPtr != MemPtrEnd; ++MemPtr) {
8517  const MemberPointerType *mptr = cast<MemberPointerType>(*MemPtr);
8518  QualType C2 = QualType(mptr->getClass(), 0);
8519  C2 = C2.getUnqualifiedType();
8520  if (C1 != C2 && !S.IsDerivedFrom(CandidateSet.getLocation(), C1, C2))
8521  break;
8522  QualType ParamTypes[2] = { *Ptr, *MemPtr };
8523  // build CV12 T&
8524  QualType T = mptr->getPointeeType();
8525  if (!VisibleTypeConversionsQuals.hasVolatile() &&
8526  T.isVolatileQualified())
8527  continue;
8528  if (!VisibleTypeConversionsQuals.hasRestrict() &&
8529  T.isRestrictQualified())
8530  continue;
8531  T = Q1.apply(S.Context, T);
8532  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8533  }
8534  }
8535  }
8536 
8537  // Note that we don't consider the first argument, since it has been
8538  // contextually converted to bool long ago. The candidates below are
8539  // therefore added as binary.
8540  //
8541  // C++ [over.built]p25:
8542  // For every type T, where T is a pointer, pointer-to-member, or scoped
8543  // enumeration type, there exist candidate operator functions of the form
8544  //
8545  // T operator?(bool, T, T);
8546  //
8547  void addConditionalOperatorOverloads() {
8548  /// Set of (canonical) types that we've already handled.
8549  llvm::SmallPtrSet<QualType, 8> AddedTypes;
8550 
8551  for (unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) {
8552  for (BuiltinCandidateTypeSet::iterator
8553  Ptr = CandidateTypes[ArgIdx].pointer_begin(),
8554  PtrEnd = CandidateTypes[ArgIdx].pointer_end();
8555  Ptr != PtrEnd; ++Ptr) {
8556  if (!AddedTypes.insert(S.Context.getCanonicalType(*Ptr)).second)
8557  continue;
8558 
8559  QualType ParamTypes[2] = { *Ptr, *Ptr };
8560  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8561  }
8562 
8563  for (BuiltinCandidateTypeSet::iterator
8564  MemPtr = CandidateTypes[ArgIdx].member_pointer_begin(),
8565  MemPtrEnd = CandidateTypes[ArgIdx].member_pointer_end();
8566  MemPtr != MemPtrEnd; ++MemPtr) {
8567  if (!AddedTypes.insert(S.Context.getCanonicalType(*MemPtr)).second)
8568  continue;
8569 
8570  QualType ParamTypes[2] = { *MemPtr, *MemPtr };
8571  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8572  }
8573 
8574  if (S.getLangOpts().CPlusPlus11) {
8575  for (BuiltinCandidateTypeSet::iterator
8576  Enum = CandidateTypes[ArgIdx].enumeration_begin(),
8577  EnumEnd = CandidateTypes[ArgIdx].enumeration_end();
8578  Enum != EnumEnd; ++Enum) {
8579  if (!(*Enum)->getAs<EnumType>()->getDecl()->isScoped())
8580  continue;
8581 
8582  if (!AddedTypes.insert(S.Context.getCanonicalType(*Enum)).second)
8583  continue;
8584 
8585  QualType ParamTypes[2] = { *Enum, *Enum };
8586  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8587  }
8588  }
8589  }
8590  }
8591 };
8592 
8593 } // end anonymous namespace
8594 
8595 /// AddBuiltinOperatorCandidates - Add the appropriate built-in
8596 /// operator overloads to the candidate set (C++ [over.built]), based
8597 /// on the operator @p Op and the arguments given. For example, if the
8598 /// operator is a binary '+', this routine might add "int
8599 /// operator+(int, int)" to cover integer addition.
8601  SourceLocation OpLoc,
8602  ArrayRef<Expr *> Args,
8603  OverloadCandidateSet &CandidateSet) {
8604  // Find all of the types that the arguments can convert to, but only
8605  // if the operator we're looking at has built-in operator candidates
8606  // that make use of these types. Also record whether we encounter non-record
8607  // candidate types or either arithmetic or enumeral candidate types.
8608  Qualifiers VisibleTypeConversionsQuals;
8609  VisibleTypeConversionsQuals.addConst();
8610  for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx)
8611  VisibleTypeConversionsQuals += CollectVRQualifiers(Context, Args[ArgIdx]);
8612 
8613  bool HasNonRecordCandidateType = false;
8614  bool HasArithmeticOrEnumeralCandidateType = false;
8616  for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
8617  CandidateTypes.emplace_back(*this);
8618  CandidateTypes[ArgIdx].AddTypesConvertedFrom(Args[ArgIdx]->getType(),
8619  OpLoc,
8620  true,
8621  (Op == OO_Exclaim ||
8622  Op == OO_AmpAmp ||
8623  Op == OO_PipePipe),
8624  VisibleTypeConversionsQuals);
8625  HasNonRecordCandidateType = HasNonRecordCandidateType ||
8626  CandidateTypes[ArgIdx].hasNonRecordTypes();
8627  HasArithmeticOrEnumeralCandidateType =
8628  HasArithmeticOrEnumeralCandidateType ||
8629  CandidateTypes[ArgIdx].hasArithmeticOrEnumeralTypes();
8630  }
8631 
8632  // Exit early when no non-record types have been added to the candidate set
8633  // for any of the arguments to the operator.
8634  //
8635  // We can't exit early for !, ||, or &&, since there we have always have
8636  // 'bool' overloads.
8637  if (!HasNonRecordCandidateType &&
8638  !(Op == OO_Exclaim || Op == OO_AmpAmp || Op == OO_PipePipe))
8639  return;
8640 
8641  // Setup an object to manage the common state for building overloads.
8642  BuiltinOperatorOverloadBuilder OpBuilder(*this, Args,
8643  VisibleTypeConversionsQuals,
8644  HasArithmeticOrEnumeralCandidateType,
8645  CandidateTypes, CandidateSet);
8646 
8647  // Dispatch over the operation to add in only those overloads which apply.
8648  switch (Op) {
8649  case OO_None:
8651  llvm_unreachable("Expected an overloaded operator");
8652 
8653  case OO_New:
8654  case OO_Delete:
8655  case OO_Array_New:
8656  case OO_Array_Delete:
8657  case OO_Call:
8658  llvm_unreachable(
8659  "Special operators don't use AddBuiltinOperatorCandidates");
8660 
8661  case OO_Comma:
8662  case OO_Arrow:
8663  case OO_Coawait:
8664  // C++ [over.match.oper]p3:
8665  // -- For the operator ',', the unary operator '&', the
8666  // operator '->', or the operator 'co_await', the
8667  // built-in candidates set is empty.
8668  break;
8669 
8670  case OO_Plus: // '+' is either unary or binary
8671  if (Args.size() == 1)
8672  OpBuilder.addUnaryPlusPointerOverloads();
8673  LLVM_FALLTHROUGH;
8674 
8675  case OO_Minus: // '-' is either unary or binary
8676  if (Args.size() == 1) {
8677  OpBuilder.addUnaryPlusOrMinusArithmeticOverloads();
8678  } else {
8679  OpBuilder.addBinaryPlusOrMinusPointerOverloads(Op);
8680  OpBuilder.addGenericBinaryArithmeticOverloads();
8681  }
8682  break;
8683 
8684  case OO_Star: // '*' is either unary or binary
8685  if (Args.size() == 1)
8686  OpBuilder.addUnaryStarPointerOverloads();
8687  else
8688  OpBuilder.addGenericBinaryArithmeticOverloads();
8689  break;
8690 
8691  case OO_Slash:
8692  OpBuilder.addGenericBinaryArithmeticOverloads();
8693  break;
8694 
8695  case OO_PlusPlus:
8696  case OO_MinusMinus:
8697  OpBuilder.addPlusPlusMinusMinusArithmeticOverloads(Op);
8698  OpBuilder.addPlusPlusMinusMinusPointerOverloads();
8699  break;
8700 
8701  case OO_EqualEqual:
8702  case OO_ExclaimEqual:
8703  OpBuilder.addEqualEqualOrNotEqualMemberPointerOrNullptrOverloads();
8704  LLVM_FALLTHROUGH;
8705 
8706  case OO_Less:
8707  case OO_Greater:
8708  case OO_LessEqual:
8709  case OO_GreaterEqual:
8710  OpBuilder.addRelationalPointerOrEnumeralOverloads();
8711  OpBuilder.addGenericBinaryArithmeticOverloads();
8712  break;
8713 
8714  case OO_Spaceship:
8715  llvm_unreachable("<=> expressions not supported yet");
8716 
8717  case OO_Percent:
8718  case OO_Caret:
8719  case OO_Pipe:
8720  case OO_LessLess:
8721  case OO_GreaterGreater:
8722  OpBuilder.addBinaryBitwiseArithmeticOverloads(Op);
8723  break;
8724 
8725  case OO_Amp: // '&' is either unary or binary
8726  if (Args.size() == 1)
8727  // C++ [over.match.oper]p3:
8728  // -- For the operator ',', the unary operator '&', or the
8729  // operator '->', the built-in candidates set is empty.
8730  break;
8731 
8732  OpBuilder.addBinaryBitwiseArithmeticOverloads(Op);
8733  break;
8734 
8735  case OO_Tilde:
8736  OpBuilder.addUnaryTildePromotedIntegralOverloads();
8737  break;
8738 
8739  case OO_Equal:
8740  OpBuilder.addAssignmentMemberPointerOrEnumeralOverloads();
8741  LLVM_FALLTHROUGH;
8742 
8743  case OO_PlusEqual:
8744  case OO_MinusEqual:
8745  OpBuilder.addAssignmentPointerOverloads(Op == OO_Equal);
8746  LLVM_FALLTHROUGH;
8747 
8748  case OO_StarEqual:
8749  case OO_SlashEqual:
8750  OpBuilder.addAssignmentArithmeticOverloads(Op == OO_Equal);
8751  break;
8752 
8753  case OO_PercentEqual:
8754  case OO_LessLessEqual:
8755  case OO_GreaterGreaterEqual:
8756  case OO_AmpEqual:
8757  case OO_CaretEqual:
8758  case OO_PipeEqual:
8759  OpBuilder.addAssignmentIntegralOverloads();
8760  break;
8761 
8762  case OO_Exclaim:
8763  OpBuilder.addExclaimOverload();
8764  break;
8765 
8766  case OO_AmpAmp:
8767  case OO_PipePipe:
8768  OpBuilder.addAmpAmpOrPipePipeOverload();
8769  break;
8770 
8771  case OO_Subscript:
8772  OpBuilder.addSubscriptOverloads();
8773  break;
8774 
8775  case OO_ArrowStar:
8776  OpBuilder.addArrowStarOverloads();
8777  break;
8778 
8779  case OO_Conditional:
8780  OpBuilder.addConditionalOperatorOverloads();
8781  OpBuilder.addGenericBinaryArithmeticOverloads();
8782  break;
8783  }
8784 }
8785 
8786 /// \brief Add function candidates found via argument-dependent lookup
8787 /// to the set of overloading candidates.
8788 ///
8789 /// This routine performs argument-dependent name lookup based on the
8790 /// given function name (which may also be an operator name) and adds
8791 /// all of the overload candidates found by ADL to the overload
8792 /// candidate set (C++ [basic.lookup.argdep]).
8793 void
8795  SourceLocation Loc,
8796  ArrayRef<Expr *> Args,
8797  TemplateArgumentListInfo *ExplicitTemplateArgs,
8798  OverloadCandidateSet& CandidateSet,
8799  bool PartialOverloading) {
8800  ADLResult Fns;
8801 
8802  // FIXME: This approach for uniquing ADL results (and removing
8803  // redundant candidates from the set) relies on pointer-equality,
8804  // which means we need to key off the canonical decl. However,
8805  // always going back to the canonical decl might not get us the
8806  // right set of default arguments. What default arguments are
8807  // we supposed to consider on ADL candidates, anyway?
8808 
8809  // FIXME: Pass in the explicit template arguments?
8810  ArgumentDependentLookup(Name, Loc, Args, Fns);
8811 
8812  // Erase all of the candidates we already knew about.
8813  for (OverloadCandidateSet::iterator Cand = CandidateSet.begin(),
8814  CandEnd = CandidateSet.end();
8815  Cand != CandEnd; ++Cand)
8816  if (Cand->Function) {
8817  Fns.erase(Cand->Function);
8818  if (FunctionTemplateDecl *FunTmpl = Cand->Function->getPrimaryTemplate())
8819  Fns.erase(FunTmpl);
8820  }
8821 
8822  // For each of the ADL candidates we found, add it to the overload
8823  // set.
8824  for (ADLResult::iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) {
8825  DeclAccessPair FoundDecl = DeclAccessPair::make(*I, AS_none);
8826  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
8827  if (ExplicitTemplateArgs)
8828  continue;
8829 
8830  AddOverloadCandidate(FD, FoundDecl, Args, CandidateSet, false,
8831  PartialOverloading);
8832  } else
8833  AddTemplateOverloadCandidate(cast<FunctionTemplateDecl>(*I),
8834  FoundDecl, ExplicitTemplateArgs,
8835  Args, CandidateSet, PartialOverloading);
8836  }
8837 }
8838 
8839 namespace {
8840 enum class Comparison { Equal, Better, Worse };
8841 }
8842 
8843 /// Compares the enable_if attributes of two FunctionDecls, for the purposes of
8844 /// overload resolution.
8845 ///
8846 /// Cand1's set of enable_if attributes are said to be "better" than Cand2's iff
8847 /// Cand1's first N enable_if attributes have precisely the same conditions as
8848 /// Cand2's first N enable_if attributes (where N = the number of enable_if
8849 /// attributes on Cand2), and Cand1 has more than N enable_if attributes.
8850 ///
8851 /// Note that you can have a pair of candidates such that Cand1's enable_if
8852 /// attributes are worse than Cand2's, and Cand2's enable_if attributes are
8853 /// worse than Cand1's.
8854 static Comparison compareEnableIfAttrs(const Sema &S, const FunctionDecl *Cand1,
8855  const FunctionDecl *Cand2) {
8856  // Common case: One (or both) decls don't have enable_if attrs.
8857  bool Cand1Attr = Cand1->hasAttr<EnableIfAttr>();
8858  bool Cand2Attr = Cand2->hasAttr<EnableIfAttr>();
8859  if (!Cand1Attr || !Cand2Attr) {
8860  if (Cand1Attr == Cand2Attr)
8861  return Comparison::Equal;
8862  return Cand1Attr ? Comparison::Better : Comparison::Worse;
8863  }
8864 
8865  // FIXME: The next several lines are just
8866  // specific_attr_iterator<EnableIfAttr> but going in declaration order,
8867  // instead of reverse order which is how they're stored in the AST.
8868  auto Cand1Attrs = getOrderedEnableIfAttrs(Cand1);
8869  auto Cand2Attrs = getOrderedEnableIfAttrs(Cand2);
8870 
8871  // It's impossible for Cand1 to be better than (or equal to) Cand2 if Cand1
8872  // has fewer enable_if attributes than Cand2.
8873  if (Cand1Attrs.size() < Cand2Attrs.size())
8874  return Comparison::Worse;
8875 
8876  auto Cand1I = Cand1Attrs.begin();
8877  llvm::FoldingSetNodeID Cand1ID, Cand2ID;
8878  for (auto &Cand2A : Cand2Attrs) {
8879  Cand1ID.clear();
8880  Cand2ID.clear();
8881 
8882  auto &Cand1A = *Cand1I++;
8883  Cand1A->getCond()->Profile(Cand1ID, S.getASTContext(), true);
8884  Cand2A->getCond()->Profile(Cand2ID, S.getASTContext(), true);
8885  if (Cand1ID != Cand2ID)
8886  return Comparison::Worse;
8887  }
8888 
8889  return Cand1I == Cand1Attrs.end() ? Comparison::Equal : Comparison::Better;
8890 }
8891 
8892 /// isBetterOverloadCandidate - Determines whether the first overload
8893 /// candidate is a better candidate than the second (C++ 13.3.3p1).
8895  Sema &S, const OverloadCandidate &Cand1, const OverloadCandidate &Cand2,
8897  // Define viable functions to be better candidates than non-viable
8898  // functions.
8899  if (!Cand2.Viable)
8900  return Cand1.Viable;
8901  else if (!Cand1.Viable)
8902  return false;
8903 
8904  // C++ [over.match.best]p1:
8905  //
8906  // -- if F is a static member function, ICS1(F) is defined such
8907  // that ICS1(F) is neither better nor worse than ICS1(G) for
8908  // any function G, and, symmetrically, ICS1(G) is neither
8909  // better nor worse than ICS1(F).
8910  unsigned StartArg = 0;
8911  if (Cand1.IgnoreObjectArgument || Cand2.IgnoreObjectArgument)
8912  StartArg = 1;
8913 
8914  auto IsIllFormedConversion = [&](const ImplicitConversionSequence &ICS) {
8915  // We don't allow incompatible pointer conversions in C++.
8916  if (!S.getLangOpts().CPlusPlus)
8917  return ICS.isStandard() &&
8918  ICS.Standard.Second == ICK_Incompatible_Pointer_Conversion;
8919 
8920  // The only ill-formed conversion we allow in C++ is the string literal to
8921  // char* conversion, which is only considered ill-formed after C++11.
8922  return S.getLangOpts().CPlusPlus11 && !S.getLangOpts().WritableStrings &&
8924  };
8925 
8926  // Define functions that don't require ill-formed conversions for a given
8927  // argument to be better candidates than functions that do.
8928  unsigned NumArgs = Cand1.Conversions.size();
8929  assert(Cand2.Conversions.size() == NumArgs && "Overload candidate mismatch");
8930  bool HasBetterConversion = false;
8931  for (unsigned ArgIdx = StartArg; ArgIdx < NumArgs; ++ArgIdx) {
8932  bool Cand1Bad = IsIllFormedConversion(Cand1.Conversions[ArgIdx]);
8933  bool Cand2Bad = IsIllFormedConversion(Cand2.Conversions[ArgIdx]);
8934  if (Cand1Bad != Cand2Bad) {
8935  if (Cand1Bad)
8936  return false;
8937  HasBetterConversion = true;
8938  }
8939  }
8940 
8941  if (HasBetterConversion)
8942  return true;
8943 
8944  // C++ [over.match.best]p1:
8945  // A viable function F1 is defined to be a better function than another
8946  // viable function F2 if for all arguments i, ICSi(F1) is not a worse
8947  // conversion sequence than ICSi(F2), and then...
8948  for (unsigned ArgIdx = StartArg; ArgIdx < NumArgs; ++ArgIdx) {
8949  switch (CompareImplicitConversionSequences(S, Loc,
8950  Cand1.Conversions[ArgIdx],
8951  Cand2.Conversions[ArgIdx])) {
8953  // Cand1 has a better conversion sequence.
8954  HasBetterConversion = true;
8955  break;
8956 
8958  // Cand1 can't be better than Cand2.
8959  return false;
8960 
8962  // Do nothing.
8963  break;
8964  }
8965  }
8966 
8967  // -- for some argument j, ICSj(F1) is a better conversion sequence than
8968  // ICSj(F2), or, if not that,
8969  if (HasBetterConversion)
8970  return true;
8971 
8972  // -- the context is an initialization by user-defined conversion
8973  // (see 8.5, 13.3.1.5) and the standard conversion sequence
8974  // from the return type of F1 to the destination type (i.e.,
8975  // the type of the entity being initialized) is a better
8976  // conversion sequence than the standard conversion sequence
8977  // from the return type of F2 to the destination type.
8979  Cand1.Function && Cand2.Function &&
8980  isa<CXXConversionDecl>(Cand1.Function) &&
8981  isa<CXXConversionDecl>(Cand2.Function)) {
8982  // First check whether we prefer one of the conversion functions over the
8983  // other. This only distinguishes the results in non-standard, extension
8984  // cases such as the conversion from a lambda closure type to a function
8985  // pointer or block.
8987  compareConversionFunctions(S, Cand1.Function, Cand2.Function);
8989  Result = CompareStandardConversionSequences(S, Loc,
8990  Cand1.FinalConversion,
8991  Cand2.FinalConversion);
8992 
8994  return Result == ImplicitConversionSequence::Better;
8995 
8996  // FIXME: Compare kind of reference binding if conversion functions
8997  // convert to a reference type used in direct reference binding, per
8998  // C++14 [over.match.best]p1 section 2 bullet 3.
8999  }
9000 
9001  // FIXME: Work around a defect in the C++17 guaranteed copy elision wording,
9002  // as combined with the resolution to CWG issue 243.
9003  //
9004  // When the context is initialization by constructor ([over.match.ctor] or
9005  // either phase of [over.match.list]), a constructor is preferred over
9006  // a conversion function.
9007  if (Kind == OverloadCandidateSet::CSK_InitByConstructor && NumArgs == 1 &&
9008  Cand1.Function && Cand2.Function &&
9009  isa<CXXConstructorDecl>(Cand1.Function) !=
9010  isa<CXXConstructorDecl>(Cand2.Function))
9011  return isa<CXXConstructorDecl>(Cand1.Function);
9012 
9013  // -- F1 is a non-template function and F2 is a function template
9014  // specialization, or, if not that,
9015  bool Cand1IsSpecialization = Cand1.Function &&
9016  Cand1.Function->getPrimaryTemplate();
9017  bool Cand2IsSpecialization = Cand2.Function &&
9018  Cand2.Function->getPrimaryTemplate();
9019  if (Cand1IsSpecialization != Cand2IsSpecialization)
9020  return Cand2IsSpecialization;
9021 
9022  // -- F1 and F2 are function template specializations, and the function
9023  // template for F1 is more specialized than the template for F2
9024  // according to the partial ordering rules described in 14.5.5.2, or,
9025  // if not that,
9026  if (Cand1IsSpecialization && Cand2IsSpecialization) {
9027  if (FunctionTemplateDecl *BetterTemplate
9029  Cand2.Function->getPrimaryTemplate(),
9030  Loc,
9031  isa<CXXConversionDecl>(Cand1.Function)? TPOC_Conversion
9032  : TPOC_Call,
9033  Cand1.ExplicitCallArguments,
9034  Cand2.ExplicitCallArguments))
9035  return BetterTemplate == Cand1.Function->getPrimaryTemplate();
9036  }
9037 
9038  // FIXME: Work around a defect in the C++17 inheriting constructor wording.
9039  // A derived-class constructor beats an (inherited) base class constructor.
9040  bool Cand1IsInherited =
9041  dyn_cast_or_null<ConstructorUsingShadowDecl>(Cand1.FoundDecl.getDecl());
9042  bool Cand2IsInherited =
9043  dyn_cast_or_null<ConstructorUsingShadowDecl>(Cand2.FoundDecl.getDecl());
9044  if (Cand1IsInherited != Cand2IsInherited)
9045  return Cand2IsInherited;
9046  else if (Cand1IsInherited) {
9047  assert(Cand2IsInherited);
9048  auto *Cand1Class = cast<CXXRecordDecl>(Cand1.Function->getDeclContext());
9049  auto *Cand2Class = cast<CXXRecordDecl>(Cand2.Function->getDeclContext());
9050  if (Cand1Class->isDerivedFrom(Cand2Class))
9051  return true;
9052  if (Cand2Class->isDerivedFrom(Cand1Class))
9053  return false;
9054  // Inherited from sibling base classes: still ambiguous.
9055  }
9056 
9057  // Check C++17 tie-breakers for deduction guides.
9058  {
9059  auto *Guide1 = dyn_cast_or_null<CXXDeductionGuideDecl>(Cand1.Function);
9060  auto *Guide2 = dyn_cast_or_null<CXXDeductionGuideDecl>(Cand2.Function);
9061  if (Guide1 && Guide2) {
9062  // -- F1 is generated from a deduction-guide and F2 is not
9063  if (Guide1->isImplicit() != Guide2->isImplicit())
9064  return Guide2->isImplicit();
9065 
9066  // -- F1 is the copy deduction candidate(16.3.1.8) and F2 is not
9067  if (Guide1->isCopyDeductionCandidate())
9068  return true;
9069  }
9070  }
9071 
9072  // Check for enable_if value-based overload resolution.
9073  if (Cand1.Function && Cand2.Function) {
9074  Comparison Cmp = compareEnableIfAttrs(S, Cand1.Function, Cand2.Function);
9075  if (Cmp != Comparison::Equal)
9076  return Cmp == Comparison::Better;
9077  }
9078 
9079  if (S.getLangOpts().CUDA && Cand1.Function && Cand2.Function) {
9080  FunctionDecl *Caller = dyn_cast<FunctionDecl>(S.CurContext);
9081  return S.IdentifyCUDAPreference(Caller, Cand1.Function) >
9082  S.IdentifyCUDAPreference(Caller, Cand2.Function);
9083  }
9084 
9085  bool HasPS1 = Cand1.Function != nullptr &&
9087  bool HasPS2 = Cand2.Function != nullptr &&
9089  return HasPS1 != HasPS2 && HasPS1;
9090 }
9091 
9092 /// Determine whether two declarations are "equivalent" for the purposes of
9093 /// name lookup and overload resolution. This applies when the same internal/no
9094 /// linkage entity is defined by two modules (probably by textually including
9095 /// the same header). In such a case, we don't consider the declarations to
9096 /// declare the same entity, but we also don't want lookups with both
9097 /// declarations visible to be ambiguous in some cases (this happens when using
9098 /// a modularized libstdc++).
9100  const NamedDecl *B) {
9101  auto *VA = dyn_cast_or_null<ValueDecl>(A);
9102  auto *VB = dyn_cast_or_null<ValueDecl>(B);
9103  if (!VA || !VB)
9104  return false;
9105 
9106  // The declarations must be declaring the same name as an internal linkage
9107  // entity in different modules.
9108  if (!VA->getDeclContext()->getRedeclContext()->Equals(
9109  VB->getDeclContext()->getRedeclContext()) ||
9110  getOwningModule(const_cast<ValueDecl *>(VA)) ==
9111  getOwningModule(const_cast<ValueDecl *>(VB)) ||
9112  VA->isExternallyVisible() || VB->isExternallyVisible())
9113  return false;
9114 
9115  // Check that the declarations appear to be equivalent.
9116  //
9117  // FIXME: Checking the type isn't really enough to resolve the ambiguity.
9118  // For constants and functions, we should check the initializer or body is
9119  // the same. For non-constant variables, we shouldn't allow it at all.
9120  if (Context.hasSameType(VA->getType(), VB->getType()))
9121  return true;
9122 
9123  // Enum constants within unnamed enumerations will have different types, but
9124  // may still be similar enough to be interchangeable for our purposes.
9125  if (auto *EA = dyn_cast<EnumConstantDecl>(VA)) {
9126  if (auto *EB = dyn_cast<EnumConstantDecl>(VB)) {
9127  // Only handle anonymous enums. If the enumerations were named and
9128  // equivalent, they would have been merged to the same type.
9129  auto *EnumA = cast<EnumDecl>(EA->getDeclContext());
9130  auto *EnumB = cast<EnumDecl>(EB->getDeclContext());
9131  if (EnumA->hasNameForLinkage() || EnumB->hasNameForLinkage() ||
9132  !Context.hasSameType(EnumA->getIntegerType(),
9133  EnumB->getIntegerType()))
9134  return false;
9135  // Allow this only if the value is the same for both enumerators.
9136  return llvm::APSInt::isSameValue(EA->getInitVal(), EB->getInitVal());
9137  }
9138  }
9139 
9140  // Nothing else is sufficiently similar.
9141  return false;
9142 }
9143 
9145  SourceLocation Loc, const NamedDecl *D, ArrayRef<const NamedDecl *> Equiv) {
9146  Diag(Loc, diag::ext_equivalent_internal_linkage_decl_in_modules) << D;
9147 
9148  Module *M = getOwningModule(const_cast<NamedDecl*>(D));
9149  Diag(D->getLocation(), diag::note_equivalent_internal_linkage_decl)
9150  << !M << (M ? M->getFullModuleName() : "");
9151 
9152  for (auto *E : Equiv) {
9153  Module *M = getOwningModule(const_cast<NamedDecl*>(E));
9154  Diag(E->getLocation(), diag::note_equivalent_internal_linkage_decl)
9155  << !M << (M ? M->getFullModuleName() : "");
9156  }
9157 }
9158 
9159 /// \brief Computes the best viable function (C++ 13.3.3)
9160 /// within an overload candidate set.
9161 ///
9162 /// \param Loc The location of the function name (or operator symbol) for
9163 /// which overload resolution occurs.
9164 ///
9165 /// \param Best If overload resolution was successful or found a deleted
9166 /// function, \p Best points to the candidate function found.
9167 ///
9168 /// \returns The result of overload resolution.
9171  iterator &Best) {
9173  std::transform(begin(), end(), std::back_inserter(Candidates),
9174  [](OverloadCandidate &Cand) { return &Cand; });
9175 
9176  // [CUDA] HD->H or HD->D calls are technically not allowed by CUDA but
9177  // are accepted by both clang and NVCC. However, during a particular
9178  // compilation mode only one call variant is viable. We need to
9179  // exclude non-viable overload candidates from consideration based
9180  // only on their host/device attributes. Specifically, if one
9181  // candidate call is WrongSide and the other is SameSide, we ignore
9182  // the WrongSide candidate.
9183  if (S.getLangOpts().CUDA) {
9184  const FunctionDecl *Caller = dyn_cast<FunctionDecl>(S.CurContext);
9185  bool ContainsSameSideCandidate =
9186  llvm::any_of(Candidates, [&](OverloadCandidate *Cand) {
9187  return Cand->Function &&
9188  S.IdentifyCUDAPreference(Caller, Cand->Function) ==
9190  });
9191  if (ContainsSameSideCandidate) {
9192  auto IsWrongSideCandidate = [&](OverloadCandidate *Cand) {
9193  return Cand->Function &&
9194  S.IdentifyCUDAPreference(Caller, Cand->Function) ==
9196  };
9197  llvm::erase_if(Candidates, IsWrongSideCandidate);
9198  }
9199  }
9200 
9201  // Find the best viable function.
9202  Best = end();
9203  for (auto *Cand : Candidates)
9204  if (Cand->Viable)
9205  if (Best == end() ||
9206  isBetterOverloadCandidate(S, *Cand, *Best, Loc, Kind))
9207  Best = Cand;
9208 
9209  // If we didn't find any viable functions, abort.
9210  if (Best == end())
9211  return OR_No_Viable_Function;
9212 
9214 
9215  // Make sure that this function is better than every other viable
9216  // function. If not, we have an ambiguity.
9217  for (auto *Cand : Candidates) {
9218  if (Cand->Viable && Cand != Best &&
9219  !isBetterOverloadCandidate(S, *Best, *Cand, Loc, Kind)) {
9220  if (S.isEquivalentInternalLinkageDeclaration(Best->Function,
9221  Cand->Function)) {
9222  EquivalentCands.push_back(Cand->Function);
9223  continue;
9224  }
9225 
9226  Best = end();
9227  return OR_Ambiguous;
9228  }
9229  }
9230 
9231  // Best is the best viable function.
9232  if (Best->Function &&
9233  (Best->Function->isDeleted() ||
9234  S.isFunctionConsideredUnavailable(Best->Function)))
9235  return OR_Deleted;
9236 
9237  if (!EquivalentCands.empty())
9238  S.diagnoseEquivalentInternalLinkageDeclarations(Loc, Best->Function,
9239  EquivalentCands);
9240 
9241  return OR_Success;
9242 }
9243 
9244 namespace {
9245 
9247  oc_function,
9248  oc_method,
9249  oc_constructor,
9250  oc_function_template,
9251  oc_method_template,
9252  oc_constructor_template,
9253  oc_implicit_default_constructor,
9254  oc_implicit_copy_constructor,
9255  oc_implicit_move_constructor,
9256  oc_implicit_copy_assignment,
9257  oc_implicit_move_assignment,
9258  oc_inherited_constructor,
9259  oc_inherited_constructor_template
9260 };
9261 
9262 static OverloadCandidateKind
9263 ClassifyOverloadCandidate(Sema &S, NamedDecl *Found, FunctionDecl *Fn,
9264  std::string &Description) {
9265  bool isTemplate = false;
9266 
9267  if (FunctionTemplateDecl *FunTmpl = Fn->getPrimaryTemplate()) {
9268  isTemplate = true;
9269  Description = S.getTemplateArgumentBindingsText(
9270  FunTmpl->getTemplateParameters(), *Fn->getTemplateSpecializationArgs());
9271  }
9272 
9273  if (CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(Fn)) {
9274  if (!Ctor->isImplicit()) {
9275  if (isa<ConstructorUsingShadowDecl>(Found))
9276  return isTemplate ? oc_inherited_constructor_template
9277  : oc_inherited_constructor;
9278  else
9279  return isTemplate ? oc_constructor_template : oc_constructor;
9280  }
9281 
9282  if (Ctor->isDefaultConstructor())
9283  return oc_implicit_default_constructor;
9284 
9285  if (Ctor->isMoveConstructor())
9286  return oc_implicit_move_constructor;
9287 
9288  assert(Ctor->isCopyConstructor() &&
9289  "unexpected sort of implicit constructor");
9290  return oc_implicit_copy_constructor;
9291  }
9292 
9293  if (CXXMethodDecl *Meth = dyn_cast<CXXMethodDecl>(Fn)) {
9294  // This actually gets spelled 'candidate function' for now, but
9295  // it doesn't hurt to split it out.
9296  if (!Meth->isImplicit())
9297  return isTemplate ? oc_method_template : oc_method;
9298 
9299  if (Meth->isMoveAssignmentOperator())
9300  return oc_implicit_move_assignment;
9301 
9302  if (Meth->isCopyAssignmentOperator())
9303  return oc_implicit_copy_assignment;
9304 
9305  assert(isa<CXXConversionDecl>(Meth) && "expected conversion");
9306  return oc_method;
9307  }
9308 
9309  return isTemplate ? oc_function_template : oc_function;
9310 }
9311 
9312 void MaybeEmitInheritedConstructorNote(Sema &S, Decl *FoundDecl) {
9313  // FIXME: It'd be nice to only emit a note once per using-decl per overload
9314  // set.
9315  if (auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(FoundDecl))
9316  S.Diag(FoundDecl->getLocation(),
9317  diag::note_ovl_candidate_inherited_constructor)
9318  << Shadow->getNominatedBaseClass();
9319 }
9320 
9321 } // end anonymous namespace
9322 
9323 static bool isFunctionAlwaysEnabled(const ASTContext &Ctx,
9324  const FunctionDecl *FD) {
9325  for (auto *EnableIf : FD->specific_attrs<EnableIfAttr>()) {
9326  bool AlwaysTrue;
9327  if (!EnableIf->getCond()->EvaluateAsBooleanCondition(AlwaysTrue, Ctx))
9328  return false;
9329  if (!AlwaysTrue)
9330  return false;
9331  }
9332  return true;
9333 }
9334 
9335 /// \brief Returns true if we can take the address of the function.
9336 ///
9337 /// \param Complain - If true, we'll emit a diagnostic
9338 /// \param InOverloadResolution - For the purposes of emitting a diagnostic, are
9339 /// we in overload resolution?
9340 /// \param Loc - The location of the statement we're complaining about. Ignored
9341 /// if we're not complaining, or if we're in overload resolution.
9343  bool Complain,
9344  bool InOverloadResolution,
9345  SourceLocation Loc) {
9346  if (!isFunctionAlwaysEnabled(S.Context, FD)) {
9347  if (Complain) {
9348  if (InOverloadResolution)
9349  S.Diag(FD->getLocStart(),
9350  diag::note_addrof_ovl_candidate_disabled_by_enable_if_attr);
9351  else
9352  S.Diag(Loc, diag::err_addrof_function_disabled_by_enable_if_attr) << FD;
9353  }
9354  return false;
9355  }
9356 
9357  auto I = llvm::find_if(FD->parameters(), [](const ParmVarDecl *P) {
9358  return P->hasAttr<PassObjectSizeAttr>();
9359  });
9360  if (I == FD->param_end())
9361  return true;
9362 
9363  if (Complain) {
9364  // Add one to ParamNo because it's user-facing
9365  unsigned ParamNo = std::distance(FD->param_begin(), I) + 1;
9366  if (InOverloadResolution)
9367  S.Diag(FD->getLocation(),
9368  diag::note_ovl_candidate_has_pass_object_size_params)
9369  << ParamNo;
9370  else
9371  S.Diag(Loc, diag::err_address_of_function_with_pass_object_size_params)
9372  << FD << ParamNo;
9373  }
9374  return false;
9375 }
9376 
9378  const FunctionDecl *FD) {
9379  return checkAddressOfFunctionIsAvailable(S, FD, /*Complain=*/true,
9380  /*InOverloadResolution=*/true,
9381  /*Loc=*/SourceLocation());
9382 }
9383 
9385  bool Complain,
9386  SourceLocation Loc) {
9387  return ::checkAddressOfFunctionIsAvailable(*this, Function, Complain,
9388  /*InOverloadResolution=*/false,
9389  Loc);
9390 }
9391 
9392 // Notes the location of an overload candidate.
9394  QualType DestType, bool TakingAddress) {
9395  if (TakingAddress && !checkAddressOfCandidateIsAvailable(*this, Fn))
9396  return;
9397 
9398  std::string FnDesc;
9399  OverloadCandidateKind K = ClassifyOverloadCandidate(*this, Found, Fn, FnDesc);
9400  PartialDiagnostic PD = PDiag(diag::note_ovl_candidate)
9401  << (unsigned) K << Fn << FnDesc;
9402 
9403  HandleFunctionTypeMismatch(PD, Fn->getType(), DestType);
9404  Diag(Fn->getLocation(), PD);
9405  MaybeEmitInheritedConstructorNote(*this, Found);
9406 }
9407 
9408 // Notes the location of all overload candidates designated through
9409 // OverloadedExpr
9410 void Sema::NoteAllOverloadCandidates(Expr *OverloadedExpr, QualType DestType,
9411  bool TakingAddress) {
9412  assert(OverloadedExpr->getType() == Context.OverloadTy);
9413 
9414  OverloadExpr::FindResult Ovl = OverloadExpr::find(OverloadedExpr);
9415  OverloadExpr *OvlExpr = Ovl.Expression;
9416 
9417  for (UnresolvedSetIterator I = OvlExpr->decls_begin(),
9418  IEnd = OvlExpr->decls_end();
9419  I != IEnd; ++I) {
9420  if (FunctionTemplateDecl *FunTmpl =
9421  dyn_cast<FunctionTemplateDecl>((*I)->getUnderlyingDecl()) ) {
9422  NoteOverloadCandidate(*I, FunTmpl->getTemplatedDecl(), DestType,
9423  TakingAddress);
9424  } else if (FunctionDecl *Fun
9425  = dyn_cast<FunctionDecl>((*I)->getUnderlyingDecl()) ) {
9426  NoteOverloadCandidate(*I, Fun, DestType, TakingAddress);
9427  }
9428  }
9429 }
9430 
9431 /// Diagnoses an ambiguous conversion. The partial diagnostic is the
9432 /// "lead" diagnostic; it will be given two arguments, the source and
9433 /// target types of the conversion.
9435  Sema &S,
9436  SourceLocation CaretLoc,
9437  const PartialDiagnostic &PDiag) const {
9438  S.Diag(CaretLoc, PDiag)
9439  << Ambiguous.getFromType() << Ambiguous.getToType();
9440  // FIXME: The note limiting machinery is borrowed from
9441  // OverloadCandidateSet::NoteCandidates; there's an opportunity for
9442  // refactoring here.
9443  const OverloadsShown ShowOverloads = S.Diags.getShowOverloads();
9444  unsigned CandsShown = 0;
9446  for (I = Ambiguous.begin(), E = Ambiguous.end(); I != E; ++I) {
9447  if (CandsShown >= 4 && ShowOverloads == Ovl_Best)
9448  break;
9449  ++CandsShown;
9450  S.NoteOverloadCandidate(I->first, I->second);
9451  }
9452  if (I != E)
9453  S.Diag(SourceLocation(), diag::note_ovl_too_many_candidates) << int(E - I);
9454 }
9455 
9457  unsigned I, bool TakingCandidateAddress) {
9458  const ImplicitConversionSequence &Conv = Cand->Conversions[I];
9459  assert(Conv.isBad());
9460  assert(Cand->Function && "for now, candidate must be a function");
9461  FunctionDecl *Fn = Cand->Function;
9462 
9463  // There's a conversion slot for the object argument if this is a
9464  // non-constructor method. Note that 'I' corresponds the
9465  // conversion-slot index.
9466  bool isObjectArgument = false;
9467  if (isa<CXXMethodDecl>(Fn) && !isa<CXXConstructorDecl>(Fn)) {
9468  if (I == 0)
9469  isObjectArgument = true;
9470  else
9471  I--;
9472  }
9473 
9474  std::string FnDesc;
9475  OverloadCandidateKind FnKind =
9476  ClassifyOverloadCandidate(S, Cand->FoundDecl, Fn, FnDesc);
9477 
9478  Expr *FromExpr = Conv.Bad.FromExpr;
9479  QualType FromTy = Conv.Bad.getFromType();
9480  QualType ToTy = Conv.Bad.getToType();
9481 
9482  if (FromTy == S.Context.OverloadTy) {
9483  assert(FromExpr && "overload set argument came from implicit argument?");
9484  Expr *E = FromExpr->IgnoreParens();
9485  if (isa<UnaryOperator>(E))
9486  E = cast<UnaryOperator>(E)->getSubExpr()->IgnoreParens();
9487  DeclarationName Name = cast<OverloadExpr>(E)->getName();
9488 
9489  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_overload)
9490  << (unsigned) FnKind << FnDesc
9491  << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
9492  << ToTy << Name << I+1;
9493  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9494  return;
9495  }
9496 
9497  // Do some hand-waving analysis to see if the non-viability is due
9498  // to a qualifier mismatch.
9499  CanQualType CFromTy = S.Context.getCanonicalType(FromTy);
9500  CanQualType CToTy = S.Context.getCanonicalType(ToTy);
9501  if (CanQual<ReferenceType> RT = CToTy->getAs<ReferenceType>())
9502  CToTy = RT->getPointeeType();
9503  else {
9504  // TODO: detect and diagnose the full richness of const mismatches.
9505  if (CanQual<PointerType> FromPT = CFromTy->getAs<PointerType>())
9506  if (CanQual<PointerType> ToPT = CToTy->getAs<PointerType>()) {
9507  CFromTy = FromPT->getPointeeType();
9508  CToTy = ToPT->getPointeeType();
9509  }
9510  }
9511 
9512  if (CToTy.getUnqualifiedType() == CFromTy.getUnqualifiedType() &&
9513  !CToTy.isAtLeastAsQualifiedAs(CFromTy)) {
9514  Qualifiers FromQs = CFromTy.getQualifiers();
9515  Qualifiers ToQs = CToTy.getQualifiers();
9516 
9517  if (FromQs.getAddressSpace() != ToQs.getAddressSpace()) {
9518  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_addrspace)
9519  << (unsigned) FnKind << FnDesc
9520  << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
9521  << FromTy
9524  << (unsigned) isObjectArgument << I+1;
9525  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9526  return;
9527  }
9528 
9529  if (FromQs.getObjCLifetime() != ToQs.getObjCLifetime()) {
9530  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_ownership)
9531  << (unsigned) FnKind << FnDesc
9532  << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
9533  << FromTy
9534  << FromQs.getObjCLifetime() << ToQs.getObjCLifetime()
9535  << (unsigned) isObjectArgument << I+1;
9536  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9537  return;
9538  }
9539 
9540  if (FromQs.getObjCGCAttr() != ToQs.getObjCGCAttr()) {
9541  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_gc)
9542  << (unsigned) FnKind << FnDesc
9543  << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
9544  << FromTy
9545  << FromQs.getObjCGCAttr() << ToQs.getObjCGCAttr()
9546  << (unsigned) isObjectArgument << I+1;
9547  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9548  return;
9549  }
9550 
9551  if (FromQs.hasUnaligned() != ToQs.hasUnaligned()) {
9552  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_unaligned)
9553  << (unsigned) FnKind << FnDesc
9554  << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
9555  << FromTy << FromQs.hasUnaligned() << I+1;
9556  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9557  return;
9558  }
9559 
9560  unsigned CVR = FromQs.getCVRQualifiers() & ~ToQs.getCVRQualifiers();
9561  assert(CVR && "unexpected qualifiers mismatch");
9562 
9563  if (isObjectArgument) {
9564  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_cvr_this)
9565  << (unsigned) FnKind << FnDesc
9566  << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
9567  << FromTy << (CVR - 1);
9568  } else {
9569  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_cvr)
9570  << (unsigned) FnKind << FnDesc
9571  << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
9572  << FromTy << (CVR - 1) << I+1;
9573  }
9574  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9575  return;
9576  }
9577 
9578  // Special diagnostic for failure to convert an initializer list, since
9579  // telling the user that it has type void is not useful.
9580  if (FromExpr && isa<InitListExpr>(FromExpr)) {
9581  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_list_argument)
9582  << (unsigned) FnKind << FnDesc
9583  << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
9584  << FromTy << ToTy << (unsigned) isObjectArgument << I+1;
9585  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9586  return;
9587  }
9588 
9589  // Diagnose references or pointers to incomplete types differently,
9590  // since it's far from impossible that the incompleteness triggered
9591  // the failure.
9592  QualType TempFromTy = FromTy.getNonReferenceType();
9593  if (const PointerType *PTy = TempFromTy->getAs<PointerType>())
9594  TempFromTy = PTy->getPointeeType();
9595  if (TempFromTy->isIncompleteType()) {
9596  // Emit the generic diagnostic and, optionally, add the hints to it.
9597  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_conv_incomplete)
9598  << (unsigned) FnKind << FnDesc
9599  << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
9600  << FromTy << ToTy << (unsigned) isObjectArgument << I+1
9601  << (unsigned) (Cand->Fix.Kind);
9602 
9603  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9604  return;
9605  }
9606 
9607  // Diagnose base -> derived pointer conversions.
9608  unsigned BaseToDerivedConversion = 0;
9609  if (const PointerType *FromPtrTy = FromTy->getAs<PointerType>()) {
9610  if (const PointerType *ToPtrTy = ToTy->getAs<PointerType>()) {
9611  if (ToPtrTy->getPointeeType().isAtLeastAsQualifiedAs(
9612  FromPtrTy->getPointeeType()) &&
9613  !FromPtrTy->getPointeeType()->isIncompleteType() &&
9614  !ToPtrTy->getPointeeType()->isIncompleteType() &&
9615  S.IsDerivedFrom(SourceLocation(), ToPtrTy->getPointeeType(),
9616  FromPtrTy->getPointeeType()))
9617  BaseToDerivedConversion = 1;
9618  }
9619  } else if (const ObjCObjectPointerType *FromPtrTy
9620  = FromTy->getAs<ObjCObjectPointerType>()) {
9621  if (const ObjCObjectPointerType *ToPtrTy
9622  = ToTy->getAs<ObjCObjectPointerType>())
9623  if (const ObjCInterfaceDecl *FromIface = FromPtrTy->getInterfaceDecl())
9624  if (const ObjCInterfaceDecl *ToIface = ToPtrTy->getInterfaceDecl())
9625  if (ToPtrTy->getPointeeType().isAtLeastAsQualifiedAs(
9626  FromPtrTy->getPointeeType()) &&
9627  FromIface->isSuperClassOf(ToIface))
9628  BaseToDerivedConversion = 2;
9629  } else if (const ReferenceType *ToRefTy = ToTy->getAs<ReferenceType>()) {
9630  if (ToRefTy->getPointeeType().isAtLeastAsQualifiedAs(FromTy) &&
9631  !FromTy->isIncompleteType() &&
9632  !ToRefTy->getPointeeType()->isIncompleteType() &&
9633  S.IsDerivedFrom(SourceLocation(), ToRefTy->getPointeeType(), FromTy)) {
9634  BaseToDerivedConversion = 3;
9635  } else if (ToTy->isLValueReferenceType() && !FromExpr->isLValue() &&
9638  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_lvalue)
9639  << (unsigned) FnKind << FnDesc
9640  << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
9641  << (unsigned) isObjectArgument << I + 1;
9642  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9643  return;
9644  }
9645  }
9646 
9647  if (BaseToDerivedConversion) {
9648  S.Diag(Fn->getLocation(),
9649  diag::note_ovl_candidate_bad_base_to_derived_conv)
9650  << (unsigned) FnKind << FnDesc
9651  << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
9652  << (BaseToDerivedConversion - 1)
9653  << FromTy << ToTy << I+1;
9654  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9655  return;
9656  }
9657 
9658  if (isa<ObjCObjectPointerType>(CFromTy) &&
9659  isa<PointerType>(CToTy)) {
9660  Qualifiers FromQs = CFromTy.getQualifiers();
9661  Qualifiers ToQs = CToTy.getQualifiers();
9662  if (FromQs.getObjCLifetime() != ToQs.getObjCLifetime()) {
9663  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_arc_conv)
9664  << (unsigned) FnKind << FnDesc
9665  << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
9666  << FromTy << ToTy << (unsigned) isObjectArgument << I+1;
9667  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9668  return;
9669  }
9670  }
9671 
9672  if (TakingCandidateAddress &&
9674  return;
9675 
9676  // Emit the generic diagnostic and, optionally, add the hints to it.
9677  PartialDiagnostic FDiag = S.PDiag(diag::note_ovl_candidate_bad_conv);
9678  FDiag << (unsigned) FnKind << FnDesc
9679  << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
9680  << FromTy << ToTy << (unsigned) isObjectArgument << I + 1
9681  << (unsigned) (Cand->Fix.Kind);
9682 
9683  // If we can fix the conversion, suggest the FixIts.
9684  for (std::vector<FixItHint>::iterator HI = Cand->Fix.Hints.begin(),
9685  HE = Cand->Fix.Hints.end(); HI != HE; ++HI)
9686  FDiag << *HI;
9687  S.Diag(Fn->getLocation(), FDiag);
9688 
9689  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9690 }
9691 
9692 /// Additional arity mismatch diagnosis specific to a function overload
9693 /// candidates. This is not covered by the more general DiagnoseArityMismatch()
9694 /// over a candidate in any candidate set.
9696  unsigned NumArgs) {
9697  FunctionDecl *Fn = Cand->Function;
9698  unsigned MinParams = Fn->getMinRequiredArguments();
9699 
9700  // With invalid overloaded operators, it's possible that we think we
9701  // have an arity mismatch when in fact it looks like we have the
9702  // right number of arguments, because only overloaded operators have
9703  // the weird behavior of overloading member and non-member functions.
9704  // Just don't report anything.
9705  if (Fn->isInvalidDecl() &&
9707  return true;
9708 
9709  if (NumArgs < MinParams) {
9710  assert((Cand->FailureKind == ovl_fail_too_few_arguments) ||
9711  (Cand->FailureKind == ovl_fail_bad_deduction &&
9713  } else {
9714  assert((Cand->FailureKind == ovl_fail_too_many_arguments) ||
9715  (Cand->FailureKind == ovl_fail_bad_deduction &&
9717  }
9718 
9719  return false;
9720 }
9721 
9722 /// General arity mismatch diagnosis over a candidate in a candidate set.
9723 static void DiagnoseArityMismatch(Sema &S, NamedDecl *Found, Decl *D,
9724  unsigned NumFormalArgs) {
9725  assert(isa<FunctionDecl>(D) &&
9726  "The templated declaration should at least be a function"
9727  " when diagnosing bad template argument deduction due to too many"
9728  " or too few arguments");
9729 
9730  FunctionDecl *Fn = cast<FunctionDecl>(D);
9731 
9732  // TODO: treat calls to a missing default constructor as a special case
9733  const FunctionProtoType *FnTy = Fn->getType()->getAs<FunctionProtoType>();
9734  unsigned MinParams = Fn->getMinRequiredArguments();
9735 
9736  // at least / at most / exactly
9737  unsigned mode, modeCount;
9738  if (NumFormalArgs < MinParams) {
9739  if (MinParams != FnTy->getNumParams() || FnTy->isVariadic() ||
9740  FnTy->isTemplateVariadic())
9741  mode = 0; // "at least"
9742  else
9743  mode = 2; // "exactly"
9744  modeCount = MinParams;
9745  } else {
9746  if (MinParams != FnTy->getNumParams())
9747  mode = 1; // "at most"
9748  else
9749  mode = 2; // "exactly"
9750  modeCount = FnTy->getNumParams();
9751  }
9752 
9753  std::string Description;
9754  OverloadCandidateKind FnKind =
9755  ClassifyOverloadCandidate(S, Found, Fn, Description);
9756 
9757  if (modeCount == 1 && Fn->getParamDecl(0)->getDeclName())
9758  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_arity_one)
9759  << (unsigned) FnKind << (Fn->getDescribedFunctionTemplate() != nullptr)
9760  << mode << Fn->getParamDecl(0) << NumFormalArgs;
9761  else
9762  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_arity)
9763  << (unsigned) FnKind << (Fn->getDescribedFunctionTemplate() != nullptr)
9764  << mode << modeCount << NumFormalArgs;
9765  MaybeEmitInheritedConstructorNote(S, Found);
9766 }
9767 
9768 /// Arity mismatch diagnosis specific to a function overload candidate.
9770  unsigned NumFormalArgs) {
9771  if (!CheckArityMismatch(S, Cand, NumFormalArgs))
9772  DiagnoseArityMismatch(S, Cand->FoundDecl, Cand->Function, NumFormalArgs);
9773 }
9774 
9776  if (TemplateDecl *TD = Templated->getDescribedTemplate())
9777  return TD;
9778  llvm_unreachable("Unsupported: Getting the described template declaration"
9779  " for bad deduction diagnosis");
9780 }
9781 
9782 /// Diagnose a failed template-argument deduction.
9783 static void DiagnoseBadDeduction(Sema &S, NamedDecl *Found, Decl *Templated,
9784  DeductionFailureInfo &DeductionFailure,
9785  unsigned NumArgs,
9786  bool TakingCandidateAddress) {
9787  TemplateParameter Param = DeductionFailure.getTemplateParameter();
9788  NamedDecl *ParamD;
9789  (ParamD = Param.dyn_cast<TemplateTypeParmDecl*>()) ||
9790  (ParamD = Param.dyn_cast<NonTypeTemplateParmDecl*>()) ||
9791  (ParamD = Param.dyn_cast<TemplateTemplateParmDecl*>());
9792  switch (DeductionFailure.Result) {
9793  case Sema::TDK_Success:
9794  llvm_unreachable("TDK_success while diagnosing bad deduction");
9795 
9796  case Sema::TDK_Incomplete: {
9797  assert(ParamD && "no parameter found for incomplete deduction result");
9798  S.Diag(Templated->getLocation(),
9799  diag::note_ovl_candidate_incomplete_deduction)
9800  << ParamD->getDeclName();
9801  MaybeEmitInheritedConstructorNote(S, Found);
9802  return;
9803  }
9804 
9805  case Sema::TDK_Underqualified: {
9806  assert(ParamD && "no parameter found for bad qualifiers deduction result");
9807  TemplateTypeParmDecl *TParam = cast<TemplateTypeParmDecl>(ParamD);
9808 
9809  QualType Param = DeductionFailure.getFirstArg()->getAsType();
9810 
9811  // Param will have been canonicalized, but it should just be a
9812  // qualified version of ParamD, so move the qualifiers to that.
9813  QualifierCollector Qs;
9814  Qs.strip(Param);
9815  QualType NonCanonParam = Qs.apply(S.Context, TParam->getTypeForDecl());
9816  assert(S.Context.hasSameType(Param, NonCanonParam));
9817 
9818  // Arg has also been canonicalized, but there's nothing we can do
9819  // about that. It also doesn't matter as much, because it won't
9820  // have any template parameters in it (because deduction isn't
9821  // done on dependent types).
9822  QualType Arg = DeductionFailure.getSecondArg()->getAsType();
9823 
9824  S.Diag(Templated->getLocation(), diag::note_ovl_candidate_underqualified)
9825  << ParamD->getDeclName() << Arg << NonCanonParam;
9826  MaybeEmitInheritedConstructorNote(S, Found);
9827  return;
9828  }
9829 
9830  case Sema::TDK_Inconsistent: {
9831  assert(ParamD && "no parameter found for inconsistent deduction result");
9832  int which = 0;
9833  if (isa<TemplateTypeParmDecl>(ParamD))
9834  which = 0;
9835  else if (isa<NonTypeTemplateParmDecl>(ParamD)) {
9836  // Deduction might have failed because we deduced arguments of two
9837  // different types for a non-type template parameter.
9838  // FIXME: Use a different TDK value for this.
9839  QualType T1 =
9840  DeductionFailure.getFirstArg()->getNonTypeTemplateArgumentType();
9841  QualType T2 =
9842  DeductionFailure.getSecondArg()->getNonTypeTemplateArgumentType();
9843  if (!S.Context.hasSameType(T1, T2)) {
9844  S.Diag(Templated->getLocation(),
9845  diag::note_ovl_candidate_inconsistent_deduction_types)
9846  << ParamD->getDeclName() << *DeductionFailure.getFirstArg() << T1
9847  << *DeductionFailure.getSecondArg() << T2;
9848  MaybeEmitInheritedConstructorNote(S, Found);
9849  return;
9850  }
9851 
9852  which = 1;
9853  } else {
9854  which = 2;
9855  }
9856 
9857  S.Diag(Templated->getLocation(),
9858  diag::note_ovl_candidate_inconsistent_deduction)
9859  << which << ParamD->getDeclName() << *DeductionFailure.getFirstArg()
9860  << *DeductionFailure.getSecondArg();
9861  MaybeEmitInheritedConstructorNote(S, Found);
9862  return;
9863  }
9864 
9866  assert(ParamD && "no parameter found for invalid explicit arguments");
9867  if (ParamD->getDeclName())
9868  S.Diag(Templated->getLocation(),
9869  diag::note_ovl_candidate_explicit_arg_mismatch_named)
9870  << ParamD->getDeclName();
9871  else {
9872  int index = 0;
9873  if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ParamD))
9874  index = TTP->getIndex();
9875  else if (NonTypeTemplateParmDecl *NTTP
9876  = dyn_cast<NonTypeTemplateParmDecl>(ParamD))
9877  index = NTTP->getIndex();
9878  else
9879  index = cast<TemplateTemplateParmDecl>(ParamD)->getIndex();
9880  S.Diag(Templated->getLocation(),
9881  diag::note_ovl_candidate_explicit_arg_mismatch_unnamed)
9882  << (index + 1);
9883  }
9884  MaybeEmitInheritedConstructorNote(S, Found);
9885  return;
9886 
9889  DiagnoseArityMismatch(S, Found, Templated, NumArgs);
9890  return;
9891 
9893  S.Diag(Templated->getLocation(),
9894  diag::note_ovl_candidate_instantiation_depth);
9895  MaybeEmitInheritedConstructorNote(S, Found);
9896  return;
9897 
9899  // Format the template argument list into the argument string.
9900  SmallString<128> TemplateArgString;
9901  if (TemplateArgumentList *Args =
9902  DeductionFailure.getTemplateArgumentList()) {
9903  TemplateArgString = " ";
9904  TemplateArgString += S.getTemplateArgumentBindingsText(
9905  getDescribedTemplate(Templated)->getTemplateParameters(), *Args);
9906  }
9907 
9908  // If this candidate was disabled by enable_if, say so.
9909  PartialDiagnosticAt *PDiag = DeductionFailure.getSFINAEDiagnostic();
9910  if (PDiag && PDiag->second.getDiagID() ==
9911  diag::err_typename_nested_not_found_enable_if) {
9912  // FIXME: Use the source range of the condition, and the fully-qualified
9913  // name of the enable_if template. These are both present in PDiag.
9914  S.Diag(PDiag->first, diag::note_ovl_candidate_disabled_by_enable_if)
9915  << "'enable_if'" << TemplateArgString;
9916  return;
9917  }
9918 
9919  // We found a specific requirement that disabled the enable_if.
9920  if (PDiag && PDiag->second.getDiagID() ==
9921  diag::err_typename_nested_not_found_requirement) {
9922  S.Diag(Templated->getLocation(),
9923  diag::note_ovl_candidate_disabled_by_requirement)
9924  << PDiag->second.getStringArg(0) << TemplateArgString;
9925  return;
9926  }
9927 
9928  // Format the SFINAE diagnostic into the argument string.
9929  // FIXME: Add a general mechanism to include a PartialDiagnostic *'s
9930  // formatted message in another diagnostic.
9931  SmallString<128> SFINAEArgString;
9932  SourceRange R;
9933  if (PDiag) {
9934  SFINAEArgString = ": ";
9935  R = SourceRange(PDiag->first, PDiag->first);
9936  PDiag->second.EmitToString(S.getDiagnostics(), SFINAEArgString);
9937  }
9938 
9939  S.Diag(Templated->getLocation(),
9940  diag::note_ovl_candidate_substitution_failure)
9941  << TemplateArgString << SFINAEArgString << R;
9942  MaybeEmitInheritedConstructorNote(S, Found);
9943  return;
9944  }
9945 
9948  // Format the template argument list into the argument string.
9949  SmallString<128> TemplateArgString;
9950  if (TemplateArgumentList *Args =
9951  DeductionFailure.getTemplateArgumentList()) {
9952  TemplateArgString = " ";
9953  TemplateArgString += S.getTemplateArgumentBindingsText(
9954  getDescribedTemplate(Templated)->getTemplateParameters(), *Args);
9955  }
9956 
9957  S.Diag(Templated->getLocation(), diag::note_ovl_candidate_deduced_mismatch)
9958  << (*DeductionFailure.getCallArgIndex() + 1)
9959  << *DeductionFailure.getFirstArg() << *DeductionFailure.getSecondArg()
9960  << TemplateArgString
9961  << (DeductionFailure.Result == Sema::TDK_DeducedMismatchNested);
9962  break;
9963  }
9964 
9966  // FIXME: Provide a source location to indicate what we couldn't match.
9967  TemplateArgument FirstTA = *DeductionFailure.getFirstArg();
9968  TemplateArgument SecondTA = *DeductionFailure.getSecondArg();
9969  if (FirstTA.getKind() == TemplateArgument::Template &&
9970  SecondTA.getKind() == TemplateArgument::Template) {
9971  TemplateName FirstTN = FirstTA.getAsTemplate();
9972  TemplateName SecondTN = SecondTA.getAsTemplate();
9973  if (FirstTN.getKind() == TemplateName::Template &&
9974  SecondTN.getKind() == TemplateName::Template) {
9975  if (FirstTN.getAsTemplateDecl()->getName() ==
9976  SecondTN.getAsTemplateDecl()->getName()) {
9977  // FIXME: This fixes a bad diagnostic where both templates are named
9978  // the same. This particular case is a bit difficult since:
9979  // 1) It is passed as a string to the diagnostic printer.
9980  // 2) The diagnostic printer only attempts to find a better
9981  // name for types, not decls.
9982  // Ideally, this should folded into the diagnostic printer.
9983  S.Diag(Templated->getLocation(),
9984  diag::note_ovl_candidate_non_deduced_mismatch_qualified)
9985  << FirstTN.getAsTemplateDecl() << SecondTN.getAsTemplateDecl();
9986  return;
9987  }
9988  }
9989  }
9990 
9991  if (TakingCandidateAddress && isa<FunctionDecl>(Templated) &&
9992  !checkAddressOfCandidateIsAvailable(S, cast<FunctionDecl>(Templated)))
9993  return;
9994 
9995  // FIXME: For generic lambda parameters, check if the function is a lambda
9996  // call operator, and if so, emit a prettier and more informative
9997  // diagnostic that mentions 'auto' and lambda in addition to
9998  // (or instead of?) the canonical template type parameters.
9999  S.Diag(Templated->getLocation(),
10000  diag::note_ovl_candidate_non_deduced_mismatch)
10001  << FirstTA << SecondTA;
10002  return;
10003  }
10004  // TODO: diagnose these individually, then kill off
10005  // note_ovl_candidate_bad_deduction, which is uselessly vague.
10007  S.Diag(Templated->getLocation(), diag::note_ovl_candidate_bad_deduction);
10008  MaybeEmitInheritedConstructorNote(S, Found);
10009  return;
10011  S.Diag(Templated->getLocation(),
10012  diag::note_cuda_ovl_candidate_target_mismatch);
10013  return;
10014  }
10015 }
10016 
10017 /// Diagnose a failed template-argument deduction, for function calls.
10019  unsigned NumArgs,
10020  bool TakingCandidateAddress) {
10021  unsigned TDK = Cand->DeductionFailure.Result;
10023  if (CheckArityMismatch(S, Cand, NumArgs))
10024  return;
10025  }
10026  DiagnoseBadDeduction(S, Cand->FoundDecl, Cand->Function, // pattern
10027  Cand->DeductionFailure, NumArgs, TakingCandidateAddress);
10028 }
10029 
10030 /// CUDA: diagnose an invalid call across targets.
10031 static void DiagnoseBadTarget(Sema &S, OverloadCandidate *Cand) {
10032  FunctionDecl *Caller = cast<FunctionDecl>(S.CurContext);
10033  FunctionDecl *Callee = Cand->Function;
10034 
10035  Sema::CUDAFunctionTarget CallerTarget = S.IdentifyCUDATarget(Caller),
10036  CalleeTarget = S.IdentifyCUDATarget(Callee);
10037 
10038  std::string FnDesc;
10039  OverloadCandidateKind FnKind =
10040  ClassifyOverloadCandidate(S, Cand->FoundDecl, Callee, FnDesc);
10041 
10042  S.Diag(Callee->getLocation(), diag::note_ovl_candidate_bad_target)
10043  << (unsigned)FnKind << CalleeTarget << CallerTarget;
10044 
10045  // This could be an implicit constructor for which we could not infer the
10046  // target due to a collsion. Diagnose that case.
10047  CXXMethodDecl *Meth = dyn_cast<CXXMethodDecl>(Callee);
10048  if (Meth != nullptr && Meth->isImplicit()) {
10049  CXXRecordDecl *ParentClass = Meth->getParent();
10051 
10052  switch (FnKind) {
10053  default:
10054  return;
10055  case oc_implicit_default_constructor:
10057  break;
10058  case oc_implicit_copy_constructor:
10060  break;
10061  case oc_implicit_move_constructor:
10063  break;
10064  case oc_implicit_copy_assignment:
10066  break;
10067  case oc_implicit_move_assignment:
10069  break;
10070  };
10071 
10072  bool ConstRHS = false;
10073  if (Meth->getNumParams()) {
10074  if (const ReferenceType *RT =
10075  Meth->getParamDecl(0)->getType()->getAs<ReferenceType>()) {
10076  ConstRHS = RT->getPointeeType().isConstQualified();
10077  }
10078  }
10079 
10080  S.inferCUDATargetForImplicitSpecialMember(ParentClass, CSM, Meth,
10081  /* ConstRHS */ ConstRHS,
10082  /* Diagnose */ true);
10083  }
10084 }
10085 
10087  FunctionDecl *Callee = Cand->Function;
10088  EnableIfAttr *Attr = static_cast<EnableIfAttr*>(Cand->DeductionFailure.Data);
10089 
10090  S.Diag(Callee->getLocation(),
10091  diag::note_ovl_candidate_disabled_by_function_cond_attr)
10092  << Attr->getCond()->getSourceRange() << Attr->getMessage();
10093 }
10094 
10096  FunctionDecl *Callee = Cand->Function;
10097 
10098  S.Diag(Callee->getLocation(),
10099  diag::note_ovl_candidate_disabled_by_extension);
10100 }
10101 
10102 /// Generates a 'note' diagnostic for an overload candidate. We've
10103 /// already generated a primary error at the call site.
10104 ///
10105 /// It really does need to be a single diagnostic with its caret
10106 /// pointed at the candidate declaration. Yes, this creates some
10107 /// major challenges of technical writing. Yes, this makes pointing
10108 /// out problems with specific arguments quite awkward. It's still
10109 /// better than generating twenty screens of text for every failed
10110 /// overload.
10111 ///
10112 /// It would be great to be able to express per-candidate problems
10113 /// more richly for those diagnostic clients that cared, but we'd
10114 /// still have to be just as careful with the default diagnostics.
10116  unsigned NumArgs,
10117  bool TakingCandidateAddress) {
10118  FunctionDecl *Fn = Cand->Function;
10119 
10120  // Note deleted candidates, but only if they're viable.
10121  if (Cand->Viable) {
10122  if (Fn->isDeleted() || S.isFunctionConsideredUnavailable(Fn)) {
10123  std::string FnDesc;
10124  OverloadCandidateKind FnKind =
10125  ClassifyOverloadCandidate(S, Cand->FoundDecl, Fn, FnDesc);
10126 
10127  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_deleted)
10128  << FnKind << FnDesc
10129  << (Fn->isDeleted() ? (Fn->isDeletedAsWritten() ? 1 : 2) : 0);
10130  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
10131  return;
10132  }
10133 
10134  // We don't really have anything else to say about viable candidates.
10135  S.NoteOverloadCandidate(Cand->FoundDecl, Fn);
10136  return;
10137  }
10138 
10139  switch (Cand->FailureKind) {
10142  return DiagnoseArityMismatch(S, Cand, NumArgs);
10143 
10145  return DiagnoseBadDeduction(S, Cand, NumArgs,
10146  TakingCandidateAddress);
10147 
10149  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_illegal_constructor)
10150  << (Fn->getPrimaryTemplate() ? 1 : 0);
10151  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
10152  return;
10153  }
10154 
10158  return S.NoteOverloadCandidate(Cand->FoundDecl, Fn);
10159 
10160  case ovl_fail_bad_conversion: {
10161  unsigned I = (Cand->IgnoreObjectArgument ? 1 : 0);
10162  for (unsigned N = Cand->Conversions.size(); I != N; ++I)
10163  if (Cand->Conversions[I].isBad())
10164  return DiagnoseBadConversion(S, Cand, I, TakingCandidateAddress);
10165 
10166  // FIXME: this currently happens when we're called from SemaInit
10167  // when user-conversion overload fails. Figure out how to handle
10168  // those conditions and diagnose them well.
10169  return S.NoteOverloadCandidate(Cand->FoundDecl, Fn);
10170  }
10171 
10172  case ovl_fail_bad_target:
10173  return DiagnoseBadTarget(S, Cand);
10174 
10175  case ovl_fail_enable_if:
10176  return DiagnoseFailedEnableIfAttr(S, Cand);
10177 
10178  case ovl_fail_ext_disabled:
10179  return DiagnoseOpenCLExtensionDisabled(S, Cand);
10180 
10182  // It's generally not interesting to note copy/move constructors here.
10183  if (cast<CXXConstructorDecl>(Fn)->isCopyOrMoveConstructor())
10184  return;
10185  S.Diag(Fn->getLocation(),
10186  diag::note_ovl_candidate_inherited_constructor_slice)
10187  << (Fn->getPrimaryTemplate() ? 1 : 0)
10188  << Fn->getParamDecl(0)->getType()->isRValueReferenceType();
10189  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
10190  return;
10191 
10193  bool Available = checkAddressOfCandidateIsAvailable(S, Cand->Function);
10194  (void)Available;
10195  assert(!Available);
10196  break;
10197  }
10198  }
10199 }
10200 
10202  // Desugar the type of the surrogate down to a function type,
10203  // retaining as many typedefs as possible while still showing
10204  // the function type (and, therefore, its parameter types).
10205  QualType FnType = Cand->Surrogate->getConversionType();
10206  bool isLValueReference = false;
10207  bool isRValueReference = false;
10208  bool isPointer = false;
10209  if (const LValueReferenceType *FnTypeRef =
10210  FnType->getAs<LValueReferenceType>()) {
10211  FnType = FnTypeRef->getPointeeType();
10212  isLValueReference = true;
10213  } else if (const RValueReferenceType *FnTypeRef =
10214  FnType->getAs<RValueReferenceType>()) {
10215  FnType = FnTypeRef->getPointeeType();
10216  isRValueReference = true;
10217  }
10218  if (const PointerType *FnTypePtr = FnType->getAs<PointerType>()) {
10219  FnType = FnTypePtr->getPointeeType();
10220  isPointer = true;
10221  }
10222  // Desugar down to a function type.
10223  FnType = QualType(FnType->getAs<FunctionType>(), 0);
10224  // Reconstruct the pointer/reference as appropriate.
10225  if (isPointer) FnType = S.Context.getPointerType(FnType);
10226  if (isRValueReference) FnType = S.Context.getRValueReferenceType(FnType);
10227  if (isLValueReference) FnType = S.Context.getLValueReferenceType(FnType);
10228 
10229  S.Diag(Cand->Surrogate->getLocation(), diag::note_ovl_surrogate_cand)
10230  << FnType;
10231 }
10232 
10233 static void NoteBuiltinOperatorCandidate(Sema &S, StringRef Opc,
10234  SourceLocation OpLoc,
10235  OverloadCandidate *Cand) {
10236  assert(Cand->Conversions.size() <= 2 && "builtin operator is not binary");
10237  std::string TypeStr("operator");
10238  TypeStr += Opc;
10239  TypeStr += "(";
10240  TypeStr += Cand->BuiltinParamTypes[0].getAsString();
10241  if (Cand->Conversions.size() == 1) {
10242  TypeStr += ")";
10243  S.Diag(OpLoc, diag::note_ovl_builtin_unary_candidate) << TypeStr;
10244  } else {
10245  TypeStr += ", ";
10246  TypeStr += Cand->BuiltinParamTypes[1].getAsString();
10247  TypeStr += ")";
10248  S.Diag(OpLoc, diag::note_ovl_builtin_binary_candidate) << TypeStr;
10249  }
10250 }
10251 
10253  OverloadCandidate *Cand) {
10254  for (const ImplicitConversionSequence &ICS : Cand->Conversions) {
10255  if (ICS.isBad()) break; // all meaningless after first invalid
10256  if (!ICS.isAmbiguous()) continue;
10257 
10259  S, OpLoc, S.PDiag(diag::note_ambiguous_type_conversion));
10260  }
10261 }
10262 
10264  if (Cand->Function)
10265  return Cand->Function->getLocation();
10266  if (Cand->IsSurrogate)
10267  return Cand->Surrogate->getLocation();
10268  return SourceLocation();
10269 }
10270 
10271 static unsigned RankDeductionFailure(const DeductionFailureInfo &DFI) {
10272  switch ((Sema::TemplateDeductionResult)DFI.Result) {
10273  case Sema::TDK_Success:
10275  llvm_unreachable("non-deduction failure while diagnosing bad deduction");
10276 
10277  case Sema::TDK_Invalid:
10278  case Sema::TDK_Incomplete:
10279  return 1;
10280 
10283  return 2;
10284 
10291  return 3;
10292 
10294  return 4;
10295 
10297  return 5;
10298 
10301  return 6;
10302  }
10303  llvm_unreachable("Unhandled deduction result");
10304 }
10305 
10306 namespace {
10307 struct CompareOverloadCandidatesForDisplay {
10308  Sema &S;
10309  SourceLocation Loc;
10310  size_t NumArgs;
10312 
10313  CompareOverloadCandidatesForDisplay(
10314  Sema &S, SourceLocation Loc, size_t NArgs,
10316  : S(S), NumArgs(NArgs), CSK(CSK) {}
10317 
10318  bool operator()(const OverloadCandidate *L,
10319  const OverloadCandidate *R) {
10320  // Fast-path this check.
10321  if (L == R) return false;
10322 
10323  // Order first by viability.
10324  if (L->Viable) {
10325  if (!R->Viable) return true;
10326 
10327  // TODO: introduce a tri-valued comparison for overload
10328  // candidates. Would be more worthwhile if we had a sort
10329  // that could exploit it.
10330  if (isBetterOverloadCandidate(S, *L, *R, SourceLocation(), CSK))
10331  return true;
10332  if (isBetterOverloadCandidate(S, *R, *L, SourceLocation(), CSK))
10333  return false;
10334  } else if (R->Viable)
10335  return false;
10336 
10337  assert(L->Viable == R->Viable);
10338 
10339  // Criteria by which we can sort non-viable candidates:
10340  if (!L->Viable) {
10341  // 1. Arity mismatches come after other candidates.
10346  int LDist = std::abs((int)L->getNumParams() - (int)NumArgs);
10347  int RDist = std::abs((int)R->getNumParams() - (int)NumArgs);
10348  if (LDist == RDist) {
10349  if (L->FailureKind == R->FailureKind)
10350  // Sort non-surrogates before surrogates.
10351  return !L->IsSurrogate && R->IsSurrogate;
10352  // Sort candidates requiring fewer parameters than there were
10353  // arguments given after candidates requiring more parameters
10354  // than there were arguments given.
10356  }
10357  return LDist < RDist;
10358  }
10359  return false;
10360  }
10363  return true;
10364 
10365  // 2. Bad conversions come first and are ordered by the number
10366  // of bad conversions and quality of good conversions.
10369  return true;
10370 
10371  // The conversion that can be fixed with a smaller number of changes,
10372  // comes first.
10373  unsigned numLFixes = L->Fix.NumConversionsFixed;
10374  unsigned numRFixes = R->Fix.NumConversionsFixed;
10375  numLFixes = (numLFixes == 0) ? UINT_MAX : numLFixes;
10376  numRFixes = (numRFixes == 0) ? UINT_MAX : numRFixes;
10377  if (numLFixes != numRFixes) {
10378  return numLFixes < numRFixes;
10379  }
10380 
10381  // If there's any ordering between the defined conversions...
10382  // FIXME: this might not be transitive.
10383  assert(L->Conversions.size() == R->Conversions.size());
10384 
10385  int leftBetter = 0;
10386  unsigned I = (L->IgnoreObjectArgument || R->IgnoreObjectArgument);
10387  for (unsigned E = L->Conversions.size(); I != E; ++I) {
10388  switch (CompareImplicitConversionSequences(S, Loc,
10389  L->Conversions[I],
10390  R->Conversions[I])) {
10392  leftBetter++;
10393  break;
10394 
10396  leftBetter--;
10397  break;
10398 
10400  break;
10401  }
10402  }
10403  if (leftBetter > 0) return true;
10404  if (leftBetter < 0) return false;
10405 
10406  } else if (R->FailureKind == ovl_fail_bad_conversion)
10407  return false;
10408 
10409  if (L->FailureKind == ovl_fail_bad_deduction) {
10411  return true;
10412 
10416  } else if (R->FailureKind == ovl_fail_bad_deduction)
10417  return false;
10418 
10419  // TODO: others?
10420  }
10421 
10422  // Sort everything else by location.
10425 
10426  // Put candidates without locations (e.g. builtins) at the end.
10427  if (LLoc.isInvalid()) return false;
10428  if (RLoc.isInvalid()) return true;
10429 
10430  return S.SourceMgr.isBeforeInTranslationUnit(LLoc, RLoc);
10431  }
10432 };
10433 }
10434 
10435 /// CompleteNonViableCandidate - Normally, overload resolution only
10436 /// computes up to the first bad conversion. Produces the FixIt set if
10437 /// possible.
10439  ArrayRef<Expr *> Args) {
10440  assert(!Cand->Viable);
10441 
10442  // Don't do anything on failures other than bad conversion.
10443  if (Cand->FailureKind != ovl_fail_bad_conversion) return;
10444 
10445  // We only want the FixIts if all the arguments can be corrected.
10446  bool Unfixable = false;
10447  // Use a implicit copy initialization to check conversion fixes.
10449 
10450  // Attempt to fix the bad conversion.
10451  unsigned ConvCount = Cand->Conversions.size();
10452  for (unsigned ConvIdx = (Cand->IgnoreObjectArgument ? 1 : 0); /**/;
10453  ++ConvIdx) {
10454  assert(ConvIdx != ConvCount && "no bad conversion in candidate");
10455  if (Cand->Conversions[ConvIdx].isInitialized() &&
10456  Cand->Conversions[ConvIdx].isBad()) {
10457  Unfixable = !Cand->TryToFixBadConversion(ConvIdx, S);
10458  break;
10459  }
10460  }
10461 
10462  // FIXME: this should probably be preserved from the overload
10463  // operation somehow.
10464  bool SuppressUserConversions = false;
10465 
10466  unsigned ConvIdx = 0;
10467  ArrayRef<QualType> ParamTypes;
10468 
10469  if (Cand->IsSurrogate) {
10470  QualType ConvType
10472  if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>())
10473  ConvType = ConvPtrType->getPointeeType();
10474  ParamTypes = ConvType->getAs<FunctionProtoType>()->getParamTypes();
10475  // Conversion 0 is 'this', which doesn't have a corresponding argument.
10476  ConvIdx = 1;
10477  } else if (Cand->Function) {
10478  ParamTypes =
10479  Cand->Function->getType()->getAs<FunctionProtoType>()->getParamTypes();
10480  if (isa<CXXMethodDecl>(Cand->Function) &&
10481  !isa<CXXConstructorDecl>(Cand->Function)) {
10482  // Conversion 0 is 'this', which doesn't have a corresponding argument.
10483  ConvIdx = 1;
10484  }
10485  } else {
10486  // Builtin operator.
10487  assert(ConvCount <= 3);
10488  ParamTypes = Cand->BuiltinParamTypes;
10489  }
10490 
10491  // Fill in the rest of the conversions.
10492  for (unsigned ArgIdx = 0; ConvIdx != ConvCount; ++ConvIdx, ++ArgIdx) {
10493  if (Cand->Conversions[ConvIdx].isInitialized()) {
10494  // We've already checked this conversion.
10495  } else if (ArgIdx < ParamTypes.size()) {
10496  if (ParamTypes[ArgIdx]->isDependentType())
10497  Cand->Conversions[ConvIdx].setAsIdentityConversion(
10498  Args[ArgIdx]->getType());
10499  else {
10500  Cand->Conversions[ConvIdx] =
10501  TryCopyInitialization(S, Args[ArgIdx], ParamTypes[ArgIdx],
10502  SuppressUserConversions,
10503  /*InOverloadResolution=*/true,
10504  /*AllowObjCWritebackConversion=*/
10505  S.getLangOpts().ObjCAutoRefCount);
10506  // Store the FixIt in the candidate if it exists.
10507  if (!Unfixable && Cand->Conversions[ConvIdx].isBad())
10508  Unfixable = !Cand->TryToFixBadConversion(ConvIdx, S);
10509  }
10510  } else
10511  Cand->Conversions[ConvIdx].setEllipsis();
10512  }
10513 }
10514 
10515 /// PrintOverloadCandidates - When overload resolution fails, prints
10516 /// diagnostic messages containing the candidates in the candidate
10517 /// set.
10520  StringRef Opc, SourceLocation OpLoc,
10521  llvm::function_ref<bool(OverloadCandidate &)> Filter) {
10522  // Sort the candidates by viability and position. Sorting directly would
10523  // be prohibitive, so we make a set of pointers and sort those.
10525  if (OCD == OCD_AllCandidates) Cands.reserve(size());
10526  for (iterator Cand = begin(), LastCand = end(); Cand != LastCand; ++Cand) {
10527  if (!Filter(*Cand))
10528  continue;
10529  if (Cand->Viable)
10530  Cands.push_back(Cand);
10531  else if (OCD == OCD_AllCandidates) {
10532  CompleteNonViableCandidate(S, Cand, Args);
10533  if (Cand->Function || Cand->IsSurrogate)
10534  Cands.push_back(Cand);
10535  // Otherwise, this a non-viable builtin candidate. We do not, in general,
10536  // want to list every possible builtin candidate.
10537  }
10538  }
10539 
10540  std::stable_sort(Cands.begin(), Cands.end(),
10541  CompareOverloadCandidatesForDisplay(S, OpLoc, Args.size(), Kind));
10542 
10543  bool ReportedAmbiguousConversions = false;
10544 
10546  const OverloadsShown ShowOverloads = S.Diags.getShowOverloads();
10547  unsigned CandsShown = 0;
10548  for (I = Cands.begin(), E = Cands.end(); I != E; ++I) {
10549  OverloadCandidate *Cand = *I;
10550 
10551  // Set an arbitrary limit on the number of candidate functions we'll spam
10552  // the user with. FIXME: This limit should depend on details of the
10553  // candidate list.
10554  if (CandsShown >= 4 && ShowOverloads == Ovl_Best) {
10555  break;
10556  }
10557  ++CandsShown;
10558 
10559  if (Cand->Function)
10560  NoteFunctionCandidate(S, Cand, Args.size(),
10561  /*TakingCandidateAddress=*/false);
10562  else if (Cand->IsSurrogate)
10563  NoteSurrogateCandidate(S, Cand);
10564  else {
10565  assert(Cand->Viable &&
10566  "Non-viable built-in candidates are not added to Cands.");
10567  // Generally we only see ambiguities including viable builtin
10568  // operators if overload resolution got screwed up by an
10569  // ambiguous user-defined conversion.
10570  //
10571  // FIXME: It's quite possible for different conversions to see
10572  // different ambiguities, though.
10573  if (!ReportedAmbiguousConversions) {
10574  NoteAmbiguousUserConversions(S, OpLoc, Cand);
10575  ReportedAmbiguousConversions = true;
10576  }
10577 
10578  // If this is a viable builtin, print it.
10579  NoteBuiltinOperatorCandidate(S, Opc, OpLoc, Cand);
10580  }
10581  }
10582 
10583  if (I != E)
10584  S.Diag(OpLoc, diag::note_ovl_too_many_candidates) << int(E - I);
10585 }
10586 
10587 static SourceLocation
10589  return Cand->Specialization ? Cand->Specialization->getLocation()
10590  : SourceLocation();
10591 }
10592 
10593 namespace {
10594 struct CompareTemplateSpecCandidatesForDisplay {
10595  Sema &S;
10596  CompareTemplateSpecCandidatesForDisplay(Sema &S) : S(S) {}
10597 
10598  bool operator()(const TemplateSpecCandidate *L,
10599  const TemplateSpecCandidate *R) {
10600  // Fast-path this check.
10601  if (L == R)
10602  return false;
10603 
10604  // Assuming that both candidates are not matches...
10605 
10606  // Sort by the ranking of deduction failures.
10610 
10611  // Sort everything else by location.
10614 
10615  // Put candidates without locations (e.g. builtins) at the end.
10616  if (LLoc.isInvalid())
10617  return false;
10618  if (RLoc.isInvalid())
10619  return true;
10620 
10621  return S.SourceMgr.isBeforeInTranslationUnit(LLoc, RLoc);
10622  }
10623 };
10624 }
10625 
10626 /// Diagnose a template argument deduction failure.
10627 /// We are treating these failures as overload failures due to bad
10628 /// deductions.
10630  bool ForTakingAddress) {
10631  DiagnoseBadDeduction(S, FoundDecl, Specialization, // pattern
10632  DeductionFailure, /*NumArgs=*/0, ForTakingAddress);
10633 }
10634 
10635 void TemplateSpecCandidateSet::destroyCandidates() {
10636  for (iterator i = begin(), e = end(); i != e; ++i) {
10637  i->DeductionFailure.Destroy();
10638  }
10639 }
10640 
10642  destroyCandidates();
10643  Candidates.clear();
10644 }
10645 
10646 /// NoteCandidates - When no template specialization match is found, prints
10647 /// diagnostic messages containing the non-matching specializations that form
10648 /// the candidate set.
10649 /// This is analoguous to OverloadCandidateSet::NoteCandidates() with
10650 /// OCD == OCD_AllCandidates and Cand->Viable == false.
10652  // Sort the candidates by position (assuming no candidate is a match).
10653  // Sorting directly would be prohibitive, so we make a set of pointers
10654  // and sort those.
10656  Cands.reserve(size());
10657  for (iterator Cand = begin(), LastCand = end(); Cand != LastCand; ++Cand) {
10658  if (Cand->Specialization)
10659  Cands.push_back(Cand);
10660  // Otherwise, this is a non-matching builtin candidate. We do not,
10661  // in general, want to list every possible builtin candidate.
10662  }
10663 
10664  std::sort(Cands.begin(), Cands.end(),
10665  CompareTemplateSpecCandidatesForDisplay(S));
10666 
10667  // FIXME: Perhaps rename OverloadsShown and getShowOverloads()
10668  // for generalization purposes (?).
10669  const OverloadsShown ShowOverloads = S.Diags.getShowOverloads();
10670 
10672  unsigned CandsShown = 0;
10673  for (I = Cands.begin(), E = Cands.end(); I != E; ++I) {
10674  TemplateSpecCandidate *Cand = *I;
10675 
10676  // Set an arbitrary limit on the number of candidates we'll spam
10677  // the user with. FIXME: This limit should depend on details of the
10678  // candidate list.
10679  if (CandsShown >= 4 && ShowOverloads == Ovl_Best)
10680  break;
10681  ++CandsShown;
10682 
10683  assert(Cand->Specialization &&
10684  "Non-matching built-in candidates are not added to Cands.");
10685  Cand->NoteDeductionFailure(S, ForTakingAddress);
10686  }
10687 
10688  if (I != E)
10689  S.Diag(Loc, diag::note_ovl_too_many_candidates) << int(E - I);
10690 }
10691 
10692 // [PossiblyAFunctionType] --> [Return]
10693 // NonFunctionType --> NonFunctionType
10694 // R (A) --> R(A)
10695 // R (*)(A) --> R (A)
10696 // R (&)(A) --> R (A)
10697 // R (S::*)(A) --> R (A)
10699  QualType Ret = PossiblyAFunctionType;
10700  if (const PointerType *ToTypePtr =
10701  PossiblyAFunctionType->getAs<PointerType>())
10702  Ret = ToTypePtr->getPointeeType();
10703  else if (const ReferenceType *ToTypeRef =
10704  PossiblyAFunctionType->getAs<ReferenceType>())
10705  Ret = ToTypeRef->getPointeeType();
10706  else if (const MemberPointerType *MemTypePtr =
10707  PossiblyAFunctionType->getAs<MemberPointerType>())
10708  Ret = MemTypePtr->getPointeeType();
10709  Ret =
10710  Context.getCanonicalType(Ret).getUnqualifiedType();
10711  return Ret;
10712 }
10713 
10715  bool Complain = true) {
10716  if (S.getLangOpts().CPlusPlus14 && FD->getReturnType()->isUndeducedType() &&
10717  S.DeduceReturnType(FD, Loc, Complain))
10718  return true;
10719 
10720  auto *FPT = FD->getType()->castAs<FunctionProtoType>();
10721  if (S.getLangOpts().CPlusPlus17 &&
10722  isUnresolvedExceptionSpec(FPT->getExceptionSpecType()) &&
10723  !S.ResolveExceptionSpec(Loc, FPT))
10724  return true;
10725 
10726  return false;
10727 }
10728 
10729 namespace {
10730 // A helper class to help with address of function resolution
10731 // - allows us to avoid passing around all those ugly parameters
10732 class AddressOfFunctionResolver {
10733  Sema& S;
10734  Expr* SourceExpr;
10735  const QualType& TargetType;
10736  QualType TargetFunctionType; // Extracted function type from target type
10737 
10738  bool Complain;
10739  //DeclAccessPair& ResultFunctionAccessPair;
10740  ASTContext& Context;
10741 
10742  bool TargetTypeIsNonStaticMemberFunction;
10743  bool FoundNonTemplateFunction;
10744  bool StaticMemberFunctionFromBoundPointer;
10745  bool HasComplained;
10746 
10747  OverloadExpr::FindResult OvlExprInfo;
10748  OverloadExpr *OvlExpr;
10749  TemplateArgumentListInfo OvlExplicitTemplateArgs;
10751  TemplateSpecCandidateSet FailedCandidates;
10752 
10753 public:
10754  AddressOfFunctionResolver(Sema &S, Expr *SourceExpr,
10755  const QualType &TargetType, bool Complain)
10756  : S(S), SourceExpr(SourceExpr), TargetType(TargetType),
10757  Complain(Complain), Context(S.getASTContext()),
10758  TargetTypeIsNonStaticMemberFunction(
10759  !!TargetType->getAs<MemberPointerType>()),
10760  FoundNonTemplateFunction(false),
10761  StaticMemberFunctionFromBoundPointer(false),
10762  HasComplained(false),
10763  OvlExprInfo(OverloadExpr::find(SourceExpr)),
10764  OvlExpr(OvlExprInfo.Expression),
10765  FailedCandidates(OvlExpr->getNameLoc(), /*ForTakingAddress=*/true) {
10766  ExtractUnqualifiedFunctionTypeFromTargetType();
10767 
10768  if (TargetFunctionType->isFunctionType()) {
10769  if (UnresolvedMemberExpr *UME = dyn_cast<UnresolvedMemberExpr>(OvlExpr))
10770  if (!UME->isImplicitAccess() &&
10772  StaticMemberFunctionFromBoundPointer = true;
10773  } else if (OvlExpr->hasExplicitTemplateArgs()) {
10774  DeclAccessPair dap;
10776  OvlExpr, false, &dap)) {
10777  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn))
10778  if (!Method->isStatic()) {
10779  // If the target type is a non-function type and the function found
10780  // is a non-static member function, pretend as if that was the
10781  // target, it's the only possible type to end up with.
10782  TargetTypeIsNonStaticMemberFunction = true;
10783 
10784  // And skip adding the function if its not in the proper form.
10785  // We'll diagnose this due to an empty set of functions.
10786  if (!OvlExprInfo.HasFormOfMemberPointer)
10787  return;
10788  }
10789 
10790  Matches.push_back(std::make_pair(dap, Fn));
10791  }
10792  return;
10793  }
10794 
10795  if (OvlExpr->hasExplicitTemplateArgs())
10796  OvlExpr->copyTemplateArgumentsInto(OvlExplicitTemplateArgs);
10797 
10798  if (FindAllFunctionsThatMatchTargetTypeExactly()) {
10799  // C++ [over.over]p4:
10800  // If more than one function is selected, [...]
10801  if (Matches.size() > 1 && !eliminiateSuboptimalOverloadCandidates()) {
10802  if (FoundNonTemplateFunction)
10803  EliminateAllTemplateMatches();
10804  else
10805  EliminateAllExceptMostSpecializedTemplate();
10806  }
10807  }
10808 
10809  if (S.getLangOpts().CUDA && Matches.size() > 1)
10810  EliminateSuboptimalCudaMatches();
10811  }
10812 
10813  bool hasComplained() const { return HasComplained; }
10814 
10815 private:
10816  bool candidateHasExactlyCorrectType(const FunctionDecl *FD) {
10817  QualType Discard;
10818  return Context.hasSameUnqualifiedType(TargetFunctionType, FD->getType()) ||
10819  S.IsFunctionConversion(FD->getType(), TargetFunctionType, Discard);
10820  }
10821 
10822  /// \return true if A is considered a better overload candidate for the
10823  /// desired type than B.
10824  bool isBetterCandidate(const FunctionDecl *A, const FunctionDecl *B) {
10825  // If A doesn't have exactly the correct type, we don't want to classify it
10826  // as "better" than anything else. This way, the user is required to
10827  // disambiguate for us if there are multiple candidates and no exact match.
10828  return candidateHasExactlyCorrectType(A) &&
10829  (!candidateHasExactlyCorrectType(B) ||
10830  compareEnableIfAttrs(S, A, B) == Comparison::Better);
10831  }
10832 
10833  /// \return true if we were able to eliminate all but one overload candidate,
10834  /// false otherwise.
10835  bool eliminiateSuboptimalOverloadCandidates() {
10836  // Same algorithm as overload resolution -- one pass to pick the "best",
10837  // another pass to be sure that nothing is better than the best.
10838  auto Best = Matches.begin();
10839  for (auto I = Matches.begin()+1, E = Matches.end(); I != E; ++I)
10840  if (isBetterCandidate(I->second, Best->second))
10841  Best = I;
10842 
10843  const FunctionDecl *BestFn = Best->second;
10844  auto IsBestOrInferiorToBest = [this, BestFn](
10845  const std::pair<DeclAccessPair, FunctionDecl *> &Pair) {
10846  return BestFn == Pair.second || isBetterCandidate(BestFn, Pair.second);
10847  };
10848 
10849  // Note: We explicitly leave Matches unmodified if there isn't a clear best
10850  // option, so we can potentially give the user a better error
10851  if (!std::all_of(Matches.begin(), Matches.end(), IsBestOrInferiorToBest))
10852  return false;
10853  Matches[0] = *Best;
10854  Matches.resize(1);
10855  return true;
10856  }
10857 
10858  bool isTargetTypeAFunction() const {
10859  return TargetFunctionType->isFunctionType();
10860  }
10861 
10862  // [ToType] [Return]
10863 
10864  // R (*)(A) --> R (A), IsNonStaticMemberFunction = false
10865  // R (&)(A) --> R (A), IsNonStaticMemberFunction = false
10866  // R (S::*)(A) --> R (A), IsNonStaticMemberFunction = true
10867  void inline ExtractUnqualifiedFunctionTypeFromTargetType() {
10868  TargetFunctionType = S.ExtractUnqualifiedFunctionType(TargetType);
10869  }
10870 
10871  // return true if any matching specializations were found
10872  bool AddMatchingTemplateFunction(FunctionTemplateDecl* FunctionTemplate,
10873  const DeclAccessPair& CurAccessFunPair) {
10874  if (CXXMethodDecl *Method
10875  = dyn_cast<CXXMethodDecl>(FunctionTemplate->getTemplatedDecl())) {
10876  // Skip non-static function templates when converting to pointer, and
10877  // static when converting to member pointer.
10878  if (Method->isStatic() == TargetTypeIsNonStaticMemberFunction)
10879  return false;
10880  }
10881  else if (TargetTypeIsNonStaticMemberFunction)
10882  return false;
10883 
10884  // C++ [over.over]p2:
10885  // If the name is a function template, template argument deduction is
10886  // done (14.8.2.2), and if the argument deduction succeeds, the
10887  // resulting template argument list is used to generate a single
10888  // function template specialization, which is added to the set of
10889  // overloaded functions considered.
10890  FunctionDecl *Specialization = nullptr;
10891  TemplateDeductionInfo Info(FailedCandidates.getLocation());
10893  = S.DeduceTemplateArguments(FunctionTemplate,
10894  &OvlExplicitTemplateArgs,
10895  TargetFunctionType, Specialization,
10896  Info, /*IsAddressOfFunction*/true)) {
10897  // Make a note of the failed deduction for diagnostics.
10898  FailedCandidates.addCandidate()
10899  .set(CurAccessFunPair, FunctionTemplate->getTemplatedDecl(),
10900  MakeDeductionFailureInfo(Context, Result, Info));
10901  return false;
10902  }
10903 
10904  // Template argument deduction ensures that we have an exact match or
10905  // compatible pointer-to-function arguments that would be adjusted by ICS.
10906  // This function template specicalization works.
10908  Context.getCanonicalType(Specialization->getType()),
10909  Context.getCanonicalType(TargetFunctionType)));
10910 
10911  if (!S.checkAddressOfFunctionIsAvailable(Specialization))
10912  return false;
10913 
10914  Matches.push_back(std::make_pair(CurAccessFunPair, Specialization));
10915  return true;
10916  }
10917 
10918  bool AddMatchingNonTemplateFunction(NamedDecl* Fn,
10919  const DeclAccessPair& CurAccessFunPair) {
10920  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) {
10921  // Skip non-static functions when converting to pointer, and static
10922  // when converting to member pointer.
10923  if (Method->isStatic() == TargetTypeIsNonStaticMemberFunction)
10924  return false;
10925  }
10926  else if (TargetTypeIsNonStaticMemberFunction)
10927  return false;
10928 
10929  if (FunctionDecl *FunDecl = dyn_cast<FunctionDecl>(Fn)) {
10930  if (S.getLangOpts().CUDA)
10931  if (FunctionDecl *Caller = dyn_cast<FunctionDecl>(S.CurContext))
10932  if (!Caller->isImplicit() && !S.IsAllowedCUDACall(Caller, FunDecl))
10933  return false;
10934 
10935  // If any candidate has a placeholder return type, trigger its deduction
10936  // now.
10937  if (completeFunctionType(S, FunDecl, SourceExpr->getLocStart(),
10938  Complain)) {
10939  HasComplained |= Complain;
10940  return false;
10941  }
10942 
10943  if (!S.checkAddressOfFunctionIsAvailable(FunDecl))
10944  return false;
10945 
10946  // If we're in C, we need to support types that aren't exactly identical.
10947  if (!S.getLangOpts().CPlusPlus ||
10948  candidateHasExactlyCorrectType(FunDecl)) {
10949  Matches.push_back(std::make_pair(
10950  CurAccessFunPair, cast<FunctionDecl>(FunDecl->getCanonicalDecl())));
10951  FoundNonTemplateFunction = true;
10952  return true;
10953  }
10954  }
10955 
10956  return false;
10957  }
10958 
10959  bool FindAllFunctionsThatMatchTargetTypeExactly() {
10960  bool Ret = false;
10961 
10962  // If the overload expression doesn't have the form of a pointer to
10963  // member, don't try to convert it to a pointer-to-member type.
10964  if (IsInvalidFormOfPointerToMemberFunction())
10965  return false;
10966 
10967  for (UnresolvedSetIterator I = OvlExpr->decls_begin(),
10968  E = OvlExpr->decls_end();
10969  I != E; ++I) {
10970  // Look through any using declarations to find the underlying function.
10971  NamedDecl *Fn = (*I)->getUnderlyingDecl();
10972 
10973  // C++ [over.over]p3:
10974  // Non-member functions and static member functions match
10975  // targets of type "pointer-to-function" or "reference-to-function."
10976  // Nonstatic member functions match targets of
10977  // type "pointer-to-member-function."
10978  // Note that according to DR 247, the containing class does not matter.
10979  if (FunctionTemplateDecl *FunctionTemplate
10980  = dyn_cast<FunctionTemplateDecl>(Fn)) {
10981  if (AddMatchingTemplateFunction(FunctionTemplate, I.getPair()))
10982  Ret = true;
10983  }
10984  // If we have explicit template arguments supplied, skip non-templates.
10985  else if (!OvlExpr->hasExplicitTemplateArgs() &&
10986  AddMatchingNonTemplateFunction(Fn, I.getPair()))
10987  Ret = true;
10988  }
10989  assert(Ret || Matches.empty());
10990  return Ret;
10991  }
10992 
10993  void EliminateAllExceptMostSpecializedTemplate() {
10994  // [...] and any given function template specialization F1 is
10995  // eliminated if the set contains a second function template
10996  // specialization whose function template is more specialized
10997  // than the function template of F1 according to the partial
10998  // ordering rules of 14.5.5.2.
10999 
11000  // The algorithm specified above is quadratic. We instead use a
11001  // two-pass algorithm (similar to the one used to identify the
11002  // best viable function in an overload set) that identifies the
11003  // best function template (if it exists).
11004 
11005  UnresolvedSet<4> MatchesCopy; // TODO: avoid!
11006  for (unsigned I = 0, E = Matches.size(); I != E; ++I)
11007  MatchesCopy.addDecl(Matches[I].second, Matches[I].first.getAccess());
11008 
11009  // TODO: It looks like FailedCandidates does not serve much purpose
11010  // here, since the no_viable diagnostic has index 0.
11012  MatchesCopy.begin(), MatchesCopy.end(), FailedCandidates,
11013  SourceExpr->getLocStart(), S.PDiag(),
11014  S.PDiag(diag::err_addr_ovl_ambiguous)
11015  << Matches[0].second->getDeclName(),
11016  S.PDiag(diag::note_ovl_candidate)
11017  << (unsigned)oc_function_template,
11018  Complain, TargetFunctionType);
11019 
11020  if (Result != MatchesCopy.end()) {
11021  // Make it the first and only element
11022  Matches[0].first = Matches[Result - MatchesCopy.begin()].first;
11023  Matches[0].second = cast<FunctionDecl>(*Result);
11024  Matches.resize(1);
11025  } else
11026  HasComplained |= Complain;
11027  }
11028 
11029  void EliminateAllTemplateMatches() {
11030  // [...] any function template specializations in the set are
11031  // eliminated if the set also contains a non-template function, [...]
11032  for (unsigned I = 0, N = Matches.size(); I != N; ) {
11033  if (Matches[I].second->getPrimaryTemplate() == nullptr)
11034  ++I;
11035  else {
11036  Matches[I] = Matches[--N];
11037  Matches.resize(N);
11038  }
11039  }
11040  }
11041 
11042  void EliminateSuboptimalCudaMatches() {
11043  S.EraseUnwantedCUDAMatches(dyn_cast<FunctionDecl>(S.CurContext), Matches);
11044  }
11045 
11046 public:
11047  void ComplainNoMatchesFound() const {
11048  assert(Matches.empty());
11049  S.Diag(OvlExpr->getLocStart(), diag::err_addr_ovl_no_viable)
11050  << OvlExpr->getName() << TargetFunctionType
11051  << OvlExpr->getSourceRange();
11052  if (FailedCandidates.empty())
11053  S.NoteAllOverloadCandidates(OvlExpr, TargetFunctionType,
11054  /*TakingAddress=*/true);
11055  else {
11056  // We have some deduction failure messages. Use them to diagnose
11057  // the function templates, and diagnose the non-template candidates
11058  // normally.
11059  for (UnresolvedSetIterator I = OvlExpr->decls_begin(),
11060  IEnd = OvlExpr->decls_end();
11061  I != IEnd; ++I)
11062  if (FunctionDecl *Fun =
11063  dyn_cast<FunctionDecl>((*I)->getUnderlyingDecl()))
11065  S.NoteOverloadCandidate(*I, Fun, TargetFunctionType,
11066  /*TakingAddress=*/true);
11067  FailedCandidates.NoteCandidates(S, OvlExpr->getLocStart());
11068  }
11069  }
11070 
11071  bool IsInvalidFormOfPointerToMemberFunction() const {
11072  return TargetTypeIsNonStaticMemberFunction &&
11073  !OvlExprInfo.HasFormOfMemberPointer;
11074  }
11075 
11076  void ComplainIsInvalidFormOfPointerToMemberFunction() const {
11077  // TODO: Should we condition this on whether any functions might
11078  // have matched, or is it more appropriate to do that in callers?
11079  // TODO: a fixit wouldn't hurt.
11080  S.Diag(OvlExpr->getNameLoc(), diag::err_addr_ovl_no_qualifier)
11081  << TargetType << OvlExpr->getSourceRange();
11082  }
11083 
11084  bool IsStaticMemberFunctionFromBoundPointer() const {
11085  return StaticMemberFunctionFromBoundPointer;
11086  }
11087 
11088  void ComplainIsStaticMemberFunctionFromBoundPointer() const {
11089  S.Diag(OvlExpr->getLocStart(),
11090  diag::err_invalid_form_pointer_member_function)
11091  << OvlExpr->getSourceRange();
11092  }
11093 
11094  void ComplainOfInvalidConversion() const {
11095  S.Diag(OvlExpr->getLocStart(), diag::err_addr_ovl_not_func_ptrref)
11096  << OvlExpr->getName() << TargetType;
11097  }
11098 
11099  void ComplainMultipleMatchesFound() const {
11100  assert(Matches.size() > 1);
11101  S.Diag(OvlExpr->getLocStart(), diag::err_addr_ovl_ambiguous)
11102  << OvlExpr->getName()
11103  << OvlExpr->getSourceRange();
11104  S.NoteAllOverloadCandidates(OvlExpr, TargetFunctionType,
11105  /*TakingAddress=*/true);
11106  }
11107 
11108  bool hadMultipleCandidates() const { return (OvlExpr->getNumDecls() > 1); }
11109 
11110  int getNumMatches() const { return Matches.size(); }
11111 
11112  FunctionDecl* getMatchingFunctionDecl() const {
11113  if (Matches.size() != 1) return nullptr;
11114  return Matches[0].second;
11115  }
11116 
11117  const DeclAccessPair* getMatchingFunctionAccessPair() const {
11118  if (Matches.size() != 1) return nullptr;
11119  return &Matches[0].first;
11120  }
11121 };
11122 }
11123 
11124 /// ResolveAddressOfOverloadedFunction - Try to resolve the address of
11125 /// an overloaded function (C++ [over.over]), where @p From is an
11126 /// expression with overloaded function type and @p ToType is the type
11127 /// we're trying to resolve to. For example:
11128 ///
11129 /// @code
11130 /// int f(double);
11131 /// int f(int);
11132 ///
11133 /// int (*pfd)(double) = f; // selects f(double)
11134 /// @endcode
11135 ///
11136 /// This routine returns the resulting FunctionDecl if it could be
11137 /// resolved, and NULL otherwise. When @p Complain is true, this
11138 /// routine will emit diagnostics if there is an error.
11139 FunctionDecl *
11141  QualType TargetType,
11142  bool Complain,
11143  DeclAccessPair &FoundResult,
11144  bool *pHadMultipleCandidates) {
11145  assert(AddressOfExpr->getType() == Context.OverloadTy);
11146 
11147  AddressOfFunctionResolver Resolver(*this, AddressOfExpr, TargetType,
11148  Complain);
11149  int NumMatches = Resolver.getNumMatches();
11150  FunctionDecl *Fn = nullptr;
11151  bool ShouldComplain = Complain && !Resolver.hasComplained();
11152  if (NumMatches == 0 && ShouldComplain) {
11153  if (Resolver.IsInvalidFormOfPointerToMemberFunction())
11154  Resolver.ComplainIsInvalidFormOfPointerToMemberFunction();
11155  else
11156  Resolver.ComplainNoMatchesFound();
11157  }
11158  else if (NumMatches > 1 && ShouldComplain)
11159  Resolver.ComplainMultipleMatchesFound();
11160  else if (NumMatches == 1) {
11161  Fn = Resolver.getMatchingFunctionDecl();
11162  assert(Fn);
11163  if (auto *FPT = Fn->getType()->getAs<FunctionProtoType>())
11164  ResolveExceptionSpec(AddressOfExpr->getExprLoc(), FPT);
11165  FoundResult = *Resolver.getMatchingFunctionAccessPair();
11166  if (Complain) {
11167  if (Resolver.IsStaticMemberFunctionFromBoundPointer())
11168  Resolver.ComplainIsStaticMemberFunctionFromBoundPointer();
11169  else
11170  CheckAddressOfMemberAccess(AddressOfExpr, FoundResult);
11171  }
11172  }
11173 
11174  if (pHadMultipleCandidates)
11175  *pHadMultipleCandidates = Resolver.hadMultipleCandidates();
11176  return Fn;
11177 }
11178 
11179 /// \brief Given an expression that refers to an overloaded function, try to
11180 /// resolve that function to a single function that can have its address taken.
11181 /// This will modify `Pair` iff it returns non-null.
11182 ///
11183 /// This routine can only realistically succeed if all but one candidates in the
11184 /// overload set for SrcExpr cannot have their addresses taken.
11185 FunctionDecl *
11187  DeclAccessPair &Pair) {
11189  OverloadExpr *Ovl = R.Expression;
11190  FunctionDecl *Result = nullptr;
11191  DeclAccessPair DAP;
11192  // Don't use the AddressOfResolver because we're specifically looking for
11193  // cases where we have one overload candidate that lacks
11194  // enable_if/pass_object_size/...
11195  for (auto I = Ovl->decls_begin(), E = Ovl->decls_end(); I != E; ++I) {
11196  auto *FD = dyn_cast<FunctionDecl>(I->getUnderlyingDecl());
11197  if (!FD)
11198  return nullptr;
11199 
11201  continue;
11202 
11203  // We have more than one result; quit.
11204  if (Result)
11205  return nullptr;
11206  DAP = I.getPair();
11207  Result = FD;
11208  }
11209 
11210  if (Result)
11211  Pair = DAP;
11212  return Result;
11213 }
11214 
11215 /// \brief Given an overloaded function, tries to turn it into a non-overloaded
11216 /// function reference using resolveAddressOfOnlyViableOverloadCandidate. This
11217 /// will perform access checks, diagnose the use of the resultant decl, and, if
11218 /// requested, potentially perform a function-to-pointer decay.
11219 ///
11220 /// Returns false if resolveAddressOfOnlyViableOverloadCandidate fails.
11221 /// Otherwise, returns true. This may emit diagnostics and return true.
11223  ExprResult &SrcExpr, bool DoFunctionPointerConverion) {
11224  Expr *E = SrcExpr.get();
11225  assert(E->getType() == Context.OverloadTy && "SrcExpr must be an overload");
11226 
11227  DeclAccessPair DAP;
11228  FunctionDecl *Found = resolveAddressOfOnlyViableOverloadCandidate(E, DAP);
11229  if (!Found)
11230  return false;
11231 
11232  // Emitting multiple diagnostics for a function that is both inaccessible and
11233  // unavailable is consistent with our behavior elsewhere. So, always check
11234  // for both.
11235  DiagnoseUseOfDecl(Found, E->getExprLoc());
11236  CheckAddressOfMemberAccess(E, DAP);
11237  Expr *Fixed = FixOverloadedFunctionReference(E, DAP, Found);
11238  if (DoFunctionPointerConverion && Fixed->getType()->isFunctionType())
11239  SrcExpr = DefaultFunctionArrayConversion(Fixed, /*Diagnose=*/false);
11240  else
11241  SrcExpr = Fixed;
11242  return true;
11243 }
11244 
11245 /// \brief Given an expression that refers to an overloaded function, try to
11246 /// resolve that overloaded function expression down to a single function.
11247 ///
11248 /// This routine can only resolve template-ids that refer to a single function
11249 /// template, where that template-id refers to a single template whose template
11250 /// arguments are either provided by the template-id or have defaults,
11251 /// as described in C++0x [temp.arg.explicit]p3.
11252 ///
11253 /// If no template-ids are found, no diagnostics are emitted and NULL is
11254 /// returned.
11255 FunctionDecl *
11257  bool Complain,
11258  DeclAccessPair *FoundResult) {
11259  // C++ [over.over]p1:
11260  // [...] [Note: any redundant set of parentheses surrounding the
11261  // overloaded function name is ignored (5.1). ]
11262  // C++ [over.over]p1:
11263  // [...] The overloaded function name can be preceded by the &
11264  // operator.
11265 
11266  // If we didn't actually find any template-ids, we're done.
11267  if (!ovl->hasExplicitTemplateArgs())
11268  return nullptr;
11269 
11270  TemplateArgumentListInfo ExplicitTemplateArgs;
11271  ovl->copyTemplateArgumentsInto(ExplicitTemplateArgs);
11272  TemplateSpecCandidateSet FailedCandidates(ovl->getNameLoc());
11273 
11274  // Look through all of the overloaded functions, searching for one
11275  // whose type matches exactly.
11276  FunctionDecl *Matched = nullptr;
11277  for (UnresolvedSetIterator I = ovl->decls_begin(),
11278  E = ovl->decls_end(); I != E; ++I) {
11279  // C++0x [temp.arg.explicit]p3:
11280  // [...] In contexts where deduction is done and fails, or in contexts
11281  // where deduction is not done, if a template argument list is
11282  // specified and it, along with any default template arguments,
11283  // identifies a single function template specialization, then the
11284  // template-id is an lvalue for the function template specialization.
11285  FunctionTemplateDecl *FunctionTemplate
11286  = cast<FunctionTemplateDecl>((*I)->getUnderlyingDecl());
11287 
11288  // C++ [over.over]p2:
11289  // If the name is a function template, template argument deduction is
11290  // done (14.8.2.2), and if the argument deduction succeeds, the
11291  // resulting template argument list is used to generate a single
11292  // function template specialization, which is added to the set of
11293  // overloaded functions considered.
11294  FunctionDecl *Specialization = nullptr;
11295  TemplateDeductionInfo Info(FailedCandidates.getLocation());
11296  if (TemplateDeductionResult Result
11297  = DeduceTemplateArguments(FunctionTemplate, &ExplicitTemplateArgs,
11298  Specialization, Info,
11299  /*IsAddressOfFunction*/true)) {
11300  // Make a note of the failed deduction for diagnostics.
11301  // TODO: Actually use the failed-deduction info?
11302  FailedCandidates.addCandidate()
11303  .set(I.getPair(), FunctionTemplate->getTemplatedDecl(),
11304  MakeDeductionFailureInfo(Context, Result, Info));
11305  continue;
11306  }
11307 
11308  assert(Specialization && "no specialization and no error?");
11309 
11310  // Multiple matches; we can't resolve to a single declaration.
11311  if (Matched) {
11312  if (Complain) {
11313  Diag(ovl->getExprLoc(), diag::err_addr_ovl_ambiguous)
11314  << ovl->getName();
11315  NoteAllOverloadCandidates(ovl);
11316  }
11317  return nullptr;
11318  }
11319 
11320  Matched = Specialization;
11321  if (FoundResult) *FoundResult = I.getPair();
11322  }
11323 
11324  if (Matched &&
11325  completeFunctionType(*this, Matched, ovl->getExprLoc(), Complain))
11326  return nullptr;
11327 
11328  return Matched;
11329 }
11330 
11331 // Resolve and fix an overloaded expression that can be resolved
11332 // because it identifies a single function template specialization.
11333 //
11334 // Last three arguments should only be supplied if Complain = true
11335 //
11336 // Return true if it was logically possible to so resolve the
11337 // expression, regardless of whether or not it succeeded. Always
11338 // returns true if 'complain' is set.
11340  ExprResult &SrcExpr, bool doFunctionPointerConverion,
11341  bool complain, SourceRange OpRangeForComplaining,
11342  QualType DestTypeForComplaining,
11343  unsigned DiagIDForComplaining) {
11344  assert(SrcExpr.get()->getType() == Context.OverloadTy);
11345 
11347 
11348  DeclAccessPair found;
11349  ExprResult SingleFunctionExpression;
11350  if (FunctionDecl *fn = ResolveSingleFunctionTemplateSpecialization(
11351  ovl.Expression, /*complain*/ false, &found)) {
11352  if (DiagnoseUseOfDecl(fn, SrcExpr.get()->getLocStart())) {
11353  SrcExpr = ExprError();
11354  return true;
11355  }
11356 
11357  // It is only correct to resolve to an instance method if we're
11358  // resolving a form that's permitted to be a pointer to member.
11359  // Otherwise we'll end up making a bound member expression, which
11360  // is illegal in all the contexts we resolve like this.
11361  if (!ovl.HasFormOfMemberPointer &&
11362  isa<CXXMethodDecl>(fn) &&
11363  cast<CXXMethodDecl>(fn)->isInstance()) {
11364  if (!complain) return false;
11365 
11366  Diag(ovl.Expression->getExprLoc(),
11367  diag::err_bound_member_function)
11368  << 0 << ovl.Expression->getSourceRange();
11369 
11370  // TODO: I believe we only end up here if there's a mix of
11371  // static and non-static candidates (otherwise the expression
11372  // would have 'bound member' type, not 'overload' type).
11373  // Ideally we would note which candidate was chosen and why
11374  // the static candidates were rejected.
11375  SrcExpr = ExprError();
11376  return true;
11377  }
11378 
11379  // Fix the expression to refer to 'fn'.
11380  SingleFunctionExpression =
11381  FixOverloadedFunctionReference(SrcExpr.get(), found, fn);
11382 
11383  // If desired, do function-to-pointer decay.
11384  if (doFunctionPointerConverion) {
11385  SingleFunctionExpression =
11386  DefaultFunctionArrayLvalueConversion(SingleFunctionExpression.get());
11387  if (SingleFunctionExpression.isInvalid()) {
11388  SrcExpr = ExprError();
11389  return true;
11390  }
11391  }
11392  }
11393 
11394  if (!SingleFunctionExpression.isUsable()) {
11395  if (complain) {
11396  Diag(OpRangeForComplaining.getBegin(), DiagIDForComplaining)
11397  << ovl.Expression->getName()
11398  << DestTypeForComplaining
11399  << OpRangeForComplaining
11400  << ovl.Expression->getQualifierLoc().getSourceRange();
11401  NoteAllOverloadCandidates(SrcExpr.get());
11402 
11403  SrcExpr = ExprError();
11404  return true;
11405  }
11406 
11407  return false;
11408  }
11409 
11410  SrcExpr = SingleFunctionExpression;
11411  return true;
11412 }
11413 
11414 /// \brief Add a single candidate to the overload set.
11416  DeclAccessPair FoundDecl,
11417  TemplateArgumentListInfo *ExplicitTemplateArgs,
11418  ArrayRef<Expr *> Args,
11419  OverloadCandidateSet &CandidateSet,
11420  bool PartialOverloading,
11421  bool KnownValid) {
11422  NamedDecl *Callee = FoundDecl.getDecl();
11423  if (isa<UsingShadowDecl>(Callee))
11424  Callee = cast<UsingShadowDecl>(Callee)->getTargetDecl();
11425 
11426  if (FunctionDecl *Func = dyn_cast<FunctionDecl>(Callee)) {
11427  if (ExplicitTemplateArgs) {
11428  assert(!KnownValid && "Explicit template arguments?");
11429  return;
11430  }
11431  // Prevent ill-formed function decls to be added as overload candidates.
11432  if (!dyn_cast<FunctionProtoType>(Func->getType()->getAs<FunctionType>()))
11433  return;
11434 
11435  S.AddOverloadCandidate(Func, FoundDecl, Args, CandidateSet,
11436  /*SuppressUsedConversions=*/false,
11437  PartialOverloading);
11438  return;
11439  }
11440 
11441  if (FunctionTemplateDecl *FuncTemplate
11442  = dyn_cast<FunctionTemplateDecl>(Callee)) {
11443  S.AddTemplateOverloadCandidate(FuncTemplate, FoundDecl,
11444  ExplicitTemplateArgs, Args, CandidateSet,
11445  /*SuppressUsedConversions=*/false,
11446  PartialOverloading);
11447  return;
11448  }
11449 
11450  assert(!KnownValid && "unhandled case in overloaded call candidate");
11451 }
11452 
11453 /// \brief Add the overload candidates named by callee and/or found by argument
11454 /// dependent lookup to the given overload set.
11456  ArrayRef<Expr *> Args,
11457  OverloadCandidateSet &CandidateSet,
11458  bool PartialOverloading) {
11459 
11460 #ifndef NDEBUG
11461  // Verify that ArgumentDependentLookup is consistent with the rules
11462  // in C++0x [basic.lookup.argdep]p3:
11463  //
11464  // Let X be the lookup set produced by unqualified lookup (3.4.1)
11465  // and let Y be the lookup set produced by argument dependent
11466  // lookup (defined as follows). If X contains
11467  //
11468  // -- a declaration of a class member, or
11469  //
11470  // -- a block-scope function declaration that is not a
11471  // using-declaration, or
11472  //
11473  // -- a declaration that is neither a function or a function
11474  // template
11475  //
11476  // then Y is empty.
11477 
11478  if (ULE->requiresADL()) {
11480  E = ULE->decls_end(); I != E; ++I) {
11481  assert(!(*I)->getDeclContext()->isRecord());
11482  assert(isa<UsingShadowDecl>(*I) ||
11483  !(*I)->getDeclContext()->isFunctionOrMethod());
11484  assert((*I)->getUnderlyingDecl()->isFunctionOrFunctionTemplate());
11485  }
11486  }
11487 #endif
11488 
11489  // It would be nice to avoid this copy.
11490  TemplateArgumentListInfo TABuffer;
11491  TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr;
11492  if (ULE->hasExplicitTemplateArgs()) {
11493  ULE->copyTemplateArgumentsInto(TABuffer);
11494  ExplicitTemplateArgs = &TABuffer;
11495  }
11496 
11498  E = ULE->decls_end(); I != E; ++I)
11499  AddOverloadedCallCandidate(*this, I.getPair(), ExplicitTemplateArgs, Args,
11500  CandidateSet, PartialOverloading,
11501  /*KnownValid*/ true);
11502 
11503  if (ULE->requiresADL())
11504  AddArgumentDependentLookupCandidates(ULE->getName(), ULE->getExprLoc(),
11505  Args, ExplicitTemplateArgs,
11506  CandidateSet, PartialOverloading);
11507 }
11508 
11509 /// Determine whether a declaration with the specified name could be moved into
11510 /// a different namespace.
11511 static bool canBeDeclaredInNamespace(const DeclarationName &Name) {
11512  switch (Name.getCXXOverloadedOperator()) {
11513  case OO_New: case OO_Array_New:
11514  case OO_Delete: case OO_Array_Delete:
11515  return false;
11516 
11517  default:
11518  return true;
11519  }
11520 }
11521 
11522 /// Attempt to recover from an ill-formed use of a non-dependent name in a
11523 /// template, where the non-dependent name was declared after the template
11524 /// was defined. This is common in code written for a compilers which do not
11525 /// correctly implement two-stage name lookup.
11526 ///
11527 /// Returns true if a viable candidate was found and a diagnostic was issued.
11528 static bool
11530  const CXXScopeSpec &SS, LookupResult &R,
11532  TemplateArgumentListInfo *ExplicitTemplateArgs,
11533  ArrayRef<Expr *> Args,
11534  bool *DoDiagnoseEmptyLookup = nullptr) {
11535  if (!SemaRef.inTemplateInstantiation() || !SS.isEmpty())
11536  return false;
11537 
11538  for (DeclContext *DC = SemaRef.CurContext; DC; DC = DC->getParent()) {
11539  if (DC->isTransparentContext())
11540  continue;
11541 
11542  SemaRef.LookupQualifiedName(R, DC);
11543 
11544  if (!R.empty()) {
11545  R.suppressDiagnostics();
11546 
11547  if (isa<CXXRecordDecl>(DC)) {
11548  // Don't diagnose names we find in classes; we get much better
11549  // diagnostics for these from DiagnoseEmptyLookup.
11550  R.clear();
11551  if (DoDiagnoseEmptyLookup)
11552  *DoDiagnoseEmptyLookup = true;
11553  return false;
11554  }
11555 
11556  OverloadCandidateSet Candidates(FnLoc, CSK);
11557  for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I)
11558  AddOverloadedCallCandidate(SemaRef, I.getPair(),
11559  ExplicitTemplateArgs, Args,
11560  Candidates, false, /*KnownValid*/ false);
11561 
11563  if (Candidates.BestViableFunction(SemaRef, FnLoc, Best) != OR_Success) {
11564  // No viable functions. Don't bother the user with notes for functions
11565  // which don't work and shouldn't be found anyway.
11566  R.clear();
11567  return false;
11568  }
11569 
11570  // Find the namespaces where ADL would have looked, and suggest
11571  // declaring the function there instead.
11572  Sema::AssociatedNamespaceSet AssociatedNamespaces;
11573  Sema::AssociatedClassSet AssociatedClasses;
11574  SemaRef.FindAssociatedClassesAndNamespaces(FnLoc, Args,
11575  AssociatedNamespaces,
11576  AssociatedClasses);
11577  Sema::AssociatedNamespaceSet SuggestedNamespaces;
11579  DeclContext *Std = SemaRef.getStdNamespace();
11580  for (Sema::AssociatedNamespaceSet::iterator
11581  it = AssociatedNamespaces.begin(),
11582  end = AssociatedNamespaces.end(); it != end; ++it) {
11583  // Never suggest declaring a function within namespace 'std'.
11584  if (Std && Std->Encloses(*it))
11585  continue;
11586 
11587  // Never suggest declaring a function within a namespace with a
11588  // reserved name, like __gnu_cxx.
11589  NamespaceDecl *NS = dyn_cast<NamespaceDecl>(*it);
11590  if (NS &&
11591  NS->getQualifiedNameAsString().find("__") != std::string::npos)
11592  continue;
11593 
11594  SuggestedNamespaces.insert(*it);
11595  }
11596  }
11597 
11598  SemaRef.Diag(R.getNameLoc(), diag::err_not_found_by_two_phase_lookup)
11599  << R.getLookupName();
11600  if (SuggestedNamespaces.empty()) {
11601  SemaRef.Diag(Best->Function->getLocation(),
11602  diag::note_not_found_by_two_phase_lookup)
11603  << R.getLookupName() << 0;
11604  } else if (SuggestedNamespaces.size() == 1) {
11605  SemaRef.Diag(Best->Function->getLocation(),
11606  diag::note_not_found_by_two_phase_lookup)
11607  << R.getLookupName() << 1 << *SuggestedNamespaces.begin();
11608  } else {
11609  // FIXME: It would be useful to list the associated namespaces here,
11610  // but the diagnostics infrastructure doesn't provide a way to produce
11611  // a localized representation of a list of items.
11612  SemaRef.Diag(Best->Function->getLocation(),
11613  diag::note_not_found_by_two_phase_lookup)
11614  << R.getLookupName() << 2;
11615  }
11616 
11617  // Try to recover by calling this function.
11618  return true;
11619  }
11620 
11621  R.clear();
11622  }
11623 
11624  return false;
11625 }
11626 
11627 /// Attempt to recover from ill-formed use of a non-dependent operator in a
11628 /// template, where the non-dependent operator was declared after the template
11629 /// was defined.
11630 ///
11631 /// Returns true if a viable candidate was found and a diagnostic was issued.
11632 static bool
11634  SourceLocation OpLoc,
11635  ArrayRef<Expr *> Args) {
11636  DeclarationName OpName =
11638  LookupResult R(SemaRef, OpName, OpLoc, Sema::LookupOperatorName);
11639  return DiagnoseTwoPhaseLookup(SemaRef, OpLoc, CXXScopeSpec(), R,
11641  /*ExplicitTemplateArgs=*/nullptr, Args);
11642 }
11643 
11644 namespace {
11645 class BuildRecoveryCallExprRAII {
11646  Sema &SemaRef;
11647 public:
11648  BuildRecoveryCallExprRAII(Sema &S) : SemaRef(S) {
11649  assert(SemaRef.IsBuildingRecoveryCallExpr == false);
11650  SemaRef.IsBuildingRecoveryCallExpr = true;
11651  }
11652 
11653  ~BuildRecoveryCallExprRAII() {
11654  SemaRef.IsBuildingRecoveryCallExpr = false;
11655  }
11656 };
11657 
11658 }
11659 
11660 static std::unique_ptr<CorrectionCandidateCallback>
11661 MakeValidator(Sema &SemaRef, MemberExpr *ME, size_t NumArgs,
11662  bool HasTemplateArgs, bool AllowTypoCorrection) {
11663  if (!AllowTypoCorrection)
11664  return llvm::make_unique<NoTypoCorrectionCCC>();
11665  return llvm::make_unique<FunctionCallFilterCCC>(SemaRef, NumArgs,
11666  HasTemplateArgs, ME);
11667 }
11668 
11669 /// Attempts to recover from a call where no functions were found.
11670 ///
11671 /// Returns true if new candidates were found.
11672 static ExprResult
11674  UnresolvedLookupExpr *ULE,
11675  SourceLocation LParenLoc,
11677  SourceLocation RParenLoc,
11678  bool EmptyLookup, bool AllowTypoCorrection) {
11679  // Do not try to recover if it is already building a recovery call.
11680  // This stops infinite loops for template instantiations like
11681  //
11682  // template <typename T> auto foo(T t) -> decltype(foo(t)) {}
11683  // template <typename T> auto foo(T t) -> decltype(foo(&t)) {}
11684  //
11685  if (SemaRef.IsBuildingRecoveryCallExpr)
11686  return ExprError();
11687  BuildRecoveryCallExprRAII RCE(SemaRef);
11688 
11689  CXXScopeSpec SS;
11690  SS.Adopt(ULE->getQualifierLoc());
11691  SourceLocation TemplateKWLoc = ULE->getTemplateKeywordLoc();
11692 
11693  TemplateArgumentListInfo TABuffer;
11694  TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr;
11695  if (ULE->hasExplicitTemplateArgs()) {
11696  ULE->copyTemplateArgumentsInto(TABuffer);
11697  ExplicitTemplateArgs = &TABuffer;
11698  }
11699 
11700  LookupResult R(SemaRef, ULE->getName(), ULE->getNameLoc(),
11702  bool DoDiagnoseEmptyLookup = EmptyLookup;
11703  if (!DiagnoseTwoPhaseLookup(SemaRef, Fn->getExprLoc(), SS, R,
11705  ExplicitTemplateArgs, Args,
11706  &DoDiagnoseEmptyLookup) &&
11707  (!DoDiagnoseEmptyLookup || SemaRef.DiagnoseEmptyLookup(
11708  S, SS, R,
11709  MakeValidator(SemaRef, dyn_cast<MemberExpr>(Fn), Args.size(),
11710  ExplicitTemplateArgs != nullptr, AllowTypoCorrection),
11711  ExplicitTemplateArgs, Args)))
11712  return ExprError();
11713 
11714  assert(!R.empty() && "lookup results empty despite recovery");
11715 
11716  // If recovery created an ambiguity, just bail out.
11717  if (R.isAmbiguous()) {
11718  R.suppressDiagnostics();
11719  return ExprError();
11720  }
11721 
11722  // Build an implicit member call if appropriate. Just drop the
11723  // casts and such from the call, we don't really care.
11724  ExprResult NewFn = ExprError();
11725  if ((*R.begin())->isCXXClassMember())
11726  NewFn = SemaRef.BuildPossibleImplicitMemberExpr(SS, TemplateKWLoc, R,
11727  ExplicitTemplateArgs, S);
11728  else if (ExplicitTemplateArgs || TemplateKWLoc.isValid())
11729  NewFn = SemaRef.BuildTemplateIdExpr(SS, TemplateKWLoc, R, false,
11730  ExplicitTemplateArgs);
11731  else
11732  NewFn = SemaRef.BuildDeclarationNameExpr(SS, R, false);
11733 
11734  if (NewFn.isInvalid())
11735  return ExprError();
11736 
11737  // This shouldn't cause an infinite loop because we're giving it
11738  // an expression with viable lookup results, which should never
11739  // end up here.
11740  return SemaRef.ActOnCallExpr(/*Scope*/ nullptr, NewFn.get(), LParenLoc,
11741  MultiExprArg(Args.data(), Args.size()),
11742  RParenLoc);
11743 }
11744 
11745 /// \brief Constructs and populates an OverloadedCandidateSet from
11746 /// the given function.
11747 /// \returns true when an the ExprResult output parameter has been set.
11749  UnresolvedLookupExpr *ULE,
11750  MultiExprArg Args,
11751  SourceLocation RParenLoc,
11752  OverloadCandidateSet *CandidateSet,
11753  ExprResult *Result) {
11754 #ifndef NDEBUG
11755  if (ULE->requiresADL()) {
11756  // To do ADL, we must have found an unqualified name.
11757  assert(!ULE->getQualifier() && "qualified name with ADL");
11758 
11759  // We don't perform ADL for implicit declarations of builtins.
11760  // Verify that this was correctly set up.
11761  FunctionDecl *F;
11762  if (ULE->decls_begin() + 1 == ULE->decls_end() &&
11763  (F = dyn_cast<FunctionDecl>(*ULE->decls_begin())) &&
11764  F->getBuiltinID() && F->isImplicit())
11765  llvm_unreachable("performing ADL for builtin");
11766 
11767  // We don't perform ADL in C.
11768  assert(getLangOpts().CPlusPlus && "ADL enabled in C");
11769  }
11770 #endif
11771 
11772  UnbridgedCastsSet UnbridgedCasts;
11773  if (checkArgPlaceholdersForOverload(*this, Args, UnbridgedCasts)) {
11774  *Result = ExprError();
11775  return true;
11776  }
11777 
11778  // Add the functions denoted by the callee to the set of candidate
11779  // functions, including those from argument-dependent lookup.
11780  AddOverloadedCallCandidates(ULE, Args, *CandidateSet);
11781 
11782  if (getLangOpts().MSVCCompat &&
11783  CurContext->isDependentContext() && !isSFINAEContext() &&
11784  (isa<FunctionDecl>(CurContext) || isa<CXXRecordDecl>(CurContext))) {
11785 
11787  if (CandidateSet->empty() ||
11788  CandidateSet->BestViableFunction(*this, Fn->getLocStart(), Best) ==
11790  // In Microsoft mode, if we are inside a template class member function then
11791  // create a type dependent CallExpr. The goal is to postpone name lookup
11792  // to instantiation time to be able to search into type dependent base
11793  // classes.
11794  CallExpr *CE = new (Context) CallExpr(
11795  Context, Fn, Args, Context.DependentTy, VK_RValue, RParenLoc);
11796  CE->setTypeDependent(true);
11797  CE->setValueDependent(true);
11798  CE->setInstantiationDependent(true);
11799  *Result = CE;
11800  return true;
11801  }
11802  }
11803 
11804  if (CandidateSet->empty())
11805  return false;
11806 
11807  UnbridgedCasts.restore();
11808  return false;
11809 }
11810 
11811 /// FinishOverloadedCallExpr - given an OverloadCandidateSet, builds and returns
11812 /// the completed call expression. If overload resolution fails, emits
11813 /// diagnostics and returns ExprError()
11815  UnresolvedLookupExpr *ULE,
11816  SourceLocation LParenLoc,
11817  MultiExprArg Args,
11818  SourceLocation RParenLoc,
11819  Expr *ExecConfig,
11820  OverloadCandidateSet *CandidateSet,
11822  OverloadingResult OverloadResult,
11823  bool AllowTypoCorrection) {
11824  if (CandidateSet->empty())
11825  return BuildRecoveryCallExpr(SemaRef, S, Fn, ULE, LParenLoc, Args,
11826  RParenLoc, /*EmptyLookup=*/true,
11827  AllowTypoCorrection);
11828 
11829  switch (OverloadResult) {
11830  case OR_Success: {
11831  FunctionDecl *FDecl = (*Best)->Function;
11832  SemaRef.CheckUnresolvedLookupAccess(ULE, (*Best)->FoundDecl);
11833  if (SemaRef.DiagnoseUseOfDecl(FDecl, ULE->getNameLoc()))
11834  return ExprError();
11835  Fn = SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl);
11836  return SemaRef.BuildResolvedCallExpr(Fn, FDecl, LParenLoc, Args, RParenLoc,
11837  ExecConfig);
11838  }
11839 
11840  case OR_No_Viable_Function: {
11841  // Try to recover by looking for viable functions which the user might
11842  // have meant to call.
11843  ExprResult Recovery = BuildRecoveryCallExpr(SemaRef, S, Fn, ULE, LParenLoc,
11844  Args, RParenLoc,
11845  /*EmptyLookup=*/false,
11846  AllowTypoCorrection);
11847  if (!Recovery.isInvalid())
11848  return Recovery;
11849 
11850  // If the user passes in a function that we can't take the address of, we
11851  // generally end up emitting really bad error messages. Here, we attempt to
11852  // emit better ones.
11853  for (const Expr *Arg : Args) {
11854  if (!Arg->getType()->isFunctionType())
11855  continue;
11856  if (auto *DRE = dyn_cast<DeclRefExpr>(Arg->IgnoreParenImpCasts())) {
11857  auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl());
11858  if (FD &&
11859  !SemaRef.checkAddressOfFunctionIsAvailable(FD, /*Complain=*/true,
11860  Arg->getExprLoc()))
11861  return ExprError();
11862  }
11863  }
11864 
11865  SemaRef.Diag(Fn->getLocStart(), diag::err_ovl_no_viable_function_in_call)
11866  << ULE->getName() << Fn->getSourceRange();
11867  CandidateSet->NoteCandidates(SemaRef, OCD_AllCandidates, Args);
11868  break;
11869  }
11870 
11871  case OR_Ambiguous:
11872  SemaRef.Diag(Fn->getLocStart(), diag::err_ovl_ambiguous_call)
11873  << ULE->getName() << Fn->getSourceRange();
11874  CandidateSet->NoteCandidates(SemaRef, OCD_ViableCandidates, Args);
11875  break;
11876 
11877  case OR_Deleted: {
11878  SemaRef.Diag(Fn->getLocStart(), diag::err_ovl_deleted_call)
11879  << (*Best)->Function->isDeleted()
11880  << ULE->getName()
11881  << SemaRef.getDeletedOrUnavailableSuffix((*Best)->Function)
11882  << Fn->getSourceRange();
11883  CandidateSet->NoteCandidates(SemaRef, OCD_AllCandidates, Args);
11884 
11885  // We emitted an error for the unvailable/deleted function call but keep
11886  // the call in the AST.
11887  FunctionDecl *FDecl = (*Best)->Function;
11888  Fn = SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl);
11889  return SemaRef.BuildResolvedCallExpr(Fn, FDecl, LParenLoc, Args, RParenLoc,
11890  ExecConfig);
11891  }
11892  }
11893 
11894  // Overload resolution failed.
11895  return ExprError();
11896 }
11897 
11899  OverloadCandidateSet &CS) {
11900  for (auto I = CS.begin(), E = CS.end(); I != E; ++I) {
11901  if (I->Viable &&
11902  !S.checkAddressOfFunctionIsAvailable(I->Function, /*Complain=*/false)) {
11903  I->Viable = false;
11904  I->FailureKind = ovl_fail_addr_not_available;
11905  }
11906  }
11907 }
11908 
11909 /// BuildOverloadedCallExpr - Given the call expression that calls Fn
11910 /// (which eventually refers to the declaration Func) and the call
11911 /// arguments Args/NumArgs, attempt to resolve the function call down
11912 /// to a specific function. If overload resolution succeeds, returns
11913 /// the call expression produced by overload resolution.
11914 /// Otherwise, emits diagnostics and returns ExprError.
11916  UnresolvedLookupExpr *ULE,
11917  SourceLocation LParenLoc,
11918  MultiExprArg Args,
11919  SourceLocation RParenLoc,
11920  Expr *ExecConfig,
11921  bool AllowTypoCorrection,
11922  bool CalleesAddressIsTaken) {
11923  OverloadCandidateSet CandidateSet(Fn->getExprLoc(),
11925  ExprResult result;
11926 
11927  if (buildOverloadedCallSet(S, Fn, ULE, Args, LParenLoc, &CandidateSet,
11928  &result))
11929  return result;
11930 
11931  // If the user handed us something like `(&Foo)(Bar)`, we need to ensure that
11932  // functions that aren't addressible are considered unviable.
11933  if (CalleesAddressIsTaken)
11934  markUnaddressableCandidatesUnviable(*this, CandidateSet);
11935 
11937  OverloadingResult OverloadResult =
11938  CandidateSet.BestViableFunction(*this, Fn->getLocStart(), Best);
11939 
11940  return FinishOverloadedCallExpr(*this, S, Fn, ULE, LParenLoc, Args,
11941  RParenLoc, ExecConfig, &CandidateSet,
11942  &Best, OverloadResult,
11943  AllowTypoCorrection);
11944 }
11945 
11946 static bool IsOverloaded(const UnresolvedSetImpl &Functions) {
11947  return Functions.size() > 1 ||
11948  (Functions.size() == 1 && isa<FunctionTemplateDecl>(*Functions.begin()));
11949 }
11950 
11951 /// \brief Create a unary operation that may resolve to an overloaded
11952 /// operator.
11953 ///
11954 /// \param OpLoc The location of the operator itself (e.g., '*').
11955 ///
11956 /// \param Opc The UnaryOperatorKind that describes this operator.
11957 ///
11958 /// \param Fns The set of non-member functions that will be
11959 /// considered by overload resolution. The caller needs to build this
11960 /// set based on the context using, e.g.,
11961 /// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This
11962 /// set should not contain any member functions; those will be added
11963 /// by CreateOverloadedUnaryOp().
11964 ///
11965 /// \param Input The input argument.
11966 ExprResult
11968  const UnresolvedSetImpl &Fns,
11969  Expr *Input, bool PerformADL) {
11971  assert(Op != OO_None && "Invalid opcode for overloaded unary operator");
11973  // TODO: provide better source location info.
11974  DeclarationNameInfo OpNameInfo(OpName, OpLoc);
11975 
11976  if (checkPlaceholderForOverload(*this, Input))
11977  return ExprError();
11978 
11979  Expr *Args[2] = { Input, nullptr };
11980  unsigned NumArgs = 1;
11981 
11982  // For post-increment and post-decrement, add the implicit '0' as
11983  // the second argument, so that we know this is a post-increment or
11984  // post-decrement.
11985  if (Opc == UO_PostInc || Opc == UO_PostDec) {
11986  llvm::APSInt Zero(Context.getTypeSize(Context.IntTy), false);
11987  Args[1] = IntegerLiteral::Create(Context, Zero, Context.IntTy,
11988  SourceLocation());
11989  NumArgs = 2;
11990  }
11991 
11992  ArrayRef<Expr *> ArgsArray(Args, NumArgs);
11993 
11994  if (Input->isTypeDependent()) {
11995  if (Fns.empty())
11996  return new (Context) UnaryOperator(Input, Opc, Context.DependentTy,
11997  VK_RValue, OK_Ordinary, OpLoc);
11998 
11999  CXXRecordDecl *NamingClass = nullptr; // lookup ignores member operators
12001  = UnresolvedLookupExpr::Create(Context, NamingClass,
12002  NestedNameSpecifierLoc(), OpNameInfo,
12003  /*ADL*/ true, IsOverloaded(Fns),
12004  Fns.begin(), Fns.end());
12005  return new (Context)
12006  CXXOperatorCallExpr(Context, Op, Fn, ArgsArray, Context.DependentTy,
12007  VK_RValue, OpLoc, FPOptions());
12008  }
12009 
12010  // Build an empty overload set.
12012 
12013  // Add the candidates from the given function set.
12014  AddFunctionCandidates(Fns, ArgsArray, CandidateSet);
12015 
12016  // Add operator candidates that are member functions.
12017  AddMemberOperatorCandidates(Op, OpLoc, ArgsArray, CandidateSet);
12018 
12019  // Add candidates from ADL.
12020  if (PerformADL) {
12021  AddArgumentDependentLookupCandidates(OpName, OpLoc, ArgsArray,
12022  /*ExplicitTemplateArgs*/nullptr,
12023  CandidateSet);
12024  }
12025 
12026  // Add builtin operator candidates.
12027  AddBuiltinOperatorCandidates(Op, OpLoc, ArgsArray, CandidateSet);
12028 
12029  bool HadMultipleCandidates = (CandidateSet.size() > 1);
12030 
12031  // Perform overload resolution.
12033  switch (CandidateSet.BestViableFunction(*this, OpLoc, Best)) {
12034  case OR_Success: {
12035  // We found a built-in operator or an overloaded operator.
12036  FunctionDecl *FnDecl = Best->Function;
12037 
12038  if (FnDecl) {
12039  Expr *Base = nullptr;
12040  // We matched an overloaded operator. Build a call to that
12041  // operator.
12042 
12043  // Convert the arguments.
12044  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) {
12045  CheckMemberOperatorAccess(OpLoc, Args[0], nullptr, Best->FoundDecl);
12046 
12047  ExprResult InputRes =
12048  PerformObjectArgumentInitialization(Input, /*Qualifier=*/nullptr,
12049  Best->FoundDecl, Method);
12050  if (InputRes.isInvalid())
12051  return ExprError();
12052  Base = Input = InputRes.get();
12053  } else {
12054  // Convert the arguments.
12055  ExprResult InputInit
12056  = PerformCopyInitialization(InitializedEntity::InitializeParameter(
12057  Context,
12058  FnDecl->getParamDecl(0)),
12059  SourceLocation(),
12060  Input);
12061  if (InputInit.isInvalid())
12062  return ExprError();
12063  Input = InputInit.get();
12064  }
12065 
12066  // Build the actual expression node.
12067  ExprResult FnExpr = CreateFunctionRefExpr(*this, FnDecl, Best->FoundDecl,
12068  Base, HadMultipleCandidates,
12069  OpLoc);
12070  if (FnExpr.isInvalid())
12071  return ExprError();
12072 
12073  // Determine the result type.
12074  QualType ResultTy = FnDecl->getReturnType();
12076  ResultTy = ResultTy.getNonLValueExprType(Context);
12077 
12078  Args[0] = Input;
12079  CallExpr *TheCall =
12080  new (Context) CXXOperatorCallExpr(Context, Op, FnExpr.get(), ArgsArray,
12081  ResultTy, VK, OpLoc, FPOptions());
12082 
12083  if (CheckCallReturnType(FnDecl->getReturnType(), OpLoc, TheCall, FnDecl))
12084  return ExprError();
12085 
12086  if (CheckFunctionCall(FnDecl, TheCall,
12087  FnDecl->getType()->castAs<FunctionProtoType>()))
12088  return ExprError();
12089 
12090  return MaybeBindToTemporary(TheCall);
12091  } else {
12092  // We matched a built-in operator. Convert the arguments, then
12093  // break out so that we will build the appropriate built-in
12094  // operator node.
12095  ExprResult InputRes = PerformImplicitConversion(
12096  Input, Best->BuiltinParamTypes[0], Best->Conversions[0], AA_Passing);
12097  if (InputRes.isInvalid())
12098  return ExprError();
12099  Input = InputRes.get();
12100  break;
12101  }
12102  }
12103 
12104  case OR_No_Viable_Function:
12105  // This is an erroneous use of an operator which can be overloaded by
12106  // a non-member function. Check for non-member operators which were
12107  // defined too late to be candidates.
12108  if (DiagnoseTwoPhaseOperatorLookup(*this, Op, OpLoc, ArgsArray))
12109  // FIXME: Recover by calling the found function.
12110  return ExprError();
12111 
12112  // No viable function; fall through to handling this as a
12113  // built-in operator, which will produce an error message for us.
12114  break;
12115 
12116  case OR_Ambiguous:
12117  Diag(OpLoc, diag::err_ovl_ambiguous_oper_unary)
12119  << Input->getType()
12120  << Input->getSourceRange();
12121  CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, ArgsArray,
12122  UnaryOperator::getOpcodeStr(Opc), OpLoc);
12123  return ExprError();
12124 
12125  case OR_Deleted:
12126  Diag(OpLoc, diag::err_ovl_deleted_oper)
12127  << Best->Function->isDeleted()
12129  << getDeletedOrUnavailableSuffix(Best->Function)
12130  << Input->getSourceRange();
12131  CandidateSet.NoteCandidates(*this, OCD_AllCandidates, ArgsArray,
12132  UnaryOperator::getOpcodeStr(Opc), OpLoc);
12133  return ExprError();
12134  }
12135 
12136  // Either we found no viable overloaded operator or we matched a
12137  // built-in operator. In either case, fall through to trying to
12138  // build a built-in operation.
12139  return CreateBuiltinUnaryOp(OpLoc, Opc, Input);
12140 }
12141 
12142 /// \brief Create a binary operation that may resolve to an overloaded
12143 /// operator.
12144 ///
12145 /// \param OpLoc The location of the operator itself (e.g., '+').
12146 ///
12147 /// \param Opc The BinaryOperatorKind that describes this operator.
12148 ///
12149 /// \param Fns The set of non-member functions that will be
12150 /// considered by overload resolution. The caller needs to build this
12151 /// set based on the context using, e.g.,
12152 /// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This
12153 /// set should not contain any member functions; those will be added
12154 /// by CreateOverloadedBinOp().
12155 ///
12156 /// \param LHS Left-hand argument.
12157 /// \param RHS Right-hand argument.
12158 ExprResult
12160  BinaryOperatorKind Opc,
12161  const UnresolvedSetImpl &Fns,
12162  Expr *LHS, Expr *RHS, bool PerformADL) {
12163  Expr *Args[2] = { LHS, RHS };
12164  LHS=RHS=nullptr; // Please use only Args instead of LHS/RHS couple
12165 
12168 
12169  // If either side is type-dependent, create an appropriate dependent
12170  // expression.
12171  if (Args[0]->isTypeDependent() || Args[1]->isTypeDependent()) {
12172  if (Fns.empty()) {
12173  // If there are no functions to store, just build a dependent
12174  // BinaryOperator or CompoundAssignment.
12175  if (Opc <= BO_Assign || Opc > BO_OrAssign)
12176  return new (Context) BinaryOperator(
12177  Args[0], Args[1], Opc, Context.DependentTy, VK_RValue, OK_Ordinary,
12178  OpLoc, FPFeatures);
12179 
12180  return new (Context) CompoundAssignOperator(
12181  Args[0], Args[1], Opc, Context.DependentTy, VK_LValue, OK_Ordinary,
12182  Context.DependentTy, Context.DependentTy, OpLoc,
12183  FPFeatures);
12184  }
12185 
12186  // FIXME: save results of ADL from here?
12187  CXXRecordDecl *NamingClass = nullptr; // lookup ignores member operators
12188  // TODO: provide better source location info in DNLoc component.
12189  DeclarationNameInfo OpNameInfo(OpName, OpLoc);
12191  = UnresolvedLookupExpr::Create(Context, NamingClass,
12192  NestedNameSpecifierLoc(), OpNameInfo,
12193  /*ADL*/PerformADL, IsOverloaded(Fns),
12194  Fns.begin(), Fns.end());
12195  return new (Context)
12196  CXXOperatorCallExpr(Context, Op, Fn, Args, Context.DependentTy,
12197  VK_RValue, OpLoc, FPFeatures);
12198  }
12199 
12200  // Always do placeholder-like conversions on the RHS.
12201  if (checkPlaceholderForOverload(*this, Args[1]))
12202  return ExprError();
12203 
12204  // Do placeholder-like conversion on the LHS; note that we should
12205  // not get here with a PseudoObject LHS.
12206  assert(Args[0]->getObjectKind() != OK_ObjCProperty);
12207  if (checkPlaceholderForOverload(*this, Args[0]))
12208  return ExprError();
12209 
12210  // If this is the assignment operator, we only perform overload resolution
12211  // if the left-hand side is a class or enumeration type. This is actually
12212  // a hack. The standard requires that we do overload resolution between the
12213  // various built-in candidates, but as DR507 points out, this can lead to
12214  // problems. So we do it this way, which pretty much follows what GCC does.
12215  // Note that we go the traditional code path for compound assignment forms.
12216  if (Opc == BO_Assign && !Args[0]->getType()->isOverloadableType())
12217  return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
12218 
12219  // If this is the .* operator, which is not overloadable, just
12220  // create a built-in binary operator.
12221  if (Opc == BO_PtrMemD)
12222  return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
12223 
12224  // Build an empty overload set.
12226 
12227  // Add the candidates from the given function set.
12228  AddFunctionCandidates(Fns, Args, CandidateSet);
12229 
12230  // Add operator candidates that are member functions.
12231  AddMemberOperatorCandidates(Op, OpLoc, Args, CandidateSet);
12232 
12233  // Add candidates from ADL. Per [over.match.oper]p2, this lookup is not
12234  // performed for an assignment operator (nor for operator[] nor operator->,
12235  // which don't get here).
12236  if (Opc != BO_Assign && PerformADL)
12237  AddArgumentDependentLookupCandidates(OpName, OpLoc, Args,
12238  /*ExplicitTemplateArgs*/ nullptr,
12239  CandidateSet);
12240 
12241  // Add builtin operator candidates.
12242  AddBuiltinOperatorCandidates(Op, OpLoc, Args, CandidateSet);
12243 
12244  bool HadMultipleCandidates = (CandidateSet.size() > 1);
12245 
12246  // Perform overload resolution.
12248  switch (CandidateSet.BestViableFunction(*this, OpLoc, Best)) {
12249  case OR_Success: {
12250  // We found a built-in operator or an overloaded operator.
12251  FunctionDecl *FnDecl = Best->Function;
12252 
12253  if (FnDecl) {
12254  Expr *Base = nullptr;
12255  // We matched an overloaded operator. Build a call to that
12256  // operator.
12257 
12258  // Convert the arguments.
12259  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) {
12260  // Best->Access is only meaningful for class members.
12261  CheckMemberOperatorAccess(OpLoc, Args[0], Args[1], Best->FoundDecl);
12262 
12263  ExprResult Arg1 =
12264  PerformCopyInitialization(
12266  FnDecl->getParamDecl(0)),
12267  SourceLocation(), Args[1]);
12268  if (Arg1.isInvalid())
12269  return ExprError();
12270 
12271  ExprResult Arg0 =
12272  PerformObjectArgumentInitialization(Args[0], /*Qualifier=*/nullptr,
12273  Best->FoundDecl, Method);
12274  if (Arg0.isInvalid())
12275  return ExprError();
12276  Base = Args[0] = Arg0.getAs<Expr>();
12277  Args[1] = RHS = Arg1.getAs<Expr>();
12278  } else {
12279  // Convert the arguments.
12280  ExprResult Arg0 = PerformCopyInitialization(
12282  FnDecl->getParamDecl(0)),
12283  SourceLocation(), Args[0]);
12284  if (Arg0.isInvalid())
12285  return ExprError();
12286 
12287  ExprResult Arg1 =
12288  PerformCopyInitialization(
12290  FnDecl->getParamDecl(1)),
12291  SourceLocation(), Args[1]);
12292  if (Arg1.isInvalid())
12293  return ExprError();
12294  Args[0] = LHS = Arg0.getAs<Expr>();
12295  Args[1] = RHS = Arg1.getAs<Expr>();
12296  }
12297 
12298  // Build the actual expression node.
12299  ExprResult FnExpr = CreateFunctionRefExpr(*this, FnDecl,
12300  Best->FoundDecl, Base,
12301  HadMultipleCandidates, OpLoc);
12302  if (FnExpr.isInvalid())
12303  return ExprError();
12304 
12305  // Determine the result type.
12306  QualType ResultTy = FnDecl->getReturnType();
12308  ResultTy = ResultTy.getNonLValueExprType(Context);
12309 
12310  CXXOperatorCallExpr *TheCall =
12311  new (Context) CXXOperatorCallExpr(Context, Op, FnExpr.get(),
12312  Args, ResultTy, VK, OpLoc,
12313  FPFeatures);
12314 
12315  if (CheckCallReturnType(FnDecl->getReturnType(), OpLoc, TheCall,
12316  FnDecl))
12317  return ExprError();
12318 
12319  ArrayRef<const Expr *> ArgsArray(Args, 2);
12320  const Expr *ImplicitThis = nullptr;
12321  // Cut off the implicit 'this'.
12322  if (isa<CXXMethodDecl>(FnDecl)) {
12323  ImplicitThis = ArgsArray[0];
12324  ArgsArray = ArgsArray.slice(1);
12325  }
12326 
12327  // Check for a self move.
12328  if (Op == OO_Equal)
12329  DiagnoseSelfMove(Args[0], Args[1], OpLoc);
12330 
12331  checkCall(FnDecl, nullptr, ImplicitThis, ArgsArray,
12332  isa<CXXMethodDecl>(FnDecl), OpLoc, TheCall->getSourceRange(),
12333  VariadicDoesNotApply);
12334 
12335  return MaybeBindToTemporary(TheCall);
12336  } else {
12337  // We matched a built-in operator. Convert the arguments, then
12338  // break out so that we will build the appropriate built-in
12339  // operator node.
12340  ExprResult ArgsRes0 =
12341  PerformImplicitConversion(Args[0], Best->BuiltinParamTypes[0],
12342  Best->Conversions[0], AA_Passing);
12343  if (ArgsRes0.isInvalid())
12344  return ExprError();
12345  Args[0] = ArgsRes0.get();
12346 
12347  ExprResult ArgsRes1 =
12348  PerformImplicitConversion(Args[1], Best->BuiltinParamTypes[1],
12349  Best->Conversions[1], AA_Passing);
12350  if (ArgsRes1.isInvalid())
12351  return ExprError();
12352  Args[1] = ArgsRes1.get();
12353  break;
12354  }
12355  }
12356 
12357  case OR_No_Viable_Function: {
12358  // C++ [over.match.oper]p9:
12359  // If the operator is the operator , [...] and there are no
12360  // viable functions, then the operator is assumed to be the
12361  // built-in operator and interpreted according to clause 5.
12362  if (Opc == BO_Comma)
12363  break;
12364 
12365  // For class as left operand for assignment or compound assigment
12366  // operator do not fall through to handling in built-in, but report that
12367  // no overloaded assignment operator found
12368  ExprResult Result = ExprError();
12369  if (Args[0]->getType()->isRecordType() &&
12370  Opc >= BO_Assign && Opc <= BO_OrAssign) {
12371  Diag(OpLoc, diag::err_ovl_no_viable_oper)
12373  << Args[0]->getSourceRange() << Args[1]->getSourceRange();
12374  if (Args[0]->getType()->isIncompleteType()) {
12375  Diag(OpLoc, diag::note_assign_lhs_incomplete)
12376  << Args[0]->getType()
12377  << Args[0]->getSourceRange() << Args[1]->getSourceRange();
12378  }
12379  } else {
12380  // This is an erroneous use of an operator which can be overloaded by
12381  // a non-member function. Check for non-member operators which were
12382  // defined too late to be candidates.
12383  if (DiagnoseTwoPhaseOperatorLookup(*this, Op, OpLoc, Args))
12384  // FIXME: Recover by calling the found function.
12385  return ExprError();
12386 
12387  // No viable function; try to create a built-in operation, which will
12388  // produce an error. Then, show the non-viable candidates.
12389  Result = CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
12390  }
12391  assert(Result.isInvalid() &&
12392  "C++ binary operator overloading is missing candidates!");
12393  if (Result.isInvalid())
12394  CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args,
12395  BinaryOperator::getOpcodeStr(Opc), OpLoc);
12396  return Result;
12397  }
12398 
12399  case OR_Ambiguous:
12400  Diag(OpLoc, diag::err_ovl_ambiguous_oper_binary)
12402  << Args[0]->getType() << Args[1]->getType()
12403  << Args[0]->getSourceRange() << Args[1]->getSourceRange();
12404  CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, Args,
12405  BinaryOperator::getOpcodeStr(Opc), OpLoc);
12406  return ExprError();
12407 
12408  case OR_Deleted:
12409  if (isImplicitlyDeleted(Best->Function)) {
12410  CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
12411  Diag(OpLoc, diag::err_ovl_deleted_special_oper)
12412  << Context.getRecordType(Method->getParent())
12413  << getSpecialMember(Method);
12414 
12415  // The user probably meant to call this special member. Just
12416  // explain why it's deleted.
12417  NoteDeletedFunction(Method);
12418  return ExprError();
12419  } else {
12420  Diag(OpLoc, diag::err_ovl_deleted_oper)
12421  << Best->Function->isDeleted()
12423  << getDeletedOrUnavailableSuffix(Best->Function)
12424  << Args[0]->getSourceRange() << Args[1]->getSourceRange();
12425  }
12426  CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args,
12427  BinaryOperator::getOpcodeStr(Opc), OpLoc);
12428  return ExprError();
12429  }
12430 
12431  // We matched a built-in operator; build it.
12432  return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
12433 }
12434 
12435 ExprResult
12437  SourceLocation RLoc,
12438  Expr *Base, Expr *Idx) {
12439  Expr *Args[2] = { Base, Idx };
12440  DeclarationName OpName =
12441  Context.DeclarationNames.getCXXOperatorName(OO_Subscript);
12442 
12443  // If either side is type-dependent, create an appropriate dependent
12444  // expression.
12445  if (Args[0]->isTypeDependent() || Args[1]->isTypeDependent()) {
12446 
12447  CXXRecordDecl *NamingClass = nullptr; // lookup ignores member operators
12448  // CHECKME: no 'operator' keyword?
12449  DeclarationNameInfo OpNameInfo(OpName, LLoc);
12450  OpNameInfo.setCXXOperatorNameRange(SourceRange(LLoc, RLoc));
12452  = UnresolvedLookupExpr::Create(Context, NamingClass,
12453  NestedNameSpecifierLoc(), OpNameInfo,
12454  /*ADL*/ true, /*Overloaded*/ false,
12457  // Can't add any actual overloads yet
12458 
12459  return new (Context)
12460  CXXOperatorCallExpr(Context, OO_Subscript, Fn, Args,
12461  Context.DependentTy, VK_RValue, RLoc, FPOptions());
12462  }
12463 
12464  // Handle placeholders on both operands.
12465  if (checkPlaceholderForOverload(*this, Args[0]))
12466  return ExprError();
12467  if (checkPlaceholderForOverload(*this, Args[1]))
12468  return ExprError();
12469 
12470  // Build an empty overload set.
12472 
12473  // Subscript can only be overloaded as a member function.
12474 
12475  // Add operator candidates that are member functions.
12476  AddMemberOperatorCandidates(OO_Subscript, LLoc, Args, CandidateSet);
12477 
12478  // Add builtin operator candidates.
12479  AddBuiltinOperatorCandidates(OO_Subscript, LLoc, Args, CandidateSet);
12480 
12481  bool HadMultipleCandidates = (CandidateSet.size() > 1);
12482 
12483  // Perform overload resolution.
12485  switch (CandidateSet.BestViableFunction(*this, LLoc, Best)) {
12486  case OR_Success: {
12487  // We found a built-in operator or an overloaded operator.
12488  FunctionDecl *FnDecl = Best->Function;
12489 
12490  if (FnDecl) {
12491  // We matched an overloaded operator. Build a call to that
12492  // operator.
12493 
12494  CheckMemberOperatorAccess(LLoc, Args[0], Args[1], Best->FoundDecl);
12495 
12496  // Convert the arguments.
12497  CXXMethodDecl *Method = cast<CXXMethodDecl>(FnDecl);
12498  ExprResult Arg0 =
12499  PerformObjectArgumentInitialization(Args[0], /*Qualifier=*/nullptr,
12500  Best->FoundDecl, Method);
12501  if (Arg0.isInvalid())
12502  return ExprError();
12503  Args[0] = Arg0.get();
12504 
12505  // Convert the arguments.
12506  ExprResult InputInit
12507  = PerformCopyInitialization(InitializedEntity::InitializeParameter(
12508  Context,
12509  FnDecl->getParamDecl(0)),
12510  SourceLocation(),
12511  Args[1]);
12512  if (InputInit.isInvalid())
12513  return ExprError();
12514 
12515  Args[1] = InputInit.getAs<Expr>();
12516 
12517  // Build the actual expression node.
12518  DeclarationNameInfo OpLocInfo(OpName, LLoc);
12519  OpLocInfo.setCXXOperatorNameRange(SourceRange(LLoc, RLoc));
12520  ExprResult FnExpr = CreateFunctionRefExpr(*this, FnDecl,
12521  Best->FoundDecl,
12522  Base,
12523  HadMultipleCandidates,
12524  OpLocInfo.getLoc(),
12525  OpLocInfo.getInfo());
12526  if (FnExpr.isInvalid())
12527  return ExprError();
12528 
12529  // Determine the result type
12530  QualType ResultTy = FnDecl->getReturnType();
12532  ResultTy = ResultTy.getNonLValueExprType(Context);
12533 
12534  CXXOperatorCallExpr *TheCall =
12535  new (Context) CXXOperatorCallExpr(Context, OO_Subscript,
12536  FnExpr.get(), Args,
12537  ResultTy, VK, RLoc,
12538  FPOptions());
12539 
12540  if (CheckCallReturnType(FnDecl->getReturnType(), LLoc, TheCall, FnDecl))
12541  return ExprError();
12542 
12543  if (CheckFunctionCall(Method, TheCall,
12544  Method->getType()->castAs<FunctionProtoType>()))
12545  return ExprError();
12546 
12547  return MaybeBindToTemporary(TheCall);
12548  } else {
12549  // We matched a built-in operator. Convert the arguments, then
12550  // break out so that we will build the appropriate built-in
12551  // operator node.
12552  ExprResult ArgsRes0 =
12553  PerformImplicitConversion(Args[0], Best->BuiltinParamTypes[0],
12554  Best->Conversions[0], AA_Passing);
12555  if (ArgsRes0.isInvalid())
12556  return ExprError();
12557  Args[0] = ArgsRes0.get();
12558 
12559  ExprResult ArgsRes1 =
12560  PerformImplicitConversion(Args[1], Best->BuiltinParamTypes[1],
12561  Best->Conversions[1], AA_Passing);
12562  if (ArgsRes1.isInvalid())
12563  return ExprError();
12564  Args[1] = ArgsRes1.get();
12565 
12566  break;
12567  }
12568  }
12569 
12570  case OR_No_Viable_Function: {
12571  if (CandidateSet.empty())
12572  Diag(LLoc, diag::err_ovl_no_oper)
12573  << Args[0]->getType() << /*subscript*/ 0
12574  << Args[0]->getSourceRange() << Args[1]->getSourceRange();
12575  else
12576  Diag(LLoc, diag::err_ovl_no_viable_subscript)
12577  << Args[0]->getType()
12578  << Args[0]->getSourceRange() << Args[1]->getSourceRange();
12579  CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args,
12580  "[]", LLoc);
12581  return ExprError();
12582  }
12583 
12584  case OR_Ambiguous:
12585  Diag(LLoc, diag::err_ovl_ambiguous_oper_binary)
12586  << "[]"
12587  << Args[0]->getType() << Args[1]->getType()
12588  << Args[0]->getSourceRange() << Args[1]->getSourceRange();
12589  CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, Args,
12590  "[]", LLoc);
12591  return ExprError();
12592 
12593  case OR_Deleted:
12594  Diag(LLoc, diag::err_ovl_deleted_oper)
12595  << Best->Function->isDeleted() << "[]"
12596  << getDeletedOrUnavailableSuffix(Best->Function)
12597  << Args[0]->getSourceRange() << Args[1]->getSourceRange();
12598  CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args,
12599  "[]", LLoc);
12600  return ExprError();
12601  }
12602 
12603  // We matched a built-in operator; build it.
12604  return CreateBuiltinArraySubscriptExpr(Args[0], LLoc, Args[1], RLoc);
12605 }
12606 
12607 /// BuildCallToMemberFunction - Build a call to a member
12608 /// function. MemExpr is the expression that refers to the member
12609 /// function (and includes the object parameter), Args/NumArgs are the
12610 /// arguments to the function call (not including the object
12611 /// parameter). The caller needs to validate that the member
12612 /// expression refers to a non-static member function or an overloaded
12613 /// member function.
12614 ExprResult
12616  SourceLocation LParenLoc,
12617  MultiExprArg Args,
12618  SourceLocation RParenLoc) {
12619  assert(MemExprE->getType() == Context.BoundMemberTy ||
12620  MemExprE->getType() == Context.OverloadTy);
12621 
12622  // Dig out the member expression. This holds both the object
12623  // argument and the member function we're referring to.
12624  Expr *NakedMemExpr = MemExprE->IgnoreParens();
12625 
12626  // Determine whether this is a call to a pointer-to-member function.
12627  if (BinaryOperator *op = dyn_cast<BinaryOperator>(NakedMemExpr)) {
12628  assert(op->getType() == Context.BoundMemberTy);
12629  assert(op->getOpcode() == BO_PtrMemD || op->getOpcode() == BO_PtrMemI);
12630 
12631  QualType fnType =
12632  op->getRHS()->getType()->castAs<MemberPointerType>()->getPointeeType();
12633 
12634  const FunctionProtoType *proto = fnType->castAs<FunctionProtoType>();
12635  QualType resultType = proto->getCallResultType(Context);
12637 
12638  // Check that the object type isn't more qualified than the
12639  // member function we're calling.
12640  Qualifiers funcQuals = Qualifiers::fromCVRMask(proto->getTypeQuals());
12641 
12642  QualType objectType = op->getLHS()->getType();
12643  if (op->getOpcode() == BO_PtrMemI)
12644  objectType = objectType->castAs<PointerType>()->getPointeeType();
12645  Qualifiers objectQuals = objectType.getQualifiers();
12646 
12647  Qualifiers difference = objectQuals - funcQuals;
12648  difference.removeObjCGCAttr();
12649  difference.removeAddressSpace();
12650  if (difference) {
12651  std::string qualsString = difference.getAsString();
12652  Diag(LParenLoc, diag::err_pointer_to_member_call_drops_quals)
12653  << fnType.getUnqualifiedType()
12654  << qualsString
12655  << (qualsString.find(' ') == std::string::npos ? 1 : 2);
12656  }
12657 
12658  CXXMemberCallExpr *call
12659  = new (Context) CXXMemberCallExpr(Context, MemExprE, Args,
12660  resultType, valueKind, RParenLoc);
12661 
12662  if (CheckCallReturnType(proto->getReturnType(), op->getRHS()->getLocStart(),
12663  call, nullptr))
12664  return ExprError();
12665 
12666  if (ConvertArgumentsForCall(call, op, nullptr, proto, Args, RParenLoc))
12667  return ExprError();
12668 
12669  if (CheckOtherCall(call, proto))
12670  return ExprError();
12671 
12672  return MaybeBindToTemporary(call);
12673  }
12674 
12675  if (isa<CXXPseudoDestructorExpr>(NakedMemExpr))
12676  return new (Context)
12677  CallExpr(Context, MemExprE, Args, Context.VoidTy, VK_RValue, RParenLoc);
12678 
12679  UnbridgedCastsSet UnbridgedCasts;
12680  if (checkArgPlaceholdersForOverload(*this, Args, UnbridgedCasts))
12681  return ExprError();
12682 
12683  MemberExpr *MemExpr;
12684  CXXMethodDecl *Method = nullptr;
12685  DeclAccessPair FoundDecl = DeclAccessPair::make(nullptr, AS_public);
12686  NestedNameSpecifier *Qualifier = nullptr;
12687  if (isa<MemberExpr>(NakedMemExpr)) {
12688  MemExpr = cast<MemberExpr>(NakedMemExpr);
12689  Method = cast<CXXMethodDecl>(MemExpr->getMemberDecl());
12690  FoundDecl = MemExpr->getFoundDecl();
12691  Qualifier = MemExpr->getQualifier();
12692  UnbridgedCasts.restore();
12693  } else {
12694  UnresolvedMemberExpr *UnresExpr = cast<UnresolvedMemberExpr>(NakedMemExpr);
12695  Qualifier = UnresExpr->getQualifier();
12696 
12697  QualType ObjectType = UnresExpr->getBaseType();
12698  Expr::Classification ObjectClassification
12700  : UnresExpr->getBase()->Classify(Context);
12701 
12702  // Add overload candidates
12703  OverloadCandidateSet CandidateSet(UnresExpr->getMemberLoc(),
12705 
12706  // FIXME: avoid copy.
12707  TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
12708  if (UnresExpr->hasExplicitTemplateArgs()) {
12709  UnresExpr->copyTemplateArgumentsInto(TemplateArgsBuffer);
12710  TemplateArgs = &TemplateArgsBuffer;
12711  }
12712 
12713  for (UnresolvedMemberExpr::decls_iterator I = UnresExpr->decls_begin(),
12714  E = UnresExpr->decls_end(); I != E; ++I) {
12715 
12716  NamedDecl *Func = *I;
12717  CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(Func->getDeclContext());
12718  if (isa<UsingShadowDecl>(Func))
12719  Func = cast<UsingShadowDecl>(Func)->getTargetDecl();
12720 
12721 
12722  // Microsoft supports direct constructor calls.
12723  if (getLangOpts().MicrosoftExt && isa<CXXConstructorDecl>(Func)) {
12724  AddOverloadCandidate(cast<CXXConstructorDecl>(Func), I.getPair(),
12725  Args, CandidateSet);
12726  } else if ((Method = dyn_cast<CXXMethodDecl>(Func))) {
12727  // If explicit template arguments were provided, we can't call a
12728  // non-template member function.
12729  if (TemplateArgs)
12730  continue;
12731 
12732  AddMethodCandidate(Method, I.getPair(), ActingDC, ObjectType,
12733  ObjectClassification, Args, CandidateSet,
12734  /*SuppressUserConversions=*/false);
12735  } else {
12736  AddMethodTemplateCandidate(
12737  cast<FunctionTemplateDecl>(Func), I.getPair(), ActingDC,
12738  TemplateArgs, ObjectType, ObjectClassification, Args, CandidateSet,
12739  /*SuppressUsedConversions=*/false);
12740  }
12741  }
12742 
12743  DeclarationName DeclName = UnresExpr->getMemberName();
12744 
12745  UnbridgedCasts.restore();
12746 
12748  switch (CandidateSet.BestViableFunction(*this, UnresExpr->getLocStart(),
12749  Best)) {
12750  case OR_Success:
12751  Method = cast<CXXMethodDecl>(Best->Function);
12752  FoundDecl = Best->FoundDecl;
12753  CheckUnresolvedMemberAccess(UnresExpr, Best->FoundDecl);
12754  if (DiagnoseUseOfDecl(Best->FoundDecl, UnresExpr->getNameLoc()))
12755  return ExprError();
12756  // If FoundDecl is different from Method (such as if one is a template
12757  // and the other a specialization), make sure DiagnoseUseOfDecl is
12758  // called on both.
12759  // FIXME: This would be more comprehensively addressed by modifying
12760  // DiagnoseUseOfDecl to accept both the FoundDecl and the decl
12761  // being used.
12762  if (Method != FoundDecl.getDecl() &&
12763  DiagnoseUseOfDecl(Method, UnresExpr->getNameLoc()))
12764  return ExprError();
12765  break;
12766 
12767  case OR_No_Viable_Function:
12768  Diag(UnresExpr->getMemberLoc(),
12769  diag::err_ovl_no_viable_member_function_in_call)
12770  << DeclName << MemExprE->getSourceRange();
12771  CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args);
12772  // FIXME: Leaking incoming expressions!
12773  return ExprError();
12774 
12775  case OR_Ambiguous:
12776  Diag(UnresExpr->getMemberLoc(), diag::err_ovl_ambiguous_member_call)
12777  << DeclName << MemExprE->getSourceRange();
12778  CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args);
12779  // FIXME: Leaking incoming expressions!
12780  return ExprError();
12781 
12782  case OR_Deleted:
12783  Diag(UnresExpr->getMemberLoc(), diag::err_ovl_deleted_member_call)
12784  << Best->Function->isDeleted()
12785  << DeclName
12786  << getDeletedOrUnavailableSuffix(Best->Function)
12787  << MemExprE->getSourceRange();
12788  CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args);
12789  // FIXME: Leaking incoming expressions!
12790  return ExprError();
12791  }
12792 
12793  MemExprE = FixOverloadedFunctionReference(MemExprE, FoundDecl, Method);
12794 
12795  // If overload resolution picked a static member, build a
12796  // non-member call based on that function.
12797  if (Method->isStatic()) {
12798  return BuildResolvedCallExpr(MemExprE, Method, LParenLoc, Args,
12799  RParenLoc);
12800  }
12801 
12802  MemExpr = cast<MemberExpr>(MemExprE->IgnoreParens());
12803  }
12804 
12805  QualType ResultType = Method->getReturnType();
12806  ExprValueKind VK = Expr::getValueKindForType(ResultType);
12807  ResultType = ResultType.getNonLValueExprType(Context);
12808 
12809  assert(Method && "Member call to something that isn't a method?");
12810  CXXMemberCallExpr *TheCall =
12811  new (Context) CXXMemberCallExpr(Context, MemExprE, Args,
12812  ResultType, VK, RParenLoc);
12813 
12814  // Check for a valid return type.
12815  if (CheckCallReturnType(Method->getReturnType(), MemExpr->getMemberLoc(),
12816  TheCall, Method))
12817  return ExprError();
12818 
12819  // Convert the object argument (for a non-static member function call).
12820  // We only need to do this if there was actually an overload; otherwise
12821  // it was done at lookup.
12822  if (!Method->isStatic()) {
12823  ExprResult ObjectArg =
12824  PerformObjectArgumentInitialization(MemExpr->getBase(), Qualifier,
12825  FoundDecl, Method);
12826  if (ObjectArg.isInvalid())
12827  return ExprError();
12828  MemExpr->setBase(ObjectArg.get());
12829  }
12830 
12831  // Convert the rest of the arguments
12832  const FunctionProtoType *Proto =
12833  Method->getType()->getAs<FunctionProtoType>();
12834  if (ConvertArgumentsForCall(TheCall, MemExpr, Method, Proto, Args,
12835  RParenLoc))
12836  return ExprError();
12837 
12838  DiagnoseSentinelCalls(Method, LParenLoc, Args);
12839 
12840  if (CheckFunctionCall(Method, TheCall, Proto))
12841  return ExprError();
12842 
12843  // In the case the method to call was not selected by the overloading
12844  // resolution process, we still need to handle the enable_if attribute. Do
12845  // that here, so it will not hide previous -- and more relevant -- errors.
12846  if (auto *MemE = dyn_cast<MemberExpr>(NakedMemExpr)) {
12847  if (const EnableIfAttr *Attr = CheckEnableIf(Method, Args, true)) {
12848  Diag(MemE->getMemberLoc(),
12849  diag::err_ovl_no_viable_member_function_in_call)
12850  << Method << Method->getSourceRange();
12851  Diag(Method->getLocation(),
12852  diag::note_ovl_candidate_disabled_by_function_cond_attr)
12853  << Attr->getCond()->getSourceRange() << Attr->getMessage();
12854  return ExprError();
12855  }
12856  }
12857 
12858  if ((isa<CXXConstructorDecl>(CurContext) ||
12859  isa<CXXDestructorDecl>(CurContext)) &&
12860  TheCall->getMethodDecl()->isPure()) {
12861  const CXXMethodDecl *MD = TheCall->getMethodDecl();
12862 
12863  if (isa<CXXThisExpr>(MemExpr->getBase()->IgnoreParenCasts()) &&
12864  MemExpr->performsVirtualDispatch(getLangOpts())) {
12865  Diag(MemExpr->getLocStart(),
12866  diag::warn_call_to_pure_virtual_member_function_from_ctor_dtor)
12867  << MD->getDeclName() << isa<CXXDestructorDecl>(CurContext)
12868  << MD->getParent()->getDeclName();
12869 
12870  Diag(MD->getLocStart(), diag::note_previous_decl) << MD->getDeclName();
12871  if (getLangOpts().AppleKext)
12872  Diag(MemExpr->getLocStart(),
12873  diag::note_pure_qualified_call_kext)
12874  << MD->getParent()->getDeclName()
12875  << MD->getDeclName();
12876  }
12877  }
12878 
12879  if (CXXDestructorDecl *DD =
12880  dyn_cast<CXXDestructorDecl>(TheCall->getMethodDecl())) {
12881  // a->A::f() doesn't go through the vtable, except in AppleKext mode.
12882  bool CallCanBeVirtual = !MemExpr->hasQualifier() || getLangOpts().AppleKext;
12883  CheckVirtualDtorCall(DD, MemExpr->getLocStart(), /*IsDelete=*/false,
12884  CallCanBeVirtual, /*WarnOnNonAbstractTypes=*/true,
12885  MemExpr->getMemberLoc());
12886  }
12887 
12888  return MaybeBindToTemporary(TheCall);
12889 }
12890 
12891 /// BuildCallToObjectOfClassType - Build a call to an object of class
12892 /// type (C++ [over.call.object]), which can end up invoking an
12893 /// overloaded function call operator (@c operator()) or performing a
12894 /// user-defined conversion on the object argument.
12895 ExprResult
12897  SourceLocation LParenLoc,
12898  MultiExprArg Args,
12899  SourceLocation RParenLoc) {
12900  if (checkPlaceholderForOverload(*this, Obj))
12901  return ExprError();
12902  ExprResult Object = Obj;
12903 
12904  UnbridgedCastsSet UnbridgedCasts;
12905  if (checkArgPlaceholdersForOverload(*this, Args, UnbridgedCasts))
12906  return ExprError();
12907 
12908  assert(Object.get()->getType()->isRecordType() &&
12909  "Requires object type argument");
12910  const RecordType *Record = Object.get()->getType()->getAs<RecordType>();
12911 
12912  // C++ [over.call.object]p1:
12913  // If the primary-expression E in the function call syntax
12914  // evaluates to a class object of type "cv T", then the set of
12915  // candidate functions includes at least the function call
12916  // operators of T. The function call operators of T are obtained by
12917  // ordinary lookup of the name operator() in the context of
12918  // (E).operator().
12919  OverloadCandidateSet CandidateSet(LParenLoc,
12921  DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(OO_Call);
12922 
12923  if (RequireCompleteType(LParenLoc, Object.get()->getType(),
12924  diag::err_incomplete_object_call, Object.get()))
12925  return true;
12926 
12927  LookupResult R(*this, OpName, LParenLoc, LookupOrdinaryName);
12928  LookupQualifiedName(R, Record->getDecl());
12929  R.suppressDiagnostics();
12930 
12931  for (LookupResult::iterator Oper = R.begin(), OperEnd = R.end();
12932  Oper != OperEnd; ++Oper) {
12933  AddMethodCandidate(Oper.getPair(), Object.get()->getType(),
12934  Object.get()->Classify(Context), Args, CandidateSet,
12935  /*SuppressUserConversions=*/false);
12936  }
12937 
12938  // C++ [over.call.object]p2:
12939  // In addition, for each (non-explicit in C++0x) conversion function
12940  // declared in T of the form
12941  //
12942  // operator conversion-type-id () cv-qualifier;
12943  //
12944  // where cv-qualifier is the same cv-qualification as, or a
12945  // greater cv-qualification than, cv, and where conversion-type-id
12946  // denotes the type "pointer to function of (P1,...,Pn) returning
12947  // R", or the type "reference to pointer to function of
12948  // (P1,...,Pn) returning R", or the type "reference to function
12949  // of (P1,...,Pn) returning R", a surrogate call function [...]
12950  // is also considered as a candidate function. Similarly,
12951  // surrogate call functions are added to the set of candidate
12952  // functions for each conversion function declared in an
12953  // accessible base class provided the function is not hidden
12954  // within T by another intervening declaration.
12955  const auto &Conversions =
12956  cast<CXXRecordDecl>(Record->getDecl())->getVisibleConversionFunctions();
12957  for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
12958  NamedDecl *D = *I;
12959  CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext());
12960  if (isa<UsingShadowDecl>(D))
12961  D = cast<UsingShadowDecl>(D)->getTargetDecl();
12962 
12963  // Skip over templated conversion functions; they aren't
12964  // surrogates.
12965  if (isa<FunctionTemplateDecl>(D))
12966  continue;
12967 
12968  CXXConversionDecl *Conv = cast<CXXConversionDecl>(D);
12969  if (!Conv->isExplicit()) {
12970  // Strip the reference type (if any) and then the pointer type (if
12971  // any) to get down to what might be a function type.
12972  QualType ConvType = Conv->getConversionType().getNonReferenceType();
12973  if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>())
12974  ConvType = ConvPtrType->getPointeeType();
12975 
12976  if (const FunctionProtoType *Proto = ConvType->getAs<FunctionProtoType>())
12977  {
12978  AddSurrogateCandidate(Conv, I.getPair(), ActingContext, Proto,
12979  Object.get(), Args, CandidateSet);
12980  }
12981  }
12982  }
12983 
12984  bool HadMultipleCandidates = (CandidateSet.size() > 1);
12985 
12986  // Perform overload resolution.
12988  switch (CandidateSet.BestViableFunction(*this, Object.get()->getLocStart(),
12989  Best)) {
12990  case OR_Success:
12991  // Overload resolution succeeded; we'll build the appropriate call
12992  // below.
12993  break;
12994 
12995  case OR_No_Viable_Function:
12996  if (CandidateSet.empty())
12997  Diag(Object.get()->getLocStart(), diag::err_ovl_no_oper)
12998  << Object.get()->getType() << /*call*/ 1
12999  << Object.get()->getSourceRange();
13000  else
13001  Diag(Object.get()->getLocStart(),
13002  diag::err_ovl_no_viable_object_call)
13003  << Object.get()->getType() << Object.get()->getSourceRange();
13004  CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args);
13005  break;
13006 
13007  case OR_Ambiguous:
13008  Diag(Object.get()->getLocStart(),
13009  diag::err_ovl_ambiguous_object_call)
13010  << Object.get()->getType() << Object.get()->getSourceRange();
13011  CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, Args);
13012  break;
13013 
13014  case OR_Deleted:
13015  Diag(Object.get()->getLocStart(),
13016  diag::err_ovl_deleted_object_call)
13017  << Best->Function->isDeleted()
13018  << Object.get()->getType()
13019  << getDeletedOrUnavailableSuffix(Best->Function)
13020  << Object.get()->getSourceRange();
13021  CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args);
13022  break;
13023  }
13024 
13025  if (Best == CandidateSet.end())
13026  return true;
13027 
13028  UnbridgedCasts.restore();
13029 
13030  if (Best->Function == nullptr) {
13031  // Since there is no function declaration, this is one of the
13032  // surrogate candidates. Dig out the conversion function.
13033  CXXConversionDecl *Conv
13034  = cast<CXXConversionDecl>(
13035  Best->Conversions[0].UserDefined.ConversionFunction);
13036 
13037  CheckMemberOperatorAccess(LParenLoc, Object.get(), nullptr,
13038  Best->FoundDecl);
13039  if (DiagnoseUseOfDecl(Best->FoundDecl, LParenLoc))
13040  return ExprError();
13041  assert(Conv == Best->FoundDecl.getDecl() &&
13042  "Found Decl & conversion-to-functionptr should be same, right?!");
13043  // We selected one of the surrogate functions that converts the
13044  // object parameter to a function pointer. Perform the conversion
13045  // on the object argument, then let ActOnCallExpr finish the job.
13046 
13047  // Create an implicit member expr to refer to the conversion operator.
13048  // and then call it.
13049  ExprResult Call = BuildCXXMemberCallExpr(Object.get(), Best->FoundDecl,
13050  Conv, HadMultipleCandidates);
13051  if (Call.isInvalid())
13052  return ExprError();
13053  // Record usage of conversion in an implicit cast.
13054  Call = ImplicitCastExpr::Create(Context, Call.get()->getType(),
13055  CK_UserDefinedConversion, Call.get(),
13056  nullptr, VK_RValue);
13057 
13058  return ActOnCallExpr(S, Call.get(), LParenLoc, Args, RParenLoc);
13059  }
13060 
13061  CheckMemberOperatorAccess(LParenLoc, Object.get(), nullptr, Best->FoundDecl);
13062 
13063  // We found an overloaded operator(). Build a CXXOperatorCallExpr
13064  // that calls this method, using Object for the implicit object
13065  // parameter and passing along the remaining arguments.
13066  CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
13067 
13068  // An error diagnostic has already been printed when parsing the declaration.
13069  if (Method->isInvalidDecl())
13070  return ExprError();
13071 
13072  const FunctionProtoType *Proto =
13073  Method->getType()->getAs<FunctionProtoType>();
13074 
13075  unsigned NumParams = Proto->getNumParams();
13076 
13077  DeclarationNameInfo OpLocInfo(
13078  Context.DeclarationNames.getCXXOperatorName(OO_Call), LParenLoc);
13079  OpLocInfo.setCXXOperatorNameRange(SourceRange(LParenLoc, RParenLoc));
13080  ExprResult NewFn = CreateFunctionRefExpr(*this, Method, Best->FoundDecl,
13081  Obj, HadMultipleCandidates,
13082  OpLocInfo.getLoc(),
13083  OpLocInfo.getInfo());
13084  if (NewFn.isInvalid())
13085  return true;
13086 
13087  // Build the full argument list for the method call (the implicit object
13088  // parameter is placed at the beginning of the list).
13089  SmallVector<Expr *, 8> MethodArgs(Args.size() + 1);
13090  MethodArgs[0] = Object.get();
13091  std::copy(Args.begin(), Args.end(), MethodArgs.begin() + 1);
13092 
13093  // Once we've built TheCall, all of the expressions are properly
13094  // owned.
13095  QualType ResultTy = Method->getReturnType();
13097  ResultTy = ResultTy.getNonLValueExprType(Context);
13098 
13099  CXXOperatorCallExpr *TheCall = new (Context)
13100  CXXOperatorCallExpr(Context, OO_Call, NewFn.get(), MethodArgs, ResultTy,
13101  VK, RParenLoc, FPOptions());
13102 
13103  if (CheckCallReturnType(Method->getReturnType(), LParenLoc, TheCall, Method))
13104  return true;
13105 
13106  // We may have default arguments. If so, we need to allocate more
13107  // slots in the call for them.
13108  if (Args.size() < NumParams)
13109  TheCall->setNumArgs(Context, NumParams + 1);
13110 
13111  bool IsError = false;
13112 
13113  // Initialize the implicit object parameter.
13114  ExprResult ObjRes =
13115  PerformObjectArgumentInitialization(Object.get(), /*Qualifier=*/nullptr,
13116  Best->FoundDecl, Method);
13117  if (ObjRes.isInvalid())
13118  IsError = true;
13119  else
13120  Object = ObjRes;
13121  TheCall->setArg(0, Object.get());
13122 
13123  // Check the argument types.
13124  for (unsigned i = 0; i != NumParams; i++) {
13125  Expr *Arg;
13126  if (i < Args.size()) {
13127  Arg = Args[i];
13128 
13129  // Pass the argument.
13130 
13131  ExprResult InputInit
13132  = PerformCopyInitialization(InitializedEntity::InitializeParameter(
13133  Context,
13134  Method->getParamDecl(i)),
13135  SourceLocation(), Arg);
13136 
13137  IsError |= InputInit.isInvalid();
13138  Arg = InputInit.getAs<Expr>();
13139  } else {
13140  ExprResult DefArg
13141  = BuildCXXDefaultArgExpr(LParenLoc, Method, Method->getParamDecl(i));
13142  if (DefArg.isInvalid()) {
13143  IsError = true;
13144  break;
13145  }
13146 
13147  Arg = DefArg.getAs<Expr>();
13148  }
13149 
13150  TheCall->setArg(i + 1, Arg);
13151  }
13152 
13153  // If this is a variadic call, handle args passed through "...".
13154  if (Proto->isVariadic()) {
13155  // Promote the arguments (C99 6.5.2.2p7).
13156  for (unsigned i = NumParams, e = Args.size(); i < e; i++) {
13157  ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], VariadicMethod,
13158  nullptr);
13159  IsError |= Arg.isInvalid();
13160  TheCall->setArg(i + 1, Arg.get());
13161  }
13162  }
13163 
13164  if (IsError) return true;
13165 
13166  DiagnoseSentinelCalls(Method, LParenLoc, Args);
13167 
13168  if (CheckFunctionCall(Method, TheCall, Proto))
13169  return true;
13170 
13171  return MaybeBindToTemporary(TheCall);
13172 }
13173 
13174 /// BuildOverloadedArrowExpr - Build a call to an overloaded @c operator->
13175 /// (if one exists), where @c Base is an expression of class type and
13176 /// @c Member is the name of the member we're trying to find.
13177 ExprResult
13179  bool *NoArrowOperatorFound) {
13180  assert(Base->getType()->isRecordType() &&
13181  "left-hand side must have class type");
13182 
13183  if (checkPlaceholderForOverload(*this, Base))
13184  return ExprError();
13185 
13186  SourceLocation Loc = Base->getExprLoc();
13187 
13188  // C++ [over.ref]p1:
13189  //
13190  // [...] An expression x->m is interpreted as (x.operator->())->m
13191  // for a class object x of type T if T::operator->() exists and if
13192  // the operator is selected as the best match function by the
13193  // overload resolution mechanism (13.3).
13194  DeclarationName OpName =
13195  Context.DeclarationNames.getCXXOperatorName(OO_Arrow);
13197  const RecordType *BaseRecord = Base->getType()->getAs<RecordType>();
13198 
13199  if (RequireCompleteType(Loc, Base->getType(),
13200  diag::err_typecheck_incomplete_tag, Base))
13201  return ExprError();
13202 
13203  LookupResult R(*this, OpName, OpLoc, LookupOrdinaryName);
13204  LookupQualifiedName(R, BaseRecord->getDecl());
13205  R.suppressDiagnostics();
13206 
13207  for (LookupResult::iterator Oper = R.begin(), OperEnd = R.end();
13208  Oper != OperEnd; ++Oper) {
13209  AddMethodCandidate(Oper.getPair(), Base->getType(), Base->Classify(Context),
13210  None, CandidateSet, /*SuppressUserConversions=*/false);
13211  }
13212 
13213  bool HadMultipleCandidates = (CandidateSet.size() > 1);
13214 
13215  // Perform overload resolution.
13217  switch (CandidateSet.BestViableFunction(*this, OpLoc, Best)) {
13218  case OR_Success:
13219  // Overload resolution succeeded; we'll build the call below.
13220  break;
13221 
13222  case OR_No_Viable_Function:
13223  if (CandidateSet.empty()) {
13224  QualType BaseType = Base->getType();
13225  if (NoArrowOperatorFound) {
13226  // Report this specific error to the caller instead of emitting a
13227  // diagnostic, as requested.
13228  *NoArrowOperatorFound = true;
13229  return ExprError();
13230  }
13231  Diag(OpLoc, diag::err_typecheck_member_reference_arrow)
13232  << BaseType << Base->getSourceRange();
13233  if (BaseType->isRecordType() && !BaseType->isPointerType()) {
13234  Diag(OpLoc, diag::note_typecheck_member_reference_suggestion)
13235  << FixItHint::CreateReplacement(OpLoc, ".");
13236  }
13237  } else
13238  Diag(OpLoc, diag::err_ovl_no_viable_oper)
13239  << "operator->" << Base->getSourceRange();
13240  CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Base);
13241  return ExprError();
13242 
13243  case OR_Ambiguous:
13244  Diag(OpLoc, diag::err_ovl_ambiguous_oper_unary)
13245  << "->" << Base->getType() << Base->getSourceRange();
13246  CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, Base);
13247  return ExprError();
13248 
13249  case OR_Deleted:
13250  Diag(OpLoc, diag::err_ovl_deleted_oper)
13251  << Best->Function->isDeleted()
13252  << "->"
13253  << getDeletedOrUnavailableSuffix(Best->Function)
13254  << Base->getSourceRange();
13255  CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Base);
13256  return ExprError();
13257  }
13258 
13259  CheckMemberOperatorAccess(OpLoc, Base, nullptr, Best->FoundDecl);
13260 
13261  // Convert the object parameter.
13262  CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
13264  PerformObjectArgumentInitialization(Base, /*Qualifier=*/nullptr,
13265  Best->FoundDecl, Method);
13266  if (BaseResult.isInvalid())
13267  return ExprError();
13268  Base = BaseResult.get();
13269 
13270  // Build the operator call.
13271  ExprResult FnExpr = CreateFunctionRefExpr(*this, Method, Best->FoundDecl,
13272  Base, HadMultipleCandidates, OpLoc);
13273  if (FnExpr.isInvalid())
13274  return ExprError();
13275 
13276  QualType ResultTy = Method->getReturnType();
13278  ResultTy = ResultTy.getNonLValueExprType(Context);
13279  CXXOperatorCallExpr *TheCall =
13280  new (Context) CXXOperatorCallExpr(Context, OO_Arrow, FnExpr.get(),
13281  Base, ResultTy, VK, OpLoc, FPOptions());
13282 
13283  if (CheckCallReturnType(Method->getReturnType(), OpLoc, TheCall, Method))
13284  return ExprError();
13285 
13286  if (CheckFunctionCall(Method, TheCall,
13287  Method->getType()->castAs<FunctionProtoType>()))
13288  return ExprError();
13289 
13290  return MaybeBindToTemporary(TheCall);
13291 }
13292 
13293 /// BuildLiteralOperatorCall - Build a UserDefinedLiteral by creating a call to
13294 /// a literal operator described by the provided lookup results.
13296  DeclarationNameInfo &SuffixInfo,
13297  ArrayRef<Expr*> Args,
13298  SourceLocation LitEndLoc,
13299  TemplateArgumentListInfo *TemplateArgs) {
13300  SourceLocation UDSuffixLoc = SuffixInfo.getCXXLiteralOperatorNameLoc();
13301 
13302  OverloadCandidateSet CandidateSet(UDSuffixLoc,
13304  AddFunctionCandidates(R.asUnresolvedSet(), Args, CandidateSet, TemplateArgs,
13305  /*SuppressUserConversions=*/true);
13306 
13307  bool HadMultipleCandidates = (CandidateSet.size() > 1);
13308 
13309  // Perform overload resolution. This will usually be trivial, but might need
13310  // to perform substitutions for a literal operator template.
13312  switch (CandidateSet.BestViableFunction(*this, UDSuffixLoc, Best)) {
13313  case OR_Success:
13314  case OR_Deleted:
13315  break;
13316 
13317  case OR_No_Viable_Function:
13318  Diag(UDSuffixLoc, diag::err_ovl_no_viable_function_in_call)
13319  << R.getLookupName();
13320  CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args);
13321  return ExprError();
13322 
13323  case OR_Ambiguous:
13324  Diag(R.getNameLoc(), diag::err_ovl_ambiguous_call) << R.getLookupName();
13325  CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, Args);
13326  return ExprError();
13327  }
13328 
13329  FunctionDecl *FD = Best->Function;
13330  ExprResult Fn = CreateFunctionRefExpr(*this, FD, Best->FoundDecl,
13331  nullptr, HadMultipleCandidates,
13332  SuffixInfo.getLoc(),
13333  SuffixInfo.getInfo());
13334  if (Fn.isInvalid())
13335  return true;
13336 
13337  // Check the argument types. This should almost always be a no-op, except
13338  // that array-to-pointer decay is applied to string literals.
13339  Expr *ConvArgs[2];
13340  for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
13341  ExprResult InputInit = PerformCopyInitialization(
13343  SourceLocation(), Args[ArgIdx]);
13344  if (InputInit.isInvalid())
13345  return true;
13346  ConvArgs[ArgIdx] = InputInit.get();
13347  }
13348 
13349  QualType ResultTy = FD->getReturnType();
13351  ResultTy = ResultTy.getNonLValueExprType(Context);
13352 
13353  UserDefinedLiteral *UDL =
13354  new (Context) UserDefinedLiteral(Context, Fn.get(),
13355  llvm::makeArrayRef(ConvArgs, Args.size()),
13356  ResultTy, VK, LitEndLoc, UDSuffixLoc);
13357 
13358  if (CheckCallReturnType(FD->getReturnType(), UDSuffixLoc, UDL, FD))
13359  return ExprError();
13360 
13361  if (CheckFunctionCall(FD, UDL, nullptr))
13362  return ExprError();
13363 
13364  return MaybeBindToTemporary(UDL);
13365 }
13366 
13367 /// Build a call to 'begin' or 'end' for a C++11 for-range statement. If the
13368 /// given LookupResult is non-empty, it is assumed to describe a member which
13369 /// will be invoked. Otherwise, the function will be found via argument
13370 /// dependent lookup.
13371 /// CallExpr is set to a valid expression and FRS_Success returned on success,
13372 /// otherwise CallExpr is set to ExprError() and some non-success value
13373 /// is returned.
13376  SourceLocation RangeLoc,
13377  const DeclarationNameInfo &NameInfo,
13378  LookupResult &MemberLookup,
13379  OverloadCandidateSet *CandidateSet,
13380  Expr *Range, ExprResult *CallExpr) {
13381  Scope *S = nullptr;
13382 
13383  CandidateSet->clear(OverloadCandidateSet::CSK_Normal);
13384  if (!MemberLookup.empty()) {
13385  ExprResult MemberRef =
13386  BuildMemberReferenceExpr(Range, Range->getType(), Loc,
13387  /*IsPtr=*/false, CXXScopeSpec(),
13388  /*TemplateKWLoc=*/SourceLocation(),
13389  /*FirstQualifierInScope=*/nullptr,
13390  MemberLookup,
13391  /*TemplateArgs=*/nullptr, S);
13392  if (MemberRef.isInvalid()) {
13393  *CallExpr = ExprError();
13394  return FRS_DiagnosticIssued;
13395  }
13396  *CallExpr = ActOnCallExpr(S, MemberRef.get(), Loc, None, Loc, nullptr);
13397  if (CallExpr->isInvalid()) {
13398  *CallExpr = ExprError();
13399  return FRS_DiagnosticIssued;
13400  }
13401  } else {
13402  UnresolvedSet<0> FoundNames;
13403  UnresolvedLookupExpr *Fn =
13404  UnresolvedLookupExpr::Create(Context, /*NamingClass=*/nullptr,
13405  NestedNameSpecifierLoc(), NameInfo,
13406  /*NeedsADL=*/true, /*Overloaded=*/false,
13407  FoundNames.begin(), FoundNames.end());
13408 
13409  bool CandidateSetError = buildOverloadedCallSet(S, Fn, Fn, Range, Loc,
13410  CandidateSet, CallExpr);
13411  if (CandidateSet->empty() || CandidateSetError) {
13412  *CallExpr = ExprError();
13413  return FRS_NoViableFunction;
13414  }
13416  OverloadingResult OverloadResult =
13417  CandidateSet->BestViableFunction(*this, Fn->getLocStart(), Best);
13418 
13419  if (OverloadResult == OR_No_Viable_Function) {
13420  *CallExpr = ExprError();
13421  return FRS_NoViableFunction;
13422  }
13423  *CallExpr = FinishOverloadedCallExpr(*this, S, Fn, Fn, Loc, Range,
13424  Loc, nullptr, CandidateSet, &Best,
13425  OverloadResult,
13426  /*AllowTypoCorrection=*/false);
13427  if (CallExpr->isInvalid() || OverloadResult != OR_Success) {
13428  *CallExpr = ExprError();
13429  return FRS_DiagnosticIssued;
13430  }
13431  }
13432  return FRS_Success;
13433 }
13434 
13435 
13436 /// FixOverloadedFunctionReference - E is an expression that refers to
13437 /// a C++ overloaded function (possibly with some parentheses and
13438 /// perhaps a '&' around it). We have resolved the overloaded function
13439 /// to the function declaration Fn, so patch up the expression E to
13440 /// refer (possibly indirectly) to Fn. Returns the new expr.
13442  FunctionDecl *Fn) {
13443  if (ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
13444  Expr *SubExpr = FixOverloadedFunctionReference(PE->getSubExpr(),
13445  Found, Fn);
13446  if (SubExpr == PE->getSubExpr())
13447  return PE;
13448 
13449  return new (Context) ParenExpr(PE->getLParen(), PE->getRParen(), SubExpr);
13450  }
13451 
13452  if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
13453  Expr *SubExpr = FixOverloadedFunctionReference(ICE->getSubExpr(),
13454  Found, Fn);
13455  assert(Context.hasSameType(ICE->getSubExpr()->getType(),
13456  SubExpr->getType()) &&
13457  "Implicit cast type cannot be determined from overload");
13458  assert(ICE->path_empty() && "fixing up hierarchy conversion?");
13459  if (SubExpr == ICE->getSubExpr())
13460  return ICE;
13461 
13462  return ImplicitCastExpr::Create(Context, ICE->getType(),
13463  ICE->getCastKind(),
13464  SubExpr, nullptr,
13465  ICE->getValueKind());
13466  }
13467 
13468  if (auto *GSE = dyn_cast<GenericSelectionExpr>(E)) {
13469  if (!GSE->isResultDependent()) {
13470  Expr *SubExpr =
13471  FixOverloadedFunctionReference(GSE->getResultExpr(), Found, Fn);
13472  if (SubExpr == GSE->getResultExpr())
13473  return GSE;
13474 
13475  // Replace the resulting type information before rebuilding the generic
13476  // selection expression.
13477  ArrayRef<Expr *> A = GSE->getAssocExprs();
13478  SmallVector<Expr *, 4> AssocExprs(A.begin(), A.end());
13479  unsigned ResultIdx = GSE->getResultIndex();
13480  AssocExprs[ResultIdx] = SubExpr;
13481 
13482  return new (Context) GenericSelectionExpr(
13483  Context, GSE->getGenericLoc(), GSE->getControllingExpr(),
13484  GSE->getAssocTypeSourceInfos(), AssocExprs, GSE->getDefaultLoc(),
13485  GSE->getRParenLoc(), GSE->containsUnexpandedParameterPack(),
13486  ResultIdx);
13487  }
13488  // Rather than fall through to the unreachable, return the original generic
13489  // selection expression.
13490  return GSE;
13491  }
13492 
13493  if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(E)) {
13494  assert(UnOp->getOpcode() == UO_AddrOf &&
13495  "Can only take the address of an overloaded function");
13496  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) {
13497  if (Method->isStatic()) {
13498  // Do nothing: static member functions aren't any different
13499  // from non-member functions.
13500  } else {
13501  // Fix the subexpression, which really has to be an
13502  // UnresolvedLookupExpr holding an overloaded member function
13503  // or template.
13504  Expr *SubExpr = FixOverloadedFunctionReference(UnOp->getSubExpr(),
13505  Found, Fn);
13506  if (SubExpr == UnOp->getSubExpr())
13507  return UnOp;
13508 
13509  assert(isa<DeclRefExpr>(SubExpr)
13510  && "fixed to something other than a decl ref");
13511  assert(cast<DeclRefExpr>(SubExpr)->getQualifier()
13512  && "fixed to a member ref with no nested name qualifier");
13513 
13514  // We have taken the address of a pointer to member
13515  // function. Perform the computation here so that we get the
13516  // appropriate pointer to member type.
13517  QualType ClassType
13518  = Context.getTypeDeclType(cast<RecordDecl>(Method->getDeclContext()));
13519  QualType MemPtrType
13520  = Context.getMemberPointerType(Fn->getType(), ClassType.getTypePtr());
13521  // Under the MS ABI, lock down the inheritance model now.
13522  if (Context.getTargetInfo().getCXXABI().isMicrosoft())
13523  (void)isCompleteType(UnOp->getOperatorLoc(), MemPtrType);
13524 
13525  return new (Context) UnaryOperator(SubExpr, UO_AddrOf, MemPtrType,
13527  UnOp->getOperatorLoc());
13528  }
13529  }
13530  Expr *SubExpr = FixOverloadedFunctionReference(UnOp->getSubExpr(),
13531  Found, Fn);
13532  if (SubExpr == UnOp->getSubExpr())
13533  return UnOp;
13534 
13535  return new (Context) UnaryOperator(SubExpr, UO_AddrOf,
13536  Context.getPointerType(SubExpr->getType()),
13538  UnOp->getOperatorLoc());
13539  }
13540 
13541  // C++ [except.spec]p17:
13542  // An exception-specification is considered to be needed when:
13543  // - in an expression the function is the unique lookup result or the
13544  // selected member of a set of overloaded functions
13545  if (auto *FPT = Fn->getType()->getAs<FunctionProtoType>())
13546  ResolveExceptionSpec(E->getExprLoc(), FPT);
13547 
13548  if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
13549  // FIXME: avoid copy.
13550  TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
13551  if (ULE->hasExplicitTemplateArgs()) {
13552  ULE->copyTemplateArgumentsInto(TemplateArgsBuffer);
13553  TemplateArgs = &TemplateArgsBuffer;
13554  }
13555 
13556  DeclRefExpr *DRE = DeclRefExpr::Create(Context,
13557  ULE->getQualifierLoc(),
13558  ULE->getTemplateKeywordLoc(),
13559  Fn,
13560  /*enclosing*/ false, // FIXME?
13561  ULE->getNameLoc(),
13562  Fn->getType(),
13563  VK_LValue,
13564  Found.getDecl(),
13565  TemplateArgs);
13566  MarkDeclRefReferenced(DRE);
13567  DRE->setHadMultipleCandidates(ULE->getNumDecls() > 1);
13568  return DRE;
13569  }
13570 
13571  if (UnresolvedMemberExpr *MemExpr = dyn_cast<UnresolvedMemberExpr>(E)) {
13572  // FIXME: avoid copy.
13573  TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
13574  if (MemExpr->hasExplicitTemplateArgs()) {
13575  MemExpr->copyTemplateArgumentsInto(TemplateArgsBuffer);
13576  TemplateArgs = &TemplateArgsBuffer;
13577  }
13578 
13579  Expr *Base;
13580 
13581  // If we're filling in a static method where we used to have an
13582  // implicit member access, rewrite to a simple decl ref.
13583  if (MemExpr->isImplicitAccess()) {
13584  if (cast<CXXMethodDecl>(Fn)->isStatic()) {
13585  DeclRefExpr *DRE = DeclRefExpr::Create(Context,
13586  MemExpr->getQualifierLoc(),
13587  MemExpr->getTemplateKeywordLoc(),
13588  Fn,
13589  /*enclosing*/ false,
13590  MemExpr->getMemberLoc(),
13591  Fn->getType(),
13592  VK_LValue,
13593  Found.getDecl(),
13594  TemplateArgs);
13595  MarkDeclRefReferenced(DRE);
13596  DRE->setHadMultipleCandidates(MemExpr->getNumDecls() > 1);
13597  return DRE;
13598  } else {
13599  SourceLocation Loc = MemExpr->getMemberLoc();
13600  if (MemExpr->getQualifier())
13601  Loc = MemExpr->getQualifierLoc().getBeginLoc();
13602  CheckCXXThisCapture(Loc);
13603  Base = new (Context) CXXThisExpr(Loc,
13604  MemExpr->getBaseType(),
13605  /*isImplicit=*/true);
13606  }
13607  } else
13608  Base = MemExpr->getBase();
13609 
13610  ExprValueKind valueKind;
13611  QualType type;
13612  if (cast<CXXMethodDecl>(Fn)->isStatic()) {
13613  valueKind = VK_LValue;
13614  type = Fn->getType();
13615  } else {
13616  valueKind = VK_RValue;
13617  type = Context.BoundMemberTy;
13618  }
13619 
13621  Context, Base, MemExpr->isArrow(), MemExpr->getOperatorLoc(),
13622  MemExpr->getQualifierLoc(), MemExpr->getTemplateKeywordLoc(), Fn, Found,
13623  MemExpr->getMemberNameInfo(), TemplateArgs, type, valueKind,
13624  OK_Ordinary);
13625  ME->setHadMultipleCandidates(true);
13626  MarkMemberReferenced(ME);
13627  return ME;
13628  }
13629 
13630  llvm_unreachable("Invalid reference to overloaded function");
13631 }
13632 
13634  DeclAccessPair Found,
13635  FunctionDecl *Fn) {
13636  return FixOverloadedFunctionReference(E.get(), Found, Fn);
13637 }
Abstract class used to diagnose incomplete types.
Definition: Sema.h:1483
unsigned ExplicitCallArguments
The number of call arguments that were explicitly provided, to be used while performing partial order...
Definition: Overload.h:674
A call to an overloaded operator written using operator syntax.
Definition: ExprCXX.h:78
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
const ObjCInterfaceType * getInterfaceType() const
If this pointer points to an Objective C @interface type, gets the type for that interface.
Definition: Type.cpp:1507
void setValueDependent(bool VD)
Set whether this expression is value-dependent or not.
Definition: Expr.h:152
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Function pointer conversion (C++17 4.13)
Definition: Overload.h:65
DeclAccessPair FoundConversionFunction
The declaration that we found via name lookup, which might be the same as ConversionFunction or it mi...
Definition: Overload.h:290
Defines the clang::ASTContext interface.
unsigned DeprecatedStringLiteralToCharPtr
Whether this is the deprecated conversion of a string literal to a pointer to non-const character dat...
Definition: Overload.h:161
void clear(CandidateSetKind CSK)
Clear out all of the candidates.
SmallVector< TemplateSpecCandidate, 16 >::iterator iterator
(CUDA) This candidate was not viable because the callee was not accessible from the caller&#39;s target (...
Definition: Overload.h:601
unsigned getNumDecls() const
Gets the number of declarations in the unresolved set.
Definition: ExprCXX.h:2649
CanQualType LongLongTy
Definition: ASTContext.h:1004
An instance of this class is created to represent a function declaration or definition.
Definition: Decl.h:1697
NamespaceDecl * getStdNamespace() const
void setStdInitializerListElement(bool V=true)
Definition: Overload.h:548
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
bool EllipsisConversion
EllipsisConversion - When this is true, it means user-defined conversion sequence starts with a ...
Definition: Overload.h:271
CUDA Target attributes do not match.
Definition: Sema.h:6883
static void markUnaddressableCandidatesUnviable(Sema &S, OverloadCandidateSet &CS)
bool hasExplicitTemplateArgs() const
Determines whether this expression had explicit template arguments.
Definition: ExprCXX.h:2694
void removeUnaligned()
Definition: Type.h:316
ExprResult PerformContextuallyConvertToBool(Expr *From)
PerformContextuallyConvertToBool - Perform a contextual conversion of the expression From to bool (C+...
const TemplateArgument * getSecondArg()
Return the second template argument this deduction failure refers to, if any.
Smart pointer class that efficiently represents Objective-C method names.
static bool isTypeValid(QualType T)
Determine whether the given type is valid, e.g., it is not an invalid C++ class.
QualType getObjCIdType() const
Represents the Objective-CC id type.
Definition: ASTContext.h:1800
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2283
QualType getPointeeType() const
Definition: Type.h:2296
A (possibly-)qualified type.
Definition: Type.h:653
bool isBlockPointerType() const
Definition: Type.h:5950
static void DiagnoseArityMismatch(Sema &S, NamedDecl *Found, Decl *D, unsigned NumFormalArgs)
General arity mismatch diagnosis over a candidate in a candidate set.
void AddMethodCandidate(DeclAccessPair FoundDecl, QualType ObjectType, Expr::Classification ObjectClassification, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversion=false)
AddMethodCandidate - Adds a named decl (which is some kind of method) as a method candidate to the gi...
TemplateDeductionResult
Describes the result of template argument deduction.
Definition: Sema.h:6837
bool isArrayType() const
Definition: Type.h:5991
bool isMemberPointerType() const
Definition: Type.h:5973
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
Definition: Expr.h:2483
ImplicitConversionKind
ImplicitConversionKind - The kind of implicit conversion used to convert an argument to a parameter&#39;s...
Definition: Overload.h:60
unsigned param_size() const
Definition: DeclObjC.h:379
bool isEquivalentInternalLinkageDeclaration(const NamedDecl *A, const NamedDecl *B)
Determine if A and B are equivalent internal linkage declarations from different modules, and thus an ambiguity error can be downgraded to an extension warning.
void setFromType(QualType T)
Definition: Overload.h:215
const DeclarationNameLoc & getInfo() const
llvm::PointerUnion3< TemplateTypeParmDecl *, NonTypeTemplateParmDecl *, TemplateTemplateParmDecl * > TemplateParameter
Stores a template parameter of any kind.
Definition: DeclTemplate.h:62
Conversion not allowed by the C standard, but that we accept as an extension anyway.
Definition: Overload.h:106
static bool IsTransparentUnionStandardConversion(Sema &S, Expr *From, QualType &ToType, bool InOverloadResolution, StandardConversionSequence &SCS, bool CStyle)
Template argument deduction was successful.
Definition: Sema.h:6839
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
UnresolvedSetIterator getMostSpecialized(UnresolvedSetIterator SBegin, UnresolvedSetIterator SEnd, TemplateSpecCandidateSet &FailedCandidates, SourceLocation Loc, const PartialDiagnostic &NoneDiag, const PartialDiagnostic &AmbigDiag, const PartialDiagnostic &CandidateDiag, bool Complain=true, QualType TargetType=QualType())
Retrieve the most specialized of the given function template specializations.
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc...
Definition: Sema.h:2994
const Expr * getInit(unsigned Init) const
Definition: Expr.h:3920
bool isObjCPointerConversion(QualType FromType, QualType ToType, QualType &ConvertedType, bool &IncompatibleObjC)
isObjCPointerConversion - Determines whether this is an Objective-C pointer conversion.
CanQualType Char32Ty
Definition: ASTContext.h:1003
QualType getPointerDiffType() const
Return the unique type for "ptrdiff_t" (C99 7.17) defined in <stddef.h>.
A structure used to record information about a failed template argument deduction, for diagnosis.
Checking non-dependent argument conversions failed.
Definition: Sema.h:6879
static UnresolvedLookupExpr * Create(const ASTContext &C, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool ADL, bool Overloaded, UnresolvedSetIterator Begin, UnresolvedSetIterator End)
Definition: ExprCXX.h:2781
Cannot tell whether this is a narrowing conversion because the expression is value-dependent.
Definition: Overload.h:130
bool isArithmeticType() const
Definition: Type.cpp:1908
specific_attr_iterator< T > specific_attr_begin() const
Definition: DeclBase.h:522
Kind getKind() const
Definition: Type.h:2164
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3056
Provides information about an attempted template argument deduction, whose success or failure was des...
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:456
bool isMain() const
Determines whether this function is "main", which is the entry point into an executable program...
Definition: Decl.cpp:2645
bool diagnoseArgDependentDiagnoseIfAttrs(const FunctionDecl *Function, const Expr *ThisArg, ArrayRef< const Expr *> Args, SourceLocation Loc)
Emit diagnostics for the diagnose_if attributes on Function, ignoring any non-ArgDependent DiagnoseIf...
Vector conversions.
Definition: Overload.h:79
bool isRealFloatingType() const
Floating point categories.
Definition: Type.cpp:1893
bool hasPlaceholderType() const
Returns whether this expression has a placeholder type.
Definition: Expr.h:472
void clear()
Clear out all of the candidates.
ActionResult< Expr * > ExprResult
Definition: Ownership.h:251
Complex conversions (C99 6.3.1.6)
Definition: Overload.h:72
void setObjCLifetime(ObjCLifetime type)
Definition: Type.h:344
bool isRecordType() const
Definition: Type.h:6015
Expr * getBase() const
Definition: Expr.h:2477
bool isEmpty() const
No scope specifier.
Definition: DeclSpec.h:189
std::string getTemplateArgumentBindingsText(const TemplateParameterList *Params, const TemplateArgumentList &Args)
Produces a formatted string that describes the binding of template parameters to template arguments...
static InitializedEntity InitializeParameter(ASTContext &Context, const ParmVarDecl *Parm)
Create the initialization entity for a parameter.
UserDefinedConversionSequence UserDefined
When ConversionKind == UserDefinedConversion, provides the details of the user-defined conversion seq...
Definition: Overload.h:430
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:1880
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type...
const Type * getTypeForDecl() const
Definition: Decl.h:2784
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1270
ConstructorInfo getConstructorInfo(NamedDecl *ND)
Definition: Overload.h:872
bool isBetterOverloadCandidate(Sema &S, const OverloadCandidate &Cand1, const OverloadCandidate &Cand2, SourceLocation Loc, OverloadCandidateSet::CandidateSetKind Kind)
isBetterOverloadCandidate - Determines whether the first overload candidate is a better candidate tha...
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
static ImplicitConversionSequence TryContextuallyConvertToBool(Sema &S, Expr *From)
TryContextuallyConvertToBool - Attempt to contextually convert the expression From to bool (C++0x [co...
specific_attr_iterator - Iterates over a subrange of an AttrVec, only providing attributes that are o...
Definition: AttrIterator.h:54
bool isVariadic() const
Definition: Type.h:3615
__DEVICE__ long long abs(long long __n)
ExprResult BuildCallToMemberFunction(Scope *S, Expr *MemExpr, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc)
BuildCallToMemberFunction - Build a call to a member function.
static ImplicitConversionSequence::CompareKind CompareDerivedToBaseConversions(Sema &S, SourceLocation Loc, const StandardConversionSequence &SCS1, const StandardConversionSequence &SCS2)
CompareDerivedToBaseConversions - Compares two standard conversion sequences to determine whether the...
static TemplateDecl * getDescribedTemplate(Decl *Templated)
bool isExtVectorType() const
Definition: Type.h:6031
AssignConvertType
AssignConvertType - All of the &#39;assignment&#39; semantic checks return this enum to indicate whether the ...
Definition: Sema.h:9353
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
Definition: ExprCXX.h:2736
ExprResult PerformContextualImplicitConversion(SourceLocation Loc, Expr *FromE, ContextualImplicitConverter &Converter)
Perform a contextual implicit conversion.
bool IsOverload(FunctionDecl *New, FunctionDecl *Old, bool IsForUsingDecl, bool ConsiderCudaAttrs=true)
StringRef P
Classification Classify(ASTContext &Ctx) const
Classify - Classify this expression according to the C++11 expression taxonomy.
Definition: Expr.h:377
Not a narrowing conversion.
Definition: Overload.h:116
bool isBeforeInTranslationUnit(SourceLocation LHS, SourceLocation RHS) const
Determines the order of 2 source locations in the translation unit.
llvm::iterator_range< conversion_iterator > getVisibleConversionFunctions()
Get all conversion functions visible in current class, including conversion function templates...
Definition: DeclCXX.cpp:1314
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:1665
NamedDecl * getDecl() const
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
Definition: Type.h:5891
bool CanPerformCopyInitialization(const InitializedEntity &Entity, ExprResult Init)
Definition: SemaInit.cpp:8387
ImplicitConversionRank
ImplicitConversionRank - The rank of an implicit conversion kind.
Definition: Overload.h:97
bool hasQualifier() const
Determines whether this member expression actually had a C++ nested-name-specifier prior to the name ...
Definition: Expr.h:2497
static void NoteFunctionCandidate(Sema &S, OverloadCandidate *Cand, unsigned NumArgs, bool TakingCandidateAddress)
Generates a &#39;note&#39; diagnostic for an overload candidate.
The base class of the type hierarchy.
Definition: Type.h:1351
CanQualType LongTy
Definition: ASTContext.h:1004
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
unsigned IncompatibleObjC
IncompatibleObjC - Whether this is an Objective-C conversion that we should warn about (if we actuall...
Definition: Overload.h:169
static bool convertArgsForAvailabilityChecks(Sema &S, FunctionDecl *Function, Expr *ThisArg, ArrayRef< Expr *> Args, Sema::SFINAETrap &Trap, bool MissingImplicitThis, Expr *&ConvertedThis, SmallVectorImpl< Expr *> &ConvertedArgs)
ForRangeStatus
Definition: Sema.h:2893
NamespaceDecl - Represent a C++ namespace.
Definition: Decl.h:505
Template argument deduction produced inconsistent deduced values for the given template parameter...
Definition: Sema.h:6850
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Definition: Sema.cpp:45
static ExprValueKind getValueKindForType(QualType T)
getValueKindForType - Given a formal return or parameter type, give its value kind.
Definition: Expr.h:395
bool isRestrictQualified() const
Determine whether this type is restrict-qualified.
Definition: Type.h:5782
Ambiguous candidates found.
Definition: Overload.h:43
ExprResult BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, SourceLocation LParenLoc, ArrayRef< Expr *> Arg, SourceLocation RParenLoc, Expr *Config=nullptr, bool IsExecConfig=false)
BuildResolvedCallExpr - Build a call to a resolved expression, i.e.
Definition: SemaExpr.cpp:5400
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:671
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
Definition: Type.h:5629
Conversions between compatible types in C99.
Definition: Overload.h:77
Floating point control options.
Definition: LangOptions.h:208
static bool CheckConvertedConstantConversions(Sema &S, StandardConversionSequence &SCS)
Check that the specified conversion is permitted in a converted constant expression, according to C++11 [expr.const]p3.
bool inferCUDATargetForImplicitSpecialMember(CXXRecordDecl *ClassDecl, CXXSpecialMember CSM, CXXMethodDecl *MemberDecl, bool ConstRHS, bool Diagnose)
Given a implicit special member, infer its CUDA target from the calls it needs to make to underlying ...
Definition: SemaCUDA.cpp:264
bool IgnoreObjectArgument
IgnoreObjectArgument - True to indicate that the first argument&#39;s conversion, which for this function...
Definition: Overload.h:666
QualType getConversionType() const
Returns the type that this conversion function is converting to.
Definition: DeclCXX.h:2717
Partial ordering of function templates for a call to a conversion function.
Definition: Template.h:143
unsigned DirectBinding
DirectBinding - True when this is a reference binding that is a direct binding (C++ [dcl...
Definition: Overload.h:177
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2397
float __ovld __cnfn distance(float p0, float p1)
Returns the distance between p0 and p1.
size_t param_size() const
Definition: Decl.h:2183
QualType getElementType() const
Definition: Type.h:2593
static unsigned RankDeductionFailure(const DeductionFailureInfo &DFI)
const RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
Definition: Type.cpp:491
Exact Match.
Definition: Overload.h:98
static bool isFunctionAlwaysEnabled(const ASTContext &Ctx, const FunctionDecl *FD)
bool isUnsignedIntegerType() const
Return true if this is an integer type that is unsigned, according to C99 6.2.5p6 [which returns true...
Definition: Type.cpp:1840
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
Definition: DeclSpec.cpp:125
RAII object that enters a new expression evaluation context.
Definition: Sema.h:10640
QualType getFromType() const
Definition: Overload.h:226
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
Definition: SemaInternal.h:25
void AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet, bool PartialOverloading=false)
Add the overload candidates named by callee and/or found by argument dependent lookup to the given ov...
ExprResult PerformObjectArgumentInitialization(Expr *From, NestedNameSpecifier *Qualifier, NamedDecl *FoundDecl, CXXMethodDecl *Method)
PerformObjectArgumentInitialization - Perform initialization of the implicit object parameter for the...
static bool isAllowableExplicitConversion(Sema &S, QualType ConvType, QualType ToType, bool AllowObjCPointerConversion)
Determine whether this is an allowable conversion from the result of an explicit conversion operator ...
DeclarationName getLookupName() const
Gets the name to look up.
Definition: Lookup.h:255
void removeObjCLifetime()
Definition: Type.h:347
QualType getReturnType() const
Definition: Decl.h:2207
DiagnosticsEngine & Diags
Definition: Sema.h:318
unsigned getNumParams() const
Definition: Type.h:3489
bool isEnumeralType() const
Definition: Type.h:6019
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6305
static ExprResult FinishOverloadedCallExpr(Sema &SemaRef, Scope *S, Expr *Fn, UnresolvedLookupExpr *ULE, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc, Expr *ExecConfig, OverloadCandidateSet *CandidateSet, OverloadCandidateSet::iterator *Best, OverloadingResult OverloadResult, bool AllowTypoCorrection)
FinishOverloadedCallExpr - given an OverloadCandidateSet, builds and returns the completed call expre...
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy.
Definition: Sema.h:2128
CanQualType Float128Ty
Definition: ASTContext.h:1007
OverloadKind CheckOverload(Scope *S, FunctionDecl *New, const LookupResult &OldDecls, NamedDecl *&OldDecl, bool IsForUsingDecl)
Determine whether the given New declaration is an overload of the declarations in Old...
static bool functionHasPassObjectSizeParams(const FunctionDecl *FD)
Extra information about a function prototype.
Definition: Type.h:3387
bool IsSurrogate
IsSurrogate - True to indicate that this candidate is a surrogate for a conversion to a function poin...
Definition: Overload.h:657
static ImplicitConversionSequence::CompareKind CompareQualificationConversions(Sema &S, const StandardConversionSequence &SCS1, const StandardConversionSequence &SCS2)
CompareQualificationConversions - Compares two standard conversion sequences to determine whether the...
void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, bool AllowExplicit=false, ConversionSequenceList EarlyConversions=None)
AddOverloadCandidate - Adds the given function to the set of candidate functions, using the given fun...
std::string getDeletedOrUnavailableSuffix(const FunctionDecl *FD)
Retrieve the message suffix that should be added to a diagnostic complaining about the given function...
Definition: SemaExpr.cpp:304
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:139
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:422
QualType ExtractUnqualifiedFunctionType(QualType PossiblyAFunctionType)
QualType getMemberPointerType(QualType T, const Type *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
DeclarationName getName() const
Gets the name looked up.
Definition: ExprCXX.h:2655
bool HadMultipleCandidates
HadMultipleCandidates - When this is true, it means that the conversion function was resolved from an...
Definition: Overload.h:276
bool isInvalidDecl() const
Definition: DeclBase.h:546
Like System, but searched after the system directories.
Decl * Specialization
Specialization - The actual specialization that this candidate represents.
bool requiresADL() const
True if this declaration should be extended by argument-dependent lookup.
Definition: ExprCXX.h:2809
static bool DiagnoseTwoPhaseOperatorLookup(Sema &SemaRef, OverloadedOperatorKind Op, SourceLocation OpLoc, ArrayRef< Expr *> Args)
Attempt to recover from ill-formed use of a non-dependent operator in a template, where the non-depen...
bool IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType)
IsIntegralPromotion - Determines whether the conversion from the expression From (whose potentially-a...
bool isStatic() const
Definition: DeclCXX.cpp:1633
bool hasDefinition() const
Definition: DeclCXX.h:738
std::vector< FixItHint > Hints
The list of Hints generated so far.
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1513
QualType getLocalUnqualifiedType() const
Return this type with all of the instance-specific qualifiers removed, but without removing any quali...
Definition: Type.h:885
Defines the clang::Expr interface and subclasses for C++ expressions.
TemplateParameter Param
The template parameter to which a template argument deduction failure refers.
static const TemplateDecl * isTemplate(const NamedDecl *ND, const TemplateArgumentList *&TemplateArgs)
Conversion.
Definition: Overload.h:100
void * ToTypePtrs[3]
ToType - The types that this conversion is converting to in each step.
Definition: Overload.h:205
The collection of all-type qualifiers we support.
Definition: Type.h:152
FieldDecl * getSourceBitField()
If this expression refers to a bit-field, retrieve the declaration of that bit-field.
Definition: Expr.cpp:3433
bool isObjCObjectOrInterfaceType() const
Definition: Type.h:6047
ExprResult ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false)
ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
Definition: SemaExpr.cpp:5216
Qualifiers getQualifiers() const
Retrieve all qualifiers.
OverloadCandidate & addCandidate(unsigned NumConversions=0, ConversionSequenceList Conversions=None)
Add a new candidate with NumConversions conversion sequence slots to the overload set...
Definition: Overload.h:832
ExprResult PerformImplicitConversion(Expr *From, QualType ToType, AssignmentAction Action, bool AllowExplicit=false)
PerformImplicitConversion - Perform an implicit conversion of the expression From to the type ToType...
bool isMoveAssignmentOperator() const
Determine whether this is a move assignment operator.
Definition: DeclCXX.cpp:1880
Expr * FixOverloadedFunctionReference(Expr *E, DeclAccessPair FoundDecl, FunctionDecl *Fn)
FixOverloadedFunctionReference - E is an expression that refers to a C++ overloaded function (possibl...
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3488
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
Definition: Decl.h:291
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context encloses the declaration context DC.
Definition: DeclBase.cpp:1111
Boolean conversions (C++ 4.12)
Definition: Overload.h:76
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Definition: TargetInfo.h:859
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:149
A C++ nested-name-specifier augmented with source location information.
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
Definition: Sema.h:7393
void dump() const
dump - Print this implicit conversion sequence to standard error.
llvm::mapped_iterator< decltype(Decls)::iterator, select_second > iterator
Definition: Lookup.h:811
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
Definition: Type.cpp:3844
static bool diagnoseNoViableConversion(Sema &SemaRef, SourceLocation Loc, Expr *&From, Sema::ContextualImplicitConverter &Converter, QualType T, bool HadMultipleCandidates, UnresolvedSetImpl &ExplicitConversions)
unsigned BindsToFunctionLvalue
Whether we&#39;re binding to a function lvalue.
Definition: Overload.h:184
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
C++ [over.match.copy]: Copy-initialization of an object of class type by user-defined conversion...
Definition: Overload.h:738
BadConversionSequence Bad
When ConversionKind == BadConversion, provides the details of the bad conversion. ...
Definition: Overload.h:438
bool isCharType() const
Definition: Type.cpp:1750
bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base)
Determine whether the type Derived is a C++ class that is derived from the type Base.
field_range fields() const
Definition: Decl.h:3619
bool isObjCIdType() const
Definition: Type.h:6068
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2467
Expr * getBase()
Retrieve the base object of this member expressions, e.g., the x in x.m.
Definition: ExprCXX.h:3507
Identity conversion (no conversion)
Definition: Overload.h:61
void setNumArgs(const ASTContext &C, unsigned NumArgs)
setNumArgs - This changes the number of arguments present in this call.
Definition: Expr.cpp:1251
bool isStdInitializerListElement() const
Whether the target is really a std::initializer_list, and the sequence only represents the worst elem...
Definition: Overload.h:544
ConversionSet & conversions()
Definition: Overload.h:312
bool buildOverloadedCallSet(Scope *S, Expr *Fn, UnresolvedLookupExpr *ULE, MultiExprArg Args, SourceLocation RParenLoc, OverloadCandidateSet *CandidateSet, ExprResult *Result)
Constructs and populates an OverloadedCandidateSet from the given function.
Floating point conversions (C++ 4.8)
Definition: Overload.h:71
virtual SemaDiagnosticBuilder diagnoseConversion(Sema &S, SourceLocation Loc, QualType T, QualType ConvTy)=0
Emits a diagnostic when we picked a conversion function (for cases when we are not allowed to pick a ...
bool isReferenceType() const
Definition: Type.h:5954
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:32
static DeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *D, bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc, QualType T, ExprValueKind VK, NamedDecl *FoundD=nullptr, const TemplateArgumentListInfo *TemplateArgs=nullptr)
Definition: Expr.cpp:391
ExprResult PerformContextuallyConvertToObjCPointer(Expr *From)
PerformContextuallyConvertToObjCPointer - Perform a contextual conversion of the expression From to a...
bool match(QualType T) override
Match an integral or (possibly scoped) enumeration type.
bool isSpecialized() const
Whether this type is specialized, meaning that it has type arguments.
Definition: Type.h:5533
CompatiblePointerDiscardsQualifiers - The assignment discards c/v/r qualifiers, which we accept as an...
Definition: Sema.h:9381
void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const
Copies the template arguments into the given structure.
Definition: ExprCXX.h:2714
unsigned getTypeQualifiers() const
Definition: DeclCXX.h:2104
Represents a C++ member access expression for which lookup produced a set of overloaded functions...
Definition: ExprCXX.h:3439
Ref_Incompatible - The two types are incompatible, so direct reference binding is not possible...
Definition: Sema.h:9601
CUDAFunctionTarget IdentifyCUDATarget(const FunctionDecl *D, bool IgnoreImplicitHDAttr=false)
Determines whether the given function is a CUDA device/host/kernel/etc.
Definition: SemaCUDA.cpp:105
ConversionSequenceList allocateConversionSequences(unsigned NumConversions)
Allocate storage for conversion sequences for NumConversions conversions.
Definition: Overload.h:819
specific_attr_iterator< T > specific_attr_end() const
Definition: DeclBase.h:527
void set(DeclAccessPair Found, Decl *Spec, DeductionFailureInfo Info)
bool isFloat() const
Definition: APValue.h:184
SourceLocation getLocStart() const LLVM_READONLY
Definition: ExprCXX.h:3548
OverloadKind
C++ Overloading.
Definition: Sema.h:2478
bool isAtLeastAsQualifiedAs(QualType Other) const
Determine whether this type is at least as qualified as the other given type, requiring exact equalit...
Definition: Type.h:5872
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
Definition: Type.h:6219
Describes a module or submodule.
Definition: Module.h:65
unsigned getTypeQuals() const
Definition: Type.h:3627
OverloadCandidateDisplayKind
Definition: Overload.h:47
Qualifiers getLocalQualifiers() const
Retrieve the set of qualifiers local to this particular QualType instance, not including any qualifie...
Definition: Type.h:5737
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:107
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:2167
StringRef getOpcodeStr() const
Definition: Expr.h:3045
Floating point promotions (C++ 4.6)
Definition: Overload.h:68
bool isGLValue() const
Definition: Expr.h:252
Describes an C or C++ initializer list.
Definition: Expr.h:3872
BinaryOperatorKind
bool isFunctionConsideredUnavailable(FunctionDecl *FD)
Checks availability of the function depending on the current function context.Inside an unavailable f...
An rvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2484
bool isCompleteType(SourceLocation Loc, QualType T)
Definition: Sema.h:1615
QualType getThisType(ASTContext &C) const
Returns the type of the this pointer.
Definition: DeclCXX.cpp:1932
static ExprResult CheckConvertedConstantExpression(Sema &S, Expr *From, QualType T, APValue &Value, Sema::CCEKind CCE, bool RequireInt)
CheckConvertedConstantExpression - Check that the expression From is a converted constant expression ...
SmallVectorImpl< PartialDiagnosticAt > * Diag
Diag - If this is non-null, it will be filled in with a stack of notes indicating why evaluation fail...
Definition: Expr.h:558
Represents the results of name lookup.
Definition: Lookup.h:32
PtrTy get() const
Definition: Ownership.h:162
RefQualifierKind getRefQualifier() const
Retrieve the ref-qualifier associated with this method.
Definition: DeclCXX.h:2119
An lvalue ref-qualifier was provided (&).
Definition: Type.h:1307
ExprResult CreateOverloadedUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, const UnresolvedSetImpl &Fns, Expr *input, bool RequiresADL=true)
Create a unary operation that may resolve to an overloaded operator.
unsigned BindsToRvalue
Whether we&#39;re binding to an rvalue.
Definition: Overload.h:187
static ImplicitConversionSequence::CompareKind compareStandardConversionSubsets(ASTContext &Context, const StandardConversionSequence &SCS1, const StandardConversionSequence &SCS2)
bool UnwrapSimilarPointerTypes(QualType &T1, QualType &T2)
UnwrapSimilarPointerTypes - If T1 and T2 are pointer types that may be similar (C++ 4...
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
std::string getFullModuleName(bool AllowStringLiterals=false) const
Retrieve the full name of this module, including the path from its top-level module.
Definition: Module.cpp:169
void setCXXOperatorNameRange(SourceRange R)
setCXXOperatorNameRange - Sets the range of the operator name (without the operator keyword)...
TemplateSpecCandidateSet - A set of generalized overload candidates, used in template specializations...
ReferenceCompareResult CompareReferenceRelationship(SourceLocation Loc, QualType T1, QualType T2, bool &DerivedToBase, bool &ObjCConversion, bool &ObjCLifetimeConversion)
CompareReferenceRelationship - Compare the two types T1 and T2 to determine whether they are referenc...
Succeeded, but refers to a deleted function.
Definition: Overload.h:44
APValue Val
Val - This is the value the expression can be folded to.
Definition: Expr.h:573
A convenient class for passing around template argument information.
Definition: TemplateBase.h:546
QualType getVolatileType(QualType T) const
Return the uniqued reference to the type for a volatile qualified type.
Definition: ASTContext.h:1142
Ref_Compatible - The two types are reference-compatible.
Definition: Sema.h:9607
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
Definition: Decl.cpp:3226
unsigned QualificationIncludesObjCLifetime
Whether the qualification conversion involves a change in the Objective-C lifetime (for automatic ref...
Definition: Overload.h:165
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
Definition: Expr.h:405
SourceLocation getTemplateKeywordLoc() const
Retrieve the location of the template keyword preceding this name, if any.
Definition: ExprCXX.h:2671
QualType getToType(unsigned Idx) const
Definition: Overload.h:229
bool IsFunctionConversion(QualType FromType, QualType ToType, QualType &ResultTy)
Determine whether the conversion from FromType to ToType is a valid conversion that strips "noexcept"...
void MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base=nullptr)
Perform reference-marking and odr-use handling for a DeclRefExpr.
Definition: SemaExpr.cpp:14990
static bool isRecordType(QualType T)
bool diagnoseArgIndependentDiagnoseIfAttrs(const NamedDecl *ND, SourceLocation Loc)
Emit diagnostics for the diagnose_if attributes on Function, ignoring any ArgDependent DiagnoseIfAttr...
std::string getAsString(ASTContext &Ctx, QualType Ty) const
Definition: APValue.cpp:545
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:2985
Substitution of the deduced template argument values resulted in an error.
Definition: Sema.h:6858
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:5788
This candidate function was not viable because an enable_if attribute disabled it.
Definition: Overload.h:605
LangAS getAddressSpace() const
Definition: Type.h:367
A set of unresolved declarations.
Definition: UnresolvedSet.h:61
ImplicitConversionKind Second
Second - The second conversion can be an integral promotion, floating point promotion, integral conversion, floating point conversion, floating-integral conversion, pointer conversion, pointer-to-member conversion, or boolean conversion.
Definition: Overload.h:152
const Type * getClass() const
Definition: Type.h:2536
bool isRValueReferenceType() const
Definition: Type.h:5962
Template argument deduction exceeded the maximum template instantiation depth (which has already been...
Definition: Sema.h:6844
void diagnoseEquivalentInternalLinkageDeclarations(SourceLocation Loc, const NamedDecl *D, ArrayRef< const NamedDecl *> Equiv)
static ImplicitConversionSequence TryListConversion(Sema &S, InitListExpr *From, QualType ToType, bool SuppressUserConversions, bool InOverloadResolution, bool AllowObjCWritebackConversion)
TryListConversion - Try to copy-initialize a value of type ToType from the initializer list From...
static void AddOverloadedCallCandidate(Sema &S, DeclAccessPair FoundDecl, TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet, bool PartialOverloading, bool KnownValid)
Add a single candidate to the overload set.
Defines the Diagnostic-related interfaces.
A narrowing conversion, because a constant expression got narrowed.
Definition: Overload.h:122
FunctionDecl * ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr, QualType TargetType, bool Complain, DeclAccessPair &Found, bool *pHadMultipleCandidates=nullptr)
ResolveAddressOfOverloadedFunction - Try to resolve the address of an overloaded function (C++ [over...
ExprResult BuildOverloadedCallExpr(Scope *S, Expr *Fn, UnresolvedLookupExpr *ULE, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc, Expr *ExecConfig, bool AllowTypoCorrection=true, bool CalleesAddressIsTaken=false)
BuildOverloadedCallExpr - Given the call expression that calls Fn (which eventually refers to the dec...
unsigned IsLvalueReference
Whether this is an lvalue reference binding (otherwise, it&#39;s an rvalue reference binding).
Definition: Overload.h:181
bool isLambda() const
Determine whether this class describes a lambda function object.
Definition: DeclCXX.h:1152
CanQualType LongDoubleTy
Definition: ASTContext.h:1007
Expr * IgnoreParenCasts() LLVM_READONLY
IgnoreParenCasts - Ignore parentheses and casts.
Definition: Expr.cpp:2465
NarrowingKind
NarrowingKind - The kind of narrowing conversion being performed by a standard conversion sequence ac...
Definition: Overload.h:114
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:39
QualType getCVRQualifiedType(QualType T, unsigned CVR) const
Return a type with additional const, volatile, or restrict qualifiers.
Definition: ASTContext.h:1875
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:5718
void getAsStringInternal(std::string &Str, const PrintingPolicy &Policy) const
Definition: Type.h:1006
param_type_iterator param_type_begin() const
Definition: Type.h:3641
void Destroy()
Free any memory associated with this deduction failure.
Qualification conversions (C++ 4.4)
Definition: Overload.h:66
bool isInt() const
Definition: APValue.h:183
static bool isBooleanType(QualType Ty)
NestedNameSpecifier * getQualifier() const
Fetches the nested-name qualifier, if one was given.
Definition: ExprCXX.h:2661
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:63
static bool checkAddressOfFunctionIsAvailable(Sema &S, const FunctionDecl *FD, bool Complain, bool InOverloadResolution, SourceLocation Loc)
Returns true if we can take the address of the function.
const LangOptions & getLangOpts() const
Definition: Sema.h:1193
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value &#39;V&#39; and type &#39;type&#39;.
Definition: Expr.cpp:748
bool isTypeDependent() const
isTypeDependent - Determines whether this expression is type-dependent (C++ [temp.dep.expr]), which means that its type could change from one template instantiation to the next.
Definition: Expr.h:167
#define UINT_MAX
Definition: limits.h:72
static ImplicitConversionSequence TryContextuallyConvertToObjCPointer(Sema &S, Expr *From)
TryContextuallyConvertToObjCPointer - Attempt to contextually convert the expression From to an Objec...
void * getAsOpaquePtr() const
Definition: Type.h:699
bool compatiblyIncludesObjCLifetime(Qualifiers other) const
Determines if these qualifiers compatibly include another set of qualifiers from the narrow perspecti...
Definition: Type.h:518
AssignConvertType CheckSingleAssignmentConstraints(QualType LHSType, ExprResult &RHS, bool Diagnose=true, bool DiagnoseCFAudited=false, bool ConvertRHS=true)
Check assignment constraints for an assignment of RHS to LHSType.
Definition: SemaExpr.cpp:7924
An ordinary object is located at an address in memory.
Definition: Specifiers.h:123
virtual SemaDiagnosticBuilder diagnoseIncomplete(Sema &S, SourceLocation Loc, QualType T)=0
Emits a diagnostic when the expression has incomplete class type.
The number of conversion kinds.
Definition: Overload.h:90
ForRangeStatus BuildForRangeBeginEndCall(SourceLocation Loc, SourceLocation RangeLoc, const DeclarationNameInfo &NameInfo, LookupResult &MemberLookup, OverloadCandidateSet *CandidateSet, Expr *Range, ExprResult *CallExpr)
Build a call to &#39;begin&#39; or &#39;end&#39; for a C++11 for-range statement.
TemplateParameter getTemplateParameter()
Retrieve the template parameter this deduction failure refers to, if any.
Represents an ObjC class declaration.
Definition: DeclObjC.h:1191
static ExprResult finishContextualImplicitConversion(Sema &SemaRef, SourceLocation Loc, Expr *From, Sema::ContextualImplicitConverter &Converter)
ImplicitConversionKind Third
Third - The third conversion can be a qualification conversion or a function conversion.
Definition: Overload.h:156
IncompatiblePointerSign - The assignment is between two pointers types which point to integers which ...
Definition: Sema.h:9377
ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, LookupResult &R, bool NeedsADL, bool AcceptInvalidDecl=false)
Definition: SemaExpr.cpp:2720
Complex <-> Real conversion.
Definition: Overload.h:102
NameKind getNameKind() const
getNameKind - Determine what kind of name this is.
bool Viable
Viable - True to indicate that this overload candidate is viable.
Definition: Overload.h:652
ConversionSequenceList Conversions
The conversion sequences used to convert the function arguments to the function parameters.
Definition: Overload.h:646
bool hasConst() const
Definition: Type.h:269
FunctionDecl * resolveAddressOfOnlyViableOverloadCandidate(Expr *E, DeclAccessPair &FoundResult)
Given an expression that refers to an overloaded function, try to resolve that function to a single f...
static Classification makeSimpleLValue()
Create a simple, modifiably lvalue.
Definition: Expr.h:360
CanQualType UnsignedCharTy
Definition: ASTContext.h:1005
Integral promotions (C++ 4.5)
Definition: Overload.h:67
This conversion function template specialization candidate is not viable because the final conversion...
Definition: Overload.h:596
bool IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType)
Helper function to determine whether this is the (deprecated) C++ conversion from a string literal to...
SourceLocation getMemberLoc() const
Definition: ExprCXX.h:3542
QualType BuiltinParamTypes[3]
BuiltinParamTypes - Provides the parameter types of a built-in overload candidate.
Definition: Overload.h:638
This object can be modified without requiring retains or releases.
Definition: Type.h:173
param_iterator param_begin()
Definition: Decl.h:2179
Represents the this expression in C++.
Definition: ExprCXX.h:945
C-only conversion between pointers with incompatible types.
Definition: Overload.h:88
DeclarationName getMemberName() const
Retrieve the name of the member that this expression refers to.
Definition: ExprCXX.h:3538
bool IsComplexPromotion(QualType FromType, QualType ToType)
Determine if a conversion is a complex promotion.
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
Definition: Decl.cpp:3327
DiagnosticsEngine & getDiagnostics() const
Definition: Sema.h:1197
RAII class used to determine whether SFINAE has trapped any errors that occur during template argumen...
Definition: Sema.h:7431
bool isIntegralOrUnscopedEnumerationType() const
Determine whether this type is an integral or unscoped enumeration type.
Definition: Type.cpp:1735
static bool hasDeprecatedStringLiteralToCharPtrConversion(const ImplicitConversionSequence &ICS)
CXXSpecialMember
Kinds of C++ special members.
Definition: Sema.h:1129
OverloadFixItKind Kind
The type of fix applied.
static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, const TemplateArgument &Param, TemplateArgument Arg, TemplateDeductionInfo &Info, SmallVectorImpl< DeducedTemplateArgument > &Deduced)
bool hasAttr() const
Definition: DeclBase.h:535
DeductionFailureInfo DeductionFailure
Template argument deduction info.
static void NoteAmbiguousUserConversions(Sema &S, SourceLocation OpLoc, OverloadCandidate *Cand)
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:274
bool isPromotableIntegerType() const
More type predicates useful for type checking/promotion.
Definition: Type.cpp:2381
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1590
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3268
bool compatiblyIncludes(Qualifiers other) const
Determines if these qualifiers compatibly include another set.
Definition: Type.h:497
void erase(NamedDecl *D)
Removes any data associated with a given decl.
Definition: Lookup.h:806
Transparent Union Conversions.
Definition: Overload.h:83
bool isMoreQualifiedThan(QualType Other) const
Determine whether this type is more qualified than the other given type, requiring exact equality for...
Definition: Type.h:5862
bool isStdInitializerList(QualType Ty, QualType *Element)
Tests whether Ty is an instance of std::initializer_list and, if it is and Element is not NULL...
CastKind
CastKind - The kind of operation required for a conversion.
NestedNameSpecifier * getQualifier() const
If the member name was qualified, retrieves the nested-name-specifier that precedes the member name...
Definition: Expr.h:2512
The return type of classify().
Definition: Expr.h:302
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat)
Definition: Expr.cpp:1718
SourceLocation getLocEnd() const LLVM_READONLY
Definition: Stmt.cpp:290
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:540
OverloadedOperatorKind getCXXOverloadedOperator() const
getCXXOverloadedOperator - If this name is the name of an overloadable operator in C++ (e...
Template argument deduction did not deduce a value for every template parameter.
Definition: Sema.h:6847
static ExprResult CreateFunctionRefExpr(Sema &S, FunctionDecl *Fn, NamedDecl *FoundDecl, const Expr *Base, bool HadMultipleCandidates, SourceLocation Loc=SourceLocation(), const DeclarationNameLoc &LocInfo=DeclarationNameLoc())
A convenience routine for creating a decayed reference to a function.
bool CheckPointerConversion(Expr *From, QualType ToType, CastKind &Kind, CXXCastPath &BasePath, bool IgnoreBaseAccess, bool Diagnose=true)
CheckPointerConversion - Check the pointer conversion from the expression From to the type ToType...
virtual SemaDiagnosticBuilder diagnoseExplicitConv(Sema &S, SourceLocation Loc, QualType T, QualType ConvTy)=0
Emits a diagnostic when the only matching conversion function is explicit.
bool DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R, std::unique_ptr< CorrectionCandidateCallback > CCC, TemplateArgumentListInfo *ExplicitTemplateArgs=nullptr, ArrayRef< Expr *> Args=None, TypoExpr **Out=nullptr)
Diagnose an empty lookup.
Definition: SemaExpr.cpp:1769
bool hasQualifiers() const
Determine whether this type has any qualifiers.
Definition: Type.h:5793
static const char * GetImplicitConversionName(ImplicitConversionKind Kind)
GetImplicitConversionName - Return the name of this kind of implicit conversion.
This conversion candidate was not considered because it duplicates the work of a trivial or derived-t...
Definition: Overload.h:577
CandidateSetKind getKind() const
Definition: Overload.h:798
static void NoteBuiltinOperatorCandidate(Sema &S, StringRef Opc, SourceLocation OpLoc, OverloadCandidate *Cand)
bool isNewCandidate(Decl *F)
Determine when this overload candidate will be new to the overload set.
Definition: Overload.h:802
A narrowing conversion by virtue of the source and destination types.
Definition: Overload.h:119
Promotion.
Definition: Overload.h:99
StandardConversionSequence FinalConversion
FinalConversion - For a conversion function (where Function is a CXXConversionDecl), the standard conversion that occurs after the call to the overload candidate to convert the result of calling the conversion function to the required type.
Definition: Overload.h:683
unsigned Result
A Sema::TemplateDeductionResult.
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.
ImplicitConversionSequence TryImplicitConversion(Expr *From, QualType ToType, bool SuppressUserConversions, bool AllowExplicit, bool InOverloadResolution, bool CStyle, bool AllowObjCWritebackConversion)
bool isObjCWritebackConversion(QualType FromType, QualType ToType, QualType &ConvertedType)
Determine whether this is an Objective-C writeback conversion, used for parameter passing when perfor...
static SourceLocation GetLocationForCandidate(const OverloadCandidate *Cand)
An Objective-C property is a logical field of an Objective-C object which is read and written via Obj...
Definition: Specifiers.h:133
void AddTemplateConversionCandidate(FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl, CXXRecordDecl *ActingContext, Expr *From, QualType ToType, OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit, bool AllowResultConversion=true)
Adds a conversion function template specialization candidate to the overload set, using template argu...
Allows QualTypes to be sorted and hence used in maps and sets.
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:432
ObjC ARC writeback conversion.
Definition: Overload.h:103
ExprResult CreateOverloadedBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, const UnresolvedSetImpl &Fns, Expr *LHS, Expr *RHS, bool RequiresADL=true)
Create a binary operation that may resolve to an overloaded operator.
OpenCL Scalar Widening.
Definition: Overload.h:101
QualType getElementType() const
Definition: Type.h:2236
bool isEventT() const
Definition: Type.h:6100
static OverloadingResult IsInitializerListConstructorConversion(Sema &S, Expr *From, QualType ToType, CXXRecordDecl *To, UserDefinedConversionSequence &User, OverloadCandidateSet &CandidateSet, bool AllowExplicit)
Represents a shadow constructor declaration introduced into a class by a C++11 using-declaration that...
Definition: DeclCXX.h:3163
DeclAccessPair getFoundDecl() const
Retrieves the declaration found by lookup.
Definition: Expr.h:2487
void addVolatile()
Definition: Type.h:281
Expr - This represents one expression.
Definition: Expr.h:106
static ImplicitConversionSequence TryObjectArgumentInitialization(Sema &S, SourceLocation Loc, QualType FromType, Expr::Classification FromClassification, CXXMethodDecl *Method, CXXRecordDecl *ActingContext)
TryObjectArgumentInitialization - Try to initialize the object parameter of the given member function...
Show just the "best" overload candidates.
QualType getPointeeType() const
Definition: Type.h:2440
Represents an ambiguous user-defined conversion sequence.
Definition: Overload.h:296
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition: Specifiers.h:104
bool isVariadic() const
Whether this function is variadic.
Definition: Decl.cpp:2574
bool isDefaulted() const
Whether this function is defaulted per C++0x.
Definition: Decl.h:2012
Expr * stripARCUnbridgedCast(Expr *e)
stripARCUnbridgedCast - Given an expression of ARCUnbridgedCast type, remove the placeholder cast...
bool isArrow() const
Determine whether this member expression used the &#39;->&#39; operator; otherwise, it used the &#39;...
Definition: ExprCXX.h:3524
This inherited constructor is not viable because it would slice the argument.
Definition: Overload.h:615
void takeSFINAEDiagnostic(PartialDiagnosticAt &PD)
Take ownership of the SFINAE diagnostic.
When performing template argument deduction for a function template, there were too many call argumen...
Definition: Sema.h:6871
const FunctionProtoType * T
Declaration of a template type parameter.
static FindResult find(Expr *E)
Finds the overloaded expression in the given expression E of OverloadTy.
Definition: ExprCXX.h:2612
SourceLocation getLocation() const
Definition: Overload.h:797
StandardConversionSequence After
After - Represents the standard conversion that occurs after the actual user-defined conversion...
Definition: Overload.h:280
bool isObjCBuiltinType() const
Definition: Type.h:6086
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6368
static bool isFirstArgumentCompatibleWithType(ASTContext &Context, CXXConstructorDecl *Constructor, QualType Type)
void setTypeDependent(bool TD)
Set whether this expression is type-dependent or not.
Definition: Expr.h:170
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2620
unsigned getNumInits() const
Definition: Expr.h:3902
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:551
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
Definition: Decl.cpp:3347
Zero constant to queue.
Definition: Overload.h:86
SmallVectorImpl< OverloadCandidate >::iterator iterator
Definition: Overload.h:809
bool isNullPtrType() const
Definition: Type.h:6182
static void CompleteNonViableCandidate(Sema &S, OverloadCandidate *Cand, ArrayRef< Expr *> Args)
CompleteNonViableCandidate - Normally, overload resolution only computes up to the first bad conversi...
void copyFrom(const AmbiguousConversionSequence &)
static bool IsStandardConversion(Sema &S, Expr *From, QualType ToType, bool InOverloadResolution, StandardConversionSequence &SCS, bool CStyle, bool AllowObjCWritebackConversion)
IsStandardConversion - Determines whether there is a standard conversion sequence (C++ [conv]...
static Qualifiers CollectVRQualifiers(ASTContext &Context, Expr *ArgExpr)
CollectVRQualifiers - This routine returns Volatile/Restrict qualifiers, if any, found in visible typ...
bool performsVirtualDispatch(const LangOptions &LO) const
Returns true if virtual dispatch is performed.
Definition: Expr.h:2616
ObjCLifetime getObjCLifetime() const
Definition: Type.h:341
CXXConstructorDecl * CopyConstructor
CopyConstructor - The copy constructor that is used to perform this conversion, when the conversion i...
Definition: Overload.h:212
bool isObjCClassType() const
Definition: Type.h:6074
static bool completeFunctionType(Sema &S, FunctionDecl *FD, SourceLocation Loc, bool Complain=true)
DeclContext * getDeclContext()
Definition: DeclBase.h:425
Overload resolution succeeded.
Definition: Overload.h:41
bool isObjCIdType() const
True if this is equivalent to the &#39;id&#39; type, i.e.
Definition: Type.h:5502
bool isAnyComplexType() const
Definition: Type.h:6023
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc)
Retrieve the overloaded operator kind that corresponds to the given unary opcode. ...
Definition: Expr.cpp:1140
static bool IsOverloaded(const UnresolvedSetImpl &Functions)
When performing template argument deduction for a function template, there were too few call argument...
Definition: Sema.h:6874
CanQualType ShortTy
Definition: ASTContext.h:1004
static bool IsAcceptableNonMemberOperatorCandidate(ASTContext &Context, FunctionDecl *Fn, ArrayRef< Expr *> Args)
IsAcceptableNonMemberOperatorCandidate - Determine whether Fn is an acceptable non-member overloaded ...
unsigned ReferenceBinding
ReferenceBinding - True when this is a reference binding (C++ [over.ics.ref]).
Definition: Overload.h:173
ExprResult CheckPlaceholderExpr(Expr *E)
Check for operands with placeholder types and complain if found.
Definition: SemaExpr.cpp:15944
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
Represents a C++ template name within the type system.
Definition: TemplateName.h:178
Ref_Related - The two types are reference-related, which means that their unqualified forms (T1 and T...
Definition: Sema.h:9605
decls_iterator decls_begin() const
Definition: ExprCXX.h:2640
char __ovld __cnfn min(char x, char y)
Returns y if y < x, otherwise it returns x.
ReferenceCompareResult
ReferenceCompareResult - Expresses the result of comparing two types (cv1 T1 and cv2 T2) to determine...
Definition: Sema.h:9598
virtual SemaDiagnosticBuilder diagnoseAmbiguous(Sema &S, SourceLocation Loc, QualType T)=0
Emits a diagnostic when there are multiple possible conversion functions.
Floating-integral conversions (C++ 4.9)
Definition: Overload.h:73
static SmallVector< EnableIfAttr *, 4 > getOrderedEnableIfAttrs(const FunctionDecl *Function)
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7)...
ExprResult BuildTemplateIdExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, bool RequiresADL, const TemplateArgumentListInfo *TemplateArgs)
FunctionDecl * ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl, bool Complain=false, DeclAccessPair *Found=nullptr)
Given an expression that refers to an overloaded function, try to resolve that overloaded function ex...
bool isSameOrCompatibleFunctionType(CanQualType Param, CanQualType Arg)
Compare types for equality with respect to possibly compatible function types (noreturn adjustment...
CanQualType UnsignedInt128Ty
Definition: ASTContext.h:1006
Specifies that a value-dependent expression of integral or dependent type should be considered a null...
Definition: Expr.h:702
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char, signed char, short, int, long..], or an enum decl which has a signed representation.
Definition: Type.cpp:1800
This conversion candidate was not considered because it is an illegal instantiation of a constructor ...
Definition: Overload.h:588
bool TryToFixBadConversion(unsigned Idx, Sema &S)
Definition: Overload.h:696
static void collectViableConversionCandidates(Sema &SemaRef, Expr *From, QualType ToType, UnresolvedSetImpl &ViableConversions, OverloadCandidateSet &CandidateSet)
QualType getType() const
Definition: Expr.h:128
CXXConversionDecl * Surrogate
Surrogate - The conversion function for which this candidate is a surrogate, but only if IsSurrogate ...
Definition: Overload.h:642
UserDefinedConversionSequence - Represents a user-defined conversion sequence (C++ 13...
Definition: Overload.h:251
This candidate was not viable because its address could not be taken.
Definition: Overload.h:608
void NoteDeductionFailure(Sema &S, bool ForTakingAddress)
Diagnose a template argument deduction failure.
StandardConversionSequence Standard
When ConversionKind == StandardConversion, provides the details of the standard conversion sequence...
Definition: Overload.h:426
bool ResolveAndFixSingleFunctionTemplateSpecialization(ExprResult &SrcExpr, bool DoFunctionPointerConverion=false, bool Complain=false, SourceRange OpRangeForComplaining=SourceRange(), QualType DestTypeForComplaining=QualType(), unsigned DiagIDForComplaining=0)
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1335
ExprResult BuildLiteralOperatorCall(LookupResult &R, DeclarationNameInfo &SuffixInfo, ArrayRef< Expr *> Args, SourceLocation LitEndLoc, TemplateArgumentListInfo *ExplicitTemplateArgs=nullptr)
BuildLiteralOperatorCall - Build a UserDefinedLiteral by creating a call to a literal operator descri...
static void DiagnoseOpenCLExtensionDisabled(Sema &S, OverloadCandidate *Cand)
void DiagnoseAmbiguousConversion(Sema &S, SourceLocation CaretLoc, const PartialDiagnostic &PDiag) const
Diagnoses an ambiguous conversion.
bool resolveAndFixAddressOfOnlyViableOverloadCandidate(ExprResult &SrcExpr, bool DoFunctionPointerConversion=false)
Given an overloaded function, tries to turn it into a non-overloaded function reference using resolve...
static const FunctionProtoType * tryGetFunctionProtoType(QualType FromType)
Attempts to get the FunctionProtoType from a Type.
QualType getRecordType(const RecordDecl *Decl) const
bool isAtLeastAsQualifiedAs(CanQual< T > Other) const
Determines whether this canonical type is at least as qualified as the Other canonical type...
bool isInvalid() const
Definition: Ownership.h:158
virtual SemaDiagnosticBuilder noteExplicitConv(Sema &S, CXXConversionDecl *Conv, QualType ConvTy)=0
Emits a note for the explicit conversion function.
UnaryOperator - This represents the unary-expression&#39;s (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:1717
CXXMethodDecl * getMethodDecl() const
Retrieves the declaration of the called method.
Definition: ExprCXX.cpp:517
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
Definition: ASTContext.h:1333
bool DeduceReturnType(FunctionDecl *FD, SourceLocation Loc, bool Diagnose=true)
SourceLocation getMemberLoc() const
getMemberLoc - Return the location of the "member", in X->F, it is the location of &#39;F&#39;...
Definition: Expr.h:2587
ExprResult BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, const TemplateArgumentListInfo *TemplateArgs, const Scope *S)
Builds an expression which might be an implicit member expression.
An lvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2466
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
void AddConversionCandidate(CXXConversionDecl *Conversion, DeclAccessPair FoundDecl, CXXRecordDecl *ActingContext, Expr *From, QualType ToType, OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit, bool AllowResultConversion=true)
AddConversionCandidate - Add a C++ conversion function as a candidate in the candidate set (C++ [over...
unsigned getNumArgs() const
void AddMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl, DeclAccessPair FoundDecl, CXXRecordDecl *ActingContext, TemplateArgumentListInfo *ExplicitTemplateArgs, QualType ObjectType, Expr::Classification ObjectClassification, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false)
Add a C++ member function template as a candidate to the candidate set, using template argument deduc...
static bool CheckArityMismatch(Sema &S, OverloadCandidate *Cand, unsigned NumArgs)
Additional arity mismatch diagnosis specific to a function overload candidates.
const BuiltinType * getAsPlaceholderType() const
Definition: Type.h:6149
After substituting deduced template arguments, a dependent parameter type did not match the correspon...
Definition: Sema.h:6861
bool isUsable() const
Definition: Ownership.h:159
Represents a C++ conversion function within a class.
Definition: DeclCXX.h:2682
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1347
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:719
bool isVolatileQualified() const
OverloadsShown getShowOverloads() const
Definition: Diagnostic.h:575
CanQualType SignedCharTy
Definition: ASTContext.h:1004
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so...
Definition: DeclBase.h:1102
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
Definition: Type.h:5751
static ImplicitConversionSequence::CompareKind CompareImplicitConversionSequences(Sema &S, SourceLocation Loc, const ImplicitConversionSequence &ICS1, const ImplicitConversionSequence &ICS2)
CompareImplicitConversionSequences - Compare two implicit conversion sequences to determine whether o...
A narrowing conversion, because a non-constant-expression variable might have got narrowed...
Definition: Overload.h:126
AttrVec & getAttrs()
Definition: DeclBase.h:477
QualType getFromType() const
Definition: Overload.h:372
CanQualType getCanonicalTypeUnqualified() const
bool hasAttrs() const
Definition: DeclBase.h:471
Lvalue-to-rvalue conversion (C++ 4.1)
Definition: Overload.h:62
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:5777
RecordDecl * getDecl() const
Definition: Type.h:3986
static bool isBetterReferenceBindingKind(const StandardConversionSequence &SCS1, const StandardConversionSequence &SCS2)
Determine whether one of the given reference bindings is better than the other based on what kind of ...
bool isExplicit() const
Whether this function is explicit.
Definition: DeclCXX.h:2712
void EraseUnwantedCUDAMatches(const FunctionDecl *Caller, SmallVectorImpl< std::pair< DeclAccessPair, FunctionDecl *>> &Matches)
Finds a function in Matches with highest calling priority from Caller context and erases all function...
Definition: SemaCUDA.cpp:212
void AddBuiltinOperatorCandidates(OverloadedOperatorKind Op, SourceLocation OpLoc, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet)
AddBuiltinOperatorCandidates - Add the appropriate built-in operator overloads to the candidate set (...
unsigned ObjCLifetimeConversionBinding
Whether this binds a reference to an object with a different Objective-C lifetime qualifier...
Definition: Overload.h:195
static bool isNullPointerConstantForConversion(Expr *Expr, bool InOverloadResolution, ASTContext &Context)
CanQualType OverloadTy
Definition: ASTContext.h:1013
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
Definition: Expr.h:868
static std::unique_ptr< CorrectionCandidateCallback > MakeValidator(Sema &SemaRef, MemberExpr *ME, size_t NumArgs, bool HasTemplateArgs, bool AllowTypoCorrection)
Integral conversions (C++ 4.7)
Definition: Overload.h:70
void AddBuiltinCandidate(QualType *ParamTys, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet, bool IsAssignmentOperator=false, unsigned NumContextualBoolArguments=0)
AddBuiltinCandidate - Add a candidate for a built-in operator.
Complex promotions (Clang extension)
Definition: Overload.h:69
Assigning into this object requires the old value to be released and the new value to be retained...
Definition: Type.h:180
Kind
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr...
Definition: ExprCXX.h:2548
ImplicitConversionSequence - Represents an implicit conversion sequence, which may be a standard conv...
Definition: Overload.h:387
QualType getCanonicalType() const
Definition: Type.h:5757
bool isPointerConversionToVoidPointer(ASTContext &Context) const
isPointerConversionToVoidPointer - Determines whether this conversion is a conversion of a pointer to...
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:144
static bool checkAddressOfCandidateIsAvailable(Sema &S, const FunctionDecl *FD)
OverloadCandidate - A single candidate in an overload set (C++ 13.3).
Definition: Overload.h:624
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
Definition: DeclBase.cpp:220
NarrowingKind getNarrowingKind(ASTContext &Context, const Expr *Converted, APValue &ConstantValue, QualType &ConstantType) const
Check if this standard conversion sequence represents a narrowing conversion, according to C++11 [dcl...
ASTContext & getASTContext() const
Definition: Sema.h:1200
static bool DiagnoseTwoPhaseLookup(Sema &SemaRef, SourceLocation FnLoc, const CXXScopeSpec &SS, LookupResult &R, OverloadCandidateSet::CandidateSetKind CSK, TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef< Expr *> Args, bool *DoDiagnoseEmptyLookup=nullptr)
Attempt to recover from an ill-formed use of a non-dependent name in a template, where the non-depend...
SourceLocation getNameLoc() const
Gets the location of the name.
Definition: ExprCXX.h:2658
const ExtParameterInfo * ExtParameterInfos
Definition: Type.h:3394
NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const
isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant...
Definition: Expr.cpp:3276
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
Encodes a location in the source.
C++ [over.match.ctor], [over.match.list] Initialization of an object of class type by constructor...
Definition: Overload.h:742
QualType getReturnType() const
Definition: Type.h:3201
bool isPure() const
Whether this virtual function is pure, i.e.
Definition: Decl.h:1996
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:4002
void FindAssociatedClassesAndNamespaces(SourceLocation InstantiationLoc, ArrayRef< Expr *> Args, AssociatedNamespaceSet &AssociatedNamespaces, AssociatedClassSet &AssociatedClasses)
Find the associated classes and namespaces for argument-dependent lookup for a call with the given se...
CanQualType Int128Ty
Definition: ASTContext.h:1004
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:5384
virtual SemaDiagnosticBuilder noteAmbiguous(Sema &S, CXXConversionDecl *Conv, QualType ConvTy)=0
Emits a note for one of the candidate conversions.
static ImplicitConversionSequence::CompareKind CompareStandardConversionSequences(Sema &S, SourceLocation Loc, const StandardConversionSequence &SCS1, const StandardConversionSequence &SCS2)
CompareStandardConversionSequences - Compare two standard conversion sequences to determine whether o...
A call to a literal operator (C++11 [over.literal]) written as a user-defined literal (C++11 [lit...
Definition: ExprCXX.h:457
Template argument deduction failed due to inconsistent cv-qualifiers on a template parameter type tha...
Definition: Sema.h:6855
void AddMemberOperatorCandidates(OverloadedOperatorKind Op, SourceLocation OpLoc, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet, SourceRange OpRange=SourceRange())
Add overload candidates for overloaded operators that are member functions.
Represents a call to a member function that may be written either with member call syntax (e...
Definition: ExprCXX.h:164
A vector splat from an arithmetic type.
Definition: Overload.h:80
IncompatiblePointer - The assignment is between two pointers types that are not compatible, but we accept them as an extension.
Definition: Sema.h:9371
APFloat & getFloat()
Definition: APValue.h:209
static Comparison compareEnableIfAttrs(const Sema &S, const FunctionDecl *Cand1, const FunctionDecl *Cand2)
Compares the enable_if attributes of two FunctionDecls, for the purposes of overload resolution...
OverloadingResult
OverloadingResult - Capture the result of performing overload resolution.
Definition: Overload.h:40
static ImplicitConversionSequence::CompareKind compareConversionFunctions(Sema &S, FunctionDecl *Function1, FunctionDecl *Function2)
Compare the user-defined conversion functions or constructors of two user-defined conversion sequence...
bool isIntegralType(const ASTContext &Ctx) const
Determine whether this type is an integral type.
Definition: Type.cpp:1722
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1964
static void DiagnoseBadConversion(Sema &S, OverloadCandidate *Cand, unsigned I, bool TakingCandidateAddress)
ExprResult DefaultLvalueConversion(Expr *E)
Definition: SemaExpr.cpp:530
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
No ref-qualifier was provided.
Definition: Type.h:1304
CanQualType FloatTy
Definition: ASTContext.h:1007
Objective-C ARC writeback conversion.
Definition: Overload.h:84
bool DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType)
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:2190
The declaration was invalid; do nothing.
Definition: Sema.h:6841
static bool IsVectorConversion(Sema &S, QualType FromType, QualType ToType, ImplicitConversionKind &ICK)
Determine whether the conversion from FromType to ToType is a valid vector conversion.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
bool isSignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...
Definition: Type.cpp:1816
static bool checkArgPlaceholdersForOverload(Sema &S, MultiExprArg Args, UnbridgedCastsSet &unbridged)
checkArgPlaceholdersForOverload - Check a set of call operands for placeholders.
Specifies that a value-dependent expression should be considered to never be a null pointer constant...
Definition: Expr.h:706
OverloadingResult BestViableFunction(Sema &S, SourceLocation Loc, OverloadCandidateSet::iterator &Best)
Find the best viable function on this overload set, if it exists.
CanQualType VoidTy
Definition: ASTContext.h:996
bool isScoped() const
Returns true if this is a C++11 scoped enumeration.
Definition: Decl.h:3415
void addDecl(NamedDecl *D)
Definition: UnresolvedSet.h:89
TemplateDeductionResult DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, const TemplateArgumentList &TemplateArgs, sema::TemplateDeductionInfo &Info)
Perform template argument deduction to determine whether the given template arguments match the given...
bool hasRestrict() const
Definition: Type.h:283
llvm::Optional< unsigned > getCallArgIndex()
Return the index of the call argument that this deduction failure refers to, if any.
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
Definition: Expr.h:149
Qualifiers withoutObjCLifetime() const
Definition: Type.h:334
bool isObjCObjectPointerType() const
Definition: Type.h:6039
bool isAnyPointerType() const
Definition: Type.h:5946
bool CheckMemberPointerConversion(Expr *From, QualType ToType, CastKind &Kind, CXXCastPath &BasePath, bool IgnoreBaseAccess)
CheckMemberPointerConversion - Check the member pointer conversion from the expression From to the ty...
void setAsIdentityConversion()
StandardConversionSequence - Set the standard conversion sequence to the identity conversion...
Pointer conversions (C++ 4.10)
Definition: Overload.h:74
C++ [over.match.oper]: Lookup of operator function candidates in a call using operator syntax...
Definition: Overload.h:734
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:2822
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs. ...
bool canBindObjCObjectType(QualType To, QualType From)
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language...
Definition: Expr.h:249
bool hasUninstantiatedDefaultArg() const
Definition: Decl.h:1628
Requests that all candidates be shown.
Definition: Overload.h:50
TypeClass getTypeClass() const
Definition: Type.h:1613
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to call this function.
Definition: Decl.cpp:2931
bool isRValue() const
Definition: Expr.h:356
unsigned HasDiagnostic
Indicates whether a diagnostic is stored in Diagnostic.
bool isAnyCharacterType() const
Determine whether this type is any of the built-in character types.
Definition: Type.cpp:1780
bool IsBuildingRecoveryCallExpr
Flag indicating if Sema is building a recovery call expression.
Definition: Sema.h:513
EnumDecl * getDecl() const
Definition: Type.h:4009
virtual bool match(QualType T)=0
Determine whether the specified type is a valid destination type for this conversion.
Derived-to-base (C++ [over.best.ics])
Definition: Overload.h:78
DeductionFailureInfo MakeDeductionFailureInfo(ASTContext &Context, Sema::TemplateDeductionResult TDK, sema::TemplateDeductionInfo &Info)
Convert from Sema&#39;s representation of template deduction information to the form used in overload-can...
bool isVectorType() const
Definition: Type.h:6027
static void DiagnoseBadDeduction(Sema &S, NamedDecl *Found, Decl *Templated, DeductionFailureInfo &DeductionFailure, unsigned NumArgs, bool TakingCandidateAddress)
Diagnose a failed template-argument deduction.
Complex-real conversions (C99 6.3.1.7)
Definition: Overload.h:81
An rvalue ref-qualifier was provided (&&).
Definition: Type.h:1310
Assigning into this object requires a lifetime extension.
Definition: Type.h:186
void removeObjCGCAttr()
Definition: Type.h:324
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.cpp:1967
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13...
Definition: Overload.h:724
void setBad(BadConversionSequence::FailureKind Failure, Expr *FromExpr, QualType ToType)
Sets this sequence as a bad conversion for an explicit argument.
Definition: Overload.h:513
MutableArrayRef< Expr * > MultiExprArg
Definition: Ownership.h:261
ExprResult BuildCallToObjectOfClassType(Scope *S, Expr *Object, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc)
BuildCallToObjectOfClassType - Build a call to an object of class type (C++ [over.call.object]), which can end up invoking an overloaded function call operator (operator()) or performing a user-defined conversion on the object argument.
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2214
std::string getAsString() const
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
Definition: Type.h:1864
static MemberExpr * Create(const ASTContext &C, Expr *base, bool isarrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *memberdecl, DeclAccessPair founddecl, DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *targs, QualType ty, ExprValueKind VK, ExprObjectKind OK)
Definition: Expr.cpp:1437
void NoteOverloadCandidate(NamedDecl *Found, FunctionDecl *Fn, QualType DestType=QualType(), bool TakingAddress=false)
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:216
QualType getArrayDecayedType(QualType T) const
Return the properly qualified result of decaying the specified array type to a pointer.
unsigned getNumParams() const
Definition: Overload.h:709
const llvm::fltSemantics & getFloatTypeSemantics(QualType T) const
Return the APFloat &#39;semantics&#39; for the specified scalar floating point type.
CanProxy< U > getAs() const
Retrieve a canonical type pointer with a different static type, upcasting or downcasting as needed...
FunctionTemplateDecl * getMoreSpecializedTemplate(FunctionTemplateDecl *FT1, FunctionTemplateDecl *FT2, SourceLocation Loc, TemplatePartialOrderingContext TPOC, unsigned NumCallArguments1, unsigned NumCallArguments2)
Returns the more specialized function template according to the rules of function template partial or...
bool isPointerConversionToBool() const
isPointerConversionToBool - Determines whether this conversion is a conversion of a pointer or pointe...
CompoundAssignOperator - For compound assignments (e.g.
Definition: Expr.h:3191
SourceLocation getLocation() const
A POD class for pairing a NamedDecl* with an access specifier.
DeclarationNameLoc - Additional source/type location info for a declaration name. ...
ExprResult BuildOverloadedArrowExpr(Scope *S, Expr *Base, SourceLocation OpLoc, bool *NoArrowOperatorFound=nullptr)
BuildOverloadedArrowExpr - Build a call to an overloaded operator-> (if one exists), where Base is an expression of class type and Member is the name of the member we&#39;re trying to find.
ExprResult BuildCXXMemberCallExpr(Expr *Exp, NamedDecl *FoundDecl, CXXConversionDecl *Method, bool HadMultipleCandidates)
Represents a C11 generic selection.
Definition: Expr.h:4684
ImplicitConversionRank GetConversionRank(ImplicitConversionKind Kind)
GetConversionRank - Retrieve the implicit conversion rank corresponding to the given implicit convers...
A class for storing results from argument-dependent lookup.
Definition: Lookup.h:790
CanQualType UnsignedShortTy
Definition: ASTContext.h:1005
static const Expr * IgnoreNarrowingConversion(const Expr *Converted)
Skip any implicit casts which could be either part of a narrowing conversion or after one in an impli...
CanQualType CharTy
Definition: ASTContext.h:998
const TemplateArgument * getFirstArg()
Return the first template argument this deduction failure refers to, if any.
Represents a template argument.
Definition: TemplateBase.h:51
ExprResult PerformCopyInitialization(const InitializedEntity &Entity, SourceLocation EqualLoc, ExprResult Init, bool TopLevelOfInitList=false, bool AllowExplicit=false)
Definition: SemaInit.cpp:8402
iterator begin()
Definition: Lookup.h:813
DeclContextLookupResult LookupConstructors(CXXRecordDecl *Class)
Look up the constructors for the given class.
DeclAccessPair FoundCopyConstructor
Definition: Overload.h:213
static ExprResult diagnoseAmbiguousConversion(Sema &SemaRef, SourceLocation Loc, Expr *From, Sema::ContextualImplicitConverter &Converter, QualType T, UnresolvedSetImpl &ViableConversions)
Abstract base class used to perform a contextual implicit conversion from an expression to any type p...
Definition: Sema.h:2589
GC getObjCGCAttr() const
Definition: Type.h:320
Dataflow Directional Tag Classes.
int getFloatingTypeOrder(QualType LHS, QualType RHS) const
Compare the rank of the two specified floating point types, ignoring the domain of the type (i...
bool isValid() const
Return true if this is a valid SourceLocation object.
ExtInfo getExtInfo() const
Definition: Type.h:3212
A qualifier set is used to build a set of qualifiers.
Definition: Type.h:5685
UnaryOperatorKind
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1256
CanQualType NullPtrTy
Definition: ASTContext.h:1012
EvalResult is a struct with detailed info about an evaluated expression.
Definition: Expr.h:571
static ImplicitConversionSequence TryImplicitConversion(Sema &S, Expr *From, QualType ToType, bool SuppressUserConversions, bool AllowExplicit, bool InOverloadResolution, bool CStyle, bool AllowObjCWritebackConversion, bool AllowObjCConversionOnExplicit)
TryImplicitConversion - Attempt to perform an implicit conversion from the given expression (Expr) to...
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:399
bool IsFloatingPointPromotion(QualType FromType, QualType ToType)
IsFloatingPointPromotion - Determines whether the conversion from FromType to ToType is a floating po...
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Definition: OperatorKinds.h:22
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_RValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CCK_ImplicitConversion)
ImpCastExprToType - If Expr is not of type &#39;Type&#39;, insert an implicit cast.
Definition: Sema.cpp:466
ConversionSet::const_iterator const_iterator
Definition: Overload.h:328
QualType getRestrictType(QualType T) const
Return the uniqued reference to the type for a restrict qualified type.
Definition: ASTContext.h:1133
void AddSurrogateCandidate(CXXConversionDecl *Conversion, DeclAccessPair FoundDecl, CXXRecordDecl *ActingContext, const FunctionProtoType *Proto, Expr *Object, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet)
AddSurrogateCandidate - Adds a "surrogate" candidate function that converts the given Object to a fun...
bool isObjCClassType() const
True if this is equivalent to the &#39;Class&#39; type, i.e.
Definition: Type.h:5508
static bool hasSimilarType(ASTContext &Context, QualType T1, QualType T2)
virtual SemaDiagnosticBuilder diagnoseNoMatch(Sema &S, SourceLocation Loc, QualType T)=0
Emits a diagnostic complaining that the expression does not have integral or enumeration type...
void HandleFunctionTypeMismatch(PartialDiagnostic &PDiag, QualType FromType, QualType ToType)
HandleFunctionTypeMismatch - Gives diagnostic information for differeing function types...
bool IsAllowedCUDACall(const FunctionDecl *Caller, const FunctionDecl *Callee)
Determines whether Caller may invoke Callee, based on their CUDA host/device attributes.
Definition: Sema.h:10033
SourceLocation getLocStart() const LLVM_READONLY
Definition: ExprCXX.h:2819
BinaryOperator::Opcode getOpcode(const SymExpr *SE)
bool DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics...
Definition: SemaExpr.cpp:204
CanQualType UnsignedLongLongTy
Definition: ASTContext.h:1006
static bool checkPlaceholderForOverload(Sema &S, Expr *&E, UnbridgedCastsSet *unbridgedCasts=nullptr)
checkPlaceholderForOverload - Do any interesting placeholder-like preprocessing on the given expressi...
Conversions allowed in C, but not C++.
Definition: Overload.h:87
Array-to-pointer conversion (C++ 4.2)
Definition: Overload.h:63
void setConversionChecker(TypeComparisonFuncTy Foo)
Resets the default conversion checker method.
A non-depnedent component of the parameter did not match the corresponding component of the argument...
Definition: Sema.h:6868
PartialDiagnosticAt * getSFINAEDiagnostic()
Retrieve the diagnostic which caused this deduction failure, if any.
DeclarationName - The name of a declaration.
Expr * getDefaultArg()
Definition: Decl.cpp:2493
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
Definition: Type.h:979
StandardConversionSequence Before
Represents the standard conversion that occurs before the actual user-defined conversion.
Definition: Overload.h:263
bool IsBlockPointerConversion(QualType FromType, QualType ToType, QualType &ConvertedType)
const CXXRecordDecl * getParent() const
Returns the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:2085
bool isBooleanType() const
Definition: Type.h:6232
const Type * strip(QualType type)
Collect any qualifiers on the given type and return an unqualified type.
Definition: Type.h:5692
bool isSpecializationCopyingObject() const
Determine whether this is a member template specialization that would copy the object to itself...
Definition: DeclCXX.cpp:2166
bool isMoveConstructor(unsigned &TypeQuals) const
Determine whether this constructor is a move constructor (C++11 [class.copy]p3), which can be used to...
Definition: DeclCXX.cpp:2101
void AddArgumentDependentLookupCandidates(DeclarationName Name, SourceLocation Loc, ArrayRef< Expr *> Args, TemplateArgumentListInfo *ExplicitTemplateArgs, OverloadCandidateSet &CandidateSet, bool PartialOverloading=false)
Add function candidates found via argument-dependent lookup to the set of overloading candidates...
static QualType AdoptQualifiers(ASTContext &Context, QualType T, Qualifiers Qs)
Adopt the given qualifiers for the given type.
Expression is a Null pointer constant built from a zero integer expression that is not a simple...
Definition: Expr.h:682
bool isMSVCRTEntryPoint() const
Determines whether this function is a MSVCRT user defined entry point.
Definition: Decl.cpp:2653
A set of unresolved declarations.
void setInstantiationDependent(bool ID)
Set whether this expression is instantiation-dependent or not.
Definition: Expr.h:196
SourceLocation getLocStart() const LLVM_READONLY
Definition: Decl.h:731
Requests that only viable candidates be shown.
Definition: Overload.h:53
FunctionDecl * Function
Function - The actual function that this candidate represents.
Definition: Overload.h:629
bool IsMemberPointerConversion(Expr *From, QualType FromType, QualType ToType, bool InOverloadResolution, QualType &ConvertedType)
IsMemberPointerConversion - Determines whether the conversion of the expression From, which has the (possibly adjusted) type FromType, can be converted to the type ToType via a member pointer conversion (C++ 4.11).
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2502
static void dropPointerConversion(StandardConversionSequence &SCS)
dropPointerConversions - If the given standard conversion sequence involves any pointer conversions...
QualType getCallResultType(const ASTContext &Context) const
Determine the type of an expression that calls a function of this type.
Definition: Type.h:3219
bool isIntegerConstantExpr(llvm::APSInt &Result, const ASTContext &Ctx, SourceLocation *Loc=nullptr, bool isEvaluated=true) const
isIntegerConstantExpr - Return true if this expression is a valid integer constant expression...
const FunctionType * adjustFunctionType(const FunctionType *Fn, FunctionType::ExtInfo EInfo)
Change the ExtInfo on a function type.
TemplateSpecCandidate & addCandidate()
Add a new candidate with NumConversions conversion sequence slots to the overload set...
Optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
bool isAggregateType() const
Determines whether the type is a C++ aggregate type or C aggregate or union type. ...
Definition: Type.cpp:1962
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
QualType apply(const ASTContext &Context, QualType QT) const
Apply the collected qualifiers to the given type.
Definition: Type.cpp:3271
OverloadCandidateKind
bool CheckNonDependentConversions(FunctionTemplateDecl *FunctionTemplate, ArrayRef< QualType > ParamTypes, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet, ConversionSequenceList &Conversions, bool SuppressUserConversions, CXXRecordDecl *ActingContext=nullptr, QualType ObjectType=QualType(), Expr::Classification ObjectClassification={})
Check that implicit conversion sequences can be formed for each argument whose corresponding paramete...
void dump() const
dump - Print this user-defined conversion sequence to standard error.
void * Data
Opaque pointer containing additional data about this deduction failure.
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 &#39;auto&#39; typ...
Definition: Type.h:6238
void Profile(llvm::FoldingSetNodeID &ID) const
Definition: Type.h:570
void AddFunctionCandidates(const UnresolvedSetImpl &Functions, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet, TemplateArgumentListInfo *ExplicitTemplateArgs=nullptr, bool SuppressUserConversions=false, bool PartialOverloading=false, bool FirstArgumentIsBase=false)
Add all of the function declarations in the given function set to the overload candidate set...
param_iterator param_end()
Definition: Decl.h:2180
void addConst()
Definition: Type.h:274
static void NoteSurrogateCandidate(Sema &S, OverloadCandidate *Cand)
bool hasSFINAEDiagnostic() const
Is a SFINAE diagnostic available?
FunctionDecl * ConversionFunction
ConversionFunction - The function that will perform the user-defined conversion.
Definition: Overload.h:285
Represents a pointer to an Objective C object.
Definition: Type.h:5440
Pointer to a block type.
Definition: Type.h:2385
Conversion only allowed in the C standard.
Definition: Overload.h:104
unsigned getIntWidth(QualType T) const
Not an overloaded operator.
Definition: OperatorKinds.h:23
const UnresolvedSetImpl & asUnresolvedSet() const
Definition: Lookup.h:334
ExprResult CreateOverloadedArraySubscriptExpr(SourceLocation LLoc, SourceLocation RLoc, Expr *Base, Expr *Idx)
void setHadMultipleCandidates(bool V=true)
Sets the flag telling whether this expression refers to a method that was resolved from an overloaded...
Definition: Expr.h:2608
bool IsPointerConversion(Expr *From, QualType FromType, QualType ToType, bool InOverloadResolution, QualType &ConvertedType, bool &IncompatibleObjC)
IsPointerConversion - Determines whether the conversion of the expression From, which has the (possib...
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3976
void setAllToTypes(QualType T)
Definition: Overload.h:220
Complex values, per C99 6.2.5p11.
Definition: Type.h:2223
unsigned getKindRank() const
Return a ranking of the implicit conversion sequence kind, where smaller ranks represent better conve...
Definition: Overload.h:481
Expr * getUninstantiatedDefaultArg()
Definition: Decl.cpp:2535
CanQualType UnknownAnyTy
Definition: ASTContext.h:1013
bool empty() const
Definition: Type.h:429
ObjCInterfaceDecl * getInterfaceDecl() const
If this pointer points to an Objective @interface type, gets the declaration for that interface...
Definition: Type.h:5496
CUDAFunctionPreference IdentifyCUDAPreference(const FunctionDecl *Caller, const FunctionDecl *Callee)
Identifies relative preference of a given Caller/Callee combination, based on their host/device attri...
Definition: SemaCUDA.cpp:161
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: Type.h:6191
TemplateArgumentList * take()
Take ownership of the deduced template argument list.
CanQualType UnsignedLongTy
Definition: ASTContext.h:1005
This candidate was not viable because its OpenCL extension is disabled.
Definition: Overload.h:611
void addRestrict()
Definition: Type.h:288
bool areCompatibleVectorTypes(QualType FirstVec, QualType SecondVec)
Return true if the given vector types are of the same unqualified type or if they are equivalent to t...
unsigned BindsImplicitObjectArgumentWithoutRefQualifier
Whether this binds an implicit object argument to a non-static member function without a ref-qualifie...
Definition: Overload.h:191
unsigned char FailureKind
FailureKind - The reason why this candidate is not viable.
Definition: Overload.h:670
CanQualType DependentTy
Definition: ASTContext.h:1013
void AddTemplateOverloadCandidate(FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl, TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false)
Add a C++ function template specialization as a candidate in the candidate set, using template argume...
static bool FindConversionForRefInit(Sema &S, ImplicitConversionSequence &ICS, QualType DeclType, SourceLocation DeclLoc, Expr *Init, QualType T2, bool AllowRvalues, bool AllowExplicit)
Look for a user-defined conversion to a value reference-compatible with DeclType. ...
CanQualType WCharTy
Definition: ASTContext.h:999
bool isFunctionType() const
Definition: Type.h:5938
bool isObjCQualifiedIdType() const
Definition: Type.h:6056
DeclAccessPair FoundDecl
FoundDecl - The original declaration that was looked up / invented / otherwise found, together with its access.
Definition: Overload.h:634
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2419
CanQualType BoundMemberTy
Definition: ASTContext.h:1013
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:2190
AccessResult CheckMemberOperatorAccess(SourceLocation Loc, Expr *ObjectExpr, Expr *ArgExpr, DeclAccessPair FoundDecl)
Checks access to an overloaded member operator, including conversion operators.
TemplateSpecCandidate - This is a generalization of OverloadCandidate which keeps track of template a...
Block Pointer conversions.
Definition: Overload.h:82
Deduction failed; that&#39;s all we know.
Definition: Sema.h:6881
virtual bool hasFloat128Type() const
Determine whether the __float128 type is supported on this target.
Definition: TargetInfo.h:365
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Definition: Diagnostic.h:90
bool canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT, const ObjCObjectPointerType *RHSOPT)
canAssignObjCInterfaces - Return true if the two interface types are compatible for assignment from R...
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream...
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
Definition: Lookup.h:265
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type...
Definition: Type.cpp:2676
static ExprResult BuildRecoveryCallExpr(Sema &SemaRef, Scope *S, Expr *Fn, UnresolvedLookupExpr *ULE, SourceLocation LParenLoc, MutableArrayRef< Expr *> Args, SourceLocation RParenLoc, bool EmptyLookup, bool AllowTypoCorrection)
Attempts to recover from a call where no functions were found.
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat]...
Definition: APValue.h:38
virtual bool hasInt128Type() const
Determine whether the __int128 type is supported on this target.
Definition: TargetInfo.h:360
static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType, bool InOverloadResolution, StandardConversionSequence &SCS, bool CStyle)
Determine whether this is a conversion from a scalar type to an atomic type.
bool isInitListConstructor(const FunctionDecl *Ctor)
Determine whether Ctor is an initializer-list constructor, as defined in [dcl.init.list]p2.
static bool isNonTrivialObjCLifetimeConversion(Qualifiers FromQuals, Qualifiers ToQuals)
Determine whether the lifetime conversion between the two given qualifiers sets is nontrivial...
bool isObjectType() const
Determine whether this type is an object type.
Definition: Type.h:1668
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2007
Condition in a constexpr if statement.
Definition: Sema.h:2580
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types...
Definition: Type.cpp:1986
bool hasObjCGCAttr() const
Definition: Type.h:319
bool checkAddressOfFunctionIsAvailable(const FunctionDecl *Function, bool Complain=false, SourceLocation Loc=SourceLocation())
Returns whether the given function&#39;s address can be taken or not, optionally emitting a diagnostic if...
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
TemplateArgumentList * getTemplateArgumentList()
Retrieve the template argument list associated with this deduction failure, if any.
ConversionFixItGenerator Fix
The FixIt hints which can be used to fix the Bad candidate.
Definition: Overload.h:649
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
Definition: DeclBase.h:517
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2174
AmbiguousConversionSequence Ambiguous
When ConversionKind == AmbiguousConversion, provides the details of the ambiguous conversion...
Definition: Overload.h:434
void setHadMultipleCandidates(bool V=true)
Sets the flag telling whether this expression refers to a function that was resolved from an overload...
Definition: Expr.h:1159
A template argument list.
Definition: DeclTemplate.h:210
bool isLValueReferenceType() const
Definition: Type.h:5958
void addConversion(NamedDecl *Found, FunctionDecl *D)
Definition: Overload.h:320
SourceLocation getCXXLiteralOperatorNameLoc() const
getCXXLiteralOperatorNameLoc - Returns the location of the literal operator name (not the operator ke...
X
Add a minimal nested name specifier fixit hint to allow lookup of a tag name from an outer enclosing ...
Definition: SemaDecl.cpp:13020
Reading or writing from this object requires a barrier call.
Definition: Type.h:183
bool isQueueT() const
Definition: Type.h:6108
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:235
CCEKind
Contexts in which a converted constant expression is required.
Definition: Sema.h:2575
static void BuildBasePathArray(const CXXBasePath &Path, CXXCastPath &BasePathArray)
QualType getParamType(unsigned i) const
Definition: Type.h:3491
bool typesAreCompatible(QualType T1, QualType T2, bool CompareUnqualified=false)
Compatibility predicates used to check assignment expressions.
bool FunctionParamTypesAreEqual(const FunctionProtoType *OldType, const FunctionProtoType *NewType, unsigned *ArgPos=nullptr)
FunctionParamTypesAreEqual - This routine checks two function proto types for equality of their argum...
Function-to-pointer (C++ 4.3)
Definition: Overload.h:64
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:2387
unsigned size() const
QualType getToType() const
Definition: Overload.h:373
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:5798
bool hasUnaligned() const
Definition: Type.h:312
bool mergeExtParameterInfo(const FunctionProtoType *FirstFnType, const FunctionProtoType *SecondFnType, bool &CanUseFirst, bool &CanUseSecond, SmallVectorImpl< FunctionProtoType::ExtParameterInfo > &NewParamInfos)
This function merges the ExtParameterInfo lists of two functions.
Represents a C++ struct/union/class.
Definition: DeclCXX.h:299
static ImplicitConversionSequence TryReferenceInit(Sema &S, Expr *Init, QualType DeclType, SourceLocation DeclLoc, bool SuppressUserConversions, bool AllowExplicit)
Compute an implicit conversion sequence for reference initialization.
Compatible - the types are compatible according to the standard.
Definition: Sema.h:9355
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type...
bool isVoidType() const
Definition: Type.h:6169
The template argument is a template name that was provided for a template template parameter...
Definition: TemplateBase.h:76
CUDAFunctionTarget
Definition: Sema.h:9983
OverloadsShown
Specifies which overload candidates to display when overload resolution fails.
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:5745
CanQualType Char16Ty
Definition: ASTContext.h:1002
bool isLaxVectorConversion(QualType srcType, QualType destType)
Is this a legal conversion between two types, one of which is known to be a vector type...
Definition: SemaExpr.cpp:5966
AccessResult CheckUnresolvedLookupAccess(UnresolvedLookupExpr *E, DeclAccessPair FoundDecl)
bool isPRValue() const
Definition: Expr.h:355
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:328
TemplateArgument SecondArg
The second template argument to which the template argument deduction failure refers.
Partial ordering of function templates for a function call.
Definition: Template.h:140
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
Definition: Diagnostic.h:127
bool isXValue() const
Definition: Expr.h:353
This class is used for builtin types like &#39;int&#39;.
Definition: Type.h:2143
bool isVariadic() const
Definition: DeclObjC.h:454
static void AddBuiltinAssignmentOperatorCandidates(Sema &S, QualType T, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet)
Helper function for AddBuiltinOperatorCandidates() that adds the volatile- and non-volatile-qualified...
iterator end() const
Definition: Lookup.h:339
After substituting deduced template arguments, an element of a dependent parameter type did not match...
Definition: Sema.h:6865
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:265
static void DiagnoseBadTarget(Sema &S, OverloadCandidate *Cand)
CUDA: diagnose an invalid call across targets.
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) ...
Definition: Diagnostic.h:1227
static bool canBeDeclaredInNamespace(const DeclarationName &Name)
Determine whether a declaration with the specified name could be moved into a different namespace...
Defines the clang::TargetInfo interface.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2209
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:154
ImplicitConversionRank getRank() const
getRank - Retrieve the rank of this standard conversion sequence (C++ 13.3.3.1.1p3).
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:3509
StringRef getName() const
getName - Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:270
unsigned getCVRQualifiers() const
Definition: Type.h:291
ExprResult ExprError()
Definition: Ownership.h:267
static Qualifiers fromCVRMask(unsigned CVR)
Definition: Type.h:245
bool hasVolatile() const
Definition: Type.h:276
std::string getQualifiedNameAsString() const
Definition: Decl.cpp:1472
NameKind getKind() const
CanQualType IntTy
Definition: ASTContext.h:1004
ExprResult CheckConvertedConstantExpression(Expr *From, QualType T, llvm::APSInt &Value, CCEKind CCE)
bool IsQualificationConversion(QualType FromType, QualType ToType, bool CStyle, bool &ObjCLifetimeConversion)
IsQualificationConversion - Determines whether the conversion from an rvalue of type FromType to ToTy...
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:1858
QualType getAsType() const
Retrieve the type for a type template argument.
Definition: TemplateBase.h:257
iterator end()
Definition: Lookup.h:814
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:956
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:4493
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:2077
NestedNameSpecifierLoc getQualifierLoc() const
Fetches the nested-name qualifier with source-location information, if one was given.
Definition: ExprCXX.h:2667
bool isPointerType() const
Definition: Type.h:5942
Zero constant to event (OpenCL1.2 6.12.10)
Definition: Overload.h:85
unsigned CallArgIndex
The index of the function argument that caused a deduction failure.
SourceManager & SourceMgr
Definition: Sema.h:319
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc)
Retrieve the overloaded operator kind that corresponds to the given binary opcode.
Definition: Expr.cpp:1809
unsigned getAddressSpaceAttributePrintValue() const
Get the address space attribute value to be printed by diagnostics.
Definition: Type.h:374
void NoteAllOverloadCandidates(Expr *E, QualType DestType=QualType(), bool TakingAddress=false)
BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases...
ImplicitConversionKind First
First – The first conversion can be an lvalue-to-rvalue conversion, array-to-pointer conversion...
Definition: Overload.h:146
No viable function found.
Definition: Overload.h:42
void NoteCandidates(Sema &S, SourceLocation Loc)
NoteCandidates - When no template specialization match is found, prints diagnostic messages containin...
TemplateArgument FirstArg
The first template argument to which the template argument deduction failure refers.
DeductionFailureInfo DeductionFailure
Definition: Overload.h:677
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
Definition: Lookup.h:586
static bool recordConversion(Sema &SemaRef, SourceLocation Loc, Expr *&From, Sema::ContextualImplicitConverter &Converter, QualType T, bool HadMultipleCandidates, DeclAccessPair &Found)
QualType getType() const
Definition: Decl.h:638
bool empty() const
Return true if no decls were found.
Definition: Lookup.h:342
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:111
bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)
A trivial tuple used to represent a source range.
static StringRef getOpcodeStr(Opcode Op)
getOpcodeStr - Turn an Opcode enum value into the punctuation char it corresponds to...
Definition: Expr.cpp:1116
ASTContext & Context
Definition: Sema.h:316
NamedDecl - This represents a decl with a name.
Definition: Decl.h:245
void dump() const
dump - Print this standard conversion sequence to standard error.
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
CanQualType BoolTy
Definition: ASTContext.h:997
TemplateDecl * getDescribedTemplate() const
If this is a declaration that describes some template, this method returns that template declaration...
Definition: DeclBase.cpp:232
QualType getNonTypeTemplateArgumentType() const
If this is a non-type template argument, get its type.
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
Definition: TemplateBase.h:281
APSInt & getInt()
Definition: APValue.h:201
iterator begin() const
Definition: Lookup.h:338
CanQualType DoubleTy
Definition: ASTContext.h:1007
Pointer-to-member conversions (C++ 4.11)
Definition: Overload.h:75
SourceLocation getNameLoc() const
Gets the location of the identifier.
Definition: Lookup.h:609
static OverloadingResult IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType, UserDefinedConversionSequence &User, OverloadCandidateSet &Conversions, bool AllowExplicit, bool AllowObjCConversionOnExplicit)
Determines whether there is a user-defined conversion sequence (C++ [over.ics.user]) that converts ex...
Look up of an operator name (e.g., operator+) for use with operator overloading.
Definition: Sema.h:3006
Describes an entity that is being initialized.
void setToType(unsigned Idx, QualType T)
Definition: Overload.h:216
EnableIfAttr * CheckEnableIf(FunctionDecl *Function, ArrayRef< Expr *> Args, bool MissingImplicitThis=false)
Check the enable_if expressions on the given function.
bool isLValue() const
Definition: Expr.h:352
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
Definition: Decl.cpp:2910
void setBase(Expr *E)
Definition: Expr.h:2476
char Diagnostic[sizeof(PartialDiagnosticAt)]
A diagnostic indicating why deduction failed.
SourceLocation getLocStart() const LLVM_READONLY
Definition: Stmt.cpp:277
void removeAddressSpace()
Definition: Type.h:392
SourceLocation getBegin() const
AssignmentAction
Definition: Sema.h:2466
const LangOptions & getLangOpts() const
Definition: ASTContext.h:688
static ImplicitConversionSequence TryCopyInitialization(Sema &S, Expr *From, QualType ToType, bool SuppressUserConversions, bool InOverloadResolution, bool AllowObjCWritebackConversion, bool AllowExplicit=false)
TryCopyInitialization - Try to copy-initialize a value of type ToType from the expression From...
decls_iterator decls_end() const
Definition: ExprCXX.h:2641
The explicitly-specified template arguments were not valid template arguments for the given template...
Definition: Sema.h:6877
void NoteCandidates(Sema &S, OverloadCandidateDisplayKind OCD, ArrayRef< Expr *> Args, StringRef Opc="", SourceLocation Loc=SourceLocation(), llvm::function_ref< bool(OverloadCandidate &)> Filter=[](OverloadCandidate &) { return true;})
PrintOverloadCandidates - When overload resolution fails, prints diagnostic messages containing the c...
This conversion candidate is not viable because its result type is not implicitly convertible to the ...
Definition: Overload.h:592
QualType getBaseType() const
Definition: ExprCXX.h:3516
Declaration of a template function.
Definition: DeclTemplate.h:967
void clear()
Clears out any current state.
Definition: Lookup.h:557
static bool diagnoseDiagnoseIfAttrsWith(Sema &S, const NamedDecl *ND, bool ArgDependent, SourceLocation Loc, CheckFn &&IsSuccessful)
A class which abstracts out some details necessary for making a call.
Definition: Type.h:3081
static QualType BuildSimilarlyQualifiedPointerType(const Type *FromPtr, QualType ToPointee, QualType ToType, ASTContext &Context, bool StripObjCLifetime=false)
BuildSimilarlyQualifiedPointerType - In a pointer conversion from the pointer type FromPtr to a point...
static ImplicitConversionSequence TryUserDefinedConversion(Sema &S, Expr *From, QualType ToType, bool SuppressUserConversions, bool AllowExplicit, bool InOverloadResolution, bool CStyle, bool AllowObjCWritebackConversion, bool AllowObjCConversionOnExplicit)
Tries a user-defined conversion from From to ToType.
Comparison
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals)
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals...
Attr - This represents one attribute.
Definition: Attr.h:43
bool isDeletedAsWritten() const
Definition: Decl.h:2078
SourceLocation getLocation() const
Definition: DeclBase.h:416
bool isIncompleteOrObjectType() const
Return true if this is an incomplete or object type, in other words, not a function type...
Definition: Type.h:1663
bool isCXX11ConstantExpr(const ASTContext &Ctx, APValue *Result=nullptr, SourceLocation *Loc=nullptr) const
isCXX11ConstantExpr - Return true if this expression is a constant expression in C++11.
QualType getPointeeType() const
Definition: Type.h:2522
A single template declaration.
Definition: TemplateName.h:191
ArrayRef< ParmVarDecl * > parameters() const
Definition: DeclObjC.h:405
Expr * IgnoreParens() LLVM_READONLY
IgnoreParens - Ignore parentheses.
Definition: Expr.cpp:2434
bool isUnavailable(std::string *Message=nullptr) const
Determine whether this declaration is marked &#39;unavailable&#39;.
Definition: DeclBase.h:672
CanQualType UnsignedIntTy
Definition: ASTContext.h:1005
bool hasErrorOccurred() const
Determine whether any SFINAE errors have been trapped.
Definition: Sema.h:7462
unsigned NumConversionsFixed
The number of Conversions fixed.
param_type_iterator param_type_end() const
Definition: Type.h:3645
DeclarationName getCXXOperatorName(OverloadedOperatorKind Op)
getCXXOperatorName - Get the name of the overloadable C++ operator corresponding to Op...
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:5456
StandardConversionSequence - represents a standard conversion sequence (C++ 13.3.3.1.1).
Definition: Overload.h:141
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.cpp:1497
static void DiagnoseFailedEnableIfAttr(Sema &S, OverloadCandidate *Cand)