clang  5.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) {
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 }
847 
848 namespace {
849  class UnbridgedCastsSet {
850  struct Entry {
851  Expr **Addr;
852  Expr *Saved;
853  };
854  SmallVector<Entry, 2> Entries;
855 
856  public:
857  void save(Sema &S, Expr *&E) {
858  assert(E->hasPlaceholderType(BuiltinType::ARCUnbridgedCast));
859  Entry entry = { &E, E };
860  Entries.push_back(entry);
861  E = S.stripARCUnbridgedCast(E);
862  }
863 
864  void restore() {
866  i = Entries.begin(), e = Entries.end(); i != e; ++i)
867  *i->Addr = i->Saved;
868  }
869  };
870 }
871 
872 /// checkPlaceholderForOverload - Do any interesting placeholder-like
873 /// preprocessing on the given expression.
874 ///
875 /// \param unbridgedCasts a collection to which to add unbridged casts;
876 /// without this, they will be immediately diagnosed as errors
877 ///
878 /// Return true on unrecoverable error.
879 static bool
881  UnbridgedCastsSet *unbridgedCasts = nullptr) {
882  if (const BuiltinType *placeholder = E->getType()->getAsPlaceholderType()) {
883  // We can't handle overloaded expressions here because overload
884  // resolution might reasonably tweak them.
885  if (placeholder->getKind() == BuiltinType::Overload) return false;
886 
887  // If the context potentially accepts unbridged ARC casts, strip
888  // the unbridged cast and add it to the collection for later restoration.
889  if (placeholder->getKind() == BuiltinType::ARCUnbridgedCast &&
890  unbridgedCasts) {
891  unbridgedCasts->save(S, E);
892  return false;
893  }
894 
895  // Go ahead and check everything else.
896  ExprResult result = S.CheckPlaceholderExpr(E);
897  if (result.isInvalid())
898  return true;
899 
900  E = result.get();
901  return false;
902  }
903 
904  // Nothing to do.
905  return false;
906 }
907 
908 /// checkArgPlaceholdersForOverload - Check a set of call operands for
909 /// placeholders.
911  MultiExprArg Args,
912  UnbridgedCastsSet &unbridged) {
913  for (unsigned i = 0, e = Args.size(); i != e; ++i)
914  if (checkPlaceholderForOverload(S, Args[i], &unbridged))
915  return true;
916 
917  return false;
918 }
919 
920 /// Determine whether the given New declaration is an overload of the
921 /// declarations in Old. This routine returns Ovl_Match or Ovl_NonFunction if
922 /// New and Old cannot be overloaded, e.g., if New has the same signature as
923 /// some function in Old (C++ 1.3.10) or if the Old declarations aren't
924 /// functions (or function templates) at all. When it does return Ovl_Match or
925 /// Ovl_NonFunction, MatchedDecl will point to the decl that New cannot be
926 /// overloaded with. This decl may be a UsingShadowDecl on top of the underlying
927 /// declaration.
928 ///
929 /// Example: Given the following input:
930 ///
931 /// void f(int, float); // #1
932 /// void f(int, int); // #2
933 /// int f(int, int); // #3
934 ///
935 /// When we process #1, there is no previous declaration of "f", so IsOverload
936 /// will not be used.
937 ///
938 /// When we process #2, Old contains only the FunctionDecl for #1. By comparing
939 /// the parameter types, we see that #1 and #2 are overloaded (since they have
940 /// different signatures), so this routine returns Ovl_Overload; MatchedDecl is
941 /// unchanged.
942 ///
943 /// When we process #3, Old is an overload set containing #1 and #2. We compare
944 /// the signatures of #3 to #1 (they're overloaded, so we do nothing) and then
945 /// #3 to #2. Since the signatures of #3 and #2 are identical (return types of
946 /// functions are not part of the signature), IsOverload returns Ovl_Match and
947 /// MatchedDecl will be set to point to the FunctionDecl for #2.
948 ///
949 /// 'NewIsUsingShadowDecl' indicates that 'New' is being introduced into a class
950 /// by a using declaration. The rules for whether to hide shadow declarations
951 /// ignore some properties which otherwise figure into a function template's
952 /// signature.
955  NamedDecl *&Match, bool NewIsUsingDecl) {
956  for (LookupResult::iterator I = Old.begin(), E = Old.end();
957  I != E; ++I) {
958  NamedDecl *OldD = *I;
959 
960  bool OldIsUsingDecl = false;
961  if (isa<UsingShadowDecl>(OldD)) {
962  OldIsUsingDecl = true;
963 
964  // We can always introduce two using declarations into the same
965  // context, even if they have identical signatures.
966  if (NewIsUsingDecl) continue;
967 
968  OldD = cast<UsingShadowDecl>(OldD)->getTargetDecl();
969  }
970 
971  // A using-declaration does not conflict with another declaration
972  // if one of them is hidden.
973  if ((OldIsUsingDecl || NewIsUsingDecl) && !isVisible(*I))
974  continue;
975 
976  // If either declaration was introduced by a using declaration,
977  // we'll need to use slightly different rules for matching.
978  // Essentially, these rules are the normal rules, except that
979  // function templates hide function templates with different
980  // return types or template parameter lists.
981  bool UseMemberUsingDeclRules =
982  (OldIsUsingDecl || NewIsUsingDecl) && CurContext->isRecord() &&
983  !New->getFriendObjectKind();
984 
985  if (FunctionDecl *OldF = OldD->getAsFunction()) {
986  if (!IsOverload(New, OldF, UseMemberUsingDeclRules)) {
987  if (UseMemberUsingDeclRules && OldIsUsingDecl) {
988  HideUsingShadowDecl(S, cast<UsingShadowDecl>(*I));
989  continue;
990  }
991 
992  if (!isa<FunctionTemplateDecl>(OldD) &&
993  !shouldLinkPossiblyHiddenDecl(*I, New))
994  continue;
995 
996  Match = *I;
997  return Ovl_Match;
998  }
999  } else if (isa<UsingDecl>(OldD) || isa<UsingPackDecl>(OldD)) {
1000  // We can overload with these, which can show up when doing
1001  // redeclaration checks for UsingDecls.
1002  assert(Old.getLookupKind() == LookupUsingDeclName);
1003  } else if (isa<TagDecl>(OldD)) {
1004  // We can always overload with tags by hiding them.
1005  } else if (auto *UUD = dyn_cast<UnresolvedUsingValueDecl>(OldD)) {
1006  // Optimistically assume that an unresolved using decl will
1007  // overload; if it doesn't, we'll have to diagnose during
1008  // template instantiation.
1009  //
1010  // Exception: if the scope is dependent and this is not a class
1011  // member, the using declaration can only introduce an enumerator.
1012  if (UUD->getQualifier()->isDependent() && !UUD->isCXXClassMember()) {
1013  Match = *I;
1014  return Ovl_NonFunction;
1015  }
1016  } else {
1017  // (C++ 13p1):
1018  // Only function declarations can be overloaded; object and type
1019  // declarations cannot be overloaded.
1020  Match = *I;
1021  return Ovl_NonFunction;
1022  }
1023  }
1024 
1025  return Ovl_Overload;
1026 }
1027 
1029  bool UseMemberUsingDeclRules, bool ConsiderCudaAttrs) {
1030  // C++ [basic.start.main]p2: This function shall not be overloaded.
1031  if (New->isMain())
1032  return false;
1033 
1034  // MSVCRT user defined entry points cannot be overloaded.
1035  if (New->isMSVCRTEntryPoint())
1036  return false;
1037 
1038  FunctionTemplateDecl *OldTemplate = Old->getDescribedFunctionTemplate();
1039  FunctionTemplateDecl *NewTemplate = New->getDescribedFunctionTemplate();
1040 
1041  // C++ [temp.fct]p2:
1042  // A function template can be overloaded with other function templates
1043  // and with normal (non-template) functions.
1044  if ((OldTemplate == nullptr) != (NewTemplate == nullptr))
1045  return true;
1046 
1047  // Is the function New an overload of the function Old?
1048  QualType OldQType = Context.getCanonicalType(Old->getType());
1049  QualType NewQType = Context.getCanonicalType(New->getType());
1050 
1051  // Compare the signatures (C++ 1.3.10) of the two functions to
1052  // determine whether they are overloads. If we find any mismatch
1053  // in the signature, they are overloads.
1054 
1055  // If either of these functions is a K&R-style function (no
1056  // prototype), then we consider them to have matching signatures.
1057  if (isa<FunctionNoProtoType>(OldQType.getTypePtr()) ||
1058  isa<FunctionNoProtoType>(NewQType.getTypePtr()))
1059  return false;
1060 
1061  const FunctionProtoType *OldType = cast<FunctionProtoType>(OldQType);
1062  const FunctionProtoType *NewType = cast<FunctionProtoType>(NewQType);
1063 
1064  // The signature of a function includes the types of its
1065  // parameters (C++ 1.3.10), which includes the presence or absence
1066  // of the ellipsis; see C++ DR 357).
1067  if (OldQType != NewQType &&
1068  (OldType->getNumParams() != NewType->getNumParams() ||
1069  OldType->isVariadic() != NewType->isVariadic() ||
1070  !FunctionParamTypesAreEqual(OldType, NewType)))
1071  return true;
1072 
1073  // C++ [temp.over.link]p4:
1074  // The signature of a function template consists of its function
1075  // signature, its return type and its template parameter list. The names
1076  // of the template parameters are significant only for establishing the
1077  // relationship between the template parameters and the rest of the
1078  // signature.
1079  //
1080  // We check the return type and template parameter lists for function
1081  // templates first; the remaining checks follow.
1082  //
1083  // However, we don't consider either of these when deciding whether
1084  // a member introduced by a shadow declaration is hidden.
1085  if (!UseMemberUsingDeclRules && NewTemplate &&
1086  (!TemplateParameterListsAreEqual(NewTemplate->getTemplateParameters(),
1087  OldTemplate->getTemplateParameters(),
1088  false, TPL_TemplateMatch) ||
1089  OldType->getReturnType() != NewType->getReturnType()))
1090  return true;
1091 
1092  // If the function is a class member, its signature includes the
1093  // cv-qualifiers (if any) and ref-qualifier (if any) on the function itself.
1094  //
1095  // As part of this, also check whether one of the member functions
1096  // is static, in which case they are not overloads (C++
1097  // 13.1p2). While not part of the definition of the signature,
1098  // this check is important to determine whether these functions
1099  // can be overloaded.
1100  CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old);
1101  CXXMethodDecl *NewMethod = dyn_cast<CXXMethodDecl>(New);
1102  if (OldMethod && NewMethod &&
1103  !OldMethod->isStatic() && !NewMethod->isStatic()) {
1104  if (OldMethod->getRefQualifier() != NewMethod->getRefQualifier()) {
1105  if (!UseMemberUsingDeclRules &&
1106  (OldMethod->getRefQualifier() == RQ_None ||
1107  NewMethod->getRefQualifier() == RQ_None)) {
1108  // C++0x [over.load]p2:
1109  // - Member function declarations with the same name and the same
1110  // parameter-type-list as well as member function template
1111  // declarations with the same name, the same parameter-type-list, and
1112  // the same template parameter lists cannot be overloaded if any of
1113  // them, but not all, have a ref-qualifier (8.3.5).
1114  Diag(NewMethod->getLocation(), diag::err_ref_qualifier_overload)
1115  << NewMethod->getRefQualifier() << OldMethod->getRefQualifier();
1116  Diag(OldMethod->getLocation(), diag::note_previous_declaration);
1117  }
1118  return true;
1119  }
1120 
1121  // We may not have applied the implicit const for a constexpr member
1122  // function yet (because we haven't yet resolved whether this is a static
1123  // or non-static member function). Add it now, on the assumption that this
1124  // is a redeclaration of OldMethod.
1125  unsigned OldQuals = OldMethod->getTypeQualifiers();
1126  unsigned NewQuals = NewMethod->getTypeQualifiers();
1127  if (!getLangOpts().CPlusPlus14 && NewMethod->isConstexpr() &&
1128  !isa<CXXConstructorDecl>(NewMethod))
1129  NewQuals |= Qualifiers::Const;
1130 
1131  // We do not allow overloading based off of '__restrict'.
1132  OldQuals &= ~Qualifiers::Restrict;
1133  NewQuals &= ~Qualifiers::Restrict;
1134  if (OldQuals != NewQuals)
1135  return true;
1136  }
1137 
1138  // Though pass_object_size is placed on parameters and takes an argument, we
1139  // consider it to be a function-level modifier for the sake of function
1140  // identity. Either the function has one or more parameters with
1141  // pass_object_size or it doesn't.
1144  return true;
1145 
1146  // enable_if attributes are an order-sensitive part of the signature.
1148  NewI = New->specific_attr_begin<EnableIfAttr>(),
1149  NewE = New->specific_attr_end<EnableIfAttr>(),
1150  OldI = Old->specific_attr_begin<EnableIfAttr>(),
1151  OldE = Old->specific_attr_end<EnableIfAttr>();
1152  NewI != NewE || OldI != OldE; ++NewI, ++OldI) {
1153  if (NewI == NewE || OldI == OldE)
1154  return true;
1155  llvm::FoldingSetNodeID NewID, OldID;
1156  NewI->getCond()->Profile(NewID, Context, true);
1157  OldI->getCond()->Profile(OldID, Context, true);
1158  if (NewID != OldID)
1159  return true;
1160  }
1161 
1162  if (getLangOpts().CUDA && ConsiderCudaAttrs) {
1163  // Don't allow overloading of destructors. (In theory we could, but it
1164  // would be a giant change to clang.)
1165  if (isa<CXXDestructorDecl>(New))
1166  return false;
1167 
1168  CUDAFunctionTarget NewTarget = IdentifyCUDATarget(New),
1169  OldTarget = IdentifyCUDATarget(Old);
1170  if (NewTarget == CFT_InvalidTarget)
1171  return false;
1172 
1173  assert((OldTarget != CFT_InvalidTarget) && "Unexpected invalid target.");
1174 
1175  // Allow overloading of functions with same signature and different CUDA
1176  // target attributes.
1177  return NewTarget != OldTarget;
1178  }
1179 
1180  // The signatures match; this is not an overload.
1181  return false;
1182 }
1183 
1184 /// \brief Checks availability of the function depending on the current
1185 /// function context. Inside an unavailable function, unavailability is ignored.
1186 ///
1187 /// \returns true if \arg FD is unavailable and current context is inside
1188 /// an available function, false otherwise.
1190  if (!FD->isUnavailable())
1191  return false;
1192 
1193  // Walk up the context of the caller.
1194  Decl *C = cast<Decl>(CurContext);
1195  do {
1196  if (C->isUnavailable())
1197  return false;
1198  } while ((C = cast_or_null<Decl>(C->getDeclContext())));
1199  return true;
1200 }
1201 
1202 /// \brief Tries a user-defined conversion from From to ToType.
1203 ///
1204 /// Produces an implicit conversion sequence for when a standard conversion
1205 /// is not an option. See TryImplicitConversion for more information.
1208  bool SuppressUserConversions,
1209  bool AllowExplicit,
1210  bool InOverloadResolution,
1211  bool CStyle,
1212  bool AllowObjCWritebackConversion,
1213  bool AllowObjCConversionOnExplicit) {
1215 
1216  if (SuppressUserConversions) {
1217  // We're not in the case above, so there is no conversion that
1218  // we can perform.
1219  ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1220  return ICS;
1221  }
1222 
1223  // Attempt user-defined conversion.
1224  OverloadCandidateSet Conversions(From->getExprLoc(),
1226  switch (IsUserDefinedConversion(S, From, ToType, ICS.UserDefined,
1227  Conversions, AllowExplicit,
1228  AllowObjCConversionOnExplicit)) {
1229  case OR_Success:
1230  case OR_Deleted:
1231  ICS.setUserDefined();
1232  // C++ [over.ics.user]p4:
1233  // A conversion of an expression of class type to the same class
1234  // type is given Exact Match rank, and a conversion of an
1235  // expression of class type to a base class of that type is
1236  // given Conversion rank, in spite of the fact that a copy
1237  // constructor (i.e., a user-defined conversion function) is
1238  // called for those cases.
1239  if (CXXConstructorDecl *Constructor
1240  = dyn_cast<CXXConstructorDecl>(ICS.UserDefined.ConversionFunction)) {
1241  QualType FromCanon
1243  QualType ToCanon
1245  if (Constructor->isCopyConstructor() &&
1246  (FromCanon == ToCanon ||
1247  S.IsDerivedFrom(From->getLocStart(), FromCanon, ToCanon))) {
1248  // Turn this into a "standard" conversion sequence, so that it
1249  // gets ranked with standard conversion sequences.
1251  ICS.setStandard();
1253  ICS.Standard.setFromType(From->getType());
1254  ICS.Standard.setAllToTypes(ToType);
1255  ICS.Standard.CopyConstructor = Constructor;
1256  ICS.Standard.FoundCopyConstructor = Found;
1257  if (ToCanon != FromCanon)
1259  }
1260  }
1261  break;
1262 
1263  case OR_Ambiguous:
1264  ICS.setAmbiguous();
1265  ICS.Ambiguous.setFromType(From->getType());
1266  ICS.Ambiguous.setToType(ToType);
1267  for (OverloadCandidateSet::iterator Cand = Conversions.begin();
1268  Cand != Conversions.end(); ++Cand)
1269  if (Cand->Viable)
1270  ICS.Ambiguous.addConversion(Cand->FoundDecl, Cand->Function);
1271  break;
1272 
1273  // Fall through.
1274  case OR_No_Viable_Function:
1275  ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1276  break;
1277  }
1278 
1279  return ICS;
1280 }
1281 
1282 /// TryImplicitConversion - Attempt to perform an implicit conversion
1283 /// from the given expression (Expr) to the given type (ToType). This
1284 /// function returns an implicit conversion sequence that can be used
1285 /// to perform the initialization. Given
1286 ///
1287 /// void f(float f);
1288 /// void g(int i) { f(i); }
1289 ///
1290 /// this routine would produce an implicit conversion sequence to
1291 /// describe the initialization of f from i, which will be a standard
1292 /// conversion sequence containing an lvalue-to-rvalue conversion (C++
1293 /// 4.1) followed by a floating-integral conversion (C++ 4.9).
1294 //
1295 /// Note that this routine only determines how the conversion can be
1296 /// performed; it does not actually perform the conversion. As such,
1297 /// it will not produce any diagnostics if no conversion is available,
1298 /// but will instead return an implicit conversion sequence of kind
1299 /// "BadConversion".
1300 ///
1301 /// If @p SuppressUserConversions, then user-defined conversions are
1302 /// not permitted.
1303 /// If @p AllowExplicit, then explicit user-defined conversions are
1304 /// permitted.
1305 ///
1306 /// \param AllowObjCWritebackConversion Whether we allow the Objective-C
1307 /// writeback conversion, which allows __autoreleasing id* parameters to
1308 /// be initialized with __strong id* or __weak id* arguments.
1311  bool SuppressUserConversions,
1312  bool AllowExplicit,
1313  bool InOverloadResolution,
1314  bool CStyle,
1315  bool AllowObjCWritebackConversion,
1316  bool AllowObjCConversionOnExplicit) {
1318  if (IsStandardConversion(S, From, ToType, InOverloadResolution,
1319  ICS.Standard, CStyle, AllowObjCWritebackConversion)){
1320  ICS.setStandard();
1321  return ICS;
1322  }
1323 
1324  if (!S.getLangOpts().CPlusPlus) {
1325  ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1326  return ICS;
1327  }
1328 
1329  // C++ [over.ics.user]p4:
1330  // A conversion of an expression of class type to the same class
1331  // type is given Exact Match rank, and a conversion of an
1332  // expression of class type to a base class of that type is
1333  // given Conversion rank, in spite of the fact that a copy/move
1334  // constructor (i.e., a user-defined conversion function) is
1335  // called for those cases.
1336  QualType FromType = From->getType();
1337  if (ToType->getAs<RecordType>() && FromType->getAs<RecordType>() &&
1338  (S.Context.hasSameUnqualifiedType(FromType, ToType) ||
1339  S.IsDerivedFrom(From->getLocStart(), FromType, ToType))) {
1340  ICS.setStandard();
1342  ICS.Standard.setFromType(FromType);
1343  ICS.Standard.setAllToTypes(ToType);
1344 
1345  // We don't actually check at this point whether there is a valid
1346  // copy/move constructor, since overloading just assumes that it
1347  // exists. When we actually perform initialization, we'll find the
1348  // appropriate constructor to copy the returned object, if needed.
1349  ICS.Standard.CopyConstructor = nullptr;
1350 
1351  // Determine whether this is considered a derived-to-base conversion.
1352  if (!S.Context.hasSameUnqualifiedType(FromType, ToType))
1354 
1355  return ICS;
1356  }
1357 
1358  return TryUserDefinedConversion(S, From, ToType, SuppressUserConversions,
1359  AllowExplicit, InOverloadResolution, CStyle,
1360  AllowObjCWritebackConversion,
1361  AllowObjCConversionOnExplicit);
1362 }
1363 
1366  bool SuppressUserConversions,
1367  bool AllowExplicit,
1368  bool InOverloadResolution,
1369  bool CStyle,
1370  bool AllowObjCWritebackConversion) {
1371  return ::TryImplicitConversion(*this, From, ToType,
1372  SuppressUserConversions, AllowExplicit,
1373  InOverloadResolution, CStyle,
1374  AllowObjCWritebackConversion,
1375  /*AllowObjCConversionOnExplicit=*/false);
1376 }
1377 
1378 /// PerformImplicitConversion - Perform an implicit conversion of the
1379 /// expression From to the type ToType. Returns the
1380 /// converted expression. Flavor is the kind of conversion we're
1381 /// performing, used in the error message. If @p AllowExplicit,
1382 /// explicit user-defined conversions are permitted.
1383 ExprResult
1385  AssignmentAction Action, bool AllowExplicit) {
1387  return PerformImplicitConversion(From, ToType, Action, AllowExplicit, ICS);
1388 }
1389 
1390 ExprResult
1392  AssignmentAction Action, bool AllowExplicit,
1394  if (checkPlaceholderForOverload(*this, From))
1395  return ExprError();
1396 
1397  // Objective-C ARC: Determine whether we will allow the writeback conversion.
1398  bool AllowObjCWritebackConversion
1399  = getLangOpts().ObjCAutoRefCount &&
1400  (Action == AA_Passing || Action == AA_Sending);
1401  if (getLangOpts().ObjC1)
1402  CheckObjCBridgeRelatedConversions(From->getLocStart(),
1403  ToType, From->getType(), From);
1404  ICS = ::TryImplicitConversion(*this, From, ToType,
1405  /*SuppressUserConversions=*/false,
1406  AllowExplicit,
1407  /*InOverloadResolution=*/false,
1408  /*CStyle=*/false,
1409  AllowObjCWritebackConversion,
1410  /*AllowObjCConversionOnExplicit=*/false);
1411  return PerformImplicitConversion(From, ToType, ICS, Action);
1412 }
1413 
1414 /// \brief Determine whether the conversion from FromType to ToType is a valid
1415 /// conversion that strips "noexcept" or "noreturn" off the nested function
1416 /// type.
1418  QualType &ResultTy) {
1419  if (Context.hasSameUnqualifiedType(FromType, ToType))
1420  return false;
1421 
1422  // Permit the conversion F(t __attribute__((noreturn))) -> F(t)
1423  // or F(t noexcept) -> F(t)
1424  // where F adds one of the following at most once:
1425  // - a pointer
1426  // - a member pointer
1427  // - a block pointer
1428  // Changes here need matching changes in FindCompositePointerType.
1429  CanQualType CanTo = Context.getCanonicalType(ToType);
1430  CanQualType CanFrom = Context.getCanonicalType(FromType);
1431  Type::TypeClass TyClass = CanTo->getTypeClass();
1432  if (TyClass != CanFrom->getTypeClass()) return false;
1433  if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto) {
1434  if (TyClass == Type::Pointer) {
1435  CanTo = CanTo.getAs<PointerType>()->getPointeeType();
1436  CanFrom = CanFrom.getAs<PointerType>()->getPointeeType();
1437  } else if (TyClass == Type::BlockPointer) {
1438  CanTo = CanTo.getAs<BlockPointerType>()->getPointeeType();
1439  CanFrom = CanFrom.getAs<BlockPointerType>()->getPointeeType();
1440  } else if (TyClass == Type::MemberPointer) {
1441  auto ToMPT = CanTo.getAs<MemberPointerType>();
1442  auto FromMPT = CanFrom.getAs<MemberPointerType>();
1443  // A function pointer conversion cannot change the class of the function.
1444  if (ToMPT->getClass() != FromMPT->getClass())
1445  return false;
1446  CanTo = ToMPT->getPointeeType();
1447  CanFrom = FromMPT->getPointeeType();
1448  } else {
1449  return false;
1450  }
1451 
1452  TyClass = CanTo->getTypeClass();
1453  if (TyClass != CanFrom->getTypeClass()) return false;
1454  if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto)
1455  return false;
1456  }
1457 
1458  const auto *FromFn = cast<FunctionType>(CanFrom);
1459  FunctionType::ExtInfo FromEInfo = FromFn->getExtInfo();
1460 
1461  const auto *ToFn = cast<FunctionType>(CanTo);
1462  FunctionType::ExtInfo ToEInfo = ToFn->getExtInfo();
1463 
1464  bool Changed = false;
1465 
1466  // Drop 'noreturn' if not present in target type.
1467  if (FromEInfo.getNoReturn() && !ToEInfo.getNoReturn()) {
1468  FromFn = Context.adjustFunctionType(FromFn, FromEInfo.withNoReturn(false));
1469  Changed = true;
1470  }
1471 
1472  // Drop 'noexcept' if not present in target type.
1473  if (const auto *FromFPT = dyn_cast<FunctionProtoType>(FromFn)) {
1474  const auto *ToFPT = cast<FunctionProtoType>(ToFn);
1475  if (FromFPT->isNothrow(Context) && !ToFPT->isNothrow(Context)) {
1476  FromFn = cast<FunctionType>(
1477  Context.getFunctionType(FromFPT->getReturnType(),
1478  FromFPT->getParamTypes(),
1479  FromFPT->getExtProtoInfo().withExceptionSpec(
1481  .getTypePtr());
1482  Changed = true;
1483  }
1484  }
1485 
1486  if (!Changed)
1487  return false;
1488 
1489  assert(QualType(FromFn, 0).isCanonical());
1490  if (QualType(FromFn, 0) != CanTo) return false;
1491 
1492  ResultTy = ToType;
1493  return true;
1494 }
1495 
1496 /// \brief Determine whether the conversion from FromType to ToType is a valid
1497 /// vector conversion.
1498 ///
1499 /// \param ICK Will be set to the vector conversion kind, if this is a vector
1500 /// conversion.
1501 static bool IsVectorConversion(Sema &S, QualType FromType,
1502  QualType ToType, ImplicitConversionKind &ICK) {
1503  // We need at least one of these types to be a vector type to have a vector
1504  // conversion.
1505  if (!ToType->isVectorType() && !FromType->isVectorType())
1506  return false;
1507 
1508  // Identical types require no conversions.
1509  if (S.Context.hasSameUnqualifiedType(FromType, ToType))
1510  return false;
1511 
1512  // There are no conversions between extended vector types, only identity.
1513  if (ToType->isExtVectorType()) {
1514  // There are no conversions between extended vector types other than the
1515  // identity conversion.
1516  if (FromType->isExtVectorType())
1517  return false;
1518 
1519  // Vector splat from any arithmetic type to a vector.
1520  if (FromType->isArithmeticType()) {
1521  ICK = ICK_Vector_Splat;
1522  return true;
1523  }
1524  }
1525 
1526  // We can perform the conversion between vector types in the following cases:
1527  // 1)vector types are equivalent AltiVec and GCC vector types
1528  // 2)lax vector conversions are permitted and the vector types are of the
1529  // same size
1530  if (ToType->isVectorType() && FromType->isVectorType()) {
1531  if (S.Context.areCompatibleVectorTypes(FromType, ToType) ||
1532  S.isLaxVectorConversion(FromType, ToType)) {
1533  ICK = ICK_Vector_Conversion;
1534  return true;
1535  }
1536  }
1537 
1538  return false;
1539 }
1540 
1541 static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType,
1542  bool InOverloadResolution,
1544  bool CStyle);
1545 
1546 /// IsStandardConversion - Determines whether there is a standard
1547 /// conversion sequence (C++ [conv], C++ [over.ics.scs]) from the
1548 /// expression From to the type ToType. Standard conversion sequences
1549 /// only consider non-class types; for conversions that involve class
1550 /// types, use TryImplicitConversion. If a conversion exists, SCS will
1551 /// contain the standard conversion sequence required to perform this
1552 /// conversion and this routine will return true. Otherwise, this
1553 /// routine will return false and the value of SCS is unspecified.
1554 static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
1555  bool InOverloadResolution,
1557  bool CStyle,
1558  bool AllowObjCWritebackConversion) {
1559  QualType FromType = From->getType();
1560 
1561  // Standard conversions (C++ [conv])
1563  SCS.IncompatibleObjC = false;
1564  SCS.setFromType(FromType);
1565  SCS.CopyConstructor = nullptr;
1566 
1567  // There are no standard conversions for class types in C++, so
1568  // abort early. When overloading in C, however, we do permit them.
1569  if (S.getLangOpts().CPlusPlus &&
1570  (FromType->isRecordType() || ToType->isRecordType()))
1571  return false;
1572 
1573  // The first conversion can be an lvalue-to-rvalue conversion,
1574  // array-to-pointer conversion, or function-to-pointer conversion
1575  // (C++ 4p1).
1576 
1577  if (FromType == S.Context.OverloadTy) {
1578  DeclAccessPair AccessPair;
1579  if (FunctionDecl *Fn
1580  = S.ResolveAddressOfOverloadedFunction(From, ToType, false,
1581  AccessPair)) {
1582  // We were able to resolve the address of the overloaded function,
1583  // so we can convert to the type of that function.
1584  FromType = Fn->getType();
1585  SCS.setFromType(FromType);
1586 
1587  // we can sometimes resolve &foo<int> regardless of ToType, so check
1588  // if the type matches (identity) or we are converting to bool
1590  S.ExtractUnqualifiedFunctionType(ToType), FromType)) {
1591  QualType resultTy;
1592  // if the function type matches except for [[noreturn]], it's ok
1593  if (!S.IsFunctionConversion(FromType,
1594  S.ExtractUnqualifiedFunctionType(ToType), resultTy))
1595  // otherwise, only a boolean conversion is standard
1596  if (!ToType->isBooleanType())
1597  return false;
1598  }
1599 
1600  // Check if the "from" expression is taking the address of an overloaded
1601  // function and recompute the FromType accordingly. Take advantage of the
1602  // fact that non-static member functions *must* have such an address-of
1603  // expression.
1604  CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn);
1605  if (Method && !Method->isStatic()) {
1606  assert(isa<UnaryOperator>(From->IgnoreParens()) &&
1607  "Non-unary operator on non-static member address");
1608  assert(cast<UnaryOperator>(From->IgnoreParens())->getOpcode()
1609  == UO_AddrOf &&
1610  "Non-address-of operator on non-static member address");
1611  const Type *ClassType
1612  = S.Context.getTypeDeclType(Method->getParent()).getTypePtr();
1613  FromType = S.Context.getMemberPointerType(FromType, ClassType);
1614  } else if (isa<UnaryOperator>(From->IgnoreParens())) {
1615  assert(cast<UnaryOperator>(From->IgnoreParens())->getOpcode() ==
1616  UO_AddrOf &&
1617  "Non-address-of operator for overloaded function expression");
1618  FromType = S.Context.getPointerType(FromType);
1619  }
1620 
1621  // Check that we've computed the proper type after overload resolution.
1622  // FIXME: FixOverloadedFunctionReference has side-effects; we shouldn't
1623  // be calling it from within an NDEBUG block.
1624  assert(S.Context.hasSameType(
1625  FromType,
1626  S.FixOverloadedFunctionReference(From, AccessPair, Fn)->getType()));
1627  } else {
1628  return false;
1629  }
1630  }
1631  // Lvalue-to-rvalue conversion (C++11 4.1):
1632  // A glvalue (3.10) of a non-function, non-array type T can
1633  // be converted to a prvalue.
1634  bool argIsLValue = From->isGLValue();
1635  if (argIsLValue &&
1636  !FromType->isFunctionType() && !FromType->isArrayType() &&
1637  S.Context.getCanonicalType(FromType) != S.Context.OverloadTy) {
1639 
1640  // C11 6.3.2.1p2:
1641  // ... if the lvalue has atomic type, the value has the non-atomic version
1642  // of the type of the lvalue ...
1643  if (const AtomicType *Atomic = FromType->getAs<AtomicType>())
1644  FromType = Atomic->getValueType();
1645 
1646  // If T is a non-class type, the type of the rvalue is the
1647  // cv-unqualified version of T. Otherwise, the type of the rvalue
1648  // is T (C++ 4.1p1). C++ can't get here with class types; in C, we
1649  // just strip the qualifiers because they don't matter.
1650  FromType = FromType.getUnqualifiedType();
1651  } else if (FromType->isArrayType()) {
1652  // Array-to-pointer conversion (C++ 4.2)
1654 
1655  // An lvalue or rvalue of type "array of N T" or "array of unknown
1656  // bound of T" can be converted to an rvalue of type "pointer to
1657  // T" (C++ 4.2p1).
1658  FromType = S.Context.getArrayDecayedType(FromType);
1659 
1660  if (S.IsStringLiteralToNonConstPointerConversion(From, ToType)) {
1661  // This conversion is deprecated in C++03 (D.4)
1663 
1664  // For the purpose of ranking in overload resolution
1665  // (13.3.3.1.1), this conversion is considered an
1666  // array-to-pointer conversion followed by a qualification
1667  // conversion (4.4). (C++ 4.2p2)
1668  SCS.Second = ICK_Identity;
1669  SCS.Third = ICK_Qualification;
1671  SCS.setAllToTypes(FromType);
1672  return true;
1673  }
1674  } else if (FromType->isFunctionType() && argIsLValue) {
1675  // Function-to-pointer conversion (C++ 4.3).
1677 
1678  if (auto *DRE = dyn_cast<DeclRefExpr>(From->IgnoreParenCasts()))
1679  if (auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl()))
1681  return false;
1682 
1683  // An lvalue of function type T can be converted to an rvalue of
1684  // type "pointer to T." The result is a pointer to the
1685  // function. (C++ 4.3p1).
1686  FromType = S.Context.getPointerType(FromType);
1687  } else {
1688  // We don't require any conversions for the first step.
1689  SCS.First = ICK_Identity;
1690  }
1691  SCS.setToType(0, FromType);
1692 
1693  // The second conversion can be an integral promotion, floating
1694  // point promotion, integral conversion, floating point conversion,
1695  // floating-integral conversion, pointer conversion,
1696  // pointer-to-member conversion, or boolean conversion (C++ 4p1).
1697  // For overloading in C, this can also be a "compatible-type"
1698  // conversion.
1699  bool IncompatibleObjC = false;
1701  if (S.Context.hasSameUnqualifiedType(FromType, ToType)) {
1702  // The unqualified versions of the types are the same: there's no
1703  // conversion to do.
1704  SCS.Second = ICK_Identity;
1705  } else if (S.IsIntegralPromotion(From, FromType, ToType)) {
1706  // Integral promotion (C++ 4.5).
1708  FromType = ToType.getUnqualifiedType();
1709  } else if (S.IsFloatingPointPromotion(FromType, ToType)) {
1710  // Floating point promotion (C++ 4.6).
1712  FromType = ToType.getUnqualifiedType();
1713  } else if (S.IsComplexPromotion(FromType, ToType)) {
1714  // Complex promotion (Clang extension)
1716  FromType = ToType.getUnqualifiedType();
1717  } else if (ToType->isBooleanType() &&
1718  (FromType->isArithmeticType() ||
1719  FromType->isAnyPointerType() ||
1720  FromType->isBlockPointerType() ||
1721  FromType->isMemberPointerType() ||
1722  FromType->isNullPtrType())) {
1723  // Boolean conversions (C++ 4.12).
1725  FromType = S.Context.BoolTy;
1726  } else if (FromType->isIntegralOrUnscopedEnumerationType() &&
1727  ToType->isIntegralType(S.Context)) {
1728  // Integral conversions (C++ 4.7).
1730  FromType = ToType.getUnqualifiedType();
1731  } else if (FromType->isAnyComplexType() && ToType->isAnyComplexType()) {
1732  // Complex conversions (C99 6.3.1.6)
1734  FromType = ToType.getUnqualifiedType();
1735  } else if ((FromType->isAnyComplexType() && ToType->isArithmeticType()) ||
1736  (ToType->isAnyComplexType() && FromType->isArithmeticType())) {
1737  // Complex-real conversions (C99 6.3.1.7)
1738  SCS.Second = ICK_Complex_Real;
1739  FromType = ToType.getUnqualifiedType();
1740  } else if (FromType->isRealFloatingType() && ToType->isRealFloatingType()) {
1741  // FIXME: disable conversions between long double and __float128 if
1742  // their representation is different until there is back end support
1743  // We of course allow this conversion if long double is really double.
1744  if (&S.Context.getFloatTypeSemantics(FromType) !=
1745  &S.Context.getFloatTypeSemantics(ToType)) {
1746  bool Float128AndLongDouble = ((FromType == S.Context.Float128Ty &&
1747  ToType == S.Context.LongDoubleTy) ||
1748  (FromType == S.Context.LongDoubleTy &&
1749  ToType == S.Context.Float128Ty));
1750  if (Float128AndLongDouble &&
1752  &llvm::APFloat::IEEEdouble()))
1753  return false;
1754  }
1755  // Floating point conversions (C++ 4.8).
1757  FromType = ToType.getUnqualifiedType();
1758  } else if ((FromType->isRealFloatingType() &&
1759  ToType->isIntegralType(S.Context)) ||
1760  (FromType->isIntegralOrUnscopedEnumerationType() &&
1761  ToType->isRealFloatingType())) {
1762  // Floating-integral conversions (C++ 4.9).
1764  FromType = ToType.getUnqualifiedType();
1765  } else if (S.IsBlockPointerConversion(FromType, ToType, FromType)) {
1767  } else if (AllowObjCWritebackConversion &&
1768  S.isObjCWritebackConversion(FromType, ToType, FromType)) {
1770  } else if (S.IsPointerConversion(From, FromType, ToType, InOverloadResolution,
1771  FromType, IncompatibleObjC)) {
1772  // Pointer conversions (C++ 4.10).
1774  SCS.IncompatibleObjC = IncompatibleObjC;
1775  FromType = FromType.getUnqualifiedType();
1776  } else if (S.IsMemberPointerConversion(From, FromType, ToType,
1777  InOverloadResolution, FromType)) {
1778  // Pointer to member conversions (4.11).
1779  SCS.Second = ICK_Pointer_Member;
1780  } else if (IsVectorConversion(S, FromType, ToType, SecondICK)) {
1781  SCS.Second = SecondICK;
1782  FromType = ToType.getUnqualifiedType();
1783  } else if (!S.getLangOpts().CPlusPlus &&
1784  S.Context.typesAreCompatible(ToType, FromType)) {
1785  // Compatible conversions (Clang extension for C function overloading)
1787  FromType = ToType.getUnqualifiedType();
1788  } else if (IsTransparentUnionStandardConversion(S, From, ToType,
1789  InOverloadResolution,
1790  SCS, CStyle)) {
1792  FromType = ToType;
1793  } else if (tryAtomicConversion(S, From, ToType, InOverloadResolution, SCS,
1794  CStyle)) {
1795  // tryAtomicConversion has updated the standard conversion sequence
1796  // appropriately.
1797  return true;
1798  } else if (ToType->isEventT() &&
1799  From->isIntegerConstantExpr(S.getASTContext()) &&
1800  From->EvaluateKnownConstInt(S.getASTContext()) == 0) {
1802  FromType = ToType;
1803  } else if (ToType->isQueueT() &&
1804  From->isIntegerConstantExpr(S.getASTContext()) &&
1805  (From->EvaluateKnownConstInt(S.getASTContext()) == 0)) {
1807  FromType = ToType;
1808  } else {
1809  // No second conversion required.
1810  SCS.Second = ICK_Identity;
1811  }
1812  SCS.setToType(1, FromType);
1813 
1814  // The third conversion can be a function pointer conversion or a
1815  // qualification conversion (C++ [conv.fctptr], [conv.qual]).
1816  bool ObjCLifetimeConversion;
1817  if (S.IsFunctionConversion(FromType, ToType, FromType)) {
1818  // Function pointer conversions (removing 'noexcept') including removal of
1819  // 'noreturn' (Clang extension).
1821  } else if (S.IsQualificationConversion(FromType, ToType, CStyle,
1822  ObjCLifetimeConversion)) {
1823  SCS.Third = ICK_Qualification;
1824  SCS.QualificationIncludesObjCLifetime = ObjCLifetimeConversion;
1825  FromType = ToType;
1826  } else {
1827  // No conversion required
1828  SCS.Third = ICK_Identity;
1829  }
1830 
1831  // C++ [over.best.ics]p6:
1832  // [...] Any difference in top-level cv-qualification is
1833  // subsumed by the initialization itself and does not constitute
1834  // a conversion. [...]
1835  QualType CanonFrom = S.Context.getCanonicalType(FromType);
1836  QualType CanonTo = S.Context.getCanonicalType(ToType);
1837  if (CanonFrom.getLocalUnqualifiedType()
1838  == CanonTo.getLocalUnqualifiedType() &&
1839  CanonFrom.getLocalQualifiers() != CanonTo.getLocalQualifiers()) {
1840  FromType = ToType;
1841  CanonFrom = CanonTo;
1842  }
1843 
1844  SCS.setToType(2, FromType);
1845 
1846  if (CanonFrom == CanonTo)
1847  return true;
1848 
1849  // If we have not converted the argument type to the parameter type,
1850  // this is a bad conversion sequence, unless we're resolving an overload in C.
1851  if (S.getLangOpts().CPlusPlus || !InOverloadResolution)
1852  return false;
1853 
1854  ExprResult ER = ExprResult{From};
1856  S.CheckSingleAssignmentConstraints(ToType, ER,
1857  /*Diagnose=*/false,
1858  /*DiagnoseCFAudited=*/false,
1859  /*ConvertRHS=*/false);
1860  ImplicitConversionKind SecondConv;
1861  switch (Conv) {
1862  case Sema::Compatible:
1863  SecondConv = ICK_C_Only_Conversion;
1864  break;
1865  // For our purposes, discarding qualifiers is just as bad as using an
1866  // incompatible pointer. Note that an IncompatiblePointer conversion can drop
1867  // qualifiers, as well.
1872  break;
1873  default:
1874  return false;
1875  }
1876 
1877  // First can only be an lvalue conversion, so we pretend that this was the
1878  // second conversion. First should already be valid from earlier in the
1879  // function.
1880  SCS.Second = SecondConv;
1881  SCS.setToType(1, ToType);
1882 
1883  // Third is Identity, because Second should rank us worse than any other
1884  // conversion. This could also be ICK_Qualification, but it's simpler to just
1885  // lump everything in with the second conversion, and we don't gain anything
1886  // from making this ICK_Qualification.
1887  SCS.Third = ICK_Identity;
1888  SCS.setToType(2, ToType);
1889  return true;
1890 }
1891 
1892 static bool
1894  QualType &ToType,
1895  bool InOverloadResolution,
1897  bool CStyle) {
1898 
1899  const RecordType *UT = ToType->getAsUnionType();
1900  if (!UT || !UT->getDecl()->hasAttr<TransparentUnionAttr>())
1901  return false;
1902  // The field to initialize within the transparent union.
1903  RecordDecl *UD = UT->getDecl();
1904  // It's compatible if the expression matches any of the fields.
1905  for (const auto *it : UD->fields()) {
1906  if (IsStandardConversion(S, From, it->getType(), InOverloadResolution, SCS,
1907  CStyle, /*ObjCWritebackConversion=*/false)) {
1908  ToType = it->getType();
1909  return true;
1910  }
1911  }
1912  return false;
1913 }
1914 
1915 /// IsIntegralPromotion - Determines whether the conversion from the
1916 /// expression From (whose potentially-adjusted type is FromType) to
1917 /// ToType is an integral promotion (C++ 4.5). If so, returns true and
1918 /// sets PromotedType to the promoted type.
1919 bool Sema::IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType) {
1920  const BuiltinType *To = ToType->getAs<BuiltinType>();
1921  // All integers are built-in.
1922  if (!To) {
1923  return false;
1924  }
1925 
1926  // An rvalue of type char, signed char, unsigned char, short int, or
1927  // unsigned short int can be converted to an rvalue of type int if
1928  // int can represent all the values of the source type; otherwise,
1929  // the source rvalue can be converted to an rvalue of type unsigned
1930  // int (C++ 4.5p1).
1931  if (FromType->isPromotableIntegerType() && !FromType->isBooleanType() &&
1932  !FromType->isEnumeralType()) {
1933  if (// We can promote any signed, promotable integer type to an int
1934  (FromType->isSignedIntegerType() ||
1935  // We can promote any unsigned integer type whose size is
1936  // less than int to an int.
1937  Context.getTypeSize(FromType) < Context.getTypeSize(ToType))) {
1938  return To->getKind() == BuiltinType::Int;
1939  }
1940 
1941  return To->getKind() == BuiltinType::UInt;
1942  }
1943 
1944  // C++11 [conv.prom]p3:
1945  // A prvalue of an unscoped enumeration type whose underlying type is not
1946  // fixed (7.2) can be converted to an rvalue a prvalue of the first of the
1947  // following types that can represent all the values of the enumeration
1948  // (i.e., the values in the range bmin to bmax as described in 7.2): int,
1949  // unsigned int, long int, unsigned long int, long long int, or unsigned
1950  // long long int. If none of the types in that list can represent all the
1951  // values of the enumeration, an rvalue a prvalue of an unscoped enumeration
1952  // type can be converted to an rvalue a prvalue of the extended integer type
1953  // with lowest integer conversion rank (4.13) greater than the rank of long
1954  // long in which all the values of the enumeration can be represented. If
1955  // there are two such extended types, the signed one is chosen.
1956  // C++11 [conv.prom]p4:
1957  // A prvalue of an unscoped enumeration type whose underlying type is fixed
1958  // can be converted to a prvalue of its underlying type. Moreover, if
1959  // integral promotion can be applied to its underlying type, a prvalue of an
1960  // unscoped enumeration type whose underlying type is fixed can also be
1961  // converted to a prvalue of the promoted underlying type.
1962  if (const EnumType *FromEnumType = FromType->getAs<EnumType>()) {
1963  // C++0x 7.2p9: Note that this implicit enum to int conversion is not
1964  // provided for a scoped enumeration.
1965  if (FromEnumType->getDecl()->isScoped())
1966  return false;
1967 
1968  // We can perform an integral promotion to the underlying type of the enum,
1969  // even if that's not the promoted type. Note that the check for promoting
1970  // the underlying type is based on the type alone, and does not consider
1971  // the bitfield-ness of the actual source expression.
1972  if (FromEnumType->getDecl()->isFixed()) {
1973  QualType Underlying = FromEnumType->getDecl()->getIntegerType();
1974  return Context.hasSameUnqualifiedType(Underlying, ToType) ||
1975  IsIntegralPromotion(nullptr, Underlying, ToType);
1976  }
1977 
1978  // We have already pre-calculated the promotion type, so this is trivial.
1979  if (ToType->isIntegerType() &&
1980  isCompleteType(From->getLocStart(), FromType))
1982  ToType, FromEnumType->getDecl()->getPromotionType());
1983  }
1984 
1985  // C++0x [conv.prom]p2:
1986  // A prvalue of type char16_t, char32_t, or wchar_t (3.9.1) can be converted
1987  // to an rvalue a prvalue of the first of the following types that can
1988  // represent all the values of its underlying type: int, unsigned int,
1989  // long int, unsigned long int, long long int, or unsigned long long int.
1990  // If none of the types in that list can represent all the values of its
1991  // underlying type, an rvalue a prvalue of type char16_t, char32_t,
1992  // or wchar_t can be converted to an rvalue a prvalue of its underlying
1993  // type.
1994  if (FromType->isAnyCharacterType() && !FromType->isCharType() &&
1995  ToType->isIntegerType()) {
1996  // Determine whether the type we're converting from is signed or
1997  // unsigned.
1998  bool FromIsSigned = FromType->isSignedIntegerType();
1999  uint64_t FromSize = Context.getTypeSize(FromType);
2000 
2001  // The types we'll try to promote to, in the appropriate
2002  // order. Try each of these types.
2003  QualType PromoteTypes[6] = {
2007  };
2008  for (int Idx = 0; Idx < 6; ++Idx) {
2009  uint64_t ToSize = Context.getTypeSize(PromoteTypes[Idx]);
2010  if (FromSize < ToSize ||
2011  (FromSize == ToSize &&
2012  FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType())) {
2013  // We found the type that we can promote to. If this is the
2014  // type we wanted, we have a promotion. Otherwise, no
2015  // promotion.
2016  return Context.hasSameUnqualifiedType(ToType, PromoteTypes[Idx]);
2017  }
2018  }
2019  }
2020 
2021  // An rvalue for an integral bit-field (9.6) can be converted to an
2022  // rvalue of type int if int can represent all the values of the
2023  // bit-field; otherwise, it can be converted to unsigned int if
2024  // unsigned int can represent all the values of the bit-field. If
2025  // the bit-field is larger yet, no integral promotion applies to
2026  // it. If the bit-field has an enumerated type, it is treated as any
2027  // other value of that type for promotion purposes (C++ 4.5p3).
2028  // FIXME: We should delay checking of bit-fields until we actually perform the
2029  // conversion.
2030  if (From) {
2031  if (FieldDecl *MemberDecl = From->getSourceBitField()) {
2032  llvm::APSInt BitWidth;
2033  if (FromType->isIntegralType(Context) &&
2034  MemberDecl->getBitWidth()->isIntegerConstantExpr(BitWidth, Context)) {
2035  llvm::APSInt ToSize(BitWidth.getBitWidth(), BitWidth.isUnsigned());
2036  ToSize = Context.getTypeSize(ToType);
2037 
2038  // Are we promoting to an int from a bitfield that fits in an int?
2039  if (BitWidth < ToSize ||
2040  (FromType->isSignedIntegerType() && BitWidth <= ToSize)) {
2041  return To->getKind() == BuiltinType::Int;
2042  }
2043 
2044  // Are we promoting to an unsigned int from an unsigned bitfield
2045  // that fits into an unsigned int?
2046  if (FromType->isUnsignedIntegerType() && BitWidth <= ToSize) {
2047  return To->getKind() == BuiltinType::UInt;
2048  }
2049 
2050  return false;
2051  }
2052  }
2053  }
2054 
2055  // An rvalue of type bool can be converted to an rvalue of type int,
2056  // with false becoming zero and true becoming one (C++ 4.5p4).
2057  if (FromType->isBooleanType() && To->getKind() == BuiltinType::Int) {
2058  return true;
2059  }
2060 
2061  return false;
2062 }
2063 
2064 /// IsFloatingPointPromotion - Determines whether the conversion from
2065 /// FromType to ToType is a floating point promotion (C++ 4.6). If so,
2066 /// returns true and sets PromotedType to the promoted type.
2068  if (const BuiltinType *FromBuiltin = FromType->getAs<BuiltinType>())
2069  if (const BuiltinType *ToBuiltin = ToType->getAs<BuiltinType>()) {
2070  /// An rvalue of type float can be converted to an rvalue of type
2071  /// double. (C++ 4.6p1).
2072  if (FromBuiltin->getKind() == BuiltinType::Float &&
2073  ToBuiltin->getKind() == BuiltinType::Double)
2074  return true;
2075 
2076  // C99 6.3.1.5p1:
2077  // When a float is promoted to double or long double, or a
2078  // double is promoted to long double [...].
2079  if (!getLangOpts().CPlusPlus &&
2080  (FromBuiltin->getKind() == BuiltinType::Float ||
2081  FromBuiltin->getKind() == BuiltinType::Double) &&
2082  (ToBuiltin->getKind() == BuiltinType::LongDouble ||
2083  ToBuiltin->getKind() == BuiltinType::Float128))
2084  return true;
2085 
2086  // Half can be promoted to float.
2087  if (!getLangOpts().NativeHalfType &&
2088  FromBuiltin->getKind() == BuiltinType::Half &&
2089  ToBuiltin->getKind() == BuiltinType::Float)
2090  return true;
2091  }
2092 
2093  return false;
2094 }
2095 
2096 /// \brief Determine if a conversion is a complex promotion.
2097 ///
2098 /// A complex promotion is defined as a complex -> complex conversion
2099 /// where the conversion between the underlying real types is a
2100 /// floating-point or integral promotion.
2102  const ComplexType *FromComplex = FromType->getAs<ComplexType>();
2103  if (!FromComplex)
2104  return false;
2105 
2106  const ComplexType *ToComplex = ToType->getAs<ComplexType>();
2107  if (!ToComplex)
2108  return false;
2109 
2110  return IsFloatingPointPromotion(FromComplex->getElementType(),
2111  ToComplex->getElementType()) ||
2112  IsIntegralPromotion(nullptr, FromComplex->getElementType(),
2113  ToComplex->getElementType());
2114 }
2115 
2116 /// BuildSimilarlyQualifiedPointerType - In a pointer conversion from
2117 /// the pointer type FromPtr to a pointer to type ToPointee, with the
2118 /// same type qualifiers as FromPtr has on its pointee type. ToType,
2119 /// if non-empty, will be a pointer to ToType that may or may not have
2120 /// the right set of qualifiers on its pointee.
2121 ///
2122 static QualType
2124  QualType ToPointee, QualType ToType,
2126  bool StripObjCLifetime = false) {
2127  assert((FromPtr->getTypeClass() == Type::Pointer ||
2128  FromPtr->getTypeClass() == Type::ObjCObjectPointer) &&
2129  "Invalid similarly-qualified pointer type");
2130 
2131  /// Conversions to 'id' subsume cv-qualifier conversions.
2132  if (ToType->isObjCIdType() || ToType->isObjCQualifiedIdType())
2133  return ToType.getUnqualifiedType();
2134 
2135  QualType CanonFromPointee
2136  = Context.getCanonicalType(FromPtr->getPointeeType());
2137  QualType CanonToPointee = Context.getCanonicalType(ToPointee);
2138  Qualifiers Quals = CanonFromPointee.getQualifiers();
2139 
2140  if (StripObjCLifetime)
2141  Quals.removeObjCLifetime();
2142 
2143  // Exact qualifier match -> return the pointer type we're converting to.
2144  if (CanonToPointee.getLocalQualifiers() == Quals) {
2145  // ToType is exactly what we need. Return it.
2146  if (!ToType.isNull())
2147  return ToType.getUnqualifiedType();
2148 
2149  // Build a pointer to ToPointee. It has the right qualifiers
2150  // already.
2151  if (isa<ObjCObjectPointerType>(ToType))
2152  return Context.getObjCObjectPointerType(ToPointee);
2153  return Context.getPointerType(ToPointee);
2154  }
2155 
2156  // Just build a canonical type that has the right qualifiers.
2157  QualType QualifiedCanonToPointee
2158  = Context.getQualifiedType(CanonToPointee.getLocalUnqualifiedType(), Quals);
2159 
2160  if (isa<ObjCObjectPointerType>(ToType))
2161  return Context.getObjCObjectPointerType(QualifiedCanonToPointee);
2162  return Context.getPointerType(QualifiedCanonToPointee);
2163 }
2164 
2166  bool InOverloadResolution,
2167  ASTContext &Context) {
2168  // Handle value-dependent integral null pointer constants correctly.
2169  // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#903
2170  if (Expr->isValueDependent() && !Expr->isTypeDependent() &&
2171  Expr->getType()->isIntegerType() && !Expr->getType()->isEnumeralType())
2172  return !InOverloadResolution;
2173 
2174  return Expr->isNullPointerConstant(Context,
2175  InOverloadResolution? Expr::NPC_ValueDependentIsNotNull
2177 }
2178 
2179 /// IsPointerConversion - Determines whether the conversion of the
2180 /// expression From, which has the (possibly adjusted) type FromType,
2181 /// can be converted to the type ToType via a pointer conversion (C++
2182 /// 4.10). If so, returns true and places the converted type (that
2183 /// might differ from ToType in its cv-qualifiers at some level) into
2184 /// ConvertedType.
2185 ///
2186 /// This routine also supports conversions to and from block pointers
2187 /// and conversions with Objective-C's 'id', 'id<protocols...>', and
2188 /// pointers to interfaces. FIXME: Once we've determined the
2189 /// appropriate overloading rules for Objective-C, we may want to
2190 /// split the Objective-C checks into a different routine; however,
2191 /// GCC seems to consider all of these conversions to be pointer
2192 /// conversions, so for now they live here. IncompatibleObjC will be
2193 /// set if the conversion is an allowed Objective-C conversion that
2194 /// should result in a warning.
2195 bool Sema::IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
2196  bool InOverloadResolution,
2197  QualType& ConvertedType,
2198  bool &IncompatibleObjC) {
2199  IncompatibleObjC = false;
2200  if (isObjCPointerConversion(FromType, ToType, ConvertedType,
2201  IncompatibleObjC))
2202  return true;
2203 
2204  // Conversion from a null pointer constant to any Objective-C pointer type.
2205  if (ToType->isObjCObjectPointerType() &&
2206  isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
2207  ConvertedType = ToType;
2208  return true;
2209  }
2210 
2211  // Blocks: Block pointers can be converted to void*.
2212  if (FromType->isBlockPointerType() && ToType->isPointerType() &&
2213  ToType->getAs<PointerType>()->getPointeeType()->isVoidType()) {
2214  ConvertedType = ToType;
2215  return true;
2216  }
2217  // Blocks: A null pointer constant can be converted to a block
2218  // pointer type.
2219  if (ToType->isBlockPointerType() &&
2220  isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
2221  ConvertedType = ToType;
2222  return true;
2223  }
2224 
2225  // If the left-hand-side is nullptr_t, the right side can be a null
2226  // pointer constant.
2227  if (ToType->isNullPtrType() &&
2228  isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
2229  ConvertedType = ToType;
2230  return true;
2231  }
2232 
2233  const PointerType* ToTypePtr = ToType->getAs<PointerType>();
2234  if (!ToTypePtr)
2235  return false;
2236 
2237  // A null pointer constant can be converted to a pointer type (C++ 4.10p1).
2238  if (isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
2239  ConvertedType = ToType;
2240  return true;
2241  }
2242 
2243  // Beyond this point, both types need to be pointers
2244  // , including objective-c pointers.
2245  QualType ToPointeeType = ToTypePtr->getPointeeType();
2246  if (FromType->isObjCObjectPointerType() && ToPointeeType->isVoidType() &&
2247  !getLangOpts().ObjCAutoRefCount) {
2248  ConvertedType = BuildSimilarlyQualifiedPointerType(
2249  FromType->getAs<ObjCObjectPointerType>(),
2250  ToPointeeType,
2251  ToType, Context);
2252  return true;
2253  }
2254  const PointerType *FromTypePtr = FromType->getAs<PointerType>();
2255  if (!FromTypePtr)
2256  return false;
2257 
2258  QualType FromPointeeType = FromTypePtr->getPointeeType();
2259 
2260  // If the unqualified pointee types are the same, this can't be a
2261  // pointer conversion, so don't do all of the work below.
2262  if (Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType))
2263  return false;
2264 
2265  // An rvalue of type "pointer to cv T," where T is an object type,
2266  // can be converted to an rvalue of type "pointer to cv void" (C++
2267  // 4.10p2).
2268  if (FromPointeeType->isIncompleteOrObjectType() &&
2269  ToPointeeType->isVoidType()) {
2270  ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2271  ToPointeeType,
2272  ToType, Context,
2273  /*StripObjCLifetime=*/true);
2274  return true;
2275  }
2276 
2277  // MSVC allows implicit function to void* type conversion.
2278  if (getLangOpts().MSVCCompat && FromPointeeType->isFunctionType() &&
2279  ToPointeeType->isVoidType()) {
2280  ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2281  ToPointeeType,
2282  ToType, Context);
2283  return true;
2284  }
2285 
2286  // When we're overloading in C, we allow a special kind of pointer
2287  // conversion for compatible-but-not-identical pointee types.
2288  if (!getLangOpts().CPlusPlus &&
2289  Context.typesAreCompatible(FromPointeeType, ToPointeeType)) {
2290  ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2291  ToPointeeType,
2292  ToType, Context);
2293  return true;
2294  }
2295 
2296  // C++ [conv.ptr]p3:
2297  //
2298  // An rvalue of type "pointer to cv D," where D is a class type,
2299  // can be converted to an rvalue of type "pointer to cv B," where
2300  // B is a base class (clause 10) of D. If B is an inaccessible
2301  // (clause 11) or ambiguous (10.2) base class of D, a program that
2302  // necessitates this conversion is ill-formed. The result of the
2303  // conversion is a pointer to the base class sub-object of the
2304  // derived class object. The null pointer value is converted to
2305  // the null pointer value of the destination type.
2306  //
2307  // Note that we do not check for ambiguity or inaccessibility
2308  // here. That is handled by CheckPointerConversion.
2309  if (getLangOpts().CPlusPlus &&
2310  FromPointeeType->isRecordType() && ToPointeeType->isRecordType() &&
2311  !Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType) &&
2312  IsDerivedFrom(From->getLocStart(), FromPointeeType, ToPointeeType)) {
2313  ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2314  ToPointeeType,
2315  ToType, Context);
2316  return true;
2317  }
2318 
2319  if (FromPointeeType->isVectorType() && ToPointeeType->isVectorType() &&
2320  Context.areCompatibleVectorTypes(FromPointeeType, ToPointeeType)) {
2321  ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2322  ToPointeeType,
2323  ToType, Context);
2324  return true;
2325  }
2326 
2327  return false;
2328 }
2329 
2330 /// \brief Adopt the given qualifiers for the given type.
2332  Qualifiers TQs = T.getQualifiers();
2333 
2334  // Check whether qualifiers already match.
2335  if (TQs == Qs)
2336  return T;
2337 
2338  if (Qs.compatiblyIncludes(TQs))
2339  return Context.getQualifiedType(T, Qs);
2340 
2341  return Context.getQualifiedType(T.getUnqualifiedType(), Qs);
2342 }
2343 
2344 /// isObjCPointerConversion - Determines whether this is an
2345 /// Objective-C pointer conversion. Subroutine of IsPointerConversion,
2346 /// with the same arguments and return values.
2348  QualType& ConvertedType,
2349  bool &IncompatibleObjC) {
2350  if (!getLangOpts().ObjC1)
2351  return false;
2352 
2353  // The set of qualifiers on the type we're converting from.
2354  Qualifiers FromQualifiers = FromType.getQualifiers();
2355 
2356  // First, we handle all conversions on ObjC object pointer types.
2357  const ObjCObjectPointerType* ToObjCPtr =
2358  ToType->getAs<ObjCObjectPointerType>();
2359  const ObjCObjectPointerType *FromObjCPtr =
2360  FromType->getAs<ObjCObjectPointerType>();
2361 
2362  if (ToObjCPtr && FromObjCPtr) {
2363  // If the pointee types are the same (ignoring qualifications),
2364  // then this is not a pointer conversion.
2366  FromObjCPtr->getPointeeType()))
2367  return false;
2368 
2369  // Conversion between Objective-C pointers.
2370  if (Context.canAssignObjCInterfaces(ToObjCPtr, FromObjCPtr)) {
2371  const ObjCInterfaceType* LHS = ToObjCPtr->getInterfaceType();
2372  const ObjCInterfaceType* RHS = FromObjCPtr->getInterfaceType();
2373  if (getLangOpts().CPlusPlus && LHS && RHS &&
2374  !ToObjCPtr->getPointeeType().isAtLeastAsQualifiedAs(
2375  FromObjCPtr->getPointeeType()))
2376  return false;
2377  ConvertedType = BuildSimilarlyQualifiedPointerType(FromObjCPtr,
2378  ToObjCPtr->getPointeeType(),
2379  ToType, Context);
2380  ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2381  return true;
2382  }
2383 
2384  if (Context.canAssignObjCInterfaces(FromObjCPtr, ToObjCPtr)) {
2385  // Okay: this is some kind of implicit downcast of Objective-C
2386  // interfaces, which is permitted. However, we're going to
2387  // complain about it.
2388  IncompatibleObjC = true;
2389  ConvertedType = BuildSimilarlyQualifiedPointerType(FromObjCPtr,
2390  ToObjCPtr->getPointeeType(),
2391  ToType, Context);
2392  ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2393  return true;
2394  }
2395  }
2396  // Beyond this point, both types need to be C pointers or block pointers.
2397  QualType ToPointeeType;
2398  if (const PointerType *ToCPtr = ToType->getAs<PointerType>())
2399  ToPointeeType = ToCPtr->getPointeeType();
2400  else if (const BlockPointerType *ToBlockPtr =
2401  ToType->getAs<BlockPointerType>()) {
2402  // Objective C++: We're able to convert from a pointer to any object
2403  // to a block pointer type.
2404  if (FromObjCPtr && FromObjCPtr->isObjCBuiltinType()) {
2405  ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2406  return true;
2407  }
2408  ToPointeeType = ToBlockPtr->getPointeeType();
2409  }
2410  else if (FromType->getAs<BlockPointerType>() &&
2411  ToObjCPtr && ToObjCPtr->isObjCBuiltinType()) {
2412  // Objective C++: We're able to convert from a block pointer type to a
2413  // pointer to any object.
2414  ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2415  return true;
2416  }
2417  else
2418  return false;
2419 
2420  QualType FromPointeeType;
2421  if (const PointerType *FromCPtr = FromType->getAs<PointerType>())
2422  FromPointeeType = FromCPtr->getPointeeType();
2423  else if (const BlockPointerType *FromBlockPtr =
2424  FromType->getAs<BlockPointerType>())
2425  FromPointeeType = FromBlockPtr->getPointeeType();
2426  else
2427  return false;
2428 
2429  // If we have pointers to pointers, recursively check whether this
2430  // is an Objective-C conversion.
2431  if (FromPointeeType->isPointerType() && ToPointeeType->isPointerType() &&
2432  isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType,
2433  IncompatibleObjC)) {
2434  // We always complain about this conversion.
2435  IncompatibleObjC = true;
2436  ConvertedType = Context.getPointerType(ConvertedType);
2437  ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2438  return true;
2439  }
2440  // Allow conversion of pointee being objective-c pointer to another one;
2441  // as in I* to id.
2442  if (FromPointeeType->getAs<ObjCObjectPointerType>() &&
2443  ToPointeeType->getAs<ObjCObjectPointerType>() &&
2444  isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType,
2445  IncompatibleObjC)) {
2446 
2447  ConvertedType = Context.getPointerType(ConvertedType);
2448  ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2449  return true;
2450  }
2451 
2452  // If we have pointers to functions or blocks, check whether the only
2453  // differences in the argument and result types are in Objective-C
2454  // pointer conversions. If so, we permit the conversion (but
2455  // complain about it).
2456  const FunctionProtoType *FromFunctionType
2457  = FromPointeeType->getAs<FunctionProtoType>();
2458  const FunctionProtoType *ToFunctionType
2459  = ToPointeeType->getAs<FunctionProtoType>();
2460  if (FromFunctionType && ToFunctionType) {
2461  // If the function types are exactly the same, this isn't an
2462  // Objective-C pointer conversion.
2463  if (Context.getCanonicalType(FromPointeeType)
2464  == Context.getCanonicalType(ToPointeeType))
2465  return false;
2466 
2467  // Perform the quick checks that will tell us whether these
2468  // function types are obviously different.
2469  if (FromFunctionType->getNumParams() != ToFunctionType->getNumParams() ||
2470  FromFunctionType->isVariadic() != ToFunctionType->isVariadic() ||
2471  FromFunctionType->getTypeQuals() != ToFunctionType->getTypeQuals())
2472  return false;
2473 
2474  bool HasObjCConversion = false;
2475  if (Context.getCanonicalType(FromFunctionType->getReturnType()) ==
2476  Context.getCanonicalType(ToFunctionType->getReturnType())) {
2477  // Okay, the types match exactly. Nothing to do.
2478  } else if (isObjCPointerConversion(FromFunctionType->getReturnType(),
2479  ToFunctionType->getReturnType(),
2480  ConvertedType, IncompatibleObjC)) {
2481  // Okay, we have an Objective-C pointer conversion.
2482  HasObjCConversion = true;
2483  } else {
2484  // Function types are too different. Abort.
2485  return false;
2486  }
2487 
2488  // Check argument types.
2489  for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumParams();
2490  ArgIdx != NumArgs; ++ArgIdx) {
2491  QualType FromArgType = FromFunctionType->getParamType(ArgIdx);
2492  QualType ToArgType = ToFunctionType->getParamType(ArgIdx);
2493  if (Context.getCanonicalType(FromArgType)
2494  == Context.getCanonicalType(ToArgType)) {
2495  // Okay, the types match exactly. Nothing to do.
2496  } else if (isObjCPointerConversion(FromArgType, ToArgType,
2497  ConvertedType, IncompatibleObjC)) {
2498  // Okay, we have an Objective-C pointer conversion.
2499  HasObjCConversion = true;
2500  } else {
2501  // Argument types are too different. Abort.
2502  return false;
2503  }
2504  }
2505 
2506  if (HasObjCConversion) {
2507  // We had an Objective-C conversion. Allow this pointer
2508  // conversion, but complain about it.
2509  ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2510  IncompatibleObjC = true;
2511  return true;
2512  }
2513  }
2514 
2515  return false;
2516 }
2517 
2518 /// \brief Determine whether this is an Objective-C writeback conversion,
2519 /// used for parameter passing when performing automatic reference counting.
2520 ///
2521 /// \param FromType The type we're converting form.
2522 ///
2523 /// \param ToType The type we're converting to.
2524 ///
2525 /// \param ConvertedType The type that will be produced after applying
2526 /// this conversion.
2528  QualType &ConvertedType) {
2529  if (!getLangOpts().ObjCAutoRefCount ||
2530  Context.hasSameUnqualifiedType(FromType, ToType))
2531  return false;
2532 
2533  // Parameter must be a pointer to __autoreleasing (with no other qualifiers).
2534  QualType ToPointee;
2535  if (const PointerType *ToPointer = ToType->getAs<PointerType>())
2536  ToPointee = ToPointer->getPointeeType();
2537  else
2538  return false;
2539 
2540  Qualifiers ToQuals = ToPointee.getQualifiers();
2541  if (!ToPointee->isObjCLifetimeType() ||
2543  !ToQuals.withoutObjCLifetime().empty())
2544  return false;
2545 
2546  // Argument must be a pointer to __strong to __weak.
2547  QualType FromPointee;
2548  if (const PointerType *FromPointer = FromType->getAs<PointerType>())
2549  FromPointee = FromPointer->getPointeeType();
2550  else
2551  return false;
2552 
2553  Qualifiers FromQuals = FromPointee.getQualifiers();
2554  if (!FromPointee->isObjCLifetimeType() ||
2555  (FromQuals.getObjCLifetime() != Qualifiers::OCL_Strong &&
2556  FromQuals.getObjCLifetime() != Qualifiers::OCL_Weak))
2557  return false;
2558 
2559  // Make sure that we have compatible qualifiers.
2561  if (!ToQuals.compatiblyIncludes(FromQuals))
2562  return false;
2563 
2564  // Remove qualifiers from the pointee type we're converting from; they
2565  // aren't used in the compatibility check belong, and we'll be adding back
2566  // qualifiers (with __autoreleasing) if the compatibility check succeeds.
2567  FromPointee = FromPointee.getUnqualifiedType();
2568 
2569  // The unqualified form of the pointee types must be compatible.
2570  ToPointee = ToPointee.getUnqualifiedType();
2571  bool IncompatibleObjC;
2572  if (Context.typesAreCompatible(FromPointee, ToPointee))
2573  FromPointee = ToPointee;
2574  else if (!isObjCPointerConversion(FromPointee, ToPointee, FromPointee,
2575  IncompatibleObjC))
2576  return false;
2577 
2578  /// \brief Construct the type we're converting to, which is a pointer to
2579  /// __autoreleasing pointee.
2580  FromPointee = Context.getQualifiedType(FromPointee, FromQuals);
2581  ConvertedType = Context.getPointerType(FromPointee);
2582  return true;
2583 }
2584 
2586  QualType& ConvertedType) {
2587  QualType ToPointeeType;
2588  if (const BlockPointerType *ToBlockPtr =
2589  ToType->getAs<BlockPointerType>())
2590  ToPointeeType = ToBlockPtr->getPointeeType();
2591  else
2592  return false;
2593 
2594  QualType FromPointeeType;
2595  if (const BlockPointerType *FromBlockPtr =
2596  FromType->getAs<BlockPointerType>())
2597  FromPointeeType = FromBlockPtr->getPointeeType();
2598  else
2599  return false;
2600  // We have pointer to blocks, check whether the only
2601  // differences in the argument and result types are in Objective-C
2602  // pointer conversions. If so, we permit the conversion.
2603 
2604  const FunctionProtoType *FromFunctionType
2605  = FromPointeeType->getAs<FunctionProtoType>();
2606  const FunctionProtoType *ToFunctionType
2607  = ToPointeeType->getAs<FunctionProtoType>();
2608 
2609  if (!FromFunctionType || !ToFunctionType)
2610  return false;
2611 
2612  if (Context.hasSameType(FromPointeeType, ToPointeeType))
2613  return true;
2614 
2615  // Perform the quick checks that will tell us whether these
2616  // function types are obviously different.
2617  if (FromFunctionType->getNumParams() != ToFunctionType->getNumParams() ||
2618  FromFunctionType->isVariadic() != ToFunctionType->isVariadic())
2619  return false;
2620 
2621  FunctionType::ExtInfo FromEInfo = FromFunctionType->getExtInfo();
2622  FunctionType::ExtInfo ToEInfo = ToFunctionType->getExtInfo();
2623  if (FromEInfo != ToEInfo)
2624  return false;
2625 
2626  bool IncompatibleObjC = false;
2627  if (Context.hasSameType(FromFunctionType->getReturnType(),
2628  ToFunctionType->getReturnType())) {
2629  // Okay, the types match exactly. Nothing to do.
2630  } else {
2631  QualType RHS = FromFunctionType->getReturnType();
2632  QualType LHS = ToFunctionType->getReturnType();
2633  if ((!getLangOpts().CPlusPlus || !RHS->isRecordType()) &&
2634  !RHS.hasQualifiers() && LHS.hasQualifiers())
2635  LHS = LHS.getUnqualifiedType();
2636 
2637  if (Context.hasSameType(RHS,LHS)) {
2638  // OK exact match.
2639  } else if (isObjCPointerConversion(RHS, LHS,
2640  ConvertedType, IncompatibleObjC)) {
2641  if (IncompatibleObjC)
2642  return false;
2643  // Okay, we have an Objective-C pointer conversion.
2644  }
2645  else
2646  return false;
2647  }
2648 
2649  // Check argument types.
2650  for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumParams();
2651  ArgIdx != NumArgs; ++ArgIdx) {
2652  IncompatibleObjC = false;
2653  QualType FromArgType = FromFunctionType->getParamType(ArgIdx);
2654  QualType ToArgType = ToFunctionType->getParamType(ArgIdx);
2655  if (Context.hasSameType(FromArgType, ToArgType)) {
2656  // Okay, the types match exactly. Nothing to do.
2657  } else if (isObjCPointerConversion(ToArgType, FromArgType,
2658  ConvertedType, IncompatibleObjC)) {
2659  if (IncompatibleObjC)
2660  return false;
2661  // Okay, we have an Objective-C pointer conversion.
2662  } else
2663  // Argument types are too different. Abort.
2664  return false;
2665  }
2666  if (!Context.doFunctionTypesMatchOnExtParameterInfos(FromFunctionType,
2667  ToFunctionType))
2668  return false;
2669 
2670  ConvertedType = ToType;
2671  return true;
2672 }
2673 
2674 enum {
2682 };
2683 
2684 /// Attempts to get the FunctionProtoType from a Type. Handles
2685 /// MemberFunctionPointers properly.
2687  if (auto *FPT = FromType->getAs<FunctionProtoType>())
2688  return FPT;
2689 
2690  if (auto *MPT = FromType->getAs<MemberPointerType>())
2691  return MPT->getPointeeType()->getAs<FunctionProtoType>();
2692 
2693  return nullptr;
2694 }
2695 
2696 /// HandleFunctionTypeMismatch - Gives diagnostic information for differeing
2697 /// function types. Catches different number of parameter, mismatch in
2698 /// parameter types, and different return types.
2700  QualType FromType, QualType ToType) {
2701  // If either type is not valid, include no extra info.
2702  if (FromType.isNull() || ToType.isNull()) {
2703  PDiag << ft_default;
2704  return;
2705  }
2706 
2707  // Get the function type from the pointers.
2708  if (FromType->isMemberPointerType() && ToType->isMemberPointerType()) {
2709  const MemberPointerType *FromMember = FromType->getAs<MemberPointerType>(),
2710  *ToMember = ToType->getAs<MemberPointerType>();
2711  if (!Context.hasSameType(FromMember->getClass(), ToMember->getClass())) {
2712  PDiag << ft_different_class << QualType(ToMember->getClass(), 0)
2713  << QualType(FromMember->getClass(), 0);
2714  return;
2715  }
2716  FromType = FromMember->getPointeeType();
2717  ToType = ToMember->getPointeeType();
2718  }
2719 
2720  if (FromType->isPointerType())
2721  FromType = FromType->getPointeeType();
2722  if (ToType->isPointerType())
2723  ToType = ToType->getPointeeType();
2724 
2725  // Remove references.
2726  FromType = FromType.getNonReferenceType();
2727  ToType = ToType.getNonReferenceType();
2728 
2729  // Don't print extra info for non-specialized template functions.
2730  if (FromType->isInstantiationDependentType() &&
2731  !FromType->getAs<TemplateSpecializationType>()) {
2732  PDiag << ft_default;
2733  return;
2734  }
2735 
2736  // No extra info for same types.
2737  if (Context.hasSameType(FromType, ToType)) {
2738  PDiag << ft_default;
2739  return;
2740  }
2741 
2742  const FunctionProtoType *FromFunction = tryGetFunctionProtoType(FromType),
2743  *ToFunction = tryGetFunctionProtoType(ToType);
2744 
2745  // Both types need to be function types.
2746  if (!FromFunction || !ToFunction) {
2747  PDiag << ft_default;
2748  return;
2749  }
2750 
2751  if (FromFunction->getNumParams() != ToFunction->getNumParams()) {
2752  PDiag << ft_parameter_arity << ToFunction->getNumParams()
2753  << FromFunction->getNumParams();
2754  return;
2755  }
2756 
2757  // Handle different parameter types.
2758  unsigned ArgPos;
2759  if (!FunctionParamTypesAreEqual(FromFunction, ToFunction, &ArgPos)) {
2760  PDiag << ft_parameter_mismatch << ArgPos + 1
2761  << ToFunction->getParamType(ArgPos)
2762  << FromFunction->getParamType(ArgPos);
2763  return;
2764  }
2765 
2766  // Handle different return type.
2767  if (!Context.hasSameType(FromFunction->getReturnType(),
2768  ToFunction->getReturnType())) {
2769  PDiag << ft_return_type << ToFunction->getReturnType()
2770  << FromFunction->getReturnType();
2771  return;
2772  }
2773 
2774  unsigned FromQuals = FromFunction->getTypeQuals(),
2775  ToQuals = ToFunction->getTypeQuals();
2776  if (FromQuals != ToQuals) {
2777  PDiag << ft_qualifer_mismatch << ToQuals << FromQuals;
2778  return;
2779  }
2780 
2781  // Handle exception specification differences on canonical type (in C++17
2782  // onwards).
2783  if (cast<FunctionProtoType>(FromFunction->getCanonicalTypeUnqualified())
2784  ->isNothrow(Context) !=
2785  cast<FunctionProtoType>(ToFunction->getCanonicalTypeUnqualified())
2786  ->isNothrow(Context)) {
2787  PDiag << ft_noexcept;
2788  return;
2789  }
2790 
2791  // Unable to find a difference, so add no extra info.
2792  PDiag << ft_default;
2793 }
2794 
2795 /// FunctionParamTypesAreEqual - This routine checks two function proto types
2796 /// for equality of their argument types. Caller has already checked that
2797 /// they have same number of arguments. If the parameters are different,
2798 /// ArgPos will have the parameter index of the first different parameter.
2800  const FunctionProtoType *NewType,
2801  unsigned *ArgPos) {
2803  N = NewType->param_type_begin(),
2804  E = OldType->param_type_end();
2805  O && (O != E); ++O, ++N) {
2806  if (!Context.hasSameType(O->getUnqualifiedType(),
2807  N->getUnqualifiedType())) {
2808  if (ArgPos)
2809  *ArgPos = O - OldType->param_type_begin();
2810  return false;
2811  }
2812  }
2813  return true;
2814 }
2815 
2816 /// CheckPointerConversion - Check the pointer conversion from the
2817 /// expression From to the type ToType. This routine checks for
2818 /// ambiguous or inaccessible derived-to-base pointer
2819 /// conversions for which IsPointerConversion has already returned
2820 /// true. It returns true and produces a diagnostic if there was an
2821 /// error, or returns false otherwise.
2823  CastKind &Kind,
2824  CXXCastPath& BasePath,
2825  bool IgnoreBaseAccess,
2826  bool Diagnose) {
2827  QualType FromType = From->getType();
2828  bool IsCStyleOrFunctionalCast = IgnoreBaseAccess;
2829 
2830  Kind = CK_BitCast;
2831 
2832  if (Diagnose && !IsCStyleOrFunctionalCast && !FromType->isAnyPointerType() &&
2836  DiagRuntimeBehavior(From->getExprLoc(), From,
2837  PDiag(diag::warn_impcast_bool_to_null_pointer)
2838  << ToType << From->getSourceRange());
2839  else if (!isUnevaluatedContext())
2840  Diag(From->getExprLoc(), diag::warn_non_literal_null_pointer)
2841  << ToType << From->getSourceRange();
2842  }
2843  if (const PointerType *ToPtrType = ToType->getAs<PointerType>()) {
2844  if (const PointerType *FromPtrType = FromType->getAs<PointerType>()) {
2845  QualType FromPointeeType = FromPtrType->getPointeeType(),
2846  ToPointeeType = ToPtrType->getPointeeType();
2847 
2848  if (FromPointeeType->isRecordType() && ToPointeeType->isRecordType() &&
2849  !Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType)) {
2850  // We must have a derived-to-base conversion. Check an
2851  // ambiguous or inaccessible conversion.
2852  unsigned InaccessibleID = 0;
2853  unsigned AmbigiousID = 0;
2854  if (Diagnose) {
2855  InaccessibleID = diag::err_upcast_to_inaccessible_base;
2856  AmbigiousID = diag::err_ambiguous_derived_to_base_conv;
2857  }
2858  if (CheckDerivedToBaseConversion(
2859  FromPointeeType, ToPointeeType, InaccessibleID, AmbigiousID,
2860  From->getExprLoc(), From->getSourceRange(), DeclarationName(),
2861  &BasePath, IgnoreBaseAccess))
2862  return true;
2863 
2864  // The conversion was successful.
2865  Kind = CK_DerivedToBase;
2866  }
2867 
2868  if (Diagnose && !IsCStyleOrFunctionalCast &&
2869  FromPointeeType->isFunctionType() && ToPointeeType->isVoidType()) {
2870  assert(getLangOpts().MSVCCompat &&
2871  "this should only be possible with MSVCCompat!");
2872  Diag(From->getExprLoc(), diag::ext_ms_impcast_fn_obj)
2873  << From->getSourceRange();
2874  }
2875  }
2876  } else if (const ObjCObjectPointerType *ToPtrType =
2877  ToType->getAs<ObjCObjectPointerType>()) {
2878  if (const ObjCObjectPointerType *FromPtrType =
2879  FromType->getAs<ObjCObjectPointerType>()) {
2880  // Objective-C++ conversions are always okay.
2881  // FIXME: We should have a different class of conversions for the
2882  // Objective-C++ implicit conversions.
2883  if (FromPtrType->isObjCBuiltinType() || ToPtrType->isObjCBuiltinType())
2884  return false;
2885  } else if (FromType->isBlockPointerType()) {
2886  Kind = CK_BlockPointerToObjCPointerCast;
2887  } else {
2888  Kind = CK_CPointerToObjCPointerCast;
2889  }
2890  } else if (ToType->isBlockPointerType()) {
2891  if (!FromType->isBlockPointerType())
2892  Kind = CK_AnyPointerToBlockPointerCast;
2893  }
2894 
2895  // We shouldn't fall into this case unless it's valid for other
2896  // reasons.
2898  Kind = CK_NullToPointer;
2899 
2900  return false;
2901 }
2902 
2903 /// IsMemberPointerConversion - Determines whether the conversion of the
2904 /// expression From, which has the (possibly adjusted) type FromType, can be
2905 /// converted to the type ToType via a member pointer conversion (C++ 4.11).
2906 /// If so, returns true and places the converted type (that might differ from
2907 /// ToType in its cv-qualifiers at some level) into ConvertedType.
2909  QualType ToType,
2910  bool InOverloadResolution,
2911  QualType &ConvertedType) {
2912  const MemberPointerType *ToTypePtr = ToType->getAs<MemberPointerType>();
2913  if (!ToTypePtr)
2914  return false;
2915 
2916  // A null pointer constant can be converted to a member pointer (C++ 4.11p1)
2917  if (From->isNullPointerConstant(Context,
2918  InOverloadResolution? Expr::NPC_ValueDependentIsNotNull
2920  ConvertedType = ToType;
2921  return true;
2922  }
2923 
2924  // Otherwise, both types have to be member pointers.
2925  const MemberPointerType *FromTypePtr = FromType->getAs<MemberPointerType>();
2926  if (!FromTypePtr)
2927  return false;
2928 
2929  // A pointer to member of B can be converted to a pointer to member of D,
2930  // where D is derived from B (C++ 4.11p2).
2931  QualType FromClass(FromTypePtr->getClass(), 0);
2932  QualType ToClass(ToTypePtr->getClass(), 0);
2933 
2934  if (!Context.hasSameUnqualifiedType(FromClass, ToClass) &&
2935  IsDerivedFrom(From->getLocStart(), ToClass, FromClass)) {
2936  ConvertedType = Context.getMemberPointerType(FromTypePtr->getPointeeType(),
2937  ToClass.getTypePtr());
2938  return true;
2939  }
2940 
2941  return false;
2942 }
2943 
2944 /// CheckMemberPointerConversion - Check the member pointer conversion from the
2945 /// expression From to the type ToType. This routine checks for ambiguous or
2946 /// virtual or inaccessible base-to-derived member pointer conversions
2947 /// for which IsMemberPointerConversion has already returned true. It returns
2948 /// true and produces a diagnostic if there was an error, or returns false
2949 /// otherwise.
2951  CastKind &Kind,
2952  CXXCastPath &BasePath,
2953  bool IgnoreBaseAccess) {
2954  QualType FromType = From->getType();
2955  const MemberPointerType *FromPtrType = FromType->getAs<MemberPointerType>();
2956  if (!FromPtrType) {
2957  // This must be a null pointer to member pointer conversion
2958  assert(From->isNullPointerConstant(Context,
2960  "Expr must be null pointer constant!");
2961  Kind = CK_NullToMemberPointer;
2962  return false;
2963  }
2964 
2965  const MemberPointerType *ToPtrType = ToType->getAs<MemberPointerType>();
2966  assert(ToPtrType && "No member pointer cast has a target type "
2967  "that is not a member pointer.");
2968 
2969  QualType FromClass = QualType(FromPtrType->getClass(), 0);
2970  QualType ToClass = QualType(ToPtrType->getClass(), 0);
2971 
2972  // FIXME: What about dependent types?
2973  assert(FromClass->isRecordType() && "Pointer into non-class.");
2974  assert(ToClass->isRecordType() && "Pointer into non-class.");
2975 
2976  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
2977  /*DetectVirtual=*/true);
2978  bool DerivationOkay =
2979  IsDerivedFrom(From->getLocStart(), ToClass, FromClass, Paths);
2980  assert(DerivationOkay &&
2981  "Should not have been called if derivation isn't OK.");
2982  (void)DerivationOkay;
2983 
2984  if (Paths.isAmbiguous(Context.getCanonicalType(FromClass).
2985  getUnqualifiedType())) {
2986  std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
2987  Diag(From->getExprLoc(), diag::err_ambiguous_memptr_conv)
2988  << 0 << FromClass << ToClass << PathDisplayStr << From->getSourceRange();
2989  return true;
2990  }
2991 
2992  if (const RecordType *VBase = Paths.getDetectedVirtual()) {
2993  Diag(From->getExprLoc(), diag::err_memptr_conv_via_virtual)
2994  << FromClass << ToClass << QualType(VBase, 0)
2995  << From->getSourceRange();
2996  return true;
2997  }
2998 
2999  if (!IgnoreBaseAccess)
3000  CheckBaseClassAccess(From->getExprLoc(), FromClass, ToClass,
3001  Paths.front(),
3002  diag::err_downcast_from_inaccessible_base);
3003 
3004  // Must be a base to derived member conversion.
3005  BuildBasePathArray(Paths, BasePath);
3006  Kind = CK_BaseToDerivedMemberPointer;
3007  return false;
3008 }
3009 
3010 /// Determine whether the lifetime conversion between the two given
3011 /// qualifiers sets is nontrivial.
3013  Qualifiers ToQuals) {
3014  // Converting anything to const __unsafe_unretained is trivial.
3015  if (ToQuals.hasConst() &&
3017  return false;
3018 
3019  return true;
3020 }
3021 
3022 /// IsQualificationConversion - Determines whether the conversion from
3023 /// an rvalue of type FromType to ToType is a qualification conversion
3024 /// (C++ 4.4).
3025 ///
3026 /// \param ObjCLifetimeConversion Output parameter that will be set to indicate
3027 /// when the qualification conversion involves a change in the Objective-C
3028 /// object lifetime.
3029 bool
3031  bool CStyle, bool &ObjCLifetimeConversion) {
3032  FromType = Context.getCanonicalType(FromType);
3033  ToType = Context.getCanonicalType(ToType);
3034  ObjCLifetimeConversion = false;
3035 
3036  // If FromType and ToType are the same type, this is not a
3037  // qualification conversion.
3038  if (FromType.getUnqualifiedType() == ToType.getUnqualifiedType())
3039  return false;
3040 
3041  // (C++ 4.4p4):
3042  // A conversion can add cv-qualifiers at levels other than the first
3043  // in multi-level pointers, subject to the following rules: [...]
3044  bool PreviousToQualsIncludeConst = true;
3045  bool UnwrappedAnyPointer = false;
3046  while (Context.UnwrapSimilarPointerTypes(FromType, ToType)) {
3047  // Within each iteration of the loop, we check the qualifiers to
3048  // determine if this still looks like a qualification
3049  // conversion. Then, if all is well, we unwrap one more level of
3050  // pointers or pointers-to-members and do it all again
3051  // until there are no more pointers or pointers-to-members left to
3052  // unwrap.
3053  UnwrappedAnyPointer = true;
3054 
3055  Qualifiers FromQuals = FromType.getQualifiers();
3056  Qualifiers ToQuals = ToType.getQualifiers();
3057 
3058  // Ignore __unaligned qualifier if this type is void.
3059  if (ToType.getUnqualifiedType()->isVoidType())
3060  FromQuals.removeUnaligned();
3061 
3062  // Objective-C ARC:
3063  // Check Objective-C lifetime conversions.
3064  if (FromQuals.getObjCLifetime() != ToQuals.getObjCLifetime() &&
3065  UnwrappedAnyPointer) {
3066  if (ToQuals.compatiblyIncludesObjCLifetime(FromQuals)) {
3067  if (isNonTrivialObjCLifetimeConversion(FromQuals, ToQuals))
3068  ObjCLifetimeConversion = true;
3069  FromQuals.removeObjCLifetime();
3070  ToQuals.removeObjCLifetime();
3071  } else {
3072  // Qualification conversions cannot cast between different
3073  // Objective-C lifetime qualifiers.
3074  return false;
3075  }
3076  }
3077 
3078  // Allow addition/removal of GC attributes but not changing GC attributes.
3079  if (FromQuals.getObjCGCAttr() != ToQuals.getObjCGCAttr() &&
3080  (!FromQuals.hasObjCGCAttr() || !ToQuals.hasObjCGCAttr())) {
3081  FromQuals.removeObjCGCAttr();
3082  ToQuals.removeObjCGCAttr();
3083  }
3084 
3085  // -- for every j > 0, if const is in cv 1,j then const is in cv
3086  // 2,j, and similarly for volatile.
3087  if (!CStyle && !ToQuals.compatiblyIncludes(FromQuals))
3088  return false;
3089 
3090  // -- if the cv 1,j and cv 2,j are different, then const is in
3091  // every cv for 0 < k < j.
3092  if (!CStyle && FromQuals.getCVRQualifiers() != ToQuals.getCVRQualifiers()
3093  && !PreviousToQualsIncludeConst)
3094  return false;
3095 
3096  // Keep track of whether all prior cv-qualifiers in the "to" type
3097  // include const.
3098  PreviousToQualsIncludeConst
3099  = PreviousToQualsIncludeConst && ToQuals.hasConst();
3100  }
3101 
3102  // We are left with FromType and ToType being the pointee types
3103  // after unwrapping the original FromType and ToType the same number
3104  // of types. If we unwrapped any pointers, and if FromType and
3105  // ToType have the same unqualified type (since we checked
3106  // qualifiers above), then this is a qualification conversion.
3107  return UnwrappedAnyPointer && Context.hasSameUnqualifiedType(FromType,ToType);
3108 }
3109 
3110 /// \brief - Determine whether this is a conversion from a scalar type to an
3111 /// atomic type.
3112 ///
3113 /// If successful, updates \c SCS's second and third steps in the conversion
3114 /// sequence to finish the conversion.
3115 static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType,
3116  bool InOverloadResolution,
3118  bool CStyle) {
3119  const AtomicType *ToAtomic = ToType->getAs<AtomicType>();
3120  if (!ToAtomic)
3121  return false;
3122 
3123  StandardConversionSequence InnerSCS;
3124  if (!IsStandardConversion(S, From, ToAtomic->getValueType(),
3125  InOverloadResolution, InnerSCS,
3126  CStyle, /*AllowObjCWritebackConversion=*/false))
3127  return false;
3128 
3129  SCS.Second = InnerSCS.Second;
3130  SCS.setToType(1, InnerSCS.getToType(1));
3131  SCS.Third = InnerSCS.Third;
3133  = InnerSCS.QualificationIncludesObjCLifetime;
3134  SCS.setToType(2, InnerSCS.getToType(2));
3135  return true;
3136 }
3137 
3139  CXXConstructorDecl *Constructor,
3140  QualType Type) {
3141  const FunctionProtoType *CtorType =
3142  Constructor->getType()->getAs<FunctionProtoType>();
3143  if (CtorType->getNumParams() > 0) {
3144  QualType FirstArg = CtorType->getParamType(0);
3145  if (Context.hasSameUnqualifiedType(Type, FirstArg.getNonReferenceType()))
3146  return true;
3147  }
3148  return false;
3149 }
3150 
3151 static OverloadingResult
3153  CXXRecordDecl *To,
3155  OverloadCandidateSet &CandidateSet,
3156  bool AllowExplicit) {
3157  for (auto *D : S.LookupConstructors(To)) {
3158  auto Info = getConstructorInfo(D);
3159  if (!Info)
3160  continue;
3161 
3162  bool Usable = !Info.Constructor->isInvalidDecl() &&
3163  S.isInitListConstructor(Info.Constructor) &&
3164  (AllowExplicit || !Info.Constructor->isExplicit());
3165  if (Usable) {
3166  // If the first argument is (a reference to) the target type,
3167  // suppress conversions.
3168  bool SuppressUserConversions = isFirstArgumentCompatibleWithType(
3169  S.Context, Info.Constructor, ToType);
3170  if (Info.ConstructorTmpl)
3171  S.AddTemplateOverloadCandidate(Info.ConstructorTmpl, Info.FoundDecl,
3172  /*ExplicitArgs*/ nullptr, From,
3173  CandidateSet, SuppressUserConversions);
3174  else
3175  S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl, From,
3176  CandidateSet, SuppressUserConversions);
3177  }
3178  }
3179 
3180  bool HadMultipleCandidates = (CandidateSet.size() > 1);
3181 
3183  switch (auto Result =
3184  CandidateSet.BestViableFunction(S, From->getLocStart(),
3185  Best, true)) {
3186  case OR_Deleted:
3187  case OR_Success: {
3188  // Record the standard conversion we used and the conversion function.
3189  CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function);
3190  QualType ThisType = Constructor->getThisType(S.Context);
3191  // Initializer lists don't have conversions as such.
3193  User.HadMultipleCandidates = HadMultipleCandidates;
3194  User.ConversionFunction = Constructor;
3195  User.FoundConversionFunction = Best->FoundDecl;
3197  User.After.setFromType(ThisType->getAs<PointerType>()->getPointeeType());
3198  User.After.setAllToTypes(ToType);
3199  return Result;
3200  }
3201 
3202  case OR_No_Viable_Function:
3203  return OR_No_Viable_Function;
3204  case OR_Ambiguous:
3205  return OR_Ambiguous;
3206  }
3207 
3208  llvm_unreachable("Invalid OverloadResult!");
3209 }
3210 
3211 /// Determines whether there is a user-defined conversion sequence
3212 /// (C++ [over.ics.user]) that converts expression From to the type
3213 /// ToType. If such a conversion exists, User will contain the
3214 /// user-defined conversion sequence that performs such a conversion
3215 /// and this routine will return true. Otherwise, this routine returns
3216 /// false and User is unspecified.
3217 ///
3218 /// \param AllowExplicit true if the conversion should consider C++0x
3219 /// "explicit" conversion functions as well as non-explicit conversion
3220 /// functions (C++0x [class.conv.fct]p2).
3221 ///
3222 /// \param AllowObjCConversionOnExplicit true if the conversion should
3223 /// allow an extra Objective-C pointer conversion on uses of explicit
3224 /// constructors. Requires \c AllowExplicit to also be set.
3225 static OverloadingResult
3228  OverloadCandidateSet &CandidateSet,
3229  bool AllowExplicit,
3230  bool AllowObjCConversionOnExplicit) {
3231  assert(AllowExplicit || !AllowObjCConversionOnExplicit);
3232 
3233  // Whether we will only visit constructors.
3234  bool ConstructorsOnly = false;
3235 
3236  // If the type we are conversion to is a class type, enumerate its
3237  // constructors.
3238  if (const RecordType *ToRecordType = ToType->getAs<RecordType>()) {
3239  // C++ [over.match.ctor]p1:
3240  // When objects of class type are direct-initialized (8.5), or
3241  // copy-initialized from an expression of the same or a
3242  // derived class type (8.5), overload resolution selects the
3243  // constructor. [...] For copy-initialization, the candidate
3244  // functions are all the converting constructors (12.3.1) of
3245  // that class. The argument list is the expression-list within
3246  // the parentheses of the initializer.
3247  if (S.Context.hasSameUnqualifiedType(ToType, From->getType()) ||
3248  (From->getType()->getAs<RecordType>() &&
3249  S.IsDerivedFrom(From->getLocStart(), From->getType(), ToType)))
3250  ConstructorsOnly = true;
3251 
3252  if (!S.isCompleteType(From->getExprLoc(), ToType)) {
3253  // We're not going to find any constructors.
3254  } else if (CXXRecordDecl *ToRecordDecl
3255  = dyn_cast<CXXRecordDecl>(ToRecordType->getDecl())) {
3256 
3257  Expr **Args = &From;
3258  unsigned NumArgs = 1;
3259  bool ListInitializing = false;
3260  if (InitListExpr *InitList = dyn_cast<InitListExpr>(From)) {
3261  // But first, see if there is an init-list-constructor that will work.
3263  S, From, ToType, ToRecordDecl, User, CandidateSet, AllowExplicit);
3264  if (Result != OR_No_Viable_Function)
3265  return Result;
3266  // Never mind.
3267  CandidateSet.clear();
3268 
3269  // If we're list-initializing, we pass the individual elements as
3270  // arguments, not the entire list.
3271  Args = InitList->getInits();
3272  NumArgs = InitList->getNumInits();
3273  ListInitializing = true;
3274  }
3275 
3276  for (auto *D : S.LookupConstructors(ToRecordDecl)) {
3277  auto Info = getConstructorInfo(D);
3278  if (!Info)
3279  continue;
3280 
3281  bool Usable = !Info.Constructor->isInvalidDecl();
3282  if (ListInitializing)
3283  Usable = Usable && (AllowExplicit || !Info.Constructor->isExplicit());
3284  else
3285  Usable = Usable &&
3286  Info.Constructor->isConvertingConstructor(AllowExplicit);
3287  if (Usable) {
3288  bool SuppressUserConversions = !ConstructorsOnly;
3289  if (SuppressUserConversions && ListInitializing) {
3290  SuppressUserConversions = false;
3291  if (NumArgs == 1) {
3292  // If the first argument is (a reference to) the target type,
3293  // suppress conversions.
3294  SuppressUserConversions = isFirstArgumentCompatibleWithType(
3295  S.Context, Info.Constructor, ToType);
3296  }
3297  }
3298  if (Info.ConstructorTmpl)
3300  Info.ConstructorTmpl, Info.FoundDecl,
3301  /*ExplicitArgs*/ nullptr, llvm::makeArrayRef(Args, NumArgs),
3302  CandidateSet, SuppressUserConversions);
3303  else
3304  // Allow one user-defined conversion when user specifies a
3305  // From->ToType conversion via an static cast (c-style, etc).
3306  S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl,
3307  llvm::makeArrayRef(Args, NumArgs),
3308  CandidateSet, SuppressUserConversions);
3309  }
3310  }
3311  }
3312  }
3313 
3314  // Enumerate conversion functions, if we're allowed to.
3315  if (ConstructorsOnly || isa<InitListExpr>(From)) {
3316  } else if (!S.isCompleteType(From->getLocStart(), From->getType())) {
3317  // No conversion functions from incomplete types.
3318  } else if (const RecordType *FromRecordType
3319  = From->getType()->getAs<RecordType>()) {
3320  if (CXXRecordDecl *FromRecordDecl
3321  = dyn_cast<CXXRecordDecl>(FromRecordType->getDecl())) {
3322  // Add all of the conversion functions as candidates.
3323  const auto &Conversions = FromRecordDecl->getVisibleConversionFunctions();
3324  for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
3325  DeclAccessPair FoundDecl = I.getPair();
3326  NamedDecl *D = FoundDecl.getDecl();
3327  CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext());
3328  if (isa<UsingShadowDecl>(D))
3329  D = cast<UsingShadowDecl>(D)->getTargetDecl();
3330 
3331  CXXConversionDecl *Conv;
3332  FunctionTemplateDecl *ConvTemplate;
3333  if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D)))
3334  Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
3335  else
3336  Conv = cast<CXXConversionDecl>(D);
3337 
3338  if (AllowExplicit || !Conv->isExplicit()) {
3339  if (ConvTemplate)
3340  S.AddTemplateConversionCandidate(ConvTemplate, FoundDecl,
3341  ActingContext, From, ToType,
3342  CandidateSet,
3343  AllowObjCConversionOnExplicit);
3344  else
3345  S.AddConversionCandidate(Conv, FoundDecl, ActingContext,
3346  From, ToType, CandidateSet,
3347  AllowObjCConversionOnExplicit);
3348  }
3349  }
3350  }
3351  }
3352 
3353  bool HadMultipleCandidates = (CandidateSet.size() > 1);
3354 
3356  switch (auto Result = CandidateSet.BestViableFunction(S, From->getLocStart(),
3357  Best, true)) {
3358  case OR_Success:
3359  case OR_Deleted:
3360  // Record the standard conversion we used and the conversion function.
3361  if (CXXConstructorDecl *Constructor
3362  = dyn_cast<CXXConstructorDecl>(Best->Function)) {
3363  // C++ [over.ics.user]p1:
3364  // If the user-defined conversion is specified by a
3365  // constructor (12.3.1), the initial standard conversion
3366  // sequence converts the source type to the type required by
3367  // the argument of the constructor.
3368  //
3369  QualType ThisType = Constructor->getThisType(S.Context);
3370  if (isa<InitListExpr>(From)) {
3371  // Initializer lists don't have conversions as such.
3373  } else {
3374  if (Best->Conversions[0].isEllipsis())
3375  User.EllipsisConversion = true;
3376  else {
3377  User.Before = Best->Conversions[0].Standard;
3378  User.EllipsisConversion = false;
3379  }
3380  }
3381  User.HadMultipleCandidates = HadMultipleCandidates;
3382  User.ConversionFunction = Constructor;
3383  User.FoundConversionFunction = Best->FoundDecl;
3385  User.After.setFromType(ThisType->getAs<PointerType>()->getPointeeType());
3386  User.After.setAllToTypes(ToType);
3387  return Result;
3388  }
3389  if (CXXConversionDecl *Conversion
3390  = dyn_cast<CXXConversionDecl>(Best->Function)) {
3391  // C++ [over.ics.user]p1:
3392  //
3393  // [...] If the user-defined conversion is specified by a
3394  // conversion function (12.3.2), the initial standard
3395  // conversion sequence converts the source type to the
3396  // implicit object parameter of the conversion function.
3397  User.Before = Best->Conversions[0].Standard;
3398  User.HadMultipleCandidates = HadMultipleCandidates;
3399  User.ConversionFunction = Conversion;
3400  User.FoundConversionFunction = Best->FoundDecl;
3401  User.EllipsisConversion = false;
3402 
3403  // C++ [over.ics.user]p2:
3404  // The second standard conversion sequence converts the
3405  // result of the user-defined conversion to the target type
3406  // for the sequence. Since an implicit conversion sequence
3407  // is an initialization, the special rules for
3408  // initialization by user-defined conversion apply when
3409  // selecting the best user-defined conversion for a
3410  // user-defined conversion sequence (see 13.3.3 and
3411  // 13.3.3.1).
3412  User.After = Best->FinalConversion;
3413  return Result;
3414  }
3415  llvm_unreachable("Not a constructor or conversion function?");
3416 
3417  case OR_No_Viable_Function:
3418  return OR_No_Viable_Function;
3419 
3420  case OR_Ambiguous:
3421  return OR_Ambiguous;
3422  }
3423 
3424  llvm_unreachable("Invalid OverloadResult!");
3425 }
3426 
3427 bool
3430  OverloadCandidateSet CandidateSet(From->getExprLoc(),
3432  OverloadingResult OvResult =
3433  IsUserDefinedConversion(*this, From, ToType, ICS.UserDefined,
3434  CandidateSet, false, false);
3435  if (OvResult == OR_Ambiguous)
3436  Diag(From->getLocStart(), diag::err_typecheck_ambiguous_condition)
3437  << From->getType() << ToType << From->getSourceRange();
3438  else if (OvResult == OR_No_Viable_Function && !CandidateSet.empty()) {
3439  if (!RequireCompleteType(From->getLocStart(), ToType,
3440  diag::err_typecheck_nonviable_condition_incomplete,
3441  From->getType(), From->getSourceRange()))
3442  Diag(From->getLocStart(), diag::err_typecheck_nonviable_condition)
3443  << false << From->getType() << From->getSourceRange() << ToType;
3444  } else
3445  return false;
3446  CandidateSet.NoteCandidates(*this, OCD_AllCandidates, From);
3447  return true;
3448 }
3449 
3450 /// \brief Compare the user-defined conversion functions or constructors
3451 /// of two user-defined conversion sequences to determine whether any ordering
3452 /// is possible.
3455  FunctionDecl *Function2) {
3456  if (!S.getLangOpts().ObjC1 || !S.getLangOpts().CPlusPlus11)
3458 
3459  // Objective-C++:
3460  // If both conversion functions are implicitly-declared conversions from
3461  // a lambda closure type to a function pointer and a block pointer,
3462  // respectively, always prefer the conversion to a function pointer,
3463  // because the function pointer is more lightweight and is more likely
3464  // to keep code working.
3465  CXXConversionDecl *Conv1 = dyn_cast_or_null<CXXConversionDecl>(Function1);
3466  if (!Conv1)
3468 
3469  CXXConversionDecl *Conv2 = dyn_cast<CXXConversionDecl>(Function2);
3470  if (!Conv2)
3472 
3473  if (Conv1->getParent()->isLambda() && Conv2->getParent()->isLambda()) {
3474  bool Block1 = Conv1->getConversionType()->isBlockPointerType();
3475  bool Block2 = Conv2->getConversionType()->isBlockPointerType();
3476  if (Block1 != Block2)
3477  return Block1 ? ImplicitConversionSequence::Worse
3479  }
3480 
3482 }
3483 
3485  const ImplicitConversionSequence &ICS) {
3486  return (ICS.isStandard() && ICS.Standard.DeprecatedStringLiteralToCharPtr) ||
3487  (ICS.isUserDefined() &&
3489 }
3490 
3491 /// CompareImplicitConversionSequences - Compare two implicit
3492 /// conversion sequences to determine whether one is better than the
3493 /// other or if they are indistinguishable (C++ 13.3.3.2).
3496  const ImplicitConversionSequence& ICS1,
3497  const ImplicitConversionSequence& ICS2)
3498 {
3499  // (C++ 13.3.3.2p2): When comparing the basic forms of implicit
3500  // conversion sequences (as defined in 13.3.3.1)
3501  // -- a standard conversion sequence (13.3.3.1.1) is a better
3502  // conversion sequence than a user-defined conversion sequence or
3503  // an ellipsis conversion sequence, and
3504  // -- a user-defined conversion sequence (13.3.3.1.2) is a better
3505  // conversion sequence than an ellipsis conversion sequence
3506  // (13.3.3.1.3).
3507  //
3508  // C++0x [over.best.ics]p10:
3509  // For the purpose of ranking implicit conversion sequences as
3510  // described in 13.3.3.2, the ambiguous conversion sequence is
3511  // treated as a user-defined sequence that is indistinguishable
3512  // from any other user-defined conversion sequence.
3513 
3514  // String literal to 'char *' conversion has been deprecated in C++03. It has
3515  // been removed from C++11. We still accept this conversion, if it happens at
3516  // the best viable function. Otherwise, this conversion is considered worse
3517  // than ellipsis conversion. Consider this as an extension; this is not in the
3518  // standard. For example:
3519  //
3520  // int &f(...); // #1
3521  // void f(char*); // #2
3522  // void g() { int &r = f("foo"); }
3523  //
3524  // In C++03, we pick #2 as the best viable function.
3525  // In C++11, we pick #1 as the best viable function, because ellipsis
3526  // conversion is better than string-literal to char* conversion (since there
3527  // is no such conversion in C++11). If there was no #1 at all or #1 couldn't
3528  // convert arguments, #2 would be the best viable function in C++11.
3529  // If the best viable function has this conversion, a warning will be issued
3530  // in C++03, or an ExtWarn (+SFINAE failure) will be issued in C++11.
3531 
3532  if (S.getLangOpts().CPlusPlus11 && !S.getLangOpts().WritableStrings &&
3538 
3539  if (ICS1.getKindRank() < ICS2.getKindRank())
3541  if (ICS2.getKindRank() < ICS1.getKindRank())
3543 
3544  // The following checks require both conversion sequences to be of
3545  // the same kind.
3546  if (ICS1.getKind() != ICS2.getKind())
3548 
3551 
3552  // Two implicit conversion sequences of the same form are
3553  // indistinguishable conversion sequences unless one of the
3554  // following rules apply: (C++ 13.3.3.2p3):
3555 
3556  // List-initialization sequence L1 is a better conversion sequence than
3557  // list-initialization sequence L2 if:
3558  // - L1 converts to std::initializer_list<X> for some X and L2 does not, or,
3559  // if not that,
3560  // - L1 converts to type "array of N1 T", L2 converts to type "array of N2 T",
3561  // and N1 is smaller than N2.,
3562  // even if one of the other rules in this paragraph would otherwise apply.
3563  if (!ICS1.isBad()) {
3564  if (ICS1.isStdInitializerListElement() &&
3567  if (!ICS1.isStdInitializerListElement() &&
3570  }
3571 
3572  if (ICS1.isStandard())
3573  // Standard conversion sequence S1 is a better conversion sequence than
3574  // standard conversion sequence S2 if [...]
3575  Result = CompareStandardConversionSequences(S, Loc,
3576  ICS1.Standard, ICS2.Standard);
3577  else if (ICS1.isUserDefined()) {
3578  // User-defined conversion sequence U1 is a better conversion
3579  // sequence than another user-defined conversion sequence U2 if
3580  // they contain the same user-defined conversion function or
3581  // constructor and if the second standard conversion sequence of
3582  // U1 is better than the second standard conversion sequence of
3583  // U2 (C++ 13.3.3.2p3).
3584  if (ICS1.UserDefined.ConversionFunction ==
3586  Result = CompareStandardConversionSequences(S, Loc,
3587  ICS1.UserDefined.After,
3588  ICS2.UserDefined.After);
3589  else
3590  Result = compareConversionFunctions(S,
3593  }
3594 
3595  return Result;
3596 }
3597 
3599  while (Context.UnwrapSimilarPointerTypes(T1, T2)) {
3600  Qualifiers Quals;
3601  T1 = Context.getUnqualifiedArrayType(T1, Quals);
3602  T2 = Context.getUnqualifiedArrayType(T2, Quals);
3603  }
3604 
3605  return Context.hasSameUnqualifiedType(T1, T2);
3606 }
3607 
3608 // Per 13.3.3.2p3, compare the given standard conversion sequences to
3609 // determine if one is a proper subset of the other.
3612  const StandardConversionSequence& SCS1,
3613  const StandardConversionSequence& SCS2) {
3616 
3617  // the identity conversion sequence is considered to be a subsequence of
3618  // any non-identity conversion sequence
3619  if (SCS1.isIdentityConversion() && !SCS2.isIdentityConversion())
3621  else if (!SCS1.isIdentityConversion() && SCS2.isIdentityConversion())
3623 
3624  if (SCS1.Second != SCS2.Second) {
3625  if (SCS1.Second == ICK_Identity)
3627  else if (SCS2.Second == ICK_Identity)
3629  else
3631  } else if (!hasSimilarType(Context, SCS1.getToType(1), SCS2.getToType(1)))
3633 
3634  if (SCS1.Third == SCS2.Third) {
3635  return Context.hasSameType(SCS1.getToType(2), SCS2.getToType(2))? Result
3637  }
3638 
3639  if (SCS1.Third == ICK_Identity)
3640  return Result == ImplicitConversionSequence::Worse
3643 
3644  if (SCS2.Third == ICK_Identity)
3645  return Result == ImplicitConversionSequence::Better
3648 
3650 }
3651 
3652 /// \brief Determine whether one of the given reference bindings is better
3653 /// than the other based on what kind of bindings they are.
3654 static bool
3656  const StandardConversionSequence &SCS2) {
3657  // C++0x [over.ics.rank]p3b4:
3658  // -- S1 and S2 are reference bindings (8.5.3) and neither refers to an
3659  // implicit object parameter of a non-static member function declared
3660  // without a ref-qualifier, and *either* S1 binds an rvalue reference
3661  // to an rvalue and S2 binds an lvalue reference *or S1 binds an
3662  // lvalue reference to a function lvalue and S2 binds an rvalue
3663  // reference*.
3664  //
3665  // FIXME: Rvalue references. We're going rogue with the above edits,
3666  // because the semantics in the current C++0x working paper (N3225 at the
3667  // time of this writing) break the standard definition of std::forward
3668  // and std::reference_wrapper when dealing with references to functions.
3669  // Proposed wording changes submitted to CWG for consideration.
3672  return false;
3673 
3674  return (!SCS1.IsLvalueReference && SCS1.BindsToRvalue &&
3675  SCS2.IsLvalueReference) ||
3676  (SCS1.IsLvalueReference && SCS1.BindsToFunctionLvalue &&
3678 }
3679 
3680 /// CompareStandardConversionSequences - Compare two standard
3681 /// conversion sequences to determine whether one is better than the
3682 /// other or if they are indistinguishable (C++ 13.3.3.2p3).
3685  const StandardConversionSequence& SCS1,
3686  const StandardConversionSequence& SCS2)
3687 {
3688  // Standard conversion sequence S1 is a better conversion sequence
3689  // than standard conversion sequence S2 if (C++ 13.3.3.2p3):
3690 
3691  // -- S1 is a proper subsequence of S2 (comparing the conversion
3692  // sequences in the canonical form defined by 13.3.3.1.1,
3693  // excluding any Lvalue Transformation; the identity conversion
3694  // sequence is considered to be a subsequence of any
3695  // non-identity conversion sequence) or, if not that,
3697  = compareStandardConversionSubsets(S.Context, SCS1, SCS2))
3698  return CK;
3699 
3700  // -- the rank of S1 is better than the rank of S2 (by the rules
3701  // defined below), or, if not that,
3702  ImplicitConversionRank Rank1 = SCS1.getRank();
3703  ImplicitConversionRank Rank2 = SCS2.getRank();
3704  if (Rank1 < Rank2)
3706  else if (Rank2 < Rank1)
3708 
3709  // (C++ 13.3.3.2p4): Two conversion sequences with the same rank
3710  // are indistinguishable unless one of the following rules
3711  // applies:
3712 
3713  // A conversion that is not a conversion of a pointer, or
3714  // pointer to member, to bool is better than another conversion
3715  // that is such a conversion.
3717  return SCS2.isPointerConversionToBool()
3720 
3721  // C++ [over.ics.rank]p4b2:
3722  //
3723  // If class B is derived directly or indirectly from class A,
3724  // conversion of B* to A* is better than conversion of B* to
3725  // void*, and conversion of A* to void* is better than conversion
3726  // of B* to void*.
3727  bool SCS1ConvertsToVoid
3729  bool SCS2ConvertsToVoid
3731  if (SCS1ConvertsToVoid != SCS2ConvertsToVoid) {
3732  // Exactly one of the conversion sequences is a conversion to
3733  // a void pointer; it's the worse conversion.
3734  return SCS2ConvertsToVoid ? ImplicitConversionSequence::Better
3736  } else if (!SCS1ConvertsToVoid && !SCS2ConvertsToVoid) {
3737  // Neither conversion sequence converts to a void pointer; compare
3738  // their derived-to-base conversions.
3740  = CompareDerivedToBaseConversions(S, Loc, SCS1, SCS2))
3741  return DerivedCK;
3742  } else if (SCS1ConvertsToVoid && SCS2ConvertsToVoid &&
3743  !S.Context.hasSameType(SCS1.getFromType(), SCS2.getFromType())) {
3744  // Both conversion sequences are conversions to void
3745  // pointers. Compare the source types to determine if there's an
3746  // inheritance relationship in their sources.
3747  QualType FromType1 = SCS1.getFromType();
3748  QualType FromType2 = SCS2.getFromType();
3749 
3750  // Adjust the types we're converting from via the array-to-pointer
3751  // conversion, if we need to.
3752  if (SCS1.First == ICK_Array_To_Pointer)
3753  FromType1 = S.Context.getArrayDecayedType(FromType1);
3754  if (SCS2.First == ICK_Array_To_Pointer)
3755  FromType2 = S.Context.getArrayDecayedType(FromType2);
3756 
3757  QualType FromPointee1 = FromType1->getPointeeType().getUnqualifiedType();
3758  QualType FromPointee2 = FromType2->getPointeeType().getUnqualifiedType();
3759 
3760  if (S.IsDerivedFrom(Loc, FromPointee2, FromPointee1))
3762  else if (S.IsDerivedFrom(Loc, FromPointee1, FromPointee2))
3764 
3765  // Objective-C++: If one interface is more specific than the
3766  // other, it is the better one.
3767  const ObjCObjectPointerType* FromObjCPtr1
3768  = FromType1->getAs<ObjCObjectPointerType>();
3769  const ObjCObjectPointerType* FromObjCPtr2
3770  = FromType2->getAs<ObjCObjectPointerType>();
3771  if (FromObjCPtr1 && FromObjCPtr2) {
3772  bool AssignLeft = S.Context.canAssignObjCInterfaces(FromObjCPtr1,
3773  FromObjCPtr2);
3774  bool AssignRight = S.Context.canAssignObjCInterfaces(FromObjCPtr2,
3775  FromObjCPtr1);
3776  if (AssignLeft != AssignRight) {
3777  return AssignLeft? ImplicitConversionSequence::Better
3779  }
3780  }
3781  }
3782 
3783  // Compare based on qualification conversions (C++ 13.3.3.2p3,
3784  // bullet 3).
3786  = CompareQualificationConversions(S, SCS1, SCS2))
3787  return QualCK;
3788 
3789  if (SCS1.ReferenceBinding && SCS2.ReferenceBinding) {
3790  // Check for a better reference binding based on the kind of bindings.
3791  if (isBetterReferenceBindingKind(SCS1, SCS2))
3793  else if (isBetterReferenceBindingKind(SCS2, SCS1))
3795 
3796  // C++ [over.ics.rank]p3b4:
3797  // -- S1 and S2 are reference bindings (8.5.3), and the types to
3798  // which the references refer are the same type except for
3799  // top-level cv-qualifiers, and the type to which the reference
3800  // initialized by S2 refers is more cv-qualified than the type
3801  // to which the reference initialized by S1 refers.
3802  QualType T1 = SCS1.getToType(2);
3803  QualType T2 = SCS2.getToType(2);
3804  T1 = S.Context.getCanonicalType(T1);
3805  T2 = S.Context.getCanonicalType(T2);
3806  Qualifiers T1Quals, T2Quals;
3807  QualType UnqualT1 = S.Context.getUnqualifiedArrayType(T1, T1Quals);
3808  QualType UnqualT2 = S.Context.getUnqualifiedArrayType(T2, T2Quals);
3809  if (UnqualT1 == UnqualT2) {
3810  // Objective-C++ ARC: If the references refer to objects with different
3811  // lifetimes, prefer bindings that don't change lifetime.
3812  if (SCS1.ObjCLifetimeConversionBinding !=
3814  return SCS1.ObjCLifetimeConversionBinding
3817  }
3818 
3819  // If the type is an array type, promote the element qualifiers to the
3820  // type for comparison.
3821  if (isa<ArrayType>(T1) && T1Quals)
3822  T1 = S.Context.getQualifiedType(UnqualT1, T1Quals);
3823  if (isa<ArrayType>(T2) && T2Quals)
3824  T2 = S.Context.getQualifiedType(UnqualT2, T2Quals);
3825  if (T2.isMoreQualifiedThan(T1))
3827  else if (T1.isMoreQualifiedThan(T2))
3829  }
3830  }
3831 
3832  // In Microsoft mode, prefer an integral conversion to a
3833  // floating-to-integral conversion if the integral conversion
3834  // is between types of the same size.
3835  // For example:
3836  // void f(float);
3837  // void f(int);
3838  // int main {
3839  // long a;
3840  // f(a);
3841  // }
3842  // Here, MSVC will call f(int) instead of generating a compile error
3843  // as clang will do in standard mode.
3844  if (S.getLangOpts().MSVCCompat && SCS1.Second == ICK_Integral_Conversion &&
3845  SCS2.Second == ICK_Floating_Integral &&
3846  S.Context.getTypeSize(SCS1.getFromType()) ==
3847  S.Context.getTypeSize(SCS1.getToType(2)))
3849 
3851 }
3852 
3853 /// CompareQualificationConversions - Compares two standard conversion
3854 /// sequences to determine whether they can be ranked based on their
3855 /// qualification conversions (C++ 13.3.3.2p3 bullet 3).
3858  const StandardConversionSequence& SCS1,
3859  const StandardConversionSequence& SCS2) {
3860  // C++ 13.3.3.2p3:
3861  // -- S1 and S2 differ only in their qualification conversion and
3862  // yield similar types T1 and T2 (C++ 4.4), respectively, and the
3863  // cv-qualification signature of type T1 is a proper subset of
3864  // the cv-qualification signature of type T2, and S1 is not the
3865  // deprecated string literal array-to-pointer conversion (4.2).
3866  if (SCS1.First != SCS2.First || SCS1.Second != SCS2.Second ||
3867  SCS1.Third != SCS2.Third || SCS1.Third != ICK_Qualification)
3869 
3870  // FIXME: the example in the standard doesn't use a qualification
3871  // conversion (!)
3872  QualType T1 = SCS1.getToType(2);
3873  QualType T2 = SCS2.getToType(2);
3874  T1 = S.Context.getCanonicalType(T1);
3875  T2 = S.Context.getCanonicalType(T2);
3876  Qualifiers T1Quals, T2Quals;
3877  QualType UnqualT1 = S.Context.getUnqualifiedArrayType(T1, T1Quals);
3878  QualType UnqualT2 = S.Context.getUnqualifiedArrayType(T2, T2Quals);
3879 
3880  // If the types are the same, we won't learn anything by unwrapped
3881  // them.
3882  if (UnqualT1 == UnqualT2)
3884 
3885  // If the type is an array type, promote the element qualifiers to the type
3886  // for comparison.
3887  if (isa<ArrayType>(T1) && T1Quals)
3888  T1 = S.Context.getQualifiedType(UnqualT1, T1Quals);
3889  if (isa<ArrayType>(T2) && T2Quals)
3890  T2 = S.Context.getQualifiedType(UnqualT2, T2Quals);
3891 
3894 
3895  // Objective-C++ ARC:
3896  // Prefer qualification conversions not involving a change in lifetime
3897  // to qualification conversions that do not change lifetime.
3900  Result = SCS1.QualificationIncludesObjCLifetime
3903  }
3904 
3905  while (S.Context.UnwrapSimilarPointerTypes(T1, T2)) {
3906  // Within each iteration of the loop, we check the qualifiers to
3907  // determine if this still looks like a qualification
3908  // conversion. Then, if all is well, we unwrap one more level of
3909  // pointers or pointers-to-members and do it all again
3910  // until there are no more pointers or pointers-to-members left
3911  // to unwrap. This essentially mimics what
3912  // IsQualificationConversion does, but here we're checking for a
3913  // strict subset of qualifiers.
3914  if (T1.getCVRQualifiers() == T2.getCVRQualifiers())
3915  // The qualifiers are the same, so this doesn't tell us anything
3916  // about how the sequences rank.
3917  ;
3918  else if (T2.isMoreQualifiedThan(T1)) {
3919  // T1 has fewer qualifiers, so it could be the better sequence.
3920  if (Result == ImplicitConversionSequence::Worse)
3921  // Neither has qualifiers that are a subset of the other's
3922  // qualifiers.
3924 
3926  } else if (T1.isMoreQualifiedThan(T2)) {
3927  // T2 has fewer qualifiers, so it could be the better sequence.
3928  if (Result == ImplicitConversionSequence::Better)
3929  // Neither has qualifiers that are a subset of the other's
3930  // qualifiers.
3932 
3934  } else {
3935  // Qualifiers are disjoint.
3937  }
3938 
3939  // If the types after this point are equivalent, we're done.
3940  if (S.Context.hasSameUnqualifiedType(T1, T2))
3941  break;
3942  }
3943 
3944  // Check that the winning standard conversion sequence isn't using
3945  // the deprecated string literal array to pointer conversion.
3946  switch (Result) {
3950  break;
3951 
3953  break;
3954 
3958  break;
3959  }
3960 
3961  return Result;
3962 }
3963 
3964 /// CompareDerivedToBaseConversions - Compares two standard conversion
3965 /// sequences to determine whether they can be ranked based on their
3966 /// various kinds of derived-to-base conversions (C++
3967 /// [over.ics.rank]p4b3). As part of these checks, we also look at
3968 /// conversions between Objective-C interface types.
3971  const StandardConversionSequence& SCS1,
3972  const StandardConversionSequence& SCS2) {
3973  QualType FromType1 = SCS1.getFromType();
3974  QualType ToType1 = SCS1.getToType(1);
3975  QualType FromType2 = SCS2.getFromType();
3976  QualType ToType2 = SCS2.getToType(1);
3977 
3978  // Adjust the types we're converting from via the array-to-pointer
3979  // conversion, if we need to.
3980  if (SCS1.First == ICK_Array_To_Pointer)
3981  FromType1 = S.Context.getArrayDecayedType(FromType1);
3982  if (SCS2.First == ICK_Array_To_Pointer)
3983  FromType2 = S.Context.getArrayDecayedType(FromType2);
3984 
3985  // Canonicalize all of the types.
3986  FromType1 = S.Context.getCanonicalType(FromType1);
3987  ToType1 = S.Context.getCanonicalType(ToType1);
3988  FromType2 = S.Context.getCanonicalType(FromType2);
3989  ToType2 = S.Context.getCanonicalType(ToType2);
3990 
3991  // C++ [over.ics.rank]p4b3:
3992  //
3993  // If class B is derived directly or indirectly from class A and
3994  // class C is derived directly or indirectly from B,
3995  //
3996  // Compare based on pointer conversions.
3997  if (SCS1.Second == ICK_Pointer_Conversion &&
3998  SCS2.Second == ICK_Pointer_Conversion &&
3999  /*FIXME: Remove if Objective-C id conversions get their own rank*/
4000  FromType1->isPointerType() && FromType2->isPointerType() &&
4001  ToType1->isPointerType() && ToType2->isPointerType()) {
4002  QualType FromPointee1
4003  = FromType1->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
4004  QualType ToPointee1
4005  = ToType1->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
4006  QualType FromPointee2
4007  = FromType2->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
4008  QualType ToPointee2
4009  = ToType2->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
4010 
4011  // -- conversion of C* to B* is better than conversion of C* to A*,
4012  if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
4013  if (S.IsDerivedFrom(Loc, ToPointee1, ToPointee2))
4015  else if (S.IsDerivedFrom(Loc, ToPointee2, ToPointee1))
4017  }
4018 
4019  // -- conversion of B* to A* is better than conversion of C* to A*,
4020  if (FromPointee1 != FromPointee2 && ToPointee1 == ToPointee2) {
4021  if (S.IsDerivedFrom(Loc, FromPointee2, FromPointee1))
4023  else if (S.IsDerivedFrom(Loc, FromPointee1, FromPointee2))
4025  }
4026  } else if (SCS1.Second == ICK_Pointer_Conversion &&
4027  SCS2.Second == ICK_Pointer_Conversion) {
4028  const ObjCObjectPointerType *FromPtr1
4029  = FromType1->getAs<ObjCObjectPointerType>();
4030  const ObjCObjectPointerType *FromPtr2
4031  = FromType2->getAs<ObjCObjectPointerType>();
4032  const ObjCObjectPointerType *ToPtr1
4033  = ToType1->getAs<ObjCObjectPointerType>();
4034  const ObjCObjectPointerType *ToPtr2
4035  = ToType2->getAs<ObjCObjectPointerType>();
4036 
4037  if (FromPtr1 && FromPtr2 && ToPtr1 && ToPtr2) {
4038  // Apply the same conversion ranking rules for Objective-C pointer types
4039  // that we do for C++ pointers to class types. However, we employ the
4040  // Objective-C pseudo-subtyping relationship used for assignment of
4041  // Objective-C pointer types.
4042  bool FromAssignLeft
4043  = S.Context.canAssignObjCInterfaces(FromPtr1, FromPtr2);
4044  bool FromAssignRight
4045  = S.Context.canAssignObjCInterfaces(FromPtr2, FromPtr1);
4046  bool ToAssignLeft
4047  = S.Context.canAssignObjCInterfaces(ToPtr1, ToPtr2);
4048  bool ToAssignRight
4049  = S.Context.canAssignObjCInterfaces(ToPtr2, ToPtr1);
4050 
4051  // A conversion to an a non-id object pointer type or qualified 'id'
4052  // type is better than a conversion to 'id'.
4053  if (ToPtr1->isObjCIdType() &&
4054  (ToPtr2->isObjCQualifiedIdType() || ToPtr2->getInterfaceDecl()))
4056  if (ToPtr2->isObjCIdType() &&
4057  (ToPtr1->isObjCQualifiedIdType() || ToPtr1->getInterfaceDecl()))
4059 
4060  // A conversion to a non-id object pointer type is better than a
4061  // conversion to a qualified 'id' type
4062  if (ToPtr1->isObjCQualifiedIdType() && ToPtr2->getInterfaceDecl())
4064  if (ToPtr2->isObjCQualifiedIdType() && ToPtr1->getInterfaceDecl())
4066 
4067  // A conversion to an a non-Class object pointer type or qualified 'Class'
4068  // type is better than a conversion to 'Class'.
4069  if (ToPtr1->isObjCClassType() &&
4070  (ToPtr2->isObjCQualifiedClassType() || ToPtr2->getInterfaceDecl()))
4072  if (ToPtr2->isObjCClassType() &&
4073  (ToPtr1->isObjCQualifiedClassType() || ToPtr1->getInterfaceDecl()))
4075 
4076  // A conversion to a non-Class object pointer type is better than a
4077  // conversion to a qualified 'Class' type.
4078  if (ToPtr1->isObjCQualifiedClassType() && ToPtr2->getInterfaceDecl())
4080  if (ToPtr2->isObjCQualifiedClassType() && ToPtr1->getInterfaceDecl())
4082 
4083  // -- "conversion of C* to B* is better than conversion of C* to A*,"
4084  if (S.Context.hasSameType(FromType1, FromType2) &&
4085  !FromPtr1->isObjCIdType() && !FromPtr1->isObjCClassType() &&
4086  (ToAssignLeft != ToAssignRight)) {
4087  if (FromPtr1->isSpecialized()) {
4088  // "conversion of B<A> * to B * is better than conversion of B * to
4089  // C *.
4090  bool IsFirstSame =
4091  FromPtr1->getInterfaceDecl() == ToPtr1->getInterfaceDecl();
4092  bool IsSecondSame =
4093  FromPtr1->getInterfaceDecl() == ToPtr2->getInterfaceDecl();
4094  if (IsFirstSame) {
4095  if (!IsSecondSame)
4097  } else if (IsSecondSame)
4099  }
4100  return ToAssignLeft? ImplicitConversionSequence::Worse
4102  }
4103 
4104  // -- "conversion of B* to A* is better than conversion of C* to A*,"
4105  if (S.Context.hasSameUnqualifiedType(ToType1, ToType2) &&
4106  (FromAssignLeft != FromAssignRight))
4107  return FromAssignLeft? ImplicitConversionSequence::Better
4109  }
4110  }
4111 
4112  // Ranking of member-pointer types.
4113  if (SCS1.Second == ICK_Pointer_Member && SCS2.Second == ICK_Pointer_Member &&
4114  FromType1->isMemberPointerType() && FromType2->isMemberPointerType() &&
4115  ToType1->isMemberPointerType() && ToType2->isMemberPointerType()) {
4116  const MemberPointerType * FromMemPointer1 =
4117  FromType1->getAs<MemberPointerType>();
4118  const MemberPointerType * ToMemPointer1 =
4119  ToType1->getAs<MemberPointerType>();
4120  const MemberPointerType * FromMemPointer2 =
4121  FromType2->getAs<MemberPointerType>();
4122  const MemberPointerType * ToMemPointer2 =
4123  ToType2->getAs<MemberPointerType>();
4124  const Type *FromPointeeType1 = FromMemPointer1->getClass();
4125  const Type *ToPointeeType1 = ToMemPointer1->getClass();
4126  const Type *FromPointeeType2 = FromMemPointer2->getClass();
4127  const Type *ToPointeeType2 = ToMemPointer2->getClass();
4128  QualType FromPointee1 = QualType(FromPointeeType1, 0).getUnqualifiedType();
4129  QualType ToPointee1 = QualType(ToPointeeType1, 0).getUnqualifiedType();
4130  QualType FromPointee2 = QualType(FromPointeeType2, 0).getUnqualifiedType();
4131  QualType ToPointee2 = QualType(ToPointeeType2, 0).getUnqualifiedType();
4132  // conversion of A::* to B::* is better than conversion of A::* to C::*,
4133  if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
4134  if (S.IsDerivedFrom(Loc, ToPointee1, ToPointee2))
4136  else if (S.IsDerivedFrom(Loc, ToPointee2, ToPointee1))
4138  }
4139  // conversion of B::* to C::* is better than conversion of A::* to C::*
4140  if (ToPointee1 == ToPointee2 && FromPointee1 != FromPointee2) {
4141  if (S.IsDerivedFrom(Loc, FromPointee1, FromPointee2))
4143  else if (S.IsDerivedFrom(Loc, FromPointee2, FromPointee1))
4145  }
4146  }
4147 
4148  if (SCS1.Second == ICK_Derived_To_Base) {
4149  // -- conversion of C to B is better than conversion of C to A,
4150  // -- binding of an expression of type C to a reference of type
4151  // B& is better than binding an expression of type C to a
4152  // reference of type A&,
4153  if (S.Context.hasSameUnqualifiedType(FromType1, FromType2) &&
4154  !S.Context.hasSameUnqualifiedType(ToType1, ToType2)) {
4155  if (S.IsDerivedFrom(Loc, ToType1, ToType2))
4157  else if (S.IsDerivedFrom(Loc, ToType2, ToType1))
4159  }
4160 
4161  // -- conversion of B to A is better than conversion of C to A.
4162  // -- binding of an expression of type B to a reference of type
4163  // A& is better than binding an expression of type C to a
4164  // reference of type A&,
4165  if (!S.Context.hasSameUnqualifiedType(FromType1, FromType2) &&
4166  S.Context.hasSameUnqualifiedType(ToType1, ToType2)) {
4167  if (S.IsDerivedFrom(Loc, FromType2, FromType1))
4169  else if (S.IsDerivedFrom(Loc, FromType1, FromType2))
4171  }
4172  }
4173 
4175 }
4176 
4177 /// \brief Determine whether the given type is valid, e.g., it is not an invalid
4178 /// C++ class.
4179 static bool isTypeValid(QualType T) {
4180  if (CXXRecordDecl *Record = T->getAsCXXRecordDecl())
4181  return !Record->isInvalidDecl();
4182 
4183  return true;
4184 }
4185 
4186 /// CompareReferenceRelationship - Compare the two types T1 and T2 to
4187 /// determine whether they are reference-related,
4188 /// reference-compatible, reference-compatible with added
4189 /// qualification, or incompatible, for use in C++ initialization by
4190 /// reference (C++ [dcl.ref.init]p4). Neither type can be a reference
4191 /// type, and the first type (T1) is the pointee type of the reference
4192 /// type being initialized.
4195  QualType OrigT1, QualType OrigT2,
4196  bool &DerivedToBase,
4197  bool &ObjCConversion,
4198  bool &ObjCLifetimeConversion) {
4199  assert(!OrigT1->isReferenceType() &&
4200  "T1 must be the pointee type of the reference type");
4201  assert(!OrigT2->isReferenceType() && "T2 cannot be a reference type");
4202 
4203  QualType T1 = Context.getCanonicalType(OrigT1);
4204  QualType T2 = Context.getCanonicalType(OrigT2);
4205  Qualifiers T1Quals, T2Quals;
4206  QualType UnqualT1 = Context.getUnqualifiedArrayType(T1, T1Quals);
4207  QualType UnqualT2 = Context.getUnqualifiedArrayType(T2, T2Quals);
4208 
4209  // C++ [dcl.init.ref]p4:
4210  // Given types "cv1 T1" and "cv2 T2," "cv1 T1" is
4211  // reference-related to "cv2 T2" if T1 is the same type as T2, or
4212  // T1 is a base class of T2.
4213  DerivedToBase = false;
4214  ObjCConversion = false;
4215  ObjCLifetimeConversion = false;
4216  QualType ConvertedT2;
4217  if (UnqualT1 == UnqualT2) {
4218  // Nothing to do.
4219  } else if (isCompleteType(Loc, OrigT2) &&
4220  isTypeValid(UnqualT1) && isTypeValid(UnqualT2) &&
4221  IsDerivedFrom(Loc, UnqualT2, UnqualT1))
4222  DerivedToBase = true;
4223  else if (UnqualT1->isObjCObjectOrInterfaceType() &&
4224  UnqualT2->isObjCObjectOrInterfaceType() &&
4225  Context.canBindObjCObjectType(UnqualT1, UnqualT2))
4226  ObjCConversion = true;
4227  else if (UnqualT2->isFunctionType() &&
4228  IsFunctionConversion(UnqualT2, UnqualT1, ConvertedT2))
4229  // C++1z [dcl.init.ref]p4:
4230  // cv1 T1" is reference-compatible with "cv2 T2" if [...] T2 is "noexcept
4231  // function" and T1 is "function"
4232  //
4233  // We extend this to also apply to 'noreturn', so allow any function
4234  // conversion between function types.
4235  return Ref_Compatible;
4236  else
4237  return Ref_Incompatible;
4238 
4239  // At this point, we know that T1 and T2 are reference-related (at
4240  // least).
4241 
4242  // If the type is an array type, promote the element qualifiers to the type
4243  // for comparison.
4244  if (isa<ArrayType>(T1) && T1Quals)
4245  T1 = Context.getQualifiedType(UnqualT1, T1Quals);
4246  if (isa<ArrayType>(T2) && T2Quals)
4247  T2 = Context.getQualifiedType(UnqualT2, T2Quals);
4248 
4249  // C++ [dcl.init.ref]p4:
4250  // "cv1 T1" is reference-compatible with "cv2 T2" if T1 is
4251  // reference-related to T2 and cv1 is the same cv-qualification
4252  // as, or greater cv-qualification than, cv2. For purposes of
4253  // overload resolution, cases for which cv1 is greater
4254  // cv-qualification than cv2 are identified as
4255  // reference-compatible with added qualification (see 13.3.3.2).
4256  //
4257  // Note that we also require equivalence of Objective-C GC and address-space
4258  // qualifiers when performing these computations, so that e.g., an int in
4259  // address space 1 is not reference-compatible with an int in address
4260  // space 2.
4261  if (T1Quals.getObjCLifetime() != T2Quals.getObjCLifetime() &&
4262  T1Quals.compatiblyIncludesObjCLifetime(T2Quals)) {
4263  if (isNonTrivialObjCLifetimeConversion(T2Quals, T1Quals))
4264  ObjCLifetimeConversion = true;
4265 
4266  T1Quals.removeObjCLifetime();
4267  T2Quals.removeObjCLifetime();
4268  }
4269 
4270  // MS compiler ignores __unaligned qualifier for references; do the same.
4271  T1Quals.removeUnaligned();
4272  T2Quals.removeUnaligned();
4273 
4274  if (T1Quals.compatiblyIncludes(T2Quals))
4275  return Ref_Compatible;
4276  else
4277  return Ref_Related;
4278 }
4279 
4280 /// \brief Look for a user-defined conversion to a value reference-compatible
4281 /// with DeclType. Return true if something definite is found.
4282 static bool
4284  QualType DeclType, SourceLocation DeclLoc,
4285  Expr *Init, QualType T2, bool AllowRvalues,
4286  bool AllowExplicit) {
4287  assert(T2->isRecordType() && "Can only find conversions of record types.");
4288  CXXRecordDecl *T2RecordDecl
4289  = dyn_cast<CXXRecordDecl>(T2->getAs<RecordType>()->getDecl());
4290 
4292  const auto &Conversions = T2RecordDecl->getVisibleConversionFunctions();
4293  for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
4294  NamedDecl *D = *I;
4295  CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
4296  if (isa<UsingShadowDecl>(D))
4297  D = cast<UsingShadowDecl>(D)->getTargetDecl();
4298 
4299  FunctionTemplateDecl *ConvTemplate
4300  = dyn_cast<FunctionTemplateDecl>(D);
4301  CXXConversionDecl *Conv;
4302  if (ConvTemplate)
4303  Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
4304  else
4305  Conv = cast<CXXConversionDecl>(D);
4306 
4307  // If this is an explicit conversion, and we're not allowed to consider
4308  // explicit conversions, skip it.
4309  if (!AllowExplicit && Conv->isExplicit())
4310  continue;
4311 
4312  if (AllowRvalues) {
4313  bool DerivedToBase = false;
4314  bool ObjCConversion = false;
4315  bool ObjCLifetimeConversion = false;
4316 
4317  // If we are initializing an rvalue reference, don't permit conversion
4318  // functions that return lvalues.
4319  if (!ConvTemplate && DeclType->isRValueReferenceType()) {
4320  const ReferenceType *RefType
4321  = Conv->getConversionType()->getAs<LValueReferenceType>();
4322  if (RefType && !RefType->getPointeeType()->isFunctionType())
4323  continue;
4324  }
4325 
4326  if (!ConvTemplate &&
4328  DeclLoc,
4329  Conv->getConversionType().getNonReferenceType()
4330  .getUnqualifiedType(),
4332  DerivedToBase, ObjCConversion, ObjCLifetimeConversion) ==
4334  continue;
4335  } else {
4336  // If the conversion function doesn't return a reference type,
4337  // it can't be considered for this conversion. An rvalue reference
4338  // is only acceptable if its referencee is a function type.
4339 
4340  const ReferenceType *RefType =
4341  Conv->getConversionType()->getAs<ReferenceType>();
4342  if (!RefType ||
4343  (!RefType->isLValueReferenceType() &&
4344  !RefType->getPointeeType()->isFunctionType()))
4345  continue;
4346  }
4347 
4348  if (ConvTemplate)
4349  S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(), ActingDC,
4350  Init, DeclType, CandidateSet,
4351  /*AllowObjCConversionOnExplicit=*/false);
4352  else
4353  S.AddConversionCandidate(Conv, I.getPair(), ActingDC, Init,
4354  DeclType, CandidateSet,
4355  /*AllowObjCConversionOnExplicit=*/false);
4356  }
4357 
4358  bool HadMultipleCandidates = (CandidateSet.size() > 1);
4359 
4361  switch (CandidateSet.BestViableFunction(S, DeclLoc, Best, true)) {
4362  case OR_Success:
4363  // C++ [over.ics.ref]p1:
4364  //
4365  // [...] If the parameter binds directly to the result of
4366  // applying a conversion function to the argument
4367  // expression, the implicit conversion sequence is a
4368  // user-defined conversion sequence (13.3.3.1.2), with the
4369  // second standard conversion sequence either an identity
4370  // conversion or, if the conversion function returns an
4371  // entity of a type that is a derived class of the parameter
4372  // type, a derived-to-base Conversion.
4373  if (!Best->FinalConversion.DirectBinding)
4374  return false;
4375 
4376  ICS.setUserDefined();
4377  ICS.UserDefined.Before = Best->Conversions[0].Standard;
4378  ICS.UserDefined.After = Best->FinalConversion;
4379  ICS.UserDefined.HadMultipleCandidates = HadMultipleCandidates;
4380  ICS.UserDefined.ConversionFunction = Best->Function;
4381  ICS.UserDefined.FoundConversionFunction = Best->FoundDecl;
4382  ICS.UserDefined.EllipsisConversion = false;
4383  assert(ICS.UserDefined.After.ReferenceBinding &&
4385  "Expected a direct reference binding!");
4386  return true;
4387 
4388  case OR_Ambiguous:
4389  ICS.setAmbiguous();
4390  for (OverloadCandidateSet::iterator Cand = CandidateSet.begin();
4391  Cand != CandidateSet.end(); ++Cand)
4392  if (Cand->Viable)
4393  ICS.Ambiguous.addConversion(Cand->FoundDecl, Cand->Function);
4394  return true;
4395 
4396  case OR_No_Viable_Function:
4397  case OR_Deleted:
4398  // There was no suitable conversion, or we found a deleted
4399  // conversion; continue with other checks.
4400  return false;
4401  }
4402 
4403  llvm_unreachable("Invalid OverloadResult!");
4404 }
4405 
4406 /// \brief Compute an implicit conversion sequence for reference
4407 /// initialization.
4409 TryReferenceInit(Sema &S, Expr *Init, QualType DeclType,
4410  SourceLocation DeclLoc,
4411  bool SuppressUserConversions,
4412  bool AllowExplicit) {
4413  assert(DeclType->isReferenceType() && "Reference init needs a reference");
4414 
4415  // Most paths end in a failed conversion.
4417  ICS.setBad(BadConversionSequence::no_conversion, Init, DeclType);
4418 
4419  QualType T1 = DeclType->getAs<ReferenceType>()->getPointeeType();
4420  QualType T2 = Init->getType();
4421 
4422  // If the initializer is the address of an overloaded function, try
4423  // to resolve the overloaded function. If all goes well, T2 is the
4424  // type of the resulting function.
4425  if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) {
4426  DeclAccessPair Found;
4427  if (FunctionDecl *Fn = S.ResolveAddressOfOverloadedFunction(Init, DeclType,
4428  false, Found))
4429  T2 = Fn->getType();
4430  }
4431 
4432  // Compute some basic properties of the types and the initializer.
4433  bool isRValRef = DeclType->isRValueReferenceType();
4434  bool DerivedToBase = false;
4435  bool ObjCConversion = false;
4436  bool ObjCLifetimeConversion = false;
4437  Expr::Classification InitCategory = Init->Classify(S.Context);
4438  Sema::ReferenceCompareResult RefRelationship
4439  = S.CompareReferenceRelationship(DeclLoc, T1, T2, DerivedToBase,
4440  ObjCConversion, ObjCLifetimeConversion);
4441 
4442 
4443  // C++0x [dcl.init.ref]p5:
4444  // A reference to type "cv1 T1" is initialized by an expression
4445  // of type "cv2 T2" as follows:
4446 
4447  // -- If reference is an lvalue reference and the initializer expression
4448  if (!isRValRef) {
4449  // -- is an lvalue (but is not a bit-field), and "cv1 T1" is
4450  // reference-compatible with "cv2 T2," or
4451  //
4452  // Per C++ [over.ics.ref]p4, we don't check the bit-field property here.
4453  if (InitCategory.isLValue() && RefRelationship == Sema::Ref_Compatible) {
4454  // C++ [over.ics.ref]p1:
4455  // When a parameter of reference type binds directly (8.5.3)
4456  // to an argument expression, the implicit conversion sequence
4457  // is the identity conversion, unless the argument expression
4458  // has a type that is a derived class of the parameter type,
4459  // in which case the implicit conversion sequence is a
4460  // derived-to-base Conversion (13.3.3.1).
4461  ICS.setStandard();
4462  ICS.Standard.First = ICK_Identity;
4463  ICS.Standard.Second = DerivedToBase? ICK_Derived_To_Base
4464  : ObjCConversion? ICK_Compatible_Conversion
4465  : ICK_Identity;
4466  ICS.Standard.Third = ICK_Identity;
4467  ICS.Standard.FromTypePtr = T2.getAsOpaquePtr();
4468  ICS.Standard.setToType(0, T2);
4469  ICS.Standard.setToType(1, T1);
4470  ICS.Standard.setToType(2, T1);
4471  ICS.Standard.ReferenceBinding = true;
4472  ICS.Standard.DirectBinding = true;
4473  ICS.Standard.IsLvalueReference = !isRValRef;
4474  ICS.Standard.BindsToFunctionLvalue = T2->isFunctionType();
4475  ICS.Standard.BindsToRvalue = false;
4476  ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false;
4477  ICS.Standard.ObjCLifetimeConversionBinding = ObjCLifetimeConversion;
4478  ICS.Standard.CopyConstructor = nullptr;
4479  ICS.Standard.DeprecatedStringLiteralToCharPtr = false;
4480 
4481  // Nothing more to do: the inaccessibility/ambiguity check for
4482  // derived-to-base conversions is suppressed when we're
4483  // computing the implicit conversion sequence (C++
4484  // [over.best.ics]p2).
4485  return ICS;
4486  }
4487 
4488  // -- has a class type (i.e., T2 is a class type), where T1 is
4489  // not reference-related to T2, and can be implicitly
4490  // converted to an lvalue of type "cv3 T3," where "cv1 T1"
4491  // is reference-compatible with "cv3 T3" 92) (this
4492  // conversion is selected by enumerating the applicable
4493  // conversion functions (13.3.1.6) and choosing the best
4494  // one through overload resolution (13.3)),
4495  if (!SuppressUserConversions && T2->isRecordType() &&
4496  S.isCompleteType(DeclLoc, T2) &&
4497  RefRelationship == Sema::Ref_Incompatible) {
4498  if (FindConversionForRefInit(S, ICS, DeclType, DeclLoc,
4499  Init, T2, /*AllowRvalues=*/false,
4500  AllowExplicit))
4501  return ICS;
4502  }
4503  }
4504 
4505  // -- Otherwise, the reference shall be an lvalue reference to a
4506  // non-volatile const type (i.e., cv1 shall be const), or the reference
4507  // shall be an rvalue reference.
4508  if (!isRValRef && (!T1.isConstQualified() || T1.isVolatileQualified()))
4509  return ICS;
4510 
4511  // -- If the initializer expression
4512  //
4513  // -- is an xvalue, class prvalue, array prvalue or function
4514  // lvalue and "cv1 T1" is reference-compatible with "cv2 T2", or
4515  if (RefRelationship == Sema::Ref_Compatible &&
4516  (InitCategory.isXValue() ||
4517  (InitCategory.isPRValue() && (T2->isRecordType() || T2->isArrayType())) ||
4518  (InitCategory.isLValue() && T2->isFunctionType()))) {
4519  ICS.setStandard();
4520  ICS.Standard.First = ICK_Identity;
4521  ICS.Standard.Second = DerivedToBase? ICK_Derived_To_Base
4522  : ObjCConversion? ICK_Compatible_Conversion
4523  : ICK_Identity;
4524  ICS.Standard.Third = ICK_Identity;
4525  ICS.Standard.FromTypePtr = T2.getAsOpaquePtr();
4526  ICS.Standard.setToType(0, T2);
4527  ICS.Standard.setToType(1, T1);
4528  ICS.Standard.setToType(2, T1);
4529  ICS.Standard.ReferenceBinding = true;
4530  // In C++0x, this is always a direct binding. In C++98/03, it's a direct
4531  // binding unless we're binding to a class prvalue.
4532  // Note: Although xvalues wouldn't normally show up in C++98/03 code, we
4533  // allow the use of rvalue references in C++98/03 for the benefit of
4534  // standard library implementors; therefore, we need the xvalue check here.
4535  ICS.Standard.DirectBinding =
4536  S.getLangOpts().CPlusPlus11 ||
4537  !(InitCategory.isPRValue() || T2->isRecordType());
4538  ICS.Standard.IsLvalueReference = !isRValRef;
4539  ICS.Standard.BindsToFunctionLvalue = T2->isFunctionType();
4540  ICS.Standard.BindsToRvalue = InitCategory.isRValue();
4541  ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false;
4542  ICS.Standard.ObjCLifetimeConversionBinding = ObjCLifetimeConversion;
4543  ICS.Standard.CopyConstructor = nullptr;
4544  ICS.Standard.DeprecatedStringLiteralToCharPtr = false;
4545  return ICS;
4546  }
4547 
4548  // -- has a class type (i.e., T2 is a class type), where T1 is not
4549  // reference-related to T2, and can be implicitly converted to
4550  // an xvalue, class prvalue, or function lvalue of type
4551  // "cv3 T3", where "cv1 T1" is reference-compatible with
4552  // "cv3 T3",
4553  //
4554  // then the reference is bound to the value of the initializer
4555  // expression in the first case and to the result of the conversion
4556  // in the second case (or, in either case, to an appropriate base
4557  // class subobject).
4558  if (!SuppressUserConversions && RefRelationship == Sema::Ref_Incompatible &&
4559  T2->isRecordType() && S.isCompleteType(DeclLoc, T2) &&
4560  FindConversionForRefInit(S, ICS, DeclType, DeclLoc,
4561  Init, T2, /*AllowRvalues=*/true,
4562  AllowExplicit)) {
4563  // In the second case, if the reference is an rvalue reference
4564  // and the second standard conversion sequence of the
4565  // user-defined conversion sequence includes an lvalue-to-rvalue
4566  // conversion, the program is ill-formed.
4567  if (ICS.isUserDefined() && isRValRef &&
4568  ICS.UserDefined.After.First == ICK_Lvalue_To_Rvalue)
4569  ICS.setBad(BadConversionSequence::no_conversion, Init, DeclType);
4570 
4571  return ICS;
4572  }
4573 
4574  // A temporary of function type cannot be created; don't even try.
4575  if (T1->isFunctionType())
4576  return ICS;
4577 
4578  // -- Otherwise, a temporary of type "cv1 T1" is created and
4579  // initialized from the initializer expression using the
4580  // rules for a non-reference copy initialization (8.5). The
4581  // reference is then bound to the temporary. If T1 is
4582  // reference-related to T2, cv1 must be the same
4583  // cv-qualification as, or greater cv-qualification than,
4584  // cv2; otherwise, the program is ill-formed.
4585  if (RefRelationship == Sema::Ref_Related) {
4586  // If cv1 == cv2 or cv1 is a greater cv-qualified than cv2, then
4587  // we would be reference-compatible or reference-compatible with
4588  // added qualification. But that wasn't the case, so the reference
4589  // initialization fails.
4590  //
4591  // Note that we only want to check address spaces and cvr-qualifiers here.
4592  // ObjC GC, lifetime and unaligned qualifiers aren't important.
4593  Qualifiers T1Quals = T1.getQualifiers();
4594  Qualifiers T2Quals = T2.getQualifiers();
4595  T1Quals.removeObjCGCAttr();
4596  T1Quals.removeObjCLifetime();
4597  T2Quals.removeObjCGCAttr();
4598  T2Quals.removeObjCLifetime();
4599  // MS compiler ignores __unaligned qualifier for references; do the same.
4600  T1Quals.removeUnaligned();
4601  T2Quals.removeUnaligned();
4602  if (!T1Quals.compatiblyIncludes(T2Quals))
4603  return ICS;
4604  }
4605 
4606  // If at least one of the types is a class type, the types are not
4607  // related, and we aren't allowed any user conversions, the
4608  // reference binding fails. This case is important for breaking
4609  // recursion, since TryImplicitConversion below will attempt to
4610  // create a temporary through the use of a copy constructor.
4611  if (SuppressUserConversions && RefRelationship == Sema::Ref_Incompatible &&
4612  (T1->isRecordType() || T2->isRecordType()))
4613  return ICS;
4614 
4615  // If T1 is reference-related to T2 and the reference is an rvalue
4616  // reference, the initializer expression shall not be an lvalue.
4617  if (RefRelationship >= Sema::Ref_Related &&
4618  isRValRef && Init->Classify(S.Context).isLValue())
4619  return ICS;
4620 
4621  // C++ [over.ics.ref]p2:
4622  // When a parameter of reference type is not bound directly to
4623  // an argument expression, the conversion sequence is the one
4624  // required to convert the argument expression to the
4625  // underlying type of the reference according to
4626  // 13.3.3.1. Conceptually, this conversion sequence corresponds
4627  // to copy-initializing a temporary of the underlying type with
4628  // the argument expression. Any difference in top-level
4629  // cv-qualification is subsumed by the initialization itself
4630  // and does not constitute a conversion.
4631  ICS = TryImplicitConversion(S, Init, T1, SuppressUserConversions,
4632  /*AllowExplicit=*/false,
4633  /*InOverloadResolution=*/false,
4634  /*CStyle=*/false,
4635  /*AllowObjCWritebackConversion=*/false,
4636  /*AllowObjCConversionOnExplicit=*/false);
4637 
4638  // Of course, that's still a reference binding.
4639  if (ICS.isStandard()) {
4640  ICS.Standard.ReferenceBinding = true;
4641  ICS.Standard.IsLvalueReference = !isRValRef;
4642  ICS.Standard.BindsToFunctionLvalue = false;
4643  ICS.Standard.BindsToRvalue = true;
4644  ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false;
4645  ICS.Standard.ObjCLifetimeConversionBinding = false;
4646  } else if (ICS.isUserDefined()) {
4647  const ReferenceType *LValRefType =
4648  ICS.UserDefined.ConversionFunction->getReturnType()
4650 
4651  // C++ [over.ics.ref]p3:
4652  // Except for an implicit object parameter, for which see 13.3.1, a
4653  // standard conversion sequence cannot be formed if it requires [...]
4654  // binding an rvalue reference to an lvalue other than a function
4655  // lvalue.
4656  // Note that the function case is not possible here.
4657  if (DeclType->isRValueReferenceType() && LValRefType) {
4658  // FIXME: This is the wrong BadConversionSequence. The problem is binding
4659  // an rvalue reference to a (non-function) lvalue, not binding an lvalue
4660  // reference to an rvalue!
4661  ICS.setBad(BadConversionSequence::lvalue_ref_to_rvalue, Init, DeclType);
4662  return ICS;
4663  }
4664 
4665  ICS.UserDefined.After.ReferenceBinding = true;
4666  ICS.UserDefined.After.IsLvalueReference = !isRValRef;
4667  ICS.UserDefined.After.BindsToFunctionLvalue = false;
4668  ICS.UserDefined.After.BindsToRvalue = !LValRefType;
4669  ICS.UserDefined.After.BindsImplicitObjectArgumentWithoutRefQualifier = false;
4670  ICS.UserDefined.After.ObjCLifetimeConversionBinding = false;
4671  }
4672 
4673  return ICS;
4674 }
4675 
4677 TryCopyInitialization(Sema &S, Expr *From, QualType ToType,
4678  bool SuppressUserConversions,
4679  bool InOverloadResolution,
4680  bool AllowObjCWritebackConversion,
4681  bool AllowExplicit = false);
4682 
4683 /// TryListConversion - Try to copy-initialize a value of type ToType from the
4684 /// initializer list From.
4687  bool SuppressUserConversions,
4688  bool InOverloadResolution,
4689  bool AllowObjCWritebackConversion) {
4690  // C++11 [over.ics.list]p1:
4691  // When an argument is an initializer list, it is not an expression and
4692  // special rules apply for converting it to a parameter type.
4693 
4695  Result.setBad(BadConversionSequence::no_conversion, From, ToType);
4696 
4697  // We need a complete type for what follows. Incomplete types can never be
4698  // initialized from init lists.
4699  if (!S.isCompleteType(From->getLocStart(), ToType))
4700  return Result;
4701 
4702  // Per DR1467:
4703  // If the parameter type is a class X and the initializer list has a single
4704  // element of type cv U, where U is X or a class derived from X, the
4705  // implicit conversion sequence is the one required to convert the element
4706  // to the parameter type.
4707  //
4708  // Otherwise, if the parameter type is a character array [... ]
4709  // and the initializer list has a single element that is an
4710  // appropriately-typed string literal (8.5.2 [dcl.init.string]), the
4711  // implicit conversion sequence is the identity conversion.
4712  if (From->getNumInits() == 1) {
4713  if (ToType->isRecordType()) {
4714  QualType InitType = From->getInit(0)->getType();
4715  if (S.Context.hasSameUnqualifiedType(InitType, ToType) ||
4716  S.IsDerivedFrom(From->getLocStart(), InitType, ToType))
4717  return TryCopyInitialization(S, From->getInit(0), ToType,
4718  SuppressUserConversions,
4719  InOverloadResolution,
4720  AllowObjCWritebackConversion);
4721  }
4722  // FIXME: Check the other conditions here: array of character type,
4723  // initializer is a string literal.
4724  if (ToType->isArrayType()) {
4725  InitializedEntity Entity =
4727  /*Consumed=*/false);
4728  if (S.CanPerformCopyInitialization(Entity, From)) {
4729  Result.setStandard();
4731  Result.Standard.setFromType(ToType);
4732  Result.Standard.setAllToTypes(ToType);
4733  return Result;
4734  }
4735  }
4736  }
4737 
4738  // C++14 [over.ics.list]p2: Otherwise, if the parameter type [...] (below).
4739  // C++11 [over.ics.list]p2:
4740  // If the parameter type is std::initializer_list<X> or "array of X" and
4741  // all the elements can be implicitly converted to X, the implicit
4742  // conversion sequence is the worst conversion necessary to convert an
4743  // element of the list to X.
4744  //
4745  // C++14 [over.ics.list]p3:
4746  // Otherwise, if the parameter type is "array of N X", if the initializer
4747  // list has exactly N elements or if it has fewer than N elements and X is
4748  // default-constructible, and if all the elements of the initializer list
4749  // can be implicitly converted to X, the implicit conversion sequence is
4750  // the worst conversion necessary to convert an element of the list to X.
4751  //
4752  // FIXME: We're missing a lot of these checks.
4753  bool toStdInitializerList = false;
4754  QualType X;
4755  if (ToType->isArrayType())
4756  X = S.Context.getAsArrayType(ToType)->getElementType();
4757  else
4758  toStdInitializerList = S.isStdInitializerList(ToType, &X);
4759  if (!X.isNull()) {
4760  for (unsigned i = 0, e = From->getNumInits(); i < e; ++i) {
4761  Expr *Init = From->getInit(i);
4763  TryCopyInitialization(S, Init, X, SuppressUserConversions,
4764  InOverloadResolution,
4765  AllowObjCWritebackConversion);
4766  // If a single element isn't convertible, fail.
4767  if (ICS.isBad()) {
4768  Result = ICS;
4769  break;
4770  }
4771  // Otherwise, look for the worst conversion.
4772  if (Result.isBad() ||
4774  Result) ==
4776  Result = ICS;
4777  }
4778 
4779  // For an empty list, we won't have computed any conversion sequence.
4780  // Introduce the identity conversion sequence.
4781  if (From->getNumInits() == 0) {
4782  Result.setStandard();
4784  Result.Standard.setFromType(ToType);
4785  Result.Standard.setAllToTypes(ToType);
4786  }
4787 
4788  Result.setStdInitializerListElement(toStdInitializerList);
4789  return Result;
4790  }
4791 
4792  // C++14 [over.ics.list]p4:
4793  // C++11 [over.ics.list]p3:
4794  // Otherwise, if the parameter is a non-aggregate class X and overload
4795  // resolution chooses a single best constructor [...] the implicit
4796  // conversion sequence is a user-defined conversion sequence. If multiple
4797  // constructors are viable but none is better than the others, the
4798  // implicit conversion sequence is a user-defined conversion sequence.
4799  if (ToType->isRecordType() && !ToType->isAggregateType()) {
4800  // This function can deal with initializer lists.
4801  return TryUserDefinedConversion(S, From, ToType, SuppressUserConversions,
4802  /*AllowExplicit=*/false,
4803  InOverloadResolution, /*CStyle=*/false,
4804  AllowObjCWritebackConversion,
4805  /*AllowObjCConversionOnExplicit=*/false);
4806  }
4807 
4808  // C++14 [over.ics.list]p5:
4809  // C++11 [over.ics.list]p4:
4810  // Otherwise, if the parameter has an aggregate type which can be
4811  // initialized from the initializer list [...] the implicit conversion
4812  // sequence is a user-defined conversion sequence.
4813  if (ToType->isAggregateType()) {
4814  // Type is an aggregate, argument is an init list. At this point it comes
4815  // down to checking whether the initialization works.
4816  // FIXME: Find out whether this parameter is consumed or not.
4817  // FIXME: Expose SemaInit's aggregate initialization code so that we don't
4818  // need to call into the initialization code here; overload resolution
4819  // should not be doing that.
4820  InitializedEntity Entity =
4822  /*Consumed=*/false);
4823  if (S.CanPerformCopyInitialization(Entity, From)) {
4824  Result.setUserDefined();
4826  // Initializer lists don't have a type.
4829 
4831  Result.UserDefined.After.setFromType(ToType);
4832  Result.UserDefined.After.setAllToTypes(ToType);
4833  Result.UserDefined.ConversionFunction = nullptr;
4834  }
4835  return Result;
4836  }
4837 
4838  // C++14 [over.ics.list]p6:
4839  // C++11 [over.ics.list]p5:
4840  // Otherwise, if the parameter is a reference, see 13.3.3.1.4.
4841  if (ToType->isReferenceType()) {
4842  // The standard is notoriously unclear here, since 13.3.3.1.4 doesn't
4843  // mention initializer lists in any way. So we go by what list-
4844  // initialization would do and try to extrapolate from that.
4845 
4846  QualType T1 = ToType->getAs<ReferenceType>()->getPointeeType();
4847 
4848  // If the initializer list has a single element that is reference-related
4849  // to the parameter type, we initialize the reference from that.
4850  if (From->getNumInits() == 1) {
4851  Expr *Init = From->getInit(0);
4852 
4853  QualType T2 = Init->getType();
4854 
4855  // If the initializer is the address of an overloaded function, try
4856  // to resolve the overloaded function. If all goes well, T2 is the
4857  // type of the resulting function.
4858  if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) {
4859  DeclAccessPair Found;
4861  Init, ToType, false, Found))
4862  T2 = Fn->getType();
4863  }
4864 
4865  // Compute some basic properties of the types and the initializer.
4866  bool dummy1 = false;
4867  bool dummy2 = false;
4868  bool dummy3 = false;
4869  Sema::ReferenceCompareResult RefRelationship
4870  = S.CompareReferenceRelationship(From->getLocStart(), T1, T2, dummy1,
4871  dummy2, dummy3);
4872 
4873  if (RefRelationship >= Sema::Ref_Related) {
4874  return TryReferenceInit(S, Init, ToType, /*FIXME*/From->getLocStart(),
4875  SuppressUserConversions,
4876  /*AllowExplicit=*/false);
4877  }
4878  }
4879 
4880  // Otherwise, we bind the reference to a temporary created from the
4881  // initializer list.
4882  Result = TryListConversion(S, From, T1, SuppressUserConversions,
4883  InOverloadResolution,
4884  AllowObjCWritebackConversion);
4885  if (Result.isFailure())
4886  return Result;
4887  assert(!Result.isEllipsis() &&
4888  "Sub-initialization cannot result in ellipsis conversion.");
4889 
4890  // Can we even bind to a temporary?
4891  if (ToType->isRValueReferenceType() ||
4892  (T1.isConstQualified() && !T1.isVolatileQualified())) {
4893  StandardConversionSequence &SCS = Result.isStandard() ? Result.Standard :
4894  Result.UserDefined.After;
4895  SCS.ReferenceBinding = true;
4896  SCS.IsLvalueReference = ToType->isLValueReferenceType();
4897  SCS.BindsToRvalue = true;
4898  SCS.BindsToFunctionLvalue = false;
4900  SCS.ObjCLifetimeConversionBinding = false;
4901  } else
4903  From, ToType);
4904  return Result;
4905  }
4906 
4907  // C++14 [over.ics.list]p7:
4908  // C++11 [over.ics.list]p6:
4909  // Otherwise, if the parameter type is not a class:
4910  if (!ToType->isRecordType()) {
4911  // - if the initializer list has one element that is not itself an
4912  // initializer list, the implicit conversion sequence is the one
4913  // required to convert the element to the parameter type.
4914  unsigned NumInits = From->getNumInits();
4915  if (NumInits == 1 && !isa<InitListExpr>(From->getInit(0)))
4916  Result = TryCopyInitialization(S, From->getInit(0), ToType,
4917  SuppressUserConversions,
4918  InOverloadResolution,
4919  AllowObjCWritebackConversion);
4920  // - if the initializer list has no elements, the implicit conversion
4921  // sequence is the identity conversion.
4922  else if (NumInits == 0) {
4923  Result.setStandard();
4925  Result.Standard.setFromType(ToType);
4926  Result.Standard.setAllToTypes(ToType);
4927  }
4928  return Result;
4929  }
4930 
4931  // C++14 [over.ics.list]p8:
4932  // C++11 [over.ics.list]p7:
4933  // In all cases other than those enumerated above, no conversion is possible
4934  return Result;
4935 }
4936 
4937 /// TryCopyInitialization - Try to copy-initialize a value of type
4938 /// ToType from the expression From. Return the implicit conversion
4939 /// sequence required to pass this argument, which may be a bad
4940 /// conversion sequence (meaning that the argument cannot be passed to
4941 /// a parameter of this type). If @p SuppressUserConversions, then we
4942 /// do not permit any user-defined conversion sequences.
4945  bool SuppressUserConversions,
4946  bool InOverloadResolution,
4947  bool AllowObjCWritebackConversion,
4948  bool AllowExplicit) {
4949  if (InitListExpr *FromInitList = dyn_cast<InitListExpr>(From))
4950  return TryListConversion(S, FromInitList, ToType, SuppressUserConversions,
4951  InOverloadResolution,AllowObjCWritebackConversion);
4952 
4953  if (ToType->isReferenceType())
4954  return TryReferenceInit(S, From, ToType,
4955  /*FIXME:*/From->getLocStart(),
4956  SuppressUserConversions,
4957  AllowExplicit);
4958 
4959  return TryImplicitConversion(S, From, ToType,
4960  SuppressUserConversions,
4961  /*AllowExplicit=*/false,
4962  InOverloadResolution,
4963  /*CStyle=*/false,
4964  AllowObjCWritebackConversion,
4965  /*AllowObjCConversionOnExplicit=*/false);
4966 }
4967 
4968 static bool TryCopyInitialization(const CanQualType FromQTy,
4969  const CanQualType ToQTy,
4970  Sema &S,
4971  SourceLocation Loc,
4972  ExprValueKind FromVK) {
4973  OpaqueValueExpr TmpExpr(Loc, FromQTy, FromVK);
4975  TryCopyInitialization(S, &TmpExpr, ToQTy, true, true, false);
4976 
4977  return !ICS.isBad();
4978 }
4979 
4980 /// TryObjectArgumentInitialization - Try to initialize the object
4981 /// parameter of the given member function (@c Method) from the
4982 /// expression @p From.
4985  Expr::Classification FromClassification,
4986  CXXMethodDecl *Method,
4987  CXXRecordDecl *ActingContext) {
4988  QualType ClassType = S.Context.getTypeDeclType(ActingContext);
4989  // [class.dtor]p2: A destructor can be invoked for a const, volatile or
4990  // const volatile object.
4991  unsigned Quals = isa<CXXDestructorDecl>(Method) ?
4993  QualType ImplicitParamType = S.Context.getCVRQualifiedType(ClassType, Quals);
4994 
4995  // Set up the conversion sequence as a "bad" conversion, to allow us
4996  // to exit early.
4998 
4999  // We need to have an object of class type.
5000  if (const PointerType *PT = FromType->getAs<PointerType>()) {
5001  FromType = PT->getPointeeType();
5002 
5003  // When we had a pointer, it's implicitly dereferenced, so we
5004  // better have an lvalue.
5005  assert(FromClassification.isLValue());
5006  }
5007 
5008  assert(FromType->isRecordType());
5009 
5010  // C++0x [over.match.funcs]p4:
5011  // For non-static member functions, the type of the implicit object
5012  // parameter is
5013  //
5014  // - "lvalue reference to cv X" for functions declared without a
5015  // ref-qualifier or with the & ref-qualifier
5016  // - "rvalue reference to cv X" for functions declared with the &&
5017  // ref-qualifier
5018  //
5019  // where X is the class of which the function is a member and cv is the
5020  // cv-qualification on the member function declaration.
5021  //
5022  // However, when finding an implicit conversion sequence for the argument, we
5023  // are not allowed to perform user-defined conversions
5024  // (C++ [over.match.funcs]p5). We perform a simplified version of
5025  // reference binding here, that allows class rvalues to bind to
5026  // non-constant references.
5027 
5028  // First check the qualifiers.
5029  QualType FromTypeCanon = S.Context.getCanonicalType(FromType);
5030  if (ImplicitParamType.getCVRQualifiers()
5031  != FromTypeCanon.getLocalCVRQualifiers() &&
5032  !ImplicitParamType.isAtLeastAsQualifiedAs(FromTypeCanon)) {
5034  FromType, ImplicitParamType);
5035  return ICS;
5036  }
5037 
5038  // Check that we have either the same type or a derived type. It
5039  // affects the conversion rank.
5040  QualType ClassTypeCanon = S.Context.getCanonicalType(ClassType);
5041  ImplicitConversionKind SecondKind;
5042  if (ClassTypeCanon == FromTypeCanon.getLocalUnqualifiedType()) {
5043  SecondKind = ICK_Identity;
5044  } else if (S.IsDerivedFrom(Loc, FromType, ClassType))
5045  SecondKind = ICK_Derived_To_Base;
5046  else {
5048  FromType, ImplicitParamType);
5049  return ICS;
5050  }
5051 
5052  // Check the ref-qualifier.
5053  switch (Method->getRefQualifier()) {
5054  case RQ_None:
5055  // Do nothing; we don't care about lvalueness or rvalueness.
5056  break;
5057 
5058  case RQ_LValue:
5059  if (!FromClassification.isLValue() && Quals != Qualifiers::Const) {
5060  // non-const lvalue reference cannot bind to an rvalue
5062  ImplicitParamType);
5063  return ICS;
5064  }
5065  break;
5066 
5067  case RQ_RValue:
5068  if (!FromClassification.isRValue()) {
5069  // rvalue reference cannot bind to an lvalue
5071  ImplicitParamType);
5072  return ICS;
5073  }
5074  break;
5075  }
5076 
5077  // Success. Mark this as a reference binding.
5078  ICS.setStandard();
5080  ICS.Standard.Second = SecondKind;
5081  ICS.Standard.setFromType(FromType);
5082  ICS.Standard.setAllToTypes(ImplicitParamType);
5083  ICS.Standard.ReferenceBinding = true;
5084  ICS.Standard.DirectBinding = true;
5086  ICS.Standard.BindsToFunctionLvalue = false;
5087  ICS.Standard.BindsToRvalue = FromClassification.isRValue();
5089  = (Method->getRefQualifier() == RQ_None);
5090  return ICS;
5091 }
5092 
5093 /// PerformObjectArgumentInitialization - Perform initialization of
5094 /// the implicit object parameter for the given Method with the given
5095 /// expression.
5096 ExprResult
5098  NestedNameSpecifier *Qualifier,
5099  NamedDecl *FoundDecl,
5100  CXXMethodDecl *Method) {
5101  QualType FromRecordType, DestType;
5102  QualType ImplicitParamRecordType =
5103  Method->getThisType(Context)->getAs<PointerType>()->getPointeeType();
5104 
5105  Expr::Classification FromClassification;
5106  if (const PointerType *PT = From->getType()->getAs<PointerType>()) {
5107  FromRecordType = PT->getPointeeType();
5108  DestType = Method->getThisType(Context);
5109  FromClassification = Expr::Classification::makeSimpleLValue();
5110  } else {
5111  FromRecordType = From->getType();
5112  DestType = ImplicitParamRecordType;
5113  FromClassification = From->Classify(Context);
5114  }
5115 
5116  // Note that we always use the true parent context when performing
5117  // the actual argument initialization.
5119  *this, From->getLocStart(), From->getType(), FromClassification, Method,
5120  Method->getParent());
5121  if (ICS.isBad()) {
5123  Qualifiers FromQs = FromRecordType.getQualifiers();
5124  Qualifiers ToQs = DestType.getQualifiers();
5125  unsigned CVR = FromQs.getCVRQualifiers() & ~ToQs.getCVRQualifiers();
5126  if (CVR) {
5127  Diag(From->getLocStart(),
5128  diag::err_member_function_call_bad_cvr)
5129  << Method->getDeclName() << FromRecordType << (CVR - 1)
5130  << From->getSourceRange();
5131  Diag(Method->getLocation(), diag::note_previous_decl)
5132  << Method->getDeclName();
5133  return ExprError();
5134  }
5135  }
5136 
5137  return Diag(From->getLocStart(),
5138  diag::err_implicit_object_parameter_init)
5139  << ImplicitParamRecordType << FromRecordType << From->getSourceRange();
5140  }
5141 
5142  if (ICS.Standard.Second == ICK_Derived_To_Base) {
5143  ExprResult FromRes =
5144  PerformObjectMemberConversion(From, Qualifier, FoundDecl, Method);
5145  if (FromRes.isInvalid())
5146  return ExprError();
5147  From = FromRes.get();
5148  }
5149 
5150  if (!Context.hasSameType(From->getType(), DestType))
5151  From = ImpCastExprToType(From, DestType, CK_NoOp,
5152  From->getValueKind()).get();
5153  return From;
5154 }
5155 
5156 /// TryContextuallyConvertToBool - Attempt to contextually convert the
5157 /// expression From to bool (C++0x [conv]p3).
5160  return TryImplicitConversion(S, From, S.Context.BoolTy,
5161  /*SuppressUserConversions=*/false,
5162  /*AllowExplicit=*/true,
5163  /*InOverloadResolution=*/false,
5164  /*CStyle=*/false,
5165  /*AllowObjCWritebackConversion=*/false,
5166  /*AllowObjCConversionOnExplicit=*/false);
5167 }
5168 
5169 /// PerformContextuallyConvertToBool - Perform a contextual conversion
5170 /// of the expression From to bool (C++0x [conv]p3).
5172  if (checkPlaceholderForOverload(*this, From))
5173  return ExprError();
5174 
5176  if (!ICS.isBad())
5178 
5180  return Diag(From->getLocStart(),
5181  diag::err_typecheck_bool_condition)
5182  << From->getType() << From->getSourceRange();
5183  return ExprError();
5184 }
5185 
5186 /// Check that the specified conversion is permitted in a converted constant
5187 /// expression, according to C++11 [expr.const]p3. Return true if the conversion
5188 /// is acceptable.
5191  // Since we know that the target type is an integral or unscoped enumeration
5192  // type, most conversion kinds are impossible. All possible First and Third
5193  // conversions are fine.
5194  switch (SCS.Second) {
5195  case ICK_Identity:
5198  case ICK_Integral_Conversion: // Narrowing conversions are checked elsewhere.
5200  return true;
5201 
5203  // Conversion from an integral or unscoped enumeration type to bool is
5204  // classified as ICK_Boolean_Conversion, but it's also arguably an integral
5205  // conversion, so we allow it in a converted constant expression.
5206  //
5207  // FIXME: Per core issue 1407, we should not allow this, but that breaks
5208  // a lot of popular code. We should at least add a warning for this
5209  // (non-conforming) extension.
5211  SCS.getToType(2)->isBooleanType();
5212 
5214  case ICK_Pointer_Member:
5215  // C++1z: null pointer conversions and null member pointer conversions are
5216  // only permitted if the source type is std::nullptr_t.
5217  return SCS.getFromType()->isNullPtrType();
5218 
5220  case ICK_Complex_Promotion:
5223  case ICK_Floating_Integral:
5225  case ICK_Derived_To_Base:
5226  case ICK_Vector_Conversion:
5227  case ICK_Vector_Splat:
5228  case ICK_Complex_Real:
5233  case ICK_C_Only_Conversion:
5235  return false;
5236 
5237  case ICK_Lvalue_To_Rvalue:
5238  case ICK_Array_To_Pointer:
5240  llvm_unreachable("found a first conversion kind in Second");
5241 
5242  case ICK_Qualification:
5243  llvm_unreachable("found a third conversion kind in Second");
5244 
5246  break;
5247  }
5248 
5249  llvm_unreachable("unknown conversion kind");
5250 }
5251 
5252 /// CheckConvertedConstantExpression - Check that the expression From is a
5253 /// converted constant expression of type T, perform the conversion and produce
5254 /// the converted expression, per C++11 [expr.const]p3.
5256  QualType T, APValue &Value,
5257  Sema::CCEKind CCE,
5258  bool RequireInt) {
5259  assert(S.getLangOpts().CPlusPlus11 &&
5260  "converted constant expression outside C++11");
5261 
5262  if (checkPlaceholderForOverload(S, From))
5263  return ExprError();
5264 
5265  // C++1z [expr.const]p3:
5266  // A converted constant expression of type T is an expression,
5267  // implicitly converted to type T, where the converted
5268  // expression is a constant expression and the implicit conversion
5269  // sequence contains only [... list of conversions ...].
5270  // C++1z [stmt.if]p2:
5271  // If the if statement is of the form if constexpr, the value of the
5272  // condition shall be a contextually converted constant expression of type
5273  // bool.
5275  CCE == Sema::CCEK_ConstexprIf
5276  ? TryContextuallyConvertToBool(S, From)
5277  : TryCopyInitialization(S, From, T,
5278  /*SuppressUserConversions=*/false,
5279  /*InOverloadResolution=*/false,
5280  /*AllowObjcWritebackConversion=*/false,
5281  /*AllowExplicit=*/false);
5282  StandardConversionSequence *SCS = nullptr;
5283  switch (ICS.getKind()) {
5285  SCS = &ICS.Standard;
5286  break;
5288  // We are converting to a non-class type, so the Before sequence
5289  // must be trivial.
5290  SCS = &ICS.UserDefined.After;
5291  break;
5294  if (!S.DiagnoseMultipleUserDefinedConversion(From, T))
5295  return S.Diag(From->getLocStart(),
5296  diag::err_typecheck_converted_constant_expression)
5297  << From->getType() << From->getSourceRange() << T;
5298  return ExprError();
5299 
5301  llvm_unreachable("ellipsis conversion in converted constant expression");
5302  }
5303 
5304  // Check that we would only use permitted conversions.
5305  if (!CheckConvertedConstantConversions(S, *SCS)) {
5306  return S.Diag(From->getLocStart(),
5307  diag::err_typecheck_converted_constant_expression_disallowed)
5308  << From->getType() << From->getSourceRange() << T;
5309  }
5310  // [...] and where the reference binding (if any) binds directly.
5311  if (SCS->ReferenceBinding && !SCS->DirectBinding) {
5312  return S.Diag(From->getLocStart(),
5313  diag::err_typecheck_converted_constant_expression_indirect)
5314  << From->getType() << From->getSourceRange() << T;
5315  }
5316 
5317  ExprResult Result =
5319  if (Result.isInvalid())
5320  return Result;
5321 
5322  // Check for a narrowing implicit conversion.
5323  APValue PreNarrowingValue;
5324  QualType PreNarrowingType;
5325  switch (SCS->getNarrowingKind(S.Context, Result.get(), PreNarrowingValue,
5326  PreNarrowingType)) {
5328  // Implicit conversion to a narrower type, but the expression is
5329  // value-dependent so we can't tell whether it's actually narrowing.
5330  case NK_Variable_Narrowing:
5331  // Implicit conversion to a narrower type, and the value is not a constant
5332  // expression. We'll diagnose this in a moment.
5333  case NK_Not_Narrowing:
5334  break;
5335 
5336  case NK_Constant_Narrowing:
5337  S.Diag(From->getLocStart(), diag::ext_cce_narrowing)
5338  << CCE << /*Constant*/1
5339  << PreNarrowingValue.getAsString(S.Context, PreNarrowingType) << T;
5340  break;
5341 
5342  case NK_Type_Narrowing:
5343  S.Diag(From->getLocStart(), diag::ext_cce_narrowing)
5344  << CCE << /*Constant*/0 << From->getType() << T;
5345  break;
5346  }
5347 
5348  if (Result.get()->isValueDependent()) {
5349  Value = APValue();
5350  return Result;
5351  }
5352 
5353  // Check the expression is a constant expression.
5355  Expr::EvalResult Eval;
5356  Eval.Diag = &Notes;
5357 
5358  if ((T->isReferenceType()
5359  ? !Result.get()->EvaluateAsLValue(Eval, S.Context)
5360  : !Result.get()->EvaluateAsRValue(Eval, S.Context)) ||
5361  (RequireInt && !Eval.Val.isInt())) {
5362  // The expression can't be folded, so we can't keep it at this position in
5363  // the AST.
5364  Result = ExprError();
5365  } else {
5366  Value = Eval.Val;
5367 
5368  if (Notes.empty()) {
5369  // It's a constant expression.
5370  return Result;
5371  }
5372  }
5373 
5374  // It's not a constant expression. Produce an appropriate diagnostic.
5375  if (Notes.size() == 1 &&
5376  Notes[0].second.getDiagID() == diag::note_invalid_subexpr_in_const_expr)
5377  S.Diag(Notes[0].first, diag::err_expr_not_cce) << CCE;
5378  else {
5379  S.Diag(From->getLocStart(), diag::err_expr_not_cce)
5380  << CCE << From->getSourceRange();
5381  for (unsigned I = 0; I < Notes.size(); ++I)
5382  S.Diag(Notes[I].first, Notes[I].second);
5383  }
5384  return ExprError();
5385 }
5386 
5388  APValue &Value, CCEKind CCE) {
5389  return ::CheckConvertedConstantExpression(*this, From, T, Value, CCE, false);
5390 }
5391 
5393  llvm::APSInt &Value,
5394  CCEKind CCE) {
5395  assert(T->isIntegralOrEnumerationType() && "unexpected converted const type");
5396 
5397  APValue V;
5398  auto R = ::CheckConvertedConstantExpression(*this, From, T, V, CCE, true);
5399  if (!R.isInvalid() && !R.get()->isValueDependent())
5400  Value = V.getInt();
5401  return R;
5402 }
5403 
5404 
5405 /// dropPointerConversions - If the given standard conversion sequence
5406 /// involves any pointer conversions, remove them. This may change
5407 /// the result type of the conversion sequence.
5409  if (SCS.Second == ICK_Pointer_Conversion) {
5410  SCS.Second = ICK_Identity;
5411  SCS.Third = ICK_Identity;
5412  SCS.ToTypePtrs[2] = SCS.ToTypePtrs[1] = SCS.ToTypePtrs[0];
5413  }
5414 }
5415 
5416 /// TryContextuallyConvertToObjCPointer - Attempt to contextually
5417 /// convert the expression From to an Objective-C pointer type.
5420  // Do an implicit conversion to 'id'.
5421  QualType Ty = S.Context.getObjCIdType();
5423  = TryImplicitConversion(S, From, Ty,
5424  // FIXME: Are these flags correct?
5425  /*SuppressUserConversions=*/false,
5426  /*AllowExplicit=*/true,
5427  /*InOverloadResolution=*/false,
5428  /*CStyle=*/false,
5429  /*AllowObjCWritebackConversion=*/false,
5430  /*AllowObjCConversionOnExplicit=*/true);
5431 
5432  // Strip off any final conversions to 'id'.
5433  switch (ICS.getKind()) {
5437  break;
5438 
5441  break;
5442 
5445  break;
5446  }
5447 
5448  return ICS;
5449 }
5450 
5451 /// PerformContextuallyConvertToObjCPointer - Perform a contextual
5452 /// conversion of the expression From to an Objective-C pointer type.
5453 /// Returns a valid but null ExprResult if no conversion sequence exists.
5455  if (checkPlaceholderForOverload(*this, From))
5456  return ExprError();
5457 
5461  if (!ICS.isBad())
5462  return PerformImplicitConversion(From, Ty, ICS, AA_Converting);
5463  return ExprResult();
5464 }
5465 
5466 /// Determine whether the provided type is an integral type, or an enumeration
5467 /// type of a permitted flavor.
5469  return AllowScopedEnumerations ? T->isIntegralOrEnumerationType()
5471 }
5472 
5473 static ExprResult
5476  QualType T, UnresolvedSetImpl &ViableConversions) {
5477 
5478  if (Converter.Suppress)
5479  return ExprError();
5480 
5481  Converter.diagnoseAmbiguous(SemaRef, Loc, T) << From->getSourceRange();
5482  for (unsigned I = 0, N = ViableConversions.size(); I != N; ++I) {
5483  CXXConversionDecl *Conv =
5484  cast<CXXConversionDecl>(ViableConversions[I]->getUnderlyingDecl());
5485  QualType ConvTy = Conv->getConversionType().getNonReferenceType();
5486  Converter.noteAmbiguous(SemaRef, Conv, ConvTy);
5487  }
5488  return From;
5489 }
5490 
5491 static bool
5494  QualType T, bool HadMultipleCandidates,
5495  UnresolvedSetImpl &ExplicitConversions) {
5496  if (ExplicitConversions.size() == 1 && !Converter.Suppress) {
5497  DeclAccessPair Found = ExplicitConversions[0];
5498  CXXConversionDecl *Conversion =
5499  cast<CXXConversionDecl>(Found->getUnderlyingDecl());
5500 
5501  // The user probably meant to invoke the given explicit
5502  // conversion; use it.
5503  QualType ConvTy = Conversion->getConversionType().getNonReferenceType();
5504  std::string TypeStr;
5505  ConvTy.getAsStringInternal(TypeStr, SemaRef.getPrintingPolicy());
5506 
5507  Converter.diagnoseExplicitConv(SemaRef, Loc, T, ConvTy)
5509  "static_cast<" + TypeStr + ">(")
5511  SemaRef.getLocForEndOfToken(From->getLocEnd()), ")");
5512  Converter.noteExplicitConv(SemaRef, Conversion, ConvTy);
5513 
5514  // If we aren't in a SFINAE context, build a call to the
5515  // explicit conversion function.
5516  if (SemaRef.isSFINAEContext())
5517  return true;
5518 
5519  SemaRef.CheckMemberOperatorAccess(From->getExprLoc(), From, nullptr, Found);
5520  ExprResult Result = SemaRef.BuildCXXMemberCallExpr(From, Found, Conversion,
5521  HadMultipleCandidates);
5522  if (Result.isInvalid())
5523  return true;
5524  // Record usage of conversion in an implicit cast.
5525  From = ImplicitCastExpr::Create(SemaRef.Context, Result.get()->getType(),
5526  CK_UserDefinedConversion, Result.get(),
5527  nullptr, Result.get()->getValueKind());
5528  }
5529  return false;
5530 }
5531 
5532 static bool recordConversion(Sema &SemaRef, SourceLocation Loc, Expr *&From,
5534  QualType T, bool HadMultipleCandidates,
5535  DeclAccessPair &Found) {
5536  CXXConversionDecl *Conversion =
5537  cast<CXXConversionDecl>(Found->getUnderlyingDecl());
5538  SemaRef.CheckMemberOperatorAccess(From->getExprLoc(), From, nullptr, Found);
5539 
5540  QualType ToType = Conversion->getConversionType().getNonReferenceType();
5541  if (!Converter.SuppressConversion) {
5542  if (SemaRef.isSFINAEContext())
5543  return true;
5544 
5545  Converter.diagnoseConversion(SemaRef, Loc, T, ToType)
5546  << From->getSourceRange();
5547  }
5548 
5549  ExprResult Result = SemaRef.BuildCXXMemberCallExpr(From, Found, Conversion,
5550  HadMultipleCandidates);
5551  if (Result.isInvalid())
5552  return true;
5553  // Record usage of conversion in an implicit cast.
5554  From = ImplicitCastExpr::Create(SemaRef.Context, Result.get()->getType(),
5555  CK_UserDefinedConversion, Result.get(),
5556  nullptr, Result.get()->getValueKind());
5557  return false;
5558 }
5559 
5561  Sema &SemaRef, SourceLocation Loc, Expr *From,
5562  Sema::ContextualImplicitConverter &Converter) {
5563  if (!Converter.match(From->getType()) && !Converter.Suppress)
5564  Converter.diagnoseNoMatch(SemaRef, Loc, From->getType())
5565  << From->getSourceRange();
5566 
5567  return SemaRef.DefaultLvalueConversion(From);
5568 }
5569 
5570 static void
5572  UnresolvedSetImpl &ViableConversions,
5573  OverloadCandidateSet &CandidateSet) {
5574  for (unsigned I = 0, N = ViableConversions.size(); I != N; ++I) {
5575  DeclAccessPair FoundDecl = ViableConversions[I];
5576  NamedDecl *D = FoundDecl.getDecl();
5577  CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext());
5578  if (isa<UsingShadowDecl>(D))
5579  D = cast<UsingShadowDecl>(D)->getTargetDecl();
5580 
5581  CXXConversionDecl *Conv;
5582  FunctionTemplateDecl *ConvTemplate;
5583  if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D)))
5584  Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
5585  else
5586  Conv = cast<CXXConversionDecl>(D);
5587 
5588  if (ConvTemplate)
5590  ConvTemplate, FoundDecl, ActingContext, From, ToType, CandidateSet,
5591  /*AllowObjCConversionOnExplicit=*/false);
5592  else
5593  SemaRef.AddConversionCandidate(Conv, FoundDecl, ActingContext, From,
5594  ToType, CandidateSet,
5595  /*AllowObjCConversionOnExplicit=*/false);
5596  }
5597 }
5598 
5599 /// \brief Attempt to convert the given expression to a type which is accepted
5600 /// by the given converter.
5601 ///
5602 /// This routine will attempt to convert an expression of class type to a
5603 /// type accepted by the specified converter. In C++11 and before, the class
5604 /// must have a single non-explicit conversion function converting to a matching
5605 /// type. In C++1y, there can be multiple such conversion functions, but only
5606 /// one target type.
5607 ///
5608 /// \param Loc The source location of the construct that requires the
5609 /// conversion.
5610 ///
5611 /// \param From The expression we're converting from.
5612 ///
5613 /// \param Converter Used to control and diagnose the conversion process.
5614 ///
5615 /// \returns The expression, converted to an integral or enumeration type if
5616 /// successful.
5618  SourceLocation Loc, Expr *From, ContextualImplicitConverter &Converter) {
5619  // We can't perform any more checking for type-dependent expressions.
5620  if (From->isTypeDependent())
5621  return From;
5622 
5623  // Process placeholders immediately.
5624  if (From->hasPlaceholderType()) {
5625  ExprResult result = CheckPlaceholderExpr(From);
5626  if (result.isInvalid())
5627  return result;
5628  From = result.get();
5629  }
5630 
5631  // If the expression already has a matching type, we're golden.
5632  QualType T = From->getType();
5633  if (Converter.match(T))
5634  return DefaultLvalueConversion(From);
5635 
5636  // FIXME: Check for missing '()' if T is a function type?
5637 
5638  // We can only perform contextual implicit conversions on objects of class
5639  // type.
5640  const RecordType *RecordTy = T->getAs<RecordType>();
5641  if (!RecordTy || !getLangOpts().CPlusPlus) {
5642  if (!Converter.Suppress)
5643  Converter.diagnoseNoMatch(*this, Loc, T) << From->getSourceRange();
5644  return From;
5645  }
5646 
5647  // We must have a complete class type.
5648  struct TypeDiagnoserPartialDiag : TypeDiagnoser {
5649  ContextualImplicitConverter &Converter;
5650  Expr *From;
5651 
5652  TypeDiagnoserPartialDiag(ContextualImplicitConverter &Converter, Expr *From)
5653  : Converter(Converter), From(From) {}
5654 
5655  void diagnose(Sema &S, SourceLocation Loc, QualType T) override {
5656  Converter.diagnoseIncomplete(S, Loc, T) << From->getSourceRange();
5657  }
5658  } IncompleteDiagnoser(Converter, From);
5659 
5660  if (Converter.Suppress ? !isCompleteType(Loc, T)
5661  : RequireCompleteType(Loc, T, IncompleteDiagnoser))
5662  return From;
5663 
5664  // Look for a conversion to an integral or enumeration type.
5666  ViableConversions; // These are *potentially* viable in C++1y.
5667  UnresolvedSet<4> ExplicitConversions;
5668  const auto &Conversions =
5669  cast<CXXRecordDecl>(RecordTy->getDecl())->getVisibleConversionFunctions();
5670 
5671  bool HadMultipleCandidates =
5672  (std::distance(Conversions.begin(), Conversions.end()) > 1);
5673 
5674  // To check that there is only one target type, in C++1y:
5675  QualType ToType;
5676  bool HasUniqueTargetType = true;
5677 
5678  // Collect explicit or viable (potentially in C++1y) conversions.
5679  for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
5680  NamedDecl *D = (*I)->getUnderlyingDecl();
5681  CXXConversionDecl *Conversion;
5682  FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
5683  if (ConvTemplate) {
5684  if (getLangOpts().CPlusPlus14)
5685  Conversion = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
5686  else
5687  continue; // C++11 does not consider conversion operator templates(?).
5688  } else
5689  Conversion = cast<CXXConversionDecl>(D);
5690 
5691  assert((!ConvTemplate || getLangOpts().CPlusPlus14) &&
5692  "Conversion operator templates are considered potentially "
5693  "viable in C++1y");
5694 
5695  QualType CurToType = Conversion->getConversionType().getNonReferenceType();
5696  if (Converter.match(CurToType) || ConvTemplate) {
5697 
5698  if (Conversion->isExplicit()) {
5699  // FIXME: For C++1y, do we need this restriction?
5700  // cf. diagnoseNoViableConversion()
5701  if (!ConvTemplate)
5702  ExplicitConversions.addDecl(I.getDecl(), I.getAccess());
5703  } else {
5704  if (!ConvTemplate && getLangOpts().CPlusPlus14) {
5705  if (ToType.isNull())
5706  ToType = CurToType.getUnqualifiedType();
5707  else if (HasUniqueTargetType &&
5708  (CurToType.getUnqualifiedType() != ToType))
5709  HasUniqueTargetType = false;
5710  }
5711  ViableConversions.addDecl(I.getDecl(), I.getAccess());
5712  }
5713  }
5714  }
5715 
5716  if (getLangOpts().CPlusPlus14) {
5717  // C++1y [conv]p6:
5718  // ... An expression e of class type E appearing in such a context
5719  // is said to be contextually implicitly converted to a specified
5720  // type T and is well-formed if and only if e can be implicitly
5721  // converted to a type T that is determined as follows: E is searched
5722  // for conversion functions whose return type is cv T or reference to
5723  // cv T such that T is allowed by the context. There shall be
5724  // exactly one such T.
5725 
5726  // If no unique T is found:
5727  if (ToType.isNull()) {
5728  if (diagnoseNoViableConversion(*this, Loc, From, Converter, T,
5729  HadMultipleCandidates,
5730  ExplicitConversions))
5731  return ExprError();
5732  return finishContextualImplicitConversion(*this, Loc, From, Converter);
5733  }
5734 
5735  // If more than one unique Ts are found:
5736  if (!HasUniqueTargetType)
5737  return diagnoseAmbiguousConversion(*this, Loc, From, Converter, T,
5738  ViableConversions);
5739 
5740  // If one unique T is found:
5741  // First, build a candidate set from the previously recorded
5742  // potentially viable conversions.
5744  collectViableConversionCandidates(*this, From, ToType, ViableConversions,
5745  CandidateSet);
5746 
5747  // Then, perform overload resolution over the candidate set.
5749  switch (CandidateSet.BestViableFunction(*this, Loc, Best)) {
5750  case OR_Success: {
5751  // Apply this conversion.
5752  DeclAccessPair Found =
5753  DeclAccessPair::make(Best->Function, Best->FoundDecl.getAccess());
5754  if (recordConversion(*this, Loc, From, Converter, T,
5755  HadMultipleCandidates, Found))
5756  return ExprError();
5757  break;
5758  }
5759  case OR_Ambiguous:
5760  return diagnoseAmbiguousConversion(*this, Loc, From, Converter, T,
5761  ViableConversions);
5762  case OR_No_Viable_Function:
5763  if (diagnoseNoViableConversion(*this, Loc, From, Converter, T,
5764  HadMultipleCandidates,
5765  ExplicitConversions))
5766  return ExprError();
5767  // fall through 'OR_Deleted' case.
5768  case OR_Deleted:
5769  // We'll complain below about a non-integral condition type.
5770  break;
5771  }
5772  } else {
5773  switch (ViableConversions.size()) {
5774  case 0: {
5775  if (diagnoseNoViableConversion(*this, Loc, From, Converter, T,
5776  HadMultipleCandidates,
5777  ExplicitConversions))
5778  return ExprError();
5779 
5780  // We'll complain below about a non-integral condition type.
5781  break;
5782  }
5783  case 1: {
5784  // Apply this conversion.
5785  DeclAccessPair Found = ViableConversions[0];
5786  if (recordConversion(*this, Loc, From, Converter, T,
5787  HadMultipleCandidates, Found))
5788  return ExprError();
5789  break;
5790  }
5791  default:
5792  return diagnoseAmbiguousConversion(*this, Loc, From, Converter, T,
5793  ViableConversions);
5794  }
5795  }
5796 
5797  return finishContextualImplicitConversion(*this, Loc, From, Converter);
5798 }
5799 
5800 /// IsAcceptableNonMemberOperatorCandidate - Determine whether Fn is
5801 /// an acceptable non-member overloaded operator for a call whose
5802 /// arguments have types T1 (and, if non-empty, T2). This routine
5803 /// implements the check in C++ [over.match.oper]p3b2 concerning
5804 /// enumeration types.
5806  FunctionDecl *Fn,
5807  ArrayRef<Expr *> Args) {
5808  QualType T1 = Args[0]->getType();
5809  QualType T2 = Args.size() > 1 ? Args[1]->getType() : QualType();
5810 
5811  if (T1->isDependentType() || (!T2.isNull() && T2->isDependentType()))
5812  return true;
5813 
5814  if (T1->isRecordType() || (!T2.isNull() && T2->isRecordType()))
5815  return true;
5816 
5817  const FunctionProtoType *Proto = Fn->getType()->getAs<FunctionProtoType>();
5818  if (Proto->getNumParams() < 1)
5819  return false;
5820 
5821  if (T1->isEnumeralType()) {
5822  QualType ArgType = Proto->getParamType(0).getNonReferenceType();
5823  if (Context.hasSameUnqualifiedType(T1, ArgType))
5824  return true;
5825  }
5826 
5827  if (Proto->getNumParams() < 2)
5828  return false;
5829 
5830  if (!T2.isNull() && T2->isEnumeralType()) {
5831  QualType ArgType = Proto->getParamType(1).getNonReferenceType();
5832  if (Context.hasSameUnqualifiedType(T2, ArgType))
5833  return true;
5834  }
5835 
5836  return false;
5837 }
5838 
5839 /// AddOverloadCandidate - Adds the given function to the set of
5840 /// candidate functions, using the given function call arguments. If
5841 /// @p SuppressUserConversions, then don't allow user-defined
5842 /// conversions via constructors or conversion operators.
5843 ///
5844 /// \param PartialOverloading true if we are performing "partial" overloading
5845 /// based on an incomplete set of function arguments. This feature is used by
5846 /// code completion.
5847 void
5849  DeclAccessPair FoundDecl,
5850  ArrayRef<Expr *> Args,
5851  OverloadCandidateSet &CandidateSet,
5852  bool SuppressUserConversions,
5853  bool PartialOverloading,
5854  bool AllowExplicit,
5855  ConversionSequenceList EarlyConversions) {
5856  const FunctionProtoType *Proto
5857  = dyn_cast<FunctionProtoType>(Function->getType()->getAs<FunctionType>());
5858  assert(Proto && "Functions without a prototype cannot be overloaded");
5859  assert(!Function->getDescribedFunctionTemplate() &&
5860  "Use AddTemplateOverloadCandidate for function templates");
5861 
5862  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Function)) {
5863  if (!isa<CXXConstructorDecl>(Method)) {
5864  // If we get here, it's because we're calling a member function
5865  // that is named without a member access expression (e.g.,
5866  // "this->f") that was either written explicitly or created
5867  // implicitly. This can happen with a qualified call to a member
5868  // function, e.g., X::f(). We use an empty type for the implied
5869  // object argument (C++ [over.call.func]p3), and the acting context
5870  // is irrelevant.
5871  AddMethodCandidate(Method, FoundDecl, Method->getParent(), QualType(),
5873  CandidateSet, SuppressUserConversions,
5874  PartialOverloading, EarlyConversions);
5875  return;
5876  }
5877  // We treat a constructor like a non-member function, since its object
5878  // argument doesn't participate in overload resolution.
5879  }
5880 
5881  if (!CandidateSet.isNewCandidate(Function))
5882  return;
5883 
5884  // C++ [over.match.oper]p3:
5885  // if no operand has a class type, only those non-member functions in the
5886  // lookup set that have a first parameter of type T1 or "reference to
5887  // (possibly cv-qualified) T1", when T1 is an enumeration type, or (if there
5888  // is a right operand) a second parameter of type T2 or "reference to
5889  // (possibly cv-qualified) T2", when T2 is an enumeration type, are
5890  // candidate functions.
5891  if (CandidateSet.getKind() == OverloadCandidateSet::CSK_Operator &&
5893  return;
5894 
5895  // C++11 [class.copy]p11: [DR1402]
5896  // A defaulted move constructor that is defined as deleted is ignored by
5897  // overload resolution.
5898  CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Function);
5899  if (Constructor && Constructor->isDefaulted() && Constructor->isDeleted() &&
5900  Constructor->isMoveConstructor())
5901  return;
5902 
5903  // Overload resolution is always an unevaluated context.
5906 
5907  // Add this candidate
5908  OverloadCandidate &Candidate =
5909  CandidateSet.addCandidate(Args.size(), EarlyConversions);
5910  Candidate.FoundDecl = FoundDecl;
5911  Candidate.Function = Function;
5912  Candidate.Viable = true;
5913  Candidate.IsSurrogate = false;
5914  Candidate.IgnoreObjectArgument = false;
5915  Candidate.ExplicitCallArguments = Args.size();
5916 
5917  if (Constructor) {
5918  // C++ [class.copy]p3:
5919  // A member function template is never instantiated to perform the copy
5920  // of a class object to an object of its class type.
5921  QualType ClassType = Context.getTypeDeclType(Constructor->getParent());
5922  if (Args.size() == 1 && Constructor->isSpecializationCopyingObject() &&
5923  (Context.hasSameUnqualifiedType(ClassType, Args[0]->getType()) ||
5924  IsDerivedFrom(Args[0]->getLocStart(), Args[0]->getType(),
5925  ClassType))) {
5926  Candidate.Viable = false;
5928  return;
5929  }
5930 
5931  // C++ [over.match.funcs]p8: (proposed DR resolution)
5932  // A constructor inherited from class type C that has a first parameter
5933  // of type "reference to P" (including such a constructor instantiated
5934  // from a template) is excluded from the set of candidate functions when
5935  // constructing an object of type cv D if the argument list has exactly
5936  // one argument and D is reference-related to P and P is reference-related
5937  // to C.
5938  auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(FoundDecl.getDecl());
5939  if (Shadow && Args.size() == 1 && Constructor->getNumParams() >= 1 &&
5940  Constructor->getParamDecl(0)->getType()->isReferenceType()) {
5941  QualType P = Constructor->getParamDecl(0)->getType()->getPointeeType();
5942  QualType C = Context.getRecordType(Constructor->getParent());
5943  QualType D = Context.getRecordType(Shadow->getParent());
5944  SourceLocation Loc = Args.front()->getExprLoc();
5945  if ((Context.hasSameUnqualifiedType(P, C) || IsDerivedFrom(Loc, P, C)) &&
5946  (Context.hasSameUnqualifiedType(D, P) || IsDerivedFrom(Loc, D, P))) {
5947  Candidate.Viable = false;
5948  Candidate.FailureKind = ovl_fail_inhctor_slice;
5949  return;
5950  }
5951  }
5952  }
5953 
5954  unsigned NumParams = Proto->getNumParams();
5955 
5956  // (C++ 13.3.2p2): A candidate function having fewer than m
5957  // parameters is viable only if it has an ellipsis in its parameter
5958  // list (8.3.5).
5959  if (TooManyArguments(NumParams, Args.size(), PartialOverloading) &&
5960  !Proto->isVariadic()) {
5961  Candidate.Viable = false;
5963  return;
5964  }
5965 
5966  // (C++ 13.3.2p2): A candidate function having more than m parameters
5967  // is viable only if the (m+1)st parameter has a default argument
5968  // (8.3.6). For the purposes of overload resolution, the
5969  // parameter list is truncated on the right, so that there are
5970  // exactly m parameters.
5971  unsigned MinRequiredArgs = Function->getMinRequiredArguments();
5972  if (Args.size() < MinRequiredArgs && !PartialOverloading) {
5973  // Not enough arguments.
5974  Candidate.Viable = false;
5976  return;
5977  }
5978 
5979  // (CUDA B.1): Check for invalid calls between targets.
5980  if (getLangOpts().CUDA)
5981  if (const FunctionDecl *Caller = dyn_cast<FunctionDecl>(CurContext))
5982  // Skip the check for callers that are implicit members, because in this
5983  // case we may not yet know what the member's target is; the target is
5984  // inferred for the member automatically, based on the bases and fields of
5985  // the class.
5986  if (!Caller->isImplicit() && !IsAllowedCUDACall(Caller, Function)) {
5987  Candidate.Viable = false;
5988  Candidate.FailureKind = ovl_fail_bad_target;
5989  return;
5990  }
5991 
5992  // Determine the implicit conversion sequences for each of the
5993  // arguments.
5994  for (unsigned ArgIdx = 0; ArgIdx < Args.size(); ++ArgIdx) {
5995  if (Candidate.Conversions[ArgIdx].isInitialized()) {
5996  // We already formed a conversion sequence for this parameter during
5997  // template argument deduction.
5998  } else if (ArgIdx < NumParams) {
5999  // (C++ 13.3.2p3): for F to be a viable function, there shall
6000  // exist for each argument an implicit conversion sequence
6001  // (13.3.3.1) that converts that argument to the corresponding
6002  // parameter of F.
6003  QualType ParamType = Proto->getParamType(ArgIdx);
6004  Candidate.Conversions[ArgIdx]
6005  = TryCopyInitialization(*this, Args[ArgIdx], ParamType,
6006  SuppressUserConversions,
6007  /*InOverloadResolution=*/true,
6008  /*AllowObjCWritebackConversion=*/
6009  getLangOpts().ObjCAutoRefCount,
6010  AllowExplicit);
6011  if (Candidate.Conversions[ArgIdx].isBad()) {
6012  Candidate.Viable = false;
6014  return;
6015  }
6016  } else {
6017  // (C++ 13.3.2p2): For the purposes of overload resolution, any
6018  // argument for which there is no corresponding parameter is
6019  // considered to ""match the ellipsis" (C+ 13.3.3.1.3).
6020  Candidate.Conversions[ArgIdx].setEllipsis();
6021  }
6022  }
6023 
6024  if (EnableIfAttr *FailedAttr = CheckEnableIf(Function, Args)) {
6025  Candidate.Viable = false;
6026  Candidate.FailureKind = ovl_fail_enable_if;
6027  Candidate.DeductionFailure.Data = FailedAttr;
6028  return;
6029  }
6030 
6031  if (LangOpts.OpenCL && isOpenCLDisabledDecl(Function)) {
6032  Candidate.Viable = false;
6033  Candidate.FailureKind = ovl_fail_ext_disabled;
6034  return;
6035  }
6036 }
6037 
6039 Sema::SelectBestMethod(Selector Sel, MultiExprArg Args, bool IsInstance,
6041  if (Methods.size() <= 1)
6042  return nullptr;
6043 
6044  for (unsigned b = 0, e = Methods.size(); b < e; b++) {
6045  bool Match = true;
6046  ObjCMethodDecl *Method = Methods[b];
6047  unsigned NumNamedArgs = Sel.getNumArgs();
6048  // Method might have more arguments than selector indicates. This is due
6049  // to addition of c-style arguments in method.
6050  if (Method->param_size() > NumNamedArgs)
6051  NumNamedArgs = Method->param_size();
6052  if (Args.size() < NumNamedArgs)
6053  continue;
6054 
6055  for (unsigned i = 0; i < NumNamedArgs; i++) {
6056  // We can't do any type-checking on a type-dependent argument.
6057  if (Args[i]->isTypeDependent()) {
6058  Match = false;
6059  break;
6060  }
6061 
6062  ParmVarDecl *param = Method->parameters()[i];
6063  Expr *argExpr = Args[i];
6064  assert(argExpr && "SelectBestMethod(): missing expression");
6065 
6066  // Strip the unbridged-cast placeholder expression off unless it's
6067  // a consumed argument.
6068  if (argExpr->hasPlaceholderType(BuiltinType::ARCUnbridgedCast) &&
6069  !param->hasAttr<CFConsumedAttr>())
6070  argExpr = stripARCUnbridgedCast(argExpr);
6071 
6072  // If the parameter is __unknown_anytype, move on to the next method.
6073  if (param->getType() == Context.UnknownAnyTy) {
6074  Match = false;
6075  break;
6076  }
6077 
6078  ImplicitConversionSequence ConversionState
6079  = TryCopyInitialization(*this, argExpr, param->getType(),
6080  /*SuppressUserConversions*/false,
6081  /*InOverloadResolution=*/true,
6082  /*AllowObjCWritebackConversion=*/
6083  getLangOpts().ObjCAutoRefCount,
6084  /*AllowExplicit*/false);
6085  // This function looks for a reasonably-exact match, so we consider
6086  // incompatible pointer conversions to be a failure here.
6087  if (ConversionState.isBad() ||
6088  (ConversionState.isStandard() &&
6089  ConversionState.Standard.Second ==
6091  Match = false;
6092  break;
6093  }
6094  }
6095  // Promote additional arguments to variadic methods.
6096  if (Match && Method->isVariadic()) {
6097  for (unsigned i = NumNamedArgs, e = Args.size(); i < e; ++i) {
6098  if (Args[i]->isTypeDependent()) {
6099  Match = false;
6100  break;
6101  }
6103  nullptr);
6104  if (Arg.isInvalid()) {
6105  Match = false;
6106  break;
6107  }
6108  }
6109  } else {
6110  // Check for extra arguments to non-variadic methods.
6111  if (Args.size() != NumNamedArgs)
6112  Match = false;
6113  else if (Match && NumNamedArgs == 0 && Methods.size() > 1) {
6114  // Special case when selectors have no argument. In this case, select
6115  // one with the most general result type of 'id'.
6116  for (unsigned b = 0, e = Methods.size(); b < e; b++) {
6117  QualType ReturnT = Methods[b]->getReturnType();
6118  if (ReturnT->isObjCIdType())
6119  return Methods[b];
6120  }
6121  }
6122  }
6123 
6124  if (Match)
6125  return Method;
6126  }
6127  return nullptr;
6128 }
6129 
6130 // specific_attr_iterator iterates over enable_if attributes in reverse, and
6131 // enable_if is order-sensitive. As a result, we need to reverse things
6132 // sometimes. Size of 4 elements is arbitrary.
6136  if (!Function->hasAttrs())
6137  return Result;
6138 
6139  const auto &FuncAttrs = Function->getAttrs();
6140  for (Attr *Attr : FuncAttrs)
6141  if (auto *EnableIf = dyn_cast<EnableIfAttr>(Attr))
6142  Result.push_back(EnableIf);
6143 
6144  std::reverse(Result.begin(), Result.end());
6145  return Result;
6146 }
6147 
6148 static bool
6150  ArrayRef<Expr *> Args, Sema::SFINAETrap &Trap,
6151  bool MissingImplicitThis, Expr *&ConvertedThis,
6152  SmallVectorImpl<Expr *> &ConvertedArgs) {
6153  if (ThisArg) {
6154  CXXMethodDecl *Method = cast<CXXMethodDecl>(Function);
6155  assert(!isa<CXXConstructorDecl>(Method) &&
6156  "Shouldn't have `this` for ctors!");
6157  assert(!Method->isStatic() && "Shouldn't have `this` for static methods!");
6159  ThisArg, /*Qualifier=*/nullptr, Method, Method);
6160  if (R.isInvalid())
6161  return false;
6162  ConvertedThis = R.get();
6163  } else {
6164  if (auto *MD = dyn_cast<CXXMethodDecl>(Function)) {
6165  (void)MD;
6166  assert((MissingImplicitThis || MD->isStatic() ||
6167  isa<CXXConstructorDecl>(MD)) &&
6168  "Expected `this` for non-ctor instance methods");
6169  }
6170  ConvertedThis = nullptr;
6171  }
6172 
6173  // Ignore any variadic arguments. Converting them is pointless, since the
6174  // user can't refer to them in the function condition.
6175  unsigned ArgSizeNoVarargs = std::min(Function->param_size(), Args.size());
6176 
6177  // Convert the arguments.
6178  for (unsigned I = 0; I != ArgSizeNoVarargs; ++I) {
6179  ExprResult R;
6181  S.Context, Function->getParamDecl(I)),
6182  SourceLocation(), Args[I]);
6183 
6184  if (R.isInvalid())
6185  return false;
6186 
6187  ConvertedArgs.push_back(R.get());
6188  }
6189 
6190  if (Trap.hasErrorOccurred())
6191  return false;
6192 
6193  // Push default arguments if needed.
6194  if (!Function->isVariadic() && Args.size() < Function->getNumParams()) {
6195  for (unsigned i = Args.size(), e = Function->getNumParams(); i != e; ++i) {
6196  ParmVarDecl *P = Function->getParamDecl(i);
6199  Function->getParamDecl(i)),
6200  SourceLocation(),
6202  : P->getDefaultArg());
6203  if (R.isInvalid())
6204  return false;
6205  ConvertedArgs.push_back(R.get());
6206  }
6207 
6208  if (Trap.hasErrorOccurred())
6209  return false;
6210  }
6211  return true;
6212 }
6213 
6214 EnableIfAttr *Sema::CheckEnableIf(FunctionDecl *Function, ArrayRef<Expr *> Args,
6215  bool MissingImplicitThis) {
6216  SmallVector<EnableIfAttr *, 4> EnableIfAttrs =
6217  getOrderedEnableIfAttrs(Function);
6218  if (EnableIfAttrs.empty())
6219  return nullptr;
6220 
6221  SFINAETrap Trap(*this);
6222  SmallVector<Expr *, 16> ConvertedArgs;
6223  // FIXME: We should look into making enable_if late-parsed.
6224  Expr *DiscardedThis;
6226  *this, Function, /*ThisArg=*/nullptr, Args, Trap,
6227  /*MissingImplicitThis=*/true, DiscardedThis, ConvertedArgs))
6228  return EnableIfAttrs[0];
6229 
6230  for (auto *EIA : EnableIfAttrs) {
6231  APValue Result;
6232  // FIXME: This doesn't consider value-dependent cases, because doing so is
6233  // very difficult. Ideally, we should handle them more gracefully.
6234  if (!EIA->getCond()->EvaluateWithSubstitution(
6235  Result, Context, Function, llvm::makeArrayRef(ConvertedArgs)))
6236  return EIA;
6237 
6238  if (!Result.isInt() || !Result.getInt().getBoolValue())
6239  return EIA;
6240  }
6241  return nullptr;
6242 }
6243 
6244 template <typename CheckFn>
6245 static bool diagnoseDiagnoseIfAttrsWith(Sema &S, const NamedDecl *ND,
6246  bool ArgDependent, SourceLocation Loc,
6247  CheckFn &&IsSuccessful) {
6249  for (const auto *DIA : ND->specific_attrs<DiagnoseIfAttr>()) {
6250  if (ArgDependent == DIA->getArgDependent())
6251  Attrs.push_back(DIA);
6252  }
6253 
6254  // Common case: No diagnose_if attributes, so we can quit early.
6255  if (Attrs.empty())
6256  return false;
6257 
6258  auto WarningBegin = std::stable_partition(
6259  Attrs.begin(), Attrs.end(),
6260  [](const DiagnoseIfAttr *DIA) { return DIA->isError(); });
6261 
6262  // Note that diagnose_if attributes are late-parsed, so they appear in the
6263  // correct order (unlike enable_if attributes).
6264  auto ErrAttr = llvm::find_if(llvm::make_range(Attrs.begin(), WarningBegin),
6265  IsSuccessful);
6266  if (ErrAttr != WarningBegin) {
6267  const DiagnoseIfAttr *DIA = *ErrAttr;
6268  S.Diag(Loc, diag::err_diagnose_if_succeeded) << DIA->getMessage();
6269  S.Diag(DIA->getLocation(), diag::note_from_diagnose_if)
6270  << DIA->getParent() << DIA->getCond()->getSourceRange();
6271  return true;
6272  }
6273 
6274  for (const auto *DIA : llvm::make_range(WarningBegin, Attrs.end()))
6275  if (IsSuccessful(DIA)) {
6276  S.Diag(Loc, diag::warn_diagnose_if_succeeded) << DIA->getMessage();
6277  S.Diag(DIA->getLocation(), diag::note_from_diagnose_if)
6278  << DIA->getParent() << DIA->getCond()->getSourceRange();
6279  }
6280 
6281  return false;
6282 }
6283 
6285  const Expr *ThisArg,
6287  SourceLocation Loc) {
6289  *this, Function, /*ArgDependent=*/true, Loc,
6290  [&](const DiagnoseIfAttr *DIA) {
6291  APValue Result;
6292  // It's sane to use the same Args for any redecl of this function, since
6293  // EvaluateWithSubstitution only cares about the position of each
6294  // argument in the arg list, not the ParmVarDecl* it maps to.
6295  if (!DIA->getCond()->EvaluateWithSubstitution(
6296  Result, Context, cast<FunctionDecl>(DIA->getParent()), Args, ThisArg))
6297  return false;
6298  return Result.isInt() && Result.getInt().getBoolValue();
6299  });
6300 }
6301 
6303  SourceLocation Loc) {
6305  *this, ND, /*ArgDependent=*/false, Loc,
6306  [&](const DiagnoseIfAttr *DIA) {
6307  bool Result;
6308  return DIA->getCond()->EvaluateAsBooleanCondition(Result, Context) &&
6309  Result;
6310  });
6311 }
6312 
6313 /// \brief Add all of the function declarations in the given function set to
6314 /// the overload candidate set.
6316  ArrayRef<Expr *> Args,
6317  OverloadCandidateSet& CandidateSet,
6318  TemplateArgumentListInfo *ExplicitTemplateArgs,
6319  bool SuppressUserConversions,
6320  bool PartialOverloading) {
6321  for (UnresolvedSetIterator F = Fns.begin(), E = Fns.end(); F != E; ++F) {
6322  NamedDecl *D = F.getDecl()->getUnderlyingDecl();
6323  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
6324  if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic()) {
6325  QualType ObjectType;
6326  Expr::Classification ObjectClassification;
6327  if (Expr *E = Args[0]) {
6328  // Use the explit base to restrict the lookup:
6329  ObjectType = E->getType();
6330  ObjectClassification = E->Classify(Context);
6331  } // .. else there is an implit base.
6332  AddMethodCandidate(cast<CXXMethodDecl>(FD), F.getPair(),
6333  cast<CXXMethodDecl>(FD)->getParent(), ObjectType,
6334  ObjectClassification, Args.slice(1), CandidateSet,
6335  SuppressUserConversions, PartialOverloading);
6336  } else {
6337  AddOverloadCandidate(FD, F.getPair(), Args, CandidateSet,
6338  SuppressUserConversions, PartialOverloading);
6339  }
6340  } else {
6341  FunctionTemplateDecl *FunTmpl = cast<FunctionTemplateDecl>(D);
6342  if (isa<CXXMethodDecl>(FunTmpl->getTemplatedDecl()) &&
6343  !cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl())->isStatic()) {
6344  QualType ObjectType;
6345  Expr::Classification ObjectClassification;
6346  if (Expr *E = Args[0]) {
6347  // Use the explit base to restrict the lookup:
6348  ObjectType = E->getType();
6349  ObjectClassification = E->Classify(Context);
6350  } // .. else there is an implit base.
6352  FunTmpl, F.getPair(),
6353  cast<CXXRecordDecl>(FunTmpl->getDeclContext()),
6354  ExplicitTemplateArgs, ObjectType, ObjectClassification,
6355  Args.slice(1), CandidateSet, SuppressUserConversions,
6356  PartialOverloading);
6357  } else {
6358  AddTemplateOverloadCandidate(FunTmpl, F.getPair(),
6359  ExplicitTemplateArgs, Args,
6360  CandidateSet, SuppressUserConversions,
6361  PartialOverloading);
6362  }
6363  }
6364  }
6365 }
6366 
6367 /// AddMethodCandidate - Adds a named decl (which is some kind of
6368 /// method) as a method candidate to the given overload set.
6370  QualType ObjectType,
6371  Expr::Classification ObjectClassification,
6372  ArrayRef<Expr *> Args,
6373  OverloadCandidateSet& CandidateSet,
6374  bool SuppressUserConversions) {
6375  NamedDecl *Decl = FoundDecl.getDecl();
6376  CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(Decl->getDeclContext());
6377 
6378  if (isa<UsingShadowDecl>(Decl))
6379  Decl = cast<UsingShadowDecl>(Decl)->getTargetDecl();
6380 
6381  if (FunctionTemplateDecl *TD = dyn_cast<FunctionTemplateDecl>(Decl)) {
6382  assert(isa<CXXMethodDecl>(TD->getTemplatedDecl()) &&
6383  "Expected a member function template");
6384  AddMethodTemplateCandidate(TD, FoundDecl, ActingContext,
6385  /*ExplicitArgs*/ nullptr, ObjectType,
6386  ObjectClassification, Args, CandidateSet,
6387  SuppressUserConversions);
6388  } else {
6389  AddMethodCandidate(cast<CXXMethodDecl>(Decl), FoundDecl, ActingContext,
6390  ObjectType, ObjectClassification, Args, CandidateSet,
6391  SuppressUserConversions);
6392  }
6393 }
6394 
6395 /// AddMethodCandidate - Adds the given C++ member function to the set
6396 /// of candidate functions, using the given function call arguments
6397 /// and the object argument (@c Object). For example, in a call
6398 /// @c o.f(a1,a2), @c Object will contain @c o and @c Args will contain
6399 /// both @c a1 and @c a2. If @p SuppressUserConversions, then don't
6400 /// allow user-defined conversions via constructors or conversion
6401 /// operators.
6402 void
6404  CXXRecordDecl *ActingContext, QualType ObjectType,
6405  Expr::Classification ObjectClassification,
6406  ArrayRef<Expr *> Args,
6407  OverloadCandidateSet &CandidateSet,
6408  bool SuppressUserConversions,
6409  bool PartialOverloading,
6410  ConversionSequenceList EarlyConversions) {
6411  const FunctionProtoType *Proto
6412  = dyn_cast<FunctionProtoType>(Method->getType()->getAs<FunctionType>());
6413  assert(Proto && "Methods without a prototype cannot be overloaded");
6414  assert(!isa<CXXConstructorDecl>(Method) &&
6415  "Use AddOverloadCandidate for constructors");
6416 
6417  if (!CandidateSet.isNewCandidate(Method))
6418  return;
6419 
6420  // C++11 [class.copy]p23: [DR1402]
6421  // A defaulted move assignment operator that is defined as deleted is
6422  // ignored by overload resolution.
6423  if (Method->isDefaulted() && Method->isDeleted() &&
6424  Method->isMoveAssignmentOperator())
6425  return;
6426 
6427  // Overload resolution is always an unevaluated context.
6430 
6431  // Add this candidate
6432  OverloadCandidate &Candidate =
6433  CandidateSet.addCandidate(Args.size() + 1, EarlyConversions);
6434  Candidate.FoundDecl = FoundDecl;
6435  Candidate.Function = Method;
6436  Candidate.IsSurrogate = false;
6437  Candidate.IgnoreObjectArgument = false;
6438  Candidate.ExplicitCallArguments = Args.size();
6439 
6440  unsigned NumParams = Proto->getNumParams();
6441 
6442  // (C++ 13.3.2p2): A candidate function having fewer than m
6443  // parameters is viable only if it has an ellipsis in its parameter
6444  // list (8.3.5).
6445  if (TooManyArguments(NumParams, Args.size(), PartialOverloading) &&
6446  !Proto->isVariadic()) {
6447  Candidate.Viable = false;
6449  return;
6450  }
6451 
6452  // (C++ 13.3.2p2): A candidate function having more than m parameters
6453  // is viable only if the (m+1)st parameter has a default argument
6454  // (8.3.6). For the purposes of overload resolution, the
6455  // parameter list is truncated on the right, so that there are
6456  // exactly m parameters.
6457  unsigned MinRequiredArgs = Method->getMinRequiredArguments();
6458  if (Args.size() < MinRequiredArgs && !PartialOverloading) {
6459  // Not enough arguments.
6460  Candidate.Viable = false;
6462  return;
6463  }
6464 
6465  Candidate.Viable = true;
6466 
6467  if (Method->isStatic() || ObjectType.isNull())
6468  // The implicit object argument is ignored.
6469  Candidate.IgnoreObjectArgument = true;
6470  else {
6471  // Determine the implicit conversion sequence for the object
6472  // parameter.
6474  *this, CandidateSet.getLocation(), ObjectType, ObjectClassification,
6475  Method, ActingContext);
6476  if (Candidate.Conversions[0].isBad()) {
6477  Candidate.Viable = false;
6479  return;
6480  }
6481  }
6482 
6483  // (CUDA B.1): Check for invalid calls between targets.
6484  if (getLangOpts().CUDA)
6485  if (const FunctionDecl *Caller = dyn_cast<FunctionDecl>(CurContext))
6486  if (!IsAllowedCUDACall(Caller, Method)) {
6487  Candidate.Viable = false;
6488  Candidate.FailureKind = ovl_fail_bad_target;
6489  return;
6490  }
6491 
6492  // Determine the implicit conversion sequences for each of the
6493  // arguments.
6494  for (unsigned ArgIdx = 0; ArgIdx < Args.size(); ++ArgIdx) {
6495  if (Candidate.Conversions[ArgIdx + 1].isInitialized()) {
6496  // We already formed a conversion sequence for this parameter during
6497  // template argument deduction.
6498  } else if (ArgIdx < NumParams) {
6499  // (C++ 13.3.2p3): for F to be a viable function, there shall
6500  // exist for each argument an implicit conversion sequence
6501  // (13.3.3.1) that converts that argument to the corresponding
6502  // parameter of F.
6503  QualType ParamType = Proto->getParamType(ArgIdx);
6504  Candidate.Conversions[ArgIdx + 1]
6505  = TryCopyInitialization(*this, Args[ArgIdx], ParamType,
6506  SuppressUserConversions,
6507  /*InOverloadResolution=*/true,
6508  /*AllowObjCWritebackConversion=*/
6509  getLangOpts().ObjCAutoRefCount);
6510  if (Candidate.Conversions[ArgIdx + 1].isBad()) {
6511  Candidate.Viable = false;
6512  Candidate.FailureKind = ovl_fail_bad_conversion;
6513  return;
6514  }
6515  } else {
6516  // (C++ 13.3.2p2): For the purposes of overload resolution, any
6517  // argument for which there is no corresponding parameter is
6518  // considered to "match the ellipsis" (C+ 13.3.3.1.3).
6519  Candidate.Conversions[ArgIdx + 1].setEllipsis();
6520  }
6521  }
6522 
6523  if (EnableIfAttr *FailedAttr = CheckEnableIf(Method, Args, true)) {
6524  Candidate.Viable = false;
6525  Candidate.FailureKind = ovl_fail_enable_if;
6526  Candidate.DeductionFailure.Data = FailedAttr;
6527  return;
6528  }
6529 }
6530 
6531 /// \brief Add a C++ member function template as a candidate to the candidate
6532 /// set, using template argument deduction to produce an appropriate member
6533 /// function template specialization.
6534 void
6536  DeclAccessPair FoundDecl,
6537  CXXRecordDecl *ActingContext,
6538  TemplateArgumentListInfo *ExplicitTemplateArgs,
6539  QualType ObjectType,
6540  Expr::Classification ObjectClassification,
6541  ArrayRef<Expr *> Args,
6542  OverloadCandidateSet& CandidateSet,
6543  bool SuppressUserConversions,
6544  bool PartialOverloading) {
6545  if (!CandidateSet.isNewCandidate(MethodTmpl))
6546  return;
6547 
6548  // C++ [over.match.funcs]p7:
6549  // In each case where a candidate is a function template, candidate
6550  // function template specializations are generated using template argument
6551  // deduction (14.8.3, 14.8.2). Those candidates are then handled as
6552  // candidate functions in the usual way.113) A given name can refer to one
6553  // or more function templates and also to a set of overloaded non-template
6554  // functions. In such a case, the candidate functions generated from each
6555  // function template are combined with the set of non-template candidate
6556  // functions.
6557  TemplateDeductionInfo Info(CandidateSet.getLocation());
6558  FunctionDecl *Specialization = nullptr;
6559  ConversionSequenceList Conversions;
6561  MethodTmpl, ExplicitTemplateArgs, Args, Specialization, Info,
6562  PartialOverloading, [&](ArrayRef<QualType> ParamTypes) {
6564  MethodTmpl, ParamTypes, Args, CandidateSet, Conversions,
6565  SuppressUserConversions, ActingContext, ObjectType,
6566  ObjectClassification);
6567  })) {
6568  OverloadCandidate &Candidate =
6569  CandidateSet.addCandidate(Conversions.size(), Conversions);
6570  Candidate.FoundDecl = FoundDecl;
6571  Candidate.Function = MethodTmpl->getTemplatedDecl();
6572  Candidate.Viable = false;
6573  Candidate.IsSurrogate = false;
6574  Candidate.IgnoreObjectArgument =
6575  cast<CXXMethodDecl>(Candidate.Function)->isStatic() ||
6576  ObjectType.isNull();
6577  Candidate.ExplicitCallArguments = Args.size();
6580  else {
6581  Candidate.FailureKind = ovl_fail_bad_deduction;
6583  Info);
6584  }
6585  return;
6586  }
6587 
6588  // Add the function template specialization produced by template argument
6589  // deduction as a candidate.
6590  assert(Specialization && "Missing member function template specialization?");
6591  assert(isa<CXXMethodDecl>(Specialization) &&
6592  "Specialization is not a member function?");
6593  AddMethodCandidate(cast<CXXMethodDecl>(Specialization), FoundDecl,
6594  ActingContext, ObjectType, ObjectClassification, Args,
6595  CandidateSet, SuppressUserConversions, PartialOverloading,
6596  Conversions);
6597 }
6598 
6599 /// \brief Add a C++ function template specialization as a candidate
6600 /// in the candidate set, using template argument deduction to produce
6601 /// an appropriate function template specialization.
6602 void
6604  DeclAccessPair FoundDecl,
6605  TemplateArgumentListInfo *ExplicitTemplateArgs,
6606  ArrayRef<Expr *> Args,
6607  OverloadCandidateSet& CandidateSet,
6608  bool SuppressUserConversions,
6609  bool PartialOverloading) {
6610  if (!CandidateSet.isNewCandidate(FunctionTemplate))
6611  return;
6612 
6613  // C++ [over.match.funcs]p7:
6614  // In each case where a candidate is a function template, candidate
6615  // function template specializations are generated using template argument
6616  // deduction (14.8.3, 14.8.2). Those candidates are then handled as
6617  // candidate functions in the usual way.113) A given name can refer to one
6618  // or more function templates and also to a set of overloaded non-template
6619  // functions. In such a case, the candidate functions generated from each
6620  // function template are combined with the set of non-template candidate
6621  // functions.
6622  TemplateDeductionInfo Info(CandidateSet.getLocation());
6623  FunctionDecl *Specialization = nullptr;
6624  ConversionSequenceList Conversions;
6626  FunctionTemplate, ExplicitTemplateArgs, Args, Specialization, Info,
6627  PartialOverloading, [&](ArrayRef<QualType> ParamTypes) {
6628  return CheckNonDependentConversions(FunctionTemplate, ParamTypes,
6629  Args, CandidateSet, Conversions,
6630  SuppressUserConversions);
6631  })) {
6632  OverloadCandidate &Candidate =
6633  CandidateSet.addCandidate(Conversions.size(), Conversions);
6634  Candidate.FoundDecl = FoundDecl;
6635  Candidate.Function = FunctionTemplate->getTemplatedDecl();
6636  Candidate.Viable = false;
6637  Candidate.IsSurrogate = false;
6638  // Ignore the object argument if there is one, since we don't have an object
6639  // type.
6640  Candidate.IgnoreObjectArgument =
6641  isa<CXXMethodDecl>(Candidate.Function) &&
6642  !isa<CXXConstructorDecl>(Candidate.Function);
6643  Candidate.ExplicitCallArguments = Args.size();
6646  else {
6647  Candidate.FailureKind = ovl_fail_bad_deduction;
6649  Info);
6650  }
6651  return;
6652  }
6653 
6654  // Add the function template specialization produced by template argument
6655  // deduction as a candidate.
6656  assert(Specialization && "Missing function template specialization?");
6657  AddOverloadCandidate(Specialization, FoundDecl, Args, CandidateSet,
6658  SuppressUserConversions, PartialOverloading,
6659  /*AllowExplicit*/false, Conversions);
6660 }
6661 
6662 /// Check that implicit conversion sequences can be formed for each argument
6663 /// whose corresponding parameter has a non-dependent type, per DR1391's
6664 /// [temp.deduct.call]p10.
6666  FunctionTemplateDecl *FunctionTemplate, ArrayRef<QualType> ParamTypes,
6667  ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet,
6668  ConversionSequenceList &Conversions, bool SuppressUserConversions,
6669  CXXRecordDecl *ActingContext, QualType ObjectType,
6670  Expr::Classification ObjectClassification) {
6671  // FIXME: The cases in which we allow explicit conversions for constructor
6672  // arguments never consider calling a constructor template. It's not clear
6673  // that is correct.
6674  const bool AllowExplicit = false;
6675 
6676  auto *FD = FunctionTemplate->getTemplatedDecl();
6677  auto *Method = dyn_cast<CXXMethodDecl>(FD);
6678  bool HasThisConversion = Method && !isa<CXXConstructorDecl>(Method);
6679  unsigned ThisConversions = HasThisConversion ? 1 : 0;
6680 
6681  Conversions =
6682  CandidateSet.allocateConversionSequences(ThisConversions + Args.size());
6683 
6684  // Overload resolution is always an unevaluated context.
6687 
6688  // For a method call, check the 'this' conversion here too. DR1391 doesn't
6689  // require that, but this check should never result in a hard error, and
6690  // overload resolution is permitted to sidestep instantiations.
6691  if (HasThisConversion && !cast<CXXMethodDecl>(FD)->isStatic() &&
6692  !ObjectType.isNull()) {
6693  Conversions[0] = TryObjectArgumentInitialization(
6694  *this, CandidateSet.getLocation(), ObjectType, ObjectClassification,
6695  Method, ActingContext);
6696  if (Conversions[0].isBad())
6697  return true;
6698  }
6699 
6700  for (unsigned I = 0, N = std::min(ParamTypes.size(), Args.size()); I != N;
6701  ++I) {
6702  QualType ParamType = ParamTypes[I];
6703  if (!ParamType->isDependentType()) {
6704  Conversions[ThisConversions + I]
6705  = TryCopyInitialization(*this, Args[I], ParamType,
6706  SuppressUserConversions,
6707  /*InOverloadResolution=*/true,
6708  /*AllowObjCWritebackConversion=*/
6709  getLangOpts().ObjCAutoRefCount,
6710  AllowExplicit);
6711  if (Conversions[ThisConversions + I].isBad())
6712  return true;
6713  }
6714  }
6715 
6716  return false;
6717 }
6718 
6719 /// Determine whether this is an allowable conversion from the result
6720 /// of an explicit conversion operator to the expected type, per C++
6721 /// [over.match.conv]p1 and [over.match.ref]p1.
6722 ///
6723 /// \param ConvType The return type of the conversion function.
6724 ///
6725 /// \param ToType The type we are converting to.
6726 ///
6727 /// \param AllowObjCPointerConversion Allow a conversion from one
6728 /// Objective-C pointer to another.
6729 ///
6730 /// \returns true if the conversion is allowable, false otherwise.
6732  QualType ConvType, QualType ToType,
6733  bool AllowObjCPointerConversion) {
6734  QualType ToNonRefType = ToType.getNonReferenceType();
6735 
6736  // Easy case: the types are the same.
6737  if (S.Context.hasSameUnqualifiedType(ConvType, ToNonRefType))
6738  return true;
6739 
6740  // Allow qualification conversions.
6741  bool ObjCLifetimeConversion;
6742  if (S.IsQualificationConversion(ConvType, ToNonRefType, /*CStyle*/false,
6743  ObjCLifetimeConversion))
6744  return true;
6745 
6746  // If we're not allowed to consider Objective-C pointer conversions,
6747  // we're done.
6748  if (!AllowObjCPointerConversion)
6749  return false;
6750 
6751  // Is this an Objective-C pointer conversion?
6752  bool IncompatibleObjC = false;
6753  QualType ConvertedType;
6754  return S.isObjCPointerConversion(ConvType, ToNonRefType, ConvertedType,
6755  IncompatibleObjC);
6756 }
6757 
6758 /// AddConversionCandidate - Add a C++ conversion function as a
6759 /// candidate in the candidate set (C++ [over.match.conv],
6760 /// C++ [over.match.copy]). From is the expression we're converting from,
6761 /// and ToType is the type that we're eventually trying to convert to
6762 /// (which may or may not be the same type as the type that the
6763 /// conversion function produces).
6764 void
6766  DeclAccessPair FoundDecl,
6767  CXXRecordDecl *ActingContext,
6768  Expr *From, QualType ToType,
6769  OverloadCandidateSet& CandidateSet,
6770  bool AllowObjCConversionOnExplicit) {
6771  assert(!Conversion->getDescribedFunctionTemplate() &&
6772  "Conversion function templates use AddTemplateConversionCandidate");
6773  QualType ConvType = Conversion->getConversionType().getNonReferenceType();
6774  if (!CandidateSet.isNewCandidate(Conversion))
6775  return;
6776 
6777  // If the conversion function has an undeduced return type, trigger its
6778  // deduction now.
6779  if (getLangOpts().CPlusPlus14 && ConvType->isUndeducedType()) {
6780  if (DeduceReturnType(Conversion, From->getExprLoc()))
6781  return;
6782  ConvType = Conversion->getConversionType().getNonReferenceType();
6783  }
6784 
6785  // Per C++ [over.match.conv]p1, [over.match.ref]p1, an explicit conversion
6786  // operator is only a candidate if its return type is the target type or
6787  // can be converted to the target type with a qualification conversion.
6788  if (Conversion->isExplicit() &&
6789  !isAllowableExplicitConversion(*this, ConvType, ToType,
6790  AllowObjCConversionOnExplicit))
6791  return;
6792 
6793  // Overload resolution is always an unevaluated context.
6796 
6797  // Add this candidate
6798  OverloadCandidate &Candidate = CandidateSet.addCandidate(1);
6799  Candidate.FoundDecl = FoundDecl;
6800  Candidate.Function = Conversion;
6801  Candidate.IsSurrogate = false;
6802  Candidate.IgnoreObjectArgument = false;
6804  Candidate.FinalConversion.setFromType(ConvType);
6805  Candidate.FinalConversion.setAllToTypes(ToType);
6806  Candidate.Viable = true;
6807  Candidate.ExplicitCallArguments = 1;
6808 
6809  // C++ [over.match.funcs]p4:
6810  // For conversion functions, the function is considered to be a member of
6811  // the class of the implicit implied object argument for the purpose of
6812  // defining the type of the implicit object parameter.
6813  //
6814  // Determine the implicit conversion sequence for the implicit
6815  // object parameter.
6816  QualType ImplicitParamType = From->getType();
6817  if (const PointerType *FromPtrType = ImplicitParamType->getAs<PointerType>())
6818  ImplicitParamType = FromPtrType->getPointeeType();
6819  CXXRecordDecl *ConversionContext
6820  = cast<CXXRecordDecl>(ImplicitParamType->getAs<RecordType>()->getDecl());
6821 
6823  *this, CandidateSet.getLocation(), From->getType(),
6824  From->Classify(Context), Conversion, ConversionContext);
6825 
6826  if (Candidate.Conversions[0].isBad()) {
6827  Candidate.Viable = false;
6829  return;
6830  }
6831 
6832  // We won't go through a user-defined type conversion function to convert a
6833  // derived to base as such conversions are given Conversion Rank. They only
6834  // go through a copy constructor. 13.3.3.1.2-p4 [over.ics.user]
6835  QualType FromCanon
6838  if (FromCanon == ToCanon ||
6839  IsDerivedFrom(CandidateSet.getLocation(), FromCanon, ToCanon)) {
6840  Candidate.Viable = false;
6842  return;
6843  }
6844 
6845  // To determine what the conversion from the result of calling the
6846  // conversion function to the type we're eventually trying to
6847  // convert to (ToType), we need to synthesize a call to the
6848  // conversion function and attempt copy initialization from it. This
6849  // makes sure that we get the right semantics with respect to
6850  // lvalues/rvalues and the type. Fortunately, we can allocate this
6851  // call on the stack and we don't need its arguments to be
6852  // well-formed.
6853  DeclRefExpr ConversionRef(Conversion, false, Conversion->getType(),
6854  VK_LValue, From->getLocStart());
6856  Context.getPointerType(Conversion->getType()),
6857  CK_FunctionToPointerDecay,
6858  &ConversionRef, VK_RValue);
6859 
6860  QualType ConversionType = Conversion->getConversionType();
6861  if (!isCompleteType(From->getLocStart(), ConversionType)) {
6862  Candidate.Viable = false;
6864  return;
6865  }
6866 
6867  ExprValueKind VK = Expr::getValueKindForType(ConversionType);
6868 
6869  // Note that it is safe to allocate CallExpr on the stack here because
6870  // there are 0 arguments (i.e., nothing is allocated using ASTContext's
6871  // allocator).
6872  QualType CallResultType = ConversionType.getNonLValueExprType(Context);
6873  CallExpr Call(Context, &ConversionFn, None, CallResultType, VK,
6874  From->getLocStart());
6876  TryCopyInitialization(*this, &Call, ToType,
6877  /*SuppressUserConversions=*/true,
6878  /*InOverloadResolution=*/false,
6879  /*AllowObjCWritebackConversion=*/false);
6880 
6881  switch (ICS.getKind()) {
6883  Candidate.FinalConversion = ICS.Standard;
6884 
6885  // C++ [over.ics.user]p3:
6886  // If the user-defined conversion is specified by a specialization of a
6887  // conversion function template, the second standard conversion sequence
6888  // shall have exact match rank.
6889  if (Conversion->getPrimaryTemplate() &&
6890  GetConversionRank(ICS.Standard.Second) != ICR_Exact_Match) {
6891  Candidate.Viable = false;
6893  return;
6894  }
6895 
6896  // C++0x [dcl.init.ref]p5:
6897  // In the second case, if the reference is an rvalue reference and
6898  // the second standard conversion sequence of the user-defined
6899  // conversion sequence includes an lvalue-to-rvalue conversion, the
6900  // program is ill-formed.
6901  if (ToType->isRValueReferenceType() &&
6902  ICS.Standard.First == ICK_Lvalue_To_Rvalue) {
6903  Candidate.Viable = false;
6905  return;
6906  }
6907  break;
6908 
6910  Candidate.Viable = false;
6912  return;
6913 
6914  default:
6915  llvm_unreachable(
6916  "Can only end up with a standard conversion sequence or failure");
6917  }
6918 
6919  if (EnableIfAttr *FailedAttr = CheckEnableIf(Conversion, None)) {
6920  Candidate.Viable = false;
6921  Candidate.FailureKind = ovl_fail_enable_if;
6922  Candidate.DeductionFailure.Data = FailedAttr;
6923  return;
6924  }
6925 }
6926 
6927 /// \brief Adds a conversion function template specialization
6928 /// candidate to the overload set, using template argument deduction
6929 /// to deduce the template arguments of the conversion function
6930 /// template from the type that we are converting to (C++
6931 /// [temp.deduct.conv]).
6932 void
6934  DeclAccessPair FoundDecl,
6935  CXXRecordDecl *ActingDC,
6936  Expr *From, QualType ToType,
6937  OverloadCandidateSet &CandidateSet,
6938  bool AllowObjCConversionOnExplicit) {
6939  assert(isa<CXXConversionDecl>(FunctionTemplate->getTemplatedDecl()) &&
6940  "Only conversion function templates permitted here");
6941 
6942  if (!CandidateSet.isNewCandidate(FunctionTemplate))
6943  return;
6944 
6945  TemplateDeductionInfo Info(CandidateSet.getLocation());
6946  CXXConversionDecl *Specialization = nullptr;
6948  = DeduceTemplateArguments(FunctionTemplate, ToType,
6949  Specialization, Info)) {
6950  OverloadCandidate &Candidate = CandidateSet.addCandidate();
6951  Candidate.FoundDecl = FoundDecl;
6952  Candidate.Function = FunctionTemplate->getTemplatedDecl();
6953  Candidate.Viable = false;
6954  Candidate.FailureKind = ovl_fail_bad_deduction;
6955  Candidate.IsSurrogate = false;
6956  Candidate.IgnoreObjectArgument = false;
6957  Candidate.ExplicitCallArguments = 1;
6959  Info);
6960  return;
6961  }
6962 
6963  // Add the conversion function template specialization produced by
6964  // template argument deduction as a candidate.
6965  assert(Specialization && "Missing function template specialization?");
6966  AddConversionCandidate(Specialization, FoundDecl, ActingDC, From, ToType,
6967  CandidateSet, AllowObjCConversionOnExplicit);
6968 }
6969 
6970 /// AddSurrogateCandidate - Adds a "surrogate" candidate function that
6971 /// converts the given @c Object to a function pointer via the
6972 /// conversion function @c Conversion, and then attempts to call it
6973 /// with the given arguments (C++ [over.call.object]p2-4). Proto is
6974 /// the type of function that we'll eventually be calling.
6976  DeclAccessPair FoundDecl,
6977  CXXRecordDecl *ActingContext,
6978  const FunctionProtoType *Proto,
6979  Expr *Object,
6980  ArrayRef<Expr *> Args,
6981  OverloadCandidateSet& CandidateSet) {
6982  if (!CandidateSet.isNewCandidate(Conversion))
6983  return;
6984 
6985  // Overload resolution is always an unevaluated context.
6988 
6989  OverloadCandidate &Candidate = CandidateSet.addCandidate(Args.size() + 1);
6990  Candidate.FoundDecl = FoundDecl;
6991  Candidate.Function = nullptr;
6992  Candidate.Surrogate = Conversion;
6993  Candidate.Viable = true;
6994  Candidate.IsSurrogate = true;
6995  Candidate.IgnoreObjectArgument = false;
6996  Candidate.ExplicitCallArguments = Args.size();
6997 
6998  // Determine the implicit conversion sequence for the implicit
6999  // object parameter.
7001  *this, CandidateSet.getLocation(), Object->getType(),
7002  Object->Classify(Context), Conversion, ActingContext);
7003  if (ObjectInit.isBad()) {
7004  Candidate.Viable = false;
7006  Candidate.Conversions[0] = ObjectInit;
7007  return;
7008  }
7009 
7010  // The first conversion is actually a user-defined conversion whose
7011  // first conversion is ObjectInit's standard conversion (which is
7012  // effectively a reference binding). Record it as such.
7013  Candidate.Conversions[0].setUserDefined();
7014  Candidate.Conversions[0].UserDefined.Before = ObjectInit.Standard;
7015  Candidate.Conversions[0].UserDefined.EllipsisConversion = false;
7016  Candidate.Conversions[0].UserDefined.HadMultipleCandidates = false;
7017  Candidate.Conversions[0].UserDefined.ConversionFunction = Conversion;
7018  Candidate.Conversions[0].UserDefined.FoundConversionFunction = FoundDecl;
7019  Candidate.Conversions[0].UserDefined.After
7020  = Candidate.Conversions[0].UserDefined.Before;
7021  Candidate.Conversions[0].UserDefined.After.setAsIdentityConversion();
7022 
7023  // Find the
7024  unsigned NumParams = Proto->getNumParams();
7025 
7026  // (C++ 13.3.2p2): A candidate function having fewer than m
7027  // parameters is viable only if it has an ellipsis in its parameter
7028  // list (8.3.5).
7029  if (Args.size() > NumParams && !Proto->isVariadic()) {
7030  Candidate.Viable = false;
7032  return;
7033  }
7034 
7035  // Function types don't have any default arguments, so just check if
7036  // we have enough arguments.
7037  if (Args.size() < NumParams) {
7038  // Not enough arguments.
7039  Candidate.Viable = false;
7041  return;
7042  }
7043 
7044  // Determine the implicit conversion sequences for each of the
7045  // arguments.
7046  for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
7047  if (ArgIdx < NumParams) {
7048  // (C++ 13.3.2p3): for F to be a viable function, there shall
7049  // exist for each argument an implicit conversion sequence
7050  // (13.3.3.1) that converts that argument to the corresponding
7051  // parameter of F.
7052  QualType ParamType = Proto->getParamType(ArgIdx);
7053  Candidate.Conversions[ArgIdx + 1]
7054  = TryCopyInitialization(*this, Args[ArgIdx], ParamType,
7055  /*SuppressUserConversions=*/false,
7056  /*InOverloadResolution=*/false,
7057  /*AllowObjCWritebackConversion=*/
7058  getLangOpts().ObjCAutoRefCount);
7059  if (Candidate.Conversions[ArgIdx + 1].isBad()) {
7060  Candidate.Viable = false;
7062  return;
7063  }
7064  } else {
7065  // (C++ 13.3.2p2): For the purposes of overload resolution, any
7066  // argument for which there is no corresponding parameter is
7067  // considered to ""match the ellipsis" (C+ 13.3.3.1.3).
7068  Candidate.Conversions[ArgIdx + 1].setEllipsis();
7069  }
7070  }
7071 
7072  if (EnableIfAttr *FailedAttr = CheckEnableIf(Conversion, None)) {
7073  Candidate.Viable = false;
7074  Candidate.FailureKind = ovl_fail_enable_if;
7075  Candidate.DeductionFailure.Data = FailedAttr;
7076  return;
7077  }
7078 }
7079 
7080 /// \brief Add overload candidates for overloaded operators that are
7081 /// member functions.
7082 ///
7083 /// Add the overloaded operator candidates that are member functions
7084 /// for the operator Op that was used in an operator expression such
7085 /// as "x Op y". , Args/NumArgs provides the operator arguments, and
7086 /// CandidateSet will store the added overload candidates. (C++
7087 /// [over.match.oper]).
7089  SourceLocation OpLoc,
7090  ArrayRef<Expr *> Args,
7091  OverloadCandidateSet& CandidateSet,
7092  SourceRange OpRange) {
7094 
7095  // C++ [over.match.oper]p3:
7096  // For a unary operator @ with an operand of a type whose
7097  // cv-unqualified version is T1, and for a binary operator @ with
7098  // a left operand of a type whose cv-unqualified version is T1 and
7099  // a right operand of a type whose cv-unqualified version is T2,
7100  // three sets of candidate functions, designated member
7101  // candidates, non-member candidates and built-in candidates, are
7102  // constructed as follows:
7103  QualType T1 = Args[0]->getType();
7104 
7105  // -- If T1 is a complete class type or a class currently being
7106  // defined, the set of member candidates is the result of the
7107  // qualified lookup of T1::operator@ (13.3.1.1.1); otherwise,
7108  // the set of member candidates is empty.
7109  if (const RecordType *T1Rec = T1->getAs<RecordType>()) {
7110  // Complete the type if it can be completed.
7111  if (!isCompleteType(OpLoc, T1) && !T1Rec->isBeingDefined())
7112  return;
7113  // If the type is neither complete nor being defined, bail out now.
7114  if (!T1Rec->getDecl()->getDefinition())
7115  return;
7116 
7117  LookupResult Operators(*this, OpName, OpLoc, LookupOrdinaryName);
7118  LookupQualifiedName(Operators, T1Rec->getDecl());
7119  Operators.suppressDiagnostics();
7120 
7121  for (LookupResult::iterator Oper = Operators.begin(),
7122  OperEnd = Operators.end();
7123  Oper != OperEnd;
7124  ++Oper)
7125  AddMethodCandidate(Oper.getPair(), Args[0]->getType(),
7126  Args[0]->Classify(Context), Args.slice(1),
7127  CandidateSet, /*SuppressUserConversions=*/false);
7128  }
7129 }
7130 
7131 /// AddBuiltinCandidate - Add a candidate for a built-in
7132 /// operator. ResultTy and ParamTys are the result and parameter types
7133 /// of the built-in candidate, respectively. Args and NumArgs are the
7134 /// arguments being passed to the candidate. IsAssignmentOperator
7135 /// should be true when this built-in candidate is an assignment
7136 /// operator. NumContextualBoolArguments is the number of arguments
7137 /// (at the beginning of the argument list) that will be contextually
7138 /// converted to bool.
7140  OverloadCandidateSet& CandidateSet,
7141  bool IsAssignmentOperator,
7142  unsigned NumContextualBoolArguments) {
7143  // Overload resolution is always an unevaluated context.
7146 
7147  // Add this candidate
7148  OverloadCandidate &Candidate = CandidateSet.addCandidate(Args.size());
7149  Candidate.FoundDecl = DeclAccessPair::make(nullptr, AS_none);
7150  Candidate.Function = nullptr;
7151  Candidate.IsSurrogate = false;
7152  Candidate.IgnoreObjectArgument = false;
7153  std::copy(ParamTys, ParamTys + Args.size(), Candidate.BuiltinParamTypes);
7154 
7155  // Determine the implicit conversion sequences for each of the
7156  // arguments.
7157  Candidate.Viable = true;
7158  Candidate.ExplicitCallArguments = Args.size();
7159  for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
7160  // C++ [over.match.oper]p4:
7161  // For the built-in assignment operators, conversions of the
7162  // left operand are restricted as follows:
7163  // -- no temporaries are introduced to hold the left operand, and
7164  // -- no user-defined conversions are applied to the left
7165  // operand to achieve a type match with the left-most
7166  // parameter of a built-in candidate.
7167  //
7168  // We block these conversions by turning off user-defined
7169  // conversions, since that is the only way that initialization of
7170  // a reference to a non-class type can occur from something that
7171  // is not of the same type.
7172  if (ArgIdx < NumContextualBoolArguments) {
7173  assert(ParamTys[ArgIdx] == Context.BoolTy &&
7174  "Contextual conversion to bool requires bool type");
7175  Candidate.Conversions[ArgIdx]
7176  = TryContextuallyConvertToBool(*this, Args[ArgIdx]);
7177  } else {
7178  Candidate.Conversions[ArgIdx]
7179  = TryCopyInitialization(*this, Args[ArgIdx], ParamTys[ArgIdx],
7180  ArgIdx == 0 && IsAssignmentOperator,
7181  /*InOverloadResolution=*/false,
7182  /*AllowObjCWritebackConversion=*/
7183  getLangOpts().ObjCAutoRefCount);
7184  }
7185  if (Candidate.Conversions[ArgIdx].isBad()) {
7186  Candidate.Viable = false;
7188  break;
7189  }
7190  }
7191 }
7192 
7193 namespace {
7194 
7195 /// BuiltinCandidateTypeSet - A set of types that will be used for the
7196 /// candidate operator functions for built-in operators (C++
7197 /// [over.built]). The types are separated into pointer types and
7198 /// enumeration types.
7199 class BuiltinCandidateTypeSet {
7200  /// TypeSet - A set of types.
7201  typedef llvm::SetVector<QualType, SmallVector<QualType, 8>,
7202  llvm::SmallPtrSet<QualType, 8>> TypeSet;
7203 
7204  /// PointerTypes - The set of pointer types that will be used in the
7205  /// built-in candidates.
7206  TypeSet PointerTypes;
7207 
7208  /// MemberPointerTypes - The set of member pointer types that will be
7209  /// used in the built-in candidates.
7210  TypeSet MemberPointerTypes;
7211 
7212  /// EnumerationTypes - The set of enumeration types that will be
7213  /// used in the built-in candidates.
7214  TypeSet EnumerationTypes;
7215 
7216  /// \brief The set of vector types that will be used in the built-in
7217  /// candidates.
7218  TypeSet VectorTypes;
7219 
7220  /// \brief A flag indicating non-record types are viable candidates
7221  bool HasNonRecordTypes;
7222 
7223  /// \brief A flag indicating whether either arithmetic or enumeration types
7224  /// were present in the candidate set.
7225  bool HasArithmeticOrEnumeralTypes;
7226 
7227  /// \brief A flag indicating whether the nullptr type was present in the
7228  /// candidate set.
7229  bool HasNullPtrType;
7230 
7231  /// Sema - The semantic analysis instance where we are building the
7232  /// candidate type set.
7233  Sema &SemaRef;
7234 
7235  /// Context - The AST context in which we will build the type sets.
7237 
7238  bool AddPointerWithMoreQualifiedTypeVariants(QualType Ty,
7239  const Qualifiers &VisibleQuals);
7240  bool AddMemberPointerWithMoreQualifiedTypeVariants(QualType Ty);
7241 
7242 public:
7243  /// iterator - Iterates through the types that are part of the set.
7244  typedef TypeSet::iterator iterator;
7245 
7246  BuiltinCandidateTypeSet(Sema &SemaRef)
7247  : HasNonRecordTypes(false),
7248  HasArithmeticOrEnumeralTypes(false),
7249  HasNullPtrType(false),
7250  SemaRef(SemaRef),
7251  Context(SemaRef.Context) { }
7252 
7253  void AddTypesConvertedFrom(QualType Ty,
7254  SourceLocation Loc,
7255  bool AllowUserConversions,
7256  bool AllowExplicitConversions,
7257  const Qualifiers &VisibleTypeConversionsQuals);
7258 
7259  /// pointer_begin - First pointer type found;
7260  iterator pointer_begin() { return PointerTypes.begin(); }
7261 
7262  /// pointer_end - Past the last pointer type found;
7263  iterator pointer_end() { return PointerTypes.end(); }
7264 
7265  /// member_pointer_begin - First member pointer type found;
7266  iterator member_pointer_begin() { return MemberPointerTypes.begin(); }
7267 
7268  /// member_pointer_end - Past the last member pointer type found;
7269  iterator member_pointer_end() { return MemberPointerTypes.end(); }
7270 
7271  /// enumeration_begin - First enumeration type found;
7272  iterator enumeration_begin() { return EnumerationTypes.begin(); }
7273 
7274  /// enumeration_end - Past the last enumeration type found;
7275  iterator enumeration_end() { return EnumerationTypes.end(); }
7276 
7277  iterator vector_begin() { return VectorTypes.begin(); }
7278  iterator vector_end() { return VectorTypes.end(); }
7279 
7280  bool hasNonRecordTypes() { return HasNonRecordTypes; }
7281  bool hasArithmeticOrEnumeralTypes() { return HasArithmeticOrEnumeralTypes; }
7282  bool hasNullPtrType() const { return HasNullPtrType; }
7283 };
7284 
7285 } // end anonymous namespace
7286 
7287 /// AddPointerWithMoreQualifiedTypeVariants - Add the pointer type @p Ty to
7288 /// the set of pointer types along with any more-qualified variants of
7289 /// that type. For example, if @p Ty is "int const *", this routine
7290 /// will add "int const *", "int const volatile *", "int const
7291 /// restrict *", and "int const volatile restrict *" to the set of
7292 /// pointer types. Returns true if the add of @p Ty itself succeeded,
7293 /// false otherwise.
7294 ///
7295 /// FIXME: what to do about extended qualifiers?
7296 bool
7297 BuiltinCandidateTypeSet::AddPointerWithMoreQualifiedTypeVariants(QualType Ty,
7298  const Qualifiers &VisibleQuals) {
7299 
7300  // Insert this type.
7301  if (!PointerTypes.insert(Ty))
7302  return false;
7303 
7304  QualType PointeeTy;
7305  const PointerType *PointerTy = Ty->getAs<PointerType>();
7306  bool buildObjCPtr = false;
7307  if (!PointerTy) {
7309  PointeeTy = PTy->getPointeeType();
7310  buildObjCPtr = true;
7311  } else {
7312  PointeeTy = PointerTy->getPointeeType();
7313  }
7314 
7315  // Don't add qualified variants of arrays. For one, they're not allowed
7316  // (the qualifier would sink to the element type), and for another, the
7317  // only overload situation where it matters is subscript or pointer +- int,
7318  // and those shouldn't have qualifier variants anyway.
7319  if (PointeeTy->isArrayType())
7320  return true;
7321 
7322  unsigned BaseCVR = PointeeTy.getCVRQualifiers();
7323  bool hasVolatile = VisibleQuals.hasVolatile();
7324  bool hasRestrict = VisibleQuals.hasRestrict();
7325 
7326  // Iterate through all strict supersets of BaseCVR.
7327  for (unsigned CVR = BaseCVR+1; CVR <= Qualifiers::CVRMask; ++CVR) {
7328  if ((CVR | BaseCVR) != CVR) continue;
7329  // Skip over volatile if no volatile found anywhere in the types.
7330  if ((CVR & Qualifiers::Volatile) && !hasVolatile) continue;
7331 
7332  // Skip over restrict if no restrict found anywhere in the types, or if
7333  // the type cannot be restrict-qualified.
7334  if ((CVR & Qualifiers::Restrict) &&
7335  (!hasRestrict ||
7336  (!(PointeeTy->isAnyPointerType() || PointeeTy->isReferenceType()))))
7337  continue;
7338 
7339  // Build qualified pointee type.
7340  QualType QPointeeTy = Context.getCVRQualifiedType(PointeeTy, CVR);
7341 
7342  // Build qualified pointer type.
7343  QualType QPointerTy;
7344  if (!buildObjCPtr)
7345  QPointerTy = Context.getPointerType(QPointeeTy);
7346  else
7347  QPointerTy = Context.getObjCObjectPointerType(QPointeeTy);
7348 
7349  // Insert qualified pointer type.
7350  PointerTypes.insert(QPointerTy);
7351  }
7352 
7353  return true;
7354 }
7355 
7356 /// AddMemberPointerWithMoreQualifiedTypeVariants - Add the pointer type @p Ty
7357 /// to the set of pointer types along with any more-qualified variants of
7358 /// that type. For example, if @p Ty is "int const *", this routine
7359 /// will add "int const *", "int const volatile *", "int const
7360 /// restrict *", and "int const volatile restrict *" to the set of
7361 /// pointer types. Returns true if the add of @p Ty itself succeeded,
7362 /// false otherwise.
7363 ///
7364 /// FIXME: what to do about extended qualifiers?
7365 bool
7366 BuiltinCandidateTypeSet::AddMemberPointerWithMoreQualifiedTypeVariants(
7367  QualType Ty) {
7368  // Insert this type.
7369  if (!MemberPointerTypes.insert(Ty))
7370  return false;
7371 
7372  const MemberPointerType *PointerTy = Ty->getAs<MemberPointerType>();
7373  assert(PointerTy && "type was not a member pointer type!");
7374 
7375  QualType PointeeTy = PointerTy->getPointeeType();
7376  // Don't add qualified variants of arrays. For one, they're not allowed
7377  // (the qualifier would sink to the element type), and for another, the
7378  // only overload situation where it matters is subscript or pointer +- int,
7379  // and those shouldn't have qualifier variants anyway.
7380  if (PointeeTy->isArrayType())
7381  return true;
7382  const Type *ClassTy = PointerTy->getClass();
7383 
7384  // Iterate through all strict supersets of the pointee type's CVR
7385  // qualifiers.
7386  unsigned BaseCVR = PointeeTy.getCVRQualifiers();
7387  for (unsigned CVR = BaseCVR+1; CVR <= Qualifiers::CVRMask; ++CVR) {
7388  if ((CVR | BaseCVR) != CVR) continue;
7389 
7390  QualType QPointeeTy = Context.getCVRQualifiedType(PointeeTy, CVR);
7391  MemberPointerTypes.insert(
7392  Context.getMemberPointerType(QPointeeTy, ClassTy));
7393  }
7394 
7395  return true;
7396 }
7397 
7398 /// AddTypesConvertedFrom - Add each of the types to which the type @p
7399 /// Ty can be implicit converted to the given set of @p Types. We're
7400 /// primarily interested in pointer types and enumeration types. We also
7401 /// take member pointer types, for the conditional operator.
7402 /// AllowUserConversions is true if we should look at the conversion
7403 /// functions of a class type, and AllowExplicitConversions if we
7404 /// should also include the explicit conversion functions of a class
7405 /// type.
7406 void
7407 BuiltinCandidateTypeSet::AddTypesConvertedFrom(QualType Ty,
7408  SourceLocation Loc,
7409  bool AllowUserConversions,
7410  bool AllowExplicitConversions,
7411  const Qualifiers &VisibleQuals) {
7412  // Only deal with canonical types.
7413  Ty = Context.getCanonicalType(Ty);
7414 
7415  // Look through reference types; they aren't part of the type of an
7416  // expression for the purposes of conversions.
7417  if (const ReferenceType *RefTy = Ty->getAs<ReferenceType>())
7418  Ty = RefTy->getPointeeType();
7419 
7420  // If we're dealing with an array type, decay to the pointer.
7421  if (Ty->isArrayType())
7422  Ty = SemaRef.Context.getArrayDecayedType(Ty);
7423 
7424  // Otherwise, we don't care about qualifiers on the type.
7425  Ty = Ty.getLocalUnqualifiedType();
7426 
7427  // Flag if we ever add a non-record type.
7428  const RecordType *TyRec = Ty->getAs<RecordType>();
7429  HasNonRecordTypes = HasNonRecordTypes || !TyRec;
7430 
7431  // Flag if we encounter an arithmetic type.
7432  HasArithmeticOrEnumeralTypes =
7433  HasArithmeticOrEnumeralTypes || Ty->isArithmeticType();
7434 
7435  if (Ty->isObjCIdType() || Ty->isObjCClassType())
7436  PointerTypes.insert(Ty);
7437  else if (Ty->getAs<PointerType>() || Ty->getAs<ObjCObjectPointerType>()) {
7438  // Insert our type, and its more-qualified variants, into the set
7439  // of types.
7440  if (!AddPointerWithMoreQualifiedTypeVariants(Ty, VisibleQuals))
7441  return;
7442  } else if (Ty->isMemberPointerType()) {
7443  // Member pointers are far easier, since the pointee can't be converted.
7444  if (!AddMemberPointerWithMoreQualifiedTypeVariants(Ty))
7445  return;
7446  } else if (Ty->isEnumeralType()) {
7447  HasArithmeticOrEnumeralTypes = true;
7448  EnumerationTypes.insert(Ty);
7449  } else if (Ty->isVectorType()) {
7450  // We treat vector types as arithmetic types in many contexts as an
7451  // extension.
7452  HasArithmeticOrEnumeralTypes = true;
7453  VectorTypes.insert(Ty);
7454  } else if (Ty->isNullPtrType()) {
7455  HasNullPtrType = true;
7456  } else if (AllowUserConversions && TyRec) {
7457  // No conversion functions in incomplete types.
7458  if (!SemaRef.isCompleteType(Loc, Ty))
7459  return;
7460 
7461  CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(TyRec->getDecl());
7462  for (NamedDecl *D : ClassDecl->getVisibleConversionFunctions()) {
7463  if (isa<UsingShadowDecl>(D))
7464  D = cast<UsingShadowDecl>(D)->getTargetDecl();
7465 
7466  // Skip conversion function templates; they don't tell us anything
7467  // about which builtin types we can convert to.
7468  if (isa<FunctionTemplateDecl>(D))
7469  continue;
7470 
7471  CXXConversionDecl *Conv = cast<CXXConversionDecl>(D);
7472  if (AllowExplicitConversions || !Conv->isExplicit()) {
7473  AddTypesConvertedFrom(Conv->getConversionType(), Loc, false, false,
7474  VisibleQuals);
7475  }
7476  }
7477  }
7478 }
7479 
7480 /// \brief Helper function for AddBuiltinOperatorCandidates() that adds
7481 /// the volatile- and non-volatile-qualified assignment operators for the
7482 /// given type to the candidate set.
7484  QualType T,
7485  ArrayRef<Expr *> Args,
7486  OverloadCandidateSet &CandidateSet) {
7487  QualType ParamTypes[2];
7488 
7489  // T& operator=(T&, T)
7490  ParamTypes[0] = S.Context.getLValueReferenceType(T);
7491  ParamTypes[1] = T;
7492  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
7493  /*IsAssignmentOperator=*/true);
7494 
7496  // volatile T& operator=(volatile T&, T)
7497  ParamTypes[0]
7499  ParamTypes[1] = T;
7500  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
7501  /*IsAssignmentOperator=*/true);
7502  }
7503 }
7504 
7505 /// CollectVRQualifiers - This routine returns Volatile/Restrict qualifiers,
7506 /// if any, found in visible type conversion functions found in ArgExpr's type.
7508  Qualifiers VRQuals;
7509  const RecordType *TyRec;
7510  if (const MemberPointerType *RHSMPType =
7511  ArgExpr->getType()->getAs<MemberPointerType>())
7512  TyRec = RHSMPType->getClass()->getAs<RecordType>();
7513  else
7514  TyRec = ArgExpr->getType()->getAs<RecordType>();
7515  if (!TyRec) {
7516  // Just to be safe, assume the worst case.
7517  VRQuals.addVolatile();
7518  VRQuals.addRestrict();
7519  return VRQuals;
7520  }
7521 
7522  CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(TyRec->getDecl());
7523  if (!ClassDecl->hasDefinition())
7524  return VRQuals;
7525 
7526  for (NamedDecl *D : ClassDecl->getVisibleConversionFunctions()) {
7527  if (isa<UsingShadowDecl>(D))
7528  D = cast<UsingShadowDecl>(D)->getTargetDecl();
7529  if (CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(D)) {
7530  QualType CanTy = Context.getCanonicalType(Conv->getConversionType());
7531  if (const ReferenceType *ResTypeRef = CanTy->getAs<ReferenceType>())
7532  CanTy = ResTypeRef->getPointeeType();
7533  // Need to go down the pointer/mempointer chain and add qualifiers
7534  // as see them.
7535  bool done = false;
7536  while (!done) {
7537  if (CanTy.isRestrictQualified())
7538  VRQuals.addRestrict();
7539  if (const PointerType *ResTypePtr = CanTy->getAs<PointerType>())
7540  CanTy = ResTypePtr->getPointeeType();
7541  else if (const MemberPointerType *ResTypeMPtr =
7542  CanTy->getAs<MemberPointerType>())
7543  CanTy = ResTypeMPtr->getPointeeType();
7544  else
7545  done = true;
7546  if (CanTy.isVolatileQualified())
7547  VRQuals.addVolatile();
7548  if (VRQuals.hasRestrict() && VRQuals.hasVolatile())
7549  return VRQuals;
7550  }
7551  }
7552  }
7553  return VRQuals;
7554 }
7555 
7556 namespace {
7557 
7558 /// \brief Helper class to manage the addition of builtin operator overload
7559 /// candidates. It provides shared state and utility methods used throughout
7560 /// the process, as well as a helper method to add each group of builtin
7561 /// operator overloads from the standard to a candidate set.
7562 class BuiltinOperatorOverloadBuilder {
7563  // Common instance state available to all overload candidate addition methods.
7564  Sema &S;
7565  ArrayRef<Expr *> Args;
7566  Qualifiers VisibleTypeConversionsQuals;
7567  bool HasArithmeticOrEnumeralCandidateType;
7569  OverloadCandidateSet &CandidateSet;
7570 
7571  // Define some constants used to index and iterate over the arithemetic types
7572  // provided via the getArithmeticType() method below.
7573  // The "promoted arithmetic types" are the arithmetic
7574  // types are that preserved by promotion (C++ [over.built]p2).
7575  static const unsigned FirstIntegralType = 4;
7576  static const unsigned LastIntegralType = 21;
7577  static const unsigned FirstPromotedIntegralType = 4,
7578  LastPromotedIntegralType = 12;
7579  static const unsigned FirstPromotedArithmeticType = 0,
7580  LastPromotedArithmeticType = 12;
7581  static const unsigned NumArithmeticTypes = 21;
7582 
7583  /// \brief Get the canonical type for a given arithmetic type index.
7584  CanQualType getArithmeticType(unsigned index) {
7585  assert(index < NumArithmeticTypes);
7586  static CanQualType ASTContext::* const
7587  ArithmeticTypes[NumArithmeticTypes] = {
7588  // Start of promoted types.
7593 
7594  // Start of integral types.
7603  // End of promoted types.
7604 
7614  // End of integral types.
7615  // FIXME: What about complex? What about half?
7616  };
7617  return S.Context.*ArithmeticTypes[index];
7618  }
7619 
7620  /// \brief Helper method to factor out the common pattern of adding overloads
7621  /// for '++' and '--' builtin operators.
7622  void addPlusPlusMinusMinusStyleOverloads(QualType CandidateTy,
7623  bool HasVolatile,
7624  bool HasRestrict) {
7625  QualType ParamTypes[2] = {
7626  S.Context.getLValueReferenceType(CandidateTy),
7627  S.Context.IntTy
7628  };
7629 
7630  // Non-volatile version.
7631  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
7632 
7633  // Use a heuristic to reduce number of builtin candidates in the set:
7634  // add volatile version only if there are conversions to a volatile type.
7635  if (HasVolatile) {
7636  ParamTypes[0] =
7638  S.Context.getVolatileType(CandidateTy));
7639  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
7640  }
7641 
7642  // Add restrict version only if there are conversions to a restrict type
7643  // and our candidate type is a non-restrict-qualified pointer.
7644  if (HasRestrict && CandidateTy->isAnyPointerType() &&
7645  !CandidateTy.isRestrictQualified()) {
7646  ParamTypes[0]
7648  S.Context.getCVRQualifiedType(CandidateTy, Qualifiers::Restrict));
7649  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
7650 
7651  if (HasVolatile) {
7652  ParamTypes[0]
7654  S.Context.getCVRQualifiedType(CandidateTy,
7655  (Qualifiers::Volatile |
7656  Qualifiers::Restrict)));
7657  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
7658  }
7659  }
7660 
7661  }
7662 
7663 public:
7664  BuiltinOperatorOverloadBuilder(
7665  Sema &S, ArrayRef<Expr *> Args,
7666  Qualifiers VisibleTypeConversionsQuals,
7667  bool HasArithmeticOrEnumeralCandidateType,
7669  OverloadCandidateSet &CandidateSet)
7670  : S(S), Args(Args),
7671  VisibleTypeConversionsQuals(VisibleTypeConversionsQuals),
7672  HasArithmeticOrEnumeralCandidateType(
7673  HasArithmeticOrEnumeralCandidateType),
7674  CandidateTypes(CandidateTypes),
7675  CandidateSet(CandidateSet) {
7676  // Validate some of our static helper constants in debug builds.
7677  assert(getArithmeticType(FirstPromotedIntegralType) == S.Context.IntTy &&
7678  "Invalid first promoted integral type");
7679  assert(getArithmeticType(LastPromotedIntegralType - 1)
7680  == S.Context.UnsignedInt128Ty &&
7681  "Invalid last promoted integral type");
7682  assert(getArithmeticType(FirstPromotedArithmeticType)
7683  == S.Context.FloatTy &&
7684  "Invalid first promoted arithmetic type");
7685  assert(getArithmeticType(LastPromotedArithmeticType - 1)
7686  == S.Context.UnsignedInt128Ty &&
7687  "Invalid last promoted arithmetic type");
7688  }
7689 
7690  // C++ [over.built]p3:
7691  //
7692  // For every pair (T, VQ), where T is an arithmetic type, and VQ
7693  // is either volatile or empty, there exist candidate operator
7694  // functions of the form
7695  //
7696  // VQ T& operator++(VQ T&);
7697  // T operator++(VQ T&, int);
7698  //
7699  // C++ [over.built]p4:
7700  //
7701  // For every pair (T, VQ), where T is an arithmetic type other
7702  // than bool, and VQ is either volatile or empty, there exist
7703  // candidate operator functions of the form
7704  //
7705  // VQ T& operator--(VQ T&);
7706  // T operator--(VQ T&, int);
7707  void addPlusPlusMinusMinusArithmeticOverloads(OverloadedOperatorKind Op) {
7708  if (!HasArithmeticOrEnumeralCandidateType)
7709  return;
7710 
7711  for (unsigned Arith = (Op == OO_PlusPlus? 0 : 1);
7712  Arith < NumArithmeticTypes; ++Arith) {
7713  addPlusPlusMinusMinusStyleOverloads(
7714  getArithmeticType(Arith),
7715  VisibleTypeConversionsQuals.hasVolatile(),
7716  VisibleTypeConversionsQuals.hasRestrict());
7717  }
7718  }
7719 
7720  // C++ [over.built]p5:
7721  //
7722  // For every pair (T, VQ), where T is a cv-qualified or
7723  // cv-unqualified object type, and VQ is either volatile or
7724  // empty, there exist candidate operator functions of the form
7725  //
7726  // T*VQ& operator++(T*VQ&);
7727  // T*VQ& operator--(T*VQ&);
7728  // T* operator++(T*VQ&, int);
7729  // T* operator--(T*VQ&, int);
7730  void addPlusPlusMinusMinusPointerOverloads() {
7731  for (BuiltinCandidateTypeSet::iterator
7732  Ptr = CandidateTypes[0].pointer_begin(),
7733  PtrEnd = CandidateTypes[0].pointer_end();
7734  Ptr != PtrEnd; ++Ptr) {
7735  // Skip pointer types that aren't pointers to object types.
7736  if (!(*Ptr)->getPointeeType()->isObjectType())
7737  continue;
7738 
7739  addPlusPlusMinusMinusStyleOverloads(*Ptr,
7740  (!(*Ptr).isVolatileQualified() &&
7741  VisibleTypeConversionsQuals.hasVolatile()),
7742  (!(*Ptr).isRestrictQualified() &&
7743  VisibleTypeConversionsQuals.hasRestrict()));
7744  }
7745  }
7746 
7747  // C++ [over.built]p6:
7748  // For every cv-qualified or cv-unqualified object type T, there
7749  // exist candidate operator functions of the form
7750  //
7751  // T& operator*(T*);
7752  //
7753  // C++ [over.built]p7:
7754  // For every function type T that does not have cv-qualifiers or a
7755  // ref-qualifier, there exist candidate operator functions of the form
7756  // T& operator*(T*);
7757  void addUnaryStarPointerOverloads() {
7758  for (BuiltinCandidateTypeSet::iterator
7759  Ptr = CandidateTypes[0].pointer_begin(),
7760  PtrEnd = CandidateTypes[0].pointer_end();
7761  Ptr != PtrEnd; ++Ptr) {
7762  QualType ParamTy = *Ptr;
7763  QualType PointeeTy = ParamTy->getPointeeType();
7764  if (!PointeeTy->isObjectType() && !PointeeTy->isFunctionType())
7765  continue;
7766 
7767  if (const FunctionProtoType *Proto =PointeeTy->getAs<FunctionProtoType>())
7768  if (Proto->getTypeQuals() || Proto->getRefQualifier())
7769  continue;
7770 
7771  S.AddBuiltinCandidate(&ParamTy, Args, CandidateSet);
7772  }
7773  }
7774 
7775  // C++ [over.built]p9:
7776  // For every promoted arithmetic type T, there exist candidate
7777  // operator functions of the form
7778  //
7779  // T operator+(T);
7780  // T operator-(T);
7781  void addUnaryPlusOrMinusArithmeticOverloads() {
7782  if (!HasArithmeticOrEnumeralCandidateType)
7783  return;
7784 
7785  for (unsigned Arith = FirstPromotedArithmeticType;
7786  Arith < LastPromotedArithmeticType; ++Arith) {
7787  QualType ArithTy = getArithmeticType(Arith);
7788  S.AddBuiltinCandidate(&ArithTy, Args, CandidateSet);
7789  }
7790 
7791  // Extension: We also add these operators for vector types.
7792  for (BuiltinCandidateTypeSet::iterator
7793  Vec = CandidateTypes[0].vector_begin(),
7794  VecEnd = CandidateTypes[0].vector_end();
7795  Vec != VecEnd; ++Vec) {
7796  QualType VecTy = *Vec;
7797  S.AddBuiltinCandidate(&VecTy, Args, CandidateSet);
7798  }
7799  }
7800 
7801  // C++ [over.built]p8:
7802  // For every type T, there exist candidate operator functions of
7803  // the form
7804  //
7805  // T* operator+(T*);
7806  void addUnaryPlusPointerOverloads() {
7807  for (BuiltinCandidateTypeSet::iterator
7808  Ptr = CandidateTypes[0].pointer_begin(),
7809  PtrEnd = CandidateTypes[0].pointer_end();
7810  Ptr != PtrEnd; ++Ptr) {
7811  QualType ParamTy = *Ptr;
7812  S.AddBuiltinCandidate(&ParamTy, Args, CandidateSet);
7813  }
7814  }
7815 
7816  // C++ [over.built]p10:
7817  // For every promoted integral type T, there exist candidate
7818  // operator functions of the form
7819  //
7820  // T operator~(T);
7821  void addUnaryTildePromotedIntegralOverloads() {
7822  if (!HasArithmeticOrEnumeralCandidateType)
7823  return;
7824 
7825  for (unsigned Int = FirstPromotedIntegralType;
7826  Int < LastPromotedIntegralType; ++Int) {
7827  QualType IntTy = getArithmeticType(Int);
7828  S.AddBuiltinCandidate(&IntTy, Args, CandidateSet);
7829  }
7830 
7831  // Extension: We also add this operator for vector types.
7832  for (BuiltinCandidateTypeSet::iterator
7833  Vec = CandidateTypes[0].vector_begin(),
7834  VecEnd = CandidateTypes[0].vector_end();
7835  Vec != VecEnd; ++Vec) {
7836  QualType VecTy = *Vec;
7837  S.AddBuiltinCandidate(&VecTy, Args, CandidateSet);
7838  }
7839  }
7840 
7841  // C++ [over.match.oper]p16:
7842  // For every pointer to member type T or type std::nullptr_t, there
7843  // exist candidate operator functions of the form
7844  //
7845  // bool operator==(T,T);
7846  // bool operator!=(T,T);
7847  void addEqualEqualOrNotEqualMemberPointerOrNullptrOverloads() {
7848  /// Set of (canonical) types that we've already handled.
7849  llvm::SmallPtrSet<QualType, 8> AddedTypes;
7850 
7851  for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
7852  for (BuiltinCandidateTypeSet::iterator
7853  MemPtr = CandidateTypes[ArgIdx].member_pointer_begin(),
7854  MemPtrEnd = CandidateTypes[ArgIdx].member_pointer_end();
7855  MemPtr != MemPtrEnd;
7856  ++MemPtr) {
7857  // Don't add the same builtin candidate twice.
7858  if (!AddedTypes.insert(S.Context.getCanonicalType(*MemPtr)).second)
7859  continue;
7860 
7861  QualType ParamTypes[2] = { *MemPtr, *MemPtr };
7862  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
7863  }
7864 
7865  if (CandidateTypes[ArgIdx].hasNullPtrType()) {
7867  if (AddedTypes.insert(NullPtrTy).second) {
7868  QualType ParamTypes[2] = { NullPtrTy, NullPtrTy };
7869  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
7870  }
7871  }
7872  }
7873  }
7874 
7875  // C++ [over.built]p15:
7876  //
7877  // For every T, where T is an enumeration type or a pointer type,
7878  // there exist candidate operator functions of the form
7879  //
7880  // bool operator<(T, T);
7881  // bool operator>(T, T);
7882  // bool operator<=(T, T);
7883  // bool operator>=(T, T);
7884  // bool operator==(T, T);
7885  // bool operator!=(T, T);
7886  void addRelationalPointerOrEnumeralOverloads() {
7887  // C++ [over.match.oper]p3:
7888  // [...]the built-in candidates include all of the candidate operator
7889  // functions defined in 13.6 that, compared to the given operator, [...]
7890  // do not have the same parameter-type-list as any non-template non-member
7891  // candidate.
7892  //
7893  // Note that in practice, this only affects enumeration types because there
7894  // aren't any built-in candidates of record type, and a user-defined operator
7895  // must have an operand of record or enumeration type. Also, the only other
7896  // overloaded operator with enumeration arguments, operator=,
7897  // cannot be overloaded for enumeration types, so this is the only place
7898  // where we must suppress candidates like this.
7900  UserDefinedBinaryOperators;
7901 
7902  for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
7903  if (CandidateTypes[ArgIdx].enumeration_begin() !=
7904  CandidateTypes[ArgIdx].enumeration_end()) {
7905  for (OverloadCandidateSet::iterator C = CandidateSet.begin(),
7906  CEnd = CandidateSet.end();
7907  C != CEnd; ++C) {
7908  if (!C->Viable || !C->Function || C->Function->getNumParams() != 2)
7909  continue;
7910 
7911  if (C->Function->isFunctionTemplateSpecialization())
7912  continue;
7913 
7914  QualType FirstParamType =
7915  C->Function->getParamDecl(0)->getType().getUnqualifiedType();
7916  QualType SecondParamType =
7917  C->Function->getParamDecl(1)->getType().getUnqualifiedType();
7918 
7919  // Skip if either parameter isn't of enumeral type.
7920  if (!FirstParamType->isEnumeralType() ||
7921  !SecondParamType->isEnumeralType())
7922  continue;
7923 
7924  // Add this operator to the set of known user-defined operators.
7925  UserDefinedBinaryOperators.insert(
7926  std::make_pair(S.Context.getCanonicalType(FirstParamType),
7927  S.Context.getCanonicalType(SecondParamType)));
7928  }
7929  }
7930  }
7931 
7932  /// Set of (canonical) types that we've already handled.
7933  llvm::SmallPtrSet<QualType, 8> AddedTypes;
7934 
7935  for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
7936  for (BuiltinCandidateTypeSet::iterator
7937  Ptr = CandidateTypes[ArgIdx].pointer_begin(),
7938  PtrEnd = CandidateTypes[ArgIdx].pointer_end();
7939  Ptr != PtrEnd; ++Ptr) {
7940  // Don't add the same builtin candidate twice.
7941  if (!AddedTypes.insert(S.Context.getCanonicalType(*Ptr)).second)
7942  continue;
7943 
7944  QualType ParamTypes[2] = { *Ptr, *Ptr };
7945  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
7946  }
7947  for (BuiltinCandidateTypeSet::iterator
7948  Enum = CandidateTypes[ArgIdx].enumeration_begin(),
7949  EnumEnd = CandidateTypes[ArgIdx].enumeration_end();
7950  Enum != EnumEnd; ++Enum) {
7951  CanQualType CanonType = S.Context.getCanonicalType(*Enum);
7952 
7953  // Don't add the same builtin candidate twice, or if a user defined
7954  // candidate exists.
7955  if (!AddedTypes.insert(CanonType).second ||
7956  UserDefinedBinaryOperators.count(std::make_pair(CanonType,
7957  CanonType)))
7958  continue;
7959 
7960  QualType ParamTypes[2] = { *Enum, *Enum };
7961  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
7962  }
7963  }
7964  }
7965 
7966  // C++ [over.built]p13:
7967  //
7968  // For every cv-qualified or cv-unqualified object type T
7969  // there exist candidate operator functions of the form
7970  //
7971  // T* operator+(T*, ptrdiff_t);
7972  // T& operator[](T*, ptrdiff_t); [BELOW]
7973  // T* operator-(T*, ptrdiff_t);
7974  // T* operator+(ptrdiff_t, T*);
7975  // T& operator[](ptrdiff_t, T*); [BELOW]
7976  //
7977  // C++ [over.built]p14:
7978  //
7979  // For every T, where T is a pointer to object type, there
7980  // exist candidate operator functions of the form
7981  //
7982  // ptrdiff_t operator-(T, T);
7983  void addBinaryPlusOrMinusPointerOverloads(OverloadedOperatorKind Op) {
7984  /// Set of (canonical) types that we've already handled.
7985  llvm::SmallPtrSet<QualType, 8> AddedTypes;
7986 
7987  for (int Arg = 0; Arg < 2; ++Arg) {
7988  QualType AsymmetricParamTypes[2] = {
7991  };
7992  for (BuiltinCandidateTypeSet::iterator
7993  Ptr = CandidateTypes[Arg].pointer_begin(),
7994  PtrEnd = CandidateTypes[Arg].pointer_end();
7995  Ptr != PtrEnd; ++Ptr) {
7996  QualType PointeeTy = (*Ptr)->getPointeeType();
7997  if (!PointeeTy->isObjectType())
7998  continue;
7999 
8000  AsymmetricParamTypes[Arg] = *Ptr;
8001  if (Arg == 0 || Op == OO_Plus) {
8002  // operator+(T*, ptrdiff_t) or operator-(T*, ptrdiff_t)
8003  // T* operator+(ptrdiff_t, T*);
8004  S.AddBuiltinCandidate(AsymmetricParamTypes, Args, CandidateSet);
8005  }
8006  if (Op == OO_Minus) {
8007  // ptrdiff_t operator-(T, T);
8008  if (!AddedTypes.insert(S.Context.getCanonicalType(*Ptr)).second)
8009  continue;
8010 
8011  QualType ParamTypes[2] = { *Ptr, *Ptr };
8012  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8013  }
8014  }
8015  }
8016  }
8017 
8018  // C++ [over.built]p12:
8019  //
8020  // For every pair of promoted arithmetic types L and R, there
8021  // exist candidate operator functions of the form
8022  //
8023  // LR operator*(L, R);
8024  // LR operator/(L, R);
8025  // LR operator+(L, R);
8026  // LR operator-(L, R);
8027  // bool operator<(L, R);
8028  // bool operator>(L, R);
8029  // bool operator<=(L, R);
8030  // bool operator>=(L, R);
8031  // bool operator==(L, R);
8032  // bool operator!=(L, R);
8033  //
8034  // where LR is the result of the usual arithmetic conversions
8035  // between types L and R.
8036  //
8037  // C++ [over.built]p24:
8038  //
8039  // For every pair of promoted arithmetic types L and R, there exist
8040  // candidate operator functions of the form
8041  //
8042  // LR operator?(bool, L, R);
8043  //
8044  // where LR is the result of the usual arithmetic conversions
8045  // between types L and R.
8046  // Our candidates ignore the first parameter.
8047  void addGenericBinaryArithmeticOverloads() {
8048  if (!HasArithmeticOrEnumeralCandidateType)
8049  return;
8050 
8051  for (unsigned Left = FirstPromotedArithmeticType;
8052  Left < LastPromotedArithmeticType; ++Left) {
8053  for (unsigned Right = FirstPromotedArithmeticType;
8054  Right < LastPromotedArithmeticType; ++Right) {
8055  QualType LandR[2] = { getArithmeticType(Left),
8056  getArithmeticType(Right) };
8057  S.AddBuiltinCandidate(LandR, Args, CandidateSet);
8058  }
8059  }
8060 
8061  // Extension: Add the binary operators ==, !=, <, <=, >=, >, *, /, and the
8062  // conditional operator for vector types.
8063  for (BuiltinCandidateTypeSet::iterator
8064  Vec1 = CandidateTypes[0].vector_begin(),
8065  Vec1End = CandidateTypes[0].vector_end();
8066  Vec1 != Vec1End; ++Vec1) {
8067  for (BuiltinCandidateTypeSet::iterator
8068  Vec2 = CandidateTypes[1].vector_begin(),
8069  Vec2End = CandidateTypes[1].vector_end();
8070  Vec2 != Vec2End; ++Vec2) {
8071  QualType LandR[2] = { *Vec1, *Vec2 };
8072  S.AddBuiltinCandidate(LandR, Args, CandidateSet);
8073  }
8074  }
8075  }
8076 
8077  // C++ [over.built]p17:
8078  //
8079  // For every pair of promoted integral types L and R, there
8080  // exist candidate operator functions of the form
8081  //
8082  // LR operator%(L, R);
8083  // LR operator&(L, R);
8084  // LR operator^(L, R);
8085  // LR operator|(L, R);
8086  // L operator<<(L, R);
8087  // L operator>>(L, R);
8088  //
8089  // where LR is the result of the usual arithmetic conversions
8090  // between types L and R.
8091  void addBinaryBitwiseArithmeticOverloads(OverloadedOperatorKind Op) {
8092  if (!HasArithmeticOrEnumeralCandidateType)
8093  return;
8094 
8095  for (unsigned Left = FirstPromotedIntegralType;
8096  Left < LastPromotedIntegralType; ++Left) {
8097  for (unsigned Right = FirstPromotedIntegralType;
8098  Right < LastPromotedIntegralType; ++Right) {
8099  QualType LandR[2] = { getArithmeticType(Left),
8100  getArithmeticType(Right) };
8101  S.AddBuiltinCandidate(LandR, Args, CandidateSet);
8102  }
8103  }
8104  }
8105 
8106  // C++ [over.built]p20:
8107  //
8108  // For every pair (T, VQ), where T is an enumeration or
8109  // pointer to member type and VQ is either volatile or
8110  // empty, there exist candidate operator functions of the form
8111  //
8112  // VQ T& operator=(VQ T&, T);
8113  void addAssignmentMemberPointerOrEnumeralOverloads() {
8114  /// Set of (canonical) types that we've already handled.
8115  llvm::SmallPtrSet<QualType, 8> AddedTypes;
8116 
8117  for (unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) {
8118  for (BuiltinCandidateTypeSet::iterator
8119  Enum = CandidateTypes[ArgIdx].enumeration_begin(),
8120  EnumEnd = CandidateTypes[ArgIdx].enumeration_end();
8121  Enum != EnumEnd; ++Enum) {
8122  if (!AddedTypes.insert(S.Context.getCanonicalType(*Enum)).second)
8123  continue;
8124 
8125  AddBuiltinAssignmentOperatorCandidates(S, *Enum, Args, CandidateSet);
8126  }
8127 
8128  for (BuiltinCandidateTypeSet::iterator
8129  MemPtr = CandidateTypes[ArgIdx].member_pointer_begin(),
8130  MemPtrEnd = CandidateTypes[ArgIdx].member_pointer_end();
8131  MemPtr != MemPtrEnd; ++MemPtr) {
8132  if (!AddedTypes.insert(S.Context.getCanonicalType(*MemPtr)).second)
8133  continue;
8134 
8135  AddBuiltinAssignmentOperatorCandidates(S, *MemPtr, Args, CandidateSet);
8136  }
8137  }
8138  }
8139 
8140  // C++ [over.built]p19:
8141  //
8142  // For every pair (T, VQ), where T is any type and VQ is either
8143  // volatile or empty, there exist candidate operator functions
8144  // of the form
8145  //
8146  // T*VQ& operator=(T*VQ&, T*);
8147  //
8148  // C++ [over.built]p21:
8149  //
8150  // For every pair (T, VQ), where T is a cv-qualified or
8151  // cv-unqualified object type and VQ is either volatile or
8152  // empty, there exist candidate operator functions of the form
8153  //
8154  // T*VQ& operator+=(T*VQ&, ptrdiff_t);
8155  // T*VQ& operator-=(T*VQ&, ptrdiff_t);
8156  void addAssignmentPointerOverloads(bool isEqualOp) {
8157  /// Set of (canonical) types that we've already handled.
8158  llvm::SmallPtrSet<QualType, 8> AddedTypes;
8159 
8160  for (BuiltinCandidateTypeSet::iterator
8161  Ptr = CandidateTypes[0].pointer_begin(),
8162  PtrEnd = CandidateTypes[0].pointer_end();
8163  Ptr != PtrEnd; ++Ptr) {
8164  // If this is operator=, keep track of the builtin candidates we added.
8165  if (isEqualOp)
8166  AddedTypes.insert(S.Context.getCanonicalType(*Ptr));
8167  else if (!(*Ptr)->getPointeeType()->isObjectType())
8168  continue;
8169 
8170  // non-volatile version
8171  QualType ParamTypes[2] = {
8173  isEqualOp ? *Ptr : S.Context.getPointerDiffType(),
8174  };
8175  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8176  /*IsAssigmentOperator=*/ isEqualOp);
8177 
8178  bool NeedVolatile = !(*Ptr).isVolatileQualified() &&
8179  VisibleTypeConversionsQuals.hasVolatile();
8180  if (NeedVolatile) {
8181  // volatile version
8182  ParamTypes[0] =
8184  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8185  /*IsAssigmentOperator=*/isEqualOp);
8186  }
8187 
8188  if (!(*Ptr).isRestrictQualified() &&
8189  VisibleTypeConversionsQuals.hasRestrict()) {
8190  // restrict version
8191  ParamTypes[0]
8193  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8194  /*IsAssigmentOperator=*/isEqualOp);
8195 
8196  if (NeedVolatile) {
8197  // volatile restrict version
8198  ParamTypes[0]
8201  (Qualifiers::Volatile |
8202  Qualifiers::Restrict)));
8203  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8204  /*IsAssigmentOperator=*/isEqualOp);
8205  }
8206  }
8207  }
8208 
8209  if (isEqualOp) {
8210  for (BuiltinCandidateTypeSet::iterator
8211  Ptr = CandidateTypes[1].pointer_begin(),
8212  PtrEnd = CandidateTypes[1].pointer_end();
8213  Ptr != PtrEnd; ++Ptr) {
8214  // Make sure we don't add the same candidate twice.
8215  if (!AddedTypes.insert(S.Context.getCanonicalType(*Ptr)).second)
8216  continue;
8217 
8218  QualType ParamTypes[2] = {
8220  *Ptr,
8221  };
8222 
8223  // non-volatile version
8224  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8225  /*IsAssigmentOperator=*/true);
8226 
8227  bool NeedVolatile = !(*Ptr).isVolatileQualified() &&
8228  VisibleTypeConversionsQuals.hasVolatile();
8229  if (NeedVolatile) {
8230  // volatile version
8231  ParamTypes[0] =
8233  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8234  /*IsAssigmentOperator=*/true);
8235  }
8236 
8237  if (!(*Ptr).isRestrictQualified() &&
8238  VisibleTypeConversionsQuals.hasRestrict()) {
8239  // restrict version
8240  ParamTypes[0]
8242  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8243  /*IsAssigmentOperator=*/true);
8244 
8245  if (NeedVolatile) {
8246  // volatile restrict version
8247  ParamTypes[0]
8250  (Qualifiers::Volatile |
8251  Qualifiers::Restrict)));
8252  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8253  /*IsAssigmentOperator=*/true);
8254  }
8255  }
8256  }
8257  }
8258  }
8259 
8260  // C++ [over.built]p18:
8261  //
8262  // For every triple (L, VQ, R), where L is an arithmetic type,
8263  // VQ is either volatile or empty, and R is a promoted
8264  // arithmetic type, there exist candidate operator functions of
8265  // the form
8266  //
8267  // VQ L& operator=(VQ L&, R);
8268  // VQ L& operator*=(VQ L&, R);
8269  // VQ L& operator/=(VQ L&, R);
8270  // VQ L& operator+=(VQ L&, R);
8271  // VQ L& operator-=(VQ L&, R);
8272  void addAssignmentArithmeticOverloads(bool isEqualOp) {
8273  if (!HasArithmeticOrEnumeralCandidateType)
8274  return;
8275 
8276  for (unsigned Left = 0; Left < NumArithmeticTypes; ++Left) {
8277  for (unsigned Right = FirstPromotedArithmeticType;
8278  Right < LastPromotedArithmeticType; ++Right) {
8279  QualType ParamTypes[2];
8280  ParamTypes[1] = getArithmeticType(Right);
8281 
8282  // Add this built-in operator as a candidate (VQ is empty).
8283  ParamTypes[0] =
8284  S.Context.getLValueReferenceType(getArithmeticType(Left));
8285  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8286  /*IsAssigmentOperator=*/isEqualOp);
8287 
8288  // Add this built-in operator as a candidate (VQ is 'volatile').
8289  if (VisibleTypeConversionsQuals.hasVolatile()) {
8290  ParamTypes[0] =
8291  S.Context.getVolatileType(getArithmeticType(Left));
8292  ParamTypes[0] = S.Context.getLValueReferenceType(ParamTypes[0]);
8293  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8294  /*IsAssigmentOperator=*/isEqualOp);
8295  }
8296  }
8297  }
8298 
8299  // Extension: Add the binary operators =, +=, -=, *=, /= for vector types.
8300  for (BuiltinCandidateTypeSet::iterator
8301  Vec1 = CandidateTypes[0].vector_begin(),
8302  Vec1End = CandidateTypes[0].vector_end();
8303  Vec1 != Vec1End; ++Vec1) {
8304  for (BuiltinCandidateTypeSet::iterator
8305  Vec2 = CandidateTypes[1].vector_begin(),
8306  Vec2End = CandidateTypes[1].vector_end();
8307  Vec2 != Vec2End; ++Vec2) {
8308  QualType ParamTypes[2];
8309  ParamTypes[1] = *Vec2;
8310  // Add this built-in operator as a candidate (VQ is empty).
8311  ParamTypes[0] = S.Context.getLValueReferenceType(*Vec1);
8312  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8313  /*IsAssigmentOperator=*/isEqualOp);
8314 
8315  // Add this built-in operator as a candidate (VQ is 'volatile').
8316  if (VisibleTypeConversionsQuals.hasVolatile()) {
8317  ParamTypes[0] = S.Context.getVolatileType(*Vec1);
8318  ParamTypes[0] = S.Context.getLValueReferenceType(ParamTypes[0]);
8319  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8320  /*IsAssigmentOperator=*/isEqualOp);
8321  }
8322  }
8323  }
8324  }
8325 
8326  // C++ [over.built]p22:
8327  //
8328  // For every triple (L, VQ, R), where L is an integral type, VQ
8329  // is either volatile or empty, and R is a promoted integral
8330  // type, there exist candidate operator functions of 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  // VQ L& operator|=(VQ L&, R);
8338  void addAssignmentIntegralOverloads() {
8339  if (!HasArithmeticOrEnumeralCandidateType)
8340  return;
8341 
8342  for (unsigned Left = FirstIntegralType; Left < LastIntegralType; ++Left) {
8343  for (unsigned Right = FirstPromotedIntegralType;
8344  Right < LastPromotedIntegralType; ++Right) {
8345  QualType ParamTypes[2];
8346  ParamTypes[1] = getArithmeticType(Right);
8347 
8348  // Add this built-in operator as a candidate (VQ is empty).
8349  ParamTypes[0] =
8350  S.Context.getLValueReferenceType(getArithmeticType(Left));
8351  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8352  if (VisibleTypeConversionsQuals.hasVolatile()) {
8353  // Add this built-in operator as a candidate (VQ is 'volatile').
8354  ParamTypes[0] = getArithmeticType(Left);
8355  ParamTypes[0] = S.Context.getVolatileType(ParamTypes[0]);
8356  ParamTypes[0] = S.Context.getLValueReferenceType(ParamTypes[0]);
8357  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8358  }
8359  }
8360  }
8361  }
8362 
8363  // C++ [over.operator]p23:
8364  //
8365  // There also exist candidate operator functions of the form
8366  //
8367  // bool operator!(bool);
8368  // bool operator&&(bool, bool);
8369  // bool operator||(bool, bool);
8370  void addExclaimOverload() {
8371  QualType ParamTy = S.Context.BoolTy;
8372  S.AddBuiltinCandidate(&ParamTy, Args, CandidateSet,
8373  /*IsAssignmentOperator=*/false,
8374  /*NumContextualBoolArguments=*/1);
8375  }
8376  void addAmpAmpOrPipePipeOverload() {
8377  QualType ParamTypes[2] = { S.Context.BoolTy, S.Context.BoolTy };
8378  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8379  /*IsAssignmentOperator=*/false,
8380  /*NumContextualBoolArguments=*/2);
8381  }
8382 
8383  // C++ [over.built]p13:
8384  //
8385  // For every cv-qualified or cv-unqualified object type T there
8386  // exist candidate operator functions of the form
8387  //
8388  // T* operator+(T*, ptrdiff_t); [ABOVE]
8389  // T& operator[](T*, ptrdiff_t);
8390  // T* operator-(T*, ptrdiff_t); [ABOVE]
8391  // T* operator+(ptrdiff_t, T*); [ABOVE]
8392  // T& operator[](ptrdiff_t, T*);
8393  void addSubscriptOverloads() {
8394  for (BuiltinCandidateTypeSet::iterator
8395  Ptr = CandidateTypes[0].pointer_begin(),
8396  PtrEnd = CandidateTypes[0].pointer_end();
8397  Ptr != PtrEnd; ++Ptr) {
8398  QualType ParamTypes[2] = { *Ptr, S.Context.getPointerDiffType() };
8399  QualType PointeeType = (*Ptr)->getPointeeType();
8400  if (!PointeeType->isObjectType())
8401  continue;
8402 
8403  // T& operator[](T*, ptrdiff_t)
8404  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8405  }
8406 
8407  for (BuiltinCandidateTypeSet::iterator
8408  Ptr = CandidateTypes[1].pointer_begin(),
8409  PtrEnd = CandidateTypes[1].pointer_end();
8410  Ptr != PtrEnd; ++Ptr) {
8411  QualType ParamTypes[2] = { S.Context.getPointerDiffType(), *Ptr };
8412  QualType PointeeType = (*Ptr)->getPointeeType();
8413  if (!PointeeType->isObjectType())
8414  continue;
8415 
8416  // T& operator[](ptrdiff_t, T*)
8417  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8418  }
8419  }
8420 
8421  // C++ [over.built]p11:
8422  // For every quintuple (C1, C2, T, CV1, CV2), where C2 is a class type,
8423  // C1 is the same type as C2 or is a derived class of C2, T is an object
8424  // type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
8425  // there exist candidate operator functions of the form
8426  //
8427  // CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
8428  //
8429  // where CV12 is the union of CV1 and CV2.
8430  void addArrowStarOverloads() {
8431  for (BuiltinCandidateTypeSet::iterator
8432  Ptr = CandidateTypes[0].pointer_begin(),
8433  PtrEnd = CandidateTypes[0].pointer_end();
8434  Ptr != PtrEnd; ++Ptr) {
8435  QualType C1Ty = (*Ptr);
8436  QualType C1;
8437  QualifierCollector Q1;
8438  C1 = QualType(Q1.strip(C1Ty->getPointeeType()), 0);
8439  if (!isa<RecordType>(C1))
8440  continue;
8441  // heuristic to reduce number of builtin candidates in the set.
8442  // Add volatile/restrict version only if there are conversions to a
8443  // volatile/restrict type.
8444  if (!VisibleTypeConversionsQuals.hasVolatile() && Q1.hasVolatile())
8445  continue;
8446  if (!VisibleTypeConversionsQuals.hasRestrict() && Q1.hasRestrict())
8447  continue;
8448  for (BuiltinCandidateTypeSet::iterator
8449  MemPtr = CandidateTypes[1].member_pointer_begin(),
8450  MemPtrEnd = CandidateTypes[1].member_pointer_end();
8451  MemPtr != MemPtrEnd; ++MemPtr) {
8452  const MemberPointerType *mptr = cast<MemberPointerType>(*MemPtr);
8453  QualType C2 = QualType(mptr->getClass(), 0);
8454  C2 = C2.getUnqualifiedType();
8455  if (C1 != C2 && !S.IsDerivedFrom(CandidateSet.getLocation(), C1, C2))
8456  break;
8457  QualType ParamTypes[2] = { *Ptr, *MemPtr };
8458  // build CV12 T&
8459  QualType T = mptr->getPointeeType();
8460  if (!VisibleTypeConversionsQuals.hasVolatile() &&
8461  T.isVolatileQualified())
8462  continue;
8463  if (!VisibleTypeConversionsQuals.hasRestrict() &&
8464  T.isRestrictQualified())
8465  continue;
8466  T = Q1.apply(S.Context, T);
8467  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8468  }
8469  }
8470  }
8471 
8472  // Note that we don't consider the first argument, since it has been
8473  // contextually converted to bool long ago. The candidates below are
8474  // therefore added as binary.
8475  //
8476  // C++ [over.built]p25:
8477  // For every type T, where T is a pointer, pointer-to-member, or scoped
8478  // enumeration type, there exist candidate operator functions of the form
8479  //
8480  // T operator?(bool, T, T);
8481  //
8482  void addConditionalOperatorOverloads() {
8483  /// Set of (canonical) types that we've already handled.
8484  llvm::SmallPtrSet<QualType, 8> AddedTypes;
8485 
8486  for (unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) {
8487  for (BuiltinCandidateTypeSet::iterator
8488  Ptr = CandidateTypes[ArgIdx].pointer_begin(),
8489  PtrEnd = CandidateTypes[ArgIdx].pointer_end();
8490  Ptr != PtrEnd; ++Ptr) {
8491  if (!AddedTypes.insert(S.Context.getCanonicalType(*Ptr)).second)
8492  continue;
8493 
8494  QualType ParamTypes[2] = { *Ptr, *Ptr };
8495  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8496  }
8497 
8498  for (BuiltinCandidateTypeSet::iterator
8499  MemPtr = CandidateTypes[ArgIdx].member_pointer_begin(),
8500  MemPtrEnd = CandidateTypes[ArgIdx].member_pointer_end();
8501  MemPtr != MemPtrEnd; ++MemPtr) {
8502  if (!AddedTypes.insert(S.Context.getCanonicalType(*MemPtr)).second)
8503  continue;
8504 
8505  QualType ParamTypes[2] = { *MemPtr, *MemPtr };
8506  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8507  }
8508 
8509  if (S.getLangOpts().CPlusPlus11) {
8510  for (BuiltinCandidateTypeSet::iterator
8511  Enum = CandidateTypes[ArgIdx].enumeration_begin(),
8512  EnumEnd = CandidateTypes[ArgIdx].enumeration_end();
8513  Enum != EnumEnd; ++Enum) {
8514  if (!(*Enum)->getAs<EnumType>()->getDecl()->isScoped())
8515  continue;
8516 
8517  if (!AddedTypes.insert(S.Context.getCanonicalType(*Enum)).second)
8518  continue;
8519 
8520  QualType ParamTypes[2] = { *Enum, *Enum };
8521  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8522  }
8523  }
8524  }
8525  }
8526 };
8527 
8528 } // end anonymous namespace
8529 
8530 /// AddBuiltinOperatorCandidates - Add the appropriate built-in
8531 /// operator overloads to the candidate set (C++ [over.built]), based
8532 /// on the operator @p Op and the arguments given. For example, if the
8533 /// operator is a binary '+', this routine might add "int
8534 /// operator+(int, int)" to cover integer addition.
8536  SourceLocation OpLoc,
8537  ArrayRef<Expr *> Args,
8538  OverloadCandidateSet &CandidateSet) {
8539  // Find all of the types that the arguments can convert to, but only
8540  // if the operator we're looking at has built-in operator candidates
8541  // that make use of these types. Also record whether we encounter non-record
8542  // candidate types or either arithmetic or enumeral candidate types.
8543  Qualifiers VisibleTypeConversionsQuals;
8544  VisibleTypeConversionsQuals.addConst();
8545  for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx)
8546  VisibleTypeConversionsQuals += CollectVRQualifiers(Context, Args[ArgIdx]);
8547 
8548  bool HasNonRecordCandidateType = false;
8549  bool HasArithmeticOrEnumeralCandidateType = false;
8551  for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
8552  CandidateTypes.emplace_back(*this);
8553  CandidateTypes[ArgIdx].AddTypesConvertedFrom(Args[ArgIdx]->getType(),
8554  OpLoc,
8555  true,
8556  (Op == OO_Exclaim ||
8557  Op == OO_AmpAmp ||
8558  Op == OO_PipePipe),
8559  VisibleTypeConversionsQuals);
8560  HasNonRecordCandidateType = HasNonRecordCandidateType ||
8561  CandidateTypes[ArgIdx].hasNonRecordTypes();
8562  HasArithmeticOrEnumeralCandidateType =
8563  HasArithmeticOrEnumeralCandidateType ||
8564  CandidateTypes[ArgIdx].hasArithmeticOrEnumeralTypes();
8565  }
8566 
8567  // Exit early when no non-record types have been added to the candidate set
8568  // for any of the arguments to the operator.
8569  //
8570  // We can't exit early for !, ||, or &&, since there we have always have
8571  // 'bool' overloads.
8572  if (!HasNonRecordCandidateType &&
8573  !(Op == OO_Exclaim || Op == OO_AmpAmp || Op == OO_PipePipe))
8574  return;
8575 
8576  // Setup an object to manage the common state for building overloads.
8577  BuiltinOperatorOverloadBuilder OpBuilder(*this, Args,
8578  VisibleTypeConversionsQuals,
8579  HasArithmeticOrEnumeralCandidateType,
8580  CandidateTypes, CandidateSet);
8581 
8582  // Dispatch over the operation to add in only those overloads which apply.
8583  switch (Op) {
8584  case OO_None:
8586  llvm_unreachable("Expected an overloaded operator");
8587 
8588  case OO_New:
8589  case OO_Delete:
8590  case OO_Array_New:
8591  case OO_Array_Delete:
8592  case OO_Call:
8593  llvm_unreachable(
8594  "Special operators don't use AddBuiltinOperatorCandidates");
8595 
8596  case OO_Comma:
8597  case OO_Arrow:
8598  case OO_Coawait:
8599  // C++ [over.match.oper]p3:
8600  // -- For the operator ',', the unary operator '&', the
8601  // operator '->', or the operator 'co_await', the
8602  // built-in candidates set is empty.
8603  break;
8604 
8605  case OO_Plus: // '+' is either unary or binary
8606  if (Args.size() == 1)
8607  OpBuilder.addUnaryPlusPointerOverloads();
8608  // Fall through.
8609 
8610  case OO_Minus: // '-' is either unary or binary
8611  if (Args.size() == 1) {
8612  OpBuilder.addUnaryPlusOrMinusArithmeticOverloads();
8613  } else {
8614  OpBuilder.addBinaryPlusOrMinusPointerOverloads(Op);
8615  OpBuilder.addGenericBinaryArithmeticOverloads();
8616  }
8617  break;
8618 
8619  case OO_Star: // '*' is either unary or binary
8620  if (Args.size() == 1)
8621  OpBuilder.addUnaryStarPointerOverloads();
8622  else
8623  OpBuilder.addGenericBinaryArithmeticOverloads();
8624  break;
8625 
8626  case OO_Slash:
8627  OpBuilder.addGenericBinaryArithmeticOverloads();
8628  break;
8629 
8630  case OO_PlusPlus:
8631  case OO_MinusMinus:
8632  OpBuilder.addPlusPlusMinusMinusArithmeticOverloads(Op);
8633  OpBuilder.addPlusPlusMinusMinusPointerOverloads();
8634  break;
8635 
8636  case OO_EqualEqual:
8637  case OO_ExclaimEqual:
8638  OpBuilder.addEqualEqualOrNotEqualMemberPointerOrNullptrOverloads();
8639  // Fall through.
8640 
8641  case OO_Less:
8642  case OO_Greater:
8643  case OO_LessEqual:
8644  case OO_GreaterEqual:
8645  OpBuilder.addRelationalPointerOrEnumeralOverloads();
8646  OpBuilder.addGenericBinaryArithmeticOverloads();
8647  break;
8648 
8649  case OO_Percent:
8650  case OO_Caret:
8651  case OO_Pipe:
8652  case OO_LessLess:
8653  case OO_GreaterGreater:
8654  OpBuilder.addBinaryBitwiseArithmeticOverloads(Op);
8655  break;
8656 
8657  case OO_Amp: // '&' is either unary or binary
8658  if (Args.size() == 1)
8659  // C++ [over.match.oper]p3:
8660  // -- For the operator ',', the unary operator '&', or the
8661  // operator '->', the built-in candidates set is empty.
8662  break;
8663 
8664  OpBuilder.addBinaryBitwiseArithmeticOverloads(Op);
8665  break;
8666 
8667  case OO_Tilde:
8668  OpBuilder.addUnaryTildePromotedIntegralOverloads();
8669  break;
8670 
8671  case OO_Equal:
8672  OpBuilder.addAssignmentMemberPointerOrEnumeralOverloads();
8673  // Fall through.
8674 
8675  case OO_PlusEqual:
8676  case OO_MinusEqual:
8677  OpBuilder.addAssignmentPointerOverloads(Op == OO_Equal);
8678  // Fall through.
8679 
8680  case OO_StarEqual:
8681  case OO_SlashEqual:
8682  OpBuilder.addAssignmentArithmeticOverloads(Op == OO_Equal);
8683  break;
8684 
8685  case OO_PercentEqual:
8686  case OO_LessLessEqual:
8687  case OO_GreaterGreaterEqual:
8688  case OO_AmpEqual:
8689  case OO_CaretEqual:
8690  case OO_PipeEqual:
8691  OpBuilder.addAssignmentIntegralOverloads();
8692  break;
8693 
8694  case OO_Exclaim:
8695  OpBuilder.addExclaimOverload();
8696  break;
8697 
8698  case OO_AmpAmp:
8699  case OO_PipePipe:
8700  OpBuilder.addAmpAmpOrPipePipeOverload();
8701  break;
8702 
8703  case OO_Subscript:
8704  OpBuilder.addSubscriptOverloads();
8705  break;
8706 
8707  case OO_ArrowStar:
8708  OpBuilder.addArrowStarOverloads();
8709  break;
8710 
8711  case OO_Conditional:
8712  OpBuilder.addConditionalOperatorOverloads();
8713  OpBuilder.addGenericBinaryArithmeticOverloads();
8714  break;
8715  }
8716 }
8717 
8718 /// \brief Add function candidates found via argument-dependent lookup
8719 /// to the set of overloading candidates.
8720 ///
8721 /// This routine performs argument-dependent name lookup based on the
8722 /// given function name (which may also be an operator name) and adds
8723 /// all of the overload candidates found by ADL to the overload
8724 /// candidate set (C++ [basic.lookup.argdep]).
8725 void
8727  SourceLocation Loc,
8728  ArrayRef<Expr *> Args,
8729  TemplateArgumentListInfo *ExplicitTemplateArgs,
8730  OverloadCandidateSet& CandidateSet,
8731  bool PartialOverloading) {
8732  ADLResult Fns;
8733 
8734  // FIXME: This approach for uniquing ADL results (and removing
8735  // redundant candidates from the set) relies on pointer-equality,
8736  // which means we need to key off the canonical decl. However,
8737  // always going back to the canonical decl might not get us the
8738  // right set of default arguments. What default arguments are
8739  // we supposed to consider on ADL candidates, anyway?
8740 
8741  // FIXME: Pass in the explicit template arguments?
8742  ArgumentDependentLookup(Name, Loc, Args, Fns);
8743 
8744  // Erase all of the candidates we already knew about.
8745  for (OverloadCandidateSet::iterator Cand = CandidateSet.begin(),
8746  CandEnd = CandidateSet.end();
8747  Cand != CandEnd; ++Cand)
8748  if (Cand->Function) {
8749  Fns.erase(Cand->Function);
8750  if (FunctionTemplateDecl *FunTmpl = Cand->Function->getPrimaryTemplate())
8751  Fns.erase(FunTmpl);
8752  }
8753 
8754  // For each of the ADL candidates we found, add it to the overload
8755  // set.
8756  for (ADLResult::iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) {
8758  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
8759  if (ExplicitTemplateArgs)
8760  continue;
8761 
8762  AddOverloadCandidate(FD, FoundDecl, Args, CandidateSet, false,
8763  PartialOverloading);
8764  } else
8765  AddTemplateOverloadCandidate(cast<FunctionTemplateDecl>(*I),
8766  FoundDecl, ExplicitTemplateArgs,
8767  Args, CandidateSet, PartialOverloading);
8768  }
8769 }
8770 
8771 namespace {
8772 enum class Comparison { Equal, Better, Worse };
8773 }
8774 
8775 /// Compares the enable_if attributes of two FunctionDecls, for the purposes of
8776 /// overload resolution.
8777 ///
8778 /// Cand1's set of enable_if attributes are said to be "better" than Cand2's iff
8779 /// Cand1's first N enable_if attributes have precisely the same conditions as
8780 /// Cand2's first N enable_if attributes (where N = the number of enable_if
8781 /// attributes on Cand2), and Cand1 has more than N enable_if attributes.
8782 ///
8783 /// Note that you can have a pair of candidates such that Cand1's enable_if
8784 /// attributes are worse than Cand2's, and Cand2's enable_if attributes are
8785 /// worse than Cand1's.
8786 static Comparison compareEnableIfAttrs(const Sema &S, const FunctionDecl *Cand1,
8787  const FunctionDecl *Cand2) {
8788  // Common case: One (or both) decls don't have enable_if attrs.
8789  bool Cand1Attr = Cand1->hasAttr<EnableIfAttr>();
8790  bool Cand2Attr = Cand2->hasAttr<EnableIfAttr>();
8791  if (!Cand1Attr || !Cand2Attr) {
8792  if (Cand1Attr == Cand2Attr)
8793  return Comparison::Equal;
8794  return Cand1Attr ? Comparison::Better : Comparison::Worse;
8795  }
8796 
8797  // FIXME: The next several lines are just
8798  // specific_attr_iterator<EnableIfAttr> but going in declaration order,
8799  // instead of reverse order which is how they're stored in the AST.
8800  auto Cand1Attrs = getOrderedEnableIfAttrs(Cand1);
8801  auto Cand2Attrs = getOrderedEnableIfAttrs(Cand2);
8802 
8803  // It's impossible for Cand1 to be better than (or equal to) Cand2 if Cand1
8804  // has fewer enable_if attributes than Cand2.
8805  if (Cand1Attrs.size() < Cand2Attrs.size())
8806  return Comparison::Worse;
8807 
8808  auto Cand1I = Cand1Attrs.begin();
8809  llvm::FoldingSetNodeID Cand1ID, Cand2ID;
8810  for (auto &Cand2A : Cand2Attrs) {
8811  Cand1ID.clear();
8812  Cand2ID.clear();
8813 
8814  auto &Cand1A = *Cand1I++;
8815  Cand1A->getCond()->Profile(Cand1ID, S.getASTContext(), true);
8816  Cand2A->getCond()->Profile(Cand2ID, S.getASTContext(), true);
8817  if (Cand1ID != Cand2ID)
8818  return Comparison::Worse;
8819  }
8820 
8821  return Cand1I == Cand1Attrs.end() ? Comparison::Equal : Comparison::Better;
8822 }
8823 
8824 /// isBetterOverloadCandidate - Determines whether the first overload
8825 /// candidate is a better candidate than the second (C++ 13.3.3p1).
8827  const OverloadCandidate &Cand2,
8828  SourceLocation Loc,
8829  bool UserDefinedConversion) {
8830  // Define viable functions to be better candidates than non-viable
8831  // functions.
8832  if (!Cand2.Viable)
8833  return Cand1.Viable;
8834  else if (!Cand1.Viable)
8835  return false;
8836 
8837  // C++ [over.match.best]p1:
8838  //
8839  // -- if F is a static member function, ICS1(F) is defined such
8840  // that ICS1(F) is neither better nor worse than ICS1(G) for
8841  // any function G, and, symmetrically, ICS1(G) is neither
8842  // better nor worse than ICS1(F).
8843  unsigned StartArg = 0;
8844  if (Cand1.IgnoreObjectArgument || Cand2.IgnoreObjectArgument)
8845  StartArg = 1;
8846 
8847  auto IsIllFormedConversion = [&](const ImplicitConversionSequence &ICS) {
8848  // We don't allow incompatible pointer conversions in C++.
8849  if (!S.getLangOpts().CPlusPlus)
8850  return ICS.isStandard() &&
8851  ICS.Standard.Second == ICK_Incompatible_Pointer_Conversion;
8852 
8853  // The only ill-formed conversion we allow in C++ is the string literal to
8854  // char* conversion, which is only considered ill-formed after C++11.
8855  return S.getLangOpts().CPlusPlus11 && !S.getLangOpts().WritableStrings &&
8857  };
8858 
8859  // Define functions that don't require ill-formed conversions for a given
8860  // argument to be better candidates than functions that do.
8861  unsigned NumArgs = Cand1.Conversions.size();
8862  assert(Cand2.Conversions.size() == NumArgs && "Overload candidate mismatch");
8863  bool HasBetterConversion = false;
8864  for (unsigned ArgIdx = StartArg; ArgIdx < NumArgs; ++ArgIdx) {
8865  bool Cand1Bad = IsIllFormedConversion(Cand1.Conversions[ArgIdx]);
8866  bool Cand2Bad = IsIllFormedConversion(Cand2.Conversions[ArgIdx]);
8867  if (Cand1Bad != Cand2Bad) {
8868  if (Cand1Bad)
8869  return false;
8870  HasBetterConversion = true;
8871  }
8872  }
8873 
8874  if (HasBetterConversion)
8875  return true;
8876 
8877  // C++ [over.match.best]p1:
8878  // A viable function F1 is defined to be a better function than another
8879  // viable function F2 if for all arguments i, ICSi(F1) is not a worse
8880  // conversion sequence than ICSi(F2), and then...
8881  for (unsigned ArgIdx = StartArg; ArgIdx < NumArgs; ++ArgIdx) {
8882  switch (CompareImplicitConversionSequences(S, Loc,
8883  Cand1.Conversions[ArgIdx],
8884  Cand2.Conversions[ArgIdx])) {
8886  // Cand1 has a better conversion sequence.
8887  HasBetterConversion = true;
8888  break;
8889 
8891  // Cand1 can't be better than Cand2.
8892  return false;
8893 
8895  // Do nothing.
8896  break;
8897  }
8898  }
8899 
8900  // -- for some argument j, ICSj(F1) is a better conversion sequence than
8901  // ICSj(F2), or, if not that,
8902  if (HasBetterConversion)
8903  return true;
8904 
8905  // -- the context is an initialization by user-defined conversion
8906  // (see 8.5, 13.3.1.5) and the standard conversion sequence
8907  // from the return type of F1 to the destination type (i.e.,
8908  // the type of the entity being initialized) is a better
8909  // conversion sequence than the standard conversion sequence
8910  // from the return type of F2 to the destination type.
8911  if (UserDefinedConversion && Cand1.Function && Cand2.Function &&
8912  isa<CXXConversionDecl>(Cand1.Function) &&
8913  isa<CXXConversionDecl>(Cand2.Function)) {
8914  // First check whether we prefer one of the conversion functions over the
8915  // other. This only distinguishes the results in non-standard, extension
8916  // cases such as the conversion from a lambda closure type to a function
8917  // pointer or block.
8919  compareConversionFunctions(S, Cand1.Function, Cand2.Function);
8921  Result = CompareStandardConversionSequences(S, Loc,
8922  Cand1.FinalConversion,
8923  Cand2.FinalConversion);
8924 
8926  return Result == ImplicitConversionSequence::Better;
8927 
8928  // FIXME: Compare kind of reference binding if conversion functions
8929  // convert to a reference type used in direct reference binding, per
8930  // C++14 [over.match.best]p1 section 2 bullet 3.
8931  }
8932 
8933  // -- F1 is generated from a deduction-guide and F2 is not
8934  auto *Guide1 = dyn_cast_or_null<CXXDeductionGuideDecl>(Cand1.Function);
8935  auto *Guide2 = dyn_cast_or_null<CXXDeductionGuideDecl>(Cand2.Function);
8936  if (Guide1 && Guide2 && Guide1->isImplicit() != Guide2->isImplicit())
8937  return Guide2->isImplicit();
8938 
8939  // -- F1 is a non-template function and F2 is a function template
8940  // specialization, or, if not that,
8941  bool Cand1IsSpecialization = Cand1.Function &&
8942  Cand1.Function->getPrimaryTemplate();
8943  bool Cand2IsSpecialization = Cand2.Function &&
8944  Cand2.Function->getPrimaryTemplate();
8945  if (Cand1IsSpecialization != Cand2IsSpecialization)
8946  return Cand2IsSpecialization;
8947 
8948  // -- F1 and F2 are function template specializations, and the function
8949  // template for F1 is more specialized than the template for F2
8950  // according to the partial ordering rules described in 14.5.5.2, or,
8951  // if not that,
8952  if (Cand1IsSpecialization && Cand2IsSpecialization) {
8953  if (FunctionTemplateDecl *BetterTemplate
8955  Cand2.Function->getPrimaryTemplate(),
8956  Loc,
8957  isa<CXXConversionDecl>(Cand1.Function)? TPOC_Conversion
8958  : TPOC_Call,
8959  Cand1.ExplicitCallArguments,
8960  Cand2.ExplicitCallArguments))
8961  return BetterTemplate == Cand1.Function->getPrimaryTemplate();
8962  }
8963 
8964  // FIXME: Work around a defect in the C++17 inheriting constructor wording.
8965  // A derived-class constructor beats an (inherited) base class constructor.
8966  bool Cand1IsInherited =
8967  dyn_cast_or_null<ConstructorUsingShadowDecl>(Cand1.FoundDecl.getDecl());
8968  bool Cand2IsInherited =
8969  dyn_cast_or_null<ConstructorUsingShadowDecl>(Cand2.FoundDecl.getDecl());
8970  if (Cand1IsInherited != Cand2IsInherited)
8971  return Cand2IsInherited;
8972  else if (Cand1IsInherited) {
8973  assert(Cand2IsInherited);
8974  auto *Cand1Class = cast<CXXRecordDecl>(Cand1.Function->getDeclContext());
8975  auto *Cand2Class = cast<CXXRecordDecl>(Cand2.Function->getDeclContext());
8976  if (Cand1Class->isDerivedFrom(Cand2Class))
8977  return true;
8978  if (Cand2Class->isDerivedFrom(Cand1Class))
8979  return false;
8980  // Inherited from sibling base classes: still ambiguous.
8981  }
8982 
8983  // Check for enable_if value-based overload resolution.
8984  if (Cand1.Function && Cand2.Function) {
8985  Comparison Cmp = compareEnableIfAttrs(S, Cand1.Function, Cand2.Function);
8986  if (Cmp != Comparison::Equal)
8987  return Cmp == Comparison::Better;
8988  }
8989 
8990  if (S.getLangOpts().CUDA && Cand1.Function && Cand2.Function) {
8991  FunctionDecl *Caller = dyn_cast<FunctionDecl>(S.CurContext);
8992  return S.IdentifyCUDAPreference(Caller, Cand1.Function) >
8993  S.IdentifyCUDAPreference(Caller, Cand2.Function);
8994  }
8995 
8996  bool HasPS1 = Cand1.Function != nullptr &&
8998  bool HasPS2 = Cand2.Function != nullptr &&
9000  return HasPS1 != HasPS2 && HasPS1;
9001 }
9002 
9003 /// Determine whether two declarations are "equivalent" for the purposes of
9004 /// name lookup and overload resolution. This applies when the same internal/no
9005 /// linkage entity is defined by two modules (probably by textually including
9006 /// the same header). In such a case, we don't consider the declarations to
9007 /// declare the same entity, but we also don't want lookups with both
9008 /// declarations visible to be ambiguous in some cases (this happens when using
9009 /// a modularized libstdc++).
9011  const NamedDecl *B) {
9012  auto *VA = dyn_cast_or_null<ValueDecl>(A);
9013  auto *VB = dyn_cast_or_null<ValueDecl>(B);
9014  if (!VA || !VB)
9015  return false;
9016 
9017  // The declarations must be declaring the same name as an internal linkage
9018  // entity in different modules.
9019  if (!VA->getDeclContext()->getRedeclContext()->Equals(
9020  VB->getDeclContext()->getRedeclContext()) ||
9021  getOwningModule(const_cast<ValueDecl *>(VA)) ==
9022  getOwningModule(const_cast<ValueDecl *>(VB)) ||
9023  VA->isExternallyVisible() || VB->isExternallyVisible())
9024  return false;
9025 
9026  // Check that the declarations appear to be equivalent.
9027  //
9028  // FIXME: Checking the type isn't really enough to resolve the ambiguity.
9029  // For constants and functions, we should check the initializer or body is
9030  // the same. For non-constant variables, we shouldn't allow it at all.
9031  if (Context.hasSameType(VA->getType(), VB->getType()))
9032  return true;
9033 
9034  // Enum constants within unnamed enumerations will have different types, but
9035  // may still be similar enough to be interchangeable for our purposes.
9036  if (auto *EA = dyn_cast<EnumConstantDecl>(VA)) {
9037  if (auto *EB = dyn_cast<EnumConstantDecl>(VB)) {
9038  // Only handle anonymous enums. If the enumerations were named and
9039  // equivalent, they would have been merged to the same type.
9040  auto *EnumA = cast<EnumDecl>(EA->getDeclContext());
9041  auto *EnumB = cast<EnumDecl>(EB->getDeclContext());
9042  if (EnumA->hasNameForLinkage() || EnumB->hasNameForLinkage() ||
9043  !Context.hasSameType(EnumA->getIntegerType(),
9044  EnumB->getIntegerType()))
9045  return false;
9046  // Allow this only if the value is the same for both enumerators.
9047  return llvm::APSInt::isSameValue(EA->getInitVal(), EB->getInitVal());
9048  }
9049  }
9050 
9051  // Nothing else is sufficiently similar.
9052  return false;
9053 }
9054 
9056  SourceLocation Loc, const NamedDecl *D, ArrayRef<const NamedDecl *> Equiv) {
9057  Diag(Loc, diag::ext_equivalent_internal_linkage_decl_in_modules) << D;
9058 
9059  Module *M = getOwningModule(const_cast<NamedDecl*>(D));
9060  Diag(D->getLocation(), diag::note_equivalent_internal_linkage_decl)
9061  << !M << (M ? M->getFullModuleName() : "");
9062 
9063  for (auto *E : Equiv) {
9064  Module *M = getOwningModule(const_cast<NamedDecl*>(E));
9065  Diag(E->getLocation(), diag::note_equivalent_internal_linkage_decl)
9066  << !M << (M ? M->getFullModuleName() : "");
9067  }
9068 }
9069 
9070 /// \brief Computes the best viable function (C++ 13.3.3)
9071 /// within an overload candidate set.
9072 ///
9073 /// \param Loc The location of the function name (or operator symbol) for
9074 /// which overload resolution occurs.
9075 ///
9076 /// \param Best If overload resolution was successful or found a deleted
9077 /// function, \p Best points to the candidate function found.
9078 ///
9079 /// \returns The result of overload resolution.
9082  iterator &Best,
9083  bool UserDefinedConversion) {
9085  std::transform(begin(), end(), std::back_inserter(Candidates),
9086  [](OverloadCandidate &Cand) { return &Cand; });
9087 
9088  // [CUDA] HD->H or HD->D calls are technically not allowed by CUDA but
9089  // are accepted by both clang and NVCC. However, during a particular
9090  // compilation mode only one call variant is viable. We need to
9091  // exclude non-viable overload candidates from consideration based
9092  // only on their host/device attributes. Specifically, if one
9093  // candidate call is WrongSide and the other is SameSide, we ignore
9094  // the WrongSide candidate.
9095  if (S.getLangOpts().CUDA) {
9096  const FunctionDecl *Caller = dyn_cast<FunctionDecl>(S.CurContext);
9097  bool ContainsSameSideCandidate =
9098  llvm::any_of(Candidates, [&](OverloadCandidate *Cand) {
9099  return Cand->Function &&
9100  S.IdentifyCUDAPreference(Caller, Cand->Function) ==
9102  });
9103  if (ContainsSameSideCandidate) {
9104  auto IsWrongSideCandidate = [&](OverloadCandidate *Cand) {
9105  return Cand->Function &&
9106  S.IdentifyCUDAPreference(Caller, Cand->Function) ==
9108  };
9109  llvm::erase_if(Candidates, IsWrongSideCandidate);
9110  }
9111  }
9112 
9113  // Find the best viable function.
9114  Best = end();
9115  for (auto *Cand : Candidates)
9116  if (Cand->Viable)
9117  if (Best == end() || isBetterOverloadCandidate(S, *Cand, *Best, Loc,
9118  UserDefinedConversion))
9119  Best = Cand;
9120 
9121  // If we didn't find any viable functions, abort.
9122  if (Best == end())
9123  return OR_No_Viable_Function;
9124 
9126 
9127  // Make sure that this function is better than every other viable
9128  // function. If not, we have an ambiguity.
9129  for (auto *Cand : Candidates) {
9130  if (Cand->Viable &&
9131  Cand != Best &&
9132  !isBetterOverloadCandidate(S, *Best, *Cand, Loc,
9133  UserDefinedConversion)) {
9134  if (S.isEquivalentInternalLinkageDeclaration(Best->Function,
9135  Cand->Function)) {
9136  EquivalentCands.push_back(Cand->Function);
9137  continue;
9138  }
9139 
9140  Best = end();
9141  return OR_Ambiguous;
9142  }
9143  }
9144 
9145  // Best is the best viable function.
9146  if (Best->Function &&
9147  (Best->Function->isDeleted() ||
9148  S.isFunctionConsideredUnavailable(Best->Function)))
9149  return OR_Deleted;
9150 
9151  if (!EquivalentCands.empty())
9152  S.diagnoseEquivalentInternalLinkageDeclarations(Loc, Best->Function,
9153  EquivalentCands);
9154 
9155  return OR_Success;
9156 }
9157 
9158 namespace {
9159 
9161  oc_function,
9162  oc_method,
9163  oc_constructor,
9164  oc_function_template,
9165  oc_method_template,
9166  oc_constructor_template,
9167  oc_implicit_default_constructor,
9168  oc_implicit_copy_constructor,
9169  oc_implicit_move_constructor,
9170  oc_implicit_copy_assignment,
9171  oc_implicit_move_assignment,
9172  oc_inherited_constructor,
9173  oc_inherited_constructor_template
9174 };
9175 
9176 static OverloadCandidateKind
9177 ClassifyOverloadCandidate(Sema &S, NamedDecl *Found, FunctionDecl *Fn,
9178  std::string &Description) {
9179  bool isTemplate = false;
9180 
9181  if (FunctionTemplateDecl *FunTmpl = Fn->getPrimaryTemplate()) {
9182  isTemplate = true;
9183  Description = S.getTemplateArgumentBindingsText(
9184  FunTmpl->getTemplateParameters(), *Fn->getTemplateSpecializationArgs());
9185  }
9186 
9187  if (CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(Fn)) {
9188  if (!Ctor->isImplicit()) {
9189  if (isa<ConstructorUsingShadowDecl>(Found))
9190  return isTemplate ? oc_inherited_constructor_template
9191  : oc_inherited_constructor;
9192  else
9193  return isTemplate ? oc_constructor_template : oc_constructor;
9194  }
9195 
9196  if (Ctor->isDefaultConstructor())
9197  return oc_implicit_default_constructor;
9198 
9199  if (Ctor->isMoveConstructor())
9200  return oc_implicit_move_constructor;
9201 
9202  assert(Ctor->isCopyConstructor() &&
9203  "unexpected sort of implicit constructor");
9204  return oc_implicit_copy_constructor;
9205  }
9206 
9207  if (CXXMethodDecl *Meth = dyn_cast<CXXMethodDecl>(Fn)) {
9208  // This actually gets spelled 'candidate function' for now, but
9209  // it doesn't hurt to split it out.
9210  if (!Meth->isImplicit())
9211  return isTemplate ? oc_method_template : oc_method;
9212 
9213  if (Meth->isMoveAssignmentOperator())
9214  return oc_implicit_move_assignment;
9215 
9216  if (Meth->isCopyAssignmentOperator())
9217  return oc_implicit_copy_assignment;
9218 
9219  assert(isa<CXXConversionDecl>(Meth) && "expected conversion");
9220  return oc_method;
9221  }
9222 
9223  return isTemplate ? oc_function_template : oc_function;
9224 }
9225 
9226 void MaybeEmitInheritedConstructorNote(Sema &S, Decl *FoundDecl) {
9227  // FIXME: It'd be nice to only emit a note once per using-decl per overload
9228  // set.
9229  if (auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(FoundDecl))
9230  S.Diag(FoundDecl->getLocation(),
9231  diag::note_ovl_candidate_inherited_constructor)
9232  << Shadow->getNominatedBaseClass();
9233 }
9234 
9235 } // end anonymous namespace
9236 
9237 static bool isFunctionAlwaysEnabled(const ASTContext &Ctx,
9238  const FunctionDecl *FD) {
9239  for (auto *EnableIf : FD->specific_attrs<EnableIfAttr>()) {
9240  bool AlwaysTrue;
9241  if (!EnableIf->getCond()->EvaluateAsBooleanCondition(AlwaysTrue, Ctx))
9242  return false;
9243  if (!AlwaysTrue)
9244  return false;
9245  }
9246  return true;
9247 }
9248 
9249 /// \brief Returns true if we can take the address of the function.
9250 ///
9251 /// \param Complain - If true, we'll emit a diagnostic
9252 /// \param InOverloadResolution - For the purposes of emitting a diagnostic, are
9253 /// we in overload resolution?
9254 /// \param Loc - The location of the statement we're complaining about. Ignored
9255 /// if we're not complaining, or if we're in overload resolution.
9257  bool Complain,
9258  bool InOverloadResolution,
9259  SourceLocation Loc) {
9260  if (!isFunctionAlwaysEnabled(S.Context, FD)) {
9261  if (Complain) {
9262  if (InOverloadResolution)
9263  S.Diag(FD->getLocStart(),
9264  diag::note_addrof_ovl_candidate_disabled_by_enable_if_attr);
9265  else
9266  S.Diag(Loc, diag::err_addrof_function_disabled_by_enable_if_attr) << FD;
9267  }
9268  return false;
9269  }
9270 
9271  auto I = llvm::find_if(FD->parameters(), [](const ParmVarDecl *P) {
9272  return P->hasAttr<PassObjectSizeAttr>();
9273  });
9274  if (I == FD->param_end())
9275  return true;
9276 
9277  if (Complain) {
9278  // Add one to ParamNo because it's user-facing
9279  unsigned ParamNo = std::distance(FD->param_begin(), I) + 1;
9280  if (InOverloadResolution)
9281  S.Diag(FD->getLocation(),
9282  diag::note_ovl_candidate_has_pass_object_size_params)
9283  << ParamNo;
9284  else
9285  S.Diag(Loc, diag::err_address_of_function_with_pass_object_size_params)
9286  << FD << ParamNo;
9287  }
9288  return false;
9289 }
9290 
9292  const FunctionDecl *FD) {
9293  return checkAddressOfFunctionIsAvailable(S, FD, /*Complain=*/true,
9294  /*InOverloadResolution=*/true,
9295  /*Loc=*/SourceLocation());
9296 }
9297 
9299  bool Complain,
9300  SourceLocation Loc) {
9301  return ::checkAddressOfFunctionIsAvailable(*this, Function, Complain,
9302  /*InOverloadResolution=*/false,
9303  Loc);
9304 }
9305 
9306 // Notes the location of an overload candidate.
9308  QualType DestType, bool TakingAddress) {
9309  if (TakingAddress && !checkAddressOfCandidateIsAvailable(*this, Fn))
9310  return;
9311 
9312  std::string FnDesc;
9313  OverloadCandidateKind K = ClassifyOverloadCandidate(*this, Found, Fn, FnDesc);
9314  PartialDiagnostic PD = PDiag(diag::note_ovl_candidate)
9315  << (unsigned) K << Fn << FnDesc;
9316 
9317  HandleFunctionTypeMismatch(PD, Fn->getType(), DestType);
9318  Diag(Fn->getLocation(), PD);
9319  MaybeEmitInheritedConstructorNote(*this, Found);
9320 }
9321 
9322 // Notes the location of all overload candidates designated through
9323 // OverloadedExpr
9324 void Sema::NoteAllOverloadCandidates(Expr *OverloadedExpr, QualType DestType,
9325  bool TakingAddress) {
9326  assert(OverloadedExpr->getType() == Context.OverloadTy);
9327 
9328  OverloadExpr::FindResult Ovl = OverloadExpr::find(OverloadedExpr);
9329  OverloadExpr *OvlExpr = Ovl.Expression;
9330 
9331  for (UnresolvedSetIterator I = OvlExpr->decls_begin(),
9332  IEnd = OvlExpr->decls_end();
9333  I != IEnd; ++I) {
9334  if (FunctionTemplateDecl *FunTmpl =
9335  dyn_cast<FunctionTemplateDecl>((*I)->getUnderlyingDecl()) ) {
9336  NoteOverloadCandidate(*I, FunTmpl->getTemplatedDecl(), DestType,
9337  TakingAddress);
9338  } else if (FunctionDecl *Fun
9339  = dyn_cast<FunctionDecl>((*I)->getUnderlyingDecl()) ) {
9340  NoteOverloadCandidate(*I, Fun, DestType, TakingAddress);
9341  }
9342  }
9343 }
9344 
9345 /// Diagnoses an ambiguous conversion. The partial diagnostic is the
9346 /// "lead" diagnostic; it will be given two arguments, the source and
9347 /// target types of the conversion.
9349  Sema &S,
9350  SourceLocation CaretLoc,
9351  const PartialDiagnostic &PDiag) const {
9352  S.Diag(CaretLoc, PDiag)
9354  // FIXME: The note limiting machinery is borrowed from
9355  // OverloadCandidateSet::NoteCandidates; there's an opportunity for
9356  // refactoring here.
9357  const OverloadsShown ShowOverloads = S.Diags.getShowOverloads();
9358  unsigned CandsShown = 0;
9360  for (I = Ambiguous.begin(), E = Ambiguous.end(); I != E; ++I) {
9361  if (CandsShown >= 4 && ShowOverloads == Ovl_Best)
9362  break;
9363  ++CandsShown;
9364  S.NoteOverloadCandidate(I->first, I->second);
9365  }
9366  if (I != E)
9367  S.Diag(SourceLocation(), diag::note_ovl_too_many_candidates) << int(E - I);
9368 }
9369 
9371  unsigned I, bool TakingCandidateAddress) {
9372  const ImplicitConversionSequence &Conv = Cand->Conversions[I];
9373  assert(Conv.isBad());
9374  assert(Cand->Function && "for now, candidate must be a function");
9375  FunctionDecl *Fn = Cand->Function;
9376 
9377  // There's a conversion slot for the object argument if this is a
9378  // non-constructor method. Note that 'I' corresponds the
9379  // conversion-slot index.
9380  bool isObjectArgument = false;
9381  if (isa<CXXMethodDecl>(Fn) && !isa<CXXConstructorDecl>(Fn)) {
9382  if (I == 0)
9383  isObjectArgument = true;
9384  else
9385  I--;
9386  }
9387 
9388  std::string FnDesc;
9389  OverloadCandidateKind FnKind =
9390  ClassifyOverloadCandidate(S, Cand->FoundDecl, Fn, FnDesc);
9391 
9392  Expr *FromExpr = Conv.Bad.FromExpr;
9393  QualType FromTy = Conv.Bad.getFromType();
9394  QualType ToTy = Conv.Bad.getToType();
9395 
9396  if (FromTy == S.Context.OverloadTy) {
9397  assert(FromExpr && "overload set argument came from implicit argument?");
9398  Expr *E = FromExpr->IgnoreParens();
9399  if (isa<UnaryOperator>(E))
9400  E = cast<UnaryOperator>(E)->getSubExpr()->IgnoreParens();
9401  DeclarationName Name = cast<OverloadExpr>(E)->getName();
9402 
9403  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_overload)
9404  << (unsigned) FnKind << FnDesc
9405  << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
9406  << ToTy << Name << I+1;
9407  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9408  return;
9409  }
9410 
9411  // Do some hand-waving analysis to see if the non-viability is due
9412  // to a qualifier mismatch.
9413  CanQualType CFromTy = S.Context.getCanonicalType(FromTy);
9414  CanQualType CToTy = S.Context.getCanonicalType(ToTy);
9415  if (CanQual<ReferenceType> RT = CToTy->getAs<ReferenceType>())
9416  CToTy = RT->getPointeeType();
9417  else {
9418  // TODO: detect and diagnose the full richness of const mismatches.
9419  if (CanQual<PointerType> FromPT = CFromTy->getAs<PointerType>())
9420  if (CanQual<PointerType> ToPT = CToTy->getAs<PointerType>()) {
9421  CFromTy = FromPT->getPointeeType();
9422  CToTy = ToPT->getPointeeType();
9423  }
9424  }
9425 
9426  if (CToTy.getUnqualifiedType() == CFromTy.getUnqualifiedType() &&
9427  !CToTy.isAtLeastAsQualifiedAs(CFromTy)) {
9428  Qualifiers FromQs = CFromTy.getQualifiers();
9429  Qualifiers ToQs = CToTy.getQualifiers();
9430 
9431  if (FromQs.getAddressSpace() != ToQs.getAddressSpace()) {
9432  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_addrspace)
9433  << (unsigned) FnKind << FnDesc
9434  << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
9435  << FromTy
9438  << (unsigned) isObjectArgument << I+1;
9439  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9440  return;
9441  }
9442 
9443  if (FromQs.getObjCLifetime() != ToQs.getObjCLifetime()) {
9444  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_ownership)
9445  << (unsigned) FnKind << FnDesc
9446  << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
9447  << FromTy
9448  << FromQs.getObjCLifetime() << ToQs.getObjCLifetime()
9449  << (unsigned) isObjectArgument << I+1;
9450  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9451  return;
9452  }
9453 
9454  if (FromQs.getObjCGCAttr() != ToQs.getObjCGCAttr()) {
9455  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_gc)
9456  << (unsigned) FnKind << FnDesc
9457  << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
9458  << FromTy
9459  << FromQs.getObjCGCAttr() << ToQs.getObjCGCAttr()
9460  << (unsigned) isObjectArgument << I+1;
9461  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9462  return;
9463  }
9464 
9465  if (FromQs.hasUnaligned() != ToQs.hasUnaligned()) {
9466  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_unaligned)
9467  << (unsigned) FnKind << FnDesc
9468  << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
9469  << FromTy << FromQs.hasUnaligned() << I+1;
9470  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9471  return;
9472  }
9473 
9474  unsigned CVR = FromQs.getCVRQualifiers() & ~ToQs.getCVRQualifiers();
9475  assert(CVR && "unexpected qualifiers mismatch");
9476 
9477  if (isObjectArgument) {
9478  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_cvr_this)
9479  << (unsigned) FnKind << FnDesc
9480  << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
9481  << FromTy << (CVR - 1);
9482  } else {
9483  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_cvr)
9484  << (unsigned) FnKind << FnDesc
9485  << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
9486  << FromTy << (CVR - 1) << I+1;
9487  }
9488  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9489  return;
9490  }
9491 
9492  // Special diagnostic for failure to convert an initializer list, since
9493  // telling the user that it has type void is not useful.
9494  if (FromExpr && isa<InitListExpr>(FromExpr)) {
9495  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_list_argument)
9496  << (unsigned) FnKind << FnDesc
9497  << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
9498  << FromTy << ToTy << (unsigned) isObjectArgument << I+1;
9499  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9500  return;
9501  }
9502 
9503  // Diagnose references or pointers to incomplete types differently,
9504  // since it's far from impossible that the incompleteness triggered
9505  // the failure.
9506  QualType TempFromTy = FromTy.getNonReferenceType();
9507  if (const PointerType *PTy = TempFromTy->getAs<PointerType>())
9508  TempFromTy = PTy->getPointeeType();
9509  if (TempFromTy->isIncompleteType()) {
9510  // Emit the generic diagnostic and, optionally, add the hints to it.
9511  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_conv_incomplete)
9512  << (unsigned) FnKind << FnDesc
9513  << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
9514  << FromTy << ToTy << (unsigned) isObjectArgument << I+1
9515  << (unsigned) (Cand->Fix.Kind);
9516 
9517  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9518  return;
9519  }
9520 
9521  // Diagnose base -> derived pointer conversions.
9522  unsigned BaseToDerivedConversion = 0;
9523  if (const PointerType *FromPtrTy = FromTy->getAs<PointerType>()) {
9524  if (const PointerType *ToPtrTy = ToTy->getAs<PointerType>()) {
9525  if (ToPtrTy->getPointeeType().isAtLeastAsQualifiedAs(
9526  FromPtrTy->getPointeeType()) &&
9527  !FromPtrTy->getPointeeType()->isIncompleteType() &&
9528  !ToPtrTy->getPointeeType()->isIncompleteType() &&
9529  S.IsDerivedFrom(SourceLocation(), ToPtrTy->getPointeeType(),
9530  FromPtrTy->getPointeeType()))
9531  BaseToDerivedConversion = 1;
9532  }
9533  } else if (const ObjCObjectPointerType *FromPtrTy
9534  = FromTy->getAs<ObjCObjectPointerType>()) {
9535  if (const ObjCObjectPointerType *ToPtrTy
9536  = ToTy->getAs<ObjCObjectPointerType>())
9537  if (const ObjCInterfaceDecl *FromIface = FromPtrTy->getInterfaceDecl())
9538  if (const ObjCInterfaceDecl *ToIface = ToPtrTy->getInterfaceDecl())
9539  if (ToPtrTy->getPointeeType().isAtLeastAsQualifiedAs(
9540  FromPtrTy->getPointeeType()) &&
9541  FromIface->isSuperClassOf(ToIface))
9542  BaseToDerivedConversion = 2;
9543  } else if (const ReferenceType *ToRefTy = ToTy->getAs<ReferenceType>()) {
9544  if (ToRefTy->getPointeeType().isAtLeastAsQualifiedAs(FromTy) &&
9545  !FromTy->isIncompleteType() &&
9546  !ToRefTy->getPointeeType()->isIncompleteType() &&
9547  S.IsDerivedFrom(SourceLocation(), ToRefTy->getPointeeType(), FromTy)) {
9548  BaseToDerivedConversion = 3;
9549  } else if (ToTy->isLValueReferenceType() && !FromExpr->isLValue() &&
9552  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_lvalue)
9553  << (unsigned) FnKind << FnDesc
9554  << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
9555  << (unsigned) isObjectArgument << I + 1;
9556  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9557  return;
9558  }
9559  }
9560 
9561  if (BaseToDerivedConversion) {
9562  S.Diag(Fn->getLocation(),
9563  diag::note_ovl_candidate_bad_base_to_derived_conv)
9564  << (unsigned) FnKind << FnDesc
9565  << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
9566  << (BaseToDerivedConversion - 1)
9567  << FromTy << ToTy << I+1;
9568  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9569  return;
9570  }
9571 
9572  if (isa<ObjCObjectPointerType>(CFromTy) &&
9573  isa<PointerType>(CToTy)) {
9574  Qualifiers FromQs = CFromTy.getQualifiers();
9575  Qualifiers ToQs = CToTy.getQualifiers();
9576  if (FromQs.getObjCLifetime() != ToQs.getObjCLifetime()) {
9577  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_arc_conv)
9578  << (unsigned) FnKind << FnDesc
9579  << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
9580  << FromTy << ToTy << (unsigned) isObjectArgument << I+1;
9581  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9582  return;
9583  }
9584  }
9585 
9586  if (TakingCandidateAddress &&
9588  return;
9589 
9590  // Emit the generic diagnostic and, optionally, add the hints to it.
9591  PartialDiagnostic FDiag = S.PDiag(diag::note_ovl_candidate_bad_conv);
9592  FDiag << (unsigned) FnKind << FnDesc
9593  << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
9594  << FromTy << ToTy << (unsigned) isObjectArgument << I + 1
9595  << (unsigned) (Cand->Fix.Kind);
9596 
9597  // If we can fix the conversion, suggest the FixIts.
9598  for (std::vector<FixItHint>::iterator HI = Cand->Fix.Hints.begin(),
9599  HE = Cand->Fix.Hints.end(); HI != HE; ++HI)
9600  FDiag << *HI;
9601  S.Diag(Fn->getLocation(), FDiag);
9602 
9603  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9604 }
9605 
9606 /// Additional arity mismatch diagnosis specific to a function overload
9607 /// candidates. This is not covered by the more general DiagnoseArityMismatch()
9608 /// over a candidate in any candidate set.
9610  unsigned NumArgs) {
9611  FunctionDecl *Fn = Cand->Function;
9612  unsigned MinParams = Fn->getMinRequiredArguments();
9613 
9614  // With invalid overloaded operators, it's possible that we think we
9615  // have an arity mismatch when in fact it looks like we have the
9616  // right number of arguments, because only overloaded operators have
9617  // the weird behavior of overloading member and non-member functions.
9618  // Just don't report anything.
9619  if (Fn->isInvalidDecl() &&
9621  return true;
9622 
9623  if (NumArgs < MinParams) {
9624  assert((Cand->FailureKind == ovl_fail_too_few_arguments) ||
9625  (Cand->FailureKind == ovl_fail_bad_deduction &&
9627  } else {
9628  assert((Cand->FailureKind == ovl_fail_too_many_arguments) ||
9629  (Cand->FailureKind == ovl_fail_bad_deduction &&
9631  }
9632 
9633  return false;
9634 }
9635 
9636 /// General arity mismatch diagnosis over a candidate in a candidate set.
9637 static void DiagnoseArityMismatch(Sema &S, NamedDecl *Found, Decl *D,
9638  unsigned NumFormalArgs) {
9639  assert(isa<FunctionDecl>(D) &&
9640  "The templated declaration should at least be a function"
9641  " when diagnosing bad template argument deduction due to too many"
9642  " or too few arguments");
9643 
9644  FunctionDecl *Fn = cast<FunctionDecl>(D);
9645 
9646  // TODO: treat calls to a missing default constructor as a special case
9647  const FunctionProtoType *FnTy = Fn->getType()->getAs<FunctionProtoType>();
9648  unsigned MinParams = Fn->getMinRequiredArguments();
9649 
9650  // at least / at most / exactly
9651  unsigned mode, modeCount;
9652  if (NumFormalArgs < MinParams) {
9653  if (MinParams != FnTy->getNumParams() || FnTy->isVariadic() ||
9654  FnTy->isTemplateVariadic())
9655  mode = 0; // "at least"
9656  else
9657  mode = 2; // "exactly"
9658  modeCount = MinParams;
9659  } else {
9660  if (MinParams != FnTy->getNumParams())
9661  mode = 1; // "at most"
9662  else
9663  mode = 2; // "exactly"
9664  modeCount = FnTy->getNumParams();
9665  }
9666 
9667  std::string Description;
9668  OverloadCandidateKind FnKind =
9669  ClassifyOverloadCandidate(S, Found, Fn, Description);
9670 
9671  if (modeCount == 1 && Fn->getParamDecl(0)->getDeclName())
9672  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_arity_one)
9673  << (unsigned) FnKind << (Fn->getDescribedFunctionTemplate() != nullptr)
9674  << mode << Fn->getParamDecl(0) << NumFormalArgs;
9675  else
9676  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_arity)
9677  << (unsigned) FnKind << (Fn->getDescribedFunctionTemplate() != nullptr)
9678  << mode << modeCount << NumFormalArgs;
9679  MaybeEmitInheritedConstructorNote(S, Found);
9680 }
9681 
9682 /// Arity mismatch diagnosis specific to a function overload candidate.
9684  unsigned NumFormalArgs) {
9685  if (!CheckArityMismatch(S, Cand, NumFormalArgs))
9686  DiagnoseArityMismatch(S, Cand->FoundDecl, Cand->Function, NumFormalArgs);
9687 }
9688 
9690  if (TemplateDecl *TD = Templated->getDescribedTemplate())
9691  return TD;
9692  llvm_unreachable("Unsupported: Getting the described template declaration"
9693  " for bad deduction diagnosis");
9694 }
9695 
9696 /// Diagnose a failed template-argument deduction.
9697 static void DiagnoseBadDeduction(Sema &S, NamedDecl *Found, Decl *Templated,
9698  DeductionFailureInfo &DeductionFailure,
9699  unsigned NumArgs,
9700  bool TakingCandidateAddress) {
9701  TemplateParameter Param = DeductionFailure.getTemplateParameter();
9702  NamedDecl *ParamD;
9703  (ParamD = Param.dyn_cast<TemplateTypeParmDecl*>()) ||
9704  (ParamD = Param.dyn_cast<NonTypeTemplateParmDecl*>()) ||
9705  (ParamD = Param.dyn_cast<TemplateTemplateParmDecl*>());
9706  switch (DeductionFailure.Result) {
9707  case Sema::TDK_Success:
9708  llvm_unreachable("TDK_success while diagnosing bad deduction");
9709 
9710  case Sema::TDK_Incomplete: {
9711  assert(ParamD && "no parameter found for incomplete deduction result");
9712  S.Diag(Templated->getLocation(),
9713  diag::note_ovl_candidate_incomplete_deduction)
9714  << ParamD->getDeclName();
9715  MaybeEmitInheritedConstructorNote(S, Found);
9716  return;
9717  }
9718 
9719  case Sema::TDK_Underqualified: {
9720  assert(ParamD && "no parameter found for bad qualifiers deduction result");
9721  TemplateTypeParmDecl *TParam = cast<TemplateTypeParmDecl>(ParamD);
9722 
9723  QualType Param = DeductionFailure.getFirstArg()->getAsType();
9724 
9725  // Param will have been canonicalized, but it should just be a
9726  // qualified version of ParamD, so move the qualifiers to that.
9727  QualifierCollector Qs;
9728  Qs.strip(Param);
9729  QualType NonCanonParam = Qs.apply(S.Context, TParam->getTypeForDecl());
9730  assert(S.Context.hasSameType(Param, NonCanonParam));
9731 
9732  // Arg has also been canonicalized, but there's nothing we can do
9733  // about that. It also doesn't matter as much, because it won't
9734  // have any template parameters in it (because deduction isn't
9735  // done on dependent types).
9736  QualType Arg = DeductionFailure.getSecondArg()->getAsType();
9737 
9738  S.Diag(Templated->getLocation(), diag::note_ovl_candidate_underqualified)
9739  << ParamD->getDeclName() << Arg << NonCanonParam;
9740  MaybeEmitInheritedConstructorNote(S, Found);
9741  return;
9742  }
9743 
9744  case Sema::TDK_Inconsistent: {
9745  assert(ParamD && "no parameter found for inconsistent deduction result");
9746  int which = 0;
9747  if (isa<TemplateTypeParmDecl>(ParamD))
9748  which = 0;
9749  else if (isa<NonTypeTemplateParmDecl>(ParamD)) {
9750  // Deduction might have failed because we deduced arguments of two
9751  // different types for a non-type template parameter.
9752  // FIXME: Use a different TDK value for this.
9753  QualType T1 =
9754  DeductionFailure.getFirstArg()->getNonTypeTemplateArgumentType();
9755  QualType T2 =
9756  DeductionFailure.getSecondArg()->getNonTypeTemplateArgumentType();
9757  if (!S.Context.hasSameType(T1, T2)) {
9758  S.Diag(Templated->getLocation(),
9759  diag::note_ovl_candidate_inconsistent_deduction_types)
9760  << ParamD->getDeclName() << *DeductionFailure.getFirstArg() << T1
9761  << *DeductionFailure.getSecondArg() << T2;
9762  MaybeEmitInheritedConstructorNote(S, Found);
9763  return;
9764  }
9765 
9766  which = 1;
9767  } else {
9768  which = 2;
9769  }
9770 
9771  S.Diag(Templated->getLocation(),
9772  diag::note_ovl_candidate_inconsistent_deduction)
9773  << which << ParamD->getDeclName() << *DeductionFailure.getFirstArg()
9774  << *DeductionFailure.getSecondArg();
9775  MaybeEmitInheritedConstructorNote(S, Found);
9776  return;
9777  }
9778 
9780  assert(ParamD && "no parameter found for invalid explicit arguments");
9781  if (ParamD->getDeclName())
9782  S.Diag(Templated->getLocation(),
9783  diag::note_ovl_candidate_explicit_arg_mismatch_named)
9784  << ParamD->getDeclName();
9785  else {
9786  int index = 0;
9787  if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ParamD))
9788  index = TTP->getIndex();
9789  else if (NonTypeTemplateParmDecl *NTTP
9790  = dyn_cast<NonTypeTemplateParmDecl>(ParamD))
9791  index = NTTP->getIndex();
9792  else
9793  index = cast<TemplateTemplateParmDecl>(ParamD)->getIndex();
9794  S.Diag(Templated->getLocation(),
9795  diag::note_ovl_candidate_explicit_arg_mismatch_unnamed)
9796  << (index + 1);
9797  }
9798  MaybeEmitInheritedConstructorNote(S, Found);
9799  return;
9800 
9803  DiagnoseArityMismatch(S, Found, Templated, NumArgs);
9804  return;
9805 
9807  S.Diag(Templated->getLocation(),
9808  diag::note_ovl_candidate_instantiation_depth);
9809  MaybeEmitInheritedConstructorNote(S, Found);
9810  return;
9811 
9813  // Format the template argument list into the argument string.
9814  SmallString<128> TemplateArgString;
9815  if (TemplateArgumentList *Args =
9816  DeductionFailure.getTemplateArgumentList()) {
9817  TemplateArgString = " ";
9818  TemplateArgString += S.getTemplateArgumentBindingsText(
9819  getDescribedTemplate(Templated)->getTemplateParameters(), *Args);
9820  }
9821 
9822  // If this candidate was disabled by enable_if, say so.
9823  PartialDiagnosticAt *PDiag = DeductionFailure.getSFINAEDiagnostic();
9824  if (PDiag && PDiag->second.getDiagID() ==
9825  diag::err_typename_nested_not_found_enable_if) {
9826  // FIXME: Use the source range of the condition, and the fully-qualified
9827  // name of the enable_if template. These are both present in PDiag.
9828  S.Diag(PDiag->first, diag::note_ovl_candidate_disabled_by_enable_if)
9829  << "'enable_if'" << TemplateArgString;
9830  return;
9831  }
9832 
9833  // We found a specific requirement that disabled the enable_if.
9834  if (PDiag && PDiag->second.getDiagID() ==
9835  diag::err_typename_nested_not_found_requirement) {
9836  S.Diag(Templated->getLocation(),
9837  diag::note_ovl_candidate_disabled_by_requirement)
9838  << PDiag->second.getStringArg(0) << TemplateArgString;
9839  return;
9840  }
9841 
9842  // Format the SFINAE diagnostic into the argument string.
9843  // FIXME: Add a general mechanism to include a PartialDiagnostic *'s
9844  // formatted message in another diagnostic.
9845  SmallString<128> SFINAEArgString;
9846  SourceRange R;
9847  if (PDiag) {
9848  SFINAEArgString = ": ";
9849  R = SourceRange(PDiag->first, PDiag->first);
9850  PDiag->second.EmitToString(S.getDiagnostics(), SFINAEArgString);
9851  }
9852 
9853  S.Diag(Templated->getLocation(),
9854  diag::note_ovl_candidate_substitution_failure)
9855  << TemplateArgString << SFINAEArgString << R;
9856  MaybeEmitInheritedConstructorNote(S, Found);
9857  return;
9858  }
9859 
9862  // Format the template argument list into the argument string.
9863  SmallString<128> TemplateArgString;
9864  if (TemplateArgumentList *Args =
9865  DeductionFailure.getTemplateArgumentList()) {
9866  TemplateArgString = " ";
9867  TemplateArgString += S.getTemplateArgumentBindingsText(
9868  getDescribedTemplate(Templated)->getTemplateParameters(), *Args);
9869  }
9870 
9871  S.Diag(Templated->getLocation(), diag::note_ovl_candidate_deduced_mismatch)
9872  << (*DeductionFailure.getCallArgIndex() + 1)
9873  << *DeductionFailure.getFirstArg() << *DeductionFailure.getSecondArg()
9874  << TemplateArgString
9875  << (DeductionFailure.Result == Sema::TDK_DeducedMismatchNested);
9876  break;
9877  }
9878 
9880  // FIXME: Provide a source location to indicate what we couldn't match.
9881  TemplateArgument FirstTA = *DeductionFailure.getFirstArg();
9882  TemplateArgument SecondTA = *DeductionFailure.getSecondArg();
9883  if (FirstTA.getKind() == TemplateArgument::Template &&
9884  SecondTA.getKind() == TemplateArgument::Template) {
9885  TemplateName FirstTN = FirstTA.getAsTemplate();
9886  TemplateName SecondTN = SecondTA.getAsTemplate();
9887  if (FirstTN.getKind() == TemplateName::Template &&
9888  SecondTN.getKind() == TemplateName::Template) {
9889  if (FirstTN.getAsTemplateDecl()->getName() ==
9890  SecondTN.getAsTemplateDecl()->getName()) {
9891  // FIXME: This fixes a bad diagnostic where both templates are named
9892  // the same. This particular case is a bit difficult since:
9893  // 1) It is passed as a string to the diagnostic printer.
9894  // 2) The diagnostic printer only attempts to find a better
9895  // name for types, not decls.
9896  // Ideally, this should folded into the diagnostic printer.
9897  S.Diag(Templated->getLocation(),
9898  diag::note_ovl_candidate_non_deduced_mismatch_qualified)
9899  << FirstTN.getAsTemplateDecl() << SecondTN.getAsTemplateDecl();
9900  return;
9901  }
9902  }
9903  }
9904 
9905  if (TakingCandidateAddress && isa<FunctionDecl>(Templated) &&
9906  !checkAddressOfCandidateIsAvailable(S, cast<FunctionDecl>(Templated)))
9907  return;
9908 
9909  // FIXME: For generic lambda parameters, check if the function is a lambda
9910  // call operator, and if so, emit a prettier and more informative
9911  // diagnostic that mentions 'auto' and lambda in addition to
9912  // (or instead of?) the canonical template type parameters.
9913  S.Diag(Templated->getLocation(),
9914  diag::note_ovl_candidate_non_deduced_mismatch)
9915  << FirstTA << SecondTA;
9916  return;
9917  }
9918  // TODO: diagnose these individually, then kill off
9919  // note_ovl_candidate_bad_deduction, which is uselessly vague.
9921  S.Diag(Templated->getLocation(), diag::note_ovl_candidate_bad_deduction);
9922  MaybeEmitInheritedConstructorNote(S, Found);
9923  return;
9925  S.Diag(Templated->getLocation(),
9926  diag::note_cuda_ovl_candidate_target_mismatch);
9927  return;
9928  }
9929 }
9930 
9931 /// Diagnose a failed template-argument deduction, for function calls.
9933  unsigned NumArgs,
9934  bool TakingCandidateAddress) {
9935  unsigned TDK = Cand->DeductionFailure.Result;
9937  if (CheckArityMismatch(S, Cand, NumArgs))
9938  return;
9939  }
9940  DiagnoseBadDeduction(S, Cand->FoundDecl, Cand->Function, // pattern
9941  Cand->DeductionFailure, NumArgs, TakingCandidateAddress);
9942 }
9943 
9944 /// CUDA: diagnose an invalid call across targets.
9945 static void DiagnoseBadTarget(Sema &S, OverloadCandidate *Cand) {
9946  FunctionDecl *Caller = cast<FunctionDecl>(S.CurContext);
9947  FunctionDecl *Callee = Cand->Function;
9948 
9949  Sema::CUDAFunctionTarget CallerTarget = S.IdentifyCUDATarget(Caller),
9950  CalleeTarget = S.IdentifyCUDATarget(Callee);
9951 
9952  std::string FnDesc;
9953  OverloadCandidateKind FnKind =
9954  ClassifyOverloadCandidate(S, Cand->FoundDecl, Callee, FnDesc);
9955 
9956  S.Diag(Callee->getLocation(), diag::note_ovl_candidate_bad_target)
9957  << (unsigned)FnKind << CalleeTarget << CallerTarget;
9958 
9959  // This could be an implicit constructor for which we could not infer the
9960  // target due to a collsion. Diagnose that case.
9961  CXXMethodDecl *Meth = dyn_cast<CXXMethodDecl>(Callee);
9962  if (Meth != nullptr && Meth->isImplicit()) {
9963  CXXRecordDecl *ParentClass = Meth->getParent();
9965 
9966  switch (FnKind) {
9967  default:
9968  return;
9969  case oc_implicit_default_constructor:
9971  break;
9972  case oc_implicit_copy_constructor:
9974  break;
9975  case oc_implicit_move_constructor:
9977  break;
9978  case oc_implicit_copy_assignment:
9980  break;
9981  case oc_implicit_move_assignment:
9983  break;
9984  };
9985 
9986  bool ConstRHS = false;
9987  if (Meth->getNumParams()) {
9988  if (const ReferenceType *RT =
9989  Meth->getParamDecl(0)->getType()->getAs<ReferenceType>()) {
9990  ConstRHS = RT->getPointeeType().isConstQualified();
9991  }
9992  }
9993 
9994  S.inferCUDATargetForImplicitSpecialMember(ParentClass, CSM, Meth,
9995  /* ConstRHS */ ConstRHS,
9996  /* Diagnose */ true);
9997  }
9998 }
9999 
10001  FunctionDecl *Callee = Cand->Function;
10002  EnableIfAttr *Attr = static_cast<EnableIfAttr*>(Cand->DeductionFailure.Data);
10003 
10004  S.Diag(Callee->getLocation(),
10005  diag::note_ovl_candidate_disabled_by_function_cond_attr)
10006  << Attr->getCond()->getSourceRange() << Attr->getMessage();
10007 }
10008 
10010  FunctionDecl *Callee = Cand->Function;
10011 
10012  S.Diag(Callee->getLocation(),
10013  diag::note_ovl_candidate_disabled_by_extension);
10014 }
10015 
10016 /// Generates a 'note' diagnostic for an overload candidate. We've
10017 /// already generated a primary error at the call site.
10018 ///
10019 /// It really does need to be a single diagnostic with its caret
10020 /// pointed at the candidate declaration. Yes, this creates some
10021 /// major challenges of technical writing. Yes, this makes pointing
10022 /// out problems with specific arguments quite awkward. It's still
10023 /// better than generating twenty screens of text for every failed
10024 /// overload.
10025 ///
10026 /// It would be great to be able to express per-candidate problems
10027 /// more richly for those diagnostic clients that cared, but we'd
10028 /// still have to be just as careful with the default diagnostics.
10030  unsigned NumArgs,
10031  bool TakingCandidateAddress) {
10032  FunctionDecl *Fn = Cand->Function;
10033 
10034  // Note deleted candidates, but only if they're viable.
10035  if (Cand->Viable) {
10036  if (Fn->isDeleted() || S.isFunctionConsideredUnavailable(Fn)) {
10037  std::string FnDesc;
10038  OverloadCandidateKind FnKind =
10039  ClassifyOverloadCandidate(S, Cand->FoundDecl, Fn, FnDesc);
10040 
10041  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_deleted)
10042  << FnKind << FnDesc
10043  << (Fn->isDeleted() ? (Fn->isDeletedAsWritten() ? 1 : 2) : 0);
10044  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
10045  return;
10046  }
10047 
10048  // We don't really have anything else to say about viable candidates.
10049  S.NoteOverloadCandidate(Cand->FoundDecl, Fn);
10050  return;
10051  }
10052 
10053  switch (Cand->FailureKind) {
10056  return DiagnoseArityMismatch(S, Cand, NumArgs);
10057 
10059  return DiagnoseBadDeduction(S, Cand, NumArgs,
10060  TakingCandidateAddress);
10061 
10063  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_illegal_constructor)
10064  << (Fn->getPrimaryTemplate() ? 1 : 0);
10065  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
10066  return;
10067  }
10068 
10072  return S.NoteOverloadCandidate(Cand->FoundDecl, Fn);
10073 
10074  case ovl_fail_bad_conversion: {
10075  unsigned I = (Cand->IgnoreObjectArgument ? 1 : 0);
10076  for (unsigned N = Cand->Conversions.size(); I != N; ++I)
10077  if (Cand->Conversions[I].isBad())
10078  return DiagnoseBadConversion(S, Cand, I, TakingCandidateAddress);
10079 
10080  // FIXME: this currently happens when we're called from SemaInit
10081  // when user-conversion overload fails. Figure out how to handle
10082  // those conditions and diagnose them well.
10083  return S.NoteOverloadCandidate(Cand->FoundDecl, Fn);
10084  }
10085 
10086  case ovl_fail_bad_target:
10087  return DiagnoseBadTarget(S, Cand);
10088 
10089  case ovl_fail_enable_if:
10090  return DiagnoseFailedEnableIfAttr(S, Cand);
10091 
10092  case ovl_fail_ext_disabled:
10093  return DiagnoseOpenCLExtensionDisabled(S, Cand);
10094 
10096  // It's generally not interesting to note copy/move constructors here.
10097  if (cast<CXXConstructorDecl>(Fn)->isCopyOrMoveConstructor())
10098  return;
10099  S.Diag(Fn->getLocation(),
10100  diag::note_ovl_candidate_inherited_constructor_slice)
10101  << (Fn->getPrimaryTemplate() ? 1 : 0)
10102  << Fn->getParamDecl(0)->getType()->isRValueReferenceType();
10103  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
10104  return;
10105 
10107  bool Available = checkAddressOfCandidateIsAvailable(S, Cand->Function);
10108  (void)Available;
10109  assert(!Available);
10110  break;
10111  }
10112  }
10113 }
10114 
10116  // Desugar the type of the surrogate down to a function type,
10117  // retaining as many typedefs as possible while still showing
10118  // the function type (and, therefore, its parameter types).
10119  QualType FnType = Cand->Surrogate->getConversionType();
10120  bool isLValueReference = false;
10121  bool isRValueReference = false;
10122  bool isPointer = false;
10123  if (const LValueReferenceType *FnTypeRef =
10124  FnType->getAs<LValueReferenceType>()) {
10125  FnType = FnTypeRef->getPointeeType();
10126  isLValueReference = true;
10127  } else if (const RValueReferenceType *FnTypeRef =
10128  FnType->getAs<RValueReferenceType>()) {
10129  FnType = FnTypeRef->getPointeeType();
10130  isRValueReference = true;
10131  }
10132  if (const PointerType *FnTypePtr = FnType->getAs<PointerType>()) {
10133  FnType = FnTypePtr->getPointeeType();
10134  isPointer = true;
10135  }
10136  // Desugar down to a function type.
10137  FnType = QualType(FnType->getAs<FunctionType>(), 0);
10138  // Reconstruct the pointer/reference as appropriate.
10139  if (isPointer) FnType = S.Context.getPointerType(FnType);
10140  if (isRValueReference) FnType = S.Context.getRValueReferenceType(FnType);
10141  if (isLValueReference) FnType = S.Context.getLValueReferenceType(FnType);
10142 
10143  S.Diag(Cand->Surrogate->getLocation(), diag::note_ovl_surrogate_cand)
10144  << FnType;
10145 }
10146 
10147 static void NoteBuiltinOperatorCandidate(Sema &S, StringRef Opc,
10148  SourceLocation OpLoc,
10149  OverloadCandidate *Cand) {
10150  assert(Cand->Conversions.size() <= 2 && "builtin operator is not binary");
10151  std::string TypeStr("operator");
10152  TypeStr += Opc;
10153  TypeStr += "(";
10154  TypeStr += Cand->BuiltinParamTypes[0].getAsString();
10155  if (Cand->Conversions.size() == 1) {
10156  TypeStr += ")";
10157  S.Diag(OpLoc, diag::note_ovl_builtin_unary_candidate) << TypeStr;
10158  } else {
10159  TypeStr += ", ";
10160  TypeStr += Cand->BuiltinParamTypes[1].getAsString();
10161  TypeStr += ")";
10162  S.Diag(OpLoc, diag::note_ovl_builtin_binary_candidate) << TypeStr;
10163  }
10164 }
10165 
10167  OverloadCandidate *Cand) {
10168  for (const ImplicitConversionSequence &ICS : Cand->Conversions) {
10169  if (ICS.isBad()) break; // all meaningless after first invalid
10170  if (!ICS.isAmbiguous()) continue;
10171 
10173  S, OpLoc, S.PDiag(diag::note_ambiguous_type_conversion));
10174  }
10175 }
10176 
10178  if (Cand->Function)
10179  return Cand->Function->getLocation();
10180  if (Cand->IsSurrogate)
10181  return Cand->Surrogate->getLocation();
10182  return SourceLocation();
10183 }
10184 
10185 static unsigned RankDeductionFailure(const DeductionFailureInfo &DFI) {
10186  switch ((Sema::TemplateDeductionResult)DFI.Result) {
10187  case Sema::TDK_Success:
10189  llvm_unreachable("non-deduction failure while diagnosing bad deduction");
10190 
10191  case Sema::TDK_Invalid:
10192  case Sema::TDK_Incomplete:
10193  return 1;
10194 
10197  return 2;
10198 
10205  return 3;
10206 
10208  return 4;
10209 
10211  return 5;
10212 
10215  return 6;
10216  }
10217  llvm_unreachable("Unhandled deduction result");
10218 }
10219 
10220 namespace {
10221 struct CompareOverloadCandidatesForDisplay {
10222  Sema &S;
10223  SourceLocation Loc;
10224  size_t NumArgs;
10225 
10226  CompareOverloadCandidatesForDisplay(Sema &S, SourceLocation Loc, size_t nArgs)
10227  : S(S), NumArgs(nArgs) {}
10228 
10229  bool operator()(const OverloadCandidate *L,
10230  const OverloadCandidate *R) {
10231  // Fast-path this check.
10232  if (L == R) return false;
10233 
10234  // Order first by viability.
10235  if (L->Viable) {
10236  if (!R->Viable) return true;
10237 
10238  // TODO: introduce a tri-valued comparison for overload
10239  // candidates. Would be more worthwhile if we had a sort
10240  // that could exploit it.
10241  if (isBetterOverloadCandidate(S, *L, *R, SourceLocation())) return true;
10242  if (isBetterOverloadCandidate(S, *R, *L, SourceLocation())) return false;
10243  } else if (R->Viable)
10244  return false;
10245 
10246  assert(L->Viable == R->Viable);
10247 
10248  // Criteria by which we can sort non-viable candidates:
10249  if (!L->Viable) {
10250  // 1. Arity mismatches come after other candidates.
10255  int LDist = std::abs((int)L->getNumParams() - (int)NumArgs);
10256  int RDist = std::abs((int)R->getNumParams() - (int)NumArgs);
10257  if (LDist == RDist) {
10258  if (L->FailureKind == R->FailureKind)
10259  // Sort non-surrogates before surrogates.
10260  return !L->IsSurrogate && R->IsSurrogate;
10261  // Sort candidates requiring fewer parameters than there were
10262  // arguments given after candidates requiring more parameters
10263  // than there were arguments given.
10265  }
10266  return LDist < RDist;
10267  }
10268  return false;
10269  }
10272  return true;
10273 
10274  // 2. Bad conversions come first and are ordered by the number
10275  // of bad conversions and quality of good conversions.
10278  return true;
10279 
10280  // The conversion that can be fixed with a smaller number of changes,
10281  // comes first.
10282  unsigned numLFixes = L->Fix.NumConversionsFixed;
10283  unsigned numRFixes = R->Fix.NumConversionsFixed;
10284  numLFixes = (numLFixes == 0) ? UINT_MAX : numLFixes;
10285  numRFixes = (numRFixes == 0) ? UINT_MAX : numRFixes;
10286  if (numLFixes != numRFixes) {
10287  return numLFixes < numRFixes;
10288  }
10289 
10290  // If there's any ordering between the defined conversions...
10291  // FIXME: this might not be transitive.
10292  assert(L->Conversions.size() == R->Conversions.size());
10293 
10294  int leftBetter = 0;
10295  unsigned I = (L->IgnoreObjectArgument || R->IgnoreObjectArgument);
10296  for (unsigned E = L->Conversions.size(); I != E; ++I) {
10297  switch (CompareImplicitConversionSequences(S, Loc,
10298  L->Conversions[I],
10299  R->Conversions[I])) {
10301  leftBetter++;
10302  break;
10303 
10305  leftBetter--;
10306  break;
10307 
10309  break;
10310  }
10311  }
10312  if (leftBetter > 0) return true;
10313  if (leftBetter < 0) return false;
10314 
10315  } else if (R->FailureKind == ovl_fail_bad_conversion)
10316  return false;
10317 
10318  if (L->FailureKind == ovl_fail_bad_deduction) {
10320  return true;
10321 
10325  } else if (R->FailureKind == ovl_fail_bad_deduction)
10326  return false;
10327 
10328  // TODO: others?
10329  }
10330 
10331  // Sort everything else by location.
10334 
10335  // Put candidates without locations (e.g. builtins) at the end.
10336  if (LLoc.isInvalid()) return false;
10337  if (RLoc.isInvalid()) return true;
10338 
10339  return S.SourceMgr.isBeforeInTranslationUnit(LLoc, RLoc);
10340  }
10341 };
10342 }
10343 
10344 /// CompleteNonViableCandidate - Normally, overload resolution only
10345 /// computes up to the first bad conversion. Produces the FixIt set if
10346 /// possible.
10348  ArrayRef<Expr *> Args) {
10349  assert(!Cand->Viable);
10350 
10351  // Don't do anything on failures other than bad conversion.
10352  if (Cand->FailureKind != ovl_fail_bad_conversion) return;
10353 
10354  // We only want the FixIts if all the arguments can be corrected.
10355  bool Unfixable = false;
10356  // Use a implicit copy initialization to check conversion fixes.
10358 
10359  // Attempt to fix the bad conversion.
10360  unsigned ConvCount = Cand->Conversions.size();
10361  for (unsigned ConvIdx = (Cand->IgnoreObjectArgument ? 1 : 0); /**/;
10362  ++ConvIdx) {
10363  assert(ConvIdx != ConvCount && "no bad conversion in candidate");
10364  if (Cand->Conversions[ConvIdx].isInitialized() &&
10365  Cand->Conversions[ConvIdx].isBad()) {
10366  Unfixable = !Cand->TryToFixBadConversion(ConvIdx, S);
10367  break;
10368  }
10369  }
10370 
10371  // FIXME: this should probably be preserved from the overload
10372  // operation somehow.
10373  bool SuppressUserConversions = false;
10374 
10375  unsigned ConvIdx = 0;
10376  ArrayRef<QualType> ParamTypes;
10377 
10378  if (Cand->IsSurrogate) {
10379  QualType ConvType
10381  if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>())
10382  ConvType = ConvPtrType->getPointeeType();
10383  ParamTypes = ConvType->getAs<FunctionProtoType>()->getParamTypes();
10384  // Conversion 0 is 'this', which doesn't have a corresponding argument.
10385  ConvIdx = 1;
10386  } else if (Cand->Function) {
10387  ParamTypes =
10388  Cand->Function->getType()->getAs<FunctionProtoType>()->getParamTypes();
10389  if (isa<CXXMethodDecl>(Cand->Function) &&
10390  !isa<CXXConstructorDecl>(Cand->Function)) {
10391  // Conversion 0 is 'this', which doesn't have a corresponding argument.
10392  ConvIdx = 1;
10393  }
10394  } else {
10395  // Builtin operator.
10396  assert(ConvCount <= 3);
10397  ParamTypes = Cand->BuiltinParamTypes;
10398  }
10399 
10400  // Fill in the rest of the conversions.
10401  for (unsigned ArgIdx = 0; ConvIdx != ConvCount; ++ConvIdx, ++ArgIdx) {
10402  if (Cand->Conversions[ConvIdx].isInitialized()) {
10403  // We've already checked this conversion.
10404  } else if (ArgIdx < ParamTypes.size()) {
10405  if (ParamTypes[ArgIdx]->isDependentType())
10406  Cand->Conversions[ConvIdx].setAsIdentityConversion(
10407  Args[ArgIdx]->getType());
10408  else {
10409  Cand->Conversions[ConvIdx] =
10410  TryCopyInitialization(S, Args[ArgIdx], ParamTypes[ArgIdx],
10411  SuppressUserConversions,
10412  /*InOverloadResolution=*/true,
10413  /*AllowObjCWritebackConversion=*/
10414  S.getLangOpts().ObjCAutoRefCount);
10415  // Store the FixIt in the candidate if it exists.
10416  if (!Unfixable && Cand->Conversions[ConvIdx].isBad())
10417  Unfixable = !Cand->TryToFixBadConversion(ConvIdx, S);
10418  }
10419  } else
10420  Cand->Conversions[ConvIdx].setEllipsis();
10421  }
10422 }
10423 
10424 /// PrintOverloadCandidates - When overload resolution fails, prints
10425 /// diagnostic messages containing the candidates in the candidate
10426 /// set.
10429  StringRef Opc, SourceLocation OpLoc,
10430  llvm::function_ref<bool(OverloadCandidate &)> Filter) {
10431  // Sort the candidates by viability and position. Sorting directly would
10432  // be prohibitive, so we make a set of pointers and sort those.
10434  if (OCD == OCD_AllCandidates) Cands.reserve(size());
10435  for (iterator Cand = begin(), LastCand = end(); Cand != LastCand; ++Cand) {
10436  if (!Filter(*Cand))
10437  continue;
10438  if (Cand->Viable)
10439  Cands.push_back(Cand);
10440  else if (OCD == OCD_AllCandidates) {
10441  CompleteNonViableCandidate(S, Cand, Args);
10442  if (Cand->Function || Cand->IsSurrogate)
10443  Cands.push_back(Cand);
10444  // Otherwise, this a non-viable builtin candidate. We do not, in general,
10445  // want to list every possible builtin candidate.
10446  }
10447  }
10448 
10449  std::sort(Cands.begin(), Cands.end(),
10450  CompareOverloadCandidatesForDisplay(S, OpLoc, Args.size()));
10451 
10452  bool ReportedAmbiguousConversions = false;
10453 
10455  const OverloadsShown ShowOverloads = S.Diags.getShowOverloads();
10456  unsigned CandsShown = 0;
10457  for (I = Cands.begin(), E = Cands.end(); I != E; ++I) {
10458  OverloadCandidate *Cand = *I;
10459 
10460  // Set an arbitrary limit on the number of candidate functions we'll spam
10461  // the user with. FIXME: This limit should depend on details of the
10462  // candidate list.
10463  if (CandsShown >= 4 && ShowOverloads == Ovl_Best) {
10464  break;
10465  }
10466  ++CandsShown;
10467 
10468  if (Cand->Function)
10469  NoteFunctionCandidate(S, Cand, Args.size(),
10470  /*TakingCandidateAddress=*/false);
10471  else if (Cand->IsSurrogate)
10472  NoteSurrogateCandidate(S, Cand);
10473  else {
10474  assert(Cand->Viable &&
10475  "Non-viable built-in candidates are not added to Cands.");
10476  // Generally we only see ambiguities including viable builtin
10477  // operators if overload resolution got screwed up by an
10478  // ambiguous user-defined conversion.
10479  //
10480  // FIXME: It's quite possible for different conversions to see
10481  // different ambiguities, though.
10482  if (!ReportedAmbiguousConversions) {
10483  NoteAmbiguousUserConversions(S, OpLoc, Cand);
10484  ReportedAmbiguousConversions = true;
10485  }
10486 
10487  // If this is a viable builtin, print it.
10488  NoteBuiltinOperatorCandidate(S, Opc, OpLoc, Cand);
10489  }
10490  }
10491 
10492  if (I != E)
10493  S.Diag(OpLoc, diag::note_ovl_too_many_candidates) << int(E - I);
10494 }
10495 
10496 static SourceLocation
10498  return Cand->Specialization ? Cand->Specialization->getLocation()
10499  : SourceLocation();
10500 }
10501 
10502 namespace {
10503 struct CompareTemplateSpecCandidatesForDisplay {
10504  Sema &S;
10505  CompareTemplateSpecCandidatesForDisplay(Sema &S) : S(S) {}
10506 
10507  bool operator()(const TemplateSpecCandidate *L,
10508  const TemplateSpecCandidate *R) {
10509  // Fast-path this check.
10510  if (L == R)
10511  return false;
10512 
10513  // Assuming that both candidates are not matches...
10514 
10515  // Sort by the ranking of deduction failures.
10519 
10520  // Sort everything else by location.
10523 
10524  // Put candidates without locations (e.g. builtins) at the end.
10525  if (LLoc.isInvalid())
10526  return false;
10527  if (RLoc.isInvalid())
10528  return true;
10529 
10530  return S.SourceMgr.isBeforeInTranslationUnit(LLoc, RLoc);
10531  }
10532 };
10533 }
10534 
10535 /// Diagnose a template argument deduction failure.
10536 /// We are treating these failures as overload failures due to bad
10537 /// deductions.
10539  bool ForTakingAddress) {
10540  DiagnoseBadDeduction(S, FoundDecl, Specialization, // pattern
10541  DeductionFailure, /*NumArgs=*/0, ForTakingAddress);
10542 }
10543 
10544 void TemplateSpecCandidateSet::destroyCandidates() {
10545  for (iterator i = begin(), e = end(); i != e; ++i) {
10546  i->DeductionFailure.Destroy();
10547  }
10548 }
10549 
10551  destroyCandidates();
10552  Candidates.clear();
10553 }
10554 
10555 /// NoteCandidates - When no template specialization match is found, prints
10556 /// diagnostic messages containing the non-matching specializations that form
10557 /// the candidate set.
10558 /// This is analoguous to OverloadCandidateSet::NoteCandidates() with
10559 /// OCD == OCD_AllCandidates and Cand->Viable == false.
10561  // Sort the candidates by position (assuming no candidate is a match).
10562  // Sorting directly would be prohibitive, so we make a set of pointers
10563  // and sort those.
10565  Cands.reserve(size());
10566  for (iterator Cand = begin(), LastCand = end(); Cand != LastCand; ++Cand) {
10567  if (Cand->Specialization)
10568  Cands.push_back(Cand);
10569  // Otherwise, this is a non-matching builtin candidate. We do not,
10570  // in general, want to list every possible builtin candidate.
10571  }
10572 
10573  std::sort(Cands.begin(), Cands.end(),
10574  CompareTemplateSpecCandidatesForDisplay(S));
10575 
10576  // FIXME: Perhaps rename OverloadsShown and getShowOverloads()
10577  // for generalization purposes (?).
10578  const OverloadsShown ShowOverloads = S.Diags.getShowOverloads();
10579 
10581  unsigned CandsShown = 0;
10582  for (I = Cands.begin(), E = Cands.end(); I != E; ++I) {
10583  TemplateSpecCandidate *Cand = *I;
10584 
10585  // Set an arbitrary limit on the number of candidates we'll spam
10586  // the user with. FIXME: This limit should depend on details of the
10587  // candidate list.
10588  if (CandsShown >= 4 && ShowOverloads == Ovl_Best)
10589  break;
10590  ++CandsShown;
10591 
10592  assert(Cand->Specialization &&
10593  "Non-matching built-in candidates are not added to Cands.");
10594  Cand->NoteDeductionFailure(S, ForTakingAddress);
10595  }
10596 
10597  if (I != E)
10598  S.Diag(Loc, diag::note_ovl_too_many_candidates) << int(E - I);
10599 }
10600 
10601 // [PossiblyAFunctionType] --> [Return]
10602 // NonFunctionType --> NonFunctionType
10603 // R (A) --> R(A)
10604 // R (*)(A) --> R (A)
10605 // R (&)(A) --> R (A)
10606 // R (S::*)(A) --> R (A)
10608  QualType Ret = PossiblyAFunctionType;
10609  if (const PointerType *ToTypePtr =
10610  PossiblyAFunctionType->getAs<PointerType>())
10611  Ret = ToTypePtr->getPointeeType();
10612  else if (const ReferenceType *ToTypeRef =
10613  PossiblyAFunctionType->getAs<ReferenceType>())
10614  Ret = ToTypeRef->getPointeeType();
10615  else if (const MemberPointerType *MemTypePtr =
10616  PossiblyAFunctionType->getAs<MemberPointerType>())
10617  Ret = MemTypePtr->getPointeeType();
10618  Ret =
10620  return Ret;
10621 }
10622 
10624  bool Complain = true) {
10625  if (S.getLangOpts().CPlusPlus14 && FD->getReturnType()->isUndeducedType() &&
10626  S.DeduceReturnType(FD, Loc, Complain))
10627  return true;
10628 
10629  auto *FPT = FD->getType()->castAs<FunctionProtoType>();
10630  if (S.getLangOpts().CPlusPlus1z &&
10631  isUnresolvedExceptionSpec(FPT->getExceptionSpecType()) &&
10632  !S.ResolveExceptionSpec(Loc, FPT))
10633  return true;
10634 
10635  return false;
10636 }
10637 
10638 namespace {
10639 // A helper class to help with address of function resolution
10640 // - allows us to avoid passing around all those ugly parameters
10641 class AddressOfFunctionResolver {
10642  Sema& S;
10643  Expr* SourceExpr;
10644  const QualType& TargetType;
10645  QualType TargetFunctionType; // Extracted function type from target type
10646 
10647  bool Complain;
10648  //DeclAccessPair& ResultFunctionAccessPair;
10650 
10651  bool TargetTypeIsNonStaticMemberFunction;
10652  bool FoundNonTemplateFunction;
10653  bool StaticMemberFunctionFromBoundPointer;
10654  bool HasComplained;
10655 
10656  OverloadExpr::FindResult OvlExprInfo;
10657  OverloadExpr *OvlExpr;
10658  TemplateArgumentListInfo OvlExplicitTemplateArgs;
10660  TemplateSpecCandidateSet FailedCandidates;
10661 
10662 public:
10663  AddressOfFunctionResolver(Sema &S, Expr *SourceExpr,
10664  const QualType &TargetType, bool Complain)
10665  : S(S), SourceExpr(SourceExpr), TargetType(TargetType),
10666  Complain(Complain), Context(S.getASTContext()),
10667  TargetTypeIsNonStaticMemberFunction(
10668  !!TargetType->getAs<MemberPointerType>()),
10669  FoundNonTemplateFunction(false),
10670  StaticMemberFunctionFromBoundPointer(false),
10671  HasComplained(false),
10672  OvlExprInfo(OverloadExpr::find(SourceExpr)),
10673  OvlExpr(OvlExprInfo.Expression),
10674  FailedCandidates(OvlExpr->getNameLoc(), /*ForTakingAddress=*/true) {
10675  ExtractUnqualifiedFunctionTypeFromTargetType();
10676 
10677  if (TargetFunctionType->isFunctionType()) {
10678  if (UnresolvedMemberExpr *UME = dyn_cast<UnresolvedMemberExpr>(OvlExpr))
10679  if (!UME->isImplicitAccess() &&
10681  StaticMemberFunctionFromBoundPointer = true;
10682  } else if (OvlExpr->hasExplicitTemplateArgs()) {
10683  DeclAccessPair dap;
10685  OvlExpr, false, &dap)) {
10686  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn))
10687  if (!Method->isStatic()) {
10688  // If the target type is a non-function type and the function found
10689  // is a non-static member function, pretend as if that was the
10690  // target, it's the only possible type to end up with.
10691  TargetTypeIsNonStaticMemberFunction = true;
10692 
10693  // And skip adding the function if its not in the proper form.
10694  // We'll diagnose this due to an empty set of functions.
10695  if (!OvlExprInfo.HasFormOfMemberPointer)
10696  return;
10697  }
10698 
10699  Matches.push_back(std::make_pair(dap, Fn));
10700  }
10701  return;
10702  }
10703 
10704  if (OvlExpr->hasExplicitTemplateArgs())
10705  OvlExpr->copyTemplateArgumentsInto(OvlExplicitTemplateArgs);
10706 
10707  if (FindAllFunctionsThatMatchTargetTypeExactly()) {
10708  // C++ [over.over]p4:
10709  // If more than one function is selected, [...]
10710  if (Matches.size() > 1 && !eliminiateSuboptimalOverloadCandidates()) {
10711  if (FoundNonTemplateFunction)
10712  EliminateAllTemplateMatches();
10713  else
10714  EliminateAllExceptMostSpecializedTemplate();
10715  }
10716  }
10717 
10718  if (S.getLangOpts().CUDA && Matches.size() > 1)
10719  EliminateSuboptimalCudaMatches();
10720  }
10721 
10722  bool hasComplained() const { return HasComplained; }
10723 
10724 private:
10725  bool candidateHasExactlyCorrectType(const FunctionDecl *FD) {
10726  QualType Discard;
10727  return Context.hasSameUnqualifiedType(TargetFunctionType, FD->getType()) ||
10728  S.IsFunctionConversion(FD->getType(), TargetFunctionType, Discard);
10729  }
10730 
10731  /// \return true if A is considered a better overload candidate for the
10732  /// desired type than B.
10733  bool isBetterCandidate(const FunctionDecl *A, const FunctionDecl *B) {
10734  // If A doesn't have exactly the correct type, we don't want to classify it
10735  // as "better" than anything else. This way, the user is required to
10736  // disambiguate for us if there are multiple candidates and no exact match.
10737  return candidateHasExactlyCorrectType(A) &&
10738  (!candidateHasExactlyCorrectType(B) ||
10739  compareEnableIfAttrs(S, A, B) == Comparison::Better);
10740  }
10741 
10742  /// \return true if we were able to eliminate all but one overload candidate,
10743  /// false otherwise.
10744  bool eliminiateSuboptimalOverloadCandidates() {
10745  // Same algorithm as overload resolution -- one pass to pick the "best",
10746  // another pass to be sure that nothing is better than the best.
10747  auto Best = Matches.begin();
10748  for (auto I = Matches.begin()+1, E = Matches.end(); I != E; ++I)
10749  if (isBetterCandidate(I->second, Best->second))
10750  Best = I;
10751 
10752  const FunctionDecl *BestFn = Best->second;
10753  auto IsBestOrInferiorToBest = [this, BestFn](
10754  const std::pair<DeclAccessPair, FunctionDecl *> &Pair) {
10755  return BestFn == Pair.second || isBetterCandidate(BestFn, Pair.second);
10756  };
10757 
10758  // Note: We explicitly leave Matches unmodified if there isn't a clear best
10759  // option, so we can potentially give the user a better error
10760  if (!std::all_of(Matches.begin(), Matches.end(), IsBestOrInferiorToBest))
10761  return false;
10762  Matches[0] = *Best;
10763  Matches.resize(1);
10764  return true;
10765  }
10766 
10767  bool isTargetTypeAFunction() const {
10768  return TargetFunctionType->isFunctionType();
10769  }
10770 
10771  // [ToType] [Return]
10772 
10773  // R (*)(A) --> R (A), IsNonStaticMemberFunction = false
10774  // R (&)(A) --> R (A), IsNonStaticMemberFunction = false
10775  // R (S::*)(A) --> R (A), IsNonStaticMemberFunction = true
10776  void inline ExtractUnqualifiedFunctionTypeFromTargetType() {
10777  TargetFunctionType = S.ExtractUnqualifiedFunctionType(TargetType);
10778  }
10779 
10780  // return true if any matching specializations were found
10781  bool AddMatchingTemplateFunction(FunctionTemplateDecl* FunctionTemplate,
10782  const DeclAccessPair& CurAccessFunPair) {
10783  if (CXXMethodDecl *Method
10784  = dyn_cast<CXXMethodDecl>(FunctionTemplate->getTemplatedDecl())) {
10785  // Skip non-static function templates when converting to pointer, and
10786  // static when converting to member pointer.
10787  if (Method->isStatic() == TargetTypeIsNonStaticMemberFunction)
10788  return false;
10789  }
10790  else if (TargetTypeIsNonStaticMemberFunction)
10791  return false;
10792 
10793  // C++ [over.over]p2:
10794  // If the name is a function template, template argument deduction is
10795  // done (14.8.2.2), and if the argument deduction succeeds, the
10796  // resulting template argument list is used to generate a single
10797  // function template specialization, which is added to the set of
10798  // overloaded functions considered.
10799  FunctionDecl *Specialization = nullptr;
10800  TemplateDeductionInfo Info(FailedCandidates.getLocation());
10802  = S.DeduceTemplateArguments(FunctionTemplate,
10803  &OvlExplicitTemplateArgs,
10804  TargetFunctionType, Specialization,
10805  Info, /*IsAddressOfFunction*/true)) {
10806  // Make a note of the failed deduction for diagnostics.
10807  FailedCandidates.addCandidate()
10808  .set(CurAccessFunPair, FunctionTemplate->getTemplatedDecl(),
10810  return false;
10811  }
10812 
10813  // Template argument deduction ensures that we have an exact match or
10814  // compatible pointer-to-function arguments that would be adjusted by ICS.
10815  // This function template specicalization works.
10817  Context.getCanonicalType(Specialization->getType()),
10818  Context.getCanonicalType(TargetFunctionType)));
10819 
10820  if (!S.checkAddressOfFunctionIsAvailable(Specialization))
10821  return false;
10822 
10823  Matches.push_back(std::make_pair(CurAccessFunPair, Specialization));
10824  return true;
10825  }
10826 
10827  bool AddMatchingNonTemplateFunction(NamedDecl* Fn,
10828  const DeclAccessPair& CurAccessFunPair) {
10829  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) {
10830  // Skip non-static functions when converting to pointer, and static
10831  // when converting to member pointer.
10832  if (Method->isStatic() == TargetTypeIsNonStaticMemberFunction)
10833  return false;
10834  }
10835  else if (TargetTypeIsNonStaticMemberFunction)
10836  return false;
10837 
10838  if (FunctionDecl *FunDecl = dyn_cast<FunctionDecl>(Fn)) {
10839  if (S.getLangOpts().CUDA)
10840  if (FunctionDecl *Caller = dyn_cast<FunctionDecl>(S.CurContext))
10841  if (!Caller->isImplicit() && !S.IsAllowedCUDACall(Caller, FunDecl))
10842  return false;
10843 
10844  // If any candidate has a placeholder return type, trigger its deduction
10845  // now.
10846  if (completeFunctionType(S, FunDecl, SourceExpr->getLocStart(),
10847  Complain)) {
10848  HasComplained |= Complain;
10849  return false;
10850  }
10851 
10852  if (!S.checkAddressOfFunctionIsAvailable(FunDecl))
10853  return false;
10854 
10855  // If we're in C, we need to support types that aren't exactly identical.
10856  if (!S.getLangOpts().CPlusPlus ||
10857  candidateHasExactlyCorrectType(FunDecl)) {
10858  Matches.push_back(std::make_pair(
10859  CurAccessFunPair, cast<FunctionDecl>(FunDecl->getCanonicalDecl())));
10860  FoundNonTemplateFunction = true;
10861  return true;
10862  }
10863  }
10864 
10865  return false;
10866  }
10867 
10868  bool FindAllFunctionsThatMatchTargetTypeExactly() {
10869  bool Ret = false;
10870 
10871  // If the overload expression doesn't have the form of a pointer to
10872  // member, don't try to convert it to a pointer-to-member type.
10873  if (IsInvalidFormOfPointerToMemberFunction())
10874  return false;
10875 
10876  for (UnresolvedSetIterator I = OvlExpr->decls_begin(),
10877  E = OvlExpr->decls_end();
10878  I != E; ++I) {
10879  // Look through any using declarations to find the underlying function.
10880  NamedDecl *Fn = (*I)->getUnderlyingDecl();
10881 
10882  // C++ [over.over]p3:
10883  // Non-member functions and static member functions match
10884  // targets of type "pointer-to-function" or "reference-to-function."
10885  // Nonstatic member functions match targets of
10886  // type "pointer-to-member-function."
10887  // Note that according to DR 247, the containing class does not matter.
10888  if (FunctionTemplateDecl *FunctionTemplate
10889  = dyn_cast<FunctionTemplateDecl>(Fn)) {
10890  if (AddMatchingTemplateFunction(FunctionTemplate, I.getPair()))
10891  Ret = true;
10892  }
10893  // If we have explicit template arguments supplied, skip non-templates.
10894  else if (!OvlExpr->hasExplicitTemplateArgs() &&
10895  AddMatchingNonTemplateFunction(Fn, I.getPair()))
10896  Ret = true;
10897  }
10898  assert(Ret || Matches.empty());
10899  return Ret;
10900  }
10901 
10902  void EliminateAllExceptMostSpecializedTemplate() {
10903  // [...] and any given function template specialization F1 is
10904  // eliminated if the set contains a second function template
10905  // specialization whose function template is more specialized
10906  // than the function template of F1 according to the partial
10907  // ordering rules of 14.5.5.2.
10908 
10909  // The algorithm specified above is quadratic. We instead use a
10910  // two-pass algorithm (similar to the one used to identify the
10911  // best viable function in an overload set) that identifies the
10912  // best function template (if it exists).
10913 
10914  UnresolvedSet<4> MatchesCopy; // TODO: avoid!
10915  for (unsigned I = 0, E = Matches.size(); I != E; ++I)
10916  MatchesCopy.addDecl(Matches[I].second, Matches[I].first.getAccess());
10917 
10918  // TODO: It looks like FailedCandidates does not serve much purpose
10919  // here, since the no_viable diagnostic has index 0.
10921  MatchesCopy.begin(), MatchesCopy.end(), FailedCandidates,
10922  SourceExpr->getLocStart(), S.PDiag(),
10923  S.PDiag(diag::err_addr_ovl_ambiguous)
10924  << Matches[0].second->getDeclName(),
10925  S.PDiag(diag::note_ovl_candidate)
10926  << (unsigned)oc_function_template,
10927  Complain, TargetFunctionType);
10928 
10929  if (Result != MatchesCopy.end()) {
10930  // Make it the first and only element
10931  Matches[0].first = Matches[Result - MatchesCopy.begin()].first;
10932  Matches[0].second = cast<FunctionDecl>(*Result);
10933  Matches.resize(1);
10934  } else
10935  HasComplained |= Complain;
10936  }
10937 
10938  void EliminateAllTemplateMatches() {
10939  // [...] any function template specializations in the set are
10940  // eliminated if the set also contains a non-template function, [...]
10941  for (unsigned I = 0, N = Matches.size(); I != N; ) {
10942  if (Matches[I].second->getPrimaryTemplate() == nullptr)
10943  ++I;
10944  else {
10945  Matches[I] = Matches[--N];
10946  Matches.resize(N);
10947  }
10948  }
10949  }
10950 
10951  void EliminateSuboptimalCudaMatches() {
10952  S.EraseUnwantedCUDAMatches(dyn_cast<FunctionDecl>(S.CurContext), Matches);
10953  }
10954 
10955 public:
10956  void ComplainNoMatchesFound() const {
10957  assert(Matches.empty());
10958  S.Diag(OvlExpr->getLocStart(), diag::err_addr_ovl_no_viable)
10959  << OvlExpr->getName() << TargetFunctionType
10960  << OvlExpr->getSourceRange();
10961  if (FailedCandidates.empty())
10962  S.NoteAllOverloadCandidates(OvlExpr, TargetFunctionType,
10963  /*TakingAddress=*/true);
10964  else {
10965  // We have some deduction failure messages. Use them to diagnose
10966  // the function templates, and diagnose the non-template candidates
10967  // normally.
10968  for (UnresolvedSetIterator I = OvlExpr->decls_begin(),
10969  IEnd = OvlExpr->decls_end();
10970  I != IEnd; ++I)
10971  if (FunctionDecl *Fun =
10972  dyn_cast<FunctionDecl>((*I)->getUnderlyingDecl()))
10974  S.NoteOverloadCandidate(*I, Fun, TargetFunctionType,
10975  /*TakingAddress=*/true);
10976  FailedCandidates.NoteCandidates(S, OvlExpr->getLocStart());
10977  }
10978  }
10979 
10980  bool IsInvalidFormOfPointerToMemberFunction() const {
10981  return TargetTypeIsNonStaticMemberFunction &&
10982  !OvlExprInfo.HasFormOfMemberPointer;
10983  }
10984 
10985  void ComplainIsInvalidFormOfPointerToMemberFunction() const {
10986  // TODO: Should we condition this on whether any functions might
10987  // have matched, or is it more appropriate to do that in callers?
10988  // TODO: a fixit wouldn't hurt.
10989  S.Diag(OvlExpr->getNameLoc(), diag::err_addr_ovl_no_qualifier)
10990  << TargetType << OvlExpr->getSourceRange();
10991  }
10992 
10993  bool IsStaticMemberFunctionFromBoundPointer() const {
10994  return StaticMemberFunctionFromBoundPointer;
10995  }
10996 
10997  void ComplainIsStaticMemberFunctionFromBoundPointer() const {
10998  S.Diag(OvlExpr->getLocStart(),
10999  diag::err_invalid_form_pointer_member_function)
11000  << OvlExpr->getSourceRange();
11001  }
11002 
11003  void ComplainOfInvalidConversion() const {
11004  S.Diag(OvlExpr->getLocStart(), diag::err_addr_ovl_not_func_ptrref)
11005  << OvlExpr->getName() << TargetType;
11006  }
11007 
11008  void ComplainMultipleMatchesFound() const {
11009  assert(Matches.size() > 1);
11010  S.Diag(OvlExpr->getLocStart(), diag::err_addr_ovl_ambiguous)
11011  << OvlExpr->getName()
11012  << OvlExpr->getSourceRange();
11013  S.NoteAllOverloadCandidates(OvlExpr, TargetFunctionType,
11014  /*TakingAddress=*/true);
11015  }
11016 
11017  bool hadMultipleCandidates() const { return (OvlExpr->getNumDecls() > 1); }
11018 
11019  int getNumMatches() const { return Matches.size(); }
11020 
11021  FunctionDecl* getMatchingFunctionDecl() const {
11022  if (Matches.size() != 1) return nullptr;
11023  return Matches[0].second;
11024  }
11025 
11026  const DeclAccessPair* getMatchingFunctionAccessPair() const {
11027  if (Matches.size() != 1) return nullptr;
11028  return &Matches[0].first;
11029  }
11030 };
11031 }
11032 
11033 /// ResolveAddressOfOverloadedFunction - Try to resolve the address of
11034 /// an overloaded function (C++ [over.over]), where @p From is an
11035 /// expression with overloaded function type and @p ToType is the type
11036 /// we're trying to resolve to. For example:
11037 ///
11038 /// @code
11039 /// int f(double);
11040 /// int f(int);
11041 ///
11042 /// int (*pfd)(double) = f; // selects f(double)
11043 /// @endcode
11044 ///
11045 /// This routine returns the resulting FunctionDecl if it could be
11046 /// resolved, and NULL otherwise. When @p Complain is true, this
11047 /// routine will emit diagnostics if there is an error.
11048 FunctionDecl *
11050  QualType TargetType,
11051  bool Complain,
11052  DeclAccessPair &FoundResult,
11053  bool *pHadMultipleCandidates) {
11054  assert(AddressOfExpr->getType() == Context.OverloadTy);
11055 
11056  AddressOfFunctionResolver Resolver(*this, AddressOfExpr, TargetType,
11057  Complain);
11058  int NumMatches = Resolver.getNumMatches();
11059  FunctionDecl *Fn = nullptr;
11060  bool ShouldComplain = Complain && !Resolver.hasComplained();
11061  if (NumMatches == 0 && ShouldComplain) {
11062  if (Resolver.IsInvalidFormOfPointerToMemberFunction())
11063  Resolver.ComplainIsInvalidFormOfPointerToMemberFunction();
11064  else
11065  Resolver.ComplainNoMatchesFound();
11066  }
11067  else if (NumMatches > 1 && ShouldComplain)
11068  Resolver.ComplainMultipleMatchesFound();
11069  else if (NumMatches == 1) {
11070  Fn = Resolver.getMatchingFunctionDecl();
11071  assert(Fn);
11072  if (auto *FPT = Fn->getType()->getAs<FunctionProtoType>())
11073  ResolveExceptionSpec(AddressOfExpr->getExprLoc(), FPT);
11074  FoundResult = *Resolver.getMatchingFunctionAccessPair();
11075  if (Complain) {
11076  if (Resolver.IsStaticMemberFunctionFromBoundPointer())
11077  Resolver.ComplainIsStaticMemberFunctionFromBoundPointer();
11078  else
11079  CheckAddressOfMemberAccess(AddressOfExpr, FoundResult);
11080  }
11081  }
11082 
11083  if (pHadMultipleCandidates)
11084  *pHadMultipleCandidates = Resolver.hadMultipleCandidates();
11085  return Fn;
11086 }
11087 
11088 /// \brief Given an expression that refers to an overloaded function, try to
11089 /// resolve that function to a single function that can have its address taken.
11090 /// This will modify `Pair` iff it returns non-null.
11091 ///
11092 /// This routine can only realistically succeed if all but one candidates in the
11093 /// overload set for SrcExpr cannot have their addresses taken.
11094 FunctionDecl *
11096  DeclAccessPair &Pair) {
11098  OverloadExpr *Ovl = R.Expression;
11099  FunctionDecl *Result = nullptr;
11100  DeclAccessPair DAP;
11101  // Don't use the AddressOfResolver because we're specifically looking for
11102  // cases where we have one overload candidate that lacks
11103  // enable_if/pass_object_size/...
11104  for (auto I = Ovl->decls_begin(), E = Ovl->decls_end(); I != E; ++I) {
11105  auto *FD = dyn_cast<FunctionDecl>(I->getUnderlyingDecl());
11106  if (!FD)
11107  return nullptr;
11108 
11110  continue;
11111 
11112  // We have more than one result; quit.
11113  if (Result)
11114  return nullptr;
11115  DAP = I.getPair();
11116  Result = FD;
11117  }
11118 
11119  if (Result)
11120  Pair = DAP;
11121  return Result;
11122 }
11123 
11124 /// \brief Given an overloaded function, tries to turn it into a non-overloaded
11125 /// function reference using resolveAddressOfOnlyViableOverloadCandidate. This
11126 /// will perform access checks, diagnose the use of the resultant decl, and, if
11127 /// requested, potentially perform a function-to-pointer decay.
11128 ///
11129 /// Returns false if resolveAddressOfOnlyViableOverloadCandidate fails.
11130 /// Otherwise, returns true. This may emit diagnostics and return true.
11132  ExprResult &SrcExpr, bool DoFunctionPointerConverion) {
11133  Expr *E = SrcExpr.get();
11134  assert(E->getType() == Context.OverloadTy && "SrcExpr must be an overload");
11135 
11136  DeclAccessPair DAP;
11138  if (!Found)
11139  return false;
11140 
11141  // Emitting multiple diagnostics for a function that is both inaccessible and
11142  // unavailable is consistent with our behavior elsewhere. So, always check
11143  // for both.
11144  DiagnoseUseOfDecl(Found, E->getExprLoc());
11146  Expr *Fixed = FixOverloadedFunctionReference(E, DAP, Found);
11147  if (DoFunctionPointerConverion && Fixed->getType()->isFunctionType())
11148  SrcExpr = DefaultFunctionArrayConversion(Fixed, /*Diagnose=*/false);
11149  else
11150  SrcExpr = Fixed;
11151  return true;
11152 }
11153 
11154 /// \brief Given an expression that refers to an overloaded function, try to
11155 /// resolve that overloaded function expression down to a single function.
11156 ///
11157 /// This routine can only resolve template-ids that refer to a single function
11158 /// template, where that template-id refers to a single template whose template
11159 /// arguments are either provided by the template-id or have defaults,
11160 /// as described in C++0x [temp.arg.explicit]p3.
11161 ///
11162 /// If no template-ids are found, no diagnostics are emitted and NULL is
11163 /// returned.
11164 FunctionDecl *
11166  bool Complain,
11167  DeclAccessPair *FoundResult) {
11168  // C++ [over.over]p1:
11169  // [...] [Note: any redundant set of parentheses surrounding the
11170  // overloaded function name is ignored (5.1). ]
11171  // C++ [over.over]p1:
11172  // [...] The overloaded function name can be preceded by the &
11173  // operator.
11174 
11175  // If we didn't actually find any template-ids, we're done.
11176  if (!ovl->hasExplicitTemplateArgs())
11177  return nullptr;
11178 
11179  TemplateArgumentListInfo ExplicitTemplateArgs;
11180  ovl->copyTemplateArgumentsInto(ExplicitTemplateArgs);
11181  TemplateSpecCandidateSet FailedCandidates(ovl->getNameLoc());
11182 
11183  // Look through all of the overloaded functions, searching for one
11184  // whose type matches exactly.
11185  FunctionDecl *Matched = nullptr;
11186  for (UnresolvedSetIterator I = ovl->decls_begin(),
11187  E = ovl->decls_end(); I != E; ++I) {
11188  // C++0x [temp.arg.explicit]p3:
11189  // [...] In contexts where deduction is done and fails, or in contexts
11190  // where deduction is not done, if a template argument list is
11191  // specified and it, along with any default template arguments,
11192  // identifies a single function template specialization, then the
11193  // template-id is an lvalue for the function template specialization.
11194  FunctionTemplateDecl *FunctionTemplate
11195  = cast<FunctionTemplateDecl>((*I)->getUnderlyingDecl());
11196 
11197  // C++ [over.over]p2:
11198  // If the name is a function template, template argument deduction is
11199  // done (14.8.2.2), and if the argument deduction succeeds, the
11200  // resulting template argument list is used to generate a single
11201  // function template specialization, which is added to the set of
11202  // overloaded functions considered.
11203  FunctionDecl *Specialization = nullptr;
11204  TemplateDeductionInfo Info(FailedCandidates.getLocation());
11205  if (TemplateDeductionResult Result
11206  = DeduceTemplateArguments(FunctionTemplate, &ExplicitTemplateArgs,
11207  Specialization, Info,
11208  /*IsAddressOfFunction*/true)) {
11209  // Make a note of the failed deduction for diagnostics.
11210  // TODO: Actually use the failed-deduction info?
11211  FailedCandidates.addCandidate()
11212  .set(I.getPair(), FunctionTemplate->getTemplatedDecl(),
11213  MakeDeductionFailureInfo(Context, Result, Info));
11214  continue;
11215  }
11216 
11217  assert(Specialization && "no specialization and no error?");
11218 
11219  // Multiple matches; we can't resolve to a single declaration.
11220  if (Matched) {
11221  if (Complain) {
11222  Diag(ovl->getExprLoc(), diag::err_addr_ovl_ambiguous)
11223  << ovl->getName();
11225  }
11226  return nullptr;
11227  }
11228 
11229  Matched = Specialization;
11230  if (FoundResult) *FoundResult = I.getPair();
11231  }
11232 
11233  if (Matched &&
11234  completeFunctionType(*this, Matched, ovl->getExprLoc(), Complain))
11235  return nullptr;
11236 
11237  return Matched;
11238 }
11239 
11240 
11241 
11242 
11243 // Resolve and fix an overloaded expression that can be resolved
11244 // because it identifies a single function template specialization.
11245 //
11246 // Last three arguments should only be supplied if Complain = true
11247 //
11248 // Return true if it was logically possible to so resolve the
11249 // expression, regardless of whether or not it succeeded. Always
11250 // returns true if 'complain' is set.
11252  ExprResult &SrcExpr, bool doFunctionPointerConverion,
11253  bool complain, SourceRange OpRangeForComplaining,
11254  QualType DestTypeForComplaining,
11255  unsigned DiagIDForComplaining) {
11256  assert(SrcExpr.get()->getType() == Context.OverloadTy);
11257 
11259 
11260  DeclAccessPair found;
11261  ExprResult SingleFunctionExpression;
11263  ovl.Expression, /*complain*/ false, &found)) {
11264  if (DiagnoseUseOfDecl(fn, SrcExpr.get()->getLocStart())) {
11265  SrcExpr = ExprError();
11266  return true;
11267  }
11268 
11269  // It is only correct to resolve to an instance method if we're
11270  // resolving a form that's permitted to be a pointer to member.
11271  // Otherwise we'll end up making a bound member expression, which
11272  // is illegal in all the contexts we resolve like this.
11273  if (!ovl.HasFormOfMemberPointer &&
11274  isa<CXXMethodDecl>(fn) &&
11275  cast<CXXMethodDecl>(fn)->isInstance()) {
11276  if (!complain) return false;
11277 
11278  Diag(ovl.Expression->getExprLoc(),
11279  diag::err_bound_member_function)
11280  << 0 << ovl.Expression->getSourceRange();
11281 
11282  // TODO: I believe we only end up here if there's a mix of
11283  // static and non-static candidates (otherwise the expression
11284  // would have 'bound member' type, not 'overload' type).
11285  // Ideally we would note which candidate was chosen and why
11286  // the static candidates were rejected.
11287  SrcExpr = ExprError();
11288  return true;
11289  }
11290 
11291  // Fix the expression to refer to 'fn'.
11292  SingleFunctionExpression =
11293  FixOverloadedFunctionReference(SrcExpr.get(), found, fn);
11294 
11295  // If desired, do function-to-pointer decay.
11296  if (doFunctionPointerConverion) {
11297  SingleFunctionExpression =
11298  DefaultFunctionArrayLvalueConversion(SingleFunctionExpression.get());
11299  if (SingleFunctionExpression.isInvalid()) {
11300  SrcExpr = ExprError();
11301  return true;
11302  }
11303  }
11304  }
11305 
11306  if (!SingleFunctionExpression.isUsable()) {
11307  if (complain) {
11308  Diag(OpRangeForComplaining.getBegin(), DiagIDForComplaining)
11309  << ovl.Expression->getName()
11310  << DestTypeForComplaining
11311  << OpRangeForComplaining
11312  << ovl.Expression->getQualifierLoc().getSourceRange();
11313  NoteAllOverloadCandidates(SrcExpr.get());
11314 
11315  SrcExpr = ExprError();
11316  return true;
11317  }
11318 
11319  return false;
11320  }
11321 
11322  SrcExpr = SingleFunctionExpression;
11323  return true;
11324 }
11325 
11326 /// \brief Add a single candidate to the overload set.
11328  DeclAccessPair FoundDecl,
11329  TemplateArgumentListInfo *ExplicitTemplateArgs,
11330  ArrayRef<Expr *> Args,
11331  OverloadCandidateSet &CandidateSet,
11332  bool PartialOverloading,
11333  bool KnownValid) {
11334  NamedDecl *Callee = FoundDecl.getDecl();
11335  if (isa<UsingShadowDecl>(Callee))
11336  Callee = cast<UsingShadowDecl>(Callee)->getTargetDecl();
11337 
11338  if (FunctionDecl *Func = dyn_cast<FunctionDecl>(Callee)) {
11339  if (ExplicitTemplateArgs) {
11340  assert(!KnownValid && "Explicit template arguments?");
11341  return;
11342  }
11343  // Prevent ill-formed function decls to be added as overload candidates.
11344  if (!dyn_cast<FunctionProtoType>(Func->getType()->getAs<FunctionType>()))
11345  return;
11346 
11347  S.AddOverloadCandidate(Func, FoundDecl, Args, CandidateSet,
11348  /*SuppressUsedConversions=*/false,
11349  PartialOverloading);
11350  return;
11351  }
11352 
11353  if (FunctionTemplateDecl *FuncTemplate
11354  = dyn_cast<FunctionTemplateDecl>(Callee)) {
11355  S.AddTemplateOverloadCandidate(FuncTemplate, FoundDecl,
11356  ExplicitTemplateArgs, Args, CandidateSet,
11357  /*SuppressUsedConversions=*/false,
11358  PartialOverloading);
11359  return;
11360  }
11361 
11362  assert(!KnownValid && "unhandled case in overloaded call candidate");
11363 }
11364 
11365 /// \brief Add the overload candidates named by callee and/or found by argument
11366 /// dependent lookup to the given overload set.
11368  ArrayRef<Expr *> Args,
11369  OverloadCandidateSet &CandidateSet,
11370  bool PartialOverloading) {
11371 
11372 #ifndef NDEBUG
11373  // Verify that ArgumentDependentLookup is consistent with the rules
11374  // in C++0x [basic.lookup.argdep]p3:
11375  //
11376  // Let X be the lookup set produced by unqualified lookup (3.4.1)
11377  // and let Y be the lookup set produced by argument dependent
11378  // lookup (defined as follows). If X contains
11379  //
11380  // -- a declaration of a class member, or
11381  //
11382  // -- a block-scope function declaration that is not a
11383  // using-declaration, or
11384  //
11385  // -- a declaration that is neither a function or a function
11386  // template
11387  //
11388  // then Y is empty.
11389 
11390  if (ULE->requiresADL()) {
11392  E = ULE->decls_end(); I != E; ++I) {
11393  assert(!(*I)->getDeclContext()->isRecord());
11394  assert(isa<UsingShadowDecl>(*I) ||
11395  !(*I)->getDeclContext()->isFunctionOrMethod());
11396  assert((*I)->getUnderlyingDecl()->isFunctionOrFunctionTemplate());
11397  }
11398  }
11399 #endif
11400 
11401  // It would be nice to avoid this copy.
11402  TemplateArgumentListInfo TABuffer;
11403  TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr;
11404  if (ULE->hasExplicitTemplateArgs()) {
11405  ULE->copyTemplateArgumentsInto(TABuffer);
11406  ExplicitTemplateArgs = &TABuffer;
11407  }
11408 
11410  E = ULE->decls_end(); I != E; ++I)
11411  AddOverloadedCallCandidate(*this, I.getPair(), ExplicitTemplateArgs, Args,
11412  CandidateSet, PartialOverloading,
11413  /*KnownValid*/ true);
11414 
11415  if (ULE->requiresADL())
11417  Args, ExplicitTemplateArgs,
11418  CandidateSet, PartialOverloading);
11419 }
11420 
11421 /// Determine whether a declaration with the specified name could be moved into
11422 /// a different namespace.
11424  switch (Name.getCXXOverloadedOperator()) {
11425  case OO_New: case OO_Array_New:
11426  case OO_Delete: case OO_Array_Delete:
11427  return false;
11428 
11429  default:
11430  return true;
11431  }
11432 }
11433 
11434 /// Attempt to recover from an ill-formed use of a non-dependent name in a
11435 /// template, where the non-dependent name was declared after the template
11436 /// was defined. This is common in code written for a compilers which do not
11437 /// correctly implement two-stage name lookup.
11438 ///
11439 /// Returns true if a viable candidate was found and a diagnostic was issued.
11440 static bool
11442  const CXXScopeSpec &SS, LookupResult &R,
11444  TemplateArgumentListInfo *ExplicitTemplateArgs,
11445  ArrayRef<Expr *> Args,
11446  bool *DoDiagnoseEmptyLookup = nullptr) {
11447  if (!SemaRef.inTemplateInstantiation() || !SS.isEmpty())
11448  return false;
11449 
11450  for (DeclContext *DC = SemaRef.CurContext; DC; DC = DC->getParent()) {
11451  if (DC->isTransparentContext())
11452  continue;
11453 
11454  SemaRef.LookupQualifiedName(R, DC);
11455 
11456  if (!R.empty()) {
11457  R.suppressDiagnostics();
11458 
11459  if (isa<CXXRecordDecl>(DC)) {
11460  // Don't diagnose names we find in classes; we get much better
11461  // diagnostics for these from DiagnoseEmptyLookup.
11462  R.clear();
11463  if (DoDiagnoseEmptyLookup)
11464  *DoDiagnoseEmptyLookup = true;
11465  return false;
11466  }
11467 
11468  OverloadCandidateSet Candidates(FnLoc, CSK);
11469  for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I)
11470  AddOverloadedCallCandidate(SemaRef, I.getPair(),
11471  ExplicitTemplateArgs, Args,
11472  Candidates, false, /*KnownValid*/ false);
11473 
11475  if (Candidates.BestViableFunction(SemaRef, FnLoc, Best) != OR_Success) {
11476  // No viable functions. Don't bother the user with notes for functions
11477  // which don't work and shouldn't be found anyway.
11478  R.clear();
11479  return false;
11480  }
11481 
11482  // Find the namespaces where ADL would have looked, and suggest
11483  // declaring the function there instead.
11484  Sema::AssociatedNamespaceSet AssociatedNamespaces;
11485  Sema::AssociatedClassSet AssociatedClasses;
11486  SemaRef.FindAssociatedClassesAndNamespaces(FnLoc, Args,
11487  AssociatedNamespaces,
11488  AssociatedClasses);
11489  Sema::AssociatedNamespaceSet SuggestedNamespaces;
11491  DeclContext *Std = SemaRef.getStdNamespace();
11492  for (Sema::AssociatedNamespaceSet::iterator
11493  it = AssociatedNamespaces.begin(),
11494  end = AssociatedNamespaces.end(); it != end; ++it) {
11495  // Never suggest declaring a function within namespace 'std'.
11496  if (Std && Std->Encloses(*it))
11497  continue;
11498 
11499  // Never suggest declaring a function within a namespace with a
11500  // reserved name, like __gnu_cxx.
11501  NamespaceDecl *NS = dyn_cast<NamespaceDecl>(*it);
11502  if (NS &&
11503  NS->getQualifiedNameAsString().find("__") != std::string::npos)
11504  continue;
11505 
11506  SuggestedNamespaces.insert(*it);
11507  }
11508  }
11509 
11510  SemaRef.Diag(R.getNameLoc(), diag::err_not_found_by_two_phase_lookup)
11511  << R.getLookupName();
11512  if (SuggestedNamespaces.empty()) {
11513  SemaRef.Diag(Best->Function->getLocation(),
11514  diag::note_not_found_by_two_phase_lookup)
11515  << R.getLookupName() << 0;
11516  } else if (SuggestedNamespaces.size() == 1) {
11517  SemaRef.Diag(Best->Function->getLocation(),
11518  diag::note_not_found_by_two_phase_lookup)
11519  << R.getLookupName() << 1 << *SuggestedNamespaces.begin();
11520  } else {
11521  // FIXME: It would be useful to list the associated namespaces here,
11522  // but the diagnostics infrastructure doesn't provide a way to produce
11523  // a localized representation of a list of items.
11524  SemaRef.Diag(Best->Function->getLocation(),
11525  diag::note_not_found_by_two_phase_lookup)
11526  << R.getLookupName() << 2;
11527  }
11528 
11529  // Try to recover by calling this function.
11530  return true;
11531  }
11532 
11533  R.clear();
11534  }
11535 
11536  return false;
11537 }
11538 
11539 /// Attempt to recover from ill-formed use of a non-dependent operator in a
11540 /// template, where the non-dependent operator was declared after the template
11541 /// was defined.
11542 ///
11543 /// Returns true if a viable candidate was found and a diagnostic was issued.
11544 static bool
11546  SourceLocation OpLoc,
11547  ArrayRef<Expr *> Args) {
11548  DeclarationName OpName =
11550  LookupResult R(SemaRef, OpName, OpLoc, Sema::LookupOperatorName);
11551  return DiagnoseTwoPhaseLookup(SemaRef, OpLoc, CXXScopeSpec(), R,
11553  /*ExplicitTemplateArgs=*/nullptr, Args);
11554 }
11555 
11556 namespace {
11557 class BuildRecoveryCallExprRAII {
11558  Sema &SemaRef;
11559 public:
11560  BuildRecoveryCallExprRAII(Sema &S) : SemaRef(S) {
11561  assert(SemaRef.IsBuildingRecoveryCallExpr == false);
11562  SemaRef.IsBuildingRecoveryCallExpr = true;
11563  }
11564 
11565  ~BuildRecoveryCallExprRAII() {
11566  SemaRef.IsBuildingRecoveryCallExpr = false;
11567  }
11568 };
11569 
11570 }
11571 
11572 static std::unique_ptr<CorrectionCandidateCallback>
11573 MakeValidator(Sema &SemaRef, MemberExpr *ME, size_t NumArgs,
11574  bool HasTemplateArgs, bool AllowTypoCorrection) {
11575  if (!AllowTypoCorrection)
11576  return llvm::make_unique<NoTypoCorrectionCCC>();
11577  return llvm::make_unique<FunctionCallFilterCCC>(SemaRef, NumArgs,
11578  HasTemplateArgs, ME);
11579 }
11580 
11581 /// Attempts to recover from a call where no functions were found.
11582 ///
11583 /// Returns true if new candidates were found.
11584 static ExprResult
11586  UnresolvedLookupExpr *ULE,
11587  SourceLocation LParenLoc,
11589  SourceLocation RParenLoc,
11590  bool EmptyLookup, bool AllowTypoCorrection) {
11591  // Do not try to recover if it is already building a recovery call.
11592  // This stops infinite loops for template instantiations like
11593  //
11594  // template <typename T> auto foo(T t) -> decltype(foo(t)) {}
11595  // template <typename T> auto foo(T t) -> decltype(foo(&t)) {}
11596  //
11597  if (SemaRef.IsBuildingRecoveryCallExpr)
11598  return ExprError();
11599  BuildRecoveryCallExprRAII RCE(SemaRef);
11600 
11601  CXXScopeSpec SS;
11602  SS.Adopt(ULE->getQualifierLoc());
11603  SourceLocation TemplateKWLoc = ULE->getTemplateKeywordLoc();
11604 
11605  TemplateArgumentListInfo TABuffer;
11606  TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr;
11607  if (ULE->hasExplicitTemplateArgs()) {
11608  ULE->copyTemplateArgumentsInto(TABuffer);
11609  ExplicitTemplateArgs = &TABuffer;
11610  }
11611 
11612  LookupResult R(SemaRef, ULE->getName(), ULE->getNameLoc(),
11614  bool DoDiagnoseEmptyLookup = EmptyLookup;
11615  if (!DiagnoseTwoPhaseLookup(SemaRef, Fn->getExprLoc(), SS, R,
11617  ExplicitTemplateArgs, Args,
11618  &DoDiagnoseEmptyLookup) &&
11619  (!DoDiagnoseEmptyLookup || SemaRef.DiagnoseEmptyLookup(
11620  S, SS, R,
11621  MakeValidator(SemaRef, dyn_cast<MemberExpr>(Fn), Args.size(),
11622  ExplicitTemplateArgs != nullptr, AllowTypoCorrection),
11623  ExplicitTemplateArgs, Args)))
11624  return ExprError();
11625 
11626  assert(!R.empty() && "lookup results empty despite recovery");
11627 
11628  // If recovery created an ambiguity, just bail out.
11629  if (R.isAmbiguous()) {
11630  R.suppressDiagnostics();
11631  return ExprError();
11632  }
11633 
11634  // Build an implicit member call if appropriate. Just drop the
11635  // casts and such from the call, we don't really care.
11636  ExprResult NewFn = ExprError();
11637  if ((*R.begin())->isCXXClassMember())
11638  NewFn = SemaRef.BuildPossibleImplicitMemberExpr(SS, TemplateKWLoc, R,
11639  ExplicitTemplateArgs, S);
11640  else if (ExplicitTemplateArgs || TemplateKWLoc.isValid())
11641  NewFn = SemaRef.BuildTemplateIdExpr(SS, TemplateKWLoc, R, false,
11642  ExplicitTemplateArgs);
11643  else
11644  NewFn = SemaRef.BuildDeclarationNameExpr(SS, R, false);
11645 
11646  if (NewFn.isInvalid())
11647  return ExprError();
11648 
11649  // This shouldn't cause an infinite loop because we're giving it
11650  // an expression with viable lookup results, which should never
11651  // end up here.
11652  return SemaRef.ActOnCallExpr(/*Scope*/ nullptr, NewFn.get(), LParenLoc,
11653  MultiExprArg(Args.data(), Args.size()),
11654  RParenLoc);
11655 }
11656 
11657 /// \brief Constructs and populates an OverloadedCandidateSet from
11658 /// the given function.
11659 /// \returns true when an the ExprResult output parameter has been set.
11661  UnresolvedLookupExpr *ULE,
11662  MultiExprArg Args,
11663  SourceLocation RParenLoc,
11664  OverloadCandidateSet *CandidateSet,
11665  ExprResult *Result) {
11666 #ifndef NDEBUG
11667  if (ULE->requiresADL()) {
11668  // To do ADL, we must have found an unqualified name.
11669  assert(!ULE->getQualifier() && "qualified name with ADL");
11670 
11671  // We don't perform ADL for implicit declarations of builtins.
11672  // Verify that this was correctly set up.
11673  FunctionDecl *F;
11674  if (ULE->decls_begin() + 1 == ULE->decls_end() &&
11675  (F = dyn_cast<FunctionDecl>(*ULE->decls_begin())) &&
11676  F->getBuiltinID() && F->isImplicit())
11677  llvm_unreachable("performing ADL for builtin");
11678 
11679  // We don't perform ADL in C.
11680  assert(getLangOpts().CPlusPlus && "ADL enabled in C");
11681  }
11682 #endif
11683 
11684  UnbridgedCastsSet UnbridgedCasts;
11685  if (checkArgPlaceholdersForOverload(*this, Args, UnbridgedCasts)) {
11686  *Result = ExprError();
11687  return true;
11688  }
11689 
11690  // Add the functions denoted by the callee to the set of candidate
11691  // functions, including those from argument-dependent lookup.
11692  AddOverloadedCallCandidates(ULE, Args, *CandidateSet);
11693 
11694  if (getLangOpts().MSVCCompat &&
11696  (isa<FunctionDecl>(CurContext) || isa<CXXRecordDecl>(CurContext))) {
11697 
11699  if (CandidateSet->empty() ||
11700  CandidateSet->BestViableFunction(*this, Fn->getLocStart(), Best) ==
11702  // In Microsoft mode, if we are inside a template class member function then
11703  // create a type dependent CallExpr. The goal is to postpone name lookup
11704  // to instantiation time to be able to search into type dependent base
11705  // classes.
11706  CallExpr *CE = new (Context) CallExpr(
11707  Context, Fn, Args, Context.DependentTy, VK_RValue, RParenLoc);
11708  CE->setTypeDependent(true);
11709  CE->setValueDependent(true);
11710  CE->setInstantiationDependent(true);
11711  *Result = CE;
11712  return true;
11713  }
11714  }
11715 
11716  if (CandidateSet->empty())
11717  return false;
11718 
11719  UnbridgedCasts.restore();
11720  return false;
11721 }
11722 
11723 /// FinishOverloadedCallExpr - given an OverloadCandidateSet, builds and returns
11724 /// the completed call expression. If overload resolution fails, emits
11725 /// diagnostics and returns ExprError()
11727  UnresolvedLookupExpr *ULE,
11728  SourceLocation LParenLoc,
11729  MultiExprArg Args,
11730  SourceLocation RParenLoc,
11731  Expr *ExecConfig,
11732  OverloadCandidateSet *CandidateSet,
11734  OverloadingResult OverloadResult,
11735  bool AllowTypoCorrection) {
11736  if (CandidateSet->empty())
11737  return BuildRecoveryCallExpr(SemaRef, S, Fn, ULE, LParenLoc, Args,
11738  RParenLoc, /*EmptyLookup=*/true,
11739  AllowTypoCorrection);
11740 
11741  switch (OverloadResult) {
11742  case OR_Success: {
11743  FunctionDecl *FDecl = (*Best)->Function;
11744  SemaRef.CheckUnresolvedLookupAccess(ULE, (*Best)->FoundDecl);
11745  if (SemaRef.DiagnoseUseOfDecl(FDecl, ULE->getNameLoc()))
11746  return ExprError();
11747  Fn = SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl);
11748  return SemaRef.BuildResolvedCallExpr(Fn, FDecl, LParenLoc, Args, RParenLoc,
11749  ExecConfig);
11750  }
11751 
11752  case OR_No_Viable_Function: {
11753  // Try to recover by looking for viable functions which the user might
11754  // have meant to call.
11755  ExprResult Recovery = BuildRecoveryCallExpr(SemaRef, S, Fn, ULE, LParenLoc,
11756  Args, RParenLoc,
11757  /*EmptyLookup=*/false,
11758  AllowTypoCorrection);
11759  if (!Recovery.isInvalid())
11760  return Recovery;
11761 
11762  // If the user passes in a function that we can't take the address of, we
11763  // generally end up emitting really bad error messages. Here, we attempt to
11764  // emit better ones.
11765  for (const Expr *Arg : Args) {
11766  if (!Arg->getType()->isFunctionType())
11767  continue;
11768  if (auto *DRE = dyn_cast<DeclRefExpr>(Arg->IgnoreParenImpCasts())) {
11769  auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl());
11770  if (FD &&
11771  !SemaRef.checkAddressOfFunctionIsAvailable(FD, /*Complain=*/true,
11772  Arg->getExprLoc()))
11773  return ExprError();
11774  }
11775  }
11776 
11777  SemaRef.Diag(Fn->getLocStart(), diag::err_ovl_no_viable_function_in_call)
11778  << ULE->getName() << Fn->getSourceRange();
11779  CandidateSet->NoteCandidates(SemaRef, OCD_AllCandidates, Args);
11780  break;
11781  }
11782 
11783  case OR_Ambiguous:
11784  SemaRef.Diag(Fn->getLocStart(), diag::err_ovl_ambiguous_call)
11785  << ULE->getName() << Fn->getSourceRange();
11786  CandidateSet->NoteCandidates(SemaRef, OCD_ViableCandidates, Args);
11787  break;
11788 
11789  case OR_Deleted: {
11790  SemaRef.Diag(Fn->getLocStart(), diag::err_ovl_deleted_call)
11791  << (*Best)->Function->isDeleted()
11792  << ULE->getName()
11793  << SemaRef.getDeletedOrUnavailableSuffix((*Best)->Function)
11794  << Fn->getSourceRange();
11795  CandidateSet->NoteCandidates(SemaRef, OCD_AllCandidates, Args);
11796 
11797  // We emitted an error for the unvailable/deleted function call but keep
11798  // the call in the AST.
11799  FunctionDecl *FDecl = (*Best)->Function;
11800  Fn = SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl);
11801  return SemaRef.BuildResolvedCallExpr(Fn, FDecl, LParenLoc, Args, RParenLoc,
11802  ExecConfig);
11803  }
11804  }
11805 
11806  // Overload resolution failed.
11807  return ExprError();
11808 }
11809 
11811  OverloadCandidateSet &CS) {
11812  for (auto I = CS.begin(), E = CS.end(); I != E; ++I) {
11813  if (I->Viable &&
11814  !S.checkAddressOfFunctionIsAvailable(I->Function, /*Complain=*/false)) {
11815  I->Viable = false;
11816  I->FailureKind = ovl_fail_addr_not_available;
11817  }
11818  }
11819 }
11820 
11821 /// BuildOverloadedCallExpr - Given the call expression that calls Fn
11822 /// (which eventually refers to the declaration Func) and the call
11823 /// arguments Args/NumArgs, attempt to resolve the function call down
11824 /// to a specific function. If overload resolution succeeds, returns
11825 /// the call expression produced by overload resolution.
11826 /// Otherwise, emits diagnostics and returns ExprError.
11828  UnresolvedLookupExpr *ULE,
11829  SourceLocation LParenLoc,
11830  MultiExprArg Args,
11831  SourceLocation RParenLoc,
11832  Expr *ExecConfig,
11833  bool AllowTypoCorrection,
11834  bool CalleesAddressIsTaken) {
11835  OverloadCandidateSet CandidateSet(Fn->getExprLoc(),
11837  ExprResult result;
11838 
11839  if (buildOverloadedCallSet(S, Fn, ULE, Args, LParenLoc, &CandidateSet,
11840  &result))
11841  return result;
11842 
11843  // If the user handed us something like `(&Foo)(Bar)`, we need to ensure that
11844  // functions that aren't addressible are considered unviable.
11845  if (CalleesAddressIsTaken)
11846  markUnaddressableCandidatesUnviable(*this, CandidateSet);
11847 
11849  OverloadingResult OverloadResult =
11850  CandidateSet.BestViableFunction(*this, Fn->getLocStart(), Best);
11851 
11852  return FinishOverloadedCallExpr(*this, S, Fn, ULE, LParenLoc, Args,
11853  RParenLoc, ExecConfig, &CandidateSet,
11854  &Best, OverloadResult,
11855  AllowTypoCorrection);
11856 }
11857 
11858 static bool IsOverloaded(const UnresolvedSetImpl &Functions) {
11859  return Functions.size() > 1 ||
11860  (Functions.size() == 1 && isa<FunctionTemplateDecl>(*Functions.begin()));
11861 }
11862 
11863 /// \brief Create a unary operation that may resolve to an overloaded
11864 /// operator.
11865 ///
11866 /// \param OpLoc The location of the operator itself (e.g., '*').
11867 ///
11868 /// \param Opc The UnaryOperatorKind that describes this operator.
11869 ///
11870 /// \param Fns The set of non-member functions that will be
11871 /// considered by overload resolution. The caller needs to build this
11872 /// set based on the context using, e.g.,
11873 /// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This
11874 /// set should not contain any member functions; those will be added
11875 /// by CreateOverloadedUnaryOp().
11876 ///
11877 /// \param Input The input argument.
11878 ExprResult
11880  const UnresolvedSetImpl &Fns,
11881  Expr *Input) {
11883  assert(Op != OO_None && "Invalid opcode for overloaded unary operator");
11885  // TODO: provide better source location info.
11886  DeclarationNameInfo OpNameInfo(OpName, OpLoc);
11887 
11888  if (checkPlaceholderForOverload(*this, Input))
11889  return ExprError();
11890 
11891  Expr *Args[2] = { Input, nullptr };
11892  unsigned NumArgs = 1;
11893 
11894  // For post-increment and post-decrement, add the implicit '0' as
11895  // the second argument, so that we know this is a post-increment or
11896  // post-decrement.
11897  if (Opc == UO_PostInc || Opc == UO_PostDec) {
11898  llvm::APSInt Zero(Context.getTypeSize(Context.IntTy), false);
11899  Args[1] = IntegerLiteral::Create(Context, Zero, Context.IntTy,
11900  SourceLocation());
11901  NumArgs = 2;
11902  }
11903 
11904  ArrayRef<Expr *> ArgsArray(Args, NumArgs);
11905 
11906  if (Input->isTypeDependent()) {
11907  if (Fns.empty())
11908  return new (Context) UnaryOperator(Input, Opc, Context.DependentTy,
11909  VK_RValue, OK_Ordinary, OpLoc);
11910 
11911  CXXRecordDecl *NamingClass = nullptr; // lookup ignores member operators
11913  = UnresolvedLookupExpr::Create(Context, NamingClass,
11914  NestedNameSpecifierLoc(), OpNameInfo,
11915  /*ADL*/ true, IsOverloaded(Fns),
11916  Fns.begin(), Fns.end());
11917  return new (Context)
11918  CXXOperatorCallExpr(Context, Op, Fn, ArgsArray, Context.DependentTy,
11919  VK_RValue, OpLoc, FPOptions());
11920  }
11921 
11922  // Build an empty overload set.
11924 
11925  // Add the candidates from the given function set.
11926  AddFunctionCandidates(Fns, ArgsArray, CandidateSet);
11927 
11928  // Add operator candidates that are member functions.
11929  AddMemberOperatorCandidates(Op, OpLoc, ArgsArray, CandidateSet);
11930 
11931  // Add candidates from ADL.
11932  AddArgumentDependentLookupCandidates(OpName, OpLoc, ArgsArray,
11933  /*ExplicitTemplateArgs*/nullptr,
11934  CandidateSet);
11935 
11936  // Add builtin operator candidates.
11937  AddBuiltinOperatorCandidates(Op, OpLoc, ArgsArray, CandidateSet);
11938 
11939  bool HadMultipleCandidates = (CandidateSet.size() > 1);
11940 
11941  // Perform overload resolution.
11943  switch (CandidateSet.BestViableFunction(*this, OpLoc, Best)) {
11944  case OR_Success: {
11945  // We found a built-in operator or an overloaded operator.
11946  FunctionDecl *FnDecl = Best->Function;
11947 
11948  if (FnDecl) {
11949  Expr *Base = nullptr;
11950  // We matched an overloaded operator. Build a call to that
11951  // operator.
11952 
11953  // Convert the arguments.
11954  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) {
11955  CheckMemberOperatorAccess(OpLoc, Args[0], nullptr, Best->FoundDecl);
11956 
11957  ExprResult InputRes =
11958  PerformObjectArgumentInitialization(Input, /*Qualifier=*/nullptr,
11959  Best->FoundDecl, Method);
11960  if (InputRes.isInvalid())
11961  return ExprError();
11962  Base = Input = InputRes.get();
11963  } else {
11964  // Convert the arguments.
11965  ExprResult InputInit
11967  Context,
11968  FnDecl->getParamDecl(0)),
11969  SourceLocation(),
11970  Input);
11971  if (InputInit.isInvalid())
11972  return ExprError();
11973  Input = InputInit.get();
11974  }
11975 
11976  // Build the actual expression node.
11977  ExprResult FnExpr = CreateFunctionRefExpr(*this, FnDecl, Best->FoundDecl,
11978  Base, HadMultipleCandidates,
11979  OpLoc);
11980  if (FnExpr.isInvalid())
11981  return ExprError();
11982 
11983  // Determine the result type.
11984  QualType ResultTy = FnDecl->getReturnType();
11986  ResultTy = ResultTy.getNonLValueExprType(Context);
11987 
11988  Args[0] = Input;
11989  CallExpr *TheCall =
11990  new (Context) CXXOperatorCallExpr(Context, Op, FnExpr.get(), ArgsArray,
11991  ResultTy, VK, OpLoc, FPOptions());
11992 
11993  if (CheckCallReturnType(FnDecl->getReturnType(), OpLoc, TheCall, FnDecl))
11994  return ExprError();
11995 
11996  if (CheckFunctionCall(FnDecl, TheCall,
11997  FnDecl->getType()->castAs<FunctionProtoType>()))
11998  return ExprError();
11999 
12000  return MaybeBindToTemporary(TheCall);
12001  } else {
12002  // We matched a built-in operator. Convert the arguments, then
12003  // break out so that we will build the appropriate built-in
12004  // operator node.
12006  Input, Best->BuiltinParamTypes[0], Best->Conversions[0], AA_Passing);
12007  if (InputRes.isInvalid())
12008  return ExprError();
12009  Input = InputRes.get();
12010  break;
12011  }
12012  }
12013 
12014  case OR_No_Viable_Function:
12015  // This is an erroneous use of an operator which can be overloaded by
12016  // a non-member function. Check for non-member operators which were
12017  // defined too late to be candidates.
12018  if (DiagnoseTwoPhaseOperatorLookup(*this, Op, OpLoc, ArgsArray))
12019  // FIXME: Recover by calling the found function.
12020  return ExprError();
12021 
12022  // No viable function; fall through to handling this as a
12023  // built-in operator, which will produce an error message for us.
12024  break;
12025 
12026  case OR_Ambiguous:
12027  Diag(OpLoc, diag::err_ovl_ambiguous_oper_unary)
12029  << Input->getType()
12030  << Input->getSourceRange();
12031  CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, ArgsArray,
12032  UnaryOperator::getOpcodeStr(Opc), OpLoc);
12033  return ExprError();
12034 
12035  case OR_Deleted:
12036  Diag(OpLoc, diag::err_ovl_deleted_oper)
12037  << Best->Function->isDeleted()
12039  << getDeletedOrUnavailableSuffix(Best->Function)
12040  << Input->getSourceRange();
12041  CandidateSet.NoteCandidates(*this, OCD_AllCandidates, ArgsArray,
12042  UnaryOperator::getOpcodeStr(Opc), OpLoc);
12043  return ExprError();
12044  }
12045 
12046  // Either we found no viable overloaded operator or we matched a
12047  // built-in operator. In either case, fall through to trying to
12048  // build a built-in operation.
12049  return CreateBuiltinUnaryOp(OpLoc, Opc, Input);
12050 }
12051 
12052 /// \brief Create a binary operation that may resolve to an overloaded
12053 /// operator.
12054 ///
12055 /// \param OpLoc The location of the operator itself (e.g., '+').
12056 ///
12057 /// \param Opc The BinaryOperatorKind that describes this operator.
12058 ///
12059 /// \param Fns The set of non-member functions that will be
12060 /// considered by overload resolution. The caller needs to build this
12061 /// set based on the context using, e.g.,
12062 /// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This
12063 /// set should not contain any member functions; those will be added
12064 /// by CreateOverloadedBinOp().
12065 ///
12066 /// \param LHS Left-hand argument.
12067 /// \param RHS Right-hand argument.
12068 ExprResult
12070  BinaryOperatorKind Opc,
12071  const UnresolvedSetImpl &Fns,
12072  Expr *LHS, Expr *RHS) {
12073  Expr *Args[2] = { LHS, RHS };
12074  LHS=RHS=nullptr; // Please use only Args instead of LHS/RHS couple
12075 
12078 
12079  // If either side is type-dependent, create an appropriate dependent
12080  // expression.
12081  if (Args[0]->isTypeDependent() || Args[1]->isTypeDependent()) {
12082  if (Fns.empty()) {
12083  // If there are no functions to store, just build a dependent
12084  // BinaryOperator or CompoundAssignment.
12085  if (Opc <= BO_Assign || Opc > BO_OrAssign)
12086  return new (Context) BinaryOperator(
12087  Args[0], Args[1], Opc, Context.DependentTy, VK_RValue, OK_Ordinary,
12088  OpLoc, FPFeatures);
12089 
12090  return new (Context) CompoundAssignOperator(
12091  Args[0], Args[1], Opc, Context.DependentTy, VK_LValue, OK_Ordinary,
12093  FPFeatures);
12094  }
12095 
12096  // FIXME: save results of ADL from here?
12097  CXXRecordDecl *NamingClass = nullptr; // lookup ignores member operators
12098  // TODO: provide better source location info in DNLoc component.
12099  DeclarationNameInfo OpNameInfo(OpName, OpLoc);
12101  = UnresolvedLookupExpr::Create(Context, NamingClass,
12102  NestedNameSpecifierLoc(), OpNameInfo,
12103  /*ADL*/ true, IsOverloaded(Fns),
12104  Fns.begin(), Fns.end());
12105  return new (Context)
12107  VK_RValue, OpLoc, FPFeatures);
12108  }
12109 
12110  // Always do placeholder-like conversions on the RHS.
12111  if (checkPlaceholderForOverload(*this, Args[1]))
12112  return ExprError();
12113 
12114  // Do placeholder-like conversion on the LHS; note that we should
12115  // not get here with a PseudoObject LHS.
12116  assert(Args[0]->getObjectKind() != OK_ObjCProperty);
12117  if (checkPlaceholderForOverload(*this, Args[0]))
12118  return ExprError();
12119 
12120  // If this is the assignment operator, we only perform overload resolution
12121  // if the left-hand side is a class or enumeration type. This is actually
12122  // a hack. The standard requires that we do overload resolution between the
12123  // various built-in candidates, but as DR507 points out, this can lead to
12124  // problems. So we do it this way, which pretty much follows what GCC does.
12125  // Note that we go the traditional code path for compound assignment forms.
12126  if (Opc == BO_Assign && !Args[0]->getType()->isOverloadableType())
12127  return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
12128 
12129  // If this is the .* operator, which is not overloadable, just
12130  // create a built-in binary operator.
12131  if (Opc == BO_PtrMemD)
12132  return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
12133 
12134  // Build an empty overload set.
12136 
12137  // Add the candidates from the given function set.
12138  AddFunctionCandidates(Fns, Args, CandidateSet);
12139 
12140  // Add operator candidates that are member functions.
12141  AddMemberOperatorCandidates(Op, OpLoc, Args, CandidateSet);
12142 
12143  // Add candidates from ADL. Per [over.match.oper]p2, this lookup is not
12144  // performed for an assignment operator (nor for operator[] nor operator->,
12145  // which don't get here).
12146  if (Opc != BO_Assign)
12147  AddArgumentDependentLookupCandidates(OpName, OpLoc, Args,
12148  /*ExplicitTemplateArgs*/ nullptr,
12149  CandidateSet);
12150 
12151  // Add builtin operator candidates.
12152  AddBuiltinOperatorCandidates(Op, OpLoc, Args, CandidateSet);
12153 
12154  bool HadMultipleCandidates = (CandidateSet.size() > 1);
12155 
12156  // Perform overload resolution.
12158  switch (CandidateSet.BestViableFunction(*this, OpLoc, Best)) {
12159  case OR_Success: {
12160  // We found a built-in operator or an overloaded operator.
12161  FunctionDecl *FnDecl = Best->Function;
12162 
12163  if (FnDecl) {
12164  Expr *Base = nullptr;
12165  // We matched an overloaded operator. Build a call to that
12166  // operator.
12167 
12168  // Convert the arguments.
12169  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) {
12170  // Best->Access is only meaningful for class members.
12171  CheckMemberOperatorAccess(OpLoc, Args[0], Args[1], Best->FoundDecl);
12172 
12173  ExprResult Arg1 =
12176  FnDecl->getParamDecl(0)),
12177  SourceLocation(), Args[1]);
12178  if (Arg1.isInvalid())
12179  return ExprError();
12180 
12181  ExprResult Arg0 =
12182  PerformObjectArgumentInitialization(Args[0], /*Qualifier=*/nullptr,
12183  Best->FoundDecl, Method);
12184  if (Arg0.isInvalid())
12185  return ExprError();
12186  Base = Args[0] = Arg0.getAs<Expr>();
12187  Args[1] = RHS = Arg1.getAs<Expr>();
12188  } else {
12189  // Convert the arguments.
12192  FnDecl->getParamDecl(0)),
12193  SourceLocation(), Args[0]);
12194  if (Arg0.isInvalid())
12195  return ExprError();
12196 
12197  ExprResult Arg1 =
12200  FnDecl->getParamDecl(1)),
12201  SourceLocation(), Args[1]);
12202  if (Arg1.isInvalid())
12203  return ExprError();
12204  Args[0] = LHS = Arg0.getAs<Expr>();
12205  Args[1] = RHS = Arg1.getAs<Expr>();
12206  }
12207 
12208  // Build the actual expression node.
12209  ExprResult FnExpr = CreateFunctionRefExpr(*this, FnDecl,
12210  Best->FoundDecl, Base,
12211  HadMultipleCandidates, OpLoc);
12212  if (FnExpr.isInvalid())
12213  return ExprError();
12214 
12215  // Determine the result type.
12216  QualType ResultTy = FnDecl->getReturnType();
12218  ResultTy = ResultTy.getNonLValueExprType(Context);
12219 
12220  CXXOperatorCallExpr *TheCall =
12221  new (Context) CXXOperatorCallExpr(Context, Op, FnExpr.get(),
12222  Args, ResultTy, VK, OpLoc,
12223  FPFeatures);
12224 
12225  if (CheckCallReturnType(FnDecl->getReturnType(), OpLoc, TheCall,
12226  FnDecl))
12227  return ExprError();
12228 
12229  ArrayRef<const Expr *> ArgsArray(Args, 2);
12230  const Expr *ImplicitThis = nullptr;
12231  // Cut off the implicit 'this'.
12232  if (isa<CXXMethodDecl>(FnDecl)) {
12233  ImplicitThis = ArgsArray[0];
12234  ArgsArray = ArgsArray.slice(1);
12235  }
12236 
12237  // Check for a self move.
12238  if (Op == OO_Equal)
12239  DiagnoseSelfMove(Args[0], Args[1], OpLoc);
12240 
12241  checkCall(FnDecl, nullptr, ImplicitThis, ArgsArray,
12242  isa<CXXMethodDecl>(FnDecl), OpLoc, TheCall->getSourceRange(),
12244 
12245  return MaybeBindToTemporary(TheCall);
12246  } else {
12247  // We matched a built-in operator. Convert the arguments, then
12248  // break out so that we will build the appropriate built-in
12249  // operator node.
12250  ExprResult ArgsRes0 =
12251  PerformImplicitConversion(Args[0], Best->BuiltinParamTypes[0],
12252  Best->Conversions[0], AA_Passing);
12253  if (ArgsRes0.isInvalid())
12254  return ExprError();
12255  Args[0] = ArgsRes0.get();
12256 
12257  ExprResult ArgsRes1 =
12258  PerformImplicitConversion(Args[1], Best->BuiltinParamTypes[1],
12259  Best->Conversions[1], AA_Passing);
12260  if (ArgsRes1.isInvalid())
12261  return ExprError();
12262  Args[1] = ArgsRes1.get();
12263  break;
12264  }
12265  }
12266 
12267  case OR_No_Viable_Function: {
12268  // C++ [over.match.oper]p9:
12269  // If the operator is the operator , [...] and there are no
12270  // viable functions, then the operator is assumed to be the
12271  // built-in operator and interpreted according to clause 5.
12272  if (Opc == BO_Comma)
12273  break;
12274 
12275  // For class as left operand for assignment or compound assigment
12276  // operator do not fall through to handling in built-in, but report that
12277  // no overloaded assignment operator found
12278  ExprResult Result = ExprError();
12279  if (Args[0]->getType()->isRecordType() &&
12280  Opc >= BO_Assign && Opc <= BO_OrAssign) {
12281  Diag(OpLoc, diag::err_ovl_no_viable_oper)
12283  << Args[0]->getSourceRange() << Args[1]->getSourceRange();
12284  if (Args[0]->getType()->isIncompleteType()) {
12285  Diag(OpLoc, diag::note_assign_lhs_incomplete)
12286  << Args[0]->getType()
12287  << Args[0]->getSourceRange() << Args[1]->getSourceRange();
12288  }
12289  } else {
12290  // This is an erroneous use of an operator which can be overloaded by
12291  // a non-member function. Check for non-member operators which were
12292  // defined too late to be candidates.
12293  if (DiagnoseTwoPhaseOperatorLookup(*this, Op, OpLoc, Args))
12294  // FIXME: Recover by calling the found function.
12295  return ExprError();
12296 
12297  // No viable function; try to create a built-in operation, which will
12298  // produce an error. Then, show the non-viable candidates.
12299  Result = CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
12300  }
12301  assert(Result.isInvalid() &&
12302  "C++ binary operator overloading is missing candidates!");
12303  if (Result.isInvalid())
12304  CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args,
12305  BinaryOperator::getOpcodeStr(Opc), OpLoc);
12306  return Result;
12307  }
12308 
12309  case OR_Ambiguous:
12310  Diag(OpLoc, diag::err_ovl_ambiguous_oper_binary)
12312  << Args[0]->getType() << Args[1]->getType()
12313  << Args[0]->getSourceRange() << Args[1]->getSourceRange();
12314  CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, Args,
12315  BinaryOperator::getOpcodeStr(Opc), OpLoc);
12316  return ExprError();
12317 
12318  case OR_Deleted:
12319  if (isImplicitlyDeleted(Best->Function)) {
12320  CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
12321  Diag(OpLoc, diag::err_ovl_deleted_special_oper)
12322  << Context.getRecordType(Method->getParent())
12323  << getSpecialMember(Method);
12324 
12325  // The user probably meant to call this special member. Just
12326  // explain why it's deleted.
12327  NoteDeletedFunction(Method);
12328  return ExprError();
12329  } else {
12330  Diag(OpLoc, diag::err_ovl_deleted_oper)
12331  << Best->Function->isDeleted()
12333  << getDeletedOrUnavailableSuffix(Best->Function)
12334  << Args[0]->getSourceRange() << Args[1]->getSourceRange();
12335  }
12336  CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args,
12337  BinaryOperator::getOpcodeStr(Opc), OpLoc);
12338  return ExprError();
12339  }
12340 
12341  // We matched a built-in operator; build it.
12342  return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
12343 }
12344 
12345 ExprResult
12347  SourceLocation RLoc,
12348  Expr *Base, Expr *Idx) {
12349  Expr *Args[2] = { Base, Idx };
12350  DeclarationName OpName =
12352 
12353  // If either side is type-dependent, create an appropriate dependent
12354  // expression.
12355  if (Args[0]->isTypeDependent() || Args[1]->isTypeDependent()) {
12356 
12357  CXXRecordDecl *NamingClass = nullptr; // lookup ignores member operators
12358  // CHECKME: no 'operator' keyword?
12359  DeclarationNameInfo OpNameInfo(OpName, LLoc);
12360  OpNameInfo.setCXXOperatorNameRange(SourceRange(LLoc, RLoc));
12362  = UnresolvedLookupExpr::Create(Context, NamingClass,
12363  NestedNameSpecifierLoc(), OpNameInfo,
12364  /*ADL*/ true, /*Overloaded*/ false,
12367  // Can't add any actual overloads yet
12368 
12369  return new (Context)
12370  CXXOperatorCallExpr(Context, OO_Subscript, Fn, Args,
12372  }
12373 
12374  // Handle placeholders on both operands.
12375  if (checkPlaceholderForOverload(*this, Args[0]))
12376  return ExprError();
12377  if (checkPlaceholderForOverload(*this, Args[1]))
12378  return ExprError();
12379 
12380  // Build an empty overload set.
12382 
12383  // Subscript can only be overloaded as a member function.
12384 
12385  // Add operator candidates that are member functions.
12386  AddMemberOperatorCandidates(OO_Subscript, LLoc, Args, CandidateSet);
12387 
12388  // Add builtin operator candidates.
12389  AddBuiltinOperatorCandidates(OO_Subscript, LLoc, Args, CandidateSet);
12390 
12391  bool HadMultipleCandidates = (CandidateSet.size() > 1);
12392 
12393  // Perform overload resolution.
12395  switch (CandidateSet.BestViableFunction(*this, LLoc, Best)) {
12396  case OR_Success: {
12397  // We found a built-in operator or an overloaded operator.
12398  FunctionDecl *FnDecl = Best->Function;
12399 
12400  if (FnDecl) {
12401  // We matched an overloaded operator. Build a call to that
12402  // operator.
12403 
12404  CheckMemberOperatorAccess(LLoc, Args[0], Args[1], Best->FoundDecl);
12405 
12406  // Convert the arguments.
12407  CXXMethodDecl *Method = cast<CXXMethodDecl>(FnDecl);
12408  ExprResult Arg0 =
12409  PerformObjectArgumentInitialization(Args[0], /*Qualifier=*/nullptr,
12410  Best->FoundDecl, Method);
12411  if (Arg0.isInvalid())
12412  return ExprError();
12413  Args[0] = Arg0.get();
12414 
12415  // Convert the arguments.
12416  ExprResult InputInit
12418  Context,
12419  FnDecl->getParamDecl(0)),
12420  SourceLocation(),
12421  Args[1]);
12422  if (InputInit.isInvalid())
12423  return ExprError();
12424 
12425  Args[1] = InputInit.getAs<Expr>();
12426 
12427  // Build the actual expression node.
12428  DeclarationNameInfo OpLocInfo(OpName, LLoc);
12429  OpLocInfo.setCXXOperatorNameRange(SourceRange(LLoc, RLoc));
12430  ExprResult FnExpr = CreateFunctionRefExpr(*this, FnDecl,
12431  Best->FoundDecl,
12432  Base,
12433  HadMultipleCandidates,
12434  OpLocInfo.getLoc(),
12435  OpLocInfo.getInfo());
12436  if (FnExpr.isInvalid())
12437  return ExprError();
12438 
12439  // Determine the result type
12440  QualType ResultTy = FnDecl->getReturnType();
12442  ResultTy = ResultTy.getNonLValueExprType(Context);
12443 
12444  CXXOperatorCallExpr *TheCall =
12445  new (Context) CXXOperatorCallExpr(Context, OO_Subscript,
12446  FnExpr.get(), Args,
12447  ResultTy, VK, RLoc,
12448  FPOptions());
12449 
12450  if (CheckCallReturnType(FnDecl->getReturnType(), LLoc, TheCall, FnDecl))
12451  return ExprError();
12452 
12453  if (CheckFunctionCall(Method, TheCall,
12454  Method->getType()->castAs<FunctionProtoType>()))
12455  return ExprError();
12456 
12457  return MaybeBindToTemporary(TheCall);
12458  } else {
12459  // We matched a built-in operator. Convert the arguments, then
12460  // break out so that we will build the appropriate built-in
12461  // operator node.
12462  ExprResult ArgsRes0 =
12463  PerformImplicitConversion(Args[0], Best->BuiltinParamTypes[0],
12464  Best->Conversions[0], AA_Passing);
12465  if (ArgsRes0.isInvalid())
12466  return ExprError();
12467  Args[0] = ArgsRes0.get();
12468 
12469  ExprResult ArgsRes1 =
12470  PerformImplicitConversion(Args[1], Best->BuiltinParamTypes[1],
12471  Best->Conversions[1], AA_Passing);
12472  if (ArgsRes1.isInvalid())
12473  return ExprError();
12474  Args[1] = ArgsRes1.get();
12475 
12476  break;
12477  }
12478  }
12479 
12480  case OR_No_Viable_Function: {
12481  if (CandidateSet.empty())
12482  Diag(LLoc, diag::err_ovl_no_oper)
12483  << Args[0]->getType() << /*subscript*/ 0
12484  << Args[0]->getSourceRange() << Args[1]->getSourceRange();
12485  else
12486  Diag(LLoc, diag::err_ovl_no_viable_subscript)
12487  << Args[0]->getType()
12488  << Args[0]->getSourceRange() << Args[1]->getSourceRange();
12489  CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args,
12490  "[]", LLoc);
12491  return ExprError();
12492  }
12493 
12494  case OR_Ambiguous:
12495  Diag(LLoc, diag::err_ovl_ambiguous_oper_binary)
12496  << "[]"
12497  << Args[0]->getType() << Args[1]->getType()
12498  << Args[0]->getSourceRange() << Args[1]->getSourceRange();
12499  CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, Args,
12500  "[]", LLoc);
12501  return ExprError();
12502 
12503  case OR_Deleted:
12504  Diag(LLoc, diag::err_ovl_deleted_oper)
12505  << Best->Function->isDeleted() << "[]"
12506  << getDeletedOrUnavailableSuffix(Best->Function)
12507  << Args[0]->getSourceRange() << Args[1]->getSourceRange();
12508  CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args,
12509  "[]", LLoc);
12510  return ExprError();
12511  }
12512 
12513  // We matched a built-in operator; build it.
12514  return CreateBuiltinArraySubscriptExpr(Args[0], LLoc, Args[1], RLoc);
12515 }
12516 
12517 /// BuildCallToMemberFunction - Build a call to a member
12518 /// function. MemExpr is the expression that refers to the member
12519 /// function (and includes the object parameter), Args/NumArgs are the
12520 /// arguments to the function call (not including the object
12521 /// parameter). The caller needs to validate that the member
12522 /// expression refers to a non-static member function or an overloaded
12523 /// member function.
12524 ExprResult
12526  SourceLocation LParenLoc,
12527  MultiExprArg Args,
12528  SourceLocation RParenLoc) {
12529  assert(MemExprE->getType() == Context.BoundMemberTy ||
12530  MemExprE->getType() == Context.OverloadTy);
12531 
12532  // Dig out the member expression. This holds both the object
12533  // argument and the member function we're referring to.
12534  Expr *NakedMemExpr = MemExprE->IgnoreParens();
12535 
12536  // Determine whether this is a call to a pointer-to-member function.
12537  if (BinaryOperator *op = dyn_cast<BinaryOperator>(NakedMemExpr)) {
12538  assert(op->getType() == Context.BoundMemberTy);
12539  assert(op->getOpcode() == BO_PtrMemD || op->getOpcode() == BO_PtrMemI);
12540 
12541  QualType fnType =
12542  op->getRHS()->getType()->castAs<MemberPointerType>()->getPointeeType();
12543 
12544  const FunctionProtoType *proto = fnType->castAs<FunctionProtoType>();
12545  QualType resultType = proto->getCallResultType(Context);
12547 
12548  // Check that the object type isn't more qualified than the
12549  // member function we're calling.
12550  Qualifiers funcQuals = Qualifiers::fromCVRMask(proto->getTypeQuals());
12551 
12552  QualType objectType = op->getLHS()->getType();
12553  if (op->getOpcode() == BO_PtrMemI)
12554  objectType = objectType->castAs<PointerType>()->getPointeeType();
12555  Qualifiers objectQuals = objectType.getQualifiers();
12556 
12557  Qualifiers difference = objectQuals - funcQuals;
12558  difference.removeObjCGCAttr();
12559  difference.removeAddressSpace();
12560  if (difference) {
12561  std::string qualsString = difference.getAsString();
12562  Diag(LParenLoc, diag::err_pointer_to_member_call_drops_quals)
12563  << fnType.getUnqualifiedType()
12564  << qualsString
12565  << (qualsString.find(' ') == std::string::npos ? 1 : 2);
12566  }
12567 
12568  CXXMemberCallExpr *call
12569  = new (Context) CXXMemberCallExpr(Context, MemExprE, Args,
12570  resultType, valueKind, RParenLoc);
12571 
12572  if (CheckCallReturnType(proto->getReturnType(), op->getRHS()->getLocStart(),
12573  call, nullptr))
12574  return ExprError();
12575 
12576  if (ConvertArgumentsForCall(call, op, nullptr, proto, Args, RParenLoc))
12577  return ExprError();
12578 
12579  if (CheckOtherCall(call, proto))
12580  return ExprError();
12581 
12582  return MaybeBindToTemporary(call);
12583  }
12584 
12585  if (isa<CXXPseudoDestructorExpr>(NakedMemExpr))
12586  return new (Context)
12587  CallExpr(Context, MemExprE, Args, Context.VoidTy, VK_RValue, RParenLoc);
12588 
12589  UnbridgedCastsSet UnbridgedCasts;
12590  if (checkArgPlaceholdersForOverload(*this, Args, UnbridgedCasts))
12591  return ExprError();
12592 
12593  MemberExpr *MemExpr;
12594  CXXMethodDecl *Method = nullptr;
12595  DeclAccessPair FoundDecl = DeclAccessPair::make(nullptr, AS_public);
12596  NestedNameSpecifier *Qualifier = nullptr;
12597  if (isa<MemberExpr>(NakedMemExpr)) {
12598  MemExpr = cast<MemberExpr>(NakedMemExpr);
12599  Method = cast<CXXMethodDecl>(MemExpr->getMemberDecl());
12600  FoundDecl = MemExpr->getFoundDecl();
12601  Qualifier = MemExpr->getQualifier();
12602  UnbridgedCasts.restore();
12603  } else {
12604  UnresolvedMemberExpr *UnresExpr = cast<UnresolvedMemberExpr>(NakedMemExpr);
12605  Qualifier = UnresExpr->getQualifier();
12606 
12607  QualType ObjectType = UnresExpr->getBaseType();
12608  Expr::Classification ObjectClassification
12610  : UnresExpr->getBase()->Classify(Context);
12611 
12612  // Add overload candidates
12613  OverloadCandidateSet CandidateSet(UnresExpr->getMemberLoc(),
12615 
12616  // FIXME: avoid copy.
12617  TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
12618  if (UnresExpr->hasExplicitTemplateArgs()) {
12619  UnresExpr->copyTemplateArgumentsInto(TemplateArgsBuffer);
12620  TemplateArgs = &TemplateArgsBuffer;
12621  }
12622 
12623  for (UnresolvedMemberExpr::decls_iterator I = UnresExpr->decls_begin(),
12624  E = UnresExpr->decls_end(); I != E; ++I) {
12625 
12626  NamedDecl *Func = *I;
12627  CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(Func->getDeclContext());
12628  if (isa<UsingShadowDecl>(Func))
12629  Func = cast<UsingShadowDecl>(Func)->getTargetDecl();
12630 
12631 
12632  // Microsoft supports direct constructor calls.
12633  if (getLangOpts().MicrosoftExt && isa<CXXConstructorDecl>(Func)) {
12634  AddOverloadCandidate(cast<CXXConstructorDecl>(Func), I.getPair(),
12635  Args, CandidateSet);
12636  } else if ((Method = dyn_cast<CXXMethodDecl>(Func))) {
12637  // If explicit template arguments were provided, we can't call a
12638  // non-template member function.
12639  if (TemplateArgs)
12640  continue;
12641 
12642  AddMethodCandidate(Method, I.getPair(), ActingDC, ObjectType,
12643  ObjectClassification, Args, CandidateSet,
12644  /*SuppressUserConversions=*/false);
12645  } else {
12647  cast<FunctionTemplateDecl>(Func), I.getPair(), ActingDC,
12648  TemplateArgs, ObjectType, ObjectClassification, Args, CandidateSet,
12649  /*SuppressUsedConversions=*/false);
12650  }
12651  }
12652 
12653  DeclarationName DeclName = UnresExpr->getMemberName();
12654 
12655  UnbridgedCasts.restore();
12656 
12658  switch (CandidateSet.BestViableFunction(*this, UnresExpr->getLocStart(),
12659  Best)) {
12660  case OR_Success:
12661  Method = cast<CXXMethodDecl>(Best->Function);
12662  FoundDecl = Best->FoundDecl;
12663  CheckUnresolvedMemberAccess(UnresExpr, Best->FoundDecl);
12664  if (DiagnoseUseOfDecl(Best->FoundDecl, UnresExpr->getNameLoc()))
12665  return ExprError();
12666  // If FoundDecl is different from Method (such as if one is a template
12667  // and the other a specialization), make sure DiagnoseUseOfDecl is
12668  // called on both.
12669  // FIXME: This would be more comprehensively addressed by modifying
12670  // DiagnoseUseOfDecl to accept both the FoundDecl and the decl
12671  // being used.
12672  if (Method != FoundDecl.getDecl() &&
12673  DiagnoseUseOfDecl(Method, UnresExpr->getNameLoc()))
12674  return ExprError();
12675  break;
12676 
12677  case OR_No_Viable_Function:
12678  Diag(UnresExpr->getMemberLoc(),
12679  diag::err_ovl_no_viable_member_function_in_call)
12680  << DeclName << MemExprE->getSourceRange();
12681  CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args);
12682  // FIXME: Leaking incoming expressions!
12683  return ExprError();
12684 
12685  case OR_Ambiguous:
12686  Diag(UnresExpr->getMemberLoc(), diag::err_ovl_ambiguous_member_call)
12687  << DeclName << MemExprE->getSourceRange();
12688  CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args);
12689  // FIXME: Leaking incoming expressions!
12690  return ExprError();
12691 
12692  case OR_Deleted:
12693  Diag(UnresExpr->getMemberLoc(), diag::err_ovl_deleted_member_call)
12694  << Best->Function->isDeleted()
12695  << DeclName
12696  << getDeletedOrUnavailableSuffix(Best->Function)
12697  << MemExprE->getSourceRange();
12698  CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args);
12699  // FIXME: Leaking incoming expressions!
12700  return ExprError();
12701  }
12702 
12703  MemExprE = FixOverloadedFunctionReference(MemExprE, FoundDecl, Method);
12704 
12705  // If overload resolution picked a static member, build a
12706  // non-member call based on that function.
12707  if (Method->isStatic()) {
12708  return BuildResolvedCallExpr(MemExprE, Method, LParenLoc, Args,
12709  RParenLoc);
12710  }
12711 
12712  MemExpr = cast<MemberExpr>(MemExprE->IgnoreParens());
12713  }
12714 
12715  QualType ResultType = Method->getReturnType();
12716  ExprValueKind VK = Expr::getValueKindForType(ResultType);
12717  ResultType = ResultType.getNonLValueExprType(Context);
12718 
12719  assert(Method && "Member call to something that isn't a method?");
12720  CXXMemberCallExpr *TheCall =
12721  new (Context) CXXMemberCallExpr(Context, MemExprE, Args,
12722  ResultType, VK, RParenLoc);
12723 
12724  // Check for a valid return type.
12725  if (CheckCallReturnType(Method->getReturnType(), MemExpr->getMemberLoc(),
12726  TheCall, Method))
12727  return ExprError();
12728 
12729  // Convert the object argument (for a non-static member function call).
12730  // We only need to do this if there was actually an overload; otherwise
12731  // it was done at lookup.
12732  if (!Method->isStatic()) {
12733  ExprResult ObjectArg =
12734  PerformObjectArgumentInitialization(MemExpr->getBase(), Qualifier,
12735  FoundDecl, Method);
12736  if (ObjectArg.isInvalid())
12737  return ExprError();
12738  MemExpr->setBase(ObjectArg.get());
12739  }
12740 
12741  // Convert the rest of the arguments
12742  const FunctionProtoType *Proto =
12743  Method->getType()->getAs<FunctionProtoType>();
12744  if (ConvertArgumentsForCall(TheCall, MemExpr, Method, Proto, Args,
12745  RParenLoc))
12746  return ExprError();
12747 
12748  DiagnoseSentinelCalls(Method, LParenLoc, Args);
12749 
12750  if (CheckFunctionCall(Method, TheCall, Proto))
12751  return ExprError();
12752 
12753  // In the case the method to call was not selected by the overloading
12754  // resolution process, we still need to handle the enable_if attribute. Do
12755  // that here, so it will not hide previous -- and more relevant -- errors.
12756  if (auto *MemE = dyn_cast<MemberExpr>(NakedMemExpr)) {
12757  if (const EnableIfAttr *Attr = CheckEnableIf(Method, Args, true)) {
12758  Diag(MemE->getMemberLoc(),
12759  diag::err_ovl_no_viable_member_function_in_call)
12760  << Method << Method->getSourceRange();
12761  Diag(Method->getLocation(),
12762  diag::note_ovl_candidate_disabled_by_function_cond_attr)
12763  << Attr->getCond()->getSourceRange() << Attr->getMessage();
12764  return ExprError();
12765  }
12766  }
12767 
12768  if ((isa<CXXConstructorDecl>(CurContext) ||
12769  isa<CXXDestructorDecl>(CurContext)) &&
12770  TheCall->getMethodDecl()->isPure()) {
12771  const CXXMethodDecl *MD = TheCall->getMethodDecl();
12772 
12773  if (isa<CXXThisExpr>(MemExpr->getBase()->IgnoreParenCasts()) &&
12774  MemExpr->performsVirtualDispatch(getLangOpts())) {
12775  Diag(MemExpr->getLocStart(),
12776  diag::warn_call_to_pure_virtual_member_function_from_ctor_dtor)
12777  << MD->getDeclName() << isa<CXXDestructorDecl>(CurContext)
12778  << MD->getParent()->getDeclName();
12779 
12780  Diag(MD->getLocStart(), diag::note_previous_decl) << MD->getDeclName();
12781  if (getLangOpts().AppleKext)
12782  Diag(MemExpr->getLocStart(),
12783  diag::note_pure_qualified_call_kext)
12784  << MD->getParent()->getDeclName()
12785  << MD->getDeclName();
12786  }
12787  }
12788 
12789  if (CXXDestructorDecl *DD =
12790  dyn_cast<CXXDestructorDecl>(TheCall->getMethodDecl())) {
12791  // a->A::f() doesn't go through the vtable, except in AppleKext mode.
12792  bool CallCanBeVirtual = !MemExpr->hasQualifier() || getLangOpts().AppleKext;
12793  CheckVirtualDtorCall(DD, MemExpr->getLocStart(), /*IsDelete=*/false,
12794  CallCanBeVirtual, /*WarnOnNonAbstractTypes=*/true,
12795  MemExpr->getMemberLoc());
12796  }
12797 
12798  return MaybeBindToTemporary(TheCall);
12799 }
12800 
12801 /// BuildCallToObjectOfClassType - Build a call to an object of class
12802 /// type (C++ [over.call.object]), which can end up invoking an
12803 /// overloaded function call operator (@c operator()) or performing a
12804 /// user-defined conversion on the object argument.
12805 ExprResult
12807  SourceLocation LParenLoc,
12808  MultiExprArg Args,
12809  SourceLocation RParenLoc) {
12810  if (checkPlaceholderForOverload(*this, Obj))
12811  return ExprError();
12812  ExprResult Object = Obj;
12813 
12814  UnbridgedCastsSet UnbridgedCasts;
12815  if (checkArgPlaceholdersForOverload(*this, Args, UnbridgedCasts))
12816  return ExprError();
12817 
12818  assert(Object.get()->getType()->isRecordType() &&
12819  "Requires object type argument");
12820  const RecordType *Record = Object.get()->getType()->getAs<RecordType>();
12821 
12822  // C++ [over.call.object]p1:
12823  // If the primary-expression E in the function call syntax
12824  // evaluates to a class object of type "cv T", then the set of
12825  // candidate functions includes at least the function call
12826  // operators of T. The function call operators of T are obtained by
12827  // ordinary lookup of the name operator() in the context of
12828  // (E).operator().
12829  OverloadCandidateSet CandidateSet(LParenLoc,
12832 
12833  if (RequireCompleteType(LParenLoc, Object.get()->getType(),
12834  diag::err_incomplete_object_call, Object.get()))
12835  return true;
12836 
12837  LookupResult R(*this, OpName, LParenLoc, LookupOrdinaryName);
12838  LookupQualifiedName(R, Record->getDecl());
12839  R.suppressDiagnostics();
12840 
12841  for (LookupResult::iterator Oper = R.begin(), OperEnd = R.end();
12842  Oper != OperEnd; ++Oper) {
12843  AddMethodCandidate(Oper.getPair(), Object.get()->getType(),
12844  Object.get()->Classify(Context), Args, CandidateSet,
12845  /*SuppressUserConversions=*/false);
12846  }
12847 
12848  // C++ [over.call.object]p2:
12849  // In addition, for each (non-explicit in C++0x) conversion function
12850  // declared in T of the form
12851  //
12852  // operator conversion-type-id () cv-qualifier;
12853  //
12854  // where cv-qualifier is the same cv-qualification as, or a
12855  // greater cv-qualification than, cv, and where conversion-type-id
12856  // denotes the type "pointer to function of (P1,...,Pn) returning
12857  // R", or the type "reference to pointer to function of
12858  // (P1,...,Pn) returning R", or the type "reference to function
12859  // of (P1,...,Pn) returning R", a surrogate call function [...]
12860  // is also considered as a candidate function. Similarly,
12861  // surrogate call functions are added to the set of candidate
12862  // functions for each conversion function declared in an
12863  // accessible base class provided the function is not hidden
12864  // within T by another intervening declaration.
12865  const auto &Conversions =
12866  cast<CXXRecordDecl>(Record->getDecl())->getVisibleConversionFunctions();
12867  for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
12868  NamedDecl *D = *I;
12869  CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext());
12870  if (isa<UsingShadowDecl>(D))
12871  D = cast<UsingShadowDecl>(D)->getTargetDecl();
12872 
12873  // Skip over templated conversion functions; they aren't
12874  // surrogates.
12875  if (isa<FunctionTemplateDecl>(D))
12876  continue;
12877 
12878  CXXConversionDecl *Conv = cast<CXXConversionDecl>(D);
12879  if (!Conv->isExplicit()) {
12880  // Strip the reference type (if any) and then the pointer type (if
12881  // any) to get down to what might be a function type.
12882  QualType ConvType = Conv->getConversionType().getNonReferenceType();
12883  if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>())
12884  ConvType = ConvPtrType->getPointeeType();
12885 
12886  if (const FunctionProtoType *Proto = ConvType->getAs<FunctionProtoType>())
12887  {
12888  AddSurrogateCandidate(Conv, I.getPair(), ActingContext, Proto,
12889  Object.get(), Args, CandidateSet);
12890  }
12891  }
12892  }
12893 
12894  bool HadMultipleCandidates = (CandidateSet.size() > 1);
12895 
12896  // Perform overload resolution.
12898  switch (CandidateSet.BestViableFunction(*this, Object.get()->getLocStart(),
12899  Best)) {
12900  case OR_Success:
12901  // Overload resolution succeeded; we'll build the appropriate call
12902  // below.
12903  break;
12904 
12905  case OR_No_Viable_Function:
12906  if (CandidateSet.empty())
12907  Diag(Object.get()->getLocStart(), diag::err_ovl_no_oper)
12908  << Object.get()->getType() << /*call*/ 1
12909  << Object.get()->getSourceRange();
12910  else
12911  Diag(Object.get()->getLocStart(),
12912  diag::err_ovl_no_viable_object_call)
12913  << Object.get()->getType() << Object.get()->getSourceRange();
12914  CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args);
12915  break;
12916 
12917  case OR_Ambiguous:
12918  Diag(Object.get()->getLocStart(),
12919  diag::err_ovl_ambiguous_object_call)
12920  << Object.get()->getType() << Object.get()->getSourceRange();
12921  CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, Args);
12922  break;
12923 
12924  case OR_Deleted:
12925  Diag(Object.get()->getLocStart(),
12926  diag::err_ovl_deleted_object_call)
12927  << Best->Function->isDeleted()
12928  << Object.get()->getType()
12929  << getDeletedOrUnavailableSuffix(Best->Function)
12930  << Object.get()->getSourceRange();
12931  CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args);
12932  break;
12933  }
12934 
12935  if (Best == CandidateSet.end())
12936  return true;
12937 
12938  UnbridgedCasts.restore();
12939 
12940  if (Best->Function == nullptr) {
12941  // Since there is no function declaration, this is one of the
12942  // surrogate candidates. Dig out the conversion function.
12943  CXXConversionDecl *Conv
12944  = cast<CXXConversionDecl>(
12945  Best->Conversions[0].UserDefined.ConversionFunction);
12946 
12947  CheckMemberOperatorAccess(LParenLoc, Object.get(), nullptr,
12948  Best->FoundDecl);
12949  if (DiagnoseUseOfDecl(Best->FoundDecl, LParenLoc))
12950  return ExprError();
12951  assert(Conv == Best->FoundDecl.getDecl() &&
12952  "Found Decl & conversion-to-functionptr should be same, right?!");
12953  // We selected one of the surrogate functions that converts the
12954  // object parameter to a function pointer. Perform the conversion
12955  // on the object argument, then let ActOnCallExpr finish the job.
12956 
12957  // Create an implicit member expr to refer to the conversion operator.
12958  // and then call it.
12959  ExprResult Call = BuildCXXMemberCallExpr(Object.get(), Best->FoundDecl,
12960  Conv, HadMultipleCandidates);
12961  if (Call.isInvalid())
12962  return ExprError();
12963  // Record usage of conversion in an implicit cast.
12964  Call = ImplicitCastExpr::Create(Context, Call.get()->getType(),
12965  CK_UserDefinedConversion, Call.get(),
12966  nullptr, VK_RValue);
12967 
12968  return ActOnCallExpr(S, Call.get(), LParenLoc, Args, RParenLoc);
12969  }
12970 
12971  CheckMemberOperatorAccess(LParenLoc, Object.get(), nullptr, Best->FoundDecl);
12972 
12973  // We found an overloaded operator(). Build a CXXOperatorCallExpr
12974  // that calls this method, using Object for the implicit object
12975  // parameter and passing along the remaining arguments.
12976  CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
12977 
12978  // An error diagnostic has already been printed when parsing the declaration.
12979  if (Method->isInvalidDecl())
12980  return ExprError();
12981 
12982  const FunctionProtoType *Proto =
12983  Method->getType()->getAs<FunctionProtoType>();
12984 
12985  unsigned NumParams = Proto->getNumParams();
12986 
12987  DeclarationNameInfo OpLocInfo(
12988  Context.DeclarationNames.getCXXOperatorName(OO_Call), LParenLoc);
12989  OpLocInfo.setCXXOperatorNameRange(SourceRange(LParenLoc, RParenLoc));
12990  ExprResult NewFn = CreateFunctionRefExpr(*this, Method, Best->FoundDecl,
12991  Obj, HadMultipleCandidates,
12992  OpLocInfo.getLoc(),
12993  OpLocInfo.getInfo());
12994  if (NewFn.isInvalid())
12995  return true;
12996 
12997  // Build the full argument list for the method call (the implicit object
12998  // parameter is placed at the beginning of the list).
12999  SmallVector<Expr *, 8> MethodArgs(Args.size() + 1);
13000  MethodArgs[0] = Object.get();
13001  std::copy(Args.begin(), Args.end(), MethodArgs.begin() + 1);
13002 
13003  // Once we've built TheCall, all of the expressions are properly
13004  // owned.
13005  QualType ResultTy = Method->getReturnType();
13007  ResultTy = ResultTy.getNonLValueExprType(Context);
13008 
13009  CXXOperatorCallExpr *TheCall = new (Context)
13010  CXXOperatorCallExpr(Context, OO_Call, NewFn.get(), MethodArgs, ResultTy,
13011  VK, RParenLoc, FPOptions());
13012 
13013  if (CheckCallReturnType(Method->getReturnType(), LParenLoc, TheCall, Method))
13014  return true;
13015 
13016  // We may have default arguments. If so, we need to allocate more
13017  // slots in the call for them.
13018  if (Args.size() < NumParams)
13019  TheCall->setNumArgs(Context, NumParams + 1);
13020 
13021  bool IsError = false;
13022 
13023  // Initialize the implicit object parameter.
13024  ExprResult ObjRes =
13025  PerformObjectArgumentInitialization(Object.get(), /*Qualifier=*/nullptr,
13026  Best->FoundDecl, Method);
13027  if (ObjRes.isInvalid())
13028  IsError = true;
13029  else
13030  Object = ObjRes;
13031  TheCall->setArg(0, Object.get());
13032 
13033  // Check the argument types.
13034  for (unsigned i = 0; i != NumParams; i++) {
13035  Expr *Arg;
13036  if (i < Args.size()) {
13037  Arg = Args[i];
13038 
13039  // Pass the argument.
13040 
13041  ExprResult InputInit
13043  Context,
13044  Method->getParamDecl(i)),
13045  SourceLocation(), Arg);
13046 
13047  IsError |= InputInit.isInvalid();
13048  Arg = InputInit.getAs<Expr>();
13049  } else {
13050  ExprResult DefArg
13051  = BuildCXXDefaultArgExpr(LParenLoc, Method, Method->getParamDecl(i));
13052  if (DefArg.isInvalid()) {
13053  IsError = true;
13054  break;
13055  }
13056 
13057  Arg = DefArg.getAs<Expr>();
13058  }
13059 
13060  TheCall->setArg(i + 1, Arg);
13061  }
13062 
13063  // If this is a variadic call, handle args passed through "...".
13064  if (Proto->isVariadic()) {
13065  // Promote the arguments (C99 6.5.2.2p7).
13066  for (unsigned i = NumParams, e = Args.size(); i < e; i++) {
13068  nullptr);
13069  IsError |= Arg.isInvalid();
13070  TheCall->setArg(i + 1, Arg.get());
13071  }
13072  }
13073 
13074  if (IsError) return true;
13075 
13076  DiagnoseSentinelCalls(Method, LParenLoc, Args);
13077 
13078  if (CheckFunctionCall(Method, TheCall, Proto))
13079  return true;
13080 
13081  return MaybeBindToTemporary(TheCall);
13082 }
13083 
13084 /// BuildOverloadedArrowExpr - Build a call to an overloaded @c operator->
13085 /// (if one exists), where @c Base is an expression of class type and
13086 /// @c Member is the name of the member we're trying to find.
13087 ExprResult
13089  bool *NoArrowOperatorFound) {
13090  assert(Base->getType()->isRecordType() &&
13091  "left-hand side must have class type");
13092 
13093  if (checkPlaceholderForOverload(*this, Base))
13094  return ExprError();
13095 
13096  SourceLocation Loc = Base->getExprLoc();
13097 
13098  // C++ [over.ref]p1:
13099  //
13100  // [...] An expression x->m is interpreted as (x.operator->())->m
13101  // for a class object x of type T if T::operator->() exists and if
13102  // the operator is selected as the best match function by the
13103  // overload resolution mechanism (13.3).
13104  DeclarationName OpName =
13107  const RecordType *BaseRecord = Base->getType()->getAs<RecordType>();
13108 
13109  if (RequireCompleteType(Loc, Base->getType(),
13110  diag::err_typecheck_incomplete_tag, Base))
13111  return ExprError();
13112 
13113  LookupResult R(*this, OpName, OpLoc, LookupOrdinaryName);
13114  LookupQualifiedName(R, BaseRecord->getDecl());
13115  R.suppressDiagnostics();
13116 
13117  for (LookupResult::iterator Oper = R.begin(), OperEnd = R.end();
13118  Oper != OperEnd; ++Oper) {
13119  AddMethodCandidate(Oper.getPair(), Base->getType(), Base->Classify(Context),
13120  None, CandidateSet, /*SuppressUserConversions=*/false);
13121  }
13122 
13123  bool HadMultipleCandidates = (CandidateSet.size() > 1);
13124 
13125  // Perform overload resolution.
13127  switch (CandidateSet.BestViableFunction(*this, OpLoc, Best)) {
13128  case OR_Success:
13129  // Overload resolution succeeded; we'll build the call below.
13130  break;
13131 
13132  case OR_No_Viable_Function:
13133  if (CandidateSet.empty()) {
13134  QualType BaseType = Base->getType();
13135  if (NoArrowOperatorFound) {
13136  // Report this specific error to the caller instead of emitting a
13137  // diagnostic, as requested.
13138  *NoArrowOperatorFound = true;
13139  return ExprError();
13140  }
13141  Diag(OpLoc, diag::err_typecheck_member_reference_arrow)
13142  << BaseType << Base->getSourceRange();
13143  if (BaseType->isRecordType() && !BaseType->isPointerType()) {
13144  Diag(OpLoc, diag::note_typecheck_member_reference_suggestion)
13145  << FixItHint::CreateReplacement(OpLoc, ".");
13146  }
13147  } else
13148  Diag(OpLoc, diag::err_ovl_no_viable_oper)
13149  << "operator->" << Base->getSourceRange();
13150  CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Base);
13151  return ExprError();
13152 
13153  case OR_Ambiguous:
13154  Diag(OpLoc, diag::err_ovl_ambiguous_oper_unary)
13155  << "->" << Base->getType() << Base->getSourceRange();
13156  CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, Base);
13157  return ExprError();
13158 
13159  case OR_Deleted:
13160  Diag(OpLoc, diag::err_ovl_deleted_oper)
13161  << Best->Function->isDeleted()
13162  << "->"
13163  << getDeletedOrUnavailableSuffix(Best->Function)
13164  << Base->getSourceRange();
13165  CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Base);
13166  return ExprError();
13167  }
13168 
13169  CheckMemberOperatorAccess(OpLoc, Base, nullptr, Best->FoundDecl);
13170 
13171  // Convert the object parameter.
13172  CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
13174  PerformObjectArgumentInitialization(Base, /*Qualifier=*/nullptr,
13175  Best->FoundDecl, Method);
13176  if (BaseResult.isInvalid())
13177  return ExprError();
13178  Base = BaseResult.get();
13179 
13180  // Build the operator call.
13181  ExprResult FnExpr = CreateFunctionRefExpr(*this, Method, Best->FoundDecl,
13182  Base, HadMultipleCandidates, OpLoc);
13183  if (FnExpr.isInvalid())
13184  return ExprError();
13185 
13186  QualType ResultTy = Method->getReturnType();
13188  ResultTy = ResultTy.getNonLValueExprType(Context);
13189  CXXOperatorCallExpr *TheCall =
13190  new (Context) CXXOperatorCallExpr(Context, OO_Arrow, FnExpr.get(),
13191  Base, ResultTy, VK, OpLoc, FPOptions());
13192 
13193  if (CheckCallReturnType(Method->getReturnType(), OpLoc, TheCall, Method))
13194  return ExprError();
13195 
13196  if (CheckFunctionCall(Method, TheCall,
13197  Method->getType()->castAs<FunctionProtoType>()))
13198  return ExprError();
13199 
13200  return MaybeBindToTemporary(TheCall);
13201 }
13202 
13203 /// BuildLiteralOperatorCall - Build a UserDefinedLiteral by creating a call to
13204 /// a literal operator described by the provided lookup results.
13206  DeclarationNameInfo &SuffixInfo,
13207  ArrayRef<Expr*> Args,
13208  SourceLocation LitEndLoc,
13209  TemplateArgumentListInfo *TemplateArgs) {
13210  SourceLocation UDSuffixLoc = SuffixInfo.getCXXLiteralOperatorNameLoc();
13211 
13212  OverloadCandidateSet CandidateSet(UDSuffixLoc,
13214  AddFunctionCandidates(R.asUnresolvedSet(), Args, CandidateSet, TemplateArgs,
13215  /*SuppressUserConversions=*/true);
13216 
13217  bool HadMultipleCandidates = (CandidateSet.size() > 1);
13218 
13219  // Perform overload resolution. This will usually be trivial, but might need
13220  // to perform substitutions for a literal operator template.
13222  switch (CandidateSet.BestViableFunction(*this, UDSuffixLoc, Best)) {
13223  case OR_Success:
13224  case OR_Deleted:
13225  break;
13226 
13227  case OR_No_Viable_Function:
13228  Diag(UDSuffixLoc, diag::err_ovl_no_viable_function_in_call)
13229  << R.getLookupName();
13230  CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args);
13231  return ExprError();
13232 
13233  case OR_Ambiguous:
13234  Diag(R.getNameLoc(), diag::err_ovl_ambiguous_call) << R.getLookupName();
13235  CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, Args);
13236  return ExprError();
13237  }
13238 
13239  FunctionDecl *FD = Best->Function;
13240  ExprResult Fn = CreateFunctionRefExpr(*this, FD, Best->FoundDecl,
13241  nullptr, HadMultipleCandidates,
13242  SuffixInfo.getLoc(),
13243  SuffixInfo.getInfo());
13244  if (Fn.isInvalid())
13245  return true;
13246 
13247  // Check the argument types. This should almost always be a no-op, except
13248  // that array-to-pointer decay is applied to string literals.
13249  Expr *ConvArgs[2];
13250  for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
13253  SourceLocation(), Args[ArgIdx]);
13254  if (InputInit.isInvalid())
13255  return true;
13256  ConvArgs[ArgIdx] = InputInit.get();
13257  }
13258 
13259  QualType ResultTy = FD->getReturnType();
13261  ResultTy = ResultTy.getNonLValueExprType(Context);
13262 
13263  UserDefinedLiteral *UDL =
13264  new (Context) UserDefinedLiteral(Context, Fn.get(),
13265  llvm::makeArrayRef(ConvArgs, Args.size()),
13266  ResultTy, VK, LitEndLoc, UDSuffixLoc);
13267 
13268  if (CheckCallReturnType(FD->getReturnType(), UDSuffixLoc, UDL, FD))
13269  return ExprError();
13270 
13271  if (CheckFunctionCall(FD, UDL, nullptr))
13272  return ExprError();
13273 
13274  return MaybeBindToTemporary(UDL);
13275 }
13276 
13277 /// Build a call to 'begin' or 'end' for a C++11 for-range statement. If the
13278 /// given LookupResult is non-empty, it is assumed to describe a member which
13279 /// will be invoked. Otherwise, the function will be found via argument
13280 /// dependent lookup.
13281 /// CallExpr is set to a valid expression and FRS_Success returned on success,
13282 /// otherwise CallExpr is set to ExprError() and some non-success value
13283 /// is returned.
13286  SourceLocation RangeLoc,
13287  const DeclarationNameInfo &NameInfo,
13288  LookupResult &MemberLookup,
13289  OverloadCandidateSet *CandidateSet,
13290  Expr *Range, ExprResult *CallExpr) {
13291  Scope *S = nullptr;
13292 
13293  CandidateSet->clear();
13294  if (!MemberLookup.empty()) {
13295  ExprResult MemberRef =
13296  BuildMemberReferenceExpr(Range, Range->getType(), Loc,
13297  /*IsPtr=*/false, CXXScopeSpec(),
13298  /*TemplateKWLoc=*/SourceLocation(),
13299  /*FirstQualifierInScope=*/nullptr,
13300  MemberLookup,
13301  /*TemplateArgs=*/nullptr, S);
13302  if (MemberRef.isInvalid()) {
13303  *CallExpr = ExprError();
13304  return FRS_DiagnosticIssued;
13305  }
13306  *CallExpr = ActOnCallExpr(S, MemberRef.get(), Loc, None, Loc, nullptr);
13307  if (CallExpr->isInvalid()) {
13308  *CallExpr = ExprError();
13309  return FRS_DiagnosticIssued;
13310  }
13311  } else {
13312  UnresolvedSet<0> FoundNames;
13313  UnresolvedLookupExpr *Fn =
13314  UnresolvedLookupExpr::Create(Context, /*NamingClass=*/nullptr,
13315  NestedNameSpecifierLoc(), NameInfo,
13316  /*NeedsADL=*/true, /*Overloaded=*/false,
13317  FoundNames.begin(), FoundNames.end());
13318 
13319  bool CandidateSetError = buildOverloadedCallSet(S, Fn, Fn, Range, Loc,
13320  CandidateSet, CallExpr);
13321  if (CandidateSet->empty() || CandidateSetError) {
13322  *CallExpr = ExprError();
13323  return FRS_NoViableFunction;
13324  }
13326  OverloadingResult OverloadResult =
13327  CandidateSet->BestViableFunction(*this, Fn->getLocStart(), Best);
13328 
13329  if (OverloadResult == OR_No_Viable_Function) {
13330  *CallExpr = ExprError();
13331  return FRS_NoViableFunction;
13332  }
13333  *CallExpr = FinishOverloadedCallExpr(*this, S, Fn, Fn, Loc, Range,
13334  Loc, nullptr, CandidateSet, &Best,
13335  OverloadResult,
13336  /*AllowTypoCorrection=*/false);
13337  if (CallExpr->isInvalid() || OverloadResult != OR_Success) {
13338  *CallExpr = ExprError();
13339  return FRS_DiagnosticIssued;
13340  }
13341  }
13342  return FRS_Success;
13343 }
13344 
13345 
13346 /// FixOverloadedFunctionReference - E is an expression that refers to
13347 /// a C++ overloaded function (possibly with some parentheses and
13348 /// perhaps a '&' around it). We have resolved the overloaded function
13349 /// to the function declaration Fn, so patch up the expression E to
13350 /// refer (possibly indirectly) to Fn. Returns the new expr.
13352  FunctionDecl *Fn) {
13353  if (ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
13354  Expr *SubExpr = FixOverloadedFunctionReference(PE->getSubExpr(),
13355  Found, Fn);
13356  if (SubExpr == PE->getSubExpr())
13357  return PE;
13358 
13359  return new (Context) ParenExpr(PE->getLParen(), PE->getRParen(), SubExpr);
13360  }
13361 
13362  if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
13363  Expr *SubExpr = FixOverloadedFunctionReference(ICE->getSubExpr(),
13364  Found, Fn);
13365  assert(Context.hasSameType(ICE->getSubExpr()->getType(),
13366  SubExpr->getType()) &&
13367  "Implicit cast type cannot be determined from overload");
13368  assert(ICE->path_empty() && "fixing up hierarchy conversion?");
13369  if (SubExpr == ICE->getSubExpr())
13370  return ICE;
13371 
13372  return ImplicitCastExpr::Create(Context, ICE->getType(),
13373  ICE->getCastKind(),
13374  SubExpr, nullptr,
13375  ICE->getValueKind());
13376  }
13377 
13378  if (auto *GSE = dyn_cast<GenericSelectionExpr>(E)) {
13379  if (!GSE->isResultDependent()) {
13380  Expr *SubExpr =
13381  FixOverloadedFunctionReference(GSE->getResultExpr(), Found, Fn);
13382  if (SubExpr == GSE->getResultExpr())
13383  return GSE;
13384 
13385  // Replace the resulting type information before rebuilding the generic
13386  // selection expression.
13387  ArrayRef<Expr *> A = GSE->getAssocExprs();
13388  SmallVector<Expr *, 4> AssocExprs(A.begin(), A.end());
13389  unsigned ResultIdx = GSE->getResultIndex();
13390  AssocExprs[ResultIdx] = SubExpr;
13391 
13392  return new (Context) GenericSelectionExpr(
13393  Context, GSE->getGenericLoc(), GSE->getControllingExpr(),
13394  GSE->getAssocTypeSourceInfos(), AssocExprs, GSE->getDefaultLoc(),
13395  GSE->getRParenLoc(), GSE->containsUnexpandedParameterPack(),
13396  ResultIdx);
13397  }
13398  // Rather than fall through to the unreachable, return the original generic
13399  // selection expression.
13400  return GSE;
13401  }
13402 
13403  if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(E)) {
13404  assert(UnOp->getOpcode() == UO_AddrOf &&
13405  "Can only take the address of an overloaded function");
13406  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) {
13407  if (Method->isStatic()) {
13408  // Do nothing: static member functions aren't any different
13409  // from non-member functions.
13410  } else {
13411  // Fix the subexpression, which really has to be an
13412  // UnresolvedLookupExpr holding an overloaded member function
13413  // or template.
13414  Expr *SubExpr = FixOverloadedFunctionReference(UnOp->getSubExpr(),
13415  Found, Fn);
13416  if (SubExpr == UnOp->getSubExpr())
13417  return UnOp;
13418 
13419  assert(isa<DeclRefExpr>(SubExpr)
13420  && "fixed to something other than a decl ref");
13421  assert(cast<DeclRefExpr>(SubExpr)->getQualifier()
13422  && "fixed to a member ref with no nested name qualifier");
13423 
13424  // We have taken the address of a pointer to member
13425  // function. Perform the computation here so that we get the
13426  // appropriate pointer to member type.
13427  QualType ClassType
13428  = Context.getTypeDeclType(cast<RecordDecl>(Method->getDeclContext()));
13429  QualType MemPtrType
13430  = Context.getMemberPointerType(Fn->getType(), ClassType.getTypePtr());
13431  // Under the MS ABI, lock down the inheritance model now.
13433  (void)isCompleteType(UnOp->getOperatorLoc(), MemPtrType);
13434 
13435  return new (Context) UnaryOperator(SubExpr, UO_AddrOf, MemPtrType,
13437  UnOp->getOperatorLoc());
13438  }
13439  }
13440  Expr *SubExpr = FixOverloadedFunctionReference(UnOp->getSubExpr(),
13441  Found, Fn);
13442  if (SubExpr == UnOp->getSubExpr())
13443  return UnOp;
13444 
13445  return new (Context) UnaryOperator(SubExpr, UO_AddrOf,
13446  Context.getPointerType(SubExpr->getType()),
13448  UnOp->getOperatorLoc());
13449  }
13450 
13451  // C++ [except.spec]p17:
13452  // An exception-specification is considered to be needed when:
13453  // - in an expression the function is the unique lookup result or the
13454  // selected member of a set of overloaded functions
13455  if (auto *FPT = Fn->getType()->getAs<FunctionProtoType>())
13456  ResolveExceptionSpec(E->getExprLoc(), FPT);
13457 
13458  if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
13459  // FIXME: avoid copy.
13460  TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
13461  if (ULE->hasExplicitTemplateArgs()) {
13462  ULE->copyTemplateArgumentsInto(TemplateArgsBuffer);
13463  TemplateArgs = &TemplateArgsBuffer;
13464  }
13465 
13467  ULE->getQualifierLoc(),
13468  ULE->getTemplateKeywordLoc(),
13469  Fn,
13470  /*enclosing*/ false, // FIXME?
13471  ULE->getNameLoc(),
13472  Fn->getType(),
13473  VK_LValue,
13474  Found.getDecl(),
13475  TemplateArgs);
13476  MarkDeclRefReferenced(DRE);
13477  DRE->setHadMultipleCandidates(ULE->getNumDecls() > 1);
13478  return DRE;
13479  }
13480 
13481  if (UnresolvedMemberExpr *MemExpr = dyn_cast<UnresolvedMemberExpr>(E)) {
13482  // FIXME: avoid copy.
13483  TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
13484  if (MemExpr->hasExplicitTemplateArgs()) {
13485  MemExpr->copyTemplateArgumentsInto(TemplateArgsBuffer);
13486  TemplateArgs = &TemplateArgsBuffer;
13487  }
13488 
13489  Expr *Base;
13490 
13491  // If we're filling in a static method where we used to have an
13492  // implicit member access, rewrite to a simple decl ref.
13493  if (MemExpr->isImplicitAccess()) {
13494  if (cast<CXXMethodDecl>(Fn)->isStatic()) {
13496  MemExpr->getQualifierLoc(),
13497  MemExpr->getTemplateKeywordLoc(),
13498  Fn,
13499  /*enclosing*/ false,
13500  MemExpr->getMemberLoc(),
13501  Fn->getType(),
13502  VK_LValue,
13503  Found.getDecl(),
13504  TemplateArgs);
13505  MarkDeclRefReferenced(DRE);
13506  DRE->setHadMultipleCandidates(MemExpr->getNumDecls() > 1);
13507  return DRE;
13508  } else {
13509  SourceLocation Loc = MemExpr->getMemberLoc();
13510  if (MemExpr->getQualifier())
13511  Loc = MemExpr->getQualifierLoc().getBeginLoc();
13512  CheckCXXThisCapture(Loc);
13513  Base = new (Context) CXXThisExpr(Loc,
13514  MemExpr->getBaseType(),
13515  /*isImplicit=*/true);
13516  }
13517  } else
13518  Base = MemExpr->getBase();
13519 
13520  ExprValueKind valueKind;
13521  QualType type;
13522  if (cast<CXXMethodDecl>(Fn)->isStatic()) {
13523  valueKind = VK_LValue;
13524  type = Fn->getType();
13525  } else {
13526  valueKind = VK_RValue;
13527  type = Context.BoundMemberTy;
13528  }
13529 
13531  Context, Base, MemExpr->isArrow(), MemExpr->getOperatorLoc(),
13532  MemExpr->getQualifierLoc(), MemExpr->getTemplateKeywordLoc(), Fn, Found,
13533  MemExpr->getMemberNameInfo(), TemplateArgs, type, valueKind,
13534  OK_Ordinary);
13535  ME->setHadMultipleCandidates(true);
13537  return ME;
13538  }
13539 
13540  llvm_unreachable("Invalid reference to overloaded function");
13541 }
13542 
13544  DeclAccessPair Found,
13545  FunctionDecl *Fn) {
13546  return FixOverloadedFunctionReference(E.get(), Found, Fn);
13547 }
Abstract class used to diagnose incomplete types.
Definition: Sema.h:1454
Kind getKind() const
Definition: Type.h:2105
unsigned ExplicitCallArguments
The number of call arguments that were explicitly provided, to be used while performing partial order...
Definition: Overload.h:674
bool hasObjCGCAttr() const
Definition: Type.h:287
A call to an overloaded operator written using operator syntax.
Definition: ExprCXX.h:52
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
Definition: Expr.h:2474
bool compatiblyIncludesObjCLifetime(Qualifiers other) const
Determines if these qualifiers compatibly include another set of qualifiers from the narrow perspecti...
Definition: Type.h:484
int getFloatingTypeOrder(QualType LHS, QualType RHS) const
Compare the rank of the two specified floating point types, ignoring the domain of the type (i...
void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const
Copies the template arguments into the given structure.
Definition: ExprCXX.h:2630
void setValueDependent(bool VD)
Set whether this expression is value-dependent or not.
Definition: Expr.h:151
bool isObjCObjectOrInterfaceType() const
Definition: Type.h:5790
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 getNumInits() const
Definition: Expr.h:3878
unsigned DeprecatedStringLiteralToCharPtr
Whether this is the deprecated conversion of a string literal to a pointer to non-const character dat...
Definition: Overload.h:161
Qualifiers getLocalQualifiers() const
Retrieve the set of qualifiers local to this particular QualType instance, not including any qualifie...
Definition: Type.h:5508
SmallVector< TemplateSpecCandidate, 16 >::iterator iterator
(CUDA) This candidate was not viable because the callee was not accessible from the caller's target (...
Definition: Overload.h:601
CanQualType LongLongTy
Definition: ASTContext.h:971
FunctionDecl - An instance of this class is created to represent a function declaration or definition...
Definition: Decl.h:1618
bool isMSVCRTEntryPoint() const
Determines whether this function is a MSVCRT user defined entry point.
Definition: Decl.cpp:2634
bool isVariadic() const
Definition: Type.h:3442
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:6818
static void markUnaddressableCandidatesUnviable(Sema &S, OverloadCandidateSet &CS)
bool isNullPtrType() const
Definition: Type.h:5919
void removeUnaligned()
Definition: Type.h:284
StringRef getName() const
getName - Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:237
ExprResult PerformContextuallyConvertToBool(Expr *From)
PerformContextuallyConvertToBool - Perform a contextual conversion of the expression From to bool (C+...
QualType getNonTypeTemplateArgumentType() const
If this is a non-type template argument, get its type.
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.
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...
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2224
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:5643
A (possibly-)qualified type.
Definition: Type.h:616
bool hasExplicitTemplateArgs() const
Determines whether this expression had explicit template arguments.
Definition: ExprCXX.h:2610
static void DiagnoseArityMismatch(Sema &S, NamedDecl *Found, Decl *D, unsigned NumFormalArgs)
General arity mismatch diagnosis over a candidate in a candidate set.
TemplateDeductionResult
Describes the result of template argument deduction.
Definition: Sema.h:6772
bool isInvalid() const
Definition: Ownership.h:159
TemplateDecl * getDescribedTemplate() const
If this is a declaration that describes some template, this method returns that template declaration...
Definition: DeclBase.cpp:211
ImplicitConversionKind
ImplicitConversionKind - The kind of implicit conversion used to convert an argument to a parameter's...
Definition: Overload.h:60
QualType getCallResultType(const ASTContext &Context) const
Determine the type of an expression that calls a function of this type.
Definition: Type.h:3081
bool isCharType() const
Definition: Type.cpp:1694
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
QualType getConversionType() const
Returns the type that this conversion function is converting to.
Definition: DeclCXX.h:2637
Conversion not allowed by the C standard, but that we accept as an extension anyway.
Definition: Overload.h:106
specific_attr_iterator< T > specific_attr_begin() const
Definition: DeclBase.h:510
static bool IsTransparentUnionStandardConversion(Sema &S, Expr *From, QualType &ToType, bool InOverloadResolution, StandardConversionSequence &SCS, bool CStyle)
EnableIfAttr * CheckEnableIf(FunctionDecl *Function, ArrayRef< Expr * > Args, bool MissingImplicitThis=false)
Check the enable_if expressions on the given function.
bool isMemberPointerType() const
Definition: Type.h:5736
bool isUnavailable(std::string *Message=nullptr) const
Determine whether this declaration is marked 'unavailable'.
Definition: DeclBase.h:659
Template argument deduction was successful.
Definition: Sema.h:6774
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:2954
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
Definition: Type.h:1803
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:970
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type...
Definition: Type.cpp:2618
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:1804
const LangOptions & getLangOpts() const
Definition: Sema.h:1166
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...
A structure used to record information about a failed template argument deduction, for diagnosis.
Checking non-dependent argument conversions failed.
Definition: Sema.h:6814
static UnresolvedLookupExpr * Create(const ASTContext &C, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool ADL, bool Overloaded, UnresolvedSetIterator Begin, UnresolvedSetIterator End)
Definition: ExprCXX.h:2703
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
void dump() const
dump - Print this standard conversion sequence to standard error.
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...
Cannot tell whether this is a narrowing conversion because the expression is value-dependent.
Definition: Overload.h:130
SourceLocation getCXXLiteralOperatorNameLoc() const
getCXXLiteralOperatorNameLoc - Returns the location of the literal operator name (not the operator ke...
bool isAnyCharacterType() const
Determine whether this type is any of the built-in character types.
Definition: Type.cpp:1724
static void AddBuiltinAssignmentOperatorCandidates(Sema &S, QualType T, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet)
Helper function for AddBuiltinOperatorCandidates() that adds the volatile- and non-volatile-qualified...
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:2923
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
bool isMain() const
Determines whether this function is "main", which is the entry point into an executable program...
Definition: Decl.cpp:2626
Provides information about an attempted template argument deduction, whose success or failure was des...
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type...
unsigned getIntWidth(QualType T) const
Vector conversions.
Definition: Overload.h:79
void clear()
Clear out all of the candidates.
ActionResult< Expr * > ExprResult
Definition: Ownership.h:252
ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param)
BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating the default expr if needed...
Definition: SemaExpr.cpp:4566
Complex conversions (C99 6.3.1.6)
Definition: Overload.h:72
void setObjCLifetime(ObjCLifetime type)
Definition: Type.h:312
bool hasPlaceholderType() const
Returns whether this expression has a placeholder type.
Definition: Expr.h:469
std::string getTemplateArgumentBindingsText(const TemplateParameterList *Params, const TemplateArgumentList &Args)
Produces a formatted string that describes the binding of template parameters to template arguments...
NestedNameSpecifier * getQualifier() const
If the member name was qualified, retrieves the nested-name-specifier that precedes the member name...
Definition: Expr.h:2503
static InitializedEntity InitializeParameter(ASTContext &Context, const ParmVarDecl *Parm)
Create the initialization entity for a parameter.
bool isRecordType() const
Definition: Type.h:5769
UserDefinedConversionSequence UserDefined
When ConversionKind == UserDefinedConversion, provides the details of the user-defined conversion seq...
Definition: Overload.h:430
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1243
ConstructorInfo getConstructorInfo(NamedDecl *ND)
Definition: Overload.h:864
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:81
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:47
__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.
bool isSpecializationCopyingObject() const
Determine whether this is a member template specialization that would copy the object to itself...
Definition: DeclCXX.cpp:2088
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)
AssignConvertType
AssignConvertType - All of the 'assignment' semantic checks return this enum to indicate whether the ...
Definition: Sema.h:9246
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
Definition: ExprCXX.h:2655
void AddBuiltinCandidate(QualType *ParamTys, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool IsAssignmentOperator=false, unsigned NumContextualBoolArguments=0)
AddBuiltinCandidate - Add a candidate for a built-in operator.
ExprResult PerformContextualImplicitConversion(SourceLocation Loc, Expr *FromE, ContextualImplicitConverter &Converter)
Perform a contextual implicit conversion.
QualType getVolatileType(QualType T) const
Return the uniqued reference to the type for a volatile qualified type.
Definition: ASTContext.h:1101
bool IsOverload(FunctionDecl *New, FunctionDecl *Old, bool IsForUsingDecl, bool ConsiderCudaAttrs=true)
StringRef P
Not a narrowing conversion.
Definition: Overload.h:116
llvm::iterator_range< conversion_iterator > getVisibleConversionFunctions()
Get all conversion functions visible in current class, including conversion function templates...
Definition: DeclCXX.cpp:1293
bool isEnumeralType() const
Definition: Type.h:5772
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:1662
bool CanPerformCopyInitialization(const InitializedEntity &Entity, ExprResult Init)
Definition: SemaInit.cpp:8265
ImplicitConversionRank
ImplicitConversionRank - The rank of an implicit conversion kind.
Definition: Overload.h:97
bool hasDefinition() const
Definition: DeclCXX.h:702
std::string getAsString() const
Definition: Type.h:942
static void NoteFunctionCandidate(Sema &S, OverloadCandidate *Cand, unsigned NumArgs, bool TakingCandidateAddress)
Generates a 'note' diagnostic for an overload candidate.
PtrTy get() const
Definition: Ownership.h:163
ExprResult CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc, Expr *Idx, SourceLocation RLoc)
Definition: SemaExpr.cpp:4312
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type...
RefQualifierKind getRefQualifier() const
Retrieve the ref-qualifier associated with this method.
Definition: DeclCXX.h:2052
bool hasErrorOccurred() const
Determine whether any SFINAE errors have been trapped.
Definition: Sema.h:7392
QualType getPointeeType() const
Definition: Type.h:2461
static void CompleteNonViableCandidate(Sema &S, OverloadCandidate *Cand, ArrayRef< Expr * > Args)
CompleteNonViableCandidate - Normally, overload resolution only computes up to the first bad conversi...
The base class of the type hierarchy.
Definition: Type.h:1303
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:1009
CanQualType LongTy
Definition: ASTContext.h:971
iterator begin() const
Definition: Lookup.h:321
unsigned IncompatibleObjC
IncompatibleObjC - Whether this is an Objective-C conversion that we should warn about (if we actuall...
Definition: Overload.h:169
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
Definition: Type.h:5522
QualType getRecordType(const RecordDecl *Decl) const
ForRangeStatus
Definition: Sema.h:2854
NamespaceDecl - Represent a C++ namespace.
Definition: Decl.h:461
Template argument deduction produced inconsistent deduced values for the given template parameter...
Definition: Sema.h:6785
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:392
Ambiguous candidates found.
Definition: Overload.h:43
bool isBooleanType() const
Definition: Type.h:5969
bool compatiblyIncludes(Qualifiers other) const
Determines if these qualifiers compatibly include another set.
Definition: Type.h:463
Conversions between compatible types in C99.
Definition: Overload.h:77
Floating point control options.
Definition: LangOptions.h:203
bool isBlockPointerType() const
Definition: Type.h:5718
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's conversion, which for this function...
Definition: Overload.h:666
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:2329
float __ovld __cnfn distance(float p0, float p1)
Returns the distance between p0 and p1.
static unsigned RankDeductionFailure(const DeductionFailureInfo &DFI)
void * getAsOpaquePtr() const
Definition: Type.h:664
Exact Match.
Definition: Overload.h:98
void ArgumentDependentLookup(DeclarationName Name, SourceLocation Loc, ArrayRef< Expr * > Args, ADLResult &Functions)
static bool isFunctionAlwaysEnabled(const ASTContext &Ctx, const FunctionDecl *FD)
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:10497
QualType getRestrictType(QualType T) const
Return the uniqued reference to the type for a restrict qualified type.
Definition: ASTContext.h:1092
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
Definition: SemaInternal.h:25
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 ...
void removeObjCLifetime()
Definition: Type.h:315
DiagnosticsEngine & Diags
Definition: Sema.h:307
ObjCLifetime getObjCLifetime() const
Definition: Type.h:309
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...
CanQualType Float128Ty
Definition: ASTContext.h:974
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)
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...
std::string getAsString() const
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:303
bool isSpecialized() const
Whether this type is specialized, meaning that it has type arguments.
Definition: Type.h:5312
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:1924
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:113
QualType getThisType(ASTContext &C) const
Returns the type of the this pointer.
Definition: DeclCXX.cpp:1845
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:377
QualType ExtractUnqualifiedFunctionType(QualType PossiblyAFunctionType)
unsigned size() const
bool HadMultipleCandidates
HadMultipleCandidates - When this is true, it means that the conversion function was resolved from an...
Definition: Overload.h:276
Like System, but searched after the system directories.
Decl * Specialization
Specialization - The actual specialization that this candidate represents.
void getAsStringInternal(std::string &Str, const PrintingPolicy &Policy) const
Definition: Type.h:967
const BuiltinType * getAsPlaceholderType() const
Definition: Type.h:5886
bool IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType)
IsIntegralPromotion - Determines whether the conversion from the expression From (whose potentially-a...
unsigned param_size() const
Definition: DeclObjC.h:348
std::vector< FixItHint > Hints
The list of Hints generated so far.
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1434
QualType getBaseType() const
Definition: ExprCXX.h:3427
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:3209
bool isMoveAssignmentOperator() const
Determine whether this is a move assignment operator.
Definition: DeclCXX.cpp:1793
Defines the clang::Expr interface and subclasses for C++ expressions.
TemplateParameter Param
The template parameter to which a template argument deduction failure refers.
bool isEmpty() const
No scope specifier.
Definition: DeclSpec.h:189
bool isVoidType() const
Definition: Type.h:5906
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
bool isLValue() const
Definition: Expr.h:349
The collection of all-type qualifiers we support.
Definition: Type.h:118
FieldDecl * getSourceBitField()
If this expression refers to a bit-field, retrieve the declaration of that bit-field.
Definition: Expr.cpp:3366
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:5110
QualType getArrayDecayedType(QualType T) const
Return the properly qualified result of decaying the specified array type to a pointer.
OverloadCandidate & addCandidate(unsigned NumConversions=0, ConversionSequenceList Conversions=None)
Add a new candidate with NumConversions conversion sequence slots to the overload set...
Definition: Overload.h:823
ExprResult PerformImplicitConversion(Expr *From, QualType ToType, AssignmentAction Action, bool AllowExplicit=false)
PerformImplicitConversion - Perform an implicit conversion of the expression From to the type ToType...
ExprResult CreateOverloadedBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, const UnresolvedSetImpl &Fns, Expr *LHS, Expr *RHS)
Create a binary operation that may resolve to an overloaded operator.
unsigned getNumParams() const
Definition: Type.h:3338
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:3354
bool doFunctionTypesMatchOnExtParameterInfos(const FunctionProtoType *FromFunctionType, const FunctionProtoType *ToFunctionType)
bool hasUninstantiatedDefaultArg() const
Definition: Decl.h:1549
DeclarationName getMemberName() const
Retrieve the name of the member that this expression refers to.
Definition: ExprCXX.h:3449
Boolean conversions (C++ 4.12)
Definition: Overload.h:76
iterator end() const
Definition: Lookup.h:322
QualType apply(const ASTContext &Context, QualType QT) const
Apply the collected qualifiers to the given type.
Definition: Type.cpp:3209
bool hasAttr() const
Definition: DeclBase.h:521
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...
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
Definition: Decl.cpp:3314
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:128
A C++ nested-name-specifier augmented with source location information.
llvm::mapped_iterator< decltype(Decls)::iterator, select_second > iterator
Definition: Lookup.h:792
static bool diagnoseNoViableConversion(Sema &SemaRef, SourceLocation Loc, Expr *&From, Sema::ContextualImplicitConverter &Converter, QualType T, bool HadMultipleCandidates, UnresolvedSetImpl &ExplicitConversions)
unsigned BindsToFunctionLvalue
Whether we're binding to a function lvalue.
Definition: Overload.h:184
BadConversionSequence Bad
When ConversionKind == BadConversion, provides the details of the bad conversion. ...
Definition: Overload.h:438
bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base)
Determine whether the type Derived is a C++ class that is derived from the type Base.
bool isReferenceType() const
Definition: Type.h:5721
QualType getReturnType() const
Definition: Decl.h:2106
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2366
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
Definition: DeclTemplate.h:998
bool isAnyPointerType() const
Definition: Type.h:5715
Expr * getBase()
Retrieve the base object of this member expressions, e.g., the x in x.m.
Definition: ExprCXX.h:3418
Identity conversion (no conversion)
Definition: Overload.h:61
void AddBuiltinOperatorCandidates(OverloadedOperatorKind Op, SourceLocation OpLoc, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet)
AddBuiltinOperatorCandidates - Add the appropriate built-in operator overloads to the candidate set (...
void setNumArgs(const ASTContext &C, unsigned NumArgs)
setNumArgs - This changes the number of arguments present in this call.
Definition: Expr.cpp:1251
ConversionSet & conversions()
Definition: Overload.h:312
bool isPure() const
Whether this virtual function is pure, i.e.
Definition: Decl.h:1898
NameKind getKind() const
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.
QualType getToType() const
Definition: Overload.h:373
bool isPRValue() const
Definition: Expr.h:352
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 ...
unsigned getCVRQualifiers() const
Definition: Type.h:259
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:27
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:2103
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:158
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 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:2023
CompatiblePointerDiscardsQualifiers - The assignment discards c/v/r qualifiers, which we accept as an...
Definition: Sema.h:9274
const RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
Definition: Type.cpp:449
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...
Represents a C++ member access expression for which lookup produced a set of overloaded functions...
Definition: ExprCXX.h:3350
Ref_Incompatible - The two types are incompatible, so direct reference binding is not possible...
Definition: Sema.h:9494
FrontendAction * Action
Definition: Tooling.cpp:205
CUDAFunctionTarget IdentifyCUDATarget(const FunctionDecl *D, bool IgnoreImplicitHDAttr=false)
Determines whether the given function is a CUDA device/host/kernel/etc.
Definition: SemaCUDA.cpp:105
bool isOpenCLDisabledDecl(Decl *FD)
Definition: Sema.cpp:1661
ExprResult CreateOverloadedUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, const UnresolvedSetImpl &Fns, Expr *input)
Create a unary operation that may resolve to an overloaded operator.
ConversionSequenceList allocateConversionSequences(unsigned NumConversions)
Allocate storage for conversion sequences for NumConversions conversions.
Definition: Overload.h:810
void AddConversionCandidate(CXXConversionDecl *Conversion, DeclAccessPair FoundDecl, CXXRecordDecl *ActingContext, Expr *From, QualType ToType, OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit)
AddConversionCandidate - Add a C++ conversion function as a candidate in the candidate set (C++ [over...
ExprResult DefaultFunctionArrayConversion(Expr *E, bool Diagnose=true)
DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4).
Definition: SemaExpr.cpp:416
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:1295
SourceLocation getLocStart() const LLVM_READONLY
Definition: ExprCXX.h:3459
OverloadKind
C++ Overloading.
Definition: Sema.h:2450
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2128
Describes a module or submodule.
Definition: Module.h:57
OverloadCandidateDisplayKind
Definition: Overload.h:47
void NoteDeletedFunction(FunctionDecl *FD)
Emit a note explaining that this function is deleted.
Definition: SemaExpr.cpp:91
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:106
Floating point promotions (C++ 4.6)
Definition: Overload.h:68
Describes an C or C++ initializer list.
Definition: Expr.h:3848
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...
bool isIntegralOrUnscopedEnumerationType() const
Determine whether this type is an integral or unscoped enumeration type.
Definition: Type.cpp:1677
ImplicitConversionRank getRank() const
getRank - Retrieve the rank of this standard conversion sequence (C++ 13.3.3.1.1p3).
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:2424
bool isCompleteType(SourceLocation Loc, QualType T)
Definition: Sema.h:1585
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:555
Represents the results of name lookup.
Definition: Lookup.h:32
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:643
An lvalue ref-qualifier was provided (&).
Definition: Type.h:1262
unsigned BindsToRvalue
Whether we'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)
const LangOptions & getLangOpts() const
Definition: ASTContext.h:659
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:537
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:570
A convenient class for passing around template argument information.
Definition: TemplateBase.h:524
Module * getOwningModule(Decl *Entity)
Get the module owning an entity.
Definition: Sema.h:1522
CanProxy< U > getAs() const
Retrieve a canonical type pointer with a different static type, upcasting or downcasting as needed...
Ref_Compatible - The two types are reference-compatible.
Definition: Sema.h:9500
QualType getReturnType() const
Definition: Type.h:3065
unsigned getMinRequiredArguments() const
getMinRequiredArguments - Returns the minimum number of arguments needed to call this function...
Definition: Decl.cpp:2899
const CXXRecordDecl * getParent() const
Returns the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:2018
bool isDefaulted() const
Whether this function is defaulted per C++0x.
Definition: Decl.h:1914
unsigned QualificationIncludesObjCLifetime
Whether the qualification conversion involves a change in the Objective-C lifetime (for automatic ref...
Definition: Overload.h:165
field_range fields() const
Definition: Decl.h:3483
bool CheckCXXThisCapture(SourceLocation Loc, bool Explicit=false, bool BuildAndDiagnose=true, const unsigned *const FunctionScopeIndexToStopAt=nullptr, bool ByCopy=false)
Make sure the value of 'this' is actually available in the current context, if it is a potentially ev...
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
Definition: Type.cpp:3770
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:14601
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
static bool isRecordType(QualType T)
static bool IsAcceptableNonMemberOperatorCandidate(ASTContext &Context, FunctionDecl *Fn, ArrayRef< Expr * > Args)
IsAcceptableNonMemberOperatorCandidate - Determine whether Fn is an acceptable non-member overloaded ...
bool diagnoseArgIndependentDiagnoseIfAttrs(const NamedDecl *ND, SourceLocation Loc)
Emit diagnostics for the diagnose_if attributes on Function, ignoring any ArgDependent DiagnoseIfAttr...
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:2967
Substitution of the deduced template argument values resulted in an error.
Definition: Sema.h:6793
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.
This candidate function was not viable because an enable_if attribute disabled it.
Definition: Overload.h:605
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
Definition: Expr.h:148
A set of unresolved declarations.
Definition: UnresolvedSet.h:56
RecordDecl * getDecl() const
Definition: Type.h:3793
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
SourceLocation getTemplateKeywordLoc() const
Retrieve the location of the template keyword preceding this name, if any.
Definition: ExprCXX.h:2587
bool requiresADL() const
True if this declaration should be extended by argument-dependent lookup.
Definition: ExprCXX.h:2731
Template argument deduction exceeded the maximum template instantiation depth (which has already been...
Definition: Sema.h:6779
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...
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:1784
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's an rvalue reference binding).
Definition: Overload.h:181
CanQualType LongDoubleTy
Definition: ASTContext.h:974
Expr * IgnoreParenCasts() LLVM_READONLY
IgnoreParenCasts - Ignore parentheses and casts.
Definition: Expr.cpp:2399
bool isVariadic() const
Whether this function is variadic.
Definition: Decl.cpp:2555
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
void Destroy()
Free any memory associated with this deduction failure.
Qualification conversions (C++ 4.4)
Definition: Overload.h:66
static bool isBooleanType(QualType Ty)
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:63
TypeClass getTypeClass() const
Definition: Type.h:1555
void diagnoseEquivalentInternalLinkageDeclarations(SourceLocation Loc, const NamedDecl *D, ArrayRef< const NamedDecl * > Equiv)
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types...
Definition: Type.cpp:1930
bool hasConst() const
Definition: Type.h:237
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.
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...
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
Definition: Expr.cpp:748
ExprResult DefaultFunctionArrayLvalueConversion(Expr *E, bool Diagnose=true)
Definition: SemaExpr.cpp:633
#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...
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:7789
An ordinary object is located at an address in memory.
Definition: Specifiers.h:122
virtual SemaDiagnosticBuilder diagnoseIncomplete(Sema &S, SourceLocation Loc, QualType T)=0
Emits a diagnostic when the expression has incomplete class type.
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
Definition: Decl.cpp:3193
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 'begin' or 'end' 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:1108
ExprResult BuildMemberReferenceExpr(Expr *Base, QualType BaseType, SourceLocation OpLoc, bool IsArrow, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierInScope, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs, const Scope *S, ActOnMemberAccessExtraArgs *ExtraArgs=nullptr)
bool isExtVectorType() const
Definition: Type.h:5781
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
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.
bool empty() const
Definition: Type.h:395
detail::InMemoryDirectory::const_iterator I
IncompatiblePointerSign - The assignment is between two pointers types which point to integers which ...
Definition: Sema.h:9270
ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, LookupResult &R, bool NeedsADL, bool AcceptInvalidDecl=false)
Definition: SemaExpr.cpp:2721
Complex <-> Real conversion.
Definition: Overload.h:102
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
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:357
CanQualType UnsignedCharTy
Definition: ASTContext.h:972
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
QualType getType() const
Definition: Decl.h:589
bool isInvalid() const
const LangOptions & LangOpts
Definition: Sema.h:303
bool IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType)
Helper function to determine whether this is the (deprecated) C++ conversion from a string literal to...
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 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:139
const UnresolvedSetImpl & asUnresolvedSet() const
Definition: Lookup.h:317
AccessResult CheckUnresolvedMemberAccess(UnresolvedMemberExpr *E, DeclAccessPair FoundDecl)
Perform access-control checking on a previously-unresolved member access which has now been resolved ...
param_iterator param_begin()
Definition: Decl.h:2077
Represents the this expression in C++.
Definition: ExprCXX.h:888
C-only conversion between pointers with incompatible types.
Definition: Overload.h:88
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
EnumDecl * getDecl() const
Definition: Type.h:3816
bool IsComplexPromotion(QualType FromType, QualType ToType)
Determine if a conversion is a complex promotion.
RAII class used to determine whether SFINAE has trapped any errors that occur during template argumen...
Definition: Sema.h:7366
static bool hasDeprecatedStringLiteralToCharPtrConversion(const ImplicitConversionSequence &ICS)
specific_attr_iterator< T > specific_attr_end() const
Definition: DeclBase.h:514
CXXSpecialMember
Kinds of C++ special members.
Definition: Sema.h:1103
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
bool isStatic() const
Definition: DeclCXX.cpp:1552
OverloadFixItKind Kind
The type of fix applied.
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
Definition: Type.h:5402
DeductionFailureInfo DeductionFailure
Template argument deduction info.
ExtInfo getExtInfo() const
Definition: Type.h:3074
static void NoteAmbiguousUserConversions(Sema &S, SourceLocation OpLoc, OverloadCandidate *Cand)
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:269
bool isBetterOverloadCandidate(Sema &S, const OverloadCandidate &Cand1, const OverloadCandidate &Cand2, SourceLocation Loc, bool UserDefinedConversion=false)
isBetterOverloadCandidate - Determines whether the first overload candidate is a better candidate tha...
CanQualType getCanonicalTypeUnqualified() const
QualType getParamType(unsigned i) const
Definition: Type.h:3339
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3129
CXXMethodDecl * getMethodDecl() const
Retrieves the declaration of the called method.
Definition: ExprCXX.cpp:487
ExprResult CreateBuiltinBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr)
CreateBuiltinBinOp - Creates a new built-in binary operation with operator Opc at location TokLoc...
Definition: SemaExpr.cpp:11239
void erase(NamedDecl *D)
Removes any data associated with a given decl.
Definition: Lookup.h:787
Transparent Union Conversions.
Definition: Overload.h:83
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...
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx) const
EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy t...
CastKind
CastKind - The kind of operation required for a conversion.
The return type of classify().
Definition: Expr.h:300
param_type_iterator param_type_begin() const
Definition: Type.h:3468
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat)
Definition: Expr.cpp:1698
SourceLocation getLocEnd() const LLVM_READONLY
Definition: Stmt.cpp:270
void AddMemberOperatorCandidates(OverloadedOperatorKind Op, SourceLocation OpLoc, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, SourceRange OpRange=SourceRange())
Add overload candidates for overloaded operators that are member functions.
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:516
Template argument deduction did not deduce a value for every template parameter.
Definition: Sema.h:6782
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.
NamedDecl * getDecl() const
ASTContext * Context
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
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:793
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.
bool isMoreQualifiedThan(QualType Other) const
Determine whether this type is more qualified than the other given type, requiring exact equality for...
Definition: Type.h:5633
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:414
NameKind getNameKind() const
getNameKind - Determine what kind of name this is.
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...
bool hasUnaligned() const
Definition: Type.h:280
bool isRealFloatingType() const
Floating point categories.
Definition: Type.cpp:1837
bool hasVolatile() const
Definition: Type.h:244
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:132
bool isSignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...
Definition: Type.cpp:1760
Allows QualTypes to be sorted and hence used in maps and sets.
ObjC ARC writeback conversion.
Definition: Overload.h:103
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:1979
OpenCL Scalar Widening.
Definition: Overload.h:101
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:154
const Type * getTypeForDecl() const
Definition: Decl.h:2663
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:3070
unsigned getTypeQualifiers() const
Definition: DeclCXX.h:2037
void dump() const
dump - Print this user-defined conversion sequence to standard error.
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:5289
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
Definition: Type.h:5975
void addVolatile()
Definition: Type.h:249
Expr - This represents one expression.
Definition: Expr.h:105
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:1771
bool isQueueT() const
Definition: Type.h:5845
DeclarationName getLookupName() const
Gets the name to look up.
Definition: Lookup.h:249
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.
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:103
bool performsVirtualDispatch(const LangOptions &LO) const
Returns true if virtual dispatch is performed.
Definition: Expr.h:2607
Expr * stripARCUnbridgedCast(Expr *e)
stripARCUnbridgedCast - Given an expression of ARCUnbridgedCast type, remove the placeholder cast...
Qualifiers getQualifiers() const
Retrieve all qualifiers.
unsigned getNumArgs() const
This inherited constructor is not viable because it would slice the argument.
Definition: Overload.h:615
bool isAnyComplexType() const
Definition: Type.h:5775
bool isDeletedAsWritten() const
Definition: Decl.h:1980
void takeSFINAEDiagnostic(PartialDiagnosticAt &PD)
Take ownership of the SFINAE diagnostic.
bool isBeforeInTranslationUnit(SourceLocation LHS, SourceLocation RHS) const
Determines the order of 2 source locations in the translation unit.
When performing template argument deduction for a function template, there were too many call argumen...
Definition: Sema.h:6806
NestedNameSpecifierLoc getQualifierLoc() const
Fetches the nested-name qualifier with source-location information, if one was given.
Definition: ExprCXX.h:2583
bool isObjCClassType() const
Definition: Type.h:5813
decls_iterator decls_end() const
Definition: ExprCXX.h:2557
Declaration of a template type parameter.
SourceLocation getNameLoc() const
Gets the location of the name.
Definition: ExprCXX.h:2574
static FindResult find(Expr *E)
Finds the overloaded expression in the given expression E of OverloadTy.
Definition: ExprCXX.h:2529
StandardConversionSequence After
After - Represents the standard conversion that occurs after the actual user-defined conversion...
Definition: Overload.h:280
SourceLocation getNameLoc() const
Gets the location of the identifier.
Definition: Lookup.h:591
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context encloses the declaration context DC.
Definition: DeclBase.cpp:1080
SourceLocation getMemberLoc() const
Definition: ExprCXX.h:3453
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:169
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2551
Zero constant to queue.
Definition: Overload.h:86
SmallVectorImpl< OverloadCandidate >::iterator iterator
Definition: Overload.h:800
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]...
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:213
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:2088
static Qualifiers CollectVRQualifiers(ASTContext &Context, Expr *ArgExpr)
CollectVRQualifiers - This routine returns Volatile/Restrict qualifiers, if any, found in visible typ...
CXXConstructorDecl * CopyConstructor
CopyConstructor - The copy constructor that is used to perform this conversion, when the conversion i...
Definition: Overload.h:212
static bool completeFunctionType(Sema &S, FunctionDecl *FD, SourceLocation Loc, bool Complain=true)
DeclContext * getDeclContext()
Definition: DeclBase.h:416
Overload resolution succeeded.
Definition: Overload.h:41
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:6809
CanQualType ShortTy
Definition: ASTContext.h:971
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:15541
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
QualType getFromType() const
Definition: Overload.h:372
Classification Classify(ASTContext &Ctx) const
Classify - Classify this expression according to the C++11 expression taxonomy.
Definition: Expr.h:374
Represents a C++ template name within the type system.
Definition: TemplateName.h:176
Ref_Related - The two types are reference-related, which means that their unqualified forms (T1 and T...
Definition: Sema.h:9498
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:9491
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:7107
bool isObjCIdType() const
Definition: Type.h:5808
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:973
Specifies that a value-dependent expression of integral or dependent type should be considered a null...
Definition: Expr.h:699
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
QualType getFromType() const
Definition: Overload.h:226
static void collectViableConversionCandidates(Sema &SemaRef, Expr *From, QualType ToType, UnresolvedSetImpl &ViableConversions, OverloadCandidateSet &CandidateSet)
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
bool isScoped() const
Returns true if this is a C++11 scoped enumeration.
Definition: Decl.h:3277
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.
static bool TooManyArguments(size_t NumParams, size_t NumArgs, bool PartialOverloading=false)
To be used for checking whether the arguments being passed to function exceeds the number of paramete...
Definition: Sema.h:10436
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:1797
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:1294
bool isAtLeastAsQualifiedAs(CanQual< T > Other) const
Determines whether this canonical type is at least as qualified as the Other canonical type...
void AddFunctionCandidates(const UnresolvedSetImpl &Functions, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, TemplateArgumentListInfo *ExplicitTemplateArgs=nullptr, bool SuppressUserConversions=false, bool PartialOverloading=false)
Add all of the function declarations in the given function set to the overload candidate set...
static void DiagnoseOpenCLExtensionDisabled(Sema &S, OverloadCandidate *Cand)
QualType getObjCIdType() const
Represents the Objective-CC id type.
Definition: ASTContext.h:1724
bool resolveAndFixAddressOfOnlyViableOverloadCandidate(ExprResult &SrcExpr, bool DoFunctionPointerConversion=false)
Given an overloaded function, tries to turn it into a non-overloaded function reference using resolve...
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 const FunctionProtoType * tryGetFunctionProtoType(QualType FromType)
Attempts to get the FunctionProtoType from a Type.
virtual SemaDiagnosticBuilder noteExplicitConv(Sema &S, CXXConversionDecl *Conv, QualType ConvTy)=0
Emits a note for the explicit conversion function.
UnaryOperator - This represents the unary-expression's (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:1714
bool DeduceReturnType(FunctionDecl *FD, SourceLocation Loc, bool Diagnose=true)
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:2407
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
Definition: Decl.h:258
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
DiagnosticsEngine & getDiagnostics() const
Definition: Sema.h:1170
static bool CheckArityMismatch(Sema &S, OverloadCandidate *Cand, unsigned NumArgs)
Additional arity mismatch diagnosis specific to a function overload candidates.
After substituting deduced template arguments, a dependent parameter type did not match the correspon...
Definition: Sema.h:6796
bool isGLValue() const
Definition: Expr.h:251
Represents a C++ conversion function within a class.
Definition: DeclCXX.h:2605
QualType getCVRQualifiedType(QualType T, unsigned CVR) const
Return a type with additional const, volatile, or restrict qualifiers.
Definition: ASTContext.h:1799
The result type of a method or function.
CanQualType SignedCharTy
Definition: ASTContext.h:971
bool isExplicit() const
Whether this function is explicit.
Definition: DeclCXX.h:2632
bool isObjectType() const
Determine whether this type is an object type.
Definition: Type.h:1610
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:466
Lvalue-to-rvalue conversion (C++ 4.1)
Definition: Overload.h:62
decls_iterator decls_begin() const
Definition: ExprCXX.h:2556
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 ...
ArrayRef< ParmVarDecl * > parameters() const
Definition: DeclObjC.h:371
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)
bool isIdentityConversion() const
Definition: Overload.h:236
CanQualType OverloadTy
Definition: ASTContext.h:979
QualType getFromType() const
Definition: Overload.h:303
const Decl * FoundDecl
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
Definition: Expr.h:865
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
Complex promotions (Clang extension)
Definition: Overload.h:69
#define false
Definition: stdbool.h:33
ExprResult MaybeBindToTemporary(Expr *E)
MaybeBindToTemporary - If the passed in expression has a record type with a non-trivial destructor...
Assigning into this object requires the old value to be released and the new value to be retained...
Definition: Type.h:146
Kind
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr...
Definition: ExprCXX.h:2467
ImplicitConversionSequence - Represents an implicit conversion sequence, which may be a standard conv...
Definition: Overload.h:387
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
Definition: Type.h:5956
static bool checkAddressOfCandidateIsAvailable(Sema &S, const FunctionDecl *FD)
bool isVolatileQualified() const
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:199
Encodes a location in the source.
unsigned getNumParams() const
getNumParams - Return the number of parameters this function must have based on its FunctionType...
Definition: Decl.cpp:2878
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:5489
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:3810
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
Definition: TemplateBase.h:259
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...
QualType getElementType() const
Definition: Type.h:2176
CanQualType Int128Ty
Definition: ASTContext.h:971
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:5165
virtual SemaDiagnosticBuilder noteAmbiguous(Sema &S, CXXConversionDecl *Conv, QualType ConvTy)=0
Emits a note for one of the candidate conversions.
bool isValid() const
Return true if this is a valid SourceLocation object.
OverloadedOperatorKind getCXXOverloadedOperator() const
getCXXOverloadedOperator - If this name is the name of an overloadable operator in C++ (e...
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:424
Template argument deduction failed due to inconsistent cv-qualifiers on a template parameter type tha...
Definition: Sema.h:6790
Represents a call to a member function that may be written either with member call syntax (e...
Definition: ExprCXX.h:136
ASTContext & getASTContext() const
Definition: Sema.h:1173
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:9264
bool isVariadic() const
Definition: DeclObjC.h:418
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.
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...
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1903
bool isObjCBuiltinType() const
Definition: Type.h:5823
static void DiagnoseBadConversion(Sema &S, OverloadCandidate *Cand, unsigned I, bool TakingCandidateAddress)
void AddTemplateConversionCandidate(FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl, CXXRecordDecl *ActingContext, Expr *From, QualType ToType, OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit)
Adds a conversion function template specialization candidate to the overload set, using template argu...
ExprResult DefaultLvalueConversion(Expr *E)
Definition: SemaExpr.cpp:537
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
No ref-qualifier was provided.
Definition: Type.h:1260
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:2066
CanQualType FloatTy
Definition: ASTContext.h:974
Objective-C ARC writeback conversion.
Definition: Overload.h:84
bool DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType)
The declaration was invalid; do nothing.
Definition: Sema.h:6776
bool isIntegralType(const ASTContext &Ctx) const
Determine whether this type is an integral type.
Definition: Type.cpp:1663
static bool IsVectorConversion(Sema &S, QualType FromType, QualType ToType, ImplicitConversionKind &ICK)
Determine whether the conversion from FromType to ToType is a valid vector conversion.
void dump() const
dump - Print this implicit conversion sequence to standard error.
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...
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:703
CanQualType VoidTy
Definition: ASTContext.h:963
void addDecl(NamedDecl *D)
Definition: UnresolvedSet.h:83
TemplateDeductionResult DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, const TemplateArgumentList &TemplateArgs, sema::TemplateDeductionInfo &Info)
Perform template argument deduction to determine whether the given template arguments match the given...
llvm::Optional< unsigned > getCallArgIndex()
Return the index of the call argument that this deduction failure refers to, if any.
bool isStdInitializerListElement() const
Whether the target is really a std::initializer_list, and the sequence only represents the worst elem...
Definition: Overload.h:544
bool Matches
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
Lookup for candidates for a call using operator syntax.
Definition: Overload.h:733
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:2804
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs. ...
bool canBindObjCObjectType(QualType To, QualType From)
bool isRValue() const
Definition: Expr.h:353
CandidateSetKind getKind() const
Definition: Overload.h:789
QualType getToType(unsigned Idx) const
Definition: Overload.h:229
SourceLocation getBegin() const
Requests that all candidates be shown.
Definition: Overload.h:50
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6105
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:166
bool isArrow() const
Determine whether this member expression used the '->' operator; otherwise, it used the '...
Definition: ExprCXX.h:3435
bool isVectorType() const
Definition: Type.h:5778
unsigned HasDiagnostic
Indicates whether a diagnostic is stored in Diagnostic.
bool IsBuildingRecoveryCallExpr
Flag indicating if Sema is building a recovery call expression.
Definition: Sema.h:492
bool isPromotableIntegerType() const
More type predicates useful for type checking/promotion.
Definition: Type.cpp:2325
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's representation of template deduction information to the form used in overload-can...
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:1264
Assigning into this object requires a lifetime extension.
Definition: Type.h:152
void removeObjCGCAttr()
Definition: Type.h:292
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.cpp:1902
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:5559
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:262
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.
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 getPointeeType() const
Definition: Type.h:2238
CXXSpecialMember getSpecialMember(const CXXMethodDecl *MD)
getSpecialMember - get the special member enum for a method.
Definition: SemaDecl.cpp:2735
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...
CompoundAssignOperator - For compound assignments (e.g.
Definition: Expr.h:3167
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're trying to find.
ExprResult BuildCXXMemberCallExpr(Expr *Exp, NamedDecl *FoundDecl, CXXConversionDecl *Method, bool HadMultipleCandidates)
Represents a C11 generic selection.
Definition: Expr.h:4653
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:771
CanQualType UnsignedShortTy
Definition: ASTContext.h:972
void MarkMemberReferenced(MemberExpr *E)
Perform reference-marking and odr-use handling for a MemberExpr.
Definition: SemaExpr.cpp:14614
QualType getType() const
Definition: Expr.h:127
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:965
const TemplateArgument * getFirstArg()
Return the first template argument this deduction failure refers to, if any.
Represents a template argument.
Definition: TemplateBase.h:40
ExprResult PerformCopyInitialization(const InitializedEntity &Entity, SourceLocation EqualLoc, ExprResult Init, bool TopLevelOfInitList=false, bool AllowExplicit=false)
Definition: SemaInit.cpp:8280
void DiagnoseAmbiguousConversion(Sema &S, SourceLocation CaretLoc, const PartialDiagnostic &PDiag) const
Diagnoses an ambiguous conversion.
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 ...
QualType getAsType() const
Retrieve the type for a type template argument.
Definition: TemplateBase.h:235
iterator begin()
Definition: Lookup.h:794
DeclContextLookupResult LookupConstructors(CXXRecordDecl *Class)
Look up the constructors for the given class.
DeclAccessPair FoundCopyConstructor
Definition: Overload.h:213
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
Definition: Decl.cpp:3294
llvm::PointerUnion3< TemplateTypeParmDecl *, NonTypeTemplateParmDecl *, TemplateTemplateParmDecl * > TemplateParameter
Stores a template parameter of any kind.
Definition: DeclTemplate.h:40
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:2561
void CheckVirtualDtorCall(CXXDestructorDecl *dtor, SourceLocation Loc, bool IsDelete, bool CallCanBeVirtual, bool WarnOnNonAbstractTypes, SourceLocation DtorLoc)
StringRef getOpcodeStr() const
Definition: Expr.h:3027
A qualifier set is used to build a set of qualifiers.
Definition: Type.h:5455
Qualifiers withoutObjCLifetime() const
Definition: Type.h:302
UnaryOperatorKind
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1215
bool isAggregateType() const
Determines whether the type is a C++ aggregate type or C aggregate or union type. ...
Definition: Type.cpp:1906
CanQualType NullPtrTy
Definition: ASTContext.h:978
EvalResult is a struct with detailed info about an evaluated expression.
Definition: Expr.h:568
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...
StringRef Name
Definition: USRFinder.cpp:123
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:378
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
Definition: Lookup.h:259
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
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchers.h:2126
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 'Type', insert an implicit cast.
Definition: Sema.cpp:401
ConversionSet::const_iterator const_iterator
Definition: Overload.h:328
bool isXValue() const
Definition: Expr.h:350
static bool hasSimilarType(ASTContext &Context, QualType T1, QualType T2)
bool isInvalidDecl() const
Definition: DeclBase.h:532
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:9926
SourceLocation getLocStart() const LLVM_READONLY
Definition: ExprCXX.h:2741
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:203
CanQualType UnsignedLongLongTy
Definition: ASTContext.h:973
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:6803
const ObjCInterfaceType * getInterfaceType() const
If this pointer points to an Objective C @interface type, gets the type for that interface.
Definition: Type.cpp:1466
PartialDiagnosticAt * getSFINAEDiagnostic()
Retrieve the diagnostic which caused this deduction failure, if any.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
bool hasSFINAEDiagnostic() const
Is a SFINAE diagnostic available?
DeclarationName - The name of a declaration.
Expr * getDefaultArg()
Definition: Decl.cpp:2473
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 Type * strip(QualType type)
Collect any qualifiers on the given type and return an unqualified type.
Definition: Type.h:5462
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language...
Definition: Expr.h:248
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:679
param_type_iterator param_type_end() const
Definition: Type.h:3471
A set of unresolved declarations.
std::string getAsString(ASTContext &Ctx, QualType Ty) const
Definition: APValue.cpp:545
void setInstantiationDependent(bool ID)
Set whether this expression is instantiation-dependent or not.
Definition: Expr.h:195
SourceLocation getLocStart() const LLVM_READONLY
Definition: Decl.h:683
size_t param_size() const
Definition: Decl.h:2081
bool hasAttrs() const
Definition: DeclBase.h:462
Requests that only viable candidates be shown.
Definition: Overload.h:53
detail::InMemoryDirectory::const_iterator E
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
Definition: Sema.h:7328
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:2442
static void dropPointerConversion(StandardConversionSequence &SCS)
dropPointerConversions - If the given standard conversion sequence involves any pointer conversions...
const FunctionType * adjustFunctionType(const FunctionType *Fn, FunctionType::ExtInfo EInfo)
Change the ExtInfo on a function type.
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2087
static bool convertArgsForAvailabilityChecks(Sema &S, FunctionDecl *Function, Expr *ThisArg, ArrayRef< Expr * > Args, Sema::SFINAETrap &Trap, bool MissingImplicitThis, Expr *&ConvertedThis, SmallVectorImpl< Expr * > &ConvertedArgs)
bool isLValueReferenceType() const
Definition: Type.h:5724
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
OverloadCandidateKind
bool isFloat() const
Definition: APValue.h:184
unsigned getNumParams() const
Definition: Overload.h:709
bool isLambda() const
Determine whether this class describes a lambda function object.
Definition: DeclCXX.h:1102
void * Data
Opaque pointer containing additional data about this deduction failure.
bool isPointerConversionToBool() const
isPointerConversionToBool - Determines whether this conversion is a conversion of a pointer or pointe...
param_iterator param_end()
Definition: Decl.h:2078
bool isRValueReferenceType() const
Definition: Type.h:5727
void addConst()
Definition: Type.h:242
static void NoteSurrogateCandidate(Sema &S, OverloadCandidate *Cand)
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:5235
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:5662
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:5220
SourceLocation getMemberLoc() const
getMemberLoc - Return the location of the "member", in X->F, it is the location of 'F'...
Definition: Expr.h:2578
Pointer to a block type.
Definition: Type.h:2327
Conversion only allowed in the C standard.
Definition: Overload.h:104
bool empty() const
Return true if no decls were found.
Definition: Lookup.h:325
Not an overloaded operator.
Definition: OperatorKinds.h:23
QualType getLocalUnqualifiedType() const
Return this type with all of the instance-specific qualifiers removed, but without removing any quali...
Definition: Type.h:849
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:2599
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:3784
void setAllToTypes(QualType T)
Definition: Overload.h:220
Complex values, per C99 6.2.5p11.
Definition: Type.h:2164
QualType getPointerDiffType() const
Return the unique type for "ptrdiff_t" (C99 7.17) defined in <stddef.h>.
Expr * getUninstantiatedDefaultArg()
Definition: Decl.cpp:2515
CanQualType UnknownAnyTy
Definition: ASTContext.h:979
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:6042
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...
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy.
Definition: Sema.h:2100
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 ConvertArgumentsForCall(CallExpr *Call, Expr *Fn, FunctionDecl *FDecl, const FunctionProtoType *Proto, ArrayRef< Expr * > Args, SourceLocation RParenLoc, bool ExecConfig=false)
ConvertArgumentsForCall - Converts the arguments specified in Args/NumArgs to the parameter types of ...
Definition: SemaExpr.cpp:4660
unsigned getTypeQuals() const
Definition: Type.h:3454
QualType getCanonicalType() const
Definition: Type.h:5528
TemplateArgumentList * take()
Take ownership of the deduced template argument list.
CanQualType UnsignedLongTy
Definition: ASTContext.h:972
This candidate was not viable because its OpenCL extension is disabled.
Definition: Overload.h:611
ObjCInterfaceDecl * getInterfaceDecl() const
If this pointer points to an Objective @interface type, gets the declaration for that interface...
Definition: Type.h:5275
void addRestrict()
Definition: Type.h:256
unsigned getKindRank() const
Return a ranking of the implicit conversion sequence kind, where smaller ranks represent better conve...
Definition: Overload.h:481
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...
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:1281
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:979
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:966
bool isObjCQualifiedIdType() const
Definition: Type.h:5798
bool isFunctionType() const
Definition: Type.h:5709
DeclAccessPair FoundDecl
FoundDecl - The original declaration that was looked up / invented / otherwise found, together with its access.
Definition: Overload.h:634
bool isImplicitlyDeleted(FunctionDecl *FD)
Determine whether the given function is an implicitly-deleted special member function.
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2360
CanQualType BoundMemberTy
Definition: ASTContext.h:979
const DeclarationNameLoc & getInfo() const
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1548
AccessResult CheckMemberOperatorAccess(SourceLocation Loc, Expr *ObjectExpr, Expr *ArgExpr, DeclAccessPair FoundDecl)
Checks access to an overloaded member operator, including conversion operators.
unsigned getAddressSpace() const
Definition: Type.h:335
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so...
Definition: DeclBase.h:1070
ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *InputExpr)
Definition: SemaExpr.cpp:11792
TemplateSpecCandidate - This is a generalization of OverloadCandidate which keeps track of template a...
bool isRestrictQualified() const
Determine whether this type is restrict-qualified.
Definition: Type.h:5553
Block Pointer conversions.
Definition: Overload.h:82
Deduction failed; that's all we know.
Definition: Sema.h:6816
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...
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat]...
Definition: APValue.h:38
GC getObjCGCAttr() const
Definition: Type.h:288
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 isUsable() const
Definition: Ownership.h:160
void DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc, ArrayRef< Expr * > Args)
DiagnoseSentinelCalls - This routine checks whether a call or message-send is to a declaration with t...
Definition: SemaExpr.cpp:315
QualType getPointeeType() const
Definition: Type.h:2381
Condition in a constexpr if statement.
Definition: Sema.h:2552
std::string getQualifiedNameAsString() const
Definition: Decl.cpp:1451
bool checkAddressOfFunctionIsAvailable(const FunctionDecl *Function, bool Complain=false, SourceLocation Loc=SourceLocation())
Returns whether the given function'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
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:1156
Expr * getBase() const
Definition: Expr.h:2468
A template argument list.
Definition: DeclTemplate.h:195
void addConversion(NamedDecl *Found, FunctionDecl *D)
Definition: Overload.h:320
X
Add a minimal nested name specifier fixit hint to allow lookup of a tag name from an outer enclosing ...
Definition: SemaDecl.cpp:13074
const Type * getClass() const
Definition: Type.h:2475
Reading or writing from this object requires a barrier call.
Definition: Type.h:149
CCEKind
Contexts in which a converted constant expression is required.
Definition: Sema.h:2547
ExprResult DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT, FunctionDecl *FDecl)
DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but will create a trap if the resul...
Definition: SemaExpr.cpp:859
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:2378
bool isObjCClassType() const
True if this is equivalent to the 'Class' type, i.e.
Definition: Type.h:5287
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:5569
Represents a C++ struct/union/class.
Definition: DeclCXX.h:267
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:9248
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Definition: TargetInfo.h:861
bool isObjCObjectPointerType() const
Definition: Type.h:5784
The template argument is a template name that was provided for a template template parameter...
Definition: TemplateBase.h:60
CUDAFunctionTarget
Definition: Sema.h:9876
Optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
Definition: DeclBase.h:505
OverloadsShown
Specifies which overload candidates to display when overload resolution fails.
OverloadsShown getShowOverloads() const
Definition: Diagnostic.h:575
bool hasQualifier() const
Determines whether this member expression actually had a C++ nested-name-specifier prior to the name ...
Definition: Expr.h:2488
CanQualType Char16Ty
Definition: ASTContext.h:969
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:5855
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...
AccessResult CheckUnresolvedLookupAccess(UnresolvedLookupExpr *E, DeclAccessPair FoundDecl)
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:317
TemplateArgument SecondArg
The second template argument to which the template argument deduction failure refers.
bool isEventT() const
Definition: Type.h:5837
Partial ordering of function templates for a function call.
Definition: Template.h:140
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
This class is used for builtin types like 'int'.
Definition: Type.h:2084
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:410
After substituting deduced template arguments, an element of a dependent parameter type did not match...
Definition: Sema.h:6800
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:245
static void DiagnoseBadTarget(Sema &S, OverloadCandidate *Cand)
CUDA: diagnose an invalid call across targets.
bool isArrayType() const
Definition: Type.h:5751
const StringRef Input
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...
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) ...
Definition: Diagnostic.h:1225
OverloadingResult BestViableFunction(Sema &S, SourceLocation Loc, OverloadCandidateSet::iterator &Best, bool UserDefinedConversion=false)
Find the best viable function on this overload set, if it exists.
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:2206
DeclarationName getName() const
Gets the name looked up.
Definition: ExprCXX.h:2571
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:3471
ExprResult ExprError()
Definition: Ownership.h:268
static Qualifiers fromCVRMask(unsigned CVR)
Definition: Type.h:213
ExprResult PerformObjectMemberConversion(Expr *From, NestedNameSpecifier *Qualifier, NamedDecl *FoundDecl, NamedDecl *Member)
Cast a base object to a member's actual type.
Definition: SemaExpr.cpp:2493
bool isInt() const
Definition: APValue.h:183
CanQualType IntTy
Definition: ASTContext.h:971
unsigned getAddressSpaceAttributePrintValue() const
Get the address space attribute value to be printed by diagnostics.
Definition: Type.h:340
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...
FPOptions FPFeatures
Definition: Sema.h:301
void DiagnoseSelfMove(const Expr *LHSExpr, const Expr *RHSExpr, SourceLocation OpLoc)
Warn if a value is moved to itself.
iterator end()
Definition: Lookup.h:795
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:953
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
Definition: Expr.h:402
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:4297
bool hasRestrict() const
Definition: Type.h:251
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...
QualType getElementType() const
Definition: Type.h:2531
bool hasQualifiers() const
Determine whether this type has any qualifiers.
Definition: Type.h:5564
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:308
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc)
Retrieve the overloaded operator kind that corresponds to the given binary opcode.
Definition: Expr.cpp:1788
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...
void clear()
Clear out all of the candidates.
ImplicitConversionKind First
First – The first conversion can be an lvalue-to-rvalue conversion, array-to-pointer conversion...
Definition: Overload.h:146
const Expr * getInit(unsigned Init) const
Definition: Expr.h:3896
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:568
static bool recordConversion(Sema &SemaRef, SourceLocation Loc, Expr *&From, Sema::ContextualImplicitConverter &Converter, QualType T, bool HadMultipleCandidates, DeclAccessPair &Found)
#define true
Definition: stdbool.h:32
AccessResult CheckAddressOfMemberAccess(Expr *OvlExpr, DeclAccessPair FoundDecl)
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:110
bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)
size_t size() const
Definition: Overload.h:804
const llvm::fltSemantics & getFloatTypeSemantics(QualType T) const
Return the APFloat 'semantics' for the specified scalar floating point type.
A trivial tuple used to represent a source range.
SourceLocation getLocation() const
Definition: DeclBase.h:407
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:305
NamedDecl - This represents a decl with a name.
Definition: Decl.h:213
NestedNameSpecifier * getQualifier() const
Fetches the nested-name qualifier, if one was given.
Definition: ExprCXX.h:2577
CanQualType BoolTy
Definition: ASTContext.h:964
bool CheckCallReturnType(QualType ReturnType, SourceLocation Loc, CallExpr *CE, FunctionDecl *FD)
CheckCallReturnType - Checks that a call expression's return type is complete.
Definition: SemaExpr.cpp:14823
bool isArithmeticType() const
Definition: Type.cpp:1852
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...
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:1744
APSInt & getInt()
Definition: APValue.h:201
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:5548
CanQualType DoubleTy
Definition: ASTContext.h:974
Pointer-to-member conversions (C++ 4.11)
Definition: Overload.h:75
bool EvaluateAsLValue(EvalResult &Result, const ASTContext &Ctx) const
EvaluateAsLValue - Evaluate an expression to see if we can fold it to an lvalue with link time known ...
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:683
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...
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:2966
Describes an entity that is being initialized.
void setToType(unsigned Idx, QualType T)
Definition: Overload.h:216
bool isObjCIdType() const
True if this is equivalent to the 'id' type, i.e.
Definition: Type.h:5281
NamespaceDecl * getStdNamespace() const
void setBase(Expr *E)
Definition: Expr.h:2467
char Diagnostic[sizeof(PartialDiagnosticAt)]
A diagnostic indicating why deduction failed.
SourceLocation getLocStart() const LLVM_READONLY
Definition: Stmt.cpp:257
void removeAddressSpace()
Definition: Type.h:358
AssignmentAction
Definition: Sema.h:2438
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...
bool isPointerConversionToVoidPointer(ASTContext &Context) const
isPointerConversionToVoidPointer - Determines whether this conversion is a conversion of a pointer to...
The explicitly-specified template arguments were not valid template arguments for the given template...
Definition: Sema.h:6812
This conversion candidate is not viable because its result type is not implicitly convertible to the ...
Definition: Overload.h:592
Declaration of a template function.
Definition: DeclTemplate.h:939
void clear()
Clears out any current state.
Definition: Lookup.h:540
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:2948
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.
const NamedDecl * Result
Definition: USRFinder.cpp:70
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
A single template declaration.
Definition: TemplateName.h:190
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: Type.h:5928
SourceLocation getLocation() const
Definition: Overload.h:788
Expr * IgnoreParens() LLVM_READONLY
IgnoreParens - Ignore parentheses.
Definition: Expr.cpp:2368
CanQualType UnsignedIntTy
Definition: ASTContext.h:972
DeclAccessPair getFoundDecl() const
Retrieves the declaration found by lookup.
Definition: Expr.h:2478
void Profile(llvm::FoldingSetNodeID &ID) const
Definition: Type.h:536
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:5516
bool isPointerType() const
Definition: Type.h:5712
unsigned NumConversionsFixed
The number of Conversions fixed.
DeclarationName getCXXOperatorName(OverloadedOperatorKind Op)
getCXXOperatorName - Get the name of the overloadable C++ operator corresponding to Op...
StandardConversionSequence - represents a standard conversion sequence (C++ 13.3.3.1.1).
Definition: Overload.h:141
bool isIncompleteOrObjectType() const
Return true if this is an incomplete or object type, in other words, not a function type...
Definition: Type.h:1605
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.cpp:1497
static void DiagnoseFailedEnableIfAttr(Sema &S, OverloadCandidate *Cand)