clang  6.0.0svn
SemaOverload.cpp
Go to the documentation of this file.
1 //===--- SemaOverload.cpp - C++ Overloading -------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file provides Sema routines for C++ overloading.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/Sema/Overload.h"
15 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/DeclObjC.h"
18 #include "clang/AST/Expr.h"
19 #include "clang/AST/ExprCXX.h"
20 #include "clang/AST/ExprObjC.h"
21 #include "clang/AST/TypeOrdering.h"
22 #include "clang/Basic/Diagnostic.h"
25 #include "clang/Basic/TargetInfo.h"
27 #include "clang/Sema/Lookup.h"
29 #include "clang/Sema/Template.h"
31 #include "llvm/ADT/DenseSet.h"
32 #include "llvm/ADT/Optional.h"
33 #include "llvm/ADT/STLExtras.h"
34 #include "llvm/ADT/SmallPtrSet.h"
35 #include "llvm/ADT/SmallString.h"
36 #include <algorithm>
37 #include <cstdlib>
38 
39 using namespace clang;
40 using namespace sema;
41 
43  return llvm::any_of(FD->parameters(), [](const ParmVarDecl *P) {
44  return P->hasAttr<PassObjectSizeAttr>();
45  });
46 }
47 
48 /// A convenience routine for creating a decayed reference to a function.
49 static ExprResult
51  const Expr *Base, bool HadMultipleCandidates,
53  const DeclarationNameLoc &LocInfo = DeclarationNameLoc()){
54  if (S.DiagnoseUseOfDecl(FoundDecl, Loc))
55  return ExprError();
56  // If FoundDecl is different from Fn (such as if one is a template
57  // and the other a specialization), make sure DiagnoseUseOfDecl is
58  // called on both.
59  // FIXME: This would be more comprehensively addressed by modifying
60  // DiagnoseUseOfDecl to accept both the FoundDecl and the decl
61  // being used.
62  if (FoundDecl != Fn && S.DiagnoseUseOfDecl(Fn, Loc))
63  return ExprError();
64  if (auto *FPT = Fn->getType()->getAs<FunctionProtoType>())
65  S.ResolveExceptionSpec(Loc, FPT);
66  DeclRefExpr *DRE = new (S.Context) DeclRefExpr(Fn, false, Fn->getType(),
67  VK_LValue, Loc, LocInfo);
68  if (HadMultipleCandidates)
69  DRE->setHadMultipleCandidates(true);
70 
71  S.MarkDeclRefReferenced(DRE, Base);
72  return S.ImpCastExprToType(DRE, S.Context.getPointerType(DRE->getType()),
73  CK_FunctionToPointerDecay);
74 }
75 
76 static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
77  bool InOverloadResolution,
79  bool CStyle,
80  bool AllowObjCWritebackConversion);
81 
82 static bool IsTransparentUnionStandardConversion(Sema &S, Expr* From,
83  QualType &ToType,
84  bool InOverloadResolution,
86  bool CStyle);
87 static OverloadingResult
88 IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
90  OverloadCandidateSet& Conversions,
91  bool AllowExplicit,
92  bool AllowObjCConversionOnExplicit);
93 
94 
97  const StandardConversionSequence& SCS1,
98  const StandardConversionSequence& SCS2);
99 
102  const StandardConversionSequence& SCS1,
103  const StandardConversionSequence& SCS2);
104 
107  const StandardConversionSequence& SCS1,
108  const StandardConversionSequence& SCS2);
109 
110 /// GetConversionRank - Retrieve the implicit conversion rank
111 /// corresponding to the given implicit conversion kind.
113  static const ImplicitConversionRank
114  Rank[(int)ICK_Num_Conversion_Kinds] = {
139  ICR_Exact_Match, // NOTE(gbiv): This may not be completely right --
140  // it was omitted by the patch that added
141  // ICK_Zero_Event_Conversion
144  };
145  return Rank[(int)Kind];
146 }
147 
148 /// GetImplicitConversionName - Return the name of this kind of
149 /// implicit conversion.
151  static const char* const Name[(int)ICK_Num_Conversion_Kinds] = {
152  "No conversion",
153  "Lvalue-to-rvalue",
154  "Array-to-pointer",
155  "Function-to-pointer",
156  "Function pointer conversion",
157  "Qualification",
158  "Integral promotion",
159  "Floating point promotion",
160  "Complex promotion",
161  "Integral conversion",
162  "Floating conversion",
163  "Complex conversion",
164  "Floating-integral conversion",
165  "Pointer conversion",
166  "Pointer-to-member conversion",
167  "Boolean conversion",
168  "Compatible-types conversion",
169  "Derived-to-base conversion",
170  "Vector conversion",
171  "Vector splat",
172  "Complex-real conversion",
173  "Block Pointer conversion",
174  "Transparent Union Conversion",
175  "Writeback conversion",
176  "OpenCL Zero Event Conversion",
177  "C specific type conversion",
178  "Incompatible pointer conversion"
179  };
180  return Name[Kind];
181 }
182 
183 /// StandardConversionSequence - Set the standard conversion
184 /// sequence to the identity conversion.
186  First = ICK_Identity;
187  Second = ICK_Identity;
188  Third = ICK_Identity;
189  DeprecatedStringLiteralToCharPtr = false;
190  QualificationIncludesObjCLifetime = false;
191  ReferenceBinding = false;
192  DirectBinding = false;
193  IsLvalueReference = true;
194  BindsToFunctionLvalue = false;
195  BindsToRvalue = false;
196  BindsImplicitObjectArgumentWithoutRefQualifier = false;
197  ObjCLifetimeConversionBinding = false;
198  CopyConstructor = nullptr;
199 }
200 
201 /// getRank - Retrieve the rank of this standard conversion sequence
202 /// (C++ 13.3.3.1.1p3). The rank is the largest rank of each of the
203 /// implicit conversions.
206  if (GetConversionRank(First) > Rank)
207  Rank = GetConversionRank(First);
208  if (GetConversionRank(Second) > Rank)
209  Rank = GetConversionRank(Second);
210  if (GetConversionRank(Third) > Rank)
211  Rank = GetConversionRank(Third);
212  return Rank;
213 }
214 
215 /// isPointerConversionToBool - Determines whether this conversion is
216 /// a conversion of a pointer or pointer-to-member to bool. This is
217 /// used as part of the ranking of standard conversion sequences
218 /// (C++ 13.3.3.2p4).
220  // Note that FromType has not necessarily been transformed by the
221  // array-to-pointer or function-to-pointer implicit conversions, so
222  // check for their presence as well as checking whether FromType is
223  // a pointer.
224  if (getToType(1)->isBooleanType() &&
225  (getFromType()->isPointerType() ||
226  getFromType()->isObjCObjectPointerType() ||
227  getFromType()->isBlockPointerType() ||
228  getFromType()->isNullPtrType() ||
229  First == ICK_Array_To_Pointer || First == ICK_Function_To_Pointer))
230  return true;
231 
232  return false;
233 }
234 
235 /// isPointerConversionToVoidPointer - Determines whether this
236 /// conversion is a conversion of a pointer to a void pointer. This is
237 /// used as part of the ranking of standard conversion sequences (C++
238 /// 13.3.3.2p4).
239 bool
242  QualType FromType = getFromType();
243  QualType ToType = getToType(1);
244 
245  // Note that FromType has not necessarily been transformed by the
246  // array-to-pointer implicit conversion, so check for its presence
247  // and redo the conversion to get a pointer.
248  if (First == ICK_Array_To_Pointer)
249  FromType = Context.getArrayDecayedType(FromType);
250 
251  if (Second == ICK_Pointer_Conversion && FromType->isAnyPointerType())
252  if (const PointerType* ToPtrType = ToType->getAs<PointerType>())
253  return ToPtrType->getPointeeType()->isVoidType();
254 
255  return false;
256 }
257 
258 /// Skip any implicit casts which could be either part of a narrowing conversion
259 /// or after one in an implicit conversion.
260 static const Expr *IgnoreNarrowingConversion(const Expr *Converted) {
261  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Converted)) {
262  switch (ICE->getCastKind()) {
263  case CK_NoOp:
264  case CK_IntegralCast:
265  case CK_IntegralToBoolean:
266  case CK_IntegralToFloating:
267  case CK_BooleanToSignedIntegral:
268  case CK_FloatingToIntegral:
269  case CK_FloatingToBoolean:
270  case CK_FloatingCast:
271  Converted = ICE->getSubExpr();
272  continue;
273 
274  default:
275  return Converted;
276  }
277  }
278 
279  return Converted;
280 }
281 
282 /// Check if this standard conversion sequence represents a narrowing
283 /// conversion, according to C++11 [dcl.init.list]p7.
284 ///
285 /// \param Ctx The AST context.
286 /// \param Converted The result of applying this standard conversion sequence.
287 /// \param ConstantValue If this is an NK_Constant_Narrowing conversion, the
288 /// value of the expression prior to the narrowing conversion.
289 /// \param ConstantType If this is an NK_Constant_Narrowing conversion, the
290 /// type of the expression prior to the narrowing conversion.
293  const Expr *Converted,
294  APValue &ConstantValue,
295  QualType &ConstantType) const {
296  assert(Ctx.getLangOpts().CPlusPlus && "narrowing check outside C++");
297 
298  // C++11 [dcl.init.list]p7:
299  // A narrowing conversion is an implicit conversion ...
300  QualType FromType = getToType(0);
301  QualType ToType = getToType(1);
302 
303  // A conversion to an enumeration type is narrowing if the conversion to
304  // the underlying type is narrowing. This only arises for expressions of
305  // the form 'Enum{init}'.
306  if (auto *ET = ToType->getAs<EnumType>())
307  ToType = ET->getDecl()->getIntegerType();
308 
309  switch (Second) {
310  // 'bool' is an integral type; dispatch to the right place to handle it.
312  if (FromType->isRealFloatingType())
313  goto FloatingIntegralConversion;
314  if (FromType->isIntegralOrUnscopedEnumerationType())
315  goto IntegralConversion;
316  // Boolean conversions can be from pointers and pointers to members
317  // [conv.bool], and those aren't considered narrowing conversions.
318  return NK_Not_Narrowing;
319 
320  // -- from a floating-point type to an integer type, or
321  //
322  // -- from an integer type or unscoped enumeration type to a floating-point
323  // type, except where the source is a constant expression and the actual
324  // value after conversion will fit into the target type and will produce
325  // the original value when converted back to the original type, or
327  FloatingIntegralConversion:
328  if (FromType->isRealFloatingType() && ToType->isIntegralType(Ctx)) {
329  return NK_Type_Narrowing;
330  } else if (FromType->isIntegralType(Ctx) && ToType->isRealFloatingType()) {
331  llvm::APSInt IntConstantValue;
332  const Expr *Initializer = IgnoreNarrowingConversion(Converted);
333  assert(Initializer && "Unknown conversion expression");
334 
335  // If it's value-dependent, we can't tell whether it's narrowing.
336  if (Initializer->isValueDependent())
337  return NK_Dependent_Narrowing;
338 
339  if (Initializer->isIntegerConstantExpr(IntConstantValue, Ctx)) {
340  // Convert the integer to the floating type.
341  llvm::APFloat Result(Ctx.getFloatTypeSemantics(ToType));
342  Result.convertFromAPInt(IntConstantValue, IntConstantValue.isSigned(),
343  llvm::APFloat::rmNearestTiesToEven);
344  // And back.
345  llvm::APSInt ConvertedValue = IntConstantValue;
346  bool ignored;
347  Result.convertToInteger(ConvertedValue,
348  llvm::APFloat::rmTowardZero, &ignored);
349  // If the resulting value is different, this was a narrowing conversion.
350  if (IntConstantValue != ConvertedValue) {
351  ConstantValue = APValue(IntConstantValue);
352  ConstantType = Initializer->getType();
353  return NK_Constant_Narrowing;
354  }
355  } else {
356  // Variables are always narrowings.
357  return NK_Variable_Narrowing;
358  }
359  }
360  return NK_Not_Narrowing;
361 
362  // -- from long double to double or float, or from double to float, except
363  // where the source is a constant expression and the actual value after
364  // conversion is within the range of values that can be represented (even
365  // if it cannot be represented exactly), or
367  if (FromType->isRealFloatingType() && ToType->isRealFloatingType() &&
368  Ctx.getFloatingTypeOrder(FromType, ToType) == 1) {
369  // FromType is larger than ToType.
370  const Expr *Initializer = IgnoreNarrowingConversion(Converted);
371 
372  // If it's value-dependent, we can't tell whether it's narrowing.
373  if (Initializer->isValueDependent())
374  return NK_Dependent_Narrowing;
375 
376  if (Initializer->isCXX11ConstantExpr(Ctx, &ConstantValue)) {
377  // Constant!
378  assert(ConstantValue.isFloat());
379  llvm::APFloat FloatVal = ConstantValue.getFloat();
380  // Convert the source value into the target type.
381  bool ignored;
382  llvm::APFloat::opStatus ConvertStatus = FloatVal.convert(
383  Ctx.getFloatTypeSemantics(ToType),
384  llvm::APFloat::rmNearestTiesToEven, &ignored);
385  // If there was no overflow, the source value is within the range of
386  // values that can be represented.
387  if (ConvertStatus & llvm::APFloat::opOverflow) {
388  ConstantType = Initializer->getType();
389  return NK_Constant_Narrowing;
390  }
391  } else {
392  return NK_Variable_Narrowing;
393  }
394  }
395  return NK_Not_Narrowing;
396 
397  // -- from an integer type or unscoped enumeration type to an integer type
398  // that cannot represent all the values of the original type, except where
399  // the source is a constant expression and the actual value after
400  // conversion will fit into the target type and will produce the original
401  // value when converted back to the original type.
403  IntegralConversion: {
404  assert(FromType->isIntegralOrUnscopedEnumerationType());
405  assert(ToType->isIntegralOrUnscopedEnumerationType());
406  const bool FromSigned = FromType->isSignedIntegerOrEnumerationType();
407  const unsigned FromWidth = Ctx.getIntWidth(FromType);
408  const bool ToSigned = ToType->isSignedIntegerOrEnumerationType();
409  const unsigned ToWidth = Ctx.getIntWidth(ToType);
410 
411  if (FromWidth > ToWidth ||
412  (FromWidth == ToWidth && FromSigned != ToSigned) ||
413  (FromSigned && !ToSigned)) {
414  // Not all values of FromType can be represented in ToType.
415  llvm::APSInt InitializerValue;
416  const Expr *Initializer = IgnoreNarrowingConversion(Converted);
417 
418  // If it's value-dependent, we can't tell whether it's narrowing.
419  if (Initializer->isValueDependent())
420  return NK_Dependent_Narrowing;
421 
422  if (!Initializer->isIntegerConstantExpr(InitializerValue, Ctx)) {
423  // Such conversions on variables are always narrowing.
424  return NK_Variable_Narrowing;
425  }
426  bool Narrowing = false;
427  if (FromWidth < ToWidth) {
428  // Negative -> unsigned is narrowing. Otherwise, more bits is never
429  // narrowing.
430  if (InitializerValue.isSigned() && InitializerValue.isNegative())
431  Narrowing = true;
432  } else {
433  // Add a bit to the InitializerValue so we don't have to worry about
434  // signed vs. unsigned comparisons.
435  InitializerValue = InitializerValue.extend(
436  InitializerValue.getBitWidth() + 1);
437  // Convert the initializer to and from the target width and signed-ness.
438  llvm::APSInt ConvertedValue = InitializerValue;
439  ConvertedValue = ConvertedValue.trunc(ToWidth);
440  ConvertedValue.setIsSigned(ToSigned);
441  ConvertedValue = ConvertedValue.extend(InitializerValue.getBitWidth());
442  ConvertedValue.setIsSigned(InitializerValue.isSigned());
443  // If the result is different, this was a narrowing conversion.
444  if (ConvertedValue != InitializerValue)
445  Narrowing = true;
446  }
447  if (Narrowing) {
448  ConstantType = Initializer->getType();
449  ConstantValue = APValue(InitializerValue);
450  return NK_Constant_Narrowing;
451  }
452  }
453  return NK_Not_Narrowing;
454  }
455 
456  default:
457  // Other kinds of conversions are not narrowings.
458  return NK_Not_Narrowing;
459  }
460 }
461 
462 /// dump - Print this standard conversion sequence to standard
463 /// error. Useful for debugging overloading issues.
464 LLVM_DUMP_METHOD void StandardConversionSequence::dump() const {
465  raw_ostream &OS = llvm::errs();
466  bool PrintedSomething = false;
467  if (First != ICK_Identity) {
468  OS << GetImplicitConversionName(First);
469  PrintedSomething = true;
470  }
471 
472  if (Second != ICK_Identity) {
473  if (PrintedSomething) {
474  OS << " -> ";
475  }
476  OS << GetImplicitConversionName(Second);
477 
478  if (CopyConstructor) {
479  OS << " (by copy constructor)";
480  } else if (DirectBinding) {
481  OS << " (direct reference binding)";
482  } else if (ReferenceBinding) {
483  OS << " (reference binding)";
484  }
485  PrintedSomething = true;
486  }
487 
488  if (Third != ICK_Identity) {
489  if (PrintedSomething) {
490  OS << " -> ";
491  }
492  OS << GetImplicitConversionName(Third);
493  PrintedSomething = true;
494  }
495 
496  if (!PrintedSomething) {
497  OS << "No conversions required";
498  }
499 }
500 
501 /// dump - Print this user-defined conversion sequence to standard
502 /// error. Useful for debugging overloading issues.
504  raw_ostream &OS = llvm::errs();
505  if (Before.First || Before.Second || Before.Third) {
506  Before.dump();
507  OS << " -> ";
508  }
509  if (ConversionFunction)
510  OS << '\'' << *ConversionFunction << '\'';
511  else
512  OS << "aggregate initialization";
513  if (After.First || After.Second || After.Third) {
514  OS << " -> ";
515  After.dump();
516  }
517 }
518 
519 /// dump - Print this implicit conversion sequence to standard
520 /// error. Useful for debugging overloading issues.
522  raw_ostream &OS = llvm::errs();
523  if (isStdInitializerListElement())
524  OS << "Worst std::initializer_list element conversion: ";
525  switch (ConversionKind) {
526  case StandardConversion:
527  OS << "Standard conversion: ";
528  Standard.dump();
529  break;
530  case UserDefinedConversion:
531  OS << "User-defined conversion: ";
532  UserDefined.dump();
533  break;
534  case EllipsisConversion:
535  OS << "Ellipsis conversion";
536  break;
537  case AmbiguousConversion:
538  OS << "Ambiguous conversion";
539  break;
540  case BadConversion:
541  OS << "Bad conversion";
542  break;
543  }
544 
545  OS << "\n";
546 }
547 
549  new (&conversions()) ConversionSet();
550 }
551 
553  conversions().~ConversionSet();
554 }
555 
556 void
558  FromTypePtr = O.FromTypePtr;
559  ToTypePtr = O.ToTypePtr;
560  new (&conversions()) ConversionSet(O.conversions());
561 }
562 
563 namespace {
564  // Structure used by DeductionFailureInfo to store
565  // template argument information.
566  struct DFIArguments {
567  TemplateArgument FirstArg;
568  TemplateArgument SecondArg;
569  };
570  // Structure used by DeductionFailureInfo to store
571  // template parameter and template argument information.
572  struct DFIParamWithArguments : DFIArguments {
573  TemplateParameter Param;
574  };
575  // Structure used by DeductionFailureInfo to store template argument
576  // information and the index of the problematic call argument.
577  struct DFIDeducedMismatchArgs : DFIArguments {
578  TemplateArgumentList *TemplateArgs;
579  unsigned CallArgIndex;
580  };
581 }
582 
583 /// \brief Convert from Sema's representation of template deduction information
584 /// to the form used in overload-candidate information.
588  TemplateDeductionInfo &Info) {
589  DeductionFailureInfo Result;
590  Result.Result = static_cast<unsigned>(TDK);
591  Result.HasDiagnostic = false;
592  switch (TDK) {
593  case Sema::TDK_Invalid:
599  Result.Data = nullptr;
600  break;
601 
604  Result.Data = Info.Param.getOpaqueValue();
605  break;
606 
609  // FIXME: Should allocate from normal heap so that we can free this later.
610  auto *Saved = new (Context) DFIDeducedMismatchArgs;
611  Saved->FirstArg = Info.FirstArg;
612  Saved->SecondArg = Info.SecondArg;
613  Saved->TemplateArgs = Info.take();
614  Saved->CallArgIndex = Info.CallArgIndex;
615  Result.Data = Saved;
616  break;
617  }
618 
620  // FIXME: Should allocate from normal heap so that we can free this later.
621  DFIArguments *Saved = new (Context) DFIArguments;
622  Saved->FirstArg = Info.FirstArg;
623  Saved->SecondArg = Info.SecondArg;
624  Result.Data = Saved;
625  break;
626  }
627 
630  // FIXME: Should allocate from normal heap so that we can free this later.
631  DFIParamWithArguments *Saved = new (Context) DFIParamWithArguments;
632  Saved->Param = Info.Param;
633  Saved->FirstArg = Info.FirstArg;
634  Saved->SecondArg = Info.SecondArg;
635  Result.Data = Saved;
636  break;
637  }
638 
640  Result.Data = Info.take();
641  if (Info.hasSFINAEDiagnostic()) {
644  Info.takeSFINAEDiagnostic(*Diag);
645  Result.HasDiagnostic = true;
646  }
647  break;
648 
649  case Sema::TDK_Success:
651  llvm_unreachable("not a deduction failure");
652  }
653 
654  return Result;
655 }
656 
658  switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
659  case Sema::TDK_Success:
660  case Sema::TDK_Invalid:
668  break;
669 
675  // FIXME: Destroy the data?
676  Data = nullptr;
677  break;
678 
680  // FIXME: Destroy the template argument list?
681  Data = nullptr;
682  if (PartialDiagnosticAt *Diag = getSFINAEDiagnostic()) {
683  Diag->~PartialDiagnosticAt();
684  HasDiagnostic = false;
685  }
686  break;
687 
688  // Unhandled
690  break;
691  }
692 }
693 
695  if (HasDiagnostic)
696  return static_cast<PartialDiagnosticAt*>(static_cast<void*>(Diagnostic));
697  return nullptr;
698 }
699 
701  switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
702  case Sema::TDK_Success:
703  case Sema::TDK_Invalid:
713  return TemplateParameter();
714 
717  return TemplateParameter::getFromOpaqueValue(Data);
718 
721  return static_cast<DFIParamWithArguments*>(Data)->Param;
722 
723  // Unhandled
725  break;
726  }
727 
728  return TemplateParameter();
729 }
730 
732  switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
733  case Sema::TDK_Success:
734  case Sema::TDK_Invalid:
745  return nullptr;
746 
749  return static_cast<DFIDeducedMismatchArgs*>(Data)->TemplateArgs;
750 
752  return static_cast<TemplateArgumentList*>(Data);
753 
754  // Unhandled
756  break;
757  }
758 
759  return nullptr;
760 }
761 
763  switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
764  case Sema::TDK_Success:
765  case Sema::TDK_Invalid:
774  return nullptr;
775 
781  return &static_cast<DFIArguments*>(Data)->FirstArg;
782 
783  // Unhandled
785  break;
786  }
787 
788  return nullptr;
789 }
790 
792  switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
793  case Sema::TDK_Success:
794  case Sema::TDK_Invalid:
803  return nullptr;
804 
810  return &static_cast<DFIArguments*>(Data)->SecondArg;
811 
812  // Unhandled
814  break;
815  }
816 
817  return nullptr;
818 }
819 
821  switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
824  return static_cast<DFIDeducedMismatchArgs*>(Data)->CallArgIndex;
825 
826  default:
827  return llvm::None;
828  }
829 }
830 
831 void OverloadCandidateSet::destroyCandidates() {
832  for (iterator i = begin(), e = end(); i != e; ++i) {
833  for (auto &C : i->Conversions)
834  C.~ImplicitConversionSequence();
835  if (!i->Viable && i->FailureKind == ovl_fail_bad_deduction)
836  i->DeductionFailure.Destroy();
837  }
838 }
839 
841  destroyCandidates();
842  SlabAllocator.Reset();
843  NumInlineBytesUsed = 0;
844  Candidates.clear();
845  Functions.clear();
846  Kind = CSK;
847 }
848 
849 namespace {
850  class UnbridgedCastsSet {
851  struct Entry {
852  Expr **Addr;
853  Expr *Saved;
854  };
855  SmallVector<Entry, 2> Entries;
856 
857  public:
858  void save(Sema &S, Expr *&E) {
859  assert(E->hasPlaceholderType(BuiltinType::ARCUnbridgedCast));
860  Entry entry = { &E, E };
861  Entries.push_back(entry);
862  E = S.stripARCUnbridgedCast(E);
863  }
864 
865  void restore() {
867  i = Entries.begin(), e = Entries.end(); i != e; ++i)
868  *i->Addr = i->Saved;
869  }
870  };
871 }
872 
873 /// checkPlaceholderForOverload - Do any interesting placeholder-like
874 /// preprocessing on the given expression.
875 ///
876 /// \param unbridgedCasts a collection to which to add unbridged casts;
877 /// without this, they will be immediately diagnosed as errors
878 ///
879 /// Return true on unrecoverable error.
880 static bool
882  UnbridgedCastsSet *unbridgedCasts = nullptr) {
883  if (const BuiltinType *placeholder = E->getType()->getAsPlaceholderType()) {
884  // We can't handle overloaded expressions here because overload
885  // resolution might reasonably tweak them.
886  if (placeholder->getKind() == BuiltinType::Overload) return false;
887 
888  // If the context potentially accepts unbridged ARC casts, strip
889  // the unbridged cast and add it to the collection for later restoration.
890  if (placeholder->getKind() == BuiltinType::ARCUnbridgedCast &&
891  unbridgedCasts) {
892  unbridgedCasts->save(S, E);
893  return false;
894  }
895 
896  // Go ahead and check everything else.
897  ExprResult result = S.CheckPlaceholderExpr(E);
898  if (result.isInvalid())
899  return true;
900 
901  E = result.get();
902  return false;
903  }
904 
905  // Nothing to do.
906  return false;
907 }
908 
909 /// checkArgPlaceholdersForOverload - Check a set of call operands for
910 /// placeholders.
912  MultiExprArg Args,
913  UnbridgedCastsSet &unbridged) {
914  for (unsigned i = 0, e = Args.size(); i != e; ++i)
915  if (checkPlaceholderForOverload(S, Args[i], &unbridged))
916  return true;
917 
918  return false;
919 }
920 
921 /// Determine whether the given New declaration is an overload of the
922 /// declarations in Old. This routine returns Ovl_Match or Ovl_NonFunction if
923 /// New and Old cannot be overloaded, e.g., if New has the same signature as
924 /// some function in Old (C++ 1.3.10) or if the Old declarations aren't
925 /// functions (or function templates) at all. When it does return Ovl_Match or
926 /// Ovl_NonFunction, MatchedDecl will point to the decl that New cannot be
927 /// overloaded with. This decl may be a UsingShadowDecl on top of the underlying
928 /// declaration.
929 ///
930 /// Example: Given the following input:
931 ///
932 /// void f(int, float); // #1
933 /// void f(int, int); // #2
934 /// int f(int, int); // #3
935 ///
936 /// When we process #1, there is no previous declaration of "f", so IsOverload
937 /// will not be used.
938 ///
939 /// When we process #2, Old contains only the FunctionDecl for #1. By comparing
940 /// the parameter types, we see that #1 and #2 are overloaded (since they have
941 /// different signatures), so this routine returns Ovl_Overload; MatchedDecl is
942 /// unchanged.
943 ///
944 /// When we process #3, Old is an overload set containing #1 and #2. We compare
945 /// the signatures of #3 to #1 (they're overloaded, so we do nothing) and then
946 /// #3 to #2. Since the signatures of #3 and #2 are identical (return types of
947 /// functions are not part of the signature), IsOverload returns Ovl_Match and
948 /// MatchedDecl will be set to point to the FunctionDecl for #2.
949 ///
950 /// 'NewIsUsingShadowDecl' indicates that 'New' is being introduced into a class
951 /// by a using declaration. The rules for whether to hide shadow declarations
952 /// ignore some properties which otherwise figure into a function template's
953 /// signature.
956  NamedDecl *&Match, bool NewIsUsingDecl) {
957  for (LookupResult::iterator I = Old.begin(), E = Old.end();
958  I != E; ++I) {
959  NamedDecl *OldD = *I;
960 
961  bool OldIsUsingDecl = false;
962  if (isa<UsingShadowDecl>(OldD)) {
963  OldIsUsingDecl = true;
964 
965  // We can always introduce two using declarations into the same
966  // context, even if they have identical signatures.
967  if (NewIsUsingDecl) continue;
968 
969  OldD = cast<UsingShadowDecl>(OldD)->getTargetDecl();
970  }
971 
972  // A using-declaration does not conflict with another declaration
973  // if one of them is hidden.
974  if ((OldIsUsingDecl || NewIsUsingDecl) && !isVisible(*I))
975  continue;
976 
977  // If either declaration was introduced by a using declaration,
978  // we'll need to use slightly different rules for matching.
979  // Essentially, these rules are the normal rules, except that
980  // function templates hide function templates with different
981  // return types or template parameter lists.
982  bool UseMemberUsingDeclRules =
983  (OldIsUsingDecl || NewIsUsingDecl) && CurContext->isRecord() &&
984  !New->getFriendObjectKind();
985 
986  if (FunctionDecl *OldF = OldD->getAsFunction()) {
987  if (!IsOverload(New, OldF, UseMemberUsingDeclRules)) {
988  if (UseMemberUsingDeclRules && OldIsUsingDecl) {
989  HideUsingShadowDecl(S, cast<UsingShadowDecl>(*I));
990  continue;
991  }
992 
993  if (!isa<FunctionTemplateDecl>(OldD) &&
994  !shouldLinkPossiblyHiddenDecl(*I, New))
995  continue;
996 
997  Match = *I;
998  return Ovl_Match;
999  }
1000  } else if (isa<UsingDecl>(OldD) || isa<UsingPackDecl>(OldD)) {
1001  // We can overload with these, which can show up when doing
1002  // redeclaration checks for UsingDecls.
1003  assert(Old.getLookupKind() == LookupUsingDeclName);
1004  } else if (isa<TagDecl>(OldD)) {
1005  // We can always overload with tags by hiding them.
1006  } else if (auto *UUD = dyn_cast<UnresolvedUsingValueDecl>(OldD)) {
1007  // Optimistically assume that an unresolved using decl will
1008  // overload; if it doesn't, we'll have to diagnose during
1009  // template instantiation.
1010  //
1011  // Exception: if the scope is dependent and this is not a class
1012  // member, the using declaration can only introduce an enumerator.
1013  if (UUD->getQualifier()->isDependent() && !UUD->isCXXClassMember()) {
1014  Match = *I;
1015  return Ovl_NonFunction;
1016  }
1017  } else {
1018  // (C++ 13p1):
1019  // Only function declarations can be overloaded; object and type
1020  // declarations cannot be overloaded.
1021  Match = *I;
1022  return Ovl_NonFunction;
1023  }
1024  }
1025 
1026  return Ovl_Overload;
1027 }
1028 
1030  bool UseMemberUsingDeclRules, bool ConsiderCudaAttrs) {
1031  // C++ [basic.start.main]p2: This function shall not be overloaded.
1032  if (New->isMain())
1033  return false;
1034 
1035  // MSVCRT user defined entry points cannot be overloaded.
1036  if (New->isMSVCRTEntryPoint())
1037  return false;
1038 
1039  FunctionTemplateDecl *OldTemplate = Old->getDescribedFunctionTemplate();
1040  FunctionTemplateDecl *NewTemplate = New->getDescribedFunctionTemplate();
1041 
1042  // C++ [temp.fct]p2:
1043  // A function template can be overloaded with other function templates
1044  // and with normal (non-template) functions.
1045  if ((OldTemplate == nullptr) != (NewTemplate == nullptr))
1046  return true;
1047 
1048  // Is the function New an overload of the function Old?
1049  QualType OldQType = Context.getCanonicalType(Old->getType());
1050  QualType NewQType = Context.getCanonicalType(New->getType());
1051 
1052  // Compare the signatures (C++ 1.3.10) of the two functions to
1053  // determine whether they are overloads. If we find any mismatch
1054  // in the signature, they are overloads.
1055 
1056  // If either of these functions is a K&R-style function (no
1057  // prototype), then we consider them to have matching signatures.
1058  if (isa<FunctionNoProtoType>(OldQType.getTypePtr()) ||
1059  isa<FunctionNoProtoType>(NewQType.getTypePtr()))
1060  return false;
1061 
1062  const FunctionProtoType *OldType = cast<FunctionProtoType>(OldQType);
1063  const FunctionProtoType *NewType = cast<FunctionProtoType>(NewQType);
1064 
1065  // The signature of a function includes the types of its
1066  // parameters (C++ 1.3.10), which includes the presence or absence
1067  // of the ellipsis; see C++ DR 357).
1068  if (OldQType != NewQType &&
1069  (OldType->getNumParams() != NewType->getNumParams() ||
1070  OldType->isVariadic() != NewType->isVariadic() ||
1071  !FunctionParamTypesAreEqual(OldType, NewType)))
1072  return true;
1073 
1074  // C++ [temp.over.link]p4:
1075  // The signature of a function template consists of its function
1076  // signature, its return type and its template parameter list. The names
1077  // of the template parameters are significant only for establishing the
1078  // relationship between the template parameters and the rest of the
1079  // signature.
1080  //
1081  // We check the return type and template parameter lists for function
1082  // templates first; the remaining checks follow.
1083  //
1084  // However, we don't consider either of these when deciding whether
1085  // a member introduced by a shadow declaration is hidden.
1086  if (!UseMemberUsingDeclRules && NewTemplate &&
1087  (!TemplateParameterListsAreEqual(NewTemplate->getTemplateParameters(),
1088  OldTemplate->getTemplateParameters(),
1089  false, TPL_TemplateMatch) ||
1090  OldType->getReturnType() != NewType->getReturnType()))
1091  return true;
1092 
1093  // If the function is a class member, its signature includes the
1094  // cv-qualifiers (if any) and ref-qualifier (if any) on the function itself.
1095  //
1096  // As part of this, also check whether one of the member functions
1097  // is static, in which case they are not overloads (C++
1098  // 13.1p2). While not part of the definition of the signature,
1099  // this check is important to determine whether these functions
1100  // can be overloaded.
1101  CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old);
1102  CXXMethodDecl *NewMethod = dyn_cast<CXXMethodDecl>(New);
1103  if (OldMethod && NewMethod &&
1104  !OldMethod->isStatic() && !NewMethod->isStatic()) {
1105  if (OldMethod->getRefQualifier() != NewMethod->getRefQualifier()) {
1106  if (!UseMemberUsingDeclRules &&
1107  (OldMethod->getRefQualifier() == RQ_None ||
1108  NewMethod->getRefQualifier() == RQ_None)) {
1109  // C++0x [over.load]p2:
1110  // - Member function declarations with the same name and the same
1111  // parameter-type-list as well as member function template
1112  // declarations with the same name, the same parameter-type-list, and
1113  // the same template parameter lists cannot be overloaded if any of
1114  // them, but not all, have a ref-qualifier (8.3.5).
1115  Diag(NewMethod->getLocation(), diag::err_ref_qualifier_overload)
1116  << NewMethod->getRefQualifier() << OldMethod->getRefQualifier();
1117  Diag(OldMethod->getLocation(), diag::note_previous_declaration);
1118  }
1119  return true;
1120  }
1121 
1122  // We may not have applied the implicit const for a constexpr member
1123  // function yet (because we haven't yet resolved whether this is a static
1124  // or non-static member function). Add it now, on the assumption that this
1125  // is a redeclaration of OldMethod.
1126  unsigned OldQuals = OldMethod->getTypeQualifiers();
1127  unsigned NewQuals = NewMethod->getTypeQualifiers();
1128  if (!getLangOpts().CPlusPlus14 && NewMethod->isConstexpr() &&
1129  !isa<CXXConstructorDecl>(NewMethod))
1130  NewQuals |= Qualifiers::Const;
1131 
1132  // We do not allow overloading based off of '__restrict'.
1133  OldQuals &= ~Qualifiers::Restrict;
1134  NewQuals &= ~Qualifiers::Restrict;
1135  if (OldQuals != NewQuals)
1136  return true;
1137  }
1138 
1139  // Though pass_object_size is placed on parameters and takes an argument, we
1140  // consider it to be a function-level modifier for the sake of function
1141  // identity. Either the function has one or more parameters with
1142  // pass_object_size or it doesn't.
1145  return true;
1146 
1147  // enable_if attributes are an order-sensitive part of the signature.
1149  NewI = New->specific_attr_begin<EnableIfAttr>(),
1150  NewE = New->specific_attr_end<EnableIfAttr>(),
1151  OldI = Old->specific_attr_begin<EnableIfAttr>(),
1152  OldE = Old->specific_attr_end<EnableIfAttr>();
1153  NewI != NewE || OldI != OldE; ++NewI, ++OldI) {
1154  if (NewI == NewE || OldI == OldE)
1155  return true;
1156  llvm::FoldingSetNodeID NewID, OldID;
1157  NewI->getCond()->Profile(NewID, Context, true);
1158  OldI->getCond()->Profile(OldID, Context, true);
1159  if (NewID != OldID)
1160  return true;
1161  }
1162 
1163  if (getLangOpts().CUDA && ConsiderCudaAttrs) {
1164  // Don't allow overloading of destructors. (In theory we could, but it
1165  // would be a giant change to clang.)
1166  if (isa<CXXDestructorDecl>(New))
1167  return false;
1168 
1169  CUDAFunctionTarget NewTarget = IdentifyCUDATarget(New),
1170  OldTarget = IdentifyCUDATarget(Old);
1171  if (NewTarget == CFT_InvalidTarget)
1172  return false;
1173 
1174  assert((OldTarget != CFT_InvalidTarget) && "Unexpected invalid target.");
1175 
1176  // Allow overloading of functions with same signature and different CUDA
1177  // target attributes.
1178  return NewTarget != OldTarget;
1179  }
1180 
1181  // The signatures match; this is not an overload.
1182  return false;
1183 }
1184 
1185 /// \brief Checks availability of the function depending on the current
1186 /// function context. Inside an unavailable function, unavailability is ignored.
1187 ///
1188 /// \returns true if \arg FD is unavailable and current context is inside
1189 /// an available function, false otherwise.
1191  if (!FD->isUnavailable())
1192  return false;
1193 
1194  // Walk up the context of the caller.
1195  Decl *C = cast<Decl>(CurContext);
1196  do {
1197  if (C->isUnavailable())
1198  return false;
1199  } while ((C = cast_or_null<Decl>(C->getDeclContext())));
1200  return true;
1201 }
1202 
1203 /// \brief Tries a user-defined conversion from From to ToType.
1204 ///
1205 /// Produces an implicit conversion sequence for when a standard conversion
1206 /// is not an option. See TryImplicitConversion for more information.
1209  bool SuppressUserConversions,
1210  bool AllowExplicit,
1211  bool InOverloadResolution,
1212  bool CStyle,
1213  bool AllowObjCWritebackConversion,
1214  bool AllowObjCConversionOnExplicit) {
1216 
1217  if (SuppressUserConversions) {
1218  // We're not in the case above, so there is no conversion that
1219  // we can perform.
1220  ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1221  return ICS;
1222  }
1223 
1224  // Attempt user-defined conversion.
1225  OverloadCandidateSet Conversions(From->getExprLoc(),
1227  switch (IsUserDefinedConversion(S, From, ToType, ICS.UserDefined,
1228  Conversions, AllowExplicit,
1229  AllowObjCConversionOnExplicit)) {
1230  case OR_Success:
1231  case OR_Deleted:
1232  ICS.setUserDefined();
1233  // C++ [over.ics.user]p4:
1234  // A conversion of an expression of class type to the same class
1235  // type is given Exact Match rank, and a conversion of an
1236  // expression of class type to a base class of that type is
1237  // given Conversion rank, in spite of the fact that a copy
1238  // constructor (i.e., a user-defined conversion function) is
1239  // called for those cases.
1240  if (CXXConstructorDecl *Constructor
1241  = dyn_cast<CXXConstructorDecl>(ICS.UserDefined.ConversionFunction)) {
1242  QualType FromCanon
1244  QualType ToCanon
1246  if (Constructor->isCopyConstructor() &&
1247  (FromCanon == ToCanon ||
1248  S.IsDerivedFrom(From->getLocStart(), FromCanon, ToCanon))) {
1249  // Turn this into a "standard" conversion sequence, so that it
1250  // gets ranked with standard conversion sequences.
1252  ICS.setStandard();
1254  ICS.Standard.setFromType(From->getType());
1255  ICS.Standard.setAllToTypes(ToType);
1256  ICS.Standard.CopyConstructor = Constructor;
1257  ICS.Standard.FoundCopyConstructor = Found;
1258  if (ToCanon != FromCanon)
1260  }
1261  }
1262  break;
1263 
1264  case OR_Ambiguous:
1265  ICS.setAmbiguous();
1266  ICS.Ambiguous.setFromType(From->getType());
1267  ICS.Ambiguous.setToType(ToType);
1268  for (OverloadCandidateSet::iterator Cand = Conversions.begin();
1269  Cand != Conversions.end(); ++Cand)
1270  if (Cand->Viable)
1271  ICS.Ambiguous.addConversion(Cand->FoundDecl, Cand->Function);
1272  break;
1273 
1274  // Fall through.
1275  case OR_No_Viable_Function:
1276  ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1277  break;
1278  }
1279 
1280  return ICS;
1281 }
1282 
1283 /// TryImplicitConversion - Attempt to perform an implicit conversion
1284 /// from the given expression (Expr) to the given type (ToType). This
1285 /// function returns an implicit conversion sequence that can be used
1286 /// to perform the initialization. Given
1287 ///
1288 /// void f(float f);
1289 /// void g(int i) { f(i); }
1290 ///
1291 /// this routine would produce an implicit conversion sequence to
1292 /// describe the initialization of f from i, which will be a standard
1293 /// conversion sequence containing an lvalue-to-rvalue conversion (C++
1294 /// 4.1) followed by a floating-integral conversion (C++ 4.9).
1295 //
1296 /// Note that this routine only determines how the conversion can be
1297 /// performed; it does not actually perform the conversion. As such,
1298 /// it will not produce any diagnostics if no conversion is available,
1299 /// but will instead return an implicit conversion sequence of kind
1300 /// "BadConversion".
1301 ///
1302 /// If @p SuppressUserConversions, then user-defined conversions are
1303 /// not permitted.
1304 /// If @p AllowExplicit, then explicit user-defined conversions are
1305 /// permitted.
1306 ///
1307 /// \param AllowObjCWritebackConversion Whether we allow the Objective-C
1308 /// writeback conversion, which allows __autoreleasing id* parameters to
1309 /// be initialized with __strong id* or __weak id* arguments.
1312  bool SuppressUserConversions,
1313  bool AllowExplicit,
1314  bool InOverloadResolution,
1315  bool CStyle,
1316  bool AllowObjCWritebackConversion,
1317  bool AllowObjCConversionOnExplicit) {
1319  if (IsStandardConversion(S, From, ToType, InOverloadResolution,
1320  ICS.Standard, CStyle, AllowObjCWritebackConversion)){
1321  ICS.setStandard();
1322  return ICS;
1323  }
1324 
1325  if (!S.getLangOpts().CPlusPlus) {
1326  ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1327  return ICS;
1328  }
1329 
1330  // C++ [over.ics.user]p4:
1331  // A conversion of an expression of class type to the same class
1332  // type is given Exact Match rank, and a conversion of an
1333  // expression of class type to a base class of that type is
1334  // given Conversion rank, in spite of the fact that a copy/move
1335  // constructor (i.e., a user-defined conversion function) is
1336  // called for those cases.
1337  QualType FromType = From->getType();
1338  if (ToType->getAs<RecordType>() && FromType->getAs<RecordType>() &&
1339  (S.Context.hasSameUnqualifiedType(FromType, ToType) ||
1340  S.IsDerivedFrom(From->getLocStart(), FromType, ToType))) {
1341  ICS.setStandard();
1343  ICS.Standard.setFromType(FromType);
1344  ICS.Standard.setAllToTypes(ToType);
1345 
1346  // We don't actually check at this point whether there is a valid
1347  // copy/move constructor, since overloading just assumes that it
1348  // exists. When we actually perform initialization, we'll find the
1349  // appropriate constructor to copy the returned object, if needed.
1350  ICS.Standard.CopyConstructor = nullptr;
1351 
1352  // Determine whether this is considered a derived-to-base conversion.
1353  if (!S.Context.hasSameUnqualifiedType(FromType, ToType))
1355 
1356  return ICS;
1357  }
1358 
1359  return TryUserDefinedConversion(S, From, ToType, SuppressUserConversions,
1360  AllowExplicit, InOverloadResolution, CStyle,
1361  AllowObjCWritebackConversion,
1362  AllowObjCConversionOnExplicit);
1363 }
1364 
1367  bool SuppressUserConversions,
1368  bool AllowExplicit,
1369  bool InOverloadResolution,
1370  bool CStyle,
1371  bool AllowObjCWritebackConversion) {
1372  return ::TryImplicitConversion(*this, From, ToType,
1373  SuppressUserConversions, AllowExplicit,
1374  InOverloadResolution, CStyle,
1375  AllowObjCWritebackConversion,
1376  /*AllowObjCConversionOnExplicit=*/false);
1377 }
1378 
1379 /// PerformImplicitConversion - Perform an implicit conversion of the
1380 /// expression From to the type ToType. Returns the
1381 /// converted expression. Flavor is the kind of conversion we're
1382 /// performing, used in the error message. If @p AllowExplicit,
1383 /// explicit user-defined conversions are permitted.
1384 ExprResult
1386  AssignmentAction Action, bool AllowExplicit) {
1388  return PerformImplicitConversion(From, ToType, Action, AllowExplicit, ICS);
1389 }
1390 
1391 ExprResult
1393  AssignmentAction Action, bool AllowExplicit,
1395  if (checkPlaceholderForOverload(*this, From))
1396  return ExprError();
1397 
1398  // Objective-C ARC: Determine whether we will allow the writeback conversion.
1399  bool AllowObjCWritebackConversion
1400  = getLangOpts().ObjCAutoRefCount &&
1401  (Action == AA_Passing || Action == AA_Sending);
1402  if (getLangOpts().ObjC1)
1403  CheckObjCBridgeRelatedConversions(From->getLocStart(),
1404  ToType, From->getType(), From);
1405  ICS = ::TryImplicitConversion(*this, From, ToType,
1406  /*SuppressUserConversions=*/false,
1407  AllowExplicit,
1408  /*InOverloadResolution=*/false,
1409  /*CStyle=*/false,
1410  AllowObjCWritebackConversion,
1411  /*AllowObjCConversionOnExplicit=*/false);
1412  return PerformImplicitConversion(From, ToType, ICS, Action);
1413 }
1414 
1415 /// \brief Determine whether the conversion from FromType to ToType is a valid
1416 /// conversion that strips "noexcept" or "noreturn" off the nested function
1417 /// type.
1419  QualType &ResultTy) {
1420  if (Context.hasSameUnqualifiedType(FromType, ToType))
1421  return false;
1422 
1423  // Permit the conversion F(t __attribute__((noreturn))) -> F(t)
1424  // or F(t noexcept) -> F(t)
1425  // where F adds one of the following at most once:
1426  // - a pointer
1427  // - a member pointer
1428  // - a block pointer
1429  // Changes here need matching changes in FindCompositePointerType.
1430  CanQualType CanTo = Context.getCanonicalType(ToType);
1431  CanQualType CanFrom = Context.getCanonicalType(FromType);
1432  Type::TypeClass TyClass = CanTo->getTypeClass();
1433  if (TyClass != CanFrom->getTypeClass()) return false;
1434  if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto) {
1435  if (TyClass == Type::Pointer) {
1436  CanTo = CanTo.getAs<PointerType>()->getPointeeType();
1437  CanFrom = CanFrom.getAs<PointerType>()->getPointeeType();
1438  } else if (TyClass == Type::BlockPointer) {
1439  CanTo = CanTo.getAs<BlockPointerType>()->getPointeeType();
1440  CanFrom = CanFrom.getAs<BlockPointerType>()->getPointeeType();
1441  } else if (TyClass == Type::MemberPointer) {
1442  auto ToMPT = CanTo.getAs<MemberPointerType>();
1443  auto FromMPT = CanFrom.getAs<MemberPointerType>();
1444  // A function pointer conversion cannot change the class of the function.
1445  if (ToMPT->getClass() != FromMPT->getClass())
1446  return false;
1447  CanTo = ToMPT->getPointeeType();
1448  CanFrom = FromMPT->getPointeeType();
1449  } else {
1450  return false;
1451  }
1452 
1453  TyClass = CanTo->getTypeClass();
1454  if (TyClass != CanFrom->getTypeClass()) return false;
1455  if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto)
1456  return false;
1457  }
1458 
1459  const auto *FromFn = cast<FunctionType>(CanFrom);
1460  FunctionType::ExtInfo FromEInfo = FromFn->getExtInfo();
1461 
1462  const auto *ToFn = cast<FunctionType>(CanTo);
1463  FunctionType::ExtInfo ToEInfo = ToFn->getExtInfo();
1464 
1465  bool Changed = false;
1466 
1467  // Drop 'noreturn' if not present in target type.
1468  if (FromEInfo.getNoReturn() && !ToEInfo.getNoReturn()) {
1469  FromFn = Context.adjustFunctionType(FromFn, FromEInfo.withNoReturn(false));
1470  Changed = true;
1471  }
1472 
1473  // Drop 'noexcept' if not present in target type.
1474  if (const auto *FromFPT = dyn_cast<FunctionProtoType>(FromFn)) {
1475  const auto *ToFPT = cast<FunctionProtoType>(ToFn);
1476  if (FromFPT->isNothrow(Context) && !ToFPT->isNothrow(Context)) {
1477  FromFn = cast<FunctionType>(
1478  Context.getFunctionType(FromFPT->getReturnType(),
1479  FromFPT->getParamTypes(),
1480  FromFPT->getExtProtoInfo().withExceptionSpec(
1482  .getTypePtr());
1483  Changed = true;
1484  }
1485 
1486  // Convert FromFPT's ExtParameterInfo if necessary. The conversion is valid
1487  // only if the ExtParameterInfo lists of the two function prototypes can be
1488  // merged and the merged list is identical to ToFPT's ExtParameterInfo list.
1490  bool CanUseToFPT, CanUseFromFPT;
1491  if (Context.mergeExtParameterInfo(ToFPT, FromFPT, CanUseToFPT,
1492  CanUseFromFPT, NewParamInfos) &&
1493  CanUseToFPT && !CanUseFromFPT) {
1494  FunctionProtoType::ExtProtoInfo ExtInfo = FromFPT->getExtProtoInfo();
1495  ExtInfo.ExtParameterInfos =
1496  NewParamInfos.empty() ? nullptr : NewParamInfos.data();
1497  QualType QT = Context.getFunctionType(FromFPT->getReturnType(),
1498  FromFPT->getParamTypes(), ExtInfo);
1499  FromFn = QT->getAs<FunctionType>();
1500  Changed = true;
1501  }
1502  }
1503 
1504  if (!Changed)
1505  return false;
1506 
1507  assert(QualType(FromFn, 0).isCanonical());
1508  if (QualType(FromFn, 0) != CanTo) return false;
1509 
1510  ResultTy = ToType;
1511  return true;
1512 }
1513 
1514 /// \brief Determine whether the conversion from FromType to ToType is a valid
1515 /// vector conversion.
1516 ///
1517 /// \param ICK Will be set to the vector conversion kind, if this is a vector
1518 /// conversion.
1519 static bool IsVectorConversion(Sema &S, QualType FromType,
1520  QualType ToType, ImplicitConversionKind &ICK) {
1521  // We need at least one of these types to be a vector type to have a vector
1522  // conversion.
1523  if (!ToType->isVectorType() && !FromType->isVectorType())
1524  return false;
1525 
1526  // Identical types require no conversions.
1527  if (S.Context.hasSameUnqualifiedType(FromType, ToType))
1528  return false;
1529 
1530  // There are no conversions between extended vector types, only identity.
1531  if (ToType->isExtVectorType()) {
1532  // There are no conversions between extended vector types other than the
1533  // identity conversion.
1534  if (FromType->isExtVectorType())
1535  return false;
1536 
1537  // Vector splat from any arithmetic type to a vector.
1538  if (FromType->isArithmeticType()) {
1539  ICK = ICK_Vector_Splat;
1540  return true;
1541  }
1542  }
1543 
1544  // We can perform the conversion between vector types in the following cases:
1545  // 1)vector types are equivalent AltiVec and GCC vector types
1546  // 2)lax vector conversions are permitted and the vector types are of the
1547  // same size
1548  if (ToType->isVectorType() && FromType->isVectorType()) {
1549  if (S.Context.areCompatibleVectorTypes(FromType, ToType) ||
1550  S.isLaxVectorConversion(FromType, ToType)) {
1551  ICK = ICK_Vector_Conversion;
1552  return true;
1553  }
1554  }
1555 
1556  return false;
1557 }
1558 
1559 static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType,
1560  bool InOverloadResolution,
1562  bool CStyle);
1563 
1564 /// IsStandardConversion - Determines whether there is a standard
1565 /// conversion sequence (C++ [conv], C++ [over.ics.scs]) from the
1566 /// expression From to the type ToType. Standard conversion sequences
1567 /// only consider non-class types; for conversions that involve class
1568 /// types, use TryImplicitConversion. If a conversion exists, SCS will
1569 /// contain the standard conversion sequence required to perform this
1570 /// conversion and this routine will return true. Otherwise, this
1571 /// routine will return false and the value of SCS is unspecified.
1572 static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
1573  bool InOverloadResolution,
1575  bool CStyle,
1576  bool AllowObjCWritebackConversion) {
1577  QualType FromType = From->getType();
1578 
1579  // Standard conversions (C++ [conv])
1581  SCS.IncompatibleObjC = false;
1582  SCS.setFromType(FromType);
1583  SCS.CopyConstructor = nullptr;
1584 
1585  // There are no standard conversions for class types in C++, so
1586  // abort early. When overloading in C, however, we do permit them.
1587  if (S.getLangOpts().CPlusPlus &&
1588  (FromType->isRecordType() || ToType->isRecordType()))
1589  return false;
1590 
1591  // The first conversion can be an lvalue-to-rvalue conversion,
1592  // array-to-pointer conversion, or function-to-pointer conversion
1593  // (C++ 4p1).
1594 
1595  if (FromType == S.Context.OverloadTy) {
1596  DeclAccessPair AccessPair;
1597  if (FunctionDecl *Fn
1598  = S.ResolveAddressOfOverloadedFunction(From, ToType, false,
1599  AccessPair)) {
1600  // We were able to resolve the address of the overloaded function,
1601  // so we can convert to the type of that function.
1602  FromType = Fn->getType();
1603  SCS.setFromType(FromType);
1604 
1605  // we can sometimes resolve &foo<int> regardless of ToType, so check
1606  // if the type matches (identity) or we are converting to bool
1608  S.ExtractUnqualifiedFunctionType(ToType), FromType)) {
1609  QualType resultTy;
1610  // if the function type matches except for [[noreturn]], it's ok
1611  if (!S.IsFunctionConversion(FromType,
1612  S.ExtractUnqualifiedFunctionType(ToType), resultTy))
1613  // otherwise, only a boolean conversion is standard
1614  if (!ToType->isBooleanType())
1615  return false;
1616  }
1617 
1618  // Check if the "from" expression is taking the address of an overloaded
1619  // function and recompute the FromType accordingly. Take advantage of the
1620  // fact that non-static member functions *must* have such an address-of
1621  // expression.
1622  CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn);
1623  if (Method && !Method->isStatic()) {
1624  assert(isa<UnaryOperator>(From->IgnoreParens()) &&
1625  "Non-unary operator on non-static member address");
1626  assert(cast<UnaryOperator>(From->IgnoreParens())->getOpcode()
1627  == UO_AddrOf &&
1628  "Non-address-of operator on non-static member address");
1629  const Type *ClassType
1630  = S.Context.getTypeDeclType(Method->getParent()).getTypePtr();
1631  FromType = S.Context.getMemberPointerType(FromType, ClassType);
1632  } else if (isa<UnaryOperator>(From->IgnoreParens())) {
1633  assert(cast<UnaryOperator>(From->IgnoreParens())->getOpcode() ==
1634  UO_AddrOf &&
1635  "Non-address-of operator for overloaded function expression");
1636  FromType = S.Context.getPointerType(FromType);
1637  }
1638 
1639  // Check that we've computed the proper type after overload resolution.
1640  // FIXME: FixOverloadedFunctionReference has side-effects; we shouldn't
1641  // be calling it from within an NDEBUG block.
1642  assert(S.Context.hasSameType(
1643  FromType,
1644  S.FixOverloadedFunctionReference(From, AccessPair, Fn)->getType()));
1645  } else {
1646  return false;
1647  }
1648  }
1649  // Lvalue-to-rvalue conversion (C++11 4.1):
1650  // A glvalue (3.10) of a non-function, non-array type T can
1651  // be converted to a prvalue.
1652  bool argIsLValue = From->isGLValue();
1653  if (argIsLValue &&
1654  !FromType->isFunctionType() && !FromType->isArrayType() &&
1655  S.Context.getCanonicalType(FromType) != S.Context.OverloadTy) {
1657 
1658  // C11 6.3.2.1p2:
1659  // ... if the lvalue has atomic type, the value has the non-atomic version
1660  // of the type of the lvalue ...
1661  if (const AtomicType *Atomic = FromType->getAs<AtomicType>())
1662  FromType = Atomic->getValueType();
1663 
1664  // If T is a non-class type, the type of the rvalue is the
1665  // cv-unqualified version of T. Otherwise, the type of the rvalue
1666  // is T (C++ 4.1p1). C++ can't get here with class types; in C, we
1667  // just strip the qualifiers because they don't matter.
1668  FromType = FromType.getUnqualifiedType();
1669  } else if (FromType->isArrayType()) {
1670  // Array-to-pointer conversion (C++ 4.2)
1672 
1673  // An lvalue or rvalue of type "array of N T" or "array of unknown
1674  // bound of T" can be converted to an rvalue of type "pointer to
1675  // T" (C++ 4.2p1).
1676  FromType = S.Context.getArrayDecayedType(FromType);
1677 
1678  if (S.IsStringLiteralToNonConstPointerConversion(From, ToType)) {
1679  // This conversion is deprecated in C++03 (D.4)
1681 
1682  // For the purpose of ranking in overload resolution
1683  // (13.3.3.1.1), this conversion is considered an
1684  // array-to-pointer conversion followed by a qualification
1685  // conversion (4.4). (C++ 4.2p2)
1686  SCS.Second = ICK_Identity;
1687  SCS.Third = ICK_Qualification;
1689  SCS.setAllToTypes(FromType);
1690  return true;
1691  }
1692  } else if (FromType->isFunctionType() && argIsLValue) {
1693  // Function-to-pointer conversion (C++ 4.3).
1695 
1696  if (auto *DRE = dyn_cast<DeclRefExpr>(From->IgnoreParenCasts()))
1697  if (auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl()))
1699  return false;
1700 
1701  // An lvalue of function type T can be converted to an rvalue of
1702  // type "pointer to T." The result is a pointer to the
1703  // function. (C++ 4.3p1).
1704  FromType = S.Context.getPointerType(FromType);
1705  } else {
1706  // We don't require any conversions for the first step.
1707  SCS.First = ICK_Identity;
1708  }
1709  SCS.setToType(0, FromType);
1710 
1711  // The second conversion can be an integral promotion, floating
1712  // point promotion, integral conversion, floating point conversion,
1713  // floating-integral conversion, pointer conversion,
1714  // pointer-to-member conversion, or boolean conversion (C++ 4p1).
1715  // For overloading in C, this can also be a "compatible-type"
1716  // conversion.
1717  bool IncompatibleObjC = false;
1719  if (S.Context.hasSameUnqualifiedType(FromType, ToType)) {
1720  // The unqualified versions of the types are the same: there's no
1721  // conversion to do.
1722  SCS.Second = ICK_Identity;
1723  } else if (S.IsIntegralPromotion(From, FromType, ToType)) {
1724  // Integral promotion (C++ 4.5).
1726  FromType = ToType.getUnqualifiedType();
1727  } else if (S.IsFloatingPointPromotion(FromType, ToType)) {
1728  // Floating point promotion (C++ 4.6).
1730  FromType = ToType.getUnqualifiedType();
1731  } else if (S.IsComplexPromotion(FromType, ToType)) {
1732  // Complex promotion (Clang extension)
1734  FromType = ToType.getUnqualifiedType();
1735  } else if (ToType->isBooleanType() &&
1736  (FromType->isArithmeticType() ||
1737  FromType->isAnyPointerType() ||
1738  FromType->isBlockPointerType() ||
1739  FromType->isMemberPointerType() ||
1740  FromType->isNullPtrType())) {
1741  // Boolean conversions (C++ 4.12).
1743  FromType = S.Context.BoolTy;
1744  } else if (FromType->isIntegralOrUnscopedEnumerationType() &&
1745  ToType->isIntegralType(S.Context)) {
1746  // Integral conversions (C++ 4.7).
1748  FromType = ToType.getUnqualifiedType();
1749  } else if (FromType->isAnyComplexType() && ToType->isAnyComplexType()) {
1750  // Complex conversions (C99 6.3.1.6)
1752  FromType = ToType.getUnqualifiedType();
1753  } else if ((FromType->isAnyComplexType() && ToType->isArithmeticType()) ||
1754  (ToType->isAnyComplexType() && FromType->isArithmeticType())) {
1755  // Complex-real conversions (C99 6.3.1.7)
1756  SCS.Second = ICK_Complex_Real;
1757  FromType = ToType.getUnqualifiedType();
1758  } else if (FromType->isRealFloatingType() && ToType->isRealFloatingType()) {
1759  // FIXME: disable conversions between long double and __float128 if
1760  // their representation is different until there is back end support
1761  // We of course allow this conversion if long double is really double.
1762  if (&S.Context.getFloatTypeSemantics(FromType) !=
1763  &S.Context.getFloatTypeSemantics(ToType)) {
1764  bool Float128AndLongDouble = ((FromType == S.Context.Float128Ty &&
1765  ToType == S.Context.LongDoubleTy) ||
1766  (FromType == S.Context.LongDoubleTy &&
1767  ToType == S.Context.Float128Ty));
1768  if (Float128AndLongDouble &&
1770  &llvm::APFloat::IEEEdouble()))
1771  return false;
1772  }
1773  // Floating point conversions (C++ 4.8).
1775  FromType = ToType.getUnqualifiedType();
1776  } else if ((FromType->isRealFloatingType() &&
1777  ToType->isIntegralType(S.Context)) ||
1778  (FromType->isIntegralOrUnscopedEnumerationType() &&
1779  ToType->isRealFloatingType())) {
1780  // Floating-integral conversions (C++ 4.9).
1782  FromType = ToType.getUnqualifiedType();
1783  } else if (S.IsBlockPointerConversion(FromType, ToType, FromType)) {
1785  } else if (AllowObjCWritebackConversion &&
1786  S.isObjCWritebackConversion(FromType, ToType, FromType)) {
1788  } else if (S.IsPointerConversion(From, FromType, ToType, InOverloadResolution,
1789  FromType, IncompatibleObjC)) {
1790  // Pointer conversions (C++ 4.10).
1792  SCS.IncompatibleObjC = IncompatibleObjC;
1793  FromType = FromType.getUnqualifiedType();
1794  } else if (S.IsMemberPointerConversion(From, FromType, ToType,
1795  InOverloadResolution, FromType)) {
1796  // Pointer to member conversions (4.11).
1797  SCS.Second = ICK_Pointer_Member;
1798  } else if (IsVectorConversion(S, FromType, ToType, SecondICK)) {
1799  SCS.Second = SecondICK;
1800  FromType = ToType.getUnqualifiedType();
1801  } else if (!S.getLangOpts().CPlusPlus &&
1802  S.Context.typesAreCompatible(ToType, FromType)) {
1803  // Compatible conversions (Clang extension for C function overloading)
1805  FromType = ToType.getUnqualifiedType();
1806  } else if (IsTransparentUnionStandardConversion(S, From, ToType,
1807  InOverloadResolution,
1808  SCS, CStyle)) {
1810  FromType = ToType;
1811  } else if (tryAtomicConversion(S, From, ToType, InOverloadResolution, SCS,
1812  CStyle)) {
1813  // tryAtomicConversion has updated the standard conversion sequence
1814  // appropriately.
1815  return true;
1816  } else if (ToType->isEventT() &&
1817  From->isIntegerConstantExpr(S.getASTContext()) &&
1818  From->EvaluateKnownConstInt(S.getASTContext()) == 0) {
1820  FromType = ToType;
1821  } else if (ToType->isQueueT() &&
1822  From->isIntegerConstantExpr(S.getASTContext()) &&
1823  (From->EvaluateKnownConstInt(S.getASTContext()) == 0)) {
1825  FromType = ToType;
1826  } else {
1827  // No second conversion required.
1828  SCS.Second = ICK_Identity;
1829  }
1830  SCS.setToType(1, FromType);
1831 
1832  // The third conversion can be a function pointer conversion or a
1833  // qualification conversion (C++ [conv.fctptr], [conv.qual]).
1834  bool ObjCLifetimeConversion;
1835  if (S.IsFunctionConversion(FromType, ToType, FromType)) {
1836  // Function pointer conversions (removing 'noexcept') including removal of
1837  // 'noreturn' (Clang extension).
1839  } else if (S.IsQualificationConversion(FromType, ToType, CStyle,
1840  ObjCLifetimeConversion)) {
1841  SCS.Third = ICK_Qualification;
1842  SCS.QualificationIncludesObjCLifetime = ObjCLifetimeConversion;
1843  FromType = ToType;
1844  } else {
1845  // No conversion required
1846  SCS.Third = ICK_Identity;
1847  }
1848 
1849  // C++ [over.best.ics]p6:
1850  // [...] Any difference in top-level cv-qualification is
1851  // subsumed by the initialization itself and does not constitute
1852  // a conversion. [...]
1853  QualType CanonFrom = S.Context.getCanonicalType(FromType);
1854  QualType CanonTo = S.Context.getCanonicalType(ToType);
1855  if (CanonFrom.getLocalUnqualifiedType()
1856  == CanonTo.getLocalUnqualifiedType() &&
1857  CanonFrom.getLocalQualifiers() != CanonTo.getLocalQualifiers()) {
1858  FromType = ToType;
1859  CanonFrom = CanonTo;
1860  }
1861 
1862  SCS.setToType(2, FromType);
1863 
1864  if (CanonFrom == CanonTo)
1865  return true;
1866 
1867  // If we have not converted the argument type to the parameter type,
1868  // this is a bad conversion sequence, unless we're resolving an overload in C.
1869  if (S.getLangOpts().CPlusPlus || !InOverloadResolution)
1870  return false;
1871 
1872  ExprResult ER = ExprResult{From};
1874  S.CheckSingleAssignmentConstraints(ToType, ER,
1875  /*Diagnose=*/false,
1876  /*DiagnoseCFAudited=*/false,
1877  /*ConvertRHS=*/false);
1878  ImplicitConversionKind SecondConv;
1879  switch (Conv) {
1880  case Sema::Compatible:
1881  SecondConv = ICK_C_Only_Conversion;
1882  break;
1883  // For our purposes, discarding qualifiers is just as bad as using an
1884  // incompatible pointer. Note that an IncompatiblePointer conversion can drop
1885  // qualifiers, as well.
1890  break;
1891  default:
1892  return false;
1893  }
1894 
1895  // First can only be an lvalue conversion, so we pretend that this was the
1896  // second conversion. First should already be valid from earlier in the
1897  // function.
1898  SCS.Second = SecondConv;
1899  SCS.setToType(1, ToType);
1900 
1901  // Third is Identity, because Second should rank us worse than any other
1902  // conversion. This could also be ICK_Qualification, but it's simpler to just
1903  // lump everything in with the second conversion, and we don't gain anything
1904  // from making this ICK_Qualification.
1905  SCS.Third = ICK_Identity;
1906  SCS.setToType(2, ToType);
1907  return true;
1908 }
1909 
1910 static bool
1912  QualType &ToType,
1913  bool InOverloadResolution,
1915  bool CStyle) {
1916 
1917  const RecordType *UT = ToType->getAsUnionType();
1918  if (!UT || !UT->getDecl()->hasAttr<TransparentUnionAttr>())
1919  return false;
1920  // The field to initialize within the transparent union.
1921  RecordDecl *UD = UT->getDecl();
1922  // It's compatible if the expression matches any of the fields.
1923  for (const auto *it : UD->fields()) {
1924  if (IsStandardConversion(S, From, it->getType(), InOverloadResolution, SCS,
1925  CStyle, /*ObjCWritebackConversion=*/false)) {
1926  ToType = it->getType();
1927  return true;
1928  }
1929  }
1930  return false;
1931 }
1932 
1933 /// IsIntegralPromotion - Determines whether the conversion from the
1934 /// expression From (whose potentially-adjusted type is FromType) to
1935 /// ToType is an integral promotion (C++ 4.5). If so, returns true and
1936 /// sets PromotedType to the promoted type.
1937 bool Sema::IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType) {
1938  const BuiltinType *To = ToType->getAs<BuiltinType>();
1939  // All integers are built-in.
1940  if (!To) {
1941  return false;
1942  }
1943 
1944  // An rvalue of type char, signed char, unsigned char, short int, or
1945  // unsigned short int can be converted to an rvalue of type int if
1946  // int can represent all the values of the source type; otherwise,
1947  // the source rvalue can be converted to an rvalue of type unsigned
1948  // int (C++ 4.5p1).
1949  if (FromType->isPromotableIntegerType() && !FromType->isBooleanType() &&
1950  !FromType->isEnumeralType()) {
1951  if (// We can promote any signed, promotable integer type to an int
1952  (FromType->isSignedIntegerType() ||
1953  // We can promote any unsigned integer type whose size is
1954  // less than int to an int.
1955  Context.getTypeSize(FromType) < Context.getTypeSize(ToType))) {
1956  return To->getKind() == BuiltinType::Int;
1957  }
1958 
1959  return To->getKind() == BuiltinType::UInt;
1960  }
1961 
1962  // C++11 [conv.prom]p3:
1963  // A prvalue of an unscoped enumeration type whose underlying type is not
1964  // fixed (7.2) can be converted to an rvalue a prvalue of the first of the
1965  // following types that can represent all the values of the enumeration
1966  // (i.e., the values in the range bmin to bmax as described in 7.2): int,
1967  // unsigned int, long int, unsigned long int, long long int, or unsigned
1968  // long long int. If none of the types in that list can represent all the
1969  // values of the enumeration, an rvalue a prvalue of an unscoped enumeration
1970  // type can be converted to an rvalue a prvalue of the extended integer type
1971  // with lowest integer conversion rank (4.13) greater than the rank of long
1972  // long in which all the values of the enumeration can be represented. If
1973  // there are two such extended types, the signed one is chosen.
1974  // C++11 [conv.prom]p4:
1975  // A prvalue of an unscoped enumeration type whose underlying type is fixed
1976  // can be converted to a prvalue of its underlying type. Moreover, if
1977  // integral promotion can be applied to its underlying type, a prvalue of an
1978  // unscoped enumeration type whose underlying type is fixed can also be
1979  // converted to a prvalue of the promoted underlying type.
1980  if (const EnumType *FromEnumType = FromType->getAs<EnumType>()) {
1981  // C++0x 7.2p9: Note that this implicit enum to int conversion is not
1982  // provided for a scoped enumeration.
1983  if (FromEnumType->getDecl()->isScoped())
1984  return false;
1985 
1986  // We can perform an integral promotion to the underlying type of the enum,
1987  // even if that's not the promoted type. Note that the check for promoting
1988  // the underlying type is based on the type alone, and does not consider
1989  // the bitfield-ness of the actual source expression.
1990  if (FromEnumType->getDecl()->isFixed()) {
1991  QualType Underlying = FromEnumType->getDecl()->getIntegerType();
1992  return Context.hasSameUnqualifiedType(Underlying, ToType) ||
1993  IsIntegralPromotion(nullptr, Underlying, ToType);
1994  }
1995 
1996  // We have already pre-calculated the promotion type, so this is trivial.
1997  if (ToType->isIntegerType() &&
1998  isCompleteType(From->getLocStart(), FromType))
1999  return Context.hasSameUnqualifiedType(
2000  ToType, FromEnumType->getDecl()->getPromotionType());
2001  }
2002 
2003  // C++0x [conv.prom]p2:
2004  // A prvalue of type char16_t, char32_t, or wchar_t (3.9.1) can be converted
2005  // to an rvalue a prvalue of the first of the following types that can
2006  // represent all the values of its underlying type: int, unsigned int,
2007  // long int, unsigned long int, long long int, or unsigned long long int.
2008  // If none of the types in that list can represent all the values of its
2009  // underlying type, an rvalue a prvalue of type char16_t, char32_t,
2010  // or wchar_t can be converted to an rvalue a prvalue of its underlying
2011  // type.
2012  if (FromType->isAnyCharacterType() && !FromType->isCharType() &&
2013  ToType->isIntegerType()) {
2014  // Determine whether the type we're converting from is signed or
2015  // unsigned.
2016  bool FromIsSigned = FromType->isSignedIntegerType();
2017  uint64_t FromSize = Context.getTypeSize(FromType);
2018 
2019  // The types we'll try to promote to, in the appropriate
2020  // order. Try each of these types.
2021  QualType PromoteTypes[6] = {
2022  Context.IntTy, Context.UnsignedIntTy,
2023  Context.LongTy, Context.UnsignedLongTy ,
2024  Context.LongLongTy, Context.UnsignedLongLongTy
2025  };
2026  for (int Idx = 0; Idx < 6; ++Idx) {
2027  uint64_t ToSize = Context.getTypeSize(PromoteTypes[Idx]);
2028  if (FromSize < ToSize ||
2029  (FromSize == ToSize &&
2030  FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType())) {
2031  // We found the type that we can promote to. If this is the
2032  // type we wanted, we have a promotion. Otherwise, no
2033  // promotion.
2034  return Context.hasSameUnqualifiedType(ToType, PromoteTypes[Idx]);
2035  }
2036  }
2037  }
2038 
2039  // An rvalue for an integral bit-field (9.6) can be converted to an
2040  // rvalue of type int if int can represent all the values of the
2041  // bit-field; otherwise, it can be converted to unsigned int if
2042  // unsigned int can represent all the values of the bit-field. If
2043  // the bit-field is larger yet, no integral promotion applies to
2044  // it. If the bit-field has an enumerated type, it is treated as any
2045  // other value of that type for promotion purposes (C++ 4.5p3).
2046  // FIXME: We should delay checking of bit-fields until we actually perform the
2047  // conversion.
2048  if (From) {
2049  if (FieldDecl *MemberDecl = From->getSourceBitField()) {
2050  llvm::APSInt BitWidth;
2051  if (FromType->isIntegralType(Context) &&
2052  MemberDecl->getBitWidth()->isIntegerConstantExpr(BitWidth, Context)) {
2053  llvm::APSInt ToSize(BitWidth.getBitWidth(), BitWidth.isUnsigned());
2054  ToSize = Context.getTypeSize(ToType);
2055 
2056  // Are we promoting to an int from a bitfield that fits in an int?
2057  if (BitWidth < ToSize ||
2058  (FromType->isSignedIntegerType() && BitWidth <= ToSize)) {
2059  return To->getKind() == BuiltinType::Int;
2060  }
2061 
2062  // Are we promoting to an unsigned int from an unsigned bitfield
2063  // that fits into an unsigned int?
2064  if (FromType->isUnsignedIntegerType() && BitWidth <= ToSize) {
2065  return To->getKind() == BuiltinType::UInt;
2066  }
2067 
2068  return false;
2069  }
2070  }
2071  }
2072 
2073  // An rvalue of type bool can be converted to an rvalue of type int,
2074  // with false becoming zero and true becoming one (C++ 4.5p4).
2075  if (FromType->isBooleanType() && To->getKind() == BuiltinType::Int) {
2076  return true;
2077  }
2078 
2079  return false;
2080 }
2081 
2082 /// IsFloatingPointPromotion - Determines whether the conversion from
2083 /// FromType to ToType is a floating point promotion (C++ 4.6). If so,
2084 /// returns true and sets PromotedType to the promoted type.
2086  if (const BuiltinType *FromBuiltin = FromType->getAs<BuiltinType>())
2087  if (const BuiltinType *ToBuiltin = ToType->getAs<BuiltinType>()) {
2088  /// An rvalue of type float can be converted to an rvalue of type
2089  /// double. (C++ 4.6p1).
2090  if (FromBuiltin->getKind() == BuiltinType::Float &&
2091  ToBuiltin->getKind() == BuiltinType::Double)
2092  return true;
2093 
2094  // C99 6.3.1.5p1:
2095  // When a float is promoted to double or long double, or a
2096  // double is promoted to long double [...].
2097  if (!getLangOpts().CPlusPlus &&
2098  (FromBuiltin->getKind() == BuiltinType::Float ||
2099  FromBuiltin->getKind() == BuiltinType::Double) &&
2100  (ToBuiltin->getKind() == BuiltinType::LongDouble ||
2101  ToBuiltin->getKind() == BuiltinType::Float128))
2102  return true;
2103 
2104  // Half can be promoted to float.
2105  if (!getLangOpts().NativeHalfType &&
2106  FromBuiltin->getKind() == BuiltinType::Half &&
2107  ToBuiltin->getKind() == BuiltinType::Float)
2108  return true;
2109  }
2110 
2111  return false;
2112 }
2113 
2114 /// \brief Determine if a conversion is a complex promotion.
2115 ///
2116 /// A complex promotion is defined as a complex -> complex conversion
2117 /// where the conversion between the underlying real types is a
2118 /// floating-point or integral promotion.
2120  const ComplexType *FromComplex = FromType->getAs<ComplexType>();
2121  if (!FromComplex)
2122  return false;
2123 
2124  const ComplexType *ToComplex = ToType->getAs<ComplexType>();
2125  if (!ToComplex)
2126  return false;
2127 
2128  return IsFloatingPointPromotion(FromComplex->getElementType(),
2129  ToComplex->getElementType()) ||
2130  IsIntegralPromotion(nullptr, FromComplex->getElementType(),
2131  ToComplex->getElementType());
2132 }
2133 
2134 /// BuildSimilarlyQualifiedPointerType - In a pointer conversion from
2135 /// the pointer type FromPtr to a pointer to type ToPointee, with the
2136 /// same type qualifiers as FromPtr has on its pointee type. ToType,
2137 /// if non-empty, will be a pointer to ToType that may or may not have
2138 /// the right set of qualifiers on its pointee.
2139 ///
2140 static QualType
2142  QualType ToPointee, QualType ToType,
2143  ASTContext &Context,
2144  bool StripObjCLifetime = false) {
2145  assert((FromPtr->getTypeClass() == Type::Pointer ||
2146  FromPtr->getTypeClass() == Type::ObjCObjectPointer) &&
2147  "Invalid similarly-qualified pointer type");
2148 
2149  /// Conversions to 'id' subsume cv-qualifier conversions.
2150  if (ToType->isObjCIdType() || ToType->isObjCQualifiedIdType())
2151  return ToType.getUnqualifiedType();
2152 
2153  QualType CanonFromPointee
2154  = Context.getCanonicalType(FromPtr->getPointeeType());
2155  QualType CanonToPointee = Context.getCanonicalType(ToPointee);
2156  Qualifiers Quals = CanonFromPointee.getQualifiers();
2157 
2158  if (StripObjCLifetime)
2159  Quals.removeObjCLifetime();
2160 
2161  // Exact qualifier match -> return the pointer type we're converting to.
2162  if (CanonToPointee.getLocalQualifiers() == Quals) {
2163  // ToType is exactly what we need. Return it.
2164  if (!ToType.isNull())
2165  return ToType.getUnqualifiedType();
2166 
2167  // Build a pointer to ToPointee. It has the right qualifiers
2168  // already.
2169  if (isa<ObjCObjectPointerType>(ToType))
2170  return Context.getObjCObjectPointerType(ToPointee);
2171  return Context.getPointerType(ToPointee);
2172  }
2173 
2174  // Just build a canonical type that has the right qualifiers.
2175  QualType QualifiedCanonToPointee
2176  = Context.getQualifiedType(CanonToPointee.getLocalUnqualifiedType(), Quals);
2177 
2178  if (isa<ObjCObjectPointerType>(ToType))
2179  return Context.getObjCObjectPointerType(QualifiedCanonToPointee);
2180  return Context.getPointerType(QualifiedCanonToPointee);
2181 }
2182 
2184  bool InOverloadResolution,
2185  ASTContext &Context) {
2186  // Handle value-dependent integral null pointer constants correctly.
2187  // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#903
2188  if (Expr->isValueDependent() && !Expr->isTypeDependent() &&
2189  Expr->getType()->isIntegerType() && !Expr->getType()->isEnumeralType())
2190  return !InOverloadResolution;
2191 
2192  return Expr->isNullPointerConstant(Context,
2193  InOverloadResolution? Expr::NPC_ValueDependentIsNotNull
2195 }
2196 
2197 /// IsPointerConversion - Determines whether the conversion of the
2198 /// expression From, which has the (possibly adjusted) type FromType,
2199 /// can be converted to the type ToType via a pointer conversion (C++
2200 /// 4.10). If so, returns true and places the converted type (that
2201 /// might differ from ToType in its cv-qualifiers at some level) into
2202 /// ConvertedType.
2203 ///
2204 /// This routine also supports conversions to and from block pointers
2205 /// and conversions with Objective-C's 'id', 'id<protocols...>', and
2206 /// pointers to interfaces. FIXME: Once we've determined the
2207 /// appropriate overloading rules for Objective-C, we may want to
2208 /// split the Objective-C checks into a different routine; however,
2209 /// GCC seems to consider all of these conversions to be pointer
2210 /// conversions, so for now they live here. IncompatibleObjC will be
2211 /// set if the conversion is an allowed Objective-C conversion that
2212 /// should result in a warning.
2213 bool Sema::IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
2214  bool InOverloadResolution,
2215  QualType& ConvertedType,
2216  bool &IncompatibleObjC) {
2217  IncompatibleObjC = false;
2218  if (isObjCPointerConversion(FromType, ToType, ConvertedType,
2219  IncompatibleObjC))
2220  return true;
2221 
2222  // Conversion from a null pointer constant to any Objective-C pointer type.
2223  if (ToType->isObjCObjectPointerType() &&
2224  isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
2225  ConvertedType = ToType;
2226  return true;
2227  }
2228 
2229  // Blocks: Block pointers can be converted to void*.
2230  if (FromType->isBlockPointerType() && ToType->isPointerType() &&
2231  ToType->getAs<PointerType>()->getPointeeType()->isVoidType()) {
2232  ConvertedType = ToType;
2233  return true;
2234  }
2235  // Blocks: A null pointer constant can be converted to a block
2236  // pointer type.
2237  if (ToType->isBlockPointerType() &&
2238  isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
2239  ConvertedType = ToType;
2240  return true;
2241  }
2242 
2243  // If the left-hand-side is nullptr_t, the right side can be a null
2244  // pointer constant.
2245  if (ToType->isNullPtrType() &&
2246  isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
2247  ConvertedType = ToType;
2248  return true;
2249  }
2250 
2251  const PointerType* ToTypePtr = ToType->getAs<PointerType>();
2252  if (!ToTypePtr)
2253  return false;
2254 
2255  // A null pointer constant can be converted to a pointer type (C++ 4.10p1).
2256  if (isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
2257  ConvertedType = ToType;
2258  return true;
2259  }
2260 
2261  // Beyond this point, both types need to be pointers
2262  // , including objective-c pointers.
2263  QualType ToPointeeType = ToTypePtr->getPointeeType();
2264  if (FromType->isObjCObjectPointerType() && ToPointeeType->isVoidType() &&
2265  !getLangOpts().ObjCAutoRefCount) {
2266  ConvertedType = BuildSimilarlyQualifiedPointerType(
2267  FromType->getAs<ObjCObjectPointerType>(),
2268  ToPointeeType,
2269  ToType, Context);
2270  return true;
2271  }
2272  const PointerType *FromTypePtr = FromType->getAs<PointerType>();
2273  if (!FromTypePtr)
2274  return false;
2275 
2276  QualType FromPointeeType = FromTypePtr->getPointeeType();
2277 
2278  // If the unqualified pointee types are the same, this can't be a
2279  // pointer conversion, so don't do all of the work below.
2280  if (Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType))
2281  return false;
2282 
2283  // An rvalue of type "pointer to cv T," where T is an object type,
2284  // can be converted to an rvalue of type "pointer to cv void" (C++
2285  // 4.10p2).
2286  if (FromPointeeType->isIncompleteOrObjectType() &&
2287  ToPointeeType->isVoidType()) {
2288  ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2289  ToPointeeType,
2290  ToType, Context,
2291  /*StripObjCLifetime=*/true);
2292  return true;
2293  }
2294 
2295  // MSVC allows implicit function to void* type conversion.
2296  if (getLangOpts().MSVCCompat && FromPointeeType->isFunctionType() &&
2297  ToPointeeType->isVoidType()) {
2298  ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2299  ToPointeeType,
2300  ToType, Context);
2301  return true;
2302  }
2303 
2304  // When we're overloading in C, we allow a special kind of pointer
2305  // conversion for compatible-but-not-identical pointee types.
2306  if (!getLangOpts().CPlusPlus &&
2307  Context.typesAreCompatible(FromPointeeType, ToPointeeType)) {
2308  ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2309  ToPointeeType,
2310  ToType, Context);
2311  return true;
2312  }
2313 
2314  // C++ [conv.ptr]p3:
2315  //
2316  // An rvalue of type "pointer to cv D," where D is a class type,
2317  // can be converted to an rvalue of type "pointer to cv B," where
2318  // B is a base class (clause 10) of D. If B is an inaccessible
2319  // (clause 11) or ambiguous (10.2) base class of D, a program that
2320  // necessitates this conversion is ill-formed. The result of the
2321  // conversion is a pointer to the base class sub-object of the
2322  // derived class object. The null pointer value is converted to
2323  // the null pointer value of the destination type.
2324  //
2325  // Note that we do not check for ambiguity or inaccessibility
2326  // here. That is handled by CheckPointerConversion.
2327  if (getLangOpts().CPlusPlus &&
2328  FromPointeeType->isRecordType() && ToPointeeType->isRecordType() &&
2329  !Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType) &&
2330  IsDerivedFrom(From->getLocStart(), FromPointeeType, ToPointeeType)) {
2331  ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2332  ToPointeeType,
2333  ToType, Context);
2334  return true;
2335  }
2336 
2337  if (FromPointeeType->isVectorType() && ToPointeeType->isVectorType() &&
2338  Context.areCompatibleVectorTypes(FromPointeeType, ToPointeeType)) {
2339  ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2340  ToPointeeType,
2341  ToType, Context);
2342  return true;
2343  }
2344 
2345  return false;
2346 }
2347 
2348 /// \brief Adopt the given qualifiers for the given type.
2350  Qualifiers TQs = T.getQualifiers();
2351 
2352  // Check whether qualifiers already match.
2353  if (TQs == Qs)
2354  return T;
2355 
2356  if (Qs.compatiblyIncludes(TQs))
2357  return Context.getQualifiedType(T, Qs);
2358 
2359  return Context.getQualifiedType(T.getUnqualifiedType(), Qs);
2360 }
2361 
2362 /// isObjCPointerConversion - Determines whether this is an
2363 /// Objective-C pointer conversion. Subroutine of IsPointerConversion,
2364 /// with the same arguments and return values.
2366  QualType& ConvertedType,
2367  bool &IncompatibleObjC) {
2368  if (!getLangOpts().ObjC1)
2369  return false;
2370 
2371  // The set of qualifiers on the type we're converting from.
2372  Qualifiers FromQualifiers = FromType.getQualifiers();
2373 
2374  // First, we handle all conversions on ObjC object pointer types.
2375  const ObjCObjectPointerType* ToObjCPtr =
2376  ToType->getAs<ObjCObjectPointerType>();
2377  const ObjCObjectPointerType *FromObjCPtr =
2378  FromType->getAs<ObjCObjectPointerType>();
2379 
2380  if (ToObjCPtr && FromObjCPtr) {
2381  // If the pointee types are the same (ignoring qualifications),
2382  // then this is not a pointer conversion.
2383  if (Context.hasSameUnqualifiedType(ToObjCPtr->getPointeeType(),
2384  FromObjCPtr->getPointeeType()))
2385  return false;
2386 
2387  // Conversion between Objective-C pointers.
2388  if (Context.canAssignObjCInterfaces(ToObjCPtr, FromObjCPtr)) {
2389  const ObjCInterfaceType* LHS = ToObjCPtr->getInterfaceType();
2390  const ObjCInterfaceType* RHS = FromObjCPtr->getInterfaceType();
2391  if (getLangOpts().CPlusPlus && LHS && RHS &&
2392  !ToObjCPtr->getPointeeType().isAtLeastAsQualifiedAs(
2393  FromObjCPtr->getPointeeType()))
2394  return false;
2395  ConvertedType = BuildSimilarlyQualifiedPointerType(FromObjCPtr,
2396  ToObjCPtr->getPointeeType(),
2397  ToType, Context);
2398  ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2399  return true;
2400  }
2401 
2402  if (Context.canAssignObjCInterfaces(FromObjCPtr, ToObjCPtr)) {
2403  // Okay: this is some kind of implicit downcast of Objective-C
2404  // interfaces, which is permitted. However, we're going to
2405  // complain about it.
2406  IncompatibleObjC = true;
2407  ConvertedType = BuildSimilarlyQualifiedPointerType(FromObjCPtr,
2408  ToObjCPtr->getPointeeType(),
2409  ToType, Context);
2410  ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2411  return true;
2412  }
2413  }
2414  // Beyond this point, both types need to be C pointers or block pointers.
2415  QualType ToPointeeType;
2416  if (const PointerType *ToCPtr = ToType->getAs<PointerType>())
2417  ToPointeeType = ToCPtr->getPointeeType();
2418  else if (const BlockPointerType *ToBlockPtr =
2419  ToType->getAs<BlockPointerType>()) {
2420  // Objective C++: We're able to convert from a pointer to any object
2421  // to a block pointer type.
2422  if (FromObjCPtr && FromObjCPtr->isObjCBuiltinType()) {
2423  ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2424  return true;
2425  }
2426  ToPointeeType = ToBlockPtr->getPointeeType();
2427  }
2428  else if (FromType->getAs<BlockPointerType>() &&
2429  ToObjCPtr && ToObjCPtr->isObjCBuiltinType()) {
2430  // Objective C++: We're able to convert from a block pointer type to a
2431  // pointer to any object.
2432  ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2433  return true;
2434  }
2435  else
2436  return false;
2437 
2438  QualType FromPointeeType;
2439  if (const PointerType *FromCPtr = FromType->getAs<PointerType>())
2440  FromPointeeType = FromCPtr->getPointeeType();
2441  else if (const BlockPointerType *FromBlockPtr =
2442  FromType->getAs<BlockPointerType>())
2443  FromPointeeType = FromBlockPtr->getPointeeType();
2444  else
2445  return false;
2446 
2447  // If we have pointers to pointers, recursively check whether this
2448  // is an Objective-C conversion.
2449  if (FromPointeeType->isPointerType() && ToPointeeType->isPointerType() &&
2450  isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType,
2451  IncompatibleObjC)) {
2452  // We always complain about this conversion.
2453  IncompatibleObjC = true;
2454  ConvertedType = Context.getPointerType(ConvertedType);
2455  ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2456  return true;
2457  }
2458  // Allow conversion of pointee being objective-c pointer to another one;
2459  // as in I* to id.
2460  if (FromPointeeType->getAs<ObjCObjectPointerType>() &&
2461  ToPointeeType->getAs<ObjCObjectPointerType>() &&
2462  isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType,
2463  IncompatibleObjC)) {
2464 
2465  ConvertedType = Context.getPointerType(ConvertedType);
2466  ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2467  return true;
2468  }
2469 
2470  // If we have pointers to functions or blocks, check whether the only
2471  // differences in the argument and result types are in Objective-C
2472  // pointer conversions. If so, we permit the conversion (but
2473  // complain about it).
2474  const FunctionProtoType *FromFunctionType
2475  = FromPointeeType->getAs<FunctionProtoType>();
2476  const FunctionProtoType *ToFunctionType
2477  = ToPointeeType->getAs<FunctionProtoType>();
2478  if (FromFunctionType && ToFunctionType) {
2479  // If the function types are exactly the same, this isn't an
2480  // Objective-C pointer conversion.
2481  if (Context.getCanonicalType(FromPointeeType)
2482  == Context.getCanonicalType(ToPointeeType))
2483  return false;
2484 
2485  // Perform the quick checks that will tell us whether these
2486  // function types are obviously different.
2487  if (FromFunctionType->getNumParams() != ToFunctionType->getNumParams() ||
2488  FromFunctionType->isVariadic() != ToFunctionType->isVariadic() ||
2489  FromFunctionType->getTypeQuals() != ToFunctionType->getTypeQuals())
2490  return false;
2491 
2492  bool HasObjCConversion = false;
2493  if (Context.getCanonicalType(FromFunctionType->getReturnType()) ==
2494  Context.getCanonicalType(ToFunctionType->getReturnType())) {
2495  // Okay, the types match exactly. Nothing to do.
2496  } else if (isObjCPointerConversion(FromFunctionType->getReturnType(),
2497  ToFunctionType->getReturnType(),
2498  ConvertedType, IncompatibleObjC)) {
2499  // Okay, we have an Objective-C pointer conversion.
2500  HasObjCConversion = true;
2501  } else {
2502  // Function types are too different. Abort.
2503  return false;
2504  }
2505 
2506  // Check argument types.
2507  for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumParams();
2508  ArgIdx != NumArgs; ++ArgIdx) {
2509  QualType FromArgType = FromFunctionType->getParamType(ArgIdx);
2510  QualType ToArgType = ToFunctionType->getParamType(ArgIdx);
2511  if (Context.getCanonicalType(FromArgType)
2512  == Context.getCanonicalType(ToArgType)) {
2513  // Okay, the types match exactly. Nothing to do.
2514  } else if (isObjCPointerConversion(FromArgType, ToArgType,
2515  ConvertedType, IncompatibleObjC)) {
2516  // Okay, we have an Objective-C pointer conversion.
2517  HasObjCConversion = true;
2518  } else {
2519  // Argument types are too different. Abort.
2520  return false;
2521  }
2522  }
2523 
2524  if (HasObjCConversion) {
2525  // We had an Objective-C conversion. Allow this pointer
2526  // conversion, but complain about it.
2527  ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2528  IncompatibleObjC = true;
2529  return true;
2530  }
2531  }
2532 
2533  return false;
2534 }
2535 
2536 /// \brief Determine whether this is an Objective-C writeback conversion,
2537 /// used for parameter passing when performing automatic reference counting.
2538 ///
2539 /// \param FromType The type we're converting form.
2540 ///
2541 /// \param ToType The type we're converting to.
2542 ///
2543 /// \param ConvertedType The type that will be produced after applying
2544 /// this conversion.
2546  QualType &ConvertedType) {
2547  if (!getLangOpts().ObjCAutoRefCount ||
2548  Context.hasSameUnqualifiedType(FromType, ToType))
2549  return false;
2550 
2551  // Parameter must be a pointer to __autoreleasing (with no other qualifiers).
2552  QualType ToPointee;
2553  if (const PointerType *ToPointer = ToType->getAs<PointerType>())
2554  ToPointee = ToPointer->getPointeeType();
2555  else
2556  return false;
2557 
2558  Qualifiers ToQuals = ToPointee.getQualifiers();
2559  if (!ToPointee->isObjCLifetimeType() ||
2561  !ToQuals.withoutObjCLifetime().empty())
2562  return false;
2563 
2564  // Argument must be a pointer to __strong to __weak.
2565  QualType FromPointee;
2566  if (const PointerType *FromPointer = FromType->getAs<PointerType>())
2567  FromPointee = FromPointer->getPointeeType();
2568  else
2569  return false;
2570 
2571  Qualifiers FromQuals = FromPointee.getQualifiers();
2572  if (!FromPointee->isObjCLifetimeType() ||
2573  (FromQuals.getObjCLifetime() != Qualifiers::OCL_Strong &&
2574  FromQuals.getObjCLifetime() != Qualifiers::OCL_Weak))
2575  return false;
2576 
2577  // Make sure that we have compatible qualifiers.
2579  if (!ToQuals.compatiblyIncludes(FromQuals))
2580  return false;
2581 
2582  // Remove qualifiers from the pointee type we're converting from; they
2583  // aren't used in the compatibility check belong, and we'll be adding back
2584  // qualifiers (with __autoreleasing) if the compatibility check succeeds.
2585  FromPointee = FromPointee.getUnqualifiedType();
2586 
2587  // The unqualified form of the pointee types must be compatible.
2588  ToPointee = ToPointee.getUnqualifiedType();
2589  bool IncompatibleObjC;
2590  if (Context.typesAreCompatible(FromPointee, ToPointee))
2591  FromPointee = ToPointee;
2592  else if (!isObjCPointerConversion(FromPointee, ToPointee, FromPointee,
2593  IncompatibleObjC))
2594  return false;
2595 
2596  /// \brief Construct the type we're converting to, which is a pointer to
2597  /// __autoreleasing pointee.
2598  FromPointee = Context.getQualifiedType(FromPointee, FromQuals);
2599  ConvertedType = Context.getPointerType(FromPointee);
2600  return true;
2601 }
2602 
2604  QualType& ConvertedType) {
2605  QualType ToPointeeType;
2606  if (const BlockPointerType *ToBlockPtr =
2607  ToType->getAs<BlockPointerType>())
2608  ToPointeeType = ToBlockPtr->getPointeeType();
2609  else
2610  return false;
2611 
2612  QualType FromPointeeType;
2613  if (const BlockPointerType *FromBlockPtr =
2614  FromType->getAs<BlockPointerType>())
2615  FromPointeeType = FromBlockPtr->getPointeeType();
2616  else
2617  return false;
2618  // We have pointer to blocks, check whether the only
2619  // differences in the argument and result types are in Objective-C
2620  // pointer conversions. If so, we permit the conversion.
2621 
2622  const FunctionProtoType *FromFunctionType
2623  = FromPointeeType->getAs<FunctionProtoType>();
2624  const FunctionProtoType *ToFunctionType
2625  = ToPointeeType->getAs<FunctionProtoType>();
2626 
2627  if (!FromFunctionType || !ToFunctionType)
2628  return false;
2629 
2630  if (Context.hasSameType(FromPointeeType, ToPointeeType))
2631  return true;
2632 
2633  // Perform the quick checks that will tell us whether these
2634  // function types are obviously different.
2635  if (FromFunctionType->getNumParams() != ToFunctionType->getNumParams() ||
2636  FromFunctionType->isVariadic() != ToFunctionType->isVariadic())
2637  return false;
2638 
2639  FunctionType::ExtInfo FromEInfo = FromFunctionType->getExtInfo();
2640  FunctionType::ExtInfo ToEInfo = ToFunctionType->getExtInfo();
2641  if (FromEInfo != ToEInfo)
2642  return false;
2643 
2644  bool IncompatibleObjC = false;
2645  if (Context.hasSameType(FromFunctionType->getReturnType(),
2646  ToFunctionType->getReturnType())) {
2647  // Okay, the types match exactly. Nothing to do.
2648  } else {
2649  QualType RHS = FromFunctionType->getReturnType();
2650  QualType LHS = ToFunctionType->getReturnType();
2651  if ((!getLangOpts().CPlusPlus || !RHS->isRecordType()) &&
2652  !RHS.hasQualifiers() && LHS.hasQualifiers())
2653  LHS = LHS.getUnqualifiedType();
2654 
2655  if (Context.hasSameType(RHS,LHS)) {
2656  // OK exact match.
2657  } else if (isObjCPointerConversion(RHS, LHS,
2658  ConvertedType, IncompatibleObjC)) {
2659  if (IncompatibleObjC)
2660  return false;
2661  // Okay, we have an Objective-C pointer conversion.
2662  }
2663  else
2664  return false;
2665  }
2666 
2667  // Check argument types.
2668  for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumParams();
2669  ArgIdx != NumArgs; ++ArgIdx) {
2670  IncompatibleObjC = false;
2671  QualType FromArgType = FromFunctionType->getParamType(ArgIdx);
2672  QualType ToArgType = ToFunctionType->getParamType(ArgIdx);
2673  if (Context.hasSameType(FromArgType, ToArgType)) {
2674  // Okay, the types match exactly. Nothing to do.
2675  } else if (isObjCPointerConversion(ToArgType, FromArgType,
2676  ConvertedType, IncompatibleObjC)) {
2677  if (IncompatibleObjC)
2678  return false;
2679  // Okay, we have an Objective-C pointer conversion.
2680  } else
2681  // Argument types are too different. Abort.
2682  return false;
2683  }
2684 
2686  bool CanUseToFPT, CanUseFromFPT;
2687  if (!Context.mergeExtParameterInfo(ToFunctionType, FromFunctionType,
2688  CanUseToFPT, CanUseFromFPT,
2689  NewParamInfos))
2690  return false;
2691 
2692  ConvertedType = ToType;
2693  return true;
2694 }
2695 
2696 enum {
2704 };
2705 
2706 /// Attempts to get the FunctionProtoType from a Type. Handles
2707 /// MemberFunctionPointers properly.
2709  if (auto *FPT = FromType->getAs<FunctionProtoType>())
2710  return FPT;
2711 
2712  if (auto *MPT = FromType->getAs<MemberPointerType>())
2713  return MPT->getPointeeType()->getAs<FunctionProtoType>();
2714 
2715  return nullptr;
2716 }
2717 
2718 /// HandleFunctionTypeMismatch - Gives diagnostic information for differeing
2719 /// function types. Catches different number of parameter, mismatch in
2720 /// parameter types, and different return types.
2722  QualType FromType, QualType ToType) {
2723  // If either type is not valid, include no extra info.
2724  if (FromType.isNull() || ToType.isNull()) {
2725  PDiag << ft_default;
2726  return;
2727  }
2728 
2729  // Get the function type from the pointers.
2730  if (FromType->isMemberPointerType() && ToType->isMemberPointerType()) {
2731  const MemberPointerType *FromMember = FromType->getAs<MemberPointerType>(),
2732  *ToMember = ToType->getAs<MemberPointerType>();
2733  if (!Context.hasSameType(FromMember->getClass(), ToMember->getClass())) {
2734  PDiag << ft_different_class << QualType(ToMember->getClass(), 0)
2735  << QualType(FromMember->getClass(), 0);
2736  return;
2737  }
2738  FromType = FromMember->getPointeeType();
2739  ToType = ToMember->getPointeeType();
2740  }
2741 
2742  if (FromType->isPointerType())
2743  FromType = FromType->getPointeeType();
2744  if (ToType->isPointerType())
2745  ToType = ToType->getPointeeType();
2746 
2747  // Remove references.
2748  FromType = FromType.getNonReferenceType();
2749  ToType = ToType.getNonReferenceType();
2750 
2751  // Don't print extra info for non-specialized template functions.
2752  if (FromType->isInstantiationDependentType() &&
2753  !FromType->getAs<TemplateSpecializationType>()) {
2754  PDiag << ft_default;
2755  return;
2756  }
2757 
2758  // No extra info for same types.
2759  if (Context.hasSameType(FromType, ToType)) {
2760  PDiag << ft_default;
2761  return;
2762  }
2763 
2764  const FunctionProtoType *FromFunction = tryGetFunctionProtoType(FromType),
2765  *ToFunction = tryGetFunctionProtoType(ToType);
2766 
2767  // Both types need to be function types.
2768  if (!FromFunction || !ToFunction) {
2769  PDiag << ft_default;
2770  return;
2771  }
2772 
2773  if (FromFunction->getNumParams() != ToFunction->getNumParams()) {
2774  PDiag << ft_parameter_arity << ToFunction->getNumParams()
2775  << FromFunction->getNumParams();
2776  return;
2777  }
2778 
2779  // Handle different parameter types.
2780  unsigned ArgPos;
2781  if (!FunctionParamTypesAreEqual(FromFunction, ToFunction, &ArgPos)) {
2782  PDiag << ft_parameter_mismatch << ArgPos + 1
2783  << ToFunction->getParamType(ArgPos)
2784  << FromFunction->getParamType(ArgPos);
2785  return;
2786  }
2787 
2788  // Handle different return type.
2789  if (!Context.hasSameType(FromFunction->getReturnType(),
2790  ToFunction->getReturnType())) {
2791  PDiag << ft_return_type << ToFunction->getReturnType()
2792  << FromFunction->getReturnType();
2793  return;
2794  }
2795 
2796  unsigned FromQuals = FromFunction->getTypeQuals(),
2797  ToQuals = ToFunction->getTypeQuals();
2798  if (FromQuals != ToQuals) {
2799  PDiag << ft_qualifer_mismatch << ToQuals << FromQuals;
2800  return;
2801  }
2802 
2803  // Handle exception specification differences on canonical type (in C++17
2804  // onwards).
2805  if (cast<FunctionProtoType>(FromFunction->getCanonicalTypeUnqualified())
2806  ->isNothrow(Context) !=
2807  cast<FunctionProtoType>(ToFunction->getCanonicalTypeUnqualified())
2808  ->isNothrow(Context)) {
2809  PDiag << ft_noexcept;
2810  return;
2811  }
2812 
2813  // Unable to find a difference, so add no extra info.
2814  PDiag << ft_default;
2815 }
2816 
2817 /// FunctionParamTypesAreEqual - This routine checks two function proto types
2818 /// for equality of their argument types. Caller has already checked that
2819 /// they have same number of arguments. If the parameters are different,
2820 /// ArgPos will have the parameter index of the first different parameter.
2822  const FunctionProtoType *NewType,
2823  unsigned *ArgPos) {
2825  N = NewType->param_type_begin(),
2826  E = OldType->param_type_end();
2827  O && (O != E); ++O, ++N) {
2828  if (!Context.hasSameType(O->getUnqualifiedType(),
2829  N->getUnqualifiedType())) {
2830  if (ArgPos)
2831  *ArgPos = O - OldType->param_type_begin();
2832  return false;
2833  }
2834  }
2835  return true;
2836 }
2837 
2838 /// CheckPointerConversion - Check the pointer conversion from the
2839 /// expression From to the type ToType. This routine checks for
2840 /// ambiguous or inaccessible derived-to-base pointer
2841 /// conversions for which IsPointerConversion has already returned
2842 /// true. It returns true and produces a diagnostic if there was an
2843 /// error, or returns false otherwise.
2845  CastKind &Kind,
2846  CXXCastPath& BasePath,
2847  bool IgnoreBaseAccess,
2848  bool Diagnose) {
2849  QualType FromType = From->getType();
2850  bool IsCStyleOrFunctionalCast = IgnoreBaseAccess;
2851 
2852  Kind = CK_BitCast;
2853 
2854  if (Diagnose && !IsCStyleOrFunctionalCast && !FromType->isAnyPointerType() &&
2857  if (Context.hasSameUnqualifiedType(From->getType(), Context.BoolTy))
2858  DiagRuntimeBehavior(From->getExprLoc(), From,
2859  PDiag(diag::warn_impcast_bool_to_null_pointer)
2860  << ToType << From->getSourceRange());
2861  else if (!isUnevaluatedContext())
2862  Diag(From->getExprLoc(), diag::warn_non_literal_null_pointer)
2863  << ToType << From->getSourceRange();
2864  }
2865  if (const PointerType *ToPtrType = ToType->getAs<PointerType>()) {
2866  if (const PointerType *FromPtrType = FromType->getAs<PointerType>()) {
2867  QualType FromPointeeType = FromPtrType->getPointeeType(),
2868  ToPointeeType = ToPtrType->getPointeeType();
2869 
2870  if (FromPointeeType->isRecordType() && ToPointeeType->isRecordType() &&
2871  !Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType)) {
2872  // We must have a derived-to-base conversion. Check an
2873  // ambiguous or inaccessible conversion.
2874  unsigned InaccessibleID = 0;
2875  unsigned AmbigiousID = 0;
2876  if (Diagnose) {
2877  InaccessibleID = diag::err_upcast_to_inaccessible_base;
2878  AmbigiousID = diag::err_ambiguous_derived_to_base_conv;
2879  }
2880  if (CheckDerivedToBaseConversion(
2881  FromPointeeType, ToPointeeType, InaccessibleID, AmbigiousID,
2882  From->getExprLoc(), From->getSourceRange(), DeclarationName(),
2883  &BasePath, IgnoreBaseAccess))
2884  return true;
2885 
2886  // The conversion was successful.
2887  Kind = CK_DerivedToBase;
2888  }
2889 
2890  if (Diagnose && !IsCStyleOrFunctionalCast &&
2891  FromPointeeType->isFunctionType() && ToPointeeType->isVoidType()) {
2892  assert(getLangOpts().MSVCCompat &&
2893  "this should only be possible with MSVCCompat!");
2894  Diag(From->getExprLoc(), diag::ext_ms_impcast_fn_obj)
2895  << From->getSourceRange();
2896  }
2897  }
2898  } else if (const ObjCObjectPointerType *ToPtrType =
2899  ToType->getAs<ObjCObjectPointerType>()) {
2900  if (const ObjCObjectPointerType *FromPtrType =
2901  FromType->getAs<ObjCObjectPointerType>()) {
2902  // Objective-C++ conversions are always okay.
2903  // FIXME: We should have a different class of conversions for the
2904  // Objective-C++ implicit conversions.
2905  if (FromPtrType->isObjCBuiltinType() || ToPtrType->isObjCBuiltinType())
2906  return false;
2907  } else if (FromType->isBlockPointerType()) {
2908  Kind = CK_BlockPointerToObjCPointerCast;
2909  } else {
2910  Kind = CK_CPointerToObjCPointerCast;
2911  }
2912  } else if (ToType->isBlockPointerType()) {
2913  if (!FromType->isBlockPointerType())
2914  Kind = CK_AnyPointerToBlockPointerCast;
2915  }
2916 
2917  // We shouldn't fall into this case unless it's valid for other
2918  // reasons.
2920  Kind = CK_NullToPointer;
2921 
2922  return false;
2923 }
2924 
2925 /// IsMemberPointerConversion - Determines whether the conversion of the
2926 /// expression From, which has the (possibly adjusted) type FromType, can be
2927 /// converted to the type ToType via a member pointer conversion (C++ 4.11).
2928 /// If so, returns true and places the converted type (that might differ from
2929 /// ToType in its cv-qualifiers at some level) into ConvertedType.
2931  QualType ToType,
2932  bool InOverloadResolution,
2933  QualType &ConvertedType) {
2934  const MemberPointerType *ToTypePtr = ToType->getAs<MemberPointerType>();
2935  if (!ToTypePtr)
2936  return false;
2937 
2938  // A null pointer constant can be converted to a member pointer (C++ 4.11p1)
2939  if (From->isNullPointerConstant(Context,
2940  InOverloadResolution? Expr::NPC_ValueDependentIsNotNull
2942  ConvertedType = ToType;
2943  return true;
2944  }
2945 
2946  // Otherwise, both types have to be member pointers.
2947  const MemberPointerType *FromTypePtr = FromType->getAs<MemberPointerType>();
2948  if (!FromTypePtr)
2949  return false;
2950 
2951  // A pointer to member of B can be converted to a pointer to member of D,
2952  // where D is derived from B (C++ 4.11p2).
2953  QualType FromClass(FromTypePtr->getClass(), 0);
2954  QualType ToClass(ToTypePtr->getClass(), 0);
2955 
2956  if (!Context.hasSameUnqualifiedType(FromClass, ToClass) &&
2957  IsDerivedFrom(From->getLocStart(), ToClass, FromClass)) {
2958  ConvertedType = Context.getMemberPointerType(FromTypePtr->getPointeeType(),
2959  ToClass.getTypePtr());
2960  return true;
2961  }
2962 
2963  return false;
2964 }
2965 
2966 /// CheckMemberPointerConversion - Check the member pointer conversion from the
2967 /// expression From to the type ToType. This routine checks for ambiguous or
2968 /// virtual or inaccessible base-to-derived member pointer conversions
2969 /// for which IsMemberPointerConversion has already returned true. It returns
2970 /// true and produces a diagnostic if there was an error, or returns false
2971 /// otherwise.
2973  CastKind &Kind,
2974  CXXCastPath &BasePath,
2975  bool IgnoreBaseAccess) {
2976  QualType FromType = From->getType();
2977  const MemberPointerType *FromPtrType = FromType->getAs<MemberPointerType>();
2978  if (!FromPtrType) {
2979  // This must be a null pointer to member pointer conversion
2980  assert(From->isNullPointerConstant(Context,
2982  "Expr must be null pointer constant!");
2983  Kind = CK_NullToMemberPointer;
2984  return false;
2985  }
2986 
2987  const MemberPointerType *ToPtrType = ToType->getAs<MemberPointerType>();
2988  assert(ToPtrType && "No member pointer cast has a target type "
2989  "that is not a member pointer.");
2990 
2991  QualType FromClass = QualType(FromPtrType->getClass(), 0);
2992  QualType ToClass = QualType(ToPtrType->getClass(), 0);
2993 
2994  // FIXME: What about dependent types?
2995  assert(FromClass->isRecordType() && "Pointer into non-class.");
2996  assert(ToClass->isRecordType() && "Pointer into non-class.");
2997 
2998  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
2999  /*DetectVirtual=*/true);
3000  bool DerivationOkay =
3001  IsDerivedFrom(From->getLocStart(), ToClass, FromClass, Paths);
3002  assert(DerivationOkay &&
3003  "Should not have been called if derivation isn't OK.");
3004  (void)DerivationOkay;
3005 
3006  if (Paths.isAmbiguous(Context.getCanonicalType(FromClass).
3007  getUnqualifiedType())) {
3008  std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
3009  Diag(From->getExprLoc(), diag::err_ambiguous_memptr_conv)
3010  << 0 << FromClass << ToClass << PathDisplayStr << From->getSourceRange();
3011  return true;
3012  }
3013 
3014  if (const RecordType *VBase = Paths.getDetectedVirtual()) {
3015  Diag(From->getExprLoc(), diag::err_memptr_conv_via_virtual)
3016  << FromClass << ToClass << QualType(VBase, 0)
3017  << From->getSourceRange();
3018  return true;
3019  }
3020 
3021  if (!IgnoreBaseAccess)
3022  CheckBaseClassAccess(From->getExprLoc(), FromClass, ToClass,
3023  Paths.front(),
3024  diag::err_downcast_from_inaccessible_base);
3025 
3026  // Must be a base to derived member conversion.
3027  BuildBasePathArray(Paths, BasePath);
3028  Kind = CK_BaseToDerivedMemberPointer;
3029  return false;
3030 }
3031 
3032 /// Determine whether the lifetime conversion between the two given
3033 /// qualifiers sets is nontrivial.
3035  Qualifiers ToQuals) {
3036  // Converting anything to const __unsafe_unretained is trivial.
3037  if (ToQuals.hasConst() &&
3039  return false;
3040 
3041  return true;
3042 }
3043 
3044 /// IsQualificationConversion - Determines whether the conversion from
3045 /// an rvalue of type FromType to ToType is a qualification conversion
3046 /// (C++ 4.4).
3047 ///
3048 /// \param ObjCLifetimeConversion Output parameter that will be set to indicate
3049 /// when the qualification conversion involves a change in the Objective-C
3050 /// object lifetime.
3051 bool
3053  bool CStyle, bool &ObjCLifetimeConversion) {
3054  FromType = Context.getCanonicalType(FromType);
3055  ToType = Context.getCanonicalType(ToType);
3056  ObjCLifetimeConversion = false;
3057 
3058  // If FromType and ToType are the same type, this is not a
3059  // qualification conversion.
3060  if (FromType.getUnqualifiedType() == ToType.getUnqualifiedType())
3061  return false;
3062 
3063  // (C++ 4.4p4):
3064  // A conversion can add cv-qualifiers at levels other than the first
3065  // in multi-level pointers, subject to the following rules: [...]
3066  bool PreviousToQualsIncludeConst = true;
3067  bool UnwrappedAnyPointer = false;
3068  while (Context.UnwrapSimilarPointerTypes(FromType, ToType)) {
3069  // Within each iteration of the loop, we check the qualifiers to
3070  // determine if this still looks like a qualification
3071  // conversion. Then, if all is well, we unwrap one more level of
3072  // pointers or pointers-to-members and do it all again
3073  // until there are no more pointers or pointers-to-members left to
3074  // unwrap.
3075  UnwrappedAnyPointer = true;
3076 
3077  Qualifiers FromQuals = FromType.getQualifiers();
3078  Qualifiers ToQuals = ToType.getQualifiers();
3079 
3080  // Ignore __unaligned qualifier if this type is void.
3081  if (ToType.getUnqualifiedType()->isVoidType())
3082  FromQuals.removeUnaligned();
3083 
3084  // Objective-C ARC:
3085  // Check Objective-C lifetime conversions.
3086  if (FromQuals.getObjCLifetime() != ToQuals.getObjCLifetime() &&
3087  UnwrappedAnyPointer) {
3088  if (ToQuals.compatiblyIncludesObjCLifetime(FromQuals)) {
3089  if (isNonTrivialObjCLifetimeConversion(FromQuals, ToQuals))
3090  ObjCLifetimeConversion = true;
3091  FromQuals.removeObjCLifetime();
3092  ToQuals.removeObjCLifetime();
3093  } else {
3094  // Qualification conversions cannot cast between different
3095  // Objective-C lifetime qualifiers.
3096  return false;
3097  }
3098  }
3099 
3100  // Allow addition/removal of GC attributes but not changing GC attributes.
3101  if (FromQuals.getObjCGCAttr() != ToQuals.getObjCGCAttr() &&
3102  (!FromQuals.hasObjCGCAttr() || !ToQuals.hasObjCGCAttr())) {
3103  FromQuals.removeObjCGCAttr();
3104  ToQuals.removeObjCGCAttr();
3105  }
3106 
3107  // -- for every j > 0, if const is in cv 1,j then const is in cv
3108  // 2,j, and similarly for volatile.
3109  if (!CStyle && !ToQuals.compatiblyIncludes(FromQuals))
3110  return false;
3111 
3112  // -- if the cv 1,j and cv 2,j are different, then const is in
3113  // every cv for 0 < k < j.
3114  if (!CStyle && FromQuals.getCVRQualifiers() != ToQuals.getCVRQualifiers()
3115  && !PreviousToQualsIncludeConst)
3116  return false;
3117 
3118  // Keep track of whether all prior cv-qualifiers in the "to" type
3119  // include const.
3120  PreviousToQualsIncludeConst
3121  = PreviousToQualsIncludeConst && ToQuals.hasConst();
3122  }
3123 
3124  // We are left with FromType and ToType being the pointee types
3125  // after unwrapping the original FromType and ToType the same number
3126  // of types. If we unwrapped any pointers, and if FromType and
3127  // ToType have the same unqualified type (since we checked
3128  // qualifiers above), then this is a qualification conversion.
3129  return UnwrappedAnyPointer && Context.hasSameUnqualifiedType(FromType,ToType);
3130 }
3131 
3132 /// \brief - Determine whether this is a conversion from a scalar type to an
3133 /// atomic type.
3134 ///
3135 /// If successful, updates \c SCS's second and third steps in the conversion
3136 /// sequence to finish the conversion.
3137 static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType,
3138  bool InOverloadResolution,
3140  bool CStyle) {
3141  const AtomicType *ToAtomic = ToType->getAs<AtomicType>();
3142  if (!ToAtomic)
3143  return false;
3144 
3145  StandardConversionSequence InnerSCS;
3146  if (!IsStandardConversion(S, From, ToAtomic->getValueType(),
3147  InOverloadResolution, InnerSCS,
3148  CStyle, /*AllowObjCWritebackConversion=*/false))
3149  return false;
3150 
3151  SCS.Second = InnerSCS.Second;
3152  SCS.setToType(1, InnerSCS.getToType(1));
3153  SCS.Third = InnerSCS.Third;
3155  = InnerSCS.QualificationIncludesObjCLifetime;
3156  SCS.setToType(2, InnerSCS.getToType(2));
3157  return true;
3158 }
3159 
3161  CXXConstructorDecl *Constructor,
3162  QualType Type) {
3163  const FunctionProtoType *CtorType =
3164  Constructor->getType()->getAs<FunctionProtoType>();
3165  if (CtorType->getNumParams() > 0) {
3166  QualType FirstArg = CtorType->getParamType(0);
3167  if (Context.hasSameUnqualifiedType(Type, FirstArg.getNonReferenceType()))
3168  return true;
3169  }
3170  return false;
3171 }
3172 
3173 static OverloadingResult
3175  CXXRecordDecl *To,
3177  OverloadCandidateSet &CandidateSet,
3178  bool AllowExplicit) {
3180  for (auto *D : S.LookupConstructors(To)) {
3181  auto Info = getConstructorInfo(D);
3182  if (!Info)
3183  continue;
3184 
3185  bool Usable = !Info.Constructor->isInvalidDecl() &&
3186  S.isInitListConstructor(Info.Constructor) &&
3187  (AllowExplicit || !Info.Constructor->isExplicit());
3188  if (Usable) {
3189  // If the first argument is (a reference to) the target type,
3190  // suppress conversions.
3191  bool SuppressUserConversions = isFirstArgumentCompatibleWithType(
3192  S.Context, Info.Constructor, ToType);
3193  if (Info.ConstructorTmpl)
3194  S.AddTemplateOverloadCandidate(Info.ConstructorTmpl, Info.FoundDecl,
3195  /*ExplicitArgs*/ nullptr, From,
3196  CandidateSet, SuppressUserConversions);
3197  else
3198  S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl, From,
3199  CandidateSet, SuppressUserConversions);
3200  }
3201  }
3202 
3203  bool HadMultipleCandidates = (CandidateSet.size() > 1);
3204 
3206  switch (auto Result =
3207  CandidateSet.BestViableFunction(S, From->getLocStart(),
3208  Best)) {
3209  case OR_Deleted:
3210  case OR_Success: {
3211  // Record the standard conversion we used and the conversion function.
3212  CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function);
3213  QualType ThisType = Constructor->getThisType(S.Context);
3214  // Initializer lists don't have conversions as such.
3216  User.HadMultipleCandidates = HadMultipleCandidates;
3217  User.ConversionFunction = Constructor;
3218  User.FoundConversionFunction = Best->FoundDecl;
3220  User.After.setFromType(ThisType->getAs<PointerType>()->getPointeeType());
3221  User.After.setAllToTypes(ToType);
3222  return Result;
3223  }
3224 
3225  case OR_No_Viable_Function:
3226  return OR_No_Viable_Function;
3227  case OR_Ambiguous:
3228  return OR_Ambiguous;
3229  }
3230 
3231  llvm_unreachable("Invalid OverloadResult!");
3232 }
3233 
3234 /// Determines whether there is a user-defined conversion sequence
3235 /// (C++ [over.ics.user]) that converts expression From to the type
3236 /// ToType. If such a conversion exists, User will contain the
3237 /// user-defined conversion sequence that performs such a conversion
3238 /// and this routine will return true. Otherwise, this routine returns
3239 /// false and User is unspecified.
3240 ///
3241 /// \param AllowExplicit true if the conversion should consider C++0x
3242 /// "explicit" conversion functions as well as non-explicit conversion
3243 /// functions (C++0x [class.conv.fct]p2).
3244 ///
3245 /// \param AllowObjCConversionOnExplicit true if the conversion should
3246 /// allow an extra Objective-C pointer conversion on uses of explicit
3247 /// constructors. Requires \c AllowExplicit to also be set.
3248 static OverloadingResult
3251  OverloadCandidateSet &CandidateSet,
3252  bool AllowExplicit,
3253  bool AllowObjCConversionOnExplicit) {
3254  assert(AllowExplicit || !AllowObjCConversionOnExplicit);
3256 
3257  // Whether we will only visit constructors.
3258  bool ConstructorsOnly = false;
3259 
3260  // If the type we are conversion to is a class type, enumerate its
3261  // constructors.
3262  if (const RecordType *ToRecordType = ToType->getAs<RecordType>()) {
3263  // C++ [over.match.ctor]p1:
3264  // When objects of class type are direct-initialized (8.5), or
3265  // copy-initialized from an expression of the same or a
3266  // derived class type (8.5), overload resolution selects the
3267  // constructor. [...] For copy-initialization, the candidate
3268  // functions are all the converting constructors (12.3.1) of
3269  // that class. The argument list is the expression-list within
3270  // the parentheses of the initializer.
3271  if (S.Context.hasSameUnqualifiedType(ToType, From->getType()) ||
3272  (From->getType()->getAs<RecordType>() &&
3273  S.IsDerivedFrom(From->getLocStart(), From->getType(), ToType)))
3274  ConstructorsOnly = true;
3275 
3276  if (!S.isCompleteType(From->getExprLoc(), ToType)) {
3277  // We're not going to find any constructors.
3278  } else if (CXXRecordDecl *ToRecordDecl
3279  = dyn_cast<CXXRecordDecl>(ToRecordType->getDecl())) {
3280 
3281  Expr **Args = &From;
3282  unsigned NumArgs = 1;
3283  bool ListInitializing = false;
3284  if (InitListExpr *InitList = dyn_cast<InitListExpr>(From)) {
3285  // But first, see if there is an init-list-constructor that will work.
3287  S, From, ToType, ToRecordDecl, User, CandidateSet, AllowExplicit);
3288  if (Result != OR_No_Viable_Function)
3289  return Result;
3290  // Never mind.
3291  CandidateSet.clear(
3293 
3294  // If we're list-initializing, we pass the individual elements as
3295  // arguments, not the entire list.
3296  Args = InitList->getInits();
3297  NumArgs = InitList->getNumInits();
3298  ListInitializing = true;
3299  }
3300 
3301  for (auto *D : S.LookupConstructors(ToRecordDecl)) {
3302  auto Info = getConstructorInfo(D);
3303  if (!Info)
3304  continue;
3305 
3306  bool Usable = !Info.Constructor->isInvalidDecl();
3307  if (ListInitializing)
3308  Usable = Usable && (AllowExplicit || !Info.Constructor->isExplicit());
3309  else
3310  Usable = Usable &&
3311  Info.Constructor->isConvertingConstructor(AllowExplicit);
3312  if (Usable) {
3313  bool SuppressUserConversions = !ConstructorsOnly;
3314  if (SuppressUserConversions && ListInitializing) {
3315  SuppressUserConversions = false;
3316  if (NumArgs == 1) {
3317  // If the first argument is (a reference to) the target type,
3318  // suppress conversions.
3319  SuppressUserConversions = isFirstArgumentCompatibleWithType(
3320  S.Context, Info.Constructor, ToType);
3321  }
3322  }
3323  if (Info.ConstructorTmpl)
3325  Info.ConstructorTmpl, Info.FoundDecl,
3326  /*ExplicitArgs*/ nullptr, llvm::makeArrayRef(Args, NumArgs),
3327  CandidateSet, SuppressUserConversions);
3328  else
3329  // Allow one user-defined conversion when user specifies a
3330  // From->ToType conversion via an static cast (c-style, etc).
3331  S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl,
3332  llvm::makeArrayRef(Args, NumArgs),
3333  CandidateSet, SuppressUserConversions);
3334  }
3335  }
3336  }
3337  }
3338 
3339  // Enumerate conversion functions, if we're allowed to.
3340  if (ConstructorsOnly || isa<InitListExpr>(From)) {
3341  } else if (!S.isCompleteType(From->getLocStart(), From->getType())) {
3342  // No conversion functions from incomplete types.
3343  } else if (const RecordType *FromRecordType
3344  = From->getType()->getAs<RecordType>()) {
3345  if (CXXRecordDecl *FromRecordDecl
3346  = dyn_cast<CXXRecordDecl>(FromRecordType->getDecl())) {
3347  // Add all of the conversion functions as candidates.
3348  const auto &Conversions = FromRecordDecl->getVisibleConversionFunctions();
3349  for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
3350  DeclAccessPair FoundDecl = I.getPair();
3351  NamedDecl *D = FoundDecl.getDecl();
3352  CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext());
3353  if (isa<UsingShadowDecl>(D))
3354  D = cast<UsingShadowDecl>(D)->getTargetDecl();
3355 
3356  CXXConversionDecl *Conv;
3357  FunctionTemplateDecl *ConvTemplate;
3358  if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D)))
3359  Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
3360  else
3361  Conv = cast<CXXConversionDecl>(D);
3362 
3363  if (AllowExplicit || !Conv->isExplicit()) {
3364  if (ConvTemplate)
3365  S.AddTemplateConversionCandidate(ConvTemplate, FoundDecl,
3366  ActingContext, From, ToType,
3367  CandidateSet,
3368  AllowObjCConversionOnExplicit);
3369  else
3370  S.AddConversionCandidate(Conv, FoundDecl, ActingContext,
3371  From, ToType, CandidateSet,
3372  AllowObjCConversionOnExplicit);
3373  }
3374  }
3375  }
3376  }
3377 
3378  bool HadMultipleCandidates = (CandidateSet.size() > 1);
3379 
3381  switch (auto Result = CandidateSet.BestViableFunction(S, From->getLocStart(),
3382  Best)) {
3383  case OR_Success:
3384  case OR_Deleted:
3385  // Record the standard conversion we used and the conversion function.
3386  if (CXXConstructorDecl *Constructor
3387  = dyn_cast<CXXConstructorDecl>(Best->Function)) {
3388  // C++ [over.ics.user]p1:
3389  // If the user-defined conversion is specified by a
3390  // constructor (12.3.1), the initial standard conversion
3391  // sequence converts the source type to the type required by
3392  // the argument of the constructor.
3393  //
3394  QualType ThisType = Constructor->getThisType(S.Context);
3395  if (isa<InitListExpr>(From)) {
3396  // Initializer lists don't have conversions as such.
3398  } else {
3399  if (Best->Conversions[0].isEllipsis())
3400  User.EllipsisConversion = true;
3401  else {
3402  User.Before = Best->Conversions[0].Standard;
3403  User.EllipsisConversion = false;
3404  }
3405  }
3406  User.HadMultipleCandidates = HadMultipleCandidates;
3407  User.ConversionFunction = Constructor;
3408  User.FoundConversionFunction = Best->FoundDecl;
3410  User.After.setFromType(ThisType->getAs<PointerType>()->getPointeeType());
3411  User.After.setAllToTypes(ToType);
3412  return Result;
3413  }
3414  if (CXXConversionDecl *Conversion
3415  = dyn_cast<CXXConversionDecl>(Best->Function)) {
3416  // C++ [over.ics.user]p1:
3417  //
3418  // [...] If the user-defined conversion is specified by a
3419  // conversion function (12.3.2), the initial standard
3420  // conversion sequence converts the source type to the
3421  // implicit object parameter of the conversion function.
3422  User.Before = Best->Conversions[0].Standard;
3423  User.HadMultipleCandidates = HadMultipleCandidates;
3424  User.ConversionFunction = Conversion;
3425  User.FoundConversionFunction = Best->FoundDecl;
3426  User.EllipsisConversion = false;
3427 
3428  // C++ [over.ics.user]p2:
3429  // The second standard conversion sequence converts the
3430  // result of the user-defined conversion to the target type
3431  // for the sequence. Since an implicit conversion sequence
3432  // is an initialization, the special rules for
3433  // initialization by user-defined conversion apply when
3434  // selecting the best user-defined conversion for a
3435  // user-defined conversion sequence (see 13.3.3 and
3436  // 13.3.3.1).
3437  User.After = Best->FinalConversion;
3438  return Result;
3439  }
3440  llvm_unreachable("Not a constructor or conversion function?");
3441 
3442  case OR_No_Viable_Function:
3443  return OR_No_Viable_Function;
3444 
3445  case OR_Ambiguous:
3446  return OR_Ambiguous;
3447  }
3448 
3449  llvm_unreachable("Invalid OverloadResult!");
3450 }
3451 
3452 bool
3455  OverloadCandidateSet CandidateSet(From->getExprLoc(),
3457  OverloadingResult OvResult =
3458  IsUserDefinedConversion(*this, From, ToType, ICS.UserDefined,
3459  CandidateSet, false, false);
3460  if (OvResult == OR_Ambiguous)
3461  Diag(From->getLocStart(), diag::err_typecheck_ambiguous_condition)
3462  << From->getType() << ToType << From->getSourceRange();
3463  else if (OvResult == OR_No_Viable_Function && !CandidateSet.empty()) {
3464  if (!RequireCompleteType(From->getLocStart(), ToType,
3465  diag::err_typecheck_nonviable_condition_incomplete,
3466  From->getType(), From->getSourceRange()))
3467  Diag(From->getLocStart(), diag::err_typecheck_nonviable_condition)
3468  << false << From->getType() << From->getSourceRange() << ToType;
3469  } else
3470  return false;
3471  CandidateSet.NoteCandidates(*this, OCD_AllCandidates, From);
3472  return true;
3473 }
3474 
3475 /// \brief Compare the user-defined conversion functions or constructors
3476 /// of two user-defined conversion sequences to determine whether any ordering
3477 /// is possible.
3480  FunctionDecl *Function2) {
3481  if (!S.getLangOpts().ObjC1 || !S.getLangOpts().CPlusPlus11)
3483 
3484  // Objective-C++:
3485  // If both conversion functions are implicitly-declared conversions from
3486  // a lambda closure type to a function pointer and a block pointer,
3487  // respectively, always prefer the conversion to a function pointer,
3488  // because the function pointer is more lightweight and is more likely
3489  // to keep code working.
3490  CXXConversionDecl *Conv1 = dyn_cast_or_null<CXXConversionDecl>(Function1);
3491  if (!Conv1)
3493 
3494  CXXConversionDecl *Conv2 = dyn_cast<CXXConversionDecl>(Function2);
3495  if (!Conv2)
3497 
3498  if (Conv1->getParent()->isLambda() && Conv2->getParent()->isLambda()) {
3499  bool Block1 = Conv1->getConversionType()->isBlockPointerType();
3500  bool Block2 = Conv2->getConversionType()->isBlockPointerType();
3501  if (Block1 != Block2)
3502  return Block1 ? ImplicitConversionSequence::Worse
3504  }
3505 
3507 }
3508 
3510  const ImplicitConversionSequence &ICS) {
3511  return (ICS.isStandard() && ICS.Standard.DeprecatedStringLiteralToCharPtr) ||
3512  (ICS.isUserDefined() &&
3514 }
3515 
3516 /// CompareImplicitConversionSequences - Compare two implicit
3517 /// conversion sequences to determine whether one is better than the
3518 /// other or if they are indistinguishable (C++ 13.3.3.2).
3521  const ImplicitConversionSequence& ICS1,
3522  const ImplicitConversionSequence& ICS2)
3523 {
3524  // (C++ 13.3.3.2p2): When comparing the basic forms of implicit
3525  // conversion sequences (as defined in 13.3.3.1)
3526  // -- a standard conversion sequence (13.3.3.1.1) is a better
3527  // conversion sequence than a user-defined conversion sequence or
3528  // an ellipsis conversion sequence, and
3529  // -- a user-defined conversion sequence (13.3.3.1.2) is a better
3530  // conversion sequence than an ellipsis conversion sequence
3531  // (13.3.3.1.3).
3532  //
3533  // C++0x [over.best.ics]p10:
3534  // For the purpose of ranking implicit conversion sequences as
3535  // described in 13.3.3.2, the ambiguous conversion sequence is
3536  // treated as a user-defined sequence that is indistinguishable
3537  // from any other user-defined conversion sequence.
3538 
3539  // String literal to 'char *' conversion has been deprecated in C++03. It has
3540  // been removed from C++11. We still accept this conversion, if it happens at
3541  // the best viable function. Otherwise, this conversion is considered worse
3542  // than ellipsis conversion. Consider this as an extension; this is not in the
3543  // standard. For example:
3544  //
3545  // int &f(...); // #1
3546  // void f(char*); // #2
3547  // void g() { int &r = f("foo"); }
3548  //
3549  // In C++03, we pick #2 as the best viable function.
3550  // In C++11, we pick #1 as the best viable function, because ellipsis
3551  // conversion is better than string-literal to char* conversion (since there
3552  // is no such conversion in C++11). If there was no #1 at all or #1 couldn't
3553  // convert arguments, #2 would be the best viable function in C++11.
3554  // If the best viable function has this conversion, a warning will be issued
3555  // in C++03, or an ExtWarn (+SFINAE failure) will be issued in C++11.
3556 
3557  if (S.getLangOpts().CPlusPlus11 && !S.getLangOpts().WritableStrings &&
3563 
3564  if (ICS1.getKindRank() < ICS2.getKindRank())
3566  if (ICS2.getKindRank() < ICS1.getKindRank())
3568 
3569  // The following checks require both conversion sequences to be of
3570  // the same kind.
3571  if (ICS1.getKind() != ICS2.getKind())
3573 
3576 
3577  // Two implicit conversion sequences of the same form are
3578  // indistinguishable conversion sequences unless one of the
3579  // following rules apply: (C++ 13.3.3.2p3):
3580 
3581  // List-initialization sequence L1 is a better conversion sequence than
3582  // list-initialization sequence L2 if:
3583  // - L1 converts to std::initializer_list<X> for some X and L2 does not, or,
3584  // if not that,
3585  // - L1 converts to type "array of N1 T", L2 converts to type "array of N2 T",
3586  // and N1 is smaller than N2.,
3587  // even if one of the other rules in this paragraph would otherwise apply.
3588  if (!ICS1.isBad()) {
3589  if (ICS1.isStdInitializerListElement() &&
3592  if (!ICS1.isStdInitializerListElement() &&
3595  }
3596 
3597  if (ICS1.isStandard())
3598  // Standard conversion sequence S1 is a better conversion sequence than
3599  // standard conversion sequence S2 if [...]
3600  Result = CompareStandardConversionSequences(S, Loc,
3601  ICS1.Standard, ICS2.Standard);
3602  else if (ICS1.isUserDefined()) {
3603  // User-defined conversion sequence U1 is a better conversion
3604  // sequence than another user-defined conversion sequence U2 if
3605  // they contain the same user-defined conversion function or
3606  // constructor and if the second standard conversion sequence of
3607  // U1 is better than the second standard conversion sequence of
3608  // U2 (C++ 13.3.3.2p3).
3609  if (ICS1.UserDefined.ConversionFunction ==
3611  Result = CompareStandardConversionSequences(S, Loc,
3612  ICS1.UserDefined.After,
3613  ICS2.UserDefined.After);
3614  else
3615  Result = compareConversionFunctions(S,
3618  }
3619 
3620  return Result;
3621 }
3622 
3623 static bool hasSimilarType(ASTContext &Context, QualType T1, QualType T2) {
3624  while (Context.UnwrapSimilarPointerTypes(T1, T2)) {
3625  Qualifiers Quals;
3626  T1 = Context.getUnqualifiedArrayType(T1, Quals);
3627  T2 = Context.getUnqualifiedArrayType(T2, Quals);
3628  }
3629 
3630  return Context.hasSameUnqualifiedType(T1, T2);
3631 }
3632 
3633 // Per 13.3.3.2p3, compare the given standard conversion sequences to
3634 // determine if one is a proper subset of the other.
3637  const StandardConversionSequence& SCS1,
3638  const StandardConversionSequence& SCS2) {
3641 
3642  // the identity conversion sequence is considered to be a subsequence of
3643  // any non-identity conversion sequence
3644  if (SCS1.isIdentityConversion() && !SCS2.isIdentityConversion())
3646  else if (!SCS1.isIdentityConversion() && SCS2.isIdentityConversion())
3648 
3649  if (SCS1.Second != SCS2.Second) {
3650  if (SCS1.Second == ICK_Identity)
3652  else if (SCS2.Second == ICK_Identity)
3654  else
3656  } else if (!hasSimilarType(Context, SCS1.getToType(1), SCS2.getToType(1)))
3658 
3659  if (SCS1.Third == SCS2.Third) {
3660  return Context.hasSameType(SCS1.getToType(2), SCS2.getToType(2))? Result
3662  }
3663 
3664  if (SCS1.Third == ICK_Identity)
3665  return Result == ImplicitConversionSequence::Worse
3668 
3669  if (SCS2.Third == ICK_Identity)
3670  return Result == ImplicitConversionSequence::Better
3673 
3675 }
3676 
3677 /// \brief Determine whether one of the given reference bindings is better
3678 /// than the other based on what kind of bindings they are.
3679 static bool
3681  const StandardConversionSequence &SCS2) {
3682  // C++0x [over.ics.rank]p3b4:
3683  // -- S1 and S2 are reference bindings (8.5.3) and neither refers to an
3684  // implicit object parameter of a non-static member function declared
3685  // without a ref-qualifier, and *either* S1 binds an rvalue reference
3686  // to an rvalue and S2 binds an lvalue reference *or S1 binds an
3687  // lvalue reference to a function lvalue and S2 binds an rvalue
3688  // reference*.
3689  //
3690  // FIXME: Rvalue references. We're going rogue with the above edits,
3691  // because the semantics in the current C++0x working paper (N3225 at the
3692  // time of this writing) break the standard definition of std::forward
3693  // and std::reference_wrapper when dealing with references to functions.
3694  // Proposed wording changes submitted to CWG for consideration.
3697  return false;
3698 
3699  return (!SCS1.IsLvalueReference && SCS1.BindsToRvalue &&
3700  SCS2.IsLvalueReference) ||
3701  (SCS1.IsLvalueReference && SCS1.BindsToFunctionLvalue &&
3703 }
3704 
3705 /// CompareStandardConversionSequences - Compare two standard
3706 /// conversion sequences to determine whether one is better than the
3707 /// other or if they are indistinguishable (C++ 13.3.3.2p3).
3710  const StandardConversionSequence& SCS1,
3711  const StandardConversionSequence& SCS2)
3712 {
3713  // Standard conversion sequence S1 is a better conversion sequence
3714  // than standard conversion sequence S2 if (C++ 13.3.3.2p3):
3715 
3716  // -- S1 is a proper subsequence of S2 (comparing the conversion
3717  // sequences in the canonical form defined by 13.3.3.1.1,
3718  // excluding any Lvalue Transformation; the identity conversion
3719  // sequence is considered to be a subsequence of any
3720  // non-identity conversion sequence) or, if not that,
3722  = compareStandardConversionSubsets(S.Context, SCS1, SCS2))
3723  return CK;
3724 
3725  // -- the rank of S1 is better than the rank of S2 (by the rules
3726  // defined below), or, if not that,
3727  ImplicitConversionRank Rank1 = SCS1.getRank();
3728  ImplicitConversionRank Rank2 = SCS2.getRank();
3729  if (Rank1 < Rank2)
3731  else if (Rank2 < Rank1)
3733 
3734  // (C++ 13.3.3.2p4): Two conversion sequences with the same rank
3735  // are indistinguishable unless one of the following rules
3736  // applies:
3737 
3738  // A conversion that is not a conversion of a pointer, or
3739  // pointer to member, to bool is better than another conversion
3740  // that is such a conversion.
3742  return SCS2.isPointerConversionToBool()
3745 
3746  // C++ [over.ics.rank]p4b2:
3747  //
3748  // If class B is derived directly or indirectly from class A,
3749  // conversion of B* to A* is better than conversion of B* to
3750  // void*, and conversion of A* to void* is better than conversion
3751  // of B* to void*.
3752  bool SCS1ConvertsToVoid
3754  bool SCS2ConvertsToVoid
3756  if (SCS1ConvertsToVoid != SCS2ConvertsToVoid) {
3757  // Exactly one of the conversion sequences is a conversion to
3758  // a void pointer; it's the worse conversion.
3759  return SCS2ConvertsToVoid ? ImplicitConversionSequence::Better
3761  } else if (!SCS1ConvertsToVoid && !SCS2ConvertsToVoid) {
3762  // Neither conversion sequence converts to a void pointer; compare
3763  // their derived-to-base conversions.
3765  = CompareDerivedToBaseConversions(S, Loc, SCS1, SCS2))
3766  return DerivedCK;
3767  } else if (SCS1ConvertsToVoid && SCS2ConvertsToVoid &&
3768  !S.Context.hasSameType(SCS1.getFromType(), SCS2.getFromType())) {
3769  // Both conversion sequences are conversions to void
3770  // pointers. Compare the source types to determine if there's an
3771  // inheritance relationship in their sources.
3772  QualType FromType1 = SCS1.getFromType();
3773  QualType FromType2 = SCS2.getFromType();
3774 
3775  // Adjust the types we're converting from via the array-to-pointer
3776  // conversion, if we need to.
3777  if (SCS1.First == ICK_Array_To_Pointer)
3778  FromType1 = S.Context.getArrayDecayedType(FromType1);
3779  if (SCS2.First == ICK_Array_To_Pointer)
3780  FromType2 = S.Context.getArrayDecayedType(FromType2);
3781 
3782  QualType FromPointee1 = FromType1->getPointeeType().getUnqualifiedType();
3783  QualType FromPointee2 = FromType2->getPointeeType().getUnqualifiedType();
3784 
3785  if (S.IsDerivedFrom(Loc, FromPointee2, FromPointee1))
3787  else if (S.IsDerivedFrom(Loc, FromPointee1, FromPointee2))
3789 
3790  // Objective-C++: If one interface is more specific than the
3791  // other, it is the better one.
3792  const ObjCObjectPointerType* FromObjCPtr1
3793  = FromType1->getAs<ObjCObjectPointerType>();
3794  const ObjCObjectPointerType* FromObjCPtr2
3795  = FromType2->getAs<ObjCObjectPointerType>();
3796  if (FromObjCPtr1 && FromObjCPtr2) {
3797  bool AssignLeft = S.Context.canAssignObjCInterfaces(FromObjCPtr1,
3798  FromObjCPtr2);
3799  bool AssignRight = S.Context.canAssignObjCInterfaces(FromObjCPtr2,
3800  FromObjCPtr1);
3801  if (AssignLeft != AssignRight) {
3802  return AssignLeft? ImplicitConversionSequence::Better
3804  }
3805  }
3806  }
3807 
3808  // Compare based on qualification conversions (C++ 13.3.3.2p3,
3809  // bullet 3).
3811  = CompareQualificationConversions(S, SCS1, SCS2))
3812  return QualCK;
3813 
3814  if (SCS1.ReferenceBinding && SCS2.ReferenceBinding) {
3815  // Check for a better reference binding based on the kind of bindings.
3816  if (isBetterReferenceBindingKind(SCS1, SCS2))
3818  else if (isBetterReferenceBindingKind(SCS2, SCS1))
3820 
3821  // C++ [over.ics.rank]p3b4:
3822  // -- S1 and S2 are reference bindings (8.5.3), and the types to
3823  // which the references refer are the same type except for
3824  // top-level cv-qualifiers, and the type to which the reference
3825  // initialized by S2 refers is more cv-qualified than the type
3826  // to which the reference initialized by S1 refers.
3827  QualType T1 = SCS1.getToType(2);
3828  QualType T2 = SCS2.getToType(2);
3829  T1 = S.Context.getCanonicalType(T1);
3830  T2 = S.Context.getCanonicalType(T2);
3831  Qualifiers T1Quals, T2Quals;
3832  QualType UnqualT1 = S.Context.getUnqualifiedArrayType(T1, T1Quals);
3833  QualType UnqualT2 = S.Context.getUnqualifiedArrayType(T2, T2Quals);
3834  if (UnqualT1 == UnqualT2) {
3835  // Objective-C++ ARC: If the references refer to objects with different
3836  // lifetimes, prefer bindings that don't change lifetime.
3837  if (SCS1.ObjCLifetimeConversionBinding !=
3839  return SCS1.ObjCLifetimeConversionBinding
3842  }
3843 
3844  // If the type is an array type, promote the element qualifiers to the
3845  // type for comparison.
3846  if (isa<ArrayType>(T1) && T1Quals)
3847  T1 = S.Context.getQualifiedType(UnqualT1, T1Quals);
3848  if (isa<ArrayType>(T2) && T2Quals)
3849  T2 = S.Context.getQualifiedType(UnqualT2, T2Quals);
3850  if (T2.isMoreQualifiedThan(T1))
3852  else if (T1.isMoreQualifiedThan(T2))
3854  }
3855  }
3856 
3857  // In Microsoft mode, prefer an integral conversion to a
3858  // floating-to-integral conversion if the integral conversion
3859  // is between types of the same size.
3860  // For example:
3861  // void f(float);
3862  // void f(int);
3863  // int main {
3864  // long a;
3865  // f(a);
3866  // }
3867  // Here, MSVC will call f(int) instead of generating a compile error
3868  // as clang will do in standard mode.
3869  if (S.getLangOpts().MSVCCompat && SCS1.Second == ICK_Integral_Conversion &&
3870  SCS2.Second == ICK_Floating_Integral &&
3871  S.Context.getTypeSize(SCS1.getFromType()) ==
3872  S.Context.getTypeSize(SCS1.getToType(2)))
3874 
3876 }
3877 
3878 /// CompareQualificationConversions - Compares two standard conversion
3879 /// sequences to determine whether they can be ranked based on their
3880 /// qualification conversions (C++ 13.3.3.2p3 bullet 3).
3883  const StandardConversionSequence& SCS1,
3884  const StandardConversionSequence& SCS2) {
3885  // C++ 13.3.3.2p3:
3886  // -- S1 and S2 differ only in their qualification conversion and
3887  // yield similar types T1 and T2 (C++ 4.4), respectively, and the
3888  // cv-qualification signature of type T1 is a proper subset of
3889  // the cv-qualification signature of type T2, and S1 is not the
3890  // deprecated string literal array-to-pointer conversion (4.2).
3891  if (SCS1.First != SCS2.First || SCS1.Second != SCS2.Second ||
3892  SCS1.Third != SCS2.Third || SCS1.Third != ICK_Qualification)
3894 
3895  // FIXME: the example in the standard doesn't use a qualification
3896  // conversion (!)
3897  QualType T1 = SCS1.getToType(2);
3898  QualType T2 = SCS2.getToType(2);
3899  T1 = S.Context.getCanonicalType(T1);
3900  T2 = S.Context.getCanonicalType(T2);
3901  Qualifiers T1Quals, T2Quals;
3902  QualType UnqualT1 = S.Context.getUnqualifiedArrayType(T1, T1Quals);
3903  QualType UnqualT2 = S.Context.getUnqualifiedArrayType(T2, T2Quals);
3904 
3905  // If the types are the same, we won't learn anything by unwrapped
3906  // them.
3907  if (UnqualT1 == UnqualT2)
3909 
3910  // If the type is an array type, promote the element qualifiers to the type
3911  // for comparison.
3912  if (isa<ArrayType>(T1) && T1Quals)
3913  T1 = S.Context.getQualifiedType(UnqualT1, T1Quals);
3914  if (isa<ArrayType>(T2) && T2Quals)
3915  T2 = S.Context.getQualifiedType(UnqualT2, T2Quals);
3916 
3919 
3920  // Objective-C++ ARC:
3921  // Prefer qualification conversions not involving a change in lifetime
3922  // to qualification conversions that do not change lifetime.
3925  Result = SCS1.QualificationIncludesObjCLifetime
3928  }
3929 
3930  while (S.Context.UnwrapSimilarPointerTypes(T1, T2)) {
3931  // Within each iteration of the loop, we check the qualifiers to
3932  // determine if this still looks like a qualification
3933  // conversion. Then, if all is well, we unwrap one more level of
3934  // pointers or pointers-to-members and do it all again
3935  // until there are no more pointers or pointers-to-members left
3936  // to unwrap. This essentially mimics what
3937  // IsQualificationConversion does, but here we're checking for a
3938  // strict subset of qualifiers.
3939  if (T1.getCVRQualifiers() == T2.getCVRQualifiers())
3940  // The qualifiers are the same, so this doesn't tell us anything
3941  // about how the sequences rank.
3942  ;
3943  else if (T2.isMoreQualifiedThan(T1)) {
3944  // T1 has fewer qualifiers, so it could be the better sequence.
3945  if (Result == ImplicitConversionSequence::Worse)
3946  // Neither has qualifiers that are a subset of the other's
3947  // qualifiers.
3949 
3951  } else if (T1.isMoreQualifiedThan(T2)) {
3952  // T2 has fewer qualifiers, so it could be the better sequence.
3953  if (Result == ImplicitConversionSequence::Better)
3954  // Neither has qualifiers that are a subset of the other's
3955  // qualifiers.
3957 
3959  } else {
3960  // Qualifiers are disjoint.
3962  }
3963 
3964  // If the types after this point are equivalent, we're done.
3965  if (S.Context.hasSameUnqualifiedType(T1, T2))
3966  break;
3967  }
3968 
3969  // Check that the winning standard conversion sequence isn't using
3970  // the deprecated string literal array to pointer conversion.
3971  switch (Result) {
3975  break;
3976 
3978  break;
3979 
3983  break;
3984  }
3985 
3986  return Result;
3987 }
3988 
3989 /// CompareDerivedToBaseConversions - Compares two standard conversion
3990 /// sequences to determine whether they can be ranked based on their
3991 /// various kinds of derived-to-base conversions (C++
3992 /// [over.ics.rank]p4b3). As part of these checks, we also look at
3993 /// conversions between Objective-C interface types.
3996  const StandardConversionSequence& SCS1,
3997  const StandardConversionSequence& SCS2) {
3998  QualType FromType1 = SCS1.getFromType();
3999  QualType ToType1 = SCS1.getToType(1);
4000  QualType FromType2 = SCS2.getFromType();
4001  QualType ToType2 = SCS2.getToType(1);
4002 
4003  // Adjust the types we're converting from via the array-to-pointer
4004  // conversion, if we need to.
4005  if (SCS1.First == ICK_Array_To_Pointer)
4006  FromType1 = S.Context.getArrayDecayedType(FromType1);
4007  if (SCS2.First == ICK_Array_To_Pointer)
4008  FromType2 = S.Context.getArrayDecayedType(FromType2);
4009 
4010  // Canonicalize all of the types.
4011  FromType1 = S.Context.getCanonicalType(FromType1);
4012  ToType1 = S.Context.getCanonicalType(ToType1);
4013  FromType2 = S.Context.getCanonicalType(FromType2);
4014  ToType2 = S.Context.getCanonicalType(ToType2);
4015 
4016  // C++ [over.ics.rank]p4b3:
4017  //
4018  // If class B is derived directly or indirectly from class A and
4019  // class C is derived directly or indirectly from B,
4020  //
4021  // Compare based on pointer conversions.
4022  if (SCS1.Second == ICK_Pointer_Conversion &&
4023  SCS2.Second == ICK_Pointer_Conversion &&
4024  /*FIXME: Remove if Objective-C id conversions get their own rank*/
4025  FromType1->isPointerType() && FromType2->isPointerType() &&
4026  ToType1->isPointerType() && ToType2->isPointerType()) {
4027  QualType FromPointee1
4028  = FromType1->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
4029  QualType ToPointee1
4030  = ToType1->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
4031  QualType FromPointee2
4032  = FromType2->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
4033  QualType ToPointee2
4034  = ToType2->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
4035 
4036  // -- conversion of C* to B* is better than conversion of C* to A*,
4037  if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
4038  if (S.IsDerivedFrom(Loc, ToPointee1, ToPointee2))
4040  else if (S.IsDerivedFrom(Loc, ToPointee2, ToPointee1))
4042  }
4043 
4044  // -- conversion of B* to A* is better than conversion of C* to A*,
4045  if (FromPointee1 != FromPointee2 && ToPointee1 == ToPointee2) {
4046  if (S.IsDerivedFrom(Loc, FromPointee2, FromPointee1))
4048  else if (S.IsDerivedFrom(Loc, FromPointee1, FromPointee2))
4050  }
4051  } else if (SCS1.Second == ICK_Pointer_Conversion &&
4052  SCS2.Second == ICK_Pointer_Conversion) {
4053  const ObjCObjectPointerType *FromPtr1
4054  = FromType1->getAs<ObjCObjectPointerType>();
4055  const ObjCObjectPointerType *FromPtr2
4056  = FromType2->getAs<ObjCObjectPointerType>();
4057  const ObjCObjectPointerType *ToPtr1
4058  = ToType1->getAs<ObjCObjectPointerType>();
4059  const ObjCObjectPointerType *ToPtr2
4060  = ToType2->getAs<ObjCObjectPointerType>();
4061 
4062  if (FromPtr1 && FromPtr2 && ToPtr1 && ToPtr2) {
4063  // Apply the same conversion ranking rules for Objective-C pointer types
4064  // that we do for C++ pointers to class types. However, we employ the
4065  // Objective-C pseudo-subtyping relationship used for assignment of
4066  // Objective-C pointer types.
4067  bool FromAssignLeft
4068  = S.Context.canAssignObjCInterfaces(FromPtr1, FromPtr2);
4069  bool FromAssignRight
4070  = S.Context.canAssignObjCInterfaces(FromPtr2, FromPtr1);
4071  bool ToAssignLeft
4072  = S.Context.canAssignObjCInterfaces(ToPtr1, ToPtr2);
4073  bool ToAssignRight
4074  = S.Context.canAssignObjCInterfaces(ToPtr2, ToPtr1);
4075 
4076  // A conversion to an a non-id object pointer type or qualified 'id'
4077  // type is better than a conversion to 'id'.
4078  if (ToPtr1->isObjCIdType() &&
4079  (ToPtr2->isObjCQualifiedIdType() || ToPtr2->getInterfaceDecl()))
4081  if (ToPtr2->isObjCIdType() &&
4082  (ToPtr1->isObjCQualifiedIdType() || ToPtr1->getInterfaceDecl()))
4084 
4085  // A conversion to a non-id object pointer type is better than a
4086  // conversion to a qualified 'id' type
4087  if (ToPtr1->isObjCQualifiedIdType() && ToPtr2->getInterfaceDecl())
4089  if (ToPtr2->isObjCQualifiedIdType() && ToPtr1->getInterfaceDecl())
4091 
4092  // A conversion to an a non-Class object pointer type or qualified 'Class'
4093  // type is better than a conversion to 'Class'.
4094  if (ToPtr1->isObjCClassType() &&
4095  (ToPtr2->isObjCQualifiedClassType() || ToPtr2->getInterfaceDecl()))
4097  if (ToPtr2->isObjCClassType() &&
4098  (ToPtr1->isObjCQualifiedClassType() || ToPtr1->getInterfaceDecl()))
4100 
4101  // A conversion to a non-Class object pointer type is better than a
4102  // conversion to a qualified 'Class' type.
4103  if (ToPtr1->isObjCQualifiedClassType() && ToPtr2->getInterfaceDecl())
4105  if (ToPtr2->isObjCQualifiedClassType() && ToPtr1->getInterfaceDecl())
4107 
4108  // -- "conversion of C* to B* is better than conversion of C* to A*,"
4109  if (S.Context.hasSameType(FromType1, FromType2) &&
4110  !FromPtr1->isObjCIdType() && !FromPtr1->isObjCClassType() &&
4111  (ToAssignLeft != ToAssignRight)) {
4112  if (FromPtr1->isSpecialized()) {
4113  // "conversion of B<A> * to B * is better than conversion of B * to
4114  // C *.
4115  bool IsFirstSame =
4116  FromPtr1->getInterfaceDecl() == ToPtr1->getInterfaceDecl();
4117  bool IsSecondSame =
4118  FromPtr1->getInterfaceDecl() == ToPtr2->getInterfaceDecl();
4119  if (IsFirstSame) {
4120  if (!IsSecondSame)
4122  } else if (IsSecondSame)
4124  }
4125  return ToAssignLeft? ImplicitConversionSequence::Worse
4127  }
4128 
4129  // -- "conversion of B* to A* is better than conversion of C* to A*,"
4130  if (S.Context.hasSameUnqualifiedType(ToType1, ToType2) &&
4131  (FromAssignLeft != FromAssignRight))
4132  return FromAssignLeft? ImplicitConversionSequence::Better
4134  }
4135  }
4136 
4137  // Ranking of member-pointer types.
4138  if (SCS1.Second == ICK_Pointer_Member && SCS2.Second == ICK_Pointer_Member &&
4139  FromType1->isMemberPointerType() && FromType2->isMemberPointerType() &&
4140  ToType1->isMemberPointerType() && ToType2->isMemberPointerType()) {
4141  const MemberPointerType * FromMemPointer1 =
4142  FromType1->getAs<MemberPointerType>();
4143  const MemberPointerType * ToMemPointer1 =
4144  ToType1->getAs<MemberPointerType>();
4145  const MemberPointerType * FromMemPointer2 =
4146  FromType2->getAs<MemberPointerType>();
4147  const MemberPointerType * ToMemPointer2 =
4148  ToType2->getAs<MemberPointerType>();
4149  const Type *FromPointeeType1 = FromMemPointer1->getClass();
4150  const Type *ToPointeeType1 = ToMemPointer1->getClass();
4151  const Type *FromPointeeType2 = FromMemPointer2->getClass();
4152  const Type *ToPointeeType2 = ToMemPointer2->getClass();
4153  QualType FromPointee1 = QualType(FromPointeeType1, 0).getUnqualifiedType();
4154  QualType ToPointee1 = QualType(ToPointeeType1, 0).getUnqualifiedType();
4155  QualType FromPointee2 = QualType(FromPointeeType2, 0).getUnqualifiedType();
4156  QualType ToPointee2 = QualType(ToPointeeType2, 0).getUnqualifiedType();
4157  // conversion of A::* to B::* is better than conversion of A::* to C::*,
4158  if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
4159  if (S.IsDerivedFrom(Loc, ToPointee1, ToPointee2))
4161  else if (S.IsDerivedFrom(Loc, ToPointee2, ToPointee1))
4163  }
4164  // conversion of B::* to C::* is better than conversion of A::* to C::*
4165  if (ToPointee1 == ToPointee2 && FromPointee1 != FromPointee2) {
4166  if (S.IsDerivedFrom(Loc, FromPointee1, FromPointee2))
4168  else if (S.IsDerivedFrom(Loc, FromPointee2, FromPointee1))
4170  }
4171  }
4172 
4173  if (SCS1.Second == ICK_Derived_To_Base) {
4174  // -- conversion of C to B is better than conversion of C to A,
4175  // -- binding of an expression of type C to a reference of type
4176  // B& is better than binding an expression of type C to a
4177  // reference of type A&,
4178  if (S.Context.hasSameUnqualifiedType(FromType1, FromType2) &&
4179  !S.Context.hasSameUnqualifiedType(ToType1, ToType2)) {
4180  if (S.IsDerivedFrom(Loc, ToType1, ToType2))
4182  else if (S.IsDerivedFrom(Loc, ToType2, ToType1))
4184  }
4185 
4186  // -- conversion of B to A is better than conversion of C to A.
4187  // -- binding of an expression of type B to a reference of type
4188  // A& is better than binding an expression of type C to a
4189  // reference of type A&,
4190  if (!S.Context.hasSameUnqualifiedType(FromType1, FromType2) &&
4191  S.Context.hasSameUnqualifiedType(ToType1, ToType2)) {
4192  if (S.IsDerivedFrom(Loc, FromType2, FromType1))
4194  else if (S.IsDerivedFrom(Loc, FromType1, FromType2))
4196  }
4197  }
4198 
4200 }
4201 
4202 /// \brief Determine whether the given type is valid, e.g., it is not an invalid
4203 /// C++ class.
4204 static bool isTypeValid(QualType T) {
4205  if (CXXRecordDecl *Record = T->getAsCXXRecordDecl())
4206  return !Record->isInvalidDecl();
4207 
4208  return true;
4209 }
4210 
4211 /// CompareReferenceRelationship - Compare the two types T1 and T2 to
4212 /// determine whether they are reference-related,
4213 /// reference-compatible, reference-compatible with added
4214 /// qualification, or incompatible, for use in C++ initialization by
4215 /// reference (C++ [dcl.ref.init]p4). Neither type can be a reference
4216 /// type, and the first type (T1) is the pointee type of the reference
4217 /// type being initialized.
4220  QualType OrigT1, QualType OrigT2,
4221  bool &DerivedToBase,
4222  bool &ObjCConversion,
4223  bool &ObjCLifetimeConversion) {
4224  assert(!OrigT1->isReferenceType() &&
4225  "T1 must be the pointee type of the reference type");
4226  assert(!OrigT2->isReferenceType() && "T2 cannot be a reference type");
4227 
4228  QualType T1 = Context.getCanonicalType(OrigT1);
4229  QualType T2 = Context.getCanonicalType(OrigT2);
4230  Qualifiers T1Quals, T2Quals;
4231  QualType UnqualT1 = Context.getUnqualifiedArrayType(T1, T1Quals);
4232  QualType UnqualT2 = Context.getUnqualifiedArrayType(T2, T2Quals);
4233 
4234  // C++ [dcl.init.ref]p4:
4235  // Given types "cv1 T1" and "cv2 T2," "cv1 T1" is
4236  // reference-related to "cv2 T2" if T1 is the same type as T2, or
4237  // T1 is a base class of T2.
4238  DerivedToBase = false;
4239  ObjCConversion = false;
4240  ObjCLifetimeConversion = false;
4241  QualType ConvertedT2;
4242  if (UnqualT1 == UnqualT2) {
4243  // Nothing to do.
4244  } else if (isCompleteType(Loc, OrigT2) &&
4245  isTypeValid(UnqualT1) && isTypeValid(UnqualT2) &&
4246  IsDerivedFrom(Loc, UnqualT2, UnqualT1))
4247  DerivedToBase = true;
4248  else if (UnqualT1->isObjCObjectOrInterfaceType() &&
4249  UnqualT2->isObjCObjectOrInterfaceType() &&
4250  Context.canBindObjCObjectType(UnqualT1, UnqualT2))
4251  ObjCConversion = true;
4252  else if (UnqualT2->isFunctionType() &&
4253  IsFunctionConversion(UnqualT2, UnqualT1, ConvertedT2))
4254  // C++1z [dcl.init.ref]p4:
4255  // cv1 T1" is reference-compatible with "cv2 T2" if [...] T2 is "noexcept
4256  // function" and T1 is "function"
4257  //
4258  // We extend this to also apply to 'noreturn', so allow any function
4259  // conversion between function types.
4260  return Ref_Compatible;
4261  else
4262  return Ref_Incompatible;
4263 
4264  // At this point, we know that T1 and T2 are reference-related (at
4265  // least).
4266 
4267  // If the type is an array type, promote the element qualifiers to the type
4268  // for comparison.
4269  if (isa<ArrayType>(T1) && T1Quals)
4270  T1 = Context.getQualifiedType(UnqualT1, T1Quals);
4271  if (isa<ArrayType>(T2) && T2Quals)
4272  T2 = Context.getQualifiedType(UnqualT2, T2Quals);
4273 
4274  // C++ [dcl.init.ref]p4:
4275  // "cv1 T1" is reference-compatible with "cv2 T2" if T1 is
4276  // reference-related to T2 and cv1 is the same cv-qualification
4277  // as, or greater cv-qualification than, cv2. For purposes of
4278  // overload resolution, cases for which cv1 is greater
4279  // cv-qualification than cv2 are identified as
4280  // reference-compatible with added qualification (see 13.3.3.2).
4281  //
4282  // Note that we also require equivalence of Objective-C GC and address-space
4283  // qualifiers when performing these computations, so that e.g., an int in
4284  // address space 1 is not reference-compatible with an int in address
4285  // space 2.
4286  if (T1Quals.getObjCLifetime() != T2Quals.getObjCLifetime() &&
4287  T1Quals.compatiblyIncludesObjCLifetime(T2Quals)) {
4288  if (isNonTrivialObjCLifetimeConversion(T2Quals, T1Quals))
4289  ObjCLifetimeConversion = true;
4290 
4291  T1Quals.removeObjCLifetime();
4292  T2Quals.removeObjCLifetime();
4293  }
4294 
4295  // MS compiler ignores __unaligned qualifier for references; do the same.
4296  T1Quals.removeUnaligned();
4297  T2Quals.removeUnaligned();
4298 
4299  if (T1Quals.compatiblyIncludes(T2Quals))
4300  return Ref_Compatible;
4301  else
4302  return Ref_Related;
4303 }
4304 
4305 /// \brief Look for a user-defined conversion to a value reference-compatible
4306 /// with DeclType. Return true if something definite is found.
4307 static bool
4309  QualType DeclType, SourceLocation DeclLoc,
4310  Expr *Init, QualType T2, bool AllowRvalues,
4311  bool AllowExplicit) {
4312  assert(T2->isRecordType() && "Can only find conversions of record types.");
4313  CXXRecordDecl *T2RecordDecl
4314  = dyn_cast<CXXRecordDecl>(T2->getAs<RecordType>()->getDecl());
4315 
4316  OverloadCandidateSet CandidateSet(
4318  const auto &Conversions = T2RecordDecl->getVisibleConversionFunctions();
4319  for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
4320  NamedDecl *D = *I;
4321  CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
4322  if (isa<UsingShadowDecl>(D))
4323  D = cast<UsingShadowDecl>(D)->getTargetDecl();
4324 
4325  FunctionTemplateDecl *ConvTemplate
4326  = dyn_cast<FunctionTemplateDecl>(D);
4327  CXXConversionDecl *Conv;
4328  if (ConvTemplate)
4329  Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
4330  else
4331  Conv = cast<CXXConversionDecl>(D);
4332 
4333  // If this is an explicit conversion, and we're not allowed to consider
4334  // explicit conversions, skip it.
4335  if (!AllowExplicit && Conv->isExplicit())
4336  continue;
4337 
4338  if (AllowRvalues) {
4339  bool DerivedToBase = false;
4340  bool ObjCConversion = false;
4341  bool ObjCLifetimeConversion = false;
4342 
4343  // If we are initializing an rvalue reference, don't permit conversion
4344  // functions that return lvalues.
4345  if (!ConvTemplate && DeclType->isRValueReferenceType()) {
4346  const ReferenceType *RefType
4347  = Conv->getConversionType()->getAs<LValueReferenceType>();
4348  if (RefType && !RefType->getPointeeType()->isFunctionType())
4349  continue;
4350  }
4351 
4352  if (!ConvTemplate &&
4354  DeclLoc,
4355  Conv->getConversionType().getNonReferenceType()
4356  .getUnqualifiedType(),
4358  DerivedToBase, ObjCConversion, ObjCLifetimeConversion) ==
4360  continue;
4361  } else {
4362  // If the conversion function doesn't return a reference type,
4363  // it can't be considered for this conversion. An rvalue reference
4364  // is only acceptable if its referencee is a function type.
4365 
4366  const ReferenceType *RefType =
4367  Conv->getConversionType()->getAs<ReferenceType>();
4368  if (!RefType ||
4369  (!RefType->isLValueReferenceType() &&
4370  !RefType->getPointeeType()->isFunctionType()))
4371  continue;
4372  }
4373 
4374  if (ConvTemplate)
4375  S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(), ActingDC,
4376  Init, DeclType, CandidateSet,
4377  /*AllowObjCConversionOnExplicit=*/false);
4378  else
4379  S.AddConversionCandidate(Conv, I.getPair(), ActingDC, Init,
4380  DeclType, CandidateSet,
4381  /*AllowObjCConversionOnExplicit=*/false);
4382  }
4383 
4384  bool HadMultipleCandidates = (CandidateSet.size() > 1);
4385 
4387  switch (CandidateSet.BestViableFunction(S, DeclLoc, Best)) {
4388  case OR_Success:
4389  // C++ [over.ics.ref]p1:
4390  //
4391  // [...] If the parameter binds directly to the result of
4392  // applying a conversion function to the argument
4393  // expression, the implicit conversion sequence is a
4394  // user-defined conversion sequence (13.3.3.1.2), with the
4395  // second standard conversion sequence either an identity
4396  // conversion or, if the conversion function returns an
4397  // entity of a type that is a derived class of the parameter
4398  // type, a derived-to-base Conversion.
4399  if (!Best->FinalConversion.DirectBinding)
4400  return false;
4401 
4402  ICS.setUserDefined();
4403  ICS.UserDefined.Before = Best->Conversions[0].Standard;
4404  ICS.UserDefined.After = Best->FinalConversion;
4405  ICS.UserDefined.HadMultipleCandidates = HadMultipleCandidates;
4406  ICS.UserDefined.ConversionFunction = Best->Function;
4407  ICS.UserDefined.FoundConversionFunction = Best->FoundDecl;
4408  ICS.UserDefined.EllipsisConversion = false;
4409  assert(ICS.UserDefined.After.ReferenceBinding &&
4411  "Expected a direct reference binding!");
4412  return true;
4413 
4414  case OR_Ambiguous:
4415  ICS.setAmbiguous();
4416  for (OverloadCandidateSet::iterator Cand = CandidateSet.begin();
4417  Cand != CandidateSet.end(); ++Cand)
4418  if (Cand->Viable)
4419  ICS.Ambiguous.addConversion(Cand->FoundDecl, Cand->Function);
4420  return true;
4421 
4422  case OR_No_Viable_Function:
4423  case OR_Deleted:
4424  // There was no suitable conversion, or we found a deleted
4425  // conversion; continue with other checks.
4426  return false;
4427  }
4428 
4429  llvm_unreachable("Invalid OverloadResult!");
4430 }
4431 
4432 /// \brief Compute an implicit conversion sequence for reference
4433 /// initialization.
4435 TryReferenceInit(Sema &S, Expr *Init, QualType DeclType,
4436  SourceLocation DeclLoc,
4437  bool SuppressUserConversions,
4438  bool AllowExplicit) {
4439  assert(DeclType->isReferenceType() && "Reference init needs a reference");
4440 
4441  // Most paths end in a failed conversion.
4443  ICS.setBad(BadConversionSequence::no_conversion, Init, DeclType);
4444 
4445  QualType T1 = DeclType->getAs<ReferenceType>()->getPointeeType();
4446  QualType T2 = Init->getType();
4447 
4448  // If the initializer is the address of an overloaded function, try
4449  // to resolve the overloaded function. If all goes well, T2 is the
4450  // type of the resulting function.
4451  if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) {
4452  DeclAccessPair Found;
4453  if (FunctionDecl *Fn = S.ResolveAddressOfOverloadedFunction(Init, DeclType,
4454  false, Found))
4455  T2 = Fn->getType();
4456  }
4457 
4458  // Compute some basic properties of the types and the initializer.
4459  bool isRValRef = DeclType->isRValueReferenceType();
4460  bool DerivedToBase = false;
4461  bool ObjCConversion = false;
4462  bool ObjCLifetimeConversion = false;
4463  Expr::Classification InitCategory = Init->Classify(S.Context);
4464  Sema::ReferenceCompareResult RefRelationship
4465  = S.CompareReferenceRelationship(DeclLoc, T1, T2, DerivedToBase,
4466  ObjCConversion, ObjCLifetimeConversion);
4467 
4468 
4469  // C++0x [dcl.init.ref]p5:
4470  // A reference to type "cv1 T1" is initialized by an expression
4471  // of type "cv2 T2" as follows:
4472 
4473  // -- If reference is an lvalue reference and the initializer expression
4474  if (!isRValRef) {
4475  // -- is an lvalue (but is not a bit-field), and "cv1 T1" is
4476  // reference-compatible with "cv2 T2," or
4477  //
4478  // Per C++ [over.ics.ref]p4, we don't check the bit-field property here.
4479  if (InitCategory.isLValue() && RefRelationship == Sema::Ref_Compatible) {
4480  // C++ [over.ics.ref]p1:
4481  // When a parameter of reference type binds directly (8.5.3)
4482  // to an argument expression, the implicit conversion sequence
4483  // is the identity conversion, unless the argument expression
4484  // has a type that is a derived class of the parameter type,
4485  // in which case the implicit conversion sequence is a
4486  // derived-to-base Conversion (13.3.3.1).
4487  ICS.setStandard();
4488  ICS.Standard.First = ICK_Identity;
4489  ICS.Standard.Second = DerivedToBase? ICK_Derived_To_Base
4490  : ObjCConversion? ICK_Compatible_Conversion
4491  : ICK_Identity;
4492  ICS.Standard.Third = ICK_Identity;
4493  ICS.Standard.FromTypePtr = T2.getAsOpaquePtr();
4494  ICS.Standard.setToType(0, T2);
4495  ICS.Standard.setToType(1, T1);
4496  ICS.Standard.setToType(2, T1);
4497  ICS.Standard.ReferenceBinding = true;
4498  ICS.Standard.DirectBinding = true;
4499  ICS.Standard.IsLvalueReference = !isRValRef;
4500  ICS.Standard.BindsToFunctionLvalue = T2->isFunctionType();
4501  ICS.Standard.BindsToRvalue = false;
4502  ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false;
4503  ICS.Standard.ObjCLifetimeConversionBinding = ObjCLifetimeConversion;
4504  ICS.Standard.CopyConstructor = nullptr;
4505  ICS.Standard.DeprecatedStringLiteralToCharPtr = false;
4506 
4507  // Nothing more to do: the inaccessibility/ambiguity check for
4508  // derived-to-base conversions is suppressed when we're
4509  // computing the implicit conversion sequence (C++
4510  // [over.best.ics]p2).
4511  return ICS;
4512  }
4513 
4514  // -- has a class type (i.e., T2 is a class type), where T1 is
4515  // not reference-related to T2, and can be implicitly
4516  // converted to an lvalue of type "cv3 T3," where "cv1 T1"
4517  // is reference-compatible with "cv3 T3" 92) (this
4518  // conversion is selected by enumerating the applicable
4519  // conversion functions (13.3.1.6) and choosing the best
4520  // one through overload resolution (13.3)),
4521  if (!SuppressUserConversions && T2->isRecordType() &&
4522  S.isCompleteType(DeclLoc, T2) &&
4523  RefRelationship == Sema::Ref_Incompatible) {
4524  if (FindConversionForRefInit(S, ICS, DeclType, DeclLoc,
4525  Init, T2, /*AllowRvalues=*/false,
4526  AllowExplicit))
4527  return ICS;
4528  }
4529  }
4530 
4531  // -- Otherwise, the reference shall be an lvalue reference to a
4532  // non-volatile const type (i.e., cv1 shall be const), or the reference
4533  // shall be an rvalue reference.
4534  if (!isRValRef && (!T1.isConstQualified() || T1.isVolatileQualified()))
4535  return ICS;
4536 
4537  // -- If the initializer expression
4538  //
4539  // -- is an xvalue, class prvalue, array prvalue or function
4540  // lvalue and "cv1 T1" is reference-compatible with "cv2 T2", or
4541  if (RefRelationship == Sema::Ref_Compatible &&
4542  (InitCategory.isXValue() ||
4543  (InitCategory.isPRValue() && (T2->isRecordType() || T2->isArrayType())) ||
4544  (InitCategory.isLValue() && T2->isFunctionType()))) {
4545  ICS.setStandard();
4546  ICS.Standard.First = ICK_Identity;
4547  ICS.Standard.Second = DerivedToBase? ICK_Derived_To_Base
4548  : ObjCConversion? ICK_Compatible_Conversion
4549  : ICK_Identity;
4550  ICS.Standard.Third = ICK_Identity;
4551  ICS.Standard.FromTypePtr = T2.getAsOpaquePtr();
4552  ICS.Standard.setToType(0, T2);
4553  ICS.Standard.setToType(1, T1);
4554  ICS.Standard.setToType(2, T1);
4555  ICS.Standard.ReferenceBinding = true;
4556  // In C++0x, this is always a direct binding. In C++98/03, it's a direct
4557  // binding unless we're binding to a class prvalue.
4558  // Note: Although xvalues wouldn't normally show up in C++98/03 code, we
4559  // allow the use of rvalue references in C++98/03 for the benefit of
4560  // standard library implementors; therefore, we need the xvalue check here.
4561  ICS.Standard.DirectBinding =
4562  S.getLangOpts().CPlusPlus11 ||
4563  !(InitCategory.isPRValue() || T2->isRecordType());
4564  ICS.Standard.IsLvalueReference = !isRValRef;
4565  ICS.Standard.BindsToFunctionLvalue = T2->isFunctionType();
4566  ICS.Standard.BindsToRvalue = InitCategory.isRValue();
4567  ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false;
4568  ICS.Standard.ObjCLifetimeConversionBinding = ObjCLifetimeConversion;
4569  ICS.Standard.CopyConstructor = nullptr;
4570  ICS.Standard.DeprecatedStringLiteralToCharPtr = false;
4571  return ICS;
4572  }
4573 
4574  // -- has a class type (i.e., T2 is a class type), where T1 is not
4575  // reference-related to T2, and can be implicitly converted to
4576  // an xvalue, class prvalue, or function lvalue of type
4577  // "cv3 T3", where "cv1 T1" is reference-compatible with
4578  // "cv3 T3",
4579  //
4580  // then the reference is bound to the value of the initializer
4581  // expression in the first case and to the result of the conversion
4582  // in the second case (or, in either case, to an appropriate base
4583  // class subobject).
4584  if (!SuppressUserConversions && RefRelationship == Sema::Ref_Incompatible &&
4585  T2->isRecordType() && S.isCompleteType(DeclLoc, T2) &&
4586  FindConversionForRefInit(S, ICS, DeclType, DeclLoc,
4587  Init, T2, /*AllowRvalues=*/true,
4588  AllowExplicit)) {
4589  // In the second case, if the reference is an rvalue reference
4590  // and the second standard conversion sequence of the
4591  // user-defined conversion sequence includes an lvalue-to-rvalue
4592  // conversion, the program is ill-formed.
4593  if (ICS.isUserDefined() && isRValRef &&
4594  ICS.UserDefined.After.First == ICK_Lvalue_To_Rvalue)
4595  ICS.setBad(BadConversionSequence::no_conversion, Init, DeclType);
4596 
4597  return ICS;
4598  }
4599 
4600  // A temporary of function type cannot be created; don't even try.
4601  if (T1->isFunctionType())
4602  return ICS;
4603 
4604  // -- Otherwise, a temporary of type "cv1 T1" is created and
4605  // initialized from the initializer expression using the
4606  // rules for a non-reference copy initialization (8.5). The
4607  // reference is then bound to the temporary. If T1 is
4608  // reference-related to T2, cv1 must be the same
4609  // cv-qualification as, or greater cv-qualification than,
4610  // cv2; otherwise, the program is ill-formed.
4611  if (RefRelationship == Sema::Ref_Related) {
4612  // If cv1 == cv2 or cv1 is a greater cv-qualified than cv2, then
4613  // we would be reference-compatible or reference-compatible with
4614  // added qualification. But that wasn't the case, so the reference
4615  // initialization fails.
4616  //
4617  // Note that we only want to check address spaces and cvr-qualifiers here.
4618  // ObjC GC, lifetime and unaligned qualifiers aren't important.
4619  Qualifiers T1Quals = T1.getQualifiers();
4620  Qualifiers T2Quals = T2.getQualifiers();
4621  T1Quals.removeObjCGCAttr();
4622  T1Quals.removeObjCLifetime();
4623  T2Quals.removeObjCGCAttr();
4624  T2Quals.removeObjCLifetime();
4625  // MS compiler ignores __unaligned qualifier for references; do the same.
4626  T1Quals.removeUnaligned();
4627  T2Quals.removeUnaligned();
4628  if (!T1Quals.compatiblyIncludes(T2Quals))
4629  return ICS;
4630  }
4631 
4632  // If at least one of the types is a class type, the types are not
4633  // related, and we aren't allowed any user conversions, the
4634  // reference binding fails. This case is important for breaking
4635  // recursion, since TryImplicitConversion below will attempt to
4636  // create a temporary through the use of a copy constructor.
4637  if (SuppressUserConversions && RefRelationship == Sema::Ref_Incompatible &&
4638  (T1->isRecordType() || T2->isRecordType()))
4639  return ICS;
4640 
4641  // If T1 is reference-related to T2 and the reference is an rvalue
4642  // reference, the initializer expression shall not be an lvalue.
4643  if (RefRelationship >= Sema::Ref_Related &&
4644  isRValRef && Init->Classify(S.Context).isLValue())
4645  return ICS;
4646 
4647  // C++ [over.ics.ref]p2:
4648  // When a parameter of reference type is not bound directly to
4649  // an argument expression, the conversion sequence is the one
4650  // required to convert the argument expression to the
4651  // underlying type of the reference according to
4652  // 13.3.3.1. Conceptually, this conversion sequence corresponds
4653  // to copy-initializing a temporary of the underlying type with
4654  // the argument expression. Any difference in top-level
4655  // cv-qualification is subsumed by the initialization itself
4656  // and does not constitute a conversion.
4657  ICS = TryImplicitConversion(S, Init, T1, SuppressUserConversions,
4658  /*AllowExplicit=*/false,
4659  /*InOverloadResolution=*/false,
4660  /*CStyle=*/false,
4661  /*AllowObjCWritebackConversion=*/false,
4662  /*AllowObjCConversionOnExplicit=*/false);
4663 
4664  // Of course, that's still a reference binding.
4665  if (ICS.isStandard()) {
4666  ICS.Standard.ReferenceBinding = true;
4667  ICS.Standard.IsLvalueReference = !isRValRef;
4668  ICS.Standard.BindsToFunctionLvalue = false;
4669  ICS.Standard.BindsToRvalue = true;
4670  ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false;
4671  ICS.Standard.ObjCLifetimeConversionBinding = false;
4672  } else if (ICS.isUserDefined()) {
4673  const ReferenceType *LValRefType =
4674  ICS.UserDefined.ConversionFunction->getReturnType()
4676 
4677  // C++ [over.ics.ref]p3:
4678  // Except for an implicit object parameter, for which see 13.3.1, a
4679  // standard conversion sequence cannot be formed if it requires [...]
4680  // binding an rvalue reference to an lvalue other than a function
4681  // lvalue.
4682  // Note that the function case is not possible here.
4683  if (DeclType->isRValueReferenceType() && LValRefType) {
4684  // FIXME: This is the wrong BadConversionSequence. The problem is binding
4685  // an rvalue reference to a (non-function) lvalue, not binding an lvalue
4686  // reference to an rvalue!
4687  ICS.setBad(BadConversionSequence::lvalue_ref_to_rvalue, Init, DeclType);
4688  return ICS;
4689  }
4690 
4691  ICS.UserDefined.After.ReferenceBinding = true;
4692  ICS.UserDefined.After.IsLvalueReference = !isRValRef;
4693  ICS.UserDefined.After.BindsToFunctionLvalue = false;
4694  ICS.UserDefined.After.BindsToRvalue = !LValRefType;
4695  ICS.UserDefined.After.BindsImplicitObjectArgumentWithoutRefQualifier = false;
4696  ICS.UserDefined.After.ObjCLifetimeConversionBinding = false;
4697  }
4698 
4699  return ICS;
4700 }
4701 
4703 TryCopyInitialization(Sema &S, Expr *From, QualType ToType,
4704  bool SuppressUserConversions,
4705  bool InOverloadResolution,
4706  bool AllowObjCWritebackConversion,
4707  bool AllowExplicit = false);
4708 
4709 /// TryListConversion - Try to copy-initialize a value of type ToType from the
4710 /// initializer list From.
4713  bool SuppressUserConversions,
4714  bool InOverloadResolution,
4715  bool AllowObjCWritebackConversion) {
4716  // C++11 [over.ics.list]p1:
4717  // When an argument is an initializer list, it is not an expression and
4718  // special rules apply for converting it to a parameter type.
4719 
4721  Result.setBad(BadConversionSequence::no_conversion, From, ToType);
4722 
4723  // We need a complete type for what follows. Incomplete types can never be
4724  // initialized from init lists.
4725  if (!S.isCompleteType(From->getLocStart(), ToType))
4726  return Result;
4727 
4728  // Per DR1467:
4729  // If the parameter type is a class X and the initializer list has a single
4730  // element of type cv U, where U is X or a class derived from X, the
4731  // implicit conversion sequence is the one required to convert the element
4732  // to the parameter type.
4733  //
4734  // Otherwise, if the parameter type is a character array [... ]
4735  // and the initializer list has a single element that is an
4736  // appropriately-typed string literal (8.5.2 [dcl.init.string]), the
4737  // implicit conversion sequence is the identity conversion.
4738  if (From->getNumInits() == 1) {
4739  if (ToType->isRecordType()) {
4740  QualType InitType = From->getInit(0)->getType();
4741  if (S.Context.hasSameUnqualifiedType(InitType, ToType) ||
4742  S.IsDerivedFrom(From->getLocStart(), InitType, ToType))
4743  return TryCopyInitialization(S, From->getInit(0), ToType,
4744  SuppressUserConversions,
4745  InOverloadResolution,
4746  AllowObjCWritebackConversion);
4747  }
4748  // FIXME: Check the other conditions here: array of character type,
4749  // initializer is a string literal.
4750  if (ToType->isArrayType()) {
4751  InitializedEntity Entity =
4753  /*Consumed=*/false);
4754  if (S.CanPerformCopyInitialization(Entity, From)) {
4755  Result.setStandard();
4757  Result.Standard.setFromType(ToType);
4758  Result.Standard.setAllToTypes(ToType);
4759  return Result;
4760  }
4761  }
4762  }
4763 
4764  // C++14 [over.ics.list]p2: Otherwise, if the parameter type [...] (below).
4765  // C++11 [over.ics.list]p2:
4766  // If the parameter type is std::initializer_list<X> or "array of X" and
4767  // all the elements can be implicitly converted to X, the implicit
4768  // conversion sequence is the worst conversion necessary to convert an
4769  // element of the list to X.
4770  //
4771  // C++14 [over.ics.list]p3:
4772  // Otherwise, if the parameter type is "array of N X", if the initializer
4773  // list has exactly N elements or if it has fewer than N elements and X is
4774  // default-constructible, and if all the elements of the initializer list
4775  // can be implicitly converted to X, the implicit conversion sequence is
4776  // the worst conversion necessary to convert an element of the list to X.
4777  //
4778  // FIXME: We're missing a lot of these checks.
4779  bool toStdInitializerList = false;
4780  QualType X;
4781  if (ToType->isArrayType())
4782  X = S.Context.getAsArrayType(ToType)->getElementType();
4783  else
4784  toStdInitializerList = S.isStdInitializerList(ToType, &X);
4785  if (!X.isNull()) {
4786  for (unsigned i = 0, e = From->getNumInits(); i < e; ++i) {
4787  Expr *Init = From->getInit(i);
4789  TryCopyInitialization(S, Init, X, SuppressUserConversions,
4790  InOverloadResolution,
4791  AllowObjCWritebackConversion);
4792  // If a single element isn't convertible, fail.
4793  if (ICS.isBad()) {
4794  Result = ICS;
4795  break;
4796  }
4797  // Otherwise, look for the worst conversion.
4798  if (Result.isBad() ||
4800  Result) ==
4802  Result = ICS;
4803  }
4804 
4805  // For an empty list, we won't have computed any conversion sequence.
4806  // Introduce the identity conversion sequence.
4807  if (From->getNumInits() == 0) {
4808  Result.setStandard();
4810  Result.Standard.setFromType(ToType);
4811  Result.Standard.setAllToTypes(ToType);
4812  }
4813 
4814  Result.setStdInitializerListElement(toStdInitializerList);
4815  return Result;
4816  }
4817 
4818  // C++14 [over.ics.list]p4:
4819  // C++11 [over.ics.list]p3:
4820  // Otherwise, if the parameter is a non-aggregate class X and overload
4821  // resolution chooses a single best constructor [...] the implicit
4822  // conversion sequence is a user-defined conversion sequence. If multiple
4823  // constructors are viable but none is better than the others, the
4824  // implicit conversion sequence is a user-defined conversion sequence.
4825  if (ToType->isRecordType() && !ToType->isAggregateType()) {
4826  // This function can deal with initializer lists.
4827  return TryUserDefinedConversion(S, From, ToType, SuppressUserConversions,
4828  /*AllowExplicit=*/false,
4829  InOverloadResolution, /*CStyle=*/false,
4830  AllowObjCWritebackConversion,
4831  /*AllowObjCConversionOnExplicit=*/false);
4832  }
4833 
4834  // C++14 [over.ics.list]p5:
4835  // C++11 [over.ics.list]p4:
4836  // Otherwise, if the parameter has an aggregate type which can be
4837  // initialized from the initializer list [...] the implicit conversion
4838  // sequence is a user-defined conversion sequence.
4839  if (ToType->isAggregateType()) {
4840  // Type is an aggregate, argument is an init list. At this point it comes
4841  // down to checking whether the initialization works.
4842  // FIXME: Find out whether this parameter is consumed or not.
4843  // FIXME: Expose SemaInit's aggregate initialization code so that we don't
4844  // need to call into the initialization code here; overload resolution
4845  // should not be doing that.
4846  InitializedEntity Entity =
4848  /*Consumed=*/false);
4849  if (S.CanPerformCopyInitialization(Entity, From)) {
4850  Result.setUserDefined();
4852  // Initializer lists don't have a type.
4855 
4857  Result.UserDefined.After.setFromType(ToType);
4858  Result.UserDefined.After.setAllToTypes(ToType);
4859  Result.UserDefined.ConversionFunction = nullptr;
4860  }
4861  return Result;
4862  }
4863 
4864  // C++14 [over.ics.list]p6:
4865  // C++11 [over.ics.list]p5:
4866  // Otherwise, if the parameter is a reference, see 13.3.3.1.4.
4867  if (ToType->isReferenceType()) {
4868  // The standard is notoriously unclear here, since 13.3.3.1.4 doesn't
4869  // mention initializer lists in any way. So we go by what list-
4870  // initialization would do and try to extrapolate from that.
4871 
4872  QualType T1 = ToType->getAs<ReferenceType>()->getPointeeType();
4873 
4874  // If the initializer list has a single element that is reference-related
4875  // to the parameter type, we initialize the reference from that.
4876  if (From->getNumInits() == 1) {
4877  Expr *Init = From->getInit(0);
4878 
4879  QualType T2 = Init->getType();
4880 
4881  // If the initializer is the address of an overloaded function, try
4882  // to resolve the overloaded function. If all goes well, T2 is the
4883  // type of the resulting function.
4884  if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) {
4885  DeclAccessPair Found;
4887  Init, ToType, false, Found))
4888  T2 = Fn->getType();
4889  }
4890 
4891  // Compute some basic properties of the types and the initializer.
4892  bool dummy1 = false;
4893  bool dummy2 = false;
4894  bool dummy3 = false;
4895  Sema::ReferenceCompareResult RefRelationship
4896  = S.CompareReferenceRelationship(From->getLocStart(), T1, T2, dummy1,
4897  dummy2, dummy3);
4898 
4899  if (RefRelationship >= Sema::Ref_Related) {
4900  return TryReferenceInit(S, Init, ToType, /*FIXME*/From->getLocStart(),
4901  SuppressUserConversions,
4902  /*AllowExplicit=*/false);
4903  }
4904  }
4905 
4906  // Otherwise, we bind the reference to a temporary created from the
4907  // initializer list.
4908  Result = TryListConversion(S, From, T1, SuppressUserConversions,
4909  InOverloadResolution,
4910  AllowObjCWritebackConversion);
4911  if (Result.isFailure())
4912  return Result;
4913  assert(!Result.isEllipsis() &&
4914  "Sub-initialization cannot result in ellipsis conversion.");
4915 
4916  // Can we even bind to a temporary?
4917  if (ToType->isRValueReferenceType() ||
4918  (T1.isConstQualified() && !T1.isVolatileQualified())) {
4919  StandardConversionSequence &SCS = Result.isStandard() ? Result.Standard :
4920  Result.UserDefined.After;
4921  SCS.ReferenceBinding = true;
4922  SCS.IsLvalueReference = ToType->isLValueReferenceType();
4923  SCS.BindsToRvalue = true;
4924  SCS.BindsToFunctionLvalue = false;
4926  SCS.ObjCLifetimeConversionBinding = false;
4927  } else
4929  From, ToType);
4930  return Result;
4931  }
4932 
4933  // C++14 [over.ics.list]p7:
4934  // C++11 [over.ics.list]p6:
4935  // Otherwise, if the parameter type is not a class:
4936  if (!ToType->isRecordType()) {
4937  // - if the initializer list has one element that is not itself an
4938  // initializer list, the implicit conversion sequence is the one
4939  // required to convert the element to the parameter type.
4940  unsigned NumInits = From->getNumInits();
4941  if (NumInits == 1 && !isa<InitListExpr>(From->getInit(0)))
4942  Result = TryCopyInitialization(S, From->getInit(0), ToType,
4943  SuppressUserConversions,
4944  InOverloadResolution,
4945  AllowObjCWritebackConversion);
4946  // - if the initializer list has no elements, the implicit conversion
4947  // sequence is the identity conversion.
4948  else if (NumInits == 0) {
4949  Result.setStandard();
4951  Result.Standard.setFromType(ToType);
4952  Result.Standard.setAllToTypes(ToType);
4953  }
4954  return Result;
4955  }
4956 
4957  // C++14 [over.ics.list]p8:
4958  // C++11 [over.ics.list]p7:
4959  // In all cases other than those enumerated above, no conversion is possible
4960  return Result;
4961 }
4962 
4963 /// TryCopyInitialization - Try to copy-initialize a value of type
4964 /// ToType from the expression From. Return the implicit conversion
4965 /// sequence required to pass this argument, which may be a bad
4966 /// conversion sequence (meaning that the argument cannot be passed to
4967 /// a parameter of this type). If @p SuppressUserConversions, then we
4968 /// do not permit any user-defined conversion sequences.
4971  bool SuppressUserConversions,
4972  bool InOverloadResolution,
4973  bool AllowObjCWritebackConversion,
4974  bool AllowExplicit) {
4975  if (InitListExpr *FromInitList = dyn_cast<InitListExpr>(From))
4976  return TryListConversion(S, FromInitList, ToType, SuppressUserConversions,
4977  InOverloadResolution,AllowObjCWritebackConversion);
4978 
4979  if (ToType->isReferenceType())
4980  return TryReferenceInit(S, From, ToType,
4981  /*FIXME:*/From->getLocStart(),
4982  SuppressUserConversions,
4983  AllowExplicit);
4984 
4985  return TryImplicitConversion(S, From, ToType,
4986  SuppressUserConversions,
4987  /*AllowExplicit=*/false,
4988  InOverloadResolution,
4989  /*CStyle=*/false,
4990  AllowObjCWritebackConversion,
4991  /*AllowObjCConversionOnExplicit=*/false);
4992 }
4993 
4994 static bool TryCopyInitialization(const CanQualType FromQTy,
4995  const CanQualType ToQTy,
4996  Sema &S,
4997  SourceLocation Loc,
4998  ExprValueKind FromVK) {
4999  OpaqueValueExpr TmpExpr(Loc, FromQTy, FromVK);
5001  TryCopyInitialization(S, &TmpExpr, ToQTy, true, true, false);
5002 
5003  return !ICS.isBad();
5004 }
5005 
5006 /// TryObjectArgumentInitialization - Try to initialize the object
5007 /// parameter of the given member function (@c Method) from the
5008 /// expression @p From.
5011  Expr::Classification FromClassification,
5012  CXXMethodDecl *Method,
5013  CXXRecordDecl *ActingContext) {
5014  QualType ClassType = S.Context.getTypeDeclType(ActingContext);
5015  // [class.dtor]p2: A destructor can be invoked for a const, volatile or
5016  // const volatile object.
5017  unsigned Quals = isa<CXXDestructorDecl>(Method) ?
5019  QualType ImplicitParamType = S.Context.getCVRQualifiedType(ClassType, Quals);
5020 
5021  // Set up the conversion sequence as a "bad" conversion, to allow us
5022  // to exit early.
5024 
5025  // We need to have an object of class type.
5026  if (const PointerType *PT = FromType->getAs<PointerType>()) {
5027  FromType = PT->getPointeeType();
5028 
5029  // When we had a pointer, it's implicitly dereferenced, so we
5030  // better have an lvalue.
5031  assert(FromClassification.isLValue());
5032  }
5033 
5034  assert(FromType->isRecordType());
5035 
5036  // C++0x [over.match.funcs]p4:
5037  // For non-static member functions, the type of the implicit object
5038  // parameter is
5039  //
5040  // - "lvalue reference to cv X" for functions declared without a
5041  // ref-qualifier or with the & ref-qualifier
5042  // - "rvalue reference to cv X" for functions declared with the &&
5043  // ref-qualifier
5044  //
5045  // where X is the class of which the function is a member and cv is the
5046  // cv-qualification on the member function declaration.
5047  //
5048  // However, when finding an implicit conversion sequence for the argument, we
5049  // are not allowed to perform user-defined conversions
5050  // (C++ [over.match.funcs]p5). We perform a simplified version of
5051  // reference binding here, that allows class rvalues to bind to
5052  // non-constant references.
5053 
5054  // First check the qualifiers.
5055  QualType FromTypeCanon = S.Context.getCanonicalType(FromType);
5056  if (ImplicitParamType.getCVRQualifiers()
5057  != FromTypeCanon.getLocalCVRQualifiers() &&
5058  !ImplicitParamType.isAtLeastAsQualifiedAs(FromTypeCanon)) {
5060  FromType, ImplicitParamType);
5061  return ICS;
5062  }
5063 
5064  // Check that we have either the same type or a derived type. It
5065  // affects the conversion rank.
5066  QualType ClassTypeCanon = S.Context.getCanonicalType(ClassType);
5067  ImplicitConversionKind SecondKind;
5068  if (ClassTypeCanon == FromTypeCanon.getLocalUnqualifiedType()) {
5069  SecondKind = ICK_Identity;
5070  } else if (S.IsDerivedFrom(Loc, FromType, ClassType))
5071  SecondKind = ICK_Derived_To_Base;
5072  else {
5074  FromType, ImplicitParamType);
5075  return ICS;
5076  }
5077 
5078  // Check the ref-qualifier.
5079  switch (Method->getRefQualifier()) {
5080  case RQ_None:
5081  // Do nothing; we don't care about lvalueness or rvalueness.
5082  break;
5083 
5084  case RQ_LValue:
5085  if (!FromClassification.isLValue() && Quals != Qualifiers::Const) {
5086  // non-const lvalue reference cannot bind to an rvalue
5088  ImplicitParamType);
5089  return ICS;
5090  }
5091  break;
5092 
5093  case RQ_RValue:
5094  if (!FromClassification.isRValue()) {
5095  // rvalue reference cannot bind to an lvalue
5097  ImplicitParamType);
5098  return ICS;
5099  }
5100  break;
5101  }
5102 
5103  // Success. Mark this as a reference binding.
5104  ICS.setStandard();
5106  ICS.Standard.Second = SecondKind;
5107  ICS.Standard.setFromType(FromType);
5108  ICS.Standard.setAllToTypes(ImplicitParamType);
5109  ICS.Standard.ReferenceBinding = true;
5110  ICS.Standard.DirectBinding = true;
5112  ICS.Standard.BindsToFunctionLvalue = false;
5113  ICS.Standard.BindsToRvalue = FromClassification.isRValue();
5115  = (Method->getRefQualifier() == RQ_None);
5116  return ICS;
5117 }
5118 
5119 /// PerformObjectArgumentInitialization - Perform initialization of
5120 /// the implicit object parameter for the given Method with the given
5121 /// expression.
5122 ExprResult
5124  NestedNameSpecifier *Qualifier,
5125  NamedDecl *FoundDecl,
5126  CXXMethodDecl *Method) {
5127  QualType FromRecordType, DestType;
5128  QualType ImplicitParamRecordType =
5129  Method->getThisType(Context)->getAs<PointerType>()->getPointeeType();
5130 
5131  Expr::Classification FromClassification;
5132  if (const PointerType *PT = From->getType()->getAs<PointerType>()) {
5133  FromRecordType = PT->getPointeeType();
5134  DestType = Method->getThisType(Context);
5135  FromClassification = Expr::Classification::makeSimpleLValue();
5136  } else {
5137  FromRecordType = From->getType();
5138  DestType = ImplicitParamRecordType;
5139  FromClassification = From->Classify(Context);
5140  }
5141 
5142  // Note that we always use the true parent context when performing
5143  // the actual argument initialization.
5145  *this, From->getLocStart(), From->getType(), FromClassification, Method,
5146  Method->getParent());
5147  if (ICS.isBad()) {
5149  Qualifiers FromQs = FromRecordType.getQualifiers();
5150  Qualifiers ToQs = DestType.getQualifiers();
5151  unsigned CVR = FromQs.getCVRQualifiers() & ~ToQs.getCVRQualifiers();
5152  if (CVR) {
5153  Diag(From->getLocStart(),
5154  diag::err_member_function_call_bad_cvr)
5155  << Method->getDeclName() << FromRecordType << (CVR - 1)
5156  << From->getSourceRange();
5157  Diag(Method->getLocation(), diag::note_previous_decl)
5158  << Method->getDeclName();
5159  return ExprError();
5160  }
5161  }
5162 
5163  return Diag(From->getLocStart(),
5164  diag::err_implicit_object_parameter_init)
5165  << ImplicitParamRecordType << FromRecordType << From->getSourceRange();
5166  }
5167 
5168  if (ICS.Standard.Second == ICK_Derived_To_Base) {
5169  ExprResult FromRes =
5170  PerformObjectMemberConversion(From, Qualifier, FoundDecl, Method);
5171  if (FromRes.isInvalid())
5172  return ExprError();
5173  From = FromRes.get();
5174  }
5175 
5176  if (!Context.hasSameType(From->getType(), DestType))
5177  From = ImpCastExprToType(From, DestType, CK_NoOp,
5178  From->getValueKind()).get();
5179  return From;
5180 }
5181 
5182 /// TryContextuallyConvertToBool - Attempt to contextually convert the
5183 /// expression From to bool (C++0x [conv]p3).
5186  return TryImplicitConversion(S, From, S.Context.BoolTy,
5187  /*SuppressUserConversions=*/false,
5188  /*AllowExplicit=*/true,
5189  /*InOverloadResolution=*/false,
5190  /*CStyle=*/false,
5191  /*AllowObjCWritebackConversion=*/false,
5192  /*AllowObjCConversionOnExplicit=*/false);
5193 }
5194 
5195 /// PerformContextuallyConvertToBool - Perform a contextual conversion
5196 /// of the expression From to bool (C++0x [conv]p3).
5198  if (checkPlaceholderForOverload(*this, From))
5199  return ExprError();
5200 
5202  if (!ICS.isBad())
5203  return PerformImplicitConversion(From, Context.BoolTy, ICS, AA_Converting);
5204 
5205  if (!DiagnoseMultipleUserDefinedConversion(From, Context.BoolTy))
5206  return Diag(From->getLocStart(),
5207  diag::err_typecheck_bool_condition)
5208  << From->getType() << From->getSourceRange();
5209  return ExprError();
5210 }
5211 
5212 /// Check that the specified conversion is permitted in a converted constant
5213 /// expression, according to C++11 [expr.const]p3. Return true if the conversion
5214 /// is acceptable.
5217  // Since we know that the target type is an integral or unscoped enumeration
5218  // type, most conversion kinds are impossible. All possible First and Third
5219  // conversions are fine.
5220  switch (SCS.Second) {
5221  case ICK_Identity:
5224  case ICK_Integral_Conversion: // Narrowing conversions are checked elsewhere.
5226  return true;
5227 
5229  // Conversion from an integral or unscoped enumeration type to bool is
5230  // classified as ICK_Boolean_Conversion, but it's also arguably an integral
5231  // conversion, so we allow it in a converted constant expression.
5232  //
5233  // FIXME: Per core issue 1407, we should not allow this, but that breaks
5234  // a lot of popular code. We should at least add a warning for this
5235  // (non-conforming) extension.
5237  SCS.getToType(2)->isBooleanType();
5238 
5240  case ICK_Pointer_Member:
5241  // C++1z: null pointer conversions and null member pointer conversions are
5242  // only permitted if the source type is std::nullptr_t.
5243  return SCS.getFromType()->isNullPtrType();
5244 
5246  case ICK_Complex_Promotion:
5249  case ICK_Floating_Integral:
5251  case ICK_Derived_To_Base:
5252  case ICK_Vector_Conversion:
5253  case ICK_Vector_Splat:
5254  case ICK_Complex_Real:
5259  case ICK_C_Only_Conversion:
5261  return false;
5262 
5263  case ICK_Lvalue_To_Rvalue:
5264  case ICK_Array_To_Pointer:
5266  llvm_unreachable("found a first conversion kind in Second");
5267 
5268  case ICK_Qualification:
5269  llvm_unreachable("found a third conversion kind in Second");
5270 
5272  break;
5273  }
5274 
5275  llvm_unreachable("unknown conversion kind");
5276 }
5277 
5278 /// CheckConvertedConstantExpression - Check that the expression From is a
5279 /// converted constant expression of type T, perform the conversion and produce
5280 /// the converted expression, per C++11 [expr.const]p3.
5282  QualType T, APValue &Value,
5283  Sema::CCEKind CCE,
5284  bool RequireInt) {
5285  assert(S.getLangOpts().CPlusPlus11 &&
5286  "converted constant expression outside C++11");
5287 
5288  if (checkPlaceholderForOverload(S, From))
5289  return ExprError();
5290 
5291  // C++1z [expr.const]p3:
5292  // A converted constant expression of type T is an expression,
5293  // implicitly converted to type T, where the converted
5294  // expression is a constant expression and the implicit conversion
5295  // sequence contains only [... list of conversions ...].
5296  // C++1z [stmt.if]p2:
5297  // If the if statement is of the form if constexpr, the value of the
5298  // condition shall be a contextually converted constant expression of type
5299  // bool.
5301  CCE == Sema::CCEK_ConstexprIf
5302  ? TryContextuallyConvertToBool(S, From)
5303  : TryCopyInitialization(S, From, T,
5304  /*SuppressUserConversions=*/false,
5305  /*InOverloadResolution=*/false,
5306  /*AllowObjcWritebackConversion=*/false,
5307  /*AllowExplicit=*/false);
5308  StandardConversionSequence *SCS = nullptr;
5309  switch (ICS.getKind()) {
5311  SCS = &ICS.Standard;
5312  break;
5314  // We are converting to a non-class type, so the Before sequence
5315  // must be trivial.
5316  SCS = &ICS.UserDefined.After;
5317  break;
5320  if (!S.DiagnoseMultipleUserDefinedConversion(From, T))
5321  return S.Diag(From->getLocStart(),
5322  diag::err_typecheck_converted_constant_expression)
5323  << From->getType() << From->getSourceRange() << T;
5324  return ExprError();
5325 
5327  llvm_unreachable("ellipsis conversion in converted constant expression");
5328  }
5329 
5330  // Check that we would only use permitted conversions.
5331  if (!CheckConvertedConstantConversions(S, *SCS)) {
5332  return S.Diag(From->getLocStart(),
5333  diag::err_typecheck_converted_constant_expression_disallowed)
5334  << From->getType() << From->getSourceRange() << T;
5335  }
5336  // [...] and where the reference binding (if any) binds directly.
5337  if (SCS->ReferenceBinding && !SCS->DirectBinding) {
5338  return S.Diag(From->getLocStart(),
5339  diag::err_typecheck_converted_constant_expression_indirect)
5340  << From->getType() << From->getSourceRange() << T;
5341  }
5342 
5343