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