1 //===--- SemaOverload.cpp - C++ Overloading ---------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file provides Sema routines for C++ overloading.
12 //===----------------------------------------------------------------------===//
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"
38 /// A convenience routine for creating a decayed reference to a
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());
55 static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
56 bool InOverloadResolution,
57 StandardConversionSequence &SCS,
59 bool AllowObjCWritebackConversion);
61 static bool IsTransparentUnionStandardConversion(Sema &S, Expr* From,
63 bool InOverloadResolution,
64 StandardConversionSequence &SCS,
66 static OverloadingResult
67 IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
68 UserDefinedConversionSequence& User,
69 OverloadCandidateSet& Conversions,
73 static ImplicitConversionSequence::CompareKind
74 CompareStandardConversionSequences(Sema &S,
75 const StandardConversionSequence& SCS1,
76 const StandardConversionSequence& SCS2);
78 static ImplicitConversionSequence::CompareKind
79 CompareQualificationConversions(Sema &S,
80 const StandardConversionSequence& SCS1,
81 const StandardConversionSequence& SCS2);
83 static ImplicitConversionSequence::CompareKind
84 CompareDerivedToBaseConversions(Sema &S,
85 const StandardConversionSequence& SCS1,
86 const StandardConversionSequence& SCS2);
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] = {
97 ICC_Lvalue_Transformation,
98 ICC_Lvalue_Transformation,
99 ICC_Lvalue_Transformation,
101 ICC_Qualification_Adjustment,
119 return Category[(int)Kind];
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] = {
147 ICR_Complex_Real_Conversion,
150 ICR_Writeback_Conversion
152 return Rank[(int)Kind];
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] = {
162 "Function-to-pointer",
163 "Noreturn adjustment",
165 "Integral promotion",
166 "Floating point 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",
179 "Complex-real conversion",
180 "Block Pointer conversion",
181 "Transparent Union Conversion"
182 "Writeback conversion"
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;
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);
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
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))
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++
244 StandardConversionSequence::
245 isPointerConversionToVoidPointer(ASTContext& Context) const {
246 QualType FromType = getFromType();
247 QualType ToType = getToType(1);
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);
255 if (Second == ICK_Pointer_Conversion && FromType->isAnyPointerType())
256 if (const PointerType* ToPtrType = ToType->getAs<PointerType>())
257 return ToPtrType->getPointeeType()->isVoidType();
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()) {
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();
285 /// Check if this standard conversion sequence represents a narrowing
286 /// conversion, according to C++11 [dcl.init.list]p7.
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.
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++");
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);
306 // -- from a floating-point type to an integer type, or
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);
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);
325 llvm::APSInt ConvertedValue = IntConstantValue;
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;
336 // Variables are always narrowings.
337 return NK_Variable_Narrowing;
340 return NK_Not_Narrowing;
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)) {
353 assert(ConstantValue.isFloat());
354 llvm::APFloat FloatVal = ConstantValue.getFloat();
355 // Convert the source value into the target type.
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;
367 return NK_Variable_Narrowing;
370 return NK_Not_Narrowing;
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);
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;
401 bool Narrowing = false;
402 if (FromWidth < ToWidth) {
403 // Negative -> unsigned is narrowing. Otherwise, more bits is never
405 if (InitializerValue.isSigned() && InitializerValue.isNegative())
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)
423 ConstantType = Initializer->getType();
424 ConstantValue = APValue(InitializerValue);
425 return NK_Constant_Narrowing;
428 return NK_Not_Narrowing;
432 // Other kinds of conversions are not narrowings.
433 return NK_Not_Narrowing;
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;
447 if (Second != ICK_Identity) {
448 if (PrintedSomething) {
451 OS << GetImplicitConversionName(Second);
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)";
460 PrintedSomething = true;
463 if (Third != ICK_Identity) {
464 if (PrintedSomething) {
467 OS << GetImplicitConversionName(Third);
468 PrintedSomething = true;
471 if (!PrintedSomething) {
472 OS << "No conversions required";
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) {
484 if (ConversionFunction)
485 OS << '\'' << *ConversionFunction << '\'';
487 OS << "aggregate initialization";
488 if (After.First || After.Second || After.Third) {
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();
503 case UserDefinedConversion:
504 OS << "User-defined conversion: ";
505 UserDefined.DebugPrint();
507 case EllipsisConversion:
508 OS << "Ellipsis conversion";
510 case AmbiguousConversion:
511 OS << "Ambiguous conversion";
514 OS << "Bad conversion";
521 void AmbiguousConversionSequence::construct() {
522 new (&conversions()) ConversionSet();
525 void AmbiguousConversionSequence::destruct() {
526 conversions().~ConversionSet();
530 AmbiguousConversionSequence::copyFrom(const AmbiguousConversionSequence &O) {
531 FromTypePtr = O.FromTypePtr;
532 ToTypePtr = O.ToTypePtr;
533 new (&conversions()) ConversionSet(O.conversions());
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;
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;
557 case Sema::TDK_Success:
558 case Sema::TDK_Invalid:
559 case Sema::TDK_InstantiationDepth:
560 case Sema::TDK_TooManyArguments:
561 case Sema::TDK_TooFewArguments:
564 case Sema::TDK_Incomplete:
565 case Sema::TDK_InvalidExplicitArguments:
566 Result.Data = Info.Param.getOpaqueValue();
569 case Sema::TDK_Inconsistent:
570 case Sema::TDK_Underqualified: {
571 // FIXME: Should allocate from normal heap so that we can free this later.
572 DFIParamWithArguments *Saved = new (Context) DFIParamWithArguments;
573 Saved->Param = Info.Param;
574 Saved->FirstArg = Info.FirstArg;
575 Saved->SecondArg = Info.SecondArg;
580 case Sema::TDK_SubstitutionFailure:
581 Result.Data = Info.take();
582 if (Info.hasSFINAEDiagnostic()) {
583 PartialDiagnosticAt *Diag = new (Result.Diagnostic) PartialDiagnosticAt(
584 SourceLocation(), PartialDiagnostic::NullDiagnostic());
585 Info.takeSFINAEDiagnostic(*Diag);
586 Result.HasDiagnostic = true;
590 case Sema::TDK_NonDeducedMismatch:
591 case Sema::TDK_FailedOverloadResolution:
598 void OverloadCandidate::DeductionFailureInfo::Destroy() {
599 switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
600 case Sema::TDK_Success:
601 case Sema::TDK_Invalid:
602 case Sema::TDK_InstantiationDepth:
603 case Sema::TDK_Incomplete:
604 case Sema::TDK_TooManyArguments:
605 case Sema::TDK_TooFewArguments:
606 case Sema::TDK_InvalidExplicitArguments:
609 case Sema::TDK_Inconsistent:
610 case Sema::TDK_Underqualified:
611 // FIXME: Destroy the data?
615 case Sema::TDK_SubstitutionFailure:
616 // FIXME: Destroy the template argument list?
618 if (PartialDiagnosticAt *Diag = getSFINAEDiagnostic()) {
619 Diag->~PartialDiagnosticAt();
620 HasDiagnostic = false;
625 case Sema::TDK_NonDeducedMismatch:
626 case Sema::TDK_FailedOverloadResolution:
631 PartialDiagnosticAt *
632 OverloadCandidate::DeductionFailureInfo::getSFINAEDiagnostic() {
634 return static_cast<PartialDiagnosticAt*>(static_cast<void*>(Diagnostic));
639 OverloadCandidate::DeductionFailureInfo::getTemplateParameter() {
640 switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
641 case Sema::TDK_Success:
642 case Sema::TDK_Invalid:
643 case Sema::TDK_InstantiationDepth:
644 case Sema::TDK_TooManyArguments:
645 case Sema::TDK_TooFewArguments:
646 case Sema::TDK_SubstitutionFailure:
647 return TemplateParameter();
649 case Sema::TDK_Incomplete:
650 case Sema::TDK_InvalidExplicitArguments:
651 return TemplateParameter::getFromOpaqueValue(Data);
653 case Sema::TDK_Inconsistent:
654 case Sema::TDK_Underqualified:
655 return static_cast<DFIParamWithArguments*>(Data)->Param;
658 case Sema::TDK_NonDeducedMismatch:
659 case Sema::TDK_FailedOverloadResolution:
663 return TemplateParameter();
666 TemplateArgumentList *
667 OverloadCandidate::DeductionFailureInfo::getTemplateArgumentList() {
668 switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
669 case Sema::TDK_Success:
670 case Sema::TDK_Invalid:
671 case Sema::TDK_InstantiationDepth:
672 case Sema::TDK_TooManyArguments:
673 case Sema::TDK_TooFewArguments:
674 case Sema::TDK_Incomplete:
675 case Sema::TDK_InvalidExplicitArguments:
676 case Sema::TDK_Inconsistent:
677 case Sema::TDK_Underqualified:
680 case Sema::TDK_SubstitutionFailure:
681 return static_cast<TemplateArgumentList*>(Data);
684 case Sema::TDK_NonDeducedMismatch:
685 case Sema::TDK_FailedOverloadResolution:
692 const TemplateArgument *OverloadCandidate::DeductionFailureInfo::getFirstArg() {
693 switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
694 case Sema::TDK_Success:
695 case Sema::TDK_Invalid:
696 case Sema::TDK_InstantiationDepth:
697 case Sema::TDK_Incomplete:
698 case Sema::TDK_TooManyArguments:
699 case Sema::TDK_TooFewArguments:
700 case Sema::TDK_InvalidExplicitArguments:
701 case Sema::TDK_SubstitutionFailure:
704 case Sema::TDK_Inconsistent:
705 case Sema::TDK_Underqualified:
706 return &static_cast<DFIParamWithArguments*>(Data)->FirstArg;
709 case Sema::TDK_NonDeducedMismatch:
710 case Sema::TDK_FailedOverloadResolution:
717 const TemplateArgument *
718 OverloadCandidate::DeductionFailureInfo::getSecondArg() {
719 switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
720 case Sema::TDK_Success:
721 case Sema::TDK_Invalid:
722 case Sema::TDK_InstantiationDepth:
723 case Sema::TDK_Incomplete:
724 case Sema::TDK_TooManyArguments:
725 case Sema::TDK_TooFewArguments:
726 case Sema::TDK_InvalidExplicitArguments:
727 case Sema::TDK_SubstitutionFailure:
730 case Sema::TDK_Inconsistent:
731 case Sema::TDK_Underqualified:
732 return &static_cast<DFIParamWithArguments*>(Data)->SecondArg;
735 case Sema::TDK_NonDeducedMismatch:
736 case Sema::TDK_FailedOverloadResolution:
743 void OverloadCandidateSet::destroyCandidates() {
744 for (iterator i = begin(), e = end(); i != e; ++i) {
745 for (unsigned ii = 0, ie = i->NumConversions; ii != ie; ++ii)
746 i->Conversions[ii].~ImplicitConversionSequence();
747 if (!i->Viable && i->FailureKind == ovl_fail_bad_deduction)
748 i->DeductionFailure.Destroy();
752 void OverloadCandidateSet::clear() {
754 NumInlineSequences = 0;
760 class UnbridgedCastsSet {
765 SmallVector<Entry, 2> Entries;
768 void save(Sema &S, Expr *&E) {
769 assert(E->hasPlaceholderType(BuiltinType::ARCUnbridgedCast));
770 Entry entry = { &E, E };
771 Entries.push_back(entry);
772 E = S.stripARCUnbridgedCast(E);
776 for (SmallVectorImpl<Entry>::iterator
777 i = Entries.begin(), e = Entries.end(); i != e; ++i)
783 /// checkPlaceholderForOverload - Do any interesting placeholder-like
784 /// preprocessing on the given expression.
786 /// \param unbridgedCasts a collection to which to add unbridged casts;
787 /// without this, they will be immediately diagnosed as errors
789 /// Return true on unrecoverable error.
790 static bool checkPlaceholderForOverload(Sema &S, Expr *&E,
791 UnbridgedCastsSet *unbridgedCasts = 0) {
792 if (const BuiltinType *placeholder = E->getType()->getAsPlaceholderType()) {
793 // We can't handle overloaded expressions here because overload
794 // resolution might reasonably tweak them.
795 if (placeholder->getKind() == BuiltinType::Overload) return false;
797 // If the context potentially accepts unbridged ARC casts, strip
798 // the unbridged cast and add it to the collection for later restoration.
799 if (placeholder->getKind() == BuiltinType::ARCUnbridgedCast &&
801 unbridgedCasts->save(S, E);
805 // Go ahead and check everything else.
806 ExprResult result = S.CheckPlaceholderExpr(E);
807 if (result.isInvalid())
818 /// checkArgPlaceholdersForOverload - Check a set of call operands for
820 static bool checkArgPlaceholdersForOverload(Sema &S, Expr **args,
822 UnbridgedCastsSet &unbridged) {
823 for (unsigned i = 0; i != numArgs; ++i)
824 if (checkPlaceholderForOverload(S, args[i], &unbridged))
830 // IsOverload - Determine whether the given New declaration is an
831 // overload of the declarations in Old. This routine returns false if
832 // New and Old cannot be overloaded, e.g., if New has the same
833 // signature as some function in Old (C++ 1.3.10) or if the Old
834 // declarations aren't functions (or function templates) at all. When
835 // it does return false, MatchedDecl will point to the decl that New
836 // cannot be overloaded with. This decl may be a UsingShadowDecl on
837 // top of the underlying declaration.
839 // Example: Given the following input:
841 // void f(int, float); // #1
842 // void f(int, int); // #2
843 // int f(int, int); // #3
845 // When we process #1, there is no previous declaration of "f",
846 // so IsOverload will not be used.
848 // When we process #2, Old contains only the FunctionDecl for #1. By
849 // comparing the parameter types, we see that #1 and #2 are overloaded
850 // (since they have different signatures), so this routine returns
851 // false; MatchedDecl is unchanged.
853 // When we process #3, Old is an overload set containing #1 and #2. We
854 // compare the signatures of #3 to #1 (they're overloaded, so we do
855 // nothing) and then #3 to #2. Since the signatures of #3 and #2 are
856 // identical (return types of functions are not part of the
857 // signature), IsOverload returns false and MatchedDecl will be set to
858 // point to the FunctionDecl for #2.
860 // 'NewIsUsingShadowDecl' indicates that 'New' is being introduced
861 // into a class by a using declaration. The rules for whether to hide
862 // shadow declarations ignore some properties which otherwise figure
863 // into a function template's signature.
865 Sema::CheckOverload(Scope *S, FunctionDecl *New, const LookupResult &Old,
866 NamedDecl *&Match, bool NewIsUsingDecl) {
867 for (LookupResult::iterator I = Old.begin(), E = Old.end();
869 NamedDecl *OldD = *I;
871 bool OldIsUsingDecl = false;
872 if (isa<UsingShadowDecl>(OldD)) {
873 OldIsUsingDecl = true;
875 // We can always introduce two using declarations into the same
876 // context, even if they have identical signatures.
877 if (NewIsUsingDecl) continue;
879 OldD = cast<UsingShadowDecl>(OldD)->getTargetDecl();
882 // If either declaration was introduced by a using declaration,
883 // we'll need to use slightly different rules for matching.
884 // Essentially, these rules are the normal rules, except that
885 // function templates hide function templates with different
886 // return types or template parameter lists.
887 bool UseMemberUsingDeclRules =
888 (OldIsUsingDecl || NewIsUsingDecl) && CurContext->isRecord();
890 if (FunctionTemplateDecl *OldT = dyn_cast<FunctionTemplateDecl>(OldD)) {
891 if (!IsOverload(New, OldT->getTemplatedDecl(), UseMemberUsingDeclRules)) {
892 if (UseMemberUsingDeclRules && OldIsUsingDecl) {
893 HideUsingShadowDecl(S, cast<UsingShadowDecl>(*I));
900 } else if (FunctionDecl *OldF = dyn_cast<FunctionDecl>(OldD)) {
901 if (!IsOverload(New, OldF, UseMemberUsingDeclRules)) {
902 if (UseMemberUsingDeclRules && OldIsUsingDecl) {
903 HideUsingShadowDecl(S, cast<UsingShadowDecl>(*I));
910 } else if (isa<UsingDecl>(OldD)) {
911 // We can overload with these, which can show up when doing
912 // redeclaration checks for UsingDecls.
913 assert(Old.getLookupKind() == LookupUsingDeclName);
914 } else if (isa<TagDecl>(OldD)) {
915 // We can always overload with tags by hiding them.
916 } else if (isa<UnresolvedUsingValueDecl>(OldD)) {
917 // Optimistically assume that an unresolved using decl will
918 // overload; if it doesn't, we'll have to diagnose during
919 // template instantiation.
922 // Only function declarations can be overloaded; object and type
923 // declarations cannot be overloaded.
925 return Ovl_NonFunction;
932 bool Sema::IsOverload(FunctionDecl *New, FunctionDecl *Old,
933 bool UseUsingDeclRules) {
934 // If both of the functions are extern "C", then they are not
936 if (Old->isExternC() && New->isExternC())
939 FunctionTemplateDecl *OldTemplate = Old->getDescribedFunctionTemplate();
940 FunctionTemplateDecl *NewTemplate = New->getDescribedFunctionTemplate();
943 // A function template can be overloaded with other function templates
944 // and with normal (non-template) functions.
945 if ((OldTemplate == 0) != (NewTemplate == 0))
948 // Is the function New an overload of the function Old?
949 QualType OldQType = Context.getCanonicalType(Old->getType());
950 QualType NewQType = Context.getCanonicalType(New->getType());
952 // Compare the signatures (C++ 1.3.10) of the two functions to
953 // determine whether they are overloads. If we find any mismatch
954 // in the signature, they are overloads.
956 // If either of these functions is a K&R-style function (no
957 // prototype), then we consider them to have matching signatures.
958 if (isa<FunctionNoProtoType>(OldQType.getTypePtr()) ||
959 isa<FunctionNoProtoType>(NewQType.getTypePtr()))
962 const FunctionProtoType* OldType = cast<FunctionProtoType>(OldQType);
963 const FunctionProtoType* NewType = cast<FunctionProtoType>(NewQType);
965 // The signature of a function includes the types of its
966 // parameters (C++ 1.3.10), which includes the presence or absence
967 // of the ellipsis; see C++ DR 357).
968 if (OldQType != NewQType &&
969 (OldType->getNumArgs() != NewType->getNumArgs() ||
970 OldType->isVariadic() != NewType->isVariadic() ||
971 !FunctionArgTypesAreEqual(OldType, NewType)))
974 // C++ [temp.over.link]p4:
975 // The signature of a function template consists of its function
976 // signature, its return type and its template parameter list. The names
977 // of the template parameters are significant only for establishing the
978 // relationship between the template parameters and the rest of the
981 // We check the return type and template parameter lists for function
982 // templates first; the remaining checks follow.
984 // However, we don't consider either of these when deciding whether
985 // a member introduced by a shadow declaration is hidden.
986 if (!UseUsingDeclRules && NewTemplate &&
987 (!TemplateParameterListsAreEqual(NewTemplate->getTemplateParameters(),
988 OldTemplate->getTemplateParameters(),
989 false, TPL_TemplateMatch) ||
990 OldType->getResultType() != NewType->getResultType()))
993 // If the function is a class member, its signature includes the
994 // cv-qualifiers (if any) and ref-qualifier (if any) on the function itself.
996 // As part of this, also check whether one of the member functions
997 // is static, in which case they are not overloads (C++
998 // 13.1p2). While not part of the definition of the signature,
999 // this check is important to determine whether these functions
1000 // can be overloaded.
1001 CXXMethodDecl* OldMethod = dyn_cast<CXXMethodDecl>(Old);
1002 CXXMethodDecl* NewMethod = dyn_cast<CXXMethodDecl>(New);
1003 if (OldMethod && NewMethod &&
1004 !OldMethod->isStatic() && !NewMethod->isStatic() &&
1005 (OldMethod->getTypeQualifiers() != NewMethod->getTypeQualifiers() ||
1006 OldMethod->getRefQualifier() != NewMethod->getRefQualifier())) {
1007 if (!UseUsingDeclRules &&
1008 OldMethod->getRefQualifier() != NewMethod->getRefQualifier() &&
1009 (OldMethod->getRefQualifier() == RQ_None ||
1010 NewMethod->getRefQualifier() == RQ_None)) {
1011 // C++0x [over.load]p2:
1012 // - Member function declarations with the same name and the same
1013 // parameter-type-list as well as member function template
1014 // declarations with the same name, the same parameter-type-list, and
1015 // the same template parameter lists cannot be overloaded if any of
1016 // them, but not all, have a ref-qualifier (8.3.5).
1017 Diag(NewMethod->getLocation(), diag::err_ref_qualifier_overload)
1018 << NewMethod->getRefQualifier() << OldMethod->getRefQualifier();
1019 Diag(OldMethod->getLocation(), diag::note_previous_declaration);
1025 // The signatures match; this is not an overload.
1029 /// \brief Checks availability of the function depending on the current
1030 /// function context. Inside an unavailable function, unavailability is ignored.
1032 /// \returns true if \arg FD is unavailable and current context is inside
1033 /// an available function, false otherwise.
1034 bool Sema::isFunctionConsideredUnavailable(FunctionDecl *FD) {
1035 return FD->isUnavailable() && !cast<Decl>(CurContext)->isUnavailable();
1038 /// \brief Tries a user-defined conversion from From to ToType.
1040 /// Produces an implicit conversion sequence for when a standard conversion
1041 /// is not an option. See TryImplicitConversion for more information.
1042 static ImplicitConversionSequence
1043 TryUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
1044 bool SuppressUserConversions,
1046 bool InOverloadResolution,
1048 bool AllowObjCWritebackConversion) {
1049 ImplicitConversionSequence ICS;
1051 if (SuppressUserConversions) {
1052 // We're not in the case above, so there is no conversion that
1054 ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1058 // Attempt user-defined conversion.
1059 OverloadCandidateSet Conversions(From->getExprLoc());
1060 OverloadingResult UserDefResult
1061 = IsUserDefinedConversion(S, From, ToType, ICS.UserDefined, Conversions,
1064 if (UserDefResult == OR_Success) {
1065 ICS.setUserDefined();
1066 // C++ [over.ics.user]p4:
1067 // A conversion of an expression of class type to the same class
1068 // type is given Exact Match rank, and a conversion of an
1069 // expression of class type to a base class of that type is
1070 // given Conversion rank, in spite of the fact that a copy
1071 // constructor (i.e., a user-defined conversion function) is
1072 // called for those cases.
1073 if (CXXConstructorDecl *Constructor
1074 = dyn_cast<CXXConstructorDecl>(ICS.UserDefined.ConversionFunction)) {
1076 = S.Context.getCanonicalType(From->getType().getUnqualifiedType());
1078 = S.Context.getCanonicalType(ToType).getUnqualifiedType();
1079 if (Constructor->isCopyConstructor() &&
1080 (FromCanon == ToCanon || S.IsDerivedFrom(FromCanon, ToCanon))) {
1081 // Turn this into a "standard" conversion sequence, so that it
1082 // gets ranked with standard conversion sequences.
1084 ICS.Standard.setAsIdentityConversion();
1085 ICS.Standard.setFromType(From->getType());
1086 ICS.Standard.setAllToTypes(ToType);
1087 ICS.Standard.CopyConstructor = Constructor;
1088 if (ToCanon != FromCanon)
1089 ICS.Standard.Second = ICK_Derived_To_Base;
1093 // C++ [over.best.ics]p4:
1094 // However, when considering the argument of a user-defined
1095 // conversion function that is a candidate by 13.3.1.3 when
1096 // invoked for the copying of the temporary in the second step
1097 // of a class copy-initialization, or by 13.3.1.4, 13.3.1.5, or
1098 // 13.3.1.6 in all cases, only standard conversion sequences and
1099 // ellipsis conversion sequences are allowed.
1100 if (SuppressUserConversions && ICS.isUserDefined()) {
1101 ICS.setBad(BadConversionSequence::suppressed_user, From, ToType);
1103 } else if (UserDefResult == OR_Ambiguous && !SuppressUserConversions) {
1105 ICS.Ambiguous.setFromType(From->getType());
1106 ICS.Ambiguous.setToType(ToType);
1107 for (OverloadCandidateSet::iterator Cand = Conversions.begin();
1108 Cand != Conversions.end(); ++Cand)
1110 ICS.Ambiguous.addConversion(Cand->Function);
1112 ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1118 /// TryImplicitConversion - Attempt to perform an implicit conversion
1119 /// from the given expression (Expr) to the given type (ToType). This
1120 /// function returns an implicit conversion sequence that can be used
1121 /// to perform the initialization. Given
1123 /// void f(float f);
1124 /// void g(int i) { f(i); }
1126 /// this routine would produce an implicit conversion sequence to
1127 /// describe the initialization of f from i, which will be a standard
1128 /// conversion sequence containing an lvalue-to-rvalue conversion (C++
1129 /// 4.1) followed by a floating-integral conversion (C++ 4.9).
1131 /// Note that this routine only determines how the conversion can be
1132 /// performed; it does not actually perform the conversion. As such,
1133 /// it will not produce any diagnostics if no conversion is available,
1134 /// but will instead return an implicit conversion sequence of kind
1135 /// "BadConversion".
1137 /// If @p SuppressUserConversions, then user-defined conversions are
1139 /// If @p AllowExplicit, then explicit user-defined conversions are
1142 /// \param AllowObjCWritebackConversion Whether we allow the Objective-C
1143 /// writeback conversion, which allows __autoreleasing id* parameters to
1144 /// be initialized with __strong id* or __weak id* arguments.
1145 static ImplicitConversionSequence
1146 TryImplicitConversion(Sema &S, Expr *From, QualType ToType,
1147 bool SuppressUserConversions,
1149 bool InOverloadResolution,
1151 bool AllowObjCWritebackConversion) {
1152 ImplicitConversionSequence ICS;
1153 if (IsStandardConversion(S, From, ToType, InOverloadResolution,
1154 ICS.Standard, CStyle, AllowObjCWritebackConversion)){
1159 if (!S.getLangOpts().CPlusPlus) {
1160 ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1164 // C++ [over.ics.user]p4:
1165 // A conversion of an expression of class type to the same class
1166 // type is given Exact Match rank, and a conversion of an
1167 // expression of class type to a base class of that type is
1168 // given Conversion rank, in spite of the fact that a copy/move
1169 // constructor (i.e., a user-defined conversion function) is
1170 // called for those cases.
1171 QualType FromType = From->getType();
1172 if (ToType->getAs<RecordType>() && FromType->getAs<RecordType>() &&
1173 (S.Context.hasSameUnqualifiedType(FromType, ToType) ||
1174 S.IsDerivedFrom(FromType, ToType))) {
1176 ICS.Standard.setAsIdentityConversion();
1177 ICS.Standard.setFromType(FromType);
1178 ICS.Standard.setAllToTypes(ToType);
1180 // We don't actually check at this point whether there is a valid
1181 // copy/move constructor, since overloading just assumes that it
1182 // exists. When we actually perform initialization, we'll find the
1183 // appropriate constructor to copy the returned object, if needed.
1184 ICS.Standard.CopyConstructor = 0;
1186 // Determine whether this is considered a derived-to-base conversion.
1187 if (!S.Context.hasSameUnqualifiedType(FromType, ToType))
1188 ICS.Standard.Second = ICK_Derived_To_Base;
1193 return TryUserDefinedConversion(S, From, ToType, SuppressUserConversions,
1194 AllowExplicit, InOverloadResolution, CStyle,
1195 AllowObjCWritebackConversion);
1198 ImplicitConversionSequence
1199 Sema::TryImplicitConversion(Expr *From, QualType ToType,
1200 bool SuppressUserConversions,
1202 bool InOverloadResolution,
1204 bool AllowObjCWritebackConversion) {
1205 return clang::TryImplicitConversion(*this, From, ToType,
1206 SuppressUserConversions, AllowExplicit,
1207 InOverloadResolution, CStyle,
1208 AllowObjCWritebackConversion);
1211 /// PerformImplicitConversion - Perform an implicit conversion of the
1212 /// expression From to the type ToType. Returns the
1213 /// converted expression. Flavor is the kind of conversion we're
1214 /// performing, used in the error message. If @p AllowExplicit,
1215 /// explicit user-defined conversions are permitted.
1217 Sema::PerformImplicitConversion(Expr *From, QualType ToType,
1218 AssignmentAction Action, bool AllowExplicit) {
1219 ImplicitConversionSequence ICS;
1220 return PerformImplicitConversion(From, ToType, Action, AllowExplicit, ICS);
1224 Sema::PerformImplicitConversion(Expr *From, QualType ToType,
1225 AssignmentAction Action, bool AllowExplicit,
1226 ImplicitConversionSequence& ICS) {
1227 if (checkPlaceholderForOverload(*this, From))
1230 // Objective-C ARC: Determine whether we will allow the writeback conversion.
1231 bool AllowObjCWritebackConversion
1232 = getLangOpts().ObjCAutoRefCount &&
1233 (Action == AA_Passing || Action == AA_Sending);
1235 ICS = clang::TryImplicitConversion(*this, From, ToType,
1236 /*SuppressUserConversions=*/false,
1238 /*InOverloadResolution=*/false,
1240 AllowObjCWritebackConversion);
1241 return PerformImplicitConversion(From, ToType, ICS, Action);
1244 /// \brief Determine whether the conversion from FromType to ToType is a valid
1245 /// conversion that strips "noreturn" off the nested function type.
1246 bool Sema::IsNoReturnConversion(QualType FromType, QualType ToType,
1247 QualType &ResultTy) {
1248 if (Context.hasSameUnqualifiedType(FromType, ToType))
1251 // Permit the conversion F(t __attribute__((noreturn))) -> F(t)
1252 // where F adds one of the following at most once:
1254 // - a member pointer
1255 // - a block pointer
1256 CanQualType CanTo = Context.getCanonicalType(ToType);
1257 CanQualType CanFrom = Context.getCanonicalType(FromType);
1258 Type::TypeClass TyClass = CanTo->getTypeClass();
1259 if (TyClass != CanFrom->getTypeClass()) return false;
1260 if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto) {
1261 if (TyClass == Type::Pointer) {
1262 CanTo = CanTo.getAs<PointerType>()->getPointeeType();
1263 CanFrom = CanFrom.getAs<PointerType>()->getPointeeType();
1264 } else if (TyClass == Type::BlockPointer) {
1265 CanTo = CanTo.getAs<BlockPointerType>()->getPointeeType();
1266 CanFrom = CanFrom.getAs<BlockPointerType>()->getPointeeType();
1267 } else if (TyClass == Type::MemberPointer) {
1268 CanTo = CanTo.getAs<MemberPointerType>()->getPointeeType();
1269 CanFrom = CanFrom.getAs<MemberPointerType>()->getPointeeType();
1274 TyClass = CanTo->getTypeClass();
1275 if (TyClass != CanFrom->getTypeClass()) return false;
1276 if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto)
1280 const FunctionType *FromFn = cast<FunctionType>(CanFrom);
1281 FunctionType::ExtInfo EInfo = FromFn->getExtInfo();
1282 if (!EInfo.getNoReturn()) return false;
1284 FromFn = Context.adjustFunctionType(FromFn, EInfo.withNoReturn(false));
1285 assert(QualType(FromFn, 0).isCanonical());
1286 if (QualType(FromFn, 0) != CanTo) return false;
1292 /// \brief Determine whether the conversion from FromType to ToType is a valid
1293 /// vector conversion.
1295 /// \param ICK Will be set to the vector conversion kind, if this is a vector
1297 static bool IsVectorConversion(ASTContext &Context, QualType FromType,
1298 QualType ToType, ImplicitConversionKind &ICK) {
1299 // We need at least one of these types to be a vector type to have a vector
1301 if (!ToType->isVectorType() && !FromType->isVectorType())
1304 // Identical types require no conversions.
1305 if (Context.hasSameUnqualifiedType(FromType, ToType))
1308 // There are no conversions between extended vector types, only identity.
1309 if (ToType->isExtVectorType()) {
1310 // There are no conversions between extended vector types other than the
1311 // identity conversion.
1312 if (FromType->isExtVectorType())
1315 // Vector splat from any arithmetic type to a vector.
1316 if (FromType->isArithmeticType()) {
1317 ICK = ICK_Vector_Splat;
1322 // We can perform the conversion between vector types in the following cases:
1323 // 1)vector types are equivalent AltiVec and GCC vector types
1324 // 2)lax vector conversions are permitted and the vector types are of the
1326 if (ToType->isVectorType() && FromType->isVectorType()) {
1327 if (Context.areCompatibleVectorTypes(FromType, ToType) ||
1328 (Context.getLangOpts().LaxVectorConversions &&
1329 (Context.getTypeSize(FromType) == Context.getTypeSize(ToType)))) {
1330 ICK = ICK_Vector_Conversion;
1338 static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType,
1339 bool InOverloadResolution,
1340 StandardConversionSequence &SCS,
1343 /// IsStandardConversion - Determines whether there is a standard
1344 /// conversion sequence (C++ [conv], C++ [over.ics.scs]) from the
1345 /// expression From to the type ToType. Standard conversion sequences
1346 /// only consider non-class types; for conversions that involve class
1347 /// types, use TryImplicitConversion. If a conversion exists, SCS will
1348 /// contain the standard conversion sequence required to perform this
1349 /// conversion and this routine will return true. Otherwise, this
1350 /// routine will return false and the value of SCS is unspecified.
1351 static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
1352 bool InOverloadResolution,
1353 StandardConversionSequence &SCS,
1355 bool AllowObjCWritebackConversion) {
1356 QualType FromType = From->getType();
1358 // Standard conversions (C++ [conv])
1359 SCS.setAsIdentityConversion();
1360 SCS.DeprecatedStringLiteralToCharPtr = false;
1361 SCS.IncompatibleObjC = false;
1362 SCS.setFromType(FromType);
1363 SCS.CopyConstructor = 0;
1365 // There are no standard conversions for class types in C++, so
1366 // abort early. When overloading in C, however, we do permit
1367 if (FromType->isRecordType() || ToType->isRecordType()) {
1368 if (S.getLangOpts().CPlusPlus)
1371 // When we're overloading in C, we allow, as standard conversions,
1374 // The first conversion can be an lvalue-to-rvalue conversion,
1375 // array-to-pointer conversion, or function-to-pointer conversion
1378 if (FromType == S.Context.OverloadTy) {
1379 DeclAccessPair AccessPair;
1380 if (FunctionDecl *Fn
1381 = S.ResolveAddressOfOverloadedFunction(From, ToType, false,
1383 // We were able to resolve the address of the overloaded function,
1384 // so we can convert to the type of that function.
1385 FromType = Fn->getType();
1387 // we can sometimes resolve &foo<int> regardless of ToType, so check
1388 // if the type matches (identity) or we are converting to bool
1389 if (!S.Context.hasSameUnqualifiedType(
1390 S.ExtractUnqualifiedFunctionType(ToType), FromType)) {
1392 // if the function type matches except for [[noreturn]], it's ok
1393 if (!S.IsNoReturnConversion(FromType,
1394 S.ExtractUnqualifiedFunctionType(ToType), resultTy))
1395 // otherwise, only a boolean conversion is standard
1396 if (!ToType->isBooleanType())
1400 // Check if the "from" expression is taking the address of an overloaded
1401 // function and recompute the FromType accordingly. Take advantage of the
1402 // fact that non-static member functions *must* have such an address-of
1404 CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn);
1405 if (Method && !Method->isStatic()) {
1406 assert(isa<UnaryOperator>(From->IgnoreParens()) &&
1407 "Non-unary operator on non-static member address");
1408 assert(cast<UnaryOperator>(From->IgnoreParens())->getOpcode()
1410 "Non-address-of operator on non-static member address");
1411 const Type *ClassType
1412 = S.Context.getTypeDeclType(Method->getParent()).getTypePtr();
1413 FromType = S.Context.getMemberPointerType(FromType, ClassType);
1414 } else if (isa<UnaryOperator>(From->IgnoreParens())) {
1415 assert(cast<UnaryOperator>(From->IgnoreParens())->getOpcode() ==
1417 "Non-address-of operator for overloaded function expression");
1418 FromType = S.Context.getPointerType(FromType);
1421 // Check that we've computed the proper type after overload resolution.
1422 assert(S.Context.hasSameType(
1424 S.FixOverloadedFunctionReference(From, AccessPair, Fn)->getType()));
1429 // Lvalue-to-rvalue conversion (C++11 4.1):
1430 // A glvalue (3.10) of a non-function, non-array type T can
1431 // be converted to a prvalue.
1432 bool argIsLValue = From->isGLValue();
1434 !FromType->isFunctionType() && !FromType->isArrayType() &&
1435 S.Context.getCanonicalType(FromType) != S.Context.OverloadTy) {
1436 SCS.First = ICK_Lvalue_To_Rvalue;
1439 // ... if the lvalue has atomic type, the value has the non-atomic version
1440 // of the type of the lvalue ...
1441 if (const AtomicType *Atomic = FromType->getAs<AtomicType>())
1442 FromType = Atomic->getValueType();
1444 // If T is a non-class type, the type of the rvalue is the
1445 // cv-unqualified version of T. Otherwise, the type of the rvalue
1446 // is T (C++ 4.1p1). C++ can't get here with class types; in C, we
1447 // just strip the qualifiers because they don't matter.
1448 FromType = FromType.getUnqualifiedType();
1449 } else if (FromType->isArrayType()) {
1450 // Array-to-pointer conversion (C++ 4.2)
1451 SCS.First = ICK_Array_To_Pointer;
1453 // An lvalue or rvalue of type "array of N T" or "array of unknown
1454 // bound of T" can be converted to an rvalue of type "pointer to
1456 FromType = S.Context.getArrayDecayedType(FromType);
1458 if (S.IsStringLiteralToNonConstPointerConversion(From, ToType)) {
1459 // This conversion is deprecated. (C++ D.4).
1460 SCS.DeprecatedStringLiteralToCharPtr = true;
1462 // For the purpose of ranking in overload resolution
1463 // (13.3.3.1.1), this conversion is considered an
1464 // array-to-pointer conversion followed by a qualification
1465 // conversion (4.4). (C++ 4.2p2)
1466 SCS.Second = ICK_Identity;
1467 SCS.Third = ICK_Qualification;
1468 SCS.QualificationIncludesObjCLifetime = false;
1469 SCS.setAllToTypes(FromType);
1472 } else if (FromType->isFunctionType() && argIsLValue) {
1473 // Function-to-pointer conversion (C++ 4.3).
1474 SCS.First = ICK_Function_To_Pointer;
1476 // An lvalue of function type T can be converted to an rvalue of
1477 // type "pointer to T." The result is a pointer to the
1478 // function. (C++ 4.3p1).
1479 FromType = S.Context.getPointerType(FromType);
1481 // We don't require any conversions for the first step.
1482 SCS.First = ICK_Identity;
1484 SCS.setToType(0, FromType);
1486 // The second conversion can be an integral promotion, floating
1487 // point promotion, integral conversion, floating point conversion,
1488 // floating-integral conversion, pointer conversion,
1489 // pointer-to-member conversion, or boolean conversion (C++ 4p1).
1490 // For overloading in C, this can also be a "compatible-type"
1492 bool IncompatibleObjC = false;
1493 ImplicitConversionKind SecondICK = ICK_Identity;
1494 if (S.Context.hasSameUnqualifiedType(FromType, ToType)) {
1495 // The unqualified versions of the types are the same: there's no
1496 // conversion to do.
1497 SCS.Second = ICK_Identity;
1498 } else if (S.IsIntegralPromotion(From, FromType, ToType)) {
1499 // Integral promotion (C++ 4.5).
1500 SCS.Second = ICK_Integral_Promotion;
1501 FromType = ToType.getUnqualifiedType();
1502 } else if (S.IsFloatingPointPromotion(FromType, ToType)) {
1503 // Floating point promotion (C++ 4.6).
1504 SCS.Second = ICK_Floating_Promotion;
1505 FromType = ToType.getUnqualifiedType();
1506 } else if (S.IsComplexPromotion(FromType, ToType)) {
1507 // Complex promotion (Clang extension)
1508 SCS.Second = ICK_Complex_Promotion;
1509 FromType = ToType.getUnqualifiedType();
1510 } else if (ToType->isBooleanType() &&
1511 (FromType->isArithmeticType() ||
1512 FromType->isAnyPointerType() ||
1513 FromType->isBlockPointerType() ||
1514 FromType->isMemberPointerType() ||
1515 FromType->isNullPtrType())) {
1516 // Boolean conversions (C++ 4.12).
1517 SCS.Second = ICK_Boolean_Conversion;
1518 FromType = S.Context.BoolTy;
1519 } else if (FromType->isIntegralOrUnscopedEnumerationType() &&
1520 ToType->isIntegralType(S.Context)) {
1521 // Integral conversions (C++ 4.7).
1522 SCS.Second = ICK_Integral_Conversion;
1523 FromType = ToType.getUnqualifiedType();
1524 } else if (FromType->isAnyComplexType() && ToType->isComplexType()) {
1525 // Complex conversions (C99 6.3.1.6)
1526 SCS.Second = ICK_Complex_Conversion;
1527 FromType = ToType.getUnqualifiedType();
1528 } else if ((FromType->isAnyComplexType() && ToType->isArithmeticType()) ||
1529 (ToType->isAnyComplexType() && FromType->isArithmeticType())) {
1530 // Complex-real conversions (C99 6.3.1.7)
1531 SCS.Second = ICK_Complex_Real;
1532 FromType = ToType.getUnqualifiedType();
1533 } else if (FromType->isRealFloatingType() && ToType->isRealFloatingType()) {
1534 // Floating point conversions (C++ 4.8).
1535 SCS.Second = ICK_Floating_Conversion;
1536 FromType = ToType.getUnqualifiedType();
1537 } else if ((FromType->isRealFloatingType() &&
1538 ToType->isIntegralType(S.Context)) ||
1539 (FromType->isIntegralOrUnscopedEnumerationType() &&
1540 ToType->isRealFloatingType())) {
1541 // Floating-integral conversions (C++ 4.9).
1542 SCS.Second = ICK_Floating_Integral;
1543 FromType = ToType.getUnqualifiedType();
1544 } else if (S.IsBlockPointerConversion(FromType, ToType, FromType)) {
1545 SCS.Second = ICK_Block_Pointer_Conversion;
1546 } else if (AllowObjCWritebackConversion &&
1547 S.isObjCWritebackConversion(FromType, ToType, FromType)) {
1548 SCS.Second = ICK_Writeback_Conversion;
1549 } else if (S.IsPointerConversion(From, FromType, ToType, InOverloadResolution,
1550 FromType, IncompatibleObjC)) {
1551 // Pointer conversions (C++ 4.10).
1552 SCS.Second = ICK_Pointer_Conversion;
1553 SCS.IncompatibleObjC = IncompatibleObjC;
1554 FromType = FromType.getUnqualifiedType();
1555 } else if (S.IsMemberPointerConversion(From, FromType, ToType,
1556 InOverloadResolution, FromType)) {
1557 // Pointer to member conversions (4.11).
1558 SCS.Second = ICK_Pointer_Member;
1559 } else if (IsVectorConversion(S.Context, FromType, ToType, SecondICK)) {
1560 SCS.Second = SecondICK;
1561 FromType = ToType.getUnqualifiedType();
1562 } else if (!S.getLangOpts().CPlusPlus &&
1563 S.Context.typesAreCompatible(ToType, FromType)) {
1564 // Compatible conversions (Clang extension for C function overloading)
1565 SCS.Second = ICK_Compatible_Conversion;
1566 FromType = ToType.getUnqualifiedType();
1567 } else if (S.IsNoReturnConversion(FromType, ToType, FromType)) {
1568 // Treat a conversion that strips "noreturn" as an identity conversion.
1569 SCS.Second = ICK_NoReturn_Adjustment;
1570 } else if (IsTransparentUnionStandardConversion(S, From, ToType,
1571 InOverloadResolution,
1573 SCS.Second = ICK_TransparentUnionConversion;
1575 } else if (tryAtomicConversion(S, From, ToType, InOverloadResolution, SCS,
1577 // tryAtomicConversion has updated the standard conversion sequence
1581 // No second conversion required.
1582 SCS.Second = ICK_Identity;
1584 SCS.setToType(1, FromType);
1588 // The third conversion can be a qualification conversion (C++ 4p1).
1589 bool ObjCLifetimeConversion;
1590 if (S.IsQualificationConversion(FromType, ToType, CStyle,
1591 ObjCLifetimeConversion)) {
1592 SCS.Third = ICK_Qualification;
1593 SCS.QualificationIncludesObjCLifetime = ObjCLifetimeConversion;
1595 CanonFrom = S.Context.getCanonicalType(FromType);
1596 CanonTo = S.Context.getCanonicalType(ToType);
1598 // No conversion required
1599 SCS.Third = ICK_Identity;
1601 // C++ [over.best.ics]p6:
1602 // [...] Any difference in top-level cv-qualification is
1603 // subsumed by the initialization itself and does not constitute
1604 // a conversion. [...]
1605 CanonFrom = S.Context.getCanonicalType(FromType);
1606 CanonTo = S.Context.getCanonicalType(ToType);
1607 if (CanonFrom.getLocalUnqualifiedType()
1608 == CanonTo.getLocalUnqualifiedType() &&
1609 (CanonFrom.getLocalCVRQualifiers() != CanonTo.getLocalCVRQualifiers()
1610 || CanonFrom.getObjCGCAttr() != CanonTo.getObjCGCAttr()
1611 || CanonFrom.getObjCLifetime() != CanonTo.getObjCLifetime())) {
1613 CanonFrom = CanonTo;
1616 SCS.setToType(2, FromType);
1618 // If we have not converted the argument type to the parameter type,
1619 // this is a bad conversion sequence.
1620 if (CanonFrom != CanonTo)
1627 IsTransparentUnionStandardConversion(Sema &S, Expr* From,
1629 bool InOverloadResolution,
1630 StandardConversionSequence &SCS,
1633 const RecordType *UT = ToType->getAsUnionType();
1634 if (!UT || !UT->getDecl()->hasAttr<TransparentUnionAttr>())
1636 // The field to initialize within the transparent union.
1637 RecordDecl *UD = UT->getDecl();
1638 // It's compatible if the expression matches any of the fields.
1639 for (RecordDecl::field_iterator it = UD->field_begin(),
1640 itend = UD->field_end();
1641 it != itend; ++it) {
1642 if (IsStandardConversion(S, From, it->getType(), InOverloadResolution, SCS,
1643 CStyle, /*ObjCWritebackConversion=*/false)) {
1644 ToType = it->getType();
1651 /// IsIntegralPromotion - Determines whether the conversion from the
1652 /// expression From (whose potentially-adjusted type is FromType) to
1653 /// ToType is an integral promotion (C++ 4.5). If so, returns true and
1654 /// sets PromotedType to the promoted type.
1655 bool Sema::IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType) {
1656 const BuiltinType *To = ToType->getAs<BuiltinType>();
1657 // All integers are built-in.
1662 // An rvalue of type char, signed char, unsigned char, short int, or
1663 // unsigned short int can be converted to an rvalue of type int if
1664 // int can represent all the values of the source type; otherwise,
1665 // the source rvalue can be converted to an rvalue of type unsigned
1667 if (FromType->isPromotableIntegerType() && !FromType->isBooleanType() &&
1668 !FromType->isEnumeralType()) {
1669 if (// We can promote any signed, promotable integer type to an int
1670 (FromType->isSignedIntegerType() ||
1671 // We can promote any unsigned integer type whose size is
1672 // less than int to an int.
1673 (!FromType->isSignedIntegerType() &&
1674 Context.getTypeSize(FromType) < Context.getTypeSize(ToType)))) {
1675 return To->getKind() == BuiltinType::Int;
1678 return To->getKind() == BuiltinType::UInt;
1681 // C++11 [conv.prom]p3:
1682 // A prvalue of an unscoped enumeration type whose underlying type is not
1683 // fixed (7.2) can be converted to an rvalue a prvalue of the first of the
1684 // following types that can represent all the values of the enumeration
1685 // (i.e., the values in the range bmin to bmax as described in 7.2): int,
1686 // unsigned int, long int, unsigned long int, long long int, or unsigned
1687 // long long int. If none of the types in that list can represent all the
1688 // values of the enumeration, an rvalue a prvalue of an unscoped enumeration
1689 // type can be converted to an rvalue a prvalue of the extended integer type
1690 // with lowest integer conversion rank (4.13) greater than the rank of long
1691 // long in which all the values of the enumeration can be represented. If
1692 // there are two such extended types, the signed one is chosen.
1693 // C++11 [conv.prom]p4:
1694 // A prvalue of an unscoped enumeration type whose underlying type is fixed
1695 // can be converted to a prvalue of its underlying type. Moreover, if
1696 // integral promotion can be applied to its underlying type, a prvalue of an
1697 // unscoped enumeration type whose underlying type is fixed can also be
1698 // converted to a prvalue of the promoted underlying type.
1699 if (const EnumType *FromEnumType = FromType->getAs<EnumType>()) {
1700 // C++0x 7.2p9: Note that this implicit enum to int conversion is not
1701 // provided for a scoped enumeration.
1702 if (FromEnumType->getDecl()->isScoped())
1705 // We can perform an integral promotion to the underlying type of the enum,
1706 // even if that's not the promoted type.
1707 if (FromEnumType->getDecl()->isFixed()) {
1708 QualType Underlying = FromEnumType->getDecl()->getIntegerType();
1709 return Context.hasSameUnqualifiedType(Underlying, ToType) ||
1710 IsIntegralPromotion(From, Underlying, ToType);
1713 // We have already pre-calculated the promotion type, so this is trivial.
1714 if (ToType->isIntegerType() &&
1715 !RequireCompleteType(From->getLocStart(), FromType, 0))
1716 return Context.hasSameUnqualifiedType(ToType,
1717 FromEnumType->getDecl()->getPromotionType());
1720 // C++0x [conv.prom]p2:
1721 // A prvalue of type char16_t, char32_t, or wchar_t (3.9.1) can be converted
1722 // to an rvalue a prvalue of the first of the following types that can
1723 // represent all the values of its underlying type: int, unsigned int,
1724 // long int, unsigned long int, long long int, or unsigned long long int.
1725 // If none of the types in that list can represent all the values of its
1726 // underlying type, an rvalue a prvalue of type char16_t, char32_t,
1727 // or wchar_t can be converted to an rvalue a prvalue of its underlying
1729 if (FromType->isAnyCharacterType() && !FromType->isCharType() &&
1730 ToType->isIntegerType()) {
1731 // Determine whether the type we're converting from is signed or
1733 bool FromIsSigned = FromType->isSignedIntegerType();
1734 uint64_t FromSize = Context.getTypeSize(FromType);
1736 // The types we'll try to promote to, in the appropriate
1737 // order. Try each of these types.
1738 QualType PromoteTypes[6] = {
1739 Context.IntTy, Context.UnsignedIntTy,
1740 Context.LongTy, Context.UnsignedLongTy ,
1741 Context.LongLongTy, Context.UnsignedLongLongTy
1743 for (int Idx = 0; Idx < 6; ++Idx) {
1744 uint64_t ToSize = Context.getTypeSize(PromoteTypes[Idx]);
1745 if (FromSize < ToSize ||
1746 (FromSize == ToSize &&
1747 FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType())) {
1748 // We found the type that we can promote to. If this is the
1749 // type we wanted, we have a promotion. Otherwise, no
1751 return Context.hasSameUnqualifiedType(ToType, PromoteTypes[Idx]);
1756 // An rvalue for an integral bit-field (9.6) can be converted to an
1757 // rvalue of type int if int can represent all the values of the
1758 // bit-field; otherwise, it can be converted to unsigned int if
1759 // unsigned int can represent all the values of the bit-field. If
1760 // the bit-field is larger yet, no integral promotion applies to
1761 // it. If the bit-field has an enumerated type, it is treated as any
1762 // other value of that type for promotion purposes (C++ 4.5p3).
1763 // FIXME: We should delay checking of bit-fields until we actually perform the
1767 if (FieldDecl *MemberDecl = From->getBitField()) {
1769 if (FromType->isIntegralType(Context) &&
1770 MemberDecl->getBitWidth()->isIntegerConstantExpr(BitWidth, Context)) {
1771 APSInt ToSize(BitWidth.getBitWidth(), BitWidth.isUnsigned());
1772 ToSize = Context.getTypeSize(ToType);
1774 // Are we promoting to an int from a bitfield that fits in an int?
1775 if (BitWidth < ToSize ||
1776 (FromType->isSignedIntegerType() && BitWidth <= ToSize)) {
1777 return To->getKind() == BuiltinType::Int;
1780 // Are we promoting to an unsigned int from an unsigned bitfield
1781 // that fits into an unsigned int?
1782 if (FromType->isUnsignedIntegerType() && BitWidth <= ToSize) {
1783 return To->getKind() == BuiltinType::UInt;
1790 // An rvalue of type bool can be converted to an rvalue of type int,
1791 // with false becoming zero and true becoming one (C++ 4.5p4).
1792 if (FromType->isBooleanType() && To->getKind() == BuiltinType::Int) {
1799 /// IsFloatingPointPromotion - Determines whether the conversion from
1800 /// FromType to ToType is a floating point promotion (C++ 4.6). If so,
1801 /// returns true and sets PromotedType to the promoted type.
1802 bool Sema::IsFloatingPointPromotion(QualType FromType, QualType ToType) {
1803 if (const BuiltinType *FromBuiltin = FromType->getAs<BuiltinType>())
1804 if (const BuiltinType *ToBuiltin = ToType->getAs<BuiltinType>()) {
1805 /// An rvalue of type float can be converted to an rvalue of type
1806 /// double. (C++ 4.6p1).
1807 if (FromBuiltin->getKind() == BuiltinType::Float &&
1808 ToBuiltin->getKind() == BuiltinType::Double)
1812 // When a float is promoted to double or long double, or a
1813 // double is promoted to long double [...].
1814 if (!getLangOpts().CPlusPlus &&
1815 (FromBuiltin->getKind() == BuiltinType::Float ||
1816 FromBuiltin->getKind() == BuiltinType::Double) &&
1817 (ToBuiltin->getKind() == BuiltinType::LongDouble))
1820 // Half can be promoted to float.
1821 if (FromBuiltin->getKind() == BuiltinType::Half &&
1822 ToBuiltin->getKind() == BuiltinType::Float)
1829 /// \brief Determine if a conversion is a complex promotion.
1831 /// A complex promotion is defined as a complex -> complex conversion
1832 /// where the conversion between the underlying real types is a
1833 /// floating-point or integral promotion.
1834 bool Sema::IsComplexPromotion(QualType FromType, QualType ToType) {
1835 const ComplexType *FromComplex = FromType->getAs<ComplexType>();
1839 const ComplexType *ToComplex = ToType->getAs<ComplexType>();
1843 return IsFloatingPointPromotion(FromComplex->getElementType(),
1844 ToComplex->getElementType()) ||
1845 IsIntegralPromotion(0, FromComplex->getElementType(),
1846 ToComplex->getElementType());
1849 /// BuildSimilarlyQualifiedPointerType - In a pointer conversion from
1850 /// the pointer type FromPtr to a pointer to type ToPointee, with the
1851 /// same type qualifiers as FromPtr has on its pointee type. ToType,
1852 /// if non-empty, will be a pointer to ToType that may or may not have
1853 /// the right set of qualifiers on its pointee.
1856 BuildSimilarlyQualifiedPointerType(const Type *FromPtr,
1857 QualType ToPointee, QualType ToType,
1858 ASTContext &Context,
1859 bool StripObjCLifetime = false) {
1860 assert((FromPtr->getTypeClass() == Type::Pointer ||
1861 FromPtr->getTypeClass() == Type::ObjCObjectPointer) &&
1862 "Invalid similarly-qualified pointer type");
1864 /// Conversions to 'id' subsume cv-qualifier conversions.
1865 if (ToType->isObjCIdType() || ToType->isObjCQualifiedIdType())
1866 return ToType.getUnqualifiedType();
1868 QualType CanonFromPointee
1869 = Context.getCanonicalType(FromPtr->getPointeeType());
1870 QualType CanonToPointee = Context.getCanonicalType(ToPointee);
1871 Qualifiers Quals = CanonFromPointee.getQualifiers();
1873 if (StripObjCLifetime)
1874 Quals.removeObjCLifetime();
1876 // Exact qualifier match -> return the pointer type we're converting to.
1877 if (CanonToPointee.getLocalQualifiers() == Quals) {
1878 // ToType is exactly what we need. Return it.
1879 if (!ToType.isNull())
1880 return ToType.getUnqualifiedType();
1882 // Build a pointer to ToPointee. It has the right qualifiers
1884 if (isa<ObjCObjectPointerType>(ToType))
1885 return Context.getObjCObjectPointerType(ToPointee);
1886 return Context.getPointerType(ToPointee);
1889 // Just build a canonical type that has the right qualifiers.
1890 QualType QualifiedCanonToPointee
1891 = Context.getQualifiedType(CanonToPointee.getLocalUnqualifiedType(), Quals);
1893 if (isa<ObjCObjectPointerType>(ToType))
1894 return Context.getObjCObjectPointerType(QualifiedCanonToPointee);
1895 return Context.getPointerType(QualifiedCanonToPointee);
1898 static bool isNullPointerConstantForConversion(Expr *Expr,
1899 bool InOverloadResolution,
1900 ASTContext &Context) {
1901 // Handle value-dependent integral null pointer constants correctly.
1902 // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#903
1903 if (Expr->isValueDependent() && !Expr->isTypeDependent() &&
1904 Expr->getType()->isIntegerType() && !Expr->getType()->isEnumeralType())
1905 return !InOverloadResolution;
1907 return Expr->isNullPointerConstant(Context,
1908 InOverloadResolution? Expr::NPC_ValueDependentIsNotNull
1909 : Expr::NPC_ValueDependentIsNull);
1912 /// IsPointerConversion - Determines whether the conversion of the
1913 /// expression From, which has the (possibly adjusted) type FromType,
1914 /// can be converted to the type ToType via a pointer conversion (C++
1915 /// 4.10). If so, returns true and places the converted type (that
1916 /// might differ from ToType in its cv-qualifiers at some level) into
1919 /// This routine also supports conversions to and from block pointers
1920 /// and conversions with Objective-C's 'id', 'id<protocols...>', and
1921 /// pointers to interfaces. FIXME: Once we've determined the
1922 /// appropriate overloading rules for Objective-C, we may want to
1923 /// split the Objective-C checks into a different routine; however,
1924 /// GCC seems to consider all of these conversions to be pointer
1925 /// conversions, so for now they live here. IncompatibleObjC will be
1926 /// set if the conversion is an allowed Objective-C conversion that
1927 /// should result in a warning.
1928 bool Sema::IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
1929 bool InOverloadResolution,
1930 QualType& ConvertedType,
1931 bool &IncompatibleObjC) {
1932 IncompatibleObjC = false;
1933 if (isObjCPointerConversion(FromType, ToType, ConvertedType,
1937 // Conversion from a null pointer constant to any Objective-C pointer type.
1938 if (ToType->isObjCObjectPointerType() &&
1939 isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
1940 ConvertedType = ToType;
1944 // Blocks: Block pointers can be converted to void*.
1945 if (FromType->isBlockPointerType() && ToType->isPointerType() &&
1946 ToType->getAs<PointerType>()->getPointeeType()->isVoidType()) {
1947 ConvertedType = ToType;
1950 // Blocks: A null pointer constant can be converted to a block
1952 if (ToType->isBlockPointerType() &&
1953 isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
1954 ConvertedType = ToType;
1958 // If the left-hand-side is nullptr_t, the right side can be a null
1959 // pointer constant.
1960 if (ToType->isNullPtrType() &&
1961 isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
1962 ConvertedType = ToType;
1966 const PointerType* ToTypePtr = ToType->getAs<PointerType>();
1970 // A null pointer constant can be converted to a pointer type (C++ 4.10p1).
1971 if (isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
1972 ConvertedType = ToType;
1976 // Beyond this point, both types need to be pointers
1977 // , including objective-c pointers.
1978 QualType ToPointeeType = ToTypePtr->getPointeeType();
1979 if (FromType->isObjCObjectPointerType() && ToPointeeType->isVoidType() &&
1980 !getLangOpts().ObjCAutoRefCount) {
1981 ConvertedType = BuildSimilarlyQualifiedPointerType(
1982 FromType->getAs<ObjCObjectPointerType>(),
1987 const PointerType *FromTypePtr = FromType->getAs<PointerType>();
1991 QualType FromPointeeType = FromTypePtr->getPointeeType();
1993 // If the unqualified pointee types are the same, this can't be a
1994 // pointer conversion, so don't do all of the work below.
1995 if (Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType))
1998 // An rvalue of type "pointer to cv T," where T is an object type,
1999 // can be converted to an rvalue of type "pointer to cv void" (C++
2001 if (FromPointeeType->isIncompleteOrObjectType() &&
2002 ToPointeeType->isVoidType()) {
2003 ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2006 /*StripObjCLifetime=*/true);
2010 // MSVC allows implicit function to void* type conversion.
2011 if (getLangOpts().MicrosoftExt && FromPointeeType->isFunctionType() &&
2012 ToPointeeType->isVoidType()) {
2013 ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2019 // When we're overloading in C, we allow a special kind of pointer
2020 // conversion for compatible-but-not-identical pointee types.
2021 if (!getLangOpts().CPlusPlus &&
2022 Context.typesAreCompatible(FromPointeeType, ToPointeeType)) {
2023 ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2029 // C++ [conv.ptr]p3:
2031 // An rvalue of type "pointer to cv D," where D is a class type,
2032 // can be converted to an rvalue of type "pointer to cv B," where
2033 // B is a base class (clause 10) of D. If B is an inaccessible
2034 // (clause 11) or ambiguous (10.2) base class of D, a program that
2035 // necessitates this conversion is ill-formed. The result of the
2036 // conversion is a pointer to the base class sub-object of the
2037 // derived class object. The null pointer value is converted to
2038 // the null pointer value of the destination type.
2040 // Note that we do not check for ambiguity or inaccessibility
2041 // here. That is handled by CheckPointerConversion.
2042 if (getLangOpts().CPlusPlus &&
2043 FromPointeeType->isRecordType() && ToPointeeType->isRecordType() &&
2044 !Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType) &&
2045 !RequireCompleteType(From->getLocStart(), FromPointeeType, 0) &&
2046 IsDerivedFrom(FromPointeeType, ToPointeeType)) {
2047 ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2053 if (FromPointeeType->isVectorType() && ToPointeeType->isVectorType() &&
2054 Context.areCompatibleVectorTypes(FromPointeeType, ToPointeeType)) {
2055 ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2064 /// \brief Adopt the given qualifiers for the given type.
2065 static QualType AdoptQualifiers(ASTContext &Context, QualType T, Qualifiers Qs){
2066 Qualifiers TQs = T.getQualifiers();
2068 // Check whether qualifiers already match.
2072 if (Qs.compatiblyIncludes(TQs))
2073 return Context.getQualifiedType(T, Qs);
2075 return Context.getQualifiedType(T.getUnqualifiedType(), Qs);
2078 /// isObjCPointerConversion - Determines whether this is an
2079 /// Objective-C pointer conversion. Subroutine of IsPointerConversion,
2080 /// with the same arguments and return values.
2081 bool Sema::isObjCPointerConversion(QualType FromType, QualType ToType,
2082 QualType& ConvertedType,
2083 bool &IncompatibleObjC) {
2084 if (!getLangOpts().ObjC1)
2087 // The set of qualifiers on the type we're converting from.
2088 Qualifiers FromQualifiers = FromType.getQualifiers();
2090 // First, we handle all conversions on ObjC object pointer types.
2091 const ObjCObjectPointerType* ToObjCPtr =
2092 ToType->getAs<ObjCObjectPointerType>();
2093 const ObjCObjectPointerType *FromObjCPtr =
2094 FromType->getAs<ObjCObjectPointerType>();
2096 if (ToObjCPtr && FromObjCPtr) {
2097 // If the pointee types are the same (ignoring qualifications),
2098 // then this is not a pointer conversion.
2099 if (Context.hasSameUnqualifiedType(ToObjCPtr->getPointeeType(),
2100 FromObjCPtr->getPointeeType()))
2103 // Check for compatible
2104 // Objective C++: We're able to convert between "id" or "Class" and a
2105 // pointer to any interface (in both directions).
2106 if (ToObjCPtr->isObjCBuiltinType() && FromObjCPtr->isObjCBuiltinType()) {
2107 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2110 // Conversions with Objective-C's id<...>.
2111 if ((FromObjCPtr->isObjCQualifiedIdType() ||
2112 ToObjCPtr->isObjCQualifiedIdType()) &&
2113 Context.ObjCQualifiedIdTypesAreCompatible(ToType, FromType,
2114 /*compare=*/false)) {
2115 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2118 // Objective C++: We're able to convert from a pointer to an
2119 // interface to a pointer to a different interface.
2120 if (Context.canAssignObjCInterfaces(ToObjCPtr, FromObjCPtr)) {
2121 const ObjCInterfaceType* LHS = ToObjCPtr->getInterfaceType();
2122 const ObjCInterfaceType* RHS = FromObjCPtr->getInterfaceType();
2123 if (getLangOpts().CPlusPlus && LHS && RHS &&
2124 !ToObjCPtr->getPointeeType().isAtLeastAsQualifiedAs(
2125 FromObjCPtr->getPointeeType()))
2127 ConvertedType = BuildSimilarlyQualifiedPointerType(FromObjCPtr,
2128 ToObjCPtr->getPointeeType(),
2130 ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2134 if (Context.canAssignObjCInterfaces(FromObjCPtr, ToObjCPtr)) {
2135 // Okay: this is some kind of implicit downcast of Objective-C
2136 // interfaces, which is permitted. However, we're going to
2137 // complain about it.
2138 IncompatibleObjC = true;
2139 ConvertedType = BuildSimilarlyQualifiedPointerType(FromObjCPtr,
2140 ToObjCPtr->getPointeeType(),
2142 ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2146 // Beyond this point, both types need to be C pointers or block pointers.
2147 QualType ToPointeeType;
2148 if (const PointerType *ToCPtr = ToType->getAs<PointerType>())
2149 ToPointeeType = ToCPtr->getPointeeType();
2150 else if (const BlockPointerType *ToBlockPtr =
2151 ToType->getAs<BlockPointerType>()) {
2152 // Objective C++: We're able to convert from a pointer to any object
2153 // to a block pointer type.
2154 if (FromObjCPtr && FromObjCPtr->isObjCBuiltinType()) {
2155 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2158 ToPointeeType = ToBlockPtr->getPointeeType();
2160 else if (FromType->getAs<BlockPointerType>() &&
2161 ToObjCPtr && ToObjCPtr->isObjCBuiltinType()) {
2162 // Objective C++: We're able to convert from a block pointer type to a
2163 // pointer to any object.
2164 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2170 QualType FromPointeeType;
2171 if (const PointerType *FromCPtr = FromType->getAs<PointerType>())
2172 FromPointeeType = FromCPtr->getPointeeType();
2173 else if (const BlockPointerType *FromBlockPtr =
2174 FromType->getAs<BlockPointerType>())
2175 FromPointeeType = FromBlockPtr->getPointeeType();
2179 // If we have pointers to pointers, recursively check whether this
2180 // is an Objective-C conversion.
2181 if (FromPointeeType->isPointerType() && ToPointeeType->isPointerType() &&
2182 isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType,
2183 IncompatibleObjC)) {
2184 // We always complain about this conversion.
2185 IncompatibleObjC = true;
2186 ConvertedType = Context.getPointerType(ConvertedType);
2187 ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2190 // Allow conversion of pointee being objective-c pointer to another one;
2192 if (FromPointeeType->getAs<ObjCObjectPointerType>() &&
2193 ToPointeeType->getAs<ObjCObjectPointerType>() &&
2194 isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType,
2195 IncompatibleObjC)) {
2197 ConvertedType = Context.getPointerType(ConvertedType);
2198 ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2202 // If we have pointers to functions or blocks, check whether the only
2203 // differences in the argument and result types are in Objective-C
2204 // pointer conversions. If so, we permit the conversion (but
2205 // complain about it).
2206 const FunctionProtoType *FromFunctionType
2207 = FromPointeeType->getAs<FunctionProtoType>();
2208 const FunctionProtoType *ToFunctionType
2209 = ToPointeeType->getAs<FunctionProtoType>();
2210 if (FromFunctionType && ToFunctionType) {
2211 // If the function types are exactly the same, this isn't an
2212 // Objective-C pointer conversion.
2213 if (Context.getCanonicalType(FromPointeeType)
2214 == Context.getCanonicalType(ToPointeeType))
2217 // Perform the quick checks that will tell us whether these
2218 // function types are obviously different.
2219 if (FromFunctionType->getNumArgs() != ToFunctionType->getNumArgs() ||
2220 FromFunctionType->isVariadic() != ToFunctionType->isVariadic() ||
2221 FromFunctionType->getTypeQuals() != ToFunctionType->getTypeQuals())
2224 bool HasObjCConversion = false;
2225 if (Context.getCanonicalType(FromFunctionType->getResultType())
2226 == Context.getCanonicalType(ToFunctionType->getResultType())) {
2227 // Okay, the types match exactly. Nothing to do.
2228 } else if (isObjCPointerConversion(FromFunctionType->getResultType(),
2229 ToFunctionType->getResultType(),
2230 ConvertedType, IncompatibleObjC)) {
2231 // Okay, we have an Objective-C pointer conversion.
2232 HasObjCConversion = true;
2234 // Function types are too different. Abort.
2238 // Check argument types.
2239 for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumArgs();
2240 ArgIdx != NumArgs; ++ArgIdx) {
2241 QualType FromArgType = FromFunctionType->getArgType(ArgIdx);
2242 QualType ToArgType = ToFunctionType->getArgType(ArgIdx);
2243 if (Context.getCanonicalType(FromArgType)
2244 == Context.getCanonicalType(ToArgType)) {
2245 // Okay, the types match exactly. Nothing to do.
2246 } else if (isObjCPointerConversion(FromArgType, ToArgType,
2247 ConvertedType, IncompatibleObjC)) {
2248 // Okay, we have an Objective-C pointer conversion.
2249 HasObjCConversion = true;
2251 // Argument types are too different. Abort.
2256 if (HasObjCConversion) {
2257 // We had an Objective-C conversion. Allow this pointer
2258 // conversion, but complain about it.
2259 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2260 IncompatibleObjC = true;
2268 /// \brief Determine whether this is an Objective-C writeback conversion,
2269 /// used for parameter passing when performing automatic reference counting.
2271 /// \param FromType The type we're converting form.
2273 /// \param ToType The type we're converting to.
2275 /// \param ConvertedType The type that will be produced after applying
2276 /// this conversion.
2277 bool Sema::isObjCWritebackConversion(QualType FromType, QualType ToType,
2278 QualType &ConvertedType) {
2279 if (!getLangOpts().ObjCAutoRefCount ||
2280 Context.hasSameUnqualifiedType(FromType, ToType))
2283 // Parameter must be a pointer to __autoreleasing (with no other qualifiers).
2285 if (const PointerType *ToPointer = ToType->getAs<PointerType>())
2286 ToPointee = ToPointer->getPointeeType();
2290 Qualifiers ToQuals = ToPointee.getQualifiers();
2291 if (!ToPointee->isObjCLifetimeType() ||
2292 ToQuals.getObjCLifetime() != Qualifiers::OCL_Autoreleasing ||
2293 !ToQuals.withoutObjCLifetime().empty())
2296 // Argument must be a pointer to __strong to __weak.
2297 QualType FromPointee;
2298 if (const PointerType *FromPointer = FromType->getAs<PointerType>())
2299 FromPointee = FromPointer->getPointeeType();
2303 Qualifiers FromQuals = FromPointee.getQualifiers();
2304 if (!FromPointee->isObjCLifetimeType() ||
2305 (FromQuals.getObjCLifetime() != Qualifiers::OCL_Strong &&
2306 FromQuals.getObjCLifetime() != Qualifiers::OCL_Weak))
2309 // Make sure that we have compatible qualifiers.
2310 FromQuals.setObjCLifetime(Qualifiers::OCL_Autoreleasing);
2311 if (!ToQuals.compatiblyIncludes(FromQuals))
2314 // Remove qualifiers from the pointee type we're converting from; they
2315 // aren't used in the compatibility check belong, and we'll be adding back
2316 // qualifiers (with __autoreleasing) if the compatibility check succeeds.
2317 FromPointee = FromPointee.getUnqualifiedType();
2319 // The unqualified form of the pointee types must be compatible.
2320 ToPointee = ToPointee.getUnqualifiedType();
2321 bool IncompatibleObjC;
2322 if (Context.typesAreCompatible(FromPointee, ToPointee))
2323 FromPointee = ToPointee;
2324 else if (!isObjCPointerConversion(FromPointee, ToPointee, FromPointee,
2328 /// \brief Construct the type we're converting to, which is a pointer to
2329 /// __autoreleasing pointee.
2330 FromPointee = Context.getQualifiedType(FromPointee, FromQuals);
2331 ConvertedType = Context.getPointerType(FromPointee);
2335 bool Sema::IsBlockPointerConversion(QualType FromType, QualType ToType,
2336 QualType& ConvertedType) {
2337 QualType ToPointeeType;
2338 if (const BlockPointerType *ToBlockPtr =
2339 ToType->getAs<BlockPointerType>())
2340 ToPointeeType = ToBlockPtr->getPointeeType();
2344 QualType FromPointeeType;
2345 if (const BlockPointerType *FromBlockPtr =
2346 FromType->getAs<BlockPointerType>())
2347 FromPointeeType = FromBlockPtr->getPointeeType();
2350 // We have pointer to blocks, check whether the only
2351 // differences in the argument and result types are in Objective-C
2352 // pointer conversions. If so, we permit the conversion.
2354 const FunctionProtoType *FromFunctionType
2355 = FromPointeeType->getAs<FunctionProtoType>();
2356 const FunctionProtoType *ToFunctionType
2357 = ToPointeeType->getAs<FunctionProtoType>();
2359 if (!FromFunctionType || !ToFunctionType)
2362 if (Context.hasSameType(FromPointeeType, ToPointeeType))
2365 // Perform the quick checks that will tell us whether these
2366 // function types are obviously different.
2367 if (FromFunctionType->getNumArgs() != ToFunctionType->getNumArgs() ||
2368 FromFunctionType->isVariadic() != ToFunctionType->isVariadic())
2371 FunctionType::ExtInfo FromEInfo = FromFunctionType->getExtInfo();
2372 FunctionType::ExtInfo ToEInfo = ToFunctionType->getExtInfo();
2373 if (FromEInfo != ToEInfo)
2376 bool IncompatibleObjC = false;
2377 if (Context.hasSameType(FromFunctionType->getResultType(),
2378 ToFunctionType->getResultType())) {
2379 // Okay, the types match exactly. Nothing to do.
2381 QualType RHS = FromFunctionType->getResultType();
2382 QualType LHS = ToFunctionType->getResultType();
2383 if ((!getLangOpts().CPlusPlus || !RHS->isRecordType()) &&
2384 !RHS.hasQualifiers() && LHS.hasQualifiers())
2385 LHS = LHS.getUnqualifiedType();
2387 if (Context.hasSameType(RHS,LHS)) {
2389 } else if (isObjCPointerConversion(RHS, LHS,
2390 ConvertedType, IncompatibleObjC)) {
2391 if (IncompatibleObjC)
2393 // Okay, we have an Objective-C pointer conversion.
2399 // Check argument types.
2400 for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumArgs();
2401 ArgIdx != NumArgs; ++ArgIdx) {
2402 IncompatibleObjC = false;
2403 QualType FromArgType = FromFunctionType->getArgType(ArgIdx);
2404 QualType ToArgType = ToFunctionType->getArgType(ArgIdx);
2405 if (Context.hasSameType(FromArgType, ToArgType)) {
2406 // Okay, the types match exactly. Nothing to do.
2407 } else if (isObjCPointerConversion(ToArgType, FromArgType,
2408 ConvertedType, IncompatibleObjC)) {
2409 if (IncompatibleObjC)
2411 // Okay, we have an Objective-C pointer conversion.
2413 // Argument types are too different. Abort.
2416 if (LangOpts.ObjCAutoRefCount &&
2417 !Context.FunctionTypesMatchOnNSConsumedAttrs(FromFunctionType,
2421 ConvertedType = ToType;
2429 ft_parameter_mismatch,
2431 ft_qualifer_mismatch
2434 /// HandleFunctionTypeMismatch - Gives diagnostic information for differeing
2435 /// function types. Catches different number of parameter, mismatch in
2436 /// parameter types, and different return types.
2437 void Sema::HandleFunctionTypeMismatch(PartialDiagnostic &PDiag,
2438 QualType FromType, QualType ToType) {
2439 // If either type is not valid, include no extra info.
2440 if (FromType.isNull() || ToType.isNull()) {
2441 PDiag << ft_default;
2445 // Get the function type from the pointers.
2446 if (FromType->isMemberPointerType() && ToType->isMemberPointerType()) {
2447 const MemberPointerType *FromMember = FromType->getAs<MemberPointerType>(),
2448 *ToMember = ToType->getAs<MemberPointerType>();
2449 if (FromMember->getClass() != ToMember->getClass()) {
2450 PDiag << ft_different_class << QualType(ToMember->getClass(), 0)
2451 << QualType(FromMember->getClass(), 0);
2454 FromType = FromMember->getPointeeType();
2455 ToType = ToMember->getPointeeType();
2458 if (FromType->isPointerType())
2459 FromType = FromType->getPointeeType();
2460 if (ToType->isPointerType())
2461 ToType = ToType->getPointeeType();
2463 // Remove references.
2464 FromType = FromType.getNonReferenceType();
2465 ToType = ToType.getNonReferenceType();
2467 // Don't print extra info for non-specialized template functions.
2468 if (FromType->isInstantiationDependentType() &&
2469 !FromType->getAs<TemplateSpecializationType>()) {
2470 PDiag << ft_default;
2474 // No extra info for same types.
2475 if (Context.hasSameType(FromType, ToType)) {
2476 PDiag << ft_default;
2480 const FunctionProtoType *FromFunction = FromType->getAs<FunctionProtoType>(),
2481 *ToFunction = ToType->getAs<FunctionProtoType>();
2483 // Both types need to be function types.
2484 if (!FromFunction || !ToFunction) {
2485 PDiag << ft_default;
2489 if (FromFunction->getNumArgs() != ToFunction->getNumArgs()) {
2490 PDiag << ft_parameter_arity << ToFunction->getNumArgs()
2491 << FromFunction->getNumArgs();
2495 // Handle different parameter types.
2497 if (!FunctionArgTypesAreEqual(FromFunction, ToFunction, &ArgPos)) {
2498 PDiag << ft_parameter_mismatch << ArgPos + 1
2499 << ToFunction->getArgType(ArgPos)
2500 << FromFunction->getArgType(ArgPos);
2504 // Handle different return type.
2505 if (!Context.hasSameType(FromFunction->getResultType(),
2506 ToFunction->getResultType())) {
2507 PDiag << ft_return_type << ToFunction->getResultType()
2508 << FromFunction->getResultType();
2512 unsigned FromQuals = FromFunction->getTypeQuals(),
2513 ToQuals = ToFunction->getTypeQuals();
2514 if (FromQuals != ToQuals) {
2515 PDiag << ft_qualifer_mismatch << ToQuals << FromQuals;
2519 // Unable to find a difference, so add no extra info.
2520 PDiag << ft_default;
2523 /// FunctionArgTypesAreEqual - This routine checks two function proto types
2524 /// for equality of their argument types. Caller has already checked that
2525 /// they have same number of arguments. This routine assumes that Objective-C
2526 /// pointer types which only differ in their protocol qualifiers are equal.
2527 /// If the parameters are different, ArgPos will have the parameter index
2528 /// of the first different parameter.
2529 bool Sema::FunctionArgTypesAreEqual(const FunctionProtoType *OldType,
2530 const FunctionProtoType *NewType,
2532 if (!getLangOpts().ObjC1) {
2533 for (FunctionProtoType::arg_type_iterator O = OldType->arg_type_begin(),
2534 N = NewType->arg_type_begin(),
2535 E = OldType->arg_type_end(); O && (O != E); ++O, ++N) {
2536 if (!Context.hasSameType(*O, *N)) {
2537 if (ArgPos) *ArgPos = O - OldType->arg_type_begin();
2544 for (FunctionProtoType::arg_type_iterator O = OldType->arg_type_begin(),
2545 N = NewType->arg_type_begin(),
2546 E = OldType->arg_type_end(); O && (O != E); ++O, ++N) {
2547 QualType ToType = (*O);
2548 QualType FromType = (*N);
2549 if (!Context.hasSameType(ToType, FromType)) {
2550 if (const PointerType *PTTo = ToType->getAs<PointerType>()) {
2551 if (const PointerType *PTFr = FromType->getAs<PointerType>())
2552 if ((PTTo->getPointeeType()->isObjCQualifiedIdType() &&
2553 PTFr->getPointeeType()->isObjCQualifiedIdType()) ||
2554 (PTTo->getPointeeType()->isObjCQualifiedClassType() &&
2555 PTFr->getPointeeType()->isObjCQualifiedClassType()))
2558 else if (const ObjCObjectPointerType *PTTo =
2559 ToType->getAs<ObjCObjectPointerType>()) {
2560 if (const ObjCObjectPointerType *PTFr =
2561 FromType->getAs<ObjCObjectPointerType>())
2562 if (Context.hasSameUnqualifiedType(
2563 PTTo->getObjectType()->getBaseType(),
2564 PTFr->getObjectType()->getBaseType()))
2567 if (ArgPos) *ArgPos = O - OldType->arg_type_begin();
2574 /// CheckPointerConversion - Check the pointer conversion from the
2575 /// expression From to the type ToType. This routine checks for
2576 /// ambiguous or inaccessible derived-to-base pointer
2577 /// conversions for which IsPointerConversion has already returned
2578 /// true. It returns true and produces a diagnostic if there was an
2579 /// error, or returns false otherwise.
2580 bool Sema::CheckPointerConversion(Expr *From, QualType ToType,
2582 CXXCastPath& BasePath,
2583 bool IgnoreBaseAccess) {
2584 QualType FromType = From->getType();
2585 bool IsCStyleOrFunctionalCast = IgnoreBaseAccess;
2589 if (!IsCStyleOrFunctionalCast && !FromType->isAnyPointerType() &&
2590 From->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNotNull) ==
2591 Expr::NPCK_ZeroExpression) {
2592 if (Context.hasSameUnqualifiedType(From->getType(), Context.BoolTy))
2593 DiagRuntimeBehavior(From->getExprLoc(), From,
2594 PDiag(diag::warn_impcast_bool_to_null_pointer)
2595 << ToType << From->getSourceRange());
2596 else if (!isUnevaluatedContext())
2597 Diag(From->getExprLoc(), diag::warn_non_literal_null_pointer)
2598 << ToType << From->getSourceRange();
2600 if (const PointerType *ToPtrType = ToType->getAs<PointerType>()) {
2601 if (const PointerType *FromPtrType = FromType->getAs<PointerType>()) {
2602 QualType FromPointeeType = FromPtrType->getPointeeType(),
2603 ToPointeeType = ToPtrType->getPointeeType();
2605 if (FromPointeeType->isRecordType() && ToPointeeType->isRecordType() &&
2606 !Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType)) {
2607 // We must have a derived-to-base conversion. Check an
2608 // ambiguous or inaccessible conversion.
2609 if (CheckDerivedToBaseConversion(FromPointeeType, ToPointeeType,
2611 From->getSourceRange(), &BasePath,
2615 // The conversion was successful.
2616 Kind = CK_DerivedToBase;
2619 } else if (const ObjCObjectPointerType *ToPtrType =
2620 ToType->getAs<ObjCObjectPointerType>()) {
2621 if (const ObjCObjectPointerType *FromPtrType =
2622 FromType->getAs<ObjCObjectPointerType>()) {
2623 // Objective-C++ conversions are always okay.
2624 // FIXME: We should have a different class of conversions for the
2625 // Objective-C++ implicit conversions.
2626 if (FromPtrType->isObjCBuiltinType() || ToPtrType->isObjCBuiltinType())
2628 } else if (FromType->isBlockPointerType()) {
2629 Kind = CK_BlockPointerToObjCPointerCast;
2631 Kind = CK_CPointerToObjCPointerCast;
2633 } else if (ToType->isBlockPointerType()) {
2634 if (!FromType->isBlockPointerType())
2635 Kind = CK_AnyPointerToBlockPointerCast;
2638 // We shouldn't fall into this case unless it's valid for other
2640 if (From->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull))
2641 Kind = CK_NullToPointer;
2646 /// IsMemberPointerConversion - Determines whether the conversion of the
2647 /// expression From, which has the (possibly adjusted) type FromType, can be
2648 /// converted to the type ToType via a member pointer conversion (C++ 4.11).
2649 /// If so, returns true and places the converted type (that might differ from
2650 /// ToType in its cv-qualifiers at some level) into ConvertedType.
2651 bool Sema::IsMemberPointerConversion(Expr *From, QualType FromType,
2653 bool InOverloadResolution,
2654 QualType &ConvertedType) {
2655 const MemberPointerType *ToTypePtr = ToType->getAs<MemberPointerType>();
2659 // A null pointer constant can be converted to a member pointer (C++ 4.11p1)
2660 if (From->isNullPointerConstant(Context,
2661 InOverloadResolution? Expr::NPC_ValueDependentIsNotNull
2662 : Expr::NPC_ValueDependentIsNull)) {
2663 ConvertedType = ToType;
2667 // Otherwise, both types have to be member pointers.
2668 const MemberPointerType *FromTypePtr = FromType->getAs<MemberPointerType>();
2672 // A pointer to member of B can be converted to a pointer to member of D,
2673 // where D is derived from B (C++ 4.11p2).
2674 QualType FromClass(FromTypePtr->getClass(), 0);
2675 QualType ToClass(ToTypePtr->getClass(), 0);
2677 if (!Context.hasSameUnqualifiedType(FromClass, ToClass) &&
2678 !RequireCompleteType(From->getLocStart(), ToClass, 0) &&
2679 IsDerivedFrom(ToClass, FromClass)) {
2680 ConvertedType = Context.getMemberPointerType(FromTypePtr->getPointeeType(),
2681 ToClass.getTypePtr());
2688 /// CheckMemberPointerConversion - Check the member pointer conversion from the
2689 /// expression From to the type ToType. This routine checks for ambiguous or
2690 /// virtual or inaccessible base-to-derived member pointer conversions
2691 /// for which IsMemberPointerConversion has already returned true. It returns
2692 /// true and produces a diagnostic if there was an error, or returns false
2694 bool Sema::CheckMemberPointerConversion(Expr *From, QualType ToType,
2696 CXXCastPath &BasePath,
2697 bool IgnoreBaseAccess) {
2698 QualType FromType = From->getType();
2699 const MemberPointerType *FromPtrType = FromType->getAs<MemberPointerType>();
2701 // This must be a null pointer to member pointer conversion
2702 assert(From->isNullPointerConstant(Context,
2703 Expr::NPC_ValueDependentIsNull) &&
2704 "Expr must be null pointer constant!");
2705 Kind = CK_NullToMemberPointer;
2709 const MemberPointerType *ToPtrType = ToType->getAs<MemberPointerType>();
2710 assert(ToPtrType && "No member pointer cast has a target type "
2711 "that is not a member pointer.");
2713 QualType FromClass = QualType(FromPtrType->getClass(), 0);
2714 QualType ToClass = QualType(ToPtrType->getClass(), 0);
2716 // FIXME: What about dependent types?
2717 assert(FromClass->isRecordType() && "Pointer into non-class.");
2718 assert(ToClass->isRecordType() && "Pointer into non-class.");
2720 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
2721 /*DetectVirtual=*/true);
2722 bool DerivationOkay = IsDerivedFrom(ToClass, FromClass, Paths);
2723 assert(DerivationOkay &&
2724 "Should not have been called if derivation isn't OK.");
2725 (void)DerivationOkay;
2727 if (Paths.isAmbiguous(Context.getCanonicalType(FromClass).
2728 getUnqualifiedType())) {
2729 std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
2730 Diag(From->getExprLoc(), diag::err_ambiguous_memptr_conv)
2731 << 0 << FromClass << ToClass << PathDisplayStr << From->getSourceRange();
2735 if (const RecordType *VBase = Paths.getDetectedVirtual()) {
2736 Diag(From->getExprLoc(), diag::err_memptr_conv_via_virtual)
2737 << FromClass << ToClass << QualType(VBase, 0)
2738 << From->getSourceRange();
2742 if (!IgnoreBaseAccess)
2743 CheckBaseClassAccess(From->getExprLoc(), FromClass, ToClass,
2745 diag::err_downcast_from_inaccessible_base);
2747 // Must be a base to derived member conversion.
2748 BuildBasePathArray(Paths, BasePath);
2749 Kind = CK_BaseToDerivedMemberPointer;
2753 /// IsQualificationConversion - Determines whether the conversion from
2754 /// an rvalue of type FromType to ToType is a qualification conversion
2757 /// \param ObjCLifetimeConversion Output parameter that will be set to indicate
2758 /// when the qualification conversion involves a change in the Objective-C
2759 /// object lifetime.
2761 Sema::IsQualificationConversion(QualType FromType, QualType ToType,
2762 bool CStyle, bool &ObjCLifetimeConversion) {
2763 FromType = Context.getCanonicalType(FromType);
2764 ToType = Context.getCanonicalType(ToType);
2765 ObjCLifetimeConversion = false;
2767 // If FromType and ToType are the same type, this is not a
2768 // qualification conversion.
2769 if (FromType.getUnqualifiedType() == ToType.getUnqualifiedType())
2773 // A conversion can add cv-qualifiers at levels other than the first
2774 // in multi-level pointers, subject to the following rules: [...]
2775 bool PreviousToQualsIncludeConst = true;
2776 bool UnwrappedAnyPointer = false;
2777 while (Context.UnwrapSimilarPointerTypes(FromType, ToType)) {
2778 // Within each iteration of the loop, we check the qualifiers to
2779 // determine if this still looks like a qualification
2780 // conversion. Then, if all is well, we unwrap one more level of
2781 // pointers or pointers-to-members and do it all again
2782 // until there are no more pointers or pointers-to-members left to
2784 UnwrappedAnyPointer = true;
2786 Qualifiers FromQuals = FromType.getQualifiers();
2787 Qualifiers ToQuals = ToType.getQualifiers();
2790 // Check Objective-C lifetime conversions.
2791 if (FromQuals.getObjCLifetime() != ToQuals.getObjCLifetime() &&
2792 UnwrappedAnyPointer) {
2793 if (ToQuals.compatiblyIncludesObjCLifetime(FromQuals)) {
2794 ObjCLifetimeConversion = true;
2795 FromQuals.removeObjCLifetime();
2796 ToQuals.removeObjCLifetime();
2798 // Qualification conversions cannot cast between different
2799 // Objective-C lifetime qualifiers.
2804 // Allow addition/removal of GC attributes but not changing GC attributes.
2805 if (FromQuals.getObjCGCAttr() != ToQuals.getObjCGCAttr() &&
2806 (!FromQuals.hasObjCGCAttr() || !ToQuals.hasObjCGCAttr())) {
2807 FromQuals.removeObjCGCAttr();
2808 ToQuals.removeObjCGCAttr();
2811 // -- for every j > 0, if const is in cv 1,j then const is in cv
2812 // 2,j, and similarly for volatile.
2813 if (!CStyle && !ToQuals.compatiblyIncludes(FromQuals))
2816 // -- if the cv 1,j and cv 2,j are different, then const is in
2817 // every cv for 0 < k < j.
2818 if (!CStyle && FromQuals.getCVRQualifiers() != ToQuals.getCVRQualifiers()
2819 && !PreviousToQualsIncludeConst)
2822 // Keep track of whether all prior cv-qualifiers in the "to" type
2824 PreviousToQualsIncludeConst
2825 = PreviousToQualsIncludeConst && ToQuals.hasConst();
2828 // We are left with FromType and ToType being the pointee types
2829 // after unwrapping the original FromType and ToType the same number
2830 // of types. If we unwrapped any pointers, and if FromType and
2831 // ToType have the same unqualified type (since we checked
2832 // qualifiers above), then this is a qualification conversion.
2833 return UnwrappedAnyPointer && Context.hasSameUnqualifiedType(FromType,ToType);
2836 /// \brief - Determine whether this is a conversion from a scalar type to an
2839 /// If successful, updates \c SCS's second and third steps in the conversion
2840 /// sequence to finish the conversion.
2841 static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType,
2842 bool InOverloadResolution,
2843 StandardConversionSequence &SCS,
2845 const AtomicType *ToAtomic = ToType->getAs<AtomicType>();
2849 StandardConversionSequence InnerSCS;
2850 if (!IsStandardConversion(S, From, ToAtomic->getValueType(),
2851 InOverloadResolution, InnerSCS,
2852 CStyle, /*AllowObjCWritebackConversion=*/false))
2855 SCS.Second = InnerSCS.Second;
2856 SCS.setToType(1, InnerSCS.getToType(1));
2857 SCS.Third = InnerSCS.Third;
2858 SCS.QualificationIncludesObjCLifetime
2859 = InnerSCS.QualificationIncludesObjCLifetime;
2860 SCS.setToType(2, InnerSCS.getToType(2));
2864 static bool isFirstArgumentCompatibleWithType(ASTContext &Context,
2865 CXXConstructorDecl *Constructor,
2867 const FunctionProtoType *CtorType =
2868 Constructor->getType()->getAs<FunctionProtoType>();
2869 if (CtorType->getNumArgs() > 0) {
2870 QualType FirstArg = CtorType->getArgType(0);
2871 if (Context.hasSameUnqualifiedType(Type, FirstArg.getNonReferenceType()))
2877 static OverloadingResult
2878 IsInitializerListConstructorConversion(Sema &S, Expr *From, QualType ToType,
2880 UserDefinedConversionSequence &User,
2881 OverloadCandidateSet &CandidateSet,
2882 bool AllowExplicit) {
2883 DeclContext::lookup_iterator Con, ConEnd;
2884 for (llvm::tie(Con, ConEnd) = S.LookupConstructors(To);
2885 Con != ConEnd; ++Con) {
2886 NamedDecl *D = *Con;
2887 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
2889 // Find the constructor (which may be a template).
2890 CXXConstructorDecl *Constructor = 0;
2891 FunctionTemplateDecl *ConstructorTmpl
2892 = dyn_cast<FunctionTemplateDecl>(D);
2893 if (ConstructorTmpl)
2895 = cast<CXXConstructorDecl>(ConstructorTmpl->getTemplatedDecl());
2897 Constructor = cast<CXXConstructorDecl>(D);
2899 bool Usable = !Constructor->isInvalidDecl() &&
2900 S.isInitListConstructor(Constructor) &&
2901 (AllowExplicit || !Constructor->isExplicit());
2903 // If the first argument is (a reference to) the target type,
2904 // suppress conversions.
2905 bool SuppressUserConversions =
2906 isFirstArgumentCompatibleWithType(S.Context, Constructor, ToType);
2907 if (ConstructorTmpl)
2908 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
2911 SuppressUserConversions);
2913 S.AddOverloadCandidate(Constructor, FoundDecl,
2915 SuppressUserConversions);
2919 bool HadMultipleCandidates = (CandidateSet.size() > 1);
2921 OverloadCandidateSet::iterator Best;
2922 switch (CandidateSet.BestViableFunction(S, From->getLocStart(), Best, true)) {
2924 // Record the standard conversion we used and the conversion function.
2925 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function);
2926 QualType ThisType = Constructor->getThisType(S.Context);
2927 // Initializer lists don't have conversions as such.
2928 User.Before.setAsIdentityConversion();
2929 User.HadMultipleCandidates = HadMultipleCandidates;
2930 User.ConversionFunction = Constructor;
2931 User.FoundConversionFunction = Best->FoundDecl;
2932 User.After.setAsIdentityConversion();
2933 User.After.setFromType(ThisType->getAs<PointerType>()->getPointeeType());
2934 User.After.setAllToTypes(ToType);
2938 case OR_No_Viable_Function:
2939 return OR_No_Viable_Function;
2943 return OR_Ambiguous;
2946 llvm_unreachable("Invalid OverloadResult!");
2949 /// Determines whether there is a user-defined conversion sequence
2950 /// (C++ [over.ics.user]) that converts expression From to the type
2951 /// ToType. If such a conversion exists, User will contain the
2952 /// user-defined conversion sequence that performs such a conversion
2953 /// and this routine will return true. Otherwise, this routine returns
2954 /// false and User is unspecified.
2956 /// \param AllowExplicit true if the conversion should consider C++0x
2957 /// "explicit" conversion functions as well as non-explicit conversion
2958 /// functions (C++0x [class.conv.fct]p2).
2959 static OverloadingResult
2960 IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
2961 UserDefinedConversionSequence &User,
2962 OverloadCandidateSet &CandidateSet,
2963 bool AllowExplicit) {
2964 // Whether we will only visit constructors.
2965 bool ConstructorsOnly = false;
2967 // If the type we are conversion to is a class type, enumerate its
2969 if (const RecordType *ToRecordType = ToType->getAs<RecordType>()) {
2970 // C++ [over.match.ctor]p1:
2971 // When objects of class type are direct-initialized (8.5), or
2972 // copy-initialized from an expression of the same or a
2973 // derived class type (8.5), overload resolution selects the
2974 // constructor. [...] For copy-initialization, the candidate
2975 // functions are all the converting constructors (12.3.1) of
2976 // that class. The argument list is the expression-list within
2977 // the parentheses of the initializer.
2978 if (S.Context.hasSameUnqualifiedType(ToType, From->getType()) ||
2979 (From->getType()->getAs<RecordType>() &&
2980 S.IsDerivedFrom(From->getType(), ToType)))
2981 ConstructorsOnly = true;
2983 S.RequireCompleteType(From->getLocStart(), ToType, 0);
2984 // RequireCompleteType may have returned true due to some invalid decl
2985 // during template instantiation, but ToType may be complete enough now
2986 // to try to recover.
2987 if (ToType->isIncompleteType()) {
2988 // We're not going to find any constructors.
2989 } else if (CXXRecordDecl *ToRecordDecl
2990 = dyn_cast<CXXRecordDecl>(ToRecordType->getDecl())) {
2992 Expr **Args = &From;
2993 unsigned NumArgs = 1;
2994 bool ListInitializing = false;
2995 if (InitListExpr *InitList = dyn_cast<InitListExpr>(From)) {
2996 // But first, see if there is an init-list-contructor that will work.
2997 OverloadingResult Result = IsInitializerListConstructorConversion(
2998 S, From, ToType, ToRecordDecl, User, CandidateSet, AllowExplicit);
2999 if (Result != OR_No_Viable_Function)
3002 CandidateSet.clear();
3004 // If we're list-initializing, we pass the individual elements as
3005 // arguments, not the entire list.
3006 Args = InitList->getInits();
3007 NumArgs = InitList->getNumInits();
3008 ListInitializing = true;
3011 DeclContext::lookup_iterator Con, ConEnd;
3012 for (llvm::tie(Con, ConEnd) = S.LookupConstructors(ToRecordDecl);
3013 Con != ConEnd; ++Con) {
3014 NamedDecl *D = *Con;
3015 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
3017 // Find the constructor (which may be a template).
3018 CXXConstructorDecl *Constructor = 0;
3019 FunctionTemplateDecl *ConstructorTmpl
3020 = dyn_cast<FunctionTemplateDecl>(D);
3021 if (ConstructorTmpl)
3023 = cast<CXXConstructorDecl>(ConstructorTmpl->getTemplatedDecl());
3025 Constructor = cast<CXXConstructorDecl>(D);
3027 bool Usable = !Constructor->isInvalidDecl();
3028 if (ListInitializing)
3029 Usable = Usable && (AllowExplicit || !Constructor->isExplicit());
3031 Usable = Usable &&Constructor->isConvertingConstructor(AllowExplicit);
3033 bool SuppressUserConversions = !ConstructorsOnly;
3034 if (SuppressUserConversions && ListInitializing) {
3035 SuppressUserConversions = false;
3037 // If the first argument is (a reference to) the target type,
3038 // suppress conversions.
3039 SuppressUserConversions = isFirstArgumentCompatibleWithType(
3040 S.Context, Constructor, ToType);
3043 if (ConstructorTmpl)
3044 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
3046 llvm::makeArrayRef(Args, NumArgs),
3047 CandidateSet, SuppressUserConversions);
3049 // Allow one user-defined conversion when user specifies a
3050 // From->ToType conversion via an static cast (c-style, etc).
3051 S.AddOverloadCandidate(Constructor, FoundDecl,
3052 llvm::makeArrayRef(Args, NumArgs),
3053 CandidateSet, SuppressUserConversions);
3059 // Enumerate conversion functions, if we're allowed to.
3060 if (ConstructorsOnly || isa<InitListExpr>(From)) {
3061 } else if (S.RequireCompleteType(From->getLocStart(), From->getType(), 0)) {
3062 // No conversion functions from incomplete types.
3063 } else if (const RecordType *FromRecordType
3064 = From->getType()->getAs<RecordType>()) {
3065 if (CXXRecordDecl *FromRecordDecl
3066 = dyn_cast<CXXRecordDecl>(FromRecordType->getDecl())) {
3067 // Add all of the conversion functions as candidates.
3068 const UnresolvedSetImpl *Conversions
3069 = FromRecordDecl->getVisibleConversionFunctions();
3070 for (UnresolvedSetImpl::iterator I = Conversions->begin(),
3071 E = Conversions->end(); I != E; ++I) {
3072 DeclAccessPair FoundDecl = I.getPair();
3073 NamedDecl *D = FoundDecl.getDecl();
3074 CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext());
3075 if (isa<UsingShadowDecl>(D))
3076 D = cast<UsingShadowDecl>(D)->getTargetDecl();
3078 CXXConversionDecl *Conv;
3079 FunctionTemplateDecl *ConvTemplate;
3080 if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D)))
3081 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
3083 Conv = cast<CXXConversionDecl>(D);
3085 if (AllowExplicit || !Conv->isExplicit()) {
3087 S.AddTemplateConversionCandidate(ConvTemplate, FoundDecl,
3088 ActingContext, From, ToType,
3091 S.AddConversionCandidate(Conv, FoundDecl, ActingContext,
3092 From, ToType, CandidateSet);
3098 bool HadMultipleCandidates = (CandidateSet.size() > 1);
3100 OverloadCandidateSet::iterator Best;
3101 switch (CandidateSet.BestViableFunction(S, From->getLocStart(), Best, true)) {
3103 // Record the standard conversion we used and the conversion function.
3104 if (CXXConstructorDecl *Constructor
3105 = dyn_cast<CXXConstructorDecl>(Best->Function)) {
3106 // C++ [over.ics.user]p1:
3107 // If the user-defined conversion is specified by a
3108 // constructor (12.3.1), the initial standard conversion
3109 // sequence converts the source type to the type required by
3110 // the argument of the constructor.
3112 QualType ThisType = Constructor->getThisType(S.Context);
3113 if (isa<InitListExpr>(From)) {
3114 // Initializer lists don't have conversions as such.
3115 User.Before.setAsIdentityConversion();
3117 if (Best->Conversions[0].isEllipsis())
3118 User.EllipsisConversion = true;
3120 User.Before = Best->Conversions[0].Standard;
3121 User.EllipsisConversion = false;
3124 User.HadMultipleCandidates = HadMultipleCandidates;
3125 User.ConversionFunction = Constructor;
3126 User.FoundConversionFunction = Best->FoundDecl;
3127 User.After.setAsIdentityConversion();
3128 User.After.setFromType(ThisType->getAs<PointerType>()->getPointeeType());
3129 User.After.setAllToTypes(ToType);
3132 if (CXXConversionDecl *Conversion
3133 = dyn_cast<CXXConversionDecl>(Best->Function)) {
3134 // C++ [over.ics.user]p1:
3136 // [...] If the user-defined conversion is specified by a
3137 // conversion function (12.3.2), the initial standard
3138 // conversion sequence converts the source type to the
3139 // implicit object parameter of the conversion function.
3140 User.Before = Best->Conversions[0].Standard;
3141 User.HadMultipleCandidates = HadMultipleCandidates;
3142 User.ConversionFunction = Conversion;
3143 User.FoundConversionFunction = Best->FoundDecl;
3144 User.EllipsisConversion = false;
3146 // C++ [over.ics.user]p2:
3147 // The second standard conversion sequence converts the
3148 // result of the user-defined conversion to the target type
3149 // for the sequence. Since an implicit conversion sequence
3150 // is an initialization, the special rules for
3151 // initialization by user-defined conversion apply when
3152 // selecting the best user-defined conversion for a
3153 // user-defined conversion sequence (see 13.3.3 and
3155 User.After = Best->FinalConversion;
3158 llvm_unreachable("Not a constructor or conversion function?");
3160 case OR_No_Viable_Function:
3161 return OR_No_Viable_Function;
3163 // No conversion here! We're done.
3167 return OR_Ambiguous;
3170 llvm_unreachable("Invalid OverloadResult!");
3174 Sema::DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType) {
3175 ImplicitConversionSequence ICS;
3176 OverloadCandidateSet CandidateSet(From->getExprLoc());
3177 OverloadingResult OvResult =
3178 IsUserDefinedConversion(*this, From, ToType, ICS.UserDefined,
3179 CandidateSet, false);
3180 if (OvResult == OR_Ambiguous)
3181 Diag(From->getLocStart(),
3182 diag::err_typecheck_ambiguous_condition)
3183 << From->getType() << ToType << From->getSourceRange();
3184 else if (OvResult == OR_No_Viable_Function && !CandidateSet.empty())
3185 Diag(From->getLocStart(),
3186 diag::err_typecheck_nonviable_condition)
3187 << From->getType() << ToType << From->getSourceRange();
3190 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, From);
3194 /// \brief Compare the user-defined conversion functions or constructors
3195 /// of two user-defined conversion sequences to determine whether any ordering
3197 static ImplicitConversionSequence::CompareKind
3198 compareConversionFunctions(Sema &S,
3199 FunctionDecl *Function1,
3200 FunctionDecl *Function2) {
3201 if (!S.getLangOpts().ObjC1 || !S.getLangOpts().CPlusPlus0x)
3202 return ImplicitConversionSequence::Indistinguishable;
3205 // If both conversion functions are implicitly-declared conversions from
3206 // a lambda closure type to a function pointer and a block pointer,
3207 // respectively, always prefer the conversion to a function pointer,
3208 // because the function pointer is more lightweight and is more likely
3209 // to keep code working.
3210 CXXConversionDecl *Conv1 = dyn_cast<CXXConversionDecl>(Function1);
3212 return ImplicitConversionSequence::Indistinguishable;
3214 CXXConversionDecl *Conv2 = dyn_cast<CXXConversionDecl>(Function2);
3216 return ImplicitConversionSequence::Indistinguishable;
3218 if (Conv1->getParent()->isLambda() && Conv2->getParent()->isLambda()) {
3219 bool Block1 = Conv1->getConversionType()->isBlockPointerType();
3220 bool Block2 = Conv2->getConversionType()->isBlockPointerType();
3221 if (Block1 != Block2)
3222 return Block1? ImplicitConversionSequence::Worse
3223 : ImplicitConversionSequence::Better;
3226 return ImplicitConversionSequence::Indistinguishable;
3229 /// CompareImplicitConversionSequences - Compare two implicit
3230 /// conversion sequences to determine whether one is better than the
3231 /// other or if they are indistinguishable (C++ 13.3.3.2).
3232 static ImplicitConversionSequence::CompareKind
3233 CompareImplicitConversionSequences(Sema &S,
3234 const ImplicitConversionSequence& ICS1,
3235 const ImplicitConversionSequence& ICS2)
3237 // (C++ 13.3.3.2p2): When comparing the basic forms of implicit
3238 // conversion sequences (as defined in 13.3.3.1)
3239 // -- a standard conversion sequence (13.3.3.1.1) is a better
3240 // conversion sequence than a user-defined conversion sequence or
3241 // an ellipsis conversion sequence, and
3242 // -- a user-defined conversion sequence (13.3.3.1.2) is a better
3243 // conversion sequence than an ellipsis conversion sequence
3246 // C++0x [over.best.ics]p10:
3247 // For the purpose of ranking implicit conversion sequences as
3248 // described in 13.3.3.2, the ambiguous conversion sequence is
3249 // treated as a user-defined sequence that is indistinguishable
3250 // from any other user-defined conversion sequence.
3251 if (ICS1.getKindRank() < ICS2.getKindRank())
3252 return ImplicitConversionSequence::Better;
3253 if (ICS2.getKindRank() < ICS1.getKindRank())
3254 return ImplicitConversionSequence::Worse;
3256 // The following checks require both conversion sequences to be of
3258 if (ICS1.getKind() != ICS2.getKind())
3259 return ImplicitConversionSequence::Indistinguishable;
3261 ImplicitConversionSequence::CompareKind Result =
3262 ImplicitConversionSequence::Indistinguishable;
3264 // Two implicit conversion sequences of the same form are
3265 // indistinguishable conversion sequences unless one of the
3266 // following rules apply: (C++ 13.3.3.2p3):
3267 if (ICS1.isStandard())
3268 Result = CompareStandardConversionSequences(S,
3269 ICS1.Standard, ICS2.Standard);
3270 else if (ICS1.isUserDefined()) {
3271 // User-defined conversion sequence U1 is a better conversion
3272 // sequence than another user-defined conversion sequence U2 if
3273 // they contain the same user-defined conversion function or
3274 // constructor and if the second standard conversion sequence of
3275 // U1 is better than the second standard conversion sequence of
3276 // U2 (C++ 13.3.3.2p3).
3277 if (ICS1.UserDefined.ConversionFunction ==
3278 ICS2.UserDefined.ConversionFunction)
3279 Result = CompareStandardConversionSequences(S,
3280 ICS1.UserDefined.After,
3281 ICS2.UserDefined.After);
3283 Result = compareConversionFunctions(S,
3284 ICS1.UserDefined.ConversionFunction,
3285 ICS2.UserDefined.ConversionFunction);
3288 // List-initialization sequence L1 is a better conversion sequence than
3289 // list-initialization sequence L2 if L1 converts to std::initializer_list<X>
3290 // for some X and L2 does not.
3291 if (Result == ImplicitConversionSequence::Indistinguishable &&
3293 ICS1.isListInitializationSequence() &&
3294 ICS2.isListInitializationSequence()) {
3295 if (ICS1.isStdInitializerListElement() &&
3296 !ICS2.isStdInitializerListElement())
3297 return ImplicitConversionSequence::Better;
3298 if (!ICS1.isStdInitializerListElement() &&
3299 ICS2.isStdInitializerListElement())
3300 return ImplicitConversionSequence::Worse;
3306 static bool hasSimilarType(ASTContext &Context, QualType T1, QualType T2) {
3307 while (Context.UnwrapSimilarPointerTypes(T1, T2)) {
3309 T1 = Context.getUnqualifiedArrayType(T1, Quals);
3310 T2 = Context.getUnqualifiedArrayType(T2, Quals);
3313 return Context.hasSameUnqualifiedType(T1, T2);
3316 // Per 13.3.3.2p3, compare the given standard conversion sequences to
3317 // determine if one is a proper subset of the other.
3318 static ImplicitConversionSequence::CompareKind
3319 compareStandardConversionSubsets(ASTContext &Context,
3320 const StandardConversionSequence& SCS1,
3321 const StandardConversionSequence& SCS2) {
3322 ImplicitConversionSequence::CompareKind Result
3323 = ImplicitConversionSequence::Indistinguishable;
3325 // the identity conversion sequence is considered to be a subsequence of
3326 // any non-identity conversion sequence
3327 if (SCS1.isIdentityConversion() && !SCS2.isIdentityConversion())
3328 return ImplicitConversionSequence::Better;
3329 else if (!SCS1.isIdentityConversion() && SCS2.isIdentityConversion())
3330 return ImplicitConversionSequence::Worse;
3332 if (SCS1.Second != SCS2.Second) {
3333 if (SCS1.Second == ICK_Identity)
3334 Result = ImplicitConversionSequence::Better;
3335 else if (SCS2.Second == ICK_Identity)
3336 Result = ImplicitConversionSequence::Worse;
3338 return ImplicitConversionSequence::Indistinguishable;
3339 } else if (!hasSimilarType(Context, SCS1.getToType(1), SCS2.getToType(1)))
3340 return ImplicitConversionSequence::Indistinguishable;
3342 if (SCS1.Third == SCS2.Third) {
3343 return Context.hasSameType(SCS1.getToType(2), SCS2.getToType(2))? Result
3344 : ImplicitConversionSequence::Indistinguishable;
3347 if (SCS1.Third == ICK_Identity)
3348 return Result == ImplicitConversionSequence::Worse
3349 ? ImplicitConversionSequence::Indistinguishable
3350 : ImplicitConversionSequence::Better;
3352 if (SCS2.Third == ICK_Identity)
3353 return Result == ImplicitConversionSequence::Better
3354 ? ImplicitConversionSequence::Indistinguishable
3355 : ImplicitConversionSequence::Worse;
3357 return ImplicitConversionSequence::Indistinguishable;
3360 /// \brief Determine whether one of the given reference bindings is better
3361 /// than the other based on what kind of bindings they are.
3362 static bool isBetterReferenceBindingKind(const StandardConversionSequence &SCS1,
3363 const StandardConversionSequence &SCS2) {
3364 // C++0x [over.ics.rank]p3b4:
3365 // -- S1 and S2 are reference bindings (8.5.3) and neither refers to an
3366 // implicit object parameter of a non-static member function declared
3367 // without a ref-qualifier, and *either* S1 binds an rvalue reference
3368 // to an rvalue and S2 binds an lvalue reference *or S1 binds an
3369 // lvalue reference to a function lvalue and S2 binds an rvalue
3372 // FIXME: Rvalue references. We're going rogue with the above edits,
3373 // because the semantics in the current C++0x working paper (N3225 at the
3374 // time of this writing) break the standard definition of std::forward
3375 // and std::reference_wrapper when dealing with references to functions.
3376 // Proposed wording changes submitted to CWG for consideration.
3377 if (SCS1.BindsImplicitObjectArgumentWithoutRefQualifier ||
3378 SCS2.BindsImplicitObjectArgumentWithoutRefQualifier)
3381 return (!SCS1.IsLvalueReference && SCS1.BindsToRvalue &&
3382 SCS2.IsLvalueReference) ||
3383 (SCS1.IsLvalueReference && SCS1.BindsToFunctionLvalue &&
3384 !SCS2.IsLvalueReference);
3387 /// CompareStandardConversionSequences - Compare two standard
3388 /// conversion sequences to determine whether one is better than the
3389 /// other or if they are indistinguishable (C++ 13.3.3.2p3).
3390 static ImplicitConversionSequence::CompareKind
3391 CompareStandardConversionSequences(Sema &S,
3392 const StandardConversionSequence& SCS1,
3393 const StandardConversionSequence& SCS2)
3395 // Standard conversion sequence S1 is a better conversion sequence
3396 // than standard conversion sequence S2 if (C++ 13.3.3.2p3):
3398 // -- S1 is a proper subsequence of S2 (comparing the conversion
3399 // sequences in the canonical form defined by 13.3.3.1.1,
3400 // excluding any Lvalue Transformation; the identity conversion
3401 // sequence is considered to be a subsequence of any
3402 // non-identity conversion sequence) or, if not that,
3403 if (ImplicitConversionSequence::CompareKind CK
3404 = compareStandardConversionSubsets(S.Context, SCS1, SCS2))
3407 // -- the rank of S1 is better than the rank of S2 (by the rules
3408 // defined below), or, if not that,
3409 ImplicitConversionRank Rank1 = SCS1.getRank();
3410 ImplicitConversionRank Rank2 = SCS2.getRank();
3412 return ImplicitConversionSequence::Better;
3413 else if (Rank2 < Rank1)
3414 return ImplicitConversionSequence::Worse;
3416 // (C++ 13.3.3.2p4): Two conversion sequences with the same rank
3417 // are indistinguishable unless one of the following rules
3420 // A conversion that is not a conversion of a pointer, or
3421 // pointer to member, to bool is better than another conversion
3422 // that is such a conversion.
3423 if (SCS1.isPointerConversionToBool() != SCS2.isPointerConversionToBool())
3424 return SCS2.isPointerConversionToBool()
3425 ? ImplicitConversionSequence::Better
3426 : ImplicitConversionSequence::Worse;
3428 // C++ [over.ics.rank]p4b2:
3430 // If class B is derived directly or indirectly from class A,
3431 // conversion of B* to A* is better than conversion of B* to
3432 // void*, and conversion of A* to void* is better than conversion
3434 bool SCS1ConvertsToVoid
3435 = SCS1.isPointerConversionToVoidPointer(S.Context);
3436 bool SCS2ConvertsToVoid
3437 = SCS2.isPointerConversionToVoidPointer(S.Context);
3438 if (SCS1ConvertsToVoid != SCS2ConvertsToVoid) {
3439 // Exactly one of the conversion sequences is a conversion to
3440 // a void pointer; it's the worse conversion.
3441 return SCS2ConvertsToVoid ? ImplicitConversionSequence::Better
3442 : ImplicitConversionSequence::Worse;
3443 } else if (!SCS1ConvertsToVoid && !SCS2ConvertsToVoid) {
3444 // Neither conversion sequence converts to a void pointer; compare
3445 // their derived-to-base conversions.
3446 if (ImplicitConversionSequence::CompareKind DerivedCK
3447 = CompareDerivedToBaseConversions(S, SCS1, SCS2))
3449 } else if (SCS1ConvertsToVoid && SCS2ConvertsToVoid &&
3450 !S.Context.hasSameType(SCS1.getFromType(), SCS2.getFromType())) {
3451 // Both conversion sequences are conversions to void
3452 // pointers. Compare the source types to determine if there's an
3453 // inheritance relationship in their sources.
3454 QualType FromType1 = SCS1.getFromType();
3455 QualType FromType2 = SCS2.getFromType();
3457 // Adjust the types we're converting from via the array-to-pointer
3458 // conversion, if we need to.
3459 if (SCS1.First == ICK_Array_To_Pointer)
3460 FromType1 = S.Context.getArrayDecayedType(FromType1);
3461 if (SCS2.First == ICK_Array_To_Pointer)
3462 FromType2 = S.Context.getArrayDecayedType(FromType2);
3464 QualType FromPointee1 = FromType1->getPointeeType().getUnqualifiedType();
3465 QualType FromPointee2 = FromType2->getPointeeType().getUnqualifiedType();
3467 if (S.IsDerivedFrom(FromPointee2, FromPointee1))
3468 return ImplicitConversionSequence::Better;
3469 else if (S.IsDerivedFrom(FromPointee1, FromPointee2))
3470 return ImplicitConversionSequence::Worse;
3472 // Objective-C++: If one interface is more specific than the
3473 // other, it is the better one.
3474 const ObjCObjectPointerType* FromObjCPtr1
3475 = FromType1->getAs<ObjCObjectPointerType>();
3476 const ObjCObjectPointerType* FromObjCPtr2
3477 = FromType2->getAs<ObjCObjectPointerType>();
3478 if (FromObjCPtr1 && FromObjCPtr2) {
3479 bool AssignLeft = S.Context.canAssignObjCInterfaces(FromObjCPtr1,
3481 bool AssignRight = S.Context.canAssignObjCInterfaces(FromObjCPtr2,
3483 if (AssignLeft != AssignRight) {
3484 return AssignLeft? ImplicitConversionSequence::Better
3485 : ImplicitConversionSequence::Worse;
3490 // Compare based on qualification conversions (C++ 13.3.3.2p3,
3492 if (ImplicitConversionSequence::CompareKind QualCK
3493 = CompareQualificationConversions(S, SCS1, SCS2))
3496 if (SCS1.ReferenceBinding && SCS2.ReferenceBinding) {
3497 // Check for a better reference binding based on the kind of bindings.
3498 if (isBetterReferenceBindingKind(SCS1, SCS2))
3499 return ImplicitConversionSequence::Better;
3500 else if (isBetterReferenceBindingKind(SCS2, SCS1))
3501 return ImplicitConversionSequence::Worse;
3503 // C++ [over.ics.rank]p3b4:
3504 // -- S1 and S2 are reference bindings (8.5.3), and the types to
3505 // which the references refer are the same type except for
3506 // top-level cv-qualifiers, and the type to which the reference
3507 // initialized by S2 refers is more cv-qualified than the type
3508 // to which the reference initialized by S1 refers.
3509 QualType T1 = SCS1.getToType(2);
3510 QualType T2 = SCS2.getToType(2);
3511 T1 = S.Context.getCanonicalType(T1);
3512 T2 = S.Context.getCanonicalType(T2);
3513 Qualifiers T1Quals, T2Quals;
3514 QualType UnqualT1 = S.Context.getUnqualifiedArrayType(T1, T1Quals);
3515 QualType UnqualT2 = S.Context.getUnqualifiedArrayType(T2, T2Quals);
3516 if (UnqualT1 == UnqualT2) {
3517 // Objective-C++ ARC: If the references refer to objects with different
3518 // lifetimes, prefer bindings that don't change lifetime.
3519 if (SCS1.ObjCLifetimeConversionBinding !=
3520 SCS2.ObjCLifetimeConversionBinding) {
3521 return SCS1.ObjCLifetimeConversionBinding
3522 ? ImplicitConversionSequence::Worse
3523 : ImplicitConversionSequence::Better;
3526 // If the type is an array type, promote the element qualifiers to the
3527 // type for comparison.
3528 if (isa<ArrayType>(T1) && T1Quals)
3529 T1 = S.Context.getQualifiedType(UnqualT1, T1Quals);
3530 if (isa<ArrayType>(T2) && T2Quals)
3531 T2 = S.Context.getQualifiedType(UnqualT2, T2Quals);
3532 if (T2.isMoreQualifiedThan(T1))
3533 return ImplicitConversionSequence::Better;
3534 else if (T1.isMoreQualifiedThan(T2))
3535 return ImplicitConversionSequence::Worse;
3539 // In Microsoft mode, prefer an integral conversion to a
3540 // floating-to-integral conversion if the integral conversion
3541 // is between types of the same size.
3549 // Here, MSVC will call f(int) instead of generating a compile error
3550 // as clang will do in standard mode.
3551 if (S.getLangOpts().MicrosoftMode &&
3552 SCS1.Second == ICK_Integral_Conversion &&
3553 SCS2.Second == ICK_Floating_Integral &&
3554 S.Context.getTypeSize(SCS1.getFromType()) ==
3555 S.Context.getTypeSize(SCS1.getToType(2)))
3556 return ImplicitConversionSequence::Better;
3558 return ImplicitConversionSequence::Indistinguishable;
3561 /// CompareQualificationConversions - Compares two standard conversion
3562 /// sequences to determine whether they can be ranked based on their
3563 /// qualification conversions (C++ 13.3.3.2p3 bullet 3).
3564 ImplicitConversionSequence::CompareKind
3565 CompareQualificationConversions(Sema &S,
3566 const StandardConversionSequence& SCS1,
3567 const StandardConversionSequence& SCS2) {
3569 // -- S1 and S2 differ only in their qualification conversion and
3570 // yield similar types T1 and T2 (C++ 4.4), respectively, and the
3571 // cv-qualification signature of type T1 is a proper subset of
3572 // the cv-qualification signature of type T2, and S1 is not the
3573 // deprecated string literal array-to-pointer conversion (4.2).
3574 if (SCS1.First != SCS2.First || SCS1.Second != SCS2.Second ||
3575 SCS1.Third != SCS2.Third || SCS1.Third != ICK_Qualification)
3576 return ImplicitConversionSequence::Indistinguishable;
3578 // FIXME: the example in the standard doesn't use a qualification
3580 QualType T1 = SCS1.getToType(2);
3581 QualType T2 = SCS2.getToType(2);
3582 T1 = S.Context.getCanonicalType(T1);
3583 T2 = S.Context.getCanonicalType(T2);
3584 Qualifiers T1Quals, T2Quals;
3585 QualType UnqualT1 = S.Context.getUnqualifiedArrayType(T1, T1Quals);
3586 QualType UnqualT2 = S.Context.getUnqualifiedArrayType(T2, T2Quals);
3588 // If the types are the same, we won't learn anything by unwrapped
3590 if (UnqualT1 == UnqualT2)
3591 return ImplicitConversionSequence::Indistinguishable;
3593 // If the type is an array type, promote the element qualifiers to the type
3595 if (isa<ArrayType>(T1) && T1Quals)
3596 T1 = S.Context.getQualifiedType(UnqualT1, T1Quals);
3597 if (isa<ArrayType>(T2) && T2Quals)
3598 T2 = S.Context.getQualifiedType(UnqualT2, T2Quals);
3600 ImplicitConversionSequence::CompareKind Result
3601 = ImplicitConversionSequence::Indistinguishable;
3603 // Objective-C++ ARC:
3604 // Prefer qualification conversions not involving a change in lifetime
3605 // to qualification conversions that do not change lifetime.
3606 if (SCS1.QualificationIncludesObjCLifetime !=
3607 SCS2.QualificationIncludesObjCLifetime) {
3608 Result = SCS1.QualificationIncludesObjCLifetime
3609 ? ImplicitConversionSequence::Worse
3610 : ImplicitConversionSequence::Better;
3613 while (S.Context.UnwrapSimilarPointerTypes(T1, T2)) {
3614 // Within each iteration of the loop, we check the qualifiers to
3615 // determine if this still looks like a qualification
3616 // conversion. Then, if all is well, we unwrap one more level of
3617 // pointers or pointers-to-members and do it all again
3618 // until there are no more pointers or pointers-to-members left
3619 // to unwrap. This essentially mimics what
3620 // IsQualificationConversion does, but here we're checking for a
3621 // strict subset of qualifiers.
3622 if (T1.getCVRQualifiers() == T2.getCVRQualifiers())
3623 // The qualifiers are the same, so this doesn't tell us anything
3624 // about how the sequences rank.
3626 else if (T2.isMoreQualifiedThan(T1)) {
3627 // T1 has fewer qualifiers, so it could be the better sequence.
3628 if (Result == ImplicitConversionSequence::Worse)
3629 // Neither has qualifiers that are a subset of the other's
3631 return ImplicitConversionSequence::Indistinguishable;
3633 Result = ImplicitConversionSequence::Better;
3634 } else if (T1.isMoreQualifiedThan(T2)) {
3635 // T2 has fewer qualifiers, so it could be the better sequence.
3636 if (Result == ImplicitConversionSequence::Better)
3637 // Neither has qualifiers that are a subset of the other's
3639 return ImplicitConversionSequence::Indistinguishable;
3641 Result = ImplicitConversionSequence::Worse;
3643 // Qualifiers are disjoint.
3644 return ImplicitConversionSequence::Indistinguishable;
3647 // If the types after this point are equivalent, we're done.
3648 if (S.Context.hasSameUnqualifiedType(T1, T2))
3652 // Check that the winning standard conversion sequence isn't using
3653 // the deprecated string literal array to pointer conversion.
3655 case ImplicitConversionSequence::Better:
3656 if (SCS1.DeprecatedStringLiteralToCharPtr)
3657 Result = ImplicitConversionSequence::Indistinguishable;
3660 case ImplicitConversionSequence::Indistinguishable:
3663 case ImplicitConversionSequence::Worse:
3664 if (SCS2.DeprecatedStringLiteralToCharPtr)
3665 Result = ImplicitConversionSequence::Indistinguishable;
3672 /// CompareDerivedToBaseConversions - Compares two standard conversion
3673 /// sequences to determine whether they can be ranked based on their
3674 /// various kinds of derived-to-base conversions (C++
3675 /// [over.ics.rank]p4b3). As part of these checks, we also look at
3676 /// conversions between Objective-C interface types.
3677 ImplicitConversionSequence::CompareKind
3678 CompareDerivedToBaseConversions(Sema &S,
3679 const StandardConversionSequence& SCS1,
3680 const StandardConversionSequence& SCS2) {
3681 QualType FromType1 = SCS1.getFromType();
3682 QualType ToType1 = SCS1.getToType(1);
3683 QualType FromType2 = SCS2.getFromType();
3684 QualType ToType2 = SCS2.getToType(1);
3686 // Adjust the types we're converting from via the array-to-pointer
3687 // conversion, if we need to.
3688 if (SCS1.First == ICK_Array_To_Pointer)
3689 FromType1 = S.Context.getArrayDecayedType(FromType1);
3690 if (SCS2.First == ICK_Array_To_Pointer)
3691 FromType2 = S.Context.getArrayDecayedType(FromType2);
3693 // Canonicalize all of the types.
3694 FromType1 = S.Context.getCanonicalType(FromType1);
3695 ToType1 = S.Context.getCanonicalType(ToType1);
3696 FromType2 = S.Context.getCanonicalType(FromType2);
3697 ToType2 = S.Context.getCanonicalType(ToType2);
3699 // C++ [over.ics.rank]p4b3:
3701 // If class B is derived directly or indirectly from class A and
3702 // class C is derived directly or indirectly from B,
3704 // Compare based on pointer conversions.
3705 if (SCS1.Second == ICK_Pointer_Conversion &&
3706 SCS2.Second == ICK_Pointer_Conversion &&
3707 /*FIXME: Remove if Objective-C id conversions get their own rank*/
3708 FromType1->isPointerType() && FromType2->isPointerType() &&
3709 ToType1->isPointerType() && ToType2->isPointerType()) {
3710 QualType FromPointee1
3711 = FromType1->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
3713 = ToType1->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
3714 QualType FromPointee2
3715 = FromType2->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
3717 = ToType2->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
3719 // -- conversion of C* to B* is better than conversion of C* to A*,
3720 if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
3721 if (S.IsDerivedFrom(ToPointee1, ToPointee2))
3722 return ImplicitConversionSequence::Better;
3723 else if (S.IsDerivedFrom(ToPointee2, ToPointee1))
3724 return ImplicitConversionSequence::Worse;
3727 // -- conversion of B* to A* is better than conversion of C* to A*,
3728 if (FromPointee1 != FromPointee2 && ToPointee1 == ToPointee2) {
3729 if (S.IsDerivedFrom(FromPointee2, FromPointee1))
3730 return ImplicitConversionSequence::Better;
3731 else if (S.IsDerivedFrom(FromPointee1, FromPointee2))
3732 return ImplicitConversionSequence::Worse;
3734 } else if (SCS1.Second == ICK_Pointer_Conversion &&
3735 SCS2.Second == ICK_Pointer_Conversion) {
3736 const ObjCObjectPointerType *FromPtr1
3737 = FromType1->getAs<ObjCObjectPointerType>();
3738 const ObjCObjectPointerType *FromPtr2
3739 = FromType2->getAs<ObjCObjectPointerType>();
3740 const ObjCObjectPointerType *ToPtr1
3741 = ToType1->getAs<ObjCObjectPointerType>();
3742 const ObjCObjectPointerType *ToPtr2
3743 = ToType2->getAs<ObjCObjectPointerType>();
3745 if (FromPtr1 && FromPtr2 && ToPtr1 && ToPtr2) {
3746 // Apply the same conversion ranking rules for Objective-C pointer types
3747 // that we do for C++ pointers to class types. However, we employ the
3748 // Objective-C pseudo-subtyping relationship used for assignment of
3749 // Objective-C pointer types.
3751 = S.Context.canAssignObjCInterfaces(FromPtr1, FromPtr2);
3752 bool FromAssignRight
3753 = S.Context.canAssignObjCInterfaces(FromPtr2, FromPtr1);
3755 = S.Context.canAssignObjCInterfaces(ToPtr1, ToPtr2);
3757 = S.Context.canAssignObjCInterfaces(ToPtr2, ToPtr1);
3759 // A conversion to an a non-id object pointer type or qualified 'id'
3760 // type is better than a conversion to 'id'.
3761 if (ToPtr1->isObjCIdType() &&
3762 (ToPtr2->isObjCQualifiedIdType() || ToPtr2->getInterfaceDecl()))
3763 return ImplicitConversionSequence::Worse;
3764 if (ToPtr2->isObjCIdType() &&
3765 (ToPtr1->isObjCQualifiedIdType() || ToPtr1->getInterfaceDecl()))
3766 return ImplicitConversionSequence::Better;
3768 // A conversion to a non-id object pointer type is better than a
3769 // conversion to a qualified 'id' type
3770 if (ToPtr1->isObjCQualifiedIdType() && ToPtr2->getInterfaceDecl())
3771 return ImplicitConversionSequence::Worse;
3772 if (ToPtr2->isObjCQualifiedIdType() && ToPtr1->getInterfaceDecl())
3773 return ImplicitConversionSequence::Better;
3775 // A conversion to an a non-Class object pointer type or qualified 'Class'
3776 // type is better than a conversion to 'Class'.
3777 if (ToPtr1->isObjCClassType() &&
3778 (ToPtr2->isObjCQualifiedClassType() || ToPtr2->getInterfaceDecl()))
3779 return ImplicitConversionSequence::Worse;
3780 if (ToPtr2->isObjCClassType() &&
3781 (ToPtr1->isObjCQualifiedClassType() || ToPtr1->getInterfaceDecl()))
3782 return ImplicitConversionSequence::Better;
3784 // A conversion to a non-Class object pointer type is better than a
3785 // conversion to a qualified 'Class' type.
3786 if (ToPtr1->isObjCQualifiedClassType() && ToPtr2->getInterfaceDecl())
3787 return ImplicitConversionSequence::Worse;
3788 if (ToPtr2->isObjCQualifiedClassType() && ToPtr1->getInterfaceDecl())
3789 return ImplicitConversionSequence::Better;
3791 // -- "conversion of C* to B* is better than conversion of C* to A*,"
3792 if (S.Context.hasSameType(FromType1, FromType2) &&
3793 !FromPtr1->isObjCIdType() && !FromPtr1->isObjCClassType() &&
3794 (ToAssignLeft != ToAssignRight))
3795 return ToAssignLeft? ImplicitConversionSequence::Worse
3796 : ImplicitConversionSequence::Better;
3798 // -- "conversion of B* to A* is better than conversion of C* to A*,"
3799 if (S.Context.hasSameUnqualifiedType(ToType1, ToType2) &&
3800 (FromAssignLeft != FromAssignRight))
3801 return FromAssignLeft? ImplicitConversionSequence::Better
3802 : ImplicitConversionSequence::Worse;
3806 // Ranking of member-pointer types.
3807 if (SCS1.Second == ICK_Pointer_Member && SCS2.Second == ICK_Pointer_Member &&
3808 FromType1->isMemberPointerType() && FromType2->isMemberPointerType() &&
3809 ToType1->isMemberPointerType() && ToType2->isMemberPointerType()) {
3810 const MemberPointerType * FromMemPointer1 =
3811 FromType1->getAs<MemberPointerType>();
3812 const MemberPointerType * ToMemPointer1 =
3813 ToType1->getAs<MemberPointerType>();
3814 const MemberPointerType * FromMemPointer2 =
3815 FromType2->getAs<MemberPointerType>();
3816 const MemberPointerType * ToMemPointer2 =
3817 ToType2->getAs<MemberPointerType>();
3818 const Type *FromPointeeType1 = FromMemPointer1->getClass();
3819 const Type *ToPointeeType1 = ToMemPointer1->getClass();
3820 const Type *FromPointeeType2 = FromMemPointer2->getClass();
3821 const Type *ToPointeeType2 = ToMemPointer2->getClass();
3822 QualType FromPointee1 = QualType(FromPointeeType1, 0).getUnqualifiedType();
3823 QualType ToPointee1 = QualType(ToPointeeType1, 0).getUnqualifiedType();
3824 QualType FromPointee2 = QualType(FromPointeeType2, 0).getUnqualifiedType();
3825 QualType ToPointee2 = QualType(ToPointeeType2, 0).getUnqualifiedType();
3826 // conversion of A::* to B::* is better than conversion of A::* to C::*,
3827 if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
3828 if (S.IsDerivedFrom(ToPointee1, ToPointee2))
3829 return ImplicitConversionSequence::Worse;
3830 else if (S.IsDerivedFrom(ToPointee2, ToPointee1))
3831 return ImplicitConversionSequence::Better;
3833 // conversion of B::* to C::* is better than conversion of A::* to C::*
3834 if (ToPointee1 == ToPointee2 && FromPointee1 != FromPointee2) {
3835 if (S.IsDerivedFrom(FromPointee1, FromPointee2))
3836 return ImplicitConversionSequence::Better;
3837 else if (S.IsDerivedFrom(FromPointee2, FromPointee1))
3838 return ImplicitConversionSequence::Worse;
3842 if (SCS1.Second == ICK_Derived_To_Base) {
3843 // -- conversion of C to B is better than conversion of C to A,
3844 // -- binding of an expression of type C to a reference of type
3845 // B& is better than binding an expression of type C to a
3846 // reference of type A&,
3847 if (S.Context.hasSameUnqualifiedType(FromType1, FromType2) &&
3848 !S.Context.hasSameUnqualifiedType(ToType1, ToType2)) {
3849 if (S.IsDerivedFrom(ToType1, ToType2))
3850 return ImplicitConversionSequence::Better;
3851 else if (S.IsDerivedFrom(ToType2, ToType1))
3852 return ImplicitConversionSequence::Worse;
3855 // -- conversion of B to A is better than conversion of C to A.
3856 // -- binding of an expression of type B to a reference of type
3857 // A& is better than binding an expression of type C to a
3858 // reference of type A&,
3859 if (!S.Context.hasSameUnqualifiedType(FromType1, FromType2) &&
3860 S.Context.hasSameUnqualifiedType(ToType1, ToType2)) {
3861 if (S.IsDerivedFrom(FromType2, FromType1))
3862 return ImplicitConversionSequence::Better;
3863 else if (S.IsDerivedFrom(FromType1, FromType2))
3864 return ImplicitConversionSequence::Worse;
3868 return ImplicitConversionSequence::Indistinguishable;
3871 /// CompareReferenceRelationship - Compare the two types T1 and T2 to
3872 /// determine whether they are reference-related,
3873 /// reference-compatible, reference-compatible with added
3874 /// qualification, or incompatible, for use in C++ initialization by
3875 /// reference (C++ [dcl.ref.init]p4). Neither type can be a reference
3876 /// type, and the first type (T1) is the pointee type of the reference
3877 /// type being initialized.
3878 Sema::ReferenceCompareResult
3879 Sema::CompareReferenceRelationship(SourceLocation Loc,
3880 QualType OrigT1, QualType OrigT2,
3881 bool &DerivedToBase,
3882 bool &ObjCConversion,
3883 bool &ObjCLifetimeConversion) {
3884 assert(!OrigT1->isReferenceType() &&
3885 "T1 must be the pointee type of the reference type");
3886 assert(!OrigT2->isReferenceType() && "T2 cannot be a reference type");
3888 QualType T1 = Context.getCanonicalType(OrigT1);
3889 QualType T2 = Context.getCanonicalType(OrigT2);
3890 Qualifiers T1Quals, T2Quals;
3891 QualType UnqualT1 = Context.getUnqualifiedArrayType(T1, T1Quals);
3892 QualType UnqualT2 = Context.getUnqualifiedArrayType(T2, T2Quals);
3894 // C++ [dcl.init.ref]p4:
3895 // Given types "cv1 T1" and "cv2 T2," "cv1 T1" is
3896 // reference-related to "cv2 T2" if T1 is the same type as T2, or
3897 // T1 is a base class of T2.
3898 DerivedToBase = false;
3899 ObjCConversion = false;
3900 ObjCLifetimeConversion = false;
3901 if (UnqualT1 == UnqualT2) {
3903 } else if (!RequireCompleteType(Loc, OrigT2, 0) &&
3904 IsDerivedFrom(UnqualT2, UnqualT1))
3905 DerivedToBase = true;
3906 else if (UnqualT1->isObjCObjectOrInterfaceType() &&
3907 UnqualT2->isObjCObjectOrInterfaceType() &&
3908 Context.canBindObjCObjectType(UnqualT1, UnqualT2))
3909 ObjCConversion = true;
3911 return Ref_Incompatible;
3913 // At this point, we know that T1 and T2 are reference-related (at
3916 // If the type is an array type, promote the element qualifiers to the type
3918 if (isa<ArrayType>(T1) && T1Quals)
3919 T1 = Context.getQualifiedType(UnqualT1, T1Quals);
3920 if (isa<ArrayType>(T2) && T2Quals)
3921 T2 = Context.getQualifiedType(UnqualT2, T2Quals);
3923 // C++ [dcl.init.ref]p4:
3924 // "cv1 T1" is reference-compatible with "cv2 T2" if T1 is
3925 // reference-related to T2 and cv1 is the same cv-qualification
3926 // as, or greater cv-qualification than, cv2. For purposes of
3927 // overload resolution, cases for which cv1 is greater
3928 // cv-qualification than cv2 are identified as
3929 // reference-compatible with added qualification (see 13.3.3.2).
3931 // Note that we also require equivalence of Objective-C GC and address-space
3932 // qualifiers when performing these computations, so that e.g., an int in
3933 // address space 1 is not reference-compatible with an int in address
3935 if (T1Quals.getObjCLifetime() != T2Quals.getObjCLifetime() &&
3936 T1Quals.compatiblyIncludesObjCLifetime(T2Quals)) {
3937 T1Quals.removeObjCLifetime();
3938 T2Quals.removeObjCLifetime();
3939 ObjCLifetimeConversion = true;
3942 if (T1Quals == T2Quals)
3943 return Ref_Compatible;
3944 else if (T1Quals.compatiblyIncludes(T2Quals))
3945 return Ref_Compatible_With_Added_Qualification;
3950 /// \brief Look for a user-defined conversion to an value reference-compatible
3951 /// with DeclType. Return true if something definite is found.
3953 FindConversionForRefInit(Sema &S, ImplicitConversionSequence &ICS,
3954 QualType DeclType, SourceLocation DeclLoc,
3955 Expr *Init, QualType T2, bool AllowRvalues,
3956 bool AllowExplicit) {
3957 assert(T2->isRecordType() && "Can only find conversions of record types.");
3958 CXXRecordDecl *T2RecordDecl
3959 = dyn_cast<CXXRecordDecl>(T2->getAs<RecordType>()->getDecl());
3961 OverloadCandidateSet CandidateSet(DeclLoc);
3962 const UnresolvedSetImpl *Conversions
3963 = T2RecordDecl->getVisibleConversionFunctions();
3964 for (UnresolvedSetImpl::iterator I = Conversions->begin(),
3965 E = Conversions->end(); I != E; ++I) {
3967 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
3968 if (isa<UsingShadowDecl>(D))
3969 D = cast<UsingShadowDecl>(D)->getTargetDecl();
3971 FunctionTemplateDecl *ConvTemplate
3972 = dyn_cast<FunctionTemplateDecl>(D);
3973 CXXConversionDecl *Conv;
3975 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
3977 Conv = cast<CXXConversionDecl>(D);
3979 // If this is an explicit conversion, and we're not allowed to consider
3980 // explicit conversions, skip it.
3981 if (!AllowExplicit && Conv->isExplicit())
3985 bool DerivedToBase = false;
3986 bool ObjCConversion = false;
3987 bool ObjCLifetimeConversion = false;
3989 // If we are initializing an rvalue reference, don't permit conversion
3990 // functions that return lvalues.
3991 if (!ConvTemplate && DeclType->isRValueReferenceType()) {
3992 const ReferenceType *RefType
3993 = Conv->getConversionType()->getAs<LValueReferenceType>();
3994 if (RefType && !RefType->getPointeeType()->isFunctionType())
3998 if (!ConvTemplate &&
3999 S.CompareReferenceRelationship(
4001 Conv->getConversionType().getNonReferenceType()
4002 .getUnqualifiedType(),
4003 DeclType.getNonReferenceType().getUnqualifiedType(),
4004 DerivedToBase, ObjCConversion, ObjCLifetimeConversion) ==
4005 Sema::Ref_Incompatible)
4008 // If the conversion function doesn't return a reference type,
4009 // it can't be considered for this conversion. An rvalue reference
4010 // is only acceptable if its referencee is a function type.
4012 const ReferenceType *RefType =
4013 Conv->getConversionType()->getAs<ReferenceType>();
4015 (!RefType->isLValueReferenceType() &&
4016 !RefType->getPointeeType()->isFunctionType()))
4021 S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(), ActingDC,
4022 Init, DeclType, CandidateSet);
4024 S.AddConversionCandidate(Conv, I.getPair(), ActingDC, Init,
4025 DeclType, CandidateSet);
4028 bool HadMultipleCandidates = (CandidateSet.size() > 1);
4030 OverloadCandidateSet::iterator Best;
4031 switch (CandidateSet.BestViableFunction(S, DeclLoc, Best, true)) {
4033 // C++ [over.ics.ref]p1:
4035 // [...] If the parameter binds directly to the result of
4036 // applying a conversion function to the argument
4037 // expression, the implicit conversion sequence is a
4038 // user-defined conversion sequence (13.3.3.1.2), with the
4039 // second standard conversion sequence either an identity
4040 // conversion or, if the conversion function returns an
4041 // entity of a type that is a derived class of the parameter
4042 // type, a derived-to-base Conversion.
4043 if (!Best->FinalConversion.DirectBinding)
4046 ICS.setUserDefined();
4047 ICS.UserDefined.Before = Best->Conversions[0].Standard;
4048 ICS.UserDefined.After = Best->FinalConversion;
4049 ICS.UserDefined.HadMultipleCandidates = HadMultipleCandidates;
4050 ICS.UserDefined.ConversionFunction = Best->Function;
4051 ICS.UserDefined.FoundConversionFunction = Best->FoundDecl;
4052 ICS.UserDefined.EllipsisConversion = false;
4053 assert(ICS.UserDefined.After.ReferenceBinding &&
4054 ICS.UserDefined.After.DirectBinding &&
4055 "Expected a direct reference binding!");
4060 for (OverloadCandidateSet::iterator Cand = CandidateSet.begin();
4061 Cand != CandidateSet.end(); ++Cand)
4063 ICS.Ambiguous.addConversion(Cand->Function);
4066 case OR_No_Viable_Function:
4068 // There was no suitable conversion, or we found a deleted
4069 // conversion; continue with other checks.
4073 llvm_unreachable("Invalid OverloadResult!");
4076 /// \brief Compute an implicit conversion sequence for reference
4078 static ImplicitConversionSequence
4079 TryReferenceInit(Sema &S, Expr *Init, QualType DeclType,
4080 SourceLocation DeclLoc,
4081 bool SuppressUserConversions,
4082 bool AllowExplicit) {
4083 assert(DeclType->isReferenceType() && "Reference init needs a reference");
4085 // Most paths end in a failed conversion.
4086 ImplicitConversionSequence ICS;
4087 ICS.setBad(BadConversionSequence::no_conversion, Init, DeclType);
4089 QualType T1 = DeclType->getAs<ReferenceType>()->getPointeeType();
4090 QualType T2 = Init->getType();
4092 // If the initializer is the address of an overloaded function, try
4093 // to resolve the overloaded function. If all goes well, T2 is the
4094 // type of the resulting function.
4095 if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) {
4096 DeclAccessPair Found;
4097 if (FunctionDecl *Fn = S.ResolveAddressOfOverloadedFunction(Init, DeclType,
4102 // Compute some basic properties of the types and the initializer.
4103 bool isRValRef = DeclType->isRValueReferenceType();
4104 bool DerivedToBase = false;
4105 bool ObjCConversion = false;
4106 bool ObjCLifetimeConversion = false;
4107 Expr::Classification InitCategory = Init->Classify(S.Context);
4108 Sema::ReferenceCompareResult RefRelationship
4109 = S.CompareReferenceRelationship(DeclLoc, T1, T2, DerivedToBase,
4110 ObjCConversion, ObjCLifetimeConversion);
4113 // C++0x [dcl.init.ref]p5:
4114 // A reference to type "cv1 T1" is initialized by an expression
4115 // of type "cv2 T2" as follows:
4117 // -- If reference is an lvalue reference and the initializer expression
4119 // -- is an lvalue (but is not a bit-field), and "cv1 T1" is
4120 // reference-compatible with "cv2 T2," or
4122 // Per C++ [over.ics.ref]p4, we don't check the bit-field property here.
4123 if (InitCategory.isLValue() &&
4124 RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification) {
4125 // C++ [over.ics.ref]p1:
4126 // When a parameter of reference type binds directly (8.5.3)
4127 // to an argument expression, the implicit conversion sequence
4128 // is the identity conversion, unless the argument expression
4129 // has a type that is a derived class of the parameter type,
4130 // in which case the implicit conversion sequence is a
4131 // derived-to-base Conversion (13.3.3.1).
4133 ICS.Standard.First = ICK_Identity;
4134 ICS.Standard.Second = DerivedToBase? ICK_Derived_To_Base
4135 : ObjCConversion? ICK_Compatible_Conversion
4137 ICS.Standard.Third = ICK_Identity;
4138 ICS.Standard.FromTypePtr = T2.getAsOpaquePtr();
4139 ICS.Standard.setToType(0, T2);
4140 ICS.Standard.setToType(1, T1);
4141 ICS.Standard.setToType(2, T1);
4142 ICS.Standard.ReferenceBinding = true;
4143 ICS.Standard.DirectBinding = true;
4144 ICS.Standard.IsLvalueReference = !isRValRef;
4145 ICS.Standard.BindsToFunctionLvalue = T2->isFunctionType();
4146 ICS.Standard.BindsToRvalue = false;
4147 ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false;
4148 ICS.Standard.ObjCLifetimeConversionBinding = ObjCLifetimeConversion;
4149 ICS.Standard.CopyConstructor = 0;
4151 // Nothing more to do: the inaccessibility/ambiguity check for
4152 // derived-to-base conversions is suppressed when we're
4153 // computing the implicit conversion sequence (C++
4154 // [over.best.ics]p2).
4158 // -- has a class type (i.e., T2 is a class type), where T1 is
4159 // not reference-related to T2, and can be implicitly
4160 // converted to an lvalue of type "cv3 T3," where "cv1 T1"
4161 // is reference-compatible with "cv3 T3" 92) (this
4162 // conversion is selected by enumerating the applicable
4163 // conversion functions (13.3.1.6) and choosing the best
4164 // one through overload resolution (13.3)),
4165 if (!SuppressUserConversions && T2->isRecordType() &&
4166 !S.RequireCompleteType(DeclLoc, T2, 0) &&
4167 RefRelationship == Sema::Ref_Incompatible) {
4168 if (FindConversionForRefInit(S, ICS, DeclType, DeclLoc,
4169 Init, T2, /*AllowRvalues=*/false,
4175 // -- Otherwise, the reference shall be an lvalue reference to a
4176 // non-volatile const type (i.e., cv1 shall be const), or the reference
4177 // shall be an rvalue reference.
4179 // We actually handle one oddity of C++ [over.ics.ref] at this
4180 // point, which is that, due to p2 (which short-circuits reference
4181 // binding by only attempting a simple conversion for non-direct
4182 // bindings) and p3's strange wording, we allow a const volatile
4183 // reference to bind to an rvalue. Hence the check for the presence
4184 // of "const" rather than checking for "const" being the only
4186 // This is also the point where rvalue references and lvalue inits no longer
4188 if (!isRValRef && (!T1.isConstQualified() || T1.isVolatileQualified()))
4191 // -- If the initializer expression
4193 // -- is an xvalue, class prvalue, array prvalue or function
4194 // lvalue and "cv1 T1" is reference-compatible with "cv2 T2", or
4195 if (RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification &&
4196 (InitCategory.isXValue() ||
4197 (InitCategory.isPRValue() && (T2->isRecordType() || T2->isArrayType())) ||
4198 (InitCategory.isLValue() && T2->isFunctionType()))) {
4200 ICS.Standard.First = ICK_Identity;
4201 ICS.Standard.Second = DerivedToBase? ICK_Derived_To_Base
4202 : ObjCConversion? ICK_Compatible_Conversion
4204 ICS.Standard.Third = ICK_Identity;
4205 ICS.Standard.FromTypePtr = T2.getAsOpaquePtr();
4206 ICS.Standard.setToType(0, T2);
4207 ICS.Standard.setToType(1, T1);
4208 ICS.Standard.setToType(2, T1);
4209 ICS.Standard.ReferenceBinding = true;
4210 // In C++0x, this is always a direct binding. In C++98/03, it's a direct
4211 // binding unless we're binding to a class prvalue.
4212 // Note: Although xvalues wouldn't normally show up in C++98/03 code, we
4213 // allow the use of rvalue references in C++98/03 for the benefit of
4214 // standard library implementors; therefore, we need the xvalue check here.
4215 ICS.Standard.DirectBinding =
4216 S.getLangOpts().CPlusPlus0x ||
4217 (InitCategory.isPRValue() && !T2->isRecordType());
4218 ICS.Standard.IsLvalueReference = !isRValRef;
4219 ICS.Standard.BindsToFunctionLvalue = T2->isFunctionType();
4220 ICS.Standard.BindsToRvalue = InitCategory.isRValue();
4221 ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false;
4222 ICS.Standard.ObjCLifetimeConversionBinding = ObjCLifetimeConversion;
4223 ICS.Standard.CopyConstructor = 0;
4227 // -- has a class type (i.e., T2 is a class type), where T1 is not
4228 // reference-related to T2, and can be implicitly converted to
4229 // an xvalue, class prvalue, or function lvalue of type
4230 // "cv3 T3", where "cv1 T1" is reference-compatible with
4233 // then the reference is bound to the value of the initializer
4234 // expression in the first case and to the result of the conversion
4235 // in the second case (or, in either case, to an appropriate base
4236 // class subobject).
4237 if (!SuppressUserConversions && RefRelationship == Sema::Ref_Incompatible &&
4238 T2->isRecordType() && !S.RequireCompleteType(DeclLoc, T2, 0) &&
4239 FindConversionForRefInit(S, ICS, DeclType, DeclLoc,
4240 Init, T2, /*AllowRvalues=*/true,
4242 // In the second case, if the reference is an rvalue reference
4243 // and the second standard conversion sequence of the
4244 // user-defined conversion sequence includes an lvalue-to-rvalue
4245 // conversion, the program is ill-formed.
4246 if (ICS.isUserDefined() && isRValRef &&
4247 ICS.UserDefined.After.First == ICK_Lvalue_To_Rvalue)
4248 ICS.setBad(BadConversionSequence::no_conversion, Init, DeclType);
4253 // -- Otherwise, a temporary of type "cv1 T1" is created and
4254 // initialized from the initializer expression using the
4255 // rules for a non-reference copy initialization (8.5). The
4256 // reference is then bound to the temporary. If T1 is
4257 // reference-related to T2, cv1 must be the same
4258 // cv-qualification as, or greater cv-qualification than,
4259 // cv2; otherwise, the program is ill-formed.
4260 if (RefRelationship == Sema::Ref_Related) {
4261 // If cv1 == cv2 or cv1 is a greater cv-qualified than cv2, then
4262 // we would be reference-compatible or reference-compatible with
4263 // added qualification. But that wasn't the case, so the reference
4264 // initialization fails.
4266 // Note that we only want to check address spaces and cvr-qualifiers here.
4267 // ObjC GC and lifetime qualifiers aren't important.
4268 Qualifiers T1Quals = T1.getQualifiers();
4269 Qualifiers T2Quals = T2.getQualifiers();
4270 T1Quals.removeObjCGCAttr();
4271 T1Quals.removeObjCLifetime();
4272 T2Quals.removeObjCGCAttr();
4273 T2Quals.removeObjCLifetime();
4274 if (!T1Quals.compatiblyIncludes(T2Quals))
4278 // If at least one of the types is a class type, the types are not
4279 // related, and we aren't allowed any user conversions, the
4280 // reference binding fails. This case is important for breaking
4281 // recursion, since TryImplicitConversion below will attempt to
4282 // create a temporary through the use of a copy constructor.
4283 if (SuppressUserConversions && RefRelationship == Sema::Ref_Incompatible &&
4284 (T1->isRecordType() || T2->isRecordType()))
4287 // If T1 is reference-related to T2 and the reference is an rvalue
4288 // reference, the initializer expression shall not be an lvalue.
4289 if (RefRelationship >= Sema::Ref_Related &&
4290 isRValRef && Init->Classify(S.Context).isLValue())
4293 // C++ [over.ics.ref]p2:
4294 // When a parameter of reference type is not bound directly to
4295 // an argument expression, the conversion sequence is the one
4296 // required to convert the argument expression to the
4297 // underlying type of the reference according to
4298 // 13.3.3.1. Conceptually, this conversion sequence corresponds
4299 // to copy-initializing a temporary of the underlying type with
4300 // the argument expression. Any difference in top-level
4301 // cv-qualification is subsumed by the initialization itself
4302 // and does not constitute a conversion.
4303 ICS = TryImplicitConversion(S, Init, T1, SuppressUserConversions,
4304 /*AllowExplicit=*/false,
4305 /*InOverloadResolution=*/false,
4307 /*AllowObjCWritebackConversion=*/false);
4309 // Of course, that's still a reference binding.
4310 if (ICS.isStandard()) {
4311 ICS.Standard.ReferenceBinding = true;
4312 ICS.Standard.IsLvalueReference = !isRValRef;
4313 ICS.Standard.BindsToFunctionLvalue = T2->isFunctionType();
4314 ICS.Standard.BindsToRvalue = true;
4315 ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false;
4316 ICS.Standard.ObjCLifetimeConversionBinding = false;
4317 } else if (ICS.isUserDefined()) {
4318 // Don't allow rvalue references to bind to lvalues.
4319 if (DeclType->isRValueReferenceType()) {
4320 if (const ReferenceType *RefType
4321 = ICS.UserDefined.ConversionFunction->getResultType()
4322 ->getAs<LValueReferenceType>()) {
4323 if (!RefType->getPointeeType()->isFunctionType()) {
4324 ICS.setBad(BadConversionSequence::lvalue_ref_to_rvalue, Init,
4331 ICS.UserDefined.After.ReferenceBinding = true;
4332 ICS.UserDefined.After.IsLvalueReference = !isRValRef;
4333 ICS.UserDefined.After.BindsToFunctionLvalue = T2->isFunctionType();
4334 ICS.UserDefined.After.BindsToRvalue = true;
4335 ICS.UserDefined.After.BindsImplicitObjectArgumentWithoutRefQualifier = false;
4336 ICS.UserDefined.After.ObjCLifetimeConversionBinding = false;
4342 static ImplicitConversionSequence
4343 TryCopyInitialization(Sema &S, Expr *From, QualType ToType,
4344 bool SuppressUserConversions,
4345 bool InOverloadResolution,
4346 bool AllowObjCWritebackConversion,
4347 bool AllowExplicit = false);
4349 /// TryListConversion - Try to copy-initialize a value of type ToType from the
4350 /// initializer list From.
4351 static ImplicitConversionSequence
4352 TryListConversion(Sema &S, InitListExpr *From, QualType ToType,
4353 bool SuppressUserConversions,
4354 bool InOverloadResolution,
4355 bool AllowObjCWritebackConversion) {
4356 // C++11 [over.ics.list]p1:
4357 // When an argument is an initializer list, it is not an expression and
4358 // special rules apply for converting it to a parameter type.
4360 ImplicitConversionSequence Result;
4361 Result.setBad(BadConversionSequence::no_conversion, From, ToType);
4362 Result.setListInitializationSequence();
4364 // We need a complete type for what follows. Incomplete types can never be
4365 // initialized from init lists.
4366 if (S.RequireCompleteType(From->getLocStart(), ToType, 0))
4369 // C++11 [over.ics.list]p2:
4370 // If the parameter type is std::initializer_list<X> or "array of X" and
4371 // all the elements can be implicitly converted to X, the implicit
4372 // conversion sequence is the worst conversion necessary to convert an
4373 // element of the list to X.
4374 bool toStdInitializerList = false;
4376 if (ToType->isArrayType())
4377 X = S.Context.getBaseElementType(ToType);
4379 toStdInitializerList = S.isStdInitializerList(ToType, &X);
4381 for (unsigned i = 0, e = From->getNumInits(); i < e; ++i) {
4382 Expr *Init = From->getInit(i);
4383 ImplicitConversionSequence ICS =
4384 TryCopyInitialization(S, Init, X, SuppressUserConversions,
4385 InOverloadResolution,
4386 AllowObjCWritebackConversion);
4387 // If a single element isn't convertible, fail.
4392 // Otherwise, look for the worst conversion.
4393 if (Result.isBad() ||
4394 CompareImplicitConversionSequences(S, ICS, Result) ==
4395 ImplicitConversionSequence::Worse)
4399 // For an empty list, we won't have computed any conversion sequence.
4400 // Introduce the identity conversion sequence.
4401 if (From->getNumInits() == 0) {
4402 Result.setStandard();
4403 Result.Standard.setAsIdentityConversion();
4404 Result.Standard.setFromType(ToType);
4405 Result.Standard.setAllToTypes(ToType);
4408 Result.setListInitializationSequence();
4409 Result.setStdInitializerListElement(toStdInitializerList);
4413 // C++11 [over.ics.list]p3:
4414 // Otherwise, if the parameter is a non-aggregate class X and overload
4415 // resolution chooses a single best constructor [...] the implicit
4416 // conversion sequence is a user-defined conversion sequence. If multiple
4417 // constructors are viable but none is better than the others, the
4418 // implicit conversion sequence is a user-defined conversion sequence.
4419 if (ToType->isRecordType() && !ToType->isAggregateType()) {
4420 // This function can deal with initializer lists.
4421 Result = TryUserDefinedConversion(S, From, ToType, SuppressUserConversions,
4422 /*AllowExplicit=*/false,
4423 InOverloadResolution, /*CStyle=*/false,
4424 AllowObjCWritebackConversion);
4425 Result.setListInitializationSequence();
4429 // C++11 [over.ics.list]p4:
4430 // Otherwise, if the parameter has an aggregate type which can be
4431 // initialized from the initializer list [...] the implicit conversion
4432 // sequence is a user-defined conversion sequence.
4433 if (ToType->isAggregateType()) {
4434 // Type is an aggregate, argument is an init list. At this point it comes
4435 // down to checking whether the initialization works.
4436 // FIXME: Find out whether this parameter is consumed or not.
4437 InitializedEntity Entity =
4438 InitializedEntity::InitializeParameter(S.Context, ToType,
4439 /*Consumed=*/false);
4440 if (S.CanPerformCopyInitialization(Entity, S.Owned(From))) {
4441 Result.setUserDefined();
4442 Result.UserDefined.Before.setAsIdentityConversion();
4443 // Initializer lists don't have a type.
4444 Result.UserDefined.Before.setFromType(QualType());
4445 Result.UserDefined.Before.setAllToTypes(QualType());
4447 Result.UserDefined.After.setAsIdentityConversion();
4448 Result.UserDefined.After.setFromType(ToType);
4449 Result.UserDefined.After.setAllToTypes(ToType);
4450 Result.UserDefined.ConversionFunction = 0;
4455 // C++11 [over.ics.list]p5:
4456 // Otherwise, if the parameter is a reference, see 13.3.3.1.4.
4457 if (ToType->isReferenceType()) {
4458 // The standard is notoriously unclear here, since 13.3.3.1.4 doesn't
4459 // mention initializer lists in any way. So we go by what list-
4460 // initialization would do and try to extrapolate from that.
4462 QualType T1 = ToType->getAs<ReferenceType>()->getPointeeType();
4464 // If the initializer list has a single element that is reference-related
4465 // to the parameter type, we initialize the reference from that.
4466 if (From->getNumInits() == 1) {
4467 Expr *Init = From->getInit(0);
4469 QualType T2 = Init->getType();
4471 // If the initializer is the address of an overloaded function, try
4472 // to resolve the overloaded function. If all goes well, T2 is the
4473 // type of the resulting function.
4474 if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) {
4475 DeclAccessPair Found;
4476 if (FunctionDecl *Fn = S.ResolveAddressOfOverloadedFunction(
4477 Init, ToType, false, Found))
4481 // Compute some basic properties of the types and the initializer.
4482 bool dummy1 = false;
4483 bool dummy2 = false;
4484 bool dummy3 = false;
4485 Sema::ReferenceCompareResult RefRelationship
4486 = S.CompareReferenceRelationship(From->getLocStart(), T1, T2, dummy1,
4489 if (RefRelationship >= Sema::Ref_Related)
4490 return TryReferenceInit(S, Init, ToType,
4491 /*FIXME:*/From->getLocStart(),
4492 SuppressUserConversions,
4493 /*AllowExplicit=*/false);
4496 // Otherwise, we bind the reference to a temporary created from the
4497 // initializer list.
4498 Result = TryListConversion(S, From, T1, SuppressUserConversions,
4499 InOverloadResolution,
4500 AllowObjCWritebackConversion);
4501 if (Result.isFailure())
4503 assert(!Result.isEllipsis() &&
4504 "Sub-initialization cannot result in ellipsis conversion.");
4506 // Can we even bind to a temporary?
4507 if (ToType->isRValueReferenceType() ||
4508 (T1.isConstQualified() && !T1.isVolatileQualified())) {
4509 StandardConversionSequence &SCS = Result.isStandard() ? Result.Standard :
4510 Result.UserDefined.After;
4511 SCS.ReferenceBinding = true;
4512 SCS.IsLvalueReference = ToType->isLValueReferenceType();
4513 SCS.BindsToRvalue = true;
4514 SCS.BindsToFunctionLvalue = false;
4515 SCS.BindsImplicitObjectArgumentWithoutRefQualifier = false;
4516 SCS.ObjCLifetimeConversionBinding = false;
4518 Result.setBad(BadConversionSequence::lvalue_ref_to_rvalue,
4523 // C++11 [over.ics.list]p6:
4524 // Otherwise, if the parameter type is not a class:
4525 if (!ToType->isRecordType()) {
4526 // - if the initializer list has one element, the implicit conversion
4527 // sequence is the one required to convert the element to the
4529 unsigned NumInits = From->getNumInits();
4531 Result = TryCopyInitialization(S, From->getInit(0), ToType,
4532 SuppressUserConversions,
4533 InOverloadResolution,
4534 AllowObjCWritebackConversion);
4535 // - if the initializer list has no elements, the implicit conversion
4536 // sequence is the identity conversion.
4537 else if (NumInits == 0) {
4538 Result.setStandard();
4539 Result.Standard.setAsIdentityConversion();
4540 Result.Standard.setFromType(ToType);
4541 Result.Standard.setAllToTypes(ToType);
4543 Result.setListInitializationSequence();
4547 // C++11 [over.ics.list]p7:
4548 // In all cases other than those enumerated above, no conversion is possible
4552 /// TryCopyInitialization - Try to copy-initialize a value of type
4553 /// ToType from the expression From. Return the implicit conversion
4554 /// sequence required to pass this argument, which may be a bad
4555 /// conversion sequence (meaning that the argument cannot be passed to
4556 /// a parameter of this type). If @p SuppressUserConversions, then we
4557 /// do not permit any user-defined conversion sequences.
4558 static ImplicitConversionSequence
4559 TryCopyInitialization(Sema &S, Expr *From, QualType ToType,
4560 bool SuppressUserConversions,
4561 bool InOverloadResolution,
4562 bool AllowObjCWritebackConversion,
4563 bool AllowExplicit) {
4564 if (InitListExpr *FromInitList = dyn_cast<InitListExpr>(From))
4565 return TryListConversion(S, FromInitList, ToType, SuppressUserConversions,
4566 InOverloadResolution,AllowObjCWritebackConversion);
4568 if (ToType->isReferenceType())
4569 return TryReferenceInit(S, From, ToType,
4570 /*FIXME:*/From->getLocStart(),
4571 SuppressUserConversions,
4574 return TryImplicitConversion(S, From, ToType,
4575 SuppressUserConversions,
4576 /*AllowExplicit=*/false,
4577 InOverloadResolution,
4579 AllowObjCWritebackConversion);
4582 static bool TryCopyInitialization(const CanQualType FromQTy,
4583 const CanQualType ToQTy,
4586 ExprValueKind FromVK) {
4587 OpaqueValueExpr TmpExpr(Loc, FromQTy, FromVK);
4588 ImplicitConversionSequence ICS =
4589 TryCopyInitialization(S, &TmpExpr, ToQTy, true, true, false);
4591 return !ICS.isBad();
4594 /// TryObjectArgumentInitialization - Try to initialize the object
4595 /// parameter of the given member function (@c Method) from the
4596 /// expression @p From.
4597 static ImplicitConversionSequence
4598 TryObjectArgumentInitialization(Sema &S, QualType OrigFromType,
4599 Expr::Classification FromClassification,
4600 CXXMethodDecl *Method,
4601 CXXRecordDecl *ActingContext) {
4602 QualType ClassType = S.Context.getTypeDeclType(ActingContext);
4603 // [class.dtor]p2: A destructor can be invoked for a const, volatile or
4604 // const volatile object.
4605 unsigned Quals = isa<CXXDestructorDecl>(Method) ?
4606 Qualifiers::Const | Qualifiers::Volatile : Method->getTypeQualifiers();
4607 QualType ImplicitParamType = S.Context.getCVRQualifiedType(ClassType, Quals);
4609 // Set up the conversion sequence as a "bad" conversion, to allow us
4611 ImplicitConversionSequence ICS;
4613 // We need to have an object of class type.
4614 QualType FromType = OrigFromType;
4615 if (const PointerType *PT = FromType->getAs<PointerType>()) {
4616 FromType = PT->getPointeeType();
4618 // When we had a pointer, it's implicitly dereferenced, so we
4619 // better have an lvalue.
4620 assert(FromClassification.isLValue());
4623 assert(FromType->isRecordType());
4625 // C++0x [over.match.funcs]p4:
4626 // For non-static member functions, the type of the implicit object
4629 // - "lvalue reference to cv X" for functions declared without a
4630 // ref-qualifier or with the & ref-qualifier
4631 // - "rvalue reference to cv X" for functions declared with the &&
4634 // where X is the class of which the function is a member and cv is the
4635 // cv-qualification on the member function declaration.
4637 // However, when finding an implicit conversion sequence for the argument, we
4638 // are not allowed to create temporaries or perform user-defined conversions
4639 // (C++ [over.match.funcs]p5). We perform a simplified version of
4640 // reference binding here, that allows class rvalues to bind to
4641 // non-constant references.
4643 // First check the qualifiers.
4644 QualType FromTypeCanon = S.Context.getCanonicalType(FromType);
4645 if (ImplicitParamType.getCVRQualifiers()
4646 != FromTypeCanon.getLocalCVRQualifiers() &&
4647 !ImplicitParamType.isAtLeastAsQualifiedAs(FromTypeCanon)) {
4648 ICS.setBad(BadConversionSequence::bad_qualifiers,
4649 OrigFromType, ImplicitParamType);
4653 // Check that we have either the same type or a derived type. It
4654 // affects the conversion rank.
4655 QualType ClassTypeCanon = S.Context.getCanonicalType(ClassType);
4656 ImplicitConversionKind SecondKind;
4657 if (ClassTypeCanon == FromTypeCanon.getLocalUnqualifiedType()) {
4658 SecondKind = ICK_Identity;
4659 } else if (S.IsDerivedFrom(FromType, ClassType))
4660 SecondKind = ICK_Derived_To_Base;
4662 ICS.setBad(BadConversionSequence::unrelated_class,
4663 FromType, ImplicitParamType);
4667 // Check the ref-qualifier.
4668 switch (Method->getRefQualifier()) {
4670 // Do nothing; we don't care about lvalueness or rvalueness.
4674 if (!FromClassification.isLValue() && Quals != Qualifiers::Const) {
4675 // non-const lvalue reference cannot bind to an rvalue
4676 ICS.setBad(BadConversionSequence::lvalue_ref_to_rvalue, FromType,
4683 if (!FromClassification.isRValue()) {
4684 // rvalue reference cannot bind to an lvalue
4685 ICS.setBad(BadConversionSequence::rvalue_ref_to_lvalue, FromType,
4692 // Success. Mark this as a reference binding.
4694 ICS.Standard.setAsIdentityConversion();
4695 ICS.Standard.Second = SecondKind;
4696 ICS.Standard.setFromType(FromType);
4697 ICS.Standard.setAllToTypes(ImplicitParamType);
4698 ICS.Standard.ReferenceBinding = true;
4699 ICS.Standard.DirectBinding = true;
4700 ICS.Standard.IsLvalueReference = Method->getRefQualifier() != RQ_RValue;
4701 ICS.Standard.BindsToFunctionLvalue = false;
4702 ICS.Standard.BindsToRvalue = FromClassification.isRValue();
4703 ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier
4704 = (Method->getRefQualifier() == RQ_None);
4708 /// PerformObjectArgumentInitialization - Perform initialization of
4709 /// the implicit object parameter for the given Method with the given
4712 Sema::PerformObjectArgumentInitialization(Expr *From,
4713 NestedNameSpecifier *Qualifier,
4714 NamedDecl *FoundDecl,
4715 CXXMethodDecl *Method) {
4716 QualType FromRecordType, DestType;
4717 QualType ImplicitParamRecordType =
4718 Method->getThisType(Context)->getAs<PointerType>()->getPointeeType();
4720 Expr::Classification FromClassification;
4721 if (const PointerType *PT = From->getType()->getAs<PointerType>()) {
4722 FromRecordType = PT->getPointeeType();
4723 DestType = Method->getThisType(Context);
4724 FromClassification = Expr::Classification::makeSimpleLValue();
4726 FromRecordType = From->getType();
4727 DestType = ImplicitParamRecordType;
4728 FromClassification = From->Classify(Context);
4731 // Note that we always use the true parent context when performing
4732 // the actual argument initialization.
4733 ImplicitConversionSequence ICS
4734 = TryObjectArgumentInitialization(*this, From->getType(), FromClassification,
4735 Method, Method->getParent());
4737 if (ICS.Bad.Kind == BadConversionSequence::bad_qualifiers) {
4738 Qualifiers FromQs = FromRecordType.getQualifiers();
4739 Qualifiers ToQs = DestType.getQualifiers();
4740 unsigned CVR = FromQs.getCVRQualifiers() & ~ToQs.getCVRQualifiers();
4742 Diag(From->getLocStart(),
4743 diag::err_member_function_call_bad_cvr)
4744 << Method->getDeclName() << FromRecordType << (CVR - 1)
4745 << From->getSourceRange();
4746 Diag(Method->getLocation(), diag::note_previous_decl)
4747 << Method->getDeclName();
4752 return Diag(From->getLocStart(),
4753 diag::err_implicit_object_parameter_init)
4754 << ImplicitParamRecordType << FromRecordType << From->getSourceRange();
4757 if (ICS.Standard.Second == ICK_Derived_To_Base) {
4758 ExprResult FromRes =
4759 PerformObjectMemberConversion(From, Qualifier, FoundDecl, Method);
4760 if (FromRes.isInvalid())
4762 From = FromRes.take();
4765 if (!Context.hasSameType(From->getType(), DestType))
4766 From = ImpCastExprToType(From, DestType, CK_NoOp,
4767 From->getValueKind()).take();
4771 /// TryContextuallyConvertToBool - Attempt to contextually convert the
4772 /// expression From to bool (C++0x [conv]p3).
4773 static ImplicitConversionSequence
4774 TryContextuallyConvertToBool(Sema &S, Expr *From) {
4775 // FIXME: This is pretty broken.
4776 return TryImplicitConversion(S, From, S.Context.BoolTy,
4777 // FIXME: Are these flags correct?
4778 /*SuppressUserConversions=*/false,
4779 /*AllowExplicit=*/true,
4780 /*InOverloadResolution=*/false,
4782 /*AllowObjCWritebackConversion=*/false);
4785 /// PerformContextuallyConvertToBool - Perform a contextual conversion
4786 /// of the expression From to bool (C++0x [conv]p3).
4787 ExprResult Sema::PerformContextuallyConvertToBool(Expr *From) {
4788 if (checkPlaceholderForOverload(*this, From))
4791 ImplicitConversionSequence ICS = TryContextuallyConvertToBool(*this, From);
4793 return PerformImplicitConversion(From, Context.BoolTy, ICS, AA_Converting);
4795 if (!DiagnoseMultipleUserDefinedConversion(From, Context.BoolTy))
4796 return Diag(From->getLocStart(),
4797 diag::err_typecheck_bool_condition)
4798 << From->getType() << From->getSourceRange();
4802 /// Check that the specified conversion is permitted in a converted constant
4803 /// expression, according to C++11 [expr.const]p3. Return true if the conversion
4805 static bool CheckConvertedConstantConversions(Sema &S,
4806 StandardConversionSequence &SCS) {
4807 // Since we know that the target type is an integral or unscoped enumeration
4808 // type, most conversion kinds are impossible. All possible First and Third
4809 // conversions are fine.
4810 switch (SCS.Second) {
4812 case ICK_Integral_Promotion:
4813 case ICK_Integral_Conversion:
4816 case ICK_Boolean_Conversion:
4817 // Conversion from an integral or unscoped enumeration type to bool is
4818 // classified as ICK_Boolean_Conversion, but it's also an integral
4819 // conversion, so it's permitted in a converted constant expression.
4820 return SCS.getFromType()->isIntegralOrUnscopedEnumerationType() &&
4821 SCS.getToType(2)->isBooleanType();
4823 case ICK_Floating_Integral:
4824 case ICK_Complex_Real:
4827 case ICK_Lvalue_To_Rvalue:
4828 case ICK_Array_To_Pointer:
4829 case ICK_Function_To_Pointer:
4830 case ICK_NoReturn_Adjustment:
4831 case ICK_Qualification:
4832 case ICK_Compatible_Conversion:
4833 case ICK_Vector_Conversion:
4834 case ICK_Vector_Splat:
4835 case ICK_Derived_To_Base:
4836 case ICK_Pointer_Conversion:
4837 case ICK_Pointer_Member:
4838 case ICK_Block_Pointer_Conversion:
4839 case ICK_Writeback_Conversion:
4840 case ICK_Floating_Promotion:
4841 case ICK_Complex_Promotion:
4842 case ICK_Complex_Conversion:
4843 case ICK_Floating_Conversion:
4844 case ICK_TransparentUnionConversion:
4845 llvm_unreachable("unexpected second conversion kind");
4847 case ICK_Num_Conversion_Kinds:
4851 llvm_unreachable("unknown conversion kind");
4854 /// CheckConvertedConstantExpression - Check that the expression From is a
4855 /// converted constant expression of type T, perform the conversion and produce
4856 /// the converted expression, per C++11 [expr.const]p3.
4857 ExprResult Sema::CheckConvertedConstantExpression(Expr *From, QualType T,
4858 llvm::APSInt &Value,
4860 assert(LangOpts.CPlusPlus0x && "converted constant expression outside C++11");
4861 assert(T->isIntegralOrEnumerationType() && "unexpected converted const type");
4863 if (checkPlaceholderForOverload(*this, From))
4866 // C++11 [expr.const]p3 with proposed wording fixes:
4867 // A converted constant expression of type T is a core constant expression,
4868 // implicitly converted to a prvalue of type T, where the converted
4869 // expression is a literal constant expression and the implicit conversion
4870 // sequence contains only user-defined conversions, lvalue-to-rvalue
4871 // conversions, integral promotions, and integral conversions other than
4872 // narrowing conversions.
4873 ImplicitConversionSequence ICS =
4874 TryImplicitConversion(From, T,
4875 /*SuppressUserConversions=*/false,
4876 /*AllowExplicit=*/false,
4877 /*InOverloadResolution=*/false,
4879 /*AllowObjcWritebackConversion=*/false);
4880 StandardConversionSequence *SCS = 0;
4881 switch (ICS.getKind()) {
4882 case ImplicitConversionSequence::StandardConversion:
4883 if (!CheckConvertedConstantConversions(*this, ICS.Standard))
4884 return Diag(From->getLocStart(),
4885 diag::err_typecheck_converted_constant_expression_disallowed)
4886 << From->getType() << From->getSourceRange() << T;
4887 SCS = &ICS.Standard;
4889 case ImplicitConversionSequence::UserDefinedConversion:
4890 // We are converting from class type to an integral or enumeration type, so
4891 // the Before sequence must be trivial.
4892 if (!CheckConvertedConstantConversions(*this, ICS.UserDefined.After))
4893 return Diag(From->getLocStart(),
4894 diag::err_typecheck_converted_constant_expression_disallowed)
4895 << From->getType() << From->getSourceRange() << T;
4896 SCS = &ICS.UserDefined.After;
4898 case ImplicitConversionSequence::AmbiguousConversion:
4899 case ImplicitConversionSequence::BadConversion:
4900 if (!DiagnoseMultipleUserDefinedConversion(From, T))
4901 return Diag(From->getLocStart(),
4902 diag::err_typecheck_converted_constant_expression)
4903 << From->getType() << From->getSourceRange() << T;
4906 case ImplicitConversionSequence::EllipsisConversion:
4907 llvm_unreachable("ellipsis conversion in converted constant expression");
4910 ExprResult Result = PerformImplicitConversion(From, T, ICS, AA_Converting);
4911 if (Result.isInvalid())
4914 // Check for a narrowing implicit conversion.
4915 APValue PreNarrowingValue;
4916 QualType PreNarrowingType;
4917 switch (SCS->getNarrowingKind(Context, Result.get(), PreNarrowingValue,
4918 PreNarrowingType)) {
4919 case NK_Variable_Narrowing:
4920 // Implicit conversion to a narrower type, and the value is not a constant
4921 // expression. We'll diagnose this in a moment.
4922 case NK_Not_Narrowing:
4925 case NK_Constant_Narrowing:
4926 Diag(From->getLocStart(),
4927 isSFINAEContext() ? diag::err_cce_narrowing_sfinae :
4928 diag::err_cce_narrowing)
4929 << CCE << /*Constant*/1
4930 << PreNarrowingValue.getAsString(Context, PreNarrowingType) << T;
4933 case NK_Type_Narrowing:
4934 Diag(From->getLocStart(),
4935 isSFINAEContext() ? diag::err_cce_narrowing_sfinae :
4936 diag::err_cce_narrowing)
4937 << CCE << /*Constant*/0 << From->getType() << T;
4941 // Check the expression is a constant expression.
4942 llvm::SmallVector<PartialDiagnosticAt, 8> Notes;
4943 Expr::EvalResult Eval;
4946 if (!Result.get()->EvaluateAsRValue(Eval, Context)) {
4947 // The expression can't be folded, so we can't keep it at this position in
4949 Result = ExprError();
4951 Value = Eval.Val.getInt();
4953 if (Notes.empty()) {
4954 // It's a constant expression.
4959 // It's not a constant expression. Produce an appropriate diagnostic.
4960 if (Notes.size() == 1 &&
4961 Notes[0].second.getDiagID() == diag::note_invalid_subexpr_in_const_expr)
4962 Diag(Notes[0].first, diag::err_expr_not_cce) << CCE;
4964 Diag(From->getLocStart(), diag::err_expr_not_cce)
4965 << CCE << From->getSourceRange();
4966 for (unsigned I = 0; I < Notes.size(); ++I)
4967 Diag(Notes[I].first, Notes[I].second);
4972 /// dropPointerConversions - If the given standard conversion sequence
4973 /// involves any pointer conversions, remove them. This may change
4974 /// the result type of the conversion sequence.
4975 static void dropPointerConversion(StandardConversionSequence &SCS) {
4976 if (SCS.Second == ICK_Pointer_Conversion) {
4977 SCS.Second = ICK_Identity;
4978 SCS.Third = ICK_Identity;
4979 SCS.ToTypePtrs[2] = SCS.ToTypePtrs[1] = SCS.ToTypePtrs[0];
4983 /// TryContextuallyConvertToObjCPointer - Attempt to contextually
4984 /// convert the expression From to an Objective-C pointer type.
4985 static ImplicitConversionSequence
4986 TryContextuallyConvertToObjCPointer(Sema &S, Expr *From) {
4987 // Do an implicit conversion to 'id'.
4988 QualType Ty = S.Context.getObjCIdType();
4989 ImplicitConversionSequence ICS
4990 = TryImplicitConversion(S, From, Ty,
4991 // FIXME: Are these flags correct?
4992 /*SuppressUserConversions=*/false,
4993 /*AllowExplicit=*/true,
4994 /*InOverloadResolution=*/false,
4996 /*AllowObjCWritebackConversion=*/false);
4998 // Strip off any final conversions to 'id'.
4999 switch (ICS.getKind()) {
5000 case ImplicitConversionSequence::BadConversion:
5001 case ImplicitConversionSequence::AmbiguousConversion:
5002 case ImplicitConversionSequence::EllipsisConversion:
5005 case ImplicitConversionSequence::UserDefinedConversion:
5006 dropPointerConversion(ICS.UserDefined.After);
5009 case ImplicitConversionSequence::StandardConversion:
5010 dropPointerConversion(ICS.Standard);
5017 /// PerformContextuallyConvertToObjCPointer - Perform a contextual
5018 /// conversion of the expression From to an Objective-C pointer type.
5019 ExprResult Sema::PerformContextuallyConvertToObjCPointer(Expr *From) {
5020 if (checkPlaceholderForOverload(*this, From))
5023 QualType Ty = Context.getObjCIdType();
5024 ImplicitConversionSequence ICS =
5025 TryContextuallyConvertToObjCPointer(*this, From);
5027 return PerformImplicitConversion(From, Ty, ICS, AA_Converting);
5031 /// Determine whether the provided type is an integral type, or an enumeration
5032 /// type of a permitted flavor.
5033 static bool isIntegralOrEnumerationType(QualType T, bool AllowScopedEnum) {
5034 return AllowScopedEnum ? T->isIntegralOrEnumerationType()
5035 : T->isIntegralOrUnscopedEnumerationType();
5038 /// \brief Attempt to convert the given expression to an integral or
5039 /// enumeration type.
5041 /// This routine will attempt to convert an expression of class type to an
5042 /// integral or enumeration type, if that class type only has a single
5043 /// conversion to an integral or enumeration type.
5045 /// \param Loc The source location of the construct that requires the
5048 /// \param From The expression we're converting from.
5050 /// \param Diagnoser Used to output any diagnostics.
5052 /// \param AllowScopedEnumerations Specifies whether conversions to scoped
5053 /// enumerations should be considered.
5055 /// \returns The expression, converted to an integral or enumeration type if
5058 Sema::ConvertToIntegralOrEnumerationType(SourceLocation Loc, Expr *From,
5059 ICEConvertDiagnoser &Diagnoser,
5060 bool AllowScopedEnumerations) {
5061 // We can't perform any more checking for type-dependent expressions.
5062 if (From->isTypeDependent())
5065 // Process placeholders immediately.
5066 if (From->hasPlaceholderType()) {
5067 ExprResult result = CheckPlaceholderExpr(From);
5068 if (result.isInvalid()) return result;
5069 From = result.take();
5072 // If the expression already has integral or enumeration type, we're golden.
5073 QualType T = From->getType();
5074 if (isIntegralOrEnumerationType(T, AllowScopedEnumerations))
5075 return DefaultLvalueConversion(From);
5077 // FIXME: Check for missing '()' if T is a function type?
5079 // If we don't have a class type in C++, there's no way we can get an
5080 // expression of integral or enumeration type.
5081 const RecordType *RecordTy = T->getAs<RecordType>();
5082 if (!RecordTy || !getLangOpts().CPlusPlus) {
5083 if (!Diagnoser.Suppress)
5084 Diagnoser.diagnoseNotInt(*this, Loc, T) << From->getSourceRange();
5088 // We must have a complete class type.
5089 struct TypeDiagnoserPartialDiag : TypeDiagnoser {
5090 ICEConvertDiagnoser &Diagnoser;
5093 TypeDiagnoserPartialDiag(ICEConvertDiagnoser &Diagnoser, Expr *From)
5094 : TypeDiagnoser(Diagnoser.Suppress), Diagnoser(Diagnoser), From(From) {}
5096 virtual void diagnose(Sema &S, SourceLocation Loc, QualType T) {
5097 Diagnoser.diagnoseIncomplete(S, Loc, T) << From->getSourceRange();
5099 } IncompleteDiagnoser(Diagnoser, From);
5101 if (RequireCompleteType(Loc, T, IncompleteDiagnoser))
5104 // Look for a conversion to an integral or enumeration type.
5105 UnresolvedSet<4> ViableConversions;
5106 UnresolvedSet<4> ExplicitConversions;
5107 const UnresolvedSetImpl *Conversions
5108 = cast<CXXRecordDecl>(RecordTy->getDecl())->getVisibleConversionFunctions();
5110 bool HadMultipleCandidates = (Conversions->size() > 1);
5112 for (UnresolvedSetImpl::iterator I = Conversions->begin(),
5113 E = Conversions->end();
5116 if (CXXConversionDecl *Conversion
5117 = dyn_cast<CXXConversionDecl>((*I)->getUnderlyingDecl())) {
5118 if (isIntegralOrEnumerationType(
5119 Conversion->getConversionType().getNonReferenceType(),
5120 AllowScopedEnumerations)) {
5121 if (Conversion->isExplicit())
5122 ExplicitConversions.addDecl(I.getDecl(), I.getAccess());
5124 ViableConversions.addDecl(I.getDecl(), I.getAccess());
5129 switch (ViableConversions.size()) {
5131 if (ExplicitConversions.size() == 1 && !Diagnoser.Suppress) {
5132 DeclAccessPair Found = ExplicitConversions[0];
5133 CXXConversionDecl *Conversion
5134 = cast<CXXConversionDecl>(Found->getUnderlyingDecl());
5136 // The user probably meant to invoke the given explicit
5137 // conversion; use it.
5139 = Conversion->getConversionType().getNonReferenceType();
5140 std::string TypeStr;
5141 ConvTy.getAsStringInternal(TypeStr, getPrintingPolicy());
5143 Diagnoser.diagnoseExplicitConv(*this, Loc, T, ConvTy)
5144 << FixItHint::CreateInsertion(From->getLocStart(),
5145 "static_cast<" + TypeStr + ">(")
5146 << FixItHint::CreateInsertion(PP.getLocForEndOfToken(From->getLocEnd()),
5148 Diagnoser.noteExplicitConv(*this, Conversion, ConvTy);
5150 // If we aren't in a SFINAE context, build a call to the
5151 // explicit conversion function.
5152 if (isSFINAEContext())
5155 CheckMemberOperatorAccess(From->getExprLoc(), From, 0, Found);
5156 ExprResult Result = BuildCXXMemberCallExpr(From, Found, Conversion,
5157 HadMultipleCandidates);
5158 if (Result.isInvalid())
5160 // Record usage of conversion in an implicit cast.
5161 From = ImplicitCastExpr::Create(Context, Result.get()->getType(),
5162 CK_UserDefinedConversion,
5164 Result.get()->getValueKind());
5167 // We'll complain below about a non-integral condition type.
5171 // Apply this conversion.
5172 DeclAccessPair Found = ViableConversions[0];
5173 CheckMemberOperatorAccess(From->getExprLoc(), From, 0, Found);
5175 CXXConversionDecl *Conversion
5176 = cast<CXXConversionDecl>(Found->getUnderlyingDecl());
5178 = Conversion->getConversionType().getNonReferenceType();
5179 if (!Diagnoser.SuppressConversion) {
5180 if (isSFINAEContext())
5183 Diagnoser.diagnoseConversion(*this, Loc, T, ConvTy)
5184 << From->getSourceRange();
5187 ExprResult Result = BuildCXXMemberCallExpr(From, Found, Conversion,
5188 HadMultipleCandidates);
5189 if (Result.isInvalid())
5191 // Record usage of conversion in an implicit cast.
5192 From = ImplicitCastExpr::Create(Context, Result.get()->getType(),
5193 CK_UserDefinedConversion,
5195 Result.get()->getValueKind());
5200 if (Diagnoser.Suppress)
5203 Diagnoser.diagnoseAmbiguous(*this, Loc, T) << From->getSourceRange();
5204 for (unsigned I = 0, N = ViableConversions.size(); I != N; ++I) {
5205 CXXConversionDecl *Conv
5206 = cast<CXXConversionDecl>(ViableConversions[I]->getUnderlyingDecl());
5207 QualType ConvTy = Conv->getConversionType().getNonReferenceType();
5208 Diagnoser.noteAmbiguous(*this, Conv, ConvTy);
5213 if (!isIntegralOrEnumerationType(From->getType(), AllowScopedEnumerations) &&
5214 !Diagnoser.Suppress) {
5215 Diagnoser.diagnoseNotInt(*this, Loc, From->getType())
5216 << From->getSourceRange();
5219 return DefaultLvalueConversion(From);
5222 /// AddOverloadCandidate - Adds the given function to the set of
5223 /// candidate functions, using the given function call arguments. If
5224 /// @p SuppressUserConversions, then don't allow user-defined
5225 /// conversions via constructors or conversion operators.
5227 /// \param PartialOverloading true if we are performing "partial" overloading
5228 /// based on an incomplete set of function arguments. This feature is used by
5229 /// code completion.
5231 Sema::AddOverloadCandidate(FunctionDecl *Function,
5232 DeclAccessPair FoundDecl,
5233 llvm::ArrayRef<Expr *> Args,
5234 OverloadCandidateSet& CandidateSet,
5235 bool SuppressUserConversions,
5236 bool PartialOverloading,
5237 bool AllowExplicit) {
5238 const FunctionProtoType* Proto
5239 = dyn_cast<FunctionProtoType>(Function->getType()->getAs<FunctionType>());
5240 assert(Proto && "Functions without a prototype cannot be overloaded");
5241 assert(!Function->getDescribedFunctionTemplate() &&
5242 "Use AddTemplateOverloadCandidate for function templates");
5244 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Function)) {
5245 if (!isa<CXXConstructorDecl>(Method)) {
5246 // If we get here, it's because we're calling a member function
5247 // that is named without a member access expression (e.g.,
5248 // "this->f") that was either written explicitly or created
5249 // implicitly. This can happen with a qualified call to a member
5250 // function, e.g., X::f(). We use an empty type for the implied
5251 // object argument (C++ [over.call.func]p3), and the acting context
5253 AddMethodCandidate(Method, FoundDecl, Method->getParent(),
5254 QualType(), Expr::Classification::makeSimpleLValue(),
5255 Args, CandidateSet, SuppressUserConversions);
5258 // We treat a constructor like a non-member function, since its object
5259 // argument doesn't participate in overload resolution.
5262 if (!CandidateSet.isNewCandidate(Function))
5265 // Overload resolution is always an unevaluated context.
5266 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
5268 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Function)){
5269 // C++ [class.copy]p3:
5270 // A member function template is never instantiated to perform the copy
5271 // of a class object to an object of its class type.
5272 QualType ClassType = Context.getTypeDeclType(Constructor->getParent());
5273 if (Args.size() == 1 &&
5274 Constructor->isSpecializationCopyingObject() &&
5275 (Context.hasSameUnqualifiedType(ClassType, Args[0]->getType()) ||
5276 IsDerivedFrom(Args[0]->getType(), ClassType)))
5280 // Add this candidate
5281 OverloadCandidate &Candidate = CandidateSet.addCandidate(Args.size());
5282 Candidate.FoundDecl = FoundDecl;
5283 Candidate.Function = Function;
5284 Candidate.Viable = true;
5285 Candidate.IsSurrogate = false;
5286 Candidate.IgnoreObjectArgument = false;
5287 Candidate.ExplicitCallArguments = Args.size();
5289 unsigned NumArgsInProto = Proto->getNumArgs();
5291 // (C++ 13.3.2p2): A candidate function having fewer than m
5292 // parameters is viable only if it has an ellipsis in its parameter
5294 if ((Args.size() + (PartialOverloading && Args.size())) > NumArgsInProto &&
5295 !Proto->isVariadic()) {
5296 Candidate.Viable = false;
5297 Candidate.FailureKind = ovl_fail_too_many_arguments;
5301 // (C++ 13.3.2p2): A candidate function having more than m parameters
5302 // is viable only if the (m+1)st parameter has a default argument
5303 // (8.3.6). For the purposes of overload resolution, the
5304 // parameter list is truncated on the right, so that there are
5305 // exactly m parameters.
5306 unsigned MinRequiredArgs = Function->getMinRequiredArguments();
5307 if (Args.size() < MinRequiredArgs && !PartialOverloading) {
5308 // Not enough arguments.
5309 Candidate.Viable = false;
5310 Candidate.FailureKind = ovl_fail_too_few_arguments;
5314 // (CUDA B.1): Check for invalid calls between targets.
5315 if (getLangOpts().CUDA)
5316 if (const FunctionDecl *Caller = dyn_cast<FunctionDecl>(CurContext))
5317 if (CheckCUDATarget(Caller, Function)) {
5318 Candidate.Viable = false;
5319 Candidate.FailureKind = ovl_fail_bad_target;
5323 // Determine the implicit conversion sequences for each of the
5325 for (unsigned ArgIdx = 0; ArgIdx < Args.size(); ++ArgIdx) {
5326 if (ArgIdx < NumArgsInProto) {
5327 // (C++ 13.3.2p3): for F to be a viable function, there shall
5328 // exist for each argument an implicit conversion sequence
5329 // (13.3.3.1) that converts that argument to the corresponding
5331 QualType ParamType = Proto->getArgType(ArgIdx);
5332 Candidate.Conversions[ArgIdx]
5333 = TryCopyInitialization(*this, Args[ArgIdx], ParamType,
5334 SuppressUserConversions,
5335 /*InOverloadResolution=*/true,
5336 /*AllowObjCWritebackConversion=*/
5337 getLangOpts().ObjCAutoRefCount,
5339 if (Candidate.Conversions[ArgIdx].isBad()) {
5340 Candidate.Viable = false;
5341 Candidate.FailureKind = ovl_fail_bad_conversion;
5345 // (C++ 13.3.2p2): For the purposes of overload resolution, any
5346 // argument for which there is no corresponding parameter is
5347 // considered to ""match the ellipsis" (C+ 13.3.3.1.3).
5348 Candidate.Conversions[ArgIdx].setEllipsis();
5353 /// \brief Add all of the function declarations in the given function set to
5354 /// the overload canddiate set.
5355 void Sema::AddFunctionCandidates(const UnresolvedSetImpl &Fns,
5356 llvm::ArrayRef<Expr *> Args,
5357 OverloadCandidateSet& CandidateSet,
5358 bool SuppressUserConversions,
5359 TemplateArgumentListInfo *ExplicitTemplateArgs) {
5360 for (UnresolvedSetIterator F = Fns.begin(), E = Fns.end(); F != E; ++F) {
5361 NamedDecl *D = F.getDecl()->getUnderlyingDecl();
5362 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
5363 if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic())
5364 AddMethodCandidate(cast<CXXMethodDecl>(FD), F.getPair(),
5365 cast<CXXMethodDecl>(FD)->getParent(),
5366 Args[0]->getType(), Args[0]->Classify(Context),
5367 Args.slice(1), CandidateSet,
5368 SuppressUserConversions);
5370 AddOverloadCandidate(FD, F.getPair(), Args, CandidateSet,
5371 SuppressUserConversions);
5373 FunctionTemplateDecl *FunTmpl = cast<FunctionTemplateDecl>(D);
5374 if (isa<CXXMethodDecl>(FunTmpl->getTemplatedDecl()) &&
5375 !cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl())->isStatic())
5376 AddMethodTemplateCandidate(FunTmpl, F.getPair(),
5377 cast<CXXRecordDecl>(FunTmpl->getDeclContext()),
5378 ExplicitTemplateArgs,
5380 Args[0]->Classify(Context), Args.slice(1),
5381 CandidateSet, SuppressUserConversions);
5383 AddTemplateOverloadCandidate(FunTmpl, F.getPair(),
5384 ExplicitTemplateArgs, Args,
5385 CandidateSet, SuppressUserConversions);
5390 /// AddMethodCandidate - Adds a named decl (which is some kind of
5391 /// method) as a method candidate to the given overload set.
5392 void Sema::AddMethodCandidate(DeclAccessPair FoundDecl,
5393 QualType ObjectType,
5394 Expr::Classification ObjectClassification,
5395 Expr **Args, unsigned NumArgs,
5396 OverloadCandidateSet& CandidateSet,
5397 bool SuppressUserConversions) {
5398 NamedDecl *Decl = FoundDecl.getDecl();
5399 CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(Decl->getDeclContext());
5401 if (isa<UsingShadowDecl>(Decl))
5402 Decl = cast<UsingShadowDecl>(Decl)->getTargetDecl();
5404 if (FunctionTemplateDecl *TD = dyn_cast<FunctionTemplateDecl>(Decl)) {
5405 assert(isa<CXXMethodDecl>(TD->getTemplatedDecl()) &&
5406 "Expected a member function template");
5407 AddMethodTemplateCandidate(TD, FoundDecl, ActingContext,
5409 ObjectType, ObjectClassification,
5410 llvm::makeArrayRef(Args, NumArgs), CandidateSet,
5411 SuppressUserConversions);
5413 AddMethodCandidate(cast<CXXMethodDecl>(Decl), FoundDecl, ActingContext,
5414 ObjectType, ObjectClassification,
5415 llvm::makeArrayRef(Args, NumArgs),
5416 CandidateSet, SuppressUserConversions);
5420 /// AddMethodCandidate - Adds the given C++ member function to the set
5421 /// of candidate functions, using the given function call arguments
5422 /// and the object argument (@c Object). For example, in a call
5423 /// @c o.f(a1,a2), @c Object will contain @c o and @c Args will contain
5424 /// both @c a1 and @c a2. If @p SuppressUserConversions, then don't
5425 /// allow user-defined conversions via constructors or conversion
5428 Sema::AddMethodCandidate(CXXMethodDecl *Method, DeclAccessPair FoundDecl,
5429 CXXRecordDecl *ActingContext, QualType ObjectType,
5430 Expr::Classification ObjectClassification,
5431 llvm::ArrayRef<Expr *> Args,
5432 OverloadCandidateSet& CandidateSet,
5433 bool SuppressUserConversions) {
5434 const FunctionProtoType* Proto
5435 = dyn_cast<FunctionProtoType>(Method->getType()->getAs<FunctionType>());
5436 assert(Proto && "Methods without a prototype cannot be overloaded");
5437 assert(!isa<CXXConstructorDecl>(Method) &&
5438 "Use AddOverloadCandidate for constructors");
5440 if (!CandidateSet.isNewCandidate(Method))
5443 // Overload resolution is always an unevaluated context.
5444 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
5446 // Add this candidate
5447 OverloadCandidate &Candidate = CandidateSet.addCandidate(Args.size() + 1);
5448 Candidate.FoundDecl = FoundDecl;
5449 Candidate.Function = Method;
5450 Candidate.IsSurrogate = false;
5451 Candidate.IgnoreObjectArgument = false;
5452 Candidate.ExplicitCallArguments = Args.size();
5454 unsigned NumArgsInProto = Proto->getNumArgs();
5456 // (C++ 13.3.2p2): A candidate function having fewer than m
5457 // parameters is viable only if it has an ellipsis in its parameter
5459 if (Args.size() > NumArgsInProto && !Proto->isVariadic()) {
5460 Candidate.Viable = false;
5461 Candidate.FailureKind = ovl_fail_too_many_arguments;
5465 // (C++ 13.3.2p2): A candidate function having more than m parameters
5466 // is viable only if the (m+1)st parameter has a default argument
5467 // (8.3.6). For the purposes of overload resolution, the
5468 // parameter list is truncated on the right, so that there are
5469 // exactly m parameters.
5470 unsigned MinRequiredArgs = Method->getMinRequiredArguments();
5471 if (Args.size() < MinRequiredArgs) {
5472 // Not enough arguments.
5473 Candidate.Viable = false;
5474 Candidate.FailureKind = ovl_fail_too_few_arguments;
5478 Candidate.Viable = true;
5480 if (Method->isStatic() || ObjectType.isNull())
5481 // The implicit object argument is ignored.
5482 Candidate.IgnoreObjectArgument = true;
5484 // Determine the implicit conversion sequence for the object
5486 Candidate.Conversions[0]
5487 = TryObjectArgumentInitialization(*this, ObjectType, ObjectClassification,
5488 Method, ActingContext);
5489 if (Candidate.Conversions[0].isBad()) {
5490 Candidate.Viable = false;
5491 Candidate.FailureKind = ovl_fail_bad_conversion;
5496 // Determine the implicit conversion sequences for each of the
5498 for (unsigned ArgIdx = 0; ArgIdx < Args.size(); ++ArgIdx) {
5499 if (ArgIdx < NumArgsInProto) {
5500 // (C++ 13.3.2p3): for F to be a viable function, there shall
5501 // exist for each argument an implicit conversion sequence
5502 // (13.3.3.1) that converts that argument to the corresponding
5504 QualType ParamType = Proto->getArgType(ArgIdx);
5505 Candidate.Conversions[ArgIdx + 1]
5506 = TryCopyInitialization(*this, Args[ArgIdx], ParamType,
5507 SuppressUserConversions,
5508 /*InOverloadResolution=*/true,
5509 /*AllowObjCWritebackConversion=*/
5510 getLangOpts().ObjCAutoRefCount);
5511 if (Candidate.Conversions[ArgIdx + 1].isBad()) {
5512 Candidate.Viable = false;
5513 Candidate.FailureKind = ovl_fail_bad_conversion;
5517 // (C++ 13.3.2p2): For the purposes of overload resolution, any
5518 // argument for which there is no corresponding parameter is
5519 // considered to ""match the ellipsis" (C+ 13.3.3.1.3).
5520 Candidate.Conversions[ArgIdx + 1].setEllipsis();
5525 /// \brief Add a C++ member function template as a candidate to the candidate
5526 /// set, using template argument deduction to produce an appropriate member
5527 /// function template specialization.
5529 Sema::AddMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl,
5530 DeclAccessPair FoundDecl,
5531 CXXRecordDecl *ActingContext,
5532 TemplateArgumentListInfo *ExplicitTemplateArgs,
5533 QualType ObjectType,
5534 Expr::Classification ObjectClassification,
5535 llvm::ArrayRef<Expr *> Args,
5536 OverloadCandidateSet& CandidateSet,
5537 bool SuppressUserConversions) {
5538 if (!CandidateSet.isNewCandidate(MethodTmpl))
5541 // C++ [over.match.funcs]p7:
5542 // In each case where a candidate is a function template, candidate
5543 // function template specializations are generated using template argument
5544 // deduction (14.8.3, 14.8.2). Those candidates are then handled as
5545 // candidate functions in the usual way.113) A given name can refer to one
5546 // or more function templates and also to a set of overloaded non-template
5547 // functions. In such a case, the candidate functions generated from each
5548 // function template are combined with the set of non-template candidate
5550 TemplateDeductionInfo Info(CandidateSet.getLocation());
5551 FunctionDecl *Specialization = 0;
5552 if (TemplateDeductionResult Result
5553 = DeduceTemplateArguments(MethodTmpl, ExplicitTemplateArgs, Args,
5554 Specialization, Info)) {
5555 OverloadCandidate &Candidate = CandidateSet.addCandidate();
5556 Candidate.FoundDecl = FoundDecl;
5557 Candidate.Function = MethodTmpl->getTemplatedDecl();
5558 Candidate.Viable = false;
5559 Candidate.FailureKind = ovl_fail_bad_deduction;
5560 Candidate.IsSurrogate = false;
5561 Candidate.IgnoreObjectArgument = false;
5562 Candidate.ExplicitCallArguments = Args.size();
5563 Candidate.DeductionFailure = MakeDeductionFailureInfo(Context, Result,
5568 // Add the function template specialization produced by template argument
5569 // deduction as a candidate.
5570 assert(Specialization && "Missing member function template specialization?");
5571 assert(isa<CXXMethodDecl>(Specialization) &&
5572 "Specialization is not a member function?");
5573 AddMethodCandidate(cast<CXXMethodDecl>(Specialization), FoundDecl,
5574 ActingContext, ObjectType, ObjectClassification, Args,
5575 CandidateSet, SuppressUserConversions);
5578 /// \brief Add a C++ function template specialization as a candidate
5579 /// in the candidate set, using template argument deduction to produce
5580 /// an appropriate function template specialization.
5582 Sema::AddTemplateOverloadCandidate(FunctionTemplateDecl *FunctionTemplate,
5583 DeclAccessPair FoundDecl,
5584 TemplateArgumentListInfo *ExplicitTemplateArgs,
5585 llvm::ArrayRef<Expr *> Args,
5586 OverloadCandidateSet& CandidateSet,
5587 bool SuppressUserConversions) {
5588 if (!CandidateSet.isNewCandidate(FunctionTemplate))
5591 // C++ [over.match.funcs]p7:
5592 // In each case where a candidate is a function template, candidate
5593 // function template specializations are generated using template argument
5594 // deduction (14.8.3, 14.8.2). Those candidates are then handled as
5595 // candidate functions in the usual way.113) A given name can refer to one
5596 // or more function templates and also to a set of overloaded non-template
5597 // functions. In such a case, the candidate functions generated from each
5598 // function template are combined with the set of non-template candidate
5600 TemplateDeductionInfo Info(CandidateSet.getLocation());
5601 FunctionDecl *Specialization = 0;
5602 if (TemplateDeductionResult Result
5603 = DeduceTemplateArguments(FunctionTemplate, ExplicitTemplateArgs, Args,
5604 Specialization, Info)) {
5605 OverloadCandidate &Candidate = CandidateSet.addCandidate();
5606 Candidate.FoundDecl = FoundDecl;
5607 Candidate.Function = FunctionTemplate->getTemplatedDecl();
5608 Candidate.Viable = false;
5609 Candidate.FailureKind = ovl_fail_bad_deduction;
5610 Candidate.IsSurrogate = false;
5611 Candidate.IgnoreObjectArgument = false;
5612 Candidate.ExplicitCallArguments = Args.size();
5613 Candidate.DeductionFailure = MakeDeductionFailureInfo(Context, Result,
5618 // Add the function template specialization produced by template argument
5619 // deduction as a candidate.
5620 assert(Specialization && "Missing function template specialization?");
5621 AddOverloadCandidate(Specialization, FoundDecl, Args, CandidateSet,
5622 SuppressUserConversions);
5625 /// AddConversionCandidate - Add a C++ conversion function as a
5626 /// candidate in the candidate set (C++ [over.match.conv],
5627 /// C++ [over.match.copy]). From is the expression we're converting from,
5628 /// and ToType is the type that we're eventually trying to convert to
5629 /// (which may or may not be the same type as the type that the
5630 /// conversion function produces).
5632 Sema::AddConversionCandidate(CXXConversionDecl *Conversion,
5633 DeclAccessPair FoundDecl,
5634 CXXRecordDecl *ActingContext,
5635 Expr *From, QualType ToType,
5636 OverloadCandidateSet& CandidateSet) {
5637 assert(!Conversion->getDescribedFunctionTemplate() &&
5638 "Conversion function templates use AddTemplateConversionCandidate");
5639 QualType ConvType = Conversion->getConversionType().getNonReferenceType();
5640 if (!CandidateSet.isNewCandidate(Conversion))
5643 // Overload resolution is always an unevaluated context.
5644 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
5646 // Add this candidate
5647 OverloadCandidate &Candidate = CandidateSet.addCandidate(1);
5648 Candidate.FoundDecl = FoundDecl;
5649 Candidate.Function = Conversion;
5650 Candidate.IsSurrogate = false;
5651 Candidate.IgnoreObjectArgument = false;
5652 Candidate.FinalConversion.setAsIdentityConversion();
5653 Candidate.FinalConversion.setFromType(ConvType);
5654 Candidate.FinalConversion.setAllToTypes(ToType);
5655 Candidate.Viable = true;
5656 Candidate.ExplicitCallArguments = 1;
5658 // C++ [over.match.funcs]p4:
5659 // For conversion functions, the function is considered to be a member of
5660 // the class of the implicit implied object argument for the purpose of
5661 // defining the type of the implicit object parameter.
5663 // Determine the implicit conversion sequence for the implicit
5664 // object parameter.
5665 QualType ImplicitParamType = From->getType();
5666 if (const PointerType *FromPtrType = ImplicitParamType->getAs<PointerType>())
5667 ImplicitParamType = FromPtrType->getPointeeType();
5668 CXXRecordDecl *ConversionContext
5669 = cast<CXXRecordDecl>(ImplicitParamType->getAs<RecordType>()->getDecl());
5671 Candidate.Conversions[0]
5672 = TryObjectArgumentInitialization(*this, From->getType(),
5673 From->Classify(Context),
5674 Conversion, ConversionContext);
5676 if (Candidate.Conversions[0].isBad()) {
5677 Candidate.Viable = false;
5678 Candidate.FailureKind = ovl_fail_bad_conversion;
5682 // We won't go through a user-define type conversion function to convert a
5683 // derived to base as such conversions are given Conversion Rank. They only
5684 // go through a copy constructor. 13.3.3.1.2-p4 [over.ics.user]
5686 = Context.getCanonicalType(From->getType().getUnqualifiedType());
5687 QualType ToCanon = Context.getCanonicalType(ToType).getUnqualifiedType();
5688 if (FromCanon == ToCanon || IsDerivedFrom(FromCanon, ToCanon)) {
5689 Candidate.Viable = false;
5690 Candidate.FailureKind = ovl_fail_trivial_conversion;
5694 // To determine what the conversion from the result of calling the
5695 // conversion function to the type we're eventually trying to
5696 // convert to (ToType), we need to synthesize a call to the
5697 // conversion function and attempt copy initialization from it. This
5698 // makes sure that we get the right semantics with respect to
5699 // lvalues/rvalues and the type. Fortunately, we can allocate this
5700 // call on the stack and we don't need its arguments to be
5702 DeclRefExpr ConversionRef(Conversion, false, Conversion->getType(),
5703 VK_LValue, From->getLocStart());
5704 ImplicitCastExpr ConversionFn(ImplicitCastExpr::OnStack,
5705 Context.getPointerType(Conversion->getType()),
5706 CK_FunctionToPointerDecay,
5707 &ConversionRef, VK_RValue);
5709 QualType ConversionType = Conversion->getConversionType();
5710 if (RequireCompleteType(From->getLocStart(), ConversionType, 0)) {
5711 Candidate.Viable = false;
5712 Candidate.FailureKind = ovl_fail_bad_final_conversion;
5716 ExprValueKind VK = Expr::getValueKindForType(ConversionType);
5718 // Note that it is safe to allocate CallExpr on the stack here because
5719 // there are 0 arguments (i.e., nothing is allocated using ASTContext's
5721 QualType CallResultType = ConversionType.getNonLValueExprType(Context);
5722 CallExpr Call(Context, &ConversionFn, MultiExprArg(), CallResultType, VK,
5723 From->getLocStart());
5724 ImplicitConversionSequence ICS =
5725 TryCopyInitialization(*this, &Call, ToType,
5726 /*SuppressUserConversions=*/true,
5727 /*InOverloadResolution=*/false,
5728 /*AllowObjCWritebackConversion=*/false);
5730 switch (ICS.getKind()) {
5731 case ImplicitConversionSequence::StandardConversion:
5732 Candidate.FinalConversion = ICS.Standard;
5734 // C++ [over.ics.user]p3:
5735 // If the user-defined conversion is specified by a specialization of a
5736 // conversion function template, the second standard conversion sequence
5737 // shall have exact match rank.
5738 if (Conversion->getPrimaryTemplate() &&
5739 GetConversionRank(ICS.Standard.Second) != ICR_Exact_Match) {
5740 Candidate.Viable = false;
5741 Candidate.FailureKind = ovl_fail_final_conversion_not_exact;
5744 // C++0x [dcl.init.ref]p5:
5745 // In the second case, if the reference is an rvalue reference and
5746 // the second standard conversion sequence of the user-defined
5747 // conversion sequence includes an lvalue-to-rvalue conversion, the
5748 // program is ill-formed.
5749 if (ToType->isRValueReferenceType() &&
5750 ICS.Standard.First == ICK_Lvalue_To_Rvalue) {
5751 Candidate.Viable = false;
5752 Candidate.FailureKind = ovl_fail_bad_final_conversion;
5756 case ImplicitConversionSequence::BadConversion:
5757 Candidate.Viable = false;
5758 Candidate.FailureKind = ovl_fail_bad_final_conversion;
5763 "Can only end up with a standard conversion sequence or failure");
5767 /// \brief Adds a conversion function template specialization
5768 /// candidate to the overload set, using template argument deduction
5769 /// to deduce the template arguments of the conversion function
5770 /// template from the type that we are converting to (C++
5771 /// [temp.deduct.conv]).
5773 Sema::AddTemplateConversionCandidate(FunctionTemplateDecl *FunctionTemplate,
5774 DeclAccessPair FoundDecl,
5775 CXXRecordDecl *ActingDC,
5776 Expr *From, QualType ToType,
5777 OverloadCandidateSet &CandidateSet) {
5778 assert(isa<CXXConversionDecl>(FunctionTemplate->getTemplatedDecl()) &&
5779 "Only conversion function templates permitted here");
5781 if (!CandidateSet.isNewCandidate(FunctionTemplate))
5784 TemplateDeductionInfo Info(CandidateSet.getLocation());
5785 CXXConversionDecl *Specialization = 0;
5786 if (TemplateDeductionResult Result
5787 = DeduceTemplateArguments(FunctionTemplate, ToType,
5788 Specialization, Info)) {
5789 OverloadCandidate &Candidate = CandidateSet.addCandidate();
5790 Candidate.FoundDecl = FoundDecl;
5791 Candidate.Function = FunctionTemplate->getTemplatedDecl();
5792 Candidate.Viable = false;
5793 Candidate.FailureKind = ovl_fail_bad_deduction;
5794 Candidate.IsSurrogate = false;
5795 Candidate.IgnoreObjectArgument = false;
5796 Candidate.ExplicitCallArguments = 1;
5797 Candidate.DeductionFailure = MakeDeductionFailureInfo(Context, Result,
5802 // Add the conversion function template specialization produced by
5803 // template argument deduction as a candidate.
5804 assert(Specialization && "Missing function template specialization?");
5805 AddConversionCandidate(Specialization, FoundDecl, ActingDC, From, ToType,
5809 /// AddSurrogateCandidate - Adds a "surrogate" candidate function that
5810 /// converts the given @c Object to a function pointer via the
5811 /// conversion function @c Conversion, and then attempts to call it
5812 /// with the given arguments (C++ [over.call.object]p2-4). Proto is
5813 /// the type of function that we'll eventually be calling.
5814 void Sema::AddSurrogateCandidate(CXXConversionDecl *Conversion,
5815 DeclAccessPair FoundDecl,
5816 CXXRecordDecl *ActingContext,
5817 const FunctionProtoType *Proto,
5819 llvm::ArrayRef<Expr *> Args,
5820 OverloadCandidateSet& CandidateSet) {
5821 if (!CandidateSet.isNewCandidate(Conversion))
5824 // Overload resolution is always an unevaluated context.
5825 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
5827 OverloadCandidate &Candidate = CandidateSet.addCandidate(Args.size() + 1);
5828 Candidate.FoundDecl = FoundDecl;
5829 Candidate.Function = 0;
5830 Candidate.Surrogate = Conversion;
5831 Candidate.Viable = true;
5832 Candidate.IsSurrogate = true;
5833 Candidate.IgnoreObjectArgument = false;
5834 Candidate.ExplicitCallArguments = Args.size();
5836 // Determine the implicit conversion sequence for the implicit
5837 // object parameter.
5838 ImplicitConversionSequence ObjectInit
5839 = TryObjectArgumentInitialization(*this, Object->getType(),
5840 Object->Classify(Context),
5841 Conversion, ActingContext);
5842 if (ObjectInit.isBad()) {
5843 Candidate.Viable = false;
5844 Candidate.FailureKind = ovl_fail_bad_conversion;
5845 Candidate.Conversions[0] = ObjectInit;
5849 // The first conversion is actually a user-defined conversion whose
5850 // first conversion is ObjectInit's standard conversion (which is
5851 // effectively a reference binding). Record it as such.
5852 Candidate.Conversions[0].setUserDefined();
5853 Candidate.Conversions[0].UserDefined.Before = ObjectInit.Standard;
5854 Candidate.Conversions[0].UserDefined.EllipsisConversion = false;
5855 Candidate.Conversions[0].UserDefined.HadMultipleCandidates = false;
5856 Candidate.Conversions[0].UserDefined.ConversionFunction = Conversion;
5857 Candidate.Conversions[0].UserDefined.FoundConversionFunction = FoundDecl;
5858 Candidate.Conversions[0].UserDefined.After
5859 = Candidate.Conversions[0].UserDefined.Before;
5860 Candidate.Conversions[0].UserDefined.After.setAsIdentityConversion();
5863 unsigned NumArgsInProto = Proto->getNumArgs();
5865 // (C++ 13.3.2p2): A candidate function having fewer than m
5866 // parameters is viable only if it has an ellipsis in its parameter
5868 if (Args.size() > NumArgsInProto && !Proto->isVariadic()) {
5869 Candidate.Viable = false;
5870 Candidate.FailureKind = ovl_fail_too_many_arguments;
5874 // Function types don't have any default arguments, so just check if
5875 // we have enough arguments.
5876 if (Args.size() < NumArgsInProto) {
5877 // Not enough arguments.
5878 Candidate.Viable = false;
5879 Candidate.FailureKind = ovl_fail_too_few_arguments;
5883 // Determine the implicit conversion sequences for each of the
5885 for (unsigned ArgIdx = 0; ArgIdx < Args.size(); ++ArgIdx) {
5886 if (ArgIdx < NumArgsInProto) {
5887 // (C++ 13.3.2p3): for F to be a viable function, there shall
5888 // exist for each argument an implicit conversion sequence
5889 // (13.3.3.1) that converts that argument to the corresponding
5891 QualType ParamType = Proto->getArgType(ArgIdx);
5892 Candidate.Conversions[ArgIdx + 1]
5893 = TryCopyInitialization(*this, Args[ArgIdx], ParamType,
5894 /*SuppressUserConversions=*/false,
5895 /*InOverloadResolution=*/false,
5896 /*AllowObjCWritebackConversion=*/
5897 getLangOpts().ObjCAutoRefCount);
5898 if (Candidate.Conversions[ArgIdx + 1].isBad()) {
5899 Candidate.Viable = false;
5900 Candidate.FailureKind = ovl_fail_bad_conversion;
5904 // (C++ 13.3.2p2): For the purposes of overload resolution, any
5905 // argument for which there is no corresponding parameter is
5906 // considered to ""match the ellipsis" (C+ 13.3.3.1.3).
5907 Candidate.Conversions[ArgIdx + 1].setEllipsis();
5912 /// \brief Add overload candidates for overloaded operators that are
5913 /// member functions.
5915 /// Add the overloaded operator candidates that are member functions
5916 /// for the operator Op that was used in an operator expression such
5917 /// as "x Op y". , Args/NumArgs provides the operator arguments, and
5918 /// CandidateSet will store the added overload candidates. (C++
5919 /// [over.match.oper]).
5920 void Sema::AddMemberOperatorCandidates(OverloadedOperatorKind Op,
5921 SourceLocation OpLoc,
5922 Expr **Args, unsigned NumArgs,
5923 OverloadCandidateSet& CandidateSet,
5924 SourceRange OpRange) {
5925 DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op);
5927 // C++ [over.match.oper]p3:
5928 // For a unary operator @ with an operand of a type whose
5929 // cv-unqualified version is T1, and for a binary operator @ with
5930 // a left operand of a type whose cv-unqualified version is T1 and
5931 // a right operand of a type whose cv-unqualified version is T2,
5932 // three sets of candidate functions, designated member
5933 // candidates, non-member candidates and built-in candidates, are
5934 // constructed as follows:
5935 QualType T1 = Args[0]->getType();
5937 // -- If T1 is a class type, the set of member candidates is the
5938 // result of the qualified lookup of T1::operator@
5939 // (13.3.1.1.1); otherwise, the set of member candidates is
5941 if (const RecordType *T1Rec = T1->getAs<RecordType>()) {
5942 // Complete the type if it can be completed. Otherwise, we're done.
5943 if (RequireCompleteType(OpLoc, T1, 0))
5946 LookupResult Operators(*this, OpName, OpLoc, LookupOrdinaryName);
5947 LookupQualifiedName(Operators, T1Rec->getDecl());
5948 Operators.suppressDiagnostics();
5950 for (LookupResult::iterator Oper = Operators.begin(),
5951 OperEnd = Operators.end();
5954 AddMethodCandidate(Oper.getPair(), Args[0]->getType(),
5955 Args[0]->Classify(Context), Args + 1, NumArgs - 1,
5957 /* SuppressUserConversions = */ false);
5961 /// AddBuiltinCandidate - Add a candidate for a built-in
5962 /// operator. ResultTy and ParamTys are the result and parameter types
5963 /// of the built-in candidate, respectively. Args and NumArgs are the
5964 /// arguments being passed to the candidate. IsAssignmentOperator
5965 /// should be true when this built-in candidate is an assignment
5966 /// operator. NumContextualBoolArguments is the number of arguments
5967 /// (at the beginning of the argument list) that will be contextually
5968 /// converted to bool.
5969 void Sema::AddBuiltinCandidate(QualType ResultTy, QualType *ParamTys,
5970 Expr **Args, unsigned NumArgs,
5971 OverloadCandidateSet& CandidateSet,
5972 bool IsAssignmentOperator,
5973 unsigned NumContextualBoolArguments) {
5974 // Overload resolution is always an unevaluated context.
5975 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
5977 // Add this candidate
5978 OverloadCandidate &Candidate = CandidateSet.addCandidate(NumArgs);
5979 Candidate.FoundDecl = DeclAccessPair::make(0, AS_none);
5980 Candidate.Function = 0;
5981 Candidate.IsSurrogate = false;
5982 Candidate.IgnoreObjectArgument = false;
5983 Candidate.BuiltinTypes.ResultTy = ResultTy;
5984 for (unsigned ArgIdx = 0; ArgIdx < NumArgs; ++ArgIdx)
5985 Candidate.BuiltinTypes.ParamTypes[ArgIdx] = ParamTys[ArgIdx];
5987 // Determine the implicit conversion sequences for each of the
5989 Candidate.Viable = true;
5990 Candidate.ExplicitCallArguments = NumArgs;
5991 for (unsigned ArgIdx = 0; ArgIdx < NumArgs; ++ArgIdx) {
5992 // C++ [over.match.oper]p4:
5993 // For the built-in assignment operators, conversions of the
5994 // left operand are restricted as follows:
5995 // -- no temporaries are introduced to hold the left operand, and
5996 // -- no user-defined conversions are applied to the left
5997 // operand to achieve a type match with the left-most
5998 // parameter of a built-in candidate.
6000 // We block these conversions by turning off user-defined
6001 // conversions, since that is the only way that initialization of
6002 // a reference to a non-class type can occur from something that
6003 // is not of the same type.
6004 if (ArgIdx < NumContextualBoolArguments) {
6005 assert(ParamTys[ArgIdx] == Context.BoolTy &&
6006 "Contextual conversion to bool requires bool type");
6007 Candidate.Conversions[ArgIdx]
6008 = TryContextuallyConvertToBool(*this, Args[ArgIdx]);
6010 Candidate.Conversions[ArgIdx]
6011 = TryCopyInitialization(*this, Args[ArgIdx], ParamTys[ArgIdx],
6012 ArgIdx == 0 && IsAssignmentOperator,
6013 /*InOverloadResolution=*/false,
6014 /*AllowObjCWritebackConversion=*/
6015 getLangOpts().ObjCAutoRefCount);
6017 if (Candidate.Conversions[ArgIdx].isBad()) {
6018 Candidate.Viable = false;
6019 Candidate.FailureKind = ovl_fail_bad_conversion;
6025 /// BuiltinCandidateTypeSet - A set of types that will be used for the
6026 /// candidate operator functions for built-in operators (C++
6027 /// [over.built]). The types are separated into pointer types and
6028 /// enumeration types.
6029 class BuiltinCandidateTypeSet {
6030 /// TypeSet - A set of types.
6031 typedef llvm::SmallPtrSet<QualType, 8> TypeSet;
6033 /// PointerTypes - The set of pointer types that will be used in the
6034 /// built-in candidates.
6035 TypeSet PointerTypes;
6037 /// MemberPointerTypes - The set of member pointer types that will be
6038 /// used in the built-in candidates.
6039 TypeSet MemberPointerTypes;
6041 /// EnumerationTypes - The set of enumeration types that will be
6042 /// used in the built-in candidates.
6043 TypeSet EnumerationTypes;
6045 /// \brief The set of vector types that will be used in the built-in
6047 TypeSet VectorTypes;
6049 /// \brief A flag indicating non-record types are viable candidates
6050 bool HasNonRecordTypes;
6052 /// \brief A flag indicating whether either arithmetic or enumeration types
6053 /// were present in the candidate set.
6054 bool HasArithmeticOrEnumeralTypes;
6056 /// \brief A flag indicating whether the nullptr type was present in the
6058 bool HasNullPtrType;
6060 /// Sema - The semantic analysis instance where we are building the
6061 /// candidate type set.
6064 /// Context - The AST context in which we will build the type sets.
6065 ASTContext &Context;
6067 bool AddPointerWithMoreQualifiedTypeVariants(QualType Ty,
6068 const Qualifiers &VisibleQuals);
6069 bool AddMemberPointerWithMoreQualifiedTypeVariants(QualType Ty);
6072 /// iterator - Iterates through the types that are part of the set.
6073 typedef TypeSet::iterator iterator;
6075 BuiltinCandidateTypeSet(Sema &SemaRef)
6076 : HasNonRecordTypes(false),
6077 HasArithmeticOrEnumeralTypes(false),
6078 HasNullPtrType(false),
6080 Context(SemaRef.Context) { }
6082 void AddTypesConvertedFrom(QualType Ty,
6084 bool AllowUserConversions,
6085 bool AllowExplicitConversions,
6086 const Qualifiers &VisibleTypeConversionsQuals);
6088 /// pointer_begin - First pointer type found;
6089 iterator pointer_begin() { return PointerTypes.begin(); }
6091 /// pointer_end - Past the last pointer type found;
6092 iterator pointer_end() { return PointerTypes.end(); }
6094 /// member_pointer_begin - First member pointer type found;
6095 iterator member_pointer_begin() { return MemberPointerTypes.begin(); }
6097 /// member_pointer_end - Past the last member pointer type found;
6098 iterator member_pointer_end() { return MemberPointerTypes.end(); }
6100 /// enumeration_begin - First enumeration type found;
6101 iterator enumeration_begin() { return EnumerationTypes.begin(); }
6103 /// enumeration_end - Past the last enumeration type found;
6104 iterator enumeration_end() { return EnumerationTypes.end(); }
6106 iterator vector_begin() { return VectorTypes.begin(); }
6107 iterator vector_end() { return VectorTypes.end(); }
6109 bool hasNonRecordTypes() { return HasNonRecordTypes; }
6110 bool hasArithmeticOrEnumeralTypes() { return HasArithmeticOrEnumeralTypes; }
6111 bool hasNullPtrType() const { return HasNullPtrType; }
6114 /// AddPointerWithMoreQualifiedTypeVariants - Add the pointer type @p Ty to
6115 /// the set of pointer types along with any more-qualified variants of
6116 /// that type. For example, if @p Ty is "int const *", this routine
6117 /// will add "int const *", "int const volatile *", "int const
6118 /// restrict *", and "int const volatile restrict *" to the set of
6119 /// pointer types. Returns true if the add of @p Ty itself succeeded,
6120 /// false otherwise.
6122 /// FIXME: what to do about extended qualifiers?
6124 BuiltinCandidateTypeSet::AddPointerWithMoreQualifiedTypeVariants(QualType Ty,
6125 const Qualifiers &VisibleQuals) {
6127 // Insert this type.
6128 if (!PointerTypes.insert(Ty))
6132 const PointerType *PointerTy = Ty->getAs<PointerType>();
6133 bool buildObjCPtr = false;
6135 const ObjCObjectPointerType *PTy = Ty->castAs<ObjCObjectPointerType>();
6136 PointeeTy = PTy->getPointeeType();
6137 buildObjCPtr = true;
6139 PointeeTy = PointerTy->getPointeeType();
6142 // Don't add qualified variants of arrays. For one, they're not allowed
6143 // (the qualifier would sink to the element type), and for another, the
6144 // only overload situation where it matters is subscript or pointer +- int,
6145 // and those shouldn't have qualifier variants anyway.
6146 if (PointeeTy->isArrayType())
6149 unsigned BaseCVR = PointeeTy.getCVRQualifiers();
6150 bool hasVolatile = VisibleQuals.hasVolatile();
6151 bool hasRestrict = VisibleQuals.hasRestrict();
6153 // Iterate through all strict supersets of BaseCVR.
6154 for (unsigned CVR = BaseCVR+1; CVR <= Qualifiers::CVRMask; ++CVR) {
6155 if ((CVR | BaseCVR) != CVR) continue;
6156 // Skip over volatile if no volatile found anywhere in the types.
6157 if ((CVR & Qualifiers::Volatile) && !hasVolatile) continue;
6159 // Skip over restrict if no restrict found anywhere in the types, or if
6160 // the type cannot be restrict-qualified.
6161 if ((CVR & Qualifiers::Restrict) &&
6163 (!(PointeeTy->isAnyPointerType() || PointeeTy->isReferenceType()))))
6166 // Build qualified pointee type.
6167 QualType QPointeeTy = Context.getCVRQualifiedType(PointeeTy, CVR);
6169 // Build qualified pointer type.
6170 QualType QPointerTy;
6172 QPointerTy = Context.getPointerType(QPointeeTy);
6174 QPointerTy = Context.getObjCObjectPointerType(QPointeeTy);
6176 // Insert qualified pointer type.
6177 PointerTypes.insert(QPointerTy);
6183 /// AddMemberPointerWithMoreQualifiedTypeVariants - Add the pointer type @p Ty
6184 /// to the set of pointer types along with any more-qualified variants of
6185 /// that type. For example, if @p Ty is "int const *", this routine
6186 /// will add "int const *", "int const volatile *", "int const
6187 /// restrict *", and "int const volatile restrict *" to the set of
6188 /// pointer types. Returns true if the add of @p Ty itself succeeded,
6189 /// false otherwise.
6191 /// FIXME: what to do about extended qualifiers?
6193 BuiltinCandidateTypeSet::AddMemberPointerWithMoreQualifiedTypeVariants(
6195 // Insert this type.
6196 if (!MemberPointerTypes.insert(Ty))
6199 const MemberPointerType *PointerTy = Ty->getAs<MemberPointerType>();
6200 assert(PointerTy && "type was not a member pointer type!");
6202 QualType PointeeTy = PointerTy->getPointeeType();
6203 // Don't add qualified variants of arrays. For one, they're not allowed
6204 // (the qualifier would sink to the element type), and for another, the
6205 // only overload situation where it matters is subscript or pointer +- int,
6206 // and those shouldn't have qualifier variants anyway.
6207 if (PointeeTy->isArrayType())
6209 const Type *ClassTy = PointerTy->getClass();
6211 // Iterate through all strict supersets of the pointee type's CVR
6213 unsigned BaseCVR = PointeeTy.getCVRQualifiers();
6214 for (unsigned CVR = BaseCVR+1; CVR <= Qualifiers::CVRMask; ++CVR) {
6215 if ((CVR | BaseCVR) != CVR) continue;
6217 QualType QPointeeTy = Context.getCVRQualifiedType(PointeeTy, CVR);
6218 MemberPointerTypes.insert(
6219 Context.getMemberPointerType(QPointeeTy, ClassTy));
6225 /// AddTypesConvertedFrom - Add each of the types to which the type @p
6226 /// Ty can be implicit converted to the given set of @p Types. We're
6227 /// primarily interested in pointer types and enumeration types. We also
6228 /// take member pointer types, for the conditional operator.
6229 /// AllowUserConversions is true if we should look at the conversion
6230 /// functions of a class type, and AllowExplicitConversions if we
6231 /// should also include the explicit conversion functions of a class
6234 BuiltinCandidateTypeSet::AddTypesConvertedFrom(QualType Ty,
6236 bool AllowUserConversions,
6237 bool AllowExplicitConversions,
6238 const Qualifiers &VisibleQuals) {
6239 // Only deal with canonical types.
6240 Ty = Context.getCanonicalType(Ty);
6242 // Look through reference types; they aren't part of the type of an
6243 // expression for the purposes of conversions.
6244 if (const ReferenceType *RefTy = Ty->getAs<ReferenceType>())
6245 Ty = RefTy->getPointeeType();
6247 // If we're dealing with an array type, decay to the pointer.
6248 if (Ty->isArrayType())
6249 Ty = SemaRef.Context.getArrayDecayedType(Ty);
6251 // Otherwise, we don't care about qualifiers on the type.
6252 Ty = Ty.getLocalUnqualifiedType();
6254 // Flag if we ever add a non-record type.
6255 const RecordType *TyRec = Ty->getAs<RecordType>();
6256 HasNonRecordTypes = HasNonRecordTypes || !TyRec;
6258 // Flag if we encounter an arithmetic type.
6259 HasArithmeticOrEnumeralTypes =
6260 HasArithmeticOrEnumeralTypes || Ty->isArithmeticType();
6262 if (Ty->isObjCIdType() || Ty->isObjCClassType())
6263 PointerTypes.insert(Ty);
6264 else if (Ty->getAs<PointerType>() || Ty->getAs<ObjCObjectPointerType>()) {
6265 // Insert our type, and its more-qualified variants, into the set
6267 if (!AddPointerWithMoreQualifiedTypeVariants(Ty, VisibleQuals))
6269 } else if (Ty->isMemberPointerType()) {
6270 // Member pointers are far easier, since the pointee can't be converted.
6271 if (!AddMemberPointerWithMoreQualifiedTypeVariants(Ty))
6273 } else if (Ty->isEnumeralType()) {
6274 HasArithmeticOrEnumeralTypes = true;
6275 EnumerationTypes.insert(Ty);
6276 } else if (Ty->isVectorType()) {
6277 // We treat vector types as arithmetic types in many contexts as an
6279 HasArithmeticOrEnumeralTypes = true;
6280 VectorTypes.insert(Ty);
6281 } else if (Ty->isNullPtrType()) {
6282 HasNullPtrType = true;
6283 } else if (AllowUserConversions && TyRec) {
6284 // No conversion functions in incomplete types.
6285 if (SemaRef.RequireCompleteType(Loc, Ty, 0))
6288 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(TyRec->getDecl());
6289 const UnresolvedSetImpl *Conversions
6290 = ClassDecl->getVisibleConversionFunctions();
6291 for (UnresolvedSetImpl::iterator I = Conversions->begin(),
6292 E = Conversions->end(); I != E; ++I) {
6293 NamedDecl *D = I.getDecl();
6294 if (isa<UsingShadowDecl>(D))
6295 D = cast<UsingShadowDecl>(D)->getTargetDecl();
6297 // Skip conversion function templates; they don't tell us anything
6298 // about which builtin types we can convert to.
6299 if (isa<FunctionTemplateDecl>(D))
6302 CXXConversionDecl *Conv = cast<CXXConversionDecl>(D);
6303 if (AllowExplicitConversions || !Conv->isExplicit()) {
6304 AddTypesConvertedFrom(Conv->getConversionType(), Loc, false, false,
6311 /// \brief Helper function for AddBuiltinOperatorCandidates() that adds
6312 /// the volatile- and non-volatile-qualified assignment operators for the
6313 /// given type to the candidate set.
6314 static void AddBuiltinAssignmentOperatorCandidates(Sema &S,
6318 OverloadCandidateSet &CandidateSet) {
6319 QualType ParamTypes[2];
6321 // T& operator=(T&, T)
6322 ParamTypes[0] = S.Context.getLValueReferenceType(T);
6324 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2, CandidateSet,
6325 /*IsAssignmentOperator=*/true);
6327 if (!S.Context.getCanonicalType(T).isVolatileQualified()) {
6328 // volatile T& operator=(volatile T&, T)
6330 = S.Context.getLValueReferenceType(S.Context.getVolatileType(T));
6332 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2, CandidateSet,
6333 /*IsAssignmentOperator=*/true);
6337 /// CollectVRQualifiers - This routine returns Volatile/Restrict qualifiers,
6338 /// if any, found in visible type conversion functions found in ArgExpr's type.
6339 static Qualifiers CollectVRQualifiers(ASTContext &Context, Expr* ArgExpr) {
6341 const RecordType *TyRec;
6342 if (const MemberPointerType *RHSMPType =
6343 ArgExpr->getType()->getAs<MemberPointerType>())
6344 TyRec = RHSMPType->getClass()->getAs<RecordType>();
6346 TyRec = ArgExpr->getType()->getAs<RecordType>();
6348 // Just to be safe, assume the worst case.
6349 VRQuals.addVolatile();
6350 VRQuals.addRestrict();
6354 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(TyRec->getDecl());
6355 if (!ClassDecl->hasDefinition())
6358 const UnresolvedSetImpl *Conversions =
6359 ClassDecl->getVisibleConversionFunctions();
6361 for (UnresolvedSetImpl::iterator I = Conversions->begin(),
6362 E = Conversions->end(); I != E; ++I) {
6363 NamedDecl *D = I.getDecl();
6364 if (isa<UsingShadowDecl>(D))
6365 D = cast<UsingShadowDecl>(D)->getTargetDecl();
6366 if (CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(D)) {
6367 QualType CanTy = Context.getCanonicalType(Conv->getConversionType());
6368 if (const ReferenceType *ResTypeRef = CanTy->getAs<ReferenceType>())
6369 CanTy = ResTypeRef->getPointeeType();
6370 // Need to go down the pointer/mempointer chain and add qualifiers
6374 if (CanTy.isRestrictQualified())
6375 VRQuals.addRestrict();
6376 if (const PointerType *ResTypePtr = CanTy->getAs<PointerType>())
6377 CanTy = ResTypePtr->getPointeeType();
6378 else if (const MemberPointerType *ResTypeMPtr =
6379 CanTy->getAs<MemberPointerType>())
6380 CanTy = ResTypeMPtr->getPointeeType();
6383 if (CanTy.isVolatileQualified())
6384 VRQuals.addVolatile();
6385 if (VRQuals.hasRestrict() && VRQuals.hasVolatile())
6395 /// \brief Helper class to manage the addition of builtin operator overload
6396 /// candidates. It provides shared state and utility methods used throughout
6397 /// the process, as well as a helper method to add each group of builtin
6398 /// operator overloads from the standard to a candidate set.
6399 class BuiltinOperatorOverloadBuilder {
6400 // Common instance state available to all overload candidate addition methods.
6404 Qualifiers VisibleTypeConversionsQuals;
6405 bool HasArithmeticOrEnumeralCandidateType;
6406 SmallVectorImpl<BuiltinCandidateTypeSet> &CandidateTypes;
6407 OverloadCandidateSet &CandidateSet;
6409 // Define some constants used to index and iterate over the arithemetic types
6410 // provided via the getArithmeticType() method below.
6411 // The "promoted arithmetic types" are the arithmetic
6412 // types are that preserved by promotion (C++ [over.built]p2).
6413 static const unsigned FirstIntegralType = 3;
6414 static const unsigned LastIntegralType = 20;
6415 static const unsigned FirstPromotedIntegralType = 3,
6416 LastPromotedIntegralType = 11;
6417 static const unsigned FirstPromotedArithmeticType = 0,
6418 LastPromotedArithmeticType = 11;
6419 static const unsigned NumArithmeticTypes = 20;
6421 /// \brief Get the canonical type for a given arithmetic type index.
6422 CanQualType getArithmeticType(unsigned index) {
6423 assert(index < NumArithmeticTypes);
6424 static CanQualType ASTContext::* const
6425 ArithmeticTypes[NumArithmeticTypes] = {
6426 // Start of promoted types.
6427 &ASTContext::FloatTy,
6428 &ASTContext::DoubleTy,
6429 &ASTContext::LongDoubleTy,
6431 // Start of integral types.
6433 &ASTContext::LongTy,
6434 &ASTContext::LongLongTy,
6435 &ASTContext::Int128Ty,
6436 &ASTContext::UnsignedIntTy,
6437 &ASTContext::UnsignedLongTy,
6438 &ASTContext::UnsignedLongLongTy,
6439 &ASTContext::UnsignedInt128Ty,
6440 // End of promoted types.
6442 &ASTContext::BoolTy,
6443 &ASTContext::CharTy,
6444 &ASTContext::WCharTy,
6445 &ASTContext::Char16Ty,
6446 &ASTContext::Char32Ty,
6447 &ASTContext::SignedCharTy,
6448 &ASTContext::ShortTy,
6449 &ASTContext::UnsignedCharTy,
6450 &ASTContext::UnsignedShortTy,
6451 // End of integral types.
6452 // FIXME: What about complex? What about half?
6454 return S.Context.*ArithmeticTypes[index];
6457 /// \brief Gets the canonical type resulting from the usual arithemetic
6458 /// converions for the given arithmetic types.
6459 CanQualType getUsualArithmeticConversions(unsigned L, unsigned R) {
6460 // Accelerator table for performing the usual arithmetic conversions.
6461 // The rules are basically:
6462 // - if either is floating-point, use the wider floating-point
6463 // - if same signedness, use the higher rank
6464 // - if same size, use unsigned of the higher rank
6465 // - use the larger type
6466 // These rules, together with the axiom that higher ranks are
6467 // never smaller, are sufficient to precompute all of these results
6468 // *except* when dealing with signed types of higher rank.
6469 // (we could precompute SLL x UI for all known platforms, but it's
6470 // better not to make any assumptions).
6471 // We assume that int128 has a higher rank than long long on all platforms.
6474 Flt, Dbl, LDbl, SI, SL, SLL, S128, UI, UL, ULL, U128
6476 static const PromotedType ConversionsTable[LastPromotedArithmeticType]
6477 [LastPromotedArithmeticType] = {
6478 /* Flt*/ { Flt, Dbl, LDbl, Flt, Flt, Flt, Flt, Flt, Flt, Flt, Flt },
6479 /* Dbl*/ { Dbl, Dbl, LDbl, Dbl, Dbl, Dbl, Dbl, Dbl, Dbl, Dbl, Dbl },
6480 /*LDbl*/ { LDbl, LDbl, LDbl, LDbl, LDbl, LDbl, LDbl, LDbl, LDbl, LDbl, LDbl },
6481 /* SI*/ { Flt, Dbl, LDbl, SI, SL, SLL, S128, UI, UL, ULL, U128 },
6482 /* SL*/ { Flt, Dbl, LDbl, SL, SL, SLL, S128, Dep, UL, ULL, U128 },
6483 /* SLL*/ { Flt, Dbl, LDbl, SLL, SLL, SLL, S128, Dep, Dep, ULL, U128 },
6484 /*S128*/ { Flt, Dbl, LDbl, S128, S128, S128, S128, S128, S128, S128, U128 },
6485 /* UI*/ { Flt, Dbl, LDbl, UI, Dep, Dep, S128, UI, UL, ULL, U128 },
6486 /* UL*/ { Flt, Dbl, LDbl, UL, UL, Dep, S128, UL, UL, ULL, U128 },
6487 /* ULL*/ { Flt, Dbl, LDbl, ULL, ULL, ULL, S128, ULL, ULL, ULL, U128 },
6488 /*U128*/ { Flt, Dbl, LDbl, U128, U128, U128, U128, U128, U128, U128, U128 },
6491 assert(L < LastPromotedArithmeticType);
6492 assert(R < LastPromotedArithmeticType);
6493 int Idx = ConversionsTable[L][R];
6495 // Fast path: the table gives us a concrete answer.
6496 if (Idx != Dep) return getArithmeticType(Idx);
6498 // Slow path: we need to compare widths.
6499 // An invariant is that the signed type has higher rank.
6500 CanQualType LT = getArithmeticType(L),
6501 RT = getArithmeticType(R);
6502 unsigned LW = S.Context.getIntWidth(LT),
6503 RW = S.Context.getIntWidth(RT);
6505 // If they're different widths, use the signed type.
6506 if (LW > RW) return LT;
6507 else if (LW < RW) return RT;
6509 // Otherwise, use the unsigned type of the signed type's rank.
6510 if (L == SL || R == SL) return S.Context.UnsignedLongTy;
6511 assert(L == SLL || R == SLL);
6512 return S.Context.UnsignedLongLongTy;
6515 /// \brief Helper method to factor out the common pattern of adding overloads
6516 /// for '++' and '--' builtin operators.
6517 void addPlusPlusMinusMinusStyleOverloads(QualType CandidateTy,
6520 QualType ParamTypes[2] = {
6521 S.Context.getLValueReferenceType(CandidateTy),
6525 // Non-volatile version.
6527 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 1, CandidateSet);
6529 S.AddBuiltinCandidate(CandidateTy, ParamTypes, Args, 2, CandidateSet);
6531 // Use a heuristic to reduce number of builtin candidates in the set:
6532 // add volatile version only if there are conversions to a volatile type.
6535 S.Context.getLValueReferenceType(
6536 S.Context.getVolatileType(CandidateTy));
6538 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 1, CandidateSet);
6540 S.AddBuiltinCandidate(CandidateTy, ParamTypes, Args, 2, CandidateSet);
6543 // Add restrict version only if there are conversions to a restrict type
6544 // and our candidate type is a non-restrict-qualified pointer.
6545 if (HasRestrict && CandidateTy->isAnyPointerType() &&
6546 !CandidateTy.isRestrictQualified()) {
6548 = S.Context.getLValueReferenceType(
6549 S.Context.getCVRQualifiedType(CandidateTy, Qualifiers::Restrict));
6551 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 1, CandidateSet);
6553 S.AddBuiltinCandidate(CandidateTy, ParamTypes, Args, 2, CandidateSet);
6557 = S.Context.getLValueReferenceType(
6558 S.Context.getCVRQualifiedType(CandidateTy,
6559 (Qualifiers::Volatile |
6560 Qualifiers::Restrict)));
6562 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 1,
6565 S.AddBuiltinCandidate(CandidateTy, ParamTypes, Args, 2, CandidateSet);
6572 BuiltinOperatorOverloadBuilder(
6573 Sema &S, Expr **Args, unsigned NumArgs,
6574 Qualifiers VisibleTypeConversionsQuals,
6575 bool HasArithmeticOrEnumeralCandidateType,
6576 SmallVectorImpl<BuiltinCandidateTypeSet> &CandidateTypes,
6577 OverloadCandidateSet &CandidateSet)
6578 : S(S), Args(Args), NumArgs(NumArgs),
6579 VisibleTypeConversionsQuals(VisibleTypeConversionsQuals),
6580 HasArithmeticOrEnumeralCandidateType(
6581 HasArithmeticOrEnumeralCandidateType),
6582 CandidateTypes(CandidateTypes),
6583 CandidateSet(CandidateSet) {
6584 // Validate some of our static helper constants in debug builds.
6585 assert(getArithmeticType(FirstPromotedIntegralType) == S.Context.IntTy &&
6586 "Invalid first promoted integral type");
6587 assert(getArithmeticType(LastPromotedIntegralType - 1)
6588 == S.Context.UnsignedInt128Ty &&
6589 "Invalid last promoted integral type");
6590 assert(getArithmeticType(FirstPromotedArithmeticType)
6591 == S.Context.FloatTy &&
6592 "Invalid first promoted arithmetic type");
6593 assert(getArithmeticType(LastPromotedArithmeticType - 1)
6594 == S.Context.UnsignedInt128Ty &&
6595 "Invalid last promoted arithmetic type");
6598 // C++ [over.built]p3:
6600 // For every pair (T, VQ), where T is an arithmetic type, and VQ
6601 // is either volatile or empty, there exist candidate operator
6602 // functions of the form
6604 // VQ T& operator++(VQ T&);
6605 // T operator++(VQ T&, int);
6607 // C++ [over.built]p4:
6609 // For every pair (T, VQ), where T is an arithmetic type other
6610 // than bool, and VQ is either volatile or empty, there exist
6611 // candidate operator functions of the form
6613 // VQ T& operator--(VQ T&);
6614 // T operator--(VQ T&, int);
6615 void addPlusPlusMinusMinusArithmeticOverloads(OverloadedOperatorKind Op) {
6616 if (!HasArithmeticOrEnumeralCandidateType)
6619 for (unsigned Arith = (Op == OO_PlusPlus? 0 : 1);
6620 Arith < NumArithmeticTypes; ++Arith) {
6621 addPlusPlusMinusMinusStyleOverloads(
6622 getArithmeticType(Arith),
6623 VisibleTypeConversionsQuals.hasVolatile(),
6624 VisibleTypeConversionsQuals.hasRestrict());
6628 // C++ [over.built]p5:
6630 // For every pair (T, VQ), where T is a cv-qualified or
6631 // cv-unqualified object type, and VQ is either volatile or
6632 // empty, there exist candidate operator functions of the form
6634 // T*VQ& operator++(T*VQ&);
6635 // T*VQ& operator--(T*VQ&);
6636 // T* operator++(T*VQ&, int);
6637 // T* operator--(T*VQ&, int);
6638 void addPlusPlusMinusMinusPointerOverloads() {
6639 for (BuiltinCandidateTypeSet::iterator
6640 Ptr = CandidateTypes[0].pointer_begin(),
6641 PtrEnd = CandidateTypes[0].pointer_end();
6642 Ptr != PtrEnd; ++Ptr) {
6643 // Skip pointer types that aren't pointers to object types.
6644 if (!(*Ptr)->getPointeeType()->isObjectType())
6647 addPlusPlusMinusMinusStyleOverloads(*Ptr,
6648 (!(*Ptr).isVolatileQualified() &&
6649 VisibleTypeConversionsQuals.hasVolatile()),
6650 (!(*Ptr).isRestrictQualified() &&
6651 VisibleTypeConversionsQuals.hasRestrict()));
6655 // C++ [over.built]p6:
6656 // For every cv-qualified or cv-unqualified object type T, there
6657 // exist candidate operator functions of the form
6659 // T& operator*(T*);
6661 // C++ [over.built]p7:
6662 // For every function type T that does not have cv-qualifiers or a
6663 // ref-qualifier, there exist candidate operator functions of the form
6664 // T& operator*(T*);
6665 void addUnaryStarPointerOverloads() {
6666 for (BuiltinCandidateTypeSet::iterator
6667 Ptr = CandidateTypes[0].pointer_begin(),
6668 PtrEnd = CandidateTypes[0].pointer_end();
6669 Ptr != PtrEnd; ++Ptr) {
6670 QualType ParamTy = *Ptr;
6671 QualType PointeeTy = ParamTy->getPointeeType();
6672 if (!PointeeTy->isObjectType() && !PointeeTy->isFunctionType())
6675 if (const FunctionProtoType *Proto =PointeeTy->getAs<FunctionProtoType>())
6676 if (Proto->getTypeQuals() || Proto->getRefQualifier())
6679 S.AddBuiltinCandidate(S.Context.getLValueReferenceType(PointeeTy),
6680 &ParamTy, Args, 1, CandidateSet);
6684 // C++ [over.built]p9:
6685 // For every promoted arithmetic type T, there exist candidate
6686 // operator functions of the form
6690 void addUnaryPlusOrMinusArithmeticOverloads() {
6691 if (!HasArithmeticOrEnumeralCandidateType)
6694 for (unsigned Arith = FirstPromotedArithmeticType;
6695 Arith < LastPromotedArithmeticType; ++Arith) {
6696 QualType ArithTy = getArithmeticType(Arith);
6697 S.AddBuiltinCandidate(ArithTy, &ArithTy, Args, 1, CandidateSet);
6700 // Extension: We also add these operators for vector types.
6701 for (BuiltinCandidateTypeSet::iterator
6702 Vec = CandidateTypes[0].vector_begin(),
6703 VecEnd = CandidateTypes[0].vector_end();
6704 Vec != VecEnd; ++Vec) {
6705 QualType VecTy = *Vec;
6706 S.AddBuiltinCandidate(VecTy, &VecTy, Args, 1, CandidateSet);
6710 // C++ [over.built]p8:
6711 // For every type T, there exist candidate operator functions of
6714 // T* operator+(T*);
6715 void addUnaryPlusPointerOverloads() {
6716 for (BuiltinCandidateTypeSet::iterator
6717 Ptr = CandidateTypes[0].pointer_begin(),
6718 PtrEnd = CandidateTypes[0].pointer_end();
6719 Ptr != PtrEnd; ++Ptr) {
6720 QualType ParamTy = *Ptr;
6721 S.AddBuiltinCandidate(ParamTy, &ParamTy, Args, 1, CandidateSet);
6725 // C++ [over.built]p10:
6726 // For every promoted integral type T, there exist candidate
6727 // operator functions of the form
6730 void addUnaryTildePromotedIntegralOverloads() {
6731 if (!HasArithmeticOrEnumeralCandidateType)
6734 for (unsigned Int = FirstPromotedIntegralType;
6735 Int < LastPromotedIntegralType; ++Int) {
6736 QualType IntTy = getArithmeticType(Int);
6737 S.AddBuiltinCandidate(IntTy, &IntTy, Args, 1, CandidateSet);
6740 // Extension: We also add this operator for vector types.
6741 for (BuiltinCandidateTypeSet::iterator
6742 Vec = CandidateTypes[0].vector_begin(),
6743 VecEnd = CandidateTypes[0].vector_end();
6744 Vec != VecEnd; ++Vec) {
6745 QualType VecTy = *Vec;
6746 S.AddBuiltinCandidate(VecTy, &VecTy, Args, 1, CandidateSet);
6750 // C++ [over.match.oper]p16:
6751 // For every pointer to member type T, there exist candidate operator
6752 // functions of the form
6754 // bool operator==(T,T);
6755 // bool operator!=(T,T);
6756 void addEqualEqualOrNotEqualMemberPointerOverloads() {
6757 /// Set of (canonical) types that we've already handled.
6758 llvm::SmallPtrSet<QualType, 8> AddedTypes;
6760 for (unsigned ArgIdx = 0; ArgIdx < NumArgs; ++ArgIdx) {
6761 for (BuiltinCandidateTypeSet::iterator
6762 MemPtr = CandidateTypes[ArgIdx].member_pointer_begin(),
6763 MemPtrEnd = CandidateTypes[ArgIdx].member_pointer_end();
6764 MemPtr != MemPtrEnd;
6766 // Don't add the same builtin candidate twice.
6767 if (!AddedTypes.insert(S.Context.getCanonicalType(*MemPtr)))
6770 QualType ParamTypes[2] = { *MemPtr, *MemPtr };
6771 S.AddBuiltinCandidate(S.Context.BoolTy, ParamTypes, Args, 2,
6777 // C++ [over.built]p15:
6779 // For every T, where T is an enumeration type, a pointer type, or
6780 // std::nullptr_t, there exist candidate operator functions of the form
6782 // bool operator<(T, T);
6783 // bool operator>(T, T);
6784 // bool operator<=(T, T);
6785 // bool operator>=(T, T);
6786 // bool operator==(T, T);
6787 // bool operator!=(T, T);
6788 void addRelationalPointerOrEnumeralOverloads() {
6789 // C++ [over.match.oper]p3:
6790 // [...]the built-in candidates include all of the candidate operator
6791 // functions defined in 13.6 that, compared to the given operator, [...]
6792 // do not have the same parameter-type-list as any non-template non-member
6795 // Note that in practice, this only affects enumeration types because there
6796 // aren't any built-in candidates of record type, and a user-defined operator
6797 // must have an operand of record or enumeration type. Also, the only other
6798 // overloaded operator with enumeration arguments, operator=,
6799 // cannot be overloaded for enumeration types, so this is the only place
6800 // where we must suppress candidates like this.
6801 llvm::DenseSet<std::pair<CanQualType, CanQualType> >
6802 UserDefinedBinaryOperators;
6804 for (unsigned ArgIdx = 0; ArgIdx < NumArgs; ++ArgIdx) {
6805 if (CandidateTypes[ArgIdx].enumeration_begin() !=
6806 CandidateTypes[ArgIdx].enumeration_end()) {
6807 for (OverloadCandidateSet::iterator C = CandidateSet.begin(),
6808 CEnd = CandidateSet.end();
6810 if (!C->Viable || !C->Function || C->Function->getNumParams() != 2)
6813 if (C->Function->isFunctionTemplateSpecialization())
6816 QualType FirstParamType =
6817 C->Function->getParamDecl(0)->getType().getUnqualifiedType();
6818 QualType SecondParamType =
6819 C->Function->getParamDecl(1)->getType().getUnqualifiedType();
6821 // Skip if either parameter isn't of enumeral type.
6822 if (!FirstParamType->isEnumeralType() ||
6823 !SecondParamType->isEnumeralType())
6826 // Add this operator to the set of known user-defined operators.
6827 UserDefinedBinaryOperators.insert(
6828 std::make_pair(S.Context.getCanonicalType(FirstParamType),
6829 S.Context.getCanonicalType(SecondParamType)));
6834 /// Set of (canonical) types that we've already handled.
6835 llvm::SmallPtrSet<QualType, 8> AddedTypes;
6837 for (unsigned ArgIdx = 0; ArgIdx < NumArgs; ++ArgIdx) {
6838 for (BuiltinCandidateTypeSet::iterator
6839 Ptr = CandidateTypes[ArgIdx].pointer_begin(),
6840 PtrEnd = CandidateTypes[ArgIdx].pointer_end();
6841 Ptr != PtrEnd; ++Ptr) {
6842 // Don't add the same builtin candidate twice.
6843 if (!AddedTypes.insert(S.Context.getCanonicalType(*Ptr)))
6846 QualType ParamTypes[2] = { *Ptr, *Ptr };
6847 S.AddBuiltinCandidate(S.Context.BoolTy, ParamTypes, Args, 2,
6850 for (BuiltinCandidateTypeSet::iterator
6851 Enum = CandidateTypes[ArgIdx].enumeration_begin(),
6852 EnumEnd = CandidateTypes[ArgIdx].enumeration_end();
6853 Enum != EnumEnd; ++Enum) {
6854 CanQualType CanonType = S.Context.getCanonicalType(*Enum);
6856 // Don't add the same builtin candidate twice, or if a user defined
6857 // candidate exists.
6858 if (!AddedTypes.insert(CanonType) ||
6859 UserDefinedBinaryOperators.count(std::make_pair(CanonType,
6863 QualType ParamTypes[2] = { *Enum, *Enum };
6864 S.AddBuiltinCandidate(S.Context.BoolTy, ParamTypes, Args, 2,
6868 if (CandidateTypes[ArgIdx].hasNullPtrType()) {
6869 CanQualType NullPtrTy = S.Context.getCanonicalType(S.Context.NullPtrTy);
6870 if (AddedTypes.insert(NullPtrTy) &&
6871 !UserDefinedBinaryOperators.count(std::make_pair(NullPtrTy,
6873 QualType ParamTypes[2] = { NullPtrTy, NullPtrTy };
6874 S.AddBuiltinCandidate(S.Context.BoolTy, ParamTypes, Args, 2,
6881 // C++ [over.built]p13:
6883 // For every cv-qualified or cv-unqualified object type T
6884 // there exist candidate operator functions of the form
6886 // T* operator+(T*, ptrdiff_t);
6887 // T& operator[](T*, ptrdiff_t); [BELOW]
6888 // T* operator-(T*, ptrdiff_t);
6889 // T* operator+(ptrdiff_t, T*);
6890 // T& operator[](ptrdiff_t, T*); [BELOW]
6892 // C++ [over.built]p14:
6894 // For every T, where T is a pointer to object type, there
6895 // exist candidate operator functions of the form
6897 // ptrdiff_t operator-(T, T);
6898 void addBinaryPlusOrMinusPointerOverloads(OverloadedOperatorKind Op) {
6899 /// Set of (canonical) types that we've already handled.
6900 llvm::SmallPtrSet<QualType, 8> AddedTypes;
6902 for (int Arg = 0; Arg < 2; ++Arg) {
6903 QualType AsymetricParamTypes[2] = {
6904 S.Context.getPointerDiffType(),
6905 S.Context.getPointerDiffType(),
6907 for (BuiltinCandidateTypeSet::iterator
6908 Ptr = CandidateTypes[Arg].pointer_begin(),
6909 PtrEnd = CandidateTypes[Arg].pointer_end();
6910 Ptr != PtrEnd; ++Ptr) {
6911 QualType PointeeTy = (*Ptr)->getPointeeType();
6912 if (!PointeeTy->isObjectType())
6915 AsymetricParamTypes[Arg] = *Ptr;
6916 if (Arg == 0 || Op == OO_Plus) {
6917 // operator+(T*, ptrdiff_t) or operator-(T*, ptrdiff_t)
6918 // T* operator+(ptrdiff_t, T*);
6919 S.AddBuiltinCandidate(*Ptr, AsymetricParamTypes, Args, 2,
6922 if (Op == OO_Minus) {
6923 // ptrdiff_t operator-(T, T);
6924 if (!AddedTypes.insert(S.Context.getCanonicalType(*Ptr)))
6927 QualType ParamTypes[2] = { *Ptr, *Ptr };
6928 S.AddBuiltinCandidate(S.Context.getPointerDiffType(), ParamTypes,
6929 Args, 2, CandidateSet);
6935 // C++ [over.built]p12:
6937 // For every pair of promoted arithmetic types L and R, there
6938 // exist candidate operator functions of the form
6940 // LR operator*(L, R);
6941 // LR operator/(L, R);
6942 // LR operator+(L, R);
6943 // LR operator-(L, R);
6944 // bool operator<(L, R);
6945 // bool operator>(L, R);
6946 // bool operator<=(L, R);
6947 // bool operator>=(L, R);
6948 // bool operator==(L, R);
6949 // bool operator!=(L, R);
6951 // where LR is the result of the usual arithmetic conversions
6952 // between types L and R.
6954 // C++ [over.built]p24:
6956 // For every pair of promoted arithmetic types L and R, there exist
6957 // candidate operator functions of the form
6959 // LR operator?(bool, L, R);
6961 // where LR is the result of the usual arithmetic conversions
6962 // between types L and R.
6963 // Our candidates ignore the first parameter.
6964 void addGenericBinaryArithmeticOverloads(bool isComparison) {
6965 if (!HasArithmeticOrEnumeralCandidateType)
6968 for (unsigned Left = FirstPromotedArithmeticType;
6969 Left < LastPromotedArithmeticType; ++Left) {
6970 for (unsigned Right = FirstPromotedArithmeticType;
6971 Right < LastPromotedArithmeticType; ++Right) {
6972 QualType LandR[2] = { getArithmeticType(Left),
6973 getArithmeticType(Right) };
6975 isComparison ? S.Context.BoolTy
6976 : getUsualArithmeticConversions(Left, Right);
6977 S.AddBuiltinCandidate(Result, LandR, Args, 2, CandidateSet);
6981 // Extension: Add the binary operators ==, !=, <, <=, >=, >, *, /, and the
6982 // conditional operator for vector types.
6983 for (BuiltinCandidateTypeSet::iterator
6984 Vec1 = CandidateTypes[0].vector_begin(),
6985 Vec1End = CandidateTypes[0].vector_end();
6986 Vec1 != Vec1End; ++Vec1) {
6987 for (BuiltinCandidateTypeSet::iterator
6988 Vec2 = CandidateTypes[1].vector_begin(),
6989 Vec2End = CandidateTypes[1].vector_end();
6990 Vec2 != Vec2End; ++Vec2) {
6991 QualType LandR[2] = { *Vec1, *Vec2 };
6992 QualType Result = S.Context.BoolTy;
6993 if (!isComparison) {
6994 if ((*Vec1)->isExtVectorType() || !(*Vec2)->isExtVectorType())
7000 S.AddBuiltinCandidate(Result, LandR, Args, 2, CandidateSet);
7005 // C++ [over.built]p17:
7007 // For every pair of promoted integral types L and R, there
7008 // exist candidate operator functions of the form
7010 // LR operator%(L, R);
7011 // LR operator&(L, R);
7012 // LR operator^(L, R);
7013 // LR operator|(L, R);
7014 // L operator<<(L, R);
7015 // L operator>>(L, R);
7017 // where LR is the result of the usual arithmetic conversions
7018 // between types L and R.
7019 void addBinaryBitwiseArithmeticOverloads(OverloadedOperatorKind Op) {
7020 if (!HasArithmeticOrEnumeralCandidateType)
7023 for (unsigned Left = FirstPromotedIntegralType;
7024 Left < LastPromotedIntegralType; ++Left) {
7025 for (unsigned Right = FirstPromotedIntegralType;
7026 Right < LastPromotedIntegralType; ++Right) {
7027 QualType LandR[2] = { getArithmeticType(Left),
7028 getArithmeticType(Right) };
7029 QualType Result = (Op == OO_LessLess || Op == OO_GreaterGreater)
7031 : getUsualArithmeticConversions(Left, Right);
7032 S.AddBuiltinCandidate(Result, LandR, Args, 2, CandidateSet);
7037 // C++ [over.built]p20:
7039 // For every pair (T, VQ), where T is an enumeration or
7040 // pointer to member type and VQ is either volatile or
7041 // empty, there exist candidate operator functions of the form
7043 // VQ T& operator=(VQ T&, T);
7044 void addAssignmentMemberPointerOrEnumeralOverloads() {
7045 /// Set of (canonical) types that we've already handled.
7046 llvm::SmallPtrSet<QualType, 8> AddedTypes;
7048 for (unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) {
7049 for (BuiltinCandidateTypeSet::iterator
7050 Enum = CandidateTypes[ArgIdx].enumeration_begin(),
7051 EnumEnd = CandidateTypes[ArgIdx].enumeration_end();
7052 Enum != EnumEnd; ++Enum) {
7053 if (!AddedTypes.insert(S.Context.getCanonicalType(*Enum)))
7056 AddBuiltinAssignmentOperatorCandidates(S, *Enum, Args, 2,
7060 for (BuiltinCandidateTypeSet::iterator
7061 MemPtr = CandidateTypes[ArgIdx].member_pointer_begin(),
7062 MemPtrEnd = CandidateTypes[ArgIdx].member_pointer_end();
7063 MemPtr != MemPtrEnd; ++MemPtr) {
7064 if (!AddedTypes.insert(S.Context.getCanonicalType(*MemPtr)))
7067 AddBuiltinAssignmentOperatorCandidates(S, *MemPtr, Args, 2,
7073 // C++ [over.built]p19:
7075 // For every pair (T, VQ), where T is any type and VQ is either
7076 // volatile or empty, there exist candidate operator functions
7079 // T*VQ& operator=(T*VQ&, T*);
7081 // C++ [over.built]p21:
7083 // For every pair (T, VQ), where T is a cv-qualified or
7084 // cv-unqualified object type and VQ is either volatile or
7085 // empty, there exist candidate operator functions of the form
7087 // T*VQ& operator+=(T*VQ&, ptrdiff_t);
7088 // T*VQ& operator-=(T*VQ&, ptrdiff_t);
7089 void addAssignmentPointerOverloads(bool isEqualOp) {
7090 /// Set of (canonical) types that we've already handled.
7091 llvm::SmallPtrSet<QualType, 8> AddedTypes;
7093 for (BuiltinCandidateTypeSet::iterator
7094 Ptr = CandidateTypes[0].pointer_begin(),
7095 PtrEnd = CandidateTypes[0].pointer_end();
7096 Ptr != PtrEnd; ++Ptr) {
7097 // If this is operator=, keep track of the builtin candidates we added.
7099 AddedTypes.insert(S.Context.getCanonicalType(*Ptr));
7100 else if (!(*Ptr)->getPointeeType()->isObjectType())
7103 // non-volatile version
7104 QualType ParamTypes[2] = {
7105 S.Context.getLValueReferenceType(*Ptr),
7106 isEqualOp ? *Ptr : S.Context.getPointerDiffType(),
7108 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2, CandidateSet,
7109 /*IsAssigmentOperator=*/ isEqualOp);
7111 bool NeedVolatile = !(*Ptr).isVolatileQualified() &&
7112 VisibleTypeConversionsQuals.hasVolatile();
7116 S.Context.getLValueReferenceType(S.Context.getVolatileType(*Ptr));
7117 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2, CandidateSet,
7118 /*IsAssigmentOperator=*/isEqualOp);
7121 if (!(*Ptr).isRestrictQualified() &&
7122 VisibleTypeConversionsQuals.hasRestrict()) {
7125 = S.Context.getLValueReferenceType(S.Context.getRestrictType(*Ptr));
7126 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2, CandidateSet,
7127 /*IsAssigmentOperator=*/isEqualOp);
7130 // volatile restrict version
7132 = S.Context.getLValueReferenceType(
7133 S.Context.getCVRQualifiedType(*Ptr,
7134 (Qualifiers::Volatile |
7135 Qualifiers::Restrict)));
7136 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2,
7138 /*IsAssigmentOperator=*/isEqualOp);
7144 for (BuiltinCandidateTypeSet::iterator
7145 Ptr = CandidateTypes[1].pointer_begin(),
7146 PtrEnd = CandidateTypes[1].pointer_end();
7147 Ptr != PtrEnd; ++Ptr) {
7148 // Make sure we don't add the same candidate twice.
7149 if (!AddedTypes.insert(S.Context.getCanonicalType(*Ptr)))
7152 QualType ParamTypes[2] = {
7153 S.Context.getLValueReferenceType(*Ptr),
7157 // non-volatile version
7158 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2, CandidateSet,
7159 /*IsAssigmentOperator=*/true);
7161 bool NeedVolatile = !(*Ptr).isVolatileQualified() &&
7162 VisibleTypeConversionsQuals.hasVolatile();
7166 S.Context.getLValueReferenceType(S.Context.getVolatileType(*Ptr));
7167 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2,
7168 CandidateSet, /*IsAssigmentOperator=*/true);
7171 if (!(*Ptr).isRestrictQualified() &&
7172 VisibleTypeConversionsQuals.hasRestrict()) {
7175 = S.Context.getLValueReferenceType(S.Context.getRestrictType(*Ptr));
7176 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2,
7177 CandidateSet, /*IsAssigmentOperator=*/true);
7180 // volatile restrict version
7182 = S.Context.getLValueReferenceType(
7183 S.Context.getCVRQualifiedType(*Ptr,
7184 (Qualifiers::Volatile |
7185 Qualifiers::Restrict)));
7186 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2,
7187 CandidateSet, /*IsAssigmentOperator=*/true);
7195 // C++ [over.built]p18:
7197 // For every triple (L, VQ, R), where L is an arithmetic type,
7198 // VQ is either volatile or empty, and R is a promoted
7199 // arithmetic type, there exist candidate operator functions of
7202 // VQ L& operator=(VQ L&, R);
7203 // VQ L& operator*=(VQ L&, R);
7204 // VQ L& operator/=(VQ L&, R);
7205 // VQ L& operator+=(VQ L&, R);
7206 // VQ L& operator-=(VQ L&, R);
7207 void addAssignmentArithmeticOverloads(bool isEqualOp) {
7208 if (!HasArithmeticOrEnumeralCandidateType)
7211 for (unsigned Left = 0; Left < NumArithmeticTypes; ++Left) {
7212 for (unsigned Right = FirstPromotedArithmeticType;
7213 Right < LastPromotedArithmeticType; ++Right) {
7214 QualType ParamTypes[2];
7215 ParamTypes[1] = getArithmeticType(Right);
7217 // Add this built-in operator as a candidate (VQ is empty).
7219 S.Context.getLValueReferenceType(getArithmeticType(Left));
7220 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2, CandidateSet,
7221 /*IsAssigmentOperator=*/isEqualOp);
7223 // Add this built-in operator as a candidate (VQ is 'volatile').
7224 if (VisibleTypeConversionsQuals.hasVolatile()) {
7226 S.Context.getVolatileType(getArithmeticType(Left));
7227 ParamTypes[0] = S.Context.getLValueReferenceType(ParamTypes[0]);
7228 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2,
7230 /*IsAssigmentOperator=*/isEqualOp);
7235 // Extension: Add the binary operators =, +=, -=, *=, /= for vector types.
7236 for (BuiltinCandidateTypeSet::iterator
7237 Vec1 = CandidateTypes[0].vector_begin(),
7238 Vec1End = CandidateTypes[0].vector_end();
7239 Vec1 != Vec1End; ++Vec1) {
7240 for (BuiltinCandidateTypeSet::iterator
7241 Vec2 = CandidateTypes[1].vector_begin(),
7242 Vec2End = CandidateTypes[1].vector_end();
7243 Vec2 != Vec2End; ++Vec2) {
7244 QualType ParamTypes[2];
7245 ParamTypes[1] = *Vec2;
7246 // Add this built-in operator as a candidate (VQ is empty).
7247 ParamTypes[0] = S.Context.getLValueReferenceType(*Vec1);
7248 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2, CandidateSet,
7249 /*IsAssigmentOperator=*/isEqualOp);
7251 // Add this built-in operator as a candidate (VQ is 'volatile').
7252 if (VisibleTypeConversionsQuals.hasVolatile()) {
7253 ParamTypes[0] = S.Context.getVolatileType(*Vec1);
7254 ParamTypes[0] = S.Context.getLValueReferenceType(ParamTypes[0]);
7255 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2,
7257 /*IsAssigmentOperator=*/isEqualOp);
7263 // C++ [over.built]p22:
7265 // For every triple (L, VQ, R), where L is an integral type, VQ
7266 // is either volatile or empty, and R is a promoted integral
7267 // type, there exist candidate operator functions of the form
7269 // VQ L& operator%=(VQ L&, R);
7270 // VQ L& operator<<=(VQ L&, R);
7271 // VQ L& operator>>=(VQ L&, R);
7272 // VQ L& operator&=(VQ L&, R);
7273 // VQ L& operator^=(VQ L&, R);
7274 // VQ L& operator|=(VQ L&, R);
7275 void addAssignmentIntegralOverloads() {
7276 if (!HasArithmeticOrEnumeralCandidateType)
7279 for (unsigned Left = FirstIntegralType; Left < LastIntegralType; ++Left) {
7280 for (unsigned Right = FirstPromotedIntegralType;
7281 Right < LastPromotedIntegralType; ++Right) {
7282 QualType ParamTypes[2];
7283 ParamTypes[1] = getArithmeticType(Right);
7285 // Add this built-in operator as a candidate (VQ is empty).
7287 S.Context.getLValueReferenceType(getArithmeticType(Left));
7288 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2, CandidateSet);
7289 if (VisibleTypeConversionsQuals.hasVolatile()) {
7290 // Add this built-in operator as a candidate (VQ is 'volatile').
7291 ParamTypes[0] = getArithmeticType(Left);
7292 ParamTypes[0] = S.Context.getVolatileType(ParamTypes[0]);
7293 ParamTypes[0] = S.Context.getLValueReferenceType(ParamTypes[0]);
7294 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2,
7301 // C++ [over.operator]p23:
7303 // There also exist candidate operator functions of the form
7305 // bool operator!(bool);
7306 // bool operator&&(bool, bool);
7307 // bool operator||(bool, bool);
7308 void addExclaimOverload() {
7309 QualType ParamTy = S.Context.BoolTy;
7310 S.AddBuiltinCandidate(ParamTy, &ParamTy, Args, 1, CandidateSet,
7311 /*IsAssignmentOperator=*/false,
7312 /*NumContextualBoolArguments=*/1);
7314 void addAmpAmpOrPipePipeOverload() {
7315 QualType ParamTypes[2] = { S.Context.BoolTy, S.Context.BoolTy };
7316 S.AddBuiltinCandidate(S.Context.BoolTy, ParamTypes, Args, 2, CandidateSet,
7317 /*IsAssignmentOperator=*/false,
7318 /*NumContextualBoolArguments=*/2);
7321 // C++ [over.built]p13:
7323 // For every cv-qualified or cv-unqualified object type T there
7324 // exist candidate operator functions of the form
7326 // T* operator+(T*, ptrdiff_t); [ABOVE]
7327 // T& operator[](T*, ptrdiff_t);
7328 // T* operator-(T*, ptrdiff_t); [ABOVE]
7329 // T* operator+(ptrdiff_t, T*); [ABOVE]
7330 // T& operator[](ptrdiff_t, T*);
7331 void addSubscriptOverloads() {
7332 for (BuiltinCandidateTypeSet::iterator
7333 Ptr = CandidateTypes[0].pointer_begin(),
7334 PtrEnd = CandidateTypes[0].pointer_end();
7335 Ptr != PtrEnd; ++Ptr) {
7336 QualType ParamTypes[2] = { *Ptr, S.Context.getPointerDiffType() };
7337 QualType PointeeType = (*Ptr)->getPointeeType();
7338 if (!PointeeType->isObjectType())
7341 QualType ResultTy = S.Context.getLValueReferenceType(PointeeType);
7343 // T& operator[](T*, ptrdiff_t)
7344 S.AddBuiltinCandidate(ResultTy, ParamTypes, Args, 2, CandidateSet);
7347 for (BuiltinCandidateTypeSet::iterator
7348 Ptr = CandidateTypes[1].pointer_begin(),
7349 PtrEnd = CandidateTypes[1].pointer_end();
7350 Ptr != PtrEnd; ++Ptr) {
7351 QualType ParamTypes[2] = { S.Context.getPointerDiffType(), *Ptr };
7352 QualType PointeeType = (*Ptr)->getPointeeType();
7353 if (!PointeeType->isObjectType())
7356 QualType ResultTy = S.Context.getLValueReferenceType(PointeeType);
7358 // T& operator[](ptrdiff_t, T*)
7359 S.AddBuiltinCandidate(ResultTy, ParamTypes, Args, 2, CandidateSet);
7363 // C++ [over.built]p11:
7364 // For every quintuple (C1, C2, T, CV1, CV2), where C2 is a class type,
7365 // C1 is the same type as C2 or is a derived class of C2, T is an object
7366 // type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
7367 // there exist candidate operator functions of the form
7369 // CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
7371 // where CV12 is the union of CV1 and CV2.
7372 void addArrowStarOverloads() {
7373 for (BuiltinCandidateTypeSet::iterator
7374 Ptr = CandidateTypes[0].pointer_begin(),
7375 PtrEnd = CandidateTypes[0].pointer_end();
7376 Ptr != PtrEnd; ++Ptr) {
7377 QualType C1Ty = (*Ptr);
7379 QualifierCollector Q1;
7380 C1 = QualType(Q1.strip(C1Ty->getPointeeType()), 0);
7381 if (!isa<RecordType>(C1))
7383 // heuristic to reduce number of builtin candidates in the set.
7384 // Add volatile/restrict version only if there are conversions to a
7385 // volatile/restrict type.
7386 if (!VisibleTypeConversionsQuals.hasVolatile() && Q1.hasVolatile())
7388 if (!VisibleTypeConversionsQuals.hasRestrict() && Q1.hasRestrict())
7390 for (BuiltinCandidateTypeSet::iterator
7391 MemPtr = CandidateTypes[1].member_pointer_begin(),
7392 MemPtrEnd = CandidateTypes[1].member_pointer_end();
7393 MemPtr != MemPtrEnd; ++MemPtr) {
7394 const MemberPointerType *mptr = cast<MemberPointerType>(*MemPtr);
7395 QualType C2 = QualType(mptr->getClass(), 0);
7396 C2 = C2.getUnqualifiedType();
7397 if (C1 != C2 && !S.IsDerivedFrom(C1, C2))
7399 QualType ParamTypes[2] = { *Ptr, *MemPtr };
7401 QualType T = mptr->getPointeeType();
7402 if (!VisibleTypeConversionsQuals.hasVolatile() &&
7403 T.isVolatileQualified())
7405 if (!VisibleTypeConversionsQuals.hasRestrict() &&
7406 T.isRestrictQualified())
7408 T = Q1.apply(S.Context, T);
7409 QualType ResultTy = S.Context.getLValueReferenceType(T);
7410 S.AddBuiltinCandidate(ResultTy, ParamTypes, Args, 2, CandidateSet);
7415 // Note that we don't consider the first argument, since it has been
7416 // contextually converted to bool long ago. The candidates below are
7417 // therefore added as binary.
7419 // C++ [over.built]p25:
7420 // For every type T, where T is a pointer, pointer-to-member, or scoped
7421 // enumeration type, there exist candidate operator functions of the form
7423 // T operator?(bool, T, T);
7425 void addConditionalOperatorOverloads() {
7426 /// Set of (canonical) types that we've already handled.
7427 llvm::SmallPtrSet<QualType, 8> AddedTypes;
7429 for (unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) {
7430 for (BuiltinCandidateTypeSet::iterator
7431 Ptr = CandidateTypes[ArgIdx].pointer_begin(),
7432 PtrEnd = CandidateTypes[ArgIdx].pointer_end();
7433 Ptr != PtrEnd; ++Ptr) {
7434 if (!AddedTypes.insert(S.Context.getCanonicalType(*Ptr)))
7437 QualType ParamTypes[2] = { *Ptr, *Ptr };
7438 S.AddBuiltinCandidate(*Ptr, ParamTypes, Args, 2, CandidateSet);
7441 for (BuiltinCandidateTypeSet::iterator
7442 MemPtr = CandidateTypes[ArgIdx].member_pointer_begin(),
7443 MemPtrEnd = CandidateTypes[ArgIdx].member_pointer_end();
7444 MemPtr != MemPtrEnd; ++MemPtr) {
7445 if (!AddedTypes.insert(S.Context.getCanonicalType(*MemPtr)))
7448 QualType ParamTypes[2] = { *MemPtr, *MemPtr };
7449 S.AddBuiltinCandidate(*MemPtr, ParamTypes, Args, 2, CandidateSet);
7452 if (S.getLangOpts().CPlusPlus0x) {
7453 for (BuiltinCandidateTypeSet::iterator
7454 Enum = CandidateTypes[ArgIdx].enumeration_begin(),
7455 EnumEnd = CandidateTypes[ArgIdx].enumeration_end();
7456 Enum != EnumEnd; ++Enum) {
7457 if (!(*Enum)->getAs<EnumType>()->getDecl()->isScoped())
7460 if (!AddedTypes.insert(S.Context.getCanonicalType(*Enum)))
7463 QualType ParamTypes[2] = { *Enum, *Enum };
7464 S.AddBuiltinCandidate(*Enum, ParamTypes, Args, 2, CandidateSet);
7471 } // end anonymous namespace
7473 /// AddBuiltinOperatorCandidates - Add the appropriate built-in
7474 /// operator overloads to the candidate set (C++ [over.built]), based
7475 /// on the operator @p Op and the arguments given. For example, if the
7476 /// operator is a binary '+', this routine might add "int
7477 /// operator+(int, int)" to cover integer addition.
7479 Sema::AddBuiltinOperatorCandidates(OverloadedOperatorKind Op,
7480 SourceLocation OpLoc,
7481 Expr **Args, unsigned NumArgs,
7482 OverloadCandidateSet& CandidateSet) {
7483 // Find all of the types that the arguments can convert to, but only
7484 // if the operator we're looking at has built-in operator candidates
7485 // that make use of these types. Also record whether we encounter non-record
7486 // candidate types or either arithmetic or enumeral candidate types.
7487 Qualifiers VisibleTypeConversionsQuals;
7488 VisibleTypeConversionsQuals.addConst();
7489 for (unsigned ArgIdx = 0; ArgIdx < NumArgs; ++ArgIdx)
7490 VisibleTypeConversionsQuals += CollectVRQualifiers(Context, Args[ArgIdx]);
7492 bool HasNonRecordCandidateType = false;
7493 bool HasArithmeticOrEnumeralCandidateType = false;
7494 SmallVector<BuiltinCandidateTypeSet, 2> CandidateTypes;
7495 for (unsigned ArgIdx = 0; ArgIdx < NumArgs; ++ArgIdx) {
7496 CandidateTypes.push_back(BuiltinCandidateTypeSet(*this));
7497 CandidateTypes[ArgIdx].AddTypesConvertedFrom(Args[ArgIdx]->getType(),
7500 (Op == OO_Exclaim ||
7503 VisibleTypeConversionsQuals);
7504 HasNonRecordCandidateType = HasNonRecordCandidateType ||
7505 CandidateTypes[ArgIdx].hasNonRecordTypes();
7506 HasArithmeticOrEnumeralCandidateType =
7507 HasArithmeticOrEnumeralCandidateType ||
7508 CandidateTypes[ArgIdx].hasArithmeticOrEnumeralTypes();
7511 // Exit early when no non-record types have been added to the candidate set
7512 // for any of the arguments to the operator.
7514 // We can't exit early for !, ||, or &&, since there we have always have
7515 // 'bool' overloads.
7516 if (!HasNonRecordCandidateType &&
7517 !(Op == OO_Exclaim || Op == OO_AmpAmp || Op == OO_PipePipe))
7520 // Setup an object to manage the common state for building overloads.
7521 BuiltinOperatorOverloadBuilder OpBuilder(*this, Args, NumArgs,
7522 VisibleTypeConversionsQuals,
7523 HasArithmeticOrEnumeralCandidateType,
7524 CandidateTypes, CandidateSet);
7526 // Dispatch over the operation to add in only those overloads which apply.
7529 case NUM_OVERLOADED_OPERATORS:
7530 llvm_unreachable("Expected an overloaded operator");
7535 case OO_Array_Delete:
7538 "Special operators don't use AddBuiltinOperatorCandidates");
7542 // C++ [over.match.oper]p3:
7543 // -- For the operator ',', the unary operator '&', or the
7544 // operator '->', the built-in candidates set is empty.
7547 case OO_Plus: // '+' is either unary or binary
7549 OpBuilder.addUnaryPlusPointerOverloads();
7552 case OO_Minus: // '-' is either unary or binary
7554 OpBuilder.addUnaryPlusOrMinusArithmeticOverloads();
7556 OpBuilder.addBinaryPlusOrMinusPointerOverloads(Op);
7557 OpBuilder.addGenericBinaryArithmeticOverloads(/*isComparison=*/false);
7561 case OO_Star: // '*' is either unary or binary
7563 OpBuilder.addUnaryStarPointerOverloads();
7565 OpBuilder.addGenericBinaryArithmeticOverloads(/*isComparison=*/false);
7569 OpBuilder.addGenericBinaryArithmeticOverloads(/*isComparison=*/false);
7574 OpBuilder.addPlusPlusMinusMinusArithmeticOverloads(Op);
7575 OpBuilder.addPlusPlusMinusMinusPointerOverloads();
7579 case OO_ExclaimEqual:
7580 OpBuilder.addEqualEqualOrNotEqualMemberPointerOverloads();
7586 case OO_GreaterEqual:
7587 OpBuilder.addRelationalPointerOrEnumeralOverloads();
7588 OpBuilder.addGenericBinaryArithmeticOverloads(/*isComparison=*/true);
7595 case OO_GreaterGreater:
7596 OpBuilder.addBinaryBitwiseArithmeticOverloads(Op);
7599 case OO_Amp: // '&' is either unary or binary
7601 // C++ [over.match.oper]p3:
7602 // -- For the operator ',', the unary operator '&', or the
7603 // operator '->', the built-in candidates set is empty.
7606 OpBuilder.addBinaryBitwiseArithmeticOverloads(Op);
7610 OpBuilder.addUnaryTildePromotedIntegralOverloads();
7614 OpBuilder.addAssignmentMemberPointerOrEnumeralOverloads();
7619 OpBuilder.addAssignmentPointerOverloads(Op == OO_Equal);
7624 OpBuilder.addAssignmentArithmeticOverloads(Op == OO_Equal);
7627 case OO_PercentEqual:
7628 case OO_LessLessEqual:
7629 case OO_GreaterGreaterEqual:
7633 OpBuilder.addAssignmentIntegralOverloads();
7637 OpBuilder.addExclaimOverload();
7642 OpBuilder.addAmpAmpOrPipePipeOverload();
7646 OpBuilder.addSubscriptOverloads();
7650 OpBuilder.addArrowStarOverloads();
7653 case OO_Conditional:
7654 OpBuilder.addConditionalOperatorOverloads();
7655 OpBuilder.addGenericBinaryArithmeticOverloads(/*isComparison=*/false);
7660 /// \brief Add function candidates found via argument-dependent lookup
7661 /// to the set of overloading candidates.
7663 /// This routine performs argument-dependent name lookup based on the
7664 /// given function name (which may also be an operator name) and adds
7665 /// all of the overload candidates found by ADL to the overload
7666 /// candidate set (C++ [basic.lookup.argdep]).
7668 Sema::AddArgumentDependentLookupCandidates(DeclarationName Name,
7669 bool Operator, SourceLocation Loc,
7670 llvm::ArrayRef<Expr *> Args,
7671 TemplateArgumentListInfo *ExplicitTemplateArgs,
7672 OverloadCandidateSet& CandidateSet,
7673 bool PartialOverloading) {
7676 // FIXME: This approach for uniquing ADL results (and removing
7677 // redundant candidates from the set) relies on pointer-equality,
7678 // which means we need to key off the canonical decl. However,
7679 // always going back to the canonical decl might not get us the
7680 // right set of default arguments. What default arguments are
7681 // we supposed to consider on ADL candidates, anyway?
7683 // FIXME: Pass in the explicit template arguments?
7684 ArgumentDependentLookup(Name, Operator, Loc, Args, Fns);
7686 // Erase all of the candidates we already knew about.
7687 for (OverloadCandidateSet::iterator Cand = CandidateSet.begin(),
7688 CandEnd = CandidateSet.end();
7689 Cand != CandEnd; ++Cand)
7690 if (Cand->Function) {
7691 Fns.erase(Cand->Function);
7692 if (FunctionTemplateDecl *FunTmpl = Cand->Function->getPrimaryTemplate())
7696 // For each of the ADL candidates we found, add it to the overload
7698 for (ADLResult::iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) {
7699 DeclAccessPair FoundDecl = DeclAccessPair::make(*I, AS_none);
7700 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
7701 if (ExplicitTemplateArgs)
7704 AddOverloadCandidate(FD, FoundDecl, Args, CandidateSet, false,
7705 PartialOverloading);
7707 AddTemplateOverloadCandidate(cast<FunctionTemplateDecl>(*I),
7708 FoundDecl, ExplicitTemplateArgs,
7709 Args, CandidateSet);
7713 /// isBetterOverloadCandidate - Determines whether the first overload
7714 /// candidate is a better candidate than the second (C++ 13.3.3p1).
7716 isBetterOverloadCandidate(Sema &S,
7717 const OverloadCandidate &Cand1,
7718 const OverloadCandidate &Cand2,
7720 bool UserDefinedConversion) {
7721 // Define viable functions to be better candidates than non-viable
7724 return Cand1.Viable;
7725 else if (!Cand1.Viable)
7728 // C++ [over.match.best]p1:
7730 // -- if F is a static member function, ICS1(F) is defined such
7731 // that ICS1(F) is neither better nor worse than ICS1(G) for
7732 // any function G, and, symmetrically, ICS1(G) is neither
7733 // better nor worse than ICS1(F).
7734 unsigned StartArg = 0;
7735 if (Cand1.IgnoreObjectArgument || Cand2.IgnoreObjectArgument)
7738 // C++ [over.match.best]p1:
7739 // A viable function F1 is defined to be a better function than another
7740 // viable function F2 if for all arguments i, ICSi(F1) is not a worse
7741 // conversion sequence than ICSi(F2), and then...
7742 unsigned NumArgs = Cand1.NumConversions;
7743 assert(Cand2.NumConversions == NumArgs && "Overload candidate mismatch");
7744 bool HasBetterConversion = false;
7745 for (unsigned ArgIdx = StartArg; ArgIdx < NumArgs; ++ArgIdx) {
7746 switch (CompareImplicitConversionSequences(S,
7747 Cand1.Conversions[ArgIdx],
7748 Cand2.Conversions[ArgIdx])) {
7749 case ImplicitConversionSequence::Better:
7750 // Cand1 has a better conversion sequence.
7751 HasBetterConversion = true;
7754 case ImplicitConversionSequence::Worse:
7755 // Cand1 can't be better than Cand2.
7758 case ImplicitConversionSequence::Indistinguishable:
7764 // -- for some argument j, ICSj(F1) is a better conversion sequence than
7765 // ICSj(F2), or, if not that,
7766 if (HasBetterConversion)
7769 // - F1 is a non-template function and F2 is a function template
7770 // specialization, or, if not that,
7771 if ((!Cand1.Function || !Cand1.Function->getPrimaryTemplate()) &&
7772 Cand2.Function && Cand2.Function->getPrimaryTemplate())
7775 // -- F1 and F2 are function template specializations, and the function
7776 // template for F1 is more specialized than the template for F2
7777 // according to the partial ordering rules described in 14.5.5.2, or,
7779 if (Cand1.Function && Cand1.Function->getPrimaryTemplate() &&
7780 Cand2.Function && Cand2.Function->getPrimaryTemplate()) {
7781 if (FunctionTemplateDecl *BetterTemplate
7782 = S.getMoreSpecializedTemplate(Cand1.Function->getPrimaryTemplate(),
7783 Cand2.Function->getPrimaryTemplate(),
7785 isa<CXXConversionDecl>(Cand1.Function)? TPOC_Conversion
7787 Cand1.ExplicitCallArguments))
7788 return BetterTemplate == Cand1.Function->getPrimaryTemplate();
7791 // -- the context is an initialization by user-defined conversion
7792 // (see 8.5, 13.3.1.5) and the standard conversion sequence
7793 // from the return type of F1 to the destination type (i.e.,
7794 // the type of the entity being initialized) is a better
7795 // conversion sequence than the standard conversion sequence
7796 // from the return type of F2 to the destination type.
7797 if (UserDefinedConversion && Cand1.Function && Cand2.Function &&
7798 isa<CXXConversionDecl>(Cand1.Function) &&
7799 isa<CXXConversionDecl>(Cand2.Function)) {
7800 // First check whether we prefer one of the conversion functions over the
7801 // other. This only distinguishes the results in non-standard, extension
7802 // cases such as the conversion from a lambda closure type to a function
7803 // pointer or block.
7804 ImplicitConversionSequence::CompareKind FuncResult
7805 = compareConversionFunctions(S, Cand1.Function, Cand2.Function);
7806 if (FuncResult != ImplicitConversionSequence::Indistinguishable)
7809 switch (CompareStandardConversionSequences(S,
7810 Cand1.FinalConversion,
7811 Cand2.FinalConversion)) {
7812 case ImplicitConversionSequence::Better:
7813 // Cand1 has a better conversion sequence.
7816 case ImplicitConversionSequence::Worse:
7817 // Cand1 can't be better than Cand2.
7820 case ImplicitConversionSequence::Indistinguishable:
7829 /// \brief Computes the best viable function (C++ 13.3.3)
7830 /// within an overload candidate set.
7832 /// \param Loc The location of the function name (or operator symbol) for
7833 /// which overload resolution occurs.
7835 /// \param Best If overload resolution was successful or found a deleted
7836 /// function, \p Best points to the candidate function found.
7838 /// \returns The result of overload resolution.
7840 OverloadCandidateSet::BestViableFunction(Sema &S, SourceLocation Loc,
7842 bool UserDefinedConversion) {
7843 // Find the best viable function.
7845 for (iterator Cand = begin(); Cand != end(); ++Cand) {
7847 if (Best == end() || isBetterOverloadCandidate(S, *Cand, *Best, Loc,
7848 UserDefinedConversion))
7852 // If we didn't find any viable functions, abort.
7854 return OR_No_Viable_Function;
7856 // Make sure that this function is better than every other viable
7857 // function. If not, we have an ambiguity.
7858 for (iterator Cand = begin(); Cand != end(); ++Cand) {
7861 !isBetterOverloadCandidate(S, *Best, *Cand, Loc,
7862 UserDefinedConversion)) {
7864 return OR_Ambiguous;
7868 // Best is the best viable function.
7869 if (Best->Function &&
7870 (Best->Function->isDeleted() ||
7871 S.isFunctionConsideredUnavailable(Best->Function)))
7879 enum OverloadCandidateKind {
7883 oc_function_template,
7885 oc_constructor_template,
7886 oc_implicit_default_constructor,
7887 oc_implicit_copy_constructor,
7888 oc_implicit_move_constructor,
7889 oc_implicit_copy_assignment,
7890 oc_implicit_move_assignment,
7891 oc_implicit_inherited_constructor
7894 OverloadCandidateKind ClassifyOverloadCandidate(Sema &S,
7896 std::string &Description) {
7897 bool isTemplate = false;
7899 if (FunctionTemplateDecl *FunTmpl = Fn->getPrimaryTemplate()) {
7901 Description = S.getTemplateArgumentBindingsText(
7902 FunTmpl->getTemplateParameters(), *Fn->getTemplateSpecializationArgs());
7905 if (CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(Fn)) {
7906 if (!Ctor->isImplicit())
7907 return isTemplate ? oc_constructor_template : oc_constructor;
7909 if (Ctor->getInheritedConstructor())
7910 return oc_implicit_inherited_constructor;
7912 if (Ctor->isDefaultConstructor())
7913 return oc_implicit_default_constructor;
7915 if (Ctor->isMoveConstructor())
7916 return oc_implicit_move_constructor;
7918 assert(Ctor->isCopyConstructor() &&
7919 "unexpected sort of implicit constructor");
7920 return oc_implicit_copy_constructor;
7923 if (CXXMethodDecl *Meth = dyn_cast<CXXMethodDecl>(Fn)) {
7924 // This actually gets spelled 'candidate function' for now, but
7925 // it doesn't hurt to split it out.
7926 if (!Meth->isImplicit())
7927 return isTemplate ? oc_method_template : oc_method;
7929 if (Meth->isMoveAssignmentOperator())
7930 return oc_implicit_move_assignment;
7932 if (Meth->isCopyAssignmentOperator())
7933 return oc_implicit_copy_assignment;
7935 assert(isa<CXXConversionDecl>(Meth) && "expected conversion");
7939 return isTemplate ? oc_function_template : oc_function;
7942 void MaybeEmitInheritedConstructorNote(Sema &S, FunctionDecl *Fn) {
7943 const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(Fn);
7946 Ctor = Ctor->getInheritedConstructor();
7949 S.Diag(Ctor->getLocation(), diag::note_ovl_candidate_inherited_constructor);
7952 } // end anonymous namespace
7954 // Notes the location of an overload candidate.
7955 void Sema::NoteOverloadCandidate(FunctionDecl *Fn, QualType DestType) {
7957 OverloadCandidateKind K = ClassifyOverloadCandidate(*this, Fn, FnDesc);
7958 PartialDiagnostic PD = PDiag(diag::note_ovl_candidate)
7959 << (unsigned) K << FnDesc;
7960 HandleFunctionTypeMismatch(PD, Fn->getType(), DestType);
7961 Diag(Fn->getLocation(), PD);
7962 MaybeEmitInheritedConstructorNote(*this, Fn);
7965 //Notes the location of all overload candidates designated through
7967 void Sema::NoteAllOverloadCandidates(Expr* OverloadedExpr, QualType DestType) {
7968 assert(OverloadedExpr->getType() == Context.OverloadTy);
7970 OverloadExpr::FindResult Ovl = OverloadExpr::find(OverloadedExpr);
7971 OverloadExpr *OvlExpr = Ovl.Expression;
7973 for (UnresolvedSetIterator I = OvlExpr->decls_begin(),
7974 IEnd = OvlExpr->decls_end();
7976 if (FunctionTemplateDecl *FunTmpl =
7977 dyn_cast<FunctionTemplateDecl>((*I)->getUnderlyingDecl()) ) {
7978 NoteOverloadCandidate(FunTmpl->getTemplatedDecl(), DestType);
7979 } else if (FunctionDecl *Fun
7980 = dyn_cast<FunctionDecl>((*I)->getUnderlyingDecl()) ) {
7981 NoteOverloadCandidate(Fun, DestType);
7986 /// Diagnoses an ambiguous conversion. The partial diagnostic is the
7987 /// "lead" diagnostic; it will be given two arguments, the source and
7988 /// target types of the conversion.
7989 void ImplicitConversionSequence::DiagnoseAmbiguousConversion(
7991 SourceLocation CaretLoc,
7992 const PartialDiagnostic &PDiag) const {
7993 S.Diag(CaretLoc, PDiag)
7994 << Ambiguous.getFromType() << Ambiguous.getToType();
7995 // FIXME: The note limiting machinery is borrowed from
7996 // OverloadCandidateSet::NoteCandidates; there's an opportunity for
7997 // refactoring here.
7998 const OverloadsShown ShowOverloads = S.Diags.getShowOverloads();
7999 unsigned CandsShown = 0;
8000 AmbiguousConversionSequence::const_iterator I, E;
8001 for (I = Ambiguous.begin(), E = Ambiguous.end(); I != E; ++I) {
8002 if (CandsShown >= 4 && ShowOverloads == Ovl_Best)
8005 S.NoteOverloadCandidate(*I);
8008 S.Diag(SourceLocation(), diag::note_ovl_too_many_candidates) << int(E - I);
8013 void DiagnoseBadConversion(Sema &S, OverloadCandidate *Cand, unsigned I) {
8014 const ImplicitConversionSequence &Conv = Cand->Conversions[I];
8015 assert(Conv.isBad());
8016 assert(Cand->Function && "for now, candidate must be a function");
8017 FunctionDecl *Fn = Cand->Function;
8019 // There's a conversion slot for the object argument if this is a
8020 // non-constructor method. Note that 'I' corresponds the
8021 // conversion-slot index.
8022 bool isObjectArgument = false;
8023 if (isa<CXXMethodDecl>(Fn) && !isa<CXXConstructorDecl>(Fn)) {
8025 isObjectArgument = true;
8031 OverloadCandidateKind FnKind = ClassifyOverloadCandidate(S, Fn, FnDesc);
8033 Expr *FromExpr = Conv.Bad.FromExpr;
8034 QualType FromTy = Conv.Bad.getFromType();
8035 QualType ToTy = Conv.Bad.getToType();
8037 if (FromTy == S.Context.OverloadTy) {
8038 assert(FromExpr && "overload set argument came from implicit argument?");
8039 Expr *E = FromExpr->IgnoreParens();
8040 if (isa<UnaryOperator>(E))
8041 E = cast<UnaryOperator>(E)->getSubExpr()->IgnoreParens();
8042 DeclarationName Name = cast<OverloadExpr>(E)->getName();
8044 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_overload)
8045 << (unsigned) FnKind << FnDesc
8046 << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
8047 << ToTy << Name << I+1;
8048 MaybeEmitInheritedConstructorNote(S, Fn);
8052 // Do some hand-waving analysis to see if the non-viability is due
8053 // to a qualifier mismatch.
8054 CanQualType CFromTy = S.Context.getCanonicalType(FromTy);
8055 CanQualType CToTy = S.Context.getCanonicalType(ToTy);
8056 if (CanQual<ReferenceType> RT = CToTy->getAs<ReferenceType>())
8057 CToTy = RT->getPointeeType();
8059 // TODO: detect and diagnose the full richness of const mismatches.
8060 if (CanQual<PointerType> FromPT = CFromTy->getAs<PointerType>())
8061 if (CanQual<PointerType> ToPT = CToTy->getAs<PointerType>())
8062 CFromTy = FromPT->getPointeeType(), CToTy = ToPT->getPointeeType();
8065 if (CToTy.getUnqualifiedType() == CFromTy.getUnqualifiedType() &&
8066 !CToTy.isAtLeastAsQualifiedAs(CFromTy)) {
8067 Qualifiers FromQs = CFromTy.getQualifiers();
8068 Qualifiers ToQs = CToTy.getQualifiers();
8070 if (FromQs.getAddressSpace() != ToQs.getAddressSpace()) {
8071 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_addrspace)
8072 << (unsigned) FnKind << FnDesc
8073 << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
8075 << FromQs.getAddressSpace() << ToQs.getAddressSpace()
8076 << (unsigned) isObjectArgument << I+1;
8077 MaybeEmitInheritedConstructorNote(S, Fn);
8081 if (FromQs.getObjCLifetime() != ToQs.getObjCLifetime()) {
8082 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_ownership)
8083 << (unsigned) FnKind << FnDesc
8084 << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
8086 << FromQs.getObjCLifetime() << ToQs.getObjCLifetime()
8087 << (unsigned) isObjectArgument << I+1;
8088 MaybeEmitInheritedConstructorNote(S, Fn);
8092 if (FromQs.getObjCGCAttr() != ToQs.getObjCGCAttr()) {
8093 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_gc)
8094 << (unsigned) FnKind << FnDesc
8095 << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
8097 << FromQs.getObjCGCAttr() << ToQs.getObjCGCAttr()
8098 << (unsigned) isObjectArgument << I+1;
8099 MaybeEmitInheritedConstructorNote(S, Fn);
8103 unsigned CVR = FromQs.getCVRQualifiers() & ~ToQs.getCVRQualifiers();
8104 assert(CVR && "unexpected qualifiers mismatch");
8106 if (isObjectArgument) {
8107 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_cvr_this)
8108 << (unsigned) FnKind << FnDesc
8109 << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
8110 << FromTy << (CVR - 1);
8112 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_cvr)
8113 << (unsigned) FnKind << FnDesc
8114 << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
8115 << FromTy << (CVR - 1) << I+1;
8117 MaybeEmitInheritedConstructorNote(S, Fn);
8121 // Special diagnostic for failure to convert an initializer list, since
8122 // telling the user that it has type void is not useful.
8123 if (FromExpr && isa<InitListExpr>(FromExpr)) {
8124 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_list_argument)
8125 << (unsigned) FnKind << FnDesc
8126 << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
8127 << FromTy << ToTy << (unsigned) isObjectArgument << I+1;
8128 MaybeEmitInheritedConstructorNote(S, Fn);
8132 // Diagnose references or pointers to incomplete types differently,
8133 // since it's far from impossible that the incompleteness triggered
8135 QualType TempFromTy = FromTy.getNonReferenceType();
8136 if (const PointerType *PTy = TempFromTy->getAs<PointerType>())
8137 TempFromTy = PTy->getPointeeType();
8138 if (TempFromTy->isIncompleteType()) {
8139 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_conv_incomplete)
8140 << (unsigned) FnKind << FnDesc
8141 << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
8142 << FromTy << ToTy << (unsigned) isObjectArgument << I+1;
8143 MaybeEmitInheritedConstructorNote(S, Fn);
8147 // Diagnose base -> derived pointer conversions.
8148 unsigned BaseToDerivedConversion = 0;
8149 if (const PointerType *FromPtrTy = FromTy->getAs<PointerType>()) {
8150 if (const PointerType *ToPtrTy = ToTy->getAs<PointerType>()) {
8151 if (ToPtrTy->getPointeeType().isAtLeastAsQualifiedAs(
8152 FromPtrTy->getPointeeType()) &&
8153 !FromPtrTy->getPointeeType()->isIncompleteType() &&
8154 !ToPtrTy->getPointeeType()->isIncompleteType() &&
8155 S.IsDerivedFrom(ToPtrTy->getPointeeType(),
8156 FromPtrTy->getPointeeType()))
8157 BaseToDerivedConversion = 1;
8159 } else if (const ObjCObjectPointerType *FromPtrTy
8160 = FromTy->getAs<ObjCObjectPointerType>()) {
8161 if (const ObjCObjectPointerType *ToPtrTy
8162 = ToTy->getAs<ObjCObjectPointerType>())
8163 if (const ObjCInterfaceDecl *FromIface = FromPtrTy->getInterfaceDecl())
8164 if (const ObjCInterfaceDecl *ToIface = ToPtrTy->getInterfaceDecl())
8165 if (ToPtrTy->getPointeeType().isAtLeastAsQualifiedAs(
8166 FromPtrTy->getPointeeType()) &&
8167 FromIface->isSuperClassOf(ToIface))
8168 BaseToDerivedConversion = 2;
8169 } else if (const ReferenceType *ToRefTy = ToTy->getAs<ReferenceType>()) {
8170 if (ToRefTy->getPointeeType().isAtLeastAsQualifiedAs(FromTy) &&
8171 !FromTy->isIncompleteType() &&
8172 !ToRefTy->getPointeeType()->isIncompleteType() &&
8173 S.IsDerivedFrom(ToRefTy->getPointeeType(), FromTy)) {
8174 BaseToDerivedConversion = 3;
8175 } else if (ToTy->isLValueReferenceType() && !FromExpr->isLValue() &&
8176 ToTy.getNonReferenceType().getCanonicalType() ==
8177 FromTy.getNonReferenceType().getCanonicalType()) {
8178 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_lvalue)
8179 << (unsigned) FnKind << FnDesc
8180 << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
8181 << (unsigned) isObjectArgument << I + 1;
8182 MaybeEmitInheritedConstructorNote(S, Fn);
8187 if (BaseToDerivedConversion) {
8188 S.Diag(Fn->getLocation(),
8189 diag::note_ovl_candidate_bad_base_to_derived_conv)
8190 << (unsigned) FnKind << FnDesc
8191 << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
8192 << (BaseToDerivedConversion - 1)
8193 << FromTy << ToTy << I+1;
8194 MaybeEmitInheritedConstructorNote(S, Fn);
8198 if (isa<ObjCObjectPointerType>(CFromTy) &&
8199 isa<PointerType>(CToTy)) {
8200 Qualifiers FromQs = CFromTy.getQualifiers();
8201 Qualifiers ToQs = CToTy.getQualifiers();
8202 if (FromQs.getObjCLifetime() != ToQs.getObjCLifetime()) {
8203 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_arc_conv)
8204 << (unsigned) FnKind << FnDesc
8205 << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
8206 << FromTy << ToTy << (unsigned) isObjectArgument << I+1;
8207 MaybeEmitInheritedConstructorNote(S, Fn);
8212 // Emit the generic diagnostic and, optionally, add the hints to it.
8213 PartialDiagnostic FDiag = S.PDiag(diag::note_ovl_candidate_bad_conv);
8214 FDiag << (unsigned) FnKind << FnDesc
8215 << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
8216 << FromTy << ToTy << (unsigned) isObjectArgument << I + 1
8217 << (unsigned) (Cand->Fix.Kind);
8219 // If we can fix the conversion, suggest the FixIts.
8220 for (std::vector<FixItHint>::iterator HI = Cand->Fix.Hints.begin(),
8221 HE = Cand->Fix.Hints.end(); HI != HE; ++HI)
8223 S.Diag(Fn->getLocation(), FDiag);
8225 MaybeEmitInheritedConstructorNote(S, Fn);
8228 void DiagnoseArityMismatch(Sema &S, OverloadCandidate *Cand,
8229 unsigned NumFormalArgs) {
8230 // TODO: treat calls to a missing default constructor as a special case
8232 FunctionDecl *Fn = Cand->Function;
8233 const FunctionProtoType *FnTy = Fn->getType()->getAs<FunctionProtoType>();
8235 unsigned MinParams = Fn->getMinRequiredArguments();
8237 // With invalid overloaded operators, it's possible that we think we
8238 // have an arity mismatch when it fact it looks like we have the
8239 // right number of arguments, because only overloaded operators have
8240 // the weird behavior of overloading member and non-member functions.
8241 // Just don't report anything.
8242 if (Fn->isInvalidDecl() &&
8243 Fn->getDeclName().getNameKind() == DeclarationName::CXXOperatorName)
8246 // at least / at most / exactly
8247 unsigned mode, modeCount;
8248 if (NumFormalArgs < MinParams) {
8249 assert((Cand->FailureKind == ovl_fail_too_few_arguments) ||
8250 (Cand->FailureKind == ovl_fail_bad_deduction &&
8251 Cand->DeductionFailure.Result == Sema::TDK_TooFewArguments));
8252 if (MinParams != FnTy->getNumArgs() ||
8253 FnTy->isVariadic() || FnTy->isTemplateVariadic())
8254 mode = 0; // "at least"
8256 mode = 2; // "exactly"
8257 modeCount = MinParams;
8259 assert((Cand->FailureKind == ovl_fail_too_many_arguments) ||
8260 (Cand->FailureKind == ovl_fail_bad_deduction &&
8261 Cand->DeductionFailure.Result == Sema::TDK_TooManyArguments));
8262 if (MinParams != FnTy->getNumArgs())
8263 mode = 1; // "at most"
8265 mode = 2; // "exactly"
8266 modeCount = FnTy->getNumArgs();
8269 std::string Description;
8270 OverloadCandidateKind FnKind = ClassifyOverloadCandidate(S, Fn, Description);
8272 if (modeCount == 1 && Fn->getParamDecl(0)->getDeclName())
8273 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_arity_one)
8274 << (unsigned) FnKind << (Fn->getDescribedFunctionTemplate() != 0) << mode
8275 << Fn->getParamDecl(0) << NumFormalArgs;
8277 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_arity)
8278 << (unsigned) FnKind << (Fn->getDescribedFunctionTemplate() != 0) << mode
8279 << modeCount << NumFormalArgs;
8280 MaybeEmitInheritedConstructorNote(S, Fn);
8283 /// Diagnose a failed template-argument deduction.
8284 void DiagnoseBadDeduction(Sema &S, OverloadCandidate *Cand,
8286 FunctionDecl *Fn = Cand->Function; // pattern
8288 TemplateParameter Param = Cand->DeductionFailure.getTemplateParameter();
8290 (ParamD = Param.dyn_cast<TemplateTypeParmDecl*>()) ||
8291 (ParamD = Param.dyn_cast<NonTypeTemplateParmDecl*>()) ||
8292 (ParamD = Param.dyn_cast<TemplateTemplateParmDecl*>());
8293 switch (Cand->DeductionFailure.Result) {
8294 case Sema::TDK_Success:
8295 llvm_unreachable("TDK_success while diagnosing bad deduction");
8297 case Sema::TDK_Incomplete: {
8298 assert(ParamD && "no parameter found for incomplete deduction result");
8299 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_incomplete_deduction)
8300 << ParamD->getDeclName();
8301 MaybeEmitInheritedConstructorNote(S, Fn);
8305 case Sema::TDK_Underqualified: {
8306 assert(ParamD && "no parameter found for bad qualifiers deduction result");
8307 TemplateTypeParmDecl *TParam = cast<TemplateTypeParmDecl>(ParamD);
8309 QualType Param = Cand->DeductionFailure.getFirstArg()->getAsType();
8311 // Param will have been canonicalized, but it should just be a
8312 // qualified version of ParamD, so move the qualifiers to that.
8313 QualifierCollector Qs;
8315 QualType NonCanonParam = Qs.apply(S.Context, TParam->getTypeForDecl());
8316 assert(S.Context.hasSameType(Param, NonCanonParam));
8318 // Arg has also been canonicalized, but there's nothing we can do
8319 // about that. It also doesn't matter as much, because it won't
8320 // have any template parameters in it (because deduction isn't
8321 // done on dependent types).
8322 QualType Arg = Cand->DeductionFailure.getSecondArg()->getAsType();
8324 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_underqualified)
8325 << ParamD->getDeclName() << Arg << NonCanonParam;
8326 MaybeEmitInheritedConstructorNote(S, Fn);
8330 case Sema::TDK_Inconsistent: {
8331 assert(ParamD && "no parameter found for inconsistent deduction result");
8333 if (isa<TemplateTypeParmDecl>(ParamD))
8335 else if (isa<NonTypeTemplateParmDecl>(ParamD))
8341 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_inconsistent_deduction)
8342 << which << ParamD->getDeclName()
8343 << *Cand->DeductionFailure.getFirstArg()
8344 << *Cand->DeductionFailure.getSecondArg();
8345 MaybeEmitInheritedConstructorNote(S, Fn);
8349 case Sema::TDK_InvalidExplicitArguments:
8350 assert(ParamD && "no parameter found for invalid explicit arguments");
8351 if (ParamD->getDeclName())
8352 S.Diag(Fn->getLocation(),
8353 diag::note_ovl_candidate_explicit_arg_mismatch_named)
8354 << ParamD->getDeclName();
8357 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ParamD))
8358 index = TTP->getIndex();
8359 else if (NonTypeTemplateParmDecl *NTTP
8360 = dyn_cast<NonTypeTemplateParmDecl>(ParamD))
8361 index = NTTP->getIndex();
8363 index = cast<TemplateTemplateParmDecl>(ParamD)->getIndex();
8364 S.Diag(Fn->getLocation(),
8365 diag::note_ovl_candidate_explicit_arg_mismatch_unnamed)
8368 MaybeEmitInheritedConstructorNote(S, Fn);
8371 case Sema::TDK_TooManyArguments:
8372 case Sema::TDK_TooFewArguments:
8373 DiagnoseArityMismatch(S, Cand, NumArgs);
8376 case Sema::TDK_InstantiationDepth:
8377 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_instantiation_depth);
8378 MaybeEmitInheritedConstructorNote(S, Fn);
8381 case Sema::TDK_SubstitutionFailure: {
8382 // Format the template argument list into the argument string.
8383 llvm::SmallString<128> TemplateArgString;
8384 if (TemplateArgumentList *Args =
8385 Cand->DeductionFailure.getTemplateArgumentList()) {
8386 TemplateArgString = " ";
8387 TemplateArgString += S.getTemplateArgumentBindingsText(
8388 Fn->getDescribedFunctionTemplate()->getTemplateParameters(), *Args);
8391 // If this candidate was disabled by enable_if, say so.
8392 PartialDiagnosticAt *PDiag = Cand->DeductionFailure.getSFINAEDiagnostic();
8393 if (PDiag && PDiag->second.getDiagID() ==
8394 diag::err_typename_nested_not_found_enable_if) {
8395 // FIXME: Use the source range of the condition, and the fully-qualified
8396 // name of the enable_if template. These are both present in PDiag.
8397 S.Diag(PDiag->first, diag::note_ovl_candidate_disabled_by_enable_if)
8398 << "'enable_if'" << TemplateArgString;
8402 // Format the SFINAE diagnostic into the argument string.
8403 // FIXME: Add a general mechanism to include a PartialDiagnostic *'s
8404 // formatted message in another diagnostic.
8405 llvm::SmallString<128> SFINAEArgString;
8408 SFINAEArgString = ": ";
8409 R = SourceRange(PDiag->first, PDiag->first);
8410 PDiag->second.EmitToString(S.getDiagnostics(), SFINAEArgString);
8413 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_substitution_failure)
8414 << TemplateArgString << SFINAEArgString << R;
8415 MaybeEmitInheritedConstructorNote(S, Fn);
8419 // TODO: diagnose these individually, then kill off
8420 // note_ovl_candidate_bad_deduction, which is uselessly vague.
8421 case Sema::TDK_NonDeducedMismatch:
8422 case Sema::TDK_FailedOverloadResolution:
8423 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_deduction);
8424 MaybeEmitInheritedConstructorNote(S, Fn);
8429 /// CUDA: diagnose an invalid call across targets.
8430 void DiagnoseBadTarget(Sema &S, OverloadCandidate *Cand) {
8431 FunctionDecl *Caller = cast<FunctionDecl>(S.CurContext);
8432 FunctionDecl *Callee = Cand->Function;
8434 Sema::CUDAFunctionTarget CallerTarget = S.IdentifyCUDATarget(Caller),
8435 CalleeTarget = S.IdentifyCUDATarget(Callee);
8438 OverloadCandidateKind FnKind = ClassifyOverloadCandidate(S, Callee, FnDesc);
8440 S.Diag(Callee->getLocation(), diag::note_ovl_candidate_bad_target)
8441 << (unsigned) FnKind << CalleeTarget << CallerTarget;
8444 /// Generates a 'note' diagnostic for an overload candidate. We've
8445 /// already generated a primary error at the call site.
8447 /// It really does need to be a single diagnostic with its caret
8448 /// pointed at the candidate declaration. Yes, this creates some
8449 /// major challenges of technical writing. Yes, this makes pointing
8450 /// out problems with specific arguments quite awkward. It's still
8451 /// better than generating twenty screens of text for every failed
8454 /// It would be great to be able to express per-candidate problems
8455 /// more richly for those diagnostic clients that cared, but we'd
8456 /// still have to be just as careful with the default diagnostics.
8457 void NoteFunctionCandidate(Sema &S, OverloadCandidate *Cand,
8459 FunctionDecl *Fn = Cand->Function;
8461 // Note deleted candidates, but only if they're viable.
8462 if (Cand->Viable && (Fn->isDeleted() ||
8463 S.isFunctionConsideredUnavailable(Fn))) {
8465 OverloadCandidateKind FnKind = ClassifyOverloadCandidate(S, Fn, FnDesc);
8467 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_deleted)
8469 << (Fn->isDeleted() ? (Fn->isDeletedAsWritten() ? 1 : 2) : 0);
8470 MaybeEmitInheritedConstructorNote(S, Fn);
8474 // We don't really have anything else to say about viable candidates.
8476 S.NoteOverloadCandidate(Fn);
8480 switch (Cand->FailureKind) {
8481 case ovl_fail_too_many_arguments:
8482 case ovl_fail_too_few_arguments:
8483 return DiagnoseArityMismatch(S, Cand, NumArgs);
8485 case ovl_fail_bad_deduction:
8486 return DiagnoseBadDeduction(S, Cand, NumArgs);
8488 case ovl_fail_trivial_conversion:
8489 case ovl_fail_bad_final_conversion:
8490 case ovl_fail_final_conversion_not_exact:
8491 return S.NoteOverloadCandidate(Fn);
8493 case ovl_fail_bad_conversion: {
8494 unsigned I = (Cand->IgnoreObjectArgument ? 1 : 0);
8495 for (unsigned N = Cand->NumConversions; I != N; ++I)
8496 if (Cand->Conversions[I].isBad())
8497 return DiagnoseBadConversion(S, Cand, I);
8499 // FIXME: this currently happens when we're called from SemaInit
8500 // when user-conversion overload fails. Figure out how to handle
8501 // those conditions and diagnose them well.
8502 return S.NoteOverloadCandidate(Fn);
8505 case ovl_fail_bad_target:
8506 return DiagnoseBadTarget(S, Cand);
8510 void NoteSurrogateCandidate(Sema &S, OverloadCandidate *Cand) {
8511 // Desugar the type of the surrogate down to a function type,
8512 // retaining as many typedefs as possible while still showing
8513 // the function type (and, therefore, its parameter types).
8514 QualType FnType = Cand->Surrogate->getConversionType();
8515 bool isLValueReference = false;
8516 bool isRValueReference = false;
8517 bool isPointer = false;
8518 if (const LValueReferenceType *FnTypeRef =
8519 FnType->getAs<LValueReferenceType>()) {
8520 FnType = FnTypeRef->getPointeeType();
8521 isLValueReference = true;
8522 } else if (const RValueReferenceType *FnTypeRef =
8523 FnType->getAs<RValueReferenceType>()) {
8524 FnType = FnTypeRef->getPointeeType();
8525 isRValueReference = true;
8527 if (const PointerType *FnTypePtr = FnType->getAs<PointerType>()) {
8528 FnType = FnTypePtr->getPointeeType();
8531 // Desugar down to a function type.
8532 FnType = QualType(FnType->getAs<FunctionType>(), 0);
8533 // Reconstruct the pointer/reference as appropriate.
8534 if (isPointer) FnType = S.Context.getPointerType(FnType);
8535 if (isRValueReference) FnType = S.Context.getRValueReferenceType(FnType);
8536 if (isLValueReference) FnType = S.Context.getLValueReferenceType(FnType);
8538 S.Diag(Cand->Surrogate->getLocation(), diag::note_ovl_surrogate_cand)
8540 MaybeEmitInheritedConstructorNote(S, Cand->Surrogate);
8543 void NoteBuiltinOperatorCandidate(Sema &S,
8545 SourceLocation OpLoc,
8546 OverloadCandidate *Cand) {
8547 assert(Cand->NumConversions <= 2 && "builtin operator is not binary");
8548 std::string TypeStr("operator");
8551 TypeStr += Cand->BuiltinTypes.ParamTypes[0].getAsString();
8552 if (Cand->NumConversions == 1) {
8554 S.Diag(OpLoc, diag::note_ovl_builtin_unary_candidate) << TypeStr;
8557 TypeStr += Cand->BuiltinTypes.ParamTypes[1].getAsString();
8559 S.Diag(OpLoc, diag::note_ovl_builtin_binary_candidate) << TypeStr;
8563 void NoteAmbiguousUserConversions(Sema &S, SourceLocation OpLoc,
8564 OverloadCandidate *Cand) {
8565 unsigned NoOperands = Cand->NumConversions;
8566 for (unsigned ArgIdx = 0; ArgIdx < NoOperands; ++ArgIdx) {
8567 const ImplicitConversionSequence &ICS = Cand->Conversions[ArgIdx];
8568 if (ICS.isBad()) break; // all meaningless after first invalid
8569 if (!ICS.isAmbiguous()) continue;
8571 ICS.DiagnoseAmbiguousConversion(S, OpLoc,
8572 S.PDiag(diag::note_ambiguous_type_conversion));
8576 SourceLocation GetLocationForCandidate(const OverloadCandidate *Cand) {
8578 return Cand->Function->getLocation();
8579 if (Cand->IsSurrogate)
8580 return Cand->Surrogate->getLocation();
8581 return SourceLocation();
8585 RankDeductionFailure(const OverloadCandidate::DeductionFailureInfo &DFI) {
8586 switch ((Sema::TemplateDeductionResult)DFI.Result) {
8587 case Sema::TDK_Success:
8588 llvm_unreachable("TDK_success while diagnosing bad deduction");
8590 case Sema::TDK_Invalid:
8591 case Sema::TDK_Incomplete:
8594 case Sema::TDK_Underqualified:
8595 case Sema::TDK_Inconsistent:
8598 case Sema::TDK_SubstitutionFailure:
8599 case Sema::TDK_NonDeducedMismatch:
8602 case Sema::TDK_InstantiationDepth:
8603 case Sema::TDK_FailedOverloadResolution:
8606 case Sema::TDK_InvalidExplicitArguments:
8609 case Sema::TDK_TooManyArguments:
8610 case Sema::TDK_TooFewArguments:
8613 llvm_unreachable("Unhandled deduction result");
8616 struct CompareOverloadCandidatesForDisplay {
8618 CompareOverloadCandidatesForDisplay(Sema &S) : S(S) {}
8620 bool operator()(const OverloadCandidate *L,
8621 const OverloadCandidate *R) {
8622 // Fast-path this check.
8623 if (L == R) return false;
8625 // Order first by viability.
8627 if (!R->Viable) return true;
8629 // TODO: introduce a tri-valued comparison for overload
8630 // candidates. Would be more worthwhile if we had a sort
8631 // that could exploit it.
8632 if (isBetterOverloadCandidate(S, *L, *R, SourceLocation())) return true;
8633 if (isBetterOverloadCandidate(S, *R, *L, SourceLocation())) return false;
8634 } else if (R->Viable)
8637 assert(L->Viable == R->Viable);
8639 // Criteria by which we can sort non-viable candidates:
8641 // 1. Arity mismatches come after other candidates.
8642 if (L->FailureKind == ovl_fail_too_many_arguments ||
8643 L->FailureKind == ovl_fail_too_few_arguments)
8645 if (R->FailureKind == ovl_fail_too_many_arguments ||
8646 R->FailureKind == ovl_fail_too_few_arguments)
8649 // 2. Bad conversions come first and are ordered by the number
8650 // of bad conversions and quality of good conversions.
8651 if (L->FailureKind == ovl_fail_bad_conversion) {
8652 if (R->FailureKind != ovl_fail_bad_conversion)
8655 // The conversion that can be fixed with a smaller number of changes,
8657 unsigned numLFixes = L->Fix.NumConversionsFixed;
8658 unsigned numRFixes = R->Fix.NumConversionsFixed;
8659 numLFixes = (numLFixes == 0) ? UINT_MAX : numLFixes;
8660 numRFixes = (numRFixes == 0) ? UINT_MAX : numRFixes;
8661 if (numLFixes != numRFixes) {
8662 if (numLFixes < numRFixes)
8668 // If there's any ordering between the defined conversions...
8669 // FIXME: this might not be transitive.
8670 assert(L->NumConversions == R->NumConversions);
8673 unsigned I = (L->IgnoreObjectArgument || R->IgnoreObjectArgument);
8674 for (unsigned E = L->NumConversions; I != E; ++I) {
8675 switch (CompareImplicitConversionSequences(S,
8677 R->Conversions[I])) {
8678 case ImplicitConversionSequence::Better:
8682 case ImplicitConversionSequence::Worse:
8686 case ImplicitConversionSequence::Indistinguishable:
8690 if (leftBetter > 0) return true;
8691 if (leftBetter < 0) return false;
8693 } else if (R->FailureKind == ovl_fail_bad_conversion)
8696 if (L->FailureKind == ovl_fail_bad_deduction) {
8697 if (R->FailureKind != ovl_fail_bad_deduction)
8700 if (L->DeductionFailure.Result != R->DeductionFailure.Result)
8701 return RankDeductionFailure(L->DeductionFailure)
8702 < RankDeductionFailure(R->DeductionFailure);
8703 } else if (R->FailureKind == ovl_fail_bad_deduction)
8709 // Sort everything else by location.
8710 SourceLocation LLoc = GetLocationForCandidate(L);
8711 SourceLocation RLoc = GetLocationForCandidate(R);
8713 // Put candidates without locations (e.g. builtins) at the end.
8714 if (LLoc.isInvalid()) return false;
8715 if (RLoc.isInvalid()) return true;
8717 return S.SourceMgr.isBeforeInTranslationUnit(LLoc, RLoc);
8721 /// CompleteNonViableCandidate - Normally, overload resolution only
8722 /// computes up to the first. Produces the FixIt set if possible.
8723 void CompleteNonViableCandidate(Sema &S, OverloadCandidate *Cand,
8724 llvm::ArrayRef<Expr *> Args) {
8725 assert(!Cand->Viable);
8727 // Don't do anything on failures other than bad conversion.
8728 if (Cand->FailureKind != ovl_fail_bad_conversion) return;
8730 // We only want the FixIts if all the arguments can be corrected.
8731 bool Unfixable = false;
8732 // Use a implicit copy initialization to check conversion fixes.
8733 Cand->Fix.setConversionChecker(TryCopyInitialization);
8735 // Skip forward to the first bad conversion.
8736 unsigned ConvIdx = (Cand->IgnoreObjectArgument ? 1 : 0);
8737 unsigned ConvCount = Cand->NumConversions;
8739 assert(ConvIdx != ConvCount && "no bad conversion in candidate");
8741 if (Cand->Conversions[ConvIdx - 1].isBad()) {
8742 Unfixable = !Cand->TryToFixBadConversion(ConvIdx - 1, S);
8747 if (ConvIdx == ConvCount)
8750 assert(!Cand->Conversions[ConvIdx].isInitialized() &&
8751 "remaining conversion is initialized?");
8753 // FIXME: this should probably be preserved from the overload
8754 // operation somehow.
8755 bool SuppressUserConversions = false;
8757 const FunctionProtoType* Proto;
8758 unsigned ArgIdx = ConvIdx;
8760 if (Cand->IsSurrogate) {
8762 = Cand->Surrogate->getConversionType().getNonReferenceType();
8763 if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>())
8764 ConvType = ConvPtrType->getPointeeType();
8765 Proto = ConvType->getAs<FunctionProtoType>();
8767 } else if (Cand->Function) {
8768 Proto = Cand->Function->getType()->getAs<FunctionProtoType>();
8769 if (isa<CXXMethodDecl>(Cand->Function) &&
8770 !isa<CXXConstructorDecl>(Cand->Function))
8773 // Builtin binary operator with a bad first conversion.
8774 assert(ConvCount <= 3);
8775 for (; ConvIdx != ConvCount; ++ConvIdx)
8776 Cand->Conversions[ConvIdx]
8777 = TryCopyInitialization(S, Args[ConvIdx],
8778 Cand->BuiltinTypes.ParamTypes[ConvIdx],
8779 SuppressUserConversions,
8780 /*InOverloadResolution*/ true,
8781 /*AllowObjCWritebackConversion=*/
8782 S.getLangOpts().ObjCAutoRefCount);
8786 // Fill in the rest of the conversions.
8787 unsigned NumArgsInProto = Proto->getNumArgs();
8788 for (; ConvIdx != ConvCount; ++ConvIdx, ++ArgIdx) {
8789 if (ArgIdx < NumArgsInProto) {
8790 Cand->Conversions[ConvIdx]
8791 = TryCopyInitialization(S, Args[ArgIdx], Proto->getArgType(ArgIdx),
8792 SuppressUserConversions,
8793 /*InOverloadResolution=*/true,
8794 /*AllowObjCWritebackConversion=*/
8795 S.getLangOpts().ObjCAutoRefCount);
8796 // Store the FixIt in the candidate if it exists.
8797 if (!Unfixable && Cand->Conversions[ConvIdx].isBad())
8798 Unfixable = !Cand->TryToFixBadConversion(ConvIdx, S);
8801 Cand->Conversions[ConvIdx].setEllipsis();
8805 } // end anonymous namespace
8807 /// PrintOverloadCandidates - When overload resolution fails, prints
8808 /// diagnostic messages containing the candidates in the candidate
8810 void OverloadCandidateSet::NoteCandidates(Sema &S,
8811 OverloadCandidateDisplayKind OCD,
8812 llvm::ArrayRef<Expr *> Args,
8814 SourceLocation OpLoc) {
8815 // Sort the candidates by viability and position. Sorting directly would
8816 // be prohibitive, so we make a set of pointers and sort those.
8817 SmallVector<OverloadCandidate*, 32> Cands;
8818 if (OCD == OCD_AllCandidates) Cands.reserve(size());
8819 for (iterator Cand = begin(), LastCand = end(); Cand != LastCand; ++Cand) {
8821 Cands.push_back(Cand);
8822 else if (OCD == OCD_AllCandidates) {
8823 CompleteNonViableCandidate(S, Cand, Args);
8824 if (Cand->Function || Cand->IsSurrogate)
8825 Cands.push_back(Cand);
8826 // Otherwise, this a non-viable builtin candidate. We do not, in general,
8827 // want to list every possible builtin candidate.
8831 std::sort(Cands.begin(), Cands.end(),
8832 CompareOverloadCandidatesForDisplay(S));
8834 bool ReportedAmbiguousConversions = false;
8836 SmallVectorImpl<OverloadCandidate*>::iterator I, E;
8837 const OverloadsShown ShowOverloads = S.Diags.getShowOverloads();
8838 unsigned CandsShown = 0;
8839 for (I = Cands.begin(), E = Cands.end(); I != E; ++I) {
8840 OverloadCandidate *Cand = *I;
8842 // Set an arbitrary limit on the number of candidate functions we'll spam
8843 // the user with. FIXME: This limit should depend on details of the
8845 if (CandsShown >= 4 && ShowOverloads == Ovl_Best) {
8851 NoteFunctionCandidate(S, Cand, Args.size());
8852 else if (Cand->IsSurrogate)
8853 NoteSurrogateCandidate(S, Cand);
8855 assert(Cand->Viable &&
8856 "Non-viable built-in candidates are not added to Cands.");
8857 // Generally we only see ambiguities including viable builtin
8858 // operators if overload resolution got screwed up by an
8859 // ambiguous user-defined conversion.
8861 // FIXME: It's quite possible for different conversions to see
8862 // different ambiguities, though.
8863 if (!ReportedAmbiguousConversions) {
8864 NoteAmbiguousUserConversions(S, OpLoc, Cand);
8865 ReportedAmbiguousConversions = true;
8868 // If this is a viable builtin, print it.
8869 NoteBuiltinOperatorCandidate(S, Opc, OpLoc, Cand);
8874 S.Diag(OpLoc, diag::note_ovl_too_many_candidates) << int(E - I);
8877 // [PossiblyAFunctionType] --> [Return]
8878 // NonFunctionType --> NonFunctionType
8880 // R (*)(A) --> R (A)
8881 // R (&)(A) --> R (A)
8882 // R (S::*)(A) --> R (A)
8883 QualType Sema::ExtractUnqualifiedFunctionType(QualType PossiblyAFunctionType) {
8884 QualType Ret = PossiblyAFunctionType;
8885 if (const PointerType *ToTypePtr =
8886 PossiblyAFunctionType->getAs<PointerType>())
8887 Ret = ToTypePtr->getPointeeType();
8888 else if (const ReferenceType *ToTypeRef =
8889 PossiblyAFunctionType->getAs<ReferenceType>())
8890 Ret = ToTypeRef->getPointeeType();
8891 else if (const MemberPointerType *MemTypePtr =
8892 PossiblyAFunctionType->getAs<MemberPointerType>())
8893 Ret = MemTypePtr->getPointeeType();
8895 Context.getCanonicalType(Ret).getUnqualifiedType();
8899 // A helper class to help with address of function resolution
8900 // - allows us to avoid passing around all those ugly parameters
8901 class AddressOfFunctionResolver
8905 const QualType& TargetType;
8906 QualType TargetFunctionType; // Extracted function type from target type
8909 //DeclAccessPair& ResultFunctionAccessPair;
8910 ASTContext& Context;
8912 bool TargetTypeIsNonStaticMemberFunction;
8913 bool FoundNonTemplateFunction;
8915 OverloadExpr::FindResult OvlExprInfo;
8916 OverloadExpr *OvlExpr;
8917 TemplateArgumentListInfo OvlExplicitTemplateArgs;
8918 SmallVector<std::pair<DeclAccessPair, FunctionDecl*>, 4> Matches;
8921 AddressOfFunctionResolver(Sema &S, Expr* SourceExpr,
8922 const QualType& TargetType, bool Complain)
8923 : S(S), SourceExpr(SourceExpr), TargetType(TargetType),
8924 Complain(Complain), Context(S.getASTContext()),
8925 TargetTypeIsNonStaticMemberFunction(
8926 !!TargetType->getAs<MemberPointerType>()),
8927 FoundNonTemplateFunction(false),
8928 OvlExprInfo(OverloadExpr::find(SourceExpr)),
8929 OvlExpr(OvlExprInfo.Expression)
8931 ExtractUnqualifiedFunctionTypeFromTargetType();
8933 if (!TargetFunctionType->isFunctionType()) {
8934 if (OvlExpr->hasExplicitTemplateArgs()) {
8936 if (FunctionDecl* Fn = S.ResolveSingleFunctionTemplateSpecialization(
8937 OvlExpr, false, &dap) ) {
8939 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) {
8940 if (!Method->isStatic()) {
8941 // If the target type is a non-function type and the function
8942 // found is a non-static member function, pretend as if that was
8943 // the target, it's the only possible type to end up with.
8944 TargetTypeIsNonStaticMemberFunction = true;
8946 // And skip adding the function if its not in the proper form.
8947 // We'll diagnose this due to an empty set of functions.
8948 if (!OvlExprInfo.HasFormOfMemberPointer)
8953 Matches.push_back(std::make_pair(dap,Fn));
8959 if (OvlExpr->hasExplicitTemplateArgs())
8960 OvlExpr->getExplicitTemplateArgs().copyInto(OvlExplicitTemplateArgs);
8962 if (FindAllFunctionsThatMatchTargetTypeExactly()) {
8963 // C++ [over.over]p4:
8964 // If more than one function is selected, [...]
8965 if (Matches.size() > 1) {
8966 if (FoundNonTemplateFunction)
8967 EliminateAllTemplateMatches();
8969 EliminateAllExceptMostSpecializedTemplate();
8975 bool isTargetTypeAFunction() const {
8976 return TargetFunctionType->isFunctionType();
8979 // [ToType] [Return]
8981 // R (*)(A) --> R (A), IsNonStaticMemberFunction = false
8982 // R (&)(A) --> R (A), IsNonStaticMemberFunction = false
8983 // R (S::*)(A) --> R (A), IsNonStaticMemberFunction = true
8984 void inline ExtractUnqualifiedFunctionTypeFromTargetType() {
8985 TargetFunctionType = S.ExtractUnqualifiedFunctionType(TargetType);
8988 // return true if any matching specializations were found
8989 bool AddMatchingTemplateFunction(FunctionTemplateDecl* FunctionTemplate,
8990 const DeclAccessPair& CurAccessFunPair) {
8991 if (CXXMethodDecl *Method
8992 = dyn_cast<CXXMethodDecl>(FunctionTemplate->getTemplatedDecl())) {
8993 // Skip non-static function templates when converting to pointer, and
8994 // static when converting to member pointer.
8995 if (Method->isStatic() == TargetTypeIsNonStaticMemberFunction)
8998 else if (TargetTypeIsNonStaticMemberFunction)
9001 // C++ [over.over]p2:
9002 // If the name is a function template, template argument deduction is
9003 // done (14.8.2.2), and if the argument deduction succeeds, the
9004 // resulting template argument list is used to generate a single
9005 // function template specialization, which is added to the set of
9006 // overloaded functions considered.
9007 FunctionDecl *Specialization = 0;
9008 TemplateDeductionInfo Info(OvlExpr->getNameLoc());
9009 if (Sema::TemplateDeductionResult Result
9010 = S.DeduceTemplateArguments(FunctionTemplate,
9011 &OvlExplicitTemplateArgs,
9012 TargetFunctionType, Specialization,
9014 // FIXME: make a note of the failed deduction for diagnostics.
9019 // Template argument deduction ensures that we have an exact match.
9020 // This function template specicalization works.
9021 Specialization = cast<FunctionDecl>(Specialization->getCanonicalDecl());
9022 assert(TargetFunctionType
9023 == Context.getCanonicalType(Specialization->getType()));
9024 Matches.push_back(std::make_pair(CurAccessFunPair, Specialization));
9028 bool AddMatchingNonTemplateFunction(NamedDecl* Fn,
9029 const DeclAccessPair& CurAccessFunPair) {
9030 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) {
9031 // Skip non-static functions when converting to pointer, and static
9032 // when converting to member pointer.
9033 if (Method->isStatic() == TargetTypeIsNonStaticMemberFunction)
9036 else if (TargetTypeIsNonStaticMemberFunction)
9039 if (FunctionDecl *FunDecl = dyn_cast<FunctionDecl>(Fn)) {
9040 if (S.getLangOpts().CUDA)
9041 if (FunctionDecl *Caller = dyn_cast<FunctionDecl>(S.CurContext))
9042 if (S.CheckCUDATarget(Caller, FunDecl))
9046 if (Context.hasSameUnqualifiedType(TargetFunctionType,
9047 FunDecl->getType()) ||
9048 S.IsNoReturnConversion(FunDecl->getType(), TargetFunctionType,
9050 Matches.push_back(std::make_pair(CurAccessFunPair,
9051 cast<FunctionDecl>(FunDecl->getCanonicalDecl())));
9052 FoundNonTemplateFunction = true;
9060 bool FindAllFunctionsThatMatchTargetTypeExactly() {
9063 // If the overload expression doesn't have the form of a pointer to
9064 // member, don't try to convert it to a pointer-to-member type.
9065 if (IsInvalidFormOfPointerToMemberFunction())
9068 for (UnresolvedSetIterator I = OvlExpr->decls_begin(),
9069 E = OvlExpr->decls_end();
9071 // Look through any using declarations to find the underlying function.
9072 NamedDecl *Fn = (*I)->getUnderlyingDecl();
9074 // C++ [over.over]p3:
9075 // Non-member functions and static member functions match
9076 // targets of type "pointer-to-function" or "reference-to-function."
9077 // Nonstatic member functions match targets of
9078 // type "pointer-to-member-function."
9079 // Note that according to DR 247, the containing class does not matter.
9080 if (FunctionTemplateDecl *FunctionTemplate
9081 = dyn_cast<FunctionTemplateDecl>(Fn)) {
9082 if (AddMatchingTemplateFunction(FunctionTemplate, I.getPair()))
9085 // If we have explicit template arguments supplied, skip non-templates.
9086 else if (!OvlExpr->hasExplicitTemplateArgs() &&
9087 AddMatchingNonTemplateFunction(Fn, I.getPair()))
9090 assert(Ret || Matches.empty());
9094 void EliminateAllExceptMostSpecializedTemplate() {
9095 // [...] and any given function template specialization F1 is
9096 // eliminated if the set contains a second function template
9097 // specialization whose function template is more specialized
9098 // than the function template of F1 according to the partial
9099 // ordering rules of 14.5.5.2.
9101 // The algorithm specified above is quadratic. We instead use a
9102 // two-pass algorithm (similar to the one used to identify the
9103 // best viable function in an overload set) that identifies the
9104 // best function template (if it exists).
9106 UnresolvedSet<4> MatchesCopy; // TODO: avoid!
9107 for (unsigned I = 0, E = Matches.size(); I != E; ++I)
9108 MatchesCopy.addDecl(Matches[I].second, Matches[I].first.getAccess());
9110 UnresolvedSetIterator Result =
9111 S.getMostSpecialized(MatchesCopy.begin(), MatchesCopy.end(),
9112 TPOC_Other, 0, SourceExpr->getLocStart(),
9114 S.PDiag(diag::err_addr_ovl_ambiguous)
9115 << Matches[0].second->getDeclName(),
9116 S.PDiag(diag::note_ovl_candidate)
9117 << (unsigned) oc_function_template,
9118 Complain, TargetFunctionType);
9120 if (Result != MatchesCopy.end()) {
9121 // Make it the first and only element
9122 Matches[0].first = Matches[Result - MatchesCopy.begin()].first;
9123 Matches[0].second = cast<FunctionDecl>(*Result);
9128 void EliminateAllTemplateMatches() {
9129 // [...] any function template specializations in the set are
9130 // eliminated if the set also contains a non-template function, [...]
9131 for (unsigned I = 0, N = Matches.size(); I != N; ) {
9132 if (Matches[I].second->getPrimaryTemplate() == 0)
9135 Matches[I] = Matches[--N];
9136 Matches.set_size(N);
9142 void ComplainNoMatchesFound() const {
9143 assert(Matches.empty());
9144 S.Diag(OvlExpr->getLocStart(), diag::err_addr_ovl_no_viable)
9145 << OvlExpr->getName() << TargetFunctionType
9146 << OvlExpr->getSourceRange();
9147 S.NoteAllOverloadCandidates(OvlExpr, TargetFunctionType);
9150 bool IsInvalidFormOfPointerToMemberFunction() const {
9151 return TargetTypeIsNonStaticMemberFunction &&
9152 !OvlExprInfo.HasFormOfMemberPointer;
9155 void ComplainIsInvalidFormOfPointerToMemberFunction() const {
9156 // TODO: Should we condition this on whether any functions might
9157 // have matched, or is it more appropriate to do that in callers?
9158 // TODO: a fixit wouldn't hurt.
9159 S.Diag(OvlExpr->getNameLoc(), diag::err_addr_ovl_no_qualifier)
9160 << TargetType << OvlExpr->getSourceRange();
9163 void ComplainOfInvalidConversion() const {
9164 S.Diag(OvlExpr->getLocStart(), diag::err_addr_ovl_not_func_ptrref)
9165 << OvlExpr->getName() << TargetType;
9168 void ComplainMultipleMatchesFound() const {
9169 assert(Matches.size() > 1);
9170 S.Diag(OvlExpr->getLocStart(), diag::err_addr_ovl_ambiguous)
9171 << OvlExpr->getName()
9172 << OvlExpr->getSourceRange();
9173 S.NoteAllOverloadCandidates(OvlExpr, TargetFunctionType);
9176 bool hadMultipleCandidates() const { return (OvlExpr->getNumDecls() > 1); }
9178 int getNumMatches() const { return Matches.size(); }
9180 FunctionDecl* getMatchingFunctionDecl() const {
9181 if (Matches.size() != 1) return 0;
9182 return Matches[0].second;
9185 const DeclAccessPair* getMatchingFunctionAccessPair() const {
9186 if (Matches.size() != 1) return 0;
9187 return &Matches[0].first;
9191 /// ResolveAddressOfOverloadedFunction - Try to resolve the address of
9192 /// an overloaded function (C++ [over.over]), where @p From is an
9193 /// expression with overloaded function type and @p ToType is the type
9194 /// we're trying to resolve to. For example:
9200 /// int (*pfd)(double) = f; // selects f(double)
9203 /// This routine returns the resulting FunctionDecl if it could be
9204 /// resolved, and NULL otherwise. When @p Complain is true, this
9205 /// routine will emit diagnostics if there is an error.
9207 Sema::ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr,
9208 QualType TargetType,
9210 DeclAccessPair &FoundResult,
9211 bool *pHadMultipleCandidates) {
9212 assert(AddressOfExpr->getType() == Context.OverloadTy);
9214 AddressOfFunctionResolver Resolver(*this, AddressOfExpr, TargetType,
9216 int NumMatches = Resolver.getNumMatches();
9217 FunctionDecl* Fn = 0;
9218 if (NumMatches == 0 && Complain) {
9219 if (Resolver.IsInvalidFormOfPointerToMemberFunction())
9220 Resolver.ComplainIsInvalidFormOfPointerToMemberFunction();
9222 Resolver.ComplainNoMatchesFound();
9224 else if (NumMatches > 1 && Complain)
9225 Resolver.ComplainMultipleMatchesFound();
9226 else if (NumMatches == 1) {
9227 Fn = Resolver.getMatchingFunctionDecl();
9229 FoundResult = *Resolver.getMatchingFunctionAccessPair();
9231 CheckAddressOfMemberAccess(AddressOfExpr, FoundResult);
9234 if (pHadMultipleCandidates)
9235 *pHadMultipleCandidates = Resolver.hadMultipleCandidates();
9239 /// \brief Given an expression that refers to an overloaded function, try to
9240 /// resolve that overloaded function expression down to a single function.
9242 /// This routine can only resolve template-ids that refer to a single function
9243 /// template, where that template-id refers to a single template whose template
9244 /// arguments are either provided by the template-id or have defaults,
9245 /// as described in C++0x [temp.arg.explicit]p3.
9247 Sema::ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl,
9249 DeclAccessPair *FoundResult) {
9250 // C++ [over.over]p1:
9251 // [...] [Note: any redundant set of parentheses surrounding the
9252 // overloaded function name is ignored (5.1). ]
9253 // C++ [over.over]p1:
9254 // [...] The overloaded function name can be preceded by the &
9257 // If we didn't actually find any template-ids, we're done.
9258 if (!ovl->hasExplicitTemplateArgs())
9261 TemplateArgumentListInfo ExplicitTemplateArgs;
9262 ovl->getExplicitTemplateArgs().copyInto(ExplicitTemplateArgs);
9264 // Look through all of the overloaded functions, searching for one
9265 // whose type matches exactly.
9266 FunctionDecl *Matched = 0;
9267 for (UnresolvedSetIterator I = ovl->decls_begin(),
9268 E = ovl->decls_end(); I != E; ++I) {
9269 // C++0x [temp.arg.explicit]p3:
9270 // [...] In contexts where deduction is done and fails, or in contexts
9271 // where deduction is not done, if a template argument list is
9272 // specified and it, along with any default template arguments,
9273 // identifies a single function template specialization, then the
9274 // template-id is an lvalue for the function template specialization.
9275 FunctionTemplateDecl *FunctionTemplate
9276 = cast<FunctionTemplateDecl>((*I)->getUnderlyingDecl());
9278 // C++ [over.over]p2:
9279 // If the name is a function template, template argument deduction is
9280 // done (14.8.2.2), and if the argument deduction succeeds, the
9281 // resulting template argument list is used to generate a single
9282 // function template specialization, which is added to the set of
9283 // overloaded functions considered.
9284 FunctionDecl *Specialization = 0;
9285 TemplateDeductionInfo Info(ovl->getNameLoc());
9286 if (TemplateDeductionResult Result
9287 = DeduceTemplateArguments(FunctionTemplate, &ExplicitTemplateArgs,
9288 Specialization, Info)) {
9289 // FIXME: make a note of the failed deduction for diagnostics.
9294 assert(Specialization && "no specialization and no error?");
9296 // Multiple matches; we can't resolve to a single declaration.
9299 Diag(ovl->getExprLoc(), diag::err_addr_ovl_ambiguous)
9301 NoteAllOverloadCandidates(ovl);
9306 Matched = Specialization;
9307 if (FoundResult) *FoundResult = I.getPair();
9316 // Resolve and fix an overloaded expression that can be resolved
9317 // because it identifies a single function template specialization.
9319 // Last three arguments should only be supplied if Complain = true
9321 // Return true if it was logically possible to so resolve the
9322 // expression, regardless of whether or not it succeeded. Always
9323 // returns true if 'complain' is set.
9324 bool Sema::ResolveAndFixSingleFunctionTemplateSpecialization(
9325 ExprResult &SrcExpr, bool doFunctionPointerConverion,
9326 bool complain, const SourceRange& OpRangeForComplaining,
9327 QualType DestTypeForComplaining,
9328 unsigned DiagIDForComplaining) {
9329 assert(SrcExpr.get()->getType() == Context.OverloadTy);
9331 OverloadExpr::FindResult ovl = OverloadExpr::find(SrcExpr.get());
9333 DeclAccessPair found;
9334 ExprResult SingleFunctionExpression;
9335 if (FunctionDecl *fn = ResolveSingleFunctionTemplateSpecialization(
9336 ovl.Expression, /*complain*/ false, &found)) {
9337 if (DiagnoseUseOfDecl(fn, SrcExpr.get()->getLocStart())) {
9338 SrcExpr = ExprError();
9342 // It is only correct to resolve to an instance method if we're
9343 // resolving a form that's permitted to be a pointer to member.
9344 // Otherwise we'll end up making a bound member expression, which
9345 // is illegal in all the contexts we resolve like this.
9346 if (!ovl.HasFormOfMemberPointer &&
9347 isa<CXXMethodDecl>(fn) &&
9348 cast<CXXMethodDecl>(fn)->isInstance()) {
9349 if (!complain) return false;
9351 Diag(ovl.Expression->getExprLoc(),
9352 diag::err_bound_member_function)
9353 << 0 << ovl.Expression->getSourceRange();
9355 // TODO: I believe we only end up here if there's a mix of
9356 // static and non-static candidates (otherwise the expression
9357 // would have 'bound member' type, not 'overload' type).
9358 // Ideally we would note which candidate was chosen and why
9359 // the static candidates were rejected.
9360 SrcExpr = ExprError();
9364 // Fix the expression to refer to 'fn'.
9365 SingleFunctionExpression =
9366 Owned(FixOverloadedFunctionReference(SrcExpr.take(), found, fn));
9368 // If desired, do function-to-pointer decay.
9369 if (doFunctionPointerConverion) {
9370 SingleFunctionExpression =
9371 DefaultFunctionArrayLvalueConversion(SingleFunctionExpression.take());
9372 if (SingleFunctionExpression.isInvalid()) {
9373 SrcExpr = ExprError();
9379 if (!SingleFunctionExpression.isUsable()) {
9381 Diag(OpRangeForComplaining.getBegin(), DiagIDForComplaining)
9382 << ovl.Expression->getName()
9383 << DestTypeForComplaining
9384 << OpRangeForComplaining
9385 << ovl.Expression->getQualifierLoc().getSourceRange();
9386 NoteAllOverloadCandidates(SrcExpr.get());
9388 SrcExpr = ExprError();
9395 SrcExpr = SingleFunctionExpression;
9399 /// \brief Add a single candidate to the overload set.
9400 static void AddOverloadedCallCandidate(Sema &S,
9401 DeclAccessPair FoundDecl,
9402 TemplateArgumentListInfo *ExplicitTemplateArgs,
9403 llvm::ArrayRef<Expr *> Args,
9404 OverloadCandidateSet &CandidateSet,
9405 bool PartialOverloading,
9407 NamedDecl *Callee = FoundDecl.getDecl();
9408 if (isa<UsingShadowDecl>(Callee))
9409 Callee = cast<UsingShadowDecl>(Callee)->getTargetDecl();
9411 if (FunctionDecl *Func = dyn_cast<FunctionDecl>(Callee)) {
9412 if (ExplicitTemplateArgs) {
9413 assert(!KnownValid && "Explicit template arguments?");
9416 S.AddOverloadCandidate(Func, FoundDecl, Args, CandidateSet, false,
9417 PartialOverloading);
9421 if (FunctionTemplateDecl *FuncTemplate
9422 = dyn_cast<FunctionTemplateDecl>(Callee)) {
9423 S.AddTemplateOverloadCandidate(FuncTemplate, FoundDecl,
9424 ExplicitTemplateArgs, Args, CandidateSet);
9428 assert(!KnownValid && "unhandled case in overloaded call candidate");
9431 /// \brief Add the overload candidates named by callee and/or found by argument
9432 /// dependent lookup to the given overload set.
9433 void Sema::AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE,
9434 llvm::ArrayRef<Expr *> Args,
9435 OverloadCandidateSet &CandidateSet,
9436 bool PartialOverloading) {
9439 // Verify that ArgumentDependentLookup is consistent with the rules
9440 // in C++0x [basic.lookup.argdep]p3:
9442 // Let X be the lookup set produced by unqualified lookup (3.4.1)
9443 // and let Y be the lookup set produced by argument dependent
9444 // lookup (defined as follows). If X contains
9446 // -- a declaration of a class member, or
9448 // -- a block-scope function declaration that is not a
9449 // using-declaration, or
9451 // -- a declaration that is neither a function or a function
9456 if (ULE->requiresADL()) {
9457 for (UnresolvedLookupExpr::decls_iterator I = ULE->decls_begin(),
9458 E = ULE->decls_end(); I != E; ++I) {
9459 assert(!(*I)->getDeclContext()->isRecord());
9460 assert(isa<UsingShadowDecl>(*I) ||
9461 !(*I)->getDeclContext()->isFunctionOrMethod());
9462 assert((*I)->getUnderlyingDecl()->isFunctionOrFunctionTemplate());
9467 // It would be nice to avoid this copy.
9468 TemplateArgumentListInfo TABuffer;
9469 TemplateArgumentListInfo *ExplicitTemplateArgs = 0;
9470 if (ULE->hasExplicitTemplateArgs()) {
9471 ULE->copyTemplateArgumentsInto(TABuffer);
9472 ExplicitTemplateArgs = &TABuffer;
9475 for (UnresolvedLookupExpr::decls_iterator I = ULE->decls_begin(),
9476 E = ULE->decls_end(); I != E; ++I)
9477 AddOverloadedCallCandidate(*this, I.getPair(), ExplicitTemplateArgs, Args,
9478 CandidateSet, PartialOverloading,
9479 /*KnownValid*/ true);
9481 if (ULE->requiresADL())
9482 AddArgumentDependentLookupCandidates(ULE->getName(), /*Operator*/ false,
9484 Args, ExplicitTemplateArgs,
9485 CandidateSet, PartialOverloading);
9488 /// Attempt to recover from an ill-formed use of a non-dependent name in a
9489 /// template, where the non-dependent name was declared after the template
9490 /// was defined. This is common in code written for a compilers which do not
9491 /// correctly implement two-stage name lookup.
9493 /// Returns true if a viable candidate was found and a diagnostic was issued.
9495 DiagnoseTwoPhaseLookup(Sema &SemaRef, SourceLocation FnLoc,
9496 const CXXScopeSpec &SS, LookupResult &R,
9497 TemplateArgumentListInfo *ExplicitTemplateArgs,
9498 llvm::ArrayRef<Expr *> Args) {
9499 if (SemaRef.ActiveTemplateInstantiations.empty() || !SS.isEmpty())
9502 for (DeclContext *DC = SemaRef.CurContext; DC; DC = DC->getParent()) {
9503 if (DC->isTransparentContext())
9506 SemaRef.LookupQualifiedName(R, DC);
9509 R.suppressDiagnostics();
9511 if (isa<CXXRecordDecl>(DC)) {
9512 // Don't diagnose names we find in classes; we get much better
9513 // diagnostics for these from DiagnoseEmptyLookup.
9518 OverloadCandidateSet Candidates(FnLoc);
9519 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I)
9520 AddOverloadedCallCandidate(SemaRef, I.getPair(),
9521 ExplicitTemplateArgs, Args,
9522 Candidates, false, /*KnownValid*/ false);
9524 OverloadCandidateSet::iterator Best;
9525 if (Candidates.BestViableFunction(SemaRef, FnLoc, Best) != OR_Success) {
9526 // No viable functions. Don't bother the user with notes for functions
9527 // which don't work and shouldn't be found anyway.
9532 // Find the namespaces where ADL would have looked, and suggest
9533 // declaring the function there instead.
9534 Sema::AssociatedNamespaceSet AssociatedNamespaces;
9535 Sema::AssociatedClassSet AssociatedClasses;
9536 SemaRef.FindAssociatedClassesAndNamespaces(FnLoc, Args,
9537 AssociatedNamespaces,
9539 // Never suggest declaring a function within namespace 'std'.
9540 Sema::AssociatedNamespaceSet SuggestedNamespaces;
9541 if (DeclContext *Std = SemaRef.getStdNamespace()) {
9542 for (Sema::AssociatedNamespaceSet::iterator
9543 it = AssociatedNamespaces.begin(),
9544 end = AssociatedNamespaces.end(); it != end; ++it) {
9545 if (!Std->Encloses(*it))
9546 SuggestedNamespaces.insert(*it);
9549 // Lacking the 'std::' namespace, use all of the associated namespaces.
9550 SuggestedNamespaces = AssociatedNamespaces;
9553 SemaRef.Diag(R.getNameLoc(), diag::err_not_found_by_two_phase_lookup)
9554 << R.getLookupName();
9555 if (SuggestedNamespaces.empty()) {
9556 SemaRef.Diag(Best->Function->getLocation(),
9557 diag::note_not_found_by_two_phase_lookup)
9558 << R.getLookupName() << 0;
9559 } else if (SuggestedNamespaces.size() == 1) {
9560 SemaRef.Diag(Best->Function->getLocation(),
9561 diag::note_not_found_by_two_phase_lookup)
9562 << R.getLookupName() << 1 << *SuggestedNamespaces.begin();
9564 // FIXME: It would be useful to list the associated namespaces here,
9565 // but the diagnostics infrastructure doesn't provide a way to produce
9566 // a localized representation of a list of items.
9567 SemaRef.Diag(Best->Function->getLocation(),
9568 diag::note_not_found_by_two_phase_lookup)
9569 << R.getLookupName() << 2;
9572 // Try to recover by calling this function.
9582 /// Attempt to recover from ill-formed use of a non-dependent operator in a
9583 /// template, where the non-dependent operator was declared after the template
9586 /// Returns true if a viable candidate was found and a diagnostic was issued.
9588 DiagnoseTwoPhaseOperatorLookup(Sema &SemaRef, OverloadedOperatorKind Op,
9589 SourceLocation OpLoc,
9590 llvm::ArrayRef<Expr *> Args) {
9591 DeclarationName OpName =
9592 SemaRef.Context.DeclarationNames.getCXXOperatorName(Op);
9593 LookupResult R(SemaRef, OpName, OpLoc, Sema::LookupOperatorName);
9594 return DiagnoseTwoPhaseLookup(SemaRef, OpLoc, CXXScopeSpec(), R,
9595 /*ExplicitTemplateArgs=*/0, Args);
9599 // Callback to limit the allowed keywords and to only accept typo corrections
9600 // that are keywords or whose decls refer to functions (or template functions)
9601 // that accept the given number of arguments.
9602 class RecoveryCallCCC : public CorrectionCandidateCallback {
9604 RecoveryCallCCC(Sema &SemaRef, unsigned NumArgs, bool HasExplicitTemplateArgs)
9605 : NumArgs(NumArgs), HasExplicitTemplateArgs(HasExplicitTemplateArgs) {
9606 WantTypeSpecifiers = SemaRef.getLangOpts().CPlusPlus;
9607 WantRemainingKeywords = false;
9610 virtual bool ValidateCandidate(const TypoCorrection &candidate) {
9611 if (!candidate.getCorrectionDecl())
9612 return candidate.isKeyword();
9614 for (TypoCorrection::const_decl_iterator DI = candidate.begin(),
9615 DIEnd = candidate.end(); DI != DIEnd; ++DI) {
9616 FunctionDecl *FD = 0;
9617 NamedDecl *ND = (*DI)->getUnderlyingDecl();
9618 if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(ND))
9619 FD = FTD->getTemplatedDecl();
9620 if (!HasExplicitTemplateArgs && !FD) {
9621 if (!(FD = dyn_cast<FunctionDecl>(ND)) && isa<ValueDecl>(ND)) {
9622 // If the Decl is neither a function nor a template function,
9623 // determine if it is a pointer or reference to a function. If so,
9624 // check against the number of arguments expected for the pointee.
9625 QualType ValType = cast<ValueDecl>(ND)->getType();
9626 if (ValType->isAnyPointerType() || ValType->isReferenceType())
9627 ValType = ValType->getPointeeType();
9628 if (const FunctionProtoType *FPT = ValType->getAs<FunctionProtoType>())
9629 if (FPT->getNumArgs() == NumArgs)
9633 if (FD && FD->getNumParams() >= NumArgs &&
9634 FD->getMinRequiredArguments() <= NumArgs)
9642 bool HasExplicitTemplateArgs;
9645 // Callback that effectively disabled typo correction
9646 class NoTypoCorrectionCCC : public CorrectionCandidateCallback {
9648 NoTypoCorrectionCCC() {
9649 WantTypeSpecifiers = false;
9650 WantExpressionKeywords = false;
9651 WantCXXNamedCasts = false;
9652 WantRemainingKeywords = false;
9655 virtual bool ValidateCandidate(const TypoCorrection &candidate) {
9660 class BuildRecoveryCallExprRAII {
9663 BuildRecoveryCallExprRAII(Sema &S) : SemaRef(S) {
9664 assert(SemaRef.IsBuildingRecoveryCallExpr == false);
9665 SemaRef.IsBuildingRecoveryCallExpr = true;
9668 ~BuildRecoveryCallExprRAII() {
9669 SemaRef.IsBuildingRecoveryCallExpr = false;
9675 /// Attempts to recover from a call where no functions were found.
9677 /// Returns true if new candidates were found.
9679 BuildRecoveryCallExpr(Sema &SemaRef, Scope *S, Expr *Fn,
9680 UnresolvedLookupExpr *ULE,
9681 SourceLocation LParenLoc,
9682 llvm::MutableArrayRef<Expr *> Args,
9683 SourceLocation RParenLoc,
9684 bool EmptyLookup, bool AllowTypoCorrection) {
9685 // Do not try to recover if it is already building a recovery call.
9686 // This stops infinite loops for template instantiations like
9688 // template <typename T> auto foo(T t) -> decltype(foo(t)) {}
9689 // template <typename T> auto foo(T t) -> decltype(foo(&t)) {}
9691 if (SemaRef.IsBuildingRecoveryCallExpr)
9693 BuildRecoveryCallExprRAII RCE(SemaRef);
9696 SS.Adopt(ULE->getQualifierLoc());
9697 SourceLocation TemplateKWLoc = ULE->getTemplateKeywordLoc();
9699 TemplateArgumentListInfo TABuffer;
9700 TemplateArgumentListInfo *ExplicitTemplateArgs = 0;
9701 if (ULE->hasExplicitTemplateArgs()) {
9702 ULE->copyTemplateArgumentsInto(TABuffer);
9703 ExplicitTemplateArgs = &TABuffer;
9706 LookupResult R(SemaRef, ULE->getName(), ULE->getNameLoc(),
9707 Sema::LookupOrdinaryName);
9708 RecoveryCallCCC Validator(SemaRef, Args.size(), ExplicitTemplateArgs != 0);
9709 NoTypoCorrectionCCC RejectAll;
9710 CorrectionCandidateCallback *CCC = AllowTypoCorrection ?
9711 (CorrectionCandidateCallback*)&Validator :
9712 (CorrectionCandidateCallback*)&RejectAll;
9713 if (!DiagnoseTwoPhaseLookup(SemaRef, Fn->getExprLoc(), SS, R,
9714 ExplicitTemplateArgs, Args) &&
9716 SemaRef.DiagnoseEmptyLookup(S, SS, R, *CCC,
9717 ExplicitTemplateArgs, Args)))
9720 assert(!R.empty() && "lookup results empty despite recovery");
9722 // Build an implicit member call if appropriate. Just drop the
9723 // casts and such from the call, we don't really care.
9724 ExprResult NewFn = ExprError();
9725 if ((*R.begin())->isCXXClassMember())
9726 NewFn = SemaRef.BuildPossibleImplicitMemberExpr(SS, TemplateKWLoc,
9727 R, ExplicitTemplateArgs);
9728 else if (ExplicitTemplateArgs || TemplateKWLoc.isValid())
9729 NewFn = SemaRef.BuildTemplateIdExpr(SS, TemplateKWLoc, R, false,
9730 ExplicitTemplateArgs);
9732 NewFn = SemaRef.BuildDeclarationNameExpr(SS, R, false);
9734 if (NewFn.isInvalid())
9737 // This shouldn't cause an infinite loop because we're giving it
9738 // an expression with viable lookup results, which should never
9740 return SemaRef.ActOnCallExpr(/*Scope*/ 0, NewFn.take(), LParenLoc,
9741 MultiExprArg(Args.data(), Args.size()),
9745 /// \brief Constructs and populates an OverloadedCandidateSet from
9746 /// the given function.
9747 /// \returns true when an the ExprResult output parameter has been set.
9748 bool Sema::buildOverloadedCallSet(Scope *S, Expr *Fn,
9749 UnresolvedLookupExpr *ULE,
9750 Expr **Args, unsigned NumArgs,
9751 SourceLocation RParenLoc,
9752 OverloadCandidateSet *CandidateSet,
9753 ExprResult *Result) {
9755 if (ULE->requiresADL()) {
9756 // To do ADL, we must have found an unqualified name.
9757 assert(!ULE->getQualifier() && "qualified name with ADL");
9759 // We don't perform ADL for implicit declarations of builtins.
9760 // Verify that this was correctly set up.
9762 if (ULE->decls_begin() + 1 == ULE->decls_end() &&
9763 (F = dyn_cast<FunctionDecl>(*ULE->decls_begin())) &&
9764 F->getBuiltinID() && F->isImplicit())
9765 llvm_unreachable("performing ADL for builtin");
9767 // We don't perform ADL in C.
9768 assert(getLangOpts().CPlusPlus && "ADL enabled in C");
9772 UnbridgedCastsSet UnbridgedCasts;
9773 if (checkArgPlaceholdersForOverload(*this, Args, NumArgs, UnbridgedCasts)) {
9774 *Result = ExprError();
9778 // Add the functions denoted by the callee to the set of candidate
9779 // functions, including those from argument-dependent lookup.
9780 AddOverloadedCallCandidates(ULE, llvm::makeArrayRef(Args, NumArgs),
9783 // If we found nothing, try to recover.
9784 // BuildRecoveryCallExpr diagnoses the error itself, so we just bail
9786 if (CandidateSet->empty()) {
9787 // In Microsoft mode, if we are inside a template class member function then
9788 // create a type dependent CallExpr. The goal is to postpone name lookup
9789 // to instantiation time to be able to search into type dependent base
9791 if (getLangOpts().MicrosoftMode && CurContext->isDependentContext() &&
9792 (isa<FunctionDecl>(CurContext) || isa<CXXRecordDecl>(CurContext))) {
9793 CallExpr *CE = new (Context) CallExpr(Context, Fn,
9794 llvm::makeArrayRef(Args, NumArgs),
9795 Context.DependentTy, VK_RValue,
9797 CE->setTypeDependent(true);
9798 *Result = Owned(CE);
9804 UnbridgedCasts.restore();
9808 /// FinishOverloadedCallExpr - given an OverloadCandidateSet, builds and returns
9809 /// the completed call expression. If overload resolution fails, emits
9810 /// diagnostics and returns ExprError()
9811 static ExprResult FinishOverloadedCallExpr(Sema &SemaRef, Scope *S, Expr *Fn,
9812 UnresolvedLookupExpr *ULE,
9813 SourceLocation LParenLoc,
9814 Expr **Args, unsigned NumArgs,
9815 SourceLocation RParenLoc,
9817 OverloadCandidateSet *CandidateSet,
9818 OverloadCandidateSet::iterator *Best,
9819 OverloadingResult OverloadResult,
9820 bool AllowTypoCorrection) {
9821 if (CandidateSet->empty())
9822 return BuildRecoveryCallExpr(SemaRef, S, Fn, ULE, LParenLoc,
9823 llvm::MutableArrayRef<Expr *>(Args, NumArgs),
9824 RParenLoc, /*EmptyLookup=*/true,
9825 AllowTypoCorrection);
9827 switch (OverloadResult) {
9829 FunctionDecl *FDecl = (*Best)->Function;
9830 SemaRef.MarkFunctionReferenced(Fn->getExprLoc(), FDecl);
9831 SemaRef.CheckUnresolvedLookupAccess(ULE, (*Best)->FoundDecl);
9832 SemaRef.DiagnoseUseOfDecl(FDecl, ULE->getNameLoc());
9833 Fn = SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl);
9834 return SemaRef.BuildResolvedCallExpr(Fn, FDecl, LParenLoc, Args, NumArgs,
9835 RParenLoc, ExecConfig);
9838 case OR_No_Viable_Function: {
9839 // Try to recover by looking for viable functions which the user might
9840 // have meant to call.
9841 ExprResult Recovery = BuildRecoveryCallExpr(SemaRef, S, Fn, ULE, LParenLoc,
9842 llvm::MutableArrayRef<Expr *>(Args, NumArgs),
9844 /*EmptyLookup=*/false,
9845 AllowTypoCorrection);
9846 if (!Recovery.isInvalid())
9849 SemaRef.Diag(Fn->getLocStart(),
9850 diag::err_ovl_no_viable_function_in_call)
9851 << ULE->getName() << Fn->getSourceRange();
9852 CandidateSet->NoteCandidates(SemaRef, OCD_AllCandidates,
9853 llvm::makeArrayRef(Args, NumArgs));
9858 SemaRef.Diag(Fn->getLocStart(), diag::err_ovl_ambiguous_call)
9859 << ULE->getName() << Fn->getSourceRange();
9860 CandidateSet->NoteCandidates(SemaRef, OCD_ViableCandidates,
9861 llvm::makeArrayRef(Args, NumArgs));
9865 SemaRef.Diag(Fn->getLocStart(), diag::err_ovl_deleted_call)
9866 << (*Best)->Function->isDeleted()
9868 << SemaRef.getDeletedOrUnavailableSuffix((*Best)->Function)
9869 << Fn->getSourceRange();
9870 CandidateSet->NoteCandidates(SemaRef, OCD_AllCandidates,
9871 llvm::makeArrayRef(Args, NumArgs));
9873 // We emitted an error for the unvailable/deleted function call but keep
9874 // the call in the AST.
9875 FunctionDecl *FDecl = (*Best)->Function;
9876 Fn = SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl);
9877 return SemaRef.BuildResolvedCallExpr(Fn, FDecl, LParenLoc, Args, NumArgs,
9878 RParenLoc, ExecConfig);
9882 // Overload resolution failed.
9886 /// BuildOverloadedCallExpr - Given the call expression that calls Fn
9887 /// (which eventually refers to the declaration Func) and the call
9888 /// arguments Args/NumArgs, attempt to resolve the function call down
9889 /// to a specific function. If overload resolution succeeds, returns
9890 /// the call expression produced by overload resolution.
9891 /// Otherwise, emits diagnostics and returns ExprError.
9892 ExprResult Sema::BuildOverloadedCallExpr(Scope *S, Expr *Fn,
9893 UnresolvedLookupExpr *ULE,
9894 SourceLocation LParenLoc,
9895 Expr **Args, unsigned NumArgs,
9896 SourceLocation RParenLoc,
9898 bool AllowTypoCorrection) {
9899 OverloadCandidateSet CandidateSet(Fn->getExprLoc());
9902 if (buildOverloadedCallSet(S, Fn, ULE, Args, NumArgs, LParenLoc,
9903 &CandidateSet, &result))
9906 OverloadCandidateSet::iterator Best;
9907 OverloadingResult OverloadResult =
9908 CandidateSet.BestViableFunction(*this, Fn->getLocStart(), Best);
9910 return FinishOverloadedCallExpr(*this, S, Fn, ULE, LParenLoc, Args, NumArgs,
9911 RParenLoc, ExecConfig, &CandidateSet,
9912 &Best, OverloadResult,
9913 AllowTypoCorrection);
9916 static bool IsOverloaded(const UnresolvedSetImpl &Functions) {
9917 return Functions.size() > 1 ||
9918 (Functions.size() == 1 && isa<FunctionTemplateDecl>(*Functions.begin()));
9921 /// \brief Create a unary operation that may resolve to an overloaded
9924 /// \param OpLoc The location of the operator itself (e.g., '*').
9926 /// \param OpcIn The UnaryOperator::Opcode that describes this
9929 /// \param Fns The set of non-member functions that will be
9930 /// considered by overload resolution. The caller needs to build this
9931 /// set based on the context using, e.g.,
9932 /// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This
9933 /// set should not contain any member functions; those will be added
9934 /// by CreateOverloadedUnaryOp().
9936 /// \param Input The input argument.
9938 Sema::CreateOverloadedUnaryOp(SourceLocation OpLoc, unsigned OpcIn,
9939 const UnresolvedSetImpl &Fns,
9941 UnaryOperator::Opcode Opc = static_cast<UnaryOperator::Opcode>(OpcIn);
9943 OverloadedOperatorKind Op = UnaryOperator::getOverloadedOperator(Opc);
9944 assert(Op != OO_None && "Invalid opcode for overloaded unary operator");
9945 DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op);
9946 // TODO: provide better source location info.
9947 DeclarationNameInfo OpNameInfo(OpName, OpLoc);
9949 if (checkPlaceholderForOverload(*this, Input))
9952 Expr *Args[2] = { Input, 0 };
9953 unsigned NumArgs = 1;
9955 // For post-increment and post-decrement, add the implicit '0' as
9956 // the second argument, so that we know this is a post-increment or
9958 if (Opc == UO_PostInc || Opc == UO_PostDec) {
9959 llvm::APSInt Zero(Context.getTypeSize(Context.IntTy), false);
9960 Args[1] = IntegerLiteral::Create(Context, Zero, Context.IntTy,
9965 if (Input->isTypeDependent()) {
9967 return Owned(new (Context) UnaryOperator(Input,
9969 Context.DependentTy,
9970 VK_RValue, OK_Ordinary,
9973 CXXRecordDecl *NamingClass = 0; // because lookup ignores member operators
9974 UnresolvedLookupExpr *Fn
9975 = UnresolvedLookupExpr::Create(Context, NamingClass,
9976 NestedNameSpecifierLoc(), OpNameInfo,
9977 /*ADL*/ true, IsOverloaded(Fns),
9978 Fns.begin(), Fns.end());
9979 return Owned(new (Context) CXXOperatorCallExpr(Context, Op, Fn,
9980 llvm::makeArrayRef(Args, NumArgs),
9981 Context.DependentTy,
9986 // Build an empty overload set.
9987 OverloadCandidateSet CandidateSet(OpLoc);
9989 // Add the candidates from the given function set.
9990 AddFunctionCandidates(Fns, llvm::makeArrayRef(Args, NumArgs), CandidateSet,
9993 // Add operator candidates that are member functions.
9994 AddMemberOperatorCandidates(Op, OpLoc, &Args[0], NumArgs, CandidateSet);
9996 // Add candidates from ADL.
9997 AddArgumentDependentLookupCandidates(OpName, /*Operator*/ true,
9998 OpLoc, llvm::makeArrayRef(Args, NumArgs),
9999 /*ExplicitTemplateArgs*/ 0,
10002 // Add builtin operator candidates.
10003 AddBuiltinOperatorCandidates(Op, OpLoc, &Args[0], NumArgs, CandidateSet);
10005 bool HadMultipleCandidates = (CandidateSet.size() > 1);
10007 // Perform overload resolution.
10008 OverloadCandidateSet::iterator Best;
10009 switch (CandidateSet.BestViableFunction(*this, OpLoc, Best)) {
10011 // We found a built-in operator or an overloaded operator.
10012 FunctionDecl *FnDecl = Best->Function;
10015 // We matched an overloaded operator. Build a call to that
10018 MarkFunctionReferenced(OpLoc, FnDecl);
10020 // Convert the arguments.
10021 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) {
10022 CheckMemberOperatorAccess(OpLoc, Args[0], 0, Best->FoundDecl);
10024 ExprResult InputRes =
10025 PerformObjectArgumentInitialization(Input, /*Qualifier=*/0,
10026 Best->FoundDecl, Method);
10027 if (InputRes.isInvalid())
10028 return ExprError();
10029 Input = InputRes.take();
10031 // Convert the arguments.
10032 ExprResult InputInit
10033 = PerformCopyInitialization(InitializedEntity::InitializeParameter(
10035 FnDecl->getParamDecl(0)),
10038 if (InputInit.isInvalid())
10039 return ExprError();
10040 Input = InputInit.take();
10043 DiagnoseUseOfDecl(Best->FoundDecl, OpLoc);
10045 // Determine the result type.
10046 QualType ResultTy = FnDecl->getResultType();
10047 ExprValueKind VK = Expr::getValueKindForType(ResultTy);
10048 ResultTy = ResultTy.getNonLValueExprType(Context);
10050 // Build the actual expression node.
10051 ExprResult FnExpr = CreateFunctionRefExpr(*this, FnDecl,
10052 HadMultipleCandidates, OpLoc);
10053 if (FnExpr.isInvalid())
10054 return ExprError();
10057 CallExpr *TheCall =
10058 new (Context) CXXOperatorCallExpr(Context, Op, FnExpr.take(),
10059 llvm::makeArrayRef(Args, NumArgs),
10060 ResultTy, VK, OpLoc, false);
10062 if (CheckCallReturnType(FnDecl->getResultType(), OpLoc, TheCall,
10064 return ExprError();
10066 return MaybeBindToTemporary(TheCall);
10068 // We matched a built-in operator. Convert the arguments, then
10069 // break out so that we will build the appropriate built-in
10071 ExprResult InputRes =
10072 PerformImplicitConversion(Input, Best->BuiltinTypes.ParamTypes[0],
10073 Best->Conversions[0], AA_Passing);
10074 if (InputRes.isInvalid())
10075 return ExprError();
10076 Input = InputRes.take();
10081 case OR_No_Viable_Function:
10082 // This is an erroneous use of an operator which can be overloaded by
10083 // a non-member function. Check for non-member operators which were
10084 // defined too late to be candidates.
10085 if (DiagnoseTwoPhaseOperatorLookup(*this, Op, OpLoc,
10086 llvm::makeArrayRef(Args, NumArgs)))
10087 // FIXME: Recover by calling the found function.
10088 return ExprError();
10090 // No viable function; fall through to handling this as a
10091 // built-in operator, which will produce an error message for us.
10095 Diag(OpLoc, diag::err_ovl_ambiguous_oper_unary)
10096 << UnaryOperator::getOpcodeStr(Opc)
10097 << Input->getType()
10098 << Input->getSourceRange();
10099 CandidateSet.NoteCandidates(*this, OCD_ViableCandidates,
10100 llvm::makeArrayRef(Args, NumArgs),
10101 UnaryOperator::getOpcodeStr(Opc), OpLoc);
10102 return ExprError();
10105 Diag(OpLoc, diag::err_ovl_deleted_oper)
10106 << Best->Function->isDeleted()
10107 << UnaryOperator::getOpcodeStr(Opc)
10108 << getDeletedOrUnavailableSuffix(Best->Function)
10109 << Input->getSourceRange();
10110 CandidateSet.NoteCandidates(*this, OCD_AllCandidates,
10111 llvm::makeArrayRef(Args, NumArgs),
10112 UnaryOperator::getOpcodeStr(Opc), OpLoc);
10113 return ExprError();
10116 // Either we found no viable overloaded operator or we matched a
10117 // built-in operator. In either case, fall through to trying to
10118 // build a built-in operation.
10119 return CreateBuiltinUnaryOp(OpLoc, Opc, Input);
10122 /// \brief Create a binary operation that may resolve to an overloaded
10125 /// \param OpLoc The location of the operator itself (e.g., '+').
10127 /// \param OpcIn The BinaryOperator::Opcode that describes this
10130 /// \param Fns The set of non-member functions that will be
10131 /// considered by overload resolution. The caller needs to build this
10132 /// set based on the context using, e.g.,
10133 /// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This
10134 /// set should not contain any member functions; those will be added
10135 /// by CreateOverloadedBinOp().
10137 /// \param LHS Left-hand argument.
10138 /// \param RHS Right-hand argument.
10140 Sema::CreateOverloadedBinOp(SourceLocation OpLoc,
10142 const UnresolvedSetImpl &Fns,
10143 Expr *LHS, Expr *RHS) {
10144 Expr *Args[2] = { LHS, RHS };
10145 LHS=RHS=0; //Please use only Args instead of LHS/RHS couple
10147 BinaryOperator::Opcode Opc = static_cast<BinaryOperator::Opcode>(OpcIn);
10148 OverloadedOperatorKind Op = BinaryOperator::getOverloadedOperator(Opc);
10149 DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op);
10151 // If either side is type-dependent, create an appropriate dependent
10153 if (Args[0]->isTypeDependent() || Args[1]->isTypeDependent()) {
10155 // If there are no functions to store, just build a dependent
10156 // BinaryOperator or CompoundAssignment.
10157 if (Opc <= BO_Assign || Opc > BO_OrAssign)
10158 return Owned(new (Context) BinaryOperator(Args[0], Args[1], Opc,
10159 Context.DependentTy,
10160 VK_RValue, OK_Ordinary,
10162 FPFeatures.fp_contract));
10164 return Owned(new (Context) CompoundAssignOperator(Args[0], Args[1], Opc,
10165 Context.DependentTy,
10168 Context.DependentTy,
10169 Context.DependentTy,
10171 FPFeatures.fp_contract));
10174 // FIXME: save results of ADL from here?
10175 CXXRecordDecl *NamingClass = 0; // because lookup ignores member operators
10176 // TODO: provide better source location info in DNLoc component.
10177 DeclarationNameInfo OpNameInfo(OpName, OpLoc);
10178 UnresolvedLookupExpr *Fn
10179 = UnresolvedLookupExpr::Create(Context, NamingClass,
10180 NestedNameSpecifierLoc(), OpNameInfo,
10181 /*ADL*/ true, IsOverloaded(Fns),
10182 Fns.begin(), Fns.end());
10183 return Owned(new (Context) CXXOperatorCallExpr(Context, Op, Fn, Args,
10184 Context.DependentTy, VK_RValue,
10185 OpLoc, FPFeatures.fp_contract));
10188 // Always do placeholder-like conversions on the RHS.
10189 if (checkPlaceholderForOverload(*this, Args[1]))
10190 return ExprError();
10192 // Do placeholder-like conversion on the LHS; note that we should
10193 // not get here with a PseudoObject LHS.
10194 assert(Args[0]->getObjectKind() != OK_ObjCProperty);
10195 if (checkPlaceholderForOverload(*this, Args[0]))
10196 return ExprError();
10198 // If this is the assignment operator, we only perform overload resolution
10199 // if the left-hand side is a class or enumeration type. This is actually
10200 // a hack. The standard requires that we do overload resolution between the
10201 // various built-in candidates, but as DR507 points out, this can lead to
10202 // problems. So we do it this way, which pretty much follows what GCC does.
10203 // Note that we go the traditional code path for compound assignment forms.
10204 if (Opc == BO_Assign && !Args[0]->getType()->isOverloadableType())
10205 return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
10207 // If this is the .* operator, which is not overloadable, just
10208 // create a built-in binary operator.
10209 if (Opc == BO_PtrMemD)
10210 return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
10212 // Build an empty overload set.
10213 OverloadCandidateSet CandidateSet(OpLoc);
10215 // Add the candidates from the given function set.
10216 AddFunctionCandidates(Fns, Args, CandidateSet, false);
10218 // Add operator candidates that are member functions.
10219 AddMemberOperatorCandidates(Op, OpLoc, Args, 2, CandidateSet);
10221 // Add candidates from ADL.
10222 AddArgumentDependentLookupCandidates(OpName, /*Operator*/ true,
10224 /*ExplicitTemplateArgs*/ 0,
10227 // Add builtin operator candidates.
10228 AddBuiltinOperatorCandidates(Op, OpLoc, Args, 2, CandidateSet);
10230 bool HadMultipleCandidates = (CandidateSet.size() > 1);
10232 // Perform overload resolution.
10233 OverloadCandidateSet::iterator Best;
10234 switch (CandidateSet.BestViableFunction(*this, OpLoc, Best)) {
10236 // We found a built-in operator or an overloaded operator.
10237 FunctionDecl *FnDecl = Best->Function;
10240 // We matched an overloaded operator. Build a call to that
10243 MarkFunctionReferenced(OpLoc, FnDecl);
10245 // Convert the arguments.
10246 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) {
10247 // Best->Access is only meaningful for class members.
10248 CheckMemberOperatorAccess(OpLoc, Args[0], Args[1], Best->FoundDecl);
10251 PerformCopyInitialization(
10252 InitializedEntity::InitializeParameter(Context,
10253 FnDecl->getParamDecl(0)),
10254 SourceLocation(), Owned(Args[1]));
10255 if (Arg1.isInvalid())
10256 return ExprError();
10259 PerformObjectArgumentInitialization(Args[0], /*Qualifier=*/0,
10260 Best->FoundDecl, Method);
10261 if (Arg0.isInvalid())
10262 return ExprError();
10263 Args[0] = Arg0.takeAs<Expr>();
10264 Args[1] = RHS = Arg1.takeAs<Expr>();
10266 // Convert the arguments.
10267 ExprResult Arg0 = PerformCopyInitialization(
10268 InitializedEntity::InitializeParameter(Context,
10269 FnDecl->getParamDecl(0)),
10270 SourceLocation(), Owned(Args[0]));
10271 if (Arg0.isInvalid())
10272 return ExprError();
10275 PerformCopyInitialization(
10276 InitializedEntity::InitializeParameter(Context,
10277 FnDecl->getParamDecl(1)),
10278 SourceLocation(), Owned(Args[1]));
10279 if (Arg1.isInvalid())
10280 return ExprError();
10281 Args[0] = LHS = Arg0.takeAs<Expr>();
10282 Args[1] = RHS = Arg1.takeAs<Expr>();
10285 DiagnoseUseOfDecl(Best->FoundDecl, OpLoc);
10287 // Determine the result type.
10288 QualType ResultTy = FnDecl->getResultType();
10289 ExprValueKind VK = Expr::getValueKindForType(ResultTy);
10290 ResultTy = ResultTy.getNonLValueExprType(Context);
10292 // Build the actual expression node.
10293 ExprResult FnExpr = CreateFunctionRefExpr(*this, FnDecl,
10294 HadMultipleCandidates, OpLoc);
10295 if (FnExpr.isInvalid())
10296 return ExprError();
10298 CXXOperatorCallExpr *TheCall =
10299 new (Context) CXXOperatorCallExpr(Context, Op, FnExpr.take(),
10300 Args, ResultTy, VK, OpLoc,
10301 FPFeatures.fp_contract);
10303 if (CheckCallReturnType(FnDecl->getResultType(), OpLoc, TheCall,
10305 return ExprError();
10307 return MaybeBindToTemporary(TheCall);
10309 // We matched a built-in operator. Convert the arguments, then
10310 // break out so that we will build the appropriate built-in
10312 ExprResult ArgsRes0 =
10313 PerformImplicitConversion(Args[0], Best->BuiltinTypes.ParamTypes[0],
10314 Best->Conversions[0], AA_Passing);
10315 if (ArgsRes0.isInvalid())
10316 return ExprError();
10317 Args[0] = ArgsRes0.take();
10319 ExprResult ArgsRes1 =
10320 PerformImplicitConversion(Args[1], Best->BuiltinTypes.ParamTypes[1],
10321 Best->Conversions[1], AA_Passing);
10322 if (ArgsRes1.isInvalid())
10323 return ExprError();
10324 Args[1] = ArgsRes1.take();
10329 case OR_No_Viable_Function: {
10330 // C++ [over.match.oper]p9:
10331 // If the operator is the operator , [...] and there are no
10332 // viable functions, then the operator is assumed to be the
10333 // built-in operator and interpreted according to clause 5.
10334 if (Opc == BO_Comma)
10337 // For class as left operand for assignment or compound assigment
10338 // operator do not fall through to handling in built-in, but report that
10339 // no overloaded assignment operator found
10340 ExprResult Result = ExprError();
10341 if (Args[0]->getType()->isRecordType() &&
10342 Opc >= BO_Assign && Opc <= BO_OrAssign) {
10343 Diag(OpLoc, diag::err_ovl_no_viable_oper)
10344 << BinaryOperator::getOpcodeStr(Opc)
10345 << Args[0]->getSourceRange() << Args[1]->getSourceRange();
10347 // This is an erroneous use of an operator which can be overloaded by
10348 // a non-member function. Check for non-member operators which were
10349 // defined too late to be candidates.
10350 if (DiagnoseTwoPhaseOperatorLookup(*this, Op, OpLoc, Args))
10351 // FIXME: Recover by calling the found function.
10352 return ExprError();
10354 // No viable function; try to create a built-in operation, which will
10355 // produce an error. Then, show the non-viable candidates.
10356 Result = CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
10358 assert(Result.isInvalid() &&
10359 "C++ binary operator overloading is missing candidates!");
10360 if (Result.isInvalid())
10361 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args,
10362 BinaryOperator::getOpcodeStr(Opc), OpLoc);
10367 Diag(OpLoc, diag::err_ovl_ambiguous_oper_binary)
10368 << BinaryOperator::getOpcodeStr(Opc)
10369 << Args[0]->getType() << Args[1]->getType()
10370 << Args[0]->getSourceRange() << Args[1]->getSourceRange();
10371 CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, Args,
10372 BinaryOperator::getOpcodeStr(Opc), OpLoc);
10373 return ExprError();
10376 if (isImplicitlyDeleted(Best->Function)) {
10377 CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
10378 Diag(OpLoc, diag::err_ovl_deleted_special_oper)
10379 << getSpecialMember(Method)
10380 << BinaryOperator::getOpcodeStr(Opc)
10381 << getDeletedOrUnavailableSuffix(Best->Function);
10383 if (getSpecialMember(Method) != CXXInvalid) {
10384 // The user probably meant to call this special member. Just
10385 // explain why it's deleted.
10386 NoteDeletedFunction(Method);
10387 return ExprError();
10390 Diag(OpLoc, diag::err_ovl_deleted_oper)
10391 << Best->Function->isDeleted()
10392 << BinaryOperator::getOpcodeStr(Opc)
10393 << getDeletedOrUnavailableSuffix(Best->Function)
10394 << Args[0]->getSourceRange() << Args[1]->getSourceRange();
10396 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args,
10397 BinaryOperator::getOpcodeStr(Opc), OpLoc);
10398 return ExprError();
10401 // We matched a built-in operator; build it.
10402 return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
10406 Sema::CreateOverloadedArraySubscriptExpr(SourceLocation LLoc,
10407 SourceLocation RLoc,
10408 Expr *Base, Expr *Idx) {
10409 Expr *Args[2] = { Base, Idx };
10410 DeclarationName OpName =
10411 Context.DeclarationNames.getCXXOperatorName(OO_Subscript);
10413 // If either side is type-dependent, create an appropriate dependent
10415 if (Args[0]->isTypeDependent() || Args[1]->isTypeDependent()) {
10417 CXXRecordDecl *NamingClass = 0; // because lookup ignores member operators
10418 // CHECKME: no 'operator' keyword?
10419 DeclarationNameInfo OpNameInfo(OpName, LLoc);
10420 OpNameInfo.setCXXOperatorNameRange(SourceRange(LLoc, RLoc));
10421 UnresolvedLookupExpr *Fn
10422 = UnresolvedLookupExpr::Create(Context, NamingClass,
10423 NestedNameSpecifierLoc(), OpNameInfo,
10424 /*ADL*/ true, /*Overloaded*/ false,
10425 UnresolvedSetIterator(),
10426 UnresolvedSetIterator());
10427 // Can't add any actual overloads yet
10429 return Owned(new (Context) CXXOperatorCallExpr(Context, OO_Subscript, Fn,
10431 Context.DependentTy,
10436 // Handle placeholders on both operands.
10437 if (checkPlaceholderForOverload(*this, Args[0]))
10438 return ExprError();
10439 if (checkPlaceholderForOverload(*this, Args[1]))
10440 return ExprError();
10442 // Build an empty overload set.
10443 OverloadCandidateSet CandidateSet(LLoc);
10445 // Subscript can only be overloaded as a member function.
10447 // Add operator candidates that are member functions.
10448 AddMemberOperatorCandidates(OO_Subscript, LLoc, Args, 2, CandidateSet);
10450 // Add builtin operator candidates.
10451 AddBuiltinOperatorCandidates(OO_Subscript, LLoc, Args, 2, CandidateSet);
10453 bool HadMultipleCandidates = (CandidateSet.size() > 1);
10455 // Perform overload resolution.
10456 OverloadCandidateSet::iterator Best;
10457 switch (CandidateSet.BestViableFunction(*this, LLoc, Best)) {
10459 // We found a built-in operator or an overloaded operator.
10460 FunctionDecl *FnDecl = Best->Function;
10463 // We matched an overloaded operator. Build a call to that
10466 MarkFunctionReferenced(LLoc, FnDecl);
10468 CheckMemberOperatorAccess(LLoc, Args[0], Args[1], Best->FoundDecl);
10469 DiagnoseUseOfDecl(Best->FoundDecl, LLoc);
10471 // Convert the arguments.
10472 CXXMethodDecl *Method = cast<CXXMethodDecl>(FnDecl);
10474 PerformObjectArgumentInitialization(Args[0], /*Qualifier=*/0,
10475 Best->FoundDecl, Method);
10476 if (Arg0.isInvalid())
10477 return ExprError();
10478 Args[0] = Arg0.take();
10480 // Convert the arguments.
10481 ExprResult InputInit
10482 = PerformCopyInitialization(InitializedEntity::InitializeParameter(
10484 FnDecl->getParamDecl(0)),
10487 if (InputInit.isInvalid())
10488 return ExprError();
10490 Args[1] = InputInit.takeAs<Expr>();
10492 // Determine the result type
10493 QualType ResultTy = FnDecl->getResultType();
10494 ExprValueKind VK = Expr::getValueKindForType(ResultTy);
10495 ResultTy = ResultTy.getNonLValueExprType(Context);
10497 // Build the actual expression node.
10498 DeclarationNameInfo OpLocInfo(OpName, LLoc);
10499 OpLocInfo.setCXXOperatorNameRange(SourceRange(LLoc, RLoc));
10500 ExprResult FnExpr = CreateFunctionRefExpr(*this, FnDecl,
10501 HadMultipleCandidates,
10502 OpLocInfo.getLoc(),
10503 OpLocInfo.getInfo());
10504 if (FnExpr.isInvalid())
10505 return ExprError();
10507 CXXOperatorCallExpr *TheCall =
10508 new (Context) CXXOperatorCallExpr(Context, OO_Subscript,
10509 FnExpr.take(), Args,
10510 ResultTy, VK, RLoc,
10513 if (CheckCallReturnType(FnDecl->getResultType(), LLoc, TheCall,
10515 return ExprError();
10517 return MaybeBindToTemporary(TheCall);
10519 // We matched a built-in operator. Convert the arguments, then
10520 // break out so that we will build the appropriate built-in
10522 ExprResult ArgsRes0 =
10523 PerformImplicitConversion(Args[0], Best->BuiltinTypes.ParamTypes[0],
10524 Best->Conversions[0], AA_Passing);
10525 if (ArgsRes0.isInvalid())
10526 return ExprError();
10527 Args[0] = ArgsRes0.take();
10529 ExprResult ArgsRes1 =
10530 PerformImplicitConversion(Args[1], Best->BuiltinTypes.ParamTypes[1],
10531 Best->Conversions[1], AA_Passing);
10532 if (ArgsRes1.isInvalid())
10533 return ExprError();
10534 Args[1] = ArgsRes1.take();
10540 case OR_No_Viable_Function: {
10541 if (CandidateSet.empty())
10542 Diag(LLoc, diag::err_ovl_no_oper)
10543 << Args[0]->getType() << /*subscript*/ 0
10544 << Args[0]->getSourceRange() << Args[1]->getSourceRange();
10546 Diag(LLoc, diag::err_ovl_no_viable_subscript)
10547 << Args[0]->getType()
10548 << Args[0]->getSourceRange() << Args[1]->getSourceRange();
10549 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args,
10551 return ExprError();
10555 Diag(LLoc, diag::err_ovl_ambiguous_oper_binary)
10557 << Args[0]->getType() << Args[1]->getType()
10558 << Args[0]->getSourceRange() << Args[1]->getSourceRange();
10559 CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, Args,
10561 return ExprError();
10564 Diag(LLoc, diag::err_ovl_deleted_oper)
10565 << Best->Function->isDeleted() << "[]"
10566 << getDeletedOrUnavailableSuffix(Best->Function)
10567 << Args[0]->getSourceRange() << Args[1]->getSourceRange();
10568 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args,
10570 return ExprError();
10573 // We matched a built-in operator; build it.
10574 return CreateBuiltinArraySubscriptExpr(Args[0], LLoc, Args[1], RLoc);
10577 /// BuildCallToMemberFunction - Build a call to a member
10578 /// function. MemExpr is the expression that refers to the member
10579 /// function (and includes the object parameter), Args/NumArgs are the
10580 /// arguments to the function call (not including the object
10581 /// parameter). The caller needs to validate that the member
10582 /// expression refers to a non-static member function or an overloaded
10583 /// member function.
10585 Sema::BuildCallToMemberFunction(Scope *S, Expr *MemExprE,
10586 SourceLocation LParenLoc, Expr **Args,
10587 unsigned NumArgs, SourceLocation RParenLoc) {
10588 assert(MemExprE->getType() == Context.BoundMemberTy ||
10589 MemExprE->getType() == Context.OverloadTy);
10591 // Dig out the member expression. This holds both the object
10592 // argument and the member function we're referring to.
10593 Expr *NakedMemExpr = MemExprE->IgnoreParens();
10595 // Determine whether this is a call to a pointer-to-member function.
10596 if (BinaryOperator *op = dyn_cast<BinaryOperator>(NakedMemExpr)) {
10597 assert(op->getType() == Context.BoundMemberTy);
10598 assert(op->getOpcode() == BO_PtrMemD || op->getOpcode() == BO_PtrMemI);
10601 op->getRHS()->getType()->castAs<MemberPointerType>()->getPointeeType();
10603 const FunctionProtoType *proto = fnType->castAs<FunctionProtoType>();
10604 QualType resultType = proto->getCallResultType(Context);
10605 ExprValueKind valueKind = Expr::getValueKindForType(proto->getResultType());
10607 // Check that the object type isn't more qualified than the
10608 // member function we're calling.
10609 Qualifiers funcQuals = Qualifiers::fromCVRMask(proto->getTypeQuals());
10611 QualType objectType = op->getLHS()->getType();
10612 if (op->getOpcode() == BO_PtrMemI)
10613 objectType = objectType->castAs<PointerType>()->getPointeeType();
10614 Qualifiers objectQuals = objectType.getQualifiers();
10616 Qualifiers difference = objectQuals - funcQuals;
10617 difference.removeObjCGCAttr();
10618 difference.removeAddressSpace();
10620 std::string qualsString = difference.getAsString();
10621 Diag(LParenLoc, diag::err_pointer_to_member_call_drops_quals)
10622 << fnType.getUnqualifiedType()
10624 << (qualsString.find(' ') == std::string::npos ? 1 : 2);
10627 CXXMemberCallExpr *call
10628 = new (Context) CXXMemberCallExpr(Context, MemExprE,
10629 llvm::makeArrayRef(Args, NumArgs),
10630 resultType, valueKind, RParenLoc);
10632 if (CheckCallReturnType(proto->getResultType(),
10633 op->getRHS()->getLocStart(),
10635 return ExprError();
10637 if (ConvertArgumentsForCall(call, op, 0, proto, Args, NumArgs, RParenLoc))
10638 return ExprError();
10640 return MaybeBindToTemporary(call);
10643 UnbridgedCastsSet UnbridgedCasts;
10644 if (checkArgPlaceholdersForOverload(*this, Args, NumArgs, UnbridgedCasts))
10645 return ExprError();
10647 MemberExpr *MemExpr;
10648 CXXMethodDecl *Method = 0;
10649 DeclAccessPair FoundDecl = DeclAccessPair::make(0, AS_public);
10650 NestedNameSpecifier *Qualifier = 0;
10651 if (isa<MemberExpr>(NakedMemExpr)) {
10652 MemExpr = cast<MemberExpr>(NakedMemExpr);
10653 Method = cast<CXXMethodDecl>(MemExpr->getMemberDecl());
10654 FoundDecl = MemExpr->getFoundDecl();
10655 Qualifier = MemExpr->getQualifier();
10656 UnbridgedCasts.restore();
10658 UnresolvedMemberExpr *UnresExpr = cast<UnresolvedMemberExpr>(NakedMemExpr);
10659 Qualifier = UnresExpr->getQualifier();
10661 QualType ObjectType = UnresExpr->getBaseType();
10662 Expr::Classification ObjectClassification
10663 = UnresExpr->isArrow()? Expr::Classification::makeSimpleLValue()
10664 : UnresExpr->getBase()->Classify(Context);
10666 // Add overload candidates
10667 OverloadCandidateSet CandidateSet(UnresExpr->getMemberLoc());
10669 // FIXME: avoid copy.
10670 TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = 0;
10671 if (UnresExpr->hasExplicitTemplateArgs()) {
10672 UnresExpr->copyTemplateArgumentsInto(TemplateArgsBuffer);
10673 TemplateArgs = &TemplateArgsBuffer;
10676 for (UnresolvedMemberExpr::decls_iterator I = UnresExpr->decls_begin(),
10677 E = UnresExpr->decls_end(); I != E; ++I) {
10679 NamedDecl *Func = *I;
10680 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(Func->getDeclContext());
10681 if (isa<UsingShadowDecl>(Func))
10682 Func = cast<UsingShadowDecl>(Func)->getTargetDecl();
10685 // Microsoft supports direct constructor calls.
10686 if (getLangOpts().MicrosoftExt && isa<CXXConstructorDecl>(Func)) {
10687 AddOverloadCandidate(cast<CXXConstructorDecl>(Func), I.getPair(),
10688 llvm::makeArrayRef(Args, NumArgs), CandidateSet);
10689 } else if ((Method = dyn_cast<CXXMethodDecl>(Func))) {
10690 // If explicit template arguments were provided, we can't call a
10691 // non-template member function.
10695 AddMethodCandidate(Method, I.getPair(), ActingDC, ObjectType,
10696 ObjectClassification,
10697 llvm::makeArrayRef(Args, NumArgs), CandidateSet,
10698 /*SuppressUserConversions=*/false);
10700 AddMethodTemplateCandidate(cast<FunctionTemplateDecl>(Func),
10701 I.getPair(), ActingDC, TemplateArgs,
10702 ObjectType, ObjectClassification,
10703 llvm::makeArrayRef(Args, NumArgs),
10705 /*SuppressUsedConversions=*/false);
10709 DeclarationName DeclName = UnresExpr->getMemberName();
10711 UnbridgedCasts.restore();
10713 OverloadCandidateSet::iterator Best;
10714 switch (CandidateSet.BestViableFunction(*this, UnresExpr->getLocStart(),
10717 Method = cast<CXXMethodDecl>(Best->Function);
10718 MarkFunctionReferenced(UnresExpr->getMemberLoc(), Method);
10719 FoundDecl = Best->FoundDecl;
10720 CheckUnresolvedMemberAccess(UnresExpr, Best->FoundDecl);
10721 DiagnoseUseOfDecl(Best->FoundDecl, UnresExpr->getNameLoc());
10724 case OR_No_Viable_Function:
10725 Diag(UnresExpr->getMemberLoc(),
10726 diag::err_ovl_no_viable_member_function_in_call)
10727 << DeclName << MemExprE->getSourceRange();
10728 CandidateSet.NoteCandidates(*this, OCD_AllCandidates,
10729 llvm::makeArrayRef(Args, NumArgs));
10730 // FIXME: Leaking incoming expressions!
10731 return ExprError();
10734 Diag(UnresExpr->getMemberLoc(), diag::err_ovl_ambiguous_member_call)
10735 << DeclName << MemExprE->getSourceRange();
10736 CandidateSet.NoteCandidates(*this, OCD_AllCandidates,
10737 llvm::makeArrayRef(Args, NumArgs));
10738 // FIXME: Leaking incoming expressions!
10739 return ExprError();
10742 Diag(UnresExpr->getMemberLoc(), diag::err_ovl_deleted_member_call)
10743 << Best->Function->isDeleted()
10745 << getDeletedOrUnavailableSuffix(Best->Function)
10746 << MemExprE->getSourceRange();
10747 CandidateSet.NoteCandidates(*this, OCD_AllCandidates,
10748 llvm::makeArrayRef(Args, NumArgs));
10749 // FIXME: Leaking incoming expressions!
10750 return ExprError();
10753 MemExprE = FixOverloadedFunctionReference(MemExprE, FoundDecl, Method);
10755 // If overload resolution picked a static member, build a
10756 // non-member call based on that function.
10757 if (Method->isStatic()) {
10758 return BuildResolvedCallExpr(MemExprE, Method, LParenLoc,
10759 Args, NumArgs, RParenLoc);
10762 MemExpr = cast<MemberExpr>(MemExprE->IgnoreParens());
10765 QualType ResultType = Method->getResultType();
10766 ExprValueKind VK = Expr::getValueKindForType(ResultType);
10767 ResultType = ResultType.getNonLValueExprType(Context);
10769 assert(Method && "Member call to something that isn't a method?");
10770 CXXMemberCallExpr *TheCall =
10771 new (Context) CXXMemberCallExpr(Context, MemExprE,
10772 llvm::makeArrayRef(Args, NumArgs),
10773 ResultType, VK, RParenLoc);
10775 // Check for a valid return type.
10776 if (CheckCallReturnType(Method->getResultType(), MemExpr->getMemberLoc(),
10778 return ExprError();
10780 // Convert the object argument (for a non-static member function call).
10781 // We only need to do this if there was actually an overload; otherwise
10782 // it was done at lookup.
10783 if (!Method->isStatic()) {
10784 ExprResult ObjectArg =
10785 PerformObjectArgumentInitialization(MemExpr->getBase(), Qualifier,
10786 FoundDecl, Method);
10787 if (ObjectArg.isInvalid())
10788 return ExprError();
10789 MemExpr->setBase(ObjectArg.take());
10792 // Convert the rest of the arguments
10793 const FunctionProtoType *Proto =
10794 Method->getType()->getAs<FunctionProtoType>();
10795 if (ConvertArgumentsForCall(TheCall, MemExpr, Method, Proto, Args, NumArgs,
10797 return ExprError();
10799 DiagnoseSentinelCalls(Method, LParenLoc, Args, NumArgs);
10801 if (CheckFunctionCall(Method, TheCall, Proto))
10802 return ExprError();
10804 if ((isa<CXXConstructorDecl>(CurContext) ||
10805 isa<CXXDestructorDecl>(CurContext)) &&
10806 TheCall->getMethodDecl()->isPure()) {
10807 const CXXMethodDecl *MD = TheCall->getMethodDecl();
10809 if (isa<CXXThisExpr>(MemExpr->getBase()->IgnoreParenCasts())) {
10810 Diag(MemExpr->getLocStart(),
10811 diag::warn_call_to_pure_virtual_member_function_from_ctor_dtor)
10812 << MD->getDeclName() << isa<CXXDestructorDecl>(CurContext)
10813 << MD->getParent()->getDeclName();
10815 Diag(MD->getLocStart(), diag::note_previous_decl) << MD->getDeclName();
10818 return MaybeBindToTemporary(TheCall);
10821 /// BuildCallToObjectOfClassType - Build a call to an object of class
10822 /// type (C++ [over.call.object]), which can end up invoking an
10823 /// overloaded function call operator (@c operator()) or performing a
10824 /// user-defined conversion on the object argument.
10826 Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Obj,
10827 SourceLocation LParenLoc,
10828 Expr **Args, unsigned NumArgs,
10829 SourceLocation RParenLoc) {
10830 if (checkPlaceholderForOverload(*this, Obj))
10831 return ExprError();
10832 ExprResult Object = Owned(Obj);
10834 UnbridgedCastsSet UnbridgedCasts;
10835 if (checkArgPlaceholdersForOverload(*this, Args, NumArgs, UnbridgedCasts))
10836 return ExprError();
10838 assert(Object.get()->getType()->isRecordType() && "Requires object type argument");
10839 const RecordType *Record = Object.get()->getType()->getAs<RecordType>();
10841 // C++ [over.call.object]p1:
10842 // If the primary-expression E in the function call syntax
10843 // evaluates to a class object of type "cv T", then the set of
10844 // candidate functions includes at least the function call
10845 // operators of T. The function call operators of T are obtained by
10846 // ordinary lookup of the name operator() in the context of
10848 OverloadCandidateSet CandidateSet(LParenLoc);
10849 DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(OO_Call);
10851 if (RequireCompleteType(LParenLoc, Object.get()->getType(),
10852 diag::err_incomplete_object_call, Object.get()))
10855 LookupResult R(*this, OpName, LParenLoc, LookupOrdinaryName);
10856 LookupQualifiedName(R, Record->getDecl());
10857 R.suppressDiagnostics();
10859 for (LookupResult::iterator Oper = R.begin(), OperEnd = R.end();
10860 Oper != OperEnd; ++Oper) {
10861 AddMethodCandidate(Oper.getPair(), Object.get()->getType(),
10862 Object.get()->Classify(Context), Args, NumArgs, CandidateSet,
10863 /*SuppressUserConversions=*/ false);
10866 // C++ [over.call.object]p2:
10867 // In addition, for each (non-explicit in C++0x) conversion function
10868 // declared in T of the form
10870 // operator conversion-type-id () cv-qualifier;
10872 // where cv-qualifier is the same cv-qualification as, or a
10873 // greater cv-qualification than, cv, and where conversion-type-id
10874 // denotes the type "pointer to function of (P1,...,Pn) returning
10875 // R", or the type "reference to pointer to function of
10876 // (P1,...,Pn) returning R", or the type "reference to function
10877 // of (P1,...,Pn) returning R", a surrogate call function [...]
10878 // is also considered as a candidate function. Similarly,
10879 // surrogate call functions are added to the set of candidate
10880 // functions for each conversion function declared in an
10881 // accessible base class provided the function is not hidden
10882 // within T by another intervening declaration.
10883 const UnresolvedSetImpl *Conversions
10884 = cast<CXXRecordDecl>(Record->getDecl())->getVisibleConversionFunctions();
10885 for (UnresolvedSetImpl::iterator I = Conversions->begin(),
10886 E = Conversions->end(); I != E; ++I) {
10888 CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext());
10889 if (isa<UsingShadowDecl>(D))
10890 D = cast<UsingShadowDecl>(D)->getTargetDecl();
10892 // Skip over templated conversion functions; they aren't
10894 if (isa<FunctionTemplateDecl>(D))
10897 CXXConversionDecl *Conv = cast<CXXConversionDecl>(D);
10898 if (!Conv->isExplicit()) {
10899 // Strip the reference type (if any) and then the pointer type (if
10900 // any) to get down to what might be a function type.
10901 QualType ConvType = Conv->getConversionType().getNonReferenceType();
10902 if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>())
10903 ConvType = ConvPtrType->getPointeeType();
10905 if (const FunctionProtoType *Proto = ConvType->getAs<FunctionProtoType>())
10907 AddSurrogateCandidate(Conv, I.getPair(), ActingContext, Proto,
10908 Object.get(), llvm::makeArrayRef(Args, NumArgs),
10914 bool HadMultipleCandidates = (CandidateSet.size() > 1);
10916 // Perform overload resolution.
10917 OverloadCandidateSet::iterator Best;
10918 switch (CandidateSet.BestViableFunction(*this, Object.get()->getLocStart(),
10921 // Overload resolution succeeded; we'll build the appropriate call
10925 case OR_No_Viable_Function:
10926 if (CandidateSet.empty())
10927 Diag(Object.get()->getLocStart(), diag::err_ovl_no_oper)
10928 << Object.get()->getType() << /*call*/ 1
10929 << Object.get()->getSourceRange();
10931 Diag(Object.get()->getLocStart(),
10932 diag::err_ovl_no_viable_object_call)
10933 << Object.get()->getType() << Object.get()->getSourceRange();
10934 CandidateSet.NoteCandidates(*this, OCD_AllCandidates,
10935 llvm::makeArrayRef(Args, NumArgs));
10939 Diag(Object.get()->getLocStart(),
10940 diag::err_ovl_ambiguous_object_call)
10941 << Object.get()->getType() << Object.get()->getSourceRange();
10942 CandidateSet.NoteCandidates(*this, OCD_ViableCandidates,
10943 llvm::makeArrayRef(Args, NumArgs));
10947 Diag(Object.get()->getLocStart(),
10948 diag::err_ovl_deleted_object_call)
10949 << Best->Function->isDeleted()
10950 << Object.get()->getType()
10951 << getDeletedOrUnavailableSuffix(Best->Function)
10952 << Object.get()->getSourceRange();
10953 CandidateSet.NoteCandidates(*this, OCD_AllCandidates,
10954 llvm::makeArrayRef(Args, NumArgs));
10958 if (Best == CandidateSet.end())
10961 UnbridgedCasts.restore();
10963 if (Best->Function == 0) {
10964 // Since there is no function declaration, this is one of the
10965 // surrogate candidates. Dig out the conversion function.
10966 CXXConversionDecl *Conv
10967 = cast<CXXConversionDecl>(
10968 Best->Conversions[0].UserDefined.ConversionFunction);
10970 CheckMemberOperatorAccess(LParenLoc, Object.get(), 0, Best->FoundDecl);
10971 DiagnoseUseOfDecl(Best->FoundDecl, LParenLoc);
10973 // We selected one of the surrogate functions that converts the
10974 // object parameter to a function pointer. Perform the conversion
10975 // on the object argument, then let ActOnCallExpr finish the job.
10977 // Create an implicit member expr to refer to the conversion operator.
10978 // and then call it.
10979 ExprResult Call = BuildCXXMemberCallExpr(Object.get(), Best->FoundDecl,
10980 Conv, HadMultipleCandidates);
10981 if (Call.isInvalid())
10982 return ExprError();
10983 // Record usage of conversion in an implicit cast.
10984 Call = Owned(ImplicitCastExpr::Create(Context, Call.get()->getType(),
10985 CK_UserDefinedConversion,
10986 Call.get(), 0, VK_RValue));
10988 return ActOnCallExpr(S, Call.get(), LParenLoc, MultiExprArg(Args, NumArgs),
10992 MarkFunctionReferenced(LParenLoc, Best->Function);
10993 CheckMemberOperatorAccess(LParenLoc, Object.get(), 0, Best->FoundDecl);
10994 DiagnoseUseOfDecl(Best->FoundDecl, LParenLoc);
10996 // We found an overloaded operator(). Build a CXXOperatorCallExpr
10997 // that calls this method, using Object for the implicit object
10998 // parameter and passing along the remaining arguments.
10999 CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
11001 // An error diagnostic has already been printed when parsing the declaration.
11002 if (Method->isInvalidDecl())
11003 return ExprError();
11005 const FunctionProtoType *Proto =
11006 Method->getType()->getAs<FunctionProtoType>();
11008 unsigned NumArgsInProto = Proto->getNumArgs();
11009 unsigned NumArgsToCheck = NumArgs;
11011 // Build the full argument list for the method call (the
11012 // implicit object parameter is placed at the beginning of the
11015 if (NumArgs < NumArgsInProto) {
11016 NumArgsToCheck = NumArgsInProto;
11017 MethodArgs = new Expr*[NumArgsInProto + 1];
11019 MethodArgs = new Expr*[NumArgs + 1];
11021 MethodArgs[0] = Object.get();
11022 for (unsigned ArgIdx = 0; ArgIdx < NumArgs; ++ArgIdx)
11023 MethodArgs[ArgIdx + 1] = Args[ArgIdx];
11025 DeclarationNameInfo OpLocInfo(
11026 Context.DeclarationNames.getCXXOperatorName(OO_Call), LParenLoc);
11027 OpLocInfo.setCXXOperatorNameRange(SourceRange(LParenLoc, RParenLoc));
11028 ExprResult NewFn = CreateFunctionRefExpr(*this, Method,
11029 HadMultipleCandidates,
11030 OpLocInfo.getLoc(),
11031 OpLocInfo.getInfo());
11032 if (NewFn.isInvalid())
11035 // Once we've built TheCall, all of the expressions are properly
11037 QualType ResultTy = Method->getResultType();
11038 ExprValueKind VK = Expr::getValueKindForType(ResultTy);
11039 ResultTy = ResultTy.getNonLValueExprType(Context);
11041 CXXOperatorCallExpr *TheCall =
11042 new (Context) CXXOperatorCallExpr(Context, OO_Call, NewFn.take(),
11043 llvm::makeArrayRef(MethodArgs, NumArgs+1),
11044 ResultTy, VK, RParenLoc, false);
11045 delete [] MethodArgs;
11047 if (CheckCallReturnType(Method->getResultType(), LParenLoc, TheCall,
11051 // We may have default arguments. If so, we need to allocate more
11052 // slots in the call for them.
11053 if (NumArgs < NumArgsInProto)
11054 TheCall->setNumArgs(Context, NumArgsInProto + 1);
11055 else if (NumArgs > NumArgsInProto)
11056 NumArgsToCheck = NumArgsInProto;
11058 bool IsError = false;
11060 // Initialize the implicit object parameter.
11061 ExprResult ObjRes =
11062 PerformObjectArgumentInitialization(Object.get(), /*Qualifier=*/0,
11063 Best->FoundDecl, Method);
11064 if (ObjRes.isInvalid())
11068 TheCall->setArg(0, Object.take());
11070 // Check the argument types.
11071 for (unsigned i = 0; i != NumArgsToCheck; i++) {
11076 // Pass the argument.
11078 ExprResult InputInit
11079 = PerformCopyInitialization(InitializedEntity::InitializeParameter(
11081 Method->getParamDecl(i)),
11082 SourceLocation(), Arg);
11084 IsError |= InputInit.isInvalid();
11085 Arg = InputInit.takeAs<Expr>();
11088 = BuildCXXDefaultArgExpr(LParenLoc, Method, Method->getParamDecl(i));
11089 if (DefArg.isInvalid()) {
11094 Arg = DefArg.takeAs<Expr>();
11097 TheCall->setArg(i + 1, Arg);
11100 // If this is a variadic call, handle args passed through "...".
11101 if (Proto->isVariadic()) {
11102 // Promote the arguments (C99 6.5.2.2p7).
11103 for (unsigned i = NumArgsInProto; i < NumArgs; i++) {
11104 ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], VariadicMethod, 0);
11105 IsError |= Arg.isInvalid();
11106 TheCall->setArg(i + 1, Arg.take());
11110 if (IsError) return true;
11112 DiagnoseSentinelCalls(Method, LParenLoc, Args, NumArgs);
11114 if (CheckFunctionCall(Method, TheCall, Proto))
11117 return MaybeBindToTemporary(TheCall);
11120 /// BuildOverloadedArrowExpr - Build a call to an overloaded @c operator->
11121 /// (if one exists), where @c Base is an expression of class type and
11122 /// @c Member is the name of the member we're trying to find.
11124 Sema::BuildOverloadedArrowExpr(Scope *S, Expr *Base, SourceLocation OpLoc) {
11125 assert(Base->getType()->isRecordType() &&
11126 "left-hand side must have class type");
11128 if (checkPlaceholderForOverload(*this, Base))
11129 return ExprError();
11131 SourceLocation Loc = Base->getExprLoc();
11133 // C++ [over.ref]p1:
11135 // [...] An expression x->m is interpreted as (x.operator->())->m
11136 // for a class object x of type T if T::operator->() exists and if
11137 // the operator is selected as the best match function by the
11138 // overload resolution mechanism (13.3).
11139 DeclarationName OpName =
11140 Context.DeclarationNames.getCXXOperatorName(OO_Arrow);
11141 OverloadCandidateSet CandidateSet(Loc);
11142 const RecordType *BaseRecord = Base->getType()->getAs<RecordType>();
11144 if (RequireCompleteType(Loc, Base->getType(),
11145 diag::err_typecheck_incomplete_tag, Base))
11146 return ExprError();
11148 LookupResult R(*this, OpName, OpLoc, LookupOrdinaryName);
11149 LookupQualifiedName(R, BaseRecord->getDecl());
11150 R.suppressDiagnostics();
11152 for (LookupResult::iterator Oper = R.begin(), OperEnd = R.end();
11153 Oper != OperEnd; ++Oper) {
11154 AddMethodCandidate(Oper.getPair(), Base->getType(), Base->Classify(Context),
11155 0, 0, CandidateSet, /*SuppressUserConversions=*/false);
11158 bool HadMultipleCandidates = (CandidateSet.size() > 1);
11160 // Perform overload resolution.
11161 OverloadCandidateSet::iterator Best;
11162 switch (CandidateSet.BestViableFunction(*this, OpLoc, Best)) {
11164 // Overload resolution succeeded; we'll build the call below.
11167 case OR_No_Viable_Function:
11168 if (CandidateSet.empty())
11169 Diag(OpLoc, diag::err_typecheck_member_reference_arrow)
11170 << Base->getType() << Base->getSourceRange();
11172 Diag(OpLoc, diag::err_ovl_no_viable_oper)
11173 << "operator->" << Base->getSourceRange();
11174 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Base);
11175 return ExprError();
11178 Diag(OpLoc, diag::err_ovl_ambiguous_oper_unary)
11179 << "->" << Base->getType() << Base->getSourceRange();
11180 CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, Base);
11181 return ExprError();
11184 Diag(OpLoc, diag::err_ovl_deleted_oper)
11185 << Best->Function->isDeleted()
11187 << getDeletedOrUnavailableSuffix(Best->Function)
11188 << Base->getSourceRange();
11189 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Base);
11190 return ExprError();
11193 MarkFunctionReferenced(OpLoc, Best->Function);
11194 CheckMemberOperatorAccess(OpLoc, Base, 0, Best->FoundDecl);
11195 DiagnoseUseOfDecl(Best->FoundDecl, OpLoc);
11197 // Convert the object parameter.
11198 CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
11199 ExprResult BaseResult =
11200 PerformObjectArgumentInitialization(Base, /*Qualifier=*/0,
11201 Best->FoundDecl, Method);
11202 if (BaseResult.isInvalid())
11203 return ExprError();
11204 Base = BaseResult.take();
11206 // Build the operator call.
11207 ExprResult FnExpr = CreateFunctionRefExpr(*this, Method,
11208 HadMultipleCandidates, OpLoc);
11209 if (FnExpr.isInvalid())
11210 return ExprError();
11212 QualType ResultTy = Method->getResultType();
11213 ExprValueKind VK = Expr::getValueKindForType(ResultTy);
11214 ResultTy = ResultTy.getNonLValueExprType(Context);
11215 CXXOperatorCallExpr *TheCall =
11216 new (Context) CXXOperatorCallExpr(Context, OO_Arrow, FnExpr.take(),
11217 Base, ResultTy, VK, OpLoc, false);
11219 if (CheckCallReturnType(Method->getResultType(), OpLoc, TheCall,
11221 return ExprError();
11223 return MaybeBindToTemporary(TheCall);
11226 /// BuildLiteralOperatorCall - Build a UserDefinedLiteral by creating a call to
11227 /// a literal operator described by the provided lookup results.
11228 ExprResult Sema::BuildLiteralOperatorCall(LookupResult &R,
11229 DeclarationNameInfo &SuffixInfo,
11230 ArrayRef<Expr*> Args,
11231 SourceLocation LitEndLoc,
11232 TemplateArgumentListInfo *TemplateArgs) {
11233 SourceLocation UDSuffixLoc = SuffixInfo.getCXXLiteralOperatorNameLoc();
11235 OverloadCandidateSet CandidateSet(UDSuffixLoc);
11236 AddFunctionCandidates(R.asUnresolvedSet(), Args, CandidateSet, true,
11239 bool HadMultipleCandidates = (CandidateSet.size() > 1);
11241 // Perform overload resolution. This will usually be trivial, but might need
11242 // to perform substitutions for a literal operator template.
11243 OverloadCandidateSet::iterator Best;
11244 switch (CandidateSet.BestViableFunction(*this, UDSuffixLoc, Best)) {
11249 case OR_No_Viable_Function:
11250 Diag(UDSuffixLoc, diag::err_ovl_no_viable_function_in_call)
11251 << R.getLookupName();
11252 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args);
11253 return ExprError();
11256 Diag(R.getNameLoc(), diag::err_ovl_ambiguous_call) << R.getLookupName();
11257 CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, Args);
11258 return ExprError();
11261 FunctionDecl *FD = Best->Function;
11262 MarkFunctionReferenced(UDSuffixLoc, FD);
11263 DiagnoseUseOfDecl(Best->FoundDecl, UDSuffixLoc);
11265 ExprResult Fn = CreateFunctionRefExpr(*this, FD, HadMultipleCandidates,
11266 SuffixInfo.getLoc(),
11267 SuffixInfo.getInfo());
11268 if (Fn.isInvalid())
11271 // Check the argument types. This should almost always be a no-op, except
11272 // that array-to-pointer decay is applied to string literals.
11274 for (unsigned ArgIdx = 0; ArgIdx != Args.size(); ++ArgIdx) {
11275 ExprResult InputInit = PerformCopyInitialization(
11276 InitializedEntity::InitializeParameter(Context, FD->getParamDecl(ArgIdx)),
11277 SourceLocation(), Args[ArgIdx]);
11278 if (InputInit.isInvalid())
11280 ConvArgs[ArgIdx] = InputInit.take();
11283 QualType ResultTy = FD->getResultType();
11284 ExprValueKind VK = Expr::getValueKindForType(ResultTy);
11285 ResultTy = ResultTy.getNonLValueExprType(Context);
11287 UserDefinedLiteral *UDL =
11288 new (Context) UserDefinedLiteral(Context, Fn.take(),
11289 llvm::makeArrayRef(ConvArgs, Args.size()),
11290 ResultTy, VK, LitEndLoc, UDSuffixLoc);
11292 if (CheckCallReturnType(FD->getResultType(), UDSuffixLoc, UDL, FD))
11293 return ExprError();
11295 if (CheckFunctionCall(FD, UDL, NULL))
11296 return ExprError();
11298 return MaybeBindToTemporary(UDL);
11301 /// Build a call to 'begin' or 'end' for a C++11 for-range statement. If the
11302 /// given LookupResult is non-empty, it is assumed to describe a member which
11303 /// will be invoked. Otherwise, the function will be found via argument
11304 /// dependent lookup.
11305 /// CallExpr is set to a valid expression and FRS_Success returned on success,
11306 /// otherwise CallExpr is set to ExprError() and some non-success value
11308 Sema::ForRangeStatus
11309 Sema::BuildForRangeBeginEndCall(Scope *S, SourceLocation Loc,
11310 SourceLocation RangeLoc, VarDecl *Decl,
11311 BeginEndFunction BEF,
11312 const DeclarationNameInfo &NameInfo,
11313 LookupResult &MemberLookup,
11314 OverloadCandidateSet *CandidateSet,
11315 Expr *Range, ExprResult *CallExpr) {
11316 CandidateSet->clear();
11317 if (!MemberLookup.empty()) {
11318 ExprResult MemberRef =
11319 BuildMemberReferenceExpr(Range, Range->getType(), Loc,
11320 /*IsPtr=*/false, CXXScopeSpec(),
11321 /*TemplateKWLoc=*/SourceLocation(),
11322 /*FirstQualifierInScope=*/0,
11324 /*TemplateArgs=*/0);
11325 if (MemberRef.isInvalid()) {
11326 *CallExpr = ExprError();
11327 Diag(Range->getLocStart(), diag::note_in_for_range)
11328 << RangeLoc << BEF << Range->getType();
11329 return FRS_DiagnosticIssued;
11331 *CallExpr = ActOnCallExpr(S, MemberRef.get(), Loc, MultiExprArg(), Loc, 0);
11332 if (CallExpr->isInvalid()) {
11333 *CallExpr = ExprError();
11334 Diag(Range->getLocStart(), diag::note_in_for_range)
11335 << RangeLoc << BEF << Range->getType();
11336 return FRS_DiagnosticIssued;
11339 UnresolvedSet<0> FoundNames;
11340 UnresolvedLookupExpr *Fn =
11341 UnresolvedLookupExpr::Create(Context, /*NamingClass=*/0,
11342 NestedNameSpecifierLoc(), NameInfo,
11343 /*NeedsADL=*/true, /*Overloaded=*/false,
11344 FoundNames.begin(), FoundNames.end());
11346 bool CandidateSetError = buildOverloadedCallSet(S, Fn, Fn, &Range, 1, Loc,
11347 CandidateSet, CallExpr);
11348 if (CandidateSet->empty() || CandidateSetError) {
11349 *CallExpr = ExprError();
11350 return FRS_NoViableFunction;
11352 OverloadCandidateSet::iterator Best;
11353 OverloadingResult OverloadResult =
11354 CandidateSet->BestViableFunction(*this, Fn->getLocStart(), Best);
11356 if (OverloadResult == OR_No_Viable_Function) {
11357 *CallExpr = ExprError();
11358 return FRS_NoViableFunction;
11360 *CallExpr = FinishOverloadedCallExpr(*this, S, Fn, Fn, Loc, &Range, 1,
11361 Loc, 0, CandidateSet, &Best,
11363 /*AllowTypoCorrection=*/false);
11364 if (CallExpr->isInvalid() || OverloadResult != OR_Success) {
11365 *CallExpr = ExprError();
11366 Diag(Range->getLocStart(), diag::note_in_for_range)
11367 << RangeLoc << BEF << Range->getType();
11368 return FRS_DiagnosticIssued;
11371 return FRS_Success;
11375 /// FixOverloadedFunctionReference - E is an expression that refers to
11376 /// a C++ overloaded function (possibly with some parentheses and
11377 /// perhaps a '&' around it). We have resolved the overloaded function
11378 /// to the function declaration Fn, so patch up the expression E to
11379 /// refer (possibly indirectly) to Fn. Returns the new expr.
11380 Expr *Sema::FixOverloadedFunctionReference(Expr *E, DeclAccessPair Found,
11381 FunctionDecl *Fn) {
11382 if (ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
11383 Expr *SubExpr = FixOverloadedFunctionReference(PE->getSubExpr(),
11385 if (SubExpr == PE->getSubExpr())
11388 return new (Context) ParenExpr(PE->getLParen(), PE->getRParen(), SubExpr);
11391 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
11392 Expr *SubExpr = FixOverloadedFunctionReference(ICE->getSubExpr(),
11394 assert(Context.hasSameType(ICE->getSubExpr()->getType(),
11395 SubExpr->getType()) &&
11396 "Implicit cast type cannot be determined from overload");
11397 assert(ICE->path_empty() && "fixing up hierarchy conversion?");
11398 if (SubExpr == ICE->getSubExpr())
11401 return ImplicitCastExpr::Create(Context, ICE->getType(),
11402 ICE->getCastKind(),
11404 ICE->getValueKind());
11407 if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(E)) {
11408 assert(UnOp->getOpcode() == UO_AddrOf &&
11409 "Can only take the address of an overloaded function");
11410 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) {
11411 if (Method->isStatic()) {
11412 // Do nothing: static member functions aren't any different
11413 // from non-member functions.
11415 // Fix the sub expression, which really has to be an
11416 // UnresolvedLookupExpr holding an overloaded member function
11418 Expr *SubExpr = FixOverloadedFunctionReference(UnOp->getSubExpr(),
11420 if (SubExpr == UnOp->getSubExpr())
11423 assert(isa<DeclRefExpr>(SubExpr)
11424 && "fixed to something other than a decl ref");
11425 assert(cast<DeclRefExpr>(SubExpr)->getQualifier()
11426 && "fixed to a member ref with no nested name qualifier");
11428 // We have taken the address of a pointer to member
11429 // function. Perform the computation here so that we get the
11430 // appropriate pointer to member type.
11432 = Context.getTypeDeclType(cast<RecordDecl>(Method->getDeclContext()));
11433 QualType MemPtrType
11434 = Context.getMemberPointerType(Fn->getType(), ClassType.getTypePtr());
11436 return new (Context) UnaryOperator(SubExpr, UO_AddrOf, MemPtrType,
11437 VK_RValue, OK_Ordinary,
11438 UnOp->getOperatorLoc());
11441 Expr *SubExpr = FixOverloadedFunctionReference(UnOp->getSubExpr(),
11443 if (SubExpr == UnOp->getSubExpr())
11446 return new (Context) UnaryOperator(SubExpr, UO_AddrOf,
11447 Context.getPointerType(SubExpr->getType()),
11448 VK_RValue, OK_Ordinary,
11449 UnOp->getOperatorLoc());
11452 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
11453 // FIXME: avoid copy.
11454 TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = 0;
11455 if (ULE->hasExplicitTemplateArgs()) {
11456 ULE->copyTemplateArgumentsInto(TemplateArgsBuffer);
11457 TemplateArgs = &TemplateArgsBuffer;
11460 DeclRefExpr *DRE = DeclRefExpr::Create(Context,
11461 ULE->getQualifierLoc(),
11462 ULE->getTemplateKeywordLoc(),
11464 /*enclosing*/ false, // FIXME?
11470 MarkDeclRefReferenced(DRE);
11471 DRE->setHadMultipleCandidates(ULE->getNumDecls() > 1);
11475 if (UnresolvedMemberExpr *MemExpr = dyn_cast<UnresolvedMemberExpr>(E)) {
11476 // FIXME: avoid copy.
11477 TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = 0;
11478 if (MemExpr->hasExplicitTemplateArgs()) {
11479 MemExpr->copyTemplateArgumentsInto(TemplateArgsBuffer);
11480 TemplateArgs = &TemplateArgsBuffer;
11485 // If we're filling in a static method where we used to have an
11486 // implicit member access, rewrite to a simple decl ref.
11487 if (MemExpr->isImplicitAccess()) {
11488 if (cast<CXXMethodDecl>(Fn)->isStatic()) {
11489 DeclRefExpr *DRE = DeclRefExpr::Create(Context,
11490 MemExpr->getQualifierLoc(),
11491 MemExpr->getTemplateKeywordLoc(),
11493 /*enclosing*/ false,
11494 MemExpr->getMemberLoc(),
11499 MarkDeclRefReferenced(DRE);
11500 DRE->setHadMultipleCandidates(MemExpr->getNumDecls() > 1);
11503 SourceLocation Loc = MemExpr->getMemberLoc();
11504 if (MemExpr->getQualifier())
11505 Loc = MemExpr->getQualifierLoc().getBeginLoc();
11506 CheckCXXThisCapture(Loc);
11507 Base = new (Context) CXXThisExpr(Loc,
11508 MemExpr->getBaseType(),
11509 /*isImplicit=*/true);
11512 Base = MemExpr->getBase();
11514 ExprValueKind valueKind;
11516 if (cast<CXXMethodDecl>(Fn)->isStatic()) {
11517 valueKind = VK_LValue;
11518 type = Fn->getType();
11520 valueKind = VK_RValue;
11521 type = Context.BoundMemberTy;
11524 MemberExpr *ME = MemberExpr::Create(Context, Base,
11525 MemExpr->isArrow(),
11526 MemExpr->getQualifierLoc(),
11527 MemExpr->getTemplateKeywordLoc(),
11530 MemExpr->getMemberNameInfo(),
11532 type, valueKind, OK_Ordinary);
11533 ME->setHadMultipleCandidates(true);
11534 MarkMemberReferenced(ME);
11538 llvm_unreachable("Invalid reference to overloaded function");
11541 ExprResult Sema::FixOverloadedFunctionReference(ExprResult E,
11542 DeclAccessPair Found,
11543 FunctionDecl *Fn) {
11544 return Owned(FixOverloadedFunctionReference((Expr *)E.get(), Found, Fn));
11547 } // end namespace clang