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