62f4f18bd3a146d5f753d9ef18ab93495a64e857
[lldb.git] / clang / lib / Sema / SemaOverload.cpp
1 //===--- SemaOverload.cpp - C++ Overloading -------------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file provides Sema routines for C++ overloading.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "clang/Sema/Overload.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/CXXInheritance.h"
17 #include "clang/AST/DeclObjC.h"
18 #include "clang/AST/Expr.h"
19 #include "clang/AST/ExprCXX.h"
20 #include "clang/AST/ExprObjC.h"
21 #include "clang/AST/TypeOrdering.h"
22 #include "clang/Basic/Diagnostic.h"
23 #include "clang/Basic/DiagnosticOptions.h"
24 #include "clang/Basic/PartialDiagnostic.h"
25 #include "clang/Basic/TargetInfo.h"
26 #include "clang/Sema/Initialization.h"
27 #include "clang/Sema/Lookup.h"
28 #include "clang/Sema/SemaInternal.h"
29 #include "clang/Sema/Template.h"
30 #include "clang/Sema/TemplateDeduction.h"
31 #include "llvm/ADT/DenseSet.h"
32 #include "llvm/ADT/STLExtras.h"
33 #include "llvm/ADT/SmallPtrSet.h"
34 #include "llvm/ADT/SmallString.h"
35 #include <algorithm>
36 #include <cstdlib>
37
38 using namespace clang;
39 using namespace sema;
40
41 static bool functionHasPassObjectSizeParams(const FunctionDecl *FD) {
42   return std::any_of(FD->param_begin(), FD->param_end(),
43                      std::mem_fn(&ParmVarDecl::hasAttr<PassObjectSizeAttr>));
44 }
45
46 /// A convenience routine for creating a decayed reference to a function.
47 static ExprResult
48 CreateFunctionRefExpr(Sema &S, FunctionDecl *Fn, NamedDecl *FoundDecl,
49                       bool HadMultipleCandidates,
50                       SourceLocation Loc = SourceLocation(), 
51                       const DeclarationNameLoc &LocInfo = DeclarationNameLoc()){
52   if (S.DiagnoseUseOfDecl(FoundDecl, Loc))
53     return ExprError(); 
54   // If FoundDecl is different from Fn (such as if one is a template
55   // and the other a specialization), make sure DiagnoseUseOfDecl is 
56   // called on both.
57   // FIXME: This would be more comprehensively addressed by modifying
58   // DiagnoseUseOfDecl to accept both the FoundDecl and the decl
59   // being used.
60   if (FoundDecl != Fn && S.DiagnoseUseOfDecl(Fn, Loc))
61     return ExprError();
62   DeclRefExpr *DRE = new (S.Context) DeclRefExpr(Fn, false, Fn->getType(),
63                                                  VK_LValue, Loc, LocInfo);
64   if (HadMultipleCandidates)
65     DRE->setHadMultipleCandidates(true);
66
67   S.MarkDeclRefReferenced(DRE);
68   return S.ImpCastExprToType(DRE, S.Context.getPointerType(DRE->getType()),
69                              CK_FunctionToPointerDecay);
70 }
71
72 static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
73                                  bool InOverloadResolution,
74                                  StandardConversionSequence &SCS,
75                                  bool CStyle,
76                                  bool AllowObjCWritebackConversion);
77
78 static bool IsTransparentUnionStandardConversion(Sema &S, Expr* From, 
79                                                  QualType &ToType,
80                                                  bool InOverloadResolution,
81                                                  StandardConversionSequence &SCS,
82                                                  bool CStyle);
83 static OverloadingResult
84 IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
85                         UserDefinedConversionSequence& User,
86                         OverloadCandidateSet& Conversions,
87                         bool AllowExplicit,
88                         bool AllowObjCConversionOnExplicit);
89
90
91 static ImplicitConversionSequence::CompareKind
92 CompareStandardConversionSequences(Sema &S, SourceLocation Loc,
93                                    const StandardConversionSequence& SCS1,
94                                    const StandardConversionSequence& SCS2);
95
96 static ImplicitConversionSequence::CompareKind
97 CompareQualificationConversions(Sema &S,
98                                 const StandardConversionSequence& SCS1,
99                                 const StandardConversionSequence& SCS2);
100
101 static ImplicitConversionSequence::CompareKind
102 CompareDerivedToBaseConversions(Sema &S, SourceLocation Loc,
103                                 const StandardConversionSequence& SCS1,
104                                 const StandardConversionSequence& SCS2);
105
106 /// GetConversionRank - Retrieve the implicit conversion rank
107 /// corresponding to the given implicit conversion kind.
108 ImplicitConversionRank clang::GetConversionRank(ImplicitConversionKind Kind) {
109   static const ImplicitConversionRank
110     Rank[(int)ICK_Num_Conversion_Kinds] = {
111     ICR_Exact_Match,
112     ICR_Exact_Match,
113     ICR_Exact_Match,
114     ICR_Exact_Match,
115     ICR_Exact_Match,
116     ICR_Exact_Match,
117     ICR_Promotion,
118     ICR_Promotion,
119     ICR_Promotion,
120     ICR_Conversion,
121     ICR_Conversion,
122     ICR_Conversion,
123     ICR_Conversion,
124     ICR_Conversion,
125     ICR_Conversion,
126     ICR_Conversion,
127     ICR_Conversion,
128     ICR_Conversion,
129     ICR_Conversion,
130     ICR_Conversion,
131     ICR_Complex_Real_Conversion,
132     ICR_Conversion,
133     ICR_Conversion,
134     ICR_Writeback_Conversion,
135     ICR_Exact_Match, // NOTE(gbiv): This may not be completely right --
136                      // it was omitted by the patch that added
137                      // ICK_Zero_Event_Conversion
138     ICR_C_Conversion
139   };
140   return Rank[(int)Kind];
141 }
142
143 /// GetImplicitConversionName - Return the name of this kind of
144 /// implicit conversion.
145 static const char* GetImplicitConversionName(ImplicitConversionKind Kind) {
146   static const char* const Name[(int)ICK_Num_Conversion_Kinds] = {
147     "No conversion",
148     "Lvalue-to-rvalue",
149     "Array-to-pointer",
150     "Function-to-pointer",
151     "Noreturn adjustment",
152     "Qualification",
153     "Integral promotion",
154     "Floating point promotion",
155     "Complex promotion",
156     "Integral conversion",
157     "Floating conversion",
158     "Complex conversion",
159     "Floating-integral conversion",
160     "Pointer conversion",
161     "Pointer-to-member conversion",
162     "Boolean conversion",
163     "Compatible-types conversion",
164     "Derived-to-base conversion",
165     "Vector conversion",
166     "Vector splat",
167     "Complex-real conversion",
168     "Block Pointer conversion",
169     "Transparent Union Conversion",
170     "Writeback conversion",
171     "OpenCL Zero Event Conversion",
172     "C specific type conversion"
173   };
174   return Name[Kind];
175 }
176
177 /// StandardConversionSequence - Set the standard conversion
178 /// sequence to the identity conversion.
179 void StandardConversionSequence::setAsIdentityConversion() {
180   First = ICK_Identity;
181   Second = ICK_Identity;
182   Third = ICK_Identity;
183   DeprecatedStringLiteralToCharPtr = false;
184   QualificationIncludesObjCLifetime = false;
185   ReferenceBinding = false;
186   DirectBinding = false;
187   IsLvalueReference = true;
188   BindsToFunctionLvalue = false;
189   BindsToRvalue = false;
190   BindsImplicitObjectArgumentWithoutRefQualifier = false;
191   ObjCLifetimeConversionBinding = false;
192   CopyConstructor = nullptr;
193 }
194
195 /// getRank - Retrieve the rank of this standard conversion sequence
196 /// (C++ 13.3.3.1.1p3). The rank is the largest rank of each of the
197 /// implicit conversions.
198 ImplicitConversionRank StandardConversionSequence::getRank() const {
199   ImplicitConversionRank Rank = ICR_Exact_Match;
200   if  (GetConversionRank(First) > Rank)
201     Rank = GetConversionRank(First);
202   if  (GetConversionRank(Second) > Rank)
203     Rank = GetConversionRank(Second);
204   if  (GetConversionRank(Third) > Rank)
205     Rank = GetConversionRank(Third);
206   return Rank;
207 }
208
209 /// isPointerConversionToBool - Determines whether this conversion is
210 /// a conversion of a pointer or pointer-to-member to bool. This is
211 /// used as part of the ranking of standard conversion sequences
212 /// (C++ 13.3.3.2p4).
213 bool StandardConversionSequence::isPointerConversionToBool() const {
214   // Note that FromType has not necessarily been transformed by the
215   // array-to-pointer or function-to-pointer implicit conversions, so
216   // check for their presence as well as checking whether FromType is
217   // a pointer.
218   if (getToType(1)->isBooleanType() &&
219       (getFromType()->isPointerType() ||
220        getFromType()->isObjCObjectPointerType() ||
221        getFromType()->isBlockPointerType() ||
222        getFromType()->isNullPtrType() ||
223        First == ICK_Array_To_Pointer || First == ICK_Function_To_Pointer))
224     return true;
225
226   return false;
227 }
228
229 /// isPointerConversionToVoidPointer - Determines whether this
230 /// conversion is a conversion of a pointer to a void pointer. This is
231 /// used as part of the ranking of standard conversion sequences (C++
232 /// 13.3.3.2p4).
233 bool
234 StandardConversionSequence::
235 isPointerConversionToVoidPointer(ASTContext& Context) const {
236   QualType FromType = getFromType();
237   QualType ToType = getToType(1);
238
239   // Note that FromType has not necessarily been transformed by the
240   // array-to-pointer implicit conversion, so check for its presence
241   // and redo the conversion to get a pointer.
242   if (First == ICK_Array_To_Pointer)
243     FromType = Context.getArrayDecayedType(FromType);
244
245   if (Second == ICK_Pointer_Conversion && FromType->isAnyPointerType())
246     if (const PointerType* ToPtrType = ToType->getAs<PointerType>())
247       return ToPtrType->getPointeeType()->isVoidType();
248
249   return false;
250 }
251
252 /// Skip any implicit casts which could be either part of a narrowing conversion
253 /// or after one in an implicit conversion.
254 static const Expr *IgnoreNarrowingConversion(const Expr *Converted) {
255   while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Converted)) {
256     switch (ICE->getCastKind()) {
257     case CK_NoOp:
258     case CK_IntegralCast:
259     case CK_IntegralToBoolean:
260     case CK_IntegralToFloating:
261     case CK_FloatingToIntegral:
262     case CK_FloatingToBoolean:
263     case CK_FloatingCast:
264       Converted = ICE->getSubExpr();
265       continue;
266
267     default:
268       return Converted;
269     }
270   }
271
272   return Converted;
273 }
274
275 /// Check if this standard conversion sequence represents a narrowing
276 /// conversion, according to C++11 [dcl.init.list]p7.
277 ///
278 /// \param Ctx  The AST context.
279 /// \param Converted  The result of applying this standard conversion sequence.
280 /// \param ConstantValue  If this is an NK_Constant_Narrowing conversion, the
281 ///        value of the expression prior to the narrowing conversion.
282 /// \param ConstantType  If this is an NK_Constant_Narrowing conversion, the
283 ///        type of the expression prior to the narrowing conversion.
284 NarrowingKind
285 StandardConversionSequence::getNarrowingKind(ASTContext &Ctx,
286                                              const Expr *Converted,
287                                              APValue &ConstantValue,
288                                              QualType &ConstantType) const {
289   assert(Ctx.getLangOpts().CPlusPlus && "narrowing check outside C++");
290
291   // C++11 [dcl.init.list]p7:
292   //   A narrowing conversion is an implicit conversion ...
293   QualType FromType = getToType(0);
294   QualType ToType = getToType(1);
295   switch (Second) {
296   // 'bool' is an integral type; dispatch to the right place to handle it.
297   case ICK_Boolean_Conversion:
298     if (FromType->isRealFloatingType())
299       goto FloatingIntegralConversion;
300     if (FromType->isIntegralOrUnscopedEnumerationType())
301       goto IntegralConversion;
302     // Boolean conversions can be from pointers and pointers to members
303     // [conv.bool], and those aren't considered narrowing conversions.
304     return NK_Not_Narrowing;
305
306   // -- from a floating-point type to an integer type, or
307   //
308   // -- from an integer type or unscoped enumeration type to a floating-point
309   //    type, except where the source is a constant expression and the actual
310   //    value after conversion will fit into the target type and will produce
311   //    the original value when converted back to the original type, or
312   case ICK_Floating_Integral:
313   FloatingIntegralConversion:
314     if (FromType->isRealFloatingType() && ToType->isIntegralType(Ctx)) {
315       return NK_Type_Narrowing;
316     } else if (FromType->isIntegralType(Ctx) && ToType->isRealFloatingType()) {
317       llvm::APSInt IntConstantValue;
318       const Expr *Initializer = IgnoreNarrowingConversion(Converted);
319       if (Initializer &&
320           Initializer->isIntegerConstantExpr(IntConstantValue, Ctx)) {
321         // Convert the integer to the floating type.
322         llvm::APFloat Result(Ctx.getFloatTypeSemantics(ToType));
323         Result.convertFromAPInt(IntConstantValue, IntConstantValue.isSigned(),
324                                 llvm::APFloat::rmNearestTiesToEven);
325         // And back.
326         llvm::APSInt ConvertedValue = IntConstantValue;
327         bool ignored;
328         Result.convertToInteger(ConvertedValue,
329                                 llvm::APFloat::rmTowardZero, &ignored);
330         // If the resulting value is different, this was a narrowing conversion.
331         if (IntConstantValue != ConvertedValue) {
332           ConstantValue = APValue(IntConstantValue);
333           ConstantType = Initializer->getType();
334           return NK_Constant_Narrowing;
335         }
336       } else {
337         // Variables are always narrowings.
338         return NK_Variable_Narrowing;
339       }
340     }
341     return NK_Not_Narrowing;
342
343   // -- from long double to double or float, or from double to float, except
344   //    where the source is a constant expression and the actual value after
345   //    conversion is within the range of values that can be represented (even
346   //    if it cannot be represented exactly), or
347   case ICK_Floating_Conversion:
348     if (FromType->isRealFloatingType() && ToType->isRealFloatingType() &&
349         Ctx.getFloatingTypeOrder(FromType, ToType) == 1) {
350       // FromType is larger than ToType.
351       const Expr *Initializer = IgnoreNarrowingConversion(Converted);
352       if (Initializer->isCXX11ConstantExpr(Ctx, &ConstantValue)) {
353         // Constant!
354         assert(ConstantValue.isFloat());
355         llvm::APFloat FloatVal = ConstantValue.getFloat();
356         // Convert the source value into the target type.
357         bool ignored;
358         llvm::APFloat::opStatus ConvertStatus = FloatVal.convert(
359           Ctx.getFloatTypeSemantics(ToType),
360           llvm::APFloat::rmNearestTiesToEven, &ignored);
361         // If there was no overflow, the source value is within the range of
362         // values that can be represented.
363         if (ConvertStatus & llvm::APFloat::opOverflow) {
364           ConstantType = Initializer->getType();
365           return NK_Constant_Narrowing;
366         }
367       } else {
368         return NK_Variable_Narrowing;
369       }
370     }
371     return NK_Not_Narrowing;
372
373   // -- from an integer type or unscoped enumeration type to an integer type
374   //    that cannot represent all the values of the original type, except where
375   //    the source is a constant expression and the actual value after
376   //    conversion will fit into the target type and will produce the original
377   //    value when converted back to the original type.
378   case ICK_Integral_Conversion:
379   IntegralConversion: {
380     assert(FromType->isIntegralOrUnscopedEnumerationType());
381     assert(ToType->isIntegralOrUnscopedEnumerationType());
382     const bool FromSigned = FromType->isSignedIntegerOrEnumerationType();
383     const unsigned FromWidth = Ctx.getIntWidth(FromType);
384     const bool ToSigned = ToType->isSignedIntegerOrEnumerationType();
385     const unsigned ToWidth = Ctx.getIntWidth(ToType);
386
387     if (FromWidth > ToWidth ||
388         (FromWidth == ToWidth && FromSigned != ToSigned) ||
389         (FromSigned && !ToSigned)) {
390       // Not all values of FromType can be represented in ToType.
391       llvm::APSInt InitializerValue;
392       const Expr *Initializer = IgnoreNarrowingConversion(Converted);
393       if (!Initializer->isIntegerConstantExpr(InitializerValue, Ctx)) {
394         // Such conversions on variables are always narrowing.
395         return NK_Variable_Narrowing;
396       }
397       bool Narrowing = false;
398       if (FromWidth < ToWidth) {
399         // Negative -> unsigned is narrowing. Otherwise, more bits is never
400         // narrowing.
401         if (InitializerValue.isSigned() && InitializerValue.isNegative())
402           Narrowing = true;
403       } else {
404         // Add a bit to the InitializerValue so we don't have to worry about
405         // signed vs. unsigned comparisons.
406         InitializerValue = InitializerValue.extend(
407           InitializerValue.getBitWidth() + 1);
408         // Convert the initializer to and from the target width and signed-ness.
409         llvm::APSInt ConvertedValue = InitializerValue;
410         ConvertedValue = ConvertedValue.trunc(ToWidth);
411         ConvertedValue.setIsSigned(ToSigned);
412         ConvertedValue = ConvertedValue.extend(InitializerValue.getBitWidth());
413         ConvertedValue.setIsSigned(InitializerValue.isSigned());
414         // If the result is different, this was a narrowing conversion.
415         if (ConvertedValue != InitializerValue)
416           Narrowing = true;
417       }
418       if (Narrowing) {
419         ConstantType = Initializer->getType();
420         ConstantValue = APValue(InitializerValue);
421         return NK_Constant_Narrowing;
422       }
423     }
424     return NK_Not_Narrowing;
425   }
426
427   default:
428     // Other kinds of conversions are not narrowings.
429     return NK_Not_Narrowing;
430   }
431 }
432
433 /// dump - Print this standard conversion sequence to standard
434 /// error. Useful for debugging overloading issues.
435 void StandardConversionSequence::dump() const {
436   raw_ostream &OS = llvm::errs();
437   bool PrintedSomething = false;
438   if (First != ICK_Identity) {
439     OS << GetImplicitConversionName(First);
440     PrintedSomething = true;
441   }
442
443   if (Second != ICK_Identity) {
444     if (PrintedSomething) {
445       OS << " -> ";
446     }
447     OS << GetImplicitConversionName(Second);
448
449     if (CopyConstructor) {
450       OS << " (by copy constructor)";
451     } else if (DirectBinding) {
452       OS << " (direct reference binding)";
453     } else if (ReferenceBinding) {
454       OS << " (reference binding)";
455     }
456     PrintedSomething = true;
457   }
458
459   if (Third != ICK_Identity) {
460     if (PrintedSomething) {
461       OS << " -> ";
462     }
463     OS << GetImplicitConversionName(Third);
464     PrintedSomething = true;
465   }
466
467   if (!PrintedSomething) {
468     OS << "No conversions required";
469   }
470 }
471
472 /// dump - Print this user-defined conversion sequence to standard
473 /// error. Useful for debugging overloading issues.
474 void UserDefinedConversionSequence::dump() const {
475   raw_ostream &OS = llvm::errs();
476   if (Before.First || Before.Second || Before.Third) {
477     Before.dump();
478     OS << " -> ";
479   }
480   if (ConversionFunction)
481     OS << '\'' << *ConversionFunction << '\'';
482   else
483     OS << "aggregate initialization";
484   if (After.First || After.Second || After.Third) {
485     OS << " -> ";
486     After.dump();
487   }
488 }
489
490 /// dump - Print this implicit conversion sequence to standard
491 /// error. Useful for debugging overloading issues.
492 void ImplicitConversionSequence::dump() const {
493   raw_ostream &OS = llvm::errs();
494   if (isStdInitializerListElement())
495     OS << "Worst std::initializer_list element conversion: ";
496   switch (ConversionKind) {
497   case StandardConversion:
498     OS << "Standard conversion: ";
499     Standard.dump();
500     break;
501   case UserDefinedConversion:
502     OS << "User-defined conversion: ";
503     UserDefined.dump();
504     break;
505   case EllipsisConversion:
506     OS << "Ellipsis conversion";
507     break;
508   case AmbiguousConversion:
509     OS << "Ambiguous conversion";
510     break;
511   case BadConversion:
512     OS << "Bad conversion";
513     break;
514   }
515
516   OS << "\n";
517 }
518
519 void AmbiguousConversionSequence::construct() {
520   new (&conversions()) ConversionSet();
521 }
522
523 void AmbiguousConversionSequence::destruct() {
524   conversions().~ConversionSet();
525 }
526
527 void
528 AmbiguousConversionSequence::copyFrom(const AmbiguousConversionSequence &O) {
529   FromTypePtr = O.FromTypePtr;
530   ToTypePtr = O.ToTypePtr;
531   new (&conversions()) ConversionSet(O.conversions());
532 }
533
534 namespace {
535   // Structure used by DeductionFailureInfo to store
536   // template argument information.
537   struct DFIArguments {
538     TemplateArgument FirstArg;
539     TemplateArgument SecondArg;
540   };
541   // Structure used by DeductionFailureInfo to store
542   // template parameter and template argument information.
543   struct DFIParamWithArguments : DFIArguments {
544     TemplateParameter Param;
545   };
546 }
547
548 /// \brief Convert from Sema's representation of template deduction information
549 /// to the form used in overload-candidate information.
550 DeductionFailureInfo
551 clang::MakeDeductionFailureInfo(ASTContext &Context,
552                                 Sema::TemplateDeductionResult TDK,
553                                 TemplateDeductionInfo &Info) {
554   DeductionFailureInfo Result;
555   Result.Result = static_cast<unsigned>(TDK);
556   Result.HasDiagnostic = false;
557   Result.Data = nullptr;
558   switch (TDK) {
559   case Sema::TDK_Success:
560   case Sema::TDK_Invalid:
561   case Sema::TDK_InstantiationDepth:
562   case Sema::TDK_TooManyArguments:
563   case Sema::TDK_TooFewArguments:
564     break;
565
566   case Sema::TDK_Incomplete:
567   case Sema::TDK_InvalidExplicitArguments:
568     Result.Data = Info.Param.getOpaqueValue();
569     break;
570
571   case Sema::TDK_NonDeducedMismatch: {
572     // FIXME: Should allocate from normal heap so that we can free this later.
573     DFIArguments *Saved = new (Context) DFIArguments;
574     Saved->FirstArg = Info.FirstArg;
575     Saved->SecondArg = Info.SecondArg;
576     Result.Data = Saved;
577     break;
578   }
579
580   case Sema::TDK_Inconsistent:
581   case Sema::TDK_Underqualified: {
582     // FIXME: Should allocate from normal heap so that we can free this later.
583     DFIParamWithArguments *Saved = new (Context) DFIParamWithArguments;
584     Saved->Param = Info.Param;
585     Saved->FirstArg = Info.FirstArg;
586     Saved->SecondArg = Info.SecondArg;
587     Result.Data = Saved;
588     break;
589   }
590
591   case Sema::TDK_SubstitutionFailure:
592     Result.Data = Info.take();
593     if (Info.hasSFINAEDiagnostic()) {
594       PartialDiagnosticAt *Diag = new (Result.Diagnostic) PartialDiagnosticAt(
595           SourceLocation(), PartialDiagnostic::NullDiagnostic());
596       Info.takeSFINAEDiagnostic(*Diag);
597       Result.HasDiagnostic = true;
598     }
599     break;
600
601   case Sema::TDK_FailedOverloadResolution:
602     Result.Data = Info.Expression;
603     break;
604
605   case Sema::TDK_MiscellaneousDeductionFailure:
606     break;
607   }
608
609   return Result;
610 }
611
612 void DeductionFailureInfo::Destroy() {
613   switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
614   case Sema::TDK_Success:
615   case Sema::TDK_Invalid:
616   case Sema::TDK_InstantiationDepth:
617   case Sema::TDK_Incomplete:
618   case Sema::TDK_TooManyArguments:
619   case Sema::TDK_TooFewArguments:
620   case Sema::TDK_InvalidExplicitArguments:
621   case Sema::TDK_FailedOverloadResolution:
622     break;
623
624   case Sema::TDK_Inconsistent:
625   case Sema::TDK_Underqualified:
626   case Sema::TDK_NonDeducedMismatch:
627     // FIXME: Destroy the data?
628     Data = nullptr;
629     break;
630
631   case Sema::TDK_SubstitutionFailure:
632     // FIXME: Destroy the template argument list?
633     Data = nullptr;
634     if (PartialDiagnosticAt *Diag = getSFINAEDiagnostic()) {
635       Diag->~PartialDiagnosticAt();
636       HasDiagnostic = false;
637     }
638     break;
639
640   // Unhandled
641   case Sema::TDK_MiscellaneousDeductionFailure:
642     break;
643   }
644 }
645
646 PartialDiagnosticAt *DeductionFailureInfo::getSFINAEDiagnostic() {
647   if (HasDiagnostic)
648     return static_cast<PartialDiagnosticAt*>(static_cast<void*>(Diagnostic));
649   return nullptr;
650 }
651
652 TemplateParameter DeductionFailureInfo::getTemplateParameter() {
653   switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
654   case Sema::TDK_Success:
655   case Sema::TDK_Invalid:
656   case Sema::TDK_InstantiationDepth:
657   case Sema::TDK_TooManyArguments:
658   case Sema::TDK_TooFewArguments:
659   case Sema::TDK_SubstitutionFailure:
660   case Sema::TDK_NonDeducedMismatch:
661   case Sema::TDK_FailedOverloadResolution:
662     return TemplateParameter();
663
664   case Sema::TDK_Incomplete:
665   case Sema::TDK_InvalidExplicitArguments:
666     return TemplateParameter::getFromOpaqueValue(Data);
667
668   case Sema::TDK_Inconsistent:
669   case Sema::TDK_Underqualified:
670     return static_cast<DFIParamWithArguments*>(Data)->Param;
671
672   // Unhandled
673   case Sema::TDK_MiscellaneousDeductionFailure:
674     break;
675   }
676
677   return TemplateParameter();
678 }
679
680 TemplateArgumentList *DeductionFailureInfo::getTemplateArgumentList() {
681   switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
682   case Sema::TDK_Success:
683   case Sema::TDK_Invalid:
684   case Sema::TDK_InstantiationDepth:
685   case Sema::TDK_TooManyArguments:
686   case Sema::TDK_TooFewArguments:
687   case Sema::TDK_Incomplete:
688   case Sema::TDK_InvalidExplicitArguments:
689   case Sema::TDK_Inconsistent:
690   case Sema::TDK_Underqualified:
691   case Sema::TDK_NonDeducedMismatch:
692   case Sema::TDK_FailedOverloadResolution:
693     return nullptr;
694
695   case Sema::TDK_SubstitutionFailure:
696     return static_cast<TemplateArgumentList*>(Data);
697
698   // Unhandled
699   case Sema::TDK_MiscellaneousDeductionFailure:
700     break;
701   }
702
703   return nullptr;
704 }
705
706 const TemplateArgument *DeductionFailureInfo::getFirstArg() {
707   switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
708   case Sema::TDK_Success:
709   case Sema::TDK_Invalid:
710   case Sema::TDK_InstantiationDepth:
711   case Sema::TDK_Incomplete:
712   case Sema::TDK_TooManyArguments:
713   case Sema::TDK_TooFewArguments:
714   case Sema::TDK_InvalidExplicitArguments:
715   case Sema::TDK_SubstitutionFailure:
716   case Sema::TDK_FailedOverloadResolution:
717     return nullptr;
718
719   case Sema::TDK_Inconsistent:
720   case Sema::TDK_Underqualified:
721   case Sema::TDK_NonDeducedMismatch:
722     return &static_cast<DFIArguments*>(Data)->FirstArg;
723
724   // Unhandled
725   case Sema::TDK_MiscellaneousDeductionFailure:
726     break;
727   }
728
729   return nullptr;
730 }
731
732 const TemplateArgument *DeductionFailureInfo::getSecondArg() {
733   switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
734   case Sema::TDK_Success:
735   case Sema::TDK_Invalid:
736   case Sema::TDK_InstantiationDepth:
737   case Sema::TDK_Incomplete:
738   case Sema::TDK_TooManyArguments:
739   case Sema::TDK_TooFewArguments:
740   case Sema::TDK_InvalidExplicitArguments:
741   case Sema::TDK_SubstitutionFailure:
742   case Sema::TDK_FailedOverloadResolution:
743     return nullptr;
744
745   case Sema::TDK_Inconsistent:
746   case Sema::TDK_Underqualified:
747   case Sema::TDK_NonDeducedMismatch:
748     return &static_cast<DFIArguments*>(Data)->SecondArg;
749
750   // Unhandled
751   case Sema::TDK_MiscellaneousDeductionFailure:
752     break;
753   }
754
755   return nullptr;
756 }
757
758 Expr *DeductionFailureInfo::getExpr() {
759   if (static_cast<Sema::TemplateDeductionResult>(Result) ==
760         Sema::TDK_FailedOverloadResolution)
761     return static_cast<Expr*>(Data);
762
763   return nullptr;
764 }
765
766 void OverloadCandidateSet::destroyCandidates() {
767   for (iterator i = begin(), e = end(); i != e; ++i) {
768     for (unsigned ii = 0, ie = i->NumConversions; ii != ie; ++ii)
769       i->Conversions[ii].~ImplicitConversionSequence();
770     if (!i->Viable && i->FailureKind == ovl_fail_bad_deduction)
771       i->DeductionFailure.Destroy();
772   }
773 }
774
775 void OverloadCandidateSet::clear() {
776   destroyCandidates();
777   NumInlineSequences = 0;
778   Candidates.clear();
779   Functions.clear();
780 }
781
782 namespace {
783   class UnbridgedCastsSet {
784     struct Entry {
785       Expr **Addr;
786       Expr *Saved;
787     };
788     SmallVector<Entry, 2> Entries;
789     
790   public:
791     void save(Sema &S, Expr *&E) {
792       assert(E->hasPlaceholderType(BuiltinType::ARCUnbridgedCast));
793       Entry entry = { &E, E };
794       Entries.push_back(entry);
795       E = S.stripARCUnbridgedCast(E);
796     }
797
798     void restore() {
799       for (SmallVectorImpl<Entry>::iterator
800              i = Entries.begin(), e = Entries.end(); i != e; ++i) 
801         *i->Addr = i->Saved;
802     }
803   };
804 }
805
806 /// checkPlaceholderForOverload - Do any interesting placeholder-like
807 /// preprocessing on the given expression.
808 ///
809 /// \param unbridgedCasts a collection to which to add unbridged casts;
810 ///   without this, they will be immediately diagnosed as errors
811 ///
812 /// Return true on unrecoverable error.
813 static bool
814 checkPlaceholderForOverload(Sema &S, Expr *&E,
815                             UnbridgedCastsSet *unbridgedCasts = nullptr) {
816   if (const BuiltinType *placeholder =  E->getType()->getAsPlaceholderType()) {
817     // We can't handle overloaded expressions here because overload
818     // resolution might reasonably tweak them.
819     if (placeholder->getKind() == BuiltinType::Overload) return false;
820
821     // If the context potentially accepts unbridged ARC casts, strip
822     // the unbridged cast and add it to the collection for later restoration.
823     if (placeholder->getKind() == BuiltinType::ARCUnbridgedCast &&
824         unbridgedCasts) {
825       unbridgedCasts->save(S, E);
826       return false;
827     }
828
829     // Go ahead and check everything else.
830     ExprResult result = S.CheckPlaceholderExpr(E);
831     if (result.isInvalid())
832       return true;
833
834     E = result.get();
835     return false;
836   }
837
838   // Nothing to do.
839   return false;
840 }
841
842 /// checkArgPlaceholdersForOverload - Check a set of call operands for
843 /// placeholders.
844 static bool checkArgPlaceholdersForOverload(Sema &S,
845                                             MultiExprArg Args,
846                                             UnbridgedCastsSet &unbridged) {
847   for (unsigned i = 0, e = Args.size(); i != e; ++i)
848     if (checkPlaceholderForOverload(S, Args[i], &unbridged))
849       return true;
850
851   return false;
852 }
853
854 // IsOverload - Determine whether the given New declaration is an
855 // overload of the declarations in Old. This routine returns false if
856 // New and Old cannot be overloaded, e.g., if New has the same
857 // signature as some function in Old (C++ 1.3.10) or if the Old
858 // declarations aren't functions (or function templates) at all. When
859 // it does return false, MatchedDecl will point to the decl that New
860 // cannot be overloaded with.  This decl may be a UsingShadowDecl on
861 // top of the underlying declaration.
862 //
863 // Example: Given the following input:
864 //
865 //   void f(int, float); // #1
866 //   void f(int, int); // #2
867 //   int f(int, int); // #3
868 //
869 // When we process #1, there is no previous declaration of "f",
870 // so IsOverload will not be used.
871 //
872 // When we process #2, Old contains only the FunctionDecl for #1.  By
873 // comparing the parameter types, we see that #1 and #2 are overloaded
874 // (since they have different signatures), so this routine returns
875 // false; MatchedDecl is unchanged.
876 //
877 // When we process #3, Old is an overload set containing #1 and #2. We
878 // compare the signatures of #3 to #1 (they're overloaded, so we do
879 // nothing) and then #3 to #2. Since the signatures of #3 and #2 are
880 // identical (return types of functions are not part of the
881 // signature), IsOverload returns false and MatchedDecl will be set to
882 // point to the FunctionDecl for #2.
883 //
884 // 'NewIsUsingShadowDecl' indicates that 'New' is being introduced
885 // into a class by a using declaration.  The rules for whether to hide
886 // shadow declarations ignore some properties which otherwise figure
887 // into a function template's signature.
888 Sema::OverloadKind
889 Sema::CheckOverload(Scope *S, FunctionDecl *New, const LookupResult &Old,
890                     NamedDecl *&Match, bool NewIsUsingDecl) {
891   for (LookupResult::iterator I = Old.begin(), E = Old.end();
892          I != E; ++I) {
893     NamedDecl *OldD = *I;
894
895     bool OldIsUsingDecl = false;
896     if (isa<UsingShadowDecl>(OldD)) {
897       OldIsUsingDecl = true;
898
899       // We can always introduce two using declarations into the same
900       // context, even if they have identical signatures.
901       if (NewIsUsingDecl) continue;
902
903       OldD = cast<UsingShadowDecl>(OldD)->getTargetDecl();
904     }
905
906     // A using-declaration does not conflict with another declaration
907     // if one of them is hidden.
908     if ((OldIsUsingDecl || NewIsUsingDecl) && !isVisible(*I))
909       continue;
910
911     // If either declaration was introduced by a using declaration,
912     // we'll need to use slightly different rules for matching.
913     // Essentially, these rules are the normal rules, except that
914     // function templates hide function templates with different
915     // return types or template parameter lists.
916     bool UseMemberUsingDeclRules =
917       (OldIsUsingDecl || NewIsUsingDecl) && CurContext->isRecord() &&
918       !New->getFriendObjectKind();
919
920     if (FunctionDecl *OldF = OldD->getAsFunction()) {
921       if (!IsOverload(New, OldF, UseMemberUsingDeclRules)) {
922         if (UseMemberUsingDeclRules && OldIsUsingDecl) {
923           HideUsingShadowDecl(S, cast<UsingShadowDecl>(*I));
924           continue;
925         }
926
927         if (!isa<FunctionTemplateDecl>(OldD) &&
928             !shouldLinkPossiblyHiddenDecl(*I, New))
929           continue;
930
931         Match = *I;
932         return Ovl_Match;
933       }
934     } else if (isa<UsingDecl>(OldD)) {
935       // We can overload with these, which can show up when doing
936       // redeclaration checks for UsingDecls.
937       assert(Old.getLookupKind() == LookupUsingDeclName);
938     } else if (isa<TagDecl>(OldD)) {
939       // We can always overload with tags by hiding them.
940     } else if (isa<UnresolvedUsingValueDecl>(OldD)) {
941       // Optimistically assume that an unresolved using decl will
942       // overload; if it doesn't, we'll have to diagnose during
943       // template instantiation.
944     } else {
945       // (C++ 13p1):
946       //   Only function declarations can be overloaded; object and type
947       //   declarations cannot be overloaded.
948       Match = *I;
949       return Ovl_NonFunction;
950     }
951   }
952
953   return Ovl_Overload;
954 }
955
956 bool Sema::IsOverload(FunctionDecl *New, FunctionDecl *Old,
957                       bool UseUsingDeclRules) {
958   // C++ [basic.start.main]p2: This function shall not be overloaded.
959   if (New->isMain())
960     return false;
961
962   // MSVCRT user defined entry points cannot be overloaded.
963   if (New->isMSVCRTEntryPoint())
964     return false;
965
966   FunctionTemplateDecl *OldTemplate = Old->getDescribedFunctionTemplate();
967   FunctionTemplateDecl *NewTemplate = New->getDescribedFunctionTemplate();
968
969   // C++ [temp.fct]p2:
970   //   A function template can be overloaded with other function templates
971   //   and with normal (non-template) functions.
972   if ((OldTemplate == nullptr) != (NewTemplate == nullptr))
973     return true;
974
975   // Is the function New an overload of the function Old?
976   QualType OldQType = Context.getCanonicalType(Old->getType());
977   QualType NewQType = Context.getCanonicalType(New->getType());
978
979   // Compare the signatures (C++ 1.3.10) of the two functions to
980   // determine whether they are overloads. If we find any mismatch
981   // in the signature, they are overloads.
982
983   // If either of these functions is a K&R-style function (no
984   // prototype), then we consider them to have matching signatures.
985   if (isa<FunctionNoProtoType>(OldQType.getTypePtr()) ||
986       isa<FunctionNoProtoType>(NewQType.getTypePtr()))
987     return false;
988
989   const FunctionProtoType *OldType = cast<FunctionProtoType>(OldQType);
990   const FunctionProtoType *NewType = cast<FunctionProtoType>(NewQType);
991
992   // The signature of a function includes the types of its
993   // parameters (C++ 1.3.10), which includes the presence or absence
994   // of the ellipsis; see C++ DR 357).
995   if (OldQType != NewQType &&
996       (OldType->getNumParams() != NewType->getNumParams() ||
997        OldType->isVariadic() != NewType->isVariadic() ||
998        !FunctionParamTypesAreEqual(OldType, NewType)))
999     return true;
1000
1001   // C++ [temp.over.link]p4:
1002   //   The signature of a function template consists of its function
1003   //   signature, its return type and its template parameter list. The names
1004   //   of the template parameters are significant only for establishing the
1005   //   relationship between the template parameters and the rest of the
1006   //   signature.
1007   //
1008   // We check the return type and template parameter lists for function
1009   // templates first; the remaining checks follow.
1010   //
1011   // However, we don't consider either of these when deciding whether
1012   // a member introduced by a shadow declaration is hidden.
1013   if (!UseUsingDeclRules && NewTemplate &&
1014       (!TemplateParameterListsAreEqual(NewTemplate->getTemplateParameters(),
1015                                        OldTemplate->getTemplateParameters(),
1016                                        false, TPL_TemplateMatch) ||
1017        OldType->getReturnType() != NewType->getReturnType()))
1018     return true;
1019
1020   // If the function is a class member, its signature includes the
1021   // cv-qualifiers (if any) and ref-qualifier (if any) on the function itself.
1022   //
1023   // As part of this, also check whether one of the member functions
1024   // is static, in which case they are not overloads (C++
1025   // 13.1p2). While not part of the definition of the signature,
1026   // this check is important to determine whether these functions
1027   // can be overloaded.
1028   CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old);
1029   CXXMethodDecl *NewMethod = dyn_cast<CXXMethodDecl>(New);
1030   if (OldMethod && NewMethod &&
1031       !OldMethod->isStatic() && !NewMethod->isStatic()) {
1032     if (OldMethod->getRefQualifier() != NewMethod->getRefQualifier()) {
1033       if (!UseUsingDeclRules &&
1034           (OldMethod->getRefQualifier() == RQ_None ||
1035            NewMethod->getRefQualifier() == RQ_None)) {
1036         // C++0x [over.load]p2:
1037         //   - Member function declarations with the same name and the same
1038         //     parameter-type-list as well as member function template
1039         //     declarations with the same name, the same parameter-type-list, and
1040         //     the same template parameter lists cannot be overloaded if any of
1041         //     them, but not all, have a ref-qualifier (8.3.5).
1042         Diag(NewMethod->getLocation(), diag::err_ref_qualifier_overload)
1043           << NewMethod->getRefQualifier() << OldMethod->getRefQualifier();
1044         Diag(OldMethod->getLocation(), diag::note_previous_declaration);
1045       }
1046       return true;
1047     }
1048
1049     // We may not have applied the implicit const for a constexpr member
1050     // function yet (because we haven't yet resolved whether this is a static
1051     // or non-static member function). Add it now, on the assumption that this
1052     // is a redeclaration of OldMethod.
1053     unsigned OldQuals = OldMethod->getTypeQualifiers();
1054     unsigned NewQuals = NewMethod->getTypeQualifiers();
1055     if (!getLangOpts().CPlusPlus14 && NewMethod->isConstexpr() &&
1056         !isa<CXXConstructorDecl>(NewMethod))
1057       NewQuals |= Qualifiers::Const;
1058
1059     // We do not allow overloading based off of '__restrict'.
1060     OldQuals &= ~Qualifiers::Restrict;
1061     NewQuals &= ~Qualifiers::Restrict;
1062     if (OldQuals != NewQuals)
1063       return true;
1064   }
1065
1066   // Though pass_object_size is placed on parameters and takes an argument, we
1067   // consider it to be a function-level modifier for the sake of function
1068   // identity. Either the function has one or more parameters with
1069   // pass_object_size or it doesn't.
1070   if (functionHasPassObjectSizeParams(New) !=
1071       functionHasPassObjectSizeParams(Old))
1072     return true;
1073
1074   // enable_if attributes are an order-sensitive part of the signature.
1075   for (specific_attr_iterator<EnableIfAttr>
1076          NewI = New->specific_attr_begin<EnableIfAttr>(),
1077          NewE = New->specific_attr_end<EnableIfAttr>(),
1078          OldI = Old->specific_attr_begin<EnableIfAttr>(),
1079          OldE = Old->specific_attr_end<EnableIfAttr>();
1080        NewI != NewE || OldI != OldE; ++NewI, ++OldI) {
1081     if (NewI == NewE || OldI == OldE)
1082       return true;
1083     llvm::FoldingSetNodeID NewID, OldID;
1084     NewI->getCond()->Profile(NewID, Context, true);
1085     OldI->getCond()->Profile(OldID, Context, true);
1086     if (NewID != OldID)
1087       return true;
1088   }
1089
1090   if (getLangOpts().CUDA && getLangOpts().CUDATargetOverloads) {
1091     CUDAFunctionTarget NewTarget = IdentifyCUDATarget(New),
1092                        OldTarget = IdentifyCUDATarget(Old);
1093     if (NewTarget == CFT_InvalidTarget || NewTarget == CFT_Global)
1094       return false;
1095
1096     assert((OldTarget != CFT_InvalidTarget) && "Unexpected invalid target.");
1097
1098     // Don't allow mixing of HD with other kinds. This guarantees that
1099     // we have only one viable function with this signature on any
1100     // side of CUDA compilation .
1101     if ((NewTarget == CFT_HostDevice) || (OldTarget == CFT_HostDevice))
1102       return false;
1103
1104     // Allow overloading of functions with same signature, but
1105     // different CUDA target attributes.
1106     return NewTarget != OldTarget;
1107   }
1108
1109   // The signatures match; this is not an overload.
1110   return false;
1111 }
1112
1113 /// \brief Checks availability of the function depending on the current
1114 /// function context. Inside an unavailable function, unavailability is ignored.
1115 ///
1116 /// \returns true if \arg FD is unavailable and current context is inside
1117 /// an available function, false otherwise.
1118 bool Sema::isFunctionConsideredUnavailable(FunctionDecl *FD) {
1119   return FD->isUnavailable() && !cast<Decl>(CurContext)->isUnavailable();
1120 }
1121
1122 /// \brief Tries a user-defined conversion from From to ToType.
1123 ///
1124 /// Produces an implicit conversion sequence for when a standard conversion
1125 /// is not an option. See TryImplicitConversion for more information.
1126 static ImplicitConversionSequence
1127 TryUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
1128                          bool SuppressUserConversions,
1129                          bool AllowExplicit,
1130                          bool InOverloadResolution,
1131                          bool CStyle,
1132                          bool AllowObjCWritebackConversion,
1133                          bool AllowObjCConversionOnExplicit) {
1134   ImplicitConversionSequence ICS;
1135
1136   if (SuppressUserConversions) {
1137     // We're not in the case above, so there is no conversion that
1138     // we can perform.
1139     ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1140     return ICS;
1141   }
1142
1143   // Attempt user-defined conversion.
1144   OverloadCandidateSet Conversions(From->getExprLoc(),
1145                                    OverloadCandidateSet::CSK_Normal);
1146   switch (IsUserDefinedConversion(S, From, ToType, ICS.UserDefined,
1147                                   Conversions, AllowExplicit,
1148                                   AllowObjCConversionOnExplicit)) {
1149   case OR_Success:
1150   case OR_Deleted:
1151     ICS.setUserDefined();
1152     ICS.UserDefined.Before.setAsIdentityConversion();
1153     // C++ [over.ics.user]p4:
1154     //   A conversion of an expression of class type to the same class
1155     //   type is given Exact Match rank, and a conversion of an
1156     //   expression of class type to a base class of that type is
1157     //   given Conversion rank, in spite of the fact that a copy
1158     //   constructor (i.e., a user-defined conversion function) is
1159     //   called for those cases.
1160     if (CXXConstructorDecl *Constructor
1161           = dyn_cast<CXXConstructorDecl>(ICS.UserDefined.ConversionFunction)) {
1162       QualType FromCanon
1163         = S.Context.getCanonicalType(From->getType().getUnqualifiedType());
1164       QualType ToCanon
1165         = S.Context.getCanonicalType(ToType).getUnqualifiedType();
1166       if (Constructor->isCopyConstructor() &&
1167           (FromCanon == ToCanon ||
1168            S.IsDerivedFrom(From->getLocStart(), FromCanon, ToCanon))) {
1169         // Turn this into a "standard" conversion sequence, so that it
1170         // gets ranked with standard conversion sequences.
1171         ICS.setStandard();
1172         ICS.Standard.setAsIdentityConversion();
1173         ICS.Standard.setFromType(From->getType());
1174         ICS.Standard.setAllToTypes(ToType);
1175         ICS.Standard.CopyConstructor = Constructor;
1176         if (ToCanon != FromCanon)
1177           ICS.Standard.Second = ICK_Derived_To_Base;
1178       }
1179     }
1180     break;
1181
1182   case OR_Ambiguous:
1183     ICS.setAmbiguous();
1184     ICS.Ambiguous.setFromType(From->getType());
1185     ICS.Ambiguous.setToType(ToType);
1186     for (OverloadCandidateSet::iterator Cand = Conversions.begin();
1187          Cand != Conversions.end(); ++Cand)
1188       if (Cand->Viable)
1189         ICS.Ambiguous.addConversion(Cand->Function);
1190     break;
1191
1192     // Fall through.
1193   case OR_No_Viable_Function:
1194     ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1195     break;
1196   }
1197
1198   return ICS;
1199 }
1200
1201 /// TryImplicitConversion - Attempt to perform an implicit conversion
1202 /// from the given expression (Expr) to the given type (ToType). This
1203 /// function returns an implicit conversion sequence that can be used
1204 /// to perform the initialization. Given
1205 ///
1206 ///   void f(float f);
1207 ///   void g(int i) { f(i); }
1208 ///
1209 /// this routine would produce an implicit conversion sequence to
1210 /// describe the initialization of f from i, which will be a standard
1211 /// conversion sequence containing an lvalue-to-rvalue conversion (C++
1212 /// 4.1) followed by a floating-integral conversion (C++ 4.9).
1213 //
1214 /// Note that this routine only determines how the conversion can be
1215 /// performed; it does not actually perform the conversion. As such,
1216 /// it will not produce any diagnostics if no conversion is available,
1217 /// but will instead return an implicit conversion sequence of kind
1218 /// "BadConversion".
1219 ///
1220 /// If @p SuppressUserConversions, then user-defined conversions are
1221 /// not permitted.
1222 /// If @p AllowExplicit, then explicit user-defined conversions are
1223 /// permitted.
1224 ///
1225 /// \param AllowObjCWritebackConversion Whether we allow the Objective-C
1226 /// writeback conversion, which allows __autoreleasing id* parameters to
1227 /// be initialized with __strong id* or __weak id* arguments.
1228 static ImplicitConversionSequence
1229 TryImplicitConversion(Sema &S, Expr *From, QualType ToType,
1230                       bool SuppressUserConversions,
1231                       bool AllowExplicit,
1232                       bool InOverloadResolution,
1233                       bool CStyle,
1234                       bool AllowObjCWritebackConversion,
1235                       bool AllowObjCConversionOnExplicit) {
1236   ImplicitConversionSequence ICS;
1237   if (IsStandardConversion(S, From, ToType, InOverloadResolution,
1238                            ICS.Standard, CStyle, AllowObjCWritebackConversion)){
1239     ICS.setStandard();
1240     return ICS;
1241   }
1242
1243   if (!S.getLangOpts().CPlusPlus) {
1244     ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1245     return ICS;
1246   }
1247
1248   // C++ [over.ics.user]p4:
1249   //   A conversion of an expression of class type to the same class
1250   //   type is given Exact Match rank, and a conversion of an
1251   //   expression of class type to a base class of that type is
1252   //   given Conversion rank, in spite of the fact that a copy/move
1253   //   constructor (i.e., a user-defined conversion function) is
1254   //   called for those cases.
1255   QualType FromType = From->getType();
1256   if (ToType->getAs<RecordType>() && FromType->getAs<RecordType>() &&
1257       (S.Context.hasSameUnqualifiedType(FromType, ToType) ||
1258        S.IsDerivedFrom(From->getLocStart(), FromType, ToType))) {
1259     ICS.setStandard();
1260     ICS.Standard.setAsIdentityConversion();
1261     ICS.Standard.setFromType(FromType);
1262     ICS.Standard.setAllToTypes(ToType);
1263
1264     // We don't actually check at this point whether there is a valid
1265     // copy/move constructor, since overloading just assumes that it
1266     // exists. When we actually perform initialization, we'll find the
1267     // appropriate constructor to copy the returned object, if needed.
1268     ICS.Standard.CopyConstructor = nullptr;
1269
1270     // Determine whether this is considered a derived-to-base conversion.
1271     if (!S.Context.hasSameUnqualifiedType(FromType, ToType))
1272       ICS.Standard.Second = ICK_Derived_To_Base;
1273
1274     return ICS;
1275   }
1276
1277   return TryUserDefinedConversion(S, From, ToType, SuppressUserConversions,
1278                                   AllowExplicit, InOverloadResolution, CStyle,
1279                                   AllowObjCWritebackConversion,
1280                                   AllowObjCConversionOnExplicit);
1281 }
1282
1283 ImplicitConversionSequence
1284 Sema::TryImplicitConversion(Expr *From, QualType ToType,
1285                             bool SuppressUserConversions,
1286                             bool AllowExplicit,
1287                             bool InOverloadResolution,
1288                             bool CStyle,
1289                             bool AllowObjCWritebackConversion) {
1290   return ::TryImplicitConversion(*this, From, ToType, 
1291                                  SuppressUserConversions, AllowExplicit,
1292                                  InOverloadResolution, CStyle, 
1293                                  AllowObjCWritebackConversion,
1294                                  /*AllowObjCConversionOnExplicit=*/false);
1295 }
1296
1297 /// PerformImplicitConversion - Perform an implicit conversion of the
1298 /// expression From to the type ToType. Returns the
1299 /// converted expression. Flavor is the kind of conversion we're
1300 /// performing, used in the error message. If @p AllowExplicit,
1301 /// explicit user-defined conversions are permitted.
1302 ExprResult
1303 Sema::PerformImplicitConversion(Expr *From, QualType ToType,
1304                                 AssignmentAction Action, bool AllowExplicit) {
1305   ImplicitConversionSequence ICS;
1306   return PerformImplicitConversion(From, ToType, Action, AllowExplicit, ICS);
1307 }
1308
1309 ExprResult
1310 Sema::PerformImplicitConversion(Expr *From, QualType ToType,
1311                                 AssignmentAction Action, bool AllowExplicit,
1312                                 ImplicitConversionSequence& ICS) {
1313   if (checkPlaceholderForOverload(*this, From))
1314     return ExprError();
1315
1316   // Objective-C ARC: Determine whether we will allow the writeback conversion.
1317   bool AllowObjCWritebackConversion
1318     = getLangOpts().ObjCAutoRefCount && 
1319       (Action == AA_Passing || Action == AA_Sending);
1320   if (getLangOpts().ObjC1)
1321     CheckObjCBridgeRelatedConversions(From->getLocStart(),
1322                                       ToType, From->getType(), From);
1323   ICS = ::TryImplicitConversion(*this, From, ToType,
1324                                 /*SuppressUserConversions=*/false,
1325                                 AllowExplicit,
1326                                 /*InOverloadResolution=*/false,
1327                                 /*CStyle=*/false,
1328                                 AllowObjCWritebackConversion,
1329                                 /*AllowObjCConversionOnExplicit=*/false);
1330   return PerformImplicitConversion(From, ToType, ICS, Action);
1331 }
1332
1333 /// \brief Determine whether the conversion from FromType to ToType is a valid
1334 /// conversion that strips "noreturn" off the nested function type.
1335 bool Sema::IsNoReturnConversion(QualType FromType, QualType ToType,
1336                                 QualType &ResultTy) {
1337   if (Context.hasSameUnqualifiedType(FromType, ToType))
1338     return false;
1339
1340   // Permit the conversion F(t __attribute__((noreturn))) -> F(t)
1341   // where F adds one of the following at most once:
1342   //   - a pointer
1343   //   - a member pointer
1344   //   - a block pointer
1345   CanQualType CanTo = Context.getCanonicalType(ToType);
1346   CanQualType CanFrom = Context.getCanonicalType(FromType);
1347   Type::TypeClass TyClass = CanTo->getTypeClass();
1348   if (TyClass != CanFrom->getTypeClass()) return false;
1349   if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto) {
1350     if (TyClass == Type::Pointer) {
1351       CanTo = CanTo.getAs<PointerType>()->getPointeeType();
1352       CanFrom = CanFrom.getAs<PointerType>()->getPointeeType();
1353     } else if (TyClass == Type::BlockPointer) {
1354       CanTo = CanTo.getAs<BlockPointerType>()->getPointeeType();
1355       CanFrom = CanFrom.getAs<BlockPointerType>()->getPointeeType();
1356     } else if (TyClass == Type::MemberPointer) {
1357       CanTo = CanTo.getAs<MemberPointerType>()->getPointeeType();
1358       CanFrom = CanFrom.getAs<MemberPointerType>()->getPointeeType();
1359     } else {
1360       return false;
1361     }
1362
1363     TyClass = CanTo->getTypeClass();
1364     if (TyClass != CanFrom->getTypeClass()) return false;
1365     if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto)
1366       return false;
1367   }
1368
1369   const FunctionType *FromFn = cast<FunctionType>(CanFrom);
1370   FunctionType::ExtInfo EInfo = FromFn->getExtInfo();
1371   if (!EInfo.getNoReturn()) return false;
1372
1373   FromFn = Context.adjustFunctionType(FromFn, EInfo.withNoReturn(false));
1374   assert(QualType(FromFn, 0).isCanonical());
1375   if (QualType(FromFn, 0) != CanTo) return false;
1376
1377   ResultTy = ToType;
1378   return true;
1379 }
1380
1381 /// \brief Determine whether the conversion from FromType to ToType is a valid
1382 /// vector conversion.
1383 ///
1384 /// \param ICK Will be set to the vector conversion kind, if this is a vector
1385 /// conversion.
1386 static bool IsVectorConversion(Sema &S, QualType FromType,
1387                                QualType ToType, ImplicitConversionKind &ICK) {
1388   // We need at least one of these types to be a vector type to have a vector
1389   // conversion.
1390   if (!ToType->isVectorType() && !FromType->isVectorType())
1391     return false;
1392
1393   // Identical types require no conversions.
1394   if (S.Context.hasSameUnqualifiedType(FromType, ToType))
1395     return false;
1396
1397   // There are no conversions between extended vector types, only identity.
1398   if (ToType->isExtVectorType()) {
1399     // There are no conversions between extended vector types other than the
1400     // identity conversion.
1401     if (FromType->isExtVectorType())
1402       return false;
1403
1404     // Vector splat from any arithmetic type to a vector.
1405     if (FromType->isArithmeticType()) {
1406       ICK = ICK_Vector_Splat;
1407       return true;
1408     }
1409   }
1410
1411   // We can perform the conversion between vector types in the following cases:
1412   // 1)vector types are equivalent AltiVec and GCC vector types
1413   // 2)lax vector conversions are permitted and the vector types are of the
1414   //   same size
1415   if (ToType->isVectorType() && FromType->isVectorType()) {
1416     if (S.Context.areCompatibleVectorTypes(FromType, ToType) ||
1417         S.isLaxVectorConversion(FromType, ToType)) {
1418       ICK = ICK_Vector_Conversion;
1419       return true;
1420     }
1421   }
1422
1423   return false;
1424 }
1425
1426 static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType,
1427                                 bool InOverloadResolution,
1428                                 StandardConversionSequence &SCS,
1429                                 bool CStyle);
1430
1431 /// IsStandardConversion - Determines whether there is a standard
1432 /// conversion sequence (C++ [conv], C++ [over.ics.scs]) from the
1433 /// expression From to the type ToType. Standard conversion sequences
1434 /// only consider non-class types; for conversions that involve class
1435 /// types, use TryImplicitConversion. If a conversion exists, SCS will
1436 /// contain the standard conversion sequence required to perform this
1437 /// conversion and this routine will return true. Otherwise, this
1438 /// routine will return false and the value of SCS is unspecified.
1439 static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
1440                                  bool InOverloadResolution,
1441                                  StandardConversionSequence &SCS,
1442                                  bool CStyle,
1443                                  bool AllowObjCWritebackConversion) {
1444   QualType FromType = From->getType();
1445
1446   // Standard conversions (C++ [conv])
1447   SCS.setAsIdentityConversion();
1448   SCS.IncompatibleObjC = false;
1449   SCS.setFromType(FromType);
1450   SCS.CopyConstructor = nullptr;
1451
1452   // There are no standard conversions for class types in C++, so
1453   // abort early. When overloading in C, however, we do permit them.
1454   if (S.getLangOpts().CPlusPlus &&
1455       (FromType->isRecordType() || ToType->isRecordType()))
1456     return false;
1457
1458   // The first conversion can be an lvalue-to-rvalue conversion,
1459   // array-to-pointer conversion, or function-to-pointer conversion
1460   // (C++ 4p1).
1461
1462   if (FromType == S.Context.OverloadTy) {
1463     DeclAccessPair AccessPair;
1464     if (FunctionDecl *Fn
1465           = S.ResolveAddressOfOverloadedFunction(From, ToType, false,
1466                                                  AccessPair)) {
1467       // We were able to resolve the address of the overloaded function,
1468       // so we can convert to the type of that function.
1469       FromType = Fn->getType();
1470       SCS.setFromType(FromType);
1471
1472       // we can sometimes resolve &foo<int> regardless of ToType, so check
1473       // if the type matches (identity) or we are converting to bool
1474       if (!S.Context.hasSameUnqualifiedType(
1475                       S.ExtractUnqualifiedFunctionType(ToType), FromType)) {
1476         QualType resultTy;
1477         // if the function type matches except for [[noreturn]], it's ok
1478         if (!S.IsNoReturnConversion(FromType,
1479               S.ExtractUnqualifiedFunctionType(ToType), resultTy))
1480           // otherwise, only a boolean conversion is standard   
1481           if (!ToType->isBooleanType()) 
1482             return false; 
1483       }
1484
1485       // Check if the "from" expression is taking the address of an overloaded
1486       // function and recompute the FromType accordingly. Take advantage of the
1487       // fact that non-static member functions *must* have such an address-of
1488       // expression. 
1489       CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn);
1490       if (Method && !Method->isStatic()) {
1491         assert(isa<UnaryOperator>(From->IgnoreParens()) &&
1492                "Non-unary operator on non-static member address");
1493         assert(cast<UnaryOperator>(From->IgnoreParens())->getOpcode()
1494                == UO_AddrOf &&
1495                "Non-address-of operator on non-static member address");
1496         const Type *ClassType
1497           = S.Context.getTypeDeclType(Method->getParent()).getTypePtr();
1498         FromType = S.Context.getMemberPointerType(FromType, ClassType);
1499       } else if (isa<UnaryOperator>(From->IgnoreParens())) {
1500         assert(cast<UnaryOperator>(From->IgnoreParens())->getOpcode() ==
1501                UO_AddrOf &&
1502                "Non-address-of operator for overloaded function expression");
1503         FromType = S.Context.getPointerType(FromType);
1504       }
1505
1506       // Check that we've computed the proper type after overload resolution.
1507       assert(S.Context.hasSameType(
1508         FromType,
1509         S.FixOverloadedFunctionReference(From, AccessPair, Fn)->getType()));
1510     } else {
1511       return false;
1512     }
1513   }
1514   // Lvalue-to-rvalue conversion (C++11 4.1):
1515   //   A glvalue (3.10) of a non-function, non-array type T can
1516   //   be converted to a prvalue.
1517   bool argIsLValue = From->isGLValue();
1518   if (argIsLValue &&
1519       !FromType->isFunctionType() && !FromType->isArrayType() &&
1520       S.Context.getCanonicalType(FromType) != S.Context.OverloadTy) {
1521     SCS.First = ICK_Lvalue_To_Rvalue;
1522
1523     // C11 6.3.2.1p2:
1524     //   ... if the lvalue has atomic type, the value has the non-atomic version 
1525     //   of the type of the lvalue ...
1526     if (const AtomicType *Atomic = FromType->getAs<AtomicType>())
1527       FromType = Atomic->getValueType();
1528
1529     // If T is a non-class type, the type of the rvalue is the
1530     // cv-unqualified version of T. Otherwise, the type of the rvalue
1531     // is T (C++ 4.1p1). C++ can't get here with class types; in C, we
1532     // just strip the qualifiers because they don't matter.
1533     FromType = FromType.getUnqualifiedType();
1534   } else if (FromType->isArrayType()) {
1535     // Array-to-pointer conversion (C++ 4.2)
1536     SCS.First = ICK_Array_To_Pointer;
1537
1538     // An lvalue or rvalue of type "array of N T" or "array of unknown
1539     // bound of T" can be converted to an rvalue of type "pointer to
1540     // T" (C++ 4.2p1).
1541     FromType = S.Context.getArrayDecayedType(FromType);
1542
1543     if (S.IsStringLiteralToNonConstPointerConversion(From, ToType)) {
1544       // This conversion is deprecated in C++03 (D.4)
1545       SCS.DeprecatedStringLiteralToCharPtr = true;
1546
1547       // For the purpose of ranking in overload resolution
1548       // (13.3.3.1.1), this conversion is considered an
1549       // array-to-pointer conversion followed by a qualification
1550       // conversion (4.4). (C++ 4.2p2)
1551       SCS.Second = ICK_Identity;
1552       SCS.Third = ICK_Qualification;
1553       SCS.QualificationIncludesObjCLifetime = false;
1554       SCS.setAllToTypes(FromType);
1555       return true;
1556     }
1557   } else if (FromType->isFunctionType() && argIsLValue) {
1558     // Function-to-pointer conversion (C++ 4.3).
1559     SCS.First = ICK_Function_To_Pointer;
1560
1561     if (auto *DRE = dyn_cast<DeclRefExpr>(From->IgnoreParenCasts()))
1562       if (auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl()))
1563         if (!S.checkAddressOfFunctionIsAvailable(FD))
1564           return false;
1565
1566     // An lvalue of function type T can be converted to an rvalue of
1567     // type "pointer to T." The result is a pointer to the
1568     // function. (C++ 4.3p1).
1569     FromType = S.Context.getPointerType(FromType);
1570   } else {
1571     // We don't require any conversions for the first step.
1572     SCS.First = ICK_Identity;
1573   }
1574   SCS.setToType(0, FromType);
1575
1576   // The second conversion can be an integral promotion, floating
1577   // point promotion, integral conversion, floating point conversion,
1578   // floating-integral conversion, pointer conversion,
1579   // pointer-to-member conversion, or boolean conversion (C++ 4p1).
1580   // For overloading in C, this can also be a "compatible-type"
1581   // conversion.
1582   bool IncompatibleObjC = false;
1583   ImplicitConversionKind SecondICK = ICK_Identity;
1584   if (S.Context.hasSameUnqualifiedType(FromType, ToType)) {
1585     // The unqualified versions of the types are the same: there's no
1586     // conversion to do.
1587     SCS.Second = ICK_Identity;
1588   } else if (S.IsIntegralPromotion(From, FromType, ToType)) {
1589     // Integral promotion (C++ 4.5).
1590     SCS.Second = ICK_Integral_Promotion;
1591     FromType = ToType.getUnqualifiedType();
1592   } else if (S.IsFloatingPointPromotion(FromType, ToType)) {
1593     // Floating point promotion (C++ 4.6).
1594     SCS.Second = ICK_Floating_Promotion;
1595     FromType = ToType.getUnqualifiedType();
1596   } else if (S.IsComplexPromotion(FromType, ToType)) {
1597     // Complex promotion (Clang extension)
1598     SCS.Second = ICK_Complex_Promotion;
1599     FromType = ToType.getUnqualifiedType();
1600   } else if (ToType->isBooleanType() &&
1601              (FromType->isArithmeticType() ||
1602               FromType->isAnyPointerType() ||
1603               FromType->isBlockPointerType() ||
1604               FromType->isMemberPointerType() ||
1605               FromType->isNullPtrType())) {
1606     // Boolean conversions (C++ 4.12).
1607     SCS.Second = ICK_Boolean_Conversion;
1608     FromType = S.Context.BoolTy;
1609   } else if (FromType->isIntegralOrUnscopedEnumerationType() &&
1610              ToType->isIntegralType(S.Context)) {
1611     // Integral conversions (C++ 4.7).
1612     SCS.Second = ICK_Integral_Conversion;
1613     FromType = ToType.getUnqualifiedType();
1614   } else if (FromType->isAnyComplexType() && ToType->isAnyComplexType()) {
1615     // Complex conversions (C99 6.3.1.6)
1616     SCS.Second = ICK_Complex_Conversion;
1617     FromType = ToType.getUnqualifiedType();
1618   } else if ((FromType->isAnyComplexType() && ToType->isArithmeticType()) ||
1619              (ToType->isAnyComplexType() && FromType->isArithmeticType())) {
1620     // Complex-real conversions (C99 6.3.1.7)
1621     SCS.Second = ICK_Complex_Real;
1622     FromType = ToType.getUnqualifiedType();
1623   } else if (FromType->isRealFloatingType() && ToType->isRealFloatingType()) {
1624     // Floating point conversions (C++ 4.8).
1625     SCS.Second = ICK_Floating_Conversion;
1626     FromType = ToType.getUnqualifiedType();
1627   } else if ((FromType->isRealFloatingType() &&
1628               ToType->isIntegralType(S.Context)) ||
1629              (FromType->isIntegralOrUnscopedEnumerationType() &&
1630               ToType->isRealFloatingType())) {
1631     // Floating-integral conversions (C++ 4.9).
1632     SCS.Second = ICK_Floating_Integral;
1633     FromType = ToType.getUnqualifiedType();
1634   } else if (S.IsBlockPointerConversion(FromType, ToType, FromType)) {
1635     SCS.Second = ICK_Block_Pointer_Conversion;
1636   } else if (AllowObjCWritebackConversion &&
1637              S.isObjCWritebackConversion(FromType, ToType, FromType)) {
1638     SCS.Second = ICK_Writeback_Conversion;
1639   } else if (S.IsPointerConversion(From, FromType, ToType, InOverloadResolution,
1640                                    FromType, IncompatibleObjC)) {
1641     // Pointer conversions (C++ 4.10).
1642     SCS.Second = ICK_Pointer_Conversion;
1643     SCS.IncompatibleObjC = IncompatibleObjC;
1644     FromType = FromType.getUnqualifiedType();
1645   } else if (S.IsMemberPointerConversion(From, FromType, ToType,
1646                                          InOverloadResolution, FromType)) {
1647     // Pointer to member conversions (4.11).
1648     SCS.Second = ICK_Pointer_Member;
1649   } else if (IsVectorConversion(S, FromType, ToType, SecondICK)) {
1650     SCS.Second = SecondICK;
1651     FromType = ToType.getUnqualifiedType();
1652   } else if (!S.getLangOpts().CPlusPlus &&
1653              S.Context.typesAreCompatible(ToType, FromType)) {
1654     // Compatible conversions (Clang extension for C function overloading)
1655     SCS.Second = ICK_Compatible_Conversion;
1656     FromType = ToType.getUnqualifiedType();
1657   } else if (S.IsNoReturnConversion(FromType, ToType, FromType)) {
1658     // Treat a conversion that strips "noreturn" as an identity conversion.
1659     SCS.Second = ICK_NoReturn_Adjustment;
1660   } else if (IsTransparentUnionStandardConversion(S, From, ToType,
1661                                              InOverloadResolution,
1662                                              SCS, CStyle)) {
1663     SCS.Second = ICK_TransparentUnionConversion;
1664     FromType = ToType;
1665   } else if (tryAtomicConversion(S, From, ToType, InOverloadResolution, SCS,
1666                                  CStyle)) {
1667     // tryAtomicConversion has updated the standard conversion sequence
1668     // appropriately.
1669     return true;
1670   } else if (ToType->isEventT() &&
1671              From->isIntegerConstantExpr(S.getASTContext()) &&
1672              From->EvaluateKnownConstInt(S.getASTContext()) == 0) {
1673     SCS.Second = ICK_Zero_Event_Conversion;
1674     FromType = ToType;
1675   } else {
1676     // No second conversion required.
1677     SCS.Second = ICK_Identity;
1678   }
1679   SCS.setToType(1, FromType);
1680
1681   QualType CanonFrom;
1682   QualType CanonTo;
1683   // The third conversion can be a qualification conversion (C++ 4p1).
1684   bool ObjCLifetimeConversion;
1685   if (S.IsQualificationConversion(FromType, ToType, CStyle, 
1686                                   ObjCLifetimeConversion)) {
1687     SCS.Third = ICK_Qualification;
1688     SCS.QualificationIncludesObjCLifetime = ObjCLifetimeConversion;
1689     FromType = ToType;
1690     CanonFrom = S.Context.getCanonicalType(FromType);
1691     CanonTo = S.Context.getCanonicalType(ToType);
1692   } else {
1693     // No conversion required
1694     SCS.Third = ICK_Identity;
1695
1696     // C++ [over.best.ics]p6:
1697     //   [...] Any difference in top-level cv-qualification is
1698     //   subsumed by the initialization itself and does not constitute
1699     //   a conversion. [...]
1700     CanonFrom = S.Context.getCanonicalType(FromType);
1701     CanonTo = S.Context.getCanonicalType(ToType);
1702     if (CanonFrom.getLocalUnqualifiedType()
1703                                        == CanonTo.getLocalUnqualifiedType() &&
1704         CanonFrom.getLocalQualifiers() != CanonTo.getLocalQualifiers()) {
1705       FromType = ToType;
1706       CanonFrom = CanonTo;
1707     }
1708   }
1709   SCS.setToType(2, FromType);
1710
1711   if (CanonFrom == CanonTo)
1712     return true;
1713
1714   // If we have not converted the argument type to the parameter type,
1715   // this is a bad conversion sequence, unless we're resolving an overload in C.
1716   if (S.getLangOpts().CPlusPlus || !InOverloadResolution)
1717     return false;
1718
1719   ExprResult ER = ExprResult{From};
1720   auto Conv = S.CheckSingleAssignmentConstraints(ToType, ER,
1721                                                  /*Diagnose=*/false,
1722                                                  /*DiagnoseCFAudited=*/false,
1723                                                  /*ConvertRHS=*/false);
1724   if (Conv != Sema::Compatible)
1725     return false;
1726
1727   SCS.setAllToTypes(ToType);
1728   // We need to set all three because we want this conversion to rank terribly,
1729   // and we don't know what conversions it may overlap with.
1730   SCS.First = ICK_C_Only_Conversion;
1731   SCS.Second = ICK_C_Only_Conversion;
1732   SCS.Third = ICK_C_Only_Conversion;
1733   return true;
1734 }
1735   
1736 static bool
1737 IsTransparentUnionStandardConversion(Sema &S, Expr* From, 
1738                                      QualType &ToType,
1739                                      bool InOverloadResolution,
1740                                      StandardConversionSequence &SCS,
1741                                      bool CStyle) {
1742     
1743   const RecordType *UT = ToType->getAsUnionType();
1744   if (!UT || !UT->getDecl()->hasAttr<TransparentUnionAttr>())
1745     return false;
1746   // The field to initialize within the transparent union.
1747   RecordDecl *UD = UT->getDecl();
1748   // It's compatible if the expression matches any of the fields.
1749   for (const auto *it : UD->fields()) {
1750     if (IsStandardConversion(S, From, it->getType(), InOverloadResolution, SCS,
1751                              CStyle, /*ObjCWritebackConversion=*/false)) {
1752       ToType = it->getType();
1753       return true;
1754     }
1755   }
1756   return false;
1757 }
1758
1759 /// IsIntegralPromotion - Determines whether the conversion from the
1760 /// expression From (whose potentially-adjusted type is FromType) to
1761 /// ToType is an integral promotion (C++ 4.5). If so, returns true and
1762 /// sets PromotedType to the promoted type.
1763 bool Sema::IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType) {
1764   const BuiltinType *To = ToType->getAs<BuiltinType>();
1765   // All integers are built-in.
1766   if (!To) {
1767     return false;
1768   }
1769
1770   // An rvalue of type char, signed char, unsigned char, short int, or
1771   // unsigned short int can be converted to an rvalue of type int if
1772   // int can represent all the values of the source type; otherwise,
1773   // the source rvalue can be converted to an rvalue of type unsigned
1774   // int (C++ 4.5p1).
1775   if (FromType->isPromotableIntegerType() && !FromType->isBooleanType() &&
1776       !FromType->isEnumeralType()) {
1777     if (// We can promote any signed, promotable integer type to an int
1778         (FromType->isSignedIntegerType() ||
1779          // We can promote any unsigned integer type whose size is
1780          // less than int to an int.
1781          (!FromType->isSignedIntegerType() &&
1782           Context.getTypeSize(FromType) < Context.getTypeSize(ToType)))) {
1783       return To->getKind() == BuiltinType::Int;
1784     }
1785
1786     return To->getKind() == BuiltinType::UInt;
1787   }
1788
1789   // C++11 [conv.prom]p3:
1790   //   A prvalue of an unscoped enumeration type whose underlying type is not
1791   //   fixed (7.2) can be converted to an rvalue a prvalue of the first of the
1792   //   following types that can represent all the values of the enumeration
1793   //   (i.e., the values in the range bmin to bmax as described in 7.2): int,
1794   //   unsigned int, long int, unsigned long int, long long int, or unsigned
1795   //   long long int. If none of the types in that list can represent all the
1796   //   values of the enumeration, an rvalue a prvalue of an unscoped enumeration
1797   //   type can be converted to an rvalue a prvalue of the extended integer type
1798   //   with lowest integer conversion rank (4.13) greater than the rank of long
1799   //   long in which all the values of the enumeration can be represented. If
1800   //   there are two such extended types, the signed one is chosen.
1801   // C++11 [conv.prom]p4:
1802   //   A prvalue of an unscoped enumeration type whose underlying type is fixed
1803   //   can be converted to a prvalue of its underlying type. Moreover, if
1804   //   integral promotion can be applied to its underlying type, a prvalue of an
1805   //   unscoped enumeration type whose underlying type is fixed can also be
1806   //   converted to a prvalue of the promoted underlying type.
1807   if (const EnumType *FromEnumType = FromType->getAs<EnumType>()) {
1808     // C++0x 7.2p9: Note that this implicit enum to int conversion is not
1809     // provided for a scoped enumeration.
1810     if (FromEnumType->getDecl()->isScoped())
1811       return false;
1812
1813     // We can perform an integral promotion to the underlying type of the enum,
1814     // even if that's not the promoted type. Note that the check for promoting
1815     // the underlying type is based on the type alone, and does not consider
1816     // the bitfield-ness of the actual source expression.
1817     if (FromEnumType->getDecl()->isFixed()) {
1818       QualType Underlying = FromEnumType->getDecl()->getIntegerType();
1819       return Context.hasSameUnqualifiedType(Underlying, ToType) ||
1820              IsIntegralPromotion(nullptr, Underlying, ToType);
1821     }
1822
1823     // We have already pre-calculated the promotion type, so this is trivial.
1824     if (ToType->isIntegerType() &&
1825         isCompleteType(From->getLocStart(), FromType))
1826       return Context.hasSameUnqualifiedType(
1827           ToType, FromEnumType->getDecl()->getPromotionType());
1828   }
1829
1830   // C++0x [conv.prom]p2:
1831   //   A prvalue of type char16_t, char32_t, or wchar_t (3.9.1) can be converted
1832   //   to an rvalue a prvalue of the first of the following types that can
1833   //   represent all the values of its underlying type: int, unsigned int,
1834   //   long int, unsigned long int, long long int, or unsigned long long int.
1835   //   If none of the types in that list can represent all the values of its
1836   //   underlying type, an rvalue a prvalue of type char16_t, char32_t,
1837   //   or wchar_t can be converted to an rvalue a prvalue of its underlying
1838   //   type.
1839   if (FromType->isAnyCharacterType() && !FromType->isCharType() &&
1840       ToType->isIntegerType()) {
1841     // Determine whether the type we're converting from is signed or
1842     // unsigned.
1843     bool FromIsSigned = FromType->isSignedIntegerType();
1844     uint64_t FromSize = Context.getTypeSize(FromType);
1845
1846     // The types we'll try to promote to, in the appropriate
1847     // order. Try each of these types.
1848     QualType PromoteTypes[6] = {
1849       Context.IntTy, Context.UnsignedIntTy,
1850       Context.LongTy, Context.UnsignedLongTy ,
1851       Context.LongLongTy, Context.UnsignedLongLongTy
1852     };
1853     for (int Idx = 0; Idx < 6; ++Idx) {
1854       uint64_t ToSize = Context.getTypeSize(PromoteTypes[Idx]);
1855       if (FromSize < ToSize ||
1856           (FromSize == ToSize &&
1857            FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType())) {
1858         // We found the type that we can promote to. If this is the
1859         // type we wanted, we have a promotion. Otherwise, no
1860         // promotion.
1861         return Context.hasSameUnqualifiedType(ToType, PromoteTypes[Idx]);
1862       }
1863     }
1864   }
1865
1866   // An rvalue for an integral bit-field (9.6) can be converted to an
1867   // rvalue of type int if int can represent all the values of the
1868   // bit-field; otherwise, it can be converted to unsigned int if
1869   // unsigned int can represent all the values of the bit-field. If
1870   // the bit-field is larger yet, no integral promotion applies to
1871   // it. If the bit-field has an enumerated type, it is treated as any
1872   // other value of that type for promotion purposes (C++ 4.5p3).
1873   // FIXME: We should delay checking of bit-fields until we actually perform the
1874   // conversion.
1875   if (From) {
1876     if (FieldDecl *MemberDecl = From->getSourceBitField()) {
1877       llvm::APSInt BitWidth;
1878       if (FromType->isIntegralType(Context) &&
1879           MemberDecl->getBitWidth()->isIntegerConstantExpr(BitWidth, Context)) {
1880         llvm::APSInt ToSize(BitWidth.getBitWidth(), BitWidth.isUnsigned());
1881         ToSize = Context.getTypeSize(ToType);
1882
1883         // Are we promoting to an int from a bitfield that fits in an int?
1884         if (BitWidth < ToSize ||
1885             (FromType->isSignedIntegerType() && BitWidth <= ToSize)) {
1886           return To->getKind() == BuiltinType::Int;
1887         }
1888
1889         // Are we promoting to an unsigned int from an unsigned bitfield
1890         // that fits into an unsigned int?
1891         if (FromType->isUnsignedIntegerType() && BitWidth <= ToSize) {
1892           return To->getKind() == BuiltinType::UInt;
1893         }
1894
1895         return false;
1896       }
1897     }
1898   }
1899
1900   // An rvalue of type bool can be converted to an rvalue of type int,
1901   // with false becoming zero and true becoming one (C++ 4.5p4).
1902   if (FromType->isBooleanType() && To->getKind() == BuiltinType::Int) {
1903     return true;
1904   }
1905
1906   return false;
1907 }
1908
1909 /// IsFloatingPointPromotion - Determines whether the conversion from
1910 /// FromType to ToType is a floating point promotion (C++ 4.6). If so,
1911 /// returns true and sets PromotedType to the promoted type.
1912 bool Sema::IsFloatingPointPromotion(QualType FromType, QualType ToType) {
1913   if (const BuiltinType *FromBuiltin = FromType->getAs<BuiltinType>())
1914     if (const BuiltinType *ToBuiltin = ToType->getAs<BuiltinType>()) {
1915       /// An rvalue of type float can be converted to an rvalue of type
1916       /// double. (C++ 4.6p1).
1917       if (FromBuiltin->getKind() == BuiltinType::Float &&
1918           ToBuiltin->getKind() == BuiltinType::Double)
1919         return true;
1920
1921       // C99 6.3.1.5p1:
1922       //   When a float is promoted to double or long double, or a
1923       //   double is promoted to long double [...].
1924       if (!getLangOpts().CPlusPlus &&
1925           (FromBuiltin->getKind() == BuiltinType::Float ||
1926            FromBuiltin->getKind() == BuiltinType::Double) &&
1927           (ToBuiltin->getKind() == BuiltinType::LongDouble))
1928         return true;
1929
1930       // Half can be promoted to float.
1931       if (!getLangOpts().NativeHalfType &&
1932            FromBuiltin->getKind() == BuiltinType::Half &&
1933           ToBuiltin->getKind() == BuiltinType::Float)
1934         return true;
1935     }
1936
1937   return false;
1938 }
1939
1940 /// \brief Determine if a conversion is a complex promotion.
1941 ///
1942 /// A complex promotion is defined as a complex -> complex conversion
1943 /// where the conversion between the underlying real types is a
1944 /// floating-point or integral promotion.
1945 bool Sema::IsComplexPromotion(QualType FromType, QualType ToType) {
1946   const ComplexType *FromComplex = FromType->getAs<ComplexType>();
1947   if (!FromComplex)
1948     return false;
1949
1950   const ComplexType *ToComplex = ToType->getAs<ComplexType>();
1951   if (!ToComplex)
1952     return false;
1953
1954   return IsFloatingPointPromotion(FromComplex->getElementType(),
1955                                   ToComplex->getElementType()) ||
1956     IsIntegralPromotion(nullptr, FromComplex->getElementType(),
1957                         ToComplex->getElementType());
1958 }
1959
1960 /// BuildSimilarlyQualifiedPointerType - In a pointer conversion from
1961 /// the pointer type FromPtr to a pointer to type ToPointee, with the
1962 /// same type qualifiers as FromPtr has on its pointee type. ToType,
1963 /// if non-empty, will be a pointer to ToType that may or may not have
1964 /// the right set of qualifiers on its pointee.
1965 ///
1966 static QualType
1967 BuildSimilarlyQualifiedPointerType(const Type *FromPtr,
1968                                    QualType ToPointee, QualType ToType,
1969                                    ASTContext &Context,
1970                                    bool StripObjCLifetime = false) {
1971   assert((FromPtr->getTypeClass() == Type::Pointer ||
1972           FromPtr->getTypeClass() == Type::ObjCObjectPointer) &&
1973          "Invalid similarly-qualified pointer type");
1974
1975   /// Conversions to 'id' subsume cv-qualifier conversions.
1976   if (ToType->isObjCIdType() || ToType->isObjCQualifiedIdType()) 
1977     return ToType.getUnqualifiedType();
1978
1979   QualType CanonFromPointee
1980     = Context.getCanonicalType(FromPtr->getPointeeType());
1981   QualType CanonToPointee = Context.getCanonicalType(ToPointee);
1982   Qualifiers Quals = CanonFromPointee.getQualifiers();
1983
1984   if (StripObjCLifetime)
1985     Quals.removeObjCLifetime();
1986   
1987   // Exact qualifier match -> return the pointer type we're converting to.
1988   if (CanonToPointee.getLocalQualifiers() == Quals) {
1989     // ToType is exactly what we need. Return it.
1990     if (!ToType.isNull())
1991       return ToType.getUnqualifiedType();
1992
1993     // Build a pointer to ToPointee. It has the right qualifiers
1994     // already.
1995     if (isa<ObjCObjectPointerType>(ToType))
1996       return Context.getObjCObjectPointerType(ToPointee);
1997     return Context.getPointerType(ToPointee);
1998   }
1999
2000   // Just build a canonical type that has the right qualifiers.
2001   QualType QualifiedCanonToPointee
2002     = Context.getQualifiedType(CanonToPointee.getLocalUnqualifiedType(), Quals);
2003
2004   if (isa<ObjCObjectPointerType>(ToType))
2005     return Context.getObjCObjectPointerType(QualifiedCanonToPointee);
2006   return Context.getPointerType(QualifiedCanonToPointee);
2007 }
2008
2009 static bool isNullPointerConstantForConversion(Expr *Expr,
2010                                                bool InOverloadResolution,
2011                                                ASTContext &Context) {
2012   // Handle value-dependent integral null pointer constants correctly.
2013   // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#903
2014   if (Expr->isValueDependent() && !Expr->isTypeDependent() &&
2015       Expr->getType()->isIntegerType() && !Expr->getType()->isEnumeralType())
2016     return !InOverloadResolution;
2017
2018   return Expr->isNullPointerConstant(Context,
2019                     InOverloadResolution? Expr::NPC_ValueDependentIsNotNull
2020                                         : Expr::NPC_ValueDependentIsNull);
2021 }
2022
2023 /// IsPointerConversion - Determines whether the conversion of the
2024 /// expression From, which has the (possibly adjusted) type FromType,
2025 /// can be converted to the type ToType via a pointer conversion (C++
2026 /// 4.10). If so, returns true and places the converted type (that
2027 /// might differ from ToType in its cv-qualifiers at some level) into
2028 /// ConvertedType.
2029 ///
2030 /// This routine also supports conversions to and from block pointers
2031 /// and conversions with Objective-C's 'id', 'id<protocols...>', and
2032 /// pointers to interfaces. FIXME: Once we've determined the
2033 /// appropriate overloading rules for Objective-C, we may want to
2034 /// split the Objective-C checks into a different routine; however,
2035 /// GCC seems to consider all of these conversions to be pointer
2036 /// conversions, so for now they live here. IncompatibleObjC will be
2037 /// set if the conversion is an allowed Objective-C conversion that
2038 /// should result in a warning.
2039 bool Sema::IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
2040                                bool InOverloadResolution,
2041                                QualType& ConvertedType,
2042                                bool &IncompatibleObjC) {
2043   IncompatibleObjC = false;
2044   if (isObjCPointerConversion(FromType, ToType, ConvertedType,
2045                               IncompatibleObjC))
2046     return true;
2047
2048   // Conversion from a null pointer constant to any Objective-C pointer type.
2049   if (ToType->isObjCObjectPointerType() &&
2050       isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
2051     ConvertedType = ToType;
2052     return true;
2053   }
2054
2055   // Blocks: Block pointers can be converted to void*.
2056   if (FromType->isBlockPointerType() && ToType->isPointerType() &&
2057       ToType->getAs<PointerType>()->getPointeeType()->isVoidType()) {
2058     ConvertedType = ToType;
2059     return true;
2060   }
2061   // Blocks: A null pointer constant can be converted to a block
2062   // pointer type.
2063   if (ToType->isBlockPointerType() &&
2064       isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
2065     ConvertedType = ToType;
2066     return true;
2067   }
2068
2069   // If the left-hand-side is nullptr_t, the right side can be a null
2070   // pointer constant.
2071   if (ToType->isNullPtrType() &&
2072       isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
2073     ConvertedType = ToType;
2074     return true;
2075   }
2076
2077   const PointerType* ToTypePtr = ToType->getAs<PointerType>();
2078   if (!ToTypePtr)
2079     return false;
2080
2081   // A null pointer constant can be converted to a pointer type (C++ 4.10p1).
2082   if (isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
2083     ConvertedType = ToType;
2084     return true;
2085   }
2086
2087   // Beyond this point, both types need to be pointers
2088   // , including objective-c pointers.
2089   QualType ToPointeeType = ToTypePtr->getPointeeType();
2090   if (FromType->isObjCObjectPointerType() && ToPointeeType->isVoidType() &&
2091       !getLangOpts().ObjCAutoRefCount) {
2092     ConvertedType = BuildSimilarlyQualifiedPointerType(
2093                                       FromType->getAs<ObjCObjectPointerType>(),
2094                                                        ToPointeeType,
2095                                                        ToType, Context);
2096     return true;
2097   }
2098   const PointerType *FromTypePtr = FromType->getAs<PointerType>();
2099   if (!FromTypePtr)
2100     return false;
2101
2102   QualType FromPointeeType = FromTypePtr->getPointeeType();
2103
2104   // If the unqualified pointee types are the same, this can't be a
2105   // pointer conversion, so don't do all of the work below.
2106   if (Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType))
2107     return false;
2108
2109   // An rvalue of type "pointer to cv T," where T is an object type,
2110   // can be converted to an rvalue of type "pointer to cv void" (C++
2111   // 4.10p2).
2112   if (FromPointeeType->isIncompleteOrObjectType() &&
2113       ToPointeeType->isVoidType()) {
2114     ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2115                                                        ToPointeeType,
2116                                                        ToType, Context,
2117                                                    /*StripObjCLifetime=*/true);
2118     return true;
2119   }
2120
2121   // MSVC allows implicit function to void* type conversion.
2122   if (getLangOpts().MSVCCompat && FromPointeeType->isFunctionType() &&
2123       ToPointeeType->isVoidType()) {
2124     ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2125                                                        ToPointeeType,
2126                                                        ToType, Context);
2127     return true;
2128   }
2129
2130   // When we're overloading in C, we allow a special kind of pointer
2131   // conversion for compatible-but-not-identical pointee types.
2132   if (!getLangOpts().CPlusPlus &&
2133       Context.typesAreCompatible(FromPointeeType, ToPointeeType)) {
2134     ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2135                                                        ToPointeeType,
2136                                                        ToType, Context);
2137     return true;
2138   }
2139
2140   // C++ [conv.ptr]p3:
2141   //
2142   //   An rvalue of type "pointer to cv D," where D is a class type,
2143   //   can be converted to an rvalue of type "pointer to cv B," where
2144   //   B is a base class (clause 10) of D. If B is an inaccessible
2145   //   (clause 11) or ambiguous (10.2) base class of D, a program that
2146   //   necessitates this conversion is ill-formed. The result of the
2147   //   conversion is a pointer to the base class sub-object of the
2148   //   derived class object. The null pointer value is converted to
2149   //   the null pointer value of the destination type.
2150   //
2151   // Note that we do not check for ambiguity or inaccessibility
2152   // here. That is handled by CheckPointerConversion.
2153   if (getLangOpts().CPlusPlus &&
2154       FromPointeeType->isRecordType() && ToPointeeType->isRecordType() &&
2155       !Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType) &&
2156       IsDerivedFrom(From->getLocStart(), FromPointeeType, ToPointeeType)) {
2157     ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2158                                                        ToPointeeType,
2159                                                        ToType, Context);
2160     return true;
2161   }
2162
2163   if (FromPointeeType->isVectorType() && ToPointeeType->isVectorType() &&
2164       Context.areCompatibleVectorTypes(FromPointeeType, ToPointeeType)) {
2165     ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2166                                                        ToPointeeType,
2167                                                        ToType, Context);
2168     return true;
2169   }
2170   
2171   return false;
2172 }
2173  
2174 /// \brief Adopt the given qualifiers for the given type.
2175 static QualType AdoptQualifiers(ASTContext &Context, QualType T, Qualifiers Qs){
2176   Qualifiers TQs = T.getQualifiers();
2177   
2178   // Check whether qualifiers already match.
2179   if (TQs == Qs)
2180     return T;
2181   
2182   if (Qs.compatiblyIncludes(TQs))
2183     return Context.getQualifiedType(T, Qs);
2184   
2185   return Context.getQualifiedType(T.getUnqualifiedType(), Qs);
2186 }
2187
2188 /// isObjCPointerConversion - Determines whether this is an
2189 /// Objective-C pointer conversion. Subroutine of IsPointerConversion,
2190 /// with the same arguments and return values.
2191 bool Sema::isObjCPointerConversion(QualType FromType, QualType ToType,
2192                                    QualType& ConvertedType,
2193                                    bool &IncompatibleObjC) {
2194   if (!getLangOpts().ObjC1)
2195     return false;
2196
2197   // The set of qualifiers on the type we're converting from.
2198   Qualifiers FromQualifiers = FromType.getQualifiers();
2199   
2200   // First, we handle all conversions on ObjC object pointer types.
2201   const ObjCObjectPointerType* ToObjCPtr =
2202     ToType->getAs<ObjCObjectPointerType>();
2203   const ObjCObjectPointerType *FromObjCPtr =
2204     FromType->getAs<ObjCObjectPointerType>();
2205
2206   if (ToObjCPtr && FromObjCPtr) {
2207     // If the pointee types are the same (ignoring qualifications),
2208     // then this is not a pointer conversion.
2209     if (Context.hasSameUnqualifiedType(ToObjCPtr->getPointeeType(),
2210                                        FromObjCPtr->getPointeeType()))
2211       return false;
2212
2213     // Conversion between Objective-C pointers.
2214     if (Context.canAssignObjCInterfaces(ToObjCPtr, FromObjCPtr)) {
2215       const ObjCInterfaceType* LHS = ToObjCPtr->getInterfaceType();
2216       const ObjCInterfaceType* RHS = FromObjCPtr->getInterfaceType();
2217       if (getLangOpts().CPlusPlus && LHS && RHS &&
2218           !ToObjCPtr->getPointeeType().isAtLeastAsQualifiedAs(
2219                                                 FromObjCPtr->getPointeeType()))
2220         return false;
2221       ConvertedType = BuildSimilarlyQualifiedPointerType(FromObjCPtr,
2222                                                    ToObjCPtr->getPointeeType(),
2223                                                          ToType, Context);
2224       ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2225       return true;
2226     }
2227
2228     if (Context.canAssignObjCInterfaces(FromObjCPtr, ToObjCPtr)) {
2229       // Okay: this is some kind of implicit downcast of Objective-C
2230       // interfaces, which is permitted. However, we're going to
2231       // complain about it.
2232       IncompatibleObjC = true;
2233       ConvertedType = BuildSimilarlyQualifiedPointerType(FromObjCPtr,
2234                                                    ToObjCPtr->getPointeeType(),
2235                                                          ToType, Context);
2236       ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2237       return true;
2238     }
2239   }
2240   // Beyond this point, both types need to be C pointers or block pointers.
2241   QualType ToPointeeType;
2242   if (const PointerType *ToCPtr = ToType->getAs<PointerType>())
2243     ToPointeeType = ToCPtr->getPointeeType();
2244   else if (const BlockPointerType *ToBlockPtr =
2245             ToType->getAs<BlockPointerType>()) {
2246     // Objective C++: We're able to convert from a pointer to any object
2247     // to a block pointer type.
2248     if (FromObjCPtr && FromObjCPtr->isObjCBuiltinType()) {
2249       ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2250       return true;
2251     }
2252     ToPointeeType = ToBlockPtr->getPointeeType();
2253   }
2254   else if (FromType->getAs<BlockPointerType>() &&
2255            ToObjCPtr && ToObjCPtr->isObjCBuiltinType()) {
2256     // Objective C++: We're able to convert from a block pointer type to a
2257     // pointer to any object.
2258     ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2259     return true;
2260   }
2261   else
2262     return false;
2263
2264   QualType FromPointeeType;
2265   if (const PointerType *FromCPtr = FromType->getAs<PointerType>())
2266     FromPointeeType = FromCPtr->getPointeeType();
2267   else if (const BlockPointerType *FromBlockPtr =
2268            FromType->getAs<BlockPointerType>())
2269     FromPointeeType = FromBlockPtr->getPointeeType();
2270   else
2271     return false;
2272
2273   // If we have pointers to pointers, recursively check whether this
2274   // is an Objective-C conversion.
2275   if (FromPointeeType->isPointerType() && ToPointeeType->isPointerType() &&
2276       isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType,
2277                               IncompatibleObjC)) {
2278     // We always complain about this conversion.
2279     IncompatibleObjC = true;
2280     ConvertedType = Context.getPointerType(ConvertedType);
2281     ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2282     return true;
2283   }
2284   // Allow conversion of pointee being objective-c pointer to another one;
2285   // as in I* to id.
2286   if (FromPointeeType->getAs<ObjCObjectPointerType>() &&
2287       ToPointeeType->getAs<ObjCObjectPointerType>() &&
2288       isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType,
2289                               IncompatibleObjC)) {
2290         
2291     ConvertedType = Context.getPointerType(ConvertedType);
2292     ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2293     return true;
2294   }
2295
2296   // If we have pointers to functions or blocks, check whether the only
2297   // differences in the argument and result types are in Objective-C
2298   // pointer conversions. If so, we permit the conversion (but
2299   // complain about it).
2300   const FunctionProtoType *FromFunctionType
2301     = FromPointeeType->getAs<FunctionProtoType>();
2302   const FunctionProtoType *ToFunctionType
2303     = ToPointeeType->getAs<FunctionProtoType>();
2304   if (FromFunctionType && ToFunctionType) {
2305     // If the function types are exactly the same, this isn't an
2306     // Objective-C pointer conversion.
2307     if (Context.getCanonicalType(FromPointeeType)
2308           == Context.getCanonicalType(ToPointeeType))
2309       return false;
2310
2311     // Perform the quick checks that will tell us whether these
2312     // function types are obviously different.
2313     if (FromFunctionType->getNumParams() != ToFunctionType->getNumParams() ||
2314         FromFunctionType->isVariadic() != ToFunctionType->isVariadic() ||
2315         FromFunctionType->getTypeQuals() != ToFunctionType->getTypeQuals())
2316       return false;
2317
2318     bool HasObjCConversion = false;
2319     if (Context.getCanonicalType(FromFunctionType->getReturnType()) ==
2320         Context.getCanonicalType(ToFunctionType->getReturnType())) {
2321       // Okay, the types match exactly. Nothing to do.
2322     } else if (isObjCPointerConversion(FromFunctionType->getReturnType(),
2323                                        ToFunctionType->getReturnType(),
2324                                        ConvertedType, IncompatibleObjC)) {
2325       // Okay, we have an Objective-C pointer conversion.
2326       HasObjCConversion = true;
2327     } else {
2328       // Function types are too different. Abort.
2329       return false;
2330     }
2331
2332     // Check argument types.
2333     for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumParams();
2334          ArgIdx != NumArgs; ++ArgIdx) {
2335       QualType FromArgType = FromFunctionType->getParamType(ArgIdx);
2336       QualType ToArgType = ToFunctionType->getParamType(ArgIdx);
2337       if (Context.getCanonicalType(FromArgType)
2338             == Context.getCanonicalType(ToArgType)) {
2339         // Okay, the types match exactly. Nothing to do.
2340       } else if (isObjCPointerConversion(FromArgType, ToArgType,
2341                                          ConvertedType, IncompatibleObjC)) {
2342         // Okay, we have an Objective-C pointer conversion.
2343         HasObjCConversion = true;
2344       } else {
2345         // Argument types are too different. Abort.
2346         return false;
2347       }
2348     }
2349
2350     if (HasObjCConversion) {
2351       // We had an Objective-C conversion. Allow this pointer
2352       // conversion, but complain about it.
2353       ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2354       IncompatibleObjC = true;
2355       return true;
2356     }
2357   }
2358
2359   return false;
2360 }
2361
2362 /// \brief Determine whether this is an Objective-C writeback conversion,
2363 /// used for parameter passing when performing automatic reference counting.
2364 ///
2365 /// \param FromType The type we're converting form.
2366 ///
2367 /// \param ToType The type we're converting to.
2368 ///
2369 /// \param ConvertedType The type that will be produced after applying
2370 /// this conversion.
2371 bool Sema::isObjCWritebackConversion(QualType FromType, QualType ToType,
2372                                      QualType &ConvertedType) {
2373   if (!getLangOpts().ObjCAutoRefCount || 
2374       Context.hasSameUnqualifiedType(FromType, ToType))
2375     return false;
2376   
2377   // Parameter must be a pointer to __autoreleasing (with no other qualifiers).
2378   QualType ToPointee;
2379   if (const PointerType *ToPointer = ToType->getAs<PointerType>())
2380     ToPointee = ToPointer->getPointeeType();
2381   else
2382     return false;
2383   
2384   Qualifiers ToQuals = ToPointee.getQualifiers();
2385   if (!ToPointee->isObjCLifetimeType() || 
2386       ToQuals.getObjCLifetime() != Qualifiers::OCL_Autoreleasing ||
2387       !ToQuals.withoutObjCLifetime().empty())
2388     return false;
2389   
2390   // Argument must be a pointer to __strong to __weak.
2391   QualType FromPointee;
2392   if (const PointerType *FromPointer = FromType->getAs<PointerType>())
2393     FromPointee = FromPointer->getPointeeType();
2394   else
2395     return false;
2396   
2397   Qualifiers FromQuals = FromPointee.getQualifiers();
2398   if (!FromPointee->isObjCLifetimeType() ||
2399       (FromQuals.getObjCLifetime() != Qualifiers::OCL_Strong &&
2400        FromQuals.getObjCLifetime() != Qualifiers::OCL_Weak))
2401     return false;
2402   
2403   // Make sure that we have compatible qualifiers.
2404   FromQuals.setObjCLifetime(Qualifiers::OCL_Autoreleasing);
2405   if (!ToQuals.compatiblyIncludes(FromQuals))
2406     return false;
2407   
2408   // Remove qualifiers from the pointee type we're converting from; they
2409   // aren't used in the compatibility check belong, and we'll be adding back
2410   // qualifiers (with __autoreleasing) if the compatibility check succeeds.
2411   FromPointee = FromPointee.getUnqualifiedType();
2412   
2413   // The unqualified form of the pointee types must be compatible.
2414   ToPointee = ToPointee.getUnqualifiedType();
2415   bool IncompatibleObjC;
2416   if (Context.typesAreCompatible(FromPointee, ToPointee))
2417     FromPointee = ToPointee;
2418   else if (!isObjCPointerConversion(FromPointee, ToPointee, FromPointee,
2419                                     IncompatibleObjC))
2420     return false;
2421   
2422   /// \brief Construct the type we're converting to, which is a pointer to
2423   /// __autoreleasing pointee.
2424   FromPointee = Context.getQualifiedType(FromPointee, FromQuals);
2425   ConvertedType = Context.getPointerType(FromPointee);
2426   return true;
2427 }
2428
2429 bool Sema::IsBlockPointerConversion(QualType FromType, QualType ToType,
2430                                     QualType& ConvertedType) {
2431   QualType ToPointeeType;
2432   if (const BlockPointerType *ToBlockPtr =
2433         ToType->getAs<BlockPointerType>())
2434     ToPointeeType = ToBlockPtr->getPointeeType();
2435   else
2436     return false;
2437   
2438   QualType FromPointeeType;
2439   if (const BlockPointerType *FromBlockPtr =
2440       FromType->getAs<BlockPointerType>())
2441     FromPointeeType = FromBlockPtr->getPointeeType();
2442   else
2443     return false;
2444   // We have pointer to blocks, check whether the only
2445   // differences in the argument and result types are in Objective-C
2446   // pointer conversions. If so, we permit the conversion.
2447   
2448   const FunctionProtoType *FromFunctionType
2449     = FromPointeeType->getAs<FunctionProtoType>();
2450   const FunctionProtoType *ToFunctionType
2451     = ToPointeeType->getAs<FunctionProtoType>();
2452   
2453   if (!FromFunctionType || !ToFunctionType)
2454     return false;
2455
2456   if (Context.hasSameType(FromPointeeType, ToPointeeType))
2457     return true;
2458     
2459   // Perform the quick checks that will tell us whether these
2460   // function types are obviously different.
2461   if (FromFunctionType->getNumParams() != ToFunctionType->getNumParams() ||
2462       FromFunctionType->isVariadic() != ToFunctionType->isVariadic())
2463     return false;
2464     
2465   FunctionType::ExtInfo FromEInfo = FromFunctionType->getExtInfo();
2466   FunctionType::ExtInfo ToEInfo = ToFunctionType->getExtInfo();
2467   if (FromEInfo != ToEInfo)
2468     return false;
2469
2470   bool IncompatibleObjC = false;
2471   if (Context.hasSameType(FromFunctionType->getReturnType(),
2472                           ToFunctionType->getReturnType())) {
2473     // Okay, the types match exactly. Nothing to do.
2474   } else {
2475     QualType RHS = FromFunctionType->getReturnType();
2476     QualType LHS = ToFunctionType->getReturnType();
2477     if ((!getLangOpts().CPlusPlus || !RHS->isRecordType()) &&
2478         !RHS.hasQualifiers() && LHS.hasQualifiers())
2479        LHS = LHS.getUnqualifiedType();
2480
2481      if (Context.hasSameType(RHS,LHS)) {
2482        // OK exact match.
2483      } else if (isObjCPointerConversion(RHS, LHS,
2484                                         ConvertedType, IncompatibleObjC)) {
2485      if (IncompatibleObjC)
2486        return false;
2487      // Okay, we have an Objective-C pointer conversion.
2488      }
2489      else
2490        return false;
2491    }
2492     
2493    // Check argument types.
2494    for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumParams();
2495         ArgIdx != NumArgs; ++ArgIdx) {
2496      IncompatibleObjC = false;
2497      QualType FromArgType = FromFunctionType->getParamType(ArgIdx);
2498      QualType ToArgType = ToFunctionType->getParamType(ArgIdx);
2499      if (Context.hasSameType(FromArgType, ToArgType)) {
2500        // Okay, the types match exactly. Nothing to do.
2501      } else if (isObjCPointerConversion(ToArgType, FromArgType,
2502                                         ConvertedType, IncompatibleObjC)) {
2503        if (IncompatibleObjC)
2504          return false;
2505        // Okay, we have an Objective-C pointer conversion.
2506      } else
2507        // Argument types are too different. Abort.
2508        return false;
2509    }
2510    if (LangOpts.ObjCAutoRefCount && 
2511        !Context.FunctionTypesMatchOnNSConsumedAttrs(FromFunctionType, 
2512                                                     ToFunctionType))
2513      return false;
2514    
2515    ConvertedType = ToType;
2516    return true;
2517 }
2518
2519 enum {
2520   ft_default,
2521   ft_different_class,
2522   ft_parameter_arity,
2523   ft_parameter_mismatch,
2524   ft_return_type,
2525   ft_qualifer_mismatch
2526 };
2527
2528 /// Attempts to get the FunctionProtoType from a Type. Handles
2529 /// MemberFunctionPointers properly.
2530 static const FunctionProtoType *tryGetFunctionProtoType(QualType FromType) {
2531   if (auto *FPT = FromType->getAs<FunctionProtoType>())
2532     return FPT;
2533
2534   if (auto *MPT = FromType->getAs<MemberPointerType>())
2535     return MPT->getPointeeType()->getAs<FunctionProtoType>();
2536
2537   return nullptr;
2538 }
2539
2540 /// HandleFunctionTypeMismatch - Gives diagnostic information for differeing
2541 /// function types.  Catches different number of parameter, mismatch in
2542 /// parameter types, and different return types.
2543 void Sema::HandleFunctionTypeMismatch(PartialDiagnostic &PDiag,
2544                                       QualType FromType, QualType ToType) {
2545   // If either type is not valid, include no extra info.
2546   if (FromType.isNull() || ToType.isNull()) {
2547     PDiag << ft_default;
2548     return;
2549   }
2550
2551   // Get the function type from the pointers.
2552   if (FromType->isMemberPointerType() && ToType->isMemberPointerType()) {
2553     const MemberPointerType *FromMember = FromType->getAs<MemberPointerType>(),
2554                             *ToMember = ToType->getAs<MemberPointerType>();
2555     if (!Context.hasSameType(FromMember->getClass(), ToMember->getClass())) {
2556       PDiag << ft_different_class << QualType(ToMember->getClass(), 0)
2557             << QualType(FromMember->getClass(), 0);
2558       return;
2559     }
2560     FromType = FromMember->getPointeeType();
2561     ToType = ToMember->getPointeeType();
2562   }
2563
2564   if (FromType->isPointerType())
2565     FromType = FromType->getPointeeType();
2566   if (ToType->isPointerType())
2567     ToType = ToType->getPointeeType();
2568
2569   // Remove references.
2570   FromType = FromType.getNonReferenceType();
2571   ToType = ToType.getNonReferenceType();
2572
2573   // Don't print extra info for non-specialized template functions.
2574   if (FromType->isInstantiationDependentType() &&
2575       !FromType->getAs<TemplateSpecializationType>()) {
2576     PDiag << ft_default;
2577     return;
2578   }
2579
2580   // No extra info for same types.
2581   if (Context.hasSameType(FromType, ToType)) {
2582     PDiag << ft_default;
2583     return;
2584   }
2585
2586   const FunctionProtoType *FromFunction = tryGetFunctionProtoType(FromType),
2587                           *ToFunction = tryGetFunctionProtoType(ToType);
2588
2589   // Both types need to be function types.
2590   if (!FromFunction || !ToFunction) {
2591     PDiag << ft_default;
2592     return;
2593   }
2594
2595   if (FromFunction->getNumParams() != ToFunction->getNumParams()) {
2596     PDiag << ft_parameter_arity << ToFunction->getNumParams()
2597           << FromFunction->getNumParams();
2598     return;
2599   }
2600
2601   // Handle different parameter types.
2602   unsigned ArgPos;
2603   if (!FunctionParamTypesAreEqual(FromFunction, ToFunction, &ArgPos)) {
2604     PDiag << ft_parameter_mismatch << ArgPos + 1
2605           << ToFunction->getParamType(ArgPos)
2606           << FromFunction->getParamType(ArgPos);
2607     return;
2608   }
2609
2610   // Handle different return type.
2611   if (!Context.hasSameType(FromFunction->getReturnType(),
2612                            ToFunction->getReturnType())) {
2613     PDiag << ft_return_type << ToFunction->getReturnType()
2614           << FromFunction->getReturnType();
2615     return;
2616   }
2617
2618   unsigned FromQuals = FromFunction->getTypeQuals(),
2619            ToQuals = ToFunction->getTypeQuals();
2620   if (FromQuals != ToQuals) {
2621     PDiag << ft_qualifer_mismatch << ToQuals << FromQuals;
2622     return;
2623   }
2624
2625   // Unable to find a difference, so add no extra info.
2626   PDiag << ft_default;
2627 }
2628
2629 /// FunctionParamTypesAreEqual - This routine checks two function proto types
2630 /// for equality of their argument types. Caller has already checked that
2631 /// they have same number of arguments.  If the parameters are different,
2632 /// ArgPos will have the parameter index of the first different parameter.
2633 bool Sema::FunctionParamTypesAreEqual(const FunctionProtoType *OldType,
2634                                       const FunctionProtoType *NewType,
2635                                       unsigned *ArgPos) {
2636   for (FunctionProtoType::param_type_iterator O = OldType->param_type_begin(),
2637                                               N = NewType->param_type_begin(),
2638                                               E = OldType->param_type_end();
2639        O && (O != E); ++O, ++N) {
2640     if (!Context.hasSameType(O->getUnqualifiedType(),
2641                              N->getUnqualifiedType())) {
2642       if (ArgPos)
2643         *ArgPos = O - OldType->param_type_begin();
2644       return false;
2645     }
2646   }
2647   return true;
2648 }
2649
2650 /// CheckPointerConversion - Check the pointer conversion from the
2651 /// expression From to the type ToType. This routine checks for
2652 /// ambiguous or inaccessible derived-to-base pointer
2653 /// conversions for which IsPointerConversion has already returned
2654 /// true. It returns true and produces a diagnostic if there was an
2655 /// error, or returns false otherwise.
2656 bool Sema::CheckPointerConversion(Expr *From, QualType ToType,
2657                                   CastKind &Kind,
2658                                   CXXCastPath& BasePath,
2659                                   bool IgnoreBaseAccess) {
2660   QualType FromType = From->getType();
2661   bool IsCStyleOrFunctionalCast = IgnoreBaseAccess;
2662
2663   Kind = CK_BitCast;
2664
2665   if (!IsCStyleOrFunctionalCast && !FromType->isAnyPointerType() &&
2666       From->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNotNull) ==
2667       Expr::NPCK_ZeroExpression) {
2668     if (Context.hasSameUnqualifiedType(From->getType(), Context.BoolTy))
2669       DiagRuntimeBehavior(From->getExprLoc(), From,
2670                           PDiag(diag::warn_impcast_bool_to_null_pointer)
2671                             << ToType << From->getSourceRange());
2672     else if (!isUnevaluatedContext())
2673       Diag(From->getExprLoc(), diag::warn_non_literal_null_pointer)
2674         << ToType << From->getSourceRange();
2675   }
2676   if (const PointerType *ToPtrType = ToType->getAs<PointerType>()) {
2677     if (const PointerType *FromPtrType = FromType->getAs<PointerType>()) {
2678       QualType FromPointeeType = FromPtrType->getPointeeType(),
2679                ToPointeeType   = ToPtrType->getPointeeType();
2680
2681       if (FromPointeeType->isRecordType() && ToPointeeType->isRecordType() &&
2682           !Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType)) {
2683         // We must have a derived-to-base conversion. Check an
2684         // ambiguous or inaccessible conversion.
2685         if (CheckDerivedToBaseConversion(FromPointeeType, ToPointeeType,
2686                                          From->getExprLoc(),
2687                                          From->getSourceRange(), &BasePath,
2688                                          IgnoreBaseAccess))
2689           return true;
2690
2691         // The conversion was successful.
2692         Kind = CK_DerivedToBase;
2693       }
2694
2695       if (!IsCStyleOrFunctionalCast && FromPointeeType->isFunctionType() &&
2696           ToPointeeType->isVoidType()) {
2697         assert(getLangOpts().MSVCCompat &&
2698                "this should only be possible with MSVCCompat!");
2699         Diag(From->getExprLoc(), diag::ext_ms_impcast_fn_obj)
2700             << From->getSourceRange();
2701       }
2702     }
2703   } else if (const ObjCObjectPointerType *ToPtrType =
2704                ToType->getAs<ObjCObjectPointerType>()) {
2705     if (const ObjCObjectPointerType *FromPtrType =
2706           FromType->getAs<ObjCObjectPointerType>()) {
2707       // Objective-C++ conversions are always okay.
2708       // FIXME: We should have a different class of conversions for the
2709       // Objective-C++ implicit conversions.
2710       if (FromPtrType->isObjCBuiltinType() || ToPtrType->isObjCBuiltinType())
2711         return false;
2712     } else if (FromType->isBlockPointerType()) {
2713       Kind = CK_BlockPointerToObjCPointerCast;
2714     } else {
2715       Kind = CK_CPointerToObjCPointerCast;
2716     }
2717   } else if (ToType->isBlockPointerType()) {
2718     if (!FromType->isBlockPointerType())
2719       Kind = CK_AnyPointerToBlockPointerCast;
2720   }
2721
2722   // We shouldn't fall into this case unless it's valid for other
2723   // reasons.
2724   if (From->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull))
2725     Kind = CK_NullToPointer;
2726
2727   return false;
2728 }
2729
2730 /// IsMemberPointerConversion - Determines whether the conversion of the
2731 /// expression From, which has the (possibly adjusted) type FromType, can be
2732 /// converted to the type ToType via a member pointer conversion (C++ 4.11).
2733 /// If so, returns true and places the converted type (that might differ from
2734 /// ToType in its cv-qualifiers at some level) into ConvertedType.
2735 bool Sema::IsMemberPointerConversion(Expr *From, QualType FromType,
2736                                      QualType ToType,
2737                                      bool InOverloadResolution,
2738                                      QualType &ConvertedType) {
2739   const MemberPointerType *ToTypePtr = ToType->getAs<MemberPointerType>();
2740   if (!ToTypePtr)
2741     return false;
2742
2743   // A null pointer constant can be converted to a member pointer (C++ 4.11p1)
2744   if (From->isNullPointerConstant(Context,
2745                     InOverloadResolution? Expr::NPC_ValueDependentIsNotNull
2746                                         : Expr::NPC_ValueDependentIsNull)) {
2747     ConvertedType = ToType;
2748     return true;
2749   }
2750
2751   // Otherwise, both types have to be member pointers.
2752   const MemberPointerType *FromTypePtr = FromType->getAs<MemberPointerType>();
2753   if (!FromTypePtr)
2754     return false;
2755
2756   // A pointer to member of B can be converted to a pointer to member of D,
2757   // where D is derived from B (C++ 4.11p2).
2758   QualType FromClass(FromTypePtr->getClass(), 0);
2759   QualType ToClass(ToTypePtr->getClass(), 0);
2760
2761   if (!Context.hasSameUnqualifiedType(FromClass, ToClass) &&
2762       IsDerivedFrom(From->getLocStart(), ToClass, FromClass)) {
2763     ConvertedType = Context.getMemberPointerType(FromTypePtr->getPointeeType(),
2764                                                  ToClass.getTypePtr());
2765     return true;
2766   }
2767
2768   return false;
2769 }
2770
2771 /// CheckMemberPointerConversion - Check the member pointer conversion from the
2772 /// expression From to the type ToType. This routine checks for ambiguous or
2773 /// virtual or inaccessible base-to-derived member pointer conversions
2774 /// for which IsMemberPointerConversion has already returned true. It returns
2775 /// true and produces a diagnostic if there was an error, or returns false
2776 /// otherwise.
2777 bool Sema::CheckMemberPointerConversion(Expr *From, QualType ToType,
2778                                         CastKind &Kind,
2779                                         CXXCastPath &BasePath,
2780                                         bool IgnoreBaseAccess) {
2781   QualType FromType = From->getType();
2782   const MemberPointerType *FromPtrType = FromType->getAs<MemberPointerType>();
2783   if (!FromPtrType) {
2784     // This must be a null pointer to member pointer conversion
2785     assert(From->isNullPointerConstant(Context,
2786                                        Expr::NPC_ValueDependentIsNull) &&
2787            "Expr must be null pointer constant!");
2788     Kind = CK_NullToMemberPointer;
2789     return false;
2790   }
2791
2792   const MemberPointerType *ToPtrType = ToType->getAs<MemberPointerType>();
2793   assert(ToPtrType && "No member pointer cast has a target type "
2794                       "that is not a member pointer.");
2795
2796   QualType FromClass = QualType(FromPtrType->getClass(), 0);
2797   QualType ToClass   = QualType(ToPtrType->getClass(), 0);
2798
2799   // FIXME: What about dependent types?
2800   assert(FromClass->isRecordType() && "Pointer into non-class.");
2801   assert(ToClass->isRecordType() && "Pointer into non-class.");
2802
2803   CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
2804                      /*DetectVirtual=*/true);
2805   bool DerivationOkay =
2806       IsDerivedFrom(From->getLocStart(), ToClass, FromClass, Paths);
2807   assert(DerivationOkay &&
2808          "Should not have been called if derivation isn't OK.");
2809   (void)DerivationOkay;
2810
2811   if (Paths.isAmbiguous(Context.getCanonicalType(FromClass).
2812                                   getUnqualifiedType())) {
2813     std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
2814     Diag(From->getExprLoc(), diag::err_ambiguous_memptr_conv)
2815       << 0 << FromClass << ToClass << PathDisplayStr << From->getSourceRange();
2816     return true;
2817   }
2818
2819   if (const RecordType *VBase = Paths.getDetectedVirtual()) {
2820     Diag(From->getExprLoc(), diag::err_memptr_conv_via_virtual)
2821       << FromClass << ToClass << QualType(VBase, 0)
2822       << From->getSourceRange();
2823     return true;
2824   }
2825
2826   if (!IgnoreBaseAccess)
2827     CheckBaseClassAccess(From->getExprLoc(), FromClass, ToClass,
2828                          Paths.front(),
2829                          diag::err_downcast_from_inaccessible_base);
2830
2831   // Must be a base to derived member conversion.
2832   BuildBasePathArray(Paths, BasePath);
2833   Kind = CK_BaseToDerivedMemberPointer;
2834   return false;
2835 }
2836
2837 /// Determine whether the lifetime conversion between the two given
2838 /// qualifiers sets is nontrivial.
2839 static bool isNonTrivialObjCLifetimeConversion(Qualifiers FromQuals,
2840                                                Qualifiers ToQuals) {
2841   // Converting anything to const __unsafe_unretained is trivial.
2842   if (ToQuals.hasConst() && 
2843       ToQuals.getObjCLifetime() == Qualifiers::OCL_ExplicitNone)
2844     return false;
2845
2846   return true;
2847 }
2848
2849 /// IsQualificationConversion - Determines whether the conversion from
2850 /// an rvalue of type FromType to ToType is a qualification conversion
2851 /// (C++ 4.4).
2852 ///
2853 /// \param ObjCLifetimeConversion Output parameter that will be set to indicate
2854 /// when the qualification conversion involves a change in the Objective-C
2855 /// object lifetime.
2856 bool
2857 Sema::IsQualificationConversion(QualType FromType, QualType ToType,
2858                                 bool CStyle, bool &ObjCLifetimeConversion) {
2859   FromType = Context.getCanonicalType(FromType);
2860   ToType = Context.getCanonicalType(ToType);
2861   ObjCLifetimeConversion = false;
2862   
2863   // If FromType and ToType are the same type, this is not a
2864   // qualification conversion.
2865   if (FromType.getUnqualifiedType() == ToType.getUnqualifiedType())
2866     return false;
2867
2868   // (C++ 4.4p4):
2869   //   A conversion can add cv-qualifiers at levels other than the first
2870   //   in multi-level pointers, subject to the following rules: [...]
2871   bool PreviousToQualsIncludeConst = true;
2872   bool UnwrappedAnyPointer = false;
2873   while (Context.UnwrapSimilarPointerTypes(FromType, ToType)) {
2874     // Within each iteration of the loop, we check the qualifiers to
2875     // determine if this still looks like a qualification
2876     // conversion. Then, if all is well, we unwrap one more level of
2877     // pointers or pointers-to-members and do it all again
2878     // until there are no more pointers or pointers-to-members left to
2879     // unwrap.
2880     UnwrappedAnyPointer = true;
2881
2882     Qualifiers FromQuals = FromType.getQualifiers();
2883     Qualifiers ToQuals = ToType.getQualifiers();
2884     
2885     // Objective-C ARC:
2886     //   Check Objective-C lifetime conversions.
2887     if (FromQuals.getObjCLifetime() != ToQuals.getObjCLifetime() &&
2888         UnwrappedAnyPointer) {
2889       if (ToQuals.compatiblyIncludesObjCLifetime(FromQuals)) {
2890         if (isNonTrivialObjCLifetimeConversion(FromQuals, ToQuals))
2891           ObjCLifetimeConversion = true;
2892         FromQuals.removeObjCLifetime();
2893         ToQuals.removeObjCLifetime();
2894       } else {
2895         // Qualification conversions cannot cast between different
2896         // Objective-C lifetime qualifiers.
2897         return false;
2898       }
2899     }
2900     
2901     // Allow addition/removal of GC attributes but not changing GC attributes.
2902     if (FromQuals.getObjCGCAttr() != ToQuals.getObjCGCAttr() &&
2903         (!FromQuals.hasObjCGCAttr() || !ToQuals.hasObjCGCAttr())) {
2904       FromQuals.removeObjCGCAttr();
2905       ToQuals.removeObjCGCAttr();
2906     }
2907     
2908     //   -- for every j > 0, if const is in cv 1,j then const is in cv
2909     //      2,j, and similarly for volatile.
2910     if (!CStyle && !ToQuals.compatiblyIncludes(FromQuals))
2911       return false;
2912
2913     //   -- if the cv 1,j and cv 2,j are different, then const is in
2914     //      every cv for 0 < k < j.
2915     if (!CStyle && FromQuals.getCVRQualifiers() != ToQuals.getCVRQualifiers()
2916         && !PreviousToQualsIncludeConst)
2917       return false;
2918
2919     // Keep track of whether all prior cv-qualifiers in the "to" type
2920     // include const.
2921     PreviousToQualsIncludeConst
2922       = PreviousToQualsIncludeConst && ToQuals.hasConst();
2923   }
2924
2925   // We are left with FromType and ToType being the pointee types
2926   // after unwrapping the original FromType and ToType the same number
2927   // of types. If we unwrapped any pointers, and if FromType and
2928   // ToType have the same unqualified type (since we checked
2929   // qualifiers above), then this is a qualification conversion.
2930   return UnwrappedAnyPointer && Context.hasSameUnqualifiedType(FromType,ToType);
2931 }
2932
2933 /// \brief - Determine whether this is a conversion from a scalar type to an
2934 /// atomic type.
2935 ///
2936 /// If successful, updates \c SCS's second and third steps in the conversion
2937 /// sequence to finish the conversion.
2938 static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType,
2939                                 bool InOverloadResolution,
2940                                 StandardConversionSequence &SCS,
2941                                 bool CStyle) {
2942   const AtomicType *ToAtomic = ToType->getAs<AtomicType>();
2943   if (!ToAtomic)
2944     return false;
2945   
2946   StandardConversionSequence InnerSCS;
2947   if (!IsStandardConversion(S, From, ToAtomic->getValueType(), 
2948                             InOverloadResolution, InnerSCS,
2949                             CStyle, /*AllowObjCWritebackConversion=*/false))
2950     return false;
2951   
2952   SCS.Second = InnerSCS.Second;
2953   SCS.setToType(1, InnerSCS.getToType(1));
2954   SCS.Third = InnerSCS.Third;
2955   SCS.QualificationIncludesObjCLifetime
2956     = InnerSCS.QualificationIncludesObjCLifetime;
2957   SCS.setToType(2, InnerSCS.getToType(2));
2958   return true;
2959 }
2960
2961 static bool isFirstArgumentCompatibleWithType(ASTContext &Context,
2962                                               CXXConstructorDecl *Constructor,
2963                                               QualType Type) {
2964   const FunctionProtoType *CtorType =
2965       Constructor->getType()->getAs<FunctionProtoType>();
2966   if (CtorType->getNumParams() > 0) {
2967     QualType FirstArg = CtorType->getParamType(0);
2968     if (Context.hasSameUnqualifiedType(Type, FirstArg.getNonReferenceType()))
2969       return true;
2970   }
2971   return false;
2972 }
2973
2974 static OverloadingResult
2975 IsInitializerListConstructorConversion(Sema &S, Expr *From, QualType ToType,
2976                                        CXXRecordDecl *To,
2977                                        UserDefinedConversionSequence &User,
2978                                        OverloadCandidateSet &CandidateSet,
2979                                        bool AllowExplicit) {
2980   DeclContext::lookup_result R = S.LookupConstructors(To);
2981   for (DeclContext::lookup_iterator Con = R.begin(), ConEnd = R.end();
2982        Con != ConEnd; ++Con) {
2983     NamedDecl *D = *Con;
2984     DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
2985
2986     // Find the constructor (which may be a template).
2987     CXXConstructorDecl *Constructor = nullptr;
2988     FunctionTemplateDecl *ConstructorTmpl
2989       = dyn_cast<FunctionTemplateDecl>(D);
2990     if (ConstructorTmpl)
2991       Constructor
2992         = cast<CXXConstructorDecl>(ConstructorTmpl->getTemplatedDecl());
2993     else
2994       Constructor = cast<CXXConstructorDecl>(D);
2995
2996     bool Usable = !Constructor->isInvalidDecl() &&
2997                   S.isInitListConstructor(Constructor) &&
2998                   (AllowExplicit || !Constructor->isExplicit());
2999     if (Usable) {
3000       // If the first argument is (a reference to) the target type,
3001       // suppress conversions.
3002       bool SuppressUserConversions =
3003           isFirstArgumentCompatibleWithType(S.Context, Constructor, ToType);
3004       if (ConstructorTmpl)
3005         S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
3006                                        /*ExplicitArgs*/ nullptr,
3007                                        From, CandidateSet,
3008                                        SuppressUserConversions);
3009       else
3010         S.AddOverloadCandidate(Constructor, FoundDecl,
3011                                From, CandidateSet,
3012                                SuppressUserConversions);
3013     }
3014   }
3015
3016   bool HadMultipleCandidates = (CandidateSet.size() > 1);
3017
3018   OverloadCandidateSet::iterator Best;
3019   switch (auto Result = 
3020             CandidateSet.BestViableFunction(S, From->getLocStart(), 
3021                                             Best, true)) {
3022   case OR_Deleted:
3023   case OR_Success: {
3024     // Record the standard conversion we used and the conversion function.
3025     CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function);
3026     QualType ThisType = Constructor->getThisType(S.Context);
3027     // Initializer lists don't have conversions as such.
3028     User.Before.setAsIdentityConversion();
3029     User.HadMultipleCandidates = HadMultipleCandidates;
3030     User.ConversionFunction = Constructor;
3031     User.FoundConversionFunction = Best->FoundDecl;
3032     User.After.setAsIdentityConversion();
3033     User.After.setFromType(ThisType->getAs<PointerType>()->getPointeeType());
3034     User.After.setAllToTypes(ToType);
3035     return Result;
3036   }
3037
3038   case OR_No_Viable_Function:
3039     return OR_No_Viable_Function;
3040   case OR_Ambiguous:
3041     return OR_Ambiguous;
3042   }
3043
3044   llvm_unreachable("Invalid OverloadResult!");
3045 }
3046
3047 /// Determines whether there is a user-defined conversion sequence
3048 /// (C++ [over.ics.user]) that converts expression From to the type
3049 /// ToType. If such a conversion exists, User will contain the
3050 /// user-defined conversion sequence that performs such a conversion
3051 /// and this routine will return true. Otherwise, this routine returns
3052 /// false and User is unspecified.
3053 ///
3054 /// \param AllowExplicit  true if the conversion should consider C++0x
3055 /// "explicit" conversion functions as well as non-explicit conversion
3056 /// functions (C++0x [class.conv.fct]p2).
3057 ///
3058 /// \param AllowObjCConversionOnExplicit true if the conversion should
3059 /// allow an extra Objective-C pointer conversion on uses of explicit
3060 /// constructors. Requires \c AllowExplicit to also be set.
3061 static OverloadingResult
3062 IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
3063                         UserDefinedConversionSequence &User,
3064                         OverloadCandidateSet &CandidateSet,
3065                         bool AllowExplicit,
3066                         bool AllowObjCConversionOnExplicit) {
3067   assert(AllowExplicit || !AllowObjCConversionOnExplicit);
3068
3069   // Whether we will only visit constructors.
3070   bool ConstructorsOnly = false;
3071
3072   // If the type we are conversion to is a class type, enumerate its
3073   // constructors.
3074   if (const RecordType *ToRecordType = ToType->getAs<RecordType>()) {
3075     // C++ [over.match.ctor]p1:
3076     //   When objects of class type are direct-initialized (8.5), or
3077     //   copy-initialized from an expression of the same or a
3078     //   derived class type (8.5), overload resolution selects the
3079     //   constructor. [...] For copy-initialization, the candidate
3080     //   functions are all the converting constructors (12.3.1) of
3081     //   that class. The argument list is the expression-list within
3082     //   the parentheses of the initializer.
3083     if (S.Context.hasSameUnqualifiedType(ToType, From->getType()) ||
3084         (From->getType()->getAs<RecordType>() &&
3085          S.IsDerivedFrom(From->getLocStart(), From->getType(), ToType)))
3086       ConstructorsOnly = true;
3087
3088     if (!S.isCompleteType(From->getExprLoc(), ToType)) {
3089       // We're not going to find any constructors.
3090     } else if (CXXRecordDecl *ToRecordDecl
3091                  = dyn_cast<CXXRecordDecl>(ToRecordType->getDecl())) {
3092
3093       Expr **Args = &From;
3094       unsigned NumArgs = 1;
3095       bool ListInitializing = false;
3096       if (InitListExpr *InitList = dyn_cast<InitListExpr>(From)) {
3097         // But first, see if there is an init-list-constructor that will work.
3098         OverloadingResult Result = IsInitializerListConstructorConversion(
3099             S, From, ToType, ToRecordDecl, User, CandidateSet, AllowExplicit);
3100         if (Result != OR_No_Viable_Function)
3101           return Result;
3102         // Never mind.
3103         CandidateSet.clear();
3104
3105         // If we're list-initializing, we pass the individual elements as
3106         // arguments, not the entire list.
3107         Args = InitList->getInits();
3108         NumArgs = InitList->getNumInits();
3109         ListInitializing = true;
3110       }
3111
3112       DeclContext::lookup_result R = S.LookupConstructors(ToRecordDecl);
3113       for (DeclContext::lookup_iterator Con = R.begin(), ConEnd = R.end();
3114            Con != ConEnd; ++Con) {
3115         NamedDecl *D = *Con;
3116         DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
3117
3118         // Find the constructor (which may be a template).
3119         CXXConstructorDecl *Constructor = nullptr;
3120         FunctionTemplateDecl *ConstructorTmpl
3121           = dyn_cast<FunctionTemplateDecl>(D);
3122         if (ConstructorTmpl)
3123           Constructor
3124             = cast<CXXConstructorDecl>(ConstructorTmpl->getTemplatedDecl());
3125         else
3126           Constructor = cast<CXXConstructorDecl>(D);
3127
3128         bool Usable = !Constructor->isInvalidDecl();
3129         if (ListInitializing)
3130           Usable = Usable && (AllowExplicit || !Constructor->isExplicit());
3131         else
3132           Usable = Usable &&Constructor->isConvertingConstructor(AllowExplicit);
3133         if (Usable) {
3134           bool SuppressUserConversions = !ConstructorsOnly;
3135           if (SuppressUserConversions && ListInitializing) {
3136             SuppressUserConversions = false;
3137             if (NumArgs == 1) {
3138               // If the first argument is (a reference to) the target type,
3139               // suppress conversions.
3140               SuppressUserConversions = isFirstArgumentCompatibleWithType(
3141                                                 S.Context, Constructor, ToType);
3142             }
3143           }
3144           if (ConstructorTmpl)
3145             S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
3146                                            /*ExplicitArgs*/ nullptr,
3147                                            llvm::makeArrayRef(Args, NumArgs),
3148                                            CandidateSet, SuppressUserConversions);
3149           else
3150             // Allow one user-defined conversion when user specifies a
3151             // From->ToType conversion via an static cast (c-style, etc).
3152             S.AddOverloadCandidate(Constructor, FoundDecl,
3153                                    llvm::makeArrayRef(Args, NumArgs),
3154                                    CandidateSet, SuppressUserConversions);
3155         }
3156       }
3157     }
3158   }
3159
3160   // Enumerate conversion functions, if we're allowed to.
3161   if (ConstructorsOnly || isa<InitListExpr>(From)) {
3162   } else if (!S.isCompleteType(From->getLocStart(), From->getType())) {
3163     // No conversion functions from incomplete types.
3164   } else if (const RecordType *FromRecordType
3165                                    = From->getType()->getAs<RecordType>()) {
3166     if (CXXRecordDecl *FromRecordDecl
3167          = dyn_cast<CXXRecordDecl>(FromRecordType->getDecl())) {
3168       // Add all of the conversion functions as candidates.
3169       const auto &Conversions = FromRecordDecl->getVisibleConversionFunctions();
3170       for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
3171         DeclAccessPair FoundDecl = I.getPair();
3172         NamedDecl *D = FoundDecl.getDecl();
3173         CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext());
3174         if (isa<UsingShadowDecl>(D))
3175           D = cast<UsingShadowDecl>(D)->getTargetDecl();
3176
3177         CXXConversionDecl *Conv;
3178         FunctionTemplateDecl *ConvTemplate;
3179         if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D)))
3180           Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
3181         else
3182           Conv = cast<CXXConversionDecl>(D);
3183
3184         if (AllowExplicit || !Conv->isExplicit()) {
3185           if (ConvTemplate)
3186             S.AddTemplateConversionCandidate(ConvTemplate, FoundDecl,
3187                                              ActingContext, From, ToType,
3188                                              CandidateSet,
3189                                              AllowObjCConversionOnExplicit);
3190           else
3191             S.AddConversionCandidate(Conv, FoundDecl, ActingContext,
3192                                      From, ToType, CandidateSet,
3193                                      AllowObjCConversionOnExplicit);
3194         }
3195       }
3196     }
3197   }
3198
3199   bool HadMultipleCandidates = (CandidateSet.size() > 1);
3200
3201   OverloadCandidateSet::iterator Best;
3202   switch (auto Result = CandidateSet.BestViableFunction(S, From->getLocStart(),
3203                                                         Best, true)) {
3204   case OR_Success:
3205   case OR_Deleted:
3206     // Record the standard conversion we used and the conversion function.
3207     if (CXXConstructorDecl *Constructor
3208           = dyn_cast<CXXConstructorDecl>(Best->Function)) {
3209       // C++ [over.ics.user]p1:
3210       //   If the user-defined conversion is specified by a
3211       //   constructor (12.3.1), the initial standard conversion
3212       //   sequence converts the source type to the type required by
3213       //   the argument of the constructor.
3214       //
3215       QualType ThisType = Constructor->getThisType(S.Context);
3216       if (isa<InitListExpr>(From)) {
3217         // Initializer lists don't have conversions as such.
3218         User.Before.setAsIdentityConversion();
3219       } else {
3220         if (Best->Conversions[0].isEllipsis())
3221           User.EllipsisConversion = true;
3222         else {
3223           User.Before = Best->Conversions[0].Standard;
3224           User.EllipsisConversion = false;
3225         }
3226       }
3227       User.HadMultipleCandidates = HadMultipleCandidates;
3228       User.ConversionFunction = Constructor;
3229       User.FoundConversionFunction = Best->FoundDecl;
3230       User.After.setAsIdentityConversion();
3231       User.After.setFromType(ThisType->getAs<PointerType>()->getPointeeType());
3232       User.After.setAllToTypes(ToType);
3233       return Result;
3234     }
3235     if (CXXConversionDecl *Conversion
3236                  = dyn_cast<CXXConversionDecl>(Best->Function)) {
3237       // C++ [over.ics.user]p1:
3238       //
3239       //   [...] If the user-defined conversion is specified by a
3240       //   conversion function (12.3.2), the initial standard
3241       //   conversion sequence converts the source type to the
3242       //   implicit object parameter of the conversion function.
3243       User.Before = Best->Conversions[0].Standard;
3244       User.HadMultipleCandidates = HadMultipleCandidates;
3245       User.ConversionFunction = Conversion;
3246       User.FoundConversionFunction = Best->FoundDecl;
3247       User.EllipsisConversion = false;
3248
3249       // C++ [over.ics.user]p2:
3250       //   The second standard conversion sequence converts the
3251       //   result of the user-defined conversion to the target type
3252       //   for the sequence. Since an implicit conversion sequence
3253       //   is an initialization, the special rules for
3254       //   initialization by user-defined conversion apply when
3255       //   selecting the best user-defined conversion for a
3256       //   user-defined conversion sequence (see 13.3.3 and
3257       //   13.3.3.1).
3258       User.After = Best->FinalConversion;
3259       return Result;
3260     }
3261     llvm_unreachable("Not a constructor or conversion function?");
3262
3263   case OR_No_Viable_Function:
3264     return OR_No_Viable_Function;
3265
3266   case OR_Ambiguous:
3267     return OR_Ambiguous;
3268   }
3269
3270   llvm_unreachable("Invalid OverloadResult!");
3271 }
3272
3273 bool
3274 Sema::DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType) {
3275   ImplicitConversionSequence ICS;
3276   OverloadCandidateSet CandidateSet(From->getExprLoc(),
3277                                     OverloadCandidateSet::CSK_Normal);
3278   OverloadingResult OvResult =
3279     IsUserDefinedConversion(*this, From, ToType, ICS.UserDefined,
3280                             CandidateSet, false, false);
3281   if (OvResult == OR_Ambiguous)
3282     Diag(From->getLocStart(), diag::err_typecheck_ambiguous_condition)
3283         << From->getType() << ToType << From->getSourceRange();
3284   else if (OvResult == OR_No_Viable_Function && !CandidateSet.empty()) {
3285     if (!RequireCompleteType(From->getLocStart(), ToType,
3286                              diag::err_typecheck_nonviable_condition_incomplete,
3287                              From->getType(), From->getSourceRange()))
3288       Diag(From->getLocStart(), diag::err_typecheck_nonviable_condition)
3289           << false << From->getType() << From->getSourceRange() << ToType;
3290   } else
3291     return false;
3292   CandidateSet.NoteCandidates(*this, OCD_AllCandidates, From);
3293   return true;
3294 }
3295
3296 /// \brief Compare the user-defined conversion functions or constructors
3297 /// of two user-defined conversion sequences to determine whether any ordering
3298 /// is possible.
3299 static ImplicitConversionSequence::CompareKind
3300 compareConversionFunctions(Sema &S, FunctionDecl *Function1,
3301                            FunctionDecl *Function2) {
3302   if (!S.getLangOpts().ObjC1 || !S.getLangOpts().CPlusPlus11)
3303     return ImplicitConversionSequence::Indistinguishable;
3304
3305   // Objective-C++:
3306   //   If both conversion functions are implicitly-declared conversions from
3307   //   a lambda closure type to a function pointer and a block pointer,
3308   //   respectively, always prefer the conversion to a function pointer,
3309   //   because the function pointer is more lightweight and is more likely
3310   //   to keep code working.
3311   CXXConversionDecl *Conv1 = dyn_cast_or_null<CXXConversionDecl>(Function1);
3312   if (!Conv1)
3313     return ImplicitConversionSequence::Indistinguishable;
3314
3315   CXXConversionDecl *Conv2 = dyn_cast<CXXConversionDecl>(Function2);
3316   if (!Conv2)
3317     return ImplicitConversionSequence::Indistinguishable;
3318
3319   if (Conv1->getParent()->isLambda() && Conv2->getParent()->isLambda()) {
3320     bool Block1 = Conv1->getConversionType()->isBlockPointerType();
3321     bool Block2 = Conv2->getConversionType()->isBlockPointerType();
3322     if (Block1 != Block2)
3323       return Block1 ? ImplicitConversionSequence::Worse
3324                     : ImplicitConversionSequence::Better;
3325   }
3326
3327   return ImplicitConversionSequence::Indistinguishable;
3328 }
3329
3330 static bool hasDeprecatedStringLiteralToCharPtrConversion(
3331     const ImplicitConversionSequence &ICS) {
3332   return (ICS.isStandard() && ICS.Standard.DeprecatedStringLiteralToCharPtr) ||
3333          (ICS.isUserDefined() &&
3334           ICS.UserDefined.Before.DeprecatedStringLiteralToCharPtr);
3335 }
3336
3337 /// CompareImplicitConversionSequences - Compare two implicit
3338 /// conversion sequences to determine whether one is better than the
3339 /// other or if they are indistinguishable (C++ 13.3.3.2).
3340 static ImplicitConversionSequence::CompareKind
3341 CompareImplicitConversionSequences(Sema &S, SourceLocation Loc,
3342                                    const ImplicitConversionSequence& ICS1,
3343                                    const ImplicitConversionSequence& ICS2)
3344 {
3345   // (C++ 13.3.3.2p2): When comparing the basic forms of implicit
3346   // conversion sequences (as defined in 13.3.3.1)
3347   //   -- a standard conversion sequence (13.3.3.1.1) is a better
3348   //      conversion sequence than a user-defined conversion sequence or
3349   //      an ellipsis conversion sequence, and
3350   //   -- a user-defined conversion sequence (13.3.3.1.2) is a better
3351   //      conversion sequence than an ellipsis conversion sequence
3352   //      (13.3.3.1.3).
3353   //
3354   // C++0x [over.best.ics]p10:
3355   //   For the purpose of ranking implicit conversion sequences as
3356   //   described in 13.3.3.2, the ambiguous conversion sequence is
3357   //   treated as a user-defined sequence that is indistinguishable
3358   //   from any other user-defined conversion sequence.
3359
3360   // String literal to 'char *' conversion has been deprecated in C++03. It has
3361   // been removed from C++11. We still accept this conversion, if it happens at
3362   // the best viable function. Otherwise, this conversion is considered worse
3363   // than ellipsis conversion. Consider this as an extension; this is not in the
3364   // standard. For example:
3365   //
3366   // int &f(...);    // #1
3367   // void f(char*);  // #2
3368   // void g() { int &r = f("foo"); }
3369   //
3370   // In C++03, we pick #2 as the best viable function.
3371   // In C++11, we pick #1 as the best viable function, because ellipsis
3372   // conversion is better than string-literal to char* conversion (since there
3373   // is no such conversion in C++11). If there was no #1 at all or #1 couldn't
3374   // convert arguments, #2 would be the best viable function in C++11.
3375   // If the best viable function has this conversion, a warning will be issued
3376   // in C++03, or an ExtWarn (+SFINAE failure) will be issued in C++11.
3377
3378   if (S.getLangOpts().CPlusPlus11 && !S.getLangOpts().WritableStrings &&
3379       hasDeprecatedStringLiteralToCharPtrConversion(ICS1) !=
3380       hasDeprecatedStringLiteralToCharPtrConversion(ICS2))
3381     return hasDeprecatedStringLiteralToCharPtrConversion(ICS1)
3382                ? ImplicitConversionSequence::Worse
3383                : ImplicitConversionSequence::Better;
3384
3385   if (ICS1.getKindRank() < ICS2.getKindRank())
3386     return ImplicitConversionSequence::Better;
3387   if (ICS2.getKindRank() < ICS1.getKindRank())
3388     return ImplicitConversionSequence::Worse;
3389
3390   // The following checks require both conversion sequences to be of
3391   // the same kind.
3392   if (ICS1.getKind() != ICS2.getKind())
3393     return ImplicitConversionSequence::Indistinguishable;
3394
3395   ImplicitConversionSequence::CompareKind Result =
3396       ImplicitConversionSequence::Indistinguishable;
3397
3398   // Two implicit conversion sequences of the same form are
3399   // indistinguishable conversion sequences unless one of the
3400   // following rules apply: (C++ 13.3.3.2p3):
3401   
3402   // List-initialization sequence L1 is a better conversion sequence than
3403   // list-initialization sequence L2 if:
3404   // - L1 converts to std::initializer_list<X> for some X and L2 does not, or,
3405   //   if not that,
3406   // - L1 converts to type "array of N1 T", L2 converts to type "array of N2 T",
3407   //   and N1 is smaller than N2.,
3408   // even if one of the other rules in this paragraph would otherwise apply.
3409   if (!ICS1.isBad()) {
3410     if (ICS1.isStdInitializerListElement() &&
3411         !ICS2.isStdInitializerListElement())
3412       return ImplicitConversionSequence::Better;
3413     if (!ICS1.isStdInitializerListElement() &&
3414         ICS2.isStdInitializerListElement())
3415       return ImplicitConversionSequence::Worse;
3416   }
3417
3418   if (ICS1.isStandard())
3419     // Standard conversion sequence S1 is a better conversion sequence than
3420     // standard conversion sequence S2 if [...]
3421     Result = CompareStandardConversionSequences(S, Loc,
3422                                                 ICS1.Standard, ICS2.Standard);
3423   else if (ICS1.isUserDefined()) {
3424     // User-defined conversion sequence U1 is a better conversion
3425     // sequence than another user-defined conversion sequence U2 if
3426     // they contain the same user-defined conversion function or
3427     // constructor and if the second standard conversion sequence of
3428     // U1 is better than the second standard conversion sequence of
3429     // U2 (C++ 13.3.3.2p3).
3430     if (ICS1.UserDefined.ConversionFunction ==
3431           ICS2.UserDefined.ConversionFunction)
3432       Result = CompareStandardConversionSequences(S, Loc,
3433                                                   ICS1.UserDefined.After,
3434                                                   ICS2.UserDefined.After);
3435     else
3436       Result = compareConversionFunctions(S, 
3437                                           ICS1.UserDefined.ConversionFunction,
3438                                           ICS2.UserDefined.ConversionFunction);
3439   }
3440
3441   return Result;
3442 }
3443
3444 static bool hasSimilarType(ASTContext &Context, QualType T1, QualType T2) {
3445   while (Context.UnwrapSimilarPointerTypes(T1, T2)) {
3446     Qualifiers Quals;
3447     T1 = Context.getUnqualifiedArrayType(T1, Quals);
3448     T2 = Context.getUnqualifiedArrayType(T2, Quals);
3449   }
3450
3451   return Context.hasSameUnqualifiedType(T1, T2);
3452 }
3453
3454 // Per 13.3.3.2p3, compare the given standard conversion sequences to
3455 // determine if one is a proper subset of the other.
3456 static ImplicitConversionSequence::CompareKind
3457 compareStandardConversionSubsets(ASTContext &Context,
3458                                  const StandardConversionSequence& SCS1,
3459                                  const StandardConversionSequence& SCS2) {
3460   ImplicitConversionSequence::CompareKind Result
3461     = ImplicitConversionSequence::Indistinguishable;
3462
3463   // the identity conversion sequence is considered to be a subsequence of
3464   // any non-identity conversion sequence
3465   if (SCS1.isIdentityConversion() && !SCS2.isIdentityConversion())
3466     return ImplicitConversionSequence::Better;
3467   else if (!SCS1.isIdentityConversion() && SCS2.isIdentityConversion())
3468     return ImplicitConversionSequence::Worse;
3469
3470   if (SCS1.Second != SCS2.Second) {
3471     if (SCS1.Second == ICK_Identity)
3472       Result = ImplicitConversionSequence::Better;
3473     else if (SCS2.Second == ICK_Identity)
3474       Result = ImplicitConversionSequence::Worse;
3475     else
3476       return ImplicitConversionSequence::Indistinguishable;
3477   } else if (!hasSimilarType(Context, SCS1.getToType(1), SCS2.getToType(1)))
3478     return ImplicitConversionSequence::Indistinguishable;
3479
3480   if (SCS1.Third == SCS2.Third) {
3481     return Context.hasSameType(SCS1.getToType(2), SCS2.getToType(2))? Result
3482                              : ImplicitConversionSequence::Indistinguishable;
3483   }
3484
3485   if (SCS1.Third == ICK_Identity)
3486     return Result == ImplicitConversionSequence::Worse
3487              ? ImplicitConversionSequence::Indistinguishable
3488              : ImplicitConversionSequence::Better;
3489
3490   if (SCS2.Third == ICK_Identity)
3491     return Result == ImplicitConversionSequence::Better
3492              ? ImplicitConversionSequence::Indistinguishable
3493              : ImplicitConversionSequence::Worse;
3494
3495   return ImplicitConversionSequence::Indistinguishable;
3496 }
3497
3498 /// \brief Determine whether one of the given reference bindings is better
3499 /// than the other based on what kind of bindings they are.
3500 static bool
3501 isBetterReferenceBindingKind(const StandardConversionSequence &SCS1,
3502                              const StandardConversionSequence &SCS2) {
3503   // C++0x [over.ics.rank]p3b4:
3504   //   -- S1 and S2 are reference bindings (8.5.3) and neither refers to an
3505   //      implicit object parameter of a non-static member function declared
3506   //      without a ref-qualifier, and *either* S1 binds an rvalue reference
3507   //      to an rvalue and S2 binds an lvalue reference *or S1 binds an
3508   //      lvalue reference to a function lvalue and S2 binds an rvalue
3509   //      reference*.
3510   //
3511   // FIXME: Rvalue references. We're going rogue with the above edits,
3512   // because the semantics in the current C++0x working paper (N3225 at the
3513   // time of this writing) break the standard definition of std::forward
3514   // and std::reference_wrapper when dealing with references to functions.
3515   // Proposed wording changes submitted to CWG for consideration.
3516   if (SCS1.BindsImplicitObjectArgumentWithoutRefQualifier ||
3517       SCS2.BindsImplicitObjectArgumentWithoutRefQualifier)
3518     return false;
3519
3520   return (!SCS1.IsLvalueReference && SCS1.BindsToRvalue &&
3521           SCS2.IsLvalueReference) ||
3522          (SCS1.IsLvalueReference && SCS1.BindsToFunctionLvalue &&
3523           !SCS2.IsLvalueReference && SCS2.BindsToFunctionLvalue);
3524 }
3525
3526 /// CompareStandardConversionSequences - Compare two standard
3527 /// conversion sequences to determine whether one is better than the
3528 /// other or if they are indistinguishable (C++ 13.3.3.2p3).
3529 static ImplicitConversionSequence::CompareKind
3530 CompareStandardConversionSequences(Sema &S, SourceLocation Loc,
3531                                    const StandardConversionSequence& SCS1,
3532                                    const StandardConversionSequence& SCS2)
3533 {
3534   // Standard conversion sequence S1 is a better conversion sequence
3535   // than standard conversion sequence S2 if (C++ 13.3.3.2p3):
3536
3537   //  -- S1 is a proper subsequence of S2 (comparing the conversion
3538   //     sequences in the canonical form defined by 13.3.3.1.1,
3539   //     excluding any Lvalue Transformation; the identity conversion
3540   //     sequence is considered to be a subsequence of any
3541   //     non-identity conversion sequence) or, if not that,
3542   if (ImplicitConversionSequence::CompareKind CK
3543         = compareStandardConversionSubsets(S.Context, SCS1, SCS2))
3544     return CK;
3545
3546   //  -- the rank of S1 is better than the rank of S2 (by the rules
3547   //     defined below), or, if not that,
3548   ImplicitConversionRank Rank1 = SCS1.getRank();
3549   ImplicitConversionRank Rank2 = SCS2.getRank();
3550   if (Rank1 < Rank2)
3551     return ImplicitConversionSequence::Better;
3552   else if (Rank2 < Rank1)
3553     return ImplicitConversionSequence::Worse;
3554
3555   // (C++ 13.3.3.2p4): Two conversion sequences with the same rank
3556   // are indistinguishable unless one of the following rules
3557   // applies:
3558
3559   //   A conversion that is not a conversion of a pointer, or
3560   //   pointer to member, to bool is better than another conversion
3561   //   that is such a conversion.
3562   if (SCS1.isPointerConversionToBool() != SCS2.isPointerConversionToBool())
3563     return SCS2.isPointerConversionToBool()
3564              ? ImplicitConversionSequence::Better
3565              : ImplicitConversionSequence::Worse;
3566
3567   // C++ [over.ics.rank]p4b2:
3568   //
3569   //   If class B is derived directly or indirectly from class A,
3570   //   conversion of B* to A* is better than conversion of B* to
3571   //   void*, and conversion of A* to void* is better than conversion
3572   //   of B* to void*.
3573   bool SCS1ConvertsToVoid
3574     = SCS1.isPointerConversionToVoidPointer(S.Context);
3575   bool SCS2ConvertsToVoid
3576     = SCS2.isPointerConversionToVoidPointer(S.Context);
3577   if (SCS1ConvertsToVoid != SCS2ConvertsToVoid) {
3578     // Exactly one of the conversion sequences is a conversion to
3579     // a void pointer; it's the worse conversion.
3580     return SCS2ConvertsToVoid ? ImplicitConversionSequence::Better
3581                               : ImplicitConversionSequence::Worse;
3582   } else if (!SCS1ConvertsToVoid && !SCS2ConvertsToVoid) {
3583     // Neither conversion sequence converts to a void pointer; compare
3584     // their derived-to-base conversions.
3585     if (ImplicitConversionSequence::CompareKind DerivedCK
3586           = CompareDerivedToBaseConversions(S, Loc, SCS1, SCS2))
3587       return DerivedCK;
3588   } else if (SCS1ConvertsToVoid && SCS2ConvertsToVoid &&
3589              !S.Context.hasSameType(SCS1.getFromType(), SCS2.getFromType())) {
3590     // Both conversion sequences are conversions to void
3591     // pointers. Compare the source types to determine if there's an
3592     // inheritance relationship in their sources.
3593     QualType FromType1 = SCS1.getFromType();
3594     QualType FromType2 = SCS2.getFromType();
3595
3596     // Adjust the types we're converting from via the array-to-pointer
3597     // conversion, if we need to.
3598     if (SCS1.First == ICK_Array_To_Pointer)
3599       FromType1 = S.Context.getArrayDecayedType(FromType1);
3600     if (SCS2.First == ICK_Array_To_Pointer)
3601       FromType2 = S.Context.getArrayDecayedType(FromType2);
3602
3603     QualType FromPointee1 = FromType1->getPointeeType().getUnqualifiedType();
3604     QualType FromPointee2 = FromType2->getPointeeType().getUnqualifiedType();
3605
3606     if (S.IsDerivedFrom(Loc, FromPointee2, FromPointee1))
3607       return ImplicitConversionSequence::Better;
3608     else if (S.IsDerivedFrom(Loc, FromPointee1, FromPointee2))
3609       return ImplicitConversionSequence::Worse;
3610
3611     // Objective-C++: If one interface is more specific than the
3612     // other, it is the better one.
3613     const ObjCObjectPointerType* FromObjCPtr1
3614       = FromType1->getAs<ObjCObjectPointerType>();
3615     const ObjCObjectPointerType* FromObjCPtr2
3616       = FromType2->getAs<ObjCObjectPointerType>();
3617     if (FromObjCPtr1 && FromObjCPtr2) {
3618       bool AssignLeft = S.Context.canAssignObjCInterfaces(FromObjCPtr1, 
3619                                                           FromObjCPtr2);
3620       bool AssignRight = S.Context.canAssignObjCInterfaces(FromObjCPtr2, 
3621                                                            FromObjCPtr1);
3622       if (AssignLeft != AssignRight) {
3623         return AssignLeft? ImplicitConversionSequence::Better
3624                          : ImplicitConversionSequence::Worse;
3625       }
3626     }
3627   }
3628
3629   // Compare based on qualification conversions (C++ 13.3.3.2p3,
3630   // bullet 3).
3631   if (ImplicitConversionSequence::CompareKind QualCK
3632         = CompareQualificationConversions(S, SCS1, SCS2))
3633     return QualCK;
3634
3635   if (SCS1.ReferenceBinding && SCS2.ReferenceBinding) {
3636     // Check for a better reference binding based on the kind of bindings.
3637     if (isBetterReferenceBindingKind(SCS1, SCS2))
3638       return ImplicitConversionSequence::Better;
3639     else if (isBetterReferenceBindingKind(SCS2, SCS1))
3640       return ImplicitConversionSequence::Worse;
3641
3642     // C++ [over.ics.rank]p3b4:
3643     //   -- S1 and S2 are reference bindings (8.5.3), and the types to
3644     //      which the references refer are the same type except for
3645     //      top-level cv-qualifiers, and the type to which the reference
3646     //      initialized by S2 refers is more cv-qualified than the type
3647     //      to which the reference initialized by S1 refers.
3648     QualType T1 = SCS1.getToType(2);
3649     QualType T2 = SCS2.getToType(2);
3650     T1 = S.Context.getCanonicalType(T1);
3651     T2 = S.Context.getCanonicalType(T2);
3652     Qualifiers T1Quals, T2Quals;
3653     QualType UnqualT1 = S.Context.getUnqualifiedArrayType(T1, T1Quals);
3654     QualType UnqualT2 = S.Context.getUnqualifiedArrayType(T2, T2Quals);
3655     if (UnqualT1 == UnqualT2) {
3656       // Objective-C++ ARC: If the references refer to objects with different
3657       // lifetimes, prefer bindings that don't change lifetime.
3658       if (SCS1.ObjCLifetimeConversionBinding != 
3659                                           SCS2.ObjCLifetimeConversionBinding) {
3660         return SCS1.ObjCLifetimeConversionBinding
3661                                            ? ImplicitConversionSequence::Worse
3662                                            : ImplicitConversionSequence::Better;
3663       }
3664       
3665       // If the type is an array type, promote the element qualifiers to the
3666       // type for comparison.
3667       if (isa<ArrayType>(T1) && T1Quals)
3668         T1 = S.Context.getQualifiedType(UnqualT1, T1Quals);
3669       if (isa<ArrayType>(T2) && T2Quals)
3670         T2 = S.Context.getQualifiedType(UnqualT2, T2Quals);
3671       if (T2.isMoreQualifiedThan(T1))
3672         return ImplicitConversionSequence::Better;
3673       else if (T1.isMoreQualifiedThan(T2))
3674         return ImplicitConversionSequence::Worse;      
3675     }
3676   }
3677
3678   // In Microsoft mode, prefer an integral conversion to a
3679   // floating-to-integral conversion if the integral conversion
3680   // is between types of the same size.
3681   // For example:
3682   // void f(float);
3683   // void f(int);
3684   // int main {
3685   //    long a;
3686   //    f(a);
3687   // }
3688   // Here, MSVC will call f(int) instead of generating a compile error
3689   // as clang will do in standard mode.
3690   if (S.getLangOpts().MSVCCompat && SCS1.Second == ICK_Integral_Conversion &&
3691       SCS2.Second == ICK_Floating_Integral &&
3692       S.Context.getTypeSize(SCS1.getFromType()) ==
3693           S.Context.getTypeSize(SCS1.getToType(2)))
3694     return ImplicitConversionSequence::Better;
3695
3696   return ImplicitConversionSequence::Indistinguishable;
3697 }
3698
3699 /// CompareQualificationConversions - Compares two standard conversion
3700 /// sequences to determine whether they can be ranked based on their
3701 /// qualification conversions (C++ 13.3.3.2p3 bullet 3).
3702 static ImplicitConversionSequence::CompareKind
3703 CompareQualificationConversions(Sema &S,
3704                                 const StandardConversionSequence& SCS1,
3705                                 const StandardConversionSequence& SCS2) {
3706   // C++ 13.3.3.2p3:
3707   //  -- S1 and S2 differ only in their qualification conversion and
3708   //     yield similar types T1 and T2 (C++ 4.4), respectively, and the
3709   //     cv-qualification signature of type T1 is a proper subset of
3710   //     the cv-qualification signature of type T2, and S1 is not the
3711   //     deprecated string literal array-to-pointer conversion (4.2).
3712   if (SCS1.First != SCS2.First || SCS1.Second != SCS2.Second ||
3713       SCS1.Third != SCS2.Third || SCS1.Third != ICK_Qualification)
3714     return ImplicitConversionSequence::Indistinguishable;
3715
3716   // FIXME: the example in the standard doesn't use a qualification
3717   // conversion (!)
3718   QualType T1 = SCS1.getToType(2);
3719   QualType T2 = SCS2.getToType(2);
3720   T1 = S.Context.getCanonicalType(T1);
3721   T2 = S.Context.getCanonicalType(T2);
3722   Qualifiers T1Quals, T2Quals;
3723   QualType UnqualT1 = S.Context.getUnqualifiedArrayType(T1, T1Quals);
3724   QualType UnqualT2 = S.Context.getUnqualifiedArrayType(T2, T2Quals);
3725
3726   // If the types are the same, we won't learn anything by unwrapped
3727   // them.
3728   if (UnqualT1 == UnqualT2)
3729     return ImplicitConversionSequence::Indistinguishable;
3730
3731   // If the type is an array type, promote the element qualifiers to the type
3732   // for comparison.
3733   if (isa<ArrayType>(T1) && T1Quals)
3734     T1 = S.Context.getQualifiedType(UnqualT1, T1Quals);
3735   if (isa<ArrayType>(T2) && T2Quals)
3736     T2 = S.Context.getQualifiedType(UnqualT2, T2Quals);
3737
3738   ImplicitConversionSequence::CompareKind Result
3739     = ImplicitConversionSequence::Indistinguishable;
3740   
3741   // Objective-C++ ARC:
3742   //   Prefer qualification conversions not involving a change in lifetime
3743   //   to qualification conversions that do not change lifetime.
3744   if (SCS1.QualificationIncludesObjCLifetime != 
3745                                       SCS2.QualificationIncludesObjCLifetime) {
3746     Result = SCS1.QualificationIncludesObjCLifetime
3747                ? ImplicitConversionSequence::Worse
3748                : ImplicitConversionSequence::Better;
3749   }
3750   
3751   while (S.Context.UnwrapSimilarPointerTypes(T1, T2)) {
3752     // Within each iteration of the loop, we check the qualifiers to
3753     // determine if this still looks like a qualification
3754     // conversion. Then, if all is well, we unwrap one more level of
3755     // pointers or pointers-to-members and do it all again
3756     // until there are no more pointers or pointers-to-members left
3757     // to unwrap. This essentially mimics what
3758     // IsQualificationConversion does, but here we're checking for a
3759     // strict subset of qualifiers.
3760     if (T1.getCVRQualifiers() == T2.getCVRQualifiers())
3761       // The qualifiers are the same, so this doesn't tell us anything
3762       // about how the sequences rank.
3763       ;
3764     else if (T2.isMoreQualifiedThan(T1)) {
3765       // T1 has fewer qualifiers, so it could be the better sequence.
3766       if (Result == ImplicitConversionSequence::Worse)
3767         // Neither has qualifiers that are a subset of the other's
3768         // qualifiers.
3769         return ImplicitConversionSequence::Indistinguishable;
3770
3771       Result = ImplicitConversionSequence::Better;
3772     } else if (T1.isMoreQualifiedThan(T2)) {
3773       // T2 has fewer qualifiers, so it could be the better sequence.
3774       if (Result == ImplicitConversionSequence::Better)
3775         // Neither has qualifiers that are a subset of the other's
3776         // qualifiers.
3777         return ImplicitConversionSequence::Indistinguishable;
3778
3779       Result = ImplicitConversionSequence::Worse;
3780     } else {
3781       // Qualifiers are disjoint.
3782       return ImplicitConversionSequence::Indistinguishable;
3783     }
3784
3785     // If the types after this point are equivalent, we're done.
3786     if (S.Context.hasSameUnqualifiedType(T1, T2))
3787       break;
3788   }
3789
3790   // Check that the winning standard conversion sequence isn't using
3791   // the deprecated string literal array to pointer conversion.
3792   switch (Result) {
3793   case ImplicitConversionSequence::Better:
3794     if (SCS1.DeprecatedStringLiteralToCharPtr)
3795       Result = ImplicitConversionSequence::Indistinguishable;
3796     break;
3797
3798   case ImplicitConversionSequence::Indistinguishable:
3799     break;
3800
3801   case ImplicitConversionSequence::Worse:
3802     if (SCS2.DeprecatedStringLiteralToCharPtr)
3803       Result = ImplicitConversionSequence::Indistinguishable;
3804     break;
3805   }
3806
3807   return Result;
3808 }
3809
3810 /// CompareDerivedToBaseConversions - Compares two standard conversion
3811 /// sequences to determine whether they can be ranked based on their
3812 /// various kinds of derived-to-base conversions (C++
3813 /// [over.ics.rank]p4b3).  As part of these checks, we also look at
3814 /// conversions between Objective-C interface types.
3815 static ImplicitConversionSequence::CompareKind
3816 CompareDerivedToBaseConversions(Sema &S, SourceLocation Loc,
3817                                 const StandardConversionSequence& SCS1,
3818                                 const StandardConversionSequence& SCS2) {
3819   QualType FromType1 = SCS1.getFromType();
3820   QualType ToType1 = SCS1.getToType(1);
3821   QualType FromType2 = SCS2.getFromType();
3822   QualType ToType2 = SCS2.getToType(1);
3823
3824   // Adjust the types we're converting from via the array-to-pointer
3825   // conversion, if we need to.
3826   if (SCS1.First == ICK_Array_To_Pointer)
3827     FromType1 = S.Context.getArrayDecayedType(FromType1);
3828   if (SCS2.First == ICK_Array_To_Pointer)
3829     FromType2 = S.Context.getArrayDecayedType(FromType2);
3830
3831   // Canonicalize all of the types.
3832   FromType1 = S.Context.getCanonicalType(FromType1);
3833   ToType1 = S.Context.getCanonicalType(ToType1);
3834   FromType2 = S.Context.getCanonicalType(FromType2);
3835   ToType2 = S.Context.getCanonicalType(ToType2);
3836
3837   // C++ [over.ics.rank]p4b3:
3838   //
3839   //   If class B is derived directly or indirectly from class A and
3840   //   class C is derived directly or indirectly from B,
3841   //
3842   // Compare based on pointer conversions.
3843   if (SCS1.Second == ICK_Pointer_Conversion &&
3844       SCS2.Second == ICK_Pointer_Conversion &&
3845       /*FIXME: Remove if Objective-C id conversions get their own rank*/
3846       FromType1->isPointerType() && FromType2->isPointerType() &&
3847       ToType1->isPointerType() && ToType2->isPointerType()) {
3848     QualType FromPointee1
3849       = FromType1->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
3850     QualType ToPointee1
3851       = ToType1->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
3852     QualType FromPointee2
3853       = FromType2->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
3854     QualType ToPointee2
3855       = ToType2->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
3856
3857     //   -- conversion of C* to B* is better than conversion of C* to A*,
3858     if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
3859       if (S.IsDerivedFrom(Loc, ToPointee1, ToPointee2))
3860         return ImplicitConversionSequence::Better;
3861       else if (S.IsDerivedFrom(Loc, ToPointee2, ToPointee1))
3862         return ImplicitConversionSequence::Worse;
3863     }
3864
3865     //   -- conversion of B* to A* is better than conversion of C* to A*,
3866     if (FromPointee1 != FromPointee2 && ToPointee1 == ToPointee2) {
3867       if (S.IsDerivedFrom(Loc, FromPointee2, FromPointee1))
3868         return ImplicitConversionSequence::Better;
3869       else if (S.IsDerivedFrom(Loc, FromPointee1, FromPointee2))
3870         return ImplicitConversionSequence::Worse;
3871     }
3872   } else if (SCS1.Second == ICK_Pointer_Conversion &&
3873              SCS2.Second == ICK_Pointer_Conversion) {
3874     const ObjCObjectPointerType *FromPtr1
3875       = FromType1->getAs<ObjCObjectPointerType>();
3876     const ObjCObjectPointerType *FromPtr2
3877       = FromType2->getAs<ObjCObjectPointerType>();
3878     const ObjCObjectPointerType *ToPtr1
3879       = ToType1->getAs<ObjCObjectPointerType>();
3880     const ObjCObjectPointerType *ToPtr2
3881       = ToType2->getAs<ObjCObjectPointerType>();
3882     
3883     if (FromPtr1 && FromPtr2 && ToPtr1 && ToPtr2) {
3884       // Apply the same conversion ranking rules for Objective-C pointer types
3885       // that we do for C++ pointers to class types. However, we employ the
3886       // Objective-C pseudo-subtyping relationship used for assignment of
3887       // Objective-C pointer types.
3888       bool FromAssignLeft
3889         = S.Context.canAssignObjCInterfaces(FromPtr1, FromPtr2);
3890       bool FromAssignRight
3891         = S.Context.canAssignObjCInterfaces(FromPtr2, FromPtr1);
3892       bool ToAssignLeft
3893         = S.Context.canAssignObjCInterfaces(ToPtr1, ToPtr2);
3894       bool ToAssignRight
3895         = S.Context.canAssignObjCInterfaces(ToPtr2, ToPtr1);
3896       
3897       // A conversion to an a non-id object pointer type or qualified 'id' 
3898       // type is better than a conversion to 'id'.
3899       if (ToPtr1->isObjCIdType() &&
3900           (ToPtr2->isObjCQualifiedIdType() || ToPtr2->getInterfaceDecl()))
3901         return ImplicitConversionSequence::Worse;
3902       if (ToPtr2->isObjCIdType() &&
3903           (ToPtr1->isObjCQualifiedIdType() || ToPtr1->getInterfaceDecl()))
3904         return ImplicitConversionSequence::Better;
3905       
3906       // A conversion to a non-id object pointer type is better than a 
3907       // conversion to a qualified 'id' type 
3908       if (ToPtr1->isObjCQualifiedIdType() && ToPtr2->getInterfaceDecl())
3909         return ImplicitConversionSequence::Worse;
3910       if (ToPtr2->isObjCQualifiedIdType() && ToPtr1->getInterfaceDecl())
3911         return ImplicitConversionSequence::Better;
3912   
3913       // A conversion to an a non-Class object pointer type or qualified 'Class' 
3914       // type is better than a conversion to 'Class'.
3915       if (ToPtr1->isObjCClassType() &&
3916           (ToPtr2->isObjCQualifiedClassType() || ToPtr2->getInterfaceDecl()))
3917         return ImplicitConversionSequence::Worse;
3918       if (ToPtr2->isObjCClassType() &&
3919           (ToPtr1->isObjCQualifiedClassType() || ToPtr1->getInterfaceDecl()))
3920         return ImplicitConversionSequence::Better;
3921       
3922       // A conversion to a non-Class object pointer type is better than a 
3923       // conversion to a qualified 'Class' type.
3924       if (ToPtr1->isObjCQualifiedClassType() && ToPtr2->getInterfaceDecl())
3925         return ImplicitConversionSequence::Worse;
3926       if (ToPtr2->isObjCQualifiedClassType() && ToPtr1->getInterfaceDecl())
3927         return ImplicitConversionSequence::Better;
3928
3929       //   -- "conversion of C* to B* is better than conversion of C* to A*,"
3930       if (S.Context.hasSameType(FromType1, FromType2) && 
3931           !FromPtr1->isObjCIdType() && !FromPtr1->isObjCClassType() &&
3932           (ToAssignLeft != ToAssignRight))
3933         return ToAssignLeft? ImplicitConversionSequence::Worse
3934                            : ImplicitConversionSequence::Better;
3935
3936       //   -- "conversion of B* to A* is better than conversion of C* to A*,"
3937       if (S.Context.hasSameUnqualifiedType(ToType1, ToType2) &&
3938           (FromAssignLeft != FromAssignRight))
3939         return FromAssignLeft? ImplicitConversionSequence::Better
3940         : ImplicitConversionSequence::Worse;
3941     }
3942   }
3943   
3944   // Ranking of member-pointer types.
3945   if (SCS1.Second == ICK_Pointer_Member && SCS2.Second == ICK_Pointer_Member &&
3946       FromType1->isMemberPointerType() && FromType2->isMemberPointerType() &&
3947       ToType1->isMemberPointerType() && ToType2->isMemberPointerType()) {
3948     const MemberPointerType * FromMemPointer1 =
3949                                         FromType1->getAs<MemberPointerType>();
3950     const MemberPointerType * ToMemPointer1 =
3951                                           ToType1->getAs<MemberPointerType>();
3952     const MemberPointerType * FromMemPointer2 =
3953                                           FromType2->getAs<MemberPointerType>();
3954     const MemberPointerType * ToMemPointer2 =
3955                                           ToType2->getAs<MemberPointerType>();
3956     const Type *FromPointeeType1 = FromMemPointer1->getClass();
3957     const Type *ToPointeeType1 = ToMemPointer1->getClass();
3958     const Type *FromPointeeType2 = FromMemPointer2->getClass();
3959     const Type *ToPointeeType2 = ToMemPointer2->getClass();
3960     QualType FromPointee1 = QualType(FromPointeeType1, 0).getUnqualifiedType();
3961     QualType ToPointee1 = QualType(ToPointeeType1, 0).getUnqualifiedType();
3962     QualType FromPointee2 = QualType(FromPointeeType2, 0).getUnqualifiedType();
3963     QualType ToPointee2 = QualType(ToPointeeType2, 0).getUnqualifiedType();
3964     // conversion of A::* to B::* is better than conversion of A::* to C::*,
3965     if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
3966       if (S.IsDerivedFrom(Loc, ToPointee1, ToPointee2))
3967         return ImplicitConversionSequence::Worse;
3968       else if (S.IsDerivedFrom(Loc, ToPointee2, ToPointee1))
3969         return ImplicitConversionSequence::Better;
3970     }
3971     // conversion of B::* to C::* is better than conversion of A::* to C::*
3972     if (ToPointee1 == ToPointee2 && FromPointee1 != FromPointee2) {
3973       if (S.IsDerivedFrom(Loc, FromPointee1, FromPointee2))
3974         return ImplicitConversionSequence::Better;
3975       else if (S.IsDerivedFrom(Loc, FromPointee2, FromPointee1))
3976         return ImplicitConversionSequence::Worse;
3977     }
3978   }
3979
3980   if (SCS1.Second == ICK_Derived_To_Base) {
3981     //   -- conversion of C to B is better than conversion of C to A,
3982     //   -- binding of an expression of type C to a reference of type
3983     //      B& is better than binding an expression of type C to a
3984     //      reference of type A&,
3985     if (S.Context.hasSameUnqualifiedType(FromType1, FromType2) &&
3986         !S.Context.hasSameUnqualifiedType(ToType1, ToType2)) {
3987       if (S.IsDerivedFrom(Loc, ToType1, ToType2))
3988         return ImplicitConversionSequence::Better;
3989       else if (S.IsDerivedFrom(Loc, ToType2, ToType1))
3990         return ImplicitConversionSequence::Worse;
3991     }
3992
3993     //   -- conversion of B to A is better than conversion of C to A.
3994     //   -- binding of an expression of type B to a reference of type
3995     //      A& is better than binding an expression of type C to a
3996     //      reference of type A&,
3997     if (!S.Context.hasSameUnqualifiedType(FromType1, FromType2) &&
3998         S.Context.hasSameUnqualifiedType(ToType1, ToType2)) {
3999       if (S.IsDerivedFrom(Loc, FromType2, FromType1))
4000         return ImplicitConversionSequence::Better;
4001       else if (S.IsDerivedFrom(Loc, FromType1, FromType2))
4002         return ImplicitConversionSequence::Worse;
4003     }
4004   }
4005
4006   return ImplicitConversionSequence::Indistinguishable;
4007 }
4008
4009 /// \brief Determine whether the given type is valid, e.g., it is not an invalid
4010 /// C++ class.
4011 static bool isTypeValid(QualType T) {
4012   if (CXXRecordDecl *Record = T->getAsCXXRecordDecl())
4013     return !Record->isInvalidDecl();
4014
4015   return true;
4016 }
4017
4018 /// CompareReferenceRelationship - Compare the two types T1 and T2 to
4019 /// determine whether they are reference-related,
4020 /// reference-compatible, reference-compatible with added
4021 /// qualification, or incompatible, for use in C++ initialization by
4022 /// reference (C++ [dcl.ref.init]p4). Neither type can be a reference
4023 /// type, and the first type (T1) is the pointee type of the reference
4024 /// type being initialized.
4025 Sema::ReferenceCompareResult
4026 Sema::CompareReferenceRelationship(SourceLocation Loc,
4027                                    QualType OrigT1, QualType OrigT2,
4028                                    bool &DerivedToBase,
4029                                    bool &ObjCConversion,
4030                                    bool &ObjCLifetimeConversion) {
4031   assert(!OrigT1->isReferenceType() &&
4032     "T1 must be the pointee type of the reference type");
4033   assert(!OrigT2->isReferenceType() && "T2 cannot be a reference type");
4034
4035   QualType T1 = Context.getCanonicalType(OrigT1);
4036   QualType T2 = Context.getCanonicalType(OrigT2);
4037   Qualifiers T1Quals, T2Quals;
4038   QualType UnqualT1 = Context.getUnqualifiedArrayType(T1, T1Quals);
4039   QualType UnqualT2 = Context.getUnqualifiedArrayType(T2, T2Quals);
4040
4041   // C++ [dcl.init.ref]p4:
4042   //   Given types "cv1 T1" and "cv2 T2," "cv1 T1" is
4043   //   reference-related to "cv2 T2" if T1 is the same type as T2, or
4044   //   T1 is a base class of T2.
4045   DerivedToBase = false;
4046   ObjCConversion = false;
4047   ObjCLifetimeConversion = false;
4048   if (UnqualT1 == UnqualT2) {
4049     // Nothing to do.
4050   } else if (isCompleteType(Loc, OrigT2) &&
4051              isTypeValid(UnqualT1) && isTypeValid(UnqualT2) &&
4052              IsDerivedFrom(Loc, UnqualT2, UnqualT1))
4053     DerivedToBase = true;
4054   else if (UnqualT1->isObjCObjectOrInterfaceType() &&
4055            UnqualT2->isObjCObjectOrInterfaceType() &&
4056            Context.canBindObjCObjectType(UnqualT1, UnqualT2))
4057     ObjCConversion = true;
4058   else
4059     return Ref_Incompatible;
4060
4061   // At this point, we know that T1 and T2 are reference-related (at
4062   // least).
4063
4064   // If the type is an array type, promote the element qualifiers to the type
4065   // for comparison.
4066   if (isa<ArrayType>(T1) && T1Quals)
4067     T1 = Context.getQualifiedType(UnqualT1, T1Quals);
4068   if (isa<ArrayType>(T2) && T2Quals)
4069     T2 = Context.getQualifiedType(UnqualT2, T2Quals);
4070
4071   // C++ [dcl.init.ref]p4:
4072   //   "cv1 T1" is reference-compatible with "cv2 T2" if T1 is
4073   //   reference-related to T2 and cv1 is the same cv-qualification
4074   //   as, or greater cv-qualification than, cv2. For purposes of
4075   //   overload resolution, cases for which cv1 is greater
4076   //   cv-qualification than cv2 are identified as
4077   //   reference-compatible with added qualification