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