clang  9.0.0
SemaOverload.cpp
Go to the documentation of this file.
1 //===--- SemaOverload.cpp - C++ Overloading -------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file provides Sema routines for C++ overloading.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "clang/Sema/Overload.h"
14 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/DeclObjC.h"
17 #include "clang/AST/Expr.h"
18 #include "clang/AST/ExprCXX.h"
19 #include "clang/AST/ExprObjC.h"
20 #include "clang/AST/TypeOrdering.h"
21 #include "clang/Basic/Diagnostic.h"
24 #include "clang/Basic/TargetInfo.h"
26 #include "clang/Sema/Lookup.h"
28 #include "clang/Sema/Template.h"
30 #include "llvm/ADT/DenseSet.h"
31 #include "llvm/ADT/Optional.h"
32 #include "llvm/ADT/STLExtras.h"
33 #include "llvm/ADT/SmallPtrSet.h"
34 #include "llvm/ADT/SmallString.h"
35 #include <algorithm>
36 #include <cstdlib>
37 
38 using namespace clang;
39 using namespace sema;
40 
42  return llvm::any_of(FD->parameters(), [](const ParmVarDecl *P) {
43  return P->hasAttr<PassObjectSizeAttr>();
44  });
45 }
46 
47 /// A convenience routine for creating a decayed reference to a function.
48 static ExprResult
50  const Expr *Base, bool HadMultipleCandidates,
52  const DeclarationNameLoc &LocInfo = DeclarationNameLoc()){
53  if (S.DiagnoseUseOfDecl(FoundDecl, Loc))
54  return ExprError();
55  // If FoundDecl is different from Fn (such as if one is a template
56  // and the other a specialization), make sure DiagnoseUseOfDecl is
57  // called on both.
58  // FIXME: This would be more comprehensively addressed by modifying
59  // DiagnoseUseOfDecl to accept both the FoundDecl and the decl
60  // being used.
61  if (FoundDecl != Fn && S.DiagnoseUseOfDecl(Fn, Loc))
62  return ExprError();
63  if (auto *FPT = Fn->getType()->getAs<FunctionProtoType>())
64  S.ResolveExceptionSpec(Loc, FPT);
65  DeclRefExpr *DRE = new (S.Context)
66  DeclRefExpr(S.Context, Fn, false, Fn->getType(), VK_LValue, Loc, LocInfo);
67  if (HadMultipleCandidates)
68  DRE->setHadMultipleCandidates(true);
69 
70  S.MarkDeclRefReferenced(DRE, Base);
71  return S.ImpCastExprToType(DRE, S.Context.getPointerType(DRE->getType()),
72  CK_FunctionToPointerDecay);
73 }
74 
75 static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
76  bool InOverloadResolution,
78  bool CStyle,
79  bool AllowObjCWritebackConversion);
80 
81 static bool IsTransparentUnionStandardConversion(Sema &S, Expr* From,
82  QualType &ToType,
83  bool InOverloadResolution,
85  bool CStyle);
86 static OverloadingResult
87 IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
89  OverloadCandidateSet& Conversions,
90  bool AllowExplicit,
91  bool AllowObjCConversionOnExplicit);
92 
93 
96  const StandardConversionSequence& SCS1,
97  const StandardConversionSequence& SCS2);
98 
101  const StandardConversionSequence& SCS1,
102  const StandardConversionSequence& SCS2);
103 
106  const StandardConversionSequence& SCS1,
107  const StandardConversionSequence& SCS2);
108 
109 /// GetConversionRank - Retrieve the implicit conversion rank
110 /// corresponding to the given implicit conversion kind.
112  static const ImplicitConversionRank
113  Rank[(int)ICK_Num_Conversion_Kinds] = {
138  ICR_Exact_Match, // NOTE(gbiv): This may not be completely right --
139  // it was omitted by the patch that added
140  // ICK_Zero_Event_Conversion
143  };
144  return Rank[(int)Kind];
145 }
146 
147 /// GetImplicitConversionName - Return the name of this kind of
148 /// implicit conversion.
150  static const char* const Name[(int)ICK_Num_Conversion_Kinds] = {
151  "No conversion",
152  "Lvalue-to-rvalue",
153  "Array-to-pointer",
154  "Function-to-pointer",
155  "Function pointer conversion",
156  "Qualification",
157  "Integral promotion",
158  "Floating point promotion",
159  "Complex promotion",
160  "Integral conversion",
161  "Floating conversion",
162  "Complex conversion",
163  "Floating-integral conversion",
164  "Pointer conversion",
165  "Pointer-to-member conversion",
166  "Boolean conversion",
167  "Compatible-types conversion",
168  "Derived-to-base conversion",
169  "Vector conversion",
170  "Vector splat",
171  "Complex-real conversion",
172  "Block Pointer conversion",
173  "Transparent Union Conversion",
174  "Writeback conversion",
175  "OpenCL Zero Event Conversion",
176  "C specific type conversion",
177  "Incompatible pointer conversion"
178  };
179  return Name[Kind];
180 }
181 
182 /// StandardConversionSequence - Set the standard conversion
183 /// sequence to the identity conversion.
186  Second = ICK_Identity;
187  Third = ICK_Identity;
188  DeprecatedStringLiteralToCharPtr = false;
189  QualificationIncludesObjCLifetime = false;
190  ReferenceBinding = false;
191  DirectBinding = false;
192  IsLvalueReference = true;
193  BindsToFunctionLvalue = false;
194  BindsToRvalue = false;
195  BindsImplicitObjectArgumentWithoutRefQualifier = false;
196  ObjCLifetimeConversionBinding = false;
197  CopyConstructor = nullptr;
198 }
199 
200 /// getRank - Retrieve the rank of this standard conversion sequence
201 /// (C++ 13.3.3.1.1p3). The rank is the largest rank of each of the
202 /// implicit conversions.
205  if (GetConversionRank(First) > Rank)
206  Rank = GetConversionRank(First);
207  if (GetConversionRank(Second) > Rank)
208  Rank = GetConversionRank(Second);
209  if (GetConversionRank(Third) > Rank)
210  Rank = GetConversionRank(Third);
211  return Rank;
212 }
213 
214 /// isPointerConversionToBool - Determines whether this conversion is
215 /// a conversion of a pointer or pointer-to-member to bool. This is
216 /// used as part of the ranking of standard conversion sequences
217 /// (C++ 13.3.3.2p4).
219  // Note that FromType has not necessarily been transformed by the
220  // array-to-pointer or function-to-pointer implicit conversions, so
221  // check for their presence as well as checking whether FromType is
222  // a pointer.
223  if (getToType(1)->isBooleanType() &&
224  (getFromType()->isPointerType() ||
225  getFromType()->isMemberPointerType() ||
226  getFromType()->isObjCObjectPointerType() ||
227  getFromType()->isBlockPointerType() ||
228  getFromType()->isNullPtrType() ||
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.
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.
291 /// \param IgnoreFloatToIntegralConversion If true type-narrowing conversions
292 /// from floating point types to integral types should be ignored.
294  ASTContext &Ctx, const Expr *Converted, APValue &ConstantValue,
295  QualType &ConstantType, bool IgnoreFloatToIntegralConversion) 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->isIntegralOrUnscopedEnumerationType() &&
331  ToType->isRealFloatingType()) {
332  if (IgnoreFloatToIntegralConversion)
333  return NK_Not_Narrowing;
334  llvm::APSInt IntConstantValue;
335  const Expr *Initializer = IgnoreNarrowingConversion(Converted);
336  assert(Initializer && "Unknown conversion expression");
337 
338  // If it's value-dependent, we can't tell whether it's narrowing.
339  if (Initializer->isValueDependent())
340  return NK_Dependent_Narrowing;
341 
342  if (Initializer->isIntegerConstantExpr(IntConstantValue, Ctx)) {
343  // Convert the integer to the floating type.
344  llvm::APFloat Result(Ctx.getFloatTypeSemantics(ToType));
345  Result.convertFromAPInt(IntConstantValue, IntConstantValue.isSigned(),
346  llvm::APFloat::rmNearestTiesToEven);
347  // And back.
348  llvm::APSInt ConvertedValue = IntConstantValue;
349  bool ignored;
350  Result.convertToInteger(ConvertedValue,
351  llvm::APFloat::rmTowardZero, &ignored);
352  // If the resulting value is different, this was a narrowing conversion.
353  if (IntConstantValue != ConvertedValue) {
354  ConstantValue = APValue(IntConstantValue);
355  ConstantType = Initializer->getType();
356  return NK_Constant_Narrowing;
357  }
358  } else {
359  // Variables are always narrowings.
360  return NK_Variable_Narrowing;
361  }
362  }
363  return NK_Not_Narrowing;
364 
365  // -- from long double to double or float, or from double to float, except
366  // where the source is a constant expression and the actual value after
367  // conversion is within the range of values that can be represented (even
368  // if it cannot be represented exactly), or
370  if (FromType->isRealFloatingType() && ToType->isRealFloatingType() &&
371  Ctx.getFloatingTypeOrder(FromType, ToType) == 1) {
372  // FromType is larger than ToType.
373  const Expr *Initializer = IgnoreNarrowingConversion(Converted);
374 
375  // If it's value-dependent, we can't tell whether it's narrowing.
376  if (Initializer->isValueDependent())
377  return NK_Dependent_Narrowing;
378 
379  if (Initializer->isCXX11ConstantExpr(Ctx, &ConstantValue)) {
380  // Constant!
381  assert(ConstantValue.isFloat());
382  llvm::APFloat FloatVal = ConstantValue.getFloat();
383  // Convert the source value into the target type.
384  bool ignored;
385  llvm::APFloat::opStatus ConvertStatus = FloatVal.convert(
386  Ctx.getFloatTypeSemantics(ToType),
387  llvm::APFloat::rmNearestTiesToEven, &ignored);
388  // If there was no overflow, the source value is within the range of
389  // values that can be represented.
390  if (ConvertStatus & llvm::APFloat::opOverflow) {
391  ConstantType = Initializer->getType();
392  return NK_Constant_Narrowing;
393  }
394  } else {
395  return NK_Variable_Narrowing;
396  }
397  }
398  return NK_Not_Narrowing;
399 
400  // -- from an integer type or unscoped enumeration type to an integer type
401  // that cannot represent all the values of the original type, except where
402  // the source is a constant expression and the actual value after
403  // conversion will fit into the target type and will produce the original
404  // value when converted back to the original type.
406  IntegralConversion: {
407  assert(FromType->isIntegralOrUnscopedEnumerationType());
408  assert(ToType->isIntegralOrUnscopedEnumerationType());
409  const bool FromSigned = FromType->isSignedIntegerOrEnumerationType();
410  const unsigned FromWidth = Ctx.getIntWidth(FromType);
411  const bool ToSigned = ToType->isSignedIntegerOrEnumerationType();
412  const unsigned ToWidth = Ctx.getIntWidth(ToType);
413 
414  if (FromWidth > ToWidth ||
415  (FromWidth == ToWidth && FromSigned != ToSigned) ||
416  (FromSigned && !ToSigned)) {
417  // Not all values of FromType can be represented in ToType.
418  llvm::APSInt InitializerValue;
419  const Expr *Initializer = IgnoreNarrowingConversion(Converted);
420 
421  // If it's value-dependent, we can't tell whether it's narrowing.
422  if (Initializer->isValueDependent())
423  return NK_Dependent_Narrowing;
424 
425  if (!Initializer->isIntegerConstantExpr(InitializerValue, Ctx)) {
426  // Such conversions on variables are always narrowing.
427  return NK_Variable_Narrowing;
428  }
429  bool Narrowing = false;
430  if (FromWidth < ToWidth) {
431  // Negative -> unsigned is narrowing. Otherwise, more bits is never
432  // narrowing.
433  if (InitializerValue.isSigned() && InitializerValue.isNegative())
434  Narrowing = true;
435  } else {
436  // Add a bit to the InitializerValue so we don't have to worry about
437  // signed vs. unsigned comparisons.
438  InitializerValue = InitializerValue.extend(
439  InitializerValue.getBitWidth() + 1);
440  // Convert the initializer to and from the target width and signed-ness.
441  llvm::APSInt ConvertedValue = InitializerValue;
442  ConvertedValue = ConvertedValue.trunc(ToWidth);
443  ConvertedValue.setIsSigned(ToSigned);
444  ConvertedValue = ConvertedValue.extend(InitializerValue.getBitWidth());
445  ConvertedValue.setIsSigned(InitializerValue.isSigned());
446  // If the result is different, this was a narrowing conversion.
447  if (ConvertedValue != InitializerValue)
448  Narrowing = true;
449  }
450  if (Narrowing) {
451  ConstantType = Initializer->getType();
452  ConstantValue = APValue(InitializerValue);
453  return NK_Constant_Narrowing;
454  }
455  }
456  return NK_Not_Narrowing;
457  }
458 
459  default:
460  // Other kinds of conversions are not narrowings.
461  return NK_Not_Narrowing;
462  }
463 }
464 
465 /// dump - Print this standard conversion sequence to standard
466 /// error. Useful for debugging overloading issues.
467 LLVM_DUMP_METHOD void StandardConversionSequence::dump() const {
468  raw_ostream &OS = llvm::errs();
469  bool PrintedSomething = false;
470  if (First != ICK_Identity) {
472  PrintedSomething = true;
473  }
474 
475  if (Second != ICK_Identity) {
476  if (PrintedSomething) {
477  OS << " -> ";
478  }
479  OS << GetImplicitConversionName(Second);
480 
481  if (CopyConstructor) {
482  OS << " (by copy constructor)";
483  } else if (DirectBinding) {
484  OS << " (direct reference binding)";
485  } else if (ReferenceBinding) {
486  OS << " (reference binding)";
487  }
488  PrintedSomething = true;
489  }
490 
491  if (Third != ICK_Identity) {
492  if (PrintedSomething) {
493  OS << " -> ";
494  }
495  OS << GetImplicitConversionName(Third);
496  PrintedSomething = true;
497  }
498 
499  if (!PrintedSomething) {
500  OS << "No conversions required";
501  }
502 }
503 
504 /// dump - Print this user-defined conversion sequence to standard
505 /// error. Useful for debugging overloading issues.
507  raw_ostream &OS = llvm::errs();
508  if (Before.First || Before.Second || Before.Third) {
509  Before.dump();
510  OS << " -> ";
511  }
512  if (ConversionFunction)
513  OS << '\'' << *ConversionFunction << '\'';
514  else
515  OS << "aggregate initialization";
516  if (After.First || After.Second || After.Third) {
517  OS << " -> ";
518  After.dump();
519  }
520 }
521 
522 /// dump - Print this implicit conversion sequence to standard
523 /// error. Useful for debugging overloading issues.
525  raw_ostream &OS = llvm::errs();
526  if (isStdInitializerListElement())
527  OS << "Worst std::initializer_list element conversion: ";
528  switch (ConversionKind) {
529  case StandardConversion:
530  OS << "Standard conversion: ";
531  Standard.dump();
532  break;
533  case UserDefinedConversion:
534  OS << "User-defined conversion: ";
535  UserDefined.dump();
536  break;
537  case EllipsisConversion:
538  OS << "Ellipsis conversion";
539  break;
540  case AmbiguousConversion:
541  OS << "Ambiguous conversion";
542  break;
543  case BadConversion:
544  OS << "Bad conversion";
545  break;
546  }
547 
548  OS << "\n";
549 }
550 
552  new (&conversions()) ConversionSet();
553 }
554 
556  conversions().~ConversionSet();
557 }
558 
559 void
561  FromTypePtr = O.FromTypePtr;
562  ToTypePtr = O.ToTypePtr;
563  new (&conversions()) ConversionSet(O.conversions());
564 }
565 
566 namespace {
567  // Structure used by DeductionFailureInfo to store
568  // template argument information.
569  struct DFIArguments {
570  TemplateArgument FirstArg;
571  TemplateArgument SecondArg;
572  };
573  // Structure used by DeductionFailureInfo to store
574  // template parameter and template argument information.
575  struct DFIParamWithArguments : DFIArguments {
576  TemplateParameter Param;
577  };
578  // Structure used by DeductionFailureInfo to store template argument
579  // information and the index of the problematic call argument.
580  struct DFIDeducedMismatchArgs : DFIArguments {
581  TemplateArgumentList *TemplateArgs;
582  unsigned CallArgIndex;
583  };
584 }
585 
586 /// Convert from Sema's representation of template deduction information
587 /// to the form used in overload-candidate information.
591  TemplateDeductionInfo &Info) {
592  DeductionFailureInfo Result;
593  Result.Result = static_cast<unsigned>(TDK);
594  Result.HasDiagnostic = false;
595  switch (TDK) {
596  case Sema::TDK_Invalid:
602  Result.Data = nullptr;
603  break;
604 
607  Result.Data = Info.Param.getOpaqueValue();
608  break;
609 
612  // FIXME: Should allocate from normal heap so that we can free this later.
613  auto *Saved = new (Context) DFIDeducedMismatchArgs;
614  Saved->FirstArg = Info.FirstArg;
615  Saved->SecondArg = Info.SecondArg;
616  Saved->TemplateArgs = Info.take();
617  Saved->CallArgIndex = Info.CallArgIndex;
618  Result.Data = Saved;
619  break;
620  }
621 
623  // FIXME: Should allocate from normal heap so that we can free this later.
624  DFIArguments *Saved = new (Context) DFIArguments;
625  Saved->FirstArg = Info.FirstArg;
626  Saved->SecondArg = Info.SecondArg;
627  Result.Data = Saved;
628  break;
629  }
630 
632  // FIXME: It's slightly wasteful to allocate two TemplateArguments for this.
635  // FIXME: Should allocate from normal heap so that we can free this later.
636  DFIParamWithArguments *Saved = new (Context) DFIParamWithArguments;
637  Saved->Param = Info.Param;
638  Saved->FirstArg = Info.FirstArg;
639  Saved->SecondArg = Info.SecondArg;
640  Result.Data = Saved;
641  break;
642  }
643 
645  Result.Data = Info.take();
646  if (Info.hasSFINAEDiagnostic()) {
649  Info.takeSFINAEDiagnostic(*Diag);
650  Result.HasDiagnostic = true;
651  }
652  break;
653 
654  case Sema::TDK_Success:
656  llvm_unreachable("not a deduction failure");
657  }
658 
659  return Result;
660 }
661 
663  switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
664  case Sema::TDK_Success:
665  case Sema::TDK_Invalid:
673  break;
674 
681  // FIXME: Destroy the data?
682  Data = nullptr;
683  break;
684 
686  // FIXME: Destroy the template argument list?
687  Data = nullptr;
688  if (PartialDiagnosticAt *Diag = getSFINAEDiagnostic()) {
689  Diag->~PartialDiagnosticAt();
690  HasDiagnostic = false;
691  }
692  break;
693 
694  // Unhandled
696  break;
697  }
698 }
699 
701  if (HasDiagnostic)
702  return static_cast<PartialDiagnosticAt*>(static_cast<void*>(Diagnostic));
703  return nullptr;
704 }
705 
707  switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
708  case Sema::TDK_Success:
709  case Sema::TDK_Invalid:
719  return TemplateParameter();
720 
723  return TemplateParameter::getFromOpaqueValue(Data);
724 
728  return static_cast<DFIParamWithArguments*>(Data)->Param;
729 
730  // Unhandled
732  break;
733  }
734 
735  return TemplateParameter();
736 }
737 
739  switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
740  case Sema::TDK_Success:
741  case Sema::TDK_Invalid:
753  return nullptr;
754 
757  return static_cast<DFIDeducedMismatchArgs*>(Data)->TemplateArgs;
758 
760  return static_cast<TemplateArgumentList*>(Data);
761 
762  // Unhandled
764  break;
765  }
766 
767  return nullptr;
768 }
769 
771  switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
772  case Sema::TDK_Success:
773  case Sema::TDK_Invalid:
782  return nullptr;
783 
790  return &static_cast<DFIArguments*>(Data)->FirstArg;
791 
792  // Unhandled
794  break;
795  }
796 
797  return nullptr;
798 }
799 
801  switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
802  case Sema::TDK_Success:
803  case Sema::TDK_Invalid:
813  return nullptr;
814 
820  return &static_cast<DFIArguments*>(Data)->SecondArg;
821 
822  // Unhandled
824  break;
825  }
826 
827  return nullptr;
828 }
829 
831  switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
834  return static_cast<DFIDeducedMismatchArgs*>(Data)->CallArgIndex;
835 
836  default:
837  return llvm::None;
838  }
839 }
840 
841 void OverloadCandidateSet::destroyCandidates() {
842  for (iterator i = begin(), e = end(); i != e; ++i) {
843  for (auto &C : i->Conversions)
844  C.~ImplicitConversionSequence();
845  if (!i->Viable && i->FailureKind == ovl_fail_bad_deduction)
846  i->DeductionFailure.Destroy();
847  }
848 }
849 
851  destroyCandidates();
852  SlabAllocator.Reset();
853  NumInlineBytesUsed = 0;
854  Candidates.clear();
855  Functions.clear();
856  Kind = CSK;
857 }
858 
859 namespace {
860  class UnbridgedCastsSet {
861  struct Entry {
862  Expr **Addr;
863  Expr *Saved;
864  };
865  SmallVector<Entry, 2> Entries;
866 
867  public:
868  void save(Sema &S, Expr *&E) {
869  assert(E->hasPlaceholderType(BuiltinType::ARCUnbridgedCast));
870  Entry entry = { &E, E };
871  Entries.push_back(entry);
872  E = S.stripARCUnbridgedCast(E);
873  }
874 
875  void restore() {
877  i = Entries.begin(), e = Entries.end(); i != e; ++i)
878  *i->Addr = i->Saved;
879  }
880  };
881 }
882 
883 /// checkPlaceholderForOverload - Do any interesting placeholder-like
884 /// preprocessing on the given expression.
885 ///
886 /// \param unbridgedCasts a collection to which to add unbridged casts;
887 /// without this, they will be immediately diagnosed as errors
888 ///
889 /// Return true on unrecoverable error.
890 static bool
892  UnbridgedCastsSet *unbridgedCasts = nullptr) {
893  if (const BuiltinType *placeholder = E->getType()->getAsPlaceholderType()) {
894  // We can't handle overloaded expressions here because overload
895  // resolution might reasonably tweak them.
896  if (placeholder->getKind() == BuiltinType::Overload) return false;
897 
898  // If the context potentially accepts unbridged ARC casts, strip
899  // the unbridged cast and add it to the collection for later restoration.
900  if (placeholder->getKind() == BuiltinType::ARCUnbridgedCast &&
901  unbridgedCasts) {
902  unbridgedCasts->save(S, E);
903  return false;
904  }
905 
906  // Go ahead and check everything else.
908  if (result.isInvalid())
909  return true;
910 
911  E = result.get();
912  return false;
913  }
914 
915  // Nothing to do.
916  return false;
917 }
918 
919 /// checkArgPlaceholdersForOverload - Check a set of call operands for
920 /// placeholders.
922  MultiExprArg Args,
923  UnbridgedCastsSet &unbridged) {
924  for (unsigned i = 0, e = Args.size(); i != e; ++i)
925  if (checkPlaceholderForOverload(S, Args[i], &unbridged))
926  return true;
927 
928  return false;
929 }
930 
931 /// Determine whether the given New declaration is an overload of the
932 /// declarations in Old. This routine returns Ovl_Match or Ovl_NonFunction if
933 /// New and Old cannot be overloaded, e.g., if New has the same signature as
934 /// some function in Old (C++ 1.3.10) or if the Old declarations aren't
935 /// functions (or function templates) at all. When it does return Ovl_Match or
936 /// Ovl_NonFunction, MatchedDecl will point to the decl that New cannot be
937 /// overloaded with. This decl may be a UsingShadowDecl on top of the underlying
938 /// declaration.
939 ///
940 /// Example: Given the following input:
941 ///
942 /// void f(int, float); // #1
943 /// void f(int, int); // #2
944 /// int f(int, int); // #3
945 ///
946 /// When we process #1, there is no previous declaration of "f", so IsOverload
947 /// will not be used.
948 ///
949 /// When we process #2, Old contains only the FunctionDecl for #1. By comparing
950 /// the parameter types, we see that #1 and #2 are overloaded (since they have
951 /// different signatures), so this routine returns Ovl_Overload; MatchedDecl is
952 /// unchanged.
953 ///
954 /// When we process #3, Old is an overload set containing #1 and #2. We compare
955 /// the signatures of #3 to #1 (they're overloaded, so we do nothing) and then
956 /// #3 to #2. Since the signatures of #3 and #2 are identical (return types of
957 /// functions are not part of the signature), IsOverload returns Ovl_Match and
958 /// MatchedDecl will be set to point to the FunctionDecl for #2.
959 ///
960 /// 'NewIsUsingShadowDecl' indicates that 'New' is being introduced into a class
961 /// by a using declaration. The rules for whether to hide shadow declarations
962 /// ignore some properties which otherwise figure into a function template's
963 /// signature.
966  NamedDecl *&Match, bool NewIsUsingDecl) {
967  for (LookupResult::iterator I = Old.begin(), E = Old.end();
968  I != E; ++I) {
969  NamedDecl *OldD = *I;
970 
971  bool OldIsUsingDecl = false;
972  if (isa<UsingShadowDecl>(OldD)) {
973  OldIsUsingDecl = true;
974 
975  // We can always introduce two using declarations into the same
976  // context, even if they have identical signatures.
977  if (NewIsUsingDecl) continue;
978 
979  OldD = cast<UsingShadowDecl>(OldD)->getTargetDecl();
980  }
981 
982  // A using-declaration does not conflict with another declaration
983  // if one of them is hidden.
984  if ((OldIsUsingDecl || NewIsUsingDecl) && !isVisible(*I))
985  continue;
986 
987  // If either declaration was introduced by a using declaration,
988  // we'll need to use slightly different rules for matching.
989  // Essentially, these rules are the normal rules, except that
990  // function templates hide function templates with different
991  // return types or template parameter lists.
992  bool UseMemberUsingDeclRules =
993  (OldIsUsingDecl || NewIsUsingDecl) && CurContext->isRecord() &&
994  !New->getFriendObjectKind();
995 
996  if (FunctionDecl *OldF = OldD->getAsFunction()) {
997  if (!IsOverload(New, OldF, UseMemberUsingDeclRules)) {
998  if (UseMemberUsingDeclRules && OldIsUsingDecl) {
999  HideUsingShadowDecl(S, cast<UsingShadowDecl>(*I));
1000  continue;
1001  }
1002 
1003  if (!isa<FunctionTemplateDecl>(OldD) &&
1004  !shouldLinkPossiblyHiddenDecl(*I, New))
1005  continue;
1006 
1007  Match = *I;
1008  return Ovl_Match;
1009  }
1010 
1011  // Builtins that have custom typechecking or have a reference should
1012  // not be overloadable or redeclarable.
1013  if (!getASTContext().canBuiltinBeRedeclared(OldF)) {
1014  Match = *I;
1015  return Ovl_NonFunction;
1016  }
1017  } else if (isa<UsingDecl>(OldD) || isa<UsingPackDecl>(OldD)) {
1018  // We can overload with these, which can show up when doing
1019  // redeclaration checks for UsingDecls.
1020  assert(Old.getLookupKind() == LookupUsingDeclName);
1021  } else if (isa<TagDecl>(OldD)) {
1022  // We can always overload with tags by hiding them.
1023  } else if (auto *UUD = dyn_cast<UnresolvedUsingValueDecl>(OldD)) {
1024  // Optimistically assume that an unresolved using decl will
1025  // overload; if it doesn't, we'll have to diagnose during
1026  // template instantiation.
1027  //
1028  // Exception: if the scope is dependent and this is not a class
1029  // member, the using declaration can only introduce an enumerator.
1030  if (UUD->getQualifier()->isDependent() && !UUD->isCXXClassMember()) {
1031  Match = *I;
1032  return Ovl_NonFunction;
1033  }
1034  } else {
1035  // (C++ 13p1):
1036  // Only function declarations can be overloaded; object and type
1037  // declarations cannot be overloaded.
1038  Match = *I;
1039  return Ovl_NonFunction;
1040  }
1041  }
1042 
1043  // C++ [temp.friend]p1:
1044  // For a friend function declaration that is not a template declaration:
1045  // -- if the name of the friend is a qualified or unqualified template-id,
1046  // [...], otherwise
1047  // -- if the name of the friend is a qualified-id and a matching
1048  // non-template function is found in the specified class or namespace,
1049  // the friend declaration refers to that function, otherwise,
1050  // -- if the name of the friend is a qualified-id and a matching function
1051  // template is found in the specified class or namespace, the friend
1052  // declaration refers to the deduced specialization of that function
1053  // template, otherwise
1054  // -- the name shall be an unqualified-id [...]
1055  // If we get here for a qualified friend declaration, we've just reached the
1056  // third bullet. If the type of the friend is dependent, skip this lookup
1057  // until instantiation.
1058  if (New->getFriendObjectKind() && New->getQualifier() &&
1059  !New->getDescribedFunctionTemplate() &&
1061  !New->getType()->isDependentType()) {
1062  LookupResult TemplateSpecResult(LookupResult::Temporary, Old);
1063  TemplateSpecResult.addAllDecls(Old);
1064  if (CheckFunctionTemplateSpecialization(New, nullptr, TemplateSpecResult,
1065  /*QualifiedFriend*/true)) {
1066  New->setInvalidDecl();
1067  return Ovl_Overload;
1068  }
1069 
1070  Match = TemplateSpecResult.getAsSingle<FunctionDecl>();
1071  return Ovl_Match;
1072  }
1073 
1074  return Ovl_Overload;
1075 }
1076 
1078  bool UseMemberUsingDeclRules, bool ConsiderCudaAttrs) {
1079  // C++ [basic.start.main]p2: This function shall not be overloaded.
1080  if (New->isMain())
1081  return false;
1082 
1083  // MSVCRT user defined entry points cannot be overloaded.
1084  if (New->isMSVCRTEntryPoint())
1085  return false;
1086 
1087  FunctionTemplateDecl *OldTemplate = Old->getDescribedFunctionTemplate();
1088  FunctionTemplateDecl *NewTemplate = New->getDescribedFunctionTemplate();
1089 
1090  // C++ [temp.fct]p2:
1091  // A function template can be overloaded with other function templates
1092  // and with normal (non-template) functions.
1093  if ((OldTemplate == nullptr) != (NewTemplate == nullptr))
1094  return true;
1095 
1096  // Is the function New an overload of the function Old?
1097  QualType OldQType = Context.getCanonicalType(Old->getType());
1098  QualType NewQType = Context.getCanonicalType(New->getType());
1099 
1100  // Compare the signatures (C++ 1.3.10) of the two functions to
1101  // determine whether they are overloads. If we find any mismatch
1102  // in the signature, they are overloads.
1103 
1104  // If either of these functions is a K&R-style function (no
1105  // prototype), then we consider them to have matching signatures.
1106  if (isa<FunctionNoProtoType>(OldQType.getTypePtr()) ||
1107  isa<FunctionNoProtoType>(NewQType.getTypePtr()))
1108  return false;
1109 
1110  const FunctionProtoType *OldType = cast<FunctionProtoType>(OldQType);
1111  const FunctionProtoType *NewType = cast<FunctionProtoType>(NewQType);
1112 
1113  // The signature of a function includes the types of its
1114  // parameters (C++ 1.3.10), which includes the presence or absence
1115  // of the ellipsis; see C++ DR 357).
1116  if (OldQType != NewQType &&
1117  (OldType->getNumParams() != NewType->getNumParams() ||
1118  OldType->isVariadic() != NewType->isVariadic() ||
1119  !FunctionParamTypesAreEqual(OldType, NewType)))
1120  return true;
1121 
1122  // C++ [temp.over.link]p4:
1123  // The signature of a function template consists of its function
1124  // signature, its return type and its template parameter list. The names
1125  // of the template parameters are significant only for establishing the
1126  // relationship between the template parameters and the rest of the
1127  // signature.
1128  //
1129  // We check the return type and template parameter lists for function
1130  // templates first; the remaining checks follow.
1131  //
1132  // However, we don't consider either of these when deciding whether
1133  // a member introduced by a shadow declaration is hidden.
1134  if (!UseMemberUsingDeclRules && NewTemplate &&
1135  (!TemplateParameterListsAreEqual(NewTemplate->getTemplateParameters(),
1136  OldTemplate->getTemplateParameters(),
1137  false, TPL_TemplateMatch) ||
1138  !Context.hasSameType(Old->getDeclaredReturnType(),
1139  New->getDeclaredReturnType())))
1140  return true;
1141 
1142  // If the function is a class member, its signature includes the
1143  // cv-qualifiers (if any) and ref-qualifier (if any) on the function itself.
1144  //
1145  // As part of this, also check whether one of the member functions
1146  // is static, in which case they are not overloads (C++
1147  // 13.1p2). While not part of the definition of the signature,
1148  // this check is important to determine whether these functions
1149  // can be overloaded.
1150  CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old);
1151  CXXMethodDecl *NewMethod = dyn_cast<CXXMethodDecl>(New);
1152  if (OldMethod && NewMethod &&
1153  !OldMethod->isStatic() && !NewMethod->isStatic()) {
1154  if (OldMethod->getRefQualifier() != NewMethod->getRefQualifier()) {
1155  if (!UseMemberUsingDeclRules &&
1156  (OldMethod->getRefQualifier() == RQ_None ||
1157  NewMethod->getRefQualifier() == RQ_None)) {
1158  // C++0x [over.load]p2:
1159  // - Member function declarations with the same name and the same
1160  // parameter-type-list as well as member function template
1161  // declarations with the same name, the same parameter-type-list, and
1162  // the same template parameter lists cannot be overloaded if any of
1163  // them, but not all, have a ref-qualifier (8.3.5).
1164  Diag(NewMethod->getLocation(), diag::err_ref_qualifier_overload)
1165  << NewMethod->getRefQualifier() << OldMethod->getRefQualifier();
1166  Diag(OldMethod->getLocation(), diag::note_previous_declaration);
1167  }
1168  return true;
1169  }
1170 
1171  // We may not have applied the implicit const for a constexpr member
1172  // function yet (because we haven't yet resolved whether this is a static
1173  // or non-static member function). Add it now, on the assumption that this
1174  // is a redeclaration of OldMethod.
1175  auto OldQuals = OldMethod->getMethodQualifiers();
1176  auto NewQuals = NewMethod->getMethodQualifiers();
1177  if (!getLangOpts().CPlusPlus14 && NewMethod->isConstexpr() &&
1178  !isa<CXXConstructorDecl>(NewMethod))
1179  NewQuals.addConst();
1180  // We do not allow overloading based off of '__restrict'.
1181  OldQuals.removeRestrict();
1182  NewQuals.removeRestrict();
1183  if (OldQuals != NewQuals)
1184  return true;
1185  }
1186 
1187  // Though pass_object_size is placed on parameters and takes an argument, we
1188  // consider it to be a function-level modifier for the sake of function
1189  // identity. Either the function has one or more parameters with
1190  // pass_object_size or it doesn't.
1193  return true;
1194 
1195  // enable_if attributes are an order-sensitive part of the signature.
1197  NewI = New->specific_attr_begin<EnableIfAttr>(),
1198  NewE = New->specific_attr_end<EnableIfAttr>(),
1199  OldI = Old->specific_attr_begin<EnableIfAttr>(),
1200  OldE = Old->specific_attr_end<EnableIfAttr>();
1201  NewI != NewE || OldI != OldE; ++NewI, ++OldI) {
1202  if (NewI == NewE || OldI == OldE)
1203  return true;
1204  llvm::FoldingSetNodeID NewID, OldID;
1205  NewI->getCond()->Profile(NewID, Context, true);
1206  OldI->getCond()->Profile(OldID, Context, true);
1207  if (NewID != OldID)
1208  return true;
1209  }
1210 
1211  if (getLangOpts().CUDA && ConsiderCudaAttrs) {
1212  // Don't allow overloading of destructors. (In theory we could, but it
1213  // would be a giant change to clang.)
1214  if (isa<CXXDestructorDecl>(New))
1215  return false;
1216 
1217  CUDAFunctionTarget NewTarget = IdentifyCUDATarget(New),
1218  OldTarget = IdentifyCUDATarget(Old);
1219  if (NewTarget == CFT_InvalidTarget)
1220  return false;
1221 
1222  assert((OldTarget != CFT_InvalidTarget) && "Unexpected invalid target.");
1223 
1224  // Allow overloading of functions with same signature and different CUDA
1225  // target attributes.
1226  return NewTarget != OldTarget;
1227  }
1228 
1229  // The signatures match; this is not an overload.
1230  return false;
1231 }
1232 
1233 /// Tries a user-defined conversion from From to ToType.
1234 ///
1235 /// Produces an implicit conversion sequence for when a standard conversion
1236 /// is not an option. See TryImplicitConversion for more information.
1239  bool SuppressUserConversions,
1240  bool AllowExplicit,
1241  bool InOverloadResolution,
1242  bool CStyle,
1243  bool AllowObjCWritebackConversion,
1244  bool AllowObjCConversionOnExplicit) {
1246 
1247  if (SuppressUserConversions) {
1248  // We're not in the case above, so there is no conversion that
1249  // we can perform.
1250  ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1251  return ICS;
1252  }
1253 
1254  // Attempt user-defined conversion.
1255  OverloadCandidateSet Conversions(From->getExprLoc(),
1257  switch (IsUserDefinedConversion(S, From, ToType, ICS.UserDefined,
1258  Conversions, AllowExplicit,
1259  AllowObjCConversionOnExplicit)) {
1260  case OR_Success:
1261  case OR_Deleted:
1262  ICS.setUserDefined();
1263  // C++ [over.ics.user]p4:
1264  // A conversion of an expression of class type to the same class
1265  // type is given Exact Match rank, and a conversion of an
1266  // expression of class type to a base class of that type is
1267  // given Conversion rank, in spite of the fact that a copy
1268  // constructor (i.e., a user-defined conversion function) is
1269  // called for those cases.
1270  if (CXXConstructorDecl *Constructor
1271  = dyn_cast<CXXConstructorDecl>(ICS.UserDefined.ConversionFunction)) {
1272  QualType FromCanon
1274  QualType ToCanon
1276  if (Constructor->isCopyConstructor() &&
1277  (FromCanon == ToCanon ||
1278  S.IsDerivedFrom(From->getBeginLoc(), FromCanon, ToCanon))) {
1279  // Turn this into a "standard" conversion sequence, so that it
1280  // gets ranked with standard conversion sequences.
1282  ICS.setStandard();
1284  ICS.Standard.setFromType(From->getType());
1285  ICS.Standard.setAllToTypes(ToType);
1286  ICS.Standard.CopyConstructor = Constructor;
1287  ICS.Standard.FoundCopyConstructor = Found;
1288  if (ToCanon != FromCanon)
1290  }
1291  }
1292  break;
1293 
1294  case OR_Ambiguous:
1295  ICS.setAmbiguous();
1296  ICS.Ambiguous.setFromType(From->getType());
1297  ICS.Ambiguous.setToType(ToType);
1298  for (OverloadCandidateSet::iterator Cand = Conversions.begin();
1299  Cand != Conversions.end(); ++Cand)
1300  if (Cand->Viable)
1301  ICS.Ambiguous.addConversion(Cand->FoundDecl, Cand->Function);
1302  break;
1303 
1304  // Fall through.
1305  case OR_No_Viable_Function:
1306  ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1307  break;
1308  }
1309 
1310  return ICS;
1311 }
1312 
1313 /// TryImplicitConversion - Attempt to perform an implicit conversion
1314 /// from the given expression (Expr) to the given type (ToType). This
1315 /// function returns an implicit conversion sequence that can be used
1316 /// to perform the initialization. Given
1317 ///
1318 /// void f(float f);
1319 /// void g(int i) { f(i); }
1320 ///
1321 /// this routine would produce an implicit conversion sequence to
1322 /// describe the initialization of f from i, which will be a standard
1323 /// conversion sequence containing an lvalue-to-rvalue conversion (C++
1324 /// 4.1) followed by a floating-integral conversion (C++ 4.9).
1325 //
1326 /// Note that this routine only determines how the conversion can be
1327 /// performed; it does not actually perform the conversion. As such,
1328 /// it will not produce any diagnostics if no conversion is available,
1329 /// but will instead return an implicit conversion sequence of kind
1330 /// "BadConversion".
1331 ///
1332 /// If @p SuppressUserConversions, then user-defined conversions are
1333 /// not permitted.
1334 /// If @p AllowExplicit, then explicit user-defined conversions are
1335 /// permitted.
1336 ///
1337 /// \param AllowObjCWritebackConversion Whether we allow the Objective-C
1338 /// writeback conversion, which allows __autoreleasing id* parameters to
1339 /// be initialized with __strong id* or __weak id* arguments.
1342  bool SuppressUserConversions,
1343  bool AllowExplicit,
1344  bool InOverloadResolution,
1345  bool CStyle,
1346  bool AllowObjCWritebackConversion,
1347  bool AllowObjCConversionOnExplicit) {
1349  if (IsStandardConversion(S, From, ToType, InOverloadResolution,
1350  ICS.Standard, CStyle, AllowObjCWritebackConversion)){
1351  ICS.setStandard();
1352  return ICS;
1353  }
1354 
1355  if (!S.getLangOpts().CPlusPlus) {
1356  ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1357  return ICS;
1358  }
1359 
1360  // C++ [over.ics.user]p4:
1361  // A conversion of an expression of class type to the same class
1362  // type is given Exact Match rank, and a conversion of an
1363  // expression of class type to a base class of that type is
1364  // given Conversion rank, in spite of the fact that a copy/move
1365  // constructor (i.e., a user-defined conversion function) is
1366  // called for those cases.
1367  QualType FromType = From->getType();
1368  if (ToType->getAs<RecordType>() && FromType->getAs<RecordType>() &&
1369  (S.Context.hasSameUnqualifiedType(FromType, ToType) ||
1370  S.IsDerivedFrom(From->getBeginLoc(), FromType, ToType))) {
1371  ICS.setStandard();
1373  ICS.Standard.setFromType(FromType);
1374  ICS.Standard.setAllToTypes(ToType);
1375 
1376  // We don't actually check at this point whether there is a valid
1377  // copy/move constructor, since overloading just assumes that it
1378  // exists. When we actually perform initialization, we'll find the
1379  // appropriate constructor to copy the returned object, if needed.
1380  ICS.Standard.CopyConstructor = nullptr;
1381 
1382  // Determine whether this is considered a derived-to-base conversion.
1383  if (!S.Context.hasSameUnqualifiedType(FromType, ToType))
1385 
1386  return ICS;
1387  }
1388 
1389  return TryUserDefinedConversion(S, From, ToType, SuppressUserConversions,
1390  AllowExplicit, InOverloadResolution, CStyle,
1391  AllowObjCWritebackConversion,
1392  AllowObjCConversionOnExplicit);
1393 }
1394 
1397  bool SuppressUserConversions,
1398  bool AllowExplicit,
1399  bool InOverloadResolution,
1400  bool CStyle,
1401  bool AllowObjCWritebackConversion) {
1402  return ::TryImplicitConversion(*this, From, ToType,
1403  SuppressUserConversions, AllowExplicit,
1404  InOverloadResolution, CStyle,
1405  AllowObjCWritebackConversion,
1406  /*AllowObjCConversionOnExplicit=*/false);
1407 }
1408 
1409 /// PerformImplicitConversion - Perform an implicit conversion of the
1410 /// expression From to the type ToType. Returns the
1411 /// converted expression. Flavor is the kind of conversion we're
1412 /// performing, used in the error message. If @p AllowExplicit,
1413 /// explicit user-defined conversions are permitted.
1414 ExprResult
1416  AssignmentAction Action, bool AllowExplicit) {
1418  return PerformImplicitConversion(From, ToType, Action, AllowExplicit, ICS);
1419 }
1420 
1421 ExprResult
1423  AssignmentAction Action, bool AllowExplicit,
1425  if (checkPlaceholderForOverload(*this, From))
1426  return ExprError();
1427 
1428  // Objective-C ARC: Determine whether we will allow the writeback conversion.
1429  bool AllowObjCWritebackConversion
1430  = getLangOpts().ObjCAutoRefCount &&
1431  (Action == AA_Passing || Action == AA_Sending);
1432  if (getLangOpts().ObjC)
1433  CheckObjCBridgeRelatedConversions(From->getBeginLoc(), ToType,
1434  From->getType(), From);
1435  ICS = ::TryImplicitConversion(*this, From, ToType,
1436  /*SuppressUserConversions=*/false,
1437  AllowExplicit,
1438  /*InOverloadResolution=*/false,
1439  /*CStyle=*/false,
1440  AllowObjCWritebackConversion,
1441  /*AllowObjCConversionOnExplicit=*/false);
1442  return PerformImplicitConversion(From, ToType, ICS, Action);
1443 }
1444 
1445 /// Determine whether the conversion from FromType to ToType is a valid
1446 /// conversion that strips "noexcept" or "noreturn" off the nested function
1447 /// type.
1449  QualType &ResultTy) {
1450  if (Context.hasSameUnqualifiedType(FromType, ToType))
1451  return false;
1452 
1453  // Permit the conversion F(t __attribute__((noreturn))) -> F(t)
1454  // or F(t noexcept) -> F(t)
1455  // where F adds one of the following at most once:
1456  // - a pointer
1457  // - a member pointer
1458  // - a block pointer
1459  // Changes here need matching changes in FindCompositePointerType.
1460  CanQualType CanTo = Context.getCanonicalType(ToType);
1461  CanQualType CanFrom = Context.getCanonicalType(FromType);
1462  Type::TypeClass TyClass = CanTo->getTypeClass();
1463  if (TyClass != CanFrom->getTypeClass()) return false;
1464  if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto) {
1465  if (TyClass == Type::Pointer) {
1466  CanTo = CanTo.getAs<PointerType>()->getPointeeType();
1467  CanFrom = CanFrom.getAs<PointerType>()->getPointeeType();
1468  } else if (TyClass == Type::BlockPointer) {
1469  CanTo = CanTo.getAs<BlockPointerType>()->getPointeeType();
1470  CanFrom = CanFrom.getAs<BlockPointerType>()->getPointeeType();
1471  } else if (TyClass == Type::MemberPointer) {
1472  auto ToMPT = CanTo.getAs<MemberPointerType>();
1473  auto FromMPT = CanFrom.getAs<MemberPointerType>();
1474  // A function pointer conversion cannot change the class of the function.
1475  if (ToMPT->getClass() != FromMPT->getClass())
1476  return false;
1477  CanTo = ToMPT->getPointeeType();
1478  CanFrom = FromMPT->getPointeeType();
1479  } else {
1480  return false;
1481  }
1482 
1483  TyClass = CanTo->getTypeClass();
1484  if (TyClass != CanFrom->getTypeClass()) return false;
1485  if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto)
1486  return false;
1487  }
1488 
1489  const auto *FromFn = cast<FunctionType>(CanFrom);
1490  FunctionType::ExtInfo FromEInfo = FromFn->getExtInfo();
1491 
1492  const auto *ToFn = cast<FunctionType>(CanTo);
1493  FunctionType::ExtInfo ToEInfo = ToFn->getExtInfo();
1494 
1495  bool Changed = false;
1496 
1497  // Drop 'noreturn' if not present in target type.
1498  if (FromEInfo.getNoReturn() && !ToEInfo.getNoReturn()) {
1499  FromFn = Context.adjustFunctionType(FromFn, FromEInfo.withNoReturn(false));
1500  Changed = true;
1501  }
1502 
1503  // Drop 'noexcept' if not present in target type.
1504  if (const auto *FromFPT = dyn_cast<FunctionProtoType>(FromFn)) {
1505  const auto *ToFPT = cast<FunctionProtoType>(ToFn);
1506  if (FromFPT->isNothrow() && !ToFPT->isNothrow()) {
1507  FromFn = cast<FunctionType>(
1508  Context.getFunctionTypeWithExceptionSpec(QualType(FromFPT, 0),
1509  EST_None)
1510  .getTypePtr());
1511  Changed = true;
1512  }
1513 
1514  // Convert FromFPT's ExtParameterInfo if necessary. The conversion is valid
1515  // only if the ExtParameterInfo lists of the two function prototypes can be
1516  // merged and the merged list is identical to ToFPT's ExtParameterInfo list.
1518  bool CanUseToFPT, CanUseFromFPT;
1519  if (Context.mergeExtParameterInfo(ToFPT, FromFPT, CanUseToFPT,
1520  CanUseFromFPT, NewParamInfos) &&
1521  CanUseToFPT && !CanUseFromFPT) {
1522  FunctionProtoType::ExtProtoInfo ExtInfo = FromFPT->getExtProtoInfo();
1523  ExtInfo.ExtParameterInfos =
1524  NewParamInfos.empty() ? nullptr : NewParamInfos.data();
1525  QualType QT = Context.getFunctionType(FromFPT->getReturnType(),
1526  FromFPT->getParamTypes(), ExtInfo);
1527  FromFn = QT->getAs<FunctionType>();
1528  Changed = true;
1529  }
1530  }
1531 
1532  if (!Changed)
1533  return false;
1534 
1535  assert(QualType(FromFn, 0).isCanonical());
1536  if (QualType(FromFn, 0) != CanTo) return false;
1537 
1538  ResultTy = ToType;
1539  return true;
1540 }
1541 
1542 /// Determine whether the conversion from FromType to ToType is a valid
1543 /// vector conversion.
1544 ///
1545 /// \param ICK Will be set to the vector conversion kind, if this is a vector
1546 /// conversion.
1547 static bool IsVectorConversion(Sema &S, QualType FromType,
1548  QualType ToType, ImplicitConversionKind &ICK) {
1549  // We need at least one of these types to be a vector type to have a vector
1550  // conversion.
1551  if (!ToType->isVectorType() && !FromType->isVectorType())
1552  return false;
1553 
1554  // Identical types require no conversions.
1555  if (S.Context.hasSameUnqualifiedType(FromType, ToType))
1556  return false;
1557 
1558  // There are no conversions between extended vector types, only identity.
1559  if (ToType->isExtVectorType()) {
1560  // There are no conversions between extended vector types other than the
1561  // identity conversion.
1562  if (FromType->isExtVectorType())
1563  return false;
1564 
1565  // Vector splat from any arithmetic type to a vector.
1566  if (FromType->isArithmeticType()) {
1567  ICK = ICK_Vector_Splat;
1568  return true;
1569  }
1570  }
1571 
1572  // We can perform the conversion between vector types in the following cases:
1573  // 1)vector types are equivalent AltiVec and GCC vector types
1574  // 2)lax vector conversions are permitted and the vector types are of the
1575  // same size
1576  if (ToType->isVectorType() && FromType->isVectorType()) {
1577  if (S.Context.areCompatibleVectorTypes(FromType, ToType) ||
1578  S.isLaxVectorConversion(FromType, ToType)) {
1579  ICK = ICK_Vector_Conversion;
1580  return true;
1581  }
1582  }
1583 
1584  return false;
1585 }
1586 
1587 static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType,
1588  bool InOverloadResolution,
1590  bool CStyle);
1591 
1592 /// IsStandardConversion - Determines whether there is a standard
1593 /// conversion sequence (C++ [conv], C++ [over.ics.scs]) from the
1594 /// expression From to the type ToType. Standard conversion sequences
1595 /// only consider non-class types; for conversions that involve class
1596 /// types, use TryImplicitConversion. If a conversion exists, SCS will
1597 /// contain the standard conversion sequence required to perform this
1598 /// conversion and this routine will return true. Otherwise, this
1599 /// routine will return false and the value of SCS is unspecified.
1600 static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
1601  bool InOverloadResolution,
1603  bool CStyle,
1604  bool AllowObjCWritebackConversion) {
1605  QualType FromType = From->getType();
1606 
1607  // Standard conversions (C++ [conv])
1609  SCS.IncompatibleObjC = false;
1610  SCS.setFromType(FromType);
1611  SCS.CopyConstructor = nullptr;
1612 
1613  // There are no standard conversions for class types in C++, so
1614  // abort early. When overloading in C, however, we do permit them.
1615  if (S.getLangOpts().CPlusPlus &&
1616  (FromType->isRecordType() || ToType->isRecordType()))
1617  return false;
1618 
1619  // The first conversion can be an lvalue-to-rvalue conversion,
1620  // array-to-pointer conversion, or function-to-pointer conversion
1621  // (C++ 4p1).
1622 
1623  if (FromType == S.Context.OverloadTy) {
1624  DeclAccessPair AccessPair;
1625  if (FunctionDecl *Fn
1626  = S.ResolveAddressOfOverloadedFunction(From, ToType, false,
1627  AccessPair)) {
1628  // We were able to resolve the address of the overloaded function,
1629  // so we can convert to the type of that function.
1630  FromType = Fn->getType();
1631  SCS.setFromType(FromType);
1632 
1633  // we can sometimes resolve &foo<int> regardless of ToType, so check
1634  // if the type matches (identity) or we are converting to bool
1636  S.ExtractUnqualifiedFunctionType(ToType), FromType)) {
1637  QualType resultTy;
1638  // if the function type matches except for [[noreturn]], it's ok
1639  if (!S.IsFunctionConversion(FromType,
1640  S.ExtractUnqualifiedFunctionType(ToType), resultTy))
1641  // otherwise, only a boolean conversion is standard
1642  if (!ToType->isBooleanType())
1643  return false;
1644  }
1645 
1646  // Check if the "from" expression is taking the address of an overloaded
1647  // function and recompute the FromType accordingly. Take advantage of the
1648  // fact that non-static member functions *must* have such an address-of
1649  // expression.
1650  CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn);
1651  if (Method && !Method->isStatic()) {
1652  assert(isa<UnaryOperator>(From->IgnoreParens()) &&
1653  "Non-unary operator on non-static member address");
1654  assert(cast<UnaryOperator>(From->IgnoreParens())->getOpcode()
1655  == UO_AddrOf &&
1656  "Non-address-of operator on non-static member address");
1657  const Type *ClassType
1658  = S.Context.getTypeDeclType(Method->getParent()).getTypePtr();
1659  FromType = S.Context.getMemberPointerType(FromType, ClassType);
1660  } else if (isa<UnaryOperator>(From->IgnoreParens())) {
1661  assert(cast<UnaryOperator>(From->IgnoreParens())->getOpcode() ==
1662  UO_AddrOf &&
1663  "Non-address-of operator for overloaded function expression");
1664  FromType = S.Context.getPointerType(FromType);
1665  }
1666 
1667  // Check that we've computed the proper type after overload resolution.
1668  // FIXME: FixOverloadedFunctionReference has side-effects; we shouldn't
1669  // be calling it from within an NDEBUG block.
1670  assert(S.Context.hasSameType(
1671  FromType,
1672  S.FixOverloadedFunctionReference(From, AccessPair, Fn)->getType()));
1673  } else {
1674  return false;
1675  }
1676  }
1677  // Lvalue-to-rvalue conversion (C++11 4.1):
1678  // A glvalue (3.10) of a non-function, non-array type T can
1679  // be converted to a prvalue.
1680  bool argIsLValue = From->isGLValue();
1681  if (argIsLValue &&
1682  !FromType->isFunctionType() && !FromType->isArrayType() &&
1683  S.Context.getCanonicalType(FromType) != S.Context.OverloadTy) {
1685 
1686  // C11 6.3.2.1p2:
1687  // ... if the lvalue has atomic type, the value has the non-atomic version
1688  // of the type of the lvalue ...
1689  if (const AtomicType *Atomic = FromType->getAs<AtomicType>())
1690  FromType = Atomic->getValueType();
1691 
1692  // If T is a non-class type, the type of the rvalue is the
1693  // cv-unqualified version of T. Otherwise, the type of the rvalue
1694  // is T (C++ 4.1p1). C++ can't get here with class types; in C, we
1695  // just strip the qualifiers because they don't matter.
1696  FromType = FromType.getUnqualifiedType();
1697  } else if (FromType->isArrayType()) {
1698  // Array-to-pointer conversion (C++ 4.2)
1700 
1701  // An lvalue or rvalue of type "array of N T" or "array of unknown
1702  // bound of T" can be converted to an rvalue of type "pointer to
1703  // T" (C++ 4.2p1).
1704  FromType = S.Context.getArrayDecayedType(FromType);
1705 
1706  if (S.IsStringLiteralToNonConstPointerConversion(From, ToType)) {
1707  // This conversion is deprecated in C++03 (D.4)
1709 
1710  // For the purpose of ranking in overload resolution
1711  // (13.3.3.1.1), this conversion is considered an
1712  // array-to-pointer conversion followed by a qualification
1713  // conversion (4.4). (C++ 4.2p2)
1714  SCS.Second = ICK_Identity;
1715  SCS.Third = ICK_Qualification;
1717  SCS.setAllToTypes(FromType);
1718  return true;
1719  }
1720  } else if (FromType->isFunctionType() && argIsLValue) {
1721  // Function-to-pointer conversion (C++ 4.3).
1723 
1724  if (auto *DRE = dyn_cast<DeclRefExpr>(From->IgnoreParenCasts()))
1725  if (auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl()))
1727  return false;
1728 
1729  // An lvalue of function type T can be converted to an rvalue of
1730  // type "pointer to T." The result is a pointer to the
1731  // function. (C++ 4.3p1).
1732  FromType = S.Context.getPointerType(FromType);
1733  } else {
1734  // We don't require any conversions for the first step.
1735  SCS.First = ICK_Identity;
1736  }
1737  SCS.setToType(0, FromType);
1738 
1739  // The second conversion can be an integral promotion, floating
1740  // point promotion, integral conversion, floating point conversion,
1741  // floating-integral conversion, pointer conversion,
1742  // pointer-to-member conversion, or boolean conversion (C++ 4p1).
1743  // For overloading in C, this can also be a "compatible-type"
1744  // conversion.
1745  bool IncompatibleObjC = false;
1747  if (S.Context.hasSameUnqualifiedType(FromType, ToType)) {
1748  // The unqualified versions of the types are the same: there's no
1749  // conversion to do.
1750  SCS.Second = ICK_Identity;
1751  } else if (S.IsIntegralPromotion(From, FromType, ToType)) {
1752  // Integral promotion (C++ 4.5).
1754  FromType = ToType.getUnqualifiedType();
1755  } else if (S.IsFloatingPointPromotion(FromType, ToType)) {
1756  // Floating point promotion (C++ 4.6).
1758  FromType = ToType.getUnqualifiedType();
1759  } else if (S.IsComplexPromotion(FromType, ToType)) {
1760  // Complex promotion (Clang extension)
1762  FromType = ToType.getUnqualifiedType();
1763  } else if (ToType->isBooleanType() &&
1764  (FromType->isArithmeticType() ||
1765  FromType->isAnyPointerType() ||
1766  FromType->isBlockPointerType() ||
1767  FromType->isMemberPointerType() ||
1768  FromType->isNullPtrType())) {
1769  // Boolean conversions (C++ 4.12).
1771  FromType = S.Context.BoolTy;
1772  } else if (FromType->isIntegralOrUnscopedEnumerationType() &&
1773  ToType->isIntegralType(S.Context)) {
1774  // Integral conversions (C++ 4.7).
1776  FromType = ToType.getUnqualifiedType();
1777  } else if (FromType->isAnyComplexType() && ToType->isAnyComplexType()) {
1778  // Complex conversions (C99 6.3.1.6)
1780  FromType = ToType.getUnqualifiedType();
1781  } else if ((FromType->isAnyComplexType() && ToType->isArithmeticType()) ||
1782  (ToType->isAnyComplexType() && FromType->isArithmeticType())) {
1783  // Complex-real conversions (C99 6.3.1.7)
1784  SCS.Second = ICK_Complex_Real;
1785  FromType = ToType.getUnqualifiedType();
1786  } else if (FromType->isRealFloatingType() && ToType->isRealFloatingType()) {
1787  // FIXME: disable conversions between long double and __float128 if
1788  // their representation is different until there is back end support
1789  // We of course allow this conversion if long double is really double.
1790  if (&S.Context.getFloatTypeSemantics(FromType) !=
1791  &S.Context.getFloatTypeSemantics(ToType)) {
1792  bool Float128AndLongDouble = ((FromType == S.Context.Float128Ty &&
1793  ToType == S.Context.LongDoubleTy) ||
1794  (FromType == S.Context.LongDoubleTy &&
1795  ToType == S.Context.Float128Ty));
1796  if (Float128AndLongDouble &&
1798  &llvm::APFloat::PPCDoubleDouble()))
1799  return false;
1800  }
1801  // Floating point conversions (C++ 4.8).
1803  FromType = ToType.getUnqualifiedType();
1804  } else if ((FromType->isRealFloatingType() &&
1805  ToType->isIntegralType(S.Context)) ||
1806  (FromType->isIntegralOrUnscopedEnumerationType() &&
1807  ToType->isRealFloatingType())) {
1808  // Floating-integral conversions (C++ 4.9).
1810  FromType = ToType.getUnqualifiedType();
1811  } else if (S.IsBlockPointerConversion(FromType, ToType, FromType)) {
1813  } else if (AllowObjCWritebackConversion &&
1814  S.isObjCWritebackConversion(FromType, ToType, FromType)) {
1816  } else if (S.IsPointerConversion(From, FromType, ToType, InOverloadResolution,
1817  FromType, IncompatibleObjC)) {
1818  // Pointer conversions (C++ 4.10).
1820  SCS.IncompatibleObjC = IncompatibleObjC;
1821  FromType = FromType.getUnqualifiedType();
1822  } else if (S.IsMemberPointerConversion(From, FromType, ToType,
1823  InOverloadResolution, FromType)) {
1824  // Pointer to member conversions (4.11).
1825  SCS.Second = ICK_Pointer_Member;
1826  } else if (IsVectorConversion(S, FromType, ToType, SecondICK)) {
1827  SCS.Second = SecondICK;
1828  FromType = ToType.getUnqualifiedType();
1829  } else if (!S.getLangOpts().CPlusPlus &&
1830  S.Context.typesAreCompatible(ToType, FromType)) {
1831  // Compatible conversions (Clang extension for C function overloading)
1833  FromType = ToType.getUnqualifiedType();
1834  } else if (IsTransparentUnionStandardConversion(S, From, ToType,
1835  InOverloadResolution,
1836  SCS, CStyle)) {
1838  FromType = ToType;
1839  } else if (tryAtomicConversion(S, From, ToType, InOverloadResolution, SCS,
1840  CStyle)) {
1841  // tryAtomicConversion has updated the standard conversion sequence
1842  // appropriately.
1843  return true;
1844  } else if (ToType->isEventT() &&
1845  From->isIntegerConstantExpr(S.getASTContext()) &&
1846  From->EvaluateKnownConstInt(S.getASTContext()) == 0) {
1848  FromType = ToType;
1849  } else if (ToType->isQueueT() &&
1850  From->isIntegerConstantExpr(S.getASTContext()) &&
1851  (From->EvaluateKnownConstInt(S.getASTContext()) == 0)) {
1853  FromType = ToType;
1854  } else if (ToType->isSamplerT() &&
1855  From->isIntegerConstantExpr(S.getASTContext())) {
1857  FromType = ToType;
1858  } else {
1859  // No second conversion required.
1860  SCS.Second = ICK_Identity;
1861  }
1862  SCS.setToType(1, FromType);
1863 
1864  // The third conversion can be a function pointer conversion or a
1865  // qualification conversion (C++ [conv.fctptr], [conv.qual]).
1866  bool ObjCLifetimeConversion;
1867  if (S.IsFunctionConversion(FromType, ToType, FromType)) {
1868  // Function pointer conversions (removing 'noexcept') including removal of
1869  // 'noreturn' (Clang extension).
1871  } else if (S.IsQualificationConversion(FromType, ToType, CStyle,
1872  ObjCLifetimeConversion)) {
1873  SCS.Third = ICK_Qualification;
1874  SCS.QualificationIncludesObjCLifetime = ObjCLifetimeConversion;
1875  FromType = ToType;
1876  } else {
1877  // No conversion required
1878  SCS.Third = ICK_Identity;
1879  }
1880 
1881  // C++ [over.best.ics]p6:
1882  // [...] Any difference in top-level cv-qualification is
1883  // subsumed by the initialization itself and does not constitute
1884  // a conversion. [...]
1885  QualType CanonFrom = S.Context.getCanonicalType(FromType);
1886  QualType CanonTo = S.Context.getCanonicalType(ToType);
1887  if (CanonFrom.getLocalUnqualifiedType()
1888  == CanonTo.getLocalUnqualifiedType() &&
1889  CanonFrom.getLocalQualifiers() != CanonTo.getLocalQualifiers()) {
1890  FromType = ToType;
1891  CanonFrom = CanonTo;
1892  }
1893 
1894  SCS.setToType(2, FromType);
1895 
1896  if (CanonFrom == CanonTo)
1897  return true;
1898 
1899  // If we have not converted the argument type to the parameter type,
1900  // this is a bad conversion sequence, unless we're resolving an overload in C.
1901  if (S.getLangOpts().CPlusPlus || !InOverloadResolution)
1902  return false;
1903 
1904  ExprResult ER = ExprResult{From};
1906  S.CheckSingleAssignmentConstraints(ToType, ER,
1907  /*Diagnose=*/false,
1908  /*DiagnoseCFAudited=*/false,
1909  /*ConvertRHS=*/false);
1910  ImplicitConversionKind SecondConv;
1911  switch (Conv) {
1912  case Sema::Compatible:
1913  SecondConv = ICK_C_Only_Conversion;
1914  break;
1915  // For our purposes, discarding qualifiers is just as bad as using an
1916  // incompatible pointer. Note that an IncompatiblePointer conversion can drop
1917  // qualifiers, as well.
1922  break;
1923  default:
1924  return false;
1925  }
1926 
1927  // First can only be an lvalue conversion, so we pretend that this was the
1928  // second conversion. First should already be valid from earlier in the
1929  // function.
1930  SCS.Second = SecondConv;
1931  SCS.setToType(1, ToType);
1932 
1933  // Third is Identity, because Second should rank us worse than any other
1934  // conversion. This could also be ICK_Qualification, but it's simpler to just
1935  // lump everything in with the second conversion, and we don't gain anything
1936  // from making this ICK_Qualification.
1937  SCS.Third = ICK_Identity;
1938  SCS.setToType(2, ToType);
1939  return true;
1940 }
1941 
1942 static bool
1944  QualType &ToType,
1945  bool InOverloadResolution,
1947  bool CStyle) {
1948 
1949  const RecordType *UT = ToType->getAsUnionType();
1950  if (!UT || !UT->getDecl()->hasAttr<TransparentUnionAttr>())
1951  return false;
1952  // The field to initialize within the transparent union.
1953  RecordDecl *UD = UT->getDecl();
1954  // It's compatible if the expression matches any of the fields.
1955  for (const auto *it : UD->fields()) {
1956  if (IsStandardConversion(S, From, it->getType(), InOverloadResolution, SCS,
1957  CStyle, /*AllowObjCWritebackConversion=*/false)) {
1958  ToType = it->getType();
1959  return true;
1960  }
1961  }
1962  return false;
1963 }
1964 
1965 /// IsIntegralPromotion - Determines whether the conversion from the
1966 /// expression From (whose potentially-adjusted type is FromType) to
1967 /// ToType is an integral promotion (C++ 4.5). If so, returns true and
1968 /// sets PromotedType to the promoted type.
1969 bool Sema::IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType) {
1970  const BuiltinType *To = ToType->getAs<BuiltinType>();
1971  // All integers are built-in.
1972  if (!To) {
1973  return false;
1974  }
1975 
1976  // An rvalue of type char, signed char, unsigned char, short int, or
1977  // unsigned short int can be converted to an rvalue of type int if
1978  // int can represent all the values of the source type; otherwise,
1979  // the source rvalue can be converted to an rvalue of type unsigned
1980  // int (C++ 4.5p1).
1981  if (FromType->isPromotableIntegerType() && !FromType->isBooleanType() &&
1982  !FromType->isEnumeralType()) {
1983  if (// We can promote any signed, promotable integer type to an int
1984  (FromType->isSignedIntegerType() ||
1985  // We can promote any unsigned integer type whose size is
1986  // less than int to an int.
1987  Context.getTypeSize(FromType) < Context.getTypeSize(ToType))) {
1988  return To->getKind() == BuiltinType::Int;
1989  }
1990 
1991  return To->getKind() == BuiltinType::UInt;
1992  }
1993 
1994  // C++11 [conv.prom]p3:
1995  // A prvalue of an unscoped enumeration type whose underlying type is not
1996  // fixed (7.2) can be converted to an rvalue a prvalue of the first of the
1997  // following types that can represent all the values of the enumeration
1998  // (i.e., the values in the range bmin to bmax as described in 7.2): int,
1999  // unsigned int, long int, unsigned long int, long long int, or unsigned
2000  // long long int. If none of the types in that list can represent all the
2001  // values of the enumeration, an rvalue a prvalue of an unscoped enumeration
2002  // type can be converted to an rvalue a prvalue of the extended integer type
2003  // with lowest integer conversion rank (4.13) greater than the rank of long
2004  // long in which all the values of the enumeration can be represented. If
2005  // there are two such extended types, the signed one is chosen.
2006  // C++11 [conv.prom]p4:
2007  // A prvalue of an unscoped enumeration type whose underlying type is fixed
2008  // can be converted to a prvalue of its underlying type. Moreover, if
2009  // integral promotion can be applied to its underlying type, a prvalue of an
2010  // unscoped enumeration type whose underlying type is fixed can also be
2011  // converted to a prvalue of the promoted underlying type.
2012  if (const EnumType *FromEnumType = FromType->getAs<EnumType>()) {
2013  // C++0x 7.2p9: Note that this implicit enum to int conversion is not
2014  // provided for a scoped enumeration.
2015  if (FromEnumType->getDecl()->isScoped())
2016  return false;
2017 
2018  // We can perform an integral promotion to the underlying type of the enum,
2019  // even if that's not the promoted type. Note that the check for promoting
2020  // the underlying type is based on the type alone, and does not consider
2021  // the bitfield-ness of the actual source expression.
2022  if (FromEnumType->getDecl()->isFixed()) {
2023  QualType Underlying = FromEnumType->getDecl()->getIntegerType();
2024  return Context.hasSameUnqualifiedType(Underlying, ToType) ||
2025  IsIntegralPromotion(nullptr, Underlying, ToType);
2026  }
2027 
2028  // We have already pre-calculated the promotion type, so this is trivial.
2029  if (ToType->isIntegerType() &&
2030  isCompleteType(From->getBeginLoc(), FromType))
2031  return Context.hasSameUnqualifiedType(
2032  ToType, FromEnumType->getDecl()->getPromotionType());
2033 
2034  // C++ [conv.prom]p5:
2035  // If the bit-field has an enumerated type, it is treated as any other
2036  // value of that type for promotion purposes.
2037  //
2038  // ... so do not fall through into the bit-field checks below in C++.
2039  if (getLangOpts().CPlusPlus)
2040  return false;
2041  }
2042 
2043  // C++0x [conv.prom]p2:
2044  // A prvalue of type char16_t, char32_t, or wchar_t (3.9.1) can be converted
2045  // to an rvalue a prvalue of the first of the following types that can
2046  // represent all the values of its underlying type: int, unsigned int,
2047  // long int, unsigned long int, long long int, or unsigned long long int.
2048  // If none of the types in that list can represent all the values of its
2049  // underlying type, an rvalue a prvalue of type char16_t, char32_t,
2050  // or wchar_t can be converted to an rvalue a prvalue of its underlying
2051  // type.
2052  if (FromType->isAnyCharacterType() && !FromType->isCharType() &&
2053  ToType->isIntegerType()) {
2054  // Determine whether the type we're converting from is signed or
2055  // unsigned.
2056  bool FromIsSigned = FromType->isSignedIntegerType();
2057  uint64_t FromSize = Context.getTypeSize(FromType);
2058 
2059  // The types we'll try to promote to, in the appropriate
2060  // order. Try each of these types.
2061  QualType PromoteTypes[6] = {
2062  Context.IntTy, Context.UnsignedIntTy,
2063  Context.LongTy, Context.UnsignedLongTy ,
2064  Context.LongLongTy, Context.UnsignedLongLongTy
2065  };
2066  for (int Idx = 0; Idx < 6; ++Idx) {
2067  uint64_t ToSize = Context.getTypeSize(PromoteTypes[Idx]);
2068  if (FromSize < ToSize ||
2069  (FromSize == ToSize &&
2070  FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType())) {
2071  // We found the type that we can promote to. If this is the
2072  // type we wanted, we have a promotion. Otherwise, no
2073  // promotion.
2074  return Context.hasSameUnqualifiedType(ToType, PromoteTypes[Idx]);
2075  }
2076  }
2077  }
2078 
2079  // An rvalue for an integral bit-field (9.6) can be converted to an
2080  // rvalue of type int if int can represent all the values of the
2081  // bit-field; otherwise, it can be converted to unsigned int if
2082  // unsigned int can represent all the values of the bit-field. If
2083  // the bit-field is larger yet, no integral promotion applies to
2084  // it. If the bit-field has an enumerated type, it is treated as any
2085  // other value of that type for promotion purposes (C++ 4.5p3).
2086  // FIXME: We should delay checking of bit-fields until we actually perform the
2087  // conversion.
2088  //
2089  // FIXME: In C, only bit-fields of types _Bool, int, or unsigned int may be
2090  // promoted, per C11 6.3.1.1/2. We promote all bit-fields (including enum
2091  // bit-fields and those whose underlying type is larger than int) for GCC
2092  // compatibility.
2093  if (From) {
2094  if (FieldDecl *MemberDecl = From->getSourceBitField()) {
2095  llvm::APSInt BitWidth;
2096  if (FromType->isIntegralType(Context) &&
2097  MemberDecl->getBitWidth()->isIntegerConstantExpr(BitWidth, Context)) {
2098  llvm::APSInt ToSize(BitWidth.getBitWidth(), BitWidth.isUnsigned());
2099  ToSize = Context.getTypeSize(ToType);
2100 
2101  // Are we promoting to an int from a bitfield that fits in an int?
2102  if (BitWidth < ToSize ||
2103  (FromType->isSignedIntegerType() && BitWidth <= ToSize)) {
2104  return To->getKind() == BuiltinType::Int;
2105  }
2106 
2107  // Are we promoting to an unsigned int from an unsigned bitfield
2108  // that fits into an unsigned int?
2109  if (FromType->isUnsignedIntegerType() && BitWidth <= ToSize) {
2110  return To->getKind() == BuiltinType::UInt;
2111  }
2112 
2113  return false;
2114  }
2115  }
2116  }
2117 
2118  // An rvalue of type bool can be converted to an rvalue of type int,
2119  // with false becoming zero and true becoming one (C++ 4.5p4).
2120  if (FromType->isBooleanType() && To->getKind() == BuiltinType::Int) {
2121  return true;
2122  }
2123 
2124  return false;
2125 }
2126 
2127 /// IsFloatingPointPromotion - Determines whether the conversion from
2128 /// FromType to ToType is a floating point promotion (C++ 4.6). If so,
2129 /// returns true and sets PromotedType to the promoted type.
2131  if (const BuiltinType *FromBuiltin = FromType->getAs<BuiltinType>())
2132  if (const BuiltinType *ToBuiltin = ToType->getAs<BuiltinType>()) {
2133  /// An rvalue of type float can be converted to an rvalue of type
2134  /// double. (C++ 4.6p1).
2135  if (FromBuiltin->getKind() == BuiltinType::Float &&
2136  ToBuiltin->getKind() == BuiltinType::Double)
2137  return true;
2138 
2139  // C99 6.3.1.5p1:
2140  // When a float is promoted to double or long double, or a
2141  // double is promoted to long double [...].
2142  if (!getLangOpts().CPlusPlus &&
2143  (FromBuiltin->getKind() == BuiltinType::Float ||
2144  FromBuiltin->getKind() == BuiltinType::Double) &&
2145  (ToBuiltin->getKind() == BuiltinType::LongDouble ||
2146  ToBuiltin->getKind() == BuiltinType::Float128))
2147  return true;
2148 
2149  // Half can be promoted to float.
2150  if (!getLangOpts().NativeHalfType &&
2151  FromBuiltin->getKind() == BuiltinType::Half &&
2152  ToBuiltin->getKind() == BuiltinType::Float)
2153  return true;
2154  }
2155 
2156  return false;
2157 }
2158 
2159 /// Determine if a conversion is a complex promotion.
2160 ///
2161 /// A complex promotion is defined as a complex -> complex conversion
2162 /// where the conversion between the underlying real types is a
2163 /// floating-point or integral promotion.
2165  const ComplexType *FromComplex = FromType->getAs<ComplexType>();
2166  if (!FromComplex)
2167  return false;
2168 
2169  const ComplexType *ToComplex = ToType->getAs<ComplexType>();
2170  if (!ToComplex)
2171  return false;
2172 
2173  return IsFloatingPointPromotion(FromComplex->getElementType(),
2174  ToComplex->getElementType()) ||
2175  IsIntegralPromotion(nullptr, FromComplex->getElementType(),
2176  ToComplex->getElementType());
2177 }
2178 
2179 /// BuildSimilarlyQualifiedPointerType - In a pointer conversion from
2180 /// the pointer type FromPtr to a pointer to type ToPointee, with the
2181 /// same type qualifiers as FromPtr has on its pointee type. ToType,
2182 /// if non-empty, will be a pointer to ToType that may or may not have
2183 /// the right set of qualifiers on its pointee.
2184 ///
2185 static QualType
2187  QualType ToPointee, QualType ToType,
2188  ASTContext &Context,
2189  bool StripObjCLifetime = false) {
2190  assert((FromPtr->getTypeClass() == Type::Pointer ||
2191  FromPtr->getTypeClass() == Type::ObjCObjectPointer) &&
2192  "Invalid similarly-qualified pointer type");
2193 
2194  /// Conversions to 'id' subsume cv-qualifier conversions.
2195  if (ToType->isObjCIdType() || ToType->isObjCQualifiedIdType())
2196  return ToType.getUnqualifiedType();
2197 
2198  QualType CanonFromPointee
2199  = Context.getCanonicalType(FromPtr->getPointeeType());
2200  QualType CanonToPointee = Context.getCanonicalType(ToPointee);
2201  Qualifiers Quals = CanonFromPointee.getQualifiers();
2202 
2203  if (StripObjCLifetime)
2204  Quals.removeObjCLifetime();
2205 
2206  // Exact qualifier match -> return the pointer type we're converting to.
2207  if (CanonToPointee.getLocalQualifiers() == Quals) {
2208  // ToType is exactly what we need. Return it.
2209  if (!ToType.isNull())
2210  return ToType.getUnqualifiedType();
2211 
2212  // Build a pointer to ToPointee. It has the right qualifiers
2213  // already.
2214  if (isa<ObjCObjectPointerType>(ToType))
2215  return Context.getObjCObjectPointerType(ToPointee);
2216  return Context.getPointerType(ToPointee);
2217  }
2218 
2219  // Just build a canonical type that has the right qualifiers.
2220  QualType QualifiedCanonToPointee
2221  = Context.getQualifiedType(CanonToPointee.getLocalUnqualifiedType(), Quals);
2222 
2223  if (isa<ObjCObjectPointerType>(ToType))
2224  return Context.getObjCObjectPointerType(QualifiedCanonToPointee);
2225  return Context.getPointerType(QualifiedCanonToPointee);
2226 }
2227 
2229  bool InOverloadResolution,
2230  ASTContext &Context) {
2231  // Handle value-dependent integral null pointer constants correctly.
2232  // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#903
2233  if (Expr->isValueDependent() && !Expr->isTypeDependent() &&
2234  Expr->getType()->isIntegerType() && !Expr->getType()->isEnumeralType())
2235  return !InOverloadResolution;
2236 
2237  return Expr->isNullPointerConstant(Context,
2238  InOverloadResolution? Expr::NPC_ValueDependentIsNotNull
2240 }
2241 
2242 /// IsPointerConversion - Determines whether the conversion of the
2243 /// expression From, which has the (possibly adjusted) type FromType,
2244 /// can be converted to the type ToType via a pointer conversion (C++
2245 /// 4.10). If so, returns true and places the converted type (that
2246 /// might differ from ToType in its cv-qualifiers at some level) into
2247 /// ConvertedType.
2248 ///
2249 /// This routine also supports conversions to and from block pointers
2250 /// and conversions with Objective-C's 'id', 'id<protocols...>', and
2251 /// pointers to interfaces. FIXME: Once we've determined the
2252 /// appropriate overloading rules for Objective-C, we may want to
2253 /// split the Objective-C checks into a different routine; however,
2254 /// GCC seems to consider all of these conversions to be pointer
2255 /// conversions, so for now they live here. IncompatibleObjC will be
2256 /// set if the conversion is an allowed Objective-C conversion that
2257 /// should result in a warning.
2258 bool Sema::IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
2259  bool InOverloadResolution,
2260  QualType& ConvertedType,
2261  bool &IncompatibleObjC) {
2262  IncompatibleObjC = false;
2263  if (isObjCPointerConversion(FromType, ToType, ConvertedType,
2264  IncompatibleObjC))
2265  return true;
2266 
2267  // Conversion from a null pointer constant to any Objective-C pointer type.
2268  if (ToType->isObjCObjectPointerType() &&
2269  isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
2270  ConvertedType = ToType;
2271  return true;
2272  }
2273 
2274  // Blocks: Block pointers can be converted to void*.
2275  if (FromType->isBlockPointerType() && ToType->isPointerType() &&
2276  ToType->getAs<PointerType>()->getPointeeType()->isVoidType()) {
2277  ConvertedType = ToType;
2278  return true;
2279  }
2280  // Blocks: A null pointer constant can be converted to a block
2281  // pointer type.
2282  if (ToType->isBlockPointerType() &&
2283  isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
2284  ConvertedType = ToType;
2285  return true;
2286  }
2287 
2288  // If the left-hand-side is nullptr_t, the right side can be a null
2289  // pointer constant.
2290  if (ToType->isNullPtrType() &&
2291  isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
2292  ConvertedType = ToType;
2293  return true;
2294  }
2295 
2296  const PointerType* ToTypePtr = ToType->getAs<PointerType>();
2297  if (!ToTypePtr)
2298  return false;
2299 
2300  // A null pointer constant can be converted to a pointer type (C++ 4.10p1).
2301  if (isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
2302  ConvertedType = ToType;
2303  return true;
2304  }
2305 
2306  // Beyond this point, both types need to be pointers
2307  // , including objective-c pointers.
2308  QualType ToPointeeType = ToTypePtr->getPointeeType();
2309  if (FromType->isObjCObjectPointerType() && ToPointeeType->isVoidType() &&
2310  !getLangOpts().ObjCAutoRefCount) {
2311  ConvertedType = BuildSimilarlyQualifiedPointerType(
2312  FromType->getAs<ObjCObjectPointerType>(),
2313  ToPointeeType,
2314  ToType, Context);
2315  return true;
2316  }
2317  const PointerType *FromTypePtr = FromType->getAs<PointerType>();
2318  if (!FromTypePtr)
2319  return false;
2320 
2321  QualType FromPointeeType = FromTypePtr->getPointeeType();
2322 
2323  // If the unqualified pointee types are the same, this can't be a
2324  // pointer conversion, so don't do all of the work below.
2325  if (Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType))
2326  return false;
2327 
2328  // An rvalue of type "pointer to cv T," where T is an object type,
2329  // can be converted to an rvalue of type "pointer to cv void" (C++
2330  // 4.10p2).
2331  if (FromPointeeType->isIncompleteOrObjectType() &&
2332  ToPointeeType->isVoidType()) {
2333  ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2334  ToPointeeType,
2335  ToType, Context,
2336  /*StripObjCLifetime=*/true);
2337  return true;
2338  }
2339 
2340  // MSVC allows implicit function to void* type conversion.
2341  if (getLangOpts().MSVCCompat && FromPointeeType->isFunctionType() &&
2342  ToPointeeType->isVoidType()) {
2343  ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2344  ToPointeeType,
2345  ToType, Context);
2346  return true;
2347  }
2348 
2349  // When we're overloading in C, we allow a special kind of pointer
2350  // conversion for compatible-but-not-identical pointee types.
2351  if (!getLangOpts().CPlusPlus &&
2352  Context.typesAreCompatible(FromPointeeType, ToPointeeType)) {
2353  ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2354  ToPointeeType,
2355  ToType, Context);
2356  return true;
2357  }
2358 
2359  // C++ [conv.ptr]p3:
2360  //
2361  // An rvalue of type "pointer to cv D," where D is a class type,
2362  // can be converted to an rvalue of type "pointer to cv B," where
2363  // B is a base class (clause 10) of D. If B is an inaccessible
2364  // (clause 11) or ambiguous (10.2) base class of D, a program that
2365  // necessitates this conversion is ill-formed. The result of the
2366  // conversion is a pointer to the base class sub-object of the
2367  // derived class object. The null pointer value is converted to
2368  // the null pointer value of the destination type.
2369  //
2370  // Note that we do not check for ambiguity or inaccessibility
2371  // here. That is handled by CheckPointerConversion.
2372  if (getLangOpts().CPlusPlus && FromPointeeType->isRecordType() &&
2373  ToPointeeType->isRecordType() &&
2374  !Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType) &&
2375  IsDerivedFrom(From->getBeginLoc(), FromPointeeType, ToPointeeType)) {
2376  ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2377  ToPointeeType,
2378  ToType, Context);
2379  return true;
2380  }
2381 
2382  if (FromPointeeType->isVectorType() && ToPointeeType->isVectorType() &&
2383  Context.areCompatibleVectorTypes(FromPointeeType, ToPointeeType)) {
2384  ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2385  ToPointeeType,
2386  ToType, Context);
2387  return true;
2388  }
2389 
2390  return false;
2391 }
2392 
2393 /// Adopt the given qualifiers for the given type.
2395  Qualifiers TQs = T.getQualifiers();
2396 
2397  // Check whether qualifiers already match.
2398  if (TQs == Qs)
2399  return T;
2400 
2401  if (Qs.compatiblyIncludes(TQs))
2402  return Context.getQualifiedType(T, Qs);
2403 
2404  return Context.getQualifiedType(T.getUnqualifiedType(), Qs);
2405 }
2406 
2407 /// isObjCPointerConversion - Determines whether this is an
2408 /// Objective-C pointer conversion. Subroutine of IsPointerConversion,
2409 /// with the same arguments and return values.
2411  QualType& ConvertedType,
2412  bool &IncompatibleObjC) {
2413  if (!getLangOpts().ObjC)
2414  return false;
2415 
2416  // The set of qualifiers on the type we're converting from.
2417  Qualifiers FromQualifiers = FromType.getQualifiers();
2418 
2419  // First, we handle all conversions on ObjC object pointer types.
2420  const ObjCObjectPointerType* ToObjCPtr =
2421  ToType->getAs<ObjCObjectPointerType>();
2422  const ObjCObjectPointerType *FromObjCPtr =
2423  FromType->getAs<ObjCObjectPointerType>();
2424 
2425  if (ToObjCPtr && FromObjCPtr) {
2426  // If the pointee types are the same (ignoring qualifications),
2427  // then this is not a pointer conversion.
2428  if (Context.hasSameUnqualifiedType(ToObjCPtr->getPointeeType(),
2429  FromObjCPtr->getPointeeType()))
2430  return false;
2431 
2432  // Conversion between Objective-C pointers.
2433  if (Context.canAssignObjCInterfaces(ToObjCPtr, FromObjCPtr)) {
2434  const ObjCInterfaceType* LHS = ToObjCPtr->getInterfaceType();
2435  const ObjCInterfaceType* RHS = FromObjCPtr->getInterfaceType();
2436  if (getLangOpts().CPlusPlus && LHS && RHS &&
2437  !ToObjCPtr->getPointeeType().isAtLeastAsQualifiedAs(
2438  FromObjCPtr->getPointeeType()))
2439  return false;
2440  ConvertedType = BuildSimilarlyQualifiedPointerType(FromObjCPtr,
2441  ToObjCPtr->getPointeeType(),
2442  ToType, Context);
2443  ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2444  return true;
2445  }
2446 
2447  if (Context.canAssignObjCInterfaces(FromObjCPtr, ToObjCPtr)) {
2448  // Okay: this is some kind of implicit downcast of Objective-C
2449  // interfaces, which is permitted. However, we're going to
2450  // complain about it.
2451  IncompatibleObjC = true;
2452  ConvertedType = BuildSimilarlyQualifiedPointerType(FromObjCPtr,
2453  ToObjCPtr->getPointeeType(),
2454  ToType, Context);
2455  ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2456  return true;
2457  }
2458  }
2459  // Beyond this point, both types need to be C pointers or block pointers.
2460  QualType ToPointeeType;
2461  if (const PointerType *ToCPtr = ToType->getAs<PointerType>())
2462  ToPointeeType = ToCPtr->getPointeeType();
2463  else if (const BlockPointerType *ToBlockPtr =
2464  ToType->getAs<BlockPointerType>()) {
2465  // Objective C++: We're able to convert from a pointer to any object
2466  // to a block pointer type.
2467  if (FromObjCPtr && FromObjCPtr->isObjCBuiltinType()) {
2468  ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2469  return true;
2470  }
2471  ToPointeeType = ToBlockPtr->getPointeeType();
2472  }
2473  else if (FromType->getAs<BlockPointerType>() &&
2474  ToObjCPtr && ToObjCPtr->isObjCBuiltinType()) {
2475  // Objective C++: We're able to convert from a block pointer type to a
2476  // pointer to any object.
2477  ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2478  return true;
2479  }
2480  else
2481  return false;
2482 
2483  QualType FromPointeeType;
2484  if (const PointerType *FromCPtr = FromType->getAs<PointerType>())
2485  FromPointeeType = FromCPtr->getPointeeType();
2486  else if (const BlockPointerType *FromBlockPtr =
2487  FromType->getAs<BlockPointerType>())
2488  FromPointeeType = FromBlockPtr->getPointeeType();
2489  else
2490  return false;
2491 
2492  // If we have pointers to pointers, recursively check whether this
2493  // is an Objective-C conversion.
2494  if (FromPointeeType->isPointerType() && ToPointeeType->isPointerType() &&
2495  isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType,
2496  IncompatibleObjC)) {
2497  // We always complain about this conversion.
2498  IncompatibleObjC = true;
2499  ConvertedType = Context.getPointerType(ConvertedType);
2500  ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2501  return true;
2502  }
2503  // Allow conversion of pointee being objective-c pointer to another one;
2504  // as in I* to id.
2505  if (FromPointeeType->getAs<ObjCObjectPointerType>() &&
2506  ToPointeeType->getAs<ObjCObjectPointerType>() &&
2507  isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType,
2508  IncompatibleObjC)) {
2509 
2510  ConvertedType = Context.getPointerType(ConvertedType);
2511  ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2512  return true;
2513  }
2514 
2515  // If we have pointers to functions or blocks, check whether the only
2516  // differences in the argument and result types are in Objective-C
2517  // pointer conversions. If so, we permit the conversion (but
2518  // complain about it).
2519  const FunctionProtoType *FromFunctionType
2520  = FromPointeeType->getAs<FunctionProtoType>();
2521  const FunctionProtoType *ToFunctionType
2522  = ToPointeeType->getAs<FunctionProtoType>();
2523  if (FromFunctionType && ToFunctionType) {
2524  // If the function types are exactly the same, this isn't an
2525  // Objective-C pointer conversion.
2526  if (Context.getCanonicalType(FromPointeeType)
2527  == Context.getCanonicalType(ToPointeeType))
2528  return false;
2529 
2530  // Perform the quick checks that will tell us whether these
2531  // function types are obviously different.
2532  if (FromFunctionType->getNumParams() != ToFunctionType->getNumParams() ||
2533  FromFunctionType->isVariadic() != ToFunctionType->isVariadic() ||
2534  FromFunctionType->getMethodQuals() != ToFunctionType->getMethodQuals())
2535  return false;
2536 
2537  bool HasObjCConversion = false;
2538  if (Context.getCanonicalType(FromFunctionType->getReturnType()) ==
2539  Context.getCanonicalType(ToFunctionType->getReturnType())) {
2540  // Okay, the types match exactly. Nothing to do.
2541  } else if (isObjCPointerConversion(FromFunctionType->getReturnType(),
2542  ToFunctionType->getReturnType(),
2543  ConvertedType, IncompatibleObjC)) {
2544  // Okay, we have an Objective-C pointer conversion.
2545  HasObjCConversion = true;
2546  } else {
2547  // Function types are too different. Abort.
2548  return false;
2549  }
2550 
2551  // Check argument types.
2552  for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumParams();
2553  ArgIdx != NumArgs; ++ArgIdx) {
2554  QualType FromArgType = FromFunctionType->getParamType(ArgIdx);
2555  QualType ToArgType = ToFunctionType->getParamType(ArgIdx);
2556  if (Context.getCanonicalType(FromArgType)
2557  == Context.getCanonicalType(ToArgType)) {
2558  // Okay, the types match exactly. Nothing to do.
2559  } else if (isObjCPointerConversion(FromArgType, ToArgType,
2560  ConvertedType, IncompatibleObjC)) {
2561  // Okay, we have an Objective-C pointer conversion.
2562  HasObjCConversion = true;
2563  } else {
2564  // Argument types are too different. Abort.
2565  return false;
2566  }
2567  }
2568 
2569  if (HasObjCConversion) {
2570  // We had an Objective-C conversion. Allow this pointer
2571  // conversion, but complain about it.
2572  ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2573  IncompatibleObjC = true;
2574  return true;
2575  }
2576  }
2577 
2578  return false;
2579 }
2580 
2581 /// Determine whether this is an Objective-C writeback conversion,
2582 /// used for parameter passing when performing automatic reference counting.
2583 ///
2584 /// \param FromType The type we're converting form.
2585 ///
2586 /// \param ToType The type we're converting to.
2587 ///
2588 /// \param ConvertedType The type that will be produced after applying
2589 /// this conversion.
2591  QualType &ConvertedType) {
2592  if (!getLangOpts().ObjCAutoRefCount ||
2593  Context.hasSameUnqualifiedType(FromType, ToType))
2594  return false;
2595 
2596  // Parameter must be a pointer to __autoreleasing (with no other qualifiers).
2597  QualType ToPointee;
2598  if (const PointerType *ToPointer = ToType->getAs<PointerType>())
2599  ToPointee = ToPointer->getPointeeType();
2600  else
2601  return false;
2602 
2603  Qualifiers ToQuals = ToPointee.getQualifiers();
2604  if (!ToPointee->isObjCLifetimeType() ||
2606  !ToQuals.withoutObjCLifetime().empty())
2607  return false;
2608 
2609  // Argument must be a pointer to __strong to __weak.
2610  QualType FromPointee;
2611  if (const PointerType *FromPointer = FromType->getAs<PointerType>())
2612  FromPointee = FromPointer->getPointeeType();
2613  else
2614  return false;
2615 
2616  Qualifiers FromQuals = FromPointee.getQualifiers();
2617  if (!FromPointee->isObjCLifetimeType() ||
2618  (FromQuals.getObjCLifetime() != Qualifiers::OCL_Strong &&
2619  FromQuals.getObjCLifetime() != Qualifiers::OCL_Weak))
2620  return false;
2621 
2622  // Make sure that we have compatible qualifiers.
2624  if (!ToQuals.compatiblyIncludes(FromQuals))
2625  return false;
2626 
2627  // Remove qualifiers from the pointee type we're converting from; they
2628  // aren't used in the compatibility check belong, and we'll be adding back
2629  // qualifiers (with __autoreleasing) if the compatibility check succeeds.
2630  FromPointee = FromPointee.getUnqualifiedType();
2631 
2632  // The unqualified form of the pointee types must be compatible.
2633  ToPointee = ToPointee.getUnqualifiedType();
2634  bool IncompatibleObjC;
2635  if (Context.typesAreCompatible(FromPointee, ToPointee))
2636  FromPointee = ToPointee;
2637  else if (!isObjCPointerConversion(FromPointee, ToPointee, FromPointee,
2638  IncompatibleObjC))
2639  return false;
2640 
2641  /// Construct the type we're converting to, which is a pointer to
2642  /// __autoreleasing pointee.
2643  FromPointee = Context.getQualifiedType(FromPointee, FromQuals);
2644  ConvertedType = Context.getPointerType(FromPointee);
2645  return true;
2646 }
2647 
2649  QualType& ConvertedType) {
2650  QualType ToPointeeType;
2651  if (const BlockPointerType *ToBlockPtr =
2652  ToType->getAs<BlockPointerType>())
2653  ToPointeeType = ToBlockPtr->getPointeeType();
2654  else
2655  return false;
2656 
2657  QualType FromPointeeType;
2658  if (const BlockPointerType *FromBlockPtr =
2659  FromType->getAs<BlockPointerType>())
2660  FromPointeeType = FromBlockPtr->getPointeeType();
2661  else
2662  return false;
2663  // We have pointer to blocks, check whether the only
2664  // differences in the argument and result types are in Objective-C
2665  // pointer conversions. If so, we permit the conversion.
2666 
2667  const FunctionProtoType *FromFunctionType
2668  = FromPointeeType->getAs<FunctionProtoType>();
2669  const FunctionProtoType *ToFunctionType
2670  = ToPointeeType->getAs<FunctionProtoType>();
2671 
2672  if (!FromFunctionType || !ToFunctionType)
2673  return false;
2674 
2675  if (Context.hasSameType(FromPointeeType, ToPointeeType))
2676  return true;
2677 
2678  // Perform the quick checks that will tell us whether these
2679  // function types are obviously different.
2680  if (FromFunctionType->getNumParams() != ToFunctionType->getNumParams() ||
2681  FromFunctionType->isVariadic() != ToFunctionType->isVariadic())
2682  return false;
2683 
2684  FunctionType::ExtInfo FromEInfo = FromFunctionType->getExtInfo();
2685  FunctionType::ExtInfo ToEInfo = ToFunctionType->getExtInfo();
2686  if (FromEInfo != ToEInfo)
2687  return false;
2688 
2689  bool IncompatibleObjC = false;
2690  if (Context.hasSameType(FromFunctionType->getReturnType(),
2691  ToFunctionType->getReturnType())) {
2692  // Okay, the types match exactly. Nothing to do.
2693  } else {
2694  QualType RHS = FromFunctionType->getReturnType();
2695  QualType LHS = ToFunctionType->getReturnType();
2696  if ((!getLangOpts().CPlusPlus || !RHS->isRecordType()) &&
2697  !RHS.hasQualifiers() && LHS.hasQualifiers())
2698  LHS = LHS.getUnqualifiedType();
2699 
2700  if (Context.hasSameType(RHS,LHS)) {
2701  // OK exact match.
2702  } else if (isObjCPointerConversion(RHS, LHS,
2703  ConvertedType, IncompatibleObjC)) {
2704  if (IncompatibleObjC)
2705  return false;
2706  // Okay, we have an Objective-C pointer conversion.
2707  }
2708  else
2709  return false;
2710  }
2711 
2712  // Check argument types.
2713  for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumParams();
2714  ArgIdx != NumArgs; ++ArgIdx) {
2715  IncompatibleObjC = false;
2716  QualType FromArgType = FromFunctionType->getParamType(ArgIdx);
2717  QualType ToArgType = ToFunctionType->getParamType(ArgIdx);
2718  if (Context.hasSameType(FromArgType, ToArgType)) {
2719  // Okay, the types match exactly. Nothing to do.
2720  } else if (isObjCPointerConversion(ToArgType, FromArgType,
2721  ConvertedType, IncompatibleObjC)) {
2722  if (IncompatibleObjC)
2723  return false;
2724  // Okay, we have an Objective-C pointer conversion.
2725  } else
2726  // Argument types are too different. Abort.
2727  return false;
2728  }
2729 
2731  bool CanUseToFPT, CanUseFromFPT;
2732  if (!Context.mergeExtParameterInfo(ToFunctionType, FromFunctionType,
2733  CanUseToFPT, CanUseFromFPT,
2734  NewParamInfos))
2735  return false;
2736 
2737  ConvertedType = ToType;
2738  return true;
2739 }
2740 
2741 enum {
2749 };
2750 
2751 /// Attempts to get the FunctionProtoType from a Type. Handles
2752 /// MemberFunctionPointers properly.
2754  if (auto *FPT = FromType->getAs<FunctionProtoType>())
2755  return FPT;
2756 
2757  if (auto *MPT = FromType->getAs<MemberPointerType>())
2758  return MPT->getPointeeType()->getAs<FunctionProtoType>();
2759 
2760  return nullptr;
2761 }
2762 
2763 /// HandleFunctionTypeMismatch - Gives diagnostic information for differeing
2764 /// function types. Catches different number of parameter, mismatch in
2765 /// parameter types, and different return types.
2767  QualType FromType, QualType ToType) {
2768  // If either type is not valid, include no extra info.
2769  if (FromType.isNull() || ToType.isNull()) {
2770  PDiag << ft_default;
2771  return;
2772  }
2773 
2774  // Get the function type from the pointers.
2775  if (FromType->isMemberPointerType() && ToType->isMemberPointerType()) {
2776  const MemberPointerType *FromMember = FromType->getAs<MemberPointerType>(),
2777  *ToMember = ToType->getAs<MemberPointerType>();
2778  if (!Context.hasSameType(FromMember->getClass(), ToMember->getClass())) {
2779  PDiag << ft_different_class << QualType(ToMember->getClass(), 0)
2780  << QualType(FromMember->getClass(), 0);
2781  return;
2782  }
2783  FromType = FromMember->getPointeeType();
2784  ToType = ToMember->getPointeeType();
2785  }
2786 
2787  if (FromType->isPointerType())
2788  FromType = FromType->getPointeeType();
2789  if (ToType->isPointerType())
2790  ToType = ToType->getPointeeType();
2791 
2792  // Remove references.
2793  FromType = FromType.getNonReferenceType();
2794  ToType = ToType.getNonReferenceType();
2795 
2796  // Don't print extra info for non-specialized template functions.
2797  if (FromType->isInstantiationDependentType() &&
2798  !FromType->getAs<TemplateSpecializationType>()) {
2799  PDiag << ft_default;
2800  return;
2801  }
2802 
2803  // No extra info for same types.
2804  if (Context.hasSameType(FromType, ToType)) {
2805  PDiag << ft_default;
2806  return;
2807  }
2808 
2809  const FunctionProtoType *FromFunction = tryGetFunctionProtoType(FromType),
2810  *ToFunction = tryGetFunctionProtoType(ToType);
2811 
2812  // Both types need to be function types.
2813  if (!FromFunction || !ToFunction) {
2814  PDiag << ft_default;
2815  return;
2816  }
2817 
2818  if (FromFunction->getNumParams() != ToFunction->getNumParams()) {
2819  PDiag << ft_parameter_arity << ToFunction->getNumParams()
2820  << FromFunction->getNumParams();
2821  return;
2822  }
2823 
2824  // Handle different parameter types.
2825  unsigned ArgPos;
2826  if (!FunctionParamTypesAreEqual(FromFunction, ToFunction, &ArgPos)) {
2827  PDiag << ft_parameter_mismatch << ArgPos + 1
2828  << ToFunction->getParamType(ArgPos)
2829  << FromFunction->getParamType(ArgPos);
2830  return;
2831  }
2832 
2833  // Handle different return type.
2834  if (!Context.hasSameType(FromFunction->getReturnType(),
2835  ToFunction->getReturnType())) {
2836  PDiag << ft_return_type << ToFunction->getReturnType()
2837  << FromFunction->getReturnType();
2838  return;
2839  }
2840 
2841  if (FromFunction->getMethodQuals() != ToFunction->getMethodQuals()) {
2842  PDiag << ft_qualifer_mismatch << ToFunction->getMethodQuals()
2843  << FromFunction->getMethodQuals();
2844  return;
2845  }
2846 
2847  // Handle exception specification differences on canonical type (in C++17
2848  // onwards).
2849  if (cast<FunctionProtoType>(FromFunction->getCanonicalTypeUnqualified())
2850  ->isNothrow() !=
2851  cast<FunctionProtoType>(ToFunction->getCanonicalTypeUnqualified())
2852  ->isNothrow()) {
2853  PDiag << ft_noexcept;
2854  return;
2855  }
2856 
2857  // Unable to find a difference, so add no extra info.
2858  PDiag << ft_default;
2859 }
2860 
2861 /// FunctionParamTypesAreEqual - This routine checks two function proto types
2862 /// for equality of their argument types. Caller has already checked that
2863 /// they have same number of arguments. If the parameters are different,
2864 /// ArgPos will have the parameter index of the first different parameter.
2866  const FunctionProtoType *NewType,
2867  unsigned *ArgPos) {
2869  N = NewType->param_type_begin(),
2870  E = OldType->param_type_end();
2871  O && (O != E); ++O, ++N) {
2872  if (!Context.hasSameType(O->getUnqualifiedType(),
2873  N->getUnqualifiedType())) {
2874  if (ArgPos)
2875  *ArgPos = O - OldType->param_type_begin();
2876  return false;
2877  }
2878  }
2879  return true;
2880 }
2881 
2882 /// CheckPointerConversion - Check the pointer conversion from the
2883 /// expression From to the type ToType. This routine checks for
2884 /// ambiguous or inaccessible derived-to-base pointer
2885 /// conversions for which IsPointerConversion has already returned
2886 /// true. It returns true and produces a diagnostic if there was an
2887 /// error, or returns false otherwise.
2889  CastKind &Kind,
2890  CXXCastPath& BasePath,
2891  bool IgnoreBaseAccess,
2892  bool Diagnose) {
2893  QualType FromType = From->getType();
2894  bool IsCStyleOrFunctionalCast = IgnoreBaseAccess;
2895 
2896  Kind = CK_BitCast;
2897 
2898  if (Diagnose && !IsCStyleOrFunctionalCast && !FromType->isAnyPointerType() &&
2901  if (Context.hasSameUnqualifiedType(From->getType(), Context.BoolTy))
2902  DiagRuntimeBehavior(From->getExprLoc(), From,
2903  PDiag(diag::warn_impcast_bool_to_null_pointer)
2904  << ToType << From->getSourceRange());
2905  else if (!isUnevaluatedContext())
2906  Diag(From->getExprLoc(), diag::warn_non_literal_null_pointer)
2907  << ToType << From->getSourceRange();
2908  }
2909  if (const PointerType *ToPtrType = ToType->getAs<PointerType>()) {
2910  if (const PointerType *FromPtrType = FromType->getAs<PointerType>()) {
2911  QualType FromPointeeType = FromPtrType->getPointeeType(),
2912  ToPointeeType = ToPtrType->getPointeeType();
2913 
2914  if (FromPointeeType->isRecordType() && ToPointeeType->isRecordType() &&
2915  !Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType)) {
2916  // We must have a derived-to-base conversion. Check an
2917  // ambiguous or inaccessible conversion.
2918  unsigned InaccessibleID = 0;
2919  unsigned AmbigiousID = 0;
2920  if (Diagnose) {
2921  InaccessibleID = diag::err_upcast_to_inaccessible_base;
2922  AmbigiousID = diag::err_ambiguous_derived_to_base_conv;
2923  }
2924  if (CheckDerivedToBaseConversion(
2925  FromPointeeType, ToPointeeType, InaccessibleID, AmbigiousID,
2926  From->getExprLoc(), From->getSourceRange(), DeclarationName(),
2927  &BasePath, IgnoreBaseAccess))
2928  return true;
2929 
2930  // The conversion was successful.
2931  Kind = CK_DerivedToBase;
2932  }
2933 
2934  if (Diagnose && !IsCStyleOrFunctionalCast &&
2935  FromPointeeType->isFunctionType() && ToPointeeType->isVoidType()) {
2936  assert(getLangOpts().MSVCCompat &&
2937  "this should only be possible with MSVCCompat!");
2938  Diag(From->getExprLoc(), diag::ext_ms_impcast_fn_obj)
2939  << From->getSourceRange();
2940  }
2941  }
2942  } else if (const ObjCObjectPointerType *ToPtrType =
2943  ToType->getAs<ObjCObjectPointerType>()) {
2944  if (const ObjCObjectPointerType *FromPtrType =
2945  FromType->getAs<ObjCObjectPointerType>()) {
2946  // Objective-C++ conversions are always okay.
2947  // FIXME: We should have a different class of conversions for the
2948  // Objective-C++ implicit conversions.
2949  if (FromPtrType->isObjCBuiltinType() || ToPtrType->isObjCBuiltinType())
2950  return false;
2951  } else if (FromType->isBlockPointerType()) {
2952  Kind = CK_BlockPointerToObjCPointerCast;
2953  } else {
2954  Kind = CK_CPointerToObjCPointerCast;
2955  }
2956  } else if (ToType->isBlockPointerType()) {
2957  if (!FromType->isBlockPointerType())
2958  Kind = CK_AnyPointerToBlockPointerCast;
2959  }
2960 
2961  // We shouldn't fall into this case unless it's valid for other
2962  // reasons.
2964  Kind = CK_NullToPointer;
2965 
2966  return false;
2967 }
2968 
2969 /// IsMemberPointerConversion - Determines whether the conversion of the
2970 /// expression From, which has the (possibly adjusted) type FromType, can be
2971 /// converted to the type ToType via a member pointer conversion (C++ 4.11).
2972 /// If so, returns true and places the converted type (that might differ from
2973 /// ToType in its cv-qualifiers at some level) into ConvertedType.
2975  QualType ToType,
2976  bool InOverloadResolution,
2977  QualType &ConvertedType) {
2978  const MemberPointerType *ToTypePtr = ToType->getAs<MemberPointerType>();
2979  if (!ToTypePtr)
2980  return false;
2981 
2982  // A null pointer constant can be converted to a member pointer (C++ 4.11p1)
2983  if (From->isNullPointerConstant(Context,
2984  InOverloadResolution? Expr::NPC_ValueDependentIsNotNull
2986  ConvertedType = ToType;
2987  return true;
2988  }
2989 
2990  // Otherwise, both types have to be member pointers.
2991  const MemberPointerType *FromTypePtr = FromType->getAs<MemberPointerType>();
2992  if (!FromTypePtr)
2993  return false;
2994 
2995  // A pointer to member of B can be converted to a pointer to member of D,
2996  // where D is derived from B (C++ 4.11p2).
2997  QualType FromClass(FromTypePtr->getClass(), 0);
2998  QualType ToClass(ToTypePtr->getClass(), 0);
2999 
3000  if (!Context.hasSameUnqualifiedType(FromClass, ToClass) &&
3001  IsDerivedFrom(From->getBeginLoc(), ToClass, FromClass)) {
3002  ConvertedType = Context.getMemberPointerType(FromTypePtr->getPointeeType(),
3003  ToClass.getTypePtr());
3004  return true;
3005  }
3006 
3007  return false;
3008 }
3009 
3010 /// CheckMemberPointerConversion - Check the member pointer conversion from the
3011 /// expression From to the type ToType. This routine checks for ambiguous or
3012 /// virtual or inaccessible base-to-derived member pointer conversions
3013 /// for which IsMemberPointerConversion has already returned true. It returns
3014 /// true and produces a diagnostic if there was an error, or returns false
3015 /// otherwise.
3017  CastKind &Kind,
3018  CXXCastPath &BasePath,
3019  bool IgnoreBaseAccess) {
3020  QualType FromType = From->getType();
3021  const MemberPointerType *FromPtrType = FromType->getAs<MemberPointerType>();
3022  if (!FromPtrType) {
3023  // This must be a null pointer to member pointer conversion
3024  assert(From->isNullPointerConstant(Context,
3026  "Expr must be null pointer constant!");
3027  Kind = CK_NullToMemberPointer;
3028  return false;
3029  }
3030 
3031  const MemberPointerType *ToPtrType = ToType->getAs<MemberPointerType>();
3032  assert(ToPtrType && "No member pointer cast has a target type "
3033  "that is not a member pointer.");
3034 
3035  QualType FromClass = QualType(FromPtrType->getClass(), 0);
3036  QualType ToClass = QualType(ToPtrType->getClass(), 0);
3037 
3038  // FIXME: What about dependent types?
3039  assert(FromClass->isRecordType() && "Pointer into non-class.");
3040  assert(ToClass->isRecordType() && "Pointer into non-class.");
3041 
3042  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
3043  /*DetectVirtual=*/true);
3044  bool DerivationOkay =
3045  IsDerivedFrom(From->getBeginLoc(), ToClass, FromClass, Paths);
3046  assert(DerivationOkay &&
3047  "Should not have been called if derivation isn't OK.");
3048  (void)DerivationOkay;
3049 
3050  if (Paths.isAmbiguous(Context.getCanonicalType(FromClass).
3051  getUnqualifiedType())) {
3052  std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
3053  Diag(From->getExprLoc(), diag::err_ambiguous_memptr_conv)
3054  << 0 << FromClass << ToClass << PathDisplayStr << From->getSourceRange();
3055  return true;
3056  }
3057 
3058  if (const RecordType *VBase = Paths.getDetectedVirtual()) {
3059  Diag(From->getExprLoc(), diag::err_memptr_conv_via_virtual)
3060  << FromClass << ToClass << QualType(VBase, 0)
3061  << From->getSourceRange();
3062  return true;
3063  }
3064 
3065  if (!IgnoreBaseAccess)
3066  CheckBaseClassAccess(From->getExprLoc(), FromClass, ToClass,
3067  Paths.front(),
3068  diag::err_downcast_from_inaccessible_base);
3069 
3070  // Must be a base to derived member conversion.
3071  BuildBasePathArray(Paths, BasePath);
3072  Kind = CK_BaseToDerivedMemberPointer;
3073  return false;
3074 }
3075 
3076 /// Determine whether the lifetime conversion between the two given
3077 /// qualifiers sets is nontrivial.
3079  Qualifiers ToQuals) {
3080  // Converting anything to const __unsafe_unretained is trivial.
3081  if (ToQuals.hasConst() &&
3083  return false;
3084 
3085  return true;
3086 }
3087 
3088 /// IsQualificationConversion - Determines whether the conversion from
3089 /// an rvalue of type FromType to ToType is a qualification conversion
3090 /// (C++ 4.4).
3091 ///
3092 /// \param ObjCLifetimeConversion Output parameter that will be set to indicate
3093 /// when the qualification conversion involves a change in the Objective-C
3094 /// object lifetime.
3095 bool
3097  bool CStyle, bool &ObjCLifetimeConversion) {
3098  FromType = Context.getCanonicalType(FromType);
3099  ToType = Context.getCanonicalType(ToType);
3100  ObjCLifetimeConversion = false;
3101 
3102  // If FromType and ToType are the same type, this is not a
3103  // qualification conversion.
3104  if (FromType.getUnqualifiedType() == ToType.getUnqualifiedType())
3105  return false;
3106 
3107  // (C++ 4.4p4):
3108  // A conversion can add cv-qualifiers at levels other than the first
3109  // in multi-level pointers, subject to the following rules: [...]
3110  bool PreviousToQualsIncludeConst = true;
3111  bool UnwrappedAnyPointer = false;
3112  while (Context.UnwrapSimilarTypes(FromType, ToType)) {
3113  // Within each iteration of the loop, we check the qualifiers to
3114  // determine if this still looks like a qualification
3115  // conversion. Then, if all is well, we unwrap one more level of
3116  // pointers or pointers-to-members and do it all again
3117  // until there are no more pointers or pointers-to-members left to
3118  // unwrap.
3119  UnwrappedAnyPointer = true;
3120 
3121  Qualifiers FromQuals = FromType.getQualifiers();
3122  Qualifiers ToQuals = ToType.getQualifiers();
3123 
3124  // Ignore __unaligned qualifier if this type is void.
3125  if (ToType.getUnqualifiedType()->isVoidType())
3126  FromQuals.removeUnaligned();
3127 
3128  // Objective-C ARC:
3129  // Check Objective-C lifetime conversions.
3130  if (FromQuals.getObjCLifetime() != ToQuals.getObjCLifetime() &&
3131  UnwrappedAnyPointer) {
3132  if (ToQuals.compatiblyIncludesObjCLifetime(FromQuals)) {
3133  if (isNonTrivialObjCLifetimeConversion(FromQuals, ToQuals))
3134  ObjCLifetimeConversion = true;
3135  FromQuals.removeObjCLifetime();
3136  ToQuals.removeObjCLifetime();
3137  } else {
3138  // Qualification conversions cannot cast between different
3139  // Objective-C lifetime qualifiers.
3140  return false;
3141  }
3142  }
3143 
3144  // Allow addition/removal of GC attributes but not changing GC attributes.
3145  if (FromQuals.getObjCGCAttr() != ToQuals.getObjCGCAttr() &&
3146  (!FromQuals.hasObjCGCAttr() || !ToQuals.hasObjCGCAttr())) {
3147  FromQuals.removeObjCGCAttr();
3148  ToQuals.removeObjCGCAttr();
3149  }
3150 
3151  // -- for every j > 0, if const is in cv 1,j then const is in cv
3152  // 2,j, and similarly for volatile.
3153  if (!CStyle && !ToQuals.compatiblyIncludes(FromQuals))
3154  return false;
3155 
3156  // -- if the cv 1,j and cv 2,j are different, then const is in
3157  // every cv for 0 < k < j.
3158  if (!CStyle && FromQuals.getCVRQualifiers() != ToQuals.getCVRQualifiers()
3159  && !PreviousToQualsIncludeConst)
3160  return false;
3161 
3162  // Keep track of whether all prior cv-qualifiers in the "to" type
3163  // include const.
3164  PreviousToQualsIncludeConst
3165  = PreviousToQualsIncludeConst && ToQuals.hasConst();
3166  }
3167 
3168  // Allows address space promotion by language rules implemented in
3169  // Type::Qualifiers::isAddressSpaceSupersetOf.
3170  Qualifiers FromQuals = FromType.getQualifiers();
3171  Qualifiers ToQuals = ToType.getQualifiers();
3172  if (!ToQuals.isAddressSpaceSupersetOf(FromQuals) &&
3173  !FromQuals.isAddressSpaceSupersetOf(ToQuals)) {
3174  return false;
3175  }
3176 
3177  // We are left with FromType and ToType being the pointee types
3178  // after unwrapping the original FromType and ToType the same number
3179  // of types. If we unwrapped any pointers, and if FromType and
3180  // ToType have the same unqualified type (since we checked
3181  // qualifiers above), then this is a qualification conversion.
3182  return UnwrappedAnyPointer && Context.hasSameUnqualifiedType(FromType,ToType);
3183 }
3184 
3185 /// - Determine whether this is a conversion from a scalar type to an
3186 /// atomic type.
3187 ///
3188 /// If successful, updates \c SCS's second and third steps in the conversion
3189 /// sequence to finish the conversion.
3190 static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType,
3191  bool InOverloadResolution,
3193  bool CStyle) {
3194  const AtomicType *ToAtomic = ToType->getAs<AtomicType>();
3195  if (!ToAtomic)
3196  return false;
3197 
3198  StandardConversionSequence InnerSCS;
3199  if (!IsStandardConversion(S, From, ToAtomic->getValueType(),
3200  InOverloadResolution, InnerSCS,
3201  CStyle, /*AllowObjCWritebackConversion=*/false))
3202  return false;
3203 
3204  SCS.Second = InnerSCS.Second;
3205  SCS.setToType(1, InnerSCS.getToType(1));
3206  SCS.Third = InnerSCS.Third;
3208  = InnerSCS.QualificationIncludesObjCLifetime;
3209  SCS.setToType(2, InnerSCS.getToType(2));
3210  return true;
3211 }
3212 
3214  CXXConstructorDecl *Constructor,
3215  QualType Type) {
3216  const FunctionProtoType *CtorType =
3217  Constructor->getType()->getAs<FunctionProtoType>();
3218  if (CtorType->getNumParams() > 0) {
3219  QualType FirstArg = CtorType->getParamType(0);
3220  if (Context.hasSameUnqualifiedType(Type, FirstArg.getNonReferenceType()))
3221  return true;
3222  }
3223  return false;
3224 }
3225 
3226 static OverloadingResult
3228  CXXRecordDecl *To,
3230  OverloadCandidateSet &CandidateSet,
3231  bool AllowExplicit) {
3233  for (auto *D : S.LookupConstructors(To)) {
3234  auto Info = getConstructorInfo(D);
3235  if (!Info)
3236  continue;
3237 
3238  bool Usable = !Info.Constructor->isInvalidDecl() &&
3239  S.isInitListConstructor(Info.Constructor) &&
3240  (AllowExplicit || !Info.Constructor->isExplicit());
3241  if (Usable) {
3242  // If the first argument is (a reference to) the target type,
3243  // suppress conversions.
3244  bool SuppressUserConversions = isFirstArgumentCompatibleWithType(
3245  S.Context, Info.Constructor, ToType);
3246  if (Info.ConstructorTmpl)
3247  S.AddTemplateOverloadCandidate(Info.ConstructorTmpl, Info.FoundDecl,
3248  /*ExplicitArgs*/ nullptr, From,
3249  CandidateSet, SuppressUserConversions,
3250  /*PartialOverloading*/ false,
3251  AllowExplicit);
3252  else
3253  S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl, From,
3254  CandidateSet, SuppressUserConversions,
3255  /*PartialOverloading*/ false, AllowExplicit);
3256  }
3257  }
3258 
3259  bool HadMultipleCandidates = (CandidateSet.size() > 1);
3260 
3262  switch (auto Result =
3263  CandidateSet.BestViableFunction(S, From->getBeginLoc(), Best)) {
3264  case OR_Deleted:
3265  case OR_Success: {
3266  // Record the standard conversion we used and the conversion function.
3267  CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function);
3268  QualType ThisType = Constructor->getThisType();
3269  // Initializer lists don't have conversions as such.
3271  User.HadMultipleCandidates = HadMultipleCandidates;
3272  User.ConversionFunction = Constructor;
3273  User.FoundConversionFunction = Best->FoundDecl;
3275  User.After.setFromType(ThisType->getAs<PointerType>()->getPointeeType());
3276  User.After.setAllToTypes(ToType);
3277  return Result;
3278  }
3279 
3280  case OR_No_Viable_Function:
3281  return OR_No_Viable_Function;
3282  case OR_Ambiguous:
3283  return OR_Ambiguous;
3284  }
3285 
3286  llvm_unreachable("Invalid OverloadResult!");
3287 }
3288 
3289 /// Determines whether there is a user-defined conversion sequence
3290 /// (C++ [over.ics.user]) that converts expression From to the type
3291 /// ToType. If such a conversion exists, User will contain the
3292 /// user-defined conversion sequence that performs such a conversion
3293 /// and this routine will return true. Otherwise, this routine returns
3294 /// false and User is unspecified.
3295 ///
3296 /// \param AllowExplicit true if the conversion should consider C++0x
3297 /// "explicit" conversion functions as well as non-explicit conversion
3298 /// functions (C++0x [class.conv.fct]p2).
3299 ///
3300 /// \param AllowObjCConversionOnExplicit true if the conversion should
3301 /// allow an extra Objective-C pointer conversion on uses of explicit
3302 /// constructors. Requires \c AllowExplicit to also be set.
3303 static OverloadingResult
3306  OverloadCandidateSet &CandidateSet,
3307  bool AllowExplicit,
3308  bool AllowObjCConversionOnExplicit) {
3309  assert(AllowExplicit || !AllowObjCConversionOnExplicit);
3311 
3312  // Whether we will only visit constructors.
3313  bool ConstructorsOnly = false;
3314 
3315  // If the type we are conversion to is a class type, enumerate its
3316  // constructors.
3317  if (const RecordType *ToRecordType = ToType->getAs<RecordType>()) {
3318  // C++ [over.match.ctor]p1:
3319  // When objects of class type are direct-initialized (8.5), or
3320  // copy-initialized from an expression of the same or a
3321  // derived class type (8.5), overload resolution selects the
3322  // constructor. [...] For copy-initialization, the candidate
3323  // functions are all the converting constructors (12.3.1) of
3324  // that class. The argument list is the expression-list within
3325  // the parentheses of the initializer.
3326  if (S.Context.hasSameUnqualifiedType(ToType, From->getType()) ||
3327  (From->getType()->getAs<RecordType>() &&
3328  S.IsDerivedFrom(From->getBeginLoc(), From->getType(), ToType)))
3329  ConstructorsOnly = true;
3330 
3331  if (!S.isCompleteType(From->getExprLoc(), ToType)) {
3332  // We're not going to find any constructors.
3333  } else if (CXXRecordDecl *ToRecordDecl
3334  = dyn_cast<CXXRecordDecl>(ToRecordType->getDecl())) {
3335 
3336  Expr **Args = &From;
3337  unsigned NumArgs = 1;
3338  bool ListInitializing = false;
3339  if (InitListExpr *InitList = dyn_cast<InitListExpr>(From)) {
3340  // But first, see if there is an init-list-constructor that will work.
3342  S, From, ToType, ToRecordDecl, User, CandidateSet, AllowExplicit);
3343  if (Result != OR_No_Viable_Function)
3344  return Result;
3345  // Never mind.
3346  CandidateSet.clear(
3348 
3349  // If we're list-initializing, we pass the individual elements as
3350  // arguments, not the entire list.
3351  Args = InitList->getInits();
3352  NumArgs = InitList->getNumInits();
3353  ListInitializing = true;
3354  }
3355 
3356  for (auto *D : S.LookupConstructors(ToRecordDecl)) {
3357  auto Info = getConstructorInfo(D);
3358  if (!Info)
3359  continue;
3360 
3361  bool Usable = !Info.Constructor->isInvalidDecl();
3362  if (ListInitializing)
3363  Usable = Usable && (AllowExplicit || !Info.Constructor->isExplicit());
3364  else
3365  Usable = Usable &&
3366  Info.Constructor->isConvertingConstructor(AllowExplicit);
3367  if (Usable) {
3368  bool SuppressUserConversions = !ConstructorsOnly;
3369  if (SuppressUserConversions && ListInitializing) {
3370  SuppressUserConversions = false;
3371  if (NumArgs == 1) {
3372  // If the first argument is (a reference to) the target type,
3373  // suppress conversions.
3374  SuppressUserConversions = isFirstArgumentCompatibleWithType(
3375  S.Context, Info.Constructor, ToType);
3376  }
3377  }
3378  if (Info.ConstructorTmpl)
3380  Info.ConstructorTmpl, Info.FoundDecl,
3381  /*ExplicitArgs*/ nullptr, llvm::makeArrayRef(Args, NumArgs),
3382  CandidateSet, SuppressUserConversions,
3383  /*PartialOverloading*/ false, AllowExplicit);
3384  else
3385  // Allow one user-defined conversion when user specifies a
3386  // From->ToType conversion via an static cast (c-style, etc).
3387  S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl,
3388  llvm::makeArrayRef(Args, NumArgs),
3389  CandidateSet, SuppressUserConversions,
3390  /*PartialOverloading*/ false, AllowExplicit);
3391  }
3392  }
3393  }
3394  }
3395 
3396  // Enumerate conversion functions, if we're allowed to.
3397  if (ConstructorsOnly || isa<InitListExpr>(From)) {
3398  } else if (!S.isCompleteType(From->getBeginLoc(), From->getType())) {
3399  // No conversion functions from incomplete types.
3400  } else if (const RecordType *FromRecordType =
3401  From->getType()->getAs<RecordType>()) {
3402  if (CXXRecordDecl *FromRecordDecl
3403  = dyn_cast<CXXRecordDecl>(FromRecordType->getDecl())) {
3404  // Add all of the conversion functions as candidates.
3405  const auto &Conversions = FromRecordDecl->getVisibleConversionFunctions();
3406  for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
3407  DeclAccessPair FoundDecl = I.getPair();
3408  NamedDecl *D = FoundDecl.getDecl();
3409  CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext());
3410  if (isa<UsingShadowDecl>(D))
3411  D = cast<UsingShadowDecl>(D)->getTargetDecl();
3412 
3413  CXXConversionDecl *Conv;
3414  FunctionTemplateDecl *ConvTemplate;
3415  if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D)))
3416  Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
3417  else
3418  Conv = cast<CXXConversionDecl>(D);
3419 
3420  if (AllowExplicit || !Conv->isExplicit()) {
3421  if (ConvTemplate)
3423  ConvTemplate, FoundDecl, ActingContext, From, ToType,
3424  CandidateSet, AllowObjCConversionOnExplicit, AllowExplicit);
3425  else
3427  Conv, FoundDecl, ActingContext, From, ToType, CandidateSet,
3428  AllowObjCConversionOnExplicit, AllowExplicit);
3429  }
3430  }
3431  }
3432  }
3433 
3434  bool HadMultipleCandidates = (CandidateSet.size() > 1);
3435 
3437  switch (auto Result =
3438  CandidateSet.BestViableFunction(S, From->getBeginLoc(), Best)) {
3439  case OR_Success:
3440  case OR_Deleted:
3441  // Record the standard conversion we used and the conversion function.
3442  if (CXXConstructorDecl *Constructor
3443  = dyn_cast<CXXConstructorDecl>(Best->Function)) {
3444  // C++ [over.ics.user]p1:
3445  // If the user-defined conversion is specified by a
3446  // constructor (12.3.1), the initial standard conversion
3447  // sequence converts the source type to the type required by
3448  // the argument of the constructor.
3449  //
3450  QualType ThisType = Constructor->getThisType();
3451  if (isa<InitListExpr>(From)) {
3452  // Initializer lists don't have conversions as such.
3454  } else {
3455  if (Best->Conversions[0].isEllipsis())
3456  User.EllipsisConversion = true;
3457  else {
3458  User.Before = Best->Conversions[0].Standard;
3459  User.EllipsisConversion = false;
3460  }
3461  }
3462  User.HadMultipleCandidates = HadMultipleCandidates;
3463  User.ConversionFunction = Constructor;
3464  User.FoundConversionFunction = Best->FoundDecl;
3466  User.After.setFromType(ThisType->getAs<PointerType>()->getPointeeType());
3467  User.After.setAllToTypes(ToType);
3468  return Result;
3469  }
3470  if (CXXConversionDecl *Conversion
3471  = dyn_cast<CXXConversionDecl>(Best->Function)) {
3472  // C++ [over.ics.user]p1:
3473  //
3474  // [...] If the user-defined conversion is specified by a
3475  // conversion function (12.3.2), the initial standard
3476  // conversion sequence converts the source type to the
3477  // implicit object parameter of the conversion function.
3478  User.Before = Best->Conversions[0].Standard;
3479  User.HadMultipleCandidates = HadMultipleCandidates;
3480  User.ConversionFunction = Conversion;
3481  User.FoundConversionFunction = Best->FoundDecl;
3482  User.EllipsisConversion = false;
3483 
3484  // C++ [over.ics.user]p2:
3485  // The second standard conversion sequence converts the
3486  // result of the user-defined conversion to the target type
3487  // for the sequence. Since an implicit conversion sequence
3488  // is an initialization, the special rules for
3489  // initialization by user-defined conversion apply when
3490  // selecting the best user-defined conversion for a
3491  // user-defined conversion sequence (see 13.3.3 and
3492  // 13.3.3.1).
3493  User.After = Best->FinalConversion;
3494  return Result;
3495  }
3496  llvm_unreachable("Not a constructor or conversion function?");
3497 
3498  case OR_No_Viable_Function:
3499  return OR_No_Viable_Function;
3500 
3501  case OR_Ambiguous:
3502  return OR_Ambiguous;
3503  }
3504 
3505  llvm_unreachable("Invalid OverloadResult!");
3506 }
3507 
3508 bool
3511  OverloadCandidateSet CandidateSet(From->getExprLoc(),
3513  OverloadingResult OvResult =
3514  IsUserDefinedConversion(*this, From, ToType, ICS.UserDefined,
3515  CandidateSet, false, false);
3516 
3517  if (!(OvResult == OR_Ambiguous ||
3518  (OvResult == OR_No_Viable_Function && !CandidateSet.empty())))
3519  return false;
3520 
3521  auto Cands = CandidateSet.CompleteCandidates(*this, OCD_AllCandidates, From);
3522  if (OvResult == OR_Ambiguous)
3523  Diag(From->getBeginLoc(), diag::err_typecheck_ambiguous_condition)
3524  << From->getType() << ToType << From->getSourceRange();
3525  else { // OR_No_Viable_Function && !CandidateSet.empty()
3526  if (!RequireCompleteType(From->getBeginLoc(), ToType,
3527  diag::err_typecheck_nonviable_condition_incomplete,
3528  From->getType(), From->getSourceRange()))
3529  Diag(From->getBeginLoc(), diag::err_typecheck_nonviable_condition)
3530  << false << From->getType() << From->getSourceRange() << ToType;
3531  }
3532 
3533  CandidateSet.NoteCandidates(
3534  *this, From, Cands);
3535  return true;
3536 }
3537 
3538 /// Compare the user-defined conversion functions or constructors
3539 /// of two user-defined conversion sequences to determine whether any ordering
3540 /// is possible.
3543  FunctionDecl *Function2) {
3544  if (!S.getLangOpts().ObjC || !S.getLangOpts().CPlusPlus11)
3546 
3547  // Objective-C++:
3548  // If both conversion functions are implicitly-declared conversions from
3549  // a lambda closure type to a function pointer and a block pointer,
3550  // respectively, always prefer the conversion to a function pointer,
3551  // because the function pointer is more lightweight and is more likely
3552  // to keep code working.
3553  CXXConversionDecl *Conv1 = dyn_cast_or_null<CXXConversionDecl>(Function1);
3554  if (!Conv1)
3556 
3557  CXXConversionDecl *Conv2 = dyn_cast<CXXConversionDecl>(Function2);
3558  if (!Conv2)
3560 
3561  if (Conv1->getParent()->isLambda() && Conv2->getParent()->isLambda()) {
3562  bool Block1 = Conv1->getConversionType()->isBlockPointerType();
3563  bool Block2 = Conv2->getConversionType()->isBlockPointerType();
3564  if (Block1 != Block2)
3565  return Block1 ? ImplicitConversionSequence::Worse
3567  }
3568 
3570 }
3571 
3573  const ImplicitConversionSequence &ICS) {
3574  return (ICS.isStandard() && ICS.Standard.DeprecatedStringLiteralToCharPtr) ||
3575  (ICS.isUserDefined() &&
3577 }
3578 
3579 /// CompareImplicitConversionSequences - Compare two implicit
3580 /// conversion sequences to determine whether one is better than the
3581 /// other or if they are indistinguishable (C++ 13.3.3.2).
3584  const ImplicitConversionSequence& ICS1,
3585  const ImplicitConversionSequence& ICS2)
3586 {
3587  // (C++ 13.3.3.2p2): When comparing the basic forms of implicit
3588  // conversion sequences (as defined in 13.3.3.1)
3589  // -- a standard conversion sequence (13.3.3.1.1) is a better
3590  // conversion sequence than a user-defined conversion sequence or
3591  // an ellipsis conversion sequence, and
3592  // -- a user-defined conversion sequence (13.3.3.1.2) is a better
3593  // conversion sequence than an ellipsis conversion sequence
3594  // (13.3.3.1.3).
3595  //
3596  // C++0x [over.best.ics]p10:
3597  // For the purpose of ranking implicit conversion sequences as
3598  // described in 13.3.3.2, the ambiguous conversion sequence is
3599  // treated as a user-defined sequence that is indistinguishable
3600  // from any other user-defined conversion sequence.
3601 
3602  // String literal to 'char *' conversion has been deprecated in C++03. It has
3603  // been removed from C++11. We still accept this conversion, if it happens at
3604  // the best viable function. Otherwise, this conversion is considered worse
3605  // than ellipsis conversion. Consider this as an extension; this is not in the
3606  // standard. For example:
3607  //
3608  // int &f(...); // #1
3609  // void f(char*); // #2
3610  // void g() { int &r = f("foo"); }
3611  //
3612  // In C++03, we pick #2 as the best viable function.
3613  // In C++11, we pick #1 as the best viable function, because ellipsis
3614  // conversion is better than string-literal to char* conversion (since there
3615  // is no such conversion in C++11). If there was no #1 at all or #1 couldn't
3616  // convert arguments, #2 would be the best viable function in C++11.
3617  // If the best viable function has this conversion, a warning will be issued
3618  // in C++03, or an ExtWarn (+SFINAE failure) will be issued in C++11.
3619 
3620  if (S.getLangOpts().CPlusPlus11 && !S.getLangOpts().WritableStrings &&
3626 
3627  if (ICS1.getKindRank() < ICS2.getKindRank())
3629  if (ICS2.getKindRank() < ICS1.getKindRank())
3631 
3632  // The following checks require both conversion sequences to be of
3633  // the same kind.
3634  if (ICS1.getKind() != ICS2.getKind())
3636 
3639 
3640  // Two implicit conversion sequences of the same form are
3641  // indistinguishable conversion sequences unless one of the
3642  // following rules apply: (C++ 13.3.3.2p3):
3643 
3644  // List-initialization sequence L1 is a better conversion sequence than
3645  // list-initialization sequence L2 if:
3646  // - L1 converts to std::initializer_list<X> for some X and L2 does not, or,
3647  // if not that,
3648  // - L1 converts to type "array of N1 T", L2 converts to type "array of N2 T",
3649  // and N1 is smaller than N2.,
3650  // even if one of the other rules in this paragraph would otherwise apply.
3651  if (!ICS1.isBad()) {
3652  if (ICS1.isStdInitializerListElement() &&
3655  if (!ICS1.isStdInitializerListElement() &&
3658  }
3659 
3660  if (ICS1.isStandard())
3661  // Standard conversion sequence S1 is a better conversion sequence than
3662  // standard conversion sequence S2 if [...]
3663  Result = CompareStandardConversionSequences(S, Loc,
3664  ICS1.Standard, ICS2.Standard);
3665  else if (ICS1.isUserDefined()) {
3666  // User-defined conversion sequence U1 is a better conversion
3667  // sequence than another user-defined conversion sequence U2 if
3668  // they contain the same user-defined conversion function or
3669  // constructor and if the second standard conversion sequence of
3670  // U1 is better than the second standard conversion sequence of
3671  // U2 (C++ 13.3.3.2p3).
3672  if (ICS1.UserDefined.ConversionFunction ==
3674  Result = CompareStandardConversionSequences(S, Loc,
3675  ICS1.UserDefined.After,
3676  ICS2.UserDefined.After);
3677  else
3678  Result = compareConversionFunctions(S,
3681  }
3682 
3683  return Result;
3684 }
3685 
3686 // Per 13.3.3.2p3, compare the given standard conversion sequences to
3687 // determine if one is a proper subset of the other.
3690  const StandardConversionSequence& SCS1,
3691  const StandardConversionSequence& SCS2) {
3694 
3695  // the identity conversion sequence is considered to be a subsequence of
3696  // any non-identity conversion sequence
3697  if (SCS1.isIdentityConversion() && !SCS2.isIdentityConversion())
3699  else if (!SCS1.isIdentityConversion() && SCS2.isIdentityConversion())
3701 
3702  if (SCS1.Second != SCS2.Second) {
3703  if (SCS1.Second == ICK_Identity)
3705  else if (SCS2.Second == ICK_Identity)
3707  else
3709  } else if (!Context.hasSimilarType(SCS1.getToType(1), SCS2.getToType(1)))
3711 
3712  if (SCS1.Third == SCS2.Third) {
3713  return Context.hasSameType(SCS1.getToType(2), SCS2.getToType(2))? Result
3715  }
3716 
3717  if (SCS1.Third == ICK_Identity)
3718  return Result == ImplicitConversionSequence::Worse
3721 
3722  if (SCS2.Third == ICK_Identity)
3723  return Result == ImplicitConversionSequence::Better
3726 
3728 }
3729 
3730 /// Determine whether one of the given reference bindings is better
3731 /// than the other based on what kind of bindings they are.
3732 static bool
3734  const StandardConversionSequence &SCS2) {
3735  // C++0x [over.ics.rank]p3b4:
3736  // -- S1 and S2 are reference bindings (8.5.3) and neither refers to an
3737  // implicit object parameter of a non-static member function declared
3738  // without a ref-qualifier, and *either* S1 binds an rvalue reference
3739  // to an rvalue and S2 binds an lvalue reference *or S1 binds an
3740  // lvalue reference to a function lvalue and S2 binds an rvalue
3741  // reference*.
3742  //
3743  // FIXME: Rvalue references. We're going rogue with the above edits,
3744  // because the semantics in the current C++0x working paper (N3225 at the
3745  // time of this writing) break the standard definition of std::forward
3746  // and std::reference_wrapper when dealing with references to functions.
3747  // Proposed wording changes submitted to CWG for consideration.
3750  return false;
3751 
3752  return (!SCS1.IsLvalueReference && SCS1.BindsToRvalue &&
3753  SCS2.IsLvalueReference) ||
3754  (SCS1.IsLvalueReference && SCS1.BindsToFunctionLvalue &&
3756 }
3757 
3758 /// CompareStandardConversionSequences - Compare two standard
3759 /// conversion sequences to determine whether one is better than the
3760 /// other or if they are indistinguishable (C++ 13.3.3.2p3).
3763  const StandardConversionSequence& SCS1,
3764  const StandardConversionSequence& SCS2)
3765 {
3766  // Standard conversion sequence S1 is a better conversion sequence
3767  // than standard conversion sequence S2 if (C++ 13.3.3.2p3):
3768 
3769  // -- S1 is a proper subsequence of S2 (comparing the conversion
3770  // sequences in the canonical form defined by 13.3.3.1.1,
3771  // excluding any Lvalue Transformation; the identity conversion
3772  // sequence is considered to be a subsequence of any
3773  // non-identity conversion sequence) or, if not that,
3775  = compareStandardConversionSubsets(S.Context, SCS1, SCS2))
3776  return CK;
3777 
3778  // -- the rank of S1 is better than the rank of S2 (by the rules
3779  // defined below), or, if not that,
3780  ImplicitConversionRank Rank1 = SCS1.getRank();
3781  ImplicitConversionRank Rank2 = SCS2.getRank();
3782  if (Rank1 < Rank2)
3784  else if (Rank2 < Rank1)
3786 
3787  // (C++ 13.3.3.2p4): Two conversion sequences with the same rank
3788  // are indistinguishable unless one of the following rules
3789  // applies:
3790 
3791  // A conversion that is not a conversion of a pointer, or
3792  // pointer to member, to bool is better than another conversion
3793  // that is such a conversion.
3795  return SCS2.isPointerConversionToBool()
3798 
3799  // C++ [over.ics.rank]p4b2:
3800  //
3801  // If class B is derived directly or indirectly from class A,
3802  // conversion of B* to A* is better than conversion of B* to
3803  // void*, and conversion of A* to void* is better than conversion
3804  // of B* to void*.
3805  bool SCS1ConvertsToVoid
3807  bool SCS2ConvertsToVoid
3809  if (SCS1ConvertsToVoid != SCS2ConvertsToVoid) {
3810  // Exactly one of the conversion sequences is a conversion to
3811  // a void pointer; it's the worse conversion.
3812  return SCS2ConvertsToVoid ? ImplicitConversionSequence::Better
3814  } else if (!SCS1ConvertsToVoid && !SCS2ConvertsToVoid) {
3815  // Neither conversion sequence converts to a void pointer; compare
3816  // their derived-to-base conversions.
3818  = CompareDerivedToBaseConversions(S, Loc, SCS1, SCS2))
3819  return DerivedCK;
3820  } else if (SCS1ConvertsToVoid && SCS2ConvertsToVoid &&
3821  !S.Context.hasSameType(SCS1.getFromType(), SCS2.getFromType())) {
3822  // Both conversion sequences are conversions to void
3823  // pointers. Compare the source types to determine if there's an
3824  // inheritance relationship in their sources.
3825  QualType FromType1 = SCS1.getFromType();
3826  QualType FromType2 = SCS2.getFromType();
3827 
3828  // Adjust the types we're converting from via the array-to-pointer
3829  // conversion, if we need to.
3830  if (SCS1.First == ICK_Array_To_Pointer)
3831  FromType1 = S.Context.getArrayDecayedType(FromType1);
3832  if (SCS2.First == ICK_Array_To_Pointer)
3833  FromType2 = S.Context.getArrayDecayedType(FromType2);
3834 
3835  QualType FromPointee1 = FromType1->getPointeeType().getUnqualifiedType();
3836  QualType FromPointee2 = FromType2->getPointeeType().getUnqualifiedType();
3837 
3838  if (S.IsDerivedFrom(Loc, FromPointee2, FromPointee1))
3840  else if (S.IsDerivedFrom(Loc, FromPointee1, FromPointee2))
3842 
3843  // Objective-C++: If one interface is more specific than the
3844  // other, it is the better one.
3845  const ObjCObjectPointerType* FromObjCPtr1
3846  = FromType1->getAs<ObjCObjectPointerType>();
3847  const ObjCObjectPointerType* FromObjCPtr2
3848  = FromType2->getAs<ObjCObjectPointerType>();
3849  if (FromObjCPtr1 && FromObjCPtr2) {
3850  bool AssignLeft = S.Context.canAssignObjCInterfaces(FromObjCPtr1,
3851  FromObjCPtr2);
3852  bool AssignRight = S.Context.canAssignObjCInterfaces(FromObjCPtr2,
3853  FromObjCPtr1);
3854  if (AssignLeft != AssignRight) {
3855  return AssignLeft? ImplicitConversionSequence::Better
3857  }
3858  }
3859  }
3860 
3861  // Compare based on qualification conversions (C++ 13.3.3.2p3,
3862  // bullet 3).
3864  = CompareQualificationConversions(S, SCS1, SCS2))
3865  return QualCK;
3866 
3867  if (SCS1.ReferenceBinding && SCS2.ReferenceBinding) {
3868  // Check for a better reference binding based on the kind of bindings.
3869  if (isBetterReferenceBindingKind(SCS1, SCS2))
3871  else if (isBetterReferenceBindingKind(SCS2, SCS1))
3873 
3874  // C++ [over.ics.rank]p3b4:
3875  // -- S1 and S2 are reference bindings (8.5.3), and the types to
3876  // which the references refer are the same type except for
3877  // top-level cv-qualifiers, and the type to which the reference
3878  // initialized by S2 refers is more cv-qualified than the type
3879  // to which the reference initialized by S1 refers.
3880  QualType T1 = SCS1.getToType(2);
3881  QualType T2 = SCS2.getToType(2);
3882  T1 = S.Context.getCanonicalType(T1);
3883  T2 = S.Context.getCanonicalType(T2);
3884  Qualifiers T1Quals, T2Quals;
3885  QualType UnqualT1 = S.Context.getUnqualifiedArrayType(T1, T1Quals);
3886  QualType UnqualT2 = S.Context.getUnqualifiedArrayType(T2, T2Quals);
3887  if (UnqualT1 == UnqualT2) {
3888  // Objective-C++ ARC: If the references refer to objects with different
3889  // lifetimes, prefer bindings that don't change lifetime.
3890  if (SCS1.ObjCLifetimeConversionBinding !=
3892  return SCS1.ObjCLifetimeConversionBinding
3895  }
3896 
3897  // If the type is an array type, promote the element qualifiers to the
3898  // type for comparison.
3899  if (isa<ArrayType>(T1) && T1Quals)
3900  T1 = S.Context.getQualifiedType(UnqualT1, T1Quals);
3901  if (isa<ArrayType>(T2) && T2Quals)
3902  T2 = S.Context.getQualifiedType(UnqualT2, T2Quals);
3903  if (T2.isMoreQualifiedThan(T1))
3905  else if (T1.isMoreQualifiedThan(T2))
3907  }
3908  }
3909 
3910  // In Microsoft mode, prefer an integral conversion to a
3911  // floating-to-integral conversion if the integral conversion
3912  // is between types of the same size.
3913  // For example:
3914  // void f(float);
3915  // void f(int);
3916  // int main {
3917  // long a;
3918  // f(a);
3919  // }
3920  // Here, MSVC will call f(int) instead of generating a compile error
3921  // as clang will do in standard mode.
3922  if (S.getLangOpts().MSVCCompat && SCS1.Second == ICK_Integral_Conversion &&
3923  SCS2.Second == ICK_Floating_Integral &&
3924  S.Context.getTypeSize(SCS1.getFromType()) ==
3925  S.Context.getTypeSize(SCS1.getToType(2)))
3927 
3928  // Prefer a compatible vector conversion over a lax vector conversion
3929  // For example:
3930  //
3931  // typedef float __v4sf __attribute__((__vector_size__(16)));
3932  // void f(vector float);
3933  // void f(vector signed int);
3934  // int main() {
3935  // __v4sf a;
3936  // f(a);
3937  // }
3938  // Here, we'd like to choose f(vector float) and not
3939  // report an ambiguous call error
3940  if (SCS1.Second == ICK_Vector_Conversion &&
3941  SCS2.Second == ICK_Vector_Conversion) {
3942  bool SCS1IsCompatibleVectorConversion = S.Context.areCompatibleVectorTypes(
3943  SCS1.getFromType(), SCS1.getToType(2));
3944  bool SCS2IsCompatibleVectorConversion = S.Context.areCompatibleVectorTypes(
3945  SCS2.getFromType(), SCS2.getToType(2));
3946 
3947  if (SCS1IsCompatibleVectorConversion != SCS2IsCompatibleVectorConversion)
3948  return SCS1IsCompatibleVectorConversion
3951  }
3952 
3954 }
3955 
3956 /// CompareQualificationConversions - Compares two standard conversion
3957 /// sequences to determine whether they can be ranked based on their
3958 /// qualification conversions (C++ 13.3.3.2p3 bullet 3).
3961  const StandardConversionSequence& SCS1,
3962  const StandardConversionSequence& SCS2) {
3963  // C++ 13.3.3.2p3:
3964  // -- S1 and S2 differ only in their qualification conversion and
3965  // yield similar types T1 and T2 (C++ 4.4), respectively, and the
3966  // cv-qualification signature of type T1 is a proper subset of
3967  // the cv-qualification signature of type T2, and S1 is not the
3968  // deprecated string literal array-to-pointer conversion (4.2).
3969  if (SCS1.First != SCS2.First || SCS1.Second != SCS2.Second ||
3970  SCS1.Third != SCS2.Third || SCS1.Third != ICK_Qualification)
3972 
3973  // FIXME: the example in the standard doesn't use a qualification
3974  // conversion (!)
3975  QualType T1 = SCS1.getToType(2);
3976  QualType T2 = SCS2.getToType(2);
3977  T1 = S.Context.getCanonicalType(T1);
3978  T2 = S.Context.getCanonicalType(T2);
3979  Qualifiers T1Quals, T2Quals;
3980  QualType UnqualT1 = S.Context.getUnqualifiedArrayType(T1, T1Quals);
3981  QualType UnqualT2 = S.Context.getUnqualifiedArrayType(T2, T2Quals);
3982 
3983  // If the types are the same, we won't learn anything by unwrapped
3984  // them.
3985  if (UnqualT1 == UnqualT2)
3987 
3988  // If the type is an array type, promote the element qualifiers to the type
3989  // for comparison.
3990  if (isa<ArrayType>(T1) && T1Quals)
3991  T1 = S.Context.getQualifiedType(UnqualT1, T1Quals);
3992  if (isa<ArrayType>(T2) && T2Quals)
3993  T2 = S.Context.getQualifiedType(UnqualT2, T2Quals);
3994 
3997 
3998  // Objective-C++ ARC:
3999  // Prefer qualification conversions not involving a change in lifetime
4000  // to qualification conversions that do not change lifetime.
4003  Result = SCS1.QualificationIncludesObjCLifetime
4006  }
4007 
4008  while (S.Context.UnwrapSimilarTypes(T1, T2)) {
4009  // Within each iteration of the loop, we check the qualifiers to
4010  // determine if this still looks like a qualification
4011  // conversion. Then, if all is well, we unwrap one more level of
4012  // pointers or pointers-to-members and do it all again
4013  // until there are no more pointers or pointers-to-members left
4014  // to unwrap. This essentially mimics what
4015  // IsQualificationConversion does, but here we're checking for a
4016  // strict subset of qualifiers.
4017  if (T1.getQualifiers().withoutObjCLifetime() ==
4019  // The qualifiers are the same, so this doesn't tell us anything
4020  // about how the sequences rank.
4021  // ObjC ownership quals are omitted above as they interfere with
4022  // the ARC overload rule.
4023  ;
4024  else if (T2.isMoreQualifiedThan(T1)) {
4025  // T1 has fewer qualifiers, so it could be the better sequence.
4026  if (Result == ImplicitConversionSequence::Worse)
4027  // Neither has qualifiers that are a subset of the other's
4028  // qualifiers.
4030 
4032  } else if (T1.isMoreQualifiedThan(T2)) {
4033  // T2 has fewer qualifiers, so it could be the better sequence.
4034  if (Result == ImplicitConversionSequence::Better)
4035  // Neither has qualifiers that are a subset of the other's
4036  // qualifiers.
4038 
4040  } else {
4041  // Qualifiers are disjoint.
4043  }
4044 
4045  // If the types after this point are equivalent, we're done.
4046  if (S.Context.hasSameUnqualifiedType(T1, T2))
4047  break;
4048  }
4049 
4050  // Check that the winning standard conversion sequence isn't using
4051  // the deprecated string literal array to pointer conversion.
4052  switch (Result) {
4056  break;
4057 
4059  break;
4060 
4064  break;
4065  }
4066 
4067  return Result;
4068 }
4069 
4070 /// CompareDerivedToBaseConversions - Compares two standard conversion
4071 /// sequences to determine whether they can be ranked based on their
4072 /// various kinds of derived-to-base conversions (C++
4073 /// [over.ics.rank]p4b3). As part of these checks, we also look at
4074 /// conversions between Objective-C interface types.
4077  const StandardConversionSequence& SCS1,
4078  const StandardConversionSequence& SCS2) {
4079  QualType FromType1 = SCS1.getFromType();
4080  QualType ToType1 = SCS1.getToType(1);
4081  QualType FromType2 = SCS2.getFromType();
4082  QualType ToType2 = SCS2.getToType(1);
4083 
4084  // Adjust the types we're converting from via the array-to-pointer
4085  // conversion, if we need to.
4086  if (SCS1.First == ICK_Array_To_Pointer)
4087  FromType1 = S.Context.getArrayDecayedType(FromType1);
4088  if (SCS2.First == ICK_Array_To_Pointer)
4089  FromType2 = S.Context.getArrayDecayedType(FromType2);
4090 
4091  // Canonicalize all of the types.
4092  FromType1 = S.Context.getCanonicalType(FromType1);
4093  ToType1 = S.Context.getCanonicalType(ToType1);
4094  FromType2 = S.Context.getCanonicalType(FromType2);
4095  ToType2 = S.Context.getCanonicalType(ToType2);
4096 
4097  // C++ [over.ics.rank]p4b3:
4098  //
4099  // If class B is derived directly or indirectly from class A and
4100  // class C is derived directly or indirectly from B,
4101  //
4102  // Compare based on pointer conversions.
4103  if (SCS1.Second == ICK_Pointer_Conversion &&
4104  SCS2.Second == ICK_Pointer_Conversion &&
4105  /*FIXME: Remove if Objective-C id conversions get their own rank*/
4106  FromType1->isPointerType() && FromType2->isPointerType() &&
4107  ToType1->isPointerType() && ToType2->isPointerType()) {
4108  QualType FromPointee1
4109  = FromType1->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
4110  QualType ToPointee1
4111  = ToType1->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
4112  QualType FromPointee2
4113  = FromType2->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
4114  QualType ToPointee2
4115  = ToType2->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
4116 
4117  // -- conversion of C* to B* is better than conversion of C* to A*,
4118  if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
4119  if (S.IsDerivedFrom(Loc, ToPointee1, ToPointee2))
4121  else if (S.IsDerivedFrom(Loc, ToPointee2, ToPointee1))
4123  }
4124 
4125  // -- conversion of B* to A* is better than conversion of C* to A*,
4126  if (FromPointee1 != FromPointee2 && ToPointee1 == ToPointee2) {
4127  if (S.IsDerivedFrom(Loc, FromPointee2, FromPointee1))
4129  else if (S.IsDerivedFrom(Loc, FromPointee1, FromPointee2))
4131  }
4132  } else if (SCS1.Second == ICK_Pointer_Conversion &&
4133  SCS2.Second == ICK_Pointer_Conversion) {
4134  const ObjCObjectPointerType *FromPtr1
4135  = FromType1->getAs<ObjCObjectPointerType>();
4136  const ObjCObjectPointerType *FromPtr2
4137  = FromType2->getAs<ObjCObjectPointerType>();
4138  const ObjCObjectPointerType *ToPtr1
4139  = ToType1->getAs<ObjCObjectPointerType>();
4140  const ObjCObjectPointerType *ToPtr2
4141  = ToType2->getAs<ObjCObjectPointerType>();
4142 
4143  if (FromPtr1 && FromPtr2 && ToPtr1 && ToPtr2) {
4144  // Apply the same conversion ranking rules for Objective-C pointer types
4145  // that we do for C++ pointers to class types. However, we employ the
4146  // Objective-C pseudo-subtyping relationship used for assignment of
4147  // Objective-C pointer types.
4148  bool FromAssignLeft
4149  = S.Context.canAssignObjCInterfaces(FromPtr1, FromPtr2);
4150  bool FromAssignRight
4151  = S.Context.canAssignObjCInterfaces(FromPtr2, FromPtr1);
4152  bool ToAssignLeft
4153  = S.Context.canAssignObjCInterfaces(ToPtr1, ToPtr2);
4154  bool ToAssignRight
4155  = S.Context.canAssignObjCInterfaces(ToPtr2, ToPtr1);
4156 
4157  // A conversion to an a non-id object pointer type or qualified 'id'
4158  // type is better than a conversion to 'id'.
4159  if (ToPtr1->isObjCIdType() &&
4160  (ToPtr2->isObjCQualifiedIdType() || ToPtr2->getInterfaceDecl()))
4162  if (ToPtr2->isObjCIdType() &&
4163  (ToPtr1->isObjCQualifiedIdType() || ToPtr1->getInterfaceDecl()))
4165 
4166  // A conversion to a non-id object pointer type is better than a
4167  // conversion to a qualified 'id' type
4168  if (ToPtr1->isObjCQualifiedIdType() && ToPtr2->getInterfaceDecl())
4170  if (ToPtr2->isObjCQualifiedIdType() && ToPtr1->getInterfaceDecl())
4172 
4173  // A conversion to an a non-Class object pointer type or qualified 'Class'
4174  // type is better than a conversion to 'Class'.
4175  if (ToPtr1->isObjCClassType() &&
4176  (ToPtr2->isObjCQualifiedClassType() || ToPtr2->getInterfaceDecl()))
4178  if (ToPtr2->isObjCClassType() &&
4179  (ToPtr1->isObjCQualifiedClassType() || ToPtr1->getInterfaceDecl()))
4181 
4182  // A conversion to a non-Class object pointer type is better than a
4183  // conversion to a qualified 'Class' type.
4184  if (ToPtr1->isObjCQualifiedClassType() && ToPtr2->getInterfaceDecl())
4186  if (ToPtr2->isObjCQualifiedClassType() && ToPtr1->getInterfaceDecl())
4188 
4189  // -- "conversion of C* to B* is better than conversion of C* to A*,"
4190  if (S.Context.hasSameType(FromType1, FromType2) &&
4191  !FromPtr1->isObjCIdType() && !FromPtr1->isObjCClassType() &&
4192  (ToAssignLeft != ToAssignRight)) {
4193  if (FromPtr1->isSpecialized()) {
4194  // "conversion of B<A> * to B * is better than conversion of B * to
4195  // C *.
4196  bool IsFirstSame =
4197  FromPtr1->getInterfaceDecl() == ToPtr1->getInterfaceDecl();
4198  bool IsSecondSame =
4199  FromPtr1->getInterfaceDecl() == ToPtr2->getInterfaceDecl();
4200  if (IsFirstSame) {
4201  if (!IsSecondSame)
4203  } else if (IsSecondSame)
4205  }
4206  return ToAssignLeft? ImplicitConversionSequence::Worse
4208  }
4209 
4210  // -- "conversion of B* to A* is better than conversion of C* to A*,"
4211  if (S.Context.hasSameUnqualifiedType(ToType1, ToType2) &&
4212  (FromAssignLeft != FromAssignRight))
4213  return FromAssignLeft? ImplicitConversionSequence::Better
4215  }
4216  }
4217 
4218  // Ranking of member-pointer types.
4219  if (SCS1.Second == ICK_Pointer_Member && SCS2.Second == ICK_Pointer_Member &&
4220  FromType1->isMemberPointerType() && FromType2->isMemberPointerType() &&
4221  ToType1->isMemberPointerType() && ToType2->isMemberPointerType()) {
4222  const MemberPointerType * FromMemPointer1 =
4223  FromType1->getAs<MemberPointerType>();
4224  const MemberPointerType * ToMemPointer1 =
4225  ToType1->getAs<MemberPointerType>();
4226  const MemberPointerType * FromMemPointer2 =
4227  FromType2->getAs<MemberPointerType>();
4228  const MemberPointerType * ToMemPointer2 =
4229  ToType2->getAs<MemberPointerType>();
4230  const Type *FromPointeeType1 = FromMemPointer1->getClass();
4231  const Type *ToPointeeType1 = ToMemPointer1->getClass();
4232  const Type *FromPointeeType2 = FromMemPointer2->getClass();
4233  const Type *ToPointeeType2 = ToMemPointer2->getClass();
4234  QualType FromPointee1 = QualType(FromPointeeType1, 0).getUnqualifiedType();
4235  QualType ToPointee1 = QualType(ToPointeeType1, 0).getUnqualifiedType();
4236  QualType FromPointee2 = QualType(FromPointeeType2, 0).getUnqualifiedType();
4237  QualType ToPointee2 = QualType(ToPointeeType2, 0).getUnqualifiedType();
4238  // conversion of A::* to B::* is better than conversion of A::* to C::*,
4239  if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
4240  if (S.IsDerivedFrom(Loc, ToPointee1, ToPointee2))
4242  else if (S.IsDerivedFrom(Loc, ToPointee2, ToPointee1))
4244  }
4245  // conversion of B::* to C::* is better than conversion of A::* to C::*
4246  if (ToPointee1 == ToPointee2 && FromPointee1 != FromPointee2) {
4247  if (S.IsDerivedFrom(Loc, FromPointee1, FromPointee2))
4249  else if (S.IsDerivedFrom(Loc, FromPointee2, FromPointee1))
4251  }
4252  }
4253 
4254  if (SCS1.Second == ICK_Derived_To_Base) {
4255  // -- conversion of C to B is better than conversion of C to A,
4256  // -- binding of an expression of type C to a reference of type
4257  // B& is better than binding an expression of type C to a
4258  // reference of type A&,
4259  if (S.Context.hasSameUnqualifiedType(FromType1, FromType2) &&
4260  !S.Context.hasSameUnqualifiedType(ToType1, ToType2)) {
4261  if (S.IsDerivedFrom(Loc, ToType1, ToType2))
4263  else if (S.IsDerivedFrom(Loc, ToType2, ToType1))
4265  }
4266 
4267  // -- conversion of B to A is better than conversion of C to A.
4268  // -- binding of an expression of type B to a reference of type
4269  // A& is better than binding an expression of type C to a
4270  // reference of type A&,
4271  if (!S.Context.hasSameUnqualifiedType(FromType1, FromType2) &&
4272  S.Context.hasSameUnqualifiedType(ToType1, ToType2)) {
4273  if (S.IsDerivedFrom(Loc, FromType2, FromType1))
4275  else if (S.IsDerivedFrom(Loc, FromType1, FromType2))
4277  }
4278  }
4279 
4281 }
4282 
4283 /// Determine whether the given type is valid, e.g., it is not an invalid
4284 /// C++ class.
4285 static bool isTypeValid(QualType T) {
4286  if (CXXRecordDecl *Record = T->getAsCXXRecordDecl())
4287  return !Record->isInvalidDecl();
4288 
4289  return true;
4290 }
4291 
4292 /// CompareReferenceRelationship - Compare the two types T1 and T2 to
4293 /// determine whether they are reference-related,
4294 /// reference-compatible, reference-compatible with added
4295 /// qualification, or incompatible, for use in C++ initialization by
4296 /// reference (C++ [dcl.ref.init]p4). Neither type can be a reference
4297 /// type, and the first type (T1) is the pointee type of the reference
4298 /// type being initialized.
4301  QualType OrigT1, QualType OrigT2,
4302  bool &DerivedToBase,
4303  bool &ObjCConversion,
4304  bool &ObjCLifetimeConversion) {
4305  assert(!OrigT1->isReferenceType() &&
4306  "T1 must be the pointee type of the reference type");
4307  assert(!OrigT2->isReferenceType() && "T2 cannot be a reference type");
4308 
4309  QualType T1 = Context.getCanonicalType(OrigT1);
4310  QualType T2 = Context.getCanonicalType(OrigT2);
4311  Qualifiers T1Quals, T2Quals;
4312  QualType UnqualT1 = Context.getUnqualifiedArrayType(T1, T1Quals);
4313  QualType UnqualT2 = Context.getUnqualifiedArrayType(T2, T2Quals);
4314 
4315  // C++ [dcl.init.ref]p4:
4316  // Given types "cv1 T1" and "cv2 T2," "cv1 T1" is
4317  // reference-related to "cv2 T2" if T1 is the same type as T2, or
4318  // T1 is a base class of T2.
4319  DerivedToBase = false;
4320  ObjCConversion = false;
4321  ObjCLifetimeConversion = false;
4322  QualType ConvertedT2;
4323  if (UnqualT1 == UnqualT2) {
4324  // Nothing to do.
4325  } else if (isCompleteType(Loc, OrigT2) &&
4326  isTypeValid(UnqualT1) && isTypeValid(UnqualT2) &&
4327  IsDerivedFrom(Loc, UnqualT2, UnqualT1))
4328  DerivedToBase = true;
4329  else if (UnqualT1->isObjCObjectOrInterfaceType() &&
4330  UnqualT2->isObjCObjectOrInterfaceType() &&
4331  Context.canBindObjCObjectType(UnqualT1, UnqualT2))
4332  ObjCConversion = true;
4333  else if (UnqualT2->isFunctionType() &&
4334  IsFunctionConversion(UnqualT2, UnqualT1, ConvertedT2))
4335  // C++1z [dcl.init.ref]p4:
4336  // cv1 T1" is reference-compatible with "cv2 T2" if [...] T2 is "noexcept
4337  // function" and T1 is "function"
4338  //
4339  // We extend this to also apply to 'noreturn', so allow any function
4340  // conversion between function types.
4341  return Ref_Compatible;
4342  else
4343  return Ref_Incompatible;
4344 
4345  // At this point, we know that T1 and T2 are reference-related (at
4346  // least).
4347 
4348  // If the type is an array type, promote the element qualifiers to the type
4349  // for comparison.
4350  if (isa<ArrayType>(T1) && T1Quals)
4351  T1 = Context.getQualifiedType(UnqualT1, T1Quals);
4352  if (isa<ArrayType>(T2) && T2Quals)
4353  T2 = Context.getQualifiedType(UnqualT2, T2Quals);
4354 
4355  // C++ [dcl.init.ref]p4:
4356  // "cv1 T1" is reference-compatible with "cv2 T2" if T1 is
4357  // reference-related to T2 and cv1 is the same cv-qualification
4358  // as, or greater cv-qualification than, cv2. For purposes of
4359  // overload resolution, cases for which cv1 is greater
4360  // cv-qualification than cv2 are identified as
4361  // reference-compatible with added qualification (see 13.3.3.2).
4362  //
4363  // Note that we also require equivalence of Objective-C GC and address-space
4364  // qualifiers when performing these computations, so that e.g., an int in
4365  // address space 1 is not reference-compatible with an int in address
4366  // space 2.
4367  if (T1Quals.getObjCLifetime() != T2Quals.getObjCLifetime() &&
4368  T1Quals.compatiblyIncludesObjCLifetime(T2Quals)) {
4369  if (isNonTrivialObjCLifetimeConversion(T2Quals, T1Quals))
4370  ObjCLifetimeConversion = true;
4371 
4372  T1Quals.removeObjCLifetime();
4373  T2Quals.removeObjCLifetime();
4374  }
4375 
4376  // MS compiler ignores __unaligned qualifier for references; do the same.
4377  T1Quals.removeUnaligned();
4378  T2Quals.removeUnaligned();
4379 
4380  if (T1Quals.compatiblyIncludes(T2Quals))
4381  return Ref_Compatible;
4382  else
4383  return Ref_Related;
4384 }
4385 
4386 /// Look for a user-defined conversion to a value reference-compatible
4387 /// with DeclType. Return true if something definite is found.
4388 static bool
4390  QualType DeclType, SourceLocation DeclLoc,
4391  Expr *Init, QualType T2, bool AllowRvalues,
4392  bool AllowExplicit) {
4393  assert(T2->isRecordType() && "Can only find conversions of record types.");
4394  CXXRecordDecl *T2RecordDecl
4395  = dyn_cast<CXXRecordDecl>(T2->getAs<RecordType>()->getDecl());
4396 
4397  OverloadCandidateSet CandidateSet(
4399  const auto &Conversions = T2RecordDecl->getVisibleConversionFunctions();
4400  for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
4401  NamedDecl *D = *I;
4402  CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
4403  if (isa<UsingShadowDecl>(D))
4404  D = cast<UsingShadowDecl>(D)->getTargetDecl();
4405 
4406  FunctionTemplateDecl *ConvTemplate
4407  = dyn_cast<FunctionTemplateDecl>(D);
4408  CXXConversionDecl *Conv;
4409  if (ConvTemplate)
4410  Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
4411  else
4412  Conv = cast<CXXConversionDecl>(D);
4413 
4414  // If this is an explicit conversion, and we're not allowed to consider
4415  // explicit conversions, skip it.
4416  if (!AllowExplicit && Conv->isExplicit())
4417  continue;
4418 
4419  if (AllowRvalues) {
4420  bool DerivedToBase = false;
4421  bool ObjCConversion = false;
4422  bool ObjCLifetimeConversion = false;
4423 
4424  // If we are initializing an rvalue reference, don't permit conversion
4425  // functions that return lvalues.
4426  if (!ConvTemplate && DeclType->isRValueReferenceType()) {
4427  const ReferenceType *RefType
4428  = Conv->getConversionType()->getAs<LValueReferenceType>();
4429  if (RefType && !RefType->getPointeeType()->isFunctionType())
4430  continue;
4431  }
4432 
4433  if (!ConvTemplate &&
4435  DeclLoc,
4436  Conv->getConversionType().getNonReferenceType()
4437  .getUnqualifiedType(),
4439  DerivedToBase, ObjCConversion, ObjCLifetimeConversion) ==
4441  continue;
4442  } else {
4443  // If the conversion function doesn't return a reference type,
4444  // it can't be considered for this conversion. An rvalue reference
4445  // is only acceptable if its referencee is a function type.
4446 
4447  const ReferenceType *RefType =
4448  Conv->getConversionType()->getAs<ReferenceType>();
4449  if (!RefType ||
4450  (!RefType->isLValueReferenceType() &&
4451  !RefType->getPointeeType()->isFunctionType()))
4452  continue;
4453  }
4454 
4455  if (ConvTemplate)
4457  ConvTemplate, I.getPair(), ActingDC, Init, DeclType, CandidateSet,
4458  /*AllowObjCConversionOnExplicit=*/false, AllowExplicit);
4459  else
4461  Conv, I.getPair(), ActingDC, Init, DeclType, CandidateSet,
4462  /*AllowObjCConversionOnExplicit=*/false, AllowExplicit);
4463  }
4464 
4465  bool HadMultipleCandidates = (CandidateSet.size() > 1);
4466 
4468  switch (CandidateSet.BestViableFunction(S, DeclLoc, Best)) {
4469  case OR_Success:
4470  // C++ [over.ics.ref]p1:
4471  //
4472  // [...] If the parameter binds directly to the result of
4473  // applying a conversion function to the argument
4474  // expression, the implicit conversion sequence is a
4475  // user-defined conversion sequence (13.3.3.1.2), with the
4476  // second standard conversion sequence either an identity
4477  // conversion or, if the conversion function returns an
4478  // entity of a type that is a derived class of the parameter
4479  // type, a derived-to-base Conversion.
4480  if (!Best->FinalConversion.DirectBinding)
4481  return false;
4482 
4483  ICS.setUserDefined();
4484  ICS.UserDefined.Before = Best->Conversions[0].Standard;
4485  ICS.UserDefined.After = Best->FinalConversion;
4486  ICS.UserDefined.HadMultipleCandidates = HadMultipleCandidates;
4487  ICS.UserDefined.ConversionFunction = Best->Function;
4488  ICS.UserDefined.FoundConversionFunction = Best->FoundDecl;
4489  ICS.UserDefined.EllipsisConversion = false;
4490  assert(ICS.UserDefined.After.ReferenceBinding &&
4492  "Expected a direct reference binding!");
4493  return true;
4494 
4495  case OR_Ambiguous:
4496  ICS.setAmbiguous();
4497  for (OverloadCandidateSet::iterator Cand = CandidateSet.begin();
4498  Cand != CandidateSet.end(); ++Cand)
4499  if (Cand->Viable)
4500  ICS.Ambiguous.addConversion(Cand->FoundDecl, Cand->Function);
4501  return true;
4502 
4503  case OR_No_Viable_Function:
4504  case OR_Deleted:
4505  // There was no suitable conversion, or we found a deleted
4506  // conversion; continue with other checks.
4507  return false;
4508  }
4509 
4510  llvm_unreachable("Invalid OverloadResult!");
4511 }
4512 
4513 /// Compute an implicit conversion sequence for reference
4514 /// initialization.
4516 TryReferenceInit(Sema &S, Expr *Init, QualType DeclType,
4517  SourceLocation DeclLoc,
4518  bool SuppressUserConversions,
4519  bool AllowExplicit) {
4520  assert(DeclType->isReferenceType() && "Reference init needs a reference");
4521 
4522  // Most paths end in a failed conversion.
4524  ICS.setBad(BadConversionSequence::no_conversion, Init, DeclType);
4525 
4526  QualType T1 = DeclType->getAs<ReferenceType>()->getPointeeType();
4527  QualType T2 = Init->getType();
4528 
4529  // If the initializer is the address of an overloaded function, try
4530  // to resolve the overloaded function. If all goes well, T2 is the
4531  // type of the resulting function.
4532  if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) {
4533  DeclAccessPair Found;
4534  if (FunctionDecl *Fn = S.ResolveAddressOfOverloadedFunction(Init, DeclType,
4535  false, Found))
4536  T2 = Fn->getType();
4537  }
4538 
4539  // Compute some basic properties of the types and the initializer.
4540  bool isRValRef = DeclType->isRValueReferenceType();
4541  bool DerivedToBase = false;
4542  bool ObjCConversion = false;
4543  bool ObjCLifetimeConversion = false;
4544  Expr::Classification InitCategory = Init->Classify(S.Context);
4545  Sema::ReferenceCompareResult RefRelationship
4546  = S.CompareReferenceRelationship(DeclLoc, T1, T2, DerivedToBase,
4547  ObjCConversion, ObjCLifetimeConversion);
4548 
4549 
4550  // C++0x [dcl.init.ref]p5:
4551  // A reference to type "cv1 T1" is initialized by an expression
4552  // of type "cv2 T2" as follows:
4553 
4554  // -- If reference is an lvalue reference and the initializer expression
4555  if (!isRValRef) {
4556  // -- is an lvalue (but is not a bit-field), and "cv1 T1" is
4557  // reference-compatible with "cv2 T2," or
4558  //
4559  // Per C++ [over.ics.ref]p4, we don't check the bit-field property here.
4560  if (InitCategory.isLValue() && RefRelationship == Sema::Ref_Compatible) {
4561  // C++ [over.ics.ref]p1:
4562  // When a parameter of reference type binds directly (8.5.3)
4563  // to an argument expression, the implicit conversion sequence
4564  // is the identity conversion, unless the argument expression
4565  // has a type that is a derived class of the parameter type,
4566  // in which case the implicit conversion sequence is a
4567  // derived-to-base Conversion (13.3.3.1).
4568  ICS.setStandard();
4569  ICS.Standard.First = ICK_Identity;
4570  ICS.Standard.Second = DerivedToBase? ICK_Derived_To_Base
4571  : ObjCConversion? ICK_Compatible_Conversion
4572  : ICK_Identity;
4573  ICS.Standard.Third = ICK_Identity;
4574  ICS.Standard.FromTypePtr = T2.getAsOpaquePtr();
4575  ICS.Standard.setToType(0, T2);
4576  ICS.Standard.setToType(1, T1);
4577  ICS.Standard.setToType(2, T1);
4578  ICS.Standard.ReferenceBinding = true;
4579  ICS.Standard.DirectBinding = true;
4580  ICS.Standard.IsLvalueReference = !isRValRef;
4581  ICS.Standard.BindsToFunctionLvalue = T2->isFunctionType();
4582  ICS.Standard.BindsToRvalue = false;
4583  ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false;
4584  ICS.Standard.ObjCLifetimeConversionBinding = ObjCLifetimeConversion;
4585  ICS.Standard.CopyConstructor = nullptr;
4586  ICS.Standard.DeprecatedStringLiteralToCharPtr = false;
4587 
4588  // Nothing more to do: the inaccessibility/ambiguity check for
4589  // derived-to-base conversions is suppressed when we're
4590  // computing the implicit conversion sequence (C++
4591  // [over.best.ics]p2).
4592  return ICS;
4593  }
4594 
4595  // -- has a class type (i.e., T2 is a class type), where T1 is
4596  // not reference-related to T2, and can be implicitly
4597  // converted to an lvalue of type "cv3 T3," where "cv1 T1"
4598  // is reference-compatible with "cv3 T3" 92) (this
4599  // conversion is selected by enumerating the applicable
4600  // conversion functions (13.3.1.6) and choosing the best
4601  // one through overload resolution (13.3)),
4602  if (!SuppressUserConversions && T2->isRecordType() &&
4603  S.isCompleteType(DeclLoc, T2) &&
4604  RefRelationship == Sema::Ref_Incompatible) {
4605  if (FindConversionForRefInit(S, ICS, DeclType, DeclLoc,
4606  Init, T2, /*AllowRvalues=*/false,
4607  AllowExplicit))
4608  return ICS;
4609  }
4610  }
4611 
4612  // -- Otherwise, the reference shall be an lvalue reference to a
4613  // non-volatile const type (i.e., cv1 shall be const), or the reference
4614  // shall be an rvalue reference.
4615  if (!isRValRef && (!T1.isConstQualified() || T1.isVolatileQualified()))
4616  return ICS;
4617 
4618  // -- If the initializer expression
4619  //
4620  // -- is an xvalue, class prvalue, array prvalue or function
4621  // lvalue and "cv1 T1" is reference-compatible with "cv2 T2", or
4622  if (RefRelationship == Sema::Ref_Compatible &&
4623  (InitCategory.isXValue() ||
4624  (InitCategory.isPRValue() && (T2->isRecordType() || T2->isArrayType())) ||
4625  (InitCategory.isLValue() && T2->isFunctionType()))) {
4626  ICS.setStandard();
4627  ICS.Standard.First = ICK_Identity;
4628  ICS.Standard.Second = DerivedToBase? ICK_Derived_To_Base
4629  : ObjCConversion? ICK_Compatible_Conversion
4630  : ICK_Identity;
4631  ICS.Standard.Third = ICK_Identity;
4632  ICS.Standard.FromTypePtr = T2.getAsOpaquePtr();
4633  ICS.Standard.setToType(0, T2);
4634  ICS.Standard.setToType(1, T1);
4635  ICS.Standard.setToType(2, T1);
4636  ICS.Standard.ReferenceBinding = true;
4637  // In C++0x, this is always a direct binding. In C++98/03, it's a direct
4638  // binding unless we're binding to a class prvalue.
4639  // Note: Although xvalues wouldn't normally show up in C++98/03 code, we
4640  // allow the use of rvalue references in C++98/03 for the benefit of
4641  // standard library implementors; therefore, we need the xvalue check here.
4642  ICS.Standard.DirectBinding =
4643  S.getLangOpts().CPlusPlus11 ||
4644  !(InitCategory.isPRValue() || T2->isRecordType());
4645  ICS.Standard.IsLvalueReference = !isRValRef;
4646  ICS.Standard.BindsToFunctionLvalue = T2->isFunctionType();
4647  ICS.Standard.BindsToRvalue = InitCategory.isRValue();
4648  ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false;
4649  ICS.Standard.ObjCLifetimeConversionBinding = ObjCLifetimeConversion;
4650  ICS.Standard.CopyConstructor = nullptr;
4651  ICS.Standard.DeprecatedStringLiteralToCharPtr = false;
4652  return ICS;
4653  }
4654 
4655  // -- has a class type (i.e., T2 is a class type), where T1 is not
4656  // reference-related to T2, and can be implicitly converted to
4657  // an xvalue, class prvalue, or function lvalue of type
4658  // "cv3 T3", where "cv1 T1" is reference-compatible with
4659  // "cv3 T3",
4660  //
4661  // then the reference is bound to the value of the initializer
4662  // expression in the first case and to the result of the conversion
4663  // in the second case (or, in either case, to an appropriate base
4664  // class subobject).
4665  if (!SuppressUserConversions && RefRelationship == Sema::Ref_Incompatible &&
4666  T2->isRecordType() && S.isCompleteType(DeclLoc, T2) &&
4667  FindConversionForRefInit(S, ICS, DeclType, DeclLoc,
4668  Init, T2, /*AllowRvalues=*/true,
4669  AllowExplicit)) {
4670  // In the second case, if the reference is an rvalue reference
4671  // and the second standard conversion sequence of the
4672  // user-defined conversion sequence includes an lvalue-to-rvalue
4673  // conversion, the program is ill-formed.
4674  if (ICS.isUserDefined() && isRValRef &&
4675  ICS.UserDefined.After.First == ICK_Lvalue_To_Rvalue)
4676  ICS.setBad(BadConversionSequence::no_conversion, Init, DeclType);
4677 
4678  return ICS;
4679  }
4680 
4681  // A temporary of function type cannot be created; don't even try.
4682  if (T1->isFunctionType())
4683  return ICS;
4684 
4685  // -- Otherwise, a temporary of type "cv1 T1" is created and
4686  // initialized from the initializer expression using the
4687  // rules for a non-reference copy initialization (8.5). The
4688  // reference is then bound to the temporary. If T1 is
4689  // reference-related to T2, cv1 must be the same
4690  // cv-qualification as, or greater cv-qualification than,
4691  // cv2; otherwise, the program is ill-formed.
4692  if (RefRelationship == Sema::Ref_Related) {
4693  // If cv1 == cv2 or cv1 is a greater cv-qualified than cv2, then
4694  // we would be reference-compatible or reference-compatible with
4695  // added qualification. But that wasn't the case, so the reference
4696  // initialization fails.
4697  //
4698  // Note that we only want to check address spaces and cvr-qualifiers here.
4699  // ObjC GC, lifetime and unaligned qualifiers aren't important.
4700  Qualifiers T1Quals = T1.getQualifiers();
4701  Qualifiers T2Quals = T2.getQualifiers();
4702  T1Quals.removeObjCGCAttr();
4703  T1Quals.removeObjCLifetime();
4704  T2Quals.removeObjCGCAttr();
4705  T2Quals.removeObjCLifetime();
4706  // MS compiler ignores __unaligned qualifier for references; do the same.
4707  T1Quals.removeUnaligned();
4708  T2Quals.removeUnaligned();
4709  if (!T1Quals.compatiblyIncludes(T2Quals))
4710  return ICS;
4711  }
4712 
4713  // If at least one of the types is a class type, the types are not
4714  // related, and we aren't allowed any user conversions, the
4715  // reference binding fails. This case is important for breaking
4716  // recursion, since TryImplicitConversion below will attempt to
4717  // create a temporary through the use of a copy constructor.
4718  if (SuppressUserConversions && RefRelationship == Sema::Ref_Incompatible &&
4719  (T1->isRecordType() || T2->isRecordType()))
4720  return ICS;
4721 
4722  // If T1 is reference-related to T2 and the reference is an rvalue
4723  // reference, the initializer expression shall not be an lvalue.
4724  if (RefRelationship >= Sema::Ref_Related &&
4725  isRValRef && Init->Classify(S.Context).isLValue())
4726  return ICS;
4727 
4728  // C++ [over.ics.ref]p2:
4729  // When a parameter of reference type is not bound directly to
4730  // an argument expression, the conversion sequence is the one
4731  // required to convert the argument expression to the
4732  // underlying type of the reference according to
4733  // 13.3.3.1. Conceptually, this conversion sequence corresponds
4734  // to copy-initializing a temporary of the underlying type with
4735  // the argument expression. Any difference in top-level
4736  // cv-qualification is subsumed by the initialization itself
4737  // and does not constitute a conversion.
4738  ICS = TryImplicitConversion(S, Init, T1, SuppressUserConversions,
4739  /*AllowExplicit=*/false,
4740  /*InOverloadResolution=*/false,
4741  /*CStyle=*/false,
4742  /*AllowObjCWritebackConversion=*/false,
4743  /*AllowObjCConversionOnExplicit=*/false);
4744 
4745  // Of course, that's still a reference binding.
4746  if (ICS.isStandard()) {
4747  ICS.Standard.ReferenceBinding = true;
4748  ICS.Standard.IsLvalueReference = !isRValRef;
4749  ICS.Standard.BindsToFunctionLvalue = false;
4750  ICS.Standard.BindsToRvalue = true;
4751  ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false;
4752  ICS.Standard.ObjCLifetimeConversionBinding = false;
4753  } else if (ICS.isUserDefined()) {
4754  const ReferenceType *LValRefType =
4755  ICS.UserDefined.ConversionFunction->getReturnType()
4757 
4758  // C++ [over.ics.ref]p3:
4759  // Except for an implicit object parameter, for which see 13.3.1, a
4760  // standard conversion sequence cannot be formed if it requires [...]
4761  // binding an rvalue reference to an lvalue other than a function
4762  // lvalue.
4763  // Note that the function case is not possible here.
4764  if (DeclType->isRValueReferenceType() && LValRefType) {
4765  // FIXME: This is the wrong BadConversionSequence. The problem is binding
4766  // an rvalue reference to a (non-function) lvalue, not binding an lvalue
4767  // reference to an rvalue!
4768  ICS.setBad(BadConversionSequence::lvalue_ref_to_rvalue, Init, DeclType);
4769  return ICS;
4770  }
4771 
4772  ICS.UserDefined.After.ReferenceBinding = true;
4773  ICS.UserDefined.After.IsLvalueReference = !isRValRef;
4774  ICS.UserDefined.After.BindsToFunctionLvalue = false;
4775  ICS.UserDefined.After.BindsToRvalue = !LValRefType;
4776  ICS.UserDefined.After.BindsImplicitObjectArgumentWithoutRefQualifier = false;
4777  ICS.UserDefined.After.ObjCLifetimeConversionBinding = false;
4778  }
4779 
4780  return ICS;
4781 }
4782 
4784 TryCopyInitialization(Sema &S, Expr *From, QualType ToType,
4785  bool SuppressUserConversions,
4786  bool InOverloadResolution,
4787  bool AllowObjCWritebackConversion,
4788  bool AllowExplicit = false);
4789 
4790 /// TryListConversion - Try to copy-initialize a value of type ToType from the
4791 /// initializer list From.
4794  bool SuppressUserConversions,
4795  bool InOverloadResolution,
4796  bool AllowObjCWritebackConversion) {
4797  // C++11 [over.ics.list]p1:
4798  // When an argument is an initializer list, it is not an expression and
4799  // special rules apply for converting it to a parameter type.
4800 
4802  Result.setBad(BadConversionSequence::no_conversion, From, ToType);
4803 
4804  // We need a complete type for what follows. Incomplete types can never be
4805  // initialized from init lists.
4806  if (!S.isCompleteType(From->getBeginLoc(), ToType))
4807  return Result;
4808 
4809  // Per DR1467:
4810  // If the parameter type is a class X and the initializer list has a single
4811  // element of type cv U, where U is X or a class derived from X, the
4812  // implicit conversion sequence is the one required to convert the element
4813  // to the parameter type.
4814  //
4815  // Otherwise, if the parameter type is a character array [... ]
4816  // and the initializer list has a single element that is an
4817  // appropriately-typed string literal (8.5.2 [dcl.init.string]), the
4818  // implicit conversion sequence is the identity conversion.
4819  if (From->getNumInits() == 1) {
4820  if (ToType->isRecordType()) {
4821  QualType InitType = From->getInit(0)->getType();
4822  if (S.Context.hasSameUnqualifiedType(InitType, ToType) ||
4823  S.IsDerivedFrom(From->getBeginLoc(), InitType, ToType))
4824  return TryCopyInitialization(S, From->getInit(0), ToType,
4825  SuppressUserConversions,
4826  InOverloadResolution,
4827  AllowObjCWritebackConversion);
4828  }
4829  // FIXME: Check the other conditions here: array of character type,
4830  // initializer is a string literal.
4831  if (ToType->isArrayType()) {
4832  InitializedEntity Entity =
4834  /*Consumed=*/false);
4835  if (S.CanPerformCopyInitialization(Entity, From)) {
4836  Result.setStandard();
4838  Result.Standard.setFromType(ToType);
4839  Result.Standard.setAllToTypes(ToType);
4840  return Result;
4841  }
4842  }
4843  }
4844 
4845  // C++14 [over.ics.list]p2: Otherwise, if the parameter type [...] (below).
4846  // C++11 [over.ics.list]p2:
4847  // If the parameter type is std::initializer_list<X> or "array of X" and
4848  // all the elements can be implicitly converted to X, the implicit
4849  // conversion sequence is the worst conversion necessary to convert an
4850  // element of the list to X.
4851  //
4852  // C++14 [over.ics.list]p3:
4853  // Otherwise, if the parameter type is "array of N X", if the initializer
4854  // list has exactly N elements or if it has fewer than N elements and X is
4855  // default-constructible, and if all the elements of the initializer list
4856  // can be implicitly converted to X, the implicit conversion sequence is
4857  // the worst conversion necessary to convert an element of the list to X.
4858  //
4859  // FIXME: We're missing a lot of these checks.
4860  bool toStdInitializerList = false;
4861  QualType X;
4862  if (ToType->isArrayType())
4863  X = S.Context.getAsArrayType(ToType)->getElementType();
4864  else
4865  toStdInitializerList = S.isStdInitializerList(ToType, &X);
4866  if (!X.isNull()) {
4867  for (unsigned i = 0, e = From->getNumInits(); i < e; ++i) {
4868  Expr *Init = From->getInit(i);
4870  TryCopyInitialization(S, Init, X, SuppressUserConversions,
4871  InOverloadResolution,
4872  AllowObjCWritebackConversion);
4873  // If a single element isn't convertible, fail.
4874  if (ICS.isBad()) {
4875  Result = ICS;
4876  break;
4877  }
4878  // Otherwise, look for the worst conversion.
4879  if (Result.isBad() || CompareImplicitConversionSequences(
4880  S, From->getBeginLoc(), ICS, Result) ==
4882  Result = ICS;
4883  }
4884 
4885  // For an empty list, we won't have computed any conversion sequence.
4886  // Introduce the identity conversion sequence.
4887  if (From->getNumInits() == 0) {
4888  Result.setStandard();
4890  Result.Standard.setFromType(ToType);
4891  Result.Standard.setAllToTypes(ToType);
4892  }
4893 
4894  Result.setStdInitializerListElement(toStdInitializerList);
4895  return Result;
4896  }
4897 
4898  // C++14 [over.ics.list]p4:
4899  // C++11 [over.ics.list]p3:
4900  // Otherwise, if the parameter is a non-aggregate class X and overload
4901  // resolution chooses a single best constructor [...] the implicit
4902  // conversion sequence is a user-defined conversion sequence. If multiple
4903  // constructors are viable but none is better than the others, the
4904  // implicit conversion sequence is a user-defined conversion sequence.
4905  if (ToType->isRecordType() && !ToType->isAggregateType()) {
4906  // This function can deal with initializer lists.
4907  return TryUserDefinedConversion(S, From, ToType, SuppressUserConversions,
4908  /*AllowExplicit=*/false,
4909  InOverloadResolution, /*CStyle=*/false,
4910  AllowObjCWritebackConversion,
4911  /*AllowObjCConversionOnExplicit=*/false);
4912  }
4913 
4914  // C++14 [over.ics.list]p5:
4915  // C++11 [over.ics.list]p4:
4916  // Otherwise, if the parameter has an aggregate type which can be
4917  // initialized from the initializer list [...] the implicit conversion
4918  // sequence is a user-defined conversion sequence.
4919  if (ToType->isAggregateType()) {
4920  // Type is an aggregate, argument is an init list. At this point it comes
4921  // down to checking whether the initialization works.
4922  // FIXME: Find out whether this parameter is consumed or not.
4923  // FIXME: Expose SemaInit's aggregate initialization code so that we don't
4924  // need to call into the initialization code here; overload resolution
4925  // should not be doing that.
4926  InitializedEntity Entity =
4928  /*Consumed=*/false);
4929  if (S.CanPerformCopyInitialization(Entity, From)) {
4930  Result.setUserDefined();
4932  // Initializer lists don't have a type.
4935 
4937  Result.UserDefined.After.setFromType(ToType);
4938  Result.UserDefined.After.setAllToTypes(ToType);
4939  Result.UserDefined.ConversionFunction = nullptr;
4940  }
4941  return Result;
4942  }
4943 
4944  // C++14 [over.ics.list]p6:
4945  // C++11 [over.ics.list]p5:
4946  // Otherwise, if the parameter is a reference, see 13.3.3.1.4.
4947  if (ToType->isReferenceType()) {
4948  // The standard is notoriously unclear here, since 13.3.3.1.4 doesn't
4949  // mention initializer lists in any way. So we go by what list-
4950  // initialization would do and try to extrapolate from that.
4951 
4952  QualType T1 = ToType->getAs<ReferenceType>()->getPointeeType();
4953 
4954  // If the initializer list has a single element that is reference-related
4955  // to the parameter type, we initialize the reference from that.
4956  if (From->getNumInits() == 1) {
4957  Expr *Init = From->getInit(0);
4958 
4959  QualType T2 = Init->getType();
4960 
4961  // If the initializer is the address of an overloaded function, try
4962  // to resolve the overloaded function. If all goes well, T2 is the
4963  // type of the resulting function.
4964  if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) {
4965  DeclAccessPair Found;
4967  Init, ToType, false, Found))
4968  T2 = Fn->getType();
4969  }
4970 
4971  // Compute some basic properties of the types and the initializer.
4972  bool dummy1 = false;
4973  bool dummy2 = false;
4974  bool dummy3 = false;
4975  Sema::ReferenceCompareResult RefRelationship =
4976  S.CompareReferenceRelationship(From->getBeginLoc(), T1, T2, dummy1,
4977  dummy2, dummy3);
4978 
4979  if (RefRelationship >= Sema::Ref_Related) {
4980  return TryReferenceInit(S, Init, ToType, /*FIXME*/ From->getBeginLoc(),
4981  SuppressUserConversions,
4982  /*AllowExplicit=*/false);
4983  }
4984  }
4985 
4986  // Otherwise, we bind the reference to a temporary created from the
4987  // initializer list.
4988  Result = TryListConversion(S, From, T1, SuppressUserConversions,
4989  InOverloadResolution,
4990  AllowObjCWritebackConversion);
4991  if (Result.isFailure())
4992  return Result;
4993  assert(!Result.isEllipsis() &&
4994  "Sub-initialization cannot result in ellipsis conversion.");
4995 
4996  // Can we even bind to a temporary?
4997  if (ToType->isRValueReferenceType() ||
4998  (T1.isConstQualified() && !T1.isVolatileQualified())) {
4999  StandardConversionSequence &SCS = Result.isStandard() ? Result.Standard :
5000  Result.UserDefined.After;
5001  SCS.ReferenceBinding = true;
5002  SCS.IsLvalueReference = ToType->isLValueReferenceType();
5003  SCS.BindsToRvalue = true;
5004  SCS.BindsToFunctionLvalue = false;
5006  SCS.ObjCLifetimeConversionBinding = false;
5007  } else
5009  From, ToType);
5010  return Result;
5011  }
5012 
5013  // C++14 [over.ics.list]p7:
5014  // C++11 [over.ics.list]p6:
5015  // Otherwise, if the parameter type is not a class:
5016  if (!ToType->isRecordType()) {
5017  // - if the initializer list has one element that is not itself an
5018  // initializer list, the implicit conversion sequence is the one
5019  // required to convert the element to the parameter type.
5020  unsigned NumInits = From->getNumInits();
5021  if (NumInits == 1 && !isa<InitListExpr>(From->getInit(0)))
5022  Result = TryCopyInitialization(S, From->getInit(0), ToType,
5023  SuppressUserConversions,
5024  InOverloadResolution,
5025  AllowObjCWritebackConversion);
5026  // - if the initializer list has no elements, the implicit conversion
5027  // sequence is the identity conversion.
5028  else if (NumInits == 0) {
5029  Result.setStandard();
5031  Result.Standard.setFromType(ToType);
5032  Result.Standard.setAllToTypes(ToType);
5033  }
5034  return Result;
5035  }
5036 
5037  // C++14 [over.ics.list]p8:
5038  // C++11 [over.ics.list]p7:
5039  // In all cases other than those enumerated above, no conversion is possible
5040  return Result;
5041 }
5042 
5043 /// TryCopyInitialization - Try to copy-initialize a value of type
5044 /// ToType from the expression From. Return the implicit conversion
5045 /// sequence required to pass this argument, which may be a bad
5046 /// conversion sequence (meaning that the argument cannot be passed to
5047 /// a parameter of this type). If @p SuppressUserConversions, then we
5048 /// do not permit any user-defined conversion sequences.
5051  bool SuppressUserConversions,
5052  bool InOverloadResolution,
5053  bool AllowObjCWritebackConversion,
5054  bool AllowExplicit) {
5055  if (InitListExpr *FromInitList = dyn_cast<InitListExpr>(From))
5056  return TryListConversion(S, FromInitList, ToType, SuppressUserConversions,
5057  InOverloadResolution,AllowObjCWritebackConversion);
5058 
5059  if (ToType->isReferenceType())
5060  return TryReferenceInit(S, From, ToType,
5061  /*FIXME:*/ From->getBeginLoc(),
5062  SuppressUserConversions, AllowExplicit);
5063 
5064  return TryImplicitConversion(S, From, ToType,
5065  SuppressUserConversions,
5066  /*AllowExplicit=*/false,
5067  InOverloadResolution,
5068  /*CStyle=*/false,
5069  AllowObjCWritebackConversion,
5070  /*AllowObjCConversionOnExplicit=*/false);
5071 }
5072 
5073 static bool TryCopyInitialization(const CanQualType FromQTy,
5074  const CanQualType ToQTy,
5075  Sema &S,
5076  SourceLocation Loc,
5077  ExprValueKind FromVK) {
5078  OpaqueValueExpr TmpExpr(Loc, FromQTy, FromVK);
5080  TryCopyInitialization(S, &TmpExpr, ToQTy, true, true, false);
5081 
5082  return !ICS.isBad();
5083 }
5084 
5085 /// TryObjectArgumentInitialization - Try to initialize the object
5086 /// parameter of the given member function (@c Method) from the
5087 /// expression @p From.
5090  Expr::Classification FromClassification,
5091  CXXMethodDecl *Method,
5092  CXXRecordDecl *ActingContext) {
5093  QualType ClassType = S.Context.getTypeDeclType(ActingContext);
5094  // [class.dtor]p2: A destructor can be invoked for a const, volatile or
5095  // const volatile object.
5096  Qualifiers Quals = Method->getMethodQualifiers();
5097  if (isa<CXXDestructorDecl>(Method)) {
5098  Quals.addConst();
5099  Quals.addVolatile();
5100  }
5101 
5102  QualType ImplicitParamType = S.Context.getQualifiedType(ClassType, Quals);
5103 
5104  // Set up the conversion sequence as a "bad" conversion, to allow us
5105  // to exit early.
5107 
5108  // We need to have an object of class type.
5109  if (const PointerType *PT = FromType->getAs<PointerType>()) {
5110  FromType = PT->getPointeeType();
5111 
5112  // When we had a pointer, it's implicitly dereferenced, so we
5113  // better have an lvalue.
5114  assert(FromClassification.isLValue());
5115  }
5116 
5117  assert(FromType->isRecordType());
5118 
5119  // C++0x [over.match.funcs]p4:
5120  // For non-static member functions, the type of the implicit object
5121  // parameter is
5122  //
5123  // - "lvalue reference to cv X" for functions declared without a
5124  // ref-qualifier or with the & ref-qualifier
5125  // - "rvalue reference to cv X" for functions declared with the &&
5126  // ref-qualifier
5127  //
5128  // where X is the class of which the function is a member and cv is the
5129  // cv-qualification on the member function declaration.
5130  //
5131  // However, when finding an implicit conversion sequence for the argument, we
5132  // are not allowed to perform user-defined conversions
5133  // (C++ [over.match.funcs]p5). We perform a simplified version of
5134  // reference binding here, that allows class rvalues to bind to
5135  // non-constant references.
5136 
5137  // First check the qualifiers.
5138  QualType FromTypeCanon = S.Context.getCanonicalType(FromType);
5139  if (ImplicitParamType.getCVRQualifiers()
5140  != FromTypeCanon.getLocalCVRQualifiers() &&
5141  !ImplicitParamType.isAtLeastAsQualifiedAs(FromTypeCanon)) {
5143  FromType, ImplicitParamType);
5144  return ICS;
5145  }
5146 
5147  if (FromTypeCanon.getQualifiers().hasAddressSpace()) {
5148  Qualifiers QualsImplicitParamType = ImplicitParamType.getQualifiers();
5149  Qualifiers QualsFromType = FromTypeCanon.getQualifiers();
5150  if (!QualsImplicitParamType.isAddressSpaceSupersetOf(QualsFromType)) {
5152  FromType, ImplicitParamType);
5153  return ICS;
5154  }
5155  }
5156 
5157  // Check that we have either the same type or a derived type. It
5158  // affects the conversion rank.
5159  QualType ClassTypeCanon = S.Context.getCanonicalType(ClassType);
5160  ImplicitConversionKind SecondKind;
5161  if (ClassTypeCanon == FromTypeCanon.getLocalUnqualifiedType()) {
5162  SecondKind = ICK_Identity;
5163  } else if (S.IsDerivedFrom(Loc, FromType, ClassType))
5164  SecondKind = ICK_Derived_To_Base;
5165  else {
5167  FromType, ImplicitParamType);
5168  return ICS;
5169  }
5170 
5171  // Check the ref-qualifier.
5172  switch (Method->getRefQualifier()) {
5173  case RQ_None:
5174  // Do nothing; we don't care about lvalueness or rvalueness.
5175  break;
5176 
5177  case RQ_LValue:
5178  if (!FromClassification.isLValue() && !Quals.hasOnlyConst()) {
5179  // non-const lvalue reference cannot bind to an rvalue
5181  ImplicitParamType);
5182  return ICS;
5183  }
5184  break;
5185 
5186  case RQ_RValue:
5187  if (!FromClassification.isRValue()) {
5188  // rvalue reference cannot bind to an lvalue
5190  ImplicitParamType);
5191  return ICS;
5192  }
5193  break;
5194  }
5195 
5196  // Success. Mark this as a reference binding.
5197  ICS.setStandard();
5199  ICS.Standard.Second = SecondKind;
5200  ICS.Standard.setFromType(FromType);
5201  ICS.Standard.setAllToTypes(ImplicitParamType);
5202  ICS.Standard.ReferenceBinding = true;
5203  ICS.Standard.DirectBinding = true;
5205  ICS.Standard.BindsToFunctionLvalue = false;
5206  ICS.Standard.BindsToRvalue = FromClassification.isRValue();
5208  = (Method->getRefQualifier() == RQ_None);
5209  return ICS;
5210 }
5211 
5212 /// PerformObjectArgumentInitialization - Perform initialization of
5213 /// the implicit object parameter for the given Method with the given
5214 /// expression.
5215 ExprResult
5217  NestedNameSpecifier *Qualifier,
5218  NamedDecl *FoundDecl,
5219  CXXMethodDecl *Method) {
5220  QualType FromRecordType, DestType;
5221  QualType ImplicitParamRecordType =
5222  Method->getThisType()->getAs<PointerType>()->getPointeeType();
5223 
5224  Expr::Classification FromClassification;
5225  if (const PointerType *PT = From->getType()->getAs<PointerType>()) {
5226  FromRecordType = PT->getPointeeType();
5227  DestType = Method->getThisType();
5228  FromClassification = Expr::Classification::makeSimpleLValue();
5229  } else {
5230  FromRecordType = From->getType();
5231  DestType = ImplicitParamRecordType;
5232  FromClassification = From->Classify(Context);
5233 
5234  // When performing member access on an rvalue, materialize a temporary.
5235  if (From->isRValue()) {
5236  From = CreateMaterializeTemporaryExpr(FromRecordType, From,
5237  Method->getRefQualifier() !=
5239  }
5240  }
5241 
5242  // Note that we always use the true parent context when performing
5243  // the actual argument initialization.
5245  *this, From->getBeginLoc(), From->getType(), FromClassification, Method,
5246  Method->getParent());
5247  if (ICS.isBad()) {
5248  switch (ICS.Bad.Kind) {
5250  Qualifiers FromQs = FromRecordType.getQualifiers();
5251  Qualifiers ToQs = DestType.getQualifiers();
5252  unsigned CVR = FromQs.getCVRQualifiers() & ~ToQs.getCVRQualifiers();
5253  if (CVR) {
5254  Diag(From->getBeginLoc(), diag::err_member_function_call_bad_cvr)
5255  << Method->getDeclName() << FromRecordType << (CVR - 1)
5256  << From->getSourceRange();
5257  Diag(Method->getLocation(), diag::note_previous_decl)
5258  << Method->getDeclName();
5259  return ExprError();
5260  }
5261  break;
5262  }
5263 
5266  bool IsRValueQualified =
5267  Method->getRefQualifier() == RefQualifierKind::RQ_RValue;
5268  Diag(From->getBeginLoc(), diag::err_member_function_call_bad_ref)
5269  << Method->getDeclName() << FromClassification.isRValue()
5270  << IsRValueQualified;
5271  Diag(Method->getLocation(), diag::note_previous_decl)
5272  << Method->getDeclName();
5273  return ExprError();
5274  }
5275 
5278  break;
5279  }
5280 
5281  return Diag(From->getBeginLoc(), diag::err_member_function_call_bad_type)
5282  << ImplicitParamRecordType << FromRecordType
5283  << From->getSourceRange();
5284  }
5285 
5286  if (ICS.Standard.Second == ICK_Derived_To_Base) {
5287  ExprResult FromRes =
5288  PerformObjectMemberConversion(From, Qualifier, FoundDecl, Method);
5289  if (FromRes.isInvalid())
5290  return ExprError();
5291  From = FromRes.get();
5292  }
5293 
5294  if (!Context.hasSameType(From->getType(), DestType)) {
5295  CastKind CK;
5296  if (FromRecordType.getAddressSpace() != DestType.getAddressSpace())
5297  CK = CK_AddressSpaceConversion;
5298  else
5299  CK = CK_NoOp;
5300  From = ImpCastExprToType(From, DestType, CK, From->getValueKind()).get();
5301  }
5302  return From;
5303 }
5304 
5305 /// TryContextuallyConvertToBool - Attempt to contextually convert the
5306 /// expression From to bool (C++0x [conv]p3).
5309  return TryImplicitConversion(S, From, S.Context.BoolTy,
5310  /*SuppressUserConversions=*/false,
5311  /*AllowExplicit=*/true,
5312  /*InOverloadResolution=*/false,
5313  /*CStyle=*/false,
5314  /*AllowObjCWritebackConversion=*/false,
5315  /*AllowObjCConversionOnExplicit=*/false);
5316 }
5317 
5318 /// PerformContextuallyConvertToBool - Perform a contextual conversion
5319 /// of the expression From to bool (C++0x [conv]p3).
5321  if (checkPlaceholderForOverload(*this, From))
5322  return ExprError();
5323 
5325  if (!ICS.isBad())
5326  return PerformImplicitConversion(From, Context.BoolTy, ICS, AA_Converting);
5327 
5328  if (!DiagnoseMultipleUserDefinedConversion(From, Context.BoolTy))
5329  return Diag(From->getBeginLoc(), diag::err_typecheck_bool_condition)
5330  << From->getType() << From->getSourceRange();
5331  return ExprError();
5332 }
5333 
5334 /// Check that the specified conversion is permitted in a converted constant
5335 /// expression, according to C++11 [expr.const]p3. Return true if the conversion
5336 /// is acceptable.
5339  // Since we know that the target type is an integral or unscoped enumeration
5340  // type, most conversion kinds are impossible. All possible First and Third
5341  // conversions are fine.
5342  switch (SCS.Second) {
5343  case ICK_Identity:
5346  case ICK_Integral_Conversion: // Narrowing conversions are checked elsewhere.
5348  return true;
5349 
5351  // Conversion from an integral or unscoped enumeration type to bool is
5352  // classified as ICK_Boolean_Conversion, but it's also arguably an integral
5353  // conversion, so we allow it in a converted constant expression.
5354  //
5355  // FIXME: Per core issue 1407, we should not allow this, but that breaks
5356  // a lot of popular code. We should at least add a warning for this
5357  // (non-conforming) extension.
5359  SCS.getToType(2)->isBooleanType();
5360 
5362  case ICK_Pointer_Member:
5363  // C++1z: null pointer conversions and null member pointer conversions are
5364  // only permitted if the source type is std::nullptr_t.
5365  return SCS.getFromType()->isNullPtrType();
5366 
5368  case ICK_Complex_Promotion:
5371  case ICK_Floating_Integral:
5373  case ICK_Derived_To_Base:
5374  case ICK_Vector_Conversion:
5375  case ICK_Vector_Splat:
5376  case ICK_Complex_Real:
5381  case ICK_C_Only_Conversion:
5383  return false;
5384 
5385  case ICK_Lvalue_To_Rvalue:
5386  case ICK_Array_To_Pointer:
5388  llvm_unreachable("found a first conversion kind in Second");
5389 
5390  case ICK_Qualification:
5391  llvm_unreachable("found a third conversion kind in Second");
5392 
5394  break;
5395  }
5396 
5397  llvm_unreachable("unknown conversion kind");
5398 }
5399 
5400 /// CheckConvertedConstantExpression - Check that the expression From is a
5401 /// converted constant expression of type T, perform the conversion and produce
5402 /// the converted expression, per C++11 [expr.const]p3.
5404  QualType T, APValue &Value,
5405  Sema::CCEKind CCE,
5406  bool RequireInt) {
5407  assert(S.getLangOpts().CPlusPlus11 &&
5408  "converted constant expression outside C++11");
5409 
5410  if (checkPlaceholderForOverload(S, From))
5411  return ExprError();
5412 
5413  // C++1z [expr.const]p3:
5414  // A converted constant expression of type T is an expression,
5415  // implicitly converted to type T, where the converted
5416  // expression is a constant expression and the implicit conversion
5417  // sequence contains only [... list of conversions ...].
5418  // C++1z [stmt.if]p2:
5419  // If the if statement is of the form if constexpr, the value of the
5420  // condition shall be a contextually converted constant expression of type
5421  // bool.
5424  ? TryContextuallyConvertToBool(S, From)
5425  : TryCopyInitialization(S, From, T,
5426  /*SuppressUserConversions=*/false,
5427  /*InOverloadResolution=*/false,
5428  /*AllowObjCWritebackConversion=*/false,
5429  /*AllowExplicit=*/false);
5430  StandardConversionSequence *SCS = nullptr;
5431  switch (ICS.getKind()) {
5433  SCS = &ICS.Standard;
5434  break;
5436  // We are converting to a non-class type, so the Before sequence
5437  // must be trivial.
5438  SCS = &ICS.UserDefined.After;
5439  break;
5442  if (!S.DiagnoseMultipleUserDefinedConversion(From, T))
5443  return S.Diag(From->getBeginLoc(),
5444  diag::err_typecheck_converted_constant_expression)
5445  << From->getType() << From->getSourceRange() << T;
5446  return ExprError();
5447 
5449  llvm_unreachable("ellipsis conversion in converted constant expression");
5450  }
5451 
5452  // Check that we would only use permitted conversions.
5453  if (!CheckConvertedConstantConversions(S, *SCS)) {
5454  return S.Diag(From->getBeginLoc(),
5455  diag::err_typecheck_converted_constant_expression_disallowed)
5456  << From->getType() << From->getSourceRange() << T;
5457  }
5458  // [...] and where the reference binding (if any) binds directly.
5459  if (SCS->ReferenceBinding && !SCS->DirectBinding) {
5460  return S.Diag(From->getBeginLoc(),
5461  diag::err_typecheck_converted_constant_expression_indirect)
5462  << From->getType() << From->getSourceRange() << T;
5463  }
5464 
5465  ExprResult Result =
5467  if (Result.isInvalid())
5468  return Result;
5469 
5470  // Check for a narrowing implicit conversion.
5471  APValue PreNarrowingValue;
5472  QualType PreNarrowingType;
5473  switch (SCS->getNarrowingKind(S.Context, Result.get(), PreNarrowingValue,
5474  PreNarrowingType)) {
5476  // Implicit conversion to a narrower type, but the expression is
5477  // value-dependent so we can't tell whether it's actually narrowing.
5478  case NK_Variable_Narrowing:
5479  // Implicit conversion to a narrower type, and the value is not a constant
5480  // expression. We'll diagnose this in a moment.
5481  case NK_Not_Narrowing:
5482  break;
5483 
5484  case NK_Constant_Narrowing:
5485  S.Diag(From->getBeginLoc(), diag::ext_cce_narrowing)
5486  << CCE << /*Constant*/ 1
5487  << PreNarrowingValue.getAsString(S.Context, PreNarrowingType) << T;
5488  break;
5489 
5490  case NK_Type_Narrowing:
5491  S.Diag(From->getBeginLoc(), diag::ext_cce_narrowing)
5492  << CCE << /*Constant*/ 0 << From->getType() << T;
5493  break;
5494  }
5495 
5496  if (Result.get()->isValueDependent()) {
5497  Value = APValue();
5498  return Result;
5499  }
5500 
5501  // Check the expression is a constant expression.
5503  Expr::EvalResult Eval;
5504  Eval.Diag = &Notes;
5508 
5509  if (!Result.get()->EvaluateAsConstantExpr(Eval, Usage, S.Context) ||
5510  (RequireInt && !Eval.Val.isInt())) {
5511  // The expression can't be folded, so we can't keep it at this position in
5512  // the AST.
5513  Result = ExprError();
5514  } else {
5515  Value = Eval.Val;
5516 
5517  if (Notes.empty()) {
5518  // It's a constant expression.
5519  return ConstantExpr::Create(S.Context, Result.get(), Value);
5520  }
5521  }
5522 
5523  // It's not a constant expression. Produce an appropriate diagnostic.
5524  if (Notes.size() == 1 &&
5525  Notes[0].second.getDiagID() == diag::note_invalid_subexpr_in_const_expr)
5526  S.Diag(Notes[0].first, diag::err_expr_not_cce) << CCE;
5527  else {
5528  S.Diag(From->getBeginLoc(), diag::err_expr_not_cce)
5529  << CCE << From->getSourceRange();
5530  for (unsigned I = 0; I < Notes.size(); ++I)
5531  S.Diag(Notes[I].first, Notes[I].second);
5532  }
5533  return ExprError();
5534 }
5535 
5537  APValue &Value, CCEKind CCE) {
5538  return ::CheckConvertedConstantExpression(*this, From, T, Value, CCE, false);
5539 }
5540 
5542  llvm::APSInt &Value,
5543  CCEKind CCE) {
5544  assert(T->isIntegralOrEnumerationType() && "unexpected converted const type");
5545 
5546  APValue V;
5547  auto R = ::CheckConvertedConstantExpression(*this, From, T, V, CCE, true);
5548  if (!R.isInvalid() && !R.get()->isValueDependent())
5549  Value = V.getInt();
5550  return R;
5551 }
5552 
5553 
5554 /// dropPointerConversions - If the given standard conversion sequence
5555 /// involves any pointer conversions, remove them. This may change
5556 /// the result type of the conversion sequence.
5558  if (SCS.Second == ICK_Pointer_Conversion) {
5559  SCS.Second = ICK_Identity;
5560  SCS.Third = ICK_Identity;
5561  SCS.ToTypePtrs[2] = SCS.ToTypePtrs[1] = SCS.ToTypePtrs[0];
5562  }
5563 }
5564 
5565 /// TryContextuallyConvertToObjCPointer - Attempt to contextually
5566 /// convert the expression From to an Objective-C pointer type.
5569  // Do an implicit conversion to 'id'.
5570  QualType Ty = S.Context.getObjCIdType();
5572  = TryImplicitConversion(S, From, Ty,
5573  // FIXME: Are these flags correct?
5574  /*SuppressUserConversions=*/false,
5575  /*AllowExplicit=*/true,
5576  /*InOverloadResolution=*/false,
5577  /*CStyle=*/false,
5578  /*AllowObjCWritebackConversion=*/false,
5579  /*AllowObjCConversionOnExplicit=*/true);
5580 
5581  // Strip off any final conversions to 'id'.
5582  switch (ICS.getKind()) {
5586  break;
5587 
5590  break;
5591 
5594  break;
5595  }
5596 
5597  return ICS;
5598 }
5599 
5600 /// PerformContextuallyConvertToObjCPointer - Perform a contextual
5601 /// conversion of the expression From to an Objective-C pointer type.
5602 /// Returns a valid but null ExprResult if no conversion sequence exists.
5604  if (checkPlaceholderForOverload(*this, From))
5605  return ExprError();
5606 
5607  QualType Ty = Context.getObjCIdType();
5610  if (!ICS.isBad())
5611  return PerformImplicitConversion(From, Ty, ICS, AA_Converting);
5612  return ExprResult();
5613 }
5614 
5615 /// Determine whether the provided type is an integral type, or an enumeration
5616 /// type of a permitted flavor.
5618  return AllowScopedEnumerations ? T->isIntegralOrEnumerationType()
5620 }
5621 
5622 static ExprResult
5625  QualType T, UnresolvedSetImpl &ViableConversions) {
5626 
5627  if (Converter.Suppress)
5628  return ExprError();
5629 
5630  Converter.diagnoseAmbiguous(SemaRef, Loc, T) << From->getSourceRange();
5631  for (unsigned I = 0, N = ViableConversions.size(); I != N; ++I) {
5632  CXXConversionDecl *Conv =
5633  cast<CXXConversionDecl>(ViableConversions[I]->getUnderlyingDecl());
5634  QualType ConvTy = Conv->getConversionType().getNonReferenceType();
5635  Converter.noteAmbiguous(SemaRef, Conv, ConvTy);
5636  }
5637  return From;
5638 }
5639 
5640 static bool
5643  QualType T, bool HadMultipleCandidates,
5644  UnresolvedSetImpl &ExplicitConversions) {
5645  if (ExplicitConversions.size() == 1 && !Converter.Suppress) {
5646  DeclAccessPair Found = ExplicitConversions[0];
5647  CXXConversionDecl *Conversion =
5648  cast<CXXConversionDecl>(Found->getUnderlyingDecl());
5649 
5650  // The user probably meant to invoke the given explicit
5651  // conversion; use it.
5652  QualType ConvTy = Conversion->getConversionType().getNonReferenceType();
5653  std::string TypeStr;
5654  ConvTy.getAsStringInternal(TypeStr, SemaRef.getPrintingPolicy());
5655 
5656  Converter.diagnoseExplicitConv(SemaRef, Loc, T, ConvTy)
5658  "static_cast<" + TypeStr + ">(")
5660  SemaRef.getLocForEndOfToken(From->getEndLoc()), ")");
5661  Converter.noteExplicitConv(SemaRef, Conversion, ConvTy);
5662 
5663  // If we aren't in a SFINAE context, build a call to the
5664  // explicit conversion function.
5665  if (SemaRef.isSFINAEContext())
5666  return true;
5667 
5668  SemaRef.CheckMemberOperatorAccess(From->getExprLoc(), From, nullptr, Found);
5669  ExprResult Result = SemaRef.BuildCXXMemberCallExpr(From, Found, Conversion,
5670  HadMultipleCandidates);
5671  if (Result.isInvalid())
5672  return true;
5673  // Record usage of conversion in an implicit cast.
5674  From = ImplicitCastExpr::Create(SemaRef.Context, Result.get()->getType(),
5675  CK_UserDefinedConversion, Result.get(),
5676  nullptr, Result.get()->getValueKind());
5677  }
5678  return false;
5679 }
5680 
5681 static bool recordConversion(Sema &SemaRef, SourceLocation Loc, Expr *&From,
5683  QualType T, bool HadMultipleCandidates,
5684  DeclAccessPair &Found) {
5685  CXXConversionDecl *Conversion =
5686  cast<CXXConversionDecl>(Found->getUnderlyingDecl());
5687  SemaRef.CheckMemberOperatorAccess(From->getExprLoc(), From, nullptr, Found);
5688 
5689  QualType ToType = Conversion->getConversionType().getNonReferenceType();
5690  if (!Converter.SuppressConversion) {
5691  if (SemaRef.isSFINAEContext())
5692  return true;
5693 
5694  Converter.diagnoseConversion(SemaRef, Loc, T, ToType)
5695  << From->getSourceRange();
5696  }
5697 
5698  ExprResult Result = SemaRef.BuildCXXMemberCallExpr(From, Found, Conversion,
5699  HadMultipleCandidates);
5700  if (Result.isInvalid())
5701  return true;
5702  // Record usage of conversion in an implicit cast.
5703  From = ImplicitCastExpr::Create(SemaRef.Context, Result.get()->getType(),
5704  CK_UserDefinedConversion, Result.get(),
5705  nullptr, Result.get()->getValueKind());
5706  return false;
5707 }
5708 
5710  Sema &SemaRef, SourceLocation Loc, Expr *From,
5711  Sema::ContextualImplicitConverter &Converter) {
5712  if (!Converter.match(From->getType()) && !Converter.Suppress)
5713  Converter.diagnoseNoMatch(SemaRef, Loc, From->getType())
5714  << From->getSourceRange();
5715 
5716  return SemaRef.DefaultLvalueConversion(From);
5717 }
5718 
5719 static void
5721  UnresolvedSetImpl &ViableConversions,
5722  OverloadCandidateSet &CandidateSet) {
5723  for (unsigned I = 0, N = ViableConversions.size(); I != N; ++I) {
5724  DeclAccessPair FoundDecl = ViableConversions[I];
5725  NamedDecl *D = FoundDecl.getDecl();
5726  CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext());
5727  if (isa<UsingShadowDecl>(D))
5728  D = cast<UsingShadowDecl>(D)->getTargetDecl();
5729 
5730  CXXConversionDecl *Conv;
5731  FunctionTemplateDecl *ConvTemplate;
5732  if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D)))
5733  Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
5734  else
5735  Conv = cast<CXXConversionDecl>(D);
5736 
5737  if (ConvTemplate)
5739  ConvTemplate, FoundDecl, ActingContext, From, ToType, CandidateSet,
5740  /*AllowObjCConversionOnExplicit=*/false, /*AllowExplicit*/ true);
5741  else
5742  SemaRef.AddConversionCandidate(Conv, FoundDecl, ActingContext, From,
5743  ToType, CandidateSet,
5744  /*AllowObjCConversionOnExplicit=*/false,
5745  /*AllowExplicit*/ true);
5746  }
5747 }
5748 
5749 /// Attempt to convert the given expression to a type which is accepted
5750 /// by the given converter.
5751 ///
5752 /// This routine will attempt to convert an expression of class type to a
5753 /// type accepted by the specified converter. In C++11 and before, the class
5754 /// must have a single non-explicit conversion function converting to a matching
5755 /// type. In C++1y, there can be multiple such conversion functions, but only
5756 /// one target type.
5757 ///
5758 /// \param Loc The source location of the construct that requires the
5759 /// conversion.
5760 ///
5761 /// \param From The expression we're converting from.
5762 ///
5763 /// \param Converter Used to control and diagnose the conversion process.
5764 ///
5765 /// \returns The expression, converted to an integral or enumeration type if
5766 /// successful.
5768  SourceLocation Loc, Expr *From, ContextualImplicitConverter &Converter) {
5769  // We can't perform any more checking for type-dependent expressions.
5770  if (From->isTypeDependent())
5771  return From;
5772 
5773  // Process placeholders immediately.
5774  if (From->hasPlaceholderType()) {
5775  ExprResult result = CheckPlaceholderExpr(From);
5776  if (result.isInvalid())
5777  return result;
5778  From = result.get();
5779  }
5780 
5781  // If the expression already has a matching type, we're golden.
5782  QualType T = From->getType();
5783  if (Converter.match(T))
5784  return DefaultLvalueConversion(From);
5785 
5786  // FIXME: Check for missing '()' if T is a function type?
5787 
5788  // We can only perform contextual implicit conversions on objects of class
5789  // type.
5790  const RecordType *RecordTy = T->getAs<RecordType>();
5791  if (!RecordTy || !getLangOpts().CPlusPlus) {
5792  if (!Converter.Suppress)
5793  Converter.diagnoseNoMatch(*this, Loc, T) << From->getSourceRange();
5794  return From;
5795  }
5796 
5797  // We must have a complete class type.
5798  struct TypeDiagnoserPartialDiag : TypeDiagnoser {
5799  ContextualImplicitConverter &Converter;
5800  Expr *From;
5801 
5802  TypeDiagnoserPartialDiag(ContextualImplicitConverter &Converter, Expr *From)
5803  : Converter(Converter), From(From) {}
5804 
5805  void diagnose(Sema &S, SourceLocation Loc, QualType T) override {
5806  Converter.diagnoseIncomplete(S, Loc, T) << From->getSourceRange();
5807  }
5808  } IncompleteDiagnoser(Converter, From);
5809 
5810  if (Converter.Suppress ? !isCompleteType(Loc, T)
5811  : RequireCompleteType(Loc, T, IncompleteDiagnoser))
5812  return From;
5813 
5814  // Look for a conversion to an integral or enumeration type.
5816  ViableConversions; // These are *potentially* viable in C++1y.
5817  UnresolvedSet<4> ExplicitConversions;
5818  const auto &Conversions =
5819  cast<CXXRecordDecl>(RecordTy->getDecl())->getVisibleConversionFunctions();
5820 
5821  bool HadMultipleCandidates =
5822  (std::distance(Conversions.begin(), Conversions.end()) > 1);
5823 
5824  // To check that there is only one target type, in C++1y:
5825  QualType ToType;
5826  bool HasUniqueTargetType = true;
5827 
5828  // Collect explicit or viable (potentially in C++1y) conversions.
5829  for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
5830  NamedDecl *D = (*I)->getUnderlyingDecl();
5831  CXXConversionDecl *Conversion;
5832  FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
5833  if (ConvTemplate) {
5834  if (getLangOpts().CPlusPlus14)
5835  Conversion = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
5836  else
5837  continue; // C++11 does not consider conversion operator templates(?).
5838  } else
5839  Conversion = cast<CXXConversionDecl>(D);
5840 
5841  assert((!ConvTemplate || getLangOpts().CPlusPlus14) &&
5842  "Conversion operator templates are considered potentially "
5843  "viable in C++1y");
5844 
5845  QualType CurToType = Conversion->getConversionType().getNonReferenceType();
5846  if (Converter.match(CurToType) || ConvTemplate) {
5847 
5848  if (Conversion->isExplicit()) {
5849  // FIXME: For C++1y, do we need this restriction?
5850  // cf. diagnoseNoViableConversion()
5851  if (!ConvTemplate)
5852  ExplicitConversions.addDecl(I.getDecl(), I.getAccess());
5853  } else {
5854  if (!ConvTemplate && getLangOpts().CPlusPlus14) {
5855  if (ToType.isNull())
5856  ToType = CurToType.getUnqualifiedType();
5857  else if (HasUniqueTargetType &&
5858  (CurToType.getUnqualifiedType() != ToType))
5859  HasUniqueTargetType = false;
5860  }
5861  ViableConversions.addDecl(I.getDecl(), I.getAccess());
5862  }
5863  }
5864  }
5865 
5866  if (getLangOpts().CPlusPlus14) {
5867  // C++1y [conv]p6:
5868  // ... An expression e of class type E appearing in such a context
5869  // is said to be contextually implicitly converted to a specified
5870  // type T and is well-formed if and only if e can be implicitly
5871  // converted to a type T that is determined as follows: E is searched
5872  // for conversion functions whose return type is cv T or reference to
5873  // cv T such that T is allowed by the context. There shall be
5874  // exactly one such T.
5875 
5876  // If no unique T is found:
5877  if (ToType.isNull()) {
5878  if (diagnoseNoViableConversion(*this, Loc, From, Converter, T,
5879  HadMultipleCandidates,
5880  ExplicitConversions))
5881  return ExprError();
5882  return finishContextualImplicitConversion(*this, Loc, From, Converter);
5883  }
5884 
5885  // If more than one unique Ts are found:
5886  if (!HasUniqueTargetType)
5887  return diagnoseAmbiguousConversion(*this, Loc, From, Converter, T,
5888  ViableConversions);
5889 
5890  // If one unique T is found:
5891  // First, build a candidate set from the previously recorded
5892  // potentially viable conversions.
5894  collectViableConversionCandidates(*this, From, ToType, ViableConversions,
5895  CandidateSet);
5896 
5897  // Then, perform overload resolution over the candidate set.
5899  switch (CandidateSet.BestViableFunction(*this, Loc, Best)) {
5900  case OR_Success: {
5901  // Apply this conversion.
5902  DeclAccessPair Found =
5903  DeclAccessPair::make(Best->Function, Best->FoundDecl.getAccess());
5904  if (recordConversion(*this, Loc, From, Converter, T,
5905  HadMultipleCandidates, Found))
5906  return ExprError();
5907  break;
5908  }
5909  case OR_Ambiguous:
5910  return diagnoseAmbiguousConversion(*this, Loc, From, Converter, T,
5911  ViableConversions);
5912  case OR_No_Viable_Function:
5913  if (diagnoseNoViableConversion(*this, Loc, From, Converter, T,
5914  HadMultipleCandidates,
5915  ExplicitConversions))
5916  return ExprError();
5917  LLVM_FALLTHROUGH;
5918  case OR_Deleted:
5919  // We'll complain below about a non-integral condition type.
5920  break;
5921  }
5922  } else {
5923  switch (ViableConversions.size()) {
5924  case 0: {
5925  if (diagnoseNoViableConversion(*this, Loc, From, Converter, T,
5926  HadMultipleCandidates,
5927  ExplicitConversions))
5928  return ExprError();
5929 
5930  // We'll complain below about a non-integral condition type.
5931  break;
5932  }
5933  case 1: {
5934  // Apply this conversion.
5935  DeclAccessPair Found = ViableConversions[0];
5936  if (recordConversion(*this, Loc, From, Converter, T,
5937  HadMultipleCandidates, Found))
5938  return ExprError();
5939  break;
5940  }
5941  default:
5942  return diagnoseAmbiguousConversion(*this, Loc, From, Converter, T,
5943  ViableConversions);
5944  }
5945  }
5946 
5947  return finishContextualImplicitConversion(*this, Loc, From, Converter);
5948 }
5949 
5950 /// IsAcceptableNonMemberOperatorCandidate - Determine whether Fn is
5951 /// an acceptable non-member overloaded operator for a call whose
5952 /// arguments have types T1 (and, if non-empty, T2). This routine
5953 /// implements the check in C++ [over.match.oper]p3b2 concerning
5954 /// enumeration types.
5956  FunctionDecl *Fn,
5957  ArrayRef<Expr *> Args) {
5958  QualType T1 = Args[0]->getType();
5959  QualType T2 = Args.size() > 1 ? Args[1]->getType() : QualType();
5960 
5961  if (T1->isDependentType() || (!T2.isNull() && T2->isDependentType()))
5962  return true;
5963 
5964  if (T1->isRecordType() || (!T2.isNull() && T2->isRecordType()))
5965  return true;
5966 
5967  const FunctionProtoType *Proto = Fn->getType()->getAs<FunctionProtoType>();
5968  if (Proto->getNumParams() < 1)
5969  return false;
5970 
5971  if (T1->isEnumeralType()) {
5972  QualType ArgType = Proto->getParamType(0).getNonReferenceType();
5973  if (Context.hasSameUnqualifiedType(T1, ArgType))
5974  return true;
5975  }
5976 
5977  if (Proto->getNumParams() < 2)
5978  return false;
5979 
5980  if (!T2.isNull() && T2->isEnumeralType()) {
5981  QualType ArgType = Proto->getParamType(1).getNonReferenceType();
5982  if (Context.hasSameUnqualifiedType(T2, ArgType))
5983  return true;
5984  }
5985 
5986  return false;
5987 }
5988 
5989 /// AddOverloadCandidate - Adds the given function to the set of
5990 /// candidate functions, using the given function call arguments. If
5991 /// @p SuppressUserConversions, then don't allow user-defined
5992 /// conversions via constructors or conversion operators.
5993 ///
5994 /// \param PartialOverloading true if we are performing "partial" overloading
5995 /// based on an incomplete set of function arguments. This feature is used by
5996 /// code completion.
5998  FunctionDecl *Function, DeclAccessPair FoundDecl, ArrayRef<Expr *> Args,
5999  OverloadCandidateSet &CandidateSet, bool SuppressUserConversions,
6000  bool PartialOverloading, bool AllowExplicit, bool AllowExplicitConversions,
6001  ADLCallKind IsADLCandidate, ConversionSequenceList EarlyConversions) {
6002  const FunctionProtoType *Proto
6003  = dyn_cast<FunctionProtoType>(Function->getType()->getAs<FunctionType>());
6004  assert(Proto && "Functions without a prototype cannot be overloaded");
6005  assert(!Function->getDescribedFunctionTemplate() &&
6006  "Use AddTemplateOverloadCandidate for function templates");
6007 
6008  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Function)) {
6009  if (!isa<CXXConstructorDecl>(Method)) {
6010  // If we get here, it's because we're calling a member function
6011  // that is named without a member access expression (e.g.,
6012  // "this->f") that was either written explicitly or created
6013  // implicitly. This can happen with a qualified call to a member
6014  // function, e.g., X::f(). We use an empty type for the implied
6015  // object argument (C++ [over.call.func]p3), and the acting context
6016  // is irrelevant.
6017  AddMethodCandidate(Method, FoundDecl, Method->getParent(), QualType(),
6019  CandidateSet, SuppressUserConversions,
6020  PartialOverloading, EarlyConversions);
6021  return;
6022  }
6023  // We treat a constructor like a non-member function, since its object
6024  // argument doesn't participate in overload resolution.
6025  }
6026 
6027  if (!CandidateSet.isNewCandidate(Function))
6028  return;
6029 
6030  // C++ [over.match.oper]p3:
6031  // if no operand has a class type, only those non-member functions in the
6032  // lookup set that have a first parameter of type T1 or "reference to
6033  // (possibly cv-qualified) T1", when T1 is an enumeration type, or (if there
6034  // is a right operand) a second parameter of type T2 or "reference to
6035  // (possibly cv-qualified) T2", when T2 is an enumeration type, are
6036  // candidate functions.
6037  if (CandidateSet.getKind() == OverloadCandidateSet::CSK_Operator &&
6038  !IsAcceptableNonMemberOperatorCandidate(Context, Function, Args))
6039  return;
6040 
6041  // C++11 [class.copy]p11: [DR1402]
6042  // A defaulted move constructor that is defined as deleted is ignored by
6043  // overload resolution.
6044  CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Function);
6045  if (Constructor && Constructor->isDefaulted() && Constructor->isDeleted() &&
6046  Constructor->isMoveConstructor())
6047  return;
6048 
6049  // Overload resolution is always an unevaluated context.
6052 
6053  // Add this candidate
6054  OverloadCandidate &Candidate =
6055  CandidateSet.addCandidate(Args.size(), EarlyConversions);
6056  Candidate.FoundDecl = FoundDecl;
6057  Candidate.Function = Function;
6058  Candidate.Viable = true;
6059  Candidate.IsSurrogate = false;
6060  Candidate.IsADLCandidate = IsADLCandidate;
6061  Candidate.IgnoreObjectArgument = false;
6062  Candidate.ExplicitCallArguments = Args.size();
6063 
6064  if (Function->isMultiVersion() && Function->hasAttr<TargetAttr>() &&
6065  !Function->getAttr<TargetAttr>()->isDefaultVersion()) {
6066  Candidate.Viable = false;
6068  return;
6069  }
6070 
6071  if (Constructor) {
6072  // C++ [class.copy]p3:
6073  // A member function template is never instantiated to perform the copy
6074  // of a class object to an object of its class type.
6075  QualType ClassType = Context.getTypeDeclType(Constructor->getParent());
6076  if (Args.size() == 1 && Constructor->isSpecializationCopyingObject() &&
6077  (Context.hasSameUnqualifiedType(ClassType, Args[0]->getType()) ||
6078  IsDerivedFrom(Args[0]->getBeginLoc(), Args[0]->getType(),
6079  ClassType))) {
6080  Candidate.Viable = false;
6082  return;
6083  }
6084 
6085  // C++ [over.match.funcs]p8: (proposed DR resolution)
6086  // A constructor inherited from class type C that has a first parameter
6087  // of type "reference to P" (including such a constructor instantiated
6088  // from a template) is excluded from the set of candidate functions when
6089  // constructing an object of type cv D if the argument list has exactly
6090  // one argument and D is reference-related to P and P is reference-related
6091  // to C.
6092  auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(FoundDecl.getDecl());
6093  if (Shadow && Args.size() == 1 && Constructor->getNumParams() >= 1 &&
6094  Constructor->getParamDecl(0)->getType()->isReferenceType()) {
6095  QualType P = Constructor->getParamDecl(0)->getType()->getPointeeType();
6096  QualType C = Context.getRecordType(Constructor->getParent());
6097  QualType D = Context.getRecordType(Shadow->getParent());
6098  SourceLocation Loc = Args.front()->getExprLoc();
6099  if ((Context.hasSameUnqualifiedType(P, C) || IsDerivedFrom(Loc, P, C)) &&
6100  (Context.hasSameUnqualifiedType(D, P) || IsDerivedFrom(Loc, D, P))) {
6101  Candidate.Viable = false;
6102  Candidate.FailureKind = ovl_fail_inhctor_slice;
6103  return;
6104  }
6105  }
6106 
6107  // Check that the constructor is capable of constructing an object in the
6108  // destination address space.
6110  Constructor->getMethodQualifiers().getAddressSpace(),
6111  CandidateSet.getDestAS())) {
6112  Candidate.Viable = false;
6114  }
6115  }
6116 
6117  unsigned NumParams = Proto->getNumParams();
6118 
6119  // (C++ 13.3.2p2): A candidate function having fewer than m
6120  // parameters is viable only if it has an ellipsis in its parameter
6121  // list (8.3.5).
6122  if (TooManyArguments(NumParams, Args.size(), PartialOverloading) &&
6123  !Proto->isVariadic()) {
6124  Candidate.Viable = false;
6126  return;
6127  }
6128 
6129  // (C++ 13.3.2p2): A candidate function having more than m parameters
6130  // is viable only if the (m+1)st parameter has a default argument
6131  // (8.3.6). For the purposes of overload resolution, the
6132  // parameter list is truncated on the right, so that there are
6133  // exactly m parameters.
6134  unsigned MinRequiredArgs = Function->getMinRequiredArguments();
6135  if (Args.size() < MinRequiredArgs && !PartialOverloading) {
6136  // Not enough arguments.
6137  Candidate.Viable = false;
6139  return;
6140  }
6141 
6142  // (CUDA B.1): Check for invalid calls between targets.
6143  if (getLangOpts().CUDA)
6144  if (const FunctionDecl *Caller = dyn_cast<FunctionDecl>(CurContext))
6145  // Skip the check for callers that are implicit members, because in this
6146  // case we may not yet know what the member's target is; the target is
6147  // inferred for the member automatically, based on the bases and fields of
6148  // the class.
6149  if (!Caller->isImplicit() && !IsAllowedCUDACall(Caller, Function)) {
6150  Candidate.Viable = false;
6151  Candidate.FailureKind = ovl_fail_bad_target;
6152  return;
6153  }
6154 
6155  // Determine the implicit conversion sequences for each of the
6156  // arguments.
6157  for (unsigned ArgIdx = 0; ArgIdx < Args.size(); ++ArgIdx) {
6158  if (Candidate.Conversions[ArgIdx].isInitialized()) {
6159  // We already formed a conversion sequence for this parameter during
6160  // template argument deduction.
6161  } else if (ArgIdx < NumParams) {
6162  // (C++ 13.3.2p3): for F to be a viable function, there shall
6163  // exist for each argument an implicit conversion sequence
6164  // (13.3.3.1) that converts that argument to the corresponding
6165  // parameter of F.
6166  QualType ParamType = Proto->getParamType(ArgIdx);
6167  Candidate.Conversions[ArgIdx] = TryCopyInitialization(
6168  *this, Args[ArgIdx], ParamType, SuppressUserConversions,
6169  /*InOverloadResolution=*/true,
6170  /*AllowObjCWritebackConversion=*/
6171  getLangOpts().ObjCAutoRefCount, AllowExplicitConversions);
6172  if (Candidate.Conversions[ArgIdx].isBad()) {
6173  Candidate.Viable = false;
6175  return;
6176  }
6177  } else {
6178  // (C++ 13.3.2p2): For the purposes of overload resolution, any
6179  // argument for which there is no corresponding parameter is
6180  // considered to ""match the ellipsis" (C+ 13.3.3.1.3).
6181  Candidate.Conversions[ArgIdx].setEllipsis();
6182  }
6183  }
6184 
6185  if (!AllowExplicit) {
6188  Candidate.Viable = false;
6190  return;
6191  }
6192  }
6193 
6194  if (EnableIfAttr *FailedAttr = CheckEnableIf(Function, Args)) {
6195  Candidate.Viable = false;
6196  Candidate.FailureKind = ovl_fail_enable_if;
6197  Candidate.DeductionFailure.Data = FailedAttr;
6198  return;
6199  }
6200 
6201  if (LangOpts.OpenCL && isOpenCLDisabledDecl(Function)) {
6202  Candidate.Viable = false;
6203  Candidate.FailureKind = ovl_fail_ext_disabled;
6204  return;
6205  }
6206 }
6207 
6209 Sema::SelectBestMethod(Selector Sel, MultiExprArg Args, bool IsInstance,
6211  if (Methods.size() <= 1)
6212  return nullptr;
6213 
6214  for (unsigned b = 0, e = Methods.size(); b < e; b++) {
6215  bool Match = true;
6216  ObjCMethodDecl *Method = Methods[b];
6217  unsigned NumNamedArgs = Sel.getNumArgs();
6218  // Method might have more arguments than selector indicates. This is due
6219  // to addition of c-style arguments in method.
6220  if (Method->param_size() > NumNamedArgs)
6221  NumNamedArgs = Method->param_size();
6222  if (Args.size() < NumNamedArgs)
6223  continue;
6224 
6225  for (unsigned i = 0; i < NumNamedArgs; i++) {
6226  // We can't do any type-checking on a type-dependent argument.
6227  if (Args[i]->isTypeDependent()) {
6228  Match = false;
6229  break;
6230  }
6231 
6232  ParmVarDecl *param = Method->parameters()[i];
6233  Expr *argExpr = Args[i];
6234  assert(argExpr && "SelectBestMethod(): missing expression");
6235 
6236  // Strip the unbridged-cast placeholder expression off unless it's
6237  // a consumed argument.
6238  if (argExpr->hasPlaceholderType(BuiltinType::ARCUnbridgedCast) &&
6239  !param->hasAttr<CFConsumedAttr>())
6240  argExpr = stripARCUnbridgedCast(argExpr);
6241 
6242  // If the parameter is __unknown_anytype, move on to the next method.
6243  if (param->getType() == Context.UnknownAnyTy) {
6244  Match = false;
6245  break;
6246  }
6247 
6248  ImplicitConversionSequence ConversionState
6249  = TryCopyInitialization(*this, argExpr, param->getType(),
6250  /*SuppressUserConversions*/false,
6251  /*InOverloadResolution=*/true,
6252  /*AllowObjCWritebackConversion=*/
6253  getLangOpts().ObjCAutoRefCount,
6254  /*AllowExplicit*/false);
6255  // This function looks for a reasonably-exact match, so we consider
6256  // incompatible pointer conversions to be a failure here.
6257  if (ConversionState.isBad() ||
6258  (ConversionState.isStandard() &&
6259  ConversionState.Standard.Second ==
6261  Match = false;
6262  break;
6263  }
6264  }
6265  // Promote additional arguments to variadic methods.
6266  if (Match && Method->isVariadic()) {
6267  for (unsigned i = NumNamedArgs, e = Args.size(); i < e; ++i) {
6268  if (Args[i]->isTypeDependent()) {
6269  Match = false;
6270  break;
6271  }
6272  ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], VariadicMethod,
6273  nullptr);
6274  if (Arg.isInvalid()) {
6275  Match = false;
6276  break;
6277  }
6278  }
6279  } else {
6280  // Check for extra arguments to non-variadic methods.
6281  if (Args.size() != NumNamedArgs)
6282  Match = false;
6283  else if (Match && NumNamedArgs == 0 && Methods.size() > 1) {
6284  // Special case when selectors have no argument. In this case, select
6285  // one with the most general result type of 'id'.
6286  for (unsigned b = 0, e = Methods.size(); b < e; b++) {
6287  QualType ReturnT = Methods[b]->getReturnType();
6288  if (ReturnT->isObjCIdType())
6289  return Methods[b];
6290  }
6291  }
6292  }
6293 
6294  if (Match)
6295  return Method;
6296  }
6297  return nullptr;
6298 }
6299 
6300 static bool
6302  ArrayRef<Expr *> Args, Sema::SFINAETrap &Trap,
6303  bool MissingImplicitThis, Expr *&ConvertedThis,
6304  SmallVectorImpl<Expr *> &ConvertedArgs) {
6305  if (ThisArg) {
6306  CXXMethodDecl *Method = cast<CXXMethodDecl>(Function);
6307  assert(!isa<CXXConstructorDecl>(Method) &&
6308  "Shouldn't have `this` for ctors!");
6309  assert(!Method->isStatic() && "Shouldn't have `this` for static methods!");
6311  ThisArg, /*Qualifier=*/nullptr, Method, Method);
6312  if (R.isInvalid())
6313  return false;
6314  ConvertedThis = R.get();
6315  } else {
6316  if (auto *MD = dyn_cast<CXXMethodDecl>(Function)) {
6317  (void)MD;
6318  assert((MissingImplicitThis || MD->isStatic() ||
6319  isa<CXXConstructorDecl>(MD)) &&
6320  "Expected `this` for non-ctor instance methods");
6321  }
6322  ConvertedThis = nullptr;
6323  }
6324 
6325  // Ignore any variadic arguments. Converting them is pointless, since the
6326  // user can't refer to them in the function condition.
6327  unsigned ArgSizeNoVarargs = std::min(Function->param_size(), Args.size());
6328 
6329  // Convert the arguments.
6330  for (unsigned I = 0; I != ArgSizeNoVarargs; ++I) {
6331  ExprResult R;
6333  S.Context, Function->getParamDecl(I)),
6334  SourceLocation(), Args[I]);
6335 
6336  if (R.isInvalid())
6337  return false;
6338 
6339  ConvertedArgs.push_back(R.get());
6340  }
6341 
6342  if (Trap.hasErrorOccurred())
6343  return false;
6344 
6345  // Push default arguments if needed.
6346  if (!Function->isVariadic() && Args.size() < Function->getNumParams()) {
6347  for (unsigned i = Args.size(), e = Function->getNumParams(); i != e; ++i) {
6348  ParmVarDecl *P = Function->getParamDecl(i);
6349  Expr *DefArg = P->hasUninstantiatedDefaultArg()
6351  : P->getDefaultArg();
6352  // This can only happen in code completion, i.e. when PartialOverloading
6353  // is true.
6354  if (!DefArg)
6355  return false;
6356  ExprResult R =
6358  S.Context, Function->getParamDecl(i)),
6359  SourceLocation(), DefArg);
6360  if (R.isInvalid())
6361  return false;
6362  ConvertedArgs.push_back(R.get());
6363  }
6364 
6365  if (Trap.hasErrorOccurred())
6366  return false;
6367  }
6368  return true;
6369 }
6370 
6371 EnableIfAttr *Sema::CheckEnableIf(FunctionDecl *Function, ArrayRef<Expr *> Args,
6372  bool MissingImplicitThis) {
6373  auto EnableIfAttrs = Function->specific_attrs<EnableIfAttr>();
6374  if (EnableIfAttrs.begin() == EnableIfAttrs.end())
6375  return nullptr;
6376 
6377  SFINAETrap Trap(*this);
6378  SmallVector<Expr *, 16> ConvertedArgs;
6379  // FIXME: We should look into making enable_if late-parsed.
6380  Expr *DiscardedThis;
6382  *this, Function, /*ThisArg=*/nullptr, Args, Trap,
6383  /*MissingImplicitThis=*/true, DiscardedThis, ConvertedArgs))
6384  return *EnableIfAttrs.begin();
6385 
6386  for (auto *EIA : EnableIfAttrs) {
6387  APValue Result;
6388  // FIXME: This doesn't consider value-dependent cases, because doing so is
6389  // very difficult. Ideally, we should handle them more gracefully.
6390  if (EIA->getCond()->isValueDependent() ||
6391  !EIA->getCond()->EvaluateWithSubstitution(
6392  Result, Context, Function, llvm::makeArrayRef(ConvertedArgs)))
6393  return EIA;
6394 
6395  if (!Result.isInt() || !Result.getInt().getBoolValue())
6396  return EIA;
6397  }
6398  return nullptr;
6399 }
6400 
6401 template <typename CheckFn>
6402 static bool diagnoseDiagnoseIfAttrsWith(Sema &S, const NamedDecl *ND,
6403  bool ArgDependent, SourceLocation Loc,
6404  CheckFn &&IsSuccessful) {
6406  for (const auto *DIA : ND->specific_attrs<DiagnoseIfAttr>()) {
6407  if (ArgDependent == DIA->getArgDependent())
6408  Attrs.push_back(DIA);
6409  }
6410 
6411  // Common case: No diagnose_if attributes, so we can quit early.
6412  if (Attrs.empty())
6413  return false;
6414 
6415  auto WarningBegin = std::stable_partition(
6416  Attrs.begin(), Attrs.end(),
6417  [](const DiagnoseIfAttr *DIA) { return DIA->isError(); });
6418 
6419  // Note that diagnose_if attributes are late-parsed, so they appear in the
6420  // correct order (unlike enable_if attributes).
6421  auto ErrAttr = llvm::find_if(llvm::make_range(Attrs.begin(), WarningBegin),
6422  IsSuccessful);
6423  if (ErrAttr != WarningBegin) {
6424  const DiagnoseIfAttr *DIA = *ErrAttr;
6425  S.Diag(Loc, diag::err_diagnose_if_succeeded) << DIA->getMessage();
6426  S.Diag(DIA->getLocation(), diag::note_from_diagnose_if)
6427  << DIA->getParent() << DIA->getCond()->getSourceRange();
6428  return true;
6429  }
6430 
6431  for (const auto *DIA : llvm::make_range(WarningBegin, Attrs.end()))
6432  if (IsSuccessful(DIA)) {
6433  S.Diag(Loc, diag::warn_diagnose_if_succeeded) << DIA->getMessage();
6434  S.Diag(DIA->getLocation(), diag::note_from_diagnose_if)
6435  << DIA->getParent() << DIA->getCond()->getSourceRange();
6436  }
6437 
6438  return false;
6439 }
6440 
6442  const Expr *ThisArg,
6444  SourceLocation Loc) {
6446  *this, Function, /*ArgDependent=*/true, Loc,
6447  [&](const DiagnoseIfAttr *DIA) {
6448  APValue Result;
6449  // It's sane to use the same Args for any redecl of this function, since
6450  // EvaluateWithSubstitution only cares about the position of each
6451  // argument in the arg list, not the ParmVarDecl* it maps to.
6452  if (!DIA->getCond()->EvaluateWithSubstitution(
6453  Result, Context, cast<FunctionDecl>(DIA->getParent()), Args, ThisArg))
6454  return false;
6455  return Result.isInt() && Result.getInt().getBoolValue();
6456  });
6457 }
6458 
6460  SourceLocation Loc) {
6462  *this, ND, /*ArgDependent=*/false, Loc,
6463  [&](const DiagnoseIfAttr *DIA) {
6464  bool Result;
6465  return DIA->getCond()->EvaluateAsBooleanCondition(Result, Context) &&
6466  Result;
6467  });
6468 }
6469 
6470 /// Add all of the function declarations in the given function set to
6471 /// the overload candidate set.
6473  ArrayRef<Expr *> Args,
6474  OverloadCandidateSet &CandidateSet,
6475  TemplateArgumentListInfo *ExplicitTemplateArgs,
6476  bool SuppressUserConversions,
6477  bool PartialOverloading,
6478  bool FirstArgumentIsBase) {
6479  for (UnresolvedSetIterator F = Fns.begin(), E = Fns.end(); F != E; ++F) {
6480  NamedDecl *D = F.getDecl()->getUnderlyingDecl();
6481  ArrayRef<Expr *> FunctionArgs = Args;
6482 
6483  FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D);
6484  FunctionDecl *FD =
6485  FunTmpl ? FunTmpl->getTemplatedDecl() : cast<FunctionDecl>(D);
6486 
6487  if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic()) {
6488  QualType ObjectType;
6489  Expr::Classification ObjectClassification;
6490  if (Args.size() > 0) {
6491  if (Expr *E = Args[0]) {
6492  // Use the explicit base to restrict the lookup:
6493  ObjectType = E->getType();
6494  // Pointers in the object arguments are implicitly dereferenced, so we
6495  // always classify them as l-values.
6496  if (!ObjectType.isNull() && ObjectType->isPointerType())
6497  ObjectClassification = Expr::Classification::makeSimpleLValue();
6498  else
6499  ObjectClassification = E->Classify(Context);
6500  } // .. else there is an implicit base.
6501  FunctionArgs = Args.slice(1);
6502  }
6503  if (FunTmpl) {
6504  AddMethodTemplateCandidate(
6505  FunTmpl, F.getPair(),
6506  cast<CXXRecordDecl>(FunTmpl->getDeclContext()),
6507  ExplicitTemplateArgs, ObjectType, ObjectClassification,
6508  FunctionArgs, CandidateSet, SuppressUserConversions,
6509  PartialOverloading);
6510  } else {
6511  AddMethodCandidate(cast<CXXMethodDecl>(FD), F.getPair(),
6512  cast<CXXMethodDecl>(FD)->getParent(), ObjectType,
6513  ObjectClassification, FunctionArgs, CandidateSet,
6514  SuppressUserConversions, PartialOverloading);
6515  }
6516  } else {
6517  // This branch handles both standalone functions and static methods.
6518 
6519  // Slice the first argument (which is the base) when we access
6520  // static method as non-static.
6521  if (Args.size() > 0 &&
6522  (!Args[0] || (FirstArgumentIsBase && isa<CXXMethodDecl>(FD) &&
6523  !isa<CXXConstructorDecl>(FD)))) {
6524  assert(cast<CXXMethodDecl>(FD)->isStatic());
6525  FunctionArgs = Args.slice(1);
6526  }
6527  if (FunTmpl) {
6528  AddTemplateOverloadCandidate(
6529  FunTmpl, F.getPair(), ExplicitTemplateArgs, FunctionArgs,
6530  CandidateSet, SuppressUserConversions, PartialOverloading);
6531  } else {
6532  AddOverloadCandidate(FD, F.getPair(), FunctionArgs, CandidateSet,
6533  SuppressUserConversions, PartialOverloading);
6534  }
6535  }
6536  }
6537 }
6538 
6539 /// AddMethodCandidate - Adds a named decl (which is some kind of
6540 /// method) as a method candidate to the given overload set.
6542  QualType ObjectType,
6543  Expr::Classification ObjectClassification,
6544  ArrayRef<Expr *> Args,
6545  OverloadCandidateSet& CandidateSet,
6546  bool SuppressUserConversions) {
6547  NamedDecl *Decl = FoundDecl.getDecl();
6548  CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(Decl->getDeclContext());
6549 
6550  if (isa<UsingShadowDecl>(Decl))
6551  Decl = cast<UsingShadowDecl>(Decl)->getTargetDecl();
6552 
6553  if (FunctionTemplateDecl *TD = dyn_cast<FunctionTemplateDecl>(Decl)) {
6554  assert(isa<CXXMethodDecl>(TD->getTemplatedDecl()) &&
6555  "Expected a member function template");
6556  AddMethodTemplateCandidate(TD, FoundDecl, ActingContext,
6557  /*ExplicitArgs*/ nullptr, ObjectType,
6558  ObjectClassification, Args, CandidateSet,
6559  SuppressUserConversions);
6560  } else {
6561  AddMethodCandidate(cast<CXXMethodDecl>(Decl), FoundDecl, ActingContext,
6562  ObjectType, ObjectClassification, Args, CandidateSet,
6563  SuppressUserConversions);
6564  }
6565 }
6566 
6567 /// AddMethodCandidate - Adds the given C++ member function to the set
6568 /// of candidate functions, using the given function call arguments
6569 /// and the object argument (@c Object). For example, in a call
6570 /// @c o.f(a1,a2), @c Object will contain @c o and @c Args will contain
6571 /// both @c a1 and @c a2. If @p SuppressUserConversions, then don't
6572 /// allow user-defined conversions via constructors or conversion
6573 /// operators.
6574 void
6576  CXXRecordDecl *ActingContext, QualType ObjectType,
6577  Expr::Classification ObjectClassification,
6578  ArrayRef<Expr *> Args,
6579  OverloadCandidateSet &CandidateSet,
6580  bool SuppressUserConversions,
6581  bool PartialOverloading,
6582  ConversionSequenceList EarlyConversions) {
6583  const FunctionProtoType *Proto
6584  = dyn_cast<FunctionProtoType>(Method->getType()->getAs<FunctionType>());
6585  assert(Proto && "Methods without a prototype cannot be overloaded");
6586  assert(!isa<CXXConstructorDecl>(Method) &&
6587  "Use AddOverloadCandidate for constructors");
6588 
6589  if (!CandidateSet.isNewCandidate(Method))
6590  return;
6591 
6592  // C++11 [class.copy]p23: [DR1402]
6593  // A defaulted move assignment operator that is defined as deleted is
6594  // ignored by overload resolution.
6595  if (Method->isDefaulted() && Method->isDeleted() &&
6596  Method->isMoveAssignmentOperator())
6597  return;
6598 
6599  // Overload resolution is always an unevaluated context.
6602 
6603  // Add this candidate
6604  OverloadCandidate &Candidate =
6605  CandidateSet.addCandidate(Args.size() + 1, EarlyConversions);
6606  Candidate.FoundDecl = FoundDecl;
6607  Candidate.Function = Method;
6608  Candidate.IsSurrogate = false;
6609  Candidate.IgnoreObjectArgument = false;
6610  Candidate.ExplicitCallArguments = Args.size();
6611 
6612  unsigned NumParams = Proto->getNumParams();
6613 
6614  // (C++ 13.3.2p2): A candidate function having fewer than m
6615  // parameters is viable only if it has an ellipsis in its parameter
6616  // list (8.3.5).
6617  if (TooManyArguments(NumParams, Args.size(), PartialOverloading) &&
6618  !Proto->isVariadic()) {
6619  Candidate.Viable = false;
6621  return;
6622  }
6623 
6624  // (C++ 13.3.2p2): A candidate function having more than m parameters
6625  // is viable only if the (m+1)st parameter has a default argument
6626  // (8.3.6). For the purposes of overload resolution, the
6627  // parameter list is truncated on the right, so that there are
6628  // exactly m parameters.
6629  unsigned MinRequiredArgs = Method->getMinRequiredArguments();
6630  if (Args.size() < MinRequiredArgs && !PartialOverloading) {
6631  // Not enough arguments.
6632  Candidate.Viable = false;
6634  return;
6635  }
6636 
6637  Candidate.Viable = true;
6638 
6639  if (Method->isStatic() || ObjectType.isNull())
6640  // The implicit object argument is ignored.
6641  Candidate.IgnoreObjectArgument = true;
6642  else {
6643  // Determine the implicit conversion sequence for the object
6644  // parameter.
6646  *this, CandidateSet.getLocation(), ObjectType, ObjectClassification,
6647  Method, ActingContext);
6648  if (Candidate.Conversions[0].isBad()) {
6649  Candidate.Viable = false;
6651  return;
6652  }
6653  }
6654 
6655  // (CUDA B.1): Check for invalid calls between targets.
6656  if (getLangOpts().CUDA)
6657  if (const FunctionDecl *Caller = dyn_cast<FunctionDecl>(CurContext))
6658  if (!IsAllowedCUDACall(Caller, Method)) {
6659  Candidate.Viable = false;
6660  Candidate.FailureKind = ovl_fail_bad_target;
6661  return;
6662  }
6663 
6664  // Determine the implicit conversion sequences for each of the
6665  // arguments.
6666  for (unsigned ArgIdx = 0; ArgIdx < Args.size(); ++ArgIdx) {
6667  if (Candidate.Conversions[ArgIdx + 1].isInitialized()) {
6668  // We already formed a conversion sequence for this parameter during
6669  // template argument deduction.
6670  } else if (ArgIdx < NumParams) {
6671  // (C++ 13.3.2p3): for F to be a viable function, there shall
6672  // exist for each argument an implicit conversion sequence
6673  // (13.3.3.1) that converts that argument to the corresponding
6674  // parameter of F.
6675  QualType ParamType = Proto->getParamType(ArgIdx);
6676  Candidate.Conversions[ArgIdx + 1]
6677  = TryCopyInitialization(*this, Args[ArgIdx], ParamType,
6678  SuppressUserConversions,
6679  /*InOverloadResolution=*/true,
6680  /*AllowObjCWritebackConversion=*/
6681  getLangOpts().ObjCAutoRefCount);
6682  if (Candidate.Conversions[ArgIdx + 1].isBad()) {
6683  Candidate.Viable = false;
6684  Candidate.FailureKind = ovl_fail_bad_conversion;
6685  return;
6686  }
6687  } else {
6688  // (C++ 13.3.2p2): For the purposes of overload resolution, any
6689  // argument for which there is no corresponding parameter is
6690  // considered to "match the ellipsis" (C+ 13.3.3.1.3).
6691  Candidate.Conversions[ArgIdx + 1].setEllipsis();
6692  }
6693  }
6694 
6695  if (EnableIfAttr *FailedAttr = CheckEnableIf(Method, Args, true)) {
6696  Candidate.Viable = false;
6697  Candidate.FailureKind = ovl_fail_enable_if;
6698  Candidate.DeductionFailure.Data = FailedAttr;
6699  return;
6700  }
6701 
6702  if (Method->isMultiVersion() && Method->hasAttr<TargetAttr>() &&
6703  !Method->getAttr<TargetAttr>()->isDefaultVersion()) {
6704  Candidate.Viable = false;
6705  Candidate.FailureKind = ovl_non_default_multiversion_function;
6706  }
6707 }
6708 
6709 /// Add a C++ member function template as a candidate to the candidate
6710 /// set, using template argument deduction to produce an appropriate member
6711 /// function template specialization.
6712 void
6714  DeclAccessPair FoundDecl,
6715  CXXRecordDecl *ActingContext,
6716  TemplateArgumentListInfo *ExplicitTemplateArgs,
6717  QualType ObjectType,
6718  Expr::Classification ObjectClassification,
6719  ArrayRef<Expr *> Args,
6720  OverloadCandidateSet& CandidateSet,
6721  bool SuppressUserConversions,
6722  bool PartialOverloading) {
6723  if (!CandidateSet.isNewCandidate(MethodTmpl))
6724  return;
6725 
6726  // C++ [over.match.funcs]p7:
6727  // In each case where a candidate is a function template, candidate
6728  // function template specializations are generated using template argument
6729  // deduction (14.8.3, 14.8.2). Those candidates are then handled as
6730  // candidate functions in the usual way.113) A given name can refer to one
6731  // or more function templates and also to a set of overloaded non-template
6732  // functions. In such a case, the candidate functions generated from each
6733  // function template are combined with the set of non-template candidate
6734  // functions.
6735  TemplateDeductionInfo Info(CandidateSet.getLocation());
6736  FunctionDecl *Specialization = nullptr;
6737  ConversionSequenceList Conversions;
6739  MethodTmpl, ExplicitTemplateArgs, Args, Specialization, Info,
6740  PartialOverloading, [&](ArrayRef<QualType> ParamTypes) {
6741  return CheckNonDependentConversions(
6742  MethodTmpl, ParamTypes, Args, CandidateSet, Conversions,
6743  SuppressUserConversions, ActingContext, ObjectType,
6744  ObjectClassification);
6745  })) {
6746  OverloadCandidate &Candidate =
6747  CandidateSet.addCandidate(Conversions.size(), Conversions);
6748  Candidate.FoundDecl = FoundDecl;
6749  Candidate.Function = MethodTmpl->getTemplatedDecl();
6750  Candidate.Viable = false;
6751  Candidate.IsSurrogate = false;
6752  Candidate.IgnoreObjectArgument =
6753  cast<CXXMethodDecl>(Candidate.Function)->isStatic() ||
6754  ObjectType.isNull();
6755  Candidate.ExplicitCallArguments = Args.size();
6756  if (Result == TDK_NonDependentConversionFailure)
6758  else {
6759  Candidate.FailureKind = ovl_fail_bad_deduction;
6760  Candidate.DeductionFailure = MakeDeductionFailureInfo(Context, Result,
6761  Info);
6762  }
6763  return;
6764  }
6765 
6766  // Add the function template specialization produced by template argument
6767  // deduction as a candidate.
6768  assert(Specialization && "Missing member function template specialization?");
6769  assert(isa<CXXMethodDecl>(Specialization) &&
6770  "Specialization is not a member function?");
6771  AddMethodCandidate(cast<CXXMethodDecl>(Specialization), FoundDecl,
6772  ActingContext, ObjectType, ObjectClassification, Args,
6773  CandidateSet, SuppressUserConversions, PartialOverloading,
6774  Conversions);
6775 }
6776 
6777 /// Add a C++ function template specialization as a candidate
6778 /// in the candidate set, using template argument deduction to produce
6779 /// an appropriate function template specialization.
6781  FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl,
6782  TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,
6783  OverloadCandidateSet &CandidateSet, bool SuppressUserConversions,
6784  bool PartialOverloading, bool AllowExplicit, ADLCallKind IsADLCandidate) {
6785  if (!CandidateSet.isNewCandidate(FunctionTemplate))
6786  return;
6787 
6788  // C++ [over.match.funcs]p7:
6789  // In each case where a candidate is a function template, candidate
6790  // function template specializations are generated using template argument
6791  // deduction (14.8.3, 14.8.2). Those candidates are then handled as
6792  // candidate functions in the usual way.113) A given name can refer to one
6793  // or more function templates and also to a set of overloaded non-template
6794  // functions. In such a case, the candidate functions generated from each
6795  // function template are combined with the set of non-template candidate
6796  // functions.
6797  TemplateDeductionInfo Info(CandidateSet.getLocation());
6798  FunctionDecl *Specialization = nullptr;
6799  ConversionSequenceList Conversions;
6801  FunctionTemplate, ExplicitTemplateArgs, Args, Specialization, Info,
6802  PartialOverloading, [&](ArrayRef<QualType> ParamTypes) {
6803  return CheckNonDependentConversions(FunctionTemplate, ParamTypes,
6804  Args, CandidateSet, Conversions,
6805  SuppressUserConversions);
6806  })) {
6807  OverloadCandidate &Candidate =
6808  CandidateSet.addCandidate(Conversions.size(), Conversions);
6809  Candidate.FoundDecl = FoundDecl;
6810  Candidate.Function = FunctionTemplate->getTemplatedDecl();
6811  Candidate.Viable = false;
6812  Candidate.IsSurrogate = false;
6813  Candidate.IsADLCandidate = IsADLCandidate;
6814  // Ignore the object argument if there is one, since we don't have an object
6815  // type.
6816  Candidate.IgnoreObjectArgument =
6817  isa<CXXMethodDecl>(Candidate.Function) &&
6818  !isa<CXXConstructorDecl>(Candidate.Function);
6819  Candidate.ExplicitCallArguments = Args.size();
6820  if (Result == TDK_NonDependentConversionFailure)
6822  else {
6823  Candidate.FailureKind = ovl_fail_bad_deduction;
6824  Candidate.DeductionFailure = MakeDeductionFailureInfo(Context, Result,
6825  Info);
6826  }
6827  return;
6828  }
6829 
6830  // Add the function template specialization produced by template argument
6831  // deduction as a candidate.
6832  assert(Specialization && "Missing function template specialization?");
6833  AddOverloadCandidate(
6834  Specialization, FoundDecl, Args, CandidateSet, SuppressUserConversions,
6835  PartialOverloading, AllowExplicit,
6836  /*AllowExplicitConversions*/ false, IsADLCandidate, Conversions);
6837 }
6838 
6839 /// Check that implicit conversion sequences can be formed for each argument
6840 /// whose corresponding parameter has a non-dependent type, per DR1391's
6841 /// [temp.deduct.call]p10.
6843  FunctionTemplateDecl *FunctionTemplate, ArrayRef<QualType> ParamTypes,
6844  ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet,
6845  ConversionSequenceList &Conversions, bool SuppressUserConversions,
6846  CXXRecordDecl *ActingContext, QualType ObjectType,
6847  Expr::Classification ObjectClassification) {
6848  // FIXME: The cases in which we allow explicit conversions for constructor
6849  // arguments never consider calling a constructor template. It's not clear
6850  // that is correct.
6851  const bool AllowExplicit = false;
6852 
6853  auto *FD = FunctionTemplate->getTemplatedDecl();
6854  auto *Method = dyn_cast<CXXMethodDecl>(FD);
6855  bool HasThisConversion = Method && !isa<CXXConstructorDecl>(Method);
6856  unsigned ThisConversions = HasThisConversion ? 1 : 0;
6857 
6858  Conversions =
6859  CandidateSet.allocateConversionSequences(ThisConversions + Args.size());
6860 
6861  // Overload resolution is always an unevaluated context.
6864 
6865  // For a method call, check the 'this' conversion here too. DR1391 doesn't
6866  // require that, but this check should never result in a hard error, and
6867  // overload resolution is permitted to sidestep instantiations.
6868  if (HasThisConversion && !cast<CXXMethodDecl>(FD)->isStatic() &&
6869  !ObjectType.isNull()) {
6870  Conversions[0] = TryObjectArgumentInitialization(
6871  *this, CandidateSet.getLocation(), ObjectType, ObjectClassification,
6872  Method, ActingContext);
6873  if (Conversions[0].isBad())
6874  return true;
6875  }
6876 
6877  for (unsigned I = 0, N = std::min(ParamTypes.size(), Args.size()); I != N;
6878  ++I) {
6879  QualType ParamType = ParamTypes[I];
6880  if (!ParamType->isDependentType()) {
6881  Conversions[ThisConversions + I]
6882  = TryCopyInitialization(*this, Args[I], ParamType,
6883  SuppressUserConversions,
6884  /*InOverloadResolution=*/true,
6885  /*AllowObjCWritebackConversion=*/
6886  getLangOpts().ObjCAutoRefCount,
6887  AllowExplicit);
6888  if (Conversions[ThisConversions + I].isBad())
6889  return true;
6890  }
6891  }
6892 
6893  return false;
6894 }
6895 
6896 /// Determine whether this is an allowable conversion from the result
6897 /// of an explicit conversion operator to the expected type, per C++
6898 /// [over.match.conv]p1 and [over.match.ref]p1.
6899 ///
6900 /// \param ConvType The return type of the conversion function.
6901 ///
6902 /// \param ToType The type we are converting to.
6903 ///
6904 /// \param AllowObjCPointerConversion Allow a conversion from one
6905 /// Objective-C pointer to another.
6906 ///
6907 /// \returns true if the conversion is allowable, false otherwise.
6909  QualType ConvType, QualType ToType,
6910  bool AllowObjCPointerConversion) {
6911  QualType ToNonRefType = ToType.getNonReferenceType();
6912 
6913  // Easy case: the types are the same.
6914  if (S.Context.hasSameUnqualifiedType(ConvType, ToNonRefType))
6915  return true;
6916 
6917  // Allow qualification conversions.
6918  bool ObjCLifetimeConversion;
6919  if (S.IsQualificationConversion(ConvType, ToNonRefType, /*CStyle*/false,
6920  ObjCLifetimeConversion))
6921  return true;
6922 
6923  // If we're not allowed to consider Objective-C pointer conversions,
6924  // we're done.
6925  if (!AllowObjCPointerConversion)
6926  return false;
6927 
6928  // Is this an Objective-C pointer conversion?
6929  bool IncompatibleObjC = false;
6930  QualType ConvertedType;
6931  return S.isObjCPointerConversion(ConvType, ToNonRefType, ConvertedType,
6932  IncompatibleObjC);
6933 }
6934 
6935 /// AddConversionCandidate - Add a C++ conversion function as a
6936 /// candidate in the candidate set (C++ [over.match.conv],
6937 /// C++ [over.match.copy]). From is the expression we're converting from,
6938 /// and ToType is the type that we're eventually trying to convert to
6939 /// (which may or may not be the same type as the type that the
6940 /// conversion function produces).
6942  CXXConversionDecl *Conversion, DeclAccessPair FoundDecl,
6943  CXXRecordDecl *ActingContext, Expr *From, QualType ToType,
6944  OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit,
6945  bool AllowExplicit, bool AllowResultConversion) {
6946  assert(!Conversion->getDescribedFunctionTemplate() &&
6947  "Conversion function templates use AddTemplateConversionCandidate");
6948  QualType ConvType = Conversion->getConversionType().getNonReferenceType();
6949  if (!CandidateSet.isNewCandidate(Conversion))
6950  return;
6951 
6952  // If the conversion function has an undeduced return type, trigger its
6953  // deduction now.
6954  if (getLangOpts().CPlusPlus14 && ConvType->isUndeducedType()) {
6955  if (DeduceReturnType(Conversion, From->getExprLoc()))
6956  return;
6957  ConvType = Conversion->getConversionType().getNonReferenceType();
6958  }
6959 
6960  // If we don't allow any conversion of the result type, ignore conversion
6961  // functions that don't convert to exactly (possibly cv-qualified) T.
6962  if (!AllowResultConversion &&
6963  !Context.hasSameUnqualifiedType(Conversion->getConversionType(), ToType))
6964  return;
6965 
6966  // Per C++ [over.match.conv]p1, [over.match.ref]p1, an explicit conversion
6967  // operator is only a candidate if its return type is the target type or
6968  // can be converted to the target type with a qualification conversion.
6969  if (Conversion->isExplicit() &&
6970  !isAllowableExplicitConversion(*this, ConvType, ToType,
6971  AllowObjCConversionOnExplicit))
6972  return;
6973 
6974  // Overload resolution is always an unevaluated context.
6977 
6978  // Add this candidate
6979  OverloadCandidate &Candidate = CandidateSet.addCandidate(1);
6980  Candidate.FoundDecl = FoundDecl;
6981  Candidate.Function = Conversion;
6982  Candidate.IsSurrogate = false;
6983  Candidate.IgnoreObjectArgument = false;
6985  Candidate.FinalConversion.setFromType(ConvType);
6986  Candidate.FinalConversion.setAllToTypes(ToType);
6987  Candidate.Viable = true;
6988  Candidate.ExplicitCallArguments = 1;
6989 
6990  // C++ [over.match.funcs]p4:
6991  // For conversion functions, the function is considered to be a member of
6992  // the class of the implicit implied object argument for the purpose of
6993  // defining the type of the implicit object parameter.
6994  //
6995  // Determine the implicit conversion sequence for the implicit
6996  // object parameter.
6997  QualType ImplicitParamType = From->getType();
6998  if (const PointerType *FromPtrType = ImplicitParamType->getAs<PointerType>())
6999  ImplicitParamType = FromPtrType->getPointeeType();
7000  CXXRecordDecl *ConversionContext
7001  = cast<CXXRecordDecl>(ImplicitParamType->getAs<RecordType>()->getDecl());
7002 
7004  *this, CandidateSet.getLocation(), From->getType(),
7005  From->Classify(Context), Conversion, ConversionContext);
7006 
7007  if (Candidate.Conversions[0].isBad()) {
7008  Candidate.Viable = false;
7010  return;
7011  }
7012 
7013  // We won't go through a user-defined type conversion function to convert a
7014  // derived to base as such conversions are given Conversion Rank. They only
7015  // go through a copy constructor. 13.3.3.1.2-p4 [over.ics.user]
7016  QualType FromCanon
7017  = Context.getCanonicalType(From->getType().getUnqualifiedType());
7018  QualType ToCanon = Context.getCanonicalType(ToType).getUnqualifiedType();
7019  if (FromCanon == ToCanon ||
7020  IsDerivedFrom(CandidateSet.getLocation(), FromCanon, ToCanon)) {
7021  Candidate.Viable = false;
7023  return;
7024  }
7025 
7026  // To determine what the conversion from the result of calling the
7027  // conversion function to the type we're eventually trying to
7028  // convert to (ToType), we need to synthesize a call to the
7029  // conversion function and attempt copy initialization from it. This
7030  // makes sure that we get the right semantics with respect to
7031  // lvalues/rvalues and the type. Fortunately, we can allocate this
7032  // call on the stack and we don't need its arguments to be
7033  // well-formed.
7034  DeclRefExpr ConversionRef(Context, Conversion, false, Conversion->getType(),
7035  VK_LValue, From->getBeginLoc());
7037  Context.getPointerType(Conversion->getType()),
7038  CK_FunctionToPointerDecay,
7039  &ConversionRef, VK_RValue);
7040 
7041  QualType ConversionType = Conversion->getConversionType();
7042  if (!isCompleteType(From->getBeginLoc(), ConversionType)) {
7043  Candidate.Viable = false;
7045  return;
7046  }
7047 
7048  ExprValueKind VK = Expr::getValueKindForType(ConversionType);
7049 
7050  // Note that it is safe to allocate CallExpr on the stack here because
7051  // there are 0 arguments (i.e., nothing is allocated using ASTContext's
7052  // allocator).
7053  QualType CallResultType = ConversionType.getNonLValueExprType(Context);
7054 
7055  llvm::AlignedCharArray<alignof(CallExpr), sizeof(CallExpr) + sizeof(Stmt *)>
7056  Buffer;
7057  CallExpr *TheTemporaryCall = CallExpr::CreateTemporary(
7058  Buffer.buffer, &ConversionFn, CallResultType, VK, From->getBeginLoc());
7059 
7061  TryCopyInitialization(*this, TheTemporaryCall, ToType,
7062  /*SuppressUserConversions=*/true,
7063  /*InOverloadResolution=*/false,
7064  /*AllowObjCWritebackConversion=*/false);
7065 
7066  switch (ICS.getKind()) {
7068  Candidate.FinalConversion = ICS.Standard;
7069 
7070  // C++ [over.ics.user]p3:
7071  // If the user-defined conversion is specified by a specialization of a
7072  // conversion function template, the second standard conversion sequence
7073  // shall have exact match rank.
7074  if (Conversion->getPrimaryTemplate() &&
7075  GetConversionRank(ICS.Standard.Second) != ICR_Exact_Match) {
7076  Candidate.Viable = false;
7078  return;
7079  }
7080 
7081  // C++0x [dcl.init.ref]p5:
7082  // In the second case, if the reference is an rvalue reference and
7083  // the second standard conversion sequence of the user-defined
7084  // conversion sequence includes an lvalue-to-rvalue conversion, the
7085  // program is ill-formed.
7086  if (ToType->isRValueReferenceType() &&
7087  ICS.Standard.First == ICK_Lvalue_To_Rvalue) {
7088  Candidate.Viable = false;
7090  return;
7091  }
7092  break;
7093 
7095  Candidate.Viable = false;
7097  return;
7098 
7099  default:
7100  llvm_unreachable(
7101  "Can only end up with a standard conversion sequence or failure");
7102  }
7103 
7104  if (!AllowExplicit && Conversion->getExplicitSpecifier().getKind() !=
7106  Candidate.Viable = false;
7108  return;
7109  }
7110 
7111  if (EnableIfAttr *FailedAttr = CheckEnableIf(Conversion, None)) {
7112  Candidate.Viable = false;
7113  Candidate.FailureKind = ovl_fail_enable_if;
7114  Candidate.DeductionFailure.Data = FailedAttr;
7115  return;
7116  }
7117 
7118  if (Conversion->isMultiVersion() && Conversion->hasAttr<TargetAttr>() &&
7119  !Conversion->getAttr<TargetAttr>()->isDefaultVersion()) {
7120  Candidate.Viable = false;
7122  }
7123 }
7124 
7125 /// Adds a conversion function template specialization
7126 /// candidate to the overload set, using template argument deduction
7127 /// to deduce the template arguments of the conversion function
7128 /// template from the type that we are converting to (C++
7129 /// [temp.deduct.conv]).
7131  FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl,
7132  CXXRecordDecl *ActingDC, Expr *From, QualType ToType,
7133  OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit,
7134  bool AllowExplicit, bool AllowResultConversion) {
7135  assert(isa<CXXConversionDecl>(FunctionTemplate->getTemplatedDecl()) &&
7136  "Only conversion function templates permitted here");
7137 
7138  if (!CandidateSet.isNewCandidate(FunctionTemplate))
7139  return;
7140 
7141  TemplateDeductionInfo Info(CandidateSet.getLocation());
7142  CXXConversionDecl *Specialization = nullptr;
7143  if (TemplateDeductionResult Result
7144  = DeduceTemplateArguments(FunctionTemplate, ToType,
7145  Specialization, Info)) {
7146  OverloadCandidate &Candidate = CandidateSet.addCandidate();
7147  Candidate.FoundDecl = FoundDecl;
7148  Candidate.Function = FunctionTemplate->getTemplatedDecl();
7149  Candidate.Viable = false;
7150  Candidate.FailureKind = ovl_fail_bad_deduction;
7151  Candidate.IsSurrogate = false;
7152  Candidate.IgnoreObjectArgument = false;
7153  Candidate.ExplicitCallArguments = 1;
7154  Candidate.DeductionFailure = MakeDeductionFailureInfo(Context, Result,
7155  Info);
7156  return;
7157  }
7158 
7159  // Add the conversion function template specialization produced by
7160  // template argument deduction as a candidate.
7161  assert(Specialization && "Missing function template specialization?");
7162  AddConversionCandidate(Specialization, FoundDecl, ActingDC, From, ToType,
7163  CandidateSet, AllowObjCConversionOnExplicit,
7164  AllowExplicit, AllowResultConversion);
7165 }
7166 
7167 /// AddSurrogateCandidate - Adds a "surrogate" candidate function that
7168 /// converts the given @c Object to a function pointer via the
7169 /// conversion function @c Conversion, and then attempts to call it
7170 /// with the given arguments (C++ [over.call.object]p2-4). Proto is
7171 /// the type of function that we'll eventually be calling.
7173  DeclAccessPair FoundDecl,
7174  CXXRecordDecl *ActingContext,
7175  const FunctionProtoType *Proto,
7176  Expr *Object,
7177  ArrayRef<Expr *> Args,
7178  OverloadCandidateSet& CandidateSet) {
7179  if (!CandidateSet.isNewCandidate(Conversion))
7180  return;
7181 
7182  // Overload resolution is always an unevaluated context.
7185 
7186  OverloadCandidate &Candidate = CandidateSet.addCandidate(Args.size() + 1);
7187  Candidate.FoundDecl = FoundDecl;
7188  Candidate.Function = nullptr;
7189  Candidate.Surrogate = Conversion;
7190  Candidate.Viable = true;
7191  Candidate.IsSurrogate = true;
7192  Candidate.IgnoreObjectArgument = false;
7193  Candidate.ExplicitCallArguments = Args.size();
7194 
7195  // Determine the implicit conversion sequence for the implicit
7196  // object parameter.
7198  *this, CandidateSet.getLocation(), Object->getType(),
7199  Object->Classify(Context), Conversion, ActingContext);
7200  if (ObjectInit.isBad()) {
7201  Candidate.Viable = false;
7203  Candidate.Conversions[0] = ObjectInit;
7204  return;
7205  }
7206 
7207  // The first conversion is actually a user-defined conversion whose
7208  // first conversion is ObjectInit's standard conversion (which is
7209  // effectively a reference binding). Record it as such.
7210  Candidate.Conversions[0].setUserDefined();
7211  Candidate.Conversions[0].UserDefined.Before = ObjectInit.Standard;
7212  Candidate.Conversions[0].UserDefined.EllipsisConversion = false;
7213  Candidate.Conversions[0].UserDefined.HadMultipleCandidates = false;
7214  Candidate.Conversions[0].UserDefined.ConversionFunction = Conversion;
7215  Candidate.Conversions[0].UserDefined.FoundConversionFunction = FoundDecl;
7216  Candidate.Conversions[0].UserDefined.After
7217  = Candidate.Conversions[0].UserDefined.Before;
7218  Candidate.Conversions[0].UserDefined.After.setAsIdentityConversion();
7219 
7220  // Find the
7221  unsigned NumParams = Proto->getNumParams();
7222 
7223  // (C++ 13.3.2p2): A candidate function having fewer than m
7224  // parameters is viable only if it has an ellipsis in its parameter
7225  // list (8.3.5).
7226  if (Args.size() > NumParams && !Proto->isVariadic()) {
7227  Candidate.Viable = false;
7229  return;
7230  }
7231 
7232  // Function types don't have any default arguments, so just check if
7233  // we have enough arguments.
7234  if (Args.size() < NumParams) {
7235  // Not enough arguments.
7236  Candidate.Viable = false;
7238  return;
7239  }
7240 
7241  // Determine the implicit conversion sequences for each of the
7242  // arguments.
7243  for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
7244  if (ArgIdx < NumParams) {
7245  // (C++ 13.3.2p3): for F to be a viable function, there shall
7246  // exist for each argument an implicit conversion sequence
7247  // (13.3.3.1) that converts that argument to the corresponding
7248  // parameter of F.
7249  QualType ParamType = Proto->getParamType(ArgIdx);
7250  Candidate.Conversions[ArgIdx + 1]
7251  = TryCopyInitialization(*this, Args[ArgIdx], ParamType,
7252  /*SuppressUserConversions=*/false,
7253  /*InOverloadResolution=*/false,
7254  /*AllowObjCWritebackConversion=*/
7255  getLangOpts().ObjCAutoRefCount);
7256  if (Candidate.Conversions[ArgIdx + 1].isBad()) {
7257  Candidate.Viable = false;
7259  return;
7260  }
7261  } else {
7262  // (C++ 13.3.2p2): For the purposes of overload resolution, any
7263  // argument for which there is no corresponding parameter is
7264  // considered to ""match the ellipsis" (C+ 13.3.3.1.3).
7265  Candidate.Conversions[ArgIdx + 1].setEllipsis();
7266  }
7267  }
7268 
7269  if (EnableIfAttr *FailedAttr = CheckEnableIf(Conversion, None)) {
7270  Candidate.Viable = false;
7271  Candidate.FailureKind = ovl_fail_enable_if;
7272  Candidate.DeductionFailure.Data = FailedAttr;
7273  return;
7274  }
7275 }
7276 
7277 /// Add overload candidates for overloaded operators that are
7278 /// member functions.
7279 ///
7280 /// Add the overloaded operator candidates that are member functions
7281 /// for the operator Op that was used in an operator expression such
7282 /// as "x Op y". , Args/NumArgs provides the operator arguments, and
7283 /// CandidateSet will store the added overload candidates. (C++
7284 /// [over.match.oper]).
7286  SourceLocation OpLoc,
7287  ArrayRef<Expr *> Args,
7288  OverloadCandidateSet& CandidateSet,
7289  SourceRange OpRange) {
7291 
7292  // C++ [over.match.oper]p3:
7293  // For a unary operator @ with an operand of a type whose
7294  // cv-unqualified version is T1, and for a binary operator @ with
7295  // a left operand of a type whose cv-unqualified version is T1 and
7296  // a right operand of a type whose cv-unqualified version is T2,
7297  // three sets of candidate functions, designated member
7298  // candidates, non-member candidates and built-in candidates, are
7299  // constructed as follows:
7300  QualType T1 = Args[0]->getType();
7301 
7302  // -- If T1 is a complete class type or a class currently being
7303  // defined, the set of member candidates is the result of the
7304  // qualified lookup of T1::operator@ (13.3.1.1.1); otherwise,
7305  // the set of member candidates is empty.
7306  if (const RecordType *T1Rec = T1->getAs<RecordType>()) {
7307  // Complete the type if it can be completed.
7308  if (!isCompleteType(OpLoc, T1) && !T1Rec->isBeingDefined())
7309  return;
7310  // If the type is neither complete nor being defined, bail out now.
7311  if (!T1Rec->getDecl()->getDefinition())
7312  return;
7313 
7314  LookupResult Operators(*this, OpName, OpLoc, LookupOrdinaryName);
7315  LookupQualifiedName(Operators, T1Rec->getDecl());
7316  Operators.suppressDiagnostics();
7317 
7318  for (LookupResult::iterator Oper = Operators.begin(),
7319  OperEnd = Operators.end();
7320  Oper != OperEnd;
7321  ++Oper)
7322  AddMethodCandidate(Oper.getPair(), Args[0]->getType(),
7323  Args[0]->Classify(Context), Args.slice(1),
7324  CandidateSet, /*SuppressUserConversion=*/false);
7325  }
7326 }
7327 
7328 /// AddBuiltinCandidate - Add a candidate for a built-in
7329 /// operator. ResultTy and ParamTys are the result and parameter types
7330 /// of the built-in candidate, respectively. Args and NumArgs are the
7331 /// arguments being passed to the candidate. IsAssignmentOperator
7332 /// should be true when this built-in candidate is an assignment
7333 /// operator. NumContextualBoolArguments is the number of arguments
7334 /// (at the beginning of the argument list) that will be contextually
7335 /// converted to bool.
7337  OverloadCandidateSet& CandidateSet,
7338  bool IsAssignmentOperator,
7339  unsigned NumContextualBoolArguments) {
7340  // Overload resolution is always an unevaluated context.
7343 
7344  // Add this candidate
7345  OverloadCandidate &Candidate = CandidateSet.addCandidate(Args.size());
7346  Candidate.FoundDecl = DeclAccessPair::make(nullptr, AS_none);
7347  Candidate.Function = nullptr;
7348  Candidate.IsSurrogate = false;
7349  Candidate.IgnoreObjectArgument = false;
7350  std::copy(ParamTys, ParamTys + Args.size(), Candidate.BuiltinParamTypes);
7351 
7352  // Determine the implicit conversion sequences for each of the
7353  // arguments.
7354  Candidate.Viable = true;
7355  Candidate.ExplicitCallArguments = Args.size();
7356  for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
7357  // C++ [over.match.oper]p4:
7358  // For the built-in assignment operators, conversions of the
7359  // left operand are restricted as follows:
7360  // -- no temporaries are introduced to hold the left operand, and
7361  // -- no user-defined conversions are applied to the left
7362  // operand to achieve a type match with the left-most
7363  // parameter of a built-in candidate.
7364  //
7365  // We block these conversions by turning off user-defined
7366  // conversions, since that is the only way that initialization of
7367  // a reference to a non-class type can occur from something that
7368  // is not of the same type.
7369  if (ArgIdx < NumContextualBoolArguments) {
7370  assert(ParamTys[ArgIdx] == Context.BoolTy &&
7371  "Contextual conversion to bool requires bool type");
7372  Candidate.Conversions[ArgIdx]
7373  = TryContextuallyConvertToBool(*this, Args[ArgIdx]);
7374  } else {
7375  Candidate.Conversions[ArgIdx]
7376  = TryCopyInitialization(*this, Args[ArgIdx], ParamTys[ArgIdx],
7377  ArgIdx == 0 && IsAssignmentOperator,
7378  /*InOverloadResolution=*/false,
7379  /*AllowObjCWritebackConversion=*/
7380  getLangOpts().ObjCAutoRefCount);
7381  }
7382  if (Candidate.Conversions[ArgIdx].isBad()) {
7383  Candidate.Viable = false;
7385  break;
7386  }
7387  }
7388 }
7389 
7390 namespace {
7391 
7392 /// BuiltinCandidateTypeSet - A set of types that will be used for the
7393 /// candidate operator functions for built-in operators (C++
7394 /// [over.built]). The types are separated into pointer types and
7395 /// enumeration types.
7396 class BuiltinCandidateTypeSet {
7397  /// TypeSet - A set of types.
7398  typedef llvm::SetVector<QualType, SmallVector<QualType, 8>,
7399  llvm::SmallPtrSet<QualType, 8>> TypeSet;
7400 
7401  /// PointerTypes - The set of pointer types that will be used in the
7402  /// built-in candidates.
7403  TypeSet PointerTypes;
7404 
7405  /// MemberPointerTypes - The set of member pointer types that will be
7406  /// used in the built-in candidates.
7407  TypeSet MemberPointerTypes;
7408 
7409  /// EnumerationTypes - The set of enumeration types that will be
7410  /// used in the built-in candidates.
7411  TypeSet EnumerationTypes;
7412 
7413  /// The set of vector types that will be used in the built-in
7414  /// candidates.
7415  TypeSet VectorTypes;
7416 
7417  /// A flag indicating non-record types are viable candidates
7418  bool HasNonRecordTypes;
7419 
7420  /// A flag indicating whether either arithmetic or enumeration types
7421  /// were present in the candidate set.
7422  bool HasArithmeticOrEnumeralTypes;
7423 
7424  /// A flag indicating whether the nullptr type was present in the
7425  /// candidate set.
7426  bool HasNullPtrType;
7427 
7428  /// Sema - The semantic analysis instance where we are building the
7429  /// candidate type set.
7430  Sema &SemaRef;
7431 
7432  /// Context - The AST context in which we will build the type sets.
7433  ASTContext &Context;
7434 
7435  bool AddPointerWithMoreQualifiedTypeVariants(QualType Ty,
7436  const Qualifiers &VisibleQuals);
7437  bool AddMemberPointerWithMoreQualifiedTypeVariants(QualType Ty);
7438 
7439 public:
7440  /// iterator - Iterates through the types that are part of the set.
7441  typedef TypeSet::iterator iterator;
7442 
7443  BuiltinCandidateTypeSet(Sema &SemaRef)
7444  : HasNonRecordTypes(false),
7445  HasArithmeticOrEnumeralTypes(false),
7446  HasNullPtrType(false),
7447  SemaRef(SemaRef),
7448  Context(SemaRef.Context) { }
7449 
7450  void AddTypesConvertedFrom(QualType Ty,
7451  SourceLocation Loc,
7452  bool AllowUserConversions,
7453  bool AllowExplicitConversions,
7454  const Qualifiers &VisibleTypeConversionsQuals);
7455 
7456  /// pointer_begin - First pointer type found;
7457  iterator pointer_begin() { return PointerTypes.begin(); }
7458 
7459  /// pointer_end - Past the last pointer type found;
7460  iterator pointer_end() { return PointerTypes.end(); }
7461 
7462  /// member_pointer_begin - First member pointer type found;
7463  iterator member_pointer_begin() { return MemberPointerTypes.begin(); }
7464 
7465  /// member_pointer_end - Past the last member pointer type found;
7466  iterator member_pointer_end() { return MemberPointerTypes.end(); }
7467 
7468  /// enumeration_begin - First enumeration type found;
7469  iterator enumeration_begin() { return EnumerationTypes.begin(); }
7470 
7471  /// enumeration_end - Past the last enumeration type found;
7472  iterator enumeration_end() { return EnumerationTypes.end(); }
7473 
7474  iterator vector_begin() { return VectorTypes.begin(); }
7475  iterator vector_end() { return VectorTypes.end(); }
7476 
7477  bool hasNonRecordTypes() { return HasNonRecordTypes; }
7478  bool hasArithmeticOrEnumeralTypes() { return HasArithmeticOrEnumeralTypes; }
7479  bool hasNullPtrType() const { return HasNullPtrType; }
7480 };
7481 
7482 } // end anonymous namespace
7483 
7484 /// AddPointerWithMoreQualifiedTypeVariants - Add the pointer type @p Ty to
7485 /// the set of pointer types along with any more-qualified variants of
7486 /// that type. For example, if @p Ty is "int const *", this routine
7487 /// will add "int const *", "int const volatile *", "int const
7488 /// restrict *", and "int const volatile restrict *" to the set of
7489 /// pointer types. Returns true if the add of @p Ty itself succeeded,
7490 /// false otherwise.
7491 ///
7492 /// FIXME: what to do about extended qualifiers?
7493 bool
7494 BuiltinCandidateTypeSet::AddPointerWithMoreQualifiedTypeVariants(QualType Ty,
7495  const Qualifiers &VisibleQuals) {
7496 
7497  // Insert this type.
7498  if (!PointerTypes.insert(Ty))
7499  return false;
7500 
7501  QualType PointeeTy;
7502  const PointerType *PointerTy = Ty->getAs<PointerType>();
7503  bool buildObjCPtr = false;
7504  if (!PointerTy) {
7506  PointeeTy = PTy->getPointeeType();
7507  buildObjCPtr = true;
7508  } else {
7509  PointeeTy = PointerTy->getPointeeType();
7510  }
7511 
7512  // Don't add qualified variants of arrays. For one, they're not allowed
7513  // (the qualifier would sink to the element type), and for another, the
7514  // only overload situation where it matters is subscript or pointer +- int,
7515  // and those shouldn't have qualifier variants anyway.
7516  if (PointeeTy->isArrayType())
7517  return true;
7518 
7519  unsigned BaseCVR = PointeeTy.getCVRQualifiers();
7520  bool hasVolatile = VisibleQuals.hasVolatile();
7521  bool hasRestrict = VisibleQuals.hasRestrict();
7522 
7523  // Iterate through all strict supersets of BaseCVR.
7524  for (unsigned CVR = BaseCVR+1; CVR <= Qualifiers::CVRMask; ++CVR) {
7525  if ((CVR | BaseCVR) != CVR) continue;
7526  // Skip over volatile if no volatile found anywhere in the types.
7527  if ((CVR & Qualifiers::Volatile) && !hasVolatile) continue;
7528 
7529  // Skip over restrict if no restrict found anywhere in the types, or if
7530  // the type cannot be restrict-qualified.
7531  if ((CVR & Qualifiers::Restrict) &&
7532  (!hasRestrict ||
7533  (!(PointeeTy->isAnyPointerType() || PointeeTy->isReferenceType()))))
7534  continue;
7535 
7536  // Build qualified pointee type.
7537  QualType QPointeeTy = Context.getCVRQualifiedType(PointeeTy, CVR);
7538 
7539  // Build qualified pointer type.
7540  QualType QPointerTy;
7541  if (!buildObjCPtr)
7542  QPointerTy = Context.getPointerType(QPointeeTy);
7543  else
7544  QPointerTy = Context.getObjCObjectPointerType(QPointeeTy);
7545 
7546  // Insert qualified pointer type.
7547  PointerTypes.insert(QPointerTy);
7548  }
7549 
7550  return true;
7551 }
7552 
7553 /// AddMemberPointerWithMoreQualifiedTypeVariants - Add the pointer type @p Ty
7554 /// to the set of pointer types along with any more-qualified variants of
7555 /// that type. For example, if @p Ty is "int const *", this routine
7556 /// will add "int const *", "int const volatile *", "int const
7557 /// restrict *", and "int const volatile restrict *" to the set of
7558 /// pointer types. Returns true if the add of @p Ty itself succeeded,
7559 /// false otherwise.
7560 ///
7561 /// FIXME: what to do about extended qualifiers?
7562 bool
7563 BuiltinCandidateTypeSet::AddMemberPointerWithMoreQualifiedTypeVariants(
7564  QualType Ty) {
7565  // Insert this type.
7566  if (!MemberPointerTypes.insert(Ty))
7567  return false;
7568 
7569  const MemberPointerType *PointerTy = Ty->getAs<MemberPointerType>();
7570  assert(PointerTy && "type was not a member pointer type!");
7571 
7572  QualType PointeeTy = PointerTy->getPointeeType();
7573  // Don't add qualified variants of arrays. For one, they're not allowed
7574  // (the qualifier would sink to the element type), and for another, the
7575  // only overload situation where it matters is subscript or pointer +- int,
7576  // and those shouldn't have qualifier variants anyway.
7577  if (PointeeTy->isArrayType())
7578  return true;
7579  const Type *ClassTy = PointerTy->getClass();
7580 
7581  // Iterate through all strict supersets of the pointee type's CVR
7582  // qualifiers.
7583  unsigned BaseCVR = PointeeTy.getCVRQualifiers();
7584  for (unsigned CVR = BaseCVR+1; CVR <= Qualifiers::CVRMask; ++CVR) {
7585  if ((CVR | BaseCVR) != CVR) continue;
7586 
7587  QualType QPointeeTy = Context.getCVRQualifiedType(PointeeTy, CVR);
7588  MemberPointerTypes.insert(
7589  Context.getMemberPointerType(QPointeeTy, ClassTy));
7590  }
7591 
7592  return true;
7593 }
7594 
7595 /// AddTypesConvertedFrom - Add each of the types to which the type @p
7596 /// Ty can be implicit converted to the given set of @p Types. We're
7597 /// primarily interested in pointer types and enumeration types. We also
7598 /// take member pointer types, for the conditional operator.
7599 /// AllowUserConversions is true if we should look at the conversion
7600 /// functions of a class type, and AllowExplicitConversions if we
7601 /// should also include the explicit conversion functions of a class
7602 /// type.
7603 void
7604 BuiltinCandidateTypeSet::AddTypesConvertedFrom(QualType Ty,
7605  SourceLocation Loc,
7606  bool AllowUserConversions,
7607  bool AllowExplicitConversions,
7608  const Qualifiers &VisibleQuals) {
7609  // Only deal with canonical types.
7610  Ty = Context.getCanonicalType(Ty);
7611 
7612  // Look through reference types; they aren't part of the type of an
7613  // expression for the purposes of conversions.
7614  if (const ReferenceType *RefTy = Ty->getAs<ReferenceType>())
7615  Ty = RefTy->getPointeeType();
7616 
7617  // If we're dealing with an array type, decay to the pointer.
7618  if (Ty->isArrayType())
7619  Ty = SemaRef.Context.getArrayDecayedType(Ty);
7620 
7621  // Otherwise, we don't care about qualifiers on the type.
7622  Ty = Ty.getLocalUnqualifiedType();
7623 
7624  // Flag if we ever add a non-record type.
7625  const RecordType *TyRec = Ty->getAs<RecordType>();
7626  HasNonRecordTypes = HasNonRecordTypes || !TyRec;
7627 
7628  // Flag if we encounter an arithmetic type.
7629  HasArithmeticOrEnumeralTypes =
7630  HasArithmeticOrEnumeralTypes || Ty->isArithmeticType();
7631 
7632  if (Ty->isObjCIdType() || Ty->isObjCClassType())
7633  PointerTypes.insert(Ty);
7634  else if (Ty->getAs<PointerType>() || Ty->getAs<ObjCObjectPointerType>()) {
7635  // Insert our type, and its more-qualified variants, into the set
7636  // of types.
7637  if (!AddPointerWithMoreQualifiedTypeVariants(Ty, VisibleQuals))
7638  return;
7639  } else if (Ty->isMemberPointerType()) {
7640  // Member pointers are far easier, since the pointee can't be converted.
7641  if (!AddMemberPointerWithMoreQualifiedTypeVariants(Ty))
7642  return;
7643  } else if (Ty->isEnumeralType()) {
7644  HasArithmeticOrEnumeralTypes = true;
7645  EnumerationTypes.insert(Ty);
7646  } else if (Ty->isVectorType()) {
7647  // We treat vector types as arithmetic types in many contexts as an
7648  // extension.
7649  HasArithmeticOrEnumeralTypes = true;
7650  VectorTypes.insert(Ty);
7651  } else if (Ty->isNullPtrType()) {
7652  HasNullPtrType = true;
7653  } else if (AllowUserConversions && TyRec) {
7654  // No conversion functions in incomplete types.
7655  if (!SemaRef.isCompleteType(Loc, Ty))
7656  return;
7657 
7658  CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(TyRec->getDecl());
7659  for (NamedDecl *D : ClassDecl->getVisibleConversionFunctions()) {
7660  if (isa<UsingShadowDecl>(D))
7661  D = cast<UsingShadowDecl>(D)->getTargetDecl();
7662 
7663  // Skip conversion function templates; they don't tell us anything
7664  // about which builtin types we can convert to.
7665  if (isa<FunctionTemplateDecl>(D))
7666  continue;
7667 
7668  CXXConversionDecl *Conv = cast<CXXConversionDecl>(D);
7669  if (AllowExplicitConversions || !Conv->isExplicit()) {
7670  AddTypesConvertedFrom(Conv->getConversionType(), Loc, false, false,
7671  VisibleQuals);
7672  }
7673  }
7674  }
7675 }
7676 /// Helper function for adjusting address spaces for the pointer or reference
7677 /// operands of builtin operators depending on the argument.
7679  Expr *Arg) {
7680  return S.Context.getAddrSpaceQualType(T, Arg->getType().getAddressSpace());
7681 }
7682 
7683 /// Helper function for AddBuiltinOperatorCandidates() that adds
7684 /// the volatile- and non-volatile-qualified assignment operators for the
7685 /// given type to the candidate set.
7687  QualType T,
7688  ArrayRef<Expr *> Args,
7689  OverloadCandidateSet &CandidateSet) {
7690  QualType ParamTypes[2];
7691 
7692  // T& operator=(T&, T)
7693  ParamTypes[0] = S.Context.getLValueReferenceType(
7695  ParamTypes[1] = T;
7696  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
7697  /*IsAssignmentOperator=*/true);
7698 
7700  // volatile T& operator=(volatile T&, T)
7701  ParamTypes[0] = S.Context.getLValueReferenceType(
7703  Args[0]));
7704  ParamTypes[1] = T;
7705  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
7706  /*IsAssignmentOperator=*/true);
7707  }
7708 }
7709 
7710 /// CollectVRQualifiers - This routine returns Volatile/Restrict qualifiers,
7711 /// if any, found in visible type conversion functions found in ArgExpr's type.
7712 static Qualifiers CollectVRQualifiers(ASTContext &Context, Expr* ArgExpr) {
7713  Qualifiers VRQuals;
7714  const RecordType *TyRec;
7715  if (const MemberPointerType *RHSMPType =
7716  ArgExpr->getType()->getAs<MemberPointerType>())
7717  TyRec = RHSMPType->getClass()->getAs<RecordType>();
7718  else
7719  TyRec = ArgExpr->getType()->getAs<RecordType>();
7720  if (!TyRec) {
7721  // Just to be safe, assume the worst case.
7722  VRQuals.addVolatile();
7723  VRQuals.addRestrict();
7724  return VRQuals;
7725  }
7726 
7727  CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(TyRec->getDecl());
7728  if (!ClassDecl->hasDefinition())
7729  return VRQuals;
7730 
7731  for (NamedDecl *D : ClassDecl->getVisibleConversionFunctions()) {
7732  if (isa<UsingShadowDecl>(D))
7733  D = cast<UsingShadowDecl>(D)->getTargetDecl();
7734  if (CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(D)) {
7735  QualType CanTy = Context.getCanonicalType(Conv->getConversionType());
7736  if (const ReferenceType *ResTypeRef = CanTy->getAs<ReferenceType>())
7737  CanTy = ResTypeRef->getPointeeType();
7738  // Need to go down the pointer/mempointer chain and add qualifiers
7739  // as see them.
7740  bool done = false;
7741  while (!done) {
7742  if (CanTy.isRestrictQualified())
7743  VRQuals.addRestrict();
7744  if (const PointerType *ResTypePtr = CanTy->getAs<PointerType>())
7745  CanTy = ResTypePtr->getPointeeType();
7746  else if (const MemberPointerType *ResTypeMPtr =
7747  CanTy->getAs<MemberPointerType>())
7748  CanTy = ResTypeMPtr->getPointeeType();
7749  else
7750  done = true;
7751  if (CanTy.isVolatileQualified())
7752  VRQuals.addVolatile();
7753  if (VRQuals.hasRestrict() && VRQuals.hasVolatile())
7754  return VRQuals;
7755  }
7756  }
7757  }
7758  return VRQuals;
7759 }
7760 
7761 namespace {
7762 
7763 /// Helper class to manage the addition of builtin operator overload
7764 /// candidates. It provides shared state and utility methods used throughout
7765 /// the process, as well as a helper method to add each group of builtin
7766 /// operator overloads from the standard to a candidate set.
7767 class BuiltinOperatorOverloadBuilder {
7768  // Common instance state available to all overload candidate addition methods.
7769  Sema &S;
7770  ArrayRef<Expr *> Args;
7771  Qualifiers VisibleTypeConversionsQuals;
7772  bool HasArithmeticOrEnumeralCandidateType;
7774  OverloadCandidateSet &CandidateSet;
7775 
7776  static constexpr int ArithmeticTypesCap = 24;
7778 
7779  // Define some indices used to iterate over the arithemetic types in
7780  // ArithmeticTypes. The "promoted arithmetic types" are the arithmetic
7781  // types are that preserved by promotion (C++ [over.built]p2).
7782  unsigned FirstIntegralType,
7783  LastIntegralType;
7784  unsigned FirstPromotedIntegralType,
7785  LastPromotedIntegralType;
7786  unsigned FirstPromotedArithmeticType,
7787  LastPromotedArithmeticType;
7788  unsigned NumArithmeticTypes;
7789 
7790  void InitArithmeticTypes() {
7791  // Start of promoted types.
7792  FirstPromotedArithmeticType = 0;
7793  ArithmeticTypes.push_back(S.Context.FloatTy);
7794  ArithmeticTypes.push_back(S.Context.DoubleTy);
7795  ArithmeticTypes.push_back(S.Context.LongDoubleTy);
7797  ArithmeticTypes.push_back(S.Context.Float128Ty);
7798 
7799  // Start of integral types.
7800  FirstIntegralType = ArithmeticTypes.size();
7801  FirstPromotedIntegralType = ArithmeticTypes.size();
7802  ArithmeticTypes.push_back(S.Context.IntTy);
7803  ArithmeticTypes.push_back(S.Context.LongTy);
7804  ArithmeticTypes.push_back(S.Context.LongLongTy);
7806  ArithmeticTypes.push_back(S.Context.Int128Ty);
7807  ArithmeticTypes.push_back(S.Context.UnsignedIntTy);
7808  ArithmeticTypes.push_back(S.Context.UnsignedLongTy);
7809  ArithmeticTypes.push_back(S.Context.UnsignedLongLongTy);
7811  ArithmeticTypes.push_back(S.Context.UnsignedInt128Ty);
7812  LastPromotedIntegralType = ArithmeticTypes.size();
7813  LastPromotedArithmeticType = ArithmeticTypes.size();
7814  // End of promoted types.
7815 
7816  ArithmeticTypes.push_back(S.Context.BoolTy);
7817  ArithmeticTypes.push_back(S.Context.CharTy);
7818  ArithmeticTypes.push_back(S.Context.WCharTy);
7819  if (S.Context.getLangOpts().Char8)
7820  ArithmeticTypes.push_back(S.Context.Char8Ty);
7821  ArithmeticTypes.push_back(S.Context.Char16Ty);
7822  ArithmeticTypes.push_back(S.Context.Char32Ty);
7823  ArithmeticTypes.push_back(S.Context.SignedCharTy);
7824  ArithmeticTypes.push_back(S.Context.ShortTy);
7825  ArithmeticTypes.push_back(S.Context.UnsignedCharTy);
7826  ArithmeticTypes.push_back(S.Context.UnsignedShortTy);
7827  LastIntegralType = ArithmeticTypes.size();
7828  NumArithmeticTypes = ArithmeticTypes.size();
7829  // End of integral types.
7830  // FIXME: What about complex? What about half?
7831 
7832  assert(ArithmeticTypes.size() <= ArithmeticTypesCap &&
7833  "Enough inline storage for all arithmetic types.");
7834  }
7835 
7836  /// Helper method to factor out the common pattern of adding overloads
7837  /// for '++' and '--' builtin operators.
7838  void addPlusPlusMinusMinusStyleOverloads(QualType CandidateTy,
7839  bool HasVolatile,
7840  bool HasRestrict) {
7841  QualType ParamTypes[2] = {
7842  S.Context.getLValueReferenceType(CandidateTy),
7843  S.Context.IntTy
7844  };
7845 
7846  // Non-volatile version.
7847  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
7848 
7849  // Use a heuristic to reduce number of builtin candidates in the set:
7850  // add volatile version only if there are conversions to a volatile type.
7851  if (HasVolatile) {
7852  ParamTypes[0] =
7854  S.Context.getVolatileType(CandidateTy));
7855  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
7856  }
7857 
7858  // Add restrict version only if there are conversions to a restrict type
7859  // and our candidate type is a non-restrict-qualified pointer.
7860  if (HasRestrict && CandidateTy->isAnyPointerType() &&
7861  !CandidateTy.isRestrictQualified()) {
7862  ParamTypes[0]
7865  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
7866 
7867  if (HasVolatile) {
7868  ParamTypes[0]
7870  S.Context.getCVRQualifiedType(CandidateTy,
7873  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
7874  }
7875  }
7876 
7877  }
7878 
7879 public:
7880  BuiltinOperatorOverloadBuilder(
7881  Sema &S, ArrayRef<Expr *> Args,
7882  Qualifiers VisibleTypeConversionsQuals,
7883  bool HasArithmeticOrEnumeralCandidateType,
7885  OverloadCandidateSet &CandidateSet)
7886  : S(S), Args(Args),
7887  VisibleTypeConversionsQuals(VisibleTypeConversionsQuals),
7888  HasArithmeticOrEnumeralCandidateType(
7889  HasArithmeticOrEnumeralCandidateType),
7890  CandidateTypes(CandidateTypes),
7891  CandidateSet(CandidateSet) {
7892 
7893  InitArithmeticTypes();
7894  }
7895 
7896  // Increment is deprecated for bool since C++17.
7897  //
7898  // C++ [over.built]p3:
7899  //
7900  // For every pair (T, VQ), where T is an arithmetic type other
7901  // than bool, and VQ is either volatile or empty, there exist
7902  // candidate operator functions of the form
7903  //
7904  // VQ T& operator++(VQ T&);
7905  // T operator++(VQ T&, int);
7906  //
7907  // C++ [over.built]p4:
7908  //
7909  // For every pair (T, VQ), where T is an arithmetic type other
7910  // than bool, and VQ is either volatile or empty, there exist
7911  // candidate operator functions of the form
7912  //
7913  // VQ T& operator--(VQ T&);
7914  // T operator--(VQ T&, int);
7915  void addPlusPlusMinusMinusArithmeticOverloads(OverloadedOperatorKind Op) {
7916  if (!HasArithmeticOrEnumeralCandidateType)
7917  return;
7918 
7919  for (unsigned Arith = 0; Arith < NumArithmeticTypes; ++Arith) {
7920  const auto TypeOfT = ArithmeticTypes[Arith];
7921  if (TypeOfT == S.Context.BoolTy) {
7922  if (Op == OO_MinusMinus)
7923  continue;
7924  if (Op == OO_PlusPlus && S.getLangOpts().CPlusPlus17)
7925  continue;
7926  }
7927  addPlusPlusMinusMinusStyleOverloads(
7928  TypeOfT,
7929  VisibleTypeConversionsQuals.hasVolatile(),
7930  VisibleTypeConversionsQuals.hasRestrict());
7931  }
7932  }
7933 
7934  // C++ [over.built]p5:
7935  //
7936  // For every pair (T, VQ), where T is a cv-qualified or
7937  // cv-unqualified object type, and VQ is either volatile or
7938  // empty, there exist candidate operator functions of the form
7939  //
7940  // T*VQ& operator++(T*VQ&);
7941  // T*VQ& operator--(T*VQ&);
7942  // T* operator++(T*VQ&, int);
7943  // T* operator--(T*VQ&, int);
7944  void addPlusPlusMinusMinusPointerOverloads() {
7945  for (BuiltinCandidateTypeSet::iterator
7946  Ptr = CandidateTypes[0].pointer_begin(),
7947  PtrEnd = CandidateTypes[0].pointer_end();
7948  Ptr != PtrEnd; ++Ptr) {
7949  // Skip pointer types that aren't pointers to object types.
7950  if (!(*Ptr)->getPointeeType()->isObjectType())
7951  continue;
7952 
7953  addPlusPlusMinusMinusStyleOverloads(*Ptr,
7954  (!(*Ptr).isVolatileQualified() &&
7955  VisibleTypeConversionsQuals.hasVolatile()),
7956  (!(*Ptr).isRestrictQualified() &&
7957  VisibleTypeConversionsQuals.hasRestrict()));
7958  }
7959  }
7960 
7961  // C++ [over.built]p6:
7962  // For every cv-qualified or cv-unqualified object type T, there
7963  // exist candidate operator functions of the form
7964  //
7965  // T& operator*(T*);
7966  //
7967  // C++ [over.built]p7:
7968  // For every function type T that does not have cv-qualifiers or a
7969  // ref-qualifier, there exist candidate operator functions of the form
7970  // T& operator*(T*);
7971  void addUnaryStarPointerOverloads() {
7972  for (BuiltinCandidateTypeSet::iterator
7973  Ptr = CandidateTypes[0].pointer_begin(),
7974  PtrEnd = CandidateTypes[0].pointer_end();
7975  Ptr != PtrEnd; ++Ptr) {
7976  QualType ParamTy = *Ptr;
7977  QualType PointeeTy = ParamTy->getPointeeType();
7978  if (!PointeeTy->isObjectType() && !PointeeTy->isFunctionType())
7979  continue;
7980 
7981  if (const FunctionProtoType *Proto =PointeeTy->getAs<FunctionProtoType>())
7982  if (Proto->getMethodQuals() || Proto->getRefQualifier())
7983  continue;
7984 
7985  S.AddBuiltinCandidate(&ParamTy, Args, CandidateSet);
7986  }
7987  }
7988 
7989  // C++ [over.built]p9:
7990  // For every promoted arithmetic type T, there exist candidate
7991  // operator functions of the form
7992  //
7993  // T operator+(T);
7994  // T operator-(T);
7995  void addUnaryPlusOrMinusArithmeticOverloads() {
7996  if (!HasArithmeticOrEnumeralCandidateType)
7997  return;
7998 
7999  for (unsigned Arith = FirstPromotedArithmeticType;
8000  Arith < LastPromotedArithmeticType; ++Arith) {
8001  QualType ArithTy = ArithmeticTypes[Arith];
8002  S.AddBuiltinCandidate(&ArithTy, Args, CandidateSet);
8003  }
8004 
8005  // Extension: We also add these operators for vector types.
8006  for (BuiltinCandidateTypeSet::iterator
8007  Vec = CandidateTypes[0].vector_begin(),
8008  VecEnd = CandidateTypes[0].vector_end();
8009  Vec != VecEnd; ++Vec) {
8010  QualType VecTy = *Vec;
8011  S.AddBuiltinCandidate(&VecTy, Args, CandidateSet);
8012  }
8013  }
8014 
8015  // C++ [over.built]p8:
8016  // For every type T, there exist candidate operator functions of
8017  // the form
8018  //
8019  // T* operator+(T*);
8020  void addUnaryPlusPointerOverloads() {
8021  for (BuiltinCandidateTypeSet::iterator
8022  Ptr = CandidateTypes[0].pointer_begin(),
8023  PtrEnd = CandidateTypes[0].pointer_end();
8024  Ptr != PtrEnd; ++Ptr) {
8025  QualType ParamTy = *Ptr;
8026  S.AddBuiltinCandidate(&ParamTy, Args, CandidateSet);
8027  }
8028  }
8029 
8030  // C++ [over.built]p10:
8031  // For every promoted integral type T, there exist candidate
8032  // operator functions of the form
8033  //
8034  // T operator~(T);
8035  void addUnaryTildePromotedIntegralOverloads() {
8036  if (!HasArithmeticOrEnumeralCandidateType)
8037  return;
8038 
8039  for (unsigned Int = FirstPromotedIntegralType;
8040  Int < LastPromotedIntegralType; ++Int) {
8041  QualType IntTy = ArithmeticTypes[Int];
8042  S.AddBuiltinCandidate(&IntTy, Args, CandidateSet);
8043  }
8044 
8045  // Extension: We also add this operator for vector types.
8046  for (BuiltinCandidateTypeSet::iterator
8047  Vec = CandidateTypes[0].vector_begin(),
8048  VecEnd = CandidateTypes[0].vector_end();
8049  Vec != VecEnd; ++Vec) {
8050  QualType VecTy = *Vec;
8051  S.AddBuiltinCandidate(&VecTy, Args, CandidateSet);
8052  }
8053  }
8054 
8055  // C++ [over.match.oper]p16:
8056  // For every pointer to member type T or type std::nullptr_t, there
8057  // exist candidate operator functions of the form
8058  //
8059  // bool operator==(T,T);
8060  // bool operator!=(T,T);
8061  void addEqualEqualOrNotEqualMemberPointerOrNullptrOverloads() {
8062  /// Set of (canonical) types that we've already handled.
8063  llvm::SmallPtrSet<QualType, 8> AddedTypes;
8064 
8065  for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
8066  for (BuiltinCandidateTypeSet::iterator
8067  MemPtr = CandidateTypes[ArgIdx].member_pointer_begin(),
8068  MemPtrEnd = CandidateTypes[ArgIdx].member_pointer_end();
8069  MemPtr != MemPtrEnd;
8070  ++MemPtr) {
8071  // Don't add the same builtin candidate twice.
8072  if (!AddedTypes.insert(S.Context.getCanonicalType(*MemPtr)).second)
8073  continue;
8074 
8075  QualType ParamTypes[2] = { *MemPtr, *MemPtr };
8076  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8077  }
8078 
8079  if (CandidateTypes[ArgIdx].hasNullPtrType()) {
8081  if (AddedTypes.insert(NullPtrTy).second) {
8082  QualType ParamTypes[2] = { NullPtrTy, NullPtrTy };
8083  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8084  }
8085  }
8086  }
8087  }
8088 
8089  // C++ [over.built]p15:
8090  //
8091  // For every T, where T is an enumeration type or a pointer type,
8092  // there exist candidate operator functions of the form
8093  //
8094  // bool operator<(T, T);
8095  // bool operator>(T, T);
8096  // bool operator<=(T, T);
8097  // bool operator>=(T, T);
8098  // bool operator==(T, T);
8099  // bool operator!=(T, T);
8100  // R operator<=>(T, T)
8101  void addGenericBinaryPointerOrEnumeralOverloads() {
8102  // C++ [over.match.oper]p3:
8103  // [...]the built-in candidates include all of the candidate operator
8104  // functions defined in 13.6 that, compared to the given operator, [...]
8105  // do not have the same parameter-type-list as any non-template non-member
8106  // candidate.
8107  //
8108  // Note that in practice, this only affects enumeration types because there
8109  // aren't any built-in candidates of record type, and a user-defined operator
8110  // must have an operand of record or enumeration type. Also, the only other
8111  // overloaded operator with enumeration arguments, operator=,
8112  // cannot be overloaded for enumeration types, so this is the only place
8113  // where we must suppress candidates like this.
8115  UserDefinedBinaryOperators;
8116 
8117  for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
8118  if (CandidateTypes[ArgIdx].enumeration_begin() !=
8119  CandidateTypes[ArgIdx].enumeration_end()) {
8120  for (OverloadCandidateSet::iterator C = CandidateSet.begin(),
8121  CEnd = CandidateSet.end();
8122  C != CEnd; ++C) {
8123  if (!C->Viable || !C->Function || C->Function->getNumParams() != 2)
8124  continue;
8125 
8126  if (C->Function->isFunctionTemplateSpecialization())
8127  continue;
8128 
8129  QualType FirstParamType =
8130  C->Function->getParamDecl(0)->getType().getUnqualifiedType();
8131  QualType SecondParamType =
8132  C->Function->getParamDecl(1)->getType().getUnqualifiedType();
8133 
8134  // Skip if either parameter isn't of enumeral type.
8135  if (!FirstParamType->isEnumeralType() ||
8136  !SecondParamType->isEnumeralType())
8137  continue;
8138 
8139  // Add this operator to the set of known user-defined operators.
8140  UserDefinedBinaryOperators.insert(
8141  std::make_pair(S.Context.getCanonicalType(FirstParamType),
8142  S.Context.getCanonicalType(SecondParamType)));
8143  }
8144  }
8145  }
8146 
8147  /// Set of (canonical) types that we've already handled.
8148  llvm::SmallPtrSet<QualType, 8> AddedTypes;
8149 
8150  for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
8151  for (BuiltinCandidateTypeSet::iterator
8152  Ptr = CandidateTypes[ArgIdx].pointer_begin(),
8153  PtrEnd = CandidateTypes[ArgIdx].pointer_end();
8154  Ptr != PtrEnd; ++Ptr) {
8155  // Don't add the same builtin candidate twice.
8156  if (!AddedTypes.insert(S.Context.getCanonicalType(*Ptr)).second)
8157  continue;
8158 
8159  QualType ParamTypes[2] = { *Ptr, *Ptr };
8160  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8161  }
8162  for (BuiltinCandidateTypeSet::iterator
8163  Enum = CandidateTypes[ArgIdx].enumeration_begin(),
8164  EnumEnd = CandidateTypes[ArgIdx].enumeration_end();
8165  Enum != EnumEnd; ++Enum) {
8166  CanQualType CanonType = S.Context.getCanonicalType(*Enum);
8167 
8168  // Don't add the same builtin candidate twice, or if a user defined
8169  // candidate exists.
8170  if (!AddedTypes.insert(CanonType).second ||
8171  UserDefinedBinaryOperators.count(std::make_pair(CanonType,
8172  CanonType)))
8173  continue;
8174  QualType ParamTypes[2] = { *Enum, *Enum };
8175  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8176  }
8177  }
8178  }
8179 
8180  // C++ [over.built]p13:
8181  //
8182  // For every cv-qualified or cv-unqualified object type T
8183  // there exist candidate operator functions of the form
8184  //
8185  // T* operator+(T*, ptrdiff_t);
8186  // T& operator[](T*, ptrdiff_t); [BELOW]
8187  // T* operator-(T*, ptrdiff_t);
8188  // T* operator+(ptrdiff_t, T*);
8189  // T& operator[](ptrdiff_t, T*); [BELOW]
8190  //
8191  // C++ [over.built]p14:
8192  //
8193  // For every T, where T is a pointer to object type, there
8194  // exist candidate operator functions of the form
8195  //
8196  // ptrdiff_t operator-(T, T);
8197  void addBinaryPlusOrMinusPointerOverloads(OverloadedOperatorKind Op) {
8198  /// Set of (canonical) types that we've already handled.
8199  llvm::SmallPtrSet<QualType, 8> AddedTypes;
8200 
8201  for (int Arg = 0; Arg < 2; ++Arg) {
8202  QualType AsymmetricParamTypes[2] = {
8205  };
8206  for (BuiltinCandidateTypeSet::iterator
8207  Ptr = CandidateTypes[Arg].pointer_begin(),
8208  PtrEnd = CandidateTypes[Arg].pointer_end();
8209  Ptr != PtrEnd; ++Ptr) {
8210  QualType PointeeTy = (*Ptr)->getPointeeType();
8211  if (!PointeeTy->isObjectType())
8212  continue;
8213 
8214  AsymmetricParamTypes[Arg] = *Ptr;
8215  if (Arg == 0 || Op == OO_Plus) {
8216  // operator+(T*, ptrdiff_t) or operator-(T*, ptrdiff_t)
8217  // T* operator+(ptrdiff_t, T*);
8218  S.AddBuiltinCandidate(AsymmetricParamTypes, Args, CandidateSet);
8219  }
8220  if (Op == OO_Minus) {
8221  // ptrdiff_t operator-(T, T);
8222  if (!AddedTypes.insert(S.Context.getCanonicalType(*Ptr)).second)
8223  continue;
8224 
8225  QualType ParamTypes[2] = { *Ptr, *Ptr };
8226  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8227  }
8228  }
8229  }
8230  }
8231 
8232  // C++ [over.built]p12:
8233  //
8234  // For every pair of promoted arithmetic types L and R, there
8235  // exist candidate operator functions of the form
8236  //
8237  // LR operator*(L, R);
8238  // LR operator/(L, R);
8239  // LR operator+(L, R);
8240  // LR operator-(L, R);
8241  // bool operator<(L, R);
8242  // bool operator>(L, R);
8243  // bool operator<=(L, R);
8244  // bool operator>=(L, R);
8245  // bool operator==(L, R);
8246  // bool operator!=(L, R);
8247  //
8248  // where LR is the result of the usual arithmetic conversions
8249  // between types L and R.
8250  //
8251  // C++ [over.built]p24:
8252  //
8253  // For every pair of promoted arithmetic types L and R, there exist
8254  // candidate operator functions of the form
8255  //
8256  // LR operator?(bool, L, R);
8257  //
8258  // where LR is the result of the usual arithmetic conversions
8259  // between types L and R.
8260  // Our candidates ignore the first parameter.
8261  void addGenericBinaryArithmeticOverloads() {
8262  if (!HasArithmeticOrEnumeralCandidateType)
8263  return;
8264 
8265  for (unsigned Left = FirstPromotedArithmeticType;
8266  Left < LastPromotedArithmeticType; ++Left) {
8267  for (unsigned Right = FirstPromotedArithmeticType;
8268  Right < LastPromotedArithmeticType; ++Right) {
8269  QualType LandR[2] = { ArithmeticTypes[Left],
8270  ArithmeticTypes[Right] };
8271  S.AddBuiltinCandidate(LandR, Args, CandidateSet);
8272  }
8273  }
8274 
8275  // Extension: Add the binary operators ==, !=, <, <=, >=, >, *, /, and the
8276  // conditional operator for vector types.
8277  for (BuiltinCandidateTypeSet::iterator
8278  Vec1 = CandidateTypes[0].vector_begin(),
8279  Vec1End = CandidateTypes[0].vector_end();
8280  Vec1 != Vec1End; ++Vec1) {
8281  for (BuiltinCandidateTypeSet::iterator
8282  Vec2 = CandidateTypes[1].vector_begin(),
8283  Vec2End = CandidateTypes[1].vector_end();
8284  Vec2 != Vec2End; ++Vec2) {
8285  QualType LandR[2] = { *Vec1, *Vec2 };
8286  S.AddBuiltinCandidate(LandR, Args, CandidateSet);
8287  }
8288  }
8289  }
8290 
8291  // C++2a [over.built]p14:
8292  //
8293  // For every integral type T there exists a candidate operator function
8294  // of the form
8295  //
8296  // std::strong_ordering operator<=>(T, T)
8297  //
8298  // C++2a [over.built]p15:
8299  //
8300  // For every pair of floating-point types L and R, there exists a candidate
8301  // operator function of the form
8302  //
8303  // std::partial_ordering operator<=>(L, R);
8304  //
8305  // FIXME: The current specification for integral types doesn't play nice with
8306  // the direction of p0946r0, which allows mixed integral and unscoped-enum
8307  // comparisons. Under the current spec this can lead to ambiguity during
8308  // overload resolution. For example:
8309  //
8310  // enum A : int {a};
8311  // auto x = (a <=> (long)42);
8312  //
8313  // error: call is ambiguous for arguments 'A' and 'long'.
8314  // note: candidate operator<=>(int, int)
8315  // note: candidate operator<=>(long, long)
8316  //
8317  // To avoid this error, this function deviates from the specification and adds
8318  // the mixed overloads `operator<=>(L, R)` where L and R are promoted
8319  // arithmetic types (the same as the generic relational overloads).
8320  //
8321  // For now this function acts as a placeholder.
8322  void addThreeWayArithmeticOverloads() {
8323  addGenericBinaryArithmeticOverloads();
8324  }
8325 
8326  // C++ [over.built]p17:
8327  //
8328  // For every pair of promoted integral types L and R, there
8329  // exist candidate operator functions of the form
8330  //
8331  // LR operator%(L, R);
8332  // LR operator&(L, R);
8333  // LR operator^(L, R);
8334  // LR operator|(L, R);
8335  // L operator<<(L, R);
8336  // L operator>>(L, R);
8337  //
8338  // where LR is the result of the usual arithmetic conversions
8339  // between types L and R.
8340  void addBinaryBitwiseArithmeticOverloads(OverloadedOperatorKind Op) {
8341  if (!HasArithmeticOrEnumeralCandidateType)
8342  return;
8343 
8344  for (unsigned Left = FirstPromotedIntegralType;
8345  Left < LastPromotedIntegralType; ++Left) {
8346  for (unsigned Right = FirstPromotedIntegralType;
8347  Right < LastPromotedIntegralType; ++Right) {
8348  QualType LandR[2] = { ArithmeticTypes[Left],
8349  ArithmeticTypes[Right] };
8350  S.AddBuiltinCandidate(LandR, Args, CandidateSet);
8351  }
8352  }
8353  }
8354 
8355  // C++ [over.built]p20:
8356  //
8357  // For every pair (T, VQ), where T is an enumeration or
8358  // pointer to member type and VQ is either volatile or
8359  // empty, there exist candidate operator functions of the form
8360  //
8361  // VQ T& operator=(VQ T&, T);
8362  void addAssignmentMemberPointerOrEnumeralOverloads() {
8363  /// Set of (canonical) types that we've already handled.
8364  llvm::SmallPtrSet<QualType, 8> AddedTypes;
8365 
8366  for (unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) {
8367  for (BuiltinCandidateTypeSet::iterator
8368  Enum = CandidateTypes[ArgIdx].enumeration_begin(),
8369  EnumEnd = CandidateTypes[ArgIdx].enumeration_end();
8370  Enum != EnumEnd; ++Enum) {
8371  if (!AddedTypes.insert(S.Context.getCanonicalType(*Enum)).second)
8372  continue;
8373 
8374  AddBuiltinAssignmentOperatorCandidates(S, *Enum, Args, CandidateSet);
8375  }
8376 
8377  for (BuiltinCandidateTypeSet::iterator
8378  MemPtr = CandidateTypes[ArgIdx].member_pointer_begin(),
8379  MemPtrEnd = CandidateTypes[ArgIdx].member_pointer_end();
8380  MemPtr != MemPtrEnd; ++MemPtr) {
8381  if (!AddedTypes.insert(S.Context.getCanonicalType(*MemPtr)).second)
8382  continue;
8383 
8384  AddBuiltinAssignmentOperatorCandidates(S, *MemPtr, Args, CandidateSet);
8385  }
8386  }
8387  }
8388 
8389  // C++ [over.built]p19:
8390  //
8391  // For every pair (T, VQ), where T is any type and VQ is either
8392  // volatile or empty, there exist candidate operator functions
8393  // of the form
8394  //
8395  // T*VQ& operator=(T*VQ&, T*);
8396  //
8397  // C++ [over.built]p21:
8398  //
8399  // For every pair (T, VQ), where T is a cv-qualified or
8400  // cv-unqualified object type and VQ is either volatile or
8401  // empty, there exist candidate operator functions of the form
8402  //
8403  // T*VQ& operator+=(T*VQ&, ptrdiff_t);
8404  // T*VQ& operator-=(T*VQ&, ptrdiff_t);
8405  void addAssignmentPointerOverloads(bool isEqualOp) {
8406  /// Set of (canonical) types that we've already handled.
8407  llvm::SmallPtrSet<QualType, 8> AddedTypes;
8408 
8409  for (BuiltinCandidateTypeSet::iterator
8410  Ptr = CandidateTypes[0].pointer_begin(),
8411  PtrEnd = CandidateTypes[0].pointer_end();
8412  Ptr != PtrEnd; ++Ptr) {
8413  // If this is operator=, keep track of the builtin candidates we added.
8414  if (isEqualOp)
8415  AddedTypes.insert(S.Context.getCanonicalType(*Ptr));
8416  else if (!(*Ptr)->getPointeeType()->isObjectType())
8417  continue;
8418 
8419  // non-volatile version
8420  QualType ParamTypes[2] = {
8422  isEqualOp ? *Ptr : S.Context.getPointerDiffType(),
8423  };
8424  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8425  /*IsAssignmentOperator=*/ isEqualOp);
8426 
8427  bool NeedVolatile = !(*Ptr).isVolatileQualified() &&
8428  VisibleTypeConversionsQuals.hasVolatile();
8429  if (NeedVolatile) {
8430  // volatile version
8431  ParamTypes[0] =
8433  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8434  /*IsAssignmentOperator=*/isEqualOp);
8435  }
8436 
8437  if (!(*Ptr).isRestrictQualified() &&
8438  VisibleTypeConversionsQuals.hasRestrict()) {
8439  // restrict version
8440  ParamTypes[0]
8442  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8443  /*IsAssignmentOperator=*/isEqualOp);
8444 
8445  if (NeedVolatile) {
8446  // volatile restrict version
8447  ParamTypes[0]
8452  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8453  /*IsAssignmentOperator=*/isEqualOp);
8454  }
8455  }
8456  }
8457 
8458  if (isEqualOp) {
8459  for (BuiltinCandidateTypeSet::iterator
8460  Ptr = CandidateTypes[1].pointer_begin(),
8461  PtrEnd = CandidateTypes[1].pointer_end();
8462  Ptr != PtrEnd; ++Ptr) {
8463  // Make sure we don't add the same candidate twice.
8464  if (!AddedTypes.insert(S.Context.getCanonicalType(*Ptr)).second)
8465  continue;
8466 
8467  QualType ParamTypes[2] = {
8469  *Ptr,
8470  };
8471 
8472  // non-volatile version
8473  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8474  /*IsAssignmentOperator=*/true);
8475 
8476  bool NeedVolatile = !(*Ptr).isVolatileQualified() &&
8477  VisibleTypeConversionsQuals.hasVolatile();
8478  if (NeedVolatile) {
8479  // volatile version
8480  ParamTypes[0] =
8482  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8483  /*IsAssignmentOperator=*/true);
8484  }
8485 
8486  if (!(*Ptr).isRestrictQualified() &&
8487  VisibleTypeConversionsQuals.hasRestrict()) {
8488  // restrict version
8489  ParamTypes[0]
8491  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8492  /*IsAssignmentOperator=*/true);
8493 
8494  if (NeedVolatile) {
8495  // volatile restrict version
8496  ParamTypes[0]
8501  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8502  /*IsAssignmentOperator=*/true);
8503  }
8504  }
8505  }
8506  }
8507  }
8508 
8509  // C++ [over.built]p18:
8510  //
8511  // For every triple (L, VQ, R), where L is an arithmetic type,
8512  // VQ is either volatile or empty, and R is a promoted
8513  // arithmetic type, there exist candidate operator functions of
8514  // the form
8515  //
8516  // VQ L& operator=(VQ L&, R);
8517  // VQ L& operator*=(VQ L&, R);
8518  // VQ L& operator/=(VQ L&, R);
8519  // VQ L& operator+=(VQ L&, R);
8520  // VQ L& operator-=(VQ L&, R);
8521  void addAssignmentArithmeticOverloads(bool isEqualOp) {
8522  if (!HasArithmeticOrEnumeralCandidateType)
8523  return;
8524 
8525  for (unsigned Left = 0; Left < NumArithmeticTypes; ++Left) {
8526  for (unsigned Right = FirstPromotedArithmeticType;
8527  Right < LastPromotedArithmeticType; ++Right) {
8528  QualType ParamTypes[2];
8529  ParamTypes[1] = ArithmeticTypes[Right];
8530  auto LeftBaseTy = AdjustAddressSpaceForBuiltinOperandType(
8531  S, ArithmeticTypes[Left], Args[0]);
8532  // Add this built-in operator as a candidate (VQ is empty).
8533  ParamTypes[0] = S.Context.getLValueReferenceType(LeftBaseTy);
8534  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8535  /*IsAssignmentOperator=*/isEqualOp);
8536 
8537  // Add this built-in operator as a candidate (VQ is 'volatile').
8538  if (VisibleTypeConversionsQuals.hasVolatile()) {
8539  ParamTypes[0] = S.Context.getVolatileType(LeftBaseTy);
8540  ParamTypes[0] = S.Context.getLValueReferenceType(ParamTypes[0]);
8541  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8542  /*IsAssignmentOperator=*/isEqualOp);
8543  }
8544  }
8545  }
8546 
8547  // Extension: Add the binary operators =, +=, -=, *=, /= for vector types.
8548  for (BuiltinCandidateTypeSet::iterator
8549  Vec1 = CandidateTypes[0].vector_begin(),
8550  Vec1End = CandidateTypes[0].vector_end();
8551  Vec1 != Vec1End; ++Vec1) {
8552  for (BuiltinCandidateTypeSet::iterator
8553  Vec2 = CandidateTypes[1].vector_begin(),
8554  Vec2End = CandidateTypes[1].vector_end();
8555  Vec2 != Vec2End; ++Vec2) {
8556  QualType ParamTypes[2];
8557  ParamTypes[1] = *Vec2;
8558  // Add this built-in operator as a candidate (VQ is empty).
8559  ParamTypes[0] = S.Context.getLValueReferenceType(*Vec1);
8560  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8561  /*IsAssignmentOperator=*/isEqualOp);
8562 
8563  // Add this built-in operator as a candidate (VQ is 'volatile').
8564  if (VisibleTypeConversionsQuals.hasVolatile()) {
8565  ParamTypes[0] = S.Context.getVolatileType(*Vec1);
8566  ParamTypes[0] = S.Context.getLValueReferenceType(ParamTypes[0]);
8567  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8568  /*IsAssignmentOperator=*/isEqualOp);
8569  }
8570  }
8571  }
8572  }
8573 
8574  // C++ [over.built]p22:
8575  //
8576  // For every triple (L, VQ, R), where L is an integral type, VQ
8577  // is either volatile or empty, and R is a promoted integral
8578  // type, there exist candidate operator functions of the form
8579  //
8580  // VQ L& operator%=(VQ L&, R);
8581  // VQ L& operator<<=(VQ L&, R);
8582  // VQ L& operator>>=(VQ L&, R);
8583  // VQ L& operator&=(VQ L&, R);
8584  // VQ L& operator^=(VQ L&, R);
8585  // VQ L& operator|=(VQ L&, R);
8586  void addAssignmentIntegralOverloads() {
8587  if (!HasArithmeticOrEnumeralCandidateType)
8588  return;
8589 
8590  for (unsigned Left = FirstIntegralType; Left < LastIntegralType; ++Left) {
8591  for (unsigned Right = FirstPromotedIntegralType;
8592  Right < LastPromotedIntegralType; ++Right) {
8593  QualType ParamTypes[2];
8594  ParamTypes[1] = ArithmeticTypes[Right];
8595  auto LeftBaseTy = AdjustAddressSpaceForBuiltinOperandType(
8596  S, ArithmeticTypes[Left], Args[0]);
8597  // Add this built-in operator as a candidate (VQ is empty).
8598  ParamTypes[0] = S.Context.getLValueReferenceType(LeftBaseTy);
8599  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8600  if (VisibleTypeConversionsQuals.hasVolatile()) {
8601  // Add this built-in operator as a candidate (VQ is 'volatile').
8602  ParamTypes[0] = LeftBaseTy;
8603  ParamTypes[0] = S.Context.getVolatileType(ParamTypes[0]);
8604  ParamTypes[0] = S.Context.getLValueReferenceType(ParamTypes[0]);
8605  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8606  }
8607  }
8608  }
8609  }
8610 
8611  // C++ [over.operator]p23:
8612  //
8613  // There also exist candidate operator functions of the form
8614  //
8615  // bool operator!(bool);
8616  // bool operator&&(bool, bool);
8617  // bool operator||(bool, bool);
8618  void addExclaimOverload() {
8619  QualType ParamTy = S.Context.BoolTy;
8620  S.AddBuiltinCandidate(&ParamTy, Args, CandidateSet,
8621  /*IsAssignmentOperator=*/false,
8622  /*NumContextualBoolArguments=*/1);
8623  }
8624  void addAmpAmpOrPipePipeOverload() {
8625  QualType ParamTypes[2] = { S.Context.BoolTy, S.Context.BoolTy };
8626  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
8627  /*IsAssignmentOperator=*/false,
8628  /*NumContextualBoolArguments=*/2);
8629  }
8630 
8631  // C++ [over.built]p13:
8632  //
8633  // For every cv-qualified or cv-unqualified object type T there
8634  // exist candidate operator functions of the form
8635  //
8636  // T* operator+(T*, ptrdiff_t); [ABOVE]
8637  // T& operator[](T*, ptrdiff_t);
8638  // T* operator-(T*, ptrdiff_t); [ABOVE]
8639  // T* operator+(ptrdiff_t, T*); [ABOVE]
8640  // T& operator[](ptrdiff_t, T*);
8641  void addSubscriptOverloads() {
8642  for (BuiltinCandidateTypeSet::iterator
8643  Ptr = CandidateTypes[0].pointer_begin(),
8644  PtrEnd = CandidateTypes[0].pointer_end();
8645  Ptr != PtrEnd; ++Ptr) {
8646  QualType ParamTypes[2] = { *Ptr, S.Context.getPointerDiffType() };
8647  QualType PointeeType = (*Ptr)->getPointeeType();
8648  if (!PointeeType->isObjectType())
8649  continue;
8650 
8651  // T& operator[](T*, ptrdiff_t)
8652  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8653  }
8654 
8655  for (BuiltinCandidateTypeSet::iterator
8656  Ptr = CandidateTypes[1].pointer_begin(),
8657  PtrEnd = CandidateTypes[1].pointer_end();
8658  Ptr != PtrEnd; ++Ptr) {
8659  QualType ParamTypes[2] = { S.Context.getPointerDiffType(), *Ptr };
8660  QualType PointeeType = (*Ptr)->getPointeeType();
8661  if (!PointeeType->isObjectType())
8662  continue;
8663 
8664  // T& operator[](ptrdiff_t, T*)
8665  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8666  }
8667  }
8668 
8669  // C++ [over.built]p11:
8670  // For every quintuple (C1, C2, T, CV1, CV2), where C2 is a class type,
8671  // C1 is the same type as C2 or is a derived class of C2, T is an object
8672  // type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
8673  // there exist candidate operator functions of the form
8674  //
8675  // CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
8676  //
8677  // where CV12 is the union of CV1 and CV2.
8678  void addArrowStarOverloads() {
8679  for (BuiltinCandidateTypeSet::iterator
8680  Ptr = CandidateTypes[0].pointer_begin(),
8681  PtrEnd = CandidateTypes[0].pointer_end();
8682  Ptr != PtrEnd; ++Ptr) {
8683  QualType C1Ty = (*Ptr);
8684  QualType C1;
8685  QualifierCollector Q1;
8686  C1 = QualType(Q1.strip(C1Ty->getPointeeType()), 0);
8687  if (!isa<RecordType>(C1))
8688  continue;
8689  // heuristic to reduce number of builtin candidates in the set.
8690  // Add volatile/restrict version only if there are conversions to a
8691  // volatile/restrict type.
8692  if (!VisibleTypeConversionsQuals.hasVolatile() && Q1.hasVolatile())
8693  continue;
8694  if (!VisibleTypeConversionsQuals.hasRestrict() && Q1.hasRestrict())
8695  continue;
8696  for (BuiltinCandidateTypeSet::iterator
8697  MemPtr = CandidateTypes[1].member_pointer_begin(),
8698  MemPtrEnd = CandidateTypes[1].member_pointer_end();
8699  MemPtr != MemPtrEnd; ++MemPtr) {
8700  const MemberPointerType *mptr = cast<MemberPointerType>(*MemPtr);
8701  QualType C2 = QualType(mptr->getClass(), 0);
8702  C2 = C2.getUnqualifiedType();
8703  if (C1 != C2 && !S.IsDerivedFrom(CandidateSet.getLocation(), C1, C2))
8704  break;
8705  QualType ParamTypes[2] = { *Ptr, *MemPtr };
8706  // build CV12 T&
8707  QualType T = mptr->getPointeeType();
8708  if (!VisibleTypeConversionsQuals.hasVolatile() &&
8709  T.isVolatileQualified())
8710  continue;
8711  if (!VisibleTypeConversionsQuals.hasRestrict() &&
8712  T.isRestrictQualified())
8713  continue;
8714  T = Q1.apply(S.Context, T);
8715  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8716  }
8717  }
8718  }
8719 
8720  // Note that we don't consider the first argument, since it has been
8721  // contextually converted to bool long ago. The candidates below are
8722  // therefore added as binary.
8723  //
8724  // C++ [over.built]p25:
8725  // For every type T, where T is a pointer, pointer-to-member, or scoped
8726  // enumeration type, there exist candidate operator functions of the form
8727  //
8728  // T operator?(bool, T, T);
8729  //
8730  void addConditionalOperatorOverloads() {
8731  /// Set of (canonical) types that we've already handled.
8732  llvm::SmallPtrSet<QualType, 8> AddedTypes;
8733 
8734  for (unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) {
8735  for (BuiltinCandidateTypeSet::iterator
8736  Ptr = CandidateTypes[ArgIdx].pointer_begin(),
8737  PtrEnd = CandidateTypes[ArgIdx].pointer_end();
8738  Ptr != PtrEnd; ++Ptr) {
8739  if (!AddedTypes.insert(S.Context.getCanonicalType(*Ptr)).second)
8740  continue;
8741 
8742  QualType ParamTypes[2] = { *Ptr, *Ptr };
8743  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8744  }
8745 
8746  for (BuiltinCandidateTypeSet::iterator
8747  MemPtr = CandidateTypes[ArgIdx].member_pointer_begin(),
8748  MemPtrEnd = CandidateTypes[ArgIdx].member_pointer_end();
8749  MemPtr != MemPtrEnd; ++MemPtr) {
8750  if (!AddedTypes.insert(S.Context.getCanonicalType(*MemPtr)).second)
8751  continue;
8752 
8753  QualType ParamTypes[2] = { *MemPtr, *MemPtr };
8754  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8755  }
8756 
8757  if (S.getLangOpts().CPlusPlus11) {
8758  for (BuiltinCandidateTypeSet::iterator
8759  Enum = CandidateTypes[ArgIdx].enumeration_begin(),
8760  EnumEnd = CandidateTypes[ArgIdx].enumeration_end();
8761  Enum != EnumEnd; ++Enum) {
8762  if (!(*Enum)->getAs<EnumType>()->getDecl()->isScoped())
8763  continue;
8764 
8765  if (!AddedTypes.insert(S.Context.getCanonicalType(*Enum)).second)
8766  continue;
8767 
8768  QualType ParamTypes[2] = { *Enum, *Enum };
8769  S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
8770  }
8771  }
8772  }
8773  }
8774 };
8775 
8776 } // end anonymous namespace
8777 
8778 /// AddBuiltinOperatorCandidates - Add the appropriate built-in
8779 /// operator overloads to the candidate set (C++ [over.built]), based
8780 /// on the operator @p Op and the arguments given. For example, if the
8781 /// operator is a binary '+', this routine might add "int
8782 /// operator+(int, int)" to cover integer addition.
8784  SourceLocation OpLoc,
8785  ArrayRef<Expr *> Args,
8786  OverloadCandidateSet &CandidateSet) {
8787  // Find all of the types that the arguments can convert to, but only
8788  // if the operator we're looking at has built-in operator candidates
8789  // that make use of these types. Also record whether we encounter non-record
8790  // candidate types or either arithmetic or enumeral candidate types.
8791  Qualifiers VisibleTypeConversionsQuals;
8792  VisibleTypeConversionsQuals.addConst();
8793  for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx)
8794  VisibleTypeConversionsQuals += CollectVRQualifiers(Context, Args[ArgIdx]);
8795 
8796  bool HasNonRecordCandidateType = false;
8797  bool HasArithmeticOrEnumeralCandidateType = false;
8799  for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
8800  CandidateTypes.emplace_back(*this);
8801  CandidateTypes[ArgIdx].AddTypesConvertedFrom(Args[ArgIdx]->getType(),
8802  OpLoc,
8803  true,
8804  (Op == OO_Exclaim ||
8805  Op == OO_AmpAmp ||
8806  Op == OO_PipePipe),
8807  VisibleTypeConversionsQuals);
8808  HasNonRecordCandidateType = HasNonRecordCandidateType ||
8809  CandidateTypes[ArgIdx].hasNonRecordTypes();
8810  HasArithmeticOrEnumeralCandidateType =
8811  HasArithmeticOrEnumeralCandidateType ||
8812  CandidateTypes[ArgIdx].hasArithmeticOrEnumeralTypes();
8813  }
8814 
8815  // Exit early when no non-record types have been added to the candidate set
8816  // for any of the arguments to the operator.
8817  //
8818  // We can't exit early for !, ||, or &&, since there we have always have
8819  // 'bool' overloads.
8820  if (!HasNonRecordCandidateType &&
8821  !(Op == OO_Exclaim || Op == OO_AmpAmp || Op == OO_PipePipe))
8822  return;
8823 
8824  // Setup an object to manage the common state for building overloads.
8825  BuiltinOperatorOverloadBuilder OpBuilder(*this, Args,
8826  VisibleTypeConversionsQuals,
8827  HasArithmeticOrEnumeralCandidateType,
8828  CandidateTypes, CandidateSet);
8829 
8830  // Dispatch over the operation to add in only those overloads which apply.
8831  switch (Op) {
8832  case OO_None:
8834  llvm_unreachable("Expected an overloaded operator");
8835 
8836  case OO_New:
8837  case OO_Delete:
8838  case OO_Array_New:
8839  case OO_Array_Delete:
8840  case OO_Call:
8841  llvm_unreachable(
8842  "Special operators don't use AddBuiltinOperatorCandidates");
8843 
8844  case OO_Comma:
8845  case OO_Arrow:
8846  case OO_Coawait:
8847  // C++ [over.match.oper]p3:
8848  // -- For the operator ',', the unary operator '&', the
8849  // operator '->', or the operator 'co_await', the
8850  // built-in candidates set is empty.
8851  break;
8852 
8853  case OO_Plus: // '+' is either unary or binary
8854  if (Args.size() == 1)
8855  OpBuilder.addUnaryPlusPointerOverloads();
8856  LLVM_FALLTHROUGH;
8857 
8858  case OO_Minus: // '-' is either unary or binary
8859  if (Args.size() == 1) {
8860  OpBuilder.addUnaryPlusOrMinusArithmeticOverloads();
8861  } else {
8862  OpBuilder.addBinaryPlusOrMinusPointerOverloads(Op);
8863  OpBuilder.addGenericBinaryArithmeticOverloads();
8864  }
8865  break;
8866 
8867  case OO_Star: // '*' is either unary or binary
8868  if (Args.size() == 1)
8869  OpBuilder.addUnaryStarPointerOverloads();
8870  else
8871  OpBuilder.addGenericBinaryArithmeticOverloads();
8872  break;
8873 
8874  case OO_Slash:
8875  OpBuilder.addGenericBinaryArithmeticOverloads();
8876  break;
8877 
8878  case OO_PlusPlus:
8879  case OO_MinusMinus:
8880  OpBuilder.addPlusPlusMinusMinusArithmeticOverloads(Op);
8881  OpBuilder.addPlusPlusMinusMinusPointerOverloads();
8882  break;
8883 
8884  case OO_EqualEqual:
8885  case OO_ExclaimEqual:
8886  OpBuilder.addEqualEqualOrNotEqualMemberPointerOrNullptrOverloads();
8887  LLVM_FALLTHROUGH;
8888 
8889  case OO_Less:
8890  case OO_Greater:
8891  case OO_LessEqual:
8892  case OO_GreaterEqual:
8893  OpBuilder.addGenericBinaryPointerOrEnumeralOverloads();
8894  OpBuilder.addGenericBinaryArithmeticOverloads();
8895  break;
8896 
8897  case OO_Spaceship:
8898  OpBuilder.addGenericBinaryPointerOrEnumeralOverloads();
8899  OpBuilder.addThreeWayArithmeticOverloads();
8900  break;
8901 
8902  case OO_Percent:
8903  case OO_Caret:
8904  case OO_Pipe:
8905  case OO_LessLess:
8906  case OO_GreaterGreater:
8907  OpBuilder.addBinaryBitwiseArithmeticOverloads(Op);
8908  break;
8909 
8910  case OO_Amp: // '&' is either unary or binary
8911  if (Args.size() == 1)
8912  // C++ [over.match.oper]p3:
8913  // -- For the operator ',', the unary operator '&', or the
8914  // operator '->', the built-in candidates set is empty.
8915  break;
8916 
8917  OpBuilder.addBinaryBitwiseArithmeticOverloads(Op);
8918  break;
8919 
8920  case OO_Tilde:
8921  OpBuilder.addUnaryTildePromotedIntegralOverloads();
8922  break;
8923 
8924  case OO_Equal:
8925  OpBuilder.addAssignmentMemberPointerOrEnumeralOverloads();
8926  LLVM_FALLTHROUGH;
8927 
8928  case OO_PlusEqual:
8929  case OO_MinusEqual:
8930  OpBuilder.addAssignmentPointerOverloads(Op == OO_Equal);
8931  LLVM_FALLTHROUGH;
8932 
8933  case OO_StarEqual:
8934  case OO_SlashEqual:
8935  OpBuilder.addAssignmentArithmeticOverloads(Op == OO_Equal);
8936  break;
8937 
8938  case OO_PercentEqual:
8939  case OO_LessLessEqual:
8940  case OO_GreaterGreaterEqual:
8941  case OO_AmpEqual:
8942  case OO_CaretEqual:
8943  case OO_PipeEqual:
8944  OpBuilder.addAssignmentIntegralOverloads();
8945  break;
8946 
8947  case OO_Exclaim:
8948  OpBuilder.addExclaimOverload();
8949  break;
8950 
8951  case OO_AmpAmp:
8952  case OO_PipePipe:
8953  OpBuilder.addAmpAmpOrPipePipeOverload();
8954  break;
8955 
8956  case OO_Subscript:
8957  OpBuilder.addSubscriptOverloads();
8958  break;
8959 
8960  case OO_ArrowStar:
8961  OpBuilder.addArrowStarOverloads();
8962  break;
8963 
8964  case OO_Conditional:
8965  OpBuilder.addConditionalOperatorOverloads();
8966  OpBuilder.addGenericBinaryArithmeticOverloads();
8967  break;
8968  }
8969 }
8970 
8971 /// Add function candidates found via argument-dependent lookup
8972 /// to the set of overloading candidates.
8973 ///
8974 /// This routine performs argument-dependent name lookup based on the
8975 /// given function name (which may also be an operator name) and adds
8976 /// all of the overload candidates found by ADL to the overload
8977 /// candidate set (C++ [basic.lookup.argdep]).
8978 void
8980  SourceLocation Loc,
8981  ArrayRef<Expr *> Args,
8982  TemplateArgumentListInfo *ExplicitTemplateArgs,
8983  OverloadCandidateSet& CandidateSet,
8984  bool PartialOverloading) {
8985  ADLResult Fns;
8986 
8987  // FIXME: This approach for uniquing ADL results (and removing
8988  // redundant candidates from the set) relies on pointer-equality,
8989  // which means we need to key off the canonical decl. However,
8990  // always going back to the canonical decl might not get us the
8991  // right set of default arguments. What default arguments are
8992  // we supposed to consider on ADL candidates, anyway?
8993 
8994  // FIXME: Pass in the explicit template arguments?
8995  ArgumentDependentLookup(Name, Loc, Args, Fns);
8996 
8997  // Erase all of the candidates we already knew about.
8998  for (OverloadCandidateSet::iterator Cand = CandidateSet.begin(),
8999  CandEnd = CandidateSet.end();
9000  Cand != CandEnd; ++Cand)
9001  if (Cand->Function) {
9002  Fns.erase(Cand->Function);
9003  if (FunctionTemplateDecl *FunTmpl = Cand->Function->getPrimaryTemplate())
9004  Fns.erase(FunTmpl);
9005  }
9006 
9007  // For each of the ADL candidates we found, add it to the overload
9008  // set.
9009  for (ADLResult::iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) {
9010  DeclAccessPair FoundDecl = DeclAccessPair::make(*I, AS_none);
9011 
9012  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
9013  if (ExplicitTemplateArgs)
9014  continue;
9015 
9016  AddOverloadCandidate(FD, FoundDecl, Args, CandidateSet,
9017  /*SuppressUserConversions=*/false, PartialOverloading,
9018  /*AllowExplicit*/ true,
9019  /*AllowExplicitConversions*/ false,
9020  ADLCallKind::UsesADL);
9021  } else {
9022  AddTemplateOverloadCandidate(
9023  cast<FunctionTemplateDecl>(*I), FoundDecl, ExplicitTemplateArgs, Args,
9024  CandidateSet,
9025  /*SuppressUserConversions=*/false, PartialOverloading,
9026  /*AllowExplicit*/true, ADLCallKind::UsesADL);
9027  }
9028  }
9029 }
9030 
9031 namespace {
9032 enum class Comparison { Equal, Better, Worse };
9033 }
9034 
9035 /// Compares the enable_if attributes of two FunctionDecls, for the purposes of
9036 /// overload resolution.
9037 ///
9038 /// Cand1's set of enable_if attributes are said to be "better" than Cand2's iff
9039 /// Cand1's first N enable_if attributes have precisely the same conditions as
9040 /// Cand2's first N enable_if attributes (where N = the number of enable_if
9041 /// attributes on Cand2), and Cand1 has more than N enable_if attributes.
9042 ///
9043 /// Note that you can have a pair of candidates such that Cand1's enable_if
9044 /// attributes are worse than Cand2's, and Cand2's enable_if attributes are
9045 /// worse than Cand1's.
9046 static Comparison compareEnableIfAttrs(const Sema &S, const FunctionDecl *Cand1,
9047  const FunctionDecl *Cand2) {
9048  // Common case: One (or both) decls don't have enable_if attrs.
9049  bool Cand1Attr = Cand1->hasAttr<EnableIfAttr>();
9050  bool Cand2Attr = Cand2->hasAttr<EnableIfAttr>();
9051  if (!Cand1Attr || !Cand2Attr) {
9052  if (Cand1Attr == Cand2Attr)
9053  return Comparison::Equal;
9054  return Cand1Attr ? Comparison::Better : Comparison::Worse;
9055  }
9056 
9057  auto Cand1Attrs = Cand1->specific_attrs<EnableIfAttr>();
9058  auto Cand2Attrs = Cand2->specific_attrs<EnableIfAttr>();
9059 
9060  llvm::FoldingSetNodeID Cand1ID, Cand2ID;
9061  for (auto Pair : zip_longest(Cand1Attrs, Cand2Attrs)) {
9062  Optional<EnableIfAttr *> Cand1A = std::get<0>(Pair);
9063  Optional<EnableIfAttr *> Cand2A = std::get<1>(Pair);
9064 
9065  // It's impossible for Cand1 to be better than (or equal to) Cand2 if Cand1
9066  // has fewer enable_if attributes than Cand2, and vice versa.
9067  if (!Cand1A)
9068  return Comparison::Worse;
9069  if (!Cand2A)
9070  return Comparison::Better;
9071 
9072  Cand1ID.clear();
9073  Cand2ID.clear();
9074 
9075  (*Cand1A)->getCond()->Profile(Cand1ID, S.getASTContext(), true);
9076  (*Cand2A)->getCond()->Profile(Cand2ID, S.getASTContext(), true);
9077  if (Cand1ID != Cand2ID)
9078  return Comparison::Worse;
9079  }
9080 
9081  return Comparison::Equal;
9082 }
9083 
9085  const OverloadCandidate &Cand2) {
9086  if (!Cand1.Function || !Cand1.Function->isMultiVersion() || !Cand2.Function ||
9087  !Cand2.Function->isMultiVersion())
9088  return false;
9089 
9090  // If Cand1 is invalid, it cannot be a better match, if Cand2 is invalid, this
9091  // is obviously better.
9092  if (Cand1.Function->isInvalidDecl()) return false;
9093  if (Cand2.Function->isInvalidDecl()) return true;
9094 
9095  // If this is a cpu_dispatch/cpu_specific multiversion situation, prefer
9096  // cpu_dispatch, else arbitrarily based on the identifiers.
9097  bool Cand1CPUDisp = Cand1.Function->hasAttr<CPUDispatchAttr>();
9098  bool Cand2CPUDisp = Cand2.Function->hasAttr<CPUDispatchAttr>();
9099  const auto *Cand1CPUSpec = Cand1.Function->getAttr<CPUSpecificAttr>();
9100  const auto *Cand2CPUSpec = Cand2.Function->getAttr<CPUSpecificAttr>();
9101 
9102  if (!Cand1CPUDisp && !Cand2CPUDisp && !Cand1CPUSpec && !Cand2CPUSpec)
9103  return false;
9104 
9105  if (Cand1CPUDisp && !Cand2CPUDisp)
9106  return true;
9107  if (Cand2CPUDisp && !Cand1CPUDisp)
9108  return false;
9109 
9110  if (Cand1CPUSpec && Cand2CPUSpec) {
9111  if (Cand1CPUSpec->cpus_size() != Cand2CPUSpec->cpus_size())
9112  return Cand1CPUSpec->cpus_size() < Cand2CPUSpec->cpus_size();
9113 
9114  std::pair<CPUSpecificAttr::cpus_iterator, CPUSpecificAttr::cpus_iterator>
9115  FirstDiff = std::mismatch(
9116  Cand1CPUSpec->cpus_begin(), Cand1CPUSpec->cpus_end(),
9117  Cand2CPUSpec->cpus_begin(),
9118  [](const IdentifierInfo *LHS, const IdentifierInfo *RHS) {
9119  return LHS->getName() == RHS->getName();
9120  });
9121 
9122  assert(FirstDiff.first != Cand1CPUSpec->cpus_end() &&
9123  "Two different cpu-specific versions should not have the same "
9124  "identifier list, otherwise they'd be the same decl!");
9125  return (*FirstDiff.first)->getName() < (*FirstDiff.second)->getName();
9126  }
9127  llvm_unreachable("No way to get here unless both had cpu_dispatch");
9128 }
9129 
9130 /// isBetterOverloadCandidate - Determines whether the first overload
9131 /// candidate is a better candidate than the second (C++ 13.3.3p1).
9133  Sema &S, const OverloadCandidate &Cand1, const OverloadCandidate &Cand2,
9135  // Define viable functions to be better candidates than non-viable
9136  // functions.
9137  if (!Cand2.Viable)
9138  return Cand1.Viable;
9139  else if (!Cand1.Viable)
9140  return false;
9141 
9142  // C++ [over.match.best]p1:
9143  //
9144  // -- if F is a static member function, ICS1(F) is defined such
9145  // that ICS1(F) is neither better nor worse than ICS1(G) for
9146  // any function G, and, symmetrically, ICS1(G) is neither
9147  // better nor worse than ICS1(F).
9148  unsigned StartArg = 0;
9149  if (Cand1.IgnoreObjectArgument || Cand2.IgnoreObjectArgument)
9150  StartArg = 1;
9151 
9152  auto IsIllFormedConversion = [&](const ImplicitConversionSequence &ICS) {
9153  // We don't allow incompatible pointer conversions in C++.
9154  if (!S.getLangOpts().CPlusPlus)
9155  return ICS.isStandard() &&
9156  ICS.Standard.Second == ICK_Incompatible_Pointer_Conversion;
9157 
9158  // The only ill-formed conversion we allow in C++ is the string literal to
9159  // char* conversion, which is only considered ill-formed after C++11.
9160  return S.getLangOpts().CPlusPlus11 && !S.getLangOpts().WritableStrings &&
9162  };
9163 
9164  // Define functions that don't require ill-formed conversions for a given
9165  // argument to be better candidates than functions that do.
9166  unsigned NumArgs = Cand1.Conversions.size();
9167  assert(Cand2.Conversions.size() == NumArgs && "Overload candidate mismatch");
9168  bool HasBetterConversion = false;
9169  for (unsigned ArgIdx = StartArg; ArgIdx < NumArgs; ++ArgIdx) {
9170  bool Cand1Bad = IsIllFormedConversion(Cand1.Conversions[ArgIdx]);
9171  bool Cand2Bad = IsIllFormedConversion(Cand2.Conversions[ArgIdx]);
9172  if (Cand1Bad != Cand2Bad) {
9173  if (Cand1Bad)
9174  return false;
9175  HasBetterConversion = true;
9176  }
9177  }
9178 
9179  if (HasBetterConversion)
9180  return true;
9181 
9182  // C++ [over.match.best]p1:
9183  // A viable function F1 is defined to be a better function than another
9184  // viable function F2 if for all arguments i, ICSi(F1) is not a worse
9185  // conversion sequence than ICSi(F2), and then...
9186  for (unsigned ArgIdx = StartArg; ArgIdx < NumArgs; ++ArgIdx) {
9187  switch (CompareImplicitConversionSequences(S, Loc,
9188  Cand1.Conversions[ArgIdx],
9189  Cand2.Conversions[ArgIdx])) {
9191  // Cand1 has a better conversion sequence.
9192  HasBetterConversion = true;
9193  break;
9194 
9196  // Cand1 can't be better than Cand2.
9197  return false;
9198 
9200  // Do nothing.
9201  break;
9202  }
9203  }
9204 
9205  // -- for some argument j, ICSj(F1) is a better conversion sequence than
9206  // ICSj(F2), or, if not that,
9207  if (HasBetterConversion)
9208  return true;
9209 
9210  // -- the context is an initialization by user-defined conversion
9211  // (see 8.5, 13.3.1.5) and the standard conversion sequence
9212  // from the return type of F1 to the destination type (i.e.,
9213  // the type of the entity being initialized) is a better
9214  // conversion sequence than the standard conversion sequence
9215  // from the return type of F2 to the destination type.
9217  Cand1.Function && Cand2.Function &&
9218  isa<CXXConversionDecl>(Cand1.Function) &&
9219  isa<CXXConversionDecl>(Cand2.Function)) {
9220  // First check whether we prefer one of the conversion functions over the
9221  // other. This only distinguishes the results in non-standard, extension
9222  // cases such as the conversion from a lambda closure type to a function
9223  // pointer or block.
9225  compareConversionFunctions(S, Cand1.Function, Cand2.Function);
9227  Result = CompareStandardConversionSequences(S, Loc,
9228  Cand1.FinalConversion,
9229  Cand2.FinalConversion);
9230 
9232  return Result == ImplicitConversionSequence::Better;
9233 
9234  // FIXME: Compare kind of reference binding if conversion functions
9235  // convert to a reference type used in direct reference binding, per
9236  // C++14 [over.match.best]p1 section 2 bullet 3.
9237  }
9238 
9239  // FIXME: Work around a defect in the C++17 guaranteed copy elision wording,
9240  // as combined with the resolution to CWG issue 243.
9241  //
9242  // When the context is initialization by constructor ([over.match.ctor] or
9243  // either phase of [over.match.list]), a constructor is preferred over
9244  // a conversion function.
9245  if (Kind == OverloadCandidateSet::CSK_InitByConstructor && NumArgs == 1 &&
9246  Cand1.Function && Cand2.Function &&
9247  isa<CXXConstructorDecl>(Cand1.Function) !=
9248  isa<CXXConstructorDecl>(Cand2.Function))
9249  return isa<CXXConstructorDecl>(Cand1.Function);
9250 
9251  // -- F1 is a non-template function and F2 is a function template
9252  // specialization, or, if not that,
9253  bool Cand1IsSpecialization = Cand1.Function &&
9254  Cand1.Function->getPrimaryTemplate();
9255  bool Cand2IsSpecialization = Cand2.Function &&
9256  Cand2.Function->getPrimaryTemplate();
9257  if (Cand1IsSpecialization != Cand2IsSpecialization)
9258  return Cand2IsSpecialization;
9259 
9260  // -- F1 and F2 are function template specializations, and the function
9261  // template for F1 is more specialized than the template for F2
9262  // according to the partial ordering rules described in 14.5.5.2, or,
9263  // if not that,
9264  if (Cand1IsSpecialization && Cand2IsSpecialization) {
9265  if (FunctionTemplateDecl *BetterTemplate
9267  Cand2.Function->getPrimaryTemplate(),
9268  Loc,
9269  isa<CXXConversionDecl>(Cand1.Function)? TPOC_Conversion
9270  : TPOC_Call,
9271  Cand1.ExplicitCallArguments,
9272  Cand2.ExplicitCallArguments))
9273  return BetterTemplate == Cand1.Function->getPrimaryTemplate();
9274  }
9275 
9276  // FIXME: Work around a defect in the C++17 inheriting constructor wording.
9277  // A derived-class constructor beats an (inherited) base class constructor.
9278  bool Cand1IsInherited =
9279  dyn_cast_or_null<ConstructorUsingShadowDecl>(Cand1.FoundDecl.getDecl());
9280  bool Cand2IsInherited =
9281  dyn_cast_or_null<ConstructorUsingShadowDecl>(Cand2.FoundDecl.getDecl());
9282  if (Cand1IsInherited != Cand2IsInherited)
9283  return Cand2IsInherited;
9284  else if (Cand1IsInherited) {
9285  assert(Cand2IsInherited);
9286  auto *Cand1Class = cast<CXXRecordDecl>(Cand1.Function->getDeclContext());
9287  auto *Cand2Class = cast<CXXRecordDecl>(Cand2.Function->getDeclContext());
9288  if (Cand1Class->isDerivedFrom(Cand2Class))
9289  return true;
9290  if (Cand2Class->isDerivedFrom(Cand1Class))
9291  return false;
9292  // Inherited from sibling base classes: still ambiguous.
9293  }
9294 
9295  // Check C++17 tie-breakers for deduction guides.
9296  {
9297  auto *Guide1 = dyn_cast_or_null<CXXDeductionGuideDecl>(Cand1.Function);
9298  auto *Guide2 = dyn_cast_or_null<CXXDeductionGuideDecl>(Cand2.Function);
9299  if (Guide1 && Guide2) {
9300  // -- F1 is generated from a deduction-guide and F2 is not
9301  if (Guide1->isImplicit() != Guide2->isImplicit())
9302  return Guide2->isImplicit();
9303 
9304  // -- F1 is the copy deduction candidate(16.3.1.8) and F2 is not
9305  if (Guide1->isCopyDeductionCandidate())
9306  return true;
9307  }
9308  }
9309 
9310  // Check for enable_if value-based overload resolution.
9311  if (Cand1.Function && Cand2.Function) {
9312  Comparison Cmp = compareEnableIfAttrs(S, Cand1.Function, Cand2.Function);
9313  if (Cmp != Comparison::Equal)
9314  return Cmp == Comparison::Better;
9315  }
9316 
9317  if (S.getLangOpts().CUDA && Cand1.Function && Cand2.Function) {
9318  FunctionDecl *Caller = dyn_cast<FunctionDecl>(S.CurContext);
9319  return S.IdentifyCUDAPreference(Caller, Cand1.Function) >
9320  S.IdentifyCUDAPreference(Caller, Cand2.Function);
9321  }
9322 
9323  bool HasPS1 = Cand1.Function != nullptr &&
9325  bool HasPS2 = Cand2.Function != nullptr &&
9327  if (HasPS1 != HasPS2 && HasPS1)
9328  return true;
9329 
9330  return isBetterMultiversionCandidate(Cand1, Cand2);
9331 }
9332 
9333 /// Determine whether two declarations are "equivalent" for the purposes of
9334 /// name lookup and overload resolution. This applies when the same internal/no
9335 /// linkage entity is defined by two modules (probably by textually including
9336 /// the same header). In such a case, we don't consider the declarations to
9337 /// declare the same entity, but we also don't want lookups with both
9338 /// declarations visible to be ambiguous in some cases (this happens when using
9339 /// a modularized libstdc++).
9341  const NamedDecl *B) {
9342  auto *VA = dyn_cast_or_null<ValueDecl>(A);
9343  auto *VB = dyn_cast_or_null<ValueDecl>(B);
9344  if (!VA || !VB)
9345  return false;
9346 
9347  // The declarations must be declaring the same name as an internal linkage
9348  // entity in different modules.
9349  if (!VA->getDeclContext()->getRedeclContext()->Equals(
9350  VB->getDeclContext()->getRedeclContext()) ||
9351  getOwningModule(const_cast<ValueDecl *>(VA)) ==
9352  getOwningModule(const_cast<ValueDecl *>(VB)) ||
9353  VA->isExternallyVisible() || VB->isExternallyVisible())
9354  return false;
9355 
9356  // Check that the declarations appear to be equivalent.
9357  //
9358  // FIXME: Checking the type isn't really enough to resolve the ambiguity.
9359  // For constants and functions, we should check the initializer or body is
9360  // the same. For non-constant variables, we shouldn't allow it at all.
9361  if (Context.hasSameType(VA->getType(), VB->getType()))
9362  return true;
9363 
9364  // Enum constants within unnamed enumerations will have different types, but
9365  // may still be similar enough to be interchangeable for our purposes.
9366  if (auto *EA = dyn_cast<EnumConstantDecl>(VA)) {
9367  if (auto *EB = dyn_cast<EnumConstantDecl>(VB)) {
9368  // Only handle anonymous enums. If the enumerations were named and
9369  // equivalent, they would have been merged to the same type.
9370  auto *EnumA = cast<EnumDecl>(EA->getDeclContext());
9371  auto *EnumB = cast<EnumDecl>(EB->getDeclContext());
9372  if (EnumA->hasNameForLinkage() || EnumB->hasNameForLinkage() ||
9373  !Context.hasSameType(EnumA->getIntegerType(),
9374  EnumB->getIntegerType()))
9375  return false;
9376  // Allow this only if the value is the same for both enumerators.
9377  return llvm::APSInt::isSameValue(EA->getInitVal(), EB->getInitVal());
9378  }
9379  }
9380 
9381  // Nothing else is sufficiently similar.
9382  return false;
9383 }
9384 
9386  SourceLocation Loc, const NamedDecl *D, ArrayRef<const NamedDecl *> Equiv) {
9387  Diag(Loc, diag::ext_equivalent_internal_linkage_decl_in_modules) << D;
9388 
9389  Module *M = getOwningModule(const_cast<NamedDecl*>(D));
9390  Diag(D->getLocation(), diag::note_equivalent_internal_linkage_decl)
9391  << !M << (M ? M->getFullModuleName() : "");
9392 
9393  for (auto *E : Equiv) {
9394  Module *M = getOwningModule(const_cast<NamedDecl*>(E));
9395  Diag(E->getLocation(), diag::note_equivalent_internal_linkage_decl)
9396  << !M << (M ? M->getFullModuleName() : "");
9397  }
9398 }
9399 
9400 /// Computes the best viable function (C++ 13.3.3)
9401 /// within an overload candidate set.
9402 ///
9403 /// \param Loc The location of the function name (or operator symbol) for
9404 /// which overload resolution occurs.
9405 ///
9406 /// \param Best If overload resolution was successful or found a deleted
9407 /// function, \p Best points to the candidate function found.
9408 ///
9409 /// \returns The result of overload resolution.
9412  iterator &Best) {
9414  std::transform(begin(), end(), std::back_inserter(Candidates),
9415  [](OverloadCandidate &Cand) { return &Cand; });
9416 
9417  // [CUDA] HD->H or HD->D calls are technically not allowed by CUDA but
9418  // are accepted by both clang and NVCC. However, during a particular
9419  // compilation mode only one call variant is viable. We need to
9420  // exclude non-viable overload candidates from consideration based
9421  // only on their host/device attributes. Specifically, if one
9422  // candidate call is WrongSide and the other is SameSide, we ignore
9423  // the WrongSide candidate.
9424  if (S.getLangOpts().CUDA) {
9425  const FunctionDecl *Caller = dyn_cast<FunctionDecl>(S.CurContext);
9426  bool ContainsSameSideCandidate =
9427  llvm::any_of(Candidates, [&](OverloadCandidate *Cand) {
9428  return Cand->Function &&
9429  S.IdentifyCUDAPreference(Caller, Cand->Function) ==
9431  });
9432  if (ContainsSameSideCandidate) {
9433  auto IsWrongSideCandidate = [&](OverloadCandidate *Cand) {
9434  return Cand->Function &&
9435  S.IdentifyCUDAPreference(Caller, Cand->Function) ==
9437  };
9438  llvm::erase_if(Candidates, IsWrongSideCandidate);
9439  }
9440  }
9441 
9442  // Find the best viable function.
9443  Best = end();
9444  for (auto *Cand : Candidates)
9445  if (Cand->Viable)
9446  if (Best == end() ||
9447  isBetterOverloadCandidate(S, *Cand, *Best, Loc, Kind))
9448  Best = Cand;
9449 
9450  // If we didn't find any viable functions, abort.
9451  if (Best == end())
9452  return OR_No_Viable_Function;
9453 
9455 
9456  // Make sure that this function is better than every other viable
9457  // function. If not, we have an ambiguity.
9458  for (auto *Cand : Candidates) {
9459  if (Cand->Viable && Cand != Best &&
9460  !isBetterOverloadCandidate(S, *Best, *Cand, Loc, Kind)) {
9461  if (S.isEquivalentInternalLinkageDeclaration(Best->Function,
9462  Cand->Function)) {
9463  EquivalentCands.push_back(Cand->Function);
9464  continue;
9465  }
9466 
9467  Best = end();
9468  return OR_Ambiguous;
9469  }
9470  }
9471 
9472  // Best is the best viable function.
9473  if (Best->Function && Best->Function->isDeleted())
9474  return OR_Deleted;
9475 
9476  if (!EquivalentCands.empty())
9477  S.diagnoseEquivalentInternalLinkageDeclarations(Loc, Best->Function,
9478  EquivalentCands);
9479 
9480  return OR_Success;
9481 }
9482 
9483 namespace {
9484 
9486  oc_function,
9487  oc_method,
9488  oc_constructor,
9489  oc_implicit_default_constructor,
9490  oc_implicit_copy_constructor,
9491  oc_implicit_move_constructor,
9492  oc_implicit_copy_assignment,
9493  oc_implicit_move_assignment,
9494  oc_inherited_constructor
9495 };
9496 
9498  ocs_non_template,
9499  ocs_template,
9500  ocs_described_template,
9501 };
9502 
9503 static std::pair<OverloadCandidateKind, OverloadCandidateSelect>
9504 ClassifyOverloadCandidate(Sema &S, NamedDecl *Found, FunctionDecl *Fn,
9505  std::string &Description) {
9506 
9507  bool isTemplate = Fn->isTemplateDecl() || Found->isTemplateDecl();
9508  if (FunctionTemplateDecl *FunTmpl = Fn->getPrimaryTemplate()) {
9509  isTemplate = true;
9510  Description = S.getTemplateArgumentBindingsText(
9511  FunTmpl->getTemplateParameters(), *Fn->getTemplateSpecializationArgs());
9512  }
9513 
9514  OverloadCandidateSelect Select = [&]() {
9515  if (!Description.empty())
9516  return ocs_described_template;
9517  return isTemplate ? ocs_template : ocs_non_template;
9518  }();
9519 
9520  OverloadCandidateKind Kind = [&]() {
9521  if (CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(Fn)) {
9522  if (!Ctor->isImplicit()) {
9523  if (isa<ConstructorUsingShadowDecl>(Found))
9524  return oc_inherited_constructor;
9525  else
9526  return oc_constructor;
9527  }
9528 
9529  if (Ctor->isDefaultConstructor())
9530  return oc_implicit_default_constructor;
9531 
9532  if (Ctor->isMoveConstructor())
9533  return oc_implicit_move_constructor;
9534 
9535  assert(Ctor->isCopyConstructor() &&
9536  "unexpected sort of implicit constructor");
9537  return oc_implicit_copy_constructor;
9538  }
9539 
9540  if (CXXMethodDecl *Meth = dyn_cast<CXXMethodDecl>(Fn)) {
9541  // This actually gets spelled 'candidate function' for now, but
9542  // it doesn't hurt to split it out.
9543  if (!Meth->isImplicit())
9544  return oc_method;
9545 
9546  if (Meth->isMoveAssignmentOperator())
9547  return oc_implicit_move_assignment;
9548 
9549  if (Meth->isCopyAssignmentOperator())
9550  return oc_implicit_copy_assignment;
9551 
9552  assert(isa<CXXConversionDecl>(Meth) && "expected conversion");
9553  return oc_method;
9554  }
9555 
9556  return oc_function;
9557  }();
9558 
9559  return std::make_pair(Kind, Select);
9560 }
9561 
9562 void MaybeEmitInheritedConstructorNote(Sema &S, Decl *FoundDecl) {
9563  // FIXME: It'd be nice to only emit a note once per using-decl per overload
9564  // set.
9565  if (auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(FoundDecl))
9566  S.Diag(FoundDecl->getLocation(),
9567  diag::note_ovl_candidate_inherited_constructor)
9568  << Shadow->getNominatedBaseClass();
9569 }
9570 
9571 } // end anonymous namespace
9572 
9573 static bool isFunctionAlwaysEnabled(const ASTContext &Ctx,
9574  const FunctionDecl *FD) {
9575  for (auto *EnableIf : FD->specific_attrs<EnableIfAttr>()) {
9576  bool AlwaysTrue;
9577  if (EnableIf->getCond()->isValueDependent() ||
9578  !EnableIf->getCond()->EvaluateAsBooleanCondition(AlwaysTrue, Ctx))
9579  return false;
9580  if (!AlwaysTrue)
9581  return false;
9582  }
9583  return true;
9584 }
9585 
9586 /// Returns true if we can take the address of the function.
9587 ///
9588 /// \param Complain - If true, we'll emit a diagnostic
9589 /// \param InOverloadResolution - For the purposes of emitting a diagnostic, are
9590 /// we in overload resolution?
9591 /// \param Loc - The location of the statement we're complaining about. Ignored
9592 /// if we're not complaining, or if we're in overload resolution.
9594  bool Complain,
9595  bool InOverloadResolution,
9596  SourceLocation Loc) {
9597  if (!isFunctionAlwaysEnabled(S.Context, FD)) {
9598  if (Complain) {
9599  if (InOverloadResolution)
9600  S.Diag(FD->getBeginLoc(),
9601  diag::note_addrof_ovl_candidate_disabled_by_enable_if_attr);
9602  else
9603  S.Diag(Loc, diag::err_addrof_function_disabled_by_enable_if_attr) << FD;
9604  }
9605  return false;
9606  }
9607 
9608  auto I = llvm::find_if(FD->parameters(), [](const ParmVarDecl *P) {
9609  return P->hasAttr<PassObjectSizeAttr>();
9610  });
9611  if (I == FD->param_end())
9612  return true;
9613 
9614  if (Complain) {
9615  // Add one to ParamNo because it's user-facing
9616  unsigned ParamNo = std::distance(FD->param_begin(), I) + 1;
9617  if (InOverloadResolution)
9618  S.Diag(FD->getLocation(),
9619  diag::note_ovl_candidate_has_pass_object_size_params)
9620  << ParamNo;
9621  else
9622  S.Diag(Loc, diag::err_address_of_function_with_pass_object_size_params)
9623  << FD << ParamNo;
9624  }
9625  return false;
9626 }
9627 
9629  const FunctionDecl *FD) {
9630  return checkAddressOfFunctionIsAvailable(S, FD, /*Complain=*/true,
9631  /*InOverloadResolution=*/true,
9632  /*Loc=*/SourceLocation());
9633 }
9634 
9636  bool Complain,
9637  SourceLocation Loc) {
9638  return ::checkAddressOfFunctionIsAvailable(*this, Function, Complain,
9639  /*InOverloadResolution=*/false,
9640  Loc);
9641 }
9642 
9643 // Notes the location of an overload candidate.
9645  QualType DestType, bool TakingAddress) {
9646  if (TakingAddress && !checkAddressOfCandidateIsAvailable(*this, Fn))
9647  return;
9648  if (Fn->isMultiVersion() && Fn->hasAttr<TargetAttr>() &&
9649  !Fn->getAttr<TargetAttr>()->isDefaultVersion())
9650  return;
9651 
9652  std::string FnDesc;
9653  std::pair<OverloadCandidateKind, OverloadCandidateSelect> KSPair =
9654  ClassifyOverloadCandidate(*this, Found, Fn, FnDesc);
9655  PartialDiagnostic PD = PDiag(diag::note_ovl_candidate)
9656  << (unsigned)KSPair.first << (unsigned)KSPair.second
9657  << Fn << FnDesc;
9658 
9659  HandleFunctionTypeMismatch(PD, Fn->getType(), DestType);
9660  Diag(Fn->getLocation(), PD);
9661  MaybeEmitInheritedConstructorNote(*this, Found);
9662 }
9663 
9664 // Notes the location of all overload candidates designated through
9665 // OverloadedExpr
9666 void Sema::NoteAllOverloadCandidates(Expr *OverloadedExpr, QualType DestType,
9667  bool TakingAddress) {
9668  assert(OverloadedExpr->getType() == Context.OverloadTy);
9669 
9670  OverloadExpr::FindResult Ovl = OverloadExpr::find(OverloadedExpr);
9671  OverloadExpr *OvlExpr = Ovl.Expression;
9672 
9673  for (UnresolvedSetIterator I = OvlExpr->decls_begin(),
9674  IEnd = OvlExpr->decls_end();
9675  I != IEnd; ++I) {
9676  if (FunctionTemplateDecl *FunTmpl =
9677  dyn_cast<FunctionTemplateDecl>((*I)->getUnderlyingDecl()) ) {
9678  NoteOverloadCandidate(*I, FunTmpl->getTemplatedDecl(), DestType,
9679  TakingAddress);
9680  } else if (FunctionDecl *Fun
9681  = dyn_cast<FunctionDecl>((*I)->getUnderlyingDecl()) ) {
9682  NoteOverloadCandidate(*I, Fun, DestType, TakingAddress);
9683  }
9684  }
9685 }
9686 
9687 /// Diagnoses an ambiguous conversion. The partial diagnostic is the
9688 /// "lead" diagnostic; it will be given two arguments, the source and
9689 /// target types of the conversion.
9691  Sema &S,
9692  SourceLocation CaretLoc,
9693  const PartialDiagnostic &PDiag) const {
9694  S.Diag(CaretLoc, PDiag)
9695  << Ambiguous.getFromType() << Ambiguous.getToType();
9696  // FIXME: The note limiting machinery is borrowed from
9697  // OverloadCandidateSet::NoteCandidates; there's an opportunity for
9698  // refactoring here.
9699  const OverloadsShown ShowOverloads = S.Diags.getShowOverloads();
9700  unsigned CandsShown = 0;
9702  for (I = Ambiguous.begin(), E = Ambiguous.end(); I != E; ++I) {
9703  if (CandsShown >= 4 && ShowOverloads == Ovl_Best)
9704  break;
9705  ++CandsShown;
9706  S.NoteOverloadCandidate(I->first, I->second);
9707  }
9708  if (I != E)
9709  S.Diag(SourceLocation(), diag::note_ovl_too_many_candidates) << int(E - I);
9710 }
9711 
9713  unsigned I, bool TakingCandidateAddress) {
9714  const ImplicitConversionSequence &Conv = Cand->Conversions[I];
9715  assert(Conv.isBad());
9716  assert(Cand->Function && "for now, candidate must be a function");
9717  FunctionDecl *Fn = Cand->Function;
9718 
9719  // There's a conversion slot for the object argument if this is a
9720  // non-constructor method. Note that 'I' corresponds the
9721  // conversion-slot index.
9722  bool isObjectArgument = false;
9723  if (isa<CXXMethodDecl>(Fn) && !isa<CXXConstructorDecl>(Fn)) {
9724  if (I == 0)
9725  isObjectArgument = true;
9726  else
9727  I--;
9728  }
9729 
9730  std::string FnDesc;
9731  std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
9732  ClassifyOverloadCandidate(S, Cand->FoundDecl, Fn, FnDesc);
9733 
9734  Expr *FromExpr = Conv.Bad.FromExpr;
9735  QualType FromTy = Conv.Bad.getFromType();
9736  QualType ToTy = Conv.Bad.getToType();
9737 
9738  if (FromTy == S.Context.OverloadTy) {
9739  assert(FromExpr && "overload set argument came from implicit argument?");
9740  Expr *E = FromExpr->IgnoreParens();
9741  if (isa<UnaryOperator>(E))
9742  E = cast<UnaryOperator>(E)->getSubExpr()->IgnoreParens();
9743  DeclarationName Name = cast<OverloadExpr>(E)->getName();
9744 
9745  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_overload)
9746  << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
9747  << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) << ToTy
9748  << Name << I + 1;
9749  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9750  return;
9751  }
9752 
9753  // Do some hand-waving analysis to see if the non-viability is due
9754  // to a qualifier mismatch.
9755  CanQualType CFromTy = S.Context.getCanonicalType(FromTy);
9756  CanQualType CToTy = S.Context.getCanonicalType(ToTy);
9757  if (CanQual<ReferenceType> RT = CToTy->getAs<ReferenceType>())
9758  CToTy = RT->getPointeeType();
9759  else {
9760  // TODO: detect and diagnose the full richness of const mismatches.
9761  if (CanQual<PointerType> FromPT = CFromTy->getAs<PointerType>())
9762  if (CanQual<PointerType> ToPT = CToTy->getAs<PointerType>()) {
9763  CFromTy = FromPT->getPointeeType();
9764  CToTy = ToPT->getPointeeType();
9765  }
9766  }
9767 
9768  if (CToTy.getUnqualifiedType() == CFromTy.getUnqualifiedType() &&
9769  !CToTy.isAtLeastAsQualifiedAs(CFromTy)) {
9770  Qualifiers FromQs = CFromTy.getQualifiers();
9771  Qualifiers ToQs = CToTy.getQualifiers();
9772 
9773  if (FromQs.getAddressSpace() != ToQs.getAddressSpace()) {
9774  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_addrspace)
9775  << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
9776  << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) << FromTy
9777  << ToTy << (unsigned)isObjectArgument << I + 1;
9778  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9779  return;
9780  }
9781 
9782  if (FromQs.getObjCLifetime() != ToQs.getObjCLifetime()) {
9783  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_ownership)
9784  << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
9785  << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) << FromTy
9786  << FromQs.getObjCLifetime() << ToQs.getObjCLifetime()
9787  << (unsigned)isObjectArgument << I + 1;
9788  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9789  return;
9790  }
9791 
9792  if (FromQs.getObjCGCAttr() != ToQs.getObjCGCAttr()) {
9793  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_gc)
9794  << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
9795  << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) << FromTy
9796  << FromQs.getObjCGCAttr() << ToQs.getObjCGCAttr()
9797  << (unsigned)isObjectArgument << I + 1;
9798  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9799  return;
9800  }
9801 
9802  if (FromQs.hasUnaligned() != ToQs.hasUnaligned()) {
9803  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_unaligned)
9804  << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
9805  << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) << FromTy
9806  << FromQs.hasUnaligned() << I + 1;
9807  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9808  return;
9809  }
9810 
9811  unsigned CVR = FromQs.getCVRQualifiers() & ~ToQs.getCVRQualifiers();
9812  assert(CVR && "unexpected qualifiers mismatch");
9813 
9814  if (isObjectArgument) {
9815  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_cvr_this)
9816  << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
9817  << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) << FromTy
9818  << (CVR - 1);
9819  } else {
9820  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_cvr)
9821  << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
9822  << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) << FromTy
9823  << (CVR - 1) << I + 1;
9824  }
9825  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9826  return;
9827  }
9828 
9829  // Special diagnostic for failure to convert an initializer list, since
9830  // telling the user that it has type void is not useful.
9831  if (FromExpr && isa<InitListExpr>(FromExpr)) {
9832  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_list_argument)
9833  << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
9834  << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) << FromTy
9835  << ToTy << (unsigned)isObjectArgument << I + 1;
9836  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9837  return;
9838  }
9839 
9840  // Diagnose references or pointers to incomplete types differently,
9841  // since it's far from impossible that the incompleteness triggered
9842  // the failure.
9843  QualType TempFromTy = FromTy.getNonReferenceType();
9844  if (const PointerType *PTy = TempFromTy->getAs<PointerType>())
9845  TempFromTy = PTy->getPointeeType();
9846  if (TempFromTy->isIncompleteType()) {
9847  // Emit the generic diagnostic and, optionally, add the hints to it.
9848  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_conv_incomplete)
9849  << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
9850  << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) << FromTy
9851  << ToTy << (unsigned)isObjectArgument << I + 1
9852  << (unsigned)(Cand->Fix.Kind);
9853 
9854  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9855  return;
9856  }
9857 
9858  // Diagnose base -> derived pointer conversions.
9859  unsigned BaseToDerivedConversion = 0;
9860  if (const PointerType *FromPtrTy = FromTy->getAs<PointerType>()) {
9861  if (const PointerType *ToPtrTy = ToTy->getAs<PointerType>()) {
9862  if (ToPtrTy->getPointeeType().isAtLeastAsQualifiedAs(
9863  FromPtrTy->getPointeeType()) &&
9864  !FromPtrTy->getPointeeType()->isIncompleteType() &&
9865  !ToPtrTy->getPointeeType()->isIncompleteType() &&
9866  S.IsDerivedFrom(SourceLocation(), ToPtrTy->getPointeeType(),
9867  FromPtrTy->getPointeeType()))
9868  BaseToDerivedConversion = 1;
9869  }
9870  } else if (const ObjCObjectPointerType *FromPtrTy
9871  = FromTy->getAs<ObjCObjectPointerType>()) {
9872  if (const ObjCObjectPointerType *ToPtrTy
9873  = ToTy->getAs<ObjCObjectPointerType>())
9874  if (const ObjCInterfaceDecl *FromIface = FromPtrTy->getInterfaceDecl())
9875  if (const ObjCInterfaceDecl *ToIface = ToPtrTy->getInterfaceDecl())
9876  if (ToPtrTy->getPointeeType().isAtLeastAsQualifiedAs(
9877  FromPtrTy->getPointeeType()) &&
9878  FromIface->isSuperClassOf(ToIface))
9879  BaseToDerivedConversion = 2;
9880  } else if (const ReferenceType *ToRefTy = ToTy->getAs<ReferenceType>()) {
9881  if (ToRefTy->getPointeeType().isAtLeastAsQualifiedAs(FromTy) &&
9882  !FromTy->isIncompleteType() &&
9883  !ToRefTy->getPointeeType()->isIncompleteType() &&
9884  S.IsDerivedFrom(SourceLocation(), ToRefTy->getPointeeType(), FromTy)) {
9885  BaseToDerivedConversion = 3;
9886  } else if (ToTy->isLValueReferenceType() && !FromExpr->isLValue() &&
9889  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_lvalue)
9890  << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
9891  << (unsigned)isObjectArgument << I + 1
9892  << (FromExpr ? FromExpr->getSourceRange() : SourceRange());
9893  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9894  return;
9895  }
9896  }
9897 
9898  if (BaseToDerivedConversion) {
9899  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_base_to_derived_conv)
9900  << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
9901  << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
9902  << (BaseToDerivedConversion - 1) << FromTy << ToTy << I + 1;
9903  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9904  return;
9905  }
9906 
9907  if (isa<ObjCObjectPointerType>(CFromTy) &&
9908  isa<PointerType>(CToTy)) {
9909  Qualifiers FromQs = CFromTy.getQualifiers();
9910  Qualifiers ToQs = CToTy.getQualifiers();
9911  if (FromQs.getObjCLifetime() != ToQs.getObjCLifetime()) {
9912  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_arc_conv)
9913  << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second
9914  << FnDesc << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
9915  << FromTy << ToTy << (unsigned)isObjectArgument << I + 1;
9916  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9917  return;
9918  }
9919  }
9920 
9921  if (TakingCandidateAddress &&
9923  return;
9924 
9925  // Emit the generic diagnostic and, optionally, add the hints to it.
9926  PartialDiagnostic FDiag = S.PDiag(diag::note_ovl_candidate_bad_conv);
9927  FDiag << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
9928  << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) << FromTy
9929  << ToTy << (unsigned)isObjectArgument << I + 1
9930  << (unsigned)(Cand->Fix.Kind);
9931 
9932  // If we can fix the conversion, suggest the FixIts.
9933  for (std::vector<FixItHint>::iterator HI = Cand->Fix.Hints.begin(),
9934  HE = Cand->Fix.Hints.end(); HI != HE; ++HI)
9935  FDiag << *HI;
9936  S.Diag(Fn->getLocation(), FDiag);
9937 
9938  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
9939 }
9940 
9941 /// Additional arity mismatch diagnosis specific to a function overload
9942 /// candidates. This is not covered by the more general DiagnoseArityMismatch()
9943 /// over a candidate in any candidate set.
9945  unsigned NumArgs) {
9946  FunctionDecl *Fn = Cand->Function;
9947  unsigned MinParams = Fn->getMinRequiredArguments();
9948 
9949  // With invalid overloaded operators, it's possible that we think we
9950  // have an arity mismatch when in fact it looks like we have the
9951  // right number of arguments, because only overloaded operators have
9952  // the weird behavior of overloading member and non-member functions.
9953  // Just don't report anything.
9954  if (Fn->isInvalidDecl() &&
9956  return true;
9957 
9958  if (NumArgs < MinParams) {
9959  assert((Cand->FailureKind == ovl_fail_too_few_arguments) ||
9960  (Cand->FailureKind == ovl_fail_bad_deduction &&
9962  } else {
9963  assert((Cand->FailureKind == ovl_fail_too_many_arguments) ||
9964  (Cand->FailureKind == ovl_fail_bad_deduction &&
9966  }
9967 
9968  return false;
9969 }
9970 
9971 /// General arity mismatch diagnosis over a candidate in a candidate set.
9972 static void DiagnoseArityMismatch(Sema &S, NamedDecl *Found, Decl *D,
9973  unsigned NumFormalArgs) {
9974  assert(isa<FunctionDecl>(D) &&
9975  "The templated declaration should at least be a function"
9976  " when diagnosing bad template argument deduction due to too many"
9977  " or too few arguments");
9978 
9979  FunctionDecl *Fn = cast<FunctionDecl>(D);
9980 
9981  // TODO: treat calls to a missing default constructor as a special case
9982  const FunctionProtoType *FnTy = Fn->getType()->getAs<FunctionProtoType>();
9983  unsigned MinParams = Fn->getMinRequiredArguments();
9984 
9985  // at least / at most / exactly
9986  unsigned mode, modeCount;
9987  if (NumFormalArgs < MinParams) {
9988  if (MinParams != FnTy->getNumParams() || FnTy->isVariadic() ||
9989  FnTy->isTemplateVariadic())
9990  mode = 0; // "at least"
9991  else
9992  mode = 2; // "exactly"
9993  modeCount = MinParams;
9994  } else {
9995  if (MinParams != FnTy->getNumParams())
9996  mode = 1; // "at most"
9997  else
9998  mode = 2; // "exactly"
9999  modeCount = FnTy->getNumParams();
10000  }
10001 
10002  std::string Description;
10003  std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
10004  ClassifyOverloadCandidate(S, Found, Fn, Description);
10005 
10006  if (modeCount == 1 && Fn->getParamDecl(0)->getDeclName())
10007  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_arity_one)
10008  << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second
10009  << Description << mode << Fn->getParamDecl(0) << NumFormalArgs;
10010  else
10011  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_arity)
10012  << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second
10013  << Description << mode << modeCount << NumFormalArgs;
10014 
10015  MaybeEmitInheritedConstructorNote(S, Found);
10016 }
10017 
10018 /// Arity mismatch diagnosis specific to a function overload candidate.
10020  unsigned NumFormalArgs) {
10021  if (!CheckArityMismatch(S, Cand, NumFormalArgs))
10022  DiagnoseArityMismatch(S, Cand->FoundDecl, Cand->Function, NumFormalArgs);
10023 }
10024 
10026  if (TemplateDecl *TD = Templated->getDescribedTemplate())
10027  return TD;
10028  llvm_unreachable("Unsupported: Getting the described template declaration"
10029  " for bad deduction diagnosis");
10030 }
10031 
10032 /// Diagnose a failed template-argument deduction.
10033 static void DiagnoseBadDeduction(Sema &S, NamedDecl *Found, Decl *Templated,
10034  DeductionFailureInfo &DeductionFailure,
10035  unsigned NumArgs,
10036  bool TakingCandidateAddress) {
10037  TemplateParameter Param = DeductionFailure.getTemplateParameter();
10038  NamedDecl *ParamD;
10039  (ParamD = Param.dyn_cast<TemplateTypeParmDecl*>()) ||
10040  (ParamD = Param.dyn_cast<NonTypeTemplateParmDecl*>()) ||
10041  (ParamD = Param.dyn_cast<TemplateTemplateParmDecl*>());
10042  switch (DeductionFailure.Result) {
10043  case Sema::TDK_Success:
10044  llvm_unreachable("TDK_success while diagnosing bad deduction");
10045 
10046  case Sema::TDK_Incomplete: {
10047  assert(ParamD && "no parameter found for incomplete deduction result");
10048  S.Diag(Templated->getLocation(),
10049  diag::note_ovl_candidate_incomplete_deduction)
10050  << ParamD->getDeclName();
10051  MaybeEmitInheritedConstructorNote(S, Found);
10052  return;
10053  }
10054 
10055  case Sema::TDK_IncompletePack: {
10056  assert(ParamD && "no parameter found for incomplete deduction result");
10057  S.Diag(Templated->getLocation(),
10058  diag::note_ovl_candidate_incomplete_deduction_pack)
10059  << ParamD->getDeclName()
10060  << (DeductionFailure.getFirstArg()->pack_size() + 1)
10061  << *DeductionFailure.getFirstArg();
10062  MaybeEmitInheritedConstructorNote(S, Found);
10063  return;
10064  }
10065 
10066  case Sema::TDK_Underqualified: {
10067  assert(ParamD && "no parameter found for bad qualifiers deduction result");
10068  TemplateTypeParmDecl *TParam = cast<TemplateTypeParmDecl>(ParamD);
10069 
10070  QualType Param = DeductionFailure.getFirstArg()->getAsType();
10071 
10072  // Param will have been canonicalized, but it should just be a
10073  // qualified version of ParamD, so move the qualifiers to that.
10074  QualifierCollector Qs;
10075  Qs.strip(Param);
10076  QualType NonCanonParam = Qs.apply(S.Context, TParam->getTypeForDecl());
10077  assert(S.Context.hasSameType(Param, NonCanonParam));
10078 
10079  // Arg has also been canonicalized, but there's nothing we can do
10080  // about that. It also doesn't matter as much, because it won't
10081  // have any template parameters in it (because deduction isn't
10082  // done on dependent types).
10083  QualType Arg = DeductionFailure.getSecondArg()->getAsType();
10084 
10085  S.Diag(Templated->getLocation(), diag::note_ovl_candidate_underqualified)
10086  << ParamD->getDeclName() << Arg << NonCanonParam;
10087  MaybeEmitInheritedConstructorNote(S, Found);
10088  return;
10089  }
10090 
10091  case Sema::TDK_Inconsistent: {
10092  assert(ParamD && "no parameter found for inconsistent deduction result");
10093  int which = 0;
10094  if (isa<TemplateTypeParmDecl>(ParamD))
10095  which = 0;
10096  else if (isa<NonTypeTemplateParmDecl>(ParamD)) {
10097  // Deduction might have failed because we deduced arguments of two
10098  // different types for a non-type template parameter.
10099  // FIXME: Use a different TDK value for this.
10100  QualType T1 =
10101  DeductionFailure.getFirstArg()->getNonTypeTemplateArgumentType();
10102  QualType T2 =
10103  DeductionFailure.getSecondArg()->getNonTypeTemplateArgumentType();
10104  if (!T1.isNull() && !T2.isNull() && !S.Context.hasSameType(T1, T2)) {
10105  S.Diag(Templated->getLocation(),
10106  diag::note_ovl_candidate_inconsistent_deduction_types)
10107  << ParamD->getDeclName() << *DeductionFailure.getFirstArg() << T1
10108  << *DeductionFailure.getSecondArg() << T2;
10109  MaybeEmitInheritedConstructorNote(S, Found);
10110  return;
10111  }
10112 
10113  which = 1;
10114  } else {
10115  which = 2;
10116  }
10117 
10118  S.Diag(Templated->getLocation(),
10119  diag::note_ovl_candidate_inconsistent_deduction)
10120  << which << ParamD->getDeclName() << *DeductionFailure.getFirstArg()
10121  << *DeductionFailure.getSecondArg();
10122  MaybeEmitInheritedConstructorNote(S, Found);
10123  return;
10124  }
10125 
10127  assert(ParamD && "no parameter found for invalid explicit arguments");
10128  if (ParamD->getDeclName())
10129  S.Diag(Templated->getLocation(),
10130  diag::note_ovl_candidate_explicit_arg_mismatch_named)
10131  << ParamD->getDeclName();
10132  else {
10133  int index = 0;
10134  if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ParamD))
10135  index = TTP->getIndex();
10136  else if (NonTypeTemplateParmDecl *NTTP
10137  = dyn_cast<NonTypeTemplateParmDecl>(ParamD))
10138  index = NTTP->getIndex();
10139  else
10140  index = cast<TemplateTemplateParmDecl>(ParamD)->getIndex();
10141  S.Diag(Templated->getLocation(),
10142  diag::note_ovl_candidate_explicit_arg_mismatch_unnamed)
10143  << (index + 1);
10144  }
10145  MaybeEmitInheritedConstructorNote(S, Found);
10146  return;
10147 
10150  DiagnoseArityMismatch(S, Found, Templated, NumArgs);
10151  return;
10152 
10154  S.Diag(Templated->getLocation(),
10155  diag::note_ovl_candidate_instantiation_depth);
10156  MaybeEmitInheritedConstructorNote(S, Found);
10157  return;
10158 
10160  // Format the template argument list into the argument string.
10161  SmallString<128> TemplateArgString;
10162  if (TemplateArgumentList *Args =
10163  DeductionFailure.getTemplateArgumentList()) {
10164  TemplateArgString = " ";
10165  TemplateArgString += S.getTemplateArgumentBindingsText(
10166  getDescribedTemplate(Templated)->getTemplateParameters(), *Args);
10167  }
10168 
10169  // If this candidate was disabled by enable_if, say so.
10170  PartialDiagnosticAt *PDiag = DeductionFailure.getSFINAEDiagnostic();
10171  if (PDiag && PDiag->second.getDiagID() ==
10172  diag::err_typename_nested_not_found_enable_if) {
10173  // FIXME: Use the source range of the condition, and the fully-qualified
10174  // name of the enable_if template. These are both present in PDiag.
10175  S.Diag(PDiag->first, diag::note_ovl_candidate_disabled_by_enable_if)
10176  << "'enable_if'" << TemplateArgString;
10177  return;
10178  }
10179 
10180  // We found a specific requirement that disabled the enable_if.
10181  if (PDiag && PDiag->second.getDiagID() ==
10182  diag::err_typename_nested_not_found_requirement) {
10183  S.Diag(Templated->getLocation(),
10184  diag::note_ovl_candidate_disabled_by_requirement)
10185  << PDiag->second.getStringArg(0) << TemplateArgString;
10186  return;
10187  }
10188 
10189  // Format the SFINAE diagnostic into the argument string.
10190  // FIXME: Add a general mechanism to include a PartialDiagnostic *'s
10191  // formatted message in another diagnostic.
10192  SmallString<128> SFINAEArgString;
10193  SourceRange R;
10194  if (PDiag) {
10195  SFINAEArgString = ": ";
10196  R = SourceRange(PDiag->first, PDiag->first);
10197  PDiag->second.EmitToString(S.getDiagnostics(), SFINAEArgString);
10198  }
10199 
10200  S.Diag(Templated->getLocation(),
10201  diag::note_ovl_candidate_substitution_failure)
10202  << TemplateArgString << SFINAEArgString << R;
10203  MaybeEmitInheritedConstructorNote(S, Found);
10204  return;
10205  }
10206 
10209  // Format the template argument list into the argument string.
10210  SmallString<128> TemplateArgString;
10211  if (TemplateArgumentList *Args =
10212  DeductionFailure.getTemplateArgumentList()) {
10213  TemplateArgString = " ";
10214  TemplateArgString += S.getTemplateArgumentBindingsText(
10215  getDescribedTemplate(Templated)->getTemplateParameters(), *Args);
10216  }
10217 
10218  S.Diag(Templated->getLocation(), diag::note_ovl_candidate_deduced_mismatch)
10219  << (*DeductionFailure.getCallArgIndex() + 1)
10220  << *DeductionFailure.getFirstArg() << *DeductionFailure.getSecondArg()
10221  << TemplateArgString
10222  << (DeductionFailure.Result == Sema::TDK_DeducedMismatchNested);
10223  break;
10224  }
10225 
10227  // FIXME: Provide a source location to indicate what we couldn't match.
10228  TemplateArgument FirstTA = *DeductionFailure.getFirstArg();
10229  TemplateArgument SecondTA = *DeductionFailure.getSecondArg();
10230  if (FirstTA.getKind() == TemplateArgument::Template &&
10231  SecondTA.getKind() == TemplateArgument::Template) {
10232  TemplateName FirstTN = FirstTA.getAsTemplate();
10233  TemplateName SecondTN = SecondTA.getAsTemplate();
10234  if (FirstTN.getKind() == TemplateName::Template &&
10235  SecondTN.getKind() == TemplateName::Template) {
10236  if (FirstTN.getAsTemplateDecl()->getName() ==
10237  SecondTN.getAsTemplateDecl()->getName()) {
10238  // FIXME: This fixes a bad diagnostic where both templates are named
10239  // the same. This particular case is a bit difficult since:
10240  // 1) It is passed as a string to the diagnostic printer.
10241  // 2) The diagnostic printer only attempts to find a better
10242  // name for types, not decls.
10243  // Ideally, this should folded into the diagnostic printer.
10244  S.Diag(Templated->getLocation(),
10245  diag::note_ovl_candidate_non_deduced_mismatch_qualified)
10246  << FirstTN.getAsTemplateDecl() << SecondTN.getAsTemplateDecl();
10247  return;
10248  }
10249  }
10250  }
10251 
10252  if (TakingCandidateAddress && isa<FunctionDecl>(Templated) &&
10253  !checkAddressOfCandidateIsAvailable(S, cast<FunctionDecl>(Templated)))
10254  return;
10255 
10256  // FIXME: For generic lambda parameters, check if the function is a lambda
10257  // call operator, and if so, emit a prettier and more informative
10258  // diagnostic that mentions 'auto' and lambda in addition to
10259  // (or instead of?) the canonical template type parameters.
10260  S.Diag(Templated->getLocation(),
10261  diag::note_ovl_candidate_non_deduced_mismatch)
10262  << FirstTA << SecondTA;
10263  return;
10264  }
10265  // TODO: diagnose these individually, then kill off
10266  // note_ovl_candidate_bad_deduction, which is uselessly vague.
10268  S.Diag(Templated->getLocation(), diag::note_ovl_candidate_bad_deduction);
10269  MaybeEmitInheritedConstructorNote(S, Found);
10270  return;
10272  S.Diag(Templated->getLocation(),
10273  diag::note_cuda_ovl_candidate_target_mismatch);
10274  return;
10275  }
10276 }
10277 
10278 /// Diagnose a failed template-argument deduction, for function calls.
10280  unsigned NumArgs,
10281  bool TakingCandidateAddress) {
10282  unsigned TDK = Cand->DeductionFailure.Result;
10284  if (CheckArityMismatch(S, Cand, NumArgs))
10285  return;
10286  }
10287  DiagnoseBadDeduction(S, Cand->FoundDecl, Cand->Function, // pattern
10288  Cand->DeductionFailure, NumArgs, TakingCandidateAddress);
10289 }
10290 
10291 /// CUDA: diagnose an invalid call across targets.
10292 static void DiagnoseBadTarget(Sema &S, OverloadCandidate *Cand) {
10293  FunctionDecl *Caller = cast<FunctionDecl>(S.CurContext);
10294  FunctionDecl *Callee = Cand->Function;
10295 
10296  Sema::CUDAFunctionTarget CallerTarget = S.IdentifyCUDATarget(Caller),
10297  CalleeTarget = S.IdentifyCUDATarget(Callee);
10298 
10299  std::string FnDesc;
10300  std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
10301  ClassifyOverloadCandidate(S, Cand->FoundDecl, Callee, FnDesc);
10302 
10303  S.Diag(Callee->getLocation(), diag::note_ovl_candidate_bad_target)
10304  << (unsigned)FnKindPair.first << (unsigned)ocs_non_template
10305  << FnDesc /* Ignored */
10306  << CalleeTarget << CallerTarget;
10307 
10308  // This could be an implicit constructor for which we could not infer the
10309  // target due to a collsion. Diagnose that case.
10310  CXXMethodDecl *Meth = dyn_cast<CXXMethodDecl>(Callee);
10311  if (Meth != nullptr && Meth->isImplicit()) {
10312  CXXRecordDecl *ParentClass = Meth->getParent();
10314 
10315  switch (FnKindPair.first) {
10316  default:
10317  return;
10318  case oc_implicit_default_constructor:
10320  break;
10321  case oc_implicit_copy_constructor:
10323  break;
10324  case oc_implicit_move_constructor:
10326  break;
10327  case oc_implicit_copy_assignment:
10329  break;
10330  case oc_implicit_move_assignment:
10332  break;
10333  };
10334 
10335  bool ConstRHS = false;
10336  if (Meth->getNumParams()) {
10337  if (const ReferenceType *RT =
10338  Meth->getParamDecl(0)->getType()->getAs<ReferenceType>()) {
10339  ConstRHS = RT->getPointeeType().isConstQualified();
10340  }
10341  }
10342 
10343  S.inferCUDATargetForImplicitSpecialMember(ParentClass, CSM, Meth,
10344  /* ConstRHS */ ConstRHS,
10345  /* Diagnose */ true);
10346  }
10347 }
10348 
10350  FunctionDecl *Callee = Cand->Function;
10351  EnableIfAttr *Attr = static_cast<EnableIfAttr*>(Cand->DeductionFailure.Data);
10352 
10353  S.Diag(Callee->getLocation(),
10354  diag::note_ovl_candidate_disabled_by_function_cond_attr)
10355  << Attr->getCond()->getSourceRange() << Attr->getMessage();
10356 }
10357 
10359  ExplicitSpecifier ES;
10360  const char *DeclName;
10361  switch (Cand->Function->getDeclKind()) {
10362  case Decl::Kind::CXXConstructor:
10363  ES = cast<CXXConstructorDecl>(Cand->Function)->getExplicitSpecifier();
10364  DeclName = "constructor";
10365  break;
10366  case Decl::Kind::CXXConversion:
10367  ES = cast<CXXConversionDecl>(Cand->Function)->getExplicitSpecifier();
10368  DeclName = "conversion operator";
10369  break;
10370  case Decl::Kind::CXXDeductionGuide:
10371  ES = cast<CXXDeductionGuideDecl>(Cand->Function)->getExplicitSpecifier();
10372  DeclName = "deductiong guide";
10373  break;
10374  default:
10375  llvm_unreachable("invalid Decl");
10376  }
10377  assert(ES.getExpr() && "null expression should be handled before");
10378  S.Diag(Cand->Function->getLocation(),
10379  diag::note_ovl_candidate_explicit_forbidden)
10380  << DeclName;
10381  S.Diag(ES.getExpr()->getBeginLoc(),
10382  diag::note_explicit_bool_resolved_to_true);
10383 }
10384 
10386  FunctionDecl *Callee = Cand->Function;
10387 
10388  S.Diag(Callee->getLocation(),
10389  diag::note_ovl_candidate_disabled_by_extension)
10390  << S.getOpenCLExtensionsFromDeclExtMap(Callee);
10391 }
10392 
10393 /// Generates a 'note' diagnostic for an overload candidate. We've
10394 /// already generated a primary error at the call site.
10395 ///
10396 /// It really does need to be a single diagnostic with its caret
10397 /// pointed at the candidate declaration. Yes, this creates some
10398 /// major challenges of technical writing. Yes, this makes pointing
10399 /// out problems with specific arguments quite awkward. It's still
10400 /// better than generating twenty screens of text for every failed
10401 /// overload.
10402 ///
10403 /// It would be great to be able to express per-candidate problems
10404 /// more richly for those diagnostic clients that cared, but we'd
10405 /// still have to be just as careful with the default diagnostics.
10406 /// \param CtorDestAS Addr space of object being constructed (for ctor
10407 /// candidates only).
10409  unsigned NumArgs,
10410  bool TakingCandidateAddress,
10411  LangAS CtorDestAS = LangAS::Default) {
10412  FunctionDecl *Fn = Cand->Function;
10413 
10414  // Note deleted candidates, but only if they're viable.
10415  if (Cand->Viable) {
10416  if (Fn->isDeleted()) {
10417  std::string FnDesc;
10418  std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
10419  ClassifyOverloadCandidate(S, Cand->FoundDecl, Fn, FnDesc);
10420 
10421  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_deleted)
10422  << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
10423  << (Fn->isDeleted() ? (Fn->isDeletedAsWritten() ? 1 : 2) : 0);
10424  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
10425  return;
10426  }
10427 
10428  // We don't really have anything else to say about viable candidates.
10429  S.NoteOverloadCandidate(Cand->FoundDecl, Fn);
10430  return;
10431  }
10432 
10433  switch (Cand->FailureKind) {
10436  return DiagnoseArityMismatch(S, Cand, NumArgs);
10437 
10439  return DiagnoseBadDeduction(S, Cand, NumArgs,
10440  TakingCandidateAddress);
10441 
10443  S.Diag(Fn->getLocation(), diag::note_ovl_candidate_illegal_constructor)
10444  << (Fn->getPrimaryTemplate() ? 1 : 0);
10445  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
10446  return;
10447  }
10448 
10450  Qualifiers QualsForPrinting;
10451  QualsForPrinting.setAddressSpace(CtorDestAS);
10452  S.Diag(Fn->getLocation(),
10453  diag::note_ovl_candidate_illegal_constructor_adrspace_mismatch)
10454  << QualsForPrinting;
10455  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
10456  return;
10457  }
10458 
10462  return S.NoteOverloadCandidate(Cand->FoundDecl, Fn);
10463 
10464  case ovl_fail_bad_conversion: {
10465  unsigned I = (Cand->IgnoreObjectArgument ? 1 : 0);
10466  for (unsigned N = Cand->Conversions.size(); I != N; ++I)
10467  if (Cand->Conversions[I].isBad())
10468  return DiagnoseBadConversion(S, Cand, I, TakingCandidateAddress);
10469 
10470  // FIXME: this currently happens when we're called from SemaInit
10471  // when user-conversion overload fails. Figure out how to handle
10472  // those conditions and diagnose them well.
10473  return S.NoteOverloadCandidate(Cand->FoundDecl, Fn);
10474  }
10475 
10476  case ovl_fail_bad_target:
10477  return DiagnoseBadTarget(S, Cand);
10478 
10479  case ovl_fail_enable_if:
10480  return DiagnoseFailedEnableIfAttr(S, Cand);
10481 
10483  return DiagnoseFailedExplicitSpec(S, Cand);
10484 
10485  case ovl_fail_ext_disabled:
10486  return DiagnoseOpenCLExtensionDisabled(S, Cand);
10487 
10489  // It's generally not interesting to note copy/move constructors here.
10490  if (cast<CXXConstructorDecl>(Fn)->isCopyOrMoveConstructor())
10491  return;
10492  S.Diag(Fn->getLocation(),
10493  diag::note_ovl_candidate_inherited_constructor_slice)
10494  << (Fn->getPrimaryTemplate() ? 1 : 0)
10495  << Fn->getParamDecl(0)->getType()->isRValueReferenceType();
10496  MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
10497  return;
10498 
10500  bool Available = checkAddressOfCandidateIsAvailable(S, Cand->Function);
10501  (void)Available;
10502  assert(!Available);
10503  break;
10504  }
10506  // Do nothing, these should simply be ignored.
10507  break;
10508  }
10509 }
10510 
10512  // Desugar the type of the surrogate down to a function type,
10513  // retaining as many typedefs as possible while still showing
10514  // the function type (and, therefore, its parameter types).
10515  QualType FnType = Cand->Surrogate->getConversionType();
10516  bool isLValueReference = false;
10517  bool isRValueReference = false;
10518  bool isPointer = false;
10519  if (const LValueReferenceType *FnTypeRef =
10520  FnType->getAs<LValueReferenceType>()) {
10521  FnType = FnTypeRef->getPointeeType();
10522  isLValueReference = true;
10523  } else if (const RValueReferenceType *FnTypeRef =
10524  FnType->getAs<RValueReferenceType>()) {
10525  FnType = FnTypeRef->getPointeeType();
10526  isRValueReference = true;
10527  }
10528  if (const PointerType *FnTypePtr = FnType->getAs<PointerType>()) {
10529  FnType = FnTypePtr->getPointeeType();
10530  isPointer = true;
10531  }
10532  // Desugar down to a function type.
10533  FnType = QualType(FnType->getAs<FunctionType>(), 0);
10534  // Reconstruct the pointer/reference as appropriate.
10535  if (isPointer) FnType = S.Context.getPointerType(FnType);
10536  if (isRValueReference) FnType = S.Context.getRValueReferenceType(FnType);
10537  if (isLValueReference) FnType = S.Context.getLValueReferenceType(FnType);
10538 
10539  S.Diag(Cand->Surrogate->getLocation(), diag::note_ovl_surrogate_cand)
10540  << FnType;
10541 }
10542 
10543 static void NoteBuiltinOperatorCandidate(Sema &S, StringRef Opc,
10544  SourceLocation OpLoc,
10545  OverloadCandidate *Cand) {
10546  assert(Cand->Conversions.size() <= 2 && "builtin operator is not binary");
10547  std::string TypeStr("operator");
10548  TypeStr += Opc;
10549  TypeStr += "(";
10550  TypeStr += Cand->BuiltinParamTypes[0].getAsString();
10551  if (Cand->Conversions.size() == 1) {
10552  TypeStr += ")";
10553  S.Diag(OpLoc, diag::note_ovl_builtin_unary_candidate) << TypeStr;
10554  } else {
10555  TypeStr += ", ";
10556  TypeStr += Cand->BuiltinParamTypes[1].getAsString();
10557  TypeStr += ")";
10558  S.Diag(OpLoc, diag::note_ovl_builtin_binary_candidate) << TypeStr;
10559  }
10560 }
10561 
10563  OverloadCandidate *Cand) {
10564  for (const ImplicitConversionSequence &ICS : Cand->Conversions) {
10565  if (ICS.isBad()) break; // all meaningless after first invalid
10566  if (!ICS.isAmbiguous()) continue;
10567 
10569  S, OpLoc, S.PDiag(diag::note_ambiguous_type_conversion));
10570  }
10571 }
10572 
10574  if (Cand->Function)
10575  return Cand->Function->getLocation();
10576  if (Cand->IsSurrogate)
10577  return Cand->Surrogate->getLocation();
10578  return SourceLocation();
10579 }
10580 
10581 static unsigned RankDeductionFailure(const DeductionFailureInfo &DFI) {
10582  switch ((Sema::TemplateDeductionResult)DFI.Result) {
10583  case Sema::TDK_Success:
10585  llvm_unreachable("non-deduction failure while diagnosing bad deduction");
10586 
10587  case Sema::TDK_Invalid:
10588  case Sema::TDK_Incomplete:
10590  return 1;
10591 
10594  return 2;
10595 
10602  return 3;
10603 
10605  return 4;
10606 
10608  return 5;
10609 
10612  return 6;
10613  }
10614  llvm_unreachable("Unhandled deduction result");
10615 }
10616 
10617 namespace {
10618 struct CompareOverloadCandidatesForDisplay {
10619  Sema &S;
10620  SourceLocation Loc;
10621  size_t NumArgs;
10623 
10624  CompareOverloadCandidatesForDisplay(
10625  Sema &S, SourceLocation Loc, size_t NArgs,
10627  : S(S), NumArgs(NArgs), CSK(CSK) {}
10628 
10629  bool operator()(const OverloadCandidate *L,
10630  const OverloadCandidate *R) {
10631  // Fast-path this check.
10632  if (L == R) return false;
10633 
10634  // Order first by viability.
10635  if (L->Viable) {
10636  if (!R->Viable) return true;
10637 
10638  // TODO: introduce a tri-valued comparison for overload
10639  // candidates. Would be more worthwhile if we had a sort
10640  // that could exploit it.
10641  if (isBetterOverloadCandidate(S, *L, *R, SourceLocation(), CSK))
10642  return true;
10643  if (isBetterOverloadCandidate(S, *R, *L, SourceLocation(), CSK))
10644  return false;
10645  } else if (R->Viable)
10646  return false;
10647 
10648  assert(L->Viable == R->Viable);
10649 
10650  // Criteria by which we can sort non-viable candidates:
10651  if (!L->Viable) {
10652  // 1. Arity mismatches come after other candidates.
10657  int LDist = std::abs((int)L->getNumParams() - (int)NumArgs);
10658  int RDist = std::abs((int)R->getNumParams() - (int)NumArgs);
10659  if (LDist == RDist) {
10660  if (L->FailureKind == R->FailureKind)
10661  // Sort non-surrogates before surrogates.
10662  return !L->IsSurrogate && R->IsSurrogate;
10663  // Sort candidates requiring fewer parameters than there were
10664  // arguments given after candidates requiring more parameters
10665  // than there were arguments given.
10667  }
10668  return LDist < RDist;
10669  }
10670  return false;
10671  }
10674  return true;
10675 
10676  // 2. Bad conversions come first and are ordered by the number
10677  // of bad conversions and quality of good conversions.
10680  return true;
10681 
10682  // The conversion that can be fixed with a smaller number of changes,
10683  // comes first.
10684  unsigned numLFixes = L->Fix.NumConversionsFixed;
10685  unsigned numRFixes = R->Fix.NumConversionsFixed;
10686  numLFixes = (numLFixes == 0) ? UINT_MAX : numLFixes;
10687  numRFixes = (numRFixes == 0) ? UINT_MAX : numRFixes;
10688  if (numLFixes != numRFixes) {
10689  return numLFixes < numRFixes;
10690  }
10691 
10692  // If there's any ordering between the defined conversions...
10693  // FIXME: this might not be transitive.
10694  assert(L->Conversions.size() == R->Conversions.size());
10695 
10696  int leftBetter = 0;
10697  unsigned I = (L->IgnoreObjectArgument || R->IgnoreObjectArgument);
10698  for (unsigned E = L->Conversions.size(); I != E; ++I) {
10699  switch (CompareImplicitConversionSequences(S, Loc,
10700  L->Conversions[I],
10701  R->Conversions[I])) {
10703  leftBetter++;
10704  break;
10705 
10707  leftBetter--;
10708  break;
10709 
10711  break;
10712  }
10713  }
10714  if (leftBetter > 0) return true;
10715  if (leftBetter < 0) return false;
10716 
10717  } else if (R->FailureKind == ovl_fail_bad_conversion)
10718  return false;
10719 
10720  if (L->FailureKind == ovl_fail_bad_deduction) {
10722  return true;
10723 
10727  } else if (R->FailureKind == ovl_fail_bad_deduction)
10728  return false;
10729 
10730  // TODO: others?
10731  }
10732 
10733  // Sort everything else by location.
10736 
10737  // Put candidates without locations (e.g. builtins) at the end.
10738  if (LLoc.isInvalid()) return false;
10739  if (RLoc.isInvalid()) return true;
10740 
10741  return S.SourceMgr.isBeforeInTranslationUnit(LLoc, RLoc);
10742  }
10743 };
10744 }
10745 
10746 /// CompleteNonViableCandidate - Normally, overload resolution only
10747 /// computes up to the first bad conversion. Produces the FixIt set if
10748 /// possible.
10750  ArrayRef<Expr *> Args) {
10751  assert(!Cand->Viable);
10752 
10753  // Don't do anything on failures other than bad conversion.
10754  if (Cand->FailureKind != ovl_fail_bad_conversion) return;
10755 
10756  // We only want the FixIts if all the arguments can be corrected.
10757  bool Unfixable = false;
10758  // Use a implicit copy initialization to check conversion fixes.
10760 
10761  // Attempt to fix the bad conversion.
10762  unsigned ConvCount = Cand->Conversions.size();
10763  for (unsigned ConvIdx = (Cand->IgnoreObjectArgument ? 1 : 0); /**/;
10764  ++ConvIdx) {
10765  assert(ConvIdx != ConvCount && "no bad conversion in candidate");
10766  if (Cand->Conversions[ConvIdx].isInitialized() &&
10767  Cand->Conversions[ConvIdx].isBad()) {
10768  Unfixable = !Cand->TryToFixBadConversion(ConvIdx, S);
10769  break;
10770  }
10771  }
10772 
10773  // FIXME: this should probably be preserved from the overload
10774  // operation somehow.
10775  bool SuppressUserConversions = false;
10776 
10777  unsigned ConvIdx = 0;
10778  ArrayRef<QualType> ParamTypes;
10779 
10780  if (Cand->IsSurrogate) {
10781  QualType ConvType
10783  if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>())
10784  ConvType = ConvPtrType->getPointeeType();
10785  ParamTypes = ConvType->getAs<FunctionProtoType>()->getParamTypes();
10786  // Conversion 0 is 'this', which doesn't have a corresponding argument.
10787  ConvIdx = 1;
10788  } else if (Cand->Function) {
10789  ParamTypes =
10790  Cand->Function->getType()->getAs<FunctionProtoType>()->getParamTypes();
10791  if (isa<CXXMethodDecl>(Cand->Function) &&
10792  !isa<CXXConstructorDecl>(Cand->Function)) {
10793  // Conversion 0 is 'this', which doesn't have a corresponding argument.
10794  ConvIdx = 1;
10795  }
10796  } else {
10797  // Builtin operator.
10798  assert(ConvCount <= 3);
10799  ParamTypes = Cand->BuiltinParamTypes;
10800  }
10801 
10802  // Fill in the rest of the conversions.
10803  for (unsigned ArgIdx = 0; ConvIdx != ConvCount; ++ConvIdx, ++ArgIdx) {
10804  if (Cand->Conversions[ConvIdx].isInitialized()) {
10805  // We've already checked this conversion.
10806  } else if (ArgIdx < ParamTypes.size()) {
10807  if (ParamTypes[ArgIdx]->isDependentType())
10808  Cand->Conversions[ConvIdx].setAsIdentityConversion(
10809  Args[ArgIdx]->getType());
10810  else {
10811  Cand->Conversions[ConvIdx] =
10812  TryCopyInitialization(S, Args[ArgIdx], ParamTypes[ArgIdx],
10813  SuppressUserConversions,
10814  /*InOverloadResolution=*/true,
10815  /*AllowObjCWritebackConversion=*/
10816  S.getLangOpts().ObjCAutoRefCount);
10817  // Store the FixIt in the candidate if it exists.
10818  if (!Unfixable && Cand->Conversions[ConvIdx].isBad())
10819  Unfixable = !Cand->TryToFixBadConversion(ConvIdx, S);
10820  }
10821  } else
10822  Cand->Conversions[ConvIdx].setEllipsis();
10823  }
10824 }
10825 
10828  SourceLocation OpLoc,
10829  llvm::function_ref<bool(OverloadCandidate &)> Filter) {
10830  // Sort the candidates by viability and position. Sorting directly would
10831  // be prohibitive, so we make a set of pointers and sort those.
10833  if (OCD == OCD_AllCandidates) Cands.reserve(size());
10834  for (iterator Cand = begin(), LastCand = end(); Cand != LastCand; ++Cand) {
10835  if (!Filter(*Cand))
10836  continue;
10837  if (Cand->Viable)
10838  Cands.push_back(Cand);
10839  else if (OCD == OCD_AllCandidates) {
10840  CompleteNonViableCandidate(S, Cand, Args);
10841  if (Cand->Function || Cand->IsSurrogate)
10842  Cands.push_back(Cand);
10843  // Otherwise, this a non-viable builtin candidate. We do not, in general,
10844  // want to list every possible builtin candidate.
10845  }
10846  }
10847 
10848  llvm::stable_sort(
10849  Cands, CompareOverloadCandidatesForDisplay(S, OpLoc, Args.size(), Kind));
10850 
10851  return Cands;
10852 }
10853 
10854 /// When overload resolution fails, prints diagnostic messages containing the
10855 /// candidates in the candidate set.
10858  StringRef Opc, SourceLocation OpLoc,
10859  llvm::function_ref<bool(OverloadCandidate &)> Filter) {
10860 
10861  auto Cands = CompleteCandidates(S, OCD, Args, OpLoc, Filter);
10862 
10863  S.Diag(PD.first, PD.second);
10864 
10865  NoteCandidates(S, Args, Cands, Opc, OpLoc);
10866 }
10867 
10870  StringRef Opc, SourceLocation OpLoc) {
10871  bool ReportedAmbiguousConversions = false;
10872 
10873  const OverloadsShown ShowOverloads = S.Diags.getShowOverloads();
10874  unsigned CandsShown = 0;
10875  auto I = Cands.begin(), E = Cands.end();
10876  for (; I != E; ++I) {
10877  OverloadCandidate *Cand = *I;
10878 
10879  // Set an arbitrary limit on the number of candidate functions we'll spam
10880  // the user with. FIXME: This limit should depend on details of the
10881  // candidate list.
10882  if (CandsShown >= 4 && ShowOverloads == Ovl_Best) {
10883  break;
10884  }
10885  ++CandsShown;
10886 
10887  if (Cand->Function)
10888  NoteFunctionCandidate(S, Cand, Args.size(),
10889  /*TakingCandidateAddress=*/false, DestAS);
10890  else if (Cand->IsSurrogate)
10891  NoteSurrogateCandidate(S, Cand);
10892  else {
10893  assert(Cand->Viable &&
10894  "Non-viable built-in candidates are not added to Cands.");
10895  // Generally we only see ambiguities including viable builtin
10896  // operators if overload resolution got screwed up by an
10897  // ambiguous user-defined conversion.
10898  //
10899  // FIXME: It's quite possible for different conversions to see
10900  // different ambiguities, though.
10901  if (!ReportedAmbiguousConversions) {
10902  NoteAmbiguousUserConversions(S, OpLoc, Cand);
10903  ReportedAmbiguousConversions = true;
10904  }
10905 
10906  // If this is a viable builtin, print it.
10907  NoteBuiltinOperatorCandidate(S, Opc, OpLoc, Cand);
10908  }
10909  }
10910 
10911  if (I != E)
10912  S.Diag(OpLoc, diag::note_ovl_too_many_candidates) << int(E - I);
10913 }
10914 
10915 static SourceLocation
10917  return Cand->Specialization ? Cand->Specialization->getLocation()
10918  : SourceLocation();
10919 }
10920 
10921 namespace {
10922 struct CompareTemplateSpecCandidatesForDisplay {
10923  Sema &S;
10924  CompareTemplateSpecCandidatesForDisplay(Sema &S) : S(S) {}
10925 
10926  bool operator()(const TemplateSpecCandidate *L,
10927  const TemplateSpecCandidate *R) {
10928  // Fast-path this check.
10929  if (L == R)
10930  return false;
10931 
10932  // Assuming that both candidates are not matches...
10933 
10934  // Sort by the ranking of deduction failures.
10938 
10939  // Sort everything else by location.
10942 
10943  // Put candidates without locations (e.g. builtins) at the end.
10944  if (LLoc.isInvalid())
10945  return false;
10946  if (RLoc.isInvalid())
10947  return true;
10948 
10949  return S.SourceMgr.isBeforeInTranslationUnit(LLoc, RLoc);
10950  }
10951 };
10952 }
10953 
10954 /// Diagnose a template argument deduction failure.
10955 /// We are treating these failures as overload failures due to bad
10956 /// deductions.
10958  bool ForTakingAddress) {
10959  DiagnoseBadDeduction(S, FoundDecl, Specialization, // pattern
10960  DeductionFailure, /*NumArgs=*/0, ForTakingAddress);
10961 }
10962 
10963 void TemplateSpecCandidateSet::destroyCandidates() {
10964  for (iterator i = begin(), e = end(); i != e; ++i) {
10965  i->DeductionFailure.Destroy();
10966  }
10967 }
10968 
10970  destroyCandidates();
10971  Candidates.clear();
10972 }
10973 
10974 /// NoteCandidates - When no template specialization match is found, prints
10975 /// diagnostic messages containing the non-matching specializations that form
10976 /// the candidate set.
10977 /// This is analoguous to OverloadCandidateSet::NoteCandidates() with
10978 /// OCD == OCD_AllCandidates and Cand->Viable == false.
10980  // Sort the candidates by position (assuming no candidate is a match).
10981  // Sorting directly would be prohibitive, so we make a set of pointers
10982  // and sort those.
10984  Cands.reserve(size());
10985  for (iterator Cand = begin(), LastCand = end(); Cand != LastCand; ++Cand) {
10986  if (Cand->Specialization)
10987  Cands.push_back(Cand);
10988  // Otherwise, this is a non-matching builtin candidate. We do not,
10989  // in general, want to list every possible builtin candidate.
10990  }
10991 
10992  llvm::sort(Cands, CompareTemplateSpecCandidatesForDisplay(S));
10993 
10994  // FIXME: Perhaps rename OverloadsShown and getShowOverloads()
10995  // for generalization purposes (?).
10996  const OverloadsShown ShowOverloads = S.Diags.getShowOverloads();
10997 
10999  unsigned CandsShown = 0;
11000  for (I = Cands.begin(), E = Cands.end(); I != E; ++I) {
11001  TemplateSpecCandidate *Cand = *I;
11002 
11003  // Set an arbitrary limit on the number of candidates we'll spam
11004  // the user with. FIXME: This limit should depend on details of the
11005  // candidate list.
11006  if (CandsShown >= 4 && ShowOverloads == Ovl_Best)
11007  break;
11008  ++CandsShown;
11009 
11010  assert(Cand->Specialization &&
11011  "Non-matching built-in candidates are not added to Cands.");
11012  Cand->NoteDeductionFailure(S, ForTakingAddress);
11013  }
11014 
11015  if (I != E)
11016  S.Diag(Loc, diag::note_ovl_too_many_candidates) << int(E - I);
11017 }
11018 
11019 // [PossiblyAFunctionType] --> [Return]
11020 // NonFunctionType --> NonFunctionType
11021 // R (A) --> R(A)
11022 // R (*)(A) --> R (A)
11023 // R (&)(A) --> R (A)
11024 // R (S::*)(A) --> R (A)
11026  QualType Ret = PossiblyAFunctionType;
11027  if (const PointerType *ToTypePtr =
11028  PossiblyAFunctionType->getAs<PointerType>())
11029  Ret = ToTypePtr->getPointeeType();
11030  else if (const ReferenceType *ToTypeRef =
11031  PossiblyAFunctionType->getAs<ReferenceType>())
11032  Ret = ToTypeRef->getPointeeType();
11033  else if (const MemberPointerType *MemTypePtr =
11034  PossiblyAFunctionType->getAs<MemberPointerType>())
11035  Ret = MemTypePtr->getPointeeType();
11036  Ret =
11037  Context.getCanonicalType(Ret).getUnqualifiedType();
11038  return Ret;
11039 }
11040 
11042  bool Complain = true) {
11043  if (S.getLangOpts().CPlusPlus14 && FD->getReturnType()->isUndeducedType() &&
11044  S.DeduceReturnType(FD, Loc, Complain))
11045  return true;
11046 
11047  auto *FPT = FD->getType()->castAs<FunctionProtoType>();
11048  if (S.getLangOpts().CPlusPlus17 &&
11049  isUnresolvedExceptionSpec(FPT->getExceptionSpecType()) &&
11050  !S.ResolveExceptionSpec(Loc, FPT))
11051  return true;
11052 
11053  return false;
11054 }
11055 
11056 namespace {
11057 // A helper class to help with address of function resolution
11058 // - allows us to avoid passing around all those ugly parameters
11059 class AddressOfFunctionResolver {
11060  Sema& S;
11061  Expr* SourceExpr;
11062  const QualType& TargetType;
11063  QualType TargetFunctionType; // Extracted function type from target type
11064 
11065  bool Complain;
11066  //DeclAccessPair& ResultFunctionAccessPair;
11067  ASTContext& Context;
11068 
11069  bool TargetTypeIsNonStaticMemberFunction;
11070  bool FoundNonTemplateFunction;
11071  bool StaticMemberFunctionFromBoundPointer;
11072  bool HasComplained;
11073 
11074  OverloadExpr::FindResult OvlExprInfo;
11075  OverloadExpr *OvlExpr;
11076  TemplateArgumentListInfo OvlExplicitTemplateArgs;
11078  TemplateSpecCandidateSet FailedCandidates;
11079 
11080 public:
11081  AddressOfFunctionResolver(Sema &S, Expr *SourceExpr,
11082  const QualType &TargetType, bool Complain)
11083  : S(S), SourceExpr(SourceExpr), TargetType(TargetType),
11084  Complain(Complain), Context(S.getASTContext()),
11085  TargetTypeIsNonStaticMemberFunction(
11086  !!TargetType->getAs<MemberPointerType>()),
11087  FoundNonTemplateFunction(false),
11088  StaticMemberFunctionFromBoundPointer(false),
11089  HasComplained(false),
11090  OvlExprInfo(OverloadExpr::find(SourceExpr)),
11091  OvlExpr(OvlExprInfo.Expression),
11092  FailedCandidates(OvlExpr->getNameLoc(), /*ForTakingAddress=*/true) {
11093  ExtractUnqualifiedFunctionTypeFromTargetType();
11094 
11095  if (TargetFunctionType->isFunctionType()) {
11096  if (UnresolvedMemberExpr *UME = dyn_cast<UnresolvedMemberExpr>(OvlExpr))
11097  if (!UME->isImplicitAccess() &&
11099  StaticMemberFunctionFromBoundPointer = true;
11100  } else if (OvlExpr->hasExplicitTemplateArgs()) {
11101  DeclAccessPair dap;
11103  OvlExpr, false, &dap)) {
11104  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn))
11105  if (!Method->isStatic()) {
11106  // If the target type is a non-function type and the function found
11107  // is a non-static member function, pretend as if that was the
11108  // target, it's the only possible type to end up with.
11109  TargetTypeIsNonStaticMemberFunction = true;
11110 
11111  // And skip adding the function if its not in the proper form.
11112  // We'll diagnose this due to an empty set of functions.
11113  if (!OvlExprInfo.HasFormOfMemberPointer)
11114  return;
11115  }
11116 
11117  Matches.push_back(std::make_pair(dap, Fn));
11118  }
11119  return;
11120  }
11121 
11122  if (OvlExpr->hasExplicitTemplateArgs())
11123  OvlExpr->copyTemplateArgumentsInto(OvlExplicitTemplateArgs);
11124 
11125  if (FindAllFunctionsThatMatchTargetTypeExactly()) {
11126  // C++ [over.over]p4:
11127  // If more than one function is selected, [...]
11128  if (Matches.size() > 1 && !eliminiateSuboptimalOverloadCandidates()) {
11129  if (FoundNonTemplateFunction)
11130  EliminateAllTemplateMatches();
11131  else
11132  EliminateAllExceptMostSpecializedTemplate();
11133  }
11134  }
11135 
11136  if (S.getLangOpts().CUDA && Matches.size() > 1)
11137  EliminateSuboptimalCudaMatches();
11138  }
11139 
11140  bool hasComplained() const { return HasComplained; }
11141 
11142 private:
11143  bool candidateHasExactlyCorrectType(const FunctionDecl *FD) {
11144  QualType Discard;
11145  return Context.hasSameUnqualifiedType(TargetFunctionType, FD->getType()) ||
11146  S.IsFunctionConversion(FD->getType(), TargetFunctionType, Discard);
11147  }
11148 
11149  /// \return true if A is considered a better overload candidate for the
11150  /// desired type than B.
11151  bool isBetterCandidate(const FunctionDecl *A, const FunctionDecl *B) {
11152  // If A doesn't have exactly the correct type, we don't want to classify it
11153  // as "better" than anything else. This way, the user is required to
11154  // disambiguate for us if there are multiple candidates and no exact match.
11155  return candidateHasExactlyCorrectType(A) &&
11156  (!candidateHasExactlyCorrectType(B) ||
11157  compareEnableIfAttrs(S, A, B) == Comparison::Better);
11158  }
11159 
11160  /// \return true if we were able to eliminate all but one overload candidate,
11161  /// false otherwise.
11162  bool eliminiateSuboptimalOverloadCandidates() {
11163  // Same algorithm as overload resolution -- one pass to pick the "best",
11164  // another pass to be sure that nothing is better than the best.
11165  auto Best = Matches.begin();
11166  for (auto I = Matches.begin()+1, E = Matches.end(); I != E; ++I)
11167  if (isBetterCandidate(I->second, Best->second))
11168  Best = I;
11169 
11170  const FunctionDecl *BestFn = Best->second;
11171  auto IsBestOrInferiorToBest = [this, BestFn](
11172  const std::pair<DeclAccessPair, FunctionDecl *> &Pair) {
11173  return BestFn == Pair.second || isBetterCandidate(BestFn, Pair.second);
11174  };
11175 
11176  // Note: We explicitly leave Matches unmodified if there isn't a clear best
11177  // option, so we can potentially give the user a better error
11178  if (!llvm::all_of(Matches, IsBestOrInferiorToBest))
11179  return false;
11180  Matches[0] = *Best;
11181  Matches.resize(1);
11182  return true;
11183  }
11184 
11185  bool isTargetTypeAFunction() const {
11186  return TargetFunctionType->isFunctionType();
11187  }
11188 
11189  // [ToType] [Return]
11190 
11191  // R (*)(A) --> R (A), IsNonStaticMemberFunction = false
11192  // R (&)(A) --> R (A), IsNonStaticMemberFunction = false
11193  // R (S::*)(A) --> R (A), IsNonStaticMemberFunction = true
11194  void inline ExtractUnqualifiedFunctionTypeFromTargetType() {
11195  TargetFunctionType = S.ExtractUnqualifiedFunctionType(TargetType);
11196  }
11197 
11198  // return true if any matching specializations were found
11199  bool AddMatchingTemplateFunction(FunctionTemplateDecl* FunctionTemplate,
11200  const DeclAccessPair& CurAccessFunPair) {
11201  if (CXXMethodDecl *Method
11202  = dyn_cast<CXXMethodDecl>(FunctionTemplate->getTemplatedDecl())) {
11203  // Skip non-static function templates when converting to pointer, and
11204  // static when converting to member pointer.
11205  if (Method->isStatic() == TargetTypeIsNonStaticMemberFunction)
11206  return false;
11207  }
11208  else if (TargetTypeIsNonStaticMemberFunction)
11209  return false;
11210 
11211  // C++ [over.over]p2:
11212  // If the name is a function template, template argument deduction is
11213  // done (14.8.2.2), and if the argument deduction succeeds, the
11214  // resulting template argument list is used to generate a single
11215  // function template specialization, which is added to the set of
11216  // overloaded functions considered.
11217  FunctionDecl *Specialization = nullptr;
11218  TemplateDeductionInfo Info(FailedCandidates.getLocation());
11220  = S.DeduceTemplateArguments(FunctionTemplate,
11221  &OvlExplicitTemplateArgs,
11222  TargetFunctionType, Specialization,
11223  Info, /*IsAddressOfFunction*/true)) {
11224  // Make a note of the failed deduction for diagnostics.
11225  FailedCandidates.addCandidate()
11226  .set(CurAccessFunPair, FunctionTemplate->getTemplatedDecl(),
11227  MakeDeductionFailureInfo(Context, Result, Info));
11228  return false;
11229  }
11230 
11231  // Template argument deduction ensures that we have an exact match or
11232  // compatible pointer-to-function arguments that would be adjusted by ICS.
11233  // This function template specicalization works.
11235  Context.getCanonicalType(Specialization->getType()),
11236  Context.getCanonicalType(TargetFunctionType)));
11237 
11238  if (!S.checkAddressOfFunctionIsAvailable(Specialization))
11239  return false;
11240 
11241  Matches.push_back(std::make_pair(CurAccessFunPair, Specialization));
11242  return true;
11243  }
11244 
11245  bool AddMatchingNonTemplateFunction(NamedDecl* Fn,
11246  const DeclAccessPair& CurAccessFunPair) {
11247  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) {
11248  // Skip non-static functions when converting to pointer, and static
11249  // when converting to member pointer.
11250  if (Method->isStatic() == TargetTypeIsNonStaticMemberFunction)
11251  return false;
11252  }
11253  else if (TargetTypeIsNonStaticMemberFunction)
11254  return false;
11255 
11256  if (FunctionDecl *FunDecl = dyn_cast<FunctionDecl>(Fn)) {
11257  if (S.getLangOpts().CUDA)
11258  if (FunctionDecl *Caller = dyn_cast<FunctionDecl>(S.CurContext))
11259  if (!Caller->isImplicit() && !S.IsAllowedCUDACall(Caller, FunDecl))
11260  return false;
11261  if (FunDecl->isMultiVersion()) {
11262  const auto *TA = FunDecl->getAttr<TargetAttr>();
11263  if (TA && !TA->isDefaultVersion())
11264  return false;
11265  }
11266 
11267  // If any candidate has a placeholder return type, trigger its deduction
11268  // now.
11269  if (completeFunctionType(S, FunDecl, SourceExpr->getBeginLoc(),
11270  Complain)) {
11271  HasComplained |= Complain;
11272  return false;
11273  }
11274 
11275  if (!S.checkAddressOfFunctionIsAvailable(FunDecl))
11276  return false;
11277 
11278  // If we're in C, we need to support types that aren't exactly identical.
11279  if (!S.getLangOpts().CPlusPlus ||
11280  candidateHasExactlyCorrectType(FunDecl)) {
11281  Matches.push_back(std::make_pair(
11282  CurAccessFunPair, cast<FunctionDecl>(FunDecl->getCanonicalDecl())));
11283  FoundNonTemplateFunction = true;
11284  return true;
11285  }
11286  }
11287 
11288  return false;
11289  }
11290 
11291  bool FindAllFunctionsThatMatchTargetTypeExactly() {
11292  bool Ret = false;
11293 
11294  // If the overload expression doesn't have the form of a pointer to
11295  // member, don't try to convert it to a pointer-to-member type.
11296  if (IsInvalidFormOfPointerToMemberFunction())
11297  return false;
11298 
11299  for (UnresolvedSetIterator I = OvlExpr->decls_begin(),
11300  E = OvlExpr->decls_end();
11301  I != E; ++I) {
11302  // Look through any using declarations to find the underlying function.
11303  NamedDecl *Fn = (*I)->getUnderlyingDecl();
11304 
11305  // C++ [over.over]p3:
11306  // Non-member functions and static member functions match
11307  // targets of type "pointer-to-function" or "reference-to-function."
11308  // Nonstatic member functions match targets of
11309  // type "pointer-to-member-function."
11310  // Note that according to DR 247, the containing class does not matter.
11311  if (FunctionTemplateDecl *FunctionTemplate
11312  = dyn_cast<FunctionTemplateDecl>(Fn)) {
11313  if (AddMatchingTemplateFunction(FunctionTemplate, I.getPair()))
11314  Ret = true;
11315  }
11316  // If we have explicit template arguments supplied, skip non-templates.
11317  else if (!OvlExpr->hasExplicitTemplateArgs() &&
11318  AddMatchingNonTemplateFunction(Fn, I.getPair()))
11319  Ret = true;
11320  }
11321  assert(Ret || Matches.empty());
11322  return Ret;
11323  }
11324 
11325  void EliminateAllExceptMostSpecializedTemplate() {
11326  // [...] and any given function template specialization F1 is
11327  // eliminated if the set contains a second function template
11328  // specialization whose function template is more specialized
11329  // than the function template of F1 according to the partial
11330  // ordering rules of 14.5.5.2.
11331 
11332  // The algorithm specified above is quadratic. We instead use a
11333  // two-pass algorithm (similar to the one used to identify the
11334  // best viable function in an overload set) that identifies the
11335  // best function template (if it exists).
11336 
11337  UnresolvedSet<4> MatchesCopy; // TODO: avoid!
11338  for (unsigned I = 0, E = Matches.size(); I != E; ++I)
11339  MatchesCopy.addDecl(Matches[I].second, Matches[I].first.getAccess());
11340 
11341  // TODO: It looks like FailedCandidates does not serve much purpose
11342  // here, since the no_viable diagnostic has index 0.
11344  MatchesCopy.begin(), MatchesCopy.end(), FailedCandidates,
11345  SourceExpr->getBeginLoc(), S.PDiag(),
11346  S.PDiag(diag::err_addr_ovl_ambiguous)
11347  << Matches[0].second->getDeclName(),
11348  S.PDiag(diag::note_ovl_candidate)
11349  << (unsigned)oc_function << (unsigned)ocs_described_template,
11350  Complain, TargetFunctionType);
11351 
11352  if (Result != MatchesCopy.end()) {
11353  // Make it the first and only element
11354  Matches[0].first = Matches[Result - MatchesCopy.begin()].first;
11355  Matches[0].second = cast<FunctionDecl>(*Result);
11356  Matches.resize(1);
11357  } else
11358  HasComplained |= Complain;
11359  }
11360 
11361  void EliminateAllTemplateMatches() {
11362  // [...] any function template specializations in the set are
11363  // eliminated if the set also contains a non-template function, [...]
11364  for (unsigned I = 0, N = Matches.size(); I != N; ) {
11365  if (Matches[I].second->getPrimaryTemplate() == nullptr)
11366  ++I;
11367  else {
11368  Matches[I] = Matches[--N];
11369  Matches.resize(N);
11370  }
11371  }
11372  }
11373 
11374  void EliminateSuboptimalCudaMatches() {
11375  S.EraseUnwantedCUDAMatches(dyn_cast<FunctionDecl>(S.CurContext), Matches);
11376  }
11377 
11378 public:
11379  void ComplainNoMatchesFound() const {
11380  assert(Matches.empty());
11381  S.Diag(OvlExpr->getBeginLoc(), diag::err_addr_ovl_no_viable)
11382  << OvlExpr->getName() << TargetFunctionType
11383  << OvlExpr->getSourceRange();
11384  if (FailedCandidates.empty())
11385  S.NoteAllOverloadCandidates(OvlExpr, TargetFunctionType,
11386  /*TakingAddress=*/true);
11387  else {
11388  // We have some deduction failure messages. Use them to diagnose
11389  // the function templates, and diagnose the non-template candidates
11390  // normally.
11391  for (UnresolvedSetIterator I = OvlExpr->decls_begin(),
11392  IEnd = OvlExpr->decls_end();
11393  I != IEnd; ++I)
11394  if (FunctionDecl *Fun =
11395  dyn_cast<FunctionDecl>((*I)->getUnderlyingDecl()))
11397  S.NoteOverloadCandidate(*I, Fun, TargetFunctionType,
11398  /*TakingAddress=*/true);
11399  FailedCandidates.NoteCandidates(S, OvlExpr->getBeginLoc());
11400  }
11401  }
11402 
11403  bool IsInvalidFormOfPointerToMemberFunction() const {
11404  return TargetTypeIsNonStaticMemberFunction &&
11405  !OvlExprInfo.HasFormOfMemberPointer;
11406  }
11407 
11408  void ComplainIsInvalidFormOfPointerToMemberFunction() const {
11409  // TODO: Should we condition this on whether any functions might
11410  // have matched, or is it more appropriate to do that in callers?
11411  // TODO: a fixit wouldn't hurt.
11412  S.Diag(OvlExpr->getNameLoc(), diag::err_addr_ovl_no_qualifier)
11413  << TargetType << OvlExpr->getSourceRange();
11414  }
11415 
11416  bool IsStaticMemberFunctionFromBoundPointer() const {
11417  return StaticMemberFunctionFromBoundPointer;
11418  }
11419 
11420  void ComplainIsStaticMemberFunctionFromBoundPointer() const {
11421  S.Diag(OvlExpr->getBeginLoc(),
11422  diag::err_invalid_form_pointer_member_function)
11423  << OvlExpr->getSourceRange();
11424  }
11425 
11426  void ComplainOfInvalidConversion() const {
11427  S.Diag(OvlExpr->getBeginLoc(), diag::err_addr_ovl_not_func_ptrref)
11428  << OvlExpr->getName() << TargetType;
11429  }
11430 
11431  void ComplainMultipleMatchesFound() const {
11432  assert(Matches.size() > 1);
11433  S.Diag(OvlExpr->getBeginLoc(), diag::err_addr_ovl_ambiguous)
11434  << OvlExpr->getName() << OvlExpr->getSourceRange();
11435  S.NoteAllOverloadCandidates(OvlExpr, TargetFunctionType,
11436  /*TakingAddress=*/true);
11437  }
11438 
11439  bool hadMultipleCandidates() const { return (OvlExpr->getNumDecls() > 1); }
11440 
11441  int getNumMatches() const { return Matches.size(); }
11442 
11443  FunctionDecl* getMatchingFunctionDecl() const {
11444  if (Matches.size() != 1) return nullptr;
11445  return Matches[0].second;
11446  }
11447 
11448  const DeclAccessPair* getMatchingFunctionAccessPair() const {
11449  if (Matches.size() != 1) return nullptr;
11450  return &Matches[0].first;
11451  }
11452 };
11453 }
11454 
11455 /// ResolveAddressOfOverloadedFunction - Try to resolve the address of
11456 /// an overloaded function (C++ [over.over]), where @p From is an
11457 /// expression with overloaded function type and @p ToType is the type
11458 /// we're trying to resolve to. For example:
11459 ///
11460 /// @code
11461 /// int f(double);
11462 /// int f(int);
11463 ///
11464 /// int (*pfd)(double) = f; // selects f(double)
11465 /// @endcode
11466 ///
11467 /// This routine returns the resulting FunctionDecl if it could be
11468 /// resolved, and NULL otherwise. When @p Complain is true, this
11469 /// routine will emit diagnostics if there is an error.
11470 FunctionDecl *
11472  QualType TargetType,
11473  bool Complain,
11474  DeclAccessPair &FoundResult,
11475  bool *pHadMultipleCandidates) {
11476  assert(AddressOfExpr->getType() == Context.OverloadTy);
11477 
11478  AddressOfFunctionResolver Resolver(*this, AddressOfExpr, TargetType,
11479  Complain);
11480  int NumMatches = Resolver.getNumMatches();
11481  FunctionDecl *Fn = nullptr;
11482  bool ShouldComplain = Complain && !Resolver.hasComplained();
11483  if (NumMatches == 0 && ShouldComplain) {
11484  if (Resolver.IsInvalidFormOfPointerToMemberFunction())
11485  Resolver.ComplainIsInvalidFormOfPointerToMemberFunction();
11486  else
11487  Resolver.ComplainNoMatchesFound();
11488  }
11489  else if (NumMatches > 1 && ShouldComplain)
11490  Resolver.ComplainMultipleMatchesFound();
11491  else if (NumMatches == 1) {
11492  Fn = Resolver.getMatchingFunctionDecl();
11493  assert(Fn);
11494  if (auto *FPT = Fn->getType()->getAs<FunctionProtoType>())
11495  ResolveExceptionSpec(AddressOfExpr->getExprLoc(), FPT);
11496  FoundResult = *Resolver.getMatchingFunctionAccessPair();
11497  if (Complain) {
11498  if (Resolver.IsStaticMemberFunctionFromBoundPointer())
11499  Resolver.ComplainIsStaticMemberFunctionFromBoundPointer();
11500  else
11501  CheckAddressOfMemberAccess(AddressOfExpr, FoundResult);
11502  }
11503  }
11504 
11505  if (pHadMultipleCandidates)
11506  *pHadMultipleCandidates = Resolver.hadMultipleCandidates();
11507  return Fn;
11508 }
11509 
11510 /// Given an expression that refers to an overloaded function, try to
11511 /// resolve that function to a single function that can have its address taken.
11512 /// This will modify `Pair` iff it returns non-null.
11513 ///
11514 /// This routine can only realistically succeed if all but one candidates in the
11515 /// overload set for SrcExpr cannot have their addresses taken.
11516 FunctionDecl *
11518  DeclAccessPair &Pair) {
11520  OverloadExpr *Ovl = R.Expression;
11521  FunctionDecl *Result = nullptr;
11522  DeclAccessPair DAP;
11523  // Don't use the AddressOfResolver because we're specifically looking for
11524  // cases where we have one overload candidate that lacks
11525  // enable_if/pass_object_size/...
11526  for (auto I = Ovl->decls_begin(), E = Ovl->decls_end(); I != E; ++I) {
11527  auto *FD = dyn_cast<FunctionDecl>(I->getUnderlyingDecl());
11528  if (!FD)
11529  return nullptr;
11530 
11532  continue;
11533 
11534  // We have more than one result; quit.
11535  if (Result)
11536  return nullptr;
11537  DAP = I.getPair();
11538  Result = FD;
11539  }
11540 
11541  if (Result)
11542  Pair = DAP;
11543  return Result;
11544 }
11545 
11546 /// Given an overloaded function, tries to turn it into a non-overloaded
11547 /// function reference using resolveAddressOfOnlyViableOverloadCandidate. This
11548 /// will perform access checks, diagnose the use of the resultant decl, and, if
11549 /// requested, potentially perform a function-to-pointer decay.
11550 ///
11551 /// Returns false if resolveAddressOfOnlyViableOverloadCandidate fails.
11552 /// Otherwise, returns true. This may emit diagnostics and return true.
11554  ExprResult &SrcExpr, bool DoFunctionPointerConverion) {
11555  Expr *E = SrcExpr.get();
11556  assert(E->getType() == Context.OverloadTy && "SrcExpr must be an overload");
11557 
11558  DeclAccessPair DAP;
11559  FunctionDecl *Found = resolveAddressOfOnlyViableOverloadCandidate(E, DAP);
11560  if (!Found || Found->isCPUDispatchMultiVersion() ||
11561  Found->isCPUSpecificMultiVersion())
11562  return false;
11563 
11564  // Emitting multiple diagnostics for a function that is both inaccessible and
11565  // unavailable is consistent with our behavior elsewhere. So, always check
11566  // for both.
11567  DiagnoseUseOfDecl(Found, E->getExprLoc());
11568  CheckAddressOfMemberAccess(E, DAP);
11569  Expr *Fixed = FixOverloadedFunctionReference(E, DAP, Found);
11570  if (DoFunctionPointerConverion && Fixed->getType()->isFunctionType())
11571  SrcExpr = DefaultFunctionArrayConversion(Fixed, /*Diagnose=*/false);
11572  else
11573  SrcExpr = Fixed;
11574  return true;
11575 }
11576 
11577 /// Given an expression that refers to an overloaded function, try to
11578 /// resolve that overloaded function expression down to a single function.
11579 ///
11580 /// This routine can only resolve template-ids that refer to a single function
11581 /// template, where that template-id refers to a single template whose template
11582 /// arguments are either provided by the template-id or have defaults,
11583 /// as described in C++0x [temp.arg.explicit]p3.
11584 ///
11585 /// If no template-ids are found, no diagnostics are emitted and NULL is
11586 /// returned.
11587 FunctionDecl *
11589  bool Complain,
11590  DeclAccessPair *FoundResult) {
11591  // C++ [over.over]p1:
11592  // [...] [Note: any redundant set of parentheses surrounding the
11593  // overloaded function name is ignored (5.1). ]
11594  // C++ [over.over]p1:
11595  // [...] The overloaded function name can be preceded by the &
11596  // operator.
11597 
11598  // If we didn't actually find any template-ids, we're done.
11599  if (!ovl->hasExplicitTemplateArgs())
11600  return nullptr;
11601 
11602  TemplateArgumentListInfo ExplicitTemplateArgs;
11603  ovl->copyTemplateArgumentsInto(ExplicitTemplateArgs);
11604  TemplateSpecCandidateSet FailedCandidates(ovl->getNameLoc());
11605 
11606  // Look through all of the overloaded functions, searching for one
11607  // whose type matches exactly.
11608  FunctionDecl *Matched = nullptr;
11609  for (UnresolvedSetIterator I = ovl->decls_begin(),
11610  E = ovl->decls_end(); I != E; ++I) {
11611  // C++0x [temp.arg.explicit]p3:
11612  // [...] In contexts where deduction is done and fails, or in contexts
11613  // where deduction is not done, if a template argument list is
11614  // specified and it, along with any default template arguments,
11615  // identifies a single function template specialization, then the
11616  // template-id is an lvalue for the function template specialization.
11617  FunctionTemplateDecl *FunctionTemplate
11618  = cast<FunctionTemplateDecl>((*I)->getUnderlyingDecl());
11619 
11620  // C++ [over.over]p2:
11621  // If the name is a function template, template argument deduction is
11622  // done (14.8.2.2), and if the argument deduction succeeds, the
11623  // resulting template argument list is used to generate a single
11624  // function template specialization, which is added to the set of
11625  // overloaded functions considered.
11626  FunctionDecl *Specialization = nullptr;
11627  TemplateDeductionInfo Info(FailedCandidates.getLocation());
11628  if (TemplateDeductionResult Result
11629  = DeduceTemplateArguments(FunctionTemplate, &ExplicitTemplateArgs,
11630  Specialization, Info,
11631  /*IsAddressOfFunction*/true)) {
11632  // Make a note of the failed deduction for diagnostics.
11633  // TODO: Actually use the failed-deduction info?
11634  FailedCandidates.addCandidate()
11635  .set(I.getPair(), FunctionTemplate->getTemplatedDecl(),
11636  MakeDeductionFailureInfo(Context, Result, Info));
11637  continue;
11638  }
11639 
11640  assert(Specialization && "no specialization and no error?");
11641 
11642  // Multiple matches; we can't resolve to a single declaration.
11643  if (Matched) {
11644  if (Complain) {
11645  Diag(ovl->getExprLoc(), diag::err_addr_ovl_ambiguous)
11646  << ovl->getName();
11647  NoteAllOverloadCandidates(ovl);
11648  }
11649  return nullptr;
11650  }
11651 
11652  Matched = Specialization;
11653  if (FoundResult) *FoundResult = I.getPair();
11654  }
11655 
11656  if (Matched &&
11657  completeFunctionType(*this, Matched, ovl->getExprLoc(), Complain))
11658  return nullptr;
11659 
11660  return Matched;
11661 }
11662 
11663 // Resolve and fix an overloaded expression that can be resolved
11664 // because it identifies a single function template specialization.
11665 //
11666 // Last three arguments should only be supplied if Complain = true
11667 //
11668 // Return true if it was logically possible to so resolve the
11669 // expression, regardless of whether or not it succeeded. Always
11670 // returns true if 'complain' is set.
11672  ExprResult &SrcExpr, bool doFunctionPointerConverion,
11673  bool complain, SourceRange OpRangeForComplaining,
11674  QualType DestTypeForComplaining,
11675  unsigned DiagIDForComplaining) {
11676  assert(SrcExpr.get()->getType() == Context.OverloadTy);
11677 
11679 
11680  DeclAccessPair found;
11681  ExprResult SingleFunctionExpression;
11682  if (FunctionDecl *fn = ResolveSingleFunctionTemplateSpecialization(
11683  ovl.Expression, /*complain*/ false, &found)) {
11684  if (DiagnoseUseOfDecl(fn, SrcExpr.get()->getBeginLoc())) {
11685  SrcExpr = ExprError();
11686  return true;
11687  }
11688 
11689  // It is only correct to resolve to an instance method if we're
11690  // resolving a form that's permitted to be a pointer to member.
11691  // Otherwise we'll end up making a bound member expression, which
11692  // is illegal in all the contexts we resolve like this.
11693  if (!ovl.HasFormOfMemberPointer &&
11694  isa<CXXMethodDecl>(fn) &&
11695  cast<CXXMethodDecl>(fn)->isInstance()) {
11696  if (!complain) return false;
11697 
11698  Diag(ovl.Expression->getExprLoc(),
11699  diag::err_bound_member_function)
11700  << 0 << ovl.Expression->getSourceRange();
11701 
11702  // TODO: I believe we only end up here if there's a mix of
11703  // static and non-static candidates (otherwise the expression
11704  // would have 'bound member' type, not 'overload' type).
11705  // Ideally we would note which candidate was chosen and why
11706  // the static candidates were rejected.
11707  SrcExpr = ExprError();
11708  return true;
11709  }
11710 
11711  // Fix the expression to refer to 'fn'.
11712  SingleFunctionExpression =
11713  FixOverloadedFunctionReference(SrcExpr.get(), found, fn);
11714 
11715  // If desired, do function-to-pointer decay.
11716  if (doFunctionPointerConverion) {
11717  SingleFunctionExpression =
11718  DefaultFunctionArrayLvalueConversion(SingleFunctionExpression.get());
11719  if (SingleFunctionExpression.isInvalid()) {
11720  SrcExpr = ExprError();
11721  return true;
11722  }
11723  }
11724  }
11725 
11726  if (!SingleFunctionExpression.isUsable()) {
11727  if (complain) {
11728  Diag(OpRangeForComplaining.getBegin(), DiagIDForComplaining)
11729  << ovl.Expression->getName()
11730  << DestTypeForComplaining
11731  << OpRangeForComplaining
11732  << ovl.Expression->getQualifierLoc().getSourceRange();
11733  NoteAllOverloadCandidates(SrcExpr.get());
11734 
11735  SrcExpr = ExprError();
11736  return true;
11737  }
11738 
11739  return false;
11740  }
11741 
11742  SrcExpr = SingleFunctionExpression;
11743  return true;
11744 }
11745 
11746 /// Add a single candidate to the overload set.
11748  DeclAccessPair FoundDecl,
11749  TemplateArgumentListInfo *ExplicitTemplateArgs,
11750  ArrayRef<Expr *> Args,
11751  OverloadCandidateSet &CandidateSet,
11752  bool PartialOverloading,
11753  bool KnownValid) {
11754  NamedDecl *Callee = FoundDecl.getDecl();
11755  if (isa<UsingShadowDecl>(Callee))
11756  Callee = cast<UsingShadowDecl>(Callee)->getTargetDecl();
11757 
11758  if (FunctionDecl *Func = dyn_cast<FunctionDecl>(Callee)) {
11759  if (ExplicitTemplateArgs) {
11760  assert(!KnownValid && "Explicit template arguments?");
11761  return;
11762  }
11763  // Prevent ill-formed function decls to be added as overload candidates.
11764  if (!dyn_cast<FunctionProtoType>(Func->getType()->getAs<FunctionType>()))
11765  return;
11766 
11767  S.AddOverloadCandidate(Func, FoundDecl, Args, CandidateSet,
11768  /*SuppressUserConversions=*/false,
11769  PartialOverloading);
11770  return;
11771  }
11772 
11773  if (FunctionTemplateDecl *FuncTemplate
11774  = dyn_cast<FunctionTemplateDecl>(Callee)) {
11775  S.AddTemplateOverloadCandidate(FuncTemplate, FoundDecl,
11776  ExplicitTemplateArgs, Args, CandidateSet,
11777  /*SuppressUserConversions=*/false,
11778  PartialOverloading);
11779  return;
11780  }
11781 
11782  assert(!KnownValid && "unhandled case in overloaded call candidate");
11783 }
11784 
11785 /// Add the overload candidates named by callee and/or found by argument
11786 /// dependent lookup to the given overload set.
11788  ArrayRef<Expr *> Args,
11789  OverloadCandidateSet &CandidateSet,
11790  bool PartialOverloading) {
11791 
11792 #ifndef NDEBUG
11793  // Verify that ArgumentDependentLookup is consistent with the rules
11794  // in C++0x [basic.lookup.argdep]p3:
11795  //
11796  // Let X be the lookup set produced by unqualified lookup (3.4.1)
11797  // and let Y be the lookup set produced by argument dependent
11798  // lookup (defined as follows). If X contains
11799  //
11800  // -- a declaration of a class member, or
11801  //
11802  // -- a block-scope function declaration that is not a
11803  // using-declaration, or
11804  //
11805  // -- a declaration that is neither a function or a function
11806  // template
11807  //
11808  // then Y is empty.
11809 
11810  if (ULE->requiresADL()) {
11812  E = ULE->decls_end(); I != E; ++I) {
11813  assert(!(*I)->getDeclContext()->isRecord());
11814  assert(isa<UsingShadowDecl>(*I) ||
11815  !(*I)->getDeclContext()->isFunctionOrMethod());
11816  assert((*I)->getUnderlyingDecl()->isFunctionOrFunctionTemplate());
11817  }
11818  }
11819 #endif
11820 
11821  // It would be nice to avoid this copy.
11822  TemplateArgumentListInfo TABuffer;
11823  TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr;
11824  if (ULE->hasExplicitTemplateArgs()) {
11825  ULE->copyTemplateArgumentsInto(TABuffer);
11826  ExplicitTemplateArgs = &TABuffer;
11827  }
11828 
11830  E = ULE->decls_end(); I != E; ++I)
11831  AddOverloadedCallCandidate(*this, I.getPair(), ExplicitTemplateArgs, Args,
11832  CandidateSet, PartialOverloading,
11833  /*KnownValid*/ true);
11834 
11835  if (ULE->requiresADL())
11836  AddArgumentDependentLookupCandidates(ULE->getName(), ULE->getExprLoc(),
11837  Args, ExplicitTemplateArgs,
11838  CandidateSet, PartialOverloading);
11839 }
11840 
11841 /// Determine whether a declaration with the specified name could be moved into
11842 /// a different namespace.
11843 static bool canBeDeclaredInNamespace(const DeclarationName &Name) {
11844  switch (Name.getCXXOverloadedOperator()) {
11845  case OO_New: case OO_Array_New:
11846  case OO_Delete: case OO_Array_Delete:
11847  return false;
11848 
11849  default:
11850  return true;
11851  }
11852 }
11853 
11854 /// Attempt to recover from an ill-formed use of a non-dependent name in a
11855 /// template, where the non-dependent name was declared after the template
11856 /// was defined. This is common in code written for a compilers which do not
11857 /// correctly implement two-stage name lookup.
11858 ///
11859 /// Returns true if a viable candidate was found and a diagnostic was issued.
11860 static bool
11862  const CXXScopeSpec &SS, LookupResult &R,
11864  TemplateArgumentListInfo *ExplicitTemplateArgs,
11865  ArrayRef<Expr *> Args,
11866  bool *DoDiagnoseEmptyLookup = nullptr) {
11867  if (!SemaRef.inTemplateInstantiation() || !SS.isEmpty())
11868  return false;
11869 
11870  for (DeclContext *DC = SemaRef.CurContext; DC; DC = DC->getParent()) {
11871  if (DC->isTransparentContext())
11872  continue;
11873 
11874  SemaRef.LookupQualifiedName(R, DC);
11875 
11876  if (!R.empty()) {
11877  R.suppressDiagnostics();
11878 
11879  if (isa<CXXRecordDecl>(DC)) {
11880  // Don't diagnose names we find in classes; we get much better
11881  // diagnostics for these from DiagnoseEmptyLookup.
11882  R.clear();
11883  if (DoDiagnoseEmptyLookup)
11884  *DoDiagnoseEmptyLookup = true;
11885  return false;
11886  }
11887 
11888  OverloadCandidateSet Candidates(FnLoc, CSK);
11889  for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I)
11890  AddOverloadedCallCandidate(SemaRef, I.getPair(),
11891  ExplicitTemplateArgs, Args,
11892  Candidates, false, /*KnownValid*/ false);
11893 
11895  if (Candidates.BestViableFunction(SemaRef, FnLoc, Best) != OR_Success) {
11896  // No viable functions. Don't bother the user with notes for functions
11897  // which don't work and shouldn't be found anyway.
11898  R.clear();
11899  return false;
11900  }
11901 
11902  // Find the namespaces where ADL would have looked, and suggest
11903  // declaring the function there instead.
11904  Sema::AssociatedNamespaceSet AssociatedNamespaces;
11905  Sema::AssociatedClassSet AssociatedClasses;
11906  SemaRef.FindAssociatedClassesAndNamespaces(FnLoc, Args,
11907  AssociatedNamespaces,
11908  AssociatedClasses);
11909  Sema::AssociatedNamespaceSet SuggestedNamespaces;
11911  DeclContext *Std = SemaRef.getStdNamespace();
11912  for (Sema::AssociatedNamespaceSet::iterator
11913  it = AssociatedNamespaces.begin(),
11914  end = AssociatedNamespaces.end(); it != end; ++it) {
11915  // Never suggest declaring a function within namespace 'std'.
11916  if (Std && Std->Encloses(*it))
11917  continue;
11918 
11919  // Never suggest declaring a function within a namespace with a
11920  // reserved name, like __gnu_cxx.
11921  NamespaceDecl *NS = dyn_cast<NamespaceDecl>(*it);
11922  if (NS &&
11923  NS->getQualifiedNameAsString().find("__") != std::string::npos)
11924  continue;
11925 
11926  SuggestedNamespaces.insert(*it);
11927  }
11928  }
11929 
11930  SemaRef.Diag(R.getNameLoc(), diag::err_not_found_by_two_phase_lookup)
11931  << R.getLookupName();
11932  if (SuggestedNamespaces.empty()) {
11933  SemaRef.Diag(Best->Function->getLocation(),
11934  diag::note_not_found_by_two_phase_lookup)
11935  << R.getLookupName() << 0;
11936  } else if (SuggestedNamespaces.size() == 1) {
11937  SemaRef.Diag(Best->Function->getLocation(),
11938  diag::note_not_found_by_two_phase_lookup)
11939  << R.getLookupName() << 1 << *SuggestedNamespaces.begin();
11940  } else {
11941  // FIXME: It would be useful to list the associated namespaces here,
11942  // but the diagnostics infrastructure doesn't provide a way to produce
11943  // a localized representation of a list of items.
11944  SemaRef.Diag(Best->Function->getLocation(),
11945  diag::note_not_found_by_two_phase_lookup)
11946  << R.getLookupName() << 2;
11947  }
11948 
11949  // Try to recover by calling this function.
11950  return true;
11951  }
11952 
11953  R.clear();
11954  }
11955 
11956  return false;
11957 }
11958 
11959 /// Attempt to recover from ill-formed use of a non-dependent operator in a
11960 /// template, where the non-dependent operator was declared after the template
11961 /// was defined.
11962 ///
11963 /// Returns true if a viable candidate was found and a diagnostic was issued.
11964 static bool
11966  SourceLocation OpLoc,
11967  ArrayRef<Expr *> Args) {
11968  DeclarationName OpName =
11970  LookupResult R(SemaRef, OpName, OpLoc, Sema::LookupOperatorName);
11971  return DiagnoseTwoPhaseLookup(SemaRef, OpLoc, CXXScopeSpec(), R,
11973  /*ExplicitTemplateArgs=*/nullptr, Args);
11974 }
11975 
11976 namespace {
11977 class BuildRecoveryCallExprRAII {
11978  Sema &SemaRef;
11979 public:
11980  BuildRecoveryCallExprRAII(Sema &S) : SemaRef(S) {
11981  assert(SemaRef.IsBuildingRecoveryCallExpr == false);
11982  SemaRef.IsBuildingRecoveryCallExpr = true;
11983  }
11984 
11985  ~BuildRecoveryCallExprRAII() {
11986  SemaRef.IsBuildingRecoveryCallExpr = false;
11987  }
11988 };
11989 
11990 }
11991 
11992 /// Attempts to recover from a call where no functions were found.
11993 ///
11994 /// Returns true if new candidates were found.
11995 static ExprResult
11997  UnresolvedLookupExpr *ULE,
11998  SourceLocation LParenLoc,
12000  SourceLocation RParenLoc,
12001  bool EmptyLookup, bool AllowTypoCorrection) {
12002  // Do not try to recover if it is already building a recovery call.
12003  // This stops infinite loops for template instantiations like
12004  //
12005  // template <typename T> auto foo(T t) -> decltype(foo(t)) {}
12006  // template <typename T> auto foo(T t) -> decltype(foo(&t)) {}
12007  //
12008  if (SemaRef.IsBuildingRecoveryCallExpr)
12009  return ExprError();
12010  BuildRecoveryCallExprRAII RCE(SemaRef);
12011 
12012  CXXScopeSpec SS;
12013  SS.Adopt(ULE->getQualifierLoc());
12014  SourceLocation TemplateKWLoc = ULE->getTemplateKeywordLoc();
12015 
12016  TemplateArgumentListInfo TABuffer;
12017  TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr;
12018  if (ULE->hasExplicitTemplateArgs()) {
12019  ULE->copyTemplateArgumentsInto(TABuffer);
12020  ExplicitTemplateArgs = &TABuffer;
12021  }
12022 
12023  LookupResult R(SemaRef, ULE->getName(), ULE->getNameLoc(),
12025  bool DoDiagnoseEmptyLookup = EmptyLookup;
12027  SemaRef, Fn->getExprLoc(), SS, R, OverloadCandidateSet::CSK_Normal,
12028  ExplicitTemplateArgs, Args, &DoDiagnoseEmptyLookup)) {
12029  NoTypoCorrectionCCC NoTypoValidator{};
12030  FunctionCallFilterCCC FunctionCallValidator(SemaRef, Args.size(),
12031  ExplicitTemplateArgs != nullptr,
12032  dyn_cast<MemberExpr>(Fn));
12033  CorrectionCandidateCallback &Validator =
12034  AllowTypoCorrection
12035  ? static_cast<CorrectionCandidateCallback &>(FunctionCallValidator)
12036  : static_cast<CorrectionCandidateCallback &>(NoTypoValidator);
12037  if (!DoDiagnoseEmptyLookup ||
12038  SemaRef.DiagnoseEmptyLookup(S, SS, R, Validator, ExplicitTemplateArgs,
12039  Args))
12040  return ExprError();
12041  }
12042 
12043  assert(!R.empty() && "lookup results empty despite recovery");
12044 
12045  // If recovery created an ambiguity, just bail out.
12046  if (R.isAmbiguous()) {
12047  R.suppressDiagnostics();
12048  return ExprError();
12049  }
12050 
12051  // Build an implicit member call if appropriate. Just drop the
12052  // casts and such from the call, we don't really care.
12053  ExprResult NewFn = ExprError();
12054  if ((*R.begin())->isCXXClassMember())
12055  NewFn = SemaRef.BuildPossibleImplicitMemberExpr(SS, TemplateKWLoc, R,
12056  ExplicitTemplateArgs, S);
12057  else if (ExplicitTemplateArgs || TemplateKWLoc.isValid())
12058  NewFn = SemaRef.BuildTemplateIdExpr(SS, TemplateKWLoc, R, false,
12059  ExplicitTemplateArgs);
12060  else
12061  NewFn = SemaRef.BuildDeclarationNameExpr(SS, R, false);
12062 
12063  if (NewFn.isInvalid())
12064  return ExprError();
12065 
12066  // This shouldn't cause an infinite loop because we're giving it
12067  // an expression with viable lookup results, which should never
12068  // end up here.
12069  return SemaRef.BuildCallExpr(/*Scope*/ nullptr, NewFn.get(), LParenLoc,
12070  MultiExprArg(Args.data(), Args.size()),
12071  RParenLoc);
12072 }
12073 
12074 /// Constructs and populates an OverloadedCandidateSet from
12075 /// the given function.
12076 /// \returns true when an the ExprResult output parameter has been set.
12078  UnresolvedLookupExpr *ULE,
12079  MultiExprArg Args,
12080  SourceLocation RParenLoc,
12081  OverloadCandidateSet *CandidateSet,
12082  ExprResult *Result) {
12083 #ifndef NDEBUG
12084  if (ULE->requiresADL()) {
12085  // To do ADL, we must have found an unqualified name.
12086  assert(!ULE->getQualifier() && "qualified name with ADL");
12087 
12088  // We don't perform ADL for implicit declarations of builtins.
12089  // Verify that this was correctly set up.
12090  FunctionDecl *F;
12091  if (ULE->decls_begin() != ULE->decls_end() &&
12092  ULE->decls_begin() + 1 == ULE->decls_end() &&
12093  (F = dyn_cast<FunctionDecl>(*ULE->decls_begin())) &&
12094  F->getBuiltinID() && F->isImplicit())
12095  llvm_unreachable("performing ADL for builtin");
12096 
12097  // We don't perform ADL in C.
12098  assert(getLangOpts().CPlusPlus && "ADL enabled in C");
12099  }
12100 #endif
12101 
12102  UnbridgedCastsSet UnbridgedCasts;
12103  if (checkArgPlaceholdersForOverload(*this, Args, UnbridgedCasts)) {
12104  *Result = ExprError();
12105  return true;
12106  }
12107 
12108  // Add the functions denoted by the callee to the set of candidate
12109  // functions, including those from argument-dependent lookup.
12110  AddOverloadedCallCandidates(ULE, Args, *CandidateSet);
12111 
12112  if (getLangOpts().MSVCCompat &&
12113  CurContext->isDependentContext() && !isSFINAEContext() &&
12114  (isa<FunctionDecl>(CurContext) || isa<CXXRecordDecl>(CurContext))) {
12115 
12117  if (CandidateSet->empty() ||
12118  CandidateSet->BestViableFunction(*this, Fn->getBeginLoc(), Best) ==
12120  // In Microsoft mode, if we are inside a template class member function
12121  // then create a type dependent CallExpr. The goal is to postpone name
12122  // lookup to instantiation time to be able to search into type dependent
12123  // base classes.
12124  CallExpr *CE = CallExpr::Create(Context, Fn, Args, Context.DependentTy,
12125  VK_RValue, RParenLoc);
12126  CE->setTypeDependent(true);
12127  CE->setValueDependent(true);
12128  CE->setInstantiationDependent(true);
12129  *Result = CE;
12130  return true;
12131  }
12132  }
12133 
12134  if (CandidateSet->empty())
12135  return false;
12136 
12137  UnbridgedCasts.restore();
12138  return false;
12139 }
12140 
12141 /// FinishOverloadedCallExpr - given an OverloadCandidateSet, builds and returns
12142 /// the completed call expression. If overload resolution fails, emits
12143 /// diagnostics and returns ExprError()
12145  UnresolvedLookupExpr *ULE,
12146  SourceLocation LParenLoc,
12147  MultiExprArg Args,
12148  SourceLocation RParenLoc,
12149  Expr *ExecConfig,
12150  OverloadCandidateSet *CandidateSet,
12152  OverloadingResult OverloadResult,
12153  bool AllowTypoCorrection) {
12154  if (CandidateSet->empty())
12155  return BuildRecoveryCallExpr(SemaRef, S, Fn, ULE, LParenLoc, Args,
12156  RParenLoc, /*EmptyLookup=*/true,
12157  AllowTypoCorrection);
12158 
12159  switch (OverloadResult) {
12160  case OR_Success: {
12161  FunctionDecl *FDecl = (*Best)->Function;
12162  SemaRef.CheckUnresolvedLookupAccess(ULE, (*Best)->FoundDecl);
12163  if (SemaRef.DiagnoseUseOfDecl(FDecl, ULE->getNameLoc()))
12164  return ExprError();
12165  Fn = SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl);
12166  return SemaRef.BuildResolvedCallExpr(Fn, FDecl, LParenLoc, Args, RParenLoc,
12167  ExecConfig, /*IsExecConfig=*/false,
12168  (*Best)->IsADLCandidate);
12169  }
12170 
12171  case OR_No_Viable_Function: {
12172  // Try to recover by looking for viable functions which the user might
12173  // have meant to call.
12174  ExprResult Recovery = BuildRecoveryCallExpr(SemaRef, S, Fn, ULE, LParenLoc,
12175  Args, RParenLoc,
12176  /*EmptyLookup=*/false,
12177  AllowTypoCorrection);
12178  if (!Recovery.isInvalid())
12179  return Recovery;
12180 
12181  // If the user passes in a function that we can't take the address of, we
12182  // generally end up emitting really bad error messages. Here, we attempt to
12183  // emit better ones.
12184  for (const Expr *Arg : Args) {
12185  if (!Arg->getType()->isFunctionType())
12186  continue;
12187  if (auto *DRE = dyn_cast<DeclRefExpr>(Arg->IgnoreParenImpCasts())) {
12188  auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl());
12189  if (FD &&
12190  !SemaRef.checkAddressOfFunctionIsAvailable(FD, /*Complain=*/true,
12191  Arg->getExprLoc()))
12192  return ExprError();
12193  }
12194  }
12195 
12196  CandidateSet->NoteCandidates(
12198  Fn->getBeginLoc(),
12199  SemaRef.PDiag(diag::err_ovl_no_viable_function_in_call)
12200  << ULE->getName() << Fn->getSourceRange()),
12201  SemaRef, OCD_AllCandidates, Args);
12202  break;
12203  }
12204 
12205  case OR_Ambiguous:
12206  CandidateSet->NoteCandidates(
12208  SemaRef.PDiag(diag::err_ovl_ambiguous_call)
12209  << ULE->getName() << Fn->getSourceRange()),
12210  SemaRef, OCD_ViableCandidates, Args);
12211  break;
12212 
12213  case OR_Deleted: {
12214  CandidateSet->NoteCandidates(
12216  SemaRef.PDiag(diag::err_ovl_deleted_call)
12217  << ULE->getName() << Fn->getSourceRange()),
12218  SemaRef, OCD_AllCandidates, Args);
12219 
12220  // We emitted an error for the unavailable/deleted function call but keep
12221  // the call in the AST.
12222  FunctionDecl *FDecl = (*Best)->Function;
12223  Fn = SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl);
12224  return SemaRef.BuildResolvedCallExpr(Fn, FDecl, LParenLoc, Args, RParenLoc,
12225  ExecConfig, /*IsExecConfig=*/false,
12226  (*Best)->IsADLCandidate);
12227  }
12228  }
12229 
12230  // Overload resolution failed.
12231  return ExprError();
12232 }
12233 
12235  OverloadCandidateSet &CS) {
12236  for (auto I = CS.begin(), E = CS.end(); I != E; ++I) {
12237  if (I->Viable &&
12238  !S.checkAddressOfFunctionIsAvailable(I->Function, /*Complain=*/false)) {
12239  I->Viable = false;
12240  I->FailureKind = ovl_fail_addr_not_available;
12241  }
12242  }
12243 }
12244 
12245 /// BuildOverloadedCallExpr - Given the call expression that calls Fn
12246 /// (which eventually refers to the declaration Func) and the call
12247 /// arguments Args/NumArgs, attempt to resolve the function call down
12248 /// to a specific function. If overload resolution succeeds, returns
12249 /// the call expression produced by overload resolution.
12250 /// Otherwise, emits diagnostics and returns ExprError.
12252  UnresolvedLookupExpr *ULE,
12253  SourceLocation LParenLoc,
12254  MultiExprArg Args,
12255  SourceLocation RParenLoc,
12256  Expr *ExecConfig,
12257  bool AllowTypoCorrection,
12258  bool CalleesAddressIsTaken) {
12259  OverloadCandidateSet CandidateSet(Fn->getExprLoc(),
12262 
12263  if (buildOverloadedCallSet(S, Fn, ULE, Args, LParenLoc, &CandidateSet,
12264  &result))
12265  return result;
12266 
12267  // If the user handed us something like `(&Foo)(Bar)`, we need to ensure that
12268  // functions that aren't addressible are considered unviable.
12269  if (CalleesAddressIsTaken)
12270  markUnaddressableCandidatesUnviable(*this, CandidateSet);
12271 
12273  OverloadingResult OverloadResult =
12274  CandidateSet.BestViableFunction(*this, Fn->getBeginLoc(), Best);
12275 
12276  return FinishOverloadedCallExpr(*this, S, Fn, ULE, LParenLoc, Args, RParenLoc,
12277  ExecConfig, &CandidateSet, &Best,
12278  OverloadResult, AllowTypoCorrection);
12279 }
12280 
12281 static bool IsOverloaded(const UnresolvedSetImpl &Functions) {
12282  return Functions.size() > 1 ||
12283  (Functions.size() == 1 && isa<FunctionTemplateDecl>(*Functions.begin()));
12284 }
12285 
12286 /// Create a unary operation that may resolve to an overloaded
12287 /// operator.
12288 ///
12289 /// \param OpLoc The location of the operator itself (e.g., '*').
12290 ///
12291 /// \param Opc The UnaryOperatorKind that describes this operator.
12292 ///
12293 /// \param Fns The set of non-member functions that will be
12294 /// considered by overload resolution. The caller needs to build this
12295 /// set based on the context using, e.g.,
12296 /// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This
12297 /// set should not contain any member functions; those will be added
12298 /// by CreateOverloadedUnaryOp().
12299 ///
12300 /// \param Input The input argument.
12301 ExprResult
12303  const UnresolvedSetImpl &Fns,
12304  Expr *Input, bool PerformADL) {
12306  assert(Op != OO_None && "Invalid opcode for overloaded unary operator");
12308  // TODO: provide better source location info.
12309  DeclarationNameInfo OpNameInfo(OpName, OpLoc);
12310 
12311  if (checkPlaceholderForOverload(*this, Input))
12312  return ExprError();
12313 
12314  Expr *Args[2] = { Input, nullptr };
12315  unsigned NumArgs = 1;
12316 
12317  // For post-increment and post-decrement, add the implicit '0' as
12318  // the second argument, so that we know this is a post-increment or
12319  // post-decrement.
12320  if (Opc == UO_PostInc || Opc == UO_PostDec) {
12321  llvm::APSInt Zero(Context.getTypeSize(Context.IntTy), false);
12322  Args[1] = IntegerLiteral::Create(Context, Zero, Context.IntTy,
12323  SourceLocation());
12324  NumArgs = 2;
12325  }
12326 
12327  ArrayRef<Expr *> ArgsArray(Args, NumArgs);
12328 
12329  if (Input->isTypeDependent()) {
12330  if (Fns.empty())
12331  return new (Context) UnaryOperator(Input, Opc, Context.DependentTy,
12332  VK_RValue, OK_Ordinary, OpLoc, false);
12333 
12334  CXXRecordDecl *NamingClass = nullptr; // lookup ignores member operators
12336  Context, NamingClass, NestedNameSpecifierLoc(), OpNameInfo,
12337  /*ADL*/ true, IsOverloaded(Fns), Fns.begin(), Fns.end());
12338  return CXXOperatorCallExpr::Create(Context, Op, Fn, ArgsArray,
12339  Context.DependentTy, VK_RValue, OpLoc,
12340  FPOptions());
12341  }
12342 
12343  // Build an empty overload set.
12345 
12346  // Add the candidates from the given function set.
12347  AddFunctionCandidates(Fns, ArgsArray, CandidateSet);
12348 
12349  // Add operator candidates that are member functions.
12350  AddMemberOperatorCandidates(Op, OpLoc, ArgsArray, CandidateSet);
12351 
12352  // Add candidates from ADL.
12353  if (PerformADL) {
12354  AddArgumentDependentLookupCandidates(OpName, OpLoc, ArgsArray,
12355  /*ExplicitTemplateArgs*/nullptr,
12356  CandidateSet);
12357  }
12358 
12359  // Add builtin operator candidates.
12360  AddBuiltinOperatorCandidates(Op, OpLoc, ArgsArray, CandidateSet);
12361 
12362  bool HadMultipleCandidates = (CandidateSet.size() > 1);
12363 
12364  // Perform overload resolution.
12366  switch (CandidateSet.BestViableFunction(*this, OpLoc, Best)) {
12367  case OR_Success: {
12368  // We found a built-in operator or an overloaded operator.
12369  FunctionDecl *FnDecl = Best->Function;
12370 
12371  if (FnDecl) {
12372  Expr *Base = nullptr;
12373  // We matched an overloaded operator. Build a call to that
12374  // operator.
12375 
12376  // Convert the arguments.
12377  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) {
12378  CheckMemberOperatorAccess(OpLoc, Args[0], nullptr, Best->FoundDecl);
12379 
12380  ExprResult InputRes =
12381  PerformObjectArgumentInitialization(Input, /*Qualifier=*/nullptr,
12382  Best->FoundDecl, Method);
12383  if (InputRes.isInvalid())
12384  return ExprError();
12385  Base = Input = InputRes.get();
12386  } else {
12387  // Convert the arguments.
12388  ExprResult InputInit
12389  = PerformCopyInitialization(InitializedEntity::InitializeParameter(
12390  Context,
12391  FnDecl->getParamDecl(0)),
12392  SourceLocation(),
12393  Input);
12394  if (InputInit.isInvalid())
12395  return ExprError();
12396  Input = InputInit.get();
12397  }
12398 
12399  // Build the actual expression node.
12400  ExprResult FnExpr = CreateFunctionRefExpr(*this, FnDecl, Best->FoundDecl,
12401  Base, HadMultipleCandidates,
12402  OpLoc);
12403  if (FnExpr.isInvalid())
12404  return ExprError();
12405 
12406  // Determine the result type.
12407  QualType ResultTy = FnDecl->getReturnType();
12409  ResultTy = ResultTy.getNonLValueExprType(Context);
12410 
12411  Args[0] = Input;
12413  Context, Op, FnExpr.get(), ArgsArray, ResultTy, VK, OpLoc,
12414  FPOptions(), Best->IsADLCandidate);
12415 
12416  if (CheckCallReturnType(FnDecl->getReturnType(), OpLoc, TheCall, FnDecl))
12417  return ExprError();
12418 
12419  if (CheckFunctionCall(FnDecl, TheCall,
12420  FnDecl->getType()->castAs<FunctionProtoType>()))
12421  return ExprError();
12422 
12423  return MaybeBindToTemporary(TheCall);
12424  } else {
12425  // We matched a built-in operator. Convert the arguments, then
12426  // break out so that we will build the appropriate built-in
12427  // operator node.
12428  ExprResult InputRes = PerformImplicitConversion(
12429  Input, Best->BuiltinParamTypes[0], Best->Conversions[0], AA_Passing,
12430  CCK_ForBuiltinOverloadedOp);
12431  if (InputRes.isInvalid())
12432  return ExprError();
12433  Input = InputRes.get();
12434  break;
12435  }
12436  }
12437 
12438  case OR_No_Viable_Function:
12439  // This is an erroneous use of an operator which can be overloaded by
12440  // a non-member function. Check for non-member operators which were
12441  // defined too late to be candidates.
12442  if (DiagnoseTwoPhaseOperatorLookup(*this, Op, OpLoc, ArgsArray))
12443  // FIXME: Recover by calling the found function.
12444  return ExprError();
12445 
12446  // No viable function; fall through to handling this as a
12447  // built-in operator, which will produce an error message for us.
12448  break;
12449 
12450  case OR_Ambiguous:
12451  CandidateSet.NoteCandidates(
12452  PartialDiagnosticAt(OpLoc,
12453  PDiag(diag::err_ovl_ambiguous_oper_unary)
12455  << Input->getType() << Input->getSourceRange()),
12456  *this, OCD_ViableCandidates, ArgsArray,
12457  UnaryOperator::getOpcodeStr(Opc), OpLoc);
12458  return ExprError();
12459 
12460  case OR_Deleted:
12461  CandidateSet.NoteCandidates(
12462  PartialDiagnosticAt(OpLoc, PDiag(diag::err_ovl_deleted_oper)
12464  << Input->getSourceRange()),
12465  *this, OCD_AllCandidates, ArgsArray, UnaryOperator::getOpcodeStr(Opc),
12466  OpLoc);
12467  return ExprError();
12468  }
12469 
12470  // Either we found no viable overloaded operator or we matched a
12471  // built-in operator. In either case, fall through to trying to
12472  // build a built-in operation.
12473  return CreateBuiltinUnaryOp(OpLoc, Opc, Input);
12474 }
12475 
12476 /// Create a binary operation that may resolve to an overloaded
12477 /// operator.
12478 ///
12479 /// \param OpLoc The location of the operator itself (e.g., '+').
12480 ///
12481 /// \param Opc The BinaryOperatorKind that describes this operator.
12482 ///
12483 /// \param Fns The set of non-member functions that will be
12484 /// considered by overload resolution. The caller needs to build this
12485 /// set based on the context using, e.g.,
12486 /// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This
12487 /// set should not contain any member functions; those will be added
12488 /// by CreateOverloadedBinOp().
12489 ///
12490 /// \param LHS Left-hand argument.
12491 /// \param RHS Right-hand argument.
12492 ExprResult
12494  BinaryOperatorKind Opc,
12495  const UnresolvedSetImpl &Fns,
12496  Expr *LHS, Expr *RHS, bool PerformADL) {
12497  Expr *Args[2] = { LHS, RHS };
12498  LHS=RHS=nullptr; // Please use only Args instead of LHS/RHS couple
12499 
12502 
12503  // If either side is type-dependent, create an appropriate dependent
12504  // expression.
12505  if (Args[0]->isTypeDependent() || Args[1]->isTypeDependent()) {
12506  if (Fns.empty()) {
12507  // If there are no functions to store, just build a dependent
12508  // BinaryOperator or CompoundAssignment.
12509  if (Opc <= BO_Assign || Opc > BO_OrAssign)
12510  return new (Context) BinaryOperator(
12511  Args[0], Args[1], Opc, Context.DependentTy, VK_RValue, OK_Ordinary,
12512  OpLoc, FPFeatures);
12513 
12514  return new (Context) CompoundAssignOperator(
12515  Args[0], Args[1], Opc, Context.DependentTy, VK_LValue, OK_Ordinary,
12516  Context.DependentTy, Context.DependentTy, OpLoc,
12517  FPFeatures);
12518  }
12519 
12520  // FIXME: save results of ADL from here?
12521  CXXRecordDecl *NamingClass = nullptr; // lookup ignores member operators
12522  // TODO: provide better source location info in DNLoc component.
12523  DeclarationNameInfo OpNameInfo(OpName, OpLoc);
12525  Context, NamingClass, NestedNameSpecifierLoc(), OpNameInfo,
12526  /*ADL*/ PerformADL, IsOverloaded(Fns), Fns.begin(), Fns.end());
12527  return CXXOperatorCallExpr::Create(Context, Op, Fn, Args,
12528  Context.DependentTy, VK_RValue, OpLoc,
12529  FPFeatures);
12530  }
12531 
12532  // Always do placeholder-like conversions on the RHS.
12533  if (checkPlaceholderForOverload(*this, Args[1]))
12534  return ExprError();
12535 
12536  // Do placeholder-like conversion on the LHS; note that we should
12537  // not get here with a PseudoObject LHS.
12538  assert(Args[0]->getObjectKind() != OK_ObjCProperty);
12539  if (checkPlaceholderForOverload(*this, Args[0]))
12540  return ExprError();
12541 
12542  // If this is the assignment operator, we only perform overload resolution
12543  // if the left-hand side is a class or enumeration type. This is actually
12544  // a hack. The standard requires that we do overload resolution between the
12545  // various built-in candidates, but as DR507 points out, this can lead to
12546  // problems. So we do it this way, which pretty much follows what GCC does.
12547  // Note that we go the traditional code path for compound assignment forms.
12548  if (Opc == BO_Assign && !Args[0]->getType()->isOverloadableType())
12549  return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
12550 
12551  // If this is the .* operator, which is not overloadable, just
12552  // create a built-in binary operator.
12553  if (Opc == BO_PtrMemD)
12554  return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
12555 
12556  // Build an empty overload set.
12558 
12559  // Add the candidates from the given function set.
12560  AddFunctionCandidates(Fns, Args, CandidateSet);
12561 
12562  // Add operator candidates that are member functions.
12563  AddMemberOperatorCandidates(Op, OpLoc, Args, CandidateSet);
12564 
12565  // Add candidates from ADL. Per [over.match.oper]p2, this lookup is not
12566  // performed for an assignment operator (nor for operator[] nor operator->,
12567  // which don't get here).
12568  if (Opc != BO_Assign && PerformADL)
12569  AddArgumentDependentLookupCandidates(OpName, OpLoc, Args,
12570  /*ExplicitTemplateArgs*/ nullptr,
12571  CandidateSet);
12572 
12573  // Add builtin operator candidates.
12574  AddBuiltinOperatorCandidates(Op, OpLoc, Args, CandidateSet);
12575 
12576  bool HadMultipleCandidates = (CandidateSet.size() > 1);
12577 
12578  // Perform overload resolution.
12580  switch (CandidateSet.BestViableFunction(*this, OpLoc, Best)) {
12581  case OR_Success: {
12582  // We found a built-in operator or an overloaded operator.
12583  FunctionDecl *FnDecl = Best->Function;
12584 
12585  if (FnDecl) {
12586  Expr *Base = nullptr;
12587  // We matched an overloaded operator. Build a call to that
12588  // operator.
12589 
12590  // Convert the arguments.
12591  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) {
12592  // Best->Access is only meaningful for class members.
12593  CheckMemberOperatorAccess(OpLoc, Args[0], Args[1], Best->FoundDecl);
12594 
12595  ExprResult Arg1 =
12596  PerformCopyInitialization(
12598  FnDecl->getParamDecl(0)),
12599  SourceLocation(), Args[1]);
12600  if (Arg1.isInvalid())
12601  return ExprError();
12602 
12603  ExprResult Arg0 =
12604  PerformObjectArgumentInitialization(Args[0], /*Qualifier=*/nullptr,
12605  Best->FoundDecl, Method);
12606  if (Arg0.isInvalid())
12607  return ExprError();
12608  Base = Args[0] = Arg0.getAs<Expr>();
12609  Args[1] = RHS = Arg1.getAs<Expr>();
12610  } else {
12611  // Convert the arguments.
12612  ExprResult Arg0 = PerformCopyInitialization(
12614  FnDecl->getParamDecl(0)),
12615  SourceLocation(), Args[0]);
12616  if (Arg0.isInvalid())
12617  return ExprError();
12618 
12619  ExprResult Arg1 =
12620  PerformCopyInitialization(
12622  FnDecl->getParamDecl(1)),
12623  SourceLocation(), Args[1]);
12624  if (Arg1.isInvalid())
12625  return ExprError();
12626  Args[0] = LHS = Arg0.getAs<Expr>();
12627  Args[1] = RHS = Arg1.getAs<Expr>();
12628  }
12629 
12630  // Build the actual expression node.
12631  ExprResult FnExpr = CreateFunctionRefExpr(*this, FnDecl,
12632  Best->FoundDecl, Base,
12633  HadMultipleCandidates, OpLoc);
12634  if (FnExpr.isInvalid())
12635  return ExprError();
12636 
12637  // Determine the result type.
12638  QualType ResultTy = FnDecl->getReturnType();
12640  ResultTy = ResultTy.getNonLValueExprType(Context);
12641 
12643  Context, Op, FnExpr.get(), Args, ResultTy, VK, OpLoc, FPFeatures,
12644  Best->IsADLCandidate);
12645 
12646  if (CheckCallReturnType(FnDecl->getReturnType(), OpLoc, TheCall,
12647  FnDecl))
12648  return ExprError();
12649 
12650  ArrayRef<const Expr *> ArgsArray(Args, 2);
12651  const Expr *ImplicitThis = nullptr;
12652  // Cut off the implicit 'this'.
12653  if (isa<CXXMethodDecl>(FnDecl)) {
12654  ImplicitThis = ArgsArray[0];
12655  ArgsArray = ArgsArray.slice(1);
12656  }
12657 
12658  // Check for a self move.
12659  if (Op == OO_Equal)
12660  DiagnoseSelfMove(Args[0], Args[1], OpLoc);
12661 
12662  checkCall(FnDecl, nullptr, ImplicitThis, ArgsArray,
12663  isa<CXXMethodDecl>(FnDecl), OpLoc, TheCall->getSourceRange(),
12664  VariadicDoesNotApply);
12665 
12666  return MaybeBindToTemporary(TheCall);
12667  } else {
12668  // We matched a built-in operator. Convert the arguments, then
12669  // break out so that we will build the appropriate built-in
12670  // operator node.
12671  ExprResult ArgsRes0 = PerformImplicitConversion(
12672  Args[0], Best->BuiltinParamTypes[0], Best->Conversions[0],
12673  AA_Passing, CCK_ForBuiltinOverloadedOp);
12674  if (ArgsRes0.isInvalid())
12675  return ExprError();
12676  Args[0] = ArgsRes0.get();
12677 
12678  ExprResult ArgsRes1 = PerformImplicitConversion(
12679  Args[1], Best->BuiltinParamTypes[1], Best->Conversions[1],
12680  AA_Passing, CCK_ForBuiltinOverloadedOp);
12681  if (ArgsRes1.isInvalid())
12682  return ExprError();
12683  Args[1] = ArgsRes1.get();
12684  break;
12685  }
12686  }
12687 
12688  case OR_No_Viable_Function: {
12689  // C++ [over.match.oper]p9:
12690  // If the operator is the operator , [...] and there are no
12691  // viable functions, then the operator is assumed to be the
12692  // built-in operator and interpreted according to clause 5.
12693  if (Opc == BO_Comma)
12694  break;
12695 
12696  // For class as left operand for assignment or compound assignment
12697  // operator do not fall through to handling in built-in, but report that
12698  // no overloaded assignment operator found
12699  ExprResult Result = ExprError();
12700  StringRef OpcStr = BinaryOperator::getOpcodeStr(Opc);
12701  auto Cands = CandidateSet.CompleteCandidates(*this, OCD_AllCandidates,
12702  Args, OpLoc);
12703  if (Args[0]->getType()->isRecordType() &&
12704  Opc >= BO_Assign && Opc <= BO_OrAssign) {
12705  Diag(OpLoc, diag::err_ovl_no_viable_oper)
12707  << Args[0]->getSourceRange() << Args[1]->getSourceRange();
12708  if (Args[0]->getType()->isIncompleteType()) {
12709  Diag(OpLoc, diag::note_assign_lhs_incomplete)
12710  << Args[0]->getType()
12711  << Args[0]->getSourceRange() << Args[1]->getSourceRange();
12712  }
12713  } else {
12714  // This is an erroneous use of an operator which can be overloaded by
12715  // a non-member function. Check for non-member operators which were
12716  // defined too late to be candidates.
12717  if (DiagnoseTwoPhaseOperatorLookup(*this, Op, OpLoc, Args))
12718  // FIXME: Recover by calling the found function.
12719  return ExprError();
12720 
12721  // No viable function; try to create a built-in operation, which will
12722  // produce an error. Then, show the non-viable candidates.
12723  Result = CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
12724  }
12725  assert(Result.isInvalid() &&
12726  "C++ binary operator overloading is missing candidates!");
12727  CandidateSet.NoteCandidates(*this, Args, Cands, OpcStr, OpLoc);
12728  return Result;
12729  }
12730 
12731  case OR_Ambiguous:
12732  CandidateSet.NoteCandidates(
12733  PartialDiagnosticAt(OpLoc, PDiag(diag::err_ovl_ambiguous_oper_binary)
12735  << Args[0]->getType()
12736  << Args[1]->getType()
12737  << Args[0]->getSourceRange()
12738  << Args[1]->getSourceRange()),
12740  OpLoc);
12741  return ExprError();
12742 
12743  case OR_Deleted:
12744  if (isImplicitlyDeleted(Best->Function)) {
12745  CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
12746  Diag(OpLoc, diag::err_ovl_deleted_special_oper)
12747  << Context.getRecordType(Method->getParent())
12748  << getSpecialMember(Method);
12749 
12750  // The user probably meant to call this special member. Just
12751  // explain why it's deleted.
12752  NoteDeletedFunction(Method);
12753  return ExprError();
12754  }
12755  CandidateSet.NoteCandidates(
12756  PartialDiagnosticAt(OpLoc, PDiag(diag::err_ovl_deleted_oper)
12758  << Args[0]->getSourceRange()
12759  << Args[1]->getSourceRange()),
12761  OpLoc);
12762  return ExprError();
12763  }
12764 
12765  // We matched a built-in operator; build it.
12766  return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
12767 }
12768 
12769 ExprResult
12771  SourceLocation RLoc,
12772  Expr *Base, Expr *Idx) {
12773  Expr *Args[2] = { Base, Idx };
12774  DeclarationName OpName =
12775  Context.DeclarationNames.getCXXOperatorName(OO_Subscript);
12776 
12777  // If either side is type-dependent, create an appropriate dependent
12778  // expression.
12779  if (Args[0]->isTypeDependent() || Args[1]->isTypeDependent()) {
12780 
12781  CXXRecordDecl *NamingClass = nullptr; // lookup ignores member operators
12782  // CHECKME: no 'operator' keyword?
12783  DeclarationNameInfo OpNameInfo(OpName, LLoc);
12784  OpNameInfo.setCXXOperatorNameRange(SourceRange(LLoc, RLoc));
12786  = UnresolvedLookupExpr::Create(Context, NamingClass,
12787  NestedNameSpecifierLoc(), OpNameInfo,
12788  /*ADL*/ true, /*Overloaded*/ false,
12791  // Can't add any actual overloads yet
12792 
12793  return CXXOperatorCallExpr::Create(Context, OO_Subscript, Fn, Args,
12794  Context.DependentTy, VK_RValue, RLoc,
12795  FPOptions());
12796  }
12797 
12798  // Handle placeholders on both operands.
12799  if (checkPlaceholderForOverload(*this, Args[0]))
12800  return ExprError();
12801  if (checkPlaceholderForOverload(*this, Args[1]))
12802  return ExprError();
12803 
12804  // Build an empty overload set.
12806 
12807  // Subscript can only be overloaded as a member function.
12808 
12809  // Add operator candidates that are member functions.
12810  AddMemberOperatorCandidates(OO_Subscript, LLoc, Args, CandidateSet);
12811 
12812  // Add builtin operator candidates.
12813  AddBuiltinOperatorCandidates(OO_Subscript, LLoc, Args, CandidateSet);
12814 
12815  bool HadMultipleCandidates = (CandidateSet.size() > 1);
12816 
12817  // Perform overload resolution.
12819  switch (CandidateSet.BestViableFunction(*this, LLoc, Best)) {
12820  case OR_Success: {
12821  // We found a built-in operator or an overloaded operator.
12822  FunctionDecl *FnDecl = Best->Function;
12823 
12824  if (FnDecl) {
12825  // We matched an overloaded operator. Build a call to that
12826  // operator.
12827 
12828  CheckMemberOperatorAccess(LLoc, Args[0], Args[1], Best->FoundDecl);
12829 
12830  // Convert the arguments.
12831  CXXMethodDecl *Method = cast<CXXMethodDecl>(FnDecl);
12832  ExprResult Arg0 =
12833  PerformObjectArgumentInitialization(Args[0], /*Qualifier=*/nullptr,
12834  Best->FoundDecl, Method);
12835  if (Arg0.isInvalid())
12836  return ExprError();
12837  Args[0] = Arg0.get();
12838 
12839  // Convert the arguments.
12840  ExprResult InputInit
12841  = PerformCopyInitialization(InitializedEntity::InitializeParameter(
12842  Context,
12843  FnDecl->getParamDecl(0)),
12844  SourceLocation(),
12845  Args[1]);
12846  if (InputInit.isInvalid())
12847  return ExprError();
12848 
12849  Args[1] = InputInit.getAs<Expr>();
12850 
12851  // Build the actual expression node.
12852  DeclarationNameInfo OpLocInfo(OpName, LLoc);
12853  OpLocInfo.setCXXOperatorNameRange(SourceRange(LLoc, RLoc));
12854  ExprResult FnExpr = CreateFunctionRefExpr(*this, FnDecl,
12855  Best->FoundDecl,
12856  Base,
12857  HadMultipleCandidates,
12858  OpLocInfo.getLoc(),
12859  OpLocInfo.getInfo());
12860  if (FnExpr.isInvalid())
12861  return ExprError();
12862 
12863  // Determine the result type
12864  QualType ResultTy = FnDecl->getReturnType();
12866  ResultTy = ResultTy.getNonLValueExprType(Context);
12867 
12868  CXXOperatorCallExpr *TheCall =
12869  CXXOperatorCallExpr::Create(Context, OO_Subscript, FnExpr.get(),
12870  Args, ResultTy, VK, RLoc, FPOptions());
12871 
12872  if (CheckCallReturnType(FnDecl->getReturnType(), LLoc, TheCall, FnDecl))
12873  return ExprError();
12874 
12875  if (CheckFunctionCall(Method, TheCall,
12876  Method->getType()->castAs<FunctionProtoType>()))
12877  return ExprError();
12878 
12879  return MaybeBindToTemporary(TheCall);
12880  } else {
12881  // We matched a built-in operator. Convert the arguments, then
12882  // break out so that we will build the appropriate built-in
12883  // operator node.
12884  ExprResult ArgsRes0 = PerformImplicitConversion(
12885  Args[0], Best->BuiltinParamTypes[0], Best->Conversions[0],
12886  AA_Passing, CCK_ForBuiltinOverloadedOp);
12887  if (ArgsRes0.isInvalid())
12888  return ExprError();
12889  Args[0] = ArgsRes0.get();
12890 
12891  ExprResult ArgsRes1 = PerformImplicitConversion(
12892  Args[1], Best->BuiltinParamTypes[1], Best->Conversions[1],
12893  AA_Passing, CCK_ForBuiltinOverloadedOp);
12894  if (ArgsRes1.isInvalid())
12895  return ExprError();
12896  Args[1] = ArgsRes1.get();
12897 
12898  break;
12899  }
12900  }
12901 
12902  case OR_No_Viable_Function: {
12903  PartialDiagnostic PD = CandidateSet.empty()
12904  ? (PDiag(diag::err_ovl_no_oper)
12905  << Args[0]->getType() << /*subscript*/ 0
12906  << Args[0]->getSourceRange() << Args[1]->getSourceRange())
12907  : (PDiag(diag::err_ovl_no_viable_subscript)
12908  << Args[0]->getType() << Args[0]->getSourceRange()
12909  << Args[1]->getSourceRange());
12910  CandidateSet.NoteCandidates(PartialDiagnosticAt(LLoc, PD), *this,
12911  OCD_AllCandidates, Args, "[]", LLoc);
12912  return ExprError();
12913  }
12914 
12915  case OR_Ambiguous:
12916  CandidateSet.NoteCandidates(
12917  PartialDiagnosticAt(LLoc, PDiag(diag::err_ovl_ambiguous_oper_binary)
12918  << "[]" << Args[0]->getType()
12919  << Args[1]->getType()
12920  << Args[0]->getSourceRange()
12921  << Args[1]->getSourceRange()),
12922  *this, OCD_ViableCandidates, Args, "[]", LLoc);
12923  return ExprError();
12924 
12925  case OR_Deleted:
12926  CandidateSet.NoteCandidates(
12927  PartialDiagnosticAt(LLoc, PDiag(diag::err_ovl_deleted_oper)
12928  << "[]" << Args[0]->getSourceRange()
12929  << Args[1]->getSourceRange()),
12930  *this, OCD_AllCandidates, Args, "[]", LLoc);
12931  return ExprError();
12932  }
12933 
12934  // We matched a built-in operator; build it.
12935  return CreateBuiltinArraySubscriptExpr(Args[0], LLoc, Args[1], RLoc);
12936 }
12937 
12938 /// BuildCallToMemberFunction - Build a call to a member
12939 /// function. MemExpr is the expression that refers to the member
12940 /// function (and includes the object parameter), Args/NumArgs are the
12941 /// arguments to the function call (not including the object
12942 /// parameter). The caller needs to validate that the member
12943 /// expression refers to a non-static member function or an overloaded
12944 /// member function.
12945 ExprResult
12947  SourceLocation LParenLoc,
12948  MultiExprArg Args,
12949  SourceLocation RParenLoc) {
12950  assert(MemExprE->getType() == Context.BoundMemberTy ||
12951  MemExprE->getType() == Context.OverloadTy);
12952 
12953  // Dig out the member expression. This holds both the object
12954  // argument and the member function we're referring to.
12955  Expr *NakedMemExpr = MemExprE->IgnoreParens();
12956 
12957  // Determine whether this is a call to a pointer-to-member function.
12958  if (BinaryOperator *op = dyn_cast<BinaryOperator>(NakedMemExpr)) {
12959  assert(op->getType() == Context.BoundMemberTy);
12960  assert(op->getOpcode() == BO_PtrMemD || op->getOpcode() == BO_PtrMemI);
12961 
12962  QualType fnType =
12963  op->getRHS()->getType()->castAs<MemberPointerType>()->getPointeeType();
12964 
12965  const FunctionProtoType *proto = fnType->castAs<FunctionProtoType>();
12966  QualType resultType = proto->getCallResultType(Context);
12968 
12969  // Check that the object type isn't more qualified than the
12970  // member function we're calling.
12971  Qualifiers funcQuals = proto->getMethodQuals();
12972 
12973  QualType objectType = op->getLHS()->getType();
12974  if (op->getOpcode() == BO_PtrMemI)
12975  objectType = objectType->castAs<PointerType>()->getPointeeType();
12976  Qualifiers objectQuals = objectType.getQualifiers();
12977 
12978  Qualifiers difference = objectQuals - funcQuals;
12979  difference.removeObjCGCAttr();
12980  difference.removeAddressSpace();
12981  if (difference) {
12982  std::string qualsString = difference.getAsString();
12983  Diag(LParenLoc, diag::err_pointer_to_member_call_drops_quals)
12984  << fnType.getUnqualifiedType()
12985  << qualsString
12986  << (qualsString.find(' ') == std::string::npos ? 1 : 2);
12987  }
12988 
12989  CXXMemberCallExpr *call =
12990  CXXMemberCallExpr::Create(Context, MemExprE, Args, resultType,
12991  valueKind, RParenLoc, proto->getNumParams());
12992 
12993  if (CheckCallReturnType(proto->getReturnType(), op->getRHS()->getBeginLoc(),
12994  call, nullptr))
12995  return ExprError();
12996 
12997  if (ConvertArgumentsForCall(call, op, nullptr, proto, Args, RParenLoc))
12998  return ExprError();
12999 
13000  if (CheckOtherCall(call, proto))
13001  return ExprError();
13002 
13003  return MaybeBindToTemporary(call);
13004  }
13005 
13006  if (isa<CXXPseudoDestructorExpr>(NakedMemExpr))
13007  return CallExpr::Create(Context, MemExprE, Args, Context.VoidTy, VK_RValue,
13008  RParenLoc);
13009 
13010  UnbridgedCastsSet UnbridgedCasts;
13011  if (checkArgPlaceholdersForOverload(*this, Args, UnbridgedCasts))
13012  return ExprError();
13013 
13014  MemberExpr *MemExpr;
13015  CXXMethodDecl *Method = nullptr;
13016  DeclAccessPair FoundDecl = DeclAccessPair::make(nullptr, AS_public);
13017  NestedNameSpecifier *Qualifier = nullptr;
13018  if (isa<MemberExpr>(NakedMemExpr)) {
13019  MemExpr = cast<MemberExpr>(NakedMemExpr);
13020  Method = cast<CXXMethodDecl>(MemExpr->getMemberDecl());
13021  FoundDecl = MemExpr->getFoundDecl();
13022  Qualifier = MemExpr->getQualifier();
13023  UnbridgedCasts.restore();
13024  } else {
13025  UnresolvedMemberExpr *UnresExpr = cast<UnresolvedMemberExpr>(NakedMemExpr);
13026  Qualifier = UnresExpr->getQualifier();
13027 
13028  QualType ObjectType = UnresExpr->getBaseType();
13029  Expr::Classification ObjectClassification
13031  : UnresExpr->getBase()->Classify(Context);
13032 
13033  // Add overload candidates
13034  OverloadCandidateSet CandidateSet(UnresExpr->getMemberLoc(),
13036 
13037  // FIXME: avoid copy.
13038  TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
13039  if (UnresExpr->hasExplicitTemplateArgs()) {
13040  UnresExpr->copyTemplateArgumentsInto(TemplateArgsBuffer);
13041  TemplateArgs = &TemplateArgsBuffer;
13042  }
13043 
13044  for (UnresolvedMemberExpr::decls_iterator I = UnresExpr->decls_begin(),
13045  E = UnresExpr->decls_end(); I != E; ++I) {
13046 
13047  NamedDecl *Func = *I;
13048  CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(Func->getDeclContext());
13049  if (isa<UsingShadowDecl>(Func))
13050  Func = cast<UsingShadowDecl>(Func)->getTargetDecl();
13051 
13052 
13053  // Microsoft supports direct constructor calls.
13054  if (getLangOpts().MicrosoftExt && isa<CXXConstructorDecl>(Func)) {
13055  AddOverloadCandidate(cast<CXXConstructorDecl>(Func), I.getPair(), Args,
13056  CandidateSet,
13057  /*SuppressUserConversions*/ false);
13058  } else if ((Method = dyn_cast<CXXMethodDecl>(Func))) {
13059  // If explicit template arguments were provided, we can't call a
13060  // non-template member function.
13061  if (TemplateArgs)
13062  continue;
13063 
13064  AddMethodCandidate(Method, I.getPair(), ActingDC, ObjectType,
13065  ObjectClassification, Args, CandidateSet,
13066  /*SuppressUserConversions=*/false);
13067  } else {
13068  AddMethodTemplateCandidate(
13069  cast<FunctionTemplateDecl>(Func), I.getPair(), ActingDC,
13070  TemplateArgs, ObjectType, ObjectClassification, Args, CandidateSet,
13071  /*SuppressUserConversions=*/false);
13072  }
13073  }
13074 
13075  DeclarationName DeclName = UnresExpr->getMemberName();
13076 
13077  UnbridgedCasts.restore();
13078 
13080  switch (CandidateSet.BestViableFunction(*this, UnresExpr->getBeginLoc(),
13081  Best)) {
13082  case OR_Success:
13083  Method = cast<CXXMethodDecl>(Best->Function);
13084  FoundDecl = Best->FoundDecl;
13085  CheckUnresolvedMemberAccess(UnresExpr, Best->FoundDecl);
13086  if (DiagnoseUseOfDecl(Best->FoundDecl, UnresExpr->getNameLoc()))
13087  return ExprError();
13088  // If FoundDecl is different from Method (such as if one is a template
13089  // and the other a specialization), make sure DiagnoseUseOfDecl is
13090  // called on both.
13091  // FIXME: This would be more comprehensively addressed by modifying
13092  // DiagnoseUseOfDecl to accept both the FoundDecl and the decl
13093  // being used.
13094  if (Method != FoundDecl.getDecl() &&
13095  DiagnoseUseOfDecl(Method, UnresExpr->getNameLoc()))
13096  return ExprError();
13097  break;
13098 
13099  case OR_No_Viable_Function:
13100  CandidateSet.NoteCandidates(
13102  UnresExpr->getMemberLoc(),
13103  PDiag(diag::err_ovl_no_viable_member_function_in_call)
13104  << DeclName << MemExprE->getSourceRange()),
13105  *this, OCD_AllCandidates, Args);
13106  // FIXME: Leaking incoming expressions!
13107  return ExprError();
13108 
13109  case OR_Ambiguous:
13110  CandidateSet.NoteCandidates(
13111  PartialDiagnosticAt(UnresExpr->getMemberLoc(),
13112  PDiag(diag::err_ovl_ambiguous_member_call)
13113  << DeclName << MemExprE->getSourceRange()),
13114  *this, OCD_AllCandidates, Args);
13115  // FIXME: Leaking incoming expressions!
13116  return ExprError();
13117 
13118  case OR_Deleted:
13119  CandidateSet.NoteCandidates(
13120  PartialDiagnosticAt(UnresExpr->getMemberLoc(),
13121  PDiag(diag::err_ovl_deleted_member_call)
13122  << DeclName << MemExprE->getSourceRange()),
13123  *this, OCD_AllCandidates, Args);
13124  // FIXME: Leaking incoming expressions!
13125  return ExprError();
13126  }
13127 
13128  MemExprE = FixOverloadedFunctionReference(MemExprE, FoundDecl, Method);
13129 
13130  // If overload resolution picked a static member, build a
13131  // non-member call based on that function.
13132  if (Method->isStatic()) {
13133  return BuildResolvedCallExpr(MemExprE, Method, LParenLoc, Args,
13134  RParenLoc);
13135  }
13136 
13137  MemExpr = cast<MemberExpr>(MemExprE->IgnoreParens());
13138  }
13139 
13140  QualType ResultType = Method->getReturnType();
13141  ExprValueKind VK = Expr::getValueKindForType(ResultType);
13142  ResultType = ResultType.getNonLValueExprType(Context);
13143 
13144  assert(Method && "Member call to something that isn't a method?");
13145  const auto *Proto = Method->getType()->getAs<FunctionProtoType>();
13146  CXXMemberCallExpr *TheCall =
13147  CXXMemberCallExpr::Create(Context, MemExprE, Args, ResultType, VK,
13148  RParenLoc, Proto->getNumParams());
13149 
13150  // Check for a valid return type.
13151  if (CheckCallReturnType(Method->getReturnType(), MemExpr->getMemberLoc(),
13152  TheCall, Method))
13153  return ExprError();
13154 
13155  // Convert the object argument (for a non-static member function call).
13156  // We only need to do this if there was actually an overload; otherwise
13157  // it was done at lookup.
13158  if (!Method->isStatic()) {
13159  ExprResult ObjectArg =
13160  PerformObjectArgumentInitialization(MemExpr->getBase(), Qualifier,
13161  FoundDecl, Method);
13162  if (ObjectArg.isInvalid())
13163  return ExprError();
13164  MemExpr->setBase(ObjectArg.get());
13165  }
13166 
13167  // Convert the rest of the arguments
13168  if (ConvertArgumentsForCall(TheCall, MemExpr, Method, Proto, Args,
13169  RParenLoc))
13170  return ExprError();
13171 
13172  DiagnoseSentinelCalls(Method, LParenLoc, Args);
13173 
13174  if (CheckFunctionCall(Method, TheCall, Proto))
13175  return ExprError();
13176 
13177  // In the case the method to call was not selected by the overloading
13178  // resolution process, we still need to handle the enable_if attribute. Do
13179  // that here, so it will not hide previous -- and more relevant -- errors.
13180  if (auto *MemE = dyn_cast<MemberExpr>(NakedMemExpr)) {
13181  if (const EnableIfAttr *Attr = CheckEnableIf(Method, Args, true)) {
13182  Diag(MemE->getMemberLoc(),
13183  diag::err_ovl_no_viable_member_function_in_call)
13184  << Method << Method->getSourceRange();
13185  Diag(Method->getLocation(),
13186  diag::note_ovl_candidate_disabled_by_function_cond_attr)
13187  << Attr->getCond()->getSourceRange() << Attr->getMessage();
13188  return ExprError();
13189  }
13190  }
13191 
13192  if ((isa<CXXConstructorDecl>(CurContext) ||
13193  isa<CXXDestructorDecl>(CurContext)) &&
13194  TheCall->getMethodDecl()->isPure()) {
13195  const CXXMethodDecl *MD = TheCall->getMethodDecl();
13196 
13197  if (isa<CXXThisExpr>(MemExpr->getBase()->IgnoreParenCasts()) &&
13198  MemExpr->performsVirtualDispatch(getLangOpts())) {
13199  Diag(MemExpr->getBeginLoc(),
13200  diag::warn_call_to_pure_virtual_member_function_from_ctor_dtor)
13201  << MD->getDeclName() << isa<CXXDestructorDecl>(CurContext)
13202  << MD->getParent()->getDeclName();
13203 
13204  Diag(MD->getBeginLoc(), diag::note_previous_decl) << MD->getDeclName();
13205  if (getLangOpts().AppleKext)
13206  Diag(MemExpr->getBeginLoc(), diag::note_pure_qualified_call_kext)
13207  << MD->getParent()->getDeclName() << MD->getDeclName();
13208  }
13209  }
13210 
13211  if (CXXDestructorDecl *DD =
13212  dyn_cast<CXXDestructorDecl>(TheCall->getMethodDecl())) {
13213  // a->A::f() doesn't go through the vtable, except in AppleKext mode.
13214  bool CallCanBeVirtual = !MemExpr->hasQualifier() || getLangOpts().AppleKext;
13215  CheckVirtualDtorCall(DD, MemExpr->getBeginLoc(), /*IsDelete=*/false,
13216  CallCanBeVirtual, /*WarnOnNonAbstractTypes=*/true,
13217  MemExpr->getMemberLoc());
13218  }
13219 
13220  return MaybeBindToTemporary(TheCall);
13221 }
13222 
13223 /// BuildCallToObjectOfClassType - Build a call to an object of class
13224 /// type (C++ [over.call.object]), which can end up invoking an
13225 /// overloaded function call operator (@c operator()) or performing a
13226 /// user-defined conversion on the object argument.
13227 ExprResult
13229  SourceLocation LParenLoc,
13230  MultiExprArg Args,
13231  SourceLocation RParenLoc) {
13232  if (checkPlaceholderForOverload(*this, Obj))
13233  return ExprError();
13234  ExprResult Object = Obj;
13235 
13236  UnbridgedCastsSet UnbridgedCasts;
13237  if (checkArgPlaceholdersForOverload(*this, Args, UnbridgedCasts))
13238  return ExprError();
13239 
13240  assert(Object.get()->getType()->isRecordType() &&
13241  "Requires object type argument");
13242  const RecordType *Record = Object.get()->getType()->getAs<RecordType>();
13243 
13244  // C++ [over.call.object]p1:
13245  // If the primary-expression E in the function call syntax
13246  // evaluates to a class object of type "cv T", then the set of
13247  // candidate functions includes at least the function call
13248  // operators of T. The function call operators of T are obtained by
13249  // ordinary lookup of the name operator() in the context of
13250  // (E).operator().
13251  OverloadCandidateSet CandidateSet(LParenLoc,
13253  DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(OO_Call);
13254 
13255  if (RequireCompleteType(LParenLoc, Object.get()->getType(),
13256  diag::err_incomplete_object_call, Object.get()))
13257  return true;
13258 
13259  LookupResult R(*this, OpName, LParenLoc, LookupOrdinaryName);
13260  LookupQualifiedName(R, Record->getDecl());
13261  R.suppressDiagnostics();
13262 
13263  for (LookupResult::iterator Oper = R.begin(), OperEnd = R.end();
13264  Oper != OperEnd; ++Oper) {
13265  AddMethodCandidate(Oper.getPair(), Object.get()->getType(),
13266  Object.get()->Classify(Context), Args, CandidateSet,
13267  /*SuppressUserConversion=*/false);
13268  }
13269 
13270  // C++ [over.call.object]p2:
13271  // In addition, for each (non-explicit in C++0x) conversion function
13272  // declared in T of the form
13273  //
13274  // operator conversion-type-id () cv-qualifier;
13275  //
13276  // where cv-qualifier is the same cv-qualification as, or a
13277  // greater cv-qualification than, cv, and where conversion-type-id
13278  // denotes the type "pointer to function of (P1,...,Pn) returning
13279  // R", or the type "reference to pointer to function of
13280  // (P1,...,Pn) returning R", or the type "reference to function
13281  // of (P1,...,Pn) returning R", a surrogate call function [...]
13282  // is also considered as a candidate function. Similarly,
13283  // surrogate call functions are added to the set of candidate
13284  // functions for each conversion function declared in an
13285  // accessible base class provided the function is not hidden
13286  // within T by another intervening declaration.
13287  const auto &Conversions =
13288  cast<CXXRecordDecl>(Record->getDecl())->getVisibleConversionFunctions();
13289  for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
13290  NamedDecl *D = *I;
13291  CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext());
13292  if (isa<UsingShadowDecl>(D))
13293  D = cast<UsingShadowDecl>(D)->getTargetDecl();
13294 
13295  // Skip over templated conversion functions; they aren't
13296  // surrogates.
13297  if (isa<FunctionTemplateDecl>(D))
13298  continue;
13299 
13300  CXXConversionDecl *Conv = cast<CXXConversionDecl>(D);
13301  if (!Conv->isExplicit()) {
13302  // Strip the reference type (if any) and then the pointer type (if
13303  // any) to get down to what might be a function type.
13304  QualType ConvType = Conv->getConversionType().getNonReferenceType();
13305  if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>())
13306  ConvType = ConvPtrType->getPointeeType();
13307 
13308  if (const FunctionProtoType *Proto = ConvType->getAs<FunctionProtoType>())
13309  {
13310  AddSurrogateCandidate(Conv, I.getPair(), ActingContext, Proto,
13311  Object.get(), Args, CandidateSet);
13312  }
13313  }
13314  }
13315 
13316  bool HadMultipleCandidates = (CandidateSet.size() > 1);
13317 
13318  // Perform overload resolution.
13320  switch (CandidateSet.BestViableFunction(*this, Object.get()->getBeginLoc(),
13321  Best)) {
13322  case OR_Success:
13323  // Overload resolution succeeded; we'll build the appropriate call
13324  // below.
13325  break;
13326 
13327  case OR_No_Viable_Function: {
13328  PartialDiagnostic PD =
13329  CandidateSet.empty()
13330  ? (PDiag(diag::err_ovl_no_oper)
13331  << Object.get()->getType() << /*call*/ 1
13332  << Object.get()->getSourceRange())
13333  : (PDiag(diag::err_ovl_no_viable_object_call)
13334  << Object.get()->getType() << Object.get()->getSourceRange());
13335  CandidateSet.NoteCandidates(
13336  PartialDiagnosticAt(Object.get()->getBeginLoc(), PD), *this,
13337  OCD_AllCandidates, Args);
13338  break;
13339  }
13340  case OR_Ambiguous:
13341  CandidateSet.NoteCandidates(
13342  PartialDiagnosticAt(Object.get()->getBeginLoc(),
13343  PDiag(diag::err_ovl_ambiguous_object_call)
13344  << Object.get()->getType()
13345  << Object.get()->getSourceRange()),
13346  *this, OCD_ViableCandidates, Args);
13347  break;
13348 
13349  case OR_Deleted:
13350  CandidateSet.NoteCandidates(
13351  PartialDiagnosticAt(Object.get()->getBeginLoc(),
13352  PDiag(diag::err_ovl_deleted_object_call)
13353  << Object.get()->getType()
13354  << Object.get()->getSourceRange()),
13355  *this, OCD_AllCandidates, Args);
13356  break;
13357  }
13358 
13359  if (Best == CandidateSet.end())
13360  return true;
13361 
13362  UnbridgedCasts.restore();
13363 
13364  if (Best->Function == nullptr) {
13365  // Since there is no function declaration, this is one of the
13366  // surrogate candidates. Dig out the conversion function.
13367  CXXConversionDecl *Conv
13368  = cast<CXXConversionDecl>(
13369  Best->Conversions[0].UserDefined.ConversionFunction);
13370 
13371  CheckMemberOperatorAccess(LParenLoc, Object.get(), nullptr,
13372  Best->FoundDecl);
13373  if (DiagnoseUseOfDecl(Best->FoundDecl, LParenLoc))
13374  return ExprError();
13375  assert(Conv == Best->FoundDecl.getDecl() &&
13376  "Found Decl & conversion-to-functionptr should be same, right?!");
13377  // We selected one of the surrogate functions that converts the
13378  // object parameter to a function pointer. Perform the conversion
13379  // on the object argument, then let BuildCallExpr finish the job.
13380 
13381  // Create an implicit member expr to refer to the conversion operator.
13382  // and then call it.
13383  ExprResult Call = BuildCXXMemberCallExpr(Object.get(), Best->FoundDecl,
13384  Conv, HadMultipleCandidates);
13385  if (Call.isInvalid())
13386  return ExprError();
13387  // Record usage of conversion in an implicit cast.
13388  Call = ImplicitCastExpr::Create(Context, Call.get()->getType(),
13389  CK_UserDefinedConversion, Call.get(),
13390  nullptr, VK_RValue);
13391 
13392  return BuildCallExpr(S, Call.get(), LParenLoc, Args, RParenLoc);
13393  }
13394 
13395  CheckMemberOperatorAccess(LParenLoc, Object.get(), nullptr, Best->FoundDecl);
13396 
13397  // We found an overloaded operator(). Build a CXXOperatorCallExpr
13398  // that calls this method, using Object for the implicit object
13399  // parameter and passing along the remaining arguments.
13400  CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
13401 
13402  // An error diagnostic has already been printed when parsing the declaration.
13403  if (Method->isInvalidDecl())
13404  return ExprError();
13405 
13406  const FunctionProtoType *Proto =
13407  Method->getType()->getAs<FunctionProtoType>();
13408 
13409  unsigned NumParams = Proto->getNumParams();
13410 
13411  DeclarationNameInfo OpLocInfo(
13412  Context.DeclarationNames.getCXXOperatorName(OO_Call), LParenLoc);
13413  OpLocInfo.setCXXOperatorNameRange(SourceRange(LParenLoc, RParenLoc));
13414  ExprResult NewFn = CreateFunctionRefExpr(*this, Method, Best->FoundDecl,
13415  Obj, HadMultipleCandidates,
13416  OpLocInfo.getLoc(),
13417  OpLocInfo.getInfo());
13418  if (NewFn.isInvalid())
13419  return true;
13420 
13421  // The number of argument slots to allocate in the call. If we have default
13422  // arguments we need to allocate space for them as well. We additionally
13423  // need one more slot for the object parameter.
13424  unsigned NumArgsSlots = 1 + std::max<unsigned>(Args.size(), NumParams);
13425 
13426  // Build the full argument list for the method call (the implicit object
13427  // parameter is placed at the beginning of the list).
13428  SmallVector<Expr *, 8> MethodArgs(NumArgsSlots);
13429 
13430  bool IsError = false;
13431 
13432  // Initialize the implicit object parameter.
13433  ExprResult ObjRes =
13434  PerformObjectArgumentInitialization(Object.get(), /*Qualifier=*/nullptr,
13435  Best->FoundDecl, Method);
13436  if (ObjRes.isInvalid())
13437  IsError = true;
13438  else
13439  Object = ObjRes;
13440  MethodArgs[0] = Object.get();
13441 
13442  // Check the argument types.
13443  for (unsigned i = 0; i != NumParams; i++) {
13444  Expr *Arg;
13445  if (i < Args.size()) {
13446  Arg = Args[i];
13447 
13448  // Pass the argument.
13449 
13450  ExprResult InputInit
13451  = PerformCopyInitialization(InitializedEntity::InitializeParameter(
13452  Context,
13453  Method->getParamDecl(i)),
13454  SourceLocation(), Arg);
13455 
13456  IsError |= InputInit.isInvalid();
13457  Arg = InputInit.getAs<Expr>();
13458  } else {
13459  ExprResult DefArg
13460  = BuildCXXDefaultArgExpr(LParenLoc, Method, Method->getParamDecl(i));
13461  if (DefArg.isInvalid()) {
13462  IsError = true;
13463  break;
13464  }
13465 
13466  Arg = DefArg.getAs<Expr>();
13467  }
13468 
13469  MethodArgs[i + 1] = Arg;
13470  }
13471 
13472  // If this is a variadic call, handle args passed through "...".
13473  if (Proto->isVariadic()) {
13474  // Promote the arguments (C99 6.5.2.2p7).
13475  for (unsigned i = NumParams, e = Args.size(); i < e; i++) {
13476  ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], VariadicMethod,
13477  nullptr);
13478  IsError |= Arg.isInvalid();
13479  MethodArgs[i + 1] = Arg.get();
13480  }
13481  }
13482 
13483  if (IsError)
13484  return true;
13485 
13486  DiagnoseSentinelCalls(Method, LParenLoc, Args);
13487 
13488  // Once we've built TheCall, all of the expressions are properly owned.
13489  QualType ResultTy = Method->getReturnType();
13491  ResultTy = ResultTy.getNonLValueExprType(Context);
13492 
13493  CXXOperatorCallExpr *TheCall =
13494  CXXOperatorCallExpr::Create(Context, OO_Call, NewFn.get(), MethodArgs,
13495  ResultTy, VK, RParenLoc, FPOptions());
13496 
13497  if (CheckCallReturnType(Method->getReturnType(), LParenLoc, TheCall, Method))
13498  return true;
13499 
13500  if (CheckFunctionCall(Method, TheCall, Proto))
13501  return true;
13502 
13503  return MaybeBindToTemporary(TheCall);
13504 }
13505 
13506 /// BuildOverloadedArrowExpr - Build a call to an overloaded @c operator->
13507 /// (if one exists), where @c Base is an expression of class type and
13508 /// @c Member is the name of the member we're trying to find.
13509 ExprResult
13511  bool *NoArrowOperatorFound) {
13512  assert(Base->getType()->isRecordType() &&
13513  "left-hand side must have class type");
13514 
13515  if (checkPlaceholderForOverload(*this, Base))
13516  return ExprError();
13517 
13518  SourceLocation Loc = Base->getExprLoc();
13519 
13520  // C++ [over.ref]p1:
13521  //
13522  // [...] An expression x->m is interpreted as (x.operator->())->m
13523  // for a class object x of type T if T::operator->() exists and if
13524  // the operator is selected as the best match function by the
13525  // overload resolution mechanism (13.3).
13526  DeclarationName OpName =
13527  Context.DeclarationNames.getCXXOperatorName(OO_Arrow);
13529  const RecordType *BaseRecord = Base->getType()->getAs<RecordType>();
13530 
13531  if (RequireCompleteType(Loc, Base->getType(),
13532  diag::err_typecheck_incomplete_tag, Base))
13533  return ExprError();
13534 
13535  LookupResult R(*this, OpName, OpLoc, LookupOrdinaryName);
13536  LookupQualifiedName(R, BaseRecord->getDecl());
13537  R.suppressDiagnostics();
13538 
13539  for (LookupResult::iterator Oper = R.begin(), OperEnd = R.end();
13540  Oper != OperEnd; ++Oper) {
13541  AddMethodCandidate(Oper.getPair(), Base->getType(), Base->Classify(Context),
13542  None, CandidateSet, /*SuppressUserConversion=*/false);
13543  }
13544 
13545  bool HadMultipleCandidates = (CandidateSet.size() > 1);
13546 
13547  // Perform overload resolution.
13549  switch (CandidateSet.BestViableFunction(*this, OpLoc, Best)) {
13550  case OR_Success:
13551  // Overload resolution succeeded; we'll build the call below.
13552  break;
13553 
13554  case OR_No_Viable_Function: {
13555  auto Cands = CandidateSet.CompleteCandidates(*this, OCD_AllCandidates, Base);
13556  if (CandidateSet.empty()) {
13557  QualType BaseType = Base->getType();
13558  if (NoArrowOperatorFound) {
13559  // Report this specific error to the caller instead of emitting a
13560  // diagnostic, as requested.
13561  *NoArrowOperatorFound = true;
13562  return ExprError();
13563  }
13564  Diag(OpLoc, diag::err_typecheck_member_reference_arrow)
13565  << BaseType << Base->getSourceRange();
13566  if (BaseType->isRecordType() && !BaseType->isPointerType()) {
13567  Diag(OpLoc, diag::note_typecheck_member_reference_suggestion)
13568  << FixItHint::CreateReplacement(OpLoc, ".");
13569  }
13570  } else
13571  Diag(OpLoc, diag::err_ovl_no_viable_oper)
13572  << "operator->" << Base->getSourceRange();
13573  CandidateSet.NoteCandidates(*this, Base, Cands);
13574  return ExprError();
13575  }
13576  case OR_Ambiguous:
13577  CandidateSet.NoteCandidates(
13578  PartialDiagnosticAt(OpLoc, PDiag(diag::err_ovl_ambiguous_oper_unary)
13579  << "->" << Base->getType()
13580  << Base->getSourceRange()),
13581  *this, OCD_ViableCandidates, Base);
13582  return ExprError();
13583 
13584  case OR_Deleted:
13585  CandidateSet.NoteCandidates(
13586  PartialDiagnosticAt(OpLoc, PDiag(diag::err_ovl_deleted_oper)
13587  << "->" << Base->getSourceRange()),
13588  *this, OCD_AllCandidates, Base);
13589  return ExprError();
13590  }
13591 
13592  CheckMemberOperatorAccess(OpLoc, Base, nullptr, Best->FoundDecl);
13593 
13594  // Convert the object parameter.
13595  CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
13597  PerformObjectArgumentInitialization(Base, /*Qualifier=*/nullptr,
13598  Best->FoundDecl, Method);
13599  if (BaseResult.isInvalid())
13600  return ExprError();
13601  Base = BaseResult.get();
13602 
13603  // Build the operator call.
13604  ExprResult FnExpr = CreateFunctionRefExpr(*this, Method, Best->FoundDecl,
13605  Base, HadMultipleCandidates, OpLoc);
13606  if (FnExpr.isInvalid())
13607  return ExprError();
13608 
13609  QualType ResultTy = Method->getReturnType();
13611  ResultTy = ResultTy.getNonLValueExprType(Context);
13613  Context, OO_Arrow, FnExpr.get(), Base, ResultTy, VK, OpLoc, FPOptions());
13614 
13615  if (CheckCallReturnType(Method->getReturnType(), OpLoc, TheCall, Method))
13616  return ExprError();
13617 
13618  if (CheckFunctionCall(Method, TheCall,
13619  Method->getType()->castAs<FunctionProtoType>()))
13620  return ExprError();
13621 
13622  return MaybeBindToTemporary(TheCall);
13623 }
13624 
13625 /// BuildLiteralOperatorCall - Build a UserDefinedLiteral by creating a call to
13626 /// a literal operator described by the provided lookup results.
13628  DeclarationNameInfo &SuffixInfo,
13629  ArrayRef<Expr*> Args,
13630  SourceLocation LitEndLoc,
13631  TemplateArgumentListInfo *TemplateArgs) {
13632  SourceLocation UDSuffixLoc = SuffixInfo.getCXXLiteralOperatorNameLoc();
13633 
13634  OverloadCandidateSet CandidateSet(UDSuffixLoc,
13636  AddFunctionCandidates(R.asUnresolvedSet(), Args, CandidateSet, TemplateArgs,
13637  /*SuppressUserConversions=*/true);
13638 
13639  bool HadMultipleCandidates = (CandidateSet.size() > 1);
13640 
13641  // Perform overload resolution. This will usually be trivial, but might need
13642  // to perform substitutions for a literal operator template.
13644  switch (CandidateSet.BestViableFunction(*this, UDSuffixLoc, Best)) {
13645  case OR_Success:
13646  case OR_Deleted:
13647  break;
13648 
13649  case OR_No_Viable_Function:
13650  CandidateSet.NoteCandidates(
13651  PartialDiagnosticAt(UDSuffixLoc,
13652  PDiag(diag::err_ovl_no_viable_function_in_call)
13653  << R.getLookupName()),
13654  *this, OCD_AllCandidates, Args);
13655  return ExprError();
13656 
13657  case OR_Ambiguous:
13658  CandidateSet.NoteCandidates(
13659  PartialDiagnosticAt(R.getNameLoc(), PDiag(diag::err_ovl_ambiguous_call)
13660  << R.getLookupName()),
13661  *this, OCD_ViableCandidates, Args);
13662  return ExprError();
13663  }
13664 
13665  FunctionDecl *FD = Best->Function;
13666  ExprResult Fn = CreateFunctionRefExpr(*this, FD, Best->FoundDecl,
13667  nullptr, HadMultipleCandidates,
13668  SuffixInfo.getLoc(),
13669  SuffixInfo.getInfo());
13670  if (Fn.isInvalid())
13671  return true;
13672 
13673  // Check the argument types. This should almost always be a no-op, except
13674  // that array-to-pointer decay is applied to string literals.
13675  Expr *ConvArgs[2];
13676  for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
13677  ExprResult InputInit = PerformCopyInitialization(
13679  SourceLocation(), Args[ArgIdx]);
13680  if (InputInit.isInvalid())
13681  return true;
13682  ConvArgs[ArgIdx] = InputInit.get();
13683  }
13684 
13685  QualType ResultTy = FD->getReturnType();
13687  ResultTy = ResultTy.getNonLValueExprType(Context);
13688 
13690  Context, Fn.get(), llvm::makeArrayRef(ConvArgs, Args.size()), ResultTy,
13691  VK, LitEndLoc, UDSuffixLoc);
13692 
13693  if (CheckCallReturnType(FD->getReturnType(), UDSuffixLoc, UDL, FD))
13694  return ExprError();
13695 
13696  if (CheckFunctionCall(FD, UDL, nullptr))
13697  return ExprError();
13698 
13699  return MaybeBindToTemporary(UDL);
13700 }
13701 
13702 /// Build a call to 'begin' or 'end' for a C++11 for-range statement. If the
13703 /// given LookupResult is non-empty, it is assumed to describe a member which
13704 /// will be invoked. Otherwise, the function will be found via argument
13705 /// dependent lookup.
13706 /// CallExpr is set to a valid expression and FRS_Success returned on success,
13707 /// otherwise CallExpr is set to ExprError() and some non-success value
13708 /// is returned.
13711  SourceLocation RangeLoc,
13712  const DeclarationNameInfo &NameInfo,
13713  LookupResult &MemberLookup,
13714  OverloadCandidateSet *CandidateSet,
13715  Expr *Range, ExprResult *CallExpr) {
13716  Scope *S = nullptr;
13717 
13718  CandidateSet->clear(OverloadCandidateSet::CSK_Normal);
13719  if (!MemberLookup.empty()) {
13720  ExprResult MemberRef =
13721  BuildMemberReferenceExpr(Range, Range->getType(), Loc,
13722  /*IsPtr=*/false, CXXScopeSpec(),
13723  /*TemplateKWLoc=*/SourceLocation(),
13724  /*FirstQualifierInScope=*/nullptr,
13725  MemberLookup,
13726  /*TemplateArgs=*/nullptr, S);
13727  if (MemberRef.isInvalid()) {
13728  *CallExpr = ExprError();
13729  return FRS_DiagnosticIssued;
13730  }
13731  *CallExpr = BuildCallExpr(S, MemberRef.get(), Loc, None, Loc, nullptr);
13732  if (CallExpr->isInvalid()) {
13733  *CallExpr = ExprError();
13734  return FRS_DiagnosticIssued;
13735  }
13736  } else {
13737  UnresolvedSet<0> FoundNames;
13738  UnresolvedLookupExpr *Fn =
13739  UnresolvedLookupExpr::Create(Context, /*NamingClass=*/nullptr,
13740  NestedNameSpecifierLoc(), NameInfo,
13741  /*NeedsADL=*/true, /*Overloaded=*/false,
13742  FoundNames.begin(), FoundNames.end());
13743 
13744  bool CandidateSetError = buildOverloadedCallSet(S, Fn, Fn, Range, Loc,
13745  CandidateSet, CallExpr);
13746  if (CandidateSet->empty() || CandidateSetError) {
13747  *CallExpr = ExprError();
13748  return FRS_NoViableFunction;
13749  }
13751  OverloadingResult OverloadResult =
13752  CandidateSet->BestViableFunction(*this, Fn->getBeginLoc(), Best);
13753 
13754  if (OverloadResult == OR_No_Viable_Function) {
13755  *CallExpr = ExprError();
13756  return FRS_NoViableFunction;
13757  }
13758  *CallExpr = FinishOverloadedCallExpr(*this, S, Fn, Fn, Loc, Range,
13759  Loc, nullptr, CandidateSet, &Best,
13760  OverloadResult,
13761  /*AllowTypoCorrection=*/false);
13762  if (CallExpr->isInvalid() || OverloadResult != OR_Success) {
13763  *CallExpr = ExprError();
13764  return FRS_DiagnosticIssued;
13765  }
13766  }
13767  return FRS_Success;
13768 }
13769 
13770 
13771 /// FixOverloadedFunctionReference - E is an expression that refers to
13772 /// a C++ overloaded function (possibly with some parentheses and
13773 /// perhaps a '&' around it). We have resolved the overloaded function
13774 /// to the function declaration Fn, so patch up the expression E to
13775 /// refer (possibly indirectly) to Fn. Returns the new expr.
13777  FunctionDecl *Fn) {
13778  if (ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
13779  Expr *SubExpr = FixOverloadedFunctionReference(PE->getSubExpr(),
13780  Found, Fn);
13781  if (SubExpr == PE->getSubExpr())
13782  return PE;
13783 
13784  return new (Context) ParenExpr(PE->getLParen(), PE->getRParen(), SubExpr);
13785  }
13786 
13787  if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
13788  Expr *SubExpr = FixOverloadedFunctionReference(ICE->getSubExpr(),
13789  Found, Fn);
13790  assert(Context.hasSameType(ICE->getSubExpr()->getType(),
13791  SubExpr->getType()) &&
13792  "Implicit cast type cannot be determined from overload");
13793  assert(ICE->path_empty() && "fixing up hierarchy conversion?");
13794  if (SubExpr == ICE->getSubExpr())
13795  return ICE;
13796 
13797  return ImplicitCastExpr::Create(Context, ICE->getType(),
13798  ICE->getCastKind(),
13799  SubExpr, nullptr,
13800  ICE->getValueKind());
13801  }
13802 
13803  if (auto *GSE = dyn_cast<GenericSelectionExpr>(E)) {
13804  if (!GSE->isResultDependent()) {
13805  Expr *SubExpr =
13806  FixOverloadedFunctionReference(GSE->getResultExpr(), Found, Fn);
13807  if (SubExpr == GSE->getResultExpr())
13808  return GSE;
13809 
13810  // Replace the resulting type information before rebuilding the generic
13811  // selection expression.
13812  ArrayRef<Expr *> A = GSE->getAssocExprs();
13813  SmallVector<Expr *, 4> AssocExprs(A.begin(), A.end());
13814  unsigned ResultIdx = GSE->getResultIndex();
13815  AssocExprs[ResultIdx] = SubExpr;
13816 
13818  Context, GSE->getGenericLoc(), GSE->getControllingExpr(),
13819  GSE->getAssocTypeSourceInfos(), AssocExprs, GSE->getDefaultLoc(),
13820  GSE->getRParenLoc(), GSE->containsUnexpandedParameterPack(),
13821  ResultIdx);
13822  }
13823  // Rather than fall through to the unreachable, return the original generic
13824  // selection expression.
13825  return GSE;
13826  }
13827 
13828  if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(E)) {
13829  assert(UnOp->getOpcode() == UO_AddrOf &&
13830  "Can only take the address of an overloaded function");
13831  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) {
13832  if (Method->isStatic()) {
13833  // Do nothing: static member functions aren't any different
13834  // from non-member functions.
13835  } else {
13836  // Fix the subexpression, which really has to be an
13837  // UnresolvedLookupExpr holding an overloaded member function
13838  // or template.
13839  Expr *SubExpr = FixOverloadedFunctionReference(UnOp->getSubExpr(),
13840  Found, Fn);
13841  if (SubExpr == UnOp->getSubExpr())
13842  return UnOp;
13843 
13844  assert(isa<DeclRefExpr>(SubExpr)
13845  && "fixed to something other than a decl ref");
13846  assert(cast<DeclRefExpr>(SubExpr)->getQualifier()
13847  && "fixed to a member ref with no nested name qualifier");
13848 
13849  // We have taken the address of a pointer to member
13850  // function. Perform the computation here so that we get the
13851  // appropriate pointer to member type.
13852  QualType ClassType
13853  = Context.getTypeDeclType(cast<RecordDecl>(Method->getDeclContext()));
13854  QualType MemPtrType
13855  = Context.getMemberPointerType(Fn->getType(), ClassType.getTypePtr());
13856  // Under the MS ABI, lock down the inheritance model now.
13857  if (Context.getTargetInfo().getCXXABI().isMicrosoft())
13858  (void)isCompleteType(UnOp->getOperatorLoc(), MemPtrType);
13859 
13860  return new (Context) UnaryOperator(SubExpr, UO_AddrOf, MemPtrType,
13862  UnOp->getOperatorLoc(), false);
13863  }
13864  }
13865  Expr *SubExpr = FixOverloadedFunctionReference(UnOp->getSubExpr(),
13866  Found, Fn);
13867  if (SubExpr == UnOp->getSubExpr())
13868  return UnOp;
13869 
13870  return new (Context) UnaryOperator(SubExpr, UO_AddrOf,
13871  Context.getPointerType(SubExpr->getType()),
13873  UnOp->getOperatorLoc(), false);
13874  }
13875 
13876  // C++ [except.spec]p17:
13877  // An exception-specification is considered to be needed when:
13878  // - in an expression the function is the unique lookup result or the
13879  // selected member of a set of overloaded functions
13880  if (auto *FPT = Fn->getType()->getAs<FunctionProtoType>())
13881  ResolveExceptionSpec(E->getExprLoc(), FPT);
13882 
13883  if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
13884  // FIXME: avoid copy.
13885  TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
13886  if (ULE->hasExplicitTemplateArgs()) {
13887  ULE->copyTemplateArgumentsInto(TemplateArgsBuffer);
13888  TemplateArgs = &TemplateArgsBuffer;
13889  }
13890 
13891  DeclRefExpr *DRE =
13892  BuildDeclRefExpr(Fn, Fn->getType(), VK_LValue, ULE->getNameInfo(),
13893  ULE->getQualifierLoc(), Found.getDecl(),
13894  ULE->getTemplateKeywordLoc(), TemplateArgs);
13895  DRE->setHadMultipleCandidates(ULE->getNumDecls() > 1);
13896  return DRE;
13897  }
13898 
13899  if (UnresolvedMemberExpr *MemExpr = dyn_cast<UnresolvedMemberExpr>(E)) {
13900  // FIXME: avoid copy.
13901  TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
13902  if (MemExpr->hasExplicitTemplateArgs()) {
13903  MemExpr->copyTemplateArgumentsInto(TemplateArgsBuffer);
13904  TemplateArgs = &TemplateArgsBuffer;
13905  }
13906 
13907  Expr *Base;
13908 
13909  // If we're filling in a static method where we used to have an
13910  // implicit member access, rewrite to a simple decl ref.
13911  if (MemExpr->isImplicitAccess()) {
13912  if (cast<CXXMethodDecl>(Fn)->isStatic()) {
13913  DeclRefExpr *DRE = BuildDeclRefExpr(
13914  Fn, Fn->getType(), VK_LValue, MemExpr->getNameInfo(),
13915  MemExpr->getQualifierLoc(), Found.getDecl(),
13916  MemExpr->getTemplateKeywordLoc(), TemplateArgs);
13917  DRE->setHadMultipleCandidates(MemExpr->getNumDecls() > 1);
13918  return DRE;
13919  } else {
13920  SourceLocation Loc = MemExpr->getMemberLoc();
13921  if (MemExpr->getQualifier())
13922  Loc = MemExpr->getQualifierLoc().getBeginLoc();
13923  Base =
13924  BuildCXXThisExpr(Loc, MemExpr->getBaseType(), /*IsImplicit=*/true);
13925  }
13926  } else
13927  Base = MemExpr->getBase();
13928 
13929  ExprValueKind valueKind;
13930  QualType type;
13931  if (cast<CXXMethodDecl>(Fn)->isStatic()) {
13932  valueKind = VK_LValue;
13933  type = Fn->getType();
13934  } else {
13935  valueKind = VK_RValue;
13936  type = Context.BoundMemberTy;
13937  }
13938 
13939  return BuildMemberExpr(
13940  Base, MemExpr->isArrow(), MemExpr->getOperatorLoc(),
13941  MemExpr->getQualifierLoc(), MemExpr->getTemplateKeywordLoc(), Fn, Found,
13942  /*HadMultipleCandidates=*/true, MemExpr->getMemberNameInfo(),
13943  type, valueKind, OK_Ordinary, TemplateArgs);
13944  }
13945 
13946  llvm_unreachable("Invalid reference to overloaded function");
13947 }
13948 
13950  DeclAccessPair Found,
13951  FunctionDecl *Fn) {
13952  return FixOverloadedFunctionReference(E.get(), Found, Fn);
13953 }
Abstract class used to diagnose incomplete types.
Definition: Sema.h:1595
Condition in an explicit(bool) specifier.
Definition: Sema.h:2816
unsigned ExplicitCallArguments
The number of call arguments that were explicitly provided, to be used while performing partial order...
Definition: Overload.h:792
A call to an overloaded operator written using operator syntax.
Definition: ExprCXX.h:77
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
const ObjCInterfaceType * getInterfaceType() const
If this pointer points to an Objective C @interface type, gets the type for that interface.
Definition: Type.cpp:1553
void setValueDependent(bool VD)
Set whether this expression is value-dependent or not.
Definition: Expr.h:161
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Function pointer conversion (C++17 [conv.fctptr])
Definition: Overload.h:92
DeclAccessPair FoundConversionFunction
The declaration that we found via name lookup, which might be the same as ConversionFunction or it mi...
Definition: Overload.h:382
Defines the clang::ASTContext interface.
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
unsigned DeprecatedStringLiteralToCharPtr
Whether this is the deprecated conversion of a string literal to a pointer to non-const character dat...
Definition: Overload.h:249
void clear(CandidateSetKind CSK)
Clear out all of the candidates.
(CUDA) This candidate was not viable because the callee was not accessible from the caller&#39;s target (...
Definition: Overload.h:702
unsigned getNumDecls() const
Gets the number of declarations in the unresolved set.
Definition: ExprCXX.h:2853
CanQualType LongLongTy
Definition: ASTContext.h:1023
This candidate constructor or conversion fonction is used implicitly but the explicit(bool) specifier...
Definition: Overload.h:711
Represents a function declaration or definition.
Definition: Decl.h:1748
NamespaceDecl * getStdNamespace() const
void setStdInitializerListElement(bool V=true)
Definition: Overload.h:649
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:363
CUDA Target attributes do not match.
Definition: Sema.h:7288
static void markUnaddressableCandidatesUnviable(Sema &S, OverloadCandidateSet &CS)
bool hasExplicitTemplateArgs() const
Determines whether this expression had explicit template arguments.
Definition: ExprCXX.h:2901
void removeUnaligned()
Definition: Type.h:297
ExprResult PerformContextuallyConvertToBool(Expr *From)
PerformContextuallyConvertToBool - Perform a contextual conversion of the expression From to bool (C+...
no exception specification
const TemplateArgument * getSecondArg()
Return the second template argument this deduction failure refers to, if any.
Smart pointer class that efficiently represents Objective-C method names.
static bool isTypeValid(QualType T)
Determine whether the given type is valid, e.g., it is not an invalid C++ class.
QualType getObjCIdType() const
Represents the Objective-CC id type.
Definition: ASTContext.h:1854
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2569
QualType getPointeeType() const
Definition: Type.h:2582
A (possibly-)qualified type.
Definition: Type.h:643
bool isBlockPointerType() const
Definition: Type.h:6392
static void DiagnoseArityMismatch(Sema &S, NamedDecl *Found, Decl *D, unsigned NumFormalArgs)
General arity mismatch diagnosis over a candidate in a candidate set.
void AddMethodCandidate(DeclAccessPair FoundDecl, QualType ObjectType, Expr::Classification ObjectClassification, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversion=false)
AddMethodCandidate - Adds a named decl (which is some kind of method) as a method candidate to the gi...
TemplateDeductionResult
Describes the result of template argument deduction.
Definition: Sema.h:7239
bool isArrayType() const
Definition: Type.h:6440
bool isMemberPointerType() const
Definition: Type.h:6422
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
Definition: Expr.h:2890
ImplicitConversionKind
ImplicitConversionKind - The kind of implicit conversion used to convert an argument to a parameter&#39;s...
Definition: Overload.h:78
unsigned param_size() const
Definition: DeclObjC.h:340
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:303
const DeclarationNameLoc & getInfo() const
llvm::PointerUnion3< TemplateTypeParmDecl *, NonTypeTemplateParmDecl *, TemplateTemplateParmDecl * > TemplateParameter
Stores a template parameter of any kind.
Definition: DeclTemplate.h:61
Conversion not allowed by the C standard, but that we accept as an extension anyway.
Definition: Overload.h:195
static bool IsTransparentUnionStandardConversion(Sema &S, Expr *From, QualType &ToType, bool InOverloadResolution, StandardConversionSequence &SCS, bool CStyle)
Template argument deduction was successful.
Definition: Sema.h:7241
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:3224
const Expr * getInit(unsigned Init) const
Definition: Expr.h:4419
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:1022
QualType getPointerDiffType() const
Return the unique type for "ptrdiff_t" (C99 7.17) defined in <stddef.h>.
A structure used to record information about a failed template argument deduction, for diagnosis.
Checking non-dependent argument conversions failed.
Definition: Sema.h:7284
Cannot tell whether this is a narrowing conversion because the expression is value-dependent.
Definition: Overload.h:218
bool isArithmeticType() const
Definition: Type.cpp:1983
specific_attr_iterator< T > specific_attr_begin() const
Definition: DeclBase.h:529
Kind getKind() const
Definition: Type.h:2450
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3387
Provides information about an attempted template argument deduction, whose success or failure was des...
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:505
bool isMain() const
Determines whether this function is "main", which is the entry point into an executable program...
Definition: Decl.cpp:2837
bool diagnoseArgDependentDiagnoseIfAttrs(const FunctionDecl *Function, const Expr *ThisArg, ArrayRef< const Expr *> Args, SourceLocation Loc)
Emit diagnostics for the diagnose_if attributes on Function, ignoring any non-ArgDependent DiagnoseIf...
Vector conversions.
Definition: Overload.h:134
bool isRealFloatingType() const
Floating point categories.
Definition: Type.cpp:1968
static CallExpr * CreateTemporary(void *Mem, Expr *Fn, QualType Ty, ExprValueKind VK, SourceLocation RParenLoc, ADLCallKind UsesADL=NotADL)
Create a temporary call expression with no arguments in the memory pointed to by Mem.
Definition: Expr.cpp:1388
bool hasPlaceholderType() const
Returns whether this expression has a placeholder type.
Definition: Expr.h:481
void clear()
Clear out all of the candidates.
ConversionSet::const_iterator const_iterator
Definition: Overload.h:424
QualType getThisType() const
Return the type of the this pointer.
Definition: DeclCXX.cpp:2275
Complex conversions (C99 6.3.1.6)
Definition: Overload.h:113
void setObjCLifetime(ObjCLifetime type)
Definition: Type.h:330
bool isRecordType() const
Definition: Type.h:6464
static void DiagnoseFailedExplicitSpec(Sema &S, OverloadCandidate *Cand)
Expr * getBase() const
Definition: Expr.h:2884
bool isEmpty() const
No scope specifier.
Definition: DeclSpec.h:189
std::string getTemplateArgumentBindingsText(const TemplateParameterList *Params, const TemplateArgumentList &Args)
Produces a formatted string that describes the binding of template parameters to template arguments...
static InitializedEntity InitializeParameter(ASTContext &Context, const ParmVarDecl *Parm)
Create the initialization entity for a parameter.
UserDefinedConversionSequence UserDefined
When ConversionKind == UserDefinedConversion, provides the details of the user-defined conversion seq...
Definition: Overload.h:529
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:1938
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type...
const Type * getTypeForDecl() const
Definition: Decl.h:2931
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1362
ConstructorInfo getConstructorInfo(NamedDecl *ND)
Definition: Overload.h:1023
bool isBetterOverloadCandidate(Sema &S, const OverloadCandidate &Cand1, const OverloadCandidate &Cand2, SourceLocation Loc, OverloadCandidateSet::CandidateSetKind Kind)
isBetterOverloadCandidate - Determines whether the first overload candidate is a better candidate tha...
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:88
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:34
bool isVariadic() const
Whether this function prototype is variadic.
Definition: Type.h:4035
__DEVICE__ long long abs(long long __n)
ExprResult BuildCallToMemberFunction(Scope *S, Expr *MemExpr, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc)
BuildCallToMemberFunction - Build a call to a member function.
static ImplicitConversionSequence::CompareKind CompareDerivedToBaseConversions(Sema &S, SourceLocation Loc, const StandardConversionSequence &SCS1, const StandardConversionSequence &SCS2)
CompareDerivedToBaseConversions - Compares two standard conversion sequences to determine whether the...
static TemplateDecl * getDescribedTemplate(Decl *Templated)
bool isExtVectorType() const
Definition: Type.h:6480
AssignConvertType
AssignConvertType - All of the &#39;assignment&#39; semantic checks return this enum to indicate whether the ...
Definition: Sema.h:9872
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
Definition: ExprCXX.h:2943
ExprResult PerformContextualImplicitConversion(SourceLocation Loc, Expr *FromE, ContextualImplicitConverter &Converter)
Perform a contextual implicit conversion.
bool IsOverload(FunctionDecl *New, FunctionDecl *Old, bool IsForUsingDecl, bool ConsiderCudaAttrs=true)
ConstExprUsage
Indicates how the constant expression will be used.
Definition: Expr.h:686
StringRef P
OverloadedOperatorKind getCXXOverloadedOperator() const
If this name is the name of an overloadable operator in C++ (e.g., operator+), retrieve the kind of o...
Classification Classify(ASTContext &Ctx) const
Classify - Classify this expression according to the C++11 expression taxonomy.
Definition: Expr.h:386
Not a narrowing conversion.
Definition: Overload.h:204
ExplicitSpecifier getExplicitSpecifier()
Definition: DeclCXX.h:2924
bool isBeforeInTranslationUnit(SourceLocation LHS, SourceLocation RHS) const
Determines the order of 2 source locations in the translation unit.
llvm::iterator_range< conversion_iterator > getVisibleConversionFunctions()
Get all conversion functions visible in current class, including conversion function templates...
Definition: DeclCXX.cpp:1593
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:1964
NamedDecl * getDecl() const
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
Definition: Type.h:6333
bool CanPerformCopyInitialization(const InitializedEntity &Entity, ExprResult Init)
Definition: SemaInit.cpp:9216
ImplicitConversionRank
ImplicitConversionRank - The rank of an implicit conversion kind.
Definition: Overload.h:171
bool hasQualifier() const
Determines whether this member expression actually had a C++ nested-name-specifier prior to the name ...
Definition: Expr.h:2904
ExplicitSpecKind getKind() const
Definition: DeclCXX.h:2009
The base class of the type hierarchy.
Definition: Type.h:1433
CanQualType LongTy
Definition: ASTContext.h:1023
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
unsigned IncompatibleObjC
IncompatibleObjC - Whether this is an Objective-C conversion that we should warn about (if we actuall...
Definition: Overload.h:257
static bool convertArgsForAvailabilityChecks(Sema &S, FunctionDecl *Function, Expr *ThisArg, ArrayRef< Expr *> Args, Sema::SFINAETrap &Trap, bool MissingImplicitThis, Expr *&ConvertedThis, SmallVectorImpl< Expr *> &ConvertedArgs)
ForRangeStatus
Definition: Sema.h:3123
Represent a C++ namespace.
Definition: Decl.h:514
Template argument deduction produced inconsistent deduced values for the given template parameter...
Definition: Sema.h:7255
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Definition: Sema.cpp:47
static ExprValueKind getValueKindForType(QualType T)
getValueKindForType - Given a formal return or parameter type, give its value kind.
Definition: Expr.h:404
bool isRestrictQualified() const
Determine whether this type is restrict-qualified.
Definition: Type.h:6206
Ambiguous candidates found.
Definition: Overload.h:59
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:693
Store information needed for an explicit specifier.
Definition: DeclCXX.h:2001
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
Definition: Type.h:6053
Conversions between compatible types in C99.
Definition: Overload.h:128
Floating point control options.
Definition: LangOptions.h:307
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:265
bool IgnoreObjectArgument
IgnoreObjectArgument - True to indicate that the first argument&#39;s conversion, which for this function...
Definition: Overload.h:781
QualType getConversionType() const
Returns the type that this conversion function is converting to.
Definition: DeclCXX.h:2936
Partial ordering of function templates for a call to a conversion function.
Definition: Template.h:166
unsigned DirectBinding
DirectBinding - True when this is a reference binding that is a direct binding (C++ [dcl...
Definition: Overload.h:265
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2574
LLVM_ATTRIBUTE_REINITIALIZES void clear()
Clears out any current state.
Definition: Lookup.h:554
float __ovld __cnfn distance(float p0, float p1)
Returns the distance between p0 and p1.
size_t param_size() const
Definition: Decl.h:2305
QualType getElementType() const
Definition: Type.h:2879
static unsigned RankDeductionFailure(const DeductionFailureInfo &DFI)
const RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
Definition: Type.cpp:540
static CXXOperatorCallExpr * Create(const ASTContext &Ctx, OverloadedOperatorKind OpKind, Expr *Fn, ArrayRef< Expr *> Args, QualType Ty, ExprValueKind VK, SourceLocation OperatorLoc, FPOptions FPFeatures, ADLCallKind UsesADL=NotADL)
Definition: ExprCXX.cpp:559
Exact Match.
Definition: Overload.h:173
static bool isFunctionAlwaysEnabled(const ASTContext &Ctx, const FunctionDecl *FD)
bool isUnsignedIntegerType() const
Return true if this is an integer type that is unsigned, according to C99 6.2.5p6 [which returns true...
Definition: Type.cpp:1915
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
Definition: DeclSpec.cpp:124
RAII object that enters a new expression evaluation context.
Definition: Sema.h:11259
QualType getFromType() const
Definition: Overload.h:316
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
Definition: SemaInternal.h:24
void AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet, bool PartialOverloading=false)
Add the overload candidates named by callee and/or found by argument dependent lookup to the given ov...
ExprResult PerformObjectArgumentInitialization(Expr *From, NestedNameSpecifier *Qualifier, NamedDecl *FoundDecl, CXXMethodDecl *Method)
PerformObjectArgumentInitialization - Perform initialization of the implicit object parameter for the...
static bool isAllowableExplicitConversion(Sema &S, QualType ConvType, QualType ToType, bool AllowObjCPointerConversion)
Determine whether this is an allowable conversion from the result of an explicit conversion operator ...
DeclarationName getLookupName() const
Gets the name to look up.
Definition: Lookup.h:243
void removeObjCLifetime()
Definition: Type.h:333
QualType getReturnType() const
Definition: Decl.h:2329
DiagnosticsEngine & Diags
Definition: Sema.h:376
unsigned getNumParams() const
Definition: Type.h:3921
bool isEnumeralType() const
Definition: Type.h:6468
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6851
static ExprResult FinishOverloadedCallExpr(Sema &SemaRef, Scope *S, Expr *Fn, UnresolvedLookupExpr *ULE, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc, Expr *ExecConfig, OverloadCandidateSet *CandidateSet, OverloadCandidateSet::iterator *Best, OverloadingResult OverloadResult, bool AllowTypoCorrection)
FinishOverloadedCallExpr - given an OverloadCandidateSet, builds and returns the completed call expre...
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
Definition: Sema.h:2338
CanQualType Float128Ty
Definition: ASTContext.h:1026
OverloadKind CheckOverload(Scope *S, FunctionDecl *New, const LookupResult &OldDecls, NamedDecl *&OldDecl, bool IsForUsingDecl)
Determine whether the given New declaration is an overload of the declarations in Old...
static bool functionHasPassObjectSizeParams(const FunctionDecl *FD)
Extra information about a function prototype.
Definition: Type.h:3799
bool IsSurrogate
IsSurrogate - True to indicate that this candidate is a surrogate for a conversion to a function poin...
Definition: Overload.h:772
static ImplicitConversionSequence::CompareKind CompareQualificationConversions(Sema &S, const StandardConversionSequence &SCS1, const StandardConversionSequence &SCS2)
CompareQualificationConversions - Compares two standard conversion sequences to determine whether the...
LangAS
Defines the address space values used by the address space qualifier of QualType. ...
Definition: AddressSpaces.h:25
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:138
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:431
QualType ExtractUnqualifiedFunctionType(QualType PossiblyAFunctionType)
QualType getMemberPointerType(QualType T, const Type *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
DeclarationName getName() const
Gets the name looked up.
Definition: ExprCXX.h:2859
bool HadMultipleCandidates
HadMultipleCandidates - When this is true, it means that the conversion function was resolved from an...
Definition: Overload.h:368
bool isInvalidDecl() const
Definition: DeclBase.h:553
Like System, but searched after the system directories.
Decl * Specialization
Specialization - The actual specialization that this candidate represents.
bool requiresADL() const
True if this declaration should be extended by argument-dependent lookup.
Definition: ExprCXX.h:3011
static bool DiagnoseTwoPhaseOperatorLookup(Sema &SemaRef, OverloadedOperatorKind Op, SourceLocation OpLoc, ArrayRef< Expr *> Args)
Attempt to recover from ill-formed use of a non-dependent operator in a template, where the non-depen...
bool IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType)
IsIntegralPromotion - Determines whether the conversion from the expression From (whose potentially-a...
CharSourceRange getSourceRange(const SourceRange &Range)
Returns the token CharSourceRange corresponding to Range.
Definition: FixIt.h:32
bool isStatic() const
Definition: DeclCXX.cpp:1938
bool hasDefinition() const
Definition: DeclCXX.h:778
std::vector< FixItHint > Hints
The list of Hints generated so far.
Represents a parameter to a function.
Definition: Decl.h:1564
QualType getLocalUnqualifiedType() const
Return this type with all of the instance-specific qualifiers removed, but without removing any quali...
Definition: Type.h:882
Defines the clang::Expr interface and subclasses for C++ expressions.
TemplateParameter Param
The template parameter to which a template argument deduction failure refers.
long i
Definition: xmmintrin.h:1456
static const TemplateDecl * isTemplate(const NamedDecl *ND, const TemplateArgumentList *&TemplateArgs)
Conversion.
Definition: Overload.h:179
void * ToTypePtrs[3]
ToType - The types that this conversion is converting to in each step.
Definition: Overload.h:293
The collection of all-type qualifiers we support.
Definition: Type.h:137
FieldDecl * getSourceBitField()
If this expression refers to a bit-field, retrieve the declaration of that bit-field.
Definition: Expr.cpp:3815
bool isObjCObjectOrInterfaceType() const
Definition: Type.h:6496
bool UnwrapSimilarTypes(QualType &T1, QualType &T2)
Attempt to unwrap two types that may be similar (C++ [conv.qual]).
Qualifiers getQualifiers() const
Retrieve all qualifiers.
OverloadCandidate & addCandidate(unsigned NumConversions=0, ConversionSequenceList Conversions=None)
Add a new candidate with NumConversions conversion sequence slots to the overload set...
Definition: Overload.h:960
ExprResult PerformImplicitConversion(Expr *From, QualType ToType, AssignmentAction Action, bool AllowExplicit=false)
PerformImplicitConversion - Perform an implicit conversion of the expression From to the type ToType...
bool isMoveAssignmentOperator() const
Determine whether this is a move assignment operator.
Definition: DeclCXX.cpp:2204
Expr * FixOverloadedFunctionReference(Expr *E, DeclAccessPair FoundDecl, FunctionDecl *Fn)
FixOverloadedFunctionReference - E is an expression that refers to a C++ overloaded function (possibl...
Represents a struct/union/class.
Definition: Decl.h:3626
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:297
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context encloses the declaration context DC.
Definition: DeclBase.cpp:1152
Boolean conversions (C++ [conv.bool])
Definition: Overload.h:125
One of these records is kept for each identifier that is lexed.
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Definition: TargetInfo.h:1054
Value of a non-type template parameter.
Definition: Sema.h:2813
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: ExprCXX.h:3799
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:154
A C++ nested-name-specifier augmented with source location information.
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
Definition: Sema.h:7818
void dump() const
dump - Print this implicit conversion sequence to standard error.
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
Definition: Type.cpp:4004
static bool diagnoseNoViableConversion(Sema &SemaRef, SourceLocation Loc, Expr *&From, Sema::ContextualImplicitConverter &Converter, QualType T, bool HadMultipleCandidates, UnresolvedSetImpl &ExplicitConversions)
unsigned BindsToFunctionLvalue
Whether we&#39;re binding to a function lvalue.
Definition: Overload.h:272
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
C++ [over.match.copy]: Copy-initialization of an object of class type by user-defined conversion...
Definition: Overload.h:862
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
BadConversionSequence Bad
When ConversionKind == BadConversion, provides the details of the bad conversion. ...
Definition: Overload.h:537
bool isCharType() const
Definition: Type.cpp:1818
bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base)
Determine whether the type Derived is a C++ class that is derived from the type Base.
field_range fields() const
Definition: Decl.h:3841
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.cpp:263
NameKind getNameKind() const
Determine what kind of name this is.
bool isObjCIdType() const
Definition: Type.h:6517
Represents a member of a struct/union/class.
Definition: Decl.h:2607
Expr * getBase()
Retrieve the base object of this member expressions, e.g., the x in x.m.
Definition: ExprCXX.h:3754
Identity conversion (no conversion)
Definition: Overload.h:80
CallExpr::ADLCallKind IsADLCandidate
True if the candidate was found using ADL.
Definition: Overload.h:784
bool isStdInitializerListElement() const
Whether the target is really a std::initializer_list, and the sequence only represents the worst elem...
Definition: Overload.h:645
ConversionSet & conversions()
Definition: Overload.h:407
bool buildOverloadedCallSet(Scope *S, Expr *Fn, UnresolvedLookupExpr *ULE, MultiExprArg Args, SourceLocation RParenLoc, OverloadCandidateSet *CandidateSet, ExprResult *Result)
Constructs and populates an OverloadedCandidateSet from the given function.
Floating point conversions (C++ [conv.double].
Definition: Overload.h:110
virtual SemaDiagnosticBuilder diagnoseConversion(Sema &S, SourceLocation Loc, QualType T, QualType ConvTy)=0
Emits a diagnostic when we picked a conversion function (for cases when we are not allowed to pick a ...
bool isReferenceType() const
Definition: Type.h:6396
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:31
ExprResult PerformContextuallyConvertToObjCPointer(Expr *From)
PerformContextuallyConvertToObjCPointer - Perform a contextual conversion of the expression From to a...
bool match(QualType T) override
Match an integral or (possibly scoped) enumeration type.
bool isSpecialized() const
Whether this type is specialized, meaning that it has type arguments.
Definition: Type.h:5957
CompatiblePointerDiscardsQualifiers - The assignment discards c/v/r qualifiers, which we accept as an...
Definition: Sema.h:9900
void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const
Copies the template arguments into the given structure.
Definition: ExprCXX.h:2921
Represents a C++ member access expression for which lookup produced a set of overloaded functions...
Definition: ExprCXX.h:3677
Ref_Incompatible - The two types are incompatible, so direct reference binding is not possible...
Definition: Sema.h:10131
CUDAFunctionTarget IdentifyCUDATarget(const FunctionDecl *D, bool IgnoreImplicitHDAttr=false)
Determines whether the given function is a CUDA device/host/kernel/etc.
Definition: SemaCUDA.cpp:106
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Decl.h:738
ConversionSequenceList allocateConversionSequences(unsigned NumConversions)
Allocate storage for conversion sequences for NumConversions conversions.
Definition: Overload.h:947
specific_attr_iterator< T > specific_attr_end() const
Definition: DeclBase.h:534
void set(DeclAccessPair Found, Decl *Spec, DeductionFailureInfo Info)
bool isFloat() const
Definition: APValue.h:318
OverloadKind
C++ Overloading.
Definition: Sema.h:2715
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:6314
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
Definition: Type.h:6747
Describes a module or submodule.
Definition: Module.h:64
OverloadCandidateDisplayKind
Definition: Overload.h:65
Qualifiers getLocalQualifiers() const
Retrieve the set of qualifiers local to this particular QualType instance, not including any qualifie...
Definition: Type.h:6161
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:124
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:2289
DeclClass * getAsSingle() const
Definition: Lookup.h:507
StringRef getOpcodeStr() const
Definition: Expr.h:3461
Floating point promotions (C++ [conv.fpprom])
Definition: Overload.h:101
bool isGLValue() const
Definition: Expr.h:261
Describes an C or C++ initializer list.
Definition: Expr.h:4371
BinaryOperatorKind
An rvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2770
bool isCompleteType(SourceLocation Loc, QualType T)
Definition: Sema.h:1745
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:567
Represents the results of name lookup.
Definition: Lookup.h:46
PtrTy get() const
Definition: Ownership.h:170
RefQualifierKind getRefQualifier() const
Retrieve the ref-qualifier associated with this method.
Definition: DeclCXX.h:2282
An lvalue ref-qualifier was provided (&).
Definition: Type.h:1389
ExprResult CreateOverloadedUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, const UnresolvedSetImpl &Fns, Expr *input, bool RequiresADL=true)
Create a unary operation that may resolve to an overloaded operator.
unsigned BindsToRvalue
Whether we&#39;re binding to an rvalue.
Definition: Overload.h:275
static ImplicitConversionSequence::CompareKind compareStandardConversionSubsets(ASTContext &Context, const StandardConversionSequence &SCS1, const StandardConversionSequence &SCS2)
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
std::string getFullModuleName(bool AllowStringLiterals=false) const
Retrieve the full name of this module, including the path from its top-level module.
Definition: Module.cpp:213
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:62
APValue Val
Val - This is the value the expression can be folded to.
Definition: Expr.h:582
A convenient class for passing around template argument information.
Definition: TemplateBase.h:554
QualType getVolatileType(QualType T) const
Return the uniqued reference to the type for a volatile qualified type.
Definition: ASTContext.h:1175
Ref_Compatible - The two types are reference-compatible.
Definition: Sema.h:10137
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
Definition: Decl.cpp:3444
unsigned QualificationIncludesObjCLifetime
Whether the qualification conversion involves a change in the Objective-C lifetime (for automatic ref...
Definition: Overload.h:253
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
Definition: Expr.h:414
SourceLocation getTemplateKeywordLoc() const
Retrieve the location of the template keyword preceding this name, if any.
Definition: ExprCXX.h:2875
QualType getToType(unsigned Idx) const
Definition: Overload.h:320
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:16493
static bool isRecordType(QualType T)
bool diagnoseArgIndependentDiagnoseIfAttrs(const NamedDecl *ND, SourceLocation Loc)
Emit diagnostics for the diagnose_if attributes on Function, ignoring any ArgDependent DiagnoseIfAttr...
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:3405
Substitution of the deduced template argument values resulted in an error.
Definition: Sema.h:7263
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:6212
OverloadCandidateSelect
This candidate function was not viable because an enable_if attribute disabled it.
Definition: Overload.h:706
LangAS getAddressSpace() const
Definition: Type.h:353
A set of unresolved declarations.
Definition: UnresolvedSet.h:60
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:240
const Type * getClass() const
Definition: Type.h:2822
bool isRValueReferenceType() const
Definition: Type.h:6404
Template argument deduction exceeded the maximum template instantiation depth (which has already been...
Definition: Sema.h:7246
void diagnoseEquivalentInternalLinkageDeclarations(SourceLocation Loc, const NamedDecl *D, ArrayRef< const NamedDecl *> Equiv)
static ImplicitConversionSequence TryListConversion(Sema &S, InitListExpr *From, QualType ToType, bool SuppressUserConversions, bool InOverloadResolution, bool AllowObjCWritebackConversion)
TryListConversion - Try to copy-initialize a value of type ToType from the initializer list From...
static void AddOverloadedCallCandidate(Sema &S, DeclAccessPair FoundDecl, TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet, bool PartialOverloading, bool KnownValid)
Add a single candidate to the overload set.
Defines the Diagnostic-related interfaces.
A narrowing conversion, because a constant expression got narrowed.
Definition: Overload.h:210
FunctionDecl * ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr, QualType TargetType, bool Complain, DeclAccessPair &Found, bool *pHadMultipleCandidates=nullptr)
ResolveAddressOfOverloadedFunction - Try to resolve the address of an overloaded function (C++ [over...
ExprResult BuildOverloadedCallExpr(Scope *S, Expr *Fn, UnresolvedLookupExpr *ULE, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc, Expr *ExecConfig, bool AllowTypoCorrection=true, bool CalleesAddressIsTaken=false)
BuildOverloadedCallExpr - Given the call expression that calls Fn (which eventually refers to the dec...
unsigned IsLvalueReference
Whether this is an lvalue reference binding (otherwise, it&#39;s an rvalue reference binding).
Definition: Overload.h:269
bool isLambda() const
Determine whether this class describes a lambda function object.
Definition: DeclCXX.h:1198
CanQualType LongDoubleTy
Definition: ASTContext.h:1026
Expr * IgnoreParenCasts() LLVM_READONLY
Skip past any parentheses and casts which might surround this expression until reaching a fixed point...
Definition: Expr.cpp:2947
NarrowingKind
NarrowingKind - The kind of narrowing conversion being performed by a standard conversion sequence ac...
Definition: Overload.h:202
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:40
QualType getCVRQualifiedType(QualType T, unsigned CVR) const
Return a type with additional const, volatile, or restrict qualifiers.
Definition: ASTContext.h:1933
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:6142
ExprResult BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, SourceLocation LParenLoc, ArrayRef< Expr *> Arg, SourceLocation RParenLoc, Expr *Config=nullptr, bool IsExecConfig=false, ADLCallKind UsesADL=ADLCallKind::NotADL)
BuildResolvedCallExpr - Build a call to a resolved expression, i.e.
Definition: SemaExpr.cpp:5745
b
Definition: emmintrin.h:321
param_type_iterator param_type_begin() const
Definition: Type.h:4067
void Destroy()
Free any memory associated with this deduction failure.
Qualification conversions (C++ [conv.qual])
Definition: Overload.h:95
bool isInt() const
Definition: APValue.h:317
bool isCPUSpecificMultiVersion() const
True if this function is a multiversioned processor specific function as a part of the cpu_specific/c...
Definition: Decl.cpp:3039
static bool isBooleanType(QualType Ty)
NestedNameSpecifier * getQualifier() const
Fetches the nested-name qualifier, if one was given.
Definition: ExprCXX.h:2865
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:63
static bool checkAddressOfFunctionIsAvailable(Sema &S, const FunctionDecl *FD, bool Complain, bool InOverloadResolution, SourceLocation Loc)
Returns true if we can take the address of the function.
const LangOptions & getLangOpts() const
Definition: Sema.h:1285
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value &#39;V&#39; and type &#39;type&#39;.
Definition: Expr.cpp:919
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:176
#define UINT_MAX
Definition: limits.h:56
static ImplicitConversionSequence TryContextuallyConvertToObjCPointer(Sema &S, Expr *From)
TryContextuallyConvertToObjCPointer - Attempt to contextually convert the expression From to an Objec...
void * getAsOpaquePtr() const
Definition: Type.h:688
bool compatiblyIncludesObjCLifetime(Qualifiers other) const
Determines if these qualifiers compatibly include another set of qualifiers from the narrow perspecti...
Definition: Type.h:508
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:8401
An ordinary object is located at an address in memory.
Definition: Specifiers.h:140
virtual SemaDiagnosticBuilder diagnoseIncomplete(Sema &S, SourceLocation Loc, QualType T)=0
Emits a diagnostic when the expression has incomplete class type.
The number of conversion kinds.
Definition: Overload.h:164
ForRangeStatus BuildForRangeBeginEndCall(SourceLocation Loc, SourceLocation RangeLoc, const DeclarationNameInfo &NameInfo, LookupResult &MemberLookup, OverloadCandidateSet *CandidateSet, Expr *Range, ExprResult *CallExpr)
Build a call to &#39;begin&#39; or &#39;end&#39; for a C++11 for-range statement.
TemplateParameter getTemplateParameter()
Retrieve the template parameter this deduction failure refers to, if any.
Represents an ObjC class declaration.
Definition: DeclObjC.h:1171
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:244
IncompatiblePointerSign - The assignment is between two pointers types which point to integers which ...
Definition: Sema.h:9896
ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, LookupResult &R, bool NeedsADL, bool AcceptInvalidDecl=false)
Definition: SemaExpr.cpp:2892
static UnresolvedLookupExpr * Create(const ASTContext &Context, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool RequiresADL, bool Overloaded, UnresolvedSetIterator Begin, UnresolvedSetIterator End)
Definition: ExprCXX.cpp:327
Complex <-> Real conversion.
Definition: Overload.h:185
bool Viable
Viable - True to indicate that this overload candidate is viable.
Definition: Overload.h:767
ConversionSequenceList Conversions
The conversion sequences used to convert the function arguments to the function parameters.
Definition: Overload.h:761
bool hasConst() const
Definition: Type.h:254
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:369
CanQualType UnsignedCharTy
Definition: ASTContext.h:1024
Integral promotions (C++ [conv.prom])
Definition: Overload.h:98
This conversion function template specialization candidate is not viable because the final conversion...
Definition: Overload.h:697
bool IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType)
Helper function to determine whether this is the (deprecated) C++ conversion from a string literal to...
SourceLocation getMemberLoc() const
Retrieve the location of the name of the member that this expression refers to.
Definition: ExprCXX.h:3793
QualType BuiltinParamTypes[3]
BuiltinParamTypes - Provides the parameter types of a built-in overload candidate.
Definition: Overload.h:753
This object can be modified without requiring retains or releases.
Definition: Type.h:158
param_iterator param_begin()
Definition: Decl.h:2301
C-only conversion between pointers with incompatible types.
Definition: Overload.h:161
DeclarationName getMemberName() const
Retrieve the name of the member that this expression refers to.
Definition: ExprCXX.h:3789
bool IsComplexPromotion(QualType FromType, QualType ToType)
Determine if a conversion is a complex promotion.
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
Definition: Decl.cpp:3536
DiagnosticsEngine & getDiagnostics() const
Definition: Sema.h:1289
RAII class used to determine whether SFINAE has trapped any errors that occur during template argumen...
Definition: Sema.h:7856
bool isIntegralOrUnscopedEnumerationType() const
Determine whether this type is an integral or unscoped enumeration type.
Definition: Type.cpp:1803
static bool hasDeprecatedStringLiteralToCharPtrConversion(const ImplicitConversionSequence &ICS)
CXXSpecialMember
Kinds of C++ special members.
Definition: Sema.h:1221
QualType getDeclaredReturnType() const
Get the declared return type, which may differ from the actual return type if the return type is dedu...
Definition: Decl.h:2340
OverloadFixItKind Kind
The type of fix applied.
static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, const TemplateArgument &Param, TemplateArgument Arg, TemplateDeductionInfo &Info, SmallVectorImpl< DeducedTemplateArgument > &Deduced)
bool hasAttr() const
Definition: DeclBase.h:542
DeductionFailureInfo DeductionFailure
Template argument deduction info.
static void NoteAmbiguousUserConversions(Sema &S, SourceLocation OpLoc, OverloadCandidate *Cand)
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:328
bool isPromotableIntegerType() const
More type predicates useful for type checking/promotion.
Definition: Type.cpp:2498
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1636
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3719
bool compatiblyIncludes(Qualifiers other) const
Determines if these qualifiers compatibly include another set.
Definition: Type.h:487
void erase(NamedDecl *D)
Removes any data associated with a given decl.
Definition: Lookup.h:814
Transparent Union Conversions.
Definition: Overload.h:146
bool isMoreQualifiedThan(QualType Other) const
Determine whether this type is more qualified than the other given type, requiring exact equality for...
Definition: Type.h:6304
bool isStdInitializerList(QualType Ty, QualType *Element)
Tests whether Ty is an instance of std::initializer_list and, if it is and Element is not NULL...
CastKind
CastKind - The kind of operation required for a conversion.
NestedNameSpecifier * getQualifier() const
If the member name was qualified, retrieves the nested-name-specifier that precedes the member name...
Definition: Expr.h:2918
The return type of classify().
Definition: Expr.h:311
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat)
Definition: Expr.cpp:1975
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:572
Template argument deduction did not deduce a value for every template parameter.
Definition: Sema.h:7249
static ExprResult CreateFunctionRefExpr(Sema &S, FunctionDecl *Fn, NamedDecl *FoundDecl, const Expr *Base, bool HadMultipleCandidates, SourceLocation Loc=SourceLocation(), const DeclarationNameLoc &LocInfo=DeclarationNameLoc())
A convenience routine for creating a decayed reference to a function.
bool CheckPointerConversion(Expr *From, QualType ToType, CastKind &Kind, CXXCastPath &BasePath, bool IgnoreBaseAccess, bool Diagnose=true)
CheckPointerConversion - Check the pointer conversion from the expression From to the type ToType...
virtual SemaDiagnosticBuilder diagnoseExplicitConv(Sema &S, SourceLocation Loc, QualType T, QualType ConvTy)=0
Emits a diagnostic when the only matching conversion function is explicit.
bool hasQualifiers() const
Determine whether this type has any qualifiers.
Definition: Type.h:6217
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:678
CandidateSetKind getKind() const
Definition: Overload.h:925
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:929
A narrowing conversion by virtue of the source and destination types.
Definition: Overload.h:207
Promotion.
Definition: Overload.h:176
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:801
unsigned Result
A Sema::TemplateDeductionResult.
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.
ImplicitConversionSequence TryImplicitConversion(Expr *From, QualType ToType, bool SuppressUserConversions, bool AllowExplicit, bool InOverloadResolution, bool CStyle, bool AllowObjCWritebackConversion)
bool isObjCWritebackConversion(QualType FromType, QualType ToType, QualType &ConvertedType)
Determine whether this is an Objective-C writeback conversion, used for parameter passing when perfor...
static SourceLocation GetLocationForCandidate(const OverloadCandidate *Cand)
An Objective-C property is a logical field of an Objective-C object which is read and written via Obj...
Definition: Specifiers.h:150
Allows QualTypes to be sorted and hence used in maps and sets.
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:436
ObjC ARC writeback conversion.
Definition: Overload.h:188
ExprResult CreateOverloadedBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, const UnresolvedSetImpl &Fns, Expr *LHS, Expr *RHS, bool RequiresADL=true)
Create a binary operation that may resolve to an overloaded operator.
OpenCL Scalar Widening.
Definition: Overload.h:182
QualType getElementType() const
Definition: Type.h:2522
static CallExpr * Create(const ASTContext &Ctx, Expr *Fn, ArrayRef< Expr *> Args, QualType Ty, ExprValueKind VK, SourceLocation RParenLoc, unsigned MinNumArgs=0, ADLCallKind UsesADL=NotADL)
Create a call expression.
Definition: Expr.cpp:1375
bool isEventT() const
Definition: Type.h:6553
bool hasOnlyConst() const
Definition: Type.h:255
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:3376
bool isMultiVersion() const
True if this function is considered a multiversioned function.
Definition: Decl.h:2252
DeclAccessPair getFoundDecl() const
Retrieves the declaration found by lookup.
Definition: Expr.h:2894
void addVolatile()
Definition: Type.h:262
This represents one expression.
Definition: Expr.h:108
static ImplicitConversionSequence TryObjectArgumentInitialization(Sema &S, SourceLocation Loc, QualType FromType, Expr::Classification FromClassification, CXXMethodDecl *Method, CXXRecordDecl *ActingContext)
TryObjectArgumentInitialization - Try to initialize the object parameter of the given member function...
Show just the "best" overload candidates.
QualType getPointeeType() const
Definition: Type.h:2726
std::string getAsString(const ASTContext &Ctx, QualType Ty) const
Definition: APValue.cpp:679
Represents an ambiguous user-defined conversion sequence.
Definition: Overload.h:388
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition: Specifiers.h:121
bool isVariadic() const
Whether this function is variadic.
Definition: Decl.cpp:2766
bool isDefaulted() const
Whether this function is defaulted per C++0x.
Definition: Decl.h:2048
Expr * stripARCUnbridgedCast(Expr *e)
stripARCUnbridgedCast - Given an expression of ARCUnbridgedCast type, remove the placeholder cast...
This candidate was not viable because it is a non-default multiversioned function.
Definition: Overload.h:725
bool isArrow() const
Determine whether this member expression used the &#39;->&#39; operator; otherwise, it used the &#39;...
Definition: ExprCXX.h:3773
This inherited constructor is not viable because it would slice the argument.
Definition: Overload.h:721
void takeSFINAEDiagnostic(PartialDiagnosticAt &PD)
Take ownership of the SFINAE diagnostic.
When performing template argument deduction for a function template, there were too many call argumen...
Definition: Sema.h:7276
Declaration of a template type parameter.
static FindResult find(Expr *E)
Finds the overloaded expression in the given expression E of OverloadTy.
Definition: ExprCXX.h:2810
SourceLocation getLocation() const
Definition: Overload.h:924
StandardConversionSequence After
After - Represents the standard conversion that occurs after the actual user-defined conversion...
Definition: Overload.h:372
ExprResult BuildCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false)
BuildCallExpr - Handle a call to Fn with the specified array of arguments.
Definition: SemaExpr.cpp:5568
bool isObjCBuiltinType() const
Definition: Type.h:6535
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6916
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:179
#define V(N, I)
Definition: ASTContext.h:2907
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2838
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:131
unsigned getNumInits() const
Definition: Expr.h:4401
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:558
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
Definition: Decl.cpp:3552
Zero constant to queue.
Definition: Overload.h:155
bool isNullPtrType() const
Definition: Type.h:6668
static void CompleteNonViableCandidate(Sema &S, OverloadCandidate *Cand, ArrayRef< Expr *> Args)
CompleteNonViableCandidate - Normally, overload resolution only computes up to the first bad conversi...
void copyFrom(const AmbiguousConversionSequence &)
static bool IsStandardConversion(Sema &S, Expr *From, QualType ToType, bool InOverloadResolution, StandardConversionSequence &SCS, bool CStyle, bool AllowObjCWritebackConversion)
IsStandardConversion - Determines whether there is a standard conversion sequence (C++ [conv]...
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies the name of this declaration, if it was present in ...
Definition: Decl.h:744
static Qualifiers CollectVRQualifiers(ASTContext &Context, Expr *ArgExpr)
CollectVRQualifiers - This routine returns Volatile/Restrict qualifiers, if any, found in visible typ...
bool performsVirtualDispatch(const LangOptions &LO) const
Returns true if virtual dispatch is performed.
Definition: Expr.h:3025
ObjCLifetime getObjCLifetime() const
Definition: Type.h:327
static ConstantExpr * Create(const ASTContext &Context, Expr *E, const APValue &Result)
Definition: Expr.cpp:285
CXXConstructorDecl * CopyConstructor
CopyConstructor - The copy constructor that is used to perform this conversion, when the conversion i...
Definition: Overload.h:300
bool isObjCClassType() const
Definition: Type.h:6523
static bool completeFunctionType(Sema &S, FunctionDecl *FD, SourceLocation Loc, bool Complain=true)
DeclContext * getDeclContext()
Definition: DeclBase.h:438
Overload resolution succeeded.
Definition: Overload.h:53
bool isObjCIdType() const
True if this is equivalent to the &#39;id&#39; type, i.e.
Definition: Type.h:5926
bool isCPUDispatchMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the cpu_specific/cpu_dispatc...
Definition: Decl.cpp:3035
bool isAnyComplexType() const
Definition: Type.h:6472
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc)
Retrieve the overloaded operator kind that corresponds to the given unary opcode. ...
Definition: Expr.cpp:1309
static bool IsOverloaded(const UnresolvedSetImpl &Functions)
When performing template argument deduction for a function template, there were too few call argument...
Definition: Sema.h:7279
CanQualType ShortTy
Definition: ASTContext.h:1023
static bool IsAcceptableNonMemberOperatorCandidate(ASTContext &Context, FunctionDecl *Fn, ArrayRef< Expr *> Args)
IsAcceptableNonMemberOperatorCandidate - Determine whether Fn is an acceptable non-member overloaded ...
unsigned ReferenceBinding
ReferenceBinding - True when this is a reference binding (C++ [over.ics.ref]).
Definition: Overload.h:261
ExprResult CheckPlaceholderExpr(Expr *E)
Check for operands with placeholder types and complain if found.
Definition: SemaExpr.cpp:17451
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
Represents a C++ template name within the type system.
Definition: TemplateName.h:187
Ref_Related - The two types are reference-related, which means that their unqualified forms (T1 and T...
Definition: Sema.h:10135
const Expr * getExpr() const
Definition: DeclCXX.h:2010
void getAsStringInternal(std::string &Str, const PrintingPolicy &Policy) const
decls_iterator decls_begin() const
Definition: ExprCXX.h:2842
ReferenceCompareResult
ReferenceCompareResult - Expresses the result of comparing two types (cv1 T1 and cv2 T2) to determine...
Definition: Sema.h:10128
virtual SemaDiagnosticBuilder diagnoseAmbiguous(Sema &S, SourceLocation Loc, QualType T)=0
Emits a diagnostic when there are multiple possible conversion functions.
Floating-integral conversions (C++ [conv.fpint])
Definition: Overload.h:116
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7)...
DependentFunctionTemplateSpecializationInfo * getDependentSpecializationInfo() const
Definition: Decl.cpp:3608
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:1025
Specifies that a value-dependent expression of integral or dependent type should be considered a null...
Definition: Expr.h:733
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:1875
This conversion candidate was not considered because it is an illegal instantiation of a constructor ...
Definition: Overload.h:689
bool TryToFixBadConversion(unsigned Idx, Sema &S)
Definition: Overload.h:814
static void collectViableConversionCandidates(Sema &SemaRef, Expr *From, QualType ToType, UnresolvedSetImpl &ViableConversions, OverloadCandidateSet &CandidateSet)
QualType getType() const
Definition: Expr.h:137
CXXConversionDecl * Surrogate
Surrogate - The conversion function for which this candidate is a surrogate, but only if IsSurrogate ...
Definition: Overload.h:757
UserDefinedConversionSequence - Represents a user-defined conversion sequence (C++ 13...
Definition: Overload.h:343
This candidate was not viable because its address could not be taken.
Definition: Overload.h:714
void NoteDeductionFailure(Sema &S, bool ForTakingAddress)
Diagnose a template argument deduction failure.
static bool isBetterMultiversionCandidate(const OverloadCandidate &Cand1, const OverloadCandidate &Cand2)
StandardConversionSequence Standard
When ConversionKind == StandardConversion, provides the details of the standard conversion sequence...
Definition: Overload.h:525
DeclarationName getCXXOperatorName(OverloadedOperatorKind Op)
Get the name of the overloadable C++ operator corresponding to Op.
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:1779
ExprResult BuildLiteralOperatorCall(LookupResult &R, DeclarationNameInfo &SuffixInfo, ArrayRef< Expr *> Args, SourceLocation LitEndLoc, TemplateArgumentListInfo *ExplicitTemplateArgs=nullptr)
BuildLiteralOperatorCall - Build a UserDefinedLiteral by creating a call to a literal operator descri...
static void DiagnoseOpenCLExtensionDisabled(Sema &S, OverloadCandidate *Cand)
void setAddressSpace(LangAS space)
Definition: Type.h:373
void DiagnoseAmbiguousConversion(Sema &S, SourceLocation CaretLoc, const PartialDiagnostic &PDiag) const
Diagnoses an ambiguous conversion.
bool resolveAndFixAddressOfOnlyViableOverloadCandidate(ExprResult &SrcExpr, bool DoFunctionPointerConversion=false)
Given an overloaded function, tries to turn it into a non-overloaded function reference using resolve...
static const FunctionProtoType * tryGetFunctionProtoType(QualType FromType)
Attempts to get the FunctionProtoType from a Type.
QualType getRecordType(const RecordDecl *Decl) const
static QualType AdjustAddressSpaceForBuiltinOperandType(Sema &S, QualType T, Expr *Arg)
Helper function for adjusting address spaces for the pointer or reference operands of builtin operato...
bool isAtLeastAsQualifiedAs(CanQual< T > Other) const
Determines whether this canonical type is at least as qualified as the Other canonical type...
bool isInvalid() const
Definition: Ownership.h:166
virtual SemaDiagnosticBuilder noteExplicitConv(Sema &S, CXXConversionDecl *Conv, QualType ConvTy)=0
Emits a note for the explicit conversion function.
QualType getFunctionTypeWithExceptionSpec(QualType Orig, const FunctionProtoType::ExceptionSpecInfo &ESI)
Get a function type and produce the equivalent function type with the specified exception specificati...
UnaryOperator - This represents the unary-expression&#39;s (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:2016
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:1382
bool DeduceReturnType(FunctionDecl *FD, SourceLocation Loc, bool Diagnose=true)
SourceLocation getMemberLoc() const
getMemberLoc - Return the location of the "member", in X->F, it is the location of &#39;F&#39;...
Definition: Expr.h:2996
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:2752
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
unsigned getNumArgs() const
void AddMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl, DeclAccessPair FoundDecl, CXXRecordDecl *ActingContext, TemplateArgumentListInfo *ExplicitTemplateArgs, QualType ObjectType, Expr::Classification ObjectClassification, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false)
Add a C++ member function template as a candidate to the candidate set, using template argument deduc...
static bool CheckArityMismatch(Sema &S, OverloadCandidate *Cand, unsigned NumArgs)
Additional arity mismatch diagnosis specific to a function overload candidates.
const BuiltinType * getAsPlaceholderType() const
Definition: Type.h:6623
After substituting deduced template arguments, a dependent parameter type did not match the correspon...
Definition: Sema.h:7266
bool isUsable() const
Definition: Ownership.h:167
Represents a C++ conversion function within a class.
Definition: DeclCXX.h:2899
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:1398
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:708
bool isVolatileQualified() const
OverloadsShown getShowOverloads() const
Definition: Diagnostic.h:662
CanQualType SignedCharTy
Definition: ASTContext.h:1023
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so...
Definition: DeclBase.h:1111
SourceLocation getEndLoc() const LLVM_READONLY
Definition: Stmt.cpp:276
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
Definition: Type.h:6175
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:214
QualType getFromType() const
Definition: Overload.h:470
CanQualType getCanonicalTypeUnqualified() const
Lvalue-to-rvalue conversion (C++ [conv.lval])
Definition: Overload.h:83
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:6201
NarrowingKind getNarrowingKind(ASTContext &Context, const Expr *Converted, APValue &ConstantValue, QualType &ConstantType, bool IgnoreFloatToIntegralConversion=false) const
Check if this standard conversion sequence represents a narrowing conversion, according to C++11 [dcl...
RecordDecl * getDecl() const
Definition: Type.h:4448
static bool isBetterReferenceBindingKind(const StandardConversionSequence &SCS1, const StandardConversionSequence &SCS2)
Determine whether one of the given reference bindings is better than the other based on what kind of ...
bool isExplicit() const
Return true if the declartion is already resolved to be explicit.
Definition: DeclCXX.h:2933
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:213
void AddTemplateOverloadCandidate(FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl, TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, bool AllowExplicit=true, ADLCallKind IsADLCandidate=ADLCallKind::NotADL)
Add a C++ function template specialization as a candidate in the candidate set, using template argume...
bool isTemplateDecl() const
returns true if this declaration is a template
Definition: DeclBase.cpp:225
void AddBuiltinOperatorCandidates(OverloadedOperatorKind Op, SourceLocation OpLoc, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet)
AddBuiltinOperatorCandidates - Add the appropriate built-in operator overloads to the candidate set (...
unsigned ObjCLifetimeConversionBinding
Whether this binds a reference to an object with a different Objective-C lifetime qualifier...
Definition: Overload.h:283
static bool isNullPointerConstantForConversion(Expr *Expr, bool InOverloadResolution, ASTContext &Context)
CanQualType OverloadTy
Definition: ASTContext.h:1043
Decl::Kind getDeclKind() const
Definition: DeclBase.h:1772
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
Definition: Expr.h:1045
llvm::cl::opt< std::string > Filter
Integral conversions (C++ [conv.integral])
Definition: Overload.h:107
void AddBuiltinCandidate(QualType *ParamTys, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet, bool IsAssignmentOperator=false, unsigned NumContextualBoolArguments=0)
AddBuiltinCandidate - Add a candidate for a built-in operator.
SmallVectorImpl< OverloadCandidate >::iterator iterator
Definition: Overload.h:936
Complex promotions (Clang extension)
Definition: Overload.h:104
Assigning into this object requires the old value to be released and the new value to be retained...
Definition: Type.h:165
Kind
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr...
Definition: ExprCXX.h:2750
ImplicitConversionSequence - Represents an implicit conversion sequence, which may be a standard conv...
Definition: Overload.h:486
QualType getCanonicalType() const
Definition: Type.h:6181
bool isPointerConversionToVoidPointer(ASTContext &Context) const
isPointerConversionToVoidPointer - Determines whether this conversion is a conversion of a pointer to...
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:153
static bool checkAddressOfCandidateIsAvailable(Sema &S, const FunctionDecl *FD)
OverloadCandidate - A single candidate in an overload set (C++ 13.3).
Definition: Overload.h:739
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
Definition: DeclBase.cpp:217
ASTContext & getASTContext() const
Definition: Sema.h:1292
static bool DiagnoseTwoPhaseLookup(Sema &SemaRef, SourceLocation FnLoc, const CXXScopeSpec &SS, LookupResult &R, OverloadCandidateSet::CandidateSetKind CSK, TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef< Expr *> Args, bool *DoDiagnoseEmptyLookup=nullptr)
Attempt to recover from an ill-formed use of a non-dependent name in a template, where the non-depend...
SourceLocation getNameLoc() const
Gets the location of the name.
Definition: ExprCXX.h:2862
const ExtParameterInfo * ExtParameterInfos
Definition: Type.h:3806
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:3658
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
Encodes a location in the source.
C++ [over.match.ctor], [over.match.list] Initialization of an object of class type by constructor...
Definition: Overload.h:867
QualType getReturnType() const
Definition: Type.h:3645
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:4464
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...
LangAS getAddressSpace() const
Return the address space of this type.
Definition: Type.h:6258
llvm::mapped_iterator< decltype(Decls)::iterator, select_second > iterator
Definition: Lookup.h:819
CanQualType Int128Ty
Definition: ASTContext.h:1023
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:5808
virtual SemaDiagnosticBuilder noteAmbiguous(Sema &S, CXXConversionDecl *Conv, QualType ConvTy)=0
Emits a note for one of the candidate conversions.
static ImplicitConversionSequence::CompareKind CompareStandardConversionSequences(Sema &S, SourceLocation Loc, const StandardConversionSequence &SCS1, const StandardConversionSequence &SCS2)
CompareStandardConversionSequences - Compare two standard conversion sequences to determine whether o...
A call to a literal operator (C++11 [over.literal]) written as a user-defined literal (C++11 [lit...
Definition: ExprCXX.h:473
Template argument deduction failed due to inconsistent cv-qualifiers on a template parameter type tha...
Definition: Sema.h:7260
MutableArrayRef< Expr * > MultiExprArg
Definition: Ownership.h:273
void AddMemberOperatorCandidates(OverloadedOperatorKind Op, SourceLocation OpLoc, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet, SourceRange OpRange=SourceRange())
Add overload candidates for overloaded operators that are member functions.
Represents a call to a member function that may be written either with member call syntax (e...
Definition: ExprCXX.h:170
A vector splat from an arithmetic type.
Definition: Overload.h:137
IncompatiblePointer - The assignment is between two pointers types that are not compatible, but we accept them as an extension.
Definition: Sema.h:9890
Template argument deduction did not deduce a value for every expansion of an expanded template parame...
Definition: Sema.h:7252
APFloat & getFloat()
Definition: APValue.h:350
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:51
std::string getOpenCLExtensionsFromDeclExtMap(FunctionDecl *FD)
Check if a function declaration FD associates with any extensions present in OpenCLDeclExtMap and if ...
Definition: Sema.cpp:2167
static ImplicitConversionSequence::CompareKind compareConversionFunctions(Sema &S, FunctionDecl *Function1, FunctionDecl *Function2)
Compare the user-defined conversion functions or constructors of two user-defined conversion sequence...
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs. ...
bool isIntegralType(const ASTContext &Ctx) const
Determine whether this type is an integral type.
Definition: Type.cpp:1790
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2114
static void DiagnoseBadConversion(Sema &S, OverloadCandidate *Cand, unsigned I, bool TakingCandidateAddress)
void AddConversionCandidate(CXXConversionDecl *Conversion, DeclAccessPair FoundDecl, CXXRecordDecl *ActingContext, Expr *From, QualType ToType, OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit, bool AllowExplicit, bool AllowResultConversion=true)
AddConversionCandidate - Add a C++ conversion function as a candidate in the candidate set (C++ [over...
ExprResult DefaultLvalueConversion(Expr *E)
Definition: SemaExpr.cpp:554
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
No ref-qualifier was provided.
Definition: Type.h:1386
CanQualType FloatTy
Definition: ASTContext.h:1026
Objective-C ARC writeback conversion.
Definition: Overload.h:149
bool DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType)
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:2312
The declaration was invalid; do nothing.
Definition: Sema.h:7243
static bool IsVectorConversion(Sema &S, QualType FromType, QualType ToType, ImplicitConversionKind &ICK)
Determine whether the conversion from FromType to ToType is a valid vector conversion.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
unsigned pack_size() const
The number of template arguments in the given template argument pack.
Definition: TemplateBase.h:359
Qualifiers getMethodQuals() const
Definition: Type.h:4048
bool isSignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...
Definition: Type.cpp:1891
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:737
OverloadingResult BestViableFunction(Sema &S, SourceLocation Loc, OverloadCandidateSet::iterator &Best)
Find the best viable function on this overload set, if it exists.
CanQualType VoidTy
Definition: ASTContext.h:1014
bool isScoped() const
Returns true if this is a C++11 scoped enumeration.
Definition: Decl.h:3553
void addDecl(NamedDecl *D)
Definition: UnresolvedSet.h:88
TemplateDeductionResult DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, const TemplateArgumentList &TemplateArgs, sema::TemplateDeductionInfo &Info)
Perform template argument deduction to determine whether the given template arguments match the given...
bool hasRestrict() const
Definition: Type.h:264
llvm::Optional< unsigned > getCallArgIndex()
Return the index of the call argument that this deduction failure refers to, if any.
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
Definition: Expr.h:158
Qualifiers withoutObjCLifetime() const
Definition: Type.h:315
bool isObjCObjectPointerType() const
Definition: Type.h:6488
bool isAnyPointerType() const
Definition: Type.h:6388
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++ [conv.ptr])
Definition: Overload.h:119
C++ [over.match.oper]: Lookup of operator function candidates in a call using operator syntax...
Definition: Overload.h:857
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:3245
bool canBindObjCObjectType(QualType To, QualType From)
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language...
Definition: Expr.h:258
bool hasUninstantiatedDefaultArg() const
Definition: Decl.h:1678
Requests that all candidates be shown.
Definition: Overload.h:68
bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false, ObjCInterfaceDecl *ClassReciever=nullptr)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics...
Definition: SemaExpr.cpp:211
TypeClass getTypeClass() const
Definition: Type.h:1839
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to call this function.
Definition: Decl.cpp:3159
bool isRValue() const
Definition: Expr.h:365
unsigned HasDiagnostic
Indicates whether a diagnostic is stored in Diagnostic.
bool isAnyCharacterType() const
Determine whether this type is any of the built-in character types.
Definition: Type.cpp:1854
static ExplicitSpecifier getFromDecl(FunctionDecl *Function)
Definition: DeclCXX.cpp:1908
bool IsBuildingRecoveryCallExpr
Flag indicating if Sema is building a recovery call expression.
Definition: Sema.h:580
EnumDecl * getDecl() const
Definition: Type.h:4471
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:131
DeductionFailureInfo MakeDeductionFailureInfo(ASTContext &Context, Sema::TemplateDeductionResult TDK, sema::TemplateDeductionInfo &Info)
Convert from Sema&#39;s representation of template deduction information to the form used in overload-can...
bool isVectorType() const
Definition: Type.h:6476
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:140
This constructor/conversion candidate fail due to an address space mismatch between the object being ...
Definition: Overload.h:730
An rvalue ref-qualifier was provided (&&).
Definition: Type.h:1392
Assigning into this object requires a lifetime extension.
Definition: Type.h:171
void removeObjCGCAttr()
Definition: Type.h:305
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13...
Definition: Overload.h:846
void setBad(BadConversionSequence::FailureKind Failure, Expr *FromExpr, QualType ToType)
Sets this sequence as a bad conversion for an explicit argument.
Definition: Overload.h:613
ExprResult BuildCallToObjectOfClassType(Scope *S, Expr *Object, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc)
BuildCallToObjectOfClassType - Build a call to an object of class type (C++ [over.call.object]), which can end up invoking an overloaded function call operator (operator()) or performing a user-defined conversion on the object argument.
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2320
std::string getAsString() const
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
Definition: Type.h:2114
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:215
QualType getArrayDecayedType(QualType T) const
Return the properly qualified result of decaying the specified array type to a pointer.
unsigned getNumParams() const
Definition: Overload.h:827
const llvm::fltSemantics & getFloatTypeSemantics(QualType T) const
Return the APFloat &#39;semantics&#39; for the specified scalar floating point type.
CanProxy< U > getAs() const
Retrieve a canonical type pointer with a different static type, upcasting or downcasting as needed...
FunctionTemplateDecl * getMoreSpecializedTemplate(FunctionTemplateDecl *FT1, FunctionTemplateDecl *FT2, SourceLocation Loc, TemplatePartialOrderingContext TPOC, unsigned NumCallArguments1, unsigned NumCallArguments2)
Returns the more specialized function template according to the rules of function template partial or...
bool isPointerConversionToBool() const
isPointerConversionToBool - Determines whether this conversion is a conversion of a pointer or pointe...
CompoundAssignOperator - For compound assignments (e.g.
Definition: Expr.h:3625
SourceLocation getLocation() const
A POD class for pairing a NamedDecl* with an access specifier.
DeclarationNameLoc - Additional source/type location info for a declaration name. ...
ExprResult BuildOverloadedArrowExpr(Scope *S, Expr *Base, SourceLocation OpLoc, bool *NoArrowOperatorFound=nullptr)
BuildOverloadedArrowExpr - Build a call to an overloaded operator-> (if one exists), where Base is an expression of class type and Member is the name of the member we&#39;re trying to find.
ExprResult BuildCXXMemberCallExpr(Expr *Exp, NamedDecl *FoundDecl, CXXConversionDecl *Method, bool HadMultipleCandidates)
StringRef getName() const
Return the actual identifier string.
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:798
CanQualType UnsignedShortTy
Definition: ASTContext.h:1024
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: ExprCXX.h:3022
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:1016
const TemplateArgument * getFirstArg()
Return the first template argument this deduction failure refers to, if any.
Represents a template argument.
Definition: TemplateBase.h:50
ExprResult PerformCopyInitialization(const InitializedEntity &Entity, SourceLocation EqualLoc, ExprResult Init, bool TopLevelOfInitList=false, bool AllowExplicit=false)
Definition: SemaInit.cpp:9231
iterator begin()
Definition: Lookup.h:821
DeclContextLookupResult LookupConstructors(CXXRecordDecl *Class)
Look up the constructors for the given class.
DeclAccessPair FoundCopyConstructor
Definition: Overload.h:301
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:2825
GC getObjCGCAttr() const
Definition: Type.h:301
Dataflow Directional Tag Classes.
int getFloatingTypeOrder(QualType LHS, QualType RHS) const
Compare the rank of the two specified floating point types, ignoring the domain of the type (i...
bool isValid() const
Return true if this is a valid SourceLocation object.
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Expr.cpp:2314
ExtInfo getExtInfo() const
Definition: Type.h:3656
A qualifier set is used to build a set of qualifiers.
Definition: Type.h:6109
UnaryOperatorKind
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1271
CanQualType NullPtrTy
Definition: ASTContext.h:1042
EvalResult is a struct with detailed info about an evaluated expression.
Definition: Expr.h:580
static ImplicitConversionSequence TryImplicitConversion(Sema &S, Expr *From, QualType ToType, bool SuppressUserConversions, bool AllowExplicit, bool InOverloadResolution, bool CStyle, bool AllowObjCWritebackConversion, bool AllowObjCConversionOnExplicit)
TryImplicitConversion - Attempt to perform an implicit conversion from the given expression (Expr) to...
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:403
static std::string getName(const CallEvent &Call)
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:21
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_RValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CCK_ImplicitConversion)
ImpCastExprToType - If Expr is not of type &#39;Type&#39;, insert an implicit cast.
Definition: Sema.cpp:484
QualType getRestrictType(QualType T) const
Return the uniqued reference to the type for a restrict qualified type.
Definition: ASTContext.h:1166
void AddSurrogateCandidate(CXXConversionDecl *Conversion, DeclAccessPair FoundDecl, CXXRecordDecl *ActingContext, const FunctionProtoType *Proto, Expr *Object, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet)
AddSurrogateCandidate - Adds a "surrogate" candidate function that converts the given Object to a fun...
bool isObjCClassType() const
True if this is equivalent to the &#39;Class&#39; type, i.e.
Definition: Type.h:5932
virtual SemaDiagnosticBuilder diagnoseNoMatch(Sema &S, SourceLocation Loc, QualType T)=0
Emits a diagnostic complaining that the expression does not have integral or enumeration type...
Qualifiers getMethodQualifiers() const
Definition: DeclCXX.h:2267
void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, bool AllowExplicit=true, bool AllowExplicitConversion=false, ADLCallKind IsADLCandidate=ADLCallKind::NotADL, ConversionSequenceList EarlyConversions=None)
AddOverloadCandidate - Adds the given function to the set of candidate functions, using the given fun...
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:10601
static void NoteFunctionCandidate(Sema &S, OverloadCandidate *Cand, unsigned NumArgs, bool TakingCandidateAddress, LangAS CtorDestAS=LangAS::Default)
Generates a &#39;note&#39; diagnostic for an overload candidate.
CanQualType UnsignedLongLongTy
Definition: ASTContext.h:1025
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:158
static GenericSelectionExpr * Create(const ASTContext &Context, SourceLocation GenericLoc, Expr *ControllingExpr, ArrayRef< TypeSourceInfo *> AssocTypes, ArrayRef< Expr *> AssocExprs, SourceLocation DefaultLoc, SourceLocation RParenLoc, bool ContainsUnexpandedParameterPack, unsigned ResultIndex)
Create a non-result-dependent generic selection expression.
Definition: Expr.cpp:4052
Array-to-pointer conversion (C++ [conv.array])
Definition: Overload.h:86
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:7273
PartialDiagnosticAt * getSFINAEDiagnostic()
Retrieve the diagnostic which caused this deduction failure, if any.
The name of a declaration.
Expr * getDefaultArg()
Definition: Decl.cpp:2654
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
Definition: Type.h:976
StandardConversionSequence Before
Represents the standard conversion that occurs before the actual user-defined conversion.
Definition: Overload.h:355
bool IsBlockPointerConversion(QualType FromType, QualType ToType, QualType &ConvertedType)
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:2237
bool isBooleanType() const
Definition: Type.h:6760
const Type * strip(QualType type)
Collect any qualifiers on the given type and return an unqualified type.
Definition: Type.h:6116
bool isSpecializationCopyingObject() const
Determine whether this is a member template specialization that would copy the object to itself...
Definition: DeclCXX.cpp:2542
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:2477
void AddArgumentDependentLookupCandidates(DeclarationName Name, SourceLocation Loc, ArrayRef< Expr *> Args, TemplateArgumentListInfo *ExplicitTemplateArgs, OverloadCandidateSet &CandidateSet, bool PartialOverloading=false)
Add function candidates found via argument-dependent lookup to the set of overloading candidates...
static QualType AdoptQualifiers(ASTContext &Context, QualType T, Qualifiers Qs)
Adopt the given qualifiers for the given type.
Expression is a Null pointer constant built from a zero integer expression that is not a simple...
Definition: Expr.h:713
bool isMSVCRTEntryPoint() const
Determines whether this function is a MSVCRT user defined entry point.
Definition: Decl.cpp:2845
A set of unresolved declarations.
void setInstantiationDependent(bool ID)
Set whether this expression is instantiation-dependent or not.
Definition: Expr.h:205
Requests that only viable candidates be shown.
Definition: Overload.h:71
FunctionDecl * Function
Function - The actual function that this candidate represents.
Definition: Overload.h:744
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:2788
static void dropPointerConversion(StandardConversionSequence &SCS)
dropPointerConversions - If the given standard conversion sequence involves any pointer conversions...
QualType getCallResultType(const ASTContext &Context) const
Determine the type of an expression that calls a function of this type.
Definition: Type.h:3668
bool isIntegerConstantExpr(llvm::APSInt &Result, const ASTContext &Ctx, SourceLocation *Loc=nullptr, bool isEvaluated=true) const
isIntegerConstantExpr - Return true if this expression is a valid integer constant expression...
const FunctionType * adjustFunctionType(const FunctionType *Fn, FunctionType::ExtInfo EInfo)
Change the ExtInfo on a function type.
TemplateSpecCandidate & addCandidate()
Add a new candidate with NumConversions conversion sequence slots to the overload set...
Optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
bool isAggregateType() const
Determines whether the type is a C++ aggregate type or C aggregate or union type. ...
Definition: Type.cpp:2038
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
QualType apply(const ASTContext &Context, QualType QT) const
Apply the collected qualifiers to the given type.
Definition: Type.cpp:3428
OverloadCandidateKind
bool CheckNonDependentConversions(FunctionTemplateDecl *FunctionTemplate, ArrayRef< QualType > ParamTypes, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet, ConversionSequenceList &Conversions, bool SuppressUserConversions, CXXRecordDecl *ActingContext=nullptr, QualType ObjectType=QualType(), Expr::Classification ObjectClassification={})
Check that implicit conversion sequences can be formed for each argument whose corresponding paramete...
void dump() const
dump - Print this user-defined conversion sequence to standard error.
void * Data
Opaque pointer containing additional data about this deduction failure.
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 &#39;auto&#39; typ...
Definition: Type.h:6766
void AddFunctionCandidates(const UnresolvedSetImpl &Functions, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet, TemplateArgumentListInfo *ExplicitTemplateArgs=nullptr, bool SuppressUserConversions=false, bool PartialOverloading=false, bool FirstArgumentIsBase=false)
Add all of the function declarations in the given function set to the overload candidate set...
param_iterator param_end()
Definition: Decl.h:2302
void addConst()
Definition: Type.h:257
static void NoteSurrogateCandidate(Sema &S, OverloadCandidate *Cand)
bool hasSFINAEDiagnostic() const
Is a SFINAE diagnostic available?
FunctionDecl * ConversionFunction
ConversionFunction - The function that will perform the user-defined conversion.
Definition: Overload.h:377
Represents a pointer to an Objective C object.
Definition: Type.h:5864
Pointer to a block type.
Definition: Type.h:2671
Conversion only allowed in the C standard (e.g. void* to char*).
Definition: Overload.h:191
unsigned getIntWidth(QualType T) const
Not an overloaded operator.
Definition: OperatorKinds.h:22
const UnresolvedSetImpl & asUnresolvedSet() const
Definition: Lookup.h:331
ExprResult CreateOverloadedArraySubscriptExpr(SourceLocation LLoc, SourceLocation RLoc, Expr *Base, Expr *Idx)
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:4438
void setAllToTypes(QualType T)
Definition: Overload.h:310
Complex values, per C99 6.2.5p11.
Definition: Type.h:2509
unsigned getKindRank() const
Return a ranking of the implicit conversion sequence kind, where smaller ranks represent better conve...
Definition: Overload.h:581
Expr * getUninstantiatedDefaultArg()
Definition: Decl.cpp:2696
CanQualType UnknownAnyTy
Definition: ASTContext.h:1043
bool empty() const
Definition: Type.h:415
ObjCInterfaceDecl * getInterfaceDecl() const
If this pointer points to an Objective @interface type, gets the declaration for that interface...
Definition: Type.h:5920
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:162
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: Type.h:6677
TemplateArgumentList * take()
Take ownership of the deduced template argument list.
CanQualType UnsignedLongTy
Definition: ASTContext.h:1024
This candidate was not viable because its OpenCL extension is disabled.
Definition: Overload.h:717
void addRestrict()
Definition: Type.h:267
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...
T * getAttr() const
Definition: DeclBase.h:538
unsigned BindsImplicitObjectArgumentWithoutRefQualifier
Whether this binds an implicit object argument to a non-static member function without a ref-qualifie...
Definition: Overload.h:279
unsigned char FailureKind
FailureKind - The reason why this candidate is not viable.
Definition: Overload.h:788
CanQualType DependentTy
Definition: ASTContext.h:1043
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:1017
bool isFunctionType() const
Definition: Type.h:6380
bool isObjCQualifiedIdType() const
Definition: Type.h:6505
DeclAccessPair FoundDecl
FoundDecl - The original declaration that was looked up / invented / otherwise found, together with its access.
Definition: Overload.h:749
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2705
CanQualType BoundMemberTy
Definition: ASTContext.h:1043
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:2296
AccessResult CheckMemberOperatorAccess(SourceLocation Loc, Expr *ObjectExpr, Expr *ArgExpr, DeclAccessPair FoundDecl)
Checks access to an overloaded member operator, including conversion operators.
TemplateSpecCandidate - This is a generalization of OverloadCandidate which keeps track of template a...
Block Pointer conversions.
Definition: Overload.h:143
Deduction failed; that&#39;s all we know.
Definition: Sema.h:7286
virtual bool hasFloat128Type() const
Determine whether the __float128 type is supported on this target.
Definition: TargetInfo.h:528
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:92
bool canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT, const ObjCObjectPointerType *RHSOPT)
canAssignObjCInterfaces - Return true if the two interface types are compatible for assignment from R...
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream...
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
Definition: Lookup.h:253
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type...
Definition: Type.cpp:2849
static ExprResult BuildRecoveryCallExpr(Sema &SemaRef, Scope *S, Expr *Fn, UnresolvedLookupExpr *ULE, SourceLocation LParenLoc, MutableArrayRef< Expr *> Args, SourceLocation RParenLoc, bool EmptyLookup, bool AllowTypoCorrection)
Attempts to recover from a call where no functions were found.
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat]...
Definition: APValue.h:76
virtual bool hasInt128Type() const
Determine whether the __int128 type is supported on this target.
Definition: TargetInfo.h:520
static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType, bool InOverloadResolution, StandardConversionSequence &SCS, bool CStyle)
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...
void NoteCandidates(PartialDiagnosticAt PA, Sema &S, OverloadCandidateDisplayKind OCD, ArrayRef< Expr *> Args, StringRef Opc="", SourceLocation Loc=SourceLocation(), llvm::function_ref< bool(OverloadCandidate &)> Filter=[](OverloadCandidate &) { return true;})
When overload resolution fails, prints diagnostic messages containing the candidates in the candidate...
bool isObjectType() const
Determine whether this type is an object type.
Definition: Type.h:1894
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2079
Condition in a constexpr if statement.
Definition: Sema.h:2815
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types...
Definition: Type.cpp:2062
bool hasObjCGCAttr() const
Definition: Type.h:300
CanQualType Char8Ty
Definition: ASTContext.h:1020
bool checkAddressOfFunctionIsAvailable(const FunctionDecl *Function, bool Complain=false, SourceLocation Loc=SourceLocation())
Returns whether the given function&#39;s address can be taken or not, optionally emitting a diagnostic if...
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
TemplateArgumentList * getTemplateArgumentList()
Retrieve the template argument list associated with this deduction failure, if any.
ConversionFixItGenerator Fix
The FixIt hints which can be used to fix the Bad candidate.
Definition: Overload.h:764
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
Definition: DeclBase.h:524
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2280
AmbiguousConversionSequence Ambiguous
When ConversionKind == AmbiguousConversion, provides the details of the ambiguous conversion...
Definition: Overload.h:533
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:1336
A template argument list.
Definition: DeclTemplate.h:214
bool isLValueReferenceType() const
Definition: Type.h:6400
void addConversion(NamedDecl *Found, FunctionDecl *D)
Definition: Overload.h:415
SourceLocation getCXXLiteralOperatorNameLoc() const
getCXXLiteralOperatorNameLoc - Returns the location of the literal operator name (not the operator ke...
X
Add a minimal nested name specifier fixit hint to allow lookup of a tag name from an outer enclosing ...
Definition: SemaDecl.cpp:14445
Reading or writing from this object requires a barrier call.
Definition: Type.h:168
bool isQueueT() const
Definition: Type.h:6561
bool hasSimilarType(QualType T1, QualType T2)
Determine if two types are similar, according to the C++ rules.
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:234
CCEKind
Contexts in which a converted constant expression is required.
Definition: Sema.h:2810
static void BuildBasePathArray(const CXXBasePath &Path, CXXCastPath &BasePathArray)
static CXXMemberCallExpr * Create(const ASTContext &Ctx, Expr *Fn, ArrayRef< Expr *> Args, QualType Ty, ExprValueKind VK, SourceLocation RP, unsigned MinNumArgs=0)
Definition: ExprCXX.cpp:617
QualType getParamType(unsigned i) const
Definition: Type.h:3923
SmallVector< OverloadCandidate *, 32 > CompleteCandidates(Sema &S, OverloadCandidateDisplayKind OCD, ArrayRef< Expr *> Args, SourceLocation OpLoc=SourceLocation(), llvm::function_ref< bool(OverloadCandidate &)> Filter=[](OverloadCandidate &) { return true;})
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++ [conv.array])
Definition: Overload.h:89
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:2807
unsigned size() const
QualType getToType() const
Definition: Overload.h:471
ActionResult< Expr * > ExprResult
Definition: Ownership.h:263
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:6222
bool hasUnaligned() const
Definition: Type.h:293
bool mergeExtParameterInfo(const FunctionProtoType *FirstFnType, const FunctionProtoType *SecondFnType, bool &CanUseFirst, bool &CanUseSecond, SmallVectorImpl< FunctionProtoType::ExtParameterInfo > &NewParamInfos)
This function merges the ExtParameterInfo lists of two functions.
Represents a C++ struct/union/class.
Definition: DeclCXX.h:300
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:9874
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type...
bool isVoidType() const
Definition: Type.h:6643
The template argument is a template name that was provided for a template template parameter...
Definition: TemplateBase.h:75
CUDAFunctionTarget
Definition: Sema.h:10551
void addAllDecls(const LookupResult &Other)
Add all the declarations from another set of lookup results.
Definition: Lookup.h:439
OverloadsShown
Specifies which overload candidates to display when overload resolution fails.
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:6169
CanQualType Char16Ty
Definition: ASTContext.h:1021
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:6422
AccessResult CheckUnresolvedLookupAccess(UnresolvedLookupExpr *E, DeclAccessPair FoundDecl)
bool isPRValue() const
Definition: Expr.h:364
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:386
TemplateArgument SecondArg
The second template argument to which the template argument deduction failure refers.
bool isSamplerT() const
Definition: Type.h:6549
bool isRValue() const
Definition: Expr.h:259
Partial ordering of function templates for a function call.
Definition: Template.h:162
static bool isAddressSpaceSupersetOf(LangAS A, LangAS B)
Returns true if address space A is equal to or a superset of B.
Definition: Type.h:470
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
Definition: Diagnostic.h:129
bool isXValue() const
Definition: Expr.h:362
This class is used for builtin types like &#39;int&#39;.
Definition: Type.h:2423
bool DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R, CorrectionCandidateCallback &CCC, TemplateArgumentListInfo *ExplicitTemplateArgs=nullptr, ArrayRef< Expr *> Args=None, TypoExpr **Out=nullptr)
Diagnose an empty lookup.
Definition: SemaExpr.cpp:1920
bool isVariadic() const
Definition: DeclObjC.h:426
static void AddBuiltinAssignmentOperatorCandidates(Sema &S, QualType T, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet)
Helper function for AddBuiltinOperatorCandidates() that adds the volatile- and non-volatile-qualified...
iterator end() const
Definition: Lookup.h:336
After substituting deduced template arguments, an element of a dependent parameter type did not match...
Definition: Sema.h:7270
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:251
static void DiagnoseBadTarget(Sema &S, OverloadCandidate *Cand)
CUDA: diagnose an invalid call across targets.
__DEVICE__ int min(int __a, int __b)
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) ...
Definition: Diagnostic.h:1324
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:2516
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:153
ImplicitConversionRank getRank() const
getRank - Retrieve the rank of this standard conversion sequence (C++ 13.3.3.1.1p3).
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:3751
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:275
unsigned getCVRQualifiers() const
Definition: Type.h:270
ExprResult ExprError()
Definition: Ownership.h:279
bool hasVolatile() const
Definition: Type.h:259
std::string getQualifiedNameAsString() const
Definition: Decl.cpp:1548
NameKind getKind() const
CanQualType IntTy
Definition: ASTContext.h:1023
ExprResult CheckConvertedConstantExpression(Expr *From, QualType T, llvm::APSInt &Value, CCEKind CCE)
bool IsQualificationConversion(QualType FromType, QualType ToType, bool CStyle, bool &ObjCLifetimeConversion)
IsQualificationConversion - Determines whether the conversion from an rvalue of type FromType to ToTy...
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:2108
QualType getAsType() const
Retrieve the type for a type template argument.
Definition: TemplateBase.h:256
iterator end()
Definition: Lookup.h:822
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Expr.cpp:1728
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1141
result[0]
Definition: emmintrin.h:120
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:4911
void AddTemplateConversionCandidate(FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl, CXXRecordDecl *ActingContext, Expr *From, QualType ToType, OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit, bool AllowExplicit, bool AllowResultConversion=true)
Adds a conversion function template specialization candidate to the overload set, using template argu...
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:2163
NestedNameSpecifierLoc getQualifierLoc() const
Fetches the nested-name qualifier with source-location information, if one was given.
Definition: ExprCXX.h:2871
bool isPointerType() const
Definition: Type.h:6384
Zero constant to event (OpenCL1.2 6.12.10)
Definition: Overload.h:152
unsigned CallArgIndex
The index of the function argument that caused a deduction failure.
SourceManager & SourceMgr
Definition: Sema.h:377
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc)
Retrieve the overloaded operator kind that corresponds to the given binary opcode.
Definition: Expr.cpp:2071
void NoteAllOverloadCandidates(Expr *E, QualType DestType=QualType(), bool TakingAddress=false)
BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases...
ImplicitConversionKind First
First – The first conversion can be an lvalue-to-rvalue conversion, array-to-pointer conversion...
Definition: Overload.h:234
No viable function found.
Definition: Overload.h:56
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:795
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
Definition: Lookup.h:583
static bool recordConversion(Sema &SemaRef, SourceLocation Loc, Expr *&From, Sema::ContextualImplicitConverter &Converter, QualType T, bool HadMultipleCandidates, DeclAccessPair &Found)
QualType getType() const
Definition: Decl.h:647
bool empty() const
Return true if no decls were found.
Definition: Lookup.h:339
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:128
bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)
A trivial tuple used to represent a source range.
static StringRef getOpcodeStr(Opcode Op)
getOpcodeStr - Turn an Opcode enum value into the punctuation char it corresponds to...
Definition: Expr.cpp:1285
ASTContext & Context
Definition: Sema.h:374
This represents a decl that may have a name.
Definition: Decl.h:248
void dump() const
dump - Print this standard conversion sequence to standard error.
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
CanQualType BoolTy
Definition: ASTContext.h:1015
TemplateDecl * getDescribedTemplate() const
If this is a declaration that describes some template, this method returns that template declaration...
Definition: DeclBase.cpp:229
QualType getNonTypeTemplateArgumentType() const
If this is a non-type template argument, get its type.
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
Definition: TemplateBase.h:280
APSInt & getInt()
Definition: APValue.h:336
iterator begin() const
Definition: Lookup.h:335
CanQualType DoubleTy
Definition: ASTContext.h:1026
Pointer-to-member conversions (C++ [conv.mem])
Definition: Overload.h:122
SourceLocation getNameLoc() const
Gets the location of the identifier.
Definition: Lookup.h:606
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:3236
Describes an entity that is being initialized.
static UserDefinedLiteral * Create(const ASTContext &Ctx, Expr *Fn, ArrayRef< Expr *> Args, QualType Ty, ExprValueKind VK, SourceLocation LitEndLoc, SourceLocation SuffixLoc)
Definition: ExprCXX.cpp:857
SmallVector< TemplateSpecCandidate, 16 >::iterator iterator
void setToType(unsigned Idx, QualType T)
Definition: Overload.h:305
EnableIfAttr * CheckEnableIf(FunctionDecl *Function, ArrayRef< Expr *> Args, bool MissingImplicitThis=false)
Check the enable_if expressions on the given function.
bool isLValue() const
Definition: Expr.h:361
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
Definition: Decl.cpp:3138
void setBase(Expr *E)
Definition: Expr.h:2883
char Diagnostic[sizeof(PartialDiagnosticAt)]
A diagnostic indicating why deduction failed.
void removeAddressSpace()
Definition: Type.h:378
SourceLocation getBegin() const
AssignmentAction
Definition: Sema.h:2703
const LangOptions & getLangOpts() const
Definition: ASTContext.h:710
static ImplicitConversionSequence TryCopyInitialization(Sema &S, Expr *From, QualType ToType, bool SuppressUserConversions, bool InOverloadResolution, bool AllowObjCWritebackConversion, bool AllowExplicit=false)
TryCopyInitialization - Try to copy-initialize a value of type ToType from the expression From...
decls_iterator decls_end() const
Definition: ExprCXX.h:2845
The explicitly-specified template arguments were not valid template arguments for the given template...
Definition: Sema.h:7282
This conversion candidate is not viable because its result type is not implicitly convertible to the ...
Definition: Overload.h:693
QualType getBaseType() const
Definition: ExprCXX.h:3763
Declaration of a template function.
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:3498
static QualType BuildSimilarlyQualifiedPointerType(const Type *FromPtr, QualType ToPointee, QualType ToType, ASTContext &Context, bool StripObjCLifetime=false)
BuildSimilarlyQualifiedPointerType - In a pointer conversion from the pointer type FromPtr to a point...
static ImplicitConversionSequence TryUserDefinedConversion(Sema &S, Expr *From, QualType ToType, bool SuppressUserConversions, bool AllowExplicit, bool InOverloadResolution, bool CStyle, bool AllowObjCWritebackConversion, bool AllowObjCConversionOnExplicit)
Tries a user-defined conversion from From to ToType.
Comparison
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals)
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals...
Attr - This represents one attribute.
Definition: Attr.h:43
bool isDeletedAsWritten() const
Definition: Decl.h:2167
SourceLocation getLocation() const
Definition: DeclBase.h:429
bool isIncompleteOrObjectType() const
Return true if this is an incomplete or object type, in other words, not a function type...
Definition: Type.h:1889
bool isCXX11ConstantExpr(const ASTContext &Ctx, APValue *Result=nullptr, SourceLocation *Loc=nullptr) const
isCXX11ConstantExpr - Return true if this expression is a constant expression in C++11.
QualType getPointeeType() const
Definition: Type.h:2808
LangStandard::Kind Std
A single template declaration.
Definition: TemplateName.h:200
ArrayRef< ParmVarDecl * > parameters() const
Definition: DeclObjC.h:366
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point...
Definition: Expr.cpp:2938
CanQualType UnsignedIntTy
Definition: ASTContext.h:1024
bool hasErrorOccurred() const
Determine whether any SFINAE errors have been trapped.
Definition: Sema.h:7887
unsigned NumConversionsFixed
The number of Conversions fixed.
param_type_iterator param_type_end() const
Definition: Type.h:4071
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:5880
StandardConversionSequence - represents a standard conversion sequence (C++ 13.3.3.1.1).
Definition: Overload.h:229
static void DiagnoseFailedEnableIfAttr(Sema &S, OverloadCandidate *Cand)