1 //===--- SemaOverload.cpp - C++ Overloading -------------------------------===//
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/Overload.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/CXXInheritance.h"
17 #include "clang/AST/DeclObjC.h"
18 #include "clang/AST/Expr.h"
19 #include "clang/AST/ExprCXX.h"
20 #include "clang/AST/ExprObjC.h"
21 #include "clang/AST/TypeOrdering.h"
22 #include "clang/Basic/Diagnostic.h"
23 #include "clang/Basic/PartialDiagnostic.h"
24 #include "clang/Basic/TargetInfo.h"
25 #include "clang/Lex/Preprocessor.h"
26 #include "clang/Sema/Initialization.h"
27 #include "clang/Sema/Lookup.h"
28 #include "clang/Sema/SemaInternal.h"
29 #include "clang/Sema/Template.h"
30 #include "clang/Sema/TemplateDeduction.h"
31 #include "llvm/ADT/DenseSet.h"
32 #include "llvm/ADT/STLExtras.h"
33 #include "llvm/ADT/SmallPtrSet.h"
34 #include "llvm/ADT/SmallString.h"
40 /// A convenience routine for creating a decayed reference to a function.
42 CreateFunctionRefExpr(Sema &S, FunctionDecl *Fn, NamedDecl *FoundDecl,
43 bool HadMultipleCandidates,
44 SourceLocation Loc = SourceLocation(),
45 const DeclarationNameLoc &LocInfo = DeclarationNameLoc()){
46 if (S.DiagnoseUseOfDecl(FoundDecl, Loc))
48 // If FoundDecl is different from Fn (such as if one is a template
49 // and the other a specialization), make sure DiagnoseUseOfDecl is
51 // FIXME: This would be more comprehensively addressed by modifying
52 // DiagnoseUseOfDecl to accept both the FoundDecl and the decl
54 if (FoundDecl != Fn && S.DiagnoseUseOfDecl(Fn, Loc))
56 DeclRefExpr *DRE = new (S.Context) DeclRefExpr(Fn, false, Fn->getType(),
57 VK_LValue, Loc, LocInfo);
58 if (HadMultipleCandidates)
59 DRE->setHadMultipleCandidates(true);
61 S.MarkDeclRefReferenced(DRE);
63 ExprResult E = S.Owned(DRE);
64 E = S.DefaultFunctionArrayConversion(E.take());
70 static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
71 bool InOverloadResolution,
72 StandardConversionSequence &SCS,
74 bool AllowObjCWritebackConversion);
76 static bool IsTransparentUnionStandardConversion(Sema &S, Expr* From,
78 bool InOverloadResolution,
79 StandardConversionSequence &SCS,
81 static OverloadingResult
82 IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
83 UserDefinedConversionSequence& User,
84 OverloadCandidateSet& Conversions,
86 bool AllowObjCConversionOnExplicit);
89 static ImplicitConversionSequence::CompareKind
90 CompareStandardConversionSequences(Sema &S,
91 const StandardConversionSequence& SCS1,
92 const StandardConversionSequence& SCS2);
94 static ImplicitConversionSequence::CompareKind
95 CompareQualificationConversions(Sema &S,
96 const StandardConversionSequence& SCS1,
97 const StandardConversionSequence& SCS2);
99 static ImplicitConversionSequence::CompareKind
100 CompareDerivedToBaseConversions(Sema &S,
101 const StandardConversionSequence& SCS1,
102 const StandardConversionSequence& SCS2);
106 /// GetConversionCategory - Retrieve the implicit conversion
107 /// category corresponding to the given implicit conversion kind.
108 ImplicitConversionCategory
109 GetConversionCategory(ImplicitConversionKind Kind) {
110 static const ImplicitConversionCategory
111 Category[(int)ICK_Num_Conversion_Kinds] = {
113 ICC_Lvalue_Transformation,
114 ICC_Lvalue_Transformation,
115 ICC_Lvalue_Transformation,
117 ICC_Qualification_Adjustment,
135 return Category[(int)Kind];
138 /// GetConversionRank - Retrieve the implicit conversion rank
139 /// corresponding to the given implicit conversion kind.
140 ImplicitConversionRank GetConversionRank(ImplicitConversionKind Kind) {
141 static const ImplicitConversionRank
142 Rank[(int)ICK_Num_Conversion_Kinds] = {
163 ICR_Complex_Real_Conversion,
166 ICR_Writeback_Conversion
168 return Rank[(int)Kind];
171 /// GetImplicitConversionName - Return the name of this kind of
172 /// implicit conversion.
173 const char* GetImplicitConversionName(ImplicitConversionKind Kind) {
174 static const char* const Name[(int)ICK_Num_Conversion_Kinds] = {
178 "Function-to-pointer",
179 "Noreturn adjustment",
181 "Integral promotion",
182 "Floating point promotion",
184 "Integral conversion",
185 "Floating conversion",
186 "Complex conversion",
187 "Floating-integral conversion",
188 "Pointer conversion",
189 "Pointer-to-member conversion",
190 "Boolean conversion",
191 "Compatible-types conversion",
192 "Derived-to-base conversion",
195 "Complex-real conversion",
196 "Block Pointer conversion",
197 "Transparent Union Conversion"
198 "Writeback conversion"
203 /// StandardConversionSequence - Set the standard conversion
204 /// sequence to the identity conversion.
205 void StandardConversionSequence::setAsIdentityConversion() {
206 First = ICK_Identity;
207 Second = ICK_Identity;
208 Third = ICK_Identity;
209 DeprecatedStringLiteralToCharPtr = false;
210 QualificationIncludesObjCLifetime = false;
211 ReferenceBinding = false;
212 DirectBinding = false;
213 IsLvalueReference = true;
214 BindsToFunctionLvalue = false;
215 BindsToRvalue = false;
216 BindsImplicitObjectArgumentWithoutRefQualifier = false;
217 ObjCLifetimeConversionBinding = false;
221 /// getRank - Retrieve the rank of this standard conversion sequence
222 /// (C++ 13.3.3.1.1p3). The rank is the largest rank of each of the
223 /// implicit conversions.
224 ImplicitConversionRank StandardConversionSequence::getRank() const {
225 ImplicitConversionRank Rank = ICR_Exact_Match;
226 if (GetConversionRank(First) > Rank)
227 Rank = GetConversionRank(First);
228 if (GetConversionRank(Second) > Rank)
229 Rank = GetConversionRank(Second);
230 if (GetConversionRank(Third) > Rank)
231 Rank = GetConversionRank(Third);
235 /// isPointerConversionToBool - Determines whether this conversion is
236 /// a conversion of a pointer or pointer-to-member to bool. This is
237 /// used as part of the ranking of standard conversion sequences
238 /// (C++ 13.3.3.2p4).
239 bool StandardConversionSequence::isPointerConversionToBool() const {
240 // Note that FromType has not necessarily been transformed by the
241 // array-to-pointer or function-to-pointer implicit conversions, so
242 // check for their presence as well as checking whether FromType is
244 if (getToType(1)->isBooleanType() &&
245 (getFromType()->isPointerType() ||
246 getFromType()->isObjCObjectPointerType() ||
247 getFromType()->isBlockPointerType() ||
248 getFromType()->isNullPtrType() ||
249 First == ICK_Array_To_Pointer || First == ICK_Function_To_Pointer))
255 /// isPointerConversionToVoidPointer - Determines whether this
256 /// conversion is a conversion of a pointer to a void pointer. This is
257 /// used as part of the ranking of standard conversion sequences (C++
260 StandardConversionSequence::
261 isPointerConversionToVoidPointer(ASTContext& Context) const {
262 QualType FromType = getFromType();
263 QualType ToType = getToType(1);
265 // Note that FromType has not necessarily been transformed by the
266 // array-to-pointer implicit conversion, so check for its presence
267 // and redo the conversion to get a pointer.
268 if (First == ICK_Array_To_Pointer)
269 FromType = Context.getArrayDecayedType(FromType);
271 if (Second == ICK_Pointer_Conversion && FromType->isAnyPointerType())
272 if (const PointerType* ToPtrType = ToType->getAs<PointerType>())
273 return ToPtrType->getPointeeType()->isVoidType();
278 /// Skip any implicit casts which could be either part of a narrowing conversion
279 /// or after one in an implicit conversion.
280 static const Expr *IgnoreNarrowingConversion(const Expr *Converted) {
281 while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Converted)) {
282 switch (ICE->getCastKind()) {
284 case CK_IntegralCast:
285 case CK_IntegralToBoolean:
286 case CK_IntegralToFloating:
287 case CK_FloatingToIntegral:
288 case CK_FloatingToBoolean:
289 case CK_FloatingCast:
290 Converted = ICE->getSubExpr();
301 /// Check if this standard conversion sequence represents a narrowing
302 /// conversion, according to C++11 [dcl.init.list]p7.
304 /// \param Ctx The AST context.
305 /// \param Converted The result of applying this standard conversion sequence.
306 /// \param ConstantValue If this is an NK_Constant_Narrowing conversion, the
307 /// value of the expression prior to the narrowing conversion.
308 /// \param ConstantType If this is an NK_Constant_Narrowing conversion, the
309 /// type of the expression prior to the narrowing conversion.
311 StandardConversionSequence::getNarrowingKind(ASTContext &Ctx,
312 const Expr *Converted,
313 APValue &ConstantValue,
314 QualType &ConstantType) const {
315 assert(Ctx.getLangOpts().CPlusPlus && "narrowing check outside C++");
317 // C++11 [dcl.init.list]p7:
318 // A narrowing conversion is an implicit conversion ...
319 QualType FromType = getToType(0);
320 QualType ToType = getToType(1);
322 // -- from a floating-point type to an integer type, or
324 // -- from an integer type or unscoped enumeration type to a floating-point
325 // type, except where the source is a constant expression and the actual
326 // value after conversion will fit into the target type and will produce
327 // the original value when converted back to the original type, or
328 case ICK_Floating_Integral:
329 if (FromType->isRealFloatingType() && ToType->isIntegralType(Ctx)) {
330 return NK_Type_Narrowing;
331 } else if (FromType->isIntegralType(Ctx) && ToType->isRealFloatingType()) {
332 llvm::APSInt IntConstantValue;
333 const Expr *Initializer = IgnoreNarrowingConversion(Converted);
335 Initializer->isIntegerConstantExpr(IntConstantValue, Ctx)) {
336 // Convert the integer to the floating type.
337 llvm::APFloat Result(Ctx.getFloatTypeSemantics(ToType));
338 Result.convertFromAPInt(IntConstantValue, IntConstantValue.isSigned(),
339 llvm::APFloat::rmNearestTiesToEven);
341 llvm::APSInt ConvertedValue = IntConstantValue;
343 Result.convertToInteger(ConvertedValue,
344 llvm::APFloat::rmTowardZero, &ignored);
345 // If the resulting value is different, this was a narrowing conversion.
346 if (IntConstantValue != ConvertedValue) {
347 ConstantValue = APValue(IntConstantValue);
348 ConstantType = Initializer->getType();
349 return NK_Constant_Narrowing;
352 // Variables are always narrowings.
353 return NK_Variable_Narrowing;
356 return NK_Not_Narrowing;
358 // -- from long double to double or float, or from double to float, except
359 // where the source is a constant expression and the actual value after
360 // conversion is within the range of values that can be represented (even
361 // if it cannot be represented exactly), or
362 case ICK_Floating_Conversion:
363 if (FromType->isRealFloatingType() && ToType->isRealFloatingType() &&
364 Ctx.getFloatingTypeOrder(FromType, ToType) == 1) {
365 // FromType is larger than ToType.
366 const Expr *Initializer = IgnoreNarrowingConversion(Converted);
367 if (Initializer->isCXX11ConstantExpr(Ctx, &ConstantValue)) {
369 assert(ConstantValue.isFloat());
370 llvm::APFloat FloatVal = ConstantValue.getFloat();
371 // Convert the source value into the target type.
373 llvm::APFloat::opStatus ConvertStatus = FloatVal.convert(
374 Ctx.getFloatTypeSemantics(ToType),
375 llvm::APFloat::rmNearestTiesToEven, &ignored);
376 // If there was no overflow, the source value is within the range of
377 // values that can be represented.
378 if (ConvertStatus & llvm::APFloat::opOverflow) {
379 ConstantType = Initializer->getType();
380 return NK_Constant_Narrowing;
383 return NK_Variable_Narrowing;
386 return NK_Not_Narrowing;
388 // -- from an integer type or unscoped enumeration type to an integer type
389 // that cannot represent all the values of the original type, except where
390 // the source is a constant expression and the actual value after
391 // conversion will fit into the target type and will produce the original
392 // value when converted back to the original type.
393 case ICK_Boolean_Conversion: // Bools are integers too.
394 if (!FromType->isIntegralOrUnscopedEnumerationType()) {
395 // Boolean conversions can be from pointers and pointers to members
396 // [conv.bool], and those aren't considered narrowing conversions.
397 return NK_Not_Narrowing;
398 } // Otherwise, fall through to the integral case.
399 case ICK_Integral_Conversion: {
400 assert(FromType->isIntegralOrUnscopedEnumerationType());
401 assert(ToType->isIntegralOrUnscopedEnumerationType());
402 const bool FromSigned = FromType->isSignedIntegerOrEnumerationType();
403 const unsigned FromWidth = Ctx.getIntWidth(FromType);
404 const bool ToSigned = ToType->isSignedIntegerOrEnumerationType();
405 const unsigned ToWidth = Ctx.getIntWidth(ToType);
407 if (FromWidth > ToWidth ||
408 (FromWidth == ToWidth && FromSigned != ToSigned) ||
409 (FromSigned && !ToSigned)) {
410 // Not all values of FromType can be represented in ToType.
411 llvm::APSInt InitializerValue;
412 const Expr *Initializer = IgnoreNarrowingConversion(Converted);
413 if (!Initializer->isIntegerConstantExpr(InitializerValue, Ctx)) {
414 // Such conversions on variables are always narrowing.
415 return NK_Variable_Narrowing;
417 bool Narrowing = false;
418 if (FromWidth < ToWidth) {
419 // Negative -> unsigned is narrowing. Otherwise, more bits is never
421 if (InitializerValue.isSigned() && InitializerValue.isNegative())
424 // Add a bit to the InitializerValue so we don't have to worry about
425 // signed vs. unsigned comparisons.
426 InitializerValue = InitializerValue.extend(
427 InitializerValue.getBitWidth() + 1);
428 // Convert the initializer to and from the target width and signed-ness.
429 llvm::APSInt ConvertedValue = InitializerValue;
430 ConvertedValue = ConvertedValue.trunc(ToWidth);
431 ConvertedValue.setIsSigned(ToSigned);
432 ConvertedValue = ConvertedValue.extend(InitializerValue.getBitWidth());
433 ConvertedValue.setIsSigned(InitializerValue.isSigned());
434 // If the result is different, this was a narrowing conversion.
435 if (ConvertedValue != InitializerValue)
439 ConstantType = Initializer->getType();
440 ConstantValue = APValue(InitializerValue);
441 return NK_Constant_Narrowing;
444 return NK_Not_Narrowing;
448 // Other kinds of conversions are not narrowings.
449 return NK_Not_Narrowing;
453 /// dump - Print this standard conversion sequence to standard
454 /// error. Useful for debugging overloading issues.
455 void StandardConversionSequence::dump() const {
456 raw_ostream &OS = llvm::errs();
457 bool PrintedSomething = false;
458 if (First != ICK_Identity) {
459 OS << GetImplicitConversionName(First);
460 PrintedSomething = true;
463 if (Second != ICK_Identity) {
464 if (PrintedSomething) {
467 OS << GetImplicitConversionName(Second);
469 if (CopyConstructor) {
470 OS << " (by copy constructor)";
471 } else if (DirectBinding) {
472 OS << " (direct reference binding)";
473 } else if (ReferenceBinding) {
474 OS << " (reference binding)";
476 PrintedSomething = true;
479 if (Third != ICK_Identity) {
480 if (PrintedSomething) {
483 OS << GetImplicitConversionName(Third);
484 PrintedSomething = true;
487 if (!PrintedSomething) {
488 OS << "No conversions required";
492 /// dump - Print this user-defined conversion sequence to standard
493 /// error. Useful for debugging overloading issues.
494 void UserDefinedConversionSequence::dump() const {
495 raw_ostream &OS = llvm::errs();
496 if (Before.First || Before.Second || Before.Third) {
500 if (ConversionFunction)
501 OS << '\'' << *ConversionFunction << '\'';
503 OS << "aggregate initialization";
504 if (After.First || After.Second || After.Third) {
510 /// dump - Print this implicit conversion sequence to standard
511 /// error. Useful for debugging overloading issues.
512 void ImplicitConversionSequence::dump() const {
513 raw_ostream &OS = llvm::errs();
514 if (isStdInitializerListElement())
515 OS << "Worst std::initializer_list element conversion: ";
516 switch (ConversionKind) {
517 case StandardConversion:
518 OS << "Standard conversion: ";
521 case UserDefinedConversion:
522 OS << "User-defined conversion: ";
525 case EllipsisConversion:
526 OS << "Ellipsis conversion";
528 case AmbiguousConversion:
529 OS << "Ambiguous conversion";
532 OS << "Bad conversion";
539 void AmbiguousConversionSequence::construct() {
540 new (&conversions()) ConversionSet();
543 void AmbiguousConversionSequence::destruct() {
544 conversions().~ConversionSet();
548 AmbiguousConversionSequence::copyFrom(const AmbiguousConversionSequence &O) {
549 FromTypePtr = O.FromTypePtr;
550 ToTypePtr = O.ToTypePtr;
551 new (&conversions()) ConversionSet(O.conversions());
555 // Structure used by DeductionFailureInfo to store
556 // template argument information.
557 struct DFIArguments {
558 TemplateArgument FirstArg;
559 TemplateArgument SecondArg;
561 // Structure used by DeductionFailureInfo to store
562 // template parameter and template argument information.
563 struct DFIParamWithArguments : DFIArguments {
564 TemplateParameter Param;
568 /// \brief Convert from Sema's representation of template deduction information
569 /// to the form used in overload-candidate information.
570 DeductionFailureInfo MakeDeductionFailureInfo(ASTContext &Context,
571 Sema::TemplateDeductionResult TDK,
572 TemplateDeductionInfo &Info) {
573 DeductionFailureInfo Result;
574 Result.Result = static_cast<unsigned>(TDK);
575 Result.HasDiagnostic = false;
578 case Sema::TDK_Success:
579 case Sema::TDK_Invalid:
580 case Sema::TDK_InstantiationDepth:
581 case Sema::TDK_TooManyArguments:
582 case Sema::TDK_TooFewArguments:
585 case Sema::TDK_Incomplete:
586 case Sema::TDK_InvalidExplicitArguments:
587 Result.Data = Info.Param.getOpaqueValue();
590 case Sema::TDK_NonDeducedMismatch: {
591 // FIXME: Should allocate from normal heap so that we can free this later.
592 DFIArguments *Saved = new (Context) DFIArguments;
593 Saved->FirstArg = Info.FirstArg;
594 Saved->SecondArg = Info.SecondArg;
599 case Sema::TDK_Inconsistent:
600 case Sema::TDK_Underqualified: {
601 // FIXME: Should allocate from normal heap so that we can free this later.
602 DFIParamWithArguments *Saved = new (Context) DFIParamWithArguments;
603 Saved->Param = Info.Param;
604 Saved->FirstArg = Info.FirstArg;
605 Saved->SecondArg = Info.SecondArg;
610 case Sema::TDK_SubstitutionFailure:
611 Result.Data = Info.take();
612 if (Info.hasSFINAEDiagnostic()) {
613 PartialDiagnosticAt *Diag = new (Result.Diagnostic) PartialDiagnosticAt(
614 SourceLocation(), PartialDiagnostic::NullDiagnostic());
615 Info.takeSFINAEDiagnostic(*Diag);
616 Result.HasDiagnostic = true;
620 case Sema::TDK_FailedOverloadResolution:
621 Result.Data = Info.Expression;
624 case Sema::TDK_MiscellaneousDeductionFailure:
631 void DeductionFailureInfo::Destroy() {
632 switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
633 case Sema::TDK_Success:
634 case Sema::TDK_Invalid:
635 case Sema::TDK_InstantiationDepth:
636 case Sema::TDK_Incomplete:
637 case Sema::TDK_TooManyArguments:
638 case Sema::TDK_TooFewArguments:
639 case Sema::TDK_InvalidExplicitArguments:
640 case Sema::TDK_FailedOverloadResolution:
643 case Sema::TDK_Inconsistent:
644 case Sema::TDK_Underqualified:
645 case Sema::TDK_NonDeducedMismatch:
646 // FIXME: Destroy the data?
650 case Sema::TDK_SubstitutionFailure:
651 // FIXME: Destroy the template argument list?
653 if (PartialDiagnosticAt *Diag = getSFINAEDiagnostic()) {
654 Diag->~PartialDiagnosticAt();
655 HasDiagnostic = false;
660 case Sema::TDK_MiscellaneousDeductionFailure:
665 PartialDiagnosticAt *DeductionFailureInfo::getSFINAEDiagnostic() {
667 return static_cast<PartialDiagnosticAt*>(static_cast<void*>(Diagnostic));
671 TemplateParameter DeductionFailureInfo::getTemplateParameter() {
672 switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
673 case Sema::TDK_Success:
674 case Sema::TDK_Invalid:
675 case Sema::TDK_InstantiationDepth:
676 case Sema::TDK_TooManyArguments:
677 case Sema::TDK_TooFewArguments:
678 case Sema::TDK_SubstitutionFailure:
679 case Sema::TDK_NonDeducedMismatch:
680 case Sema::TDK_FailedOverloadResolution:
681 return TemplateParameter();
683 case Sema::TDK_Incomplete:
684 case Sema::TDK_InvalidExplicitArguments:
685 return TemplateParameter::getFromOpaqueValue(Data);
687 case Sema::TDK_Inconsistent:
688 case Sema::TDK_Underqualified:
689 return static_cast<DFIParamWithArguments*>(Data)->Param;
692 case Sema::TDK_MiscellaneousDeductionFailure:
696 return TemplateParameter();
699 TemplateArgumentList *DeductionFailureInfo::getTemplateArgumentList() {
700 switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
701 case Sema::TDK_Success:
702 case Sema::TDK_Invalid:
703 case Sema::TDK_InstantiationDepth:
704 case Sema::TDK_TooManyArguments:
705 case Sema::TDK_TooFewArguments:
706 case Sema::TDK_Incomplete:
707 case Sema::TDK_InvalidExplicitArguments:
708 case Sema::TDK_Inconsistent:
709 case Sema::TDK_Underqualified:
710 case Sema::TDK_NonDeducedMismatch:
711 case Sema::TDK_FailedOverloadResolution:
714 case Sema::TDK_SubstitutionFailure:
715 return static_cast<TemplateArgumentList*>(Data);
718 case Sema::TDK_MiscellaneousDeductionFailure:
725 const TemplateArgument *DeductionFailureInfo::getFirstArg() {
726 switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
727 case Sema::TDK_Success:
728 case Sema::TDK_Invalid:
729 case Sema::TDK_InstantiationDepth:
730 case Sema::TDK_Incomplete:
731 case Sema::TDK_TooManyArguments:
732 case Sema::TDK_TooFewArguments:
733 case Sema::TDK_InvalidExplicitArguments:
734 case Sema::TDK_SubstitutionFailure:
735 case Sema::TDK_FailedOverloadResolution:
738 case Sema::TDK_Inconsistent:
739 case Sema::TDK_Underqualified:
740 case Sema::TDK_NonDeducedMismatch:
741 return &static_cast<DFIArguments*>(Data)->FirstArg;
744 case Sema::TDK_MiscellaneousDeductionFailure:
751 const TemplateArgument *DeductionFailureInfo::getSecondArg() {
752 switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
753 case Sema::TDK_Success:
754 case Sema::TDK_Invalid:
755 case Sema::TDK_InstantiationDepth:
756 case Sema::TDK_Incomplete:
757 case Sema::TDK_TooManyArguments:
758 case Sema::TDK_TooFewArguments:
759 case Sema::TDK_InvalidExplicitArguments:
760 case Sema::TDK_SubstitutionFailure:
761 case Sema::TDK_FailedOverloadResolution:
764 case Sema::TDK_Inconsistent:
765 case Sema::TDK_Underqualified:
766 case Sema::TDK_NonDeducedMismatch:
767 return &static_cast<DFIArguments*>(Data)->SecondArg;
770 case Sema::TDK_MiscellaneousDeductionFailure:
777 Expr *DeductionFailureInfo::getExpr() {
778 if (static_cast<Sema::TemplateDeductionResult>(Result) ==
779 Sema::TDK_FailedOverloadResolution)
780 return static_cast<Expr*>(Data);
785 void OverloadCandidateSet::destroyCandidates() {
786 for (iterator i = begin(), e = end(); i != e; ++i) {
787 for (unsigned ii = 0, ie = i->NumConversions; ii != ie; ++ii)
788 i->Conversions[ii].~ImplicitConversionSequence();
789 if (!i->Viable && i->FailureKind == ovl_fail_bad_deduction)
790 i->DeductionFailure.Destroy();
794 void OverloadCandidateSet::clear() {
796 NumInlineSequences = 0;
802 class UnbridgedCastsSet {
807 SmallVector<Entry, 2> Entries;
810 void save(Sema &S, Expr *&E) {
811 assert(E->hasPlaceholderType(BuiltinType::ARCUnbridgedCast));
812 Entry entry = { &E, E };
813 Entries.push_back(entry);
814 E = S.stripARCUnbridgedCast(E);
818 for (SmallVectorImpl<Entry>::iterator
819 i = Entries.begin(), e = Entries.end(); i != e; ++i)
825 /// checkPlaceholderForOverload - Do any interesting placeholder-like
826 /// preprocessing on the given expression.
828 /// \param unbridgedCasts a collection to which to add unbridged casts;
829 /// without this, they will be immediately diagnosed as errors
831 /// Return true on unrecoverable error.
832 static bool checkPlaceholderForOverload(Sema &S, Expr *&E,
833 UnbridgedCastsSet *unbridgedCasts = 0) {
834 if (const BuiltinType *placeholder = E->getType()->getAsPlaceholderType()) {
835 // We can't handle overloaded expressions here because overload
836 // resolution might reasonably tweak them.
837 if (placeholder->getKind() == BuiltinType::Overload) return false;
839 // If the context potentially accepts unbridged ARC casts, strip
840 // the unbridged cast and add it to the collection for later restoration.
841 if (placeholder->getKind() == BuiltinType::ARCUnbridgedCast &&
843 unbridgedCasts->save(S, E);
847 // Go ahead and check everything else.
848 ExprResult result = S.CheckPlaceholderExpr(E);
849 if (result.isInvalid())
860 /// checkArgPlaceholdersForOverload - Check a set of call operands for
862 static bool checkArgPlaceholdersForOverload(Sema &S,
864 UnbridgedCastsSet &unbridged) {
865 for (unsigned i = 0, e = Args.size(); i != e; ++i)
866 if (checkPlaceholderForOverload(S, Args[i], &unbridged))
872 // IsOverload - Determine whether the given New declaration is an
873 // overload of the declarations in Old. This routine returns false if
874 // New and Old cannot be overloaded, e.g., if New has the same
875 // signature as some function in Old (C++ 1.3.10) or if the Old
876 // declarations aren't functions (or function templates) at all. When
877 // it does return false, MatchedDecl will point to the decl that New
878 // cannot be overloaded with. This decl may be a UsingShadowDecl on
879 // top of the underlying declaration.
881 // Example: Given the following input:
883 // void f(int, float); // #1
884 // void f(int, int); // #2
885 // int f(int, int); // #3
887 // When we process #1, there is no previous declaration of "f",
888 // so IsOverload will not be used.
890 // When we process #2, Old contains only the FunctionDecl for #1. By
891 // comparing the parameter types, we see that #1 and #2 are overloaded
892 // (since they have different signatures), so this routine returns
893 // false; MatchedDecl is unchanged.
895 // When we process #3, Old is an overload set containing #1 and #2. We
896 // compare the signatures of #3 to #1 (they're overloaded, so we do
897 // nothing) and then #3 to #2. Since the signatures of #3 and #2 are
898 // identical (return types of functions are not part of the
899 // signature), IsOverload returns false and MatchedDecl will be set to
900 // point to the FunctionDecl for #2.
902 // 'NewIsUsingShadowDecl' indicates that 'New' is being introduced
903 // into a class by a using declaration. The rules for whether to hide
904 // shadow declarations ignore some properties which otherwise figure
905 // into a function template's signature.
907 Sema::CheckOverload(Scope *S, FunctionDecl *New, const LookupResult &Old,
908 NamedDecl *&Match, bool NewIsUsingDecl) {
909 for (LookupResult::iterator I = Old.begin(), E = Old.end();
911 NamedDecl *OldD = *I;
913 bool OldIsUsingDecl = false;
914 if (isa<UsingShadowDecl>(OldD)) {
915 OldIsUsingDecl = true;
917 // We can always introduce two using declarations into the same
918 // context, even if they have identical signatures.
919 if (NewIsUsingDecl) continue;
921 OldD = cast<UsingShadowDecl>(OldD)->getTargetDecl();
924 // If either declaration was introduced by a using declaration,
925 // we'll need to use slightly different rules for matching.
926 // Essentially, these rules are the normal rules, except that
927 // function templates hide function templates with different
928 // return types or template parameter lists.
929 bool UseMemberUsingDeclRules =
930 (OldIsUsingDecl || NewIsUsingDecl) && CurContext->isRecord() &&
931 !New->getFriendObjectKind();
933 if (FunctionTemplateDecl *OldT = dyn_cast<FunctionTemplateDecl>(OldD)) {
934 if (!IsOverload(New, OldT->getTemplatedDecl(), UseMemberUsingDeclRules)) {
935 if (UseMemberUsingDeclRules && OldIsUsingDecl) {
936 HideUsingShadowDecl(S, cast<UsingShadowDecl>(*I));
943 } else if (FunctionDecl *OldF = dyn_cast<FunctionDecl>(OldD)) {
944 if (!IsOverload(New, OldF, UseMemberUsingDeclRules)) {
945 if (UseMemberUsingDeclRules && OldIsUsingDecl) {
946 HideUsingShadowDecl(S, cast<UsingShadowDecl>(*I));
950 if (!shouldLinkPossiblyHiddenDecl(*I, New))
956 } else if (isa<UsingDecl>(OldD)) {
957 // We can overload with these, which can show up when doing
958 // redeclaration checks for UsingDecls.
959 assert(Old.getLookupKind() == LookupUsingDeclName);
960 } else if (isa<TagDecl>(OldD)) {
961 // We can always overload with tags by hiding them.
962 } else if (isa<UnresolvedUsingValueDecl>(OldD)) {
963 // Optimistically assume that an unresolved using decl will
964 // overload; if it doesn't, we'll have to diagnose during
965 // template instantiation.
968 // Only function declarations can be overloaded; object and type
969 // declarations cannot be overloaded.
971 return Ovl_NonFunction;
978 bool Sema::IsOverload(FunctionDecl *New, FunctionDecl *Old,
979 bool UseUsingDeclRules) {
980 // C++ [basic.start.main]p2: This function shall not be overloaded.
984 // MSVCRT user defined entry points cannot be overloaded.
985 if (New->isMSVCRTEntryPoint())
988 FunctionTemplateDecl *OldTemplate = Old->getDescribedFunctionTemplate();
989 FunctionTemplateDecl *NewTemplate = New->getDescribedFunctionTemplate();
992 // A function template can be overloaded with other function templates
993 // and with normal (non-template) functions.
994 if ((OldTemplate == 0) != (NewTemplate == 0))
997 // Is the function New an overload of the function Old?
998 QualType OldQType = Context.getCanonicalType(Old->getType());
999 QualType NewQType = Context.getCanonicalType(New->getType());
1001 // Compare the signatures (C++ 1.3.10) of the two functions to
1002 // determine whether they are overloads. If we find any mismatch
1003 // in the signature, they are overloads.
1005 // If either of these functions is a K&R-style function (no
1006 // prototype), then we consider them to have matching signatures.
1007 if (isa<FunctionNoProtoType>(OldQType.getTypePtr()) ||
1008 isa<FunctionNoProtoType>(NewQType.getTypePtr()))
1011 const FunctionProtoType* OldType = cast<FunctionProtoType>(OldQType);
1012 const FunctionProtoType* NewType = cast<FunctionProtoType>(NewQType);
1014 // The signature of a function includes the types of its
1015 // parameters (C++ 1.3.10), which includes the presence or absence
1016 // of the ellipsis; see C++ DR 357).
1017 if (OldQType != NewQType &&
1018 (OldType->getNumArgs() != NewType->getNumArgs() ||
1019 OldType->isVariadic() != NewType->isVariadic() ||
1020 !FunctionArgTypesAreEqual(OldType, NewType)))
1023 // C++ [temp.over.link]p4:
1024 // The signature of a function template consists of its function
1025 // signature, its return type and its template parameter list. The names
1026 // of the template parameters are significant only for establishing the
1027 // relationship between the template parameters and the rest of the
1030 // We check the return type and template parameter lists for function
1031 // templates first; the remaining checks follow.
1033 // However, we don't consider either of these when deciding whether
1034 // a member introduced by a shadow declaration is hidden.
1035 if (!UseUsingDeclRules && NewTemplate &&
1036 (!TemplateParameterListsAreEqual(NewTemplate->getTemplateParameters(),
1037 OldTemplate->getTemplateParameters(),
1038 false, TPL_TemplateMatch) ||
1039 OldType->getResultType() != NewType->getResultType()))
1042 // If the function is a class member, its signature includes the
1043 // cv-qualifiers (if any) and ref-qualifier (if any) on the function itself.
1045 // As part of this, also check whether one of the member functions
1046 // is static, in which case they are not overloads (C++
1047 // 13.1p2). While not part of the definition of the signature,
1048 // this check is important to determine whether these functions
1049 // can be overloaded.
1050 CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old);
1051 CXXMethodDecl *NewMethod = dyn_cast<CXXMethodDecl>(New);
1052 if (OldMethod && NewMethod &&
1053 !OldMethod->isStatic() && !NewMethod->isStatic()) {
1054 if (OldMethod->getRefQualifier() != NewMethod->getRefQualifier()) {
1055 if (!UseUsingDeclRules &&
1056 (OldMethod->getRefQualifier() == RQ_None ||
1057 NewMethod->getRefQualifier() == RQ_None)) {
1058 // C++0x [over.load]p2:
1059 // - Member function declarations with the same name and the same
1060 // parameter-type-list as well as member function template
1061 // declarations with the same name, the same parameter-type-list, and
1062 // the same template parameter lists cannot be overloaded if any of
1063 // them, but not all, have a ref-qualifier (8.3.5).
1064 Diag(NewMethod->getLocation(), diag::err_ref_qualifier_overload)
1065 << NewMethod->getRefQualifier() << OldMethod->getRefQualifier();
1066 Diag(OldMethod->getLocation(), diag::note_previous_declaration);
1071 // We may not have applied the implicit const for a constexpr member
1072 // function yet (because we haven't yet resolved whether this is a static
1073 // or non-static member function). Add it now, on the assumption that this
1074 // is a redeclaration of OldMethod.
1075 unsigned OldQuals = OldMethod->getTypeQualifiers();
1076 unsigned NewQuals = NewMethod->getTypeQualifiers();
1077 if (!getLangOpts().CPlusPlus1y && NewMethod->isConstexpr() &&
1078 !isa<CXXConstructorDecl>(NewMethod))
1079 NewQuals |= Qualifiers::Const;
1081 // We do not allow overloading based off of '__restrict'.
1082 OldQuals &= ~Qualifiers::Restrict;
1083 NewQuals &= ~Qualifiers::Restrict;
1084 if (OldQuals != NewQuals)
1088 // The signatures match; this is not an overload.
1092 /// \brief Checks availability of the function depending on the current
1093 /// function context. Inside an unavailable function, unavailability is ignored.
1095 /// \returns true if \arg FD is unavailable and current context is inside
1096 /// an available function, false otherwise.
1097 bool Sema::isFunctionConsideredUnavailable(FunctionDecl *FD) {
1098 return FD->isUnavailable() && !cast<Decl>(CurContext)->isUnavailable();
1101 /// \brief Tries a user-defined conversion from From to ToType.
1103 /// Produces an implicit conversion sequence for when a standard conversion
1104 /// is not an option. See TryImplicitConversion for more information.
1105 static ImplicitConversionSequence
1106 TryUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
1107 bool SuppressUserConversions,
1109 bool InOverloadResolution,
1111 bool AllowObjCWritebackConversion,
1112 bool AllowObjCConversionOnExplicit) {
1113 ImplicitConversionSequence ICS;
1115 if (SuppressUserConversions) {
1116 // We're not in the case above, so there is no conversion that
1118 ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1122 // Attempt user-defined conversion.
1123 OverloadCandidateSet Conversions(From->getExprLoc());
1124 OverloadingResult UserDefResult
1125 = IsUserDefinedConversion(S, From, ToType, ICS.UserDefined, Conversions,
1126 AllowExplicit, AllowObjCConversionOnExplicit);
1128 if (UserDefResult == OR_Success) {
1129 ICS.setUserDefined();
1130 // C++ [over.ics.user]p4:
1131 // A conversion of an expression of class type to the same class
1132 // type is given Exact Match rank, and a conversion of an
1133 // expression of class type to a base class of that type is
1134 // given Conversion rank, in spite of the fact that a copy
1135 // constructor (i.e., a user-defined conversion function) is
1136 // called for those cases.
1137 if (CXXConstructorDecl *Constructor
1138 = dyn_cast<CXXConstructorDecl>(ICS.UserDefined.ConversionFunction)) {
1140 = S.Context.getCanonicalType(From->getType().getUnqualifiedType());
1142 = S.Context.getCanonicalType(ToType).getUnqualifiedType();
1143 if (Constructor->isCopyConstructor() &&
1144 (FromCanon == ToCanon || S.IsDerivedFrom(FromCanon, ToCanon))) {
1145 // Turn this into a "standard" conversion sequence, so that it
1146 // gets ranked with standard conversion sequences.
1148 ICS.Standard.setAsIdentityConversion();
1149 ICS.Standard.setFromType(From->getType());
1150 ICS.Standard.setAllToTypes(ToType);
1151 ICS.Standard.CopyConstructor = Constructor;
1152 if (ToCanon != FromCanon)
1153 ICS.Standard.Second = ICK_Derived_To_Base;
1157 // C++ [over.best.ics]p4:
1158 // However, when considering the argument of a user-defined
1159 // conversion function that is a candidate by 13.3.1.3 when
1160 // invoked for the copying of the temporary in the second step
1161 // of a class copy-initialization, or by 13.3.1.4, 13.3.1.5, or
1162 // 13.3.1.6 in all cases, only standard conversion sequences and
1163 // ellipsis conversion sequences are allowed.
1164 if (SuppressUserConversions && ICS.isUserDefined()) {
1165 ICS.setBad(BadConversionSequence::suppressed_user, From, ToType);
1167 } else if (UserDefResult == OR_Ambiguous && !SuppressUserConversions) {
1169 ICS.Ambiguous.setFromType(From->getType());
1170 ICS.Ambiguous.setToType(ToType);
1171 for (OverloadCandidateSet::iterator Cand = Conversions.begin();
1172 Cand != Conversions.end(); ++Cand)
1174 ICS.Ambiguous.addConversion(Cand->Function);
1176 ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1182 /// TryImplicitConversion - Attempt to perform an implicit conversion
1183 /// from the given expression (Expr) to the given type (ToType). This
1184 /// function returns an implicit conversion sequence that can be used
1185 /// to perform the initialization. Given
1187 /// void f(float f);
1188 /// void g(int i) { f(i); }
1190 /// this routine would produce an implicit conversion sequence to
1191 /// describe the initialization of f from i, which will be a standard
1192 /// conversion sequence containing an lvalue-to-rvalue conversion (C++
1193 /// 4.1) followed by a floating-integral conversion (C++ 4.9).
1195 /// Note that this routine only determines how the conversion can be
1196 /// performed; it does not actually perform the conversion. As such,
1197 /// it will not produce any diagnostics if no conversion is available,
1198 /// but will instead return an implicit conversion sequence of kind
1199 /// "BadConversion".
1201 /// If @p SuppressUserConversions, then user-defined conversions are
1203 /// If @p AllowExplicit, then explicit user-defined conversions are
1206 /// \param AllowObjCWritebackConversion Whether we allow the Objective-C
1207 /// writeback conversion, which allows __autoreleasing id* parameters to
1208 /// be initialized with __strong id* or __weak id* arguments.
1209 static ImplicitConversionSequence
1210 TryImplicitConversion(Sema &S, Expr *From, QualType ToType,
1211 bool SuppressUserConversions,
1213 bool InOverloadResolution,
1215 bool AllowObjCWritebackConversion,
1216 bool AllowObjCConversionOnExplicit) {
1217 ImplicitConversionSequence ICS;
1218 if (IsStandardConversion(S, From, ToType, InOverloadResolution,
1219 ICS.Standard, CStyle, AllowObjCWritebackConversion)){
1224 if (!S.getLangOpts().CPlusPlus) {
1225 ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1229 // C++ [over.ics.user]p4:
1230 // A conversion of an expression of class type to the same class
1231 // type is given Exact Match rank, and a conversion of an
1232 // expression of class type to a base class of that type is
1233 // given Conversion rank, in spite of the fact that a copy/move
1234 // constructor (i.e., a user-defined conversion function) is
1235 // called for those cases.
1236 QualType FromType = From->getType();
1237 if (ToType->getAs<RecordType>() && FromType->getAs<RecordType>() &&
1238 (S.Context.hasSameUnqualifiedType(FromType, ToType) ||
1239 S.IsDerivedFrom(FromType, ToType))) {
1241 ICS.Standard.setAsIdentityConversion();
1242 ICS.Standard.setFromType(FromType);
1243 ICS.Standard.setAllToTypes(ToType);
1245 // We don't actually check at this point whether there is a valid
1246 // copy/move constructor, since overloading just assumes that it
1247 // exists. When we actually perform initialization, we'll find the
1248 // appropriate constructor to copy the returned object, if needed.
1249 ICS.Standard.CopyConstructor = 0;
1251 // Determine whether this is considered a derived-to-base conversion.
1252 if (!S.Context.hasSameUnqualifiedType(FromType, ToType))
1253 ICS.Standard.Second = ICK_Derived_To_Base;
1258 return TryUserDefinedConversion(S, From, ToType, SuppressUserConversions,
1259 AllowExplicit, InOverloadResolution, CStyle,
1260 AllowObjCWritebackConversion,
1261 AllowObjCConversionOnExplicit);
1264 ImplicitConversionSequence
1265 Sema::TryImplicitConversion(Expr *From, QualType ToType,
1266 bool SuppressUserConversions,
1268 bool InOverloadResolution,
1270 bool AllowObjCWritebackConversion) {
1271 return clang::TryImplicitConversion(*this, From, ToType,
1272 SuppressUserConversions, AllowExplicit,
1273 InOverloadResolution, CStyle,
1274 AllowObjCWritebackConversion,
1275 /*AllowObjCConversionOnExplicit=*/false);
1278 /// PerformImplicitConversion - Perform an implicit conversion of the
1279 /// expression From to the type ToType. Returns the
1280 /// converted expression. Flavor is the kind of conversion we're
1281 /// performing, used in the error message. If @p AllowExplicit,
1282 /// explicit user-defined conversions are permitted.
1284 Sema::PerformImplicitConversion(Expr *From, QualType ToType,
1285 AssignmentAction Action, bool AllowExplicit) {
1286 ImplicitConversionSequence ICS;
1287 return PerformImplicitConversion(From, ToType, Action, AllowExplicit, ICS);
1291 Sema::PerformImplicitConversion(Expr *From, QualType ToType,
1292 AssignmentAction Action, bool AllowExplicit,
1293 ImplicitConversionSequence& ICS) {
1294 if (checkPlaceholderForOverload(*this, From))
1297 // Objective-C ARC: Determine whether we will allow the writeback conversion.
1298 bool AllowObjCWritebackConversion
1299 = getLangOpts().ObjCAutoRefCount &&
1300 (Action == AA_Passing || Action == AA_Sending);
1302 ICS = clang::TryImplicitConversion(*this, From, ToType,
1303 /*SuppressUserConversions=*/false,
1305 /*InOverloadResolution=*/false,
1307 AllowObjCWritebackConversion,
1308 /*AllowObjCConversionOnExplicit=*/false);
1309 return PerformImplicitConversion(From, ToType, ICS, Action);
1312 /// \brief Determine whether the conversion from FromType to ToType is a valid
1313 /// conversion that strips "noreturn" off the nested function type.
1314 bool Sema::IsNoReturnConversion(QualType FromType, QualType ToType,
1315 QualType &ResultTy) {
1316 if (Context.hasSameUnqualifiedType(FromType, ToType))
1319 // Permit the conversion F(t __attribute__((noreturn))) -> F(t)
1320 // where F adds one of the following at most once:
1322 // - a member pointer
1323 // - a block pointer
1324 CanQualType CanTo = Context.getCanonicalType(ToType);
1325 CanQualType CanFrom = Context.getCanonicalType(FromType);
1326 Type::TypeClass TyClass = CanTo->getTypeClass();
1327 if (TyClass != CanFrom->getTypeClass()) return false;
1328 if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto) {
1329 if (TyClass == Type::Pointer) {
1330 CanTo = CanTo.getAs<PointerType>()->getPointeeType();
1331 CanFrom = CanFrom.getAs<PointerType>()->getPointeeType();
1332 } else if (TyClass == Type::BlockPointer) {
1333 CanTo = CanTo.getAs<BlockPointerType>()->getPointeeType();
1334 CanFrom = CanFrom.getAs<BlockPointerType>()->getPointeeType();
1335 } else if (TyClass == Type::MemberPointer) {
1336 CanTo = CanTo.getAs<MemberPointerType>()->getPointeeType();
1337 CanFrom = CanFrom.getAs<MemberPointerType>()->getPointeeType();
1342 TyClass = CanTo->getTypeClass();
1343 if (TyClass != CanFrom->getTypeClass()) return false;
1344 if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto)
1348 const FunctionType *FromFn = cast<FunctionType>(CanFrom);
1349 FunctionType::ExtInfo EInfo = FromFn->getExtInfo();
1350 if (!EInfo.getNoReturn()) return false;
1352 FromFn = Context.adjustFunctionType(FromFn, EInfo.withNoReturn(false));
1353 assert(QualType(FromFn, 0).isCanonical());
1354 if (QualType(FromFn, 0) != CanTo) return false;
1360 /// \brief Determine whether the conversion from FromType to ToType is a valid
1361 /// vector conversion.
1363 /// \param ICK Will be set to the vector conversion kind, if this is a vector
1365 static bool IsVectorConversion(ASTContext &Context, QualType FromType,
1366 QualType ToType, ImplicitConversionKind &ICK) {
1367 // We need at least one of these types to be a vector type to have a vector
1369 if (!ToType->isVectorType() && !FromType->isVectorType())
1372 // Identical types require no conversions.
1373 if (Context.hasSameUnqualifiedType(FromType, ToType))
1376 // There are no conversions between extended vector types, only identity.
1377 if (ToType->isExtVectorType()) {
1378 // There are no conversions between extended vector types other than the
1379 // identity conversion.
1380 if (FromType->isExtVectorType())
1383 // Vector splat from any arithmetic type to a vector.
1384 if (FromType->isArithmeticType()) {
1385 ICK = ICK_Vector_Splat;
1390 // We can perform the conversion between vector types in the following cases:
1391 // 1)vector types are equivalent AltiVec and GCC vector types
1392 // 2)lax vector conversions are permitted and the vector types are of the
1394 if (ToType->isVectorType() && FromType->isVectorType()) {
1395 if (Context.areCompatibleVectorTypes(FromType, ToType) ||
1396 (Context.getLangOpts().LaxVectorConversions &&
1397 (Context.getTypeSize(FromType) == Context.getTypeSize(ToType)))) {
1398 ICK = ICK_Vector_Conversion;
1406 static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType,
1407 bool InOverloadResolution,
1408 StandardConversionSequence &SCS,
1411 /// IsStandardConversion - Determines whether there is a standard
1412 /// conversion sequence (C++ [conv], C++ [over.ics.scs]) from the
1413 /// expression From to the type ToType. Standard conversion sequences
1414 /// only consider non-class types; for conversions that involve class
1415 /// types, use TryImplicitConversion. If a conversion exists, SCS will
1416 /// contain the standard conversion sequence required to perform this
1417 /// conversion and this routine will return true. Otherwise, this
1418 /// routine will return false and the value of SCS is unspecified.
1419 static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
1420 bool InOverloadResolution,
1421 StandardConversionSequence &SCS,
1423 bool AllowObjCWritebackConversion) {
1424 QualType FromType = From->getType();
1426 // Standard conversions (C++ [conv])
1427 SCS.setAsIdentityConversion();
1428 SCS.DeprecatedStringLiteralToCharPtr = false;
1429 SCS.IncompatibleObjC = false;
1430 SCS.setFromType(FromType);
1431 SCS.CopyConstructor = 0;
1433 // There are no standard conversions for class types in C++, so
1434 // abort early. When overloading in C, however, we do permit
1435 if (FromType->isRecordType() || ToType->isRecordType()) {
1436 if (S.getLangOpts().CPlusPlus)
1439 // When we're overloading in C, we allow, as standard conversions,
1442 // The first conversion can be an lvalue-to-rvalue conversion,
1443 // array-to-pointer conversion, or function-to-pointer conversion
1446 if (FromType == S.Context.OverloadTy) {
1447 DeclAccessPair AccessPair;
1448 if (FunctionDecl *Fn
1449 = S.ResolveAddressOfOverloadedFunction(From, ToType, false,
1451 // We were able to resolve the address of the overloaded function,
1452 // so we can convert to the type of that function.
1453 FromType = Fn->getType();
1455 // we can sometimes resolve &foo<int> regardless of ToType, so check
1456 // if the type matches (identity) or we are converting to bool
1457 if (!S.Context.hasSameUnqualifiedType(
1458 S.ExtractUnqualifiedFunctionType(ToType), FromType)) {
1460 // if the function type matches except for [[noreturn]], it's ok
1461 if (!S.IsNoReturnConversion(FromType,
1462 S.ExtractUnqualifiedFunctionType(ToType), resultTy))
1463 // otherwise, only a boolean conversion is standard
1464 if (!ToType->isBooleanType())
1468 // Check if the "from" expression is taking the address of an overloaded
1469 // function and recompute the FromType accordingly. Take advantage of the
1470 // fact that non-static member functions *must* have such an address-of
1472 CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn);
1473 if (Method && !Method->isStatic()) {
1474 assert(isa<UnaryOperator>(From->IgnoreParens()) &&
1475 "Non-unary operator on non-static member address");
1476 assert(cast<UnaryOperator>(From->IgnoreParens())->getOpcode()
1478 "Non-address-of operator on non-static member address");
1479 const Type *ClassType
1480 = S.Context.getTypeDeclType(Method->getParent()).getTypePtr();
1481 FromType = S.Context.getMemberPointerType(FromType, ClassType);
1482 } else if (isa<UnaryOperator>(From->IgnoreParens())) {
1483 assert(cast<UnaryOperator>(From->IgnoreParens())->getOpcode() ==
1485 "Non-address-of operator for overloaded function expression");
1486 FromType = S.Context.getPointerType(FromType);
1489 // Check that we've computed the proper type after overload resolution.
1490 assert(S.Context.hasSameType(
1492 S.FixOverloadedFunctionReference(From, AccessPair, Fn)->getType()));
1497 // Lvalue-to-rvalue conversion (C++11 4.1):
1498 // A glvalue (3.10) of a non-function, non-array type T can
1499 // be converted to a prvalue.
1500 bool argIsLValue = From->isGLValue();
1502 !FromType->isFunctionType() && !FromType->isArrayType() &&
1503 S.Context.getCanonicalType(FromType) != S.Context.OverloadTy) {
1504 SCS.First = ICK_Lvalue_To_Rvalue;
1507 // ... if the lvalue has atomic type, the value has the non-atomic version
1508 // of the type of the lvalue ...
1509 if (const AtomicType *Atomic = FromType->getAs<AtomicType>())
1510 FromType = Atomic->getValueType();
1512 // If T is a non-class type, the type of the rvalue is the
1513 // cv-unqualified version of T. Otherwise, the type of the rvalue
1514 // is T (C++ 4.1p1). C++ can't get here with class types; in C, we
1515 // just strip the qualifiers because they don't matter.
1516 FromType = FromType.getUnqualifiedType();
1517 } else if (FromType->isArrayType()) {
1518 // Array-to-pointer conversion (C++ 4.2)
1519 SCS.First = ICK_Array_To_Pointer;
1521 // An lvalue or rvalue of type "array of N T" or "array of unknown
1522 // bound of T" can be converted to an rvalue of type "pointer to
1524 FromType = S.Context.getArrayDecayedType(FromType);
1526 if (S.IsStringLiteralToNonConstPointerConversion(From, ToType)) {
1527 // This conversion is deprecated. (C++ D.4).
1528 SCS.DeprecatedStringLiteralToCharPtr = true;
1530 // For the purpose of ranking in overload resolution
1531 // (13.3.3.1.1), this conversion is considered an
1532 // array-to-pointer conversion followed by a qualification
1533 // conversion (4.4). (C++ 4.2p2)
1534 SCS.Second = ICK_Identity;
1535 SCS.Third = ICK_Qualification;
1536 SCS.QualificationIncludesObjCLifetime = false;
1537 SCS.setAllToTypes(FromType);
1540 } else if (FromType->isFunctionType() && argIsLValue) {
1541 // Function-to-pointer conversion (C++ 4.3).
1542 SCS.First = ICK_Function_To_Pointer;
1544 // An lvalue of function type T can be converted to an rvalue of
1545 // type "pointer to T." The result is a pointer to the
1546 // function. (C++ 4.3p1).
1547 FromType = S.Context.getPointerType(FromType);
1549 // We don't require any conversions for the first step.
1550 SCS.First = ICK_Identity;
1552 SCS.setToType(0, FromType);
1554 // The second conversion can be an integral promotion, floating
1555 // point promotion, integral conversion, floating point conversion,
1556 // floating-integral conversion, pointer conversion,
1557 // pointer-to-member conversion, or boolean conversion (C++ 4p1).
1558 // For overloading in C, this can also be a "compatible-type"
1560 bool IncompatibleObjC = false;
1561 ImplicitConversionKind SecondICK = ICK_Identity;
1562 if (S.Context.hasSameUnqualifiedType(FromType, ToType)) {
1563 // The unqualified versions of the types are the same: there's no
1564 // conversion to do.
1565 SCS.Second = ICK_Identity;
1566 } else if (S.IsIntegralPromotion(From, FromType, ToType)) {
1567 // Integral promotion (C++ 4.5).
1568 SCS.Second = ICK_Integral_Promotion;
1569 FromType = ToType.getUnqualifiedType();
1570 } else if (S.IsFloatingPointPromotion(FromType, ToType)) {
1571 // Floating point promotion (C++ 4.6).
1572 SCS.Second = ICK_Floating_Promotion;
1573 FromType = ToType.getUnqualifiedType();
1574 } else if (S.IsComplexPromotion(FromType, ToType)) {
1575 // Complex promotion (Clang extension)
1576 SCS.Second = ICK_Complex_Promotion;
1577 FromType = ToType.getUnqualifiedType();
1578 } else if (ToType->isBooleanType() &&
1579 (FromType->isArithmeticType() ||
1580 FromType->isAnyPointerType() ||
1581 FromType->isBlockPointerType() ||
1582 FromType->isMemberPointerType() ||
1583 FromType->isNullPtrType())) {
1584 // Boolean conversions (C++ 4.12).
1585 SCS.Second = ICK_Boolean_Conversion;
1586 FromType = S.Context.BoolTy;
1587 } else if (FromType->isIntegralOrUnscopedEnumerationType() &&
1588 ToType->isIntegralType(S.Context)) {
1589 // Integral conversions (C++ 4.7).
1590 SCS.Second = ICK_Integral_Conversion;
1591 FromType = ToType.getUnqualifiedType();
1592 } else if (FromType->isAnyComplexType() && ToType->isAnyComplexType()) {
1593 // Complex conversions (C99 6.3.1.6)
1594 SCS.Second = ICK_Complex_Conversion;
1595 FromType = ToType.getUnqualifiedType();
1596 } else if ((FromType->isAnyComplexType() && ToType->isArithmeticType()) ||
1597 (ToType->isAnyComplexType() && FromType->isArithmeticType())) {
1598 // Complex-real conversions (C99 6.3.1.7)
1599 SCS.Second = ICK_Complex_Real;
1600 FromType = ToType.getUnqualifiedType();
1601 } else if (FromType->isRealFloatingType() && ToType->isRealFloatingType()) {
1602 // Floating point conversions (C++ 4.8).
1603 SCS.Second = ICK_Floating_Conversion;
1604 FromType = ToType.getUnqualifiedType();
1605 } else if ((FromType->isRealFloatingType() &&
1606 ToType->isIntegralType(S.Context)) ||
1607 (FromType->isIntegralOrUnscopedEnumerationType() &&
1608 ToType->isRealFloatingType())) {
1609 // Floating-integral conversions (C++ 4.9).
1610 SCS.Second = ICK_Floating_Integral;
1611 FromType = ToType.getUnqualifiedType();
1612 } else if (S.IsBlockPointerConversion(FromType, ToType, FromType)) {
1613 SCS.Second = ICK_Block_Pointer_Conversion;
1614 } else if (AllowObjCWritebackConversion &&
1615 S.isObjCWritebackConversion(FromType, ToType, FromType)) {
1616 SCS.Second = ICK_Writeback_Conversion;
1617 } else if (S.IsPointerConversion(From, FromType, ToType, InOverloadResolution,
1618 FromType, IncompatibleObjC)) {
1619 // Pointer conversions (C++ 4.10).
1620 SCS.Second = ICK_Pointer_Conversion;
1621 SCS.IncompatibleObjC = IncompatibleObjC;
1622 FromType = FromType.getUnqualifiedType();
1623 } else if (S.IsMemberPointerConversion(From, FromType, ToType,
1624 InOverloadResolution, FromType)) {
1625 // Pointer to member conversions (4.11).
1626 SCS.Second = ICK_Pointer_Member;
1627 } else if (IsVectorConversion(S.Context, FromType, ToType, SecondICK)) {
1628 SCS.Second = SecondICK;
1629 FromType = ToType.getUnqualifiedType();
1630 } else if (!S.getLangOpts().CPlusPlus &&
1631 S.Context.typesAreCompatible(ToType, FromType)) {
1632 // Compatible conversions (Clang extension for C function overloading)
1633 SCS.Second = ICK_Compatible_Conversion;
1634 FromType = ToType.getUnqualifiedType();
1635 } else if (S.IsNoReturnConversion(FromType, ToType, FromType)) {
1636 // Treat a conversion that strips "noreturn" as an identity conversion.
1637 SCS.Second = ICK_NoReturn_Adjustment;
1638 } else if (IsTransparentUnionStandardConversion(S, From, ToType,
1639 InOverloadResolution,
1641 SCS.Second = ICK_TransparentUnionConversion;
1643 } else if (tryAtomicConversion(S, From, ToType, InOverloadResolution, SCS,
1645 // tryAtomicConversion has updated the standard conversion sequence
1648 } else if (ToType->isEventT() &&
1649 From->isIntegerConstantExpr(S.getASTContext()) &&
1650 (From->EvaluateKnownConstInt(S.getASTContext()) == 0)) {
1651 SCS.Second = ICK_Zero_Event_Conversion;
1654 // No second conversion required.
1655 SCS.Second = ICK_Identity;
1657 SCS.setToType(1, FromType);
1661 // The third conversion can be a qualification conversion (C++ 4p1).
1662 bool ObjCLifetimeConversion;
1663 if (S.IsQualificationConversion(FromType, ToType, CStyle,
1664 ObjCLifetimeConversion)) {
1665 SCS.Third = ICK_Qualification;
1666 SCS.QualificationIncludesObjCLifetime = ObjCLifetimeConversion;
1668 CanonFrom = S.Context.getCanonicalType(FromType);
1669 CanonTo = S.Context.getCanonicalType(ToType);
1671 // No conversion required
1672 SCS.Third = ICK_Identity;
1674 // C++ [over.best.ics]p6:
1675 // [...] Any difference in top-level cv-qualification is
1676 // subsumed by the initialization itself and does not constitute
1677 // a conversion. [...]
1678 CanonFrom = S.Context.getCanonicalType(FromType);
1679 CanonTo = S.Context.getCanonicalType(ToType);
1680 if (CanonFrom.getLocalUnqualifiedType()
1681 == CanonTo.getLocalUnqualifiedType() &&
1682 CanonFrom.getLocalQualifiers() != CanonTo.getLocalQualifiers()) {
1684 CanonFrom = CanonTo;
1687 SCS.setToType(2, FromType);
1689 // If we have not converted the argument type to the parameter type,
1690 // this is a bad conversion sequence.
1691 if (CanonFrom != CanonTo)
1698 IsTransparentUnionStandardConversion(Sema &S, Expr* From,
1700 bool InOverloadResolution,
1701 StandardConversionSequence &SCS,
1704 const RecordType *UT = ToType->getAsUnionType();
1705 if (!UT || !UT->getDecl()->hasAttr<TransparentUnionAttr>())
1707 // The field to initialize within the transparent union.
1708 RecordDecl *UD = UT->getDecl();
1709 // It's compatible if the expression matches any of the fields.
1710 for (RecordDecl::field_iterator it = UD->field_begin(),
1711 itend = UD->field_end();
1712 it != itend; ++it) {
1713 if (IsStandardConversion(S, From, it->getType(), InOverloadResolution, SCS,
1714 CStyle, /*ObjCWritebackConversion=*/false)) {
1715 ToType = it->getType();
1722 /// IsIntegralPromotion - Determines whether the conversion from the
1723 /// expression From (whose potentially-adjusted type is FromType) to
1724 /// ToType is an integral promotion (C++ 4.5). If so, returns true and
1725 /// sets PromotedType to the promoted type.
1726 bool Sema::IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType) {
1727 const BuiltinType *To = ToType->getAs<BuiltinType>();
1728 // All integers are built-in.
1733 // An rvalue of type char, signed char, unsigned char, short int, or
1734 // unsigned short int can be converted to an rvalue of type int if
1735 // int can represent all the values of the source type; otherwise,
1736 // the source rvalue can be converted to an rvalue of type unsigned
1738 if (FromType->isPromotableIntegerType() && !FromType->isBooleanType() &&
1739 !FromType->isEnumeralType()) {
1740 if (// We can promote any signed, promotable integer type to an int
1741 (FromType->isSignedIntegerType() ||
1742 // We can promote any unsigned integer type whose size is
1743 // less than int to an int.
1744 (!FromType->isSignedIntegerType() &&
1745 Context.getTypeSize(FromType) < Context.getTypeSize(ToType)))) {
1746 return To->getKind() == BuiltinType::Int;
1749 return To->getKind() == BuiltinType::UInt;
1752 // C++11 [conv.prom]p3:
1753 // A prvalue of an unscoped enumeration type whose underlying type is not
1754 // fixed (7.2) can be converted to an rvalue a prvalue of the first of the
1755 // following types that can represent all the values of the enumeration
1756 // (i.e., the values in the range bmin to bmax as described in 7.2): int,
1757 // unsigned int, long int, unsigned long int, long long int, or unsigned
1758 // long long int. If none of the types in that list can represent all the
1759 // values of the enumeration, an rvalue a prvalue of an unscoped enumeration
1760 // type can be converted to an rvalue a prvalue of the extended integer type
1761 // with lowest integer conversion rank (4.13) greater than the rank of long
1762 // long in which all the values of the enumeration can be represented. If
1763 // there are two such extended types, the signed one is chosen.
1764 // C++11 [conv.prom]p4:
1765 // A prvalue of an unscoped enumeration type whose underlying type is fixed
1766 // can be converted to a prvalue of its underlying type. Moreover, if
1767 // integral promotion can be applied to its underlying type, a prvalue of an
1768 // unscoped enumeration type whose underlying type is fixed can also be
1769 // converted to a prvalue of the promoted underlying type.
1770 if (const EnumType *FromEnumType = FromType->getAs<EnumType>()) {
1771 // C++0x 7.2p9: Note that this implicit enum to int conversion is not
1772 // provided for a scoped enumeration.
1773 if (FromEnumType->getDecl()->isScoped())
1776 // We can perform an integral promotion to the underlying type of the enum,
1777 // even if that's not the promoted type.
1778 if (FromEnumType->getDecl()->isFixed()) {
1779 QualType Underlying = FromEnumType->getDecl()->getIntegerType();
1780 return Context.hasSameUnqualifiedType(Underlying, ToType) ||
1781 IsIntegralPromotion(From, Underlying, ToType);
1784 // We have already pre-calculated the promotion type, so this is trivial.
1785 if (ToType->isIntegerType() &&
1786 !RequireCompleteType(From->getLocStart(), FromType, 0))
1787 return Context.hasSameUnqualifiedType(ToType,
1788 FromEnumType->getDecl()->getPromotionType());
1791 // C++0x [conv.prom]p2:
1792 // A prvalue of type char16_t, char32_t, or wchar_t (3.9.1) can be converted
1793 // to an rvalue a prvalue of the first of the following types that can
1794 // represent all the values of its underlying type: int, unsigned int,
1795 // long int, unsigned long int, long long int, or unsigned long long int.
1796 // If none of the types in that list can represent all the values of its
1797 // underlying type, an rvalue a prvalue of type char16_t, char32_t,
1798 // or wchar_t can be converted to an rvalue a prvalue of its underlying
1800 if (FromType->isAnyCharacterType() && !FromType->isCharType() &&
1801 ToType->isIntegerType()) {
1802 // Determine whether the type we're converting from is signed or
1804 bool FromIsSigned = FromType->isSignedIntegerType();
1805 uint64_t FromSize = Context.getTypeSize(FromType);
1807 // The types we'll try to promote to, in the appropriate
1808 // order. Try each of these types.
1809 QualType PromoteTypes[6] = {
1810 Context.IntTy, Context.UnsignedIntTy,
1811 Context.LongTy, Context.UnsignedLongTy ,
1812 Context.LongLongTy, Context.UnsignedLongLongTy
1814 for (int Idx = 0; Idx < 6; ++Idx) {
1815 uint64_t ToSize = Context.getTypeSize(PromoteTypes[Idx]);
1816 if (FromSize < ToSize ||
1817 (FromSize == ToSize &&
1818 FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType())) {
1819 // We found the type that we can promote to. If this is the
1820 // type we wanted, we have a promotion. Otherwise, no
1822 return Context.hasSameUnqualifiedType(ToType, PromoteTypes[Idx]);
1827 // An rvalue for an integral bit-field (9.6) can be converted to an
1828 // rvalue of type int if int can represent all the values of the
1829 // bit-field; otherwise, it can be converted to unsigned int if
1830 // unsigned int can represent all the values of the bit-field. If
1831 // the bit-field is larger yet, no integral promotion applies to
1832 // it. If the bit-field has an enumerated type, it is treated as any
1833 // other value of that type for promotion purposes (C++ 4.5p3).
1834 // FIXME: We should delay checking of bit-fields until we actually perform the
1838 if (FieldDecl *MemberDecl = From->getSourceBitField()) {
1840 if (FromType->isIntegralType(Context) &&
1841 MemberDecl->getBitWidth()->isIntegerConstantExpr(BitWidth, Context)) {
1842 APSInt ToSize(BitWidth.getBitWidth(), BitWidth.isUnsigned());
1843 ToSize = Context.getTypeSize(ToType);
1845 // Are we promoting to an int from a bitfield that fits in an int?
1846 if (BitWidth < ToSize ||
1847 (FromType->isSignedIntegerType() && BitWidth <= ToSize)) {
1848 return To->getKind() == BuiltinType::Int;
1851 // Are we promoting to an unsigned int from an unsigned bitfield
1852 // that fits into an unsigned int?
1853 if (FromType->isUnsignedIntegerType() && BitWidth <= ToSize) {
1854 return To->getKind() == BuiltinType::UInt;
1861 // An rvalue of type bool can be converted to an rvalue of type int,
1862 // with false becoming zero and true becoming one (C++ 4.5p4).
1863 if (FromType->isBooleanType() && To->getKind() == BuiltinType::Int) {
1870 /// IsFloatingPointPromotion - Determines whether the conversion from
1871 /// FromType to ToType is a floating point promotion (C++ 4.6). If so,
1872 /// returns true and sets PromotedType to the promoted type.
1873 bool Sema::IsFloatingPointPromotion(QualType FromType, QualType ToType) {
1874 if (const BuiltinType *FromBuiltin = FromType->getAs<BuiltinType>())
1875 if (const BuiltinType *ToBuiltin = ToType->getAs<BuiltinType>()) {
1876 /// An rvalue of type float can be converted to an rvalue of type
1877 /// double. (C++ 4.6p1).
1878 if (FromBuiltin->getKind() == BuiltinType::Float &&
1879 ToBuiltin->getKind() == BuiltinType::Double)
1883 // When a float is promoted to double or long double, or a
1884 // double is promoted to long double [...].
1885 if (!getLangOpts().CPlusPlus &&
1886 (FromBuiltin->getKind() == BuiltinType::Float ||
1887 FromBuiltin->getKind() == BuiltinType::Double) &&
1888 (ToBuiltin->getKind() == BuiltinType::LongDouble))
1891 // Half can be promoted to float.
1892 if (!getLangOpts().NativeHalfType &&
1893 FromBuiltin->getKind() == BuiltinType::Half &&
1894 ToBuiltin->getKind() == BuiltinType::Float)
1901 /// \brief Determine if a conversion is a complex promotion.
1903 /// A complex promotion is defined as a complex -> complex conversion
1904 /// where the conversion between the underlying real types is a
1905 /// floating-point or integral promotion.
1906 bool Sema::IsComplexPromotion(QualType FromType, QualType ToType) {
1907 const ComplexType *FromComplex = FromType->getAs<ComplexType>();
1911 const ComplexType *ToComplex = ToType->getAs<ComplexType>();
1915 return IsFloatingPointPromotion(FromComplex->getElementType(),
1916 ToComplex->getElementType()) ||
1917 IsIntegralPromotion(0, FromComplex->getElementType(),
1918 ToComplex->getElementType());
1921 /// BuildSimilarlyQualifiedPointerType - In a pointer conversion from
1922 /// the pointer type FromPtr to a pointer to type ToPointee, with the
1923 /// same type qualifiers as FromPtr has on its pointee type. ToType,
1924 /// if non-empty, will be a pointer to ToType that may or may not have
1925 /// the right set of qualifiers on its pointee.
1928 BuildSimilarlyQualifiedPointerType(const Type *FromPtr,
1929 QualType ToPointee, QualType ToType,
1930 ASTContext &Context,
1931 bool StripObjCLifetime = false) {
1932 assert((FromPtr->getTypeClass() == Type::Pointer ||
1933 FromPtr->getTypeClass() == Type::ObjCObjectPointer) &&
1934 "Invalid similarly-qualified pointer type");
1936 /// Conversions to 'id' subsume cv-qualifier conversions.
1937 if (ToType->isObjCIdType() || ToType->isObjCQualifiedIdType())
1938 return ToType.getUnqualifiedType();
1940 QualType CanonFromPointee
1941 = Context.getCanonicalType(FromPtr->getPointeeType());
1942 QualType CanonToPointee = Context.getCanonicalType(ToPointee);
1943 Qualifiers Quals = CanonFromPointee.getQualifiers();
1945 if (StripObjCLifetime)
1946 Quals.removeObjCLifetime();
1948 // Exact qualifier match -> return the pointer type we're converting to.
1949 if (CanonToPointee.getLocalQualifiers() == Quals) {
1950 // ToType is exactly what we need. Return it.
1951 if (!ToType.isNull())
1952 return ToType.getUnqualifiedType();
1954 // Build a pointer to ToPointee. It has the right qualifiers
1956 if (isa<ObjCObjectPointerType>(ToType))
1957 return Context.getObjCObjectPointerType(ToPointee);
1958 return Context.getPointerType(ToPointee);
1961 // Just build a canonical type that has the right qualifiers.
1962 QualType QualifiedCanonToPointee
1963 = Context.getQualifiedType(CanonToPointee.getLocalUnqualifiedType(), Quals);
1965 if (isa<ObjCObjectPointerType>(ToType))
1966 return Context.getObjCObjectPointerType(QualifiedCanonToPointee);
1967 return Context.getPointerType(QualifiedCanonToPointee);
1970 static bool isNullPointerConstantForConversion(Expr *Expr,
1971 bool InOverloadResolution,
1972 ASTContext &Context) {
1973 // Handle value-dependent integral null pointer constants correctly.
1974 // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#903
1975 if (Expr->isValueDependent() && !Expr->isTypeDependent() &&
1976 Expr->getType()->isIntegerType() && !Expr->getType()->isEnumeralType())
1977 return !InOverloadResolution;
1979 return Expr->isNullPointerConstant(Context,
1980 InOverloadResolution? Expr::NPC_ValueDependentIsNotNull
1981 : Expr::NPC_ValueDependentIsNull);
1984 /// IsPointerConversion - Determines whether the conversion of the
1985 /// expression From, which has the (possibly adjusted) type FromType,
1986 /// can be converted to the type ToType via a pointer conversion (C++
1987 /// 4.10). If so, returns true and places the converted type (that
1988 /// might differ from ToType in its cv-qualifiers at some level) into
1991 /// This routine also supports conversions to and from block pointers
1992 /// and conversions with Objective-C's 'id', 'id<protocols...>', and
1993 /// pointers to interfaces. FIXME: Once we've determined the
1994 /// appropriate overloading rules for Objective-C, we may want to
1995 /// split the Objective-C checks into a different routine; however,
1996 /// GCC seems to consider all of these conversions to be pointer
1997 /// conversions, so for now they live here. IncompatibleObjC will be
1998 /// set if the conversion is an allowed Objective-C conversion that
1999 /// should result in a warning.
2000 bool Sema::IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
2001 bool InOverloadResolution,
2002 QualType& ConvertedType,
2003 bool &IncompatibleObjC) {
2004 IncompatibleObjC = false;
2005 if (isObjCPointerConversion(FromType, ToType, ConvertedType,
2009 // Conversion from a null pointer constant to any Objective-C pointer type.
2010 if (ToType->isObjCObjectPointerType() &&
2011 isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
2012 ConvertedType = ToType;
2016 // Blocks: Block pointers can be converted to void*.
2017 if (FromType->isBlockPointerType() && ToType->isPointerType() &&
2018 ToType->getAs<PointerType>()->getPointeeType()->isVoidType()) {
2019 ConvertedType = ToType;
2022 // Blocks: A null pointer constant can be converted to a block
2024 if (ToType->isBlockPointerType() &&
2025 isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
2026 ConvertedType = ToType;
2030 // If the left-hand-side is nullptr_t, the right side can be a null
2031 // pointer constant.
2032 if (ToType->isNullPtrType() &&
2033 isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
2034 ConvertedType = ToType;
2038 const PointerType* ToTypePtr = ToType->getAs<PointerType>();
2042 // A null pointer constant can be converted to a pointer type (C++ 4.10p1).
2043 if (isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
2044 ConvertedType = ToType;
2048 // Beyond this point, both types need to be pointers
2049 // , including objective-c pointers.
2050 QualType ToPointeeType = ToTypePtr->getPointeeType();
2051 if (FromType->isObjCObjectPointerType() && ToPointeeType->isVoidType() &&
2052 !getLangOpts().ObjCAutoRefCount) {
2053 ConvertedType = BuildSimilarlyQualifiedPointerType(
2054 FromType->getAs<ObjCObjectPointerType>(),
2059 const PointerType *FromTypePtr = FromType->getAs<PointerType>();
2063 QualType FromPointeeType = FromTypePtr->getPointeeType();
2065 // If the unqualified pointee types are the same, this can't be a
2066 // pointer conversion, so don't do all of the work below.
2067 if (Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType))
2070 // An rvalue of type "pointer to cv T," where T is an object type,
2071 // can be converted to an rvalue of type "pointer to cv void" (C++
2073 if (FromPointeeType->isIncompleteOrObjectType() &&
2074 ToPointeeType->isVoidType()) {
2075 ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2078 /*StripObjCLifetime=*/true);
2082 // MSVC allows implicit function to void* type conversion.
2083 if (getLangOpts().MicrosoftExt && FromPointeeType->isFunctionType() &&
2084 ToPointeeType->isVoidType()) {
2085 ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2091 // When we're overloading in C, we allow a special kind of pointer
2092 // conversion for compatible-but-not-identical pointee types.
2093 if (!getLangOpts().CPlusPlus &&
2094 Context.typesAreCompatible(FromPointeeType, ToPointeeType)) {
2095 ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2101 // C++ [conv.ptr]p3:
2103 // An rvalue of type "pointer to cv D," where D is a class type,
2104 // can be converted to an rvalue of type "pointer to cv B," where
2105 // B is a base class (clause 10) of D. If B is an inaccessible
2106 // (clause 11) or ambiguous (10.2) base class of D, a program that
2107 // necessitates this conversion is ill-formed. The result of the
2108 // conversion is a pointer to the base class sub-object of the
2109 // derived class object. The null pointer value is converted to
2110 // the null pointer value of the destination type.
2112 // Note that we do not check for ambiguity or inaccessibility
2113 // here. That is handled by CheckPointerConversion.
2114 if (getLangOpts().CPlusPlus &&
2115 FromPointeeType->isRecordType() && ToPointeeType->isRecordType() &&
2116 !Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType) &&
2117 !RequireCompleteType(From->getLocStart(), FromPointeeType, 0) &&
2118 IsDerivedFrom(FromPointeeType, ToPointeeType)) {
2119 ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2125 if (FromPointeeType->isVectorType() && ToPointeeType->isVectorType() &&
2126 Context.areCompatibleVectorTypes(FromPointeeType, ToPointeeType)) {
2127 ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2136 /// \brief Adopt the given qualifiers for the given type.
2137 static QualType AdoptQualifiers(ASTContext &Context, QualType T, Qualifiers Qs){
2138 Qualifiers TQs = T.getQualifiers();
2140 // Check whether qualifiers already match.
2144 if (Qs.compatiblyIncludes(TQs))
2145 return Context.getQualifiedType(T, Qs);
2147 return Context.getQualifiedType(T.getUnqualifiedType(), Qs);
2150 /// isObjCPointerConversion - Determines whether this is an
2151 /// Objective-C pointer conversion. Subroutine of IsPointerConversion,
2152 /// with the same arguments and return values.
2153 bool Sema::isObjCPointerConversion(QualType FromType, QualType ToType,
2154 QualType& ConvertedType,
2155 bool &IncompatibleObjC) {
2156 if (!getLangOpts().ObjC1)
2159 // The set of qualifiers on the type we're converting from.
2160 Qualifiers FromQualifiers = FromType.getQualifiers();
2162 // First, we handle all conversions on ObjC object pointer types.
2163 const ObjCObjectPointerType* ToObjCPtr =
2164 ToType->getAs<ObjCObjectPointerType>();
2165 const ObjCObjectPointerType *FromObjCPtr =
2166 FromType->getAs<ObjCObjectPointerType>();
2168 if (ToObjCPtr && FromObjCPtr) {
2169 // If the pointee types are the same (ignoring qualifications),
2170 // then this is not a pointer conversion.
2171 if (Context.hasSameUnqualifiedType(ToObjCPtr->getPointeeType(),
2172 FromObjCPtr->getPointeeType()))
2175 // Check for compatible
2176 // Objective C++: We're able to convert between "id" or "Class" and a
2177 // pointer to any interface (in both directions).
2178 if (ToObjCPtr->isObjCBuiltinType() && FromObjCPtr->isObjCBuiltinType()) {
2179 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2182 // Conversions with Objective-C's id<...>.
2183 if ((FromObjCPtr->isObjCQualifiedIdType() ||
2184 ToObjCPtr->isObjCQualifiedIdType()) &&
2185 Context.ObjCQualifiedIdTypesAreCompatible(ToType, FromType,
2186 /*compare=*/false)) {
2187 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2190 // Objective C++: We're able to convert from a pointer to an
2191 // interface to a pointer to a different interface.
2192 if (Context.canAssignObjCInterfaces(ToObjCPtr, FromObjCPtr)) {
2193 const ObjCInterfaceType* LHS = ToObjCPtr->getInterfaceType();
2194 const ObjCInterfaceType* RHS = FromObjCPtr->getInterfaceType();
2195 if (getLangOpts().CPlusPlus && LHS && RHS &&
2196 !ToObjCPtr->getPointeeType().isAtLeastAsQualifiedAs(
2197 FromObjCPtr->getPointeeType()))
2199 ConvertedType = BuildSimilarlyQualifiedPointerType(FromObjCPtr,
2200 ToObjCPtr->getPointeeType(),
2202 ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2206 if (Context.canAssignObjCInterfaces(FromObjCPtr, ToObjCPtr)) {
2207 // Okay: this is some kind of implicit downcast of Objective-C
2208 // interfaces, which is permitted. However, we're going to
2209 // complain about it.
2210 IncompatibleObjC = true;
2211 ConvertedType = BuildSimilarlyQualifiedPointerType(FromObjCPtr,
2212 ToObjCPtr->getPointeeType(),
2214 ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2218 // Beyond this point, both types need to be C pointers or block pointers.
2219 QualType ToPointeeType;
2220 if (const PointerType *ToCPtr = ToType->getAs<PointerType>())
2221 ToPointeeType = ToCPtr->getPointeeType();
2222 else if (const BlockPointerType *ToBlockPtr =
2223 ToType->getAs<BlockPointerType>()) {
2224 // Objective C++: We're able to convert from a pointer to any object
2225 // to a block pointer type.
2226 if (FromObjCPtr && FromObjCPtr->isObjCBuiltinType()) {
2227 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2230 ToPointeeType = ToBlockPtr->getPointeeType();
2232 else if (FromType->getAs<BlockPointerType>() &&
2233 ToObjCPtr && ToObjCPtr->isObjCBuiltinType()) {
2234 // Objective C++: We're able to convert from a block pointer type to a
2235 // pointer to any object.
2236 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2242 QualType FromPointeeType;
2243 if (const PointerType *FromCPtr = FromType->getAs<PointerType>())
2244 FromPointeeType = FromCPtr->getPointeeType();
2245 else if (const BlockPointerType *FromBlockPtr =
2246 FromType->getAs<BlockPointerType>())
2247 FromPointeeType = FromBlockPtr->getPointeeType();
2251 // If we have pointers to pointers, recursively check whether this
2252 // is an Objective-C conversion.
2253 if (FromPointeeType->isPointerType() && ToPointeeType->isPointerType() &&
2254 isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType,
2255 IncompatibleObjC)) {
2256 // We always complain about this conversion.
2257 IncompatibleObjC = true;
2258 ConvertedType = Context.getPointerType(ConvertedType);
2259 ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2262 // Allow conversion of pointee being objective-c pointer to another one;
2264 if (FromPointeeType->getAs<ObjCObjectPointerType>() &&
2265 ToPointeeType->getAs<ObjCObjectPointerType>() &&
2266 isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType,
2267 IncompatibleObjC)) {
2269 ConvertedType = Context.getPointerType(ConvertedType);
2270 ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2274 // If we have pointers to functions or blocks, check whether the only
2275 // differences in the argument and result types are in Objective-C
2276 // pointer conversions. If so, we permit the conversion (but
2277 // complain about it).
2278 const FunctionProtoType *FromFunctionType
2279 = FromPointeeType->getAs<FunctionProtoType>();
2280 const FunctionProtoType *ToFunctionType
2281 = ToPointeeType->getAs<FunctionProtoType>();
2282 if (FromFunctionType && ToFunctionType) {
2283 // If the function types are exactly the same, this isn't an
2284 // Objective-C pointer conversion.
2285 if (Context.getCanonicalType(FromPointeeType)
2286 == Context.getCanonicalType(ToPointeeType))
2289 // Perform the quick checks that will tell us whether these
2290 // function types are obviously different.
2291 if (FromFunctionType->getNumArgs() != ToFunctionType->getNumArgs() ||
2292 FromFunctionType->isVariadic() != ToFunctionType->isVariadic() ||
2293 FromFunctionType->getTypeQuals() != ToFunctionType->getTypeQuals())
2296 bool HasObjCConversion = false;
2297 if (Context.getCanonicalType(FromFunctionType->getResultType())
2298 == Context.getCanonicalType(ToFunctionType->getResultType())) {
2299 // Okay, the types match exactly. Nothing to do.
2300 } else if (isObjCPointerConversion(FromFunctionType->getResultType(),
2301 ToFunctionType->getResultType(),
2302 ConvertedType, IncompatibleObjC)) {
2303 // Okay, we have an Objective-C pointer conversion.
2304 HasObjCConversion = true;
2306 // Function types are too different. Abort.
2310 // Check argument types.
2311 for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumArgs();
2312 ArgIdx != NumArgs; ++ArgIdx) {
2313 QualType FromArgType = FromFunctionType->getArgType(ArgIdx);
2314 QualType ToArgType = ToFunctionType->getArgType(ArgIdx);
2315 if (Context.getCanonicalType(FromArgType)
2316 == Context.getCanonicalType(ToArgType)) {
2317 // Okay, the types match exactly. Nothing to do.
2318 } else if (isObjCPointerConversion(FromArgType, ToArgType,
2319 ConvertedType, IncompatibleObjC)) {
2320 // Okay, we have an Objective-C pointer conversion.
2321 HasObjCConversion = true;
2323 // Argument types are too different. Abort.
2328 if (HasObjCConversion) {
2329 // We had an Objective-C conversion. Allow this pointer
2330 // conversion, but complain about it.
2331 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2332 IncompatibleObjC = true;
2340 /// \brief Determine whether this is an Objective-C writeback conversion,
2341 /// used for parameter passing when performing automatic reference counting.
2343 /// \param FromType The type we're converting form.
2345 /// \param ToType The type we're converting to.
2347 /// \param ConvertedType The type that will be produced after applying
2348 /// this conversion.
2349 bool Sema::isObjCWritebackConversion(QualType FromType, QualType ToType,
2350 QualType &ConvertedType) {
2351 if (!getLangOpts().ObjCAutoRefCount ||
2352 Context.hasSameUnqualifiedType(FromType, ToType))
2355 // Parameter must be a pointer to __autoreleasing (with no other qualifiers).
2357 if (const PointerType *ToPointer = ToType->getAs<PointerType>())
2358 ToPointee = ToPointer->getPointeeType();
2362 Qualifiers ToQuals = ToPointee.getQualifiers();
2363 if (!ToPointee->isObjCLifetimeType() ||
2364 ToQuals.getObjCLifetime() != Qualifiers::OCL_Autoreleasing ||
2365 !ToQuals.withoutObjCLifetime().empty())
2368 // Argument must be a pointer to __strong to __weak.
2369 QualType FromPointee;
2370 if (const PointerType *FromPointer = FromType->getAs<PointerType>())
2371 FromPointee = FromPointer->getPointeeType();
2375 Qualifiers FromQuals = FromPointee.getQualifiers();
2376 if (!FromPointee->isObjCLifetimeType() ||
2377 (FromQuals.getObjCLifetime() != Qualifiers::OCL_Strong &&
2378 FromQuals.getObjCLifetime() != Qualifiers::OCL_Weak))
2381 // Make sure that we have compatible qualifiers.
2382 FromQuals.setObjCLifetime(Qualifiers::OCL_Autoreleasing);
2383 if (!ToQuals.compatiblyIncludes(FromQuals))
2386 // Remove qualifiers from the pointee type we're converting from; they
2387 // aren't used in the compatibility check belong, and we'll be adding back
2388 // qualifiers (with __autoreleasing) if the compatibility check succeeds.
2389 FromPointee = FromPointee.getUnqualifiedType();
2391 // The unqualified form of the pointee types must be compatible.
2392 ToPointee = ToPointee.getUnqualifiedType();
2393 bool IncompatibleObjC;
2394 if (Context.typesAreCompatible(FromPointee, ToPointee))
2395 FromPointee = ToPointee;
2396 else if (!isObjCPointerConversion(FromPointee, ToPointee, FromPointee,
2400 /// \brief Construct the type we're converting to, which is a pointer to
2401 /// __autoreleasing pointee.
2402 FromPointee = Context.getQualifiedType(FromPointee, FromQuals);
2403 ConvertedType = Context.getPointerType(FromPointee);
2407 bool Sema::IsBlockPointerConversion(QualType FromType, QualType ToType,
2408 QualType& ConvertedType) {
2409 QualType ToPointeeType;
2410 if (const BlockPointerType *ToBlockPtr =
2411 ToType->getAs<BlockPointerType>())
2412 ToPointeeType = ToBlockPtr->getPointeeType();
2416 QualType FromPointeeType;
2417 if (const BlockPointerType *FromBlockPtr =
2418 FromType->getAs<BlockPointerType>())
2419 FromPointeeType = FromBlockPtr->getPointeeType();
2422 // We have pointer to blocks, check whether the only
2423 // differences in the argument and result types are in Objective-C
2424 // pointer conversions. If so, we permit the conversion.
2426 const FunctionProtoType *FromFunctionType
2427 = FromPointeeType->getAs<FunctionProtoType>();
2428 const FunctionProtoType *ToFunctionType
2429 = ToPointeeType->getAs<FunctionProtoType>();
2431 if (!FromFunctionType || !ToFunctionType)
2434 if (Context.hasSameType(FromPointeeType, ToPointeeType))
2437 // Perform the quick checks that will tell us whether these
2438 // function types are obviously different.
2439 if (FromFunctionType->getNumArgs() != ToFunctionType->getNumArgs() ||
2440 FromFunctionType->isVariadic() != ToFunctionType->isVariadic())
2443 FunctionType::ExtInfo FromEInfo = FromFunctionType->getExtInfo();
2444 FunctionType::ExtInfo ToEInfo = ToFunctionType->getExtInfo();
2445 if (FromEInfo != ToEInfo)
2448 bool IncompatibleObjC = false;
2449 if (Context.hasSameType(FromFunctionType->getResultType(),
2450 ToFunctionType->getResultType())) {
2451 // Okay, the types match exactly. Nothing to do.
2453 QualType RHS = FromFunctionType->getResultType();
2454 QualType LHS = ToFunctionType->getResultType();
2455 if ((!getLangOpts().CPlusPlus || !RHS->isRecordType()) &&
2456 !RHS.hasQualifiers() && LHS.hasQualifiers())
2457 LHS = LHS.getUnqualifiedType();
2459 if (Context.hasSameType(RHS,LHS)) {
2461 } else if (isObjCPointerConversion(RHS, LHS,
2462 ConvertedType, IncompatibleObjC)) {
2463 if (IncompatibleObjC)
2465 // Okay, we have an Objective-C pointer conversion.
2471 // Check argument types.
2472 for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumArgs();
2473 ArgIdx != NumArgs; ++ArgIdx) {
2474 IncompatibleObjC = false;
2475 QualType FromArgType = FromFunctionType->getArgType(ArgIdx);
2476 QualType ToArgType = ToFunctionType->getArgType(ArgIdx);
2477 if (Context.hasSameType(FromArgType, ToArgType)) {
2478 // Okay, the types match exactly. Nothing to do.
2479 } else if (isObjCPointerConversion(ToArgType, FromArgType,
2480 ConvertedType, IncompatibleObjC)) {
2481 if (IncompatibleObjC)
2483 // Okay, we have an Objective-C pointer conversion.
2485 // Argument types are too different. Abort.
2488 if (LangOpts.ObjCAutoRefCount &&
2489 !Context.FunctionTypesMatchOnNSConsumedAttrs(FromFunctionType,
2493 ConvertedType = ToType;
2501 ft_parameter_mismatch,
2503 ft_qualifer_mismatch
2506 /// HandleFunctionTypeMismatch - Gives diagnostic information for differeing
2507 /// function types. Catches different number of parameter, mismatch in
2508 /// parameter types, and different return types.
2509 void Sema::HandleFunctionTypeMismatch(PartialDiagnostic &PDiag,
2510 QualType FromType, QualType ToType) {
2511 // If either type is not valid, include no extra info.
2512 if (FromType.isNull() || ToType.isNull()) {
2513 PDiag << ft_default;
2517 // Get the function type from the pointers.
2518 if (FromType->isMemberPointerType() && ToType->isMemberPointerType()) {
2519 const MemberPointerType *FromMember = FromType->getAs<MemberPointerType>(),
2520 *ToMember = ToType->getAs<MemberPointerType>();
2521 if (FromMember->getClass() != ToMember->getClass()) {
2522 PDiag << ft_different_class << QualType(ToMember->getClass(), 0)
2523 << QualType(FromMember->getClass(), 0);
2526 FromType = FromMember->getPointeeType();
2527 ToType = ToMember->getPointeeType();
2530 if (FromType->isPointerType())
2531 FromType = FromType->getPointeeType();
2532 if (ToType->isPointerType())
2533 ToType = ToType->getPointeeType();
2535 // Remove references.
2536 FromType = FromType.getNonReferenceType();
2537 ToType = ToType.getNonReferenceType();
2539 // Don't print extra info for non-specialized template functions.
2540 if (FromType->isInstantiationDependentType() &&
2541 !FromType->getAs<TemplateSpecializationType>()) {
2542 PDiag << ft_default;
2546 // No extra info for same types.
2547 if (Context.hasSameType(FromType, ToType)) {
2548 PDiag << ft_default;
2552 const FunctionProtoType *FromFunction = FromType->getAs<FunctionProtoType>(),
2553 *ToFunction = ToType->getAs<FunctionProtoType>();
2555 // Both types need to be function types.
2556 if (!FromFunction || !ToFunction) {
2557 PDiag << ft_default;
2561 if (FromFunction->getNumArgs() != ToFunction->getNumArgs()) {
2562 PDiag << ft_parameter_arity << ToFunction->getNumArgs()
2563 << FromFunction->getNumArgs();
2567 // Handle different parameter types.
2569 if (!FunctionArgTypesAreEqual(FromFunction, ToFunction, &ArgPos)) {
2570 PDiag << ft_parameter_mismatch << ArgPos + 1
2571 << ToFunction->getArgType(ArgPos)
2572 << FromFunction->getArgType(ArgPos);
2576 // Handle different return type.
2577 if (!Context.hasSameType(FromFunction->getResultType(),
2578 ToFunction->getResultType())) {
2579 PDiag << ft_return_type << ToFunction->getResultType()
2580 << FromFunction->getResultType();
2584 unsigned FromQuals = FromFunction->getTypeQuals(),
2585 ToQuals = ToFunction->getTypeQuals();
2586 if (FromQuals != ToQuals) {
2587 PDiag << ft_qualifer_mismatch << ToQuals << FromQuals;
2591 // Unable to find a difference, so add no extra info.
2592 PDiag << ft_default;
2595 /// FunctionArgTypesAreEqual - This routine checks two function proto types
2596 /// for equality of their argument types. Caller has already checked that
2597 /// they have same number of arguments. If the parameters are different,
2598 /// ArgPos will have the parameter index of the first different parameter.
2599 bool Sema::FunctionArgTypesAreEqual(const FunctionProtoType *OldType,
2600 const FunctionProtoType *NewType,
2602 for (FunctionProtoType::arg_type_iterator O = OldType->arg_type_begin(),
2603 N = NewType->arg_type_begin(),
2604 E = OldType->arg_type_end(); O && (O != E); ++O, ++N) {
2605 if (!Context.hasSameType(O->getUnqualifiedType(),
2606 N->getUnqualifiedType())) {
2607 if (ArgPos) *ArgPos = O - OldType->arg_type_begin();
2614 /// CheckPointerConversion - Check the pointer conversion from the
2615 /// expression From to the type ToType. This routine checks for
2616 /// ambiguous or inaccessible derived-to-base pointer
2617 /// conversions for which IsPointerConversion has already returned
2618 /// true. It returns true and produces a diagnostic if there was an
2619 /// error, or returns false otherwise.
2620 bool Sema::CheckPointerConversion(Expr *From, QualType ToType,
2622 CXXCastPath& BasePath,
2623 bool IgnoreBaseAccess) {
2624 QualType FromType = From->getType();
2625 bool IsCStyleOrFunctionalCast = IgnoreBaseAccess;
2629 if (!IsCStyleOrFunctionalCast && !FromType->isAnyPointerType() &&
2630 From->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNotNull) ==
2631 Expr::NPCK_ZeroExpression) {
2632 if (Context.hasSameUnqualifiedType(From->getType(), Context.BoolTy))
2633 DiagRuntimeBehavior(From->getExprLoc(), From,
2634 PDiag(diag::warn_impcast_bool_to_null_pointer)
2635 << ToType << From->getSourceRange());
2636 else if (!isUnevaluatedContext())
2637 Diag(From->getExprLoc(), diag::warn_non_literal_null_pointer)
2638 << ToType << From->getSourceRange();
2640 if (const PointerType *ToPtrType = ToType->getAs<PointerType>()) {
2641 if (const PointerType *FromPtrType = FromType->getAs<PointerType>()) {
2642 QualType FromPointeeType = FromPtrType->getPointeeType(),
2643 ToPointeeType = ToPtrType->getPointeeType();
2645 if (FromPointeeType->isRecordType() && ToPointeeType->isRecordType() &&
2646 !Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType)) {
2647 // We must have a derived-to-base conversion. Check an
2648 // ambiguous or inaccessible conversion.
2649 if (CheckDerivedToBaseConversion(FromPointeeType, ToPointeeType,
2651 From->getSourceRange(), &BasePath,
2655 // The conversion was successful.
2656 Kind = CK_DerivedToBase;
2659 } else if (const ObjCObjectPointerType *ToPtrType =
2660 ToType->getAs<ObjCObjectPointerType>()) {
2661 if (const ObjCObjectPointerType *FromPtrType =
2662 FromType->getAs<ObjCObjectPointerType>()) {
2663 // Objective-C++ conversions are always okay.
2664 // FIXME: We should have a different class of conversions for the
2665 // Objective-C++ implicit conversions.
2666 if (FromPtrType->isObjCBuiltinType() || ToPtrType->isObjCBuiltinType())
2668 } else if (FromType->isBlockPointerType()) {
2669 Kind = CK_BlockPointerToObjCPointerCast;
2671 Kind = CK_CPointerToObjCPointerCast;
2673 } else if (ToType->isBlockPointerType()) {
2674 if (!FromType->isBlockPointerType())
2675 Kind = CK_AnyPointerToBlockPointerCast;
2678 // We shouldn't fall into this case unless it's valid for other
2680 if (From->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull))
2681 Kind = CK_NullToPointer;
2686 /// IsMemberPointerConversion - Determines whether the conversion of the
2687 /// expression From, which has the (possibly adjusted) type FromType, can be
2688 /// converted to the type ToType via a member pointer conversion (C++ 4.11).
2689 /// If so, returns true and places the converted type (that might differ from
2690 /// ToType in its cv-qualifiers at some level) into ConvertedType.
2691 bool Sema::IsMemberPointerConversion(Expr *From, QualType FromType,
2693 bool InOverloadResolution,
2694 QualType &ConvertedType) {
2695 const MemberPointerType *ToTypePtr = ToType->getAs<MemberPointerType>();
2699 // A null pointer constant can be converted to a member pointer (C++ 4.11p1)
2700 if (From->isNullPointerConstant(Context,
2701 InOverloadResolution? Expr::NPC_ValueDependentIsNotNull
2702 : Expr::NPC_ValueDependentIsNull)) {
2703 ConvertedType = ToType;
2707 // Otherwise, both types have to be member pointers.
2708 const MemberPointerType *FromTypePtr = FromType->getAs<MemberPointerType>();
2712 // A pointer to member of B can be converted to a pointer to member of D,
2713 // where D is derived from B (C++ 4.11p2).
2714 QualType FromClass(FromTypePtr->getClass(), 0);
2715 QualType ToClass(ToTypePtr->getClass(), 0);
2717 if (!Context.hasSameUnqualifiedType(FromClass, ToClass) &&
2718 !RequireCompleteType(From->getLocStart(), ToClass, 0) &&
2719 IsDerivedFrom(ToClass, FromClass)) {
2720 ConvertedType = Context.getMemberPointerType(FromTypePtr->getPointeeType(),
2721 ToClass.getTypePtr());
2728 /// CheckMemberPointerConversion - Check the member pointer conversion from the
2729 /// expression From to the type ToType. This routine checks for ambiguous or
2730 /// virtual or inaccessible base-to-derived member pointer conversions
2731 /// for which IsMemberPointerConversion has already returned true. It returns
2732 /// true and produces a diagnostic if there was an error, or returns false
2734 bool Sema::CheckMemberPointerConversion(Expr *From, QualType ToType,
2736 CXXCastPath &BasePath,
2737 bool IgnoreBaseAccess) {
2738 QualType FromType = From->getType();
2739 const MemberPointerType *FromPtrType = FromType->getAs<MemberPointerType>();
2741 // This must be a null pointer to member pointer conversion
2742 assert(From->isNullPointerConstant(Context,
2743 Expr::NPC_ValueDependentIsNull) &&
2744 "Expr must be null pointer constant!");
2745 Kind = CK_NullToMemberPointer;
2749 const MemberPointerType *ToPtrType = ToType->getAs<MemberPointerType>();
2750 assert(ToPtrType && "No member pointer cast has a target type "
2751 "that is not a member pointer.");
2753 QualType FromClass = QualType(FromPtrType->getClass(), 0);
2754 QualType ToClass = QualType(ToPtrType->getClass(), 0);
2756 // FIXME: What about dependent types?
2757 assert(FromClass->isRecordType() && "Pointer into non-class.");
2758 assert(ToClass->isRecordType() && "Pointer into non-class.");
2760 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
2761 /*DetectVirtual=*/true);
2762 bool DerivationOkay = IsDerivedFrom(ToClass, FromClass, Paths);
2763 assert(DerivationOkay &&
2764 "Should not have been called if derivation isn't OK.");
2765 (void)DerivationOkay;
2767 if (Paths.isAmbiguous(Context.getCanonicalType(FromClass).
2768 getUnqualifiedType())) {
2769 std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
2770 Diag(From->getExprLoc(), diag::err_ambiguous_memptr_conv)
2771 << 0 << FromClass << ToClass << PathDisplayStr << From->getSourceRange();
2775 if (const RecordType *VBase = Paths.getDetectedVirtual()) {
2776 Diag(From->getExprLoc(), diag::err_memptr_conv_via_virtual)
2777 << FromClass << ToClass << QualType(VBase, 0)
2778 << From->getSourceRange();
2782 if (!IgnoreBaseAccess)
2783 CheckBaseClassAccess(From->getExprLoc(), FromClass, ToClass,
2785 diag::err_downcast_from_inaccessible_base);
2787 // Must be a base to derived member conversion.
2788 BuildBasePathArray(Paths, BasePath);
2789 Kind = CK_BaseToDerivedMemberPointer;
2793 /// Determine whether the lifetime conversion between the two given
2794 /// qualifiers sets is nontrivial.
2795 static bool isNonTrivialObjCLifetimeConversion(Qualifiers FromQuals,
2796 Qualifiers ToQuals) {
2797 // Converting anything to const __unsafe_unretained is trivial.
2798 if (ToQuals.hasConst() &&
2799 ToQuals.getObjCLifetime() == Qualifiers::OCL_ExplicitNone)
2805 /// IsQualificationConversion - Determines whether the conversion from
2806 /// an rvalue of type FromType to ToType is a qualification conversion
2809 /// \param ObjCLifetimeConversion Output parameter that will be set to indicate
2810 /// when the qualification conversion involves a change in the Objective-C
2811 /// object lifetime.
2813 Sema::IsQualificationConversion(QualType FromType, QualType ToType,
2814 bool CStyle, bool &ObjCLifetimeConversion) {
2815 FromType = Context.getCanonicalType(FromType);
2816 ToType = Context.getCanonicalType(ToType);
2817 ObjCLifetimeConversion = false;
2819 // If FromType and ToType are the same type, this is not a
2820 // qualification conversion.
2821 if (FromType.getUnqualifiedType() == ToType.getUnqualifiedType())
2825 // A conversion can add cv-qualifiers at levels other than the first
2826 // in multi-level pointers, subject to the following rules: [...]
2827 bool PreviousToQualsIncludeConst = true;
2828 bool UnwrappedAnyPointer = false;
2829 while (Context.UnwrapSimilarPointerTypes(FromType, ToType)) {
2830 // Within each iteration of the loop, we check the qualifiers to
2831 // determine if this still looks like a qualification
2832 // conversion. Then, if all is well, we unwrap one more level of
2833 // pointers or pointers-to-members and do it all again
2834 // until there are no more pointers or pointers-to-members left to
2836 UnwrappedAnyPointer = true;
2838 Qualifiers FromQuals = FromType.getQualifiers();
2839 Qualifiers ToQuals = ToType.getQualifiers();
2842 // Check Objective-C lifetime conversions.
2843 if (FromQuals.getObjCLifetime() != ToQuals.getObjCLifetime() &&
2844 UnwrappedAnyPointer) {
2845 if (ToQuals.compatiblyIncludesObjCLifetime(FromQuals)) {
2846 if (isNonTrivialObjCLifetimeConversion(FromQuals, ToQuals))
2847 ObjCLifetimeConversion = true;
2848 FromQuals.removeObjCLifetime();
2849 ToQuals.removeObjCLifetime();
2851 // Qualification conversions cannot cast between different
2852 // Objective-C lifetime qualifiers.
2857 // Allow addition/removal of GC attributes but not changing GC attributes.
2858 if (FromQuals.getObjCGCAttr() != ToQuals.getObjCGCAttr() &&
2859 (!FromQuals.hasObjCGCAttr() || !ToQuals.hasObjCGCAttr())) {
2860 FromQuals.removeObjCGCAttr();
2861 ToQuals.removeObjCGCAttr();
2864 // -- for every j > 0, if const is in cv 1,j then const is in cv
2865 // 2,j, and similarly for volatile.
2866 if (!CStyle && !ToQuals.compatiblyIncludes(FromQuals))
2869 // -- if the cv 1,j and cv 2,j are different, then const is in
2870 // every cv for 0 < k < j.
2871 if (!CStyle && FromQuals.getCVRQualifiers() != ToQuals.getCVRQualifiers()
2872 && !PreviousToQualsIncludeConst)
2875 // Keep track of whether all prior cv-qualifiers in the "to" type
2877 PreviousToQualsIncludeConst
2878 = PreviousToQualsIncludeConst && ToQuals.hasConst();
2881 // We are left with FromType and ToType being the pointee types
2882 // after unwrapping the original FromType and ToType the same number
2883 // of types. If we unwrapped any pointers, and if FromType and
2884 // ToType have the same unqualified type (since we checked
2885 // qualifiers above), then this is a qualification conversion.
2886 return UnwrappedAnyPointer && Context.hasSameUnqualifiedType(FromType,ToType);
2889 /// \brief - Determine whether this is a conversion from a scalar type to an
2892 /// If successful, updates \c SCS's second and third steps in the conversion
2893 /// sequence to finish the conversion.
2894 static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType,
2895 bool InOverloadResolution,
2896 StandardConversionSequence &SCS,
2898 const AtomicType *ToAtomic = ToType->getAs<AtomicType>();
2902 StandardConversionSequence InnerSCS;
2903 if (!IsStandardConversion(S, From, ToAtomic->getValueType(),
2904 InOverloadResolution, InnerSCS,
2905 CStyle, /*AllowObjCWritebackConversion=*/false))
2908 SCS.Second = InnerSCS.Second;
2909 SCS.setToType(1, InnerSCS.getToType(1));
2910 SCS.Third = InnerSCS.Third;
2911 SCS.QualificationIncludesObjCLifetime
2912 = InnerSCS.QualificationIncludesObjCLifetime;
2913 SCS.setToType(2, InnerSCS.getToType(2));
2917 static bool isFirstArgumentCompatibleWithType(ASTContext &Context,
2918 CXXConstructorDecl *Constructor,
2920 const FunctionProtoType *CtorType =
2921 Constructor->getType()->getAs<FunctionProtoType>();
2922 if (CtorType->getNumArgs() > 0) {
2923 QualType FirstArg = CtorType->getArgType(0);
2924 if (Context.hasSameUnqualifiedType(Type, FirstArg.getNonReferenceType()))
2930 static OverloadingResult
2931 IsInitializerListConstructorConversion(Sema &S, Expr *From, QualType ToType,
2933 UserDefinedConversionSequence &User,
2934 OverloadCandidateSet &CandidateSet,
2935 bool AllowExplicit) {
2936 DeclContext::lookup_result R = S.LookupConstructors(To);
2937 for (DeclContext::lookup_iterator Con = R.begin(), ConEnd = R.end();
2938 Con != ConEnd; ++Con) {
2939 NamedDecl *D = *Con;
2940 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
2942 // Find the constructor (which may be a template).
2943 CXXConstructorDecl *Constructor = 0;
2944 FunctionTemplateDecl *ConstructorTmpl
2945 = dyn_cast<FunctionTemplateDecl>(D);
2946 if (ConstructorTmpl)
2948 = cast<CXXConstructorDecl>(ConstructorTmpl->getTemplatedDecl());
2950 Constructor = cast<CXXConstructorDecl>(D);
2952 bool Usable = !Constructor->isInvalidDecl() &&
2953 S.isInitListConstructor(Constructor) &&
2954 (AllowExplicit || !Constructor->isExplicit());
2956 // If the first argument is (a reference to) the target type,
2957 // suppress conversions.
2958 bool SuppressUserConversions =
2959 isFirstArgumentCompatibleWithType(S.Context, Constructor, ToType);
2960 if (ConstructorTmpl)
2961 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
2964 SuppressUserConversions);
2966 S.AddOverloadCandidate(Constructor, FoundDecl,
2968 SuppressUserConversions);
2972 bool HadMultipleCandidates = (CandidateSet.size() > 1);
2974 OverloadCandidateSet::iterator Best;
2975 switch (CandidateSet.BestViableFunction(S, From->getLocStart(), Best, true)) {
2977 // Record the standard conversion we used and the conversion function.
2978 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function);
2979 QualType ThisType = Constructor->getThisType(S.Context);
2980 // Initializer lists don't have conversions as such.
2981 User.Before.setAsIdentityConversion();
2982 User.HadMultipleCandidates = HadMultipleCandidates;
2983 User.ConversionFunction = Constructor;
2984 User.FoundConversionFunction = Best->FoundDecl;
2985 User.After.setAsIdentityConversion();
2986 User.After.setFromType(ThisType->getAs<PointerType>()->getPointeeType());
2987 User.After.setAllToTypes(ToType);
2991 case OR_No_Viable_Function:
2992 return OR_No_Viable_Function;
2996 return OR_Ambiguous;
2999 llvm_unreachable("Invalid OverloadResult!");
3002 /// Determines whether there is a user-defined conversion sequence
3003 /// (C++ [over.ics.user]) that converts expression From to the type
3004 /// ToType. If such a conversion exists, User will contain the
3005 /// user-defined conversion sequence that performs such a conversion
3006 /// and this routine will return true. Otherwise, this routine returns
3007 /// false and User is unspecified.
3009 /// \param AllowExplicit true if the conversion should consider C++0x
3010 /// "explicit" conversion functions as well as non-explicit conversion
3011 /// functions (C++0x [class.conv.fct]p2).
3013 /// \param AllowObjCConversionOnExplicit true if the conversion should
3014 /// allow an extra Objective-C pointer conversion on uses of explicit
3015 /// constructors. Requires \c AllowExplicit to also be set.
3016 static OverloadingResult
3017 IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
3018 UserDefinedConversionSequence &User,
3019 OverloadCandidateSet &CandidateSet,
3021 bool AllowObjCConversionOnExplicit) {
3022 assert(AllowExplicit || !AllowObjCConversionOnExplicit);
3024 // Whether we will only visit constructors.
3025 bool ConstructorsOnly = false;
3027 // If the type we are conversion to is a class type, enumerate its
3029 if (const RecordType *ToRecordType = ToType->getAs<RecordType>()) {
3030 // C++ [over.match.ctor]p1:
3031 // When objects of class type are direct-initialized (8.5), or
3032 // copy-initialized from an expression of the same or a
3033 // derived class type (8.5), overload resolution selects the
3034 // constructor. [...] For copy-initialization, the candidate
3035 // functions are all the converting constructors (12.3.1) of
3036 // that class. The argument list is the expression-list within
3037 // the parentheses of the initializer.
3038 if (S.Context.hasSameUnqualifiedType(ToType, From->getType()) ||
3039 (From->getType()->getAs<RecordType>() &&
3040 S.IsDerivedFrom(From->getType(), ToType)))
3041 ConstructorsOnly = true;
3043 S.RequireCompleteType(From->getExprLoc(), ToType, 0);
3044 // RequireCompleteType may have returned true due to some invalid decl
3045 // during template instantiation, but ToType may be complete enough now
3046 // to try to recover.
3047 if (ToType->isIncompleteType()) {
3048 // We're not going to find any constructors.
3049 } else if (CXXRecordDecl *ToRecordDecl
3050 = dyn_cast<CXXRecordDecl>(ToRecordType->getDecl())) {
3052 Expr **Args = &From;
3053 unsigned NumArgs = 1;
3054 bool ListInitializing = false;
3055 if (InitListExpr *InitList = dyn_cast<InitListExpr>(From)) {
3056 // But first, see if there is an init-list-constructor that will work.
3057 OverloadingResult Result = IsInitializerListConstructorConversion(
3058 S, From, ToType, ToRecordDecl, User, CandidateSet, AllowExplicit);
3059 if (Result != OR_No_Viable_Function)
3062 CandidateSet.clear();
3064 // If we're list-initializing, we pass the individual elements as
3065 // arguments, not the entire list.
3066 Args = InitList->getInits();
3067 NumArgs = InitList->getNumInits();
3068 ListInitializing = true;
3071 DeclContext::lookup_result R = S.LookupConstructors(ToRecordDecl);
3072 for (DeclContext::lookup_iterator Con = R.begin(), ConEnd = R.end();
3073 Con != ConEnd; ++Con) {
3074 NamedDecl *D = *Con;
3075 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
3077 // Find the constructor (which may be a template).
3078 CXXConstructorDecl *Constructor = 0;
3079 FunctionTemplateDecl *ConstructorTmpl
3080 = dyn_cast<FunctionTemplateDecl>(D);
3081 if (ConstructorTmpl)
3083 = cast<CXXConstructorDecl>(ConstructorTmpl->getTemplatedDecl());
3085 Constructor = cast<CXXConstructorDecl>(D);
3087 bool Usable = !Constructor->isInvalidDecl();
3088 if (ListInitializing)
3089 Usable = Usable && (AllowExplicit || !Constructor->isExplicit());
3091 Usable = Usable &&Constructor->isConvertingConstructor(AllowExplicit);
3093 bool SuppressUserConversions = !ConstructorsOnly;
3094 if (SuppressUserConversions && ListInitializing) {
3095 SuppressUserConversions = false;
3097 // If the first argument is (a reference to) the target type,
3098 // suppress conversions.
3099 SuppressUserConversions = isFirstArgumentCompatibleWithType(
3100 S.Context, Constructor, ToType);
3103 if (ConstructorTmpl)
3104 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
3106 llvm::makeArrayRef(Args, NumArgs),
3107 CandidateSet, SuppressUserConversions);
3109 // Allow one user-defined conversion when user specifies a
3110 // From->ToType conversion via an static cast (c-style, etc).
3111 S.AddOverloadCandidate(Constructor, FoundDecl,
3112 llvm::makeArrayRef(Args, NumArgs),
3113 CandidateSet, SuppressUserConversions);
3119 // Enumerate conversion functions, if we're allowed to.
3120 if (ConstructorsOnly || isa<InitListExpr>(From)) {
3121 } else if (S.RequireCompleteType(From->getLocStart(), From->getType(), 0)) {
3122 // No conversion functions from incomplete types.
3123 } else if (const RecordType *FromRecordType
3124 = From->getType()->getAs<RecordType>()) {
3125 if (CXXRecordDecl *FromRecordDecl
3126 = dyn_cast<CXXRecordDecl>(FromRecordType->getDecl())) {
3127 // Add all of the conversion functions as candidates.
3128 std::pair<CXXRecordDecl::conversion_iterator,
3129 CXXRecordDecl::conversion_iterator>
3130 Conversions = FromRecordDecl->getVisibleConversionFunctions();
3131 for (CXXRecordDecl::conversion_iterator
3132 I = Conversions.first, E = Conversions.second; I != E; ++I) {
3133 DeclAccessPair FoundDecl = I.getPair();
3134 NamedDecl *D = FoundDecl.getDecl();
3135 CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext());
3136 if (isa<UsingShadowDecl>(D))
3137 D = cast<UsingShadowDecl>(D)->getTargetDecl();
3139 CXXConversionDecl *Conv;
3140 FunctionTemplateDecl *ConvTemplate;
3141 if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D)))
3142 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
3144 Conv = cast<CXXConversionDecl>(D);
3146 if (AllowExplicit || !Conv->isExplicit()) {
3148 S.AddTemplateConversionCandidate(ConvTemplate, FoundDecl,
3149 ActingContext, From, ToType,
3151 AllowObjCConversionOnExplicit);
3153 S.AddConversionCandidate(Conv, FoundDecl, ActingContext,
3154 From, ToType, CandidateSet,
3155 AllowObjCConversionOnExplicit);
3161 bool HadMultipleCandidates = (CandidateSet.size() > 1);
3163 OverloadCandidateSet::iterator Best;
3164 switch (CandidateSet.BestViableFunction(S, From->getLocStart(), Best, true)) {
3166 // Record the standard conversion we used and the conversion function.
3167 if (CXXConstructorDecl *Constructor
3168 = dyn_cast<CXXConstructorDecl>(Best->Function)) {
3169 // C++ [over.ics.user]p1:
3170 // If the user-defined conversion is specified by a
3171 // constructor (12.3.1), the initial standard conversion
3172 // sequence converts the source type to the type required by
3173 // the argument of the constructor.
3175 QualType ThisType = Constructor->getThisType(S.Context);
3176 if (isa<InitListExpr>(From)) {
3177 // Initializer lists don't have conversions as such.
3178 User.Before.setAsIdentityConversion();
3180 if (Best->Conversions[0].isEllipsis())
3181 User.EllipsisConversion = true;
3183 User.Before = Best->Conversions[0].Standard;
3184 User.EllipsisConversion = false;
3187 User.HadMultipleCandidates = HadMultipleCandidates;
3188 User.ConversionFunction = Constructor;
3189 User.FoundConversionFunction = Best->FoundDecl;
3190 User.After.setAsIdentityConversion();
3191 User.After.setFromType(ThisType->getAs<PointerType>()->getPointeeType());
3192 User.After.setAllToTypes(ToType);
3195 if (CXXConversionDecl *Conversion
3196 = dyn_cast<CXXConversionDecl>(Best->Function)) {
3197 // C++ [over.ics.user]p1:
3199 // [...] If the user-defined conversion is specified by a
3200 // conversion function (12.3.2), the initial standard
3201 // conversion sequence converts the source type to the
3202 // implicit object parameter of the conversion function.
3203 User.Before = Best->Conversions[0].Standard;
3204 User.HadMultipleCandidates = HadMultipleCandidates;
3205 User.ConversionFunction = Conversion;
3206 User.FoundConversionFunction = Best->FoundDecl;
3207 User.EllipsisConversion = false;
3209 // C++ [over.ics.user]p2:
3210 // The second standard conversion sequence converts the
3211 // result of the user-defined conversion to the target type
3212 // for the sequence. Since an implicit conversion sequence
3213 // is an initialization, the special rules for
3214 // initialization by user-defined conversion apply when
3215 // selecting the best user-defined conversion for a
3216 // user-defined conversion sequence (see 13.3.3 and
3218 User.After = Best->FinalConversion;
3221 llvm_unreachable("Not a constructor or conversion function?");
3223 case OR_No_Viable_Function:
3224 return OR_No_Viable_Function;
3226 // No conversion here! We're done.
3230 return OR_Ambiguous;
3233 llvm_unreachable("Invalid OverloadResult!");
3237 Sema::DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType) {
3238 ImplicitConversionSequence ICS;
3239 OverloadCandidateSet CandidateSet(From->getExprLoc());
3240 OverloadingResult OvResult =
3241 IsUserDefinedConversion(*this, From, ToType, ICS.UserDefined,
3242 CandidateSet, false, false);
3243 if (OvResult == OR_Ambiguous)
3244 Diag(From->getLocStart(),
3245 diag::err_typecheck_ambiguous_condition)
3246 << From->getType() << ToType << From->getSourceRange();
3247 else if (OvResult == OR_No_Viable_Function && !CandidateSet.empty()) {
3248 if (!RequireCompleteType(From->getLocStart(), ToType,
3249 diag::err_typecheck_nonviable_condition_incomplete,
3250 From->getType(), From->getSourceRange()))
3251 Diag(From->getLocStart(),
3252 diag::err_typecheck_nonviable_condition)
3253 << From->getType() << From->getSourceRange() << ToType;
3257 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, From);
3261 /// \brief Compare the user-defined conversion functions or constructors
3262 /// of two user-defined conversion sequences to determine whether any ordering
3264 static ImplicitConversionSequence::CompareKind
3265 compareConversionFunctions(Sema &S,
3266 FunctionDecl *Function1,
3267 FunctionDecl *Function2) {
3268 if (!S.getLangOpts().ObjC1 || !S.getLangOpts().CPlusPlus11)
3269 return ImplicitConversionSequence::Indistinguishable;
3272 // If both conversion functions are implicitly-declared conversions from
3273 // a lambda closure type to a function pointer and a block pointer,
3274 // respectively, always prefer the conversion to a function pointer,
3275 // because the function pointer is more lightweight and is more likely
3276 // to keep code working.
3277 CXXConversionDecl *Conv1 = dyn_cast<CXXConversionDecl>(Function1);
3279 return ImplicitConversionSequence::Indistinguishable;
3281 CXXConversionDecl *Conv2 = dyn_cast<CXXConversionDecl>(Function2);
3283 return ImplicitConversionSequence::Indistinguishable;
3285 if (Conv1->getParent()->isLambda() && Conv2->getParent()->isLambda()) {
3286 bool Block1 = Conv1->getConversionType()->isBlockPointerType();
3287 bool Block2 = Conv2->getConversionType()->isBlockPointerType();
3288 if (Block1 != Block2)
3289 return Block1? ImplicitConversionSequence::Worse
3290 : ImplicitConversionSequence::Better;
3293 return ImplicitConversionSequence::Indistinguishable;
3296 /// CompareImplicitConversionSequences - Compare two implicit
3297 /// conversion sequences to determine whether one is better than the
3298 /// other or if they are indistinguishable (C++ 13.3.3.2).
3299 static ImplicitConversionSequence::CompareKind
3300 CompareImplicitConversionSequences(Sema &S,
3301 const ImplicitConversionSequence& ICS1,
3302 const ImplicitConversionSequence& ICS2)
3304 // (C++ 13.3.3.2p2): When comparing the basic forms of implicit
3305 // conversion sequences (as defined in 13.3.3.1)
3306 // -- a standard conversion sequence (13.3.3.1.1) is a better
3307 // conversion sequence than a user-defined conversion sequence or
3308 // an ellipsis conversion sequence, and
3309 // -- a user-defined conversion sequence (13.3.3.1.2) is a better
3310 // conversion sequence than an ellipsis conversion sequence
3313 // C++0x [over.best.ics]p10:
3314 // For the purpose of ranking implicit conversion sequences as
3315 // described in 13.3.3.2, the ambiguous conversion sequence is
3316 // treated as a user-defined sequence that is indistinguishable
3317 // from any other user-defined conversion sequence.
3318 if (ICS1.getKindRank() < ICS2.getKindRank())
3319 return ImplicitConversionSequence::Better;
3320 if (ICS2.getKindRank() < ICS1.getKindRank())
3321 return ImplicitConversionSequence::Worse;
3323 // The following checks require both conversion sequences to be of
3325 if (ICS1.getKind() != ICS2.getKind())
3326 return ImplicitConversionSequence::Indistinguishable;
3328 ImplicitConversionSequence::CompareKind Result =
3329 ImplicitConversionSequence::Indistinguishable;
3331 // Two implicit conversion sequences of the same form are
3332 // indistinguishable conversion sequences unless one of the
3333 // following rules apply: (C++ 13.3.3.2p3):
3334 if (ICS1.isStandard())
3335 Result = CompareStandardConversionSequences(S,
3336 ICS1.Standard, ICS2.Standard);
3337 else if (ICS1.isUserDefined()) {
3338 // User-defined conversion sequence U1 is a better conversion
3339 // sequence than another user-defined conversion sequence U2 if
3340 // they contain the same user-defined conversion function or
3341 // constructor and if the second standard conversion sequence of
3342 // U1 is better than the second standard conversion sequence of
3343 // U2 (C++ 13.3.3.2p3).
3344 if (ICS1.UserDefined.ConversionFunction ==
3345 ICS2.UserDefined.ConversionFunction)
3346 Result = CompareStandardConversionSequences(S,
3347 ICS1.UserDefined.After,
3348 ICS2.UserDefined.After);
3350 Result = compareConversionFunctions(S,
3351 ICS1.UserDefined.ConversionFunction,
3352 ICS2.UserDefined.ConversionFunction);
3355 // List-initialization sequence L1 is a better conversion sequence than
3356 // list-initialization sequence L2 if L1 converts to std::initializer_list<X>
3357 // for some X and L2 does not.
3358 if (Result == ImplicitConversionSequence::Indistinguishable &&
3360 if (ICS1.isStdInitializerListElement() &&
3361 !ICS2.isStdInitializerListElement())
3362 return ImplicitConversionSequence::Better;
3363 if (!ICS1.isStdInitializerListElement() &&
3364 ICS2.isStdInitializerListElement())
3365 return ImplicitConversionSequence::Worse;
3371 static bool hasSimilarType(ASTContext &Context, QualType T1, QualType T2) {
3372 while (Context.UnwrapSimilarPointerTypes(T1, T2)) {
3374 T1 = Context.getUnqualifiedArrayType(T1, Quals);
3375 T2 = Context.getUnqualifiedArrayType(T2, Quals);
3378 return Context.hasSameUnqualifiedType(T1, T2);
3381 // Per 13.3.3.2p3, compare the given standard conversion sequences to
3382 // determine if one is a proper subset of the other.
3383 static ImplicitConversionSequence::CompareKind
3384 compareStandardConversionSubsets(ASTContext &Context,
3385 const StandardConversionSequence& SCS1,
3386 const StandardConversionSequence& SCS2) {
3387 ImplicitConversionSequence::CompareKind Result
3388 = ImplicitConversionSequence::Indistinguishable;
3390 // the identity conversion sequence is considered to be a subsequence of
3391 // any non-identity conversion sequence
3392 if (SCS1.isIdentityConversion() && !SCS2.isIdentityConversion())
3393 return ImplicitConversionSequence::Better;
3394 else if (!SCS1.isIdentityConversion() && SCS2.isIdentityConversion())
3395 return ImplicitConversionSequence::Worse;
3397 if (SCS1.Second != SCS2.Second) {
3398 if (SCS1.Second == ICK_Identity)
3399 Result = ImplicitConversionSequence::Better;
3400 else if (SCS2.Second == ICK_Identity)
3401 Result = ImplicitConversionSequence::Worse;
3403 return ImplicitConversionSequence::Indistinguishable;
3404 } else if (!hasSimilarType(Context, SCS1.getToType(1), SCS2.getToType(1)))
3405 return ImplicitConversionSequence::Indistinguishable;
3407 if (SCS1.Third == SCS2.Third) {
3408 return Context.hasSameType(SCS1.getToType(2), SCS2.getToType(2))? Result
3409 : ImplicitConversionSequence::Indistinguishable;
3412 if (SCS1.Third == ICK_Identity)
3413 return Result == ImplicitConversionSequence::Worse
3414 ? ImplicitConversionSequence::Indistinguishable
3415 : ImplicitConversionSequence::Better;
3417 if (SCS2.Third == ICK_Identity)
3418 return Result == ImplicitConversionSequence::Better
3419 ? ImplicitConversionSequence::Indistinguishable
3420 : ImplicitConversionSequence::Worse;
3422 return ImplicitConversionSequence::Indistinguishable;
3425 /// \brief Determine whether one of the given reference bindings is better
3426 /// than the other based on what kind of bindings they are.
3427 static bool isBetterReferenceBindingKind(const StandardConversionSequence &SCS1,
3428 const StandardConversionSequence &SCS2) {
3429 // C++0x [over.ics.rank]p3b4:
3430 // -- S1 and S2 are reference bindings (8.5.3) and neither refers to an
3431 // implicit object parameter of a non-static member function declared
3432 // without a ref-qualifier, and *either* S1 binds an rvalue reference
3433 // to an rvalue and S2 binds an lvalue reference *or S1 binds an
3434 // lvalue reference to a function lvalue and S2 binds an rvalue
3437 // FIXME: Rvalue references. We're going rogue with the above edits,
3438 // because the semantics in the current C++0x working paper (N3225 at the
3439 // time of this writing) break the standard definition of std::forward
3440 // and std::reference_wrapper when dealing with references to functions.
3441 // Proposed wording changes submitted to CWG for consideration.
3442 if (SCS1.BindsImplicitObjectArgumentWithoutRefQualifier ||
3443 SCS2.BindsImplicitObjectArgumentWithoutRefQualifier)
3446 return (!SCS1.IsLvalueReference && SCS1.BindsToRvalue &&
3447 SCS2.IsLvalueReference) ||
3448 (SCS1.IsLvalueReference && SCS1.BindsToFunctionLvalue &&
3449 !SCS2.IsLvalueReference);
3452 /// CompareStandardConversionSequences - Compare two standard
3453 /// conversion sequences to determine whether one is better than the
3454 /// other or if they are indistinguishable (C++ 13.3.3.2p3).
3455 static ImplicitConversionSequence::CompareKind
3456 CompareStandardConversionSequences(Sema &S,
3457 const StandardConversionSequence& SCS1,
3458 const StandardConversionSequence& SCS2)
3460 // Standard conversion sequence S1 is a better conversion sequence
3461 // than standard conversion sequence S2 if (C++ 13.3.3.2p3):
3463 // -- S1 is a proper subsequence of S2 (comparing the conversion
3464 // sequences in the canonical form defined by 13.3.3.1.1,
3465 // excluding any Lvalue Transformation; the identity conversion
3466 // sequence is considered to be a subsequence of any
3467 // non-identity conversion sequence) or, if not that,
3468 if (ImplicitConversionSequence::CompareKind CK
3469 = compareStandardConversionSubsets(S.Context, SCS1, SCS2))
3472 // -- the rank of S1 is better than the rank of S2 (by the rules
3473 // defined below), or, if not that,
3474 ImplicitConversionRank Rank1 = SCS1.getRank();
3475 ImplicitConversionRank Rank2 = SCS2.getRank();
3477 return ImplicitConversionSequence::Better;
3478 else if (Rank2 < Rank1)
3479 return ImplicitConversionSequence::Worse;
3481 // (C++ 13.3.3.2p4): Two conversion sequences with the same rank
3482 // are indistinguishable unless one of the following rules
3485 // A conversion that is not a conversion of a pointer, or
3486 // pointer to member, to bool is better than another conversion
3487 // that is such a conversion.
3488 if (SCS1.isPointerConversionToBool() != SCS2.isPointerConversionToBool())
3489 return SCS2.isPointerConversionToBool()
3490 ? ImplicitConversionSequence::Better
3491 : ImplicitConversionSequence::Worse;
3493 // C++ [over.ics.rank]p4b2:
3495 // If class B is derived directly or indirectly from class A,
3496 // conversion of B* to A* is better than conversion of B* to
3497 // void*, and conversion of A* to void* is better than conversion
3499 bool SCS1ConvertsToVoid
3500 = SCS1.isPointerConversionToVoidPointer(S.Context);
3501 bool SCS2ConvertsToVoid
3502 = SCS2.isPointerConversionToVoidPointer(S.Context);
3503 if (SCS1ConvertsToVoid != SCS2ConvertsToVoid) {
3504 // Exactly one of the conversion sequences is a conversion to
3505 // a void pointer; it's the worse conversion.
3506 return SCS2ConvertsToVoid ? ImplicitConversionSequence::Better
3507 : ImplicitConversionSequence::Worse;
3508 } else if (!SCS1ConvertsToVoid && !SCS2ConvertsToVoid) {
3509 // Neither conversion sequence converts to a void pointer; compare
3510 // their derived-to-base conversions.
3511 if (ImplicitConversionSequence::CompareKind DerivedCK
3512 = CompareDerivedToBaseConversions(S, SCS1, SCS2))
3514 } else if (SCS1ConvertsToVoid && SCS2ConvertsToVoid &&
3515 !S.Context.hasSameType(SCS1.getFromType(), SCS2.getFromType())) {
3516 // Both conversion sequences are conversions to void
3517 // pointers. Compare the source types to determine if there's an
3518 // inheritance relationship in their sources.
3519 QualType FromType1 = SCS1.getFromType();
3520 QualType FromType2 = SCS2.getFromType();
3522 // Adjust the types we're converting from via the array-to-pointer
3523 // conversion, if we need to.
3524 if (SCS1.First == ICK_Array_To_Pointer)
3525 FromType1 = S.Context.getArrayDecayedType(FromType1);
3526 if (SCS2.First == ICK_Array_To_Pointer)
3527 FromType2 = S.Context.getArrayDecayedType(FromType2);
3529 QualType FromPointee1 = FromType1->getPointeeType().getUnqualifiedType();
3530 QualType FromPointee2 = FromType2->getPointeeType().getUnqualifiedType();
3532 if (S.IsDerivedFrom(FromPointee2, FromPointee1))
3533 return ImplicitConversionSequence::Better;
3534 else if (S.IsDerivedFrom(FromPointee1, FromPointee2))
3535 return ImplicitConversionSequence::Worse;
3537 // Objective-C++: If one interface is more specific than the
3538 // other, it is the better one.
3539 const ObjCObjectPointerType* FromObjCPtr1
3540 = FromType1->getAs<ObjCObjectPointerType>();
3541 const ObjCObjectPointerType* FromObjCPtr2
3542 = FromType2->getAs<ObjCObjectPointerType>();
3543 if (FromObjCPtr1 && FromObjCPtr2) {
3544 bool AssignLeft = S.Context.canAssignObjCInterfaces(FromObjCPtr1,
3546 bool AssignRight = S.Context.canAssignObjCInterfaces(FromObjCPtr2,
3548 if (AssignLeft != AssignRight) {
3549 return AssignLeft? ImplicitConversionSequence::Better
3550 : ImplicitConversionSequence::Worse;
3555 // Compare based on qualification conversions (C++ 13.3.3.2p3,
3557 if (ImplicitConversionSequence::CompareKind QualCK
3558 = CompareQualificationConversions(S, SCS1, SCS2))
3561 if (SCS1.ReferenceBinding && SCS2.ReferenceBinding) {
3562 // Check for a better reference binding based on the kind of bindings.
3563 if (isBetterReferenceBindingKind(SCS1, SCS2))
3564 return ImplicitConversionSequence::Better;
3565 else if (isBetterReferenceBindingKind(SCS2, SCS1))
3566 return ImplicitConversionSequence::Worse;
3568 // C++ [over.ics.rank]p3b4:
3569 // -- S1 and S2 are reference bindings (8.5.3), and the types to
3570 // which the references refer are the same type except for
3571 // top-level cv-qualifiers, and the type to which the reference
3572 // initialized by S2 refers is more cv-qualified than the type
3573 // to which the reference initialized by S1 refers.
3574 QualType T1 = SCS1.getToType(2);
3575 QualType T2 = SCS2.getToType(2);
3576 T1 = S.Context.getCanonicalType(T1);
3577 T2 = S.Context.getCanonicalType(T2);
3578 Qualifiers T1Quals, T2Quals;
3579 QualType UnqualT1 = S.Context.getUnqualifiedArrayType(T1, T1Quals);
3580 QualType UnqualT2 = S.Context.getUnqualifiedArrayType(T2, T2Quals);
3581 if (UnqualT1 == UnqualT2) {
3582 // Objective-C++ ARC: If the references refer to objects with different
3583 // lifetimes, prefer bindings that don't change lifetime.
3584 if (SCS1.ObjCLifetimeConversionBinding !=
3585 SCS2.ObjCLifetimeConversionBinding) {
3586 return SCS1.ObjCLifetimeConversionBinding
3587 ? ImplicitConversionSequence::Worse
3588 : ImplicitConversionSequence::Better;
3591 // If the type is an array type, promote the element qualifiers to the
3592 // type for comparison.
3593 if (isa<ArrayType>(T1) && T1Quals)
3594 T1 = S.Context.getQualifiedType(UnqualT1, T1Quals);
3595 if (isa<ArrayType>(T2) && T2Quals)
3596 T2 = S.Context.getQualifiedType(UnqualT2, T2Quals);
3597 if (T2.isMoreQualifiedThan(T1))
3598 return ImplicitConversionSequence::Better;
3599 else if (T1.isMoreQualifiedThan(T2))
3600 return ImplicitConversionSequence::Worse;
3604 // In Microsoft mode, prefer an integral conversion to a
3605 // floating-to-integral conversion if the integral conversion
3606 // is between types of the same size.
3614 // Here, MSVC will call f(int) instead of generating a compile error
3615 // as clang will do in standard mode.
3616 if (S.getLangOpts().MicrosoftMode &&
3617 SCS1.Second == ICK_Integral_Conversion &&
3618 SCS2.Second == ICK_Floating_Integral &&
3619 S.Context.getTypeSize(SCS1.getFromType()) ==
3620 S.Context.getTypeSize(SCS1.getToType(2)))
3621 return ImplicitConversionSequence::Better;
3623 return ImplicitConversionSequence::Indistinguishable;
3626 /// CompareQualificationConversions - Compares two standard conversion
3627 /// sequences to determine whether they can be ranked based on their
3628 /// qualification conversions (C++ 13.3.3.2p3 bullet 3).
3629 ImplicitConversionSequence::CompareKind
3630 CompareQualificationConversions(Sema &S,
3631 const StandardConversionSequence& SCS1,
3632 const StandardConversionSequence& SCS2) {
3634 // -- S1 and S2 differ only in their qualification conversion and
3635 // yield similar types T1 and T2 (C++ 4.4), respectively, and the
3636 // cv-qualification signature of type T1 is a proper subset of
3637 // the cv-qualification signature of type T2, and S1 is not the
3638 // deprecated string literal array-to-pointer conversion (4.2).
3639 if (SCS1.First != SCS2.First || SCS1.Second != SCS2.Second ||
3640 SCS1.Third != SCS2.Third || SCS1.Third != ICK_Qualification)
3641 return ImplicitConversionSequence::Indistinguishable;
3643 // FIXME: the example in the standard doesn't use a qualification
3645 QualType T1 = SCS1.getToType(2);
3646 QualType T2 = SCS2.getToType(2);
3647 T1 = S.Context.getCanonicalType(T1);
3648 T2 = S.Context.getCanonicalType(T2);
3649 Qualifiers T1Quals, T2Quals;
3650 QualType UnqualT1 = S.Context.getUnqualifiedArrayType(T1, T1Quals);
3651 QualType UnqualT2 = S.Context.getUnqualifiedArrayType(T2, T2Quals);
3653 // If the types are the same, we won't learn anything by unwrapped
3655 if (UnqualT1 == UnqualT2)
3656 return ImplicitConversionSequence::Indistinguishable;
3658 // If the type is an array type, promote the element qualifiers to the type
3660 if (isa<ArrayType>(T1) && T1Quals)
3661 T1 = S.Context.getQualifiedType(UnqualT1, T1Quals);
3662 if (isa<ArrayType>(T2) && T2Quals)
3663 T2 = S.Context.getQualifiedType(UnqualT2, T2Quals);
3665 ImplicitConversionSequence::CompareKind Result
3666 = ImplicitConversionSequence::Indistinguishable;
3668 // Objective-C++ ARC:
3669 // Prefer qualification conversions not involving a change in lifetime
3670 // to qualification conversions that do not change lifetime.
3671 if (SCS1.QualificationIncludesObjCLifetime !=
3672 SCS2.QualificationIncludesObjCLifetime) {
3673 Result = SCS1.QualificationIncludesObjCLifetime
3674 ? ImplicitConversionSequence::Worse
3675 : ImplicitConversionSequence::Better;
3678 while (S.Context.UnwrapSimilarPointerTypes(T1, T2)) {
3679 // Within each iteration of the loop, we check the qualifiers to
3680 // determine if this still looks like a qualification
3681 // conversion. Then, if all is well, we unwrap one more level of
3682 // pointers or pointers-to-members and do it all again
3683 // until there are no more pointers or pointers-to-members left
3684 // to unwrap. This essentially mimics what
3685 // IsQualificationConversion does, but here we're checking for a
3686 // strict subset of qualifiers.
3687 if (T1.getCVRQualifiers() == T2.getCVRQualifiers())
3688 // The qualifiers are the same, so this doesn't tell us anything
3689 // about how the sequences rank.
3691 else if (T2.isMoreQualifiedThan(T1)) {
3692 // T1 has fewer qualifiers, so it could be the better sequence.
3693 if (Result == ImplicitConversionSequence::Worse)
3694 // Neither has qualifiers that are a subset of the other's
3696 return ImplicitConversionSequence::Indistinguishable;
3698 Result = ImplicitConversionSequence::Better;
3699 } else if (T1.isMoreQualifiedThan(T2)) {
3700 // T2 has fewer qualifiers, so it could be the better sequence.
3701 if (Result == ImplicitConversionSequence::Better)
3702 // Neither has qualifiers that are a subset of the other's
3704 return ImplicitConversionSequence::Indistinguishable;
3706 Result = ImplicitConversionSequence::Worse;
3708 // Qualifiers are disjoint.
3709 return ImplicitConversionSequence::Indistinguishable;
3712 // If the types after this point are equivalent, we're done.
3713 if (S.Context.hasSameUnqualifiedType(T1, T2))
3717 // Check that the winning standard conversion sequence isn't using
3718 // the deprecated string literal array to pointer conversion.
3720 case ImplicitConversionSequence::Better:
3721 if (SCS1.DeprecatedStringLiteralToCharPtr)
3722 Result = ImplicitConversionSequence::Indistinguishable;
3725 case ImplicitConversionSequence::Indistinguishable:
3728 case ImplicitConversionSequence::Worse:
3729 if (SCS2.DeprecatedStringLiteralToCharPtr)
3730 Result = ImplicitConversionSequence::Indistinguishable;
3737 /// CompareDerivedToBaseConversions - Compares two standard conversion
3738 /// sequences to determine whether they can be ranked based on their
3739 /// various kinds of derived-to-base conversions (C++
3740 /// [over.ics.rank]p4b3). As part of these checks, we also look at
3741 /// conversions between Objective-C interface types.
3742 ImplicitConversionSequence::CompareKind
3743 CompareDerivedToBaseConversions(Sema &S,
3744 const StandardConversionSequence& SCS1,
3745 const StandardConversionSequence& SCS2) {
3746 QualType FromType1 = SCS1.getFromType();
3747 QualType ToType1 = SCS1.getToType(1);
3748 QualType FromType2 = SCS2.getFromType();
3749 QualType ToType2 = SCS2.getToType(1);
3751 // Adjust the types we're converting from via the array-to-pointer
3752 // conversion, if we need to.
3753 if (SCS1.First == ICK_Array_To_Pointer)
3754 FromType1 = S.Context.getArrayDecayedType(FromType1);
3755 if (SCS2.First == ICK_Array_To_Pointer)
3756 FromType2 = S.Context.getArrayDecayedType(FromType2);
3758 // Canonicalize all of the types.
3759 FromType1 = S.Context.getCanonicalType(FromType1);
3760 ToType1 = S.Context.getCanonicalType(ToType1);
3761 FromType2 = S.Context.getCanonicalType(FromType2);
3762 ToType2 = S.Context.getCanonicalType(ToType2);
3764 // C++ [over.ics.rank]p4b3:
3766 // If class B is derived directly or indirectly from class A and
3767 // class C is derived directly or indirectly from B,
3769 // Compare based on pointer conversions.
3770 if (SCS1.Second == ICK_Pointer_Conversion &&
3771 SCS2.Second == ICK_Pointer_Conversion &&
3772 /*FIXME: Remove if Objective-C id conversions get their own rank*/
3773 FromType1->isPointerType() && FromType2->isPointerType() &&
3774 ToType1->isPointerType() && ToType2->isPointerType()) {
3775 QualType FromPointee1
3776 = FromType1->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
3778 = ToType1->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
3779 QualType FromPointee2
3780 = FromType2->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
3782 = ToType2->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
3784 // -- conversion of C* to B* is better than conversion of C* to A*,
3785 if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
3786 if (S.IsDerivedFrom(ToPointee1, ToPointee2))
3787 return ImplicitConversionSequence::Better;
3788 else if (S.IsDerivedFrom(ToPointee2, ToPointee1))
3789 return ImplicitConversionSequence::Worse;
3792 // -- conversion of B* to A* is better than conversion of C* to A*,
3793 if (FromPointee1 != FromPointee2 && ToPointee1 == ToPointee2) {
3794 if (S.IsDerivedFrom(FromPointee2, FromPointee1))
3795 return ImplicitConversionSequence::Better;
3796 else if (S.IsDerivedFrom(FromPointee1, FromPointee2))
3797 return ImplicitConversionSequence::Worse;
3799 } else if (SCS1.Second == ICK_Pointer_Conversion &&
3800 SCS2.Second == ICK_Pointer_Conversion) {
3801 const ObjCObjectPointerType *FromPtr1
3802 = FromType1->getAs<ObjCObjectPointerType>();
3803 const ObjCObjectPointerType *FromPtr2
3804 = FromType2->getAs<ObjCObjectPointerType>();
3805 const ObjCObjectPointerType *ToPtr1
3806 = ToType1->getAs<ObjCObjectPointerType>();
3807 const ObjCObjectPointerType *ToPtr2
3808 = ToType2->getAs<ObjCObjectPointerType>();
3810 if (FromPtr1 && FromPtr2 && ToPtr1 && ToPtr2) {
3811 // Apply the same conversion ranking rules for Objective-C pointer types
3812 // that we do for C++ pointers to class types. However, we employ the
3813 // Objective-C pseudo-subtyping relationship used for assignment of
3814 // Objective-C pointer types.
3816 = S.Context.canAssignObjCInterfaces(FromPtr1, FromPtr2);
3817 bool FromAssignRight
3818 = S.Context.canAssignObjCInterfaces(FromPtr2, FromPtr1);
3820 = S.Context.canAssignObjCInterfaces(ToPtr1, ToPtr2);
3822 = S.Context.canAssignObjCInterfaces(ToPtr2, ToPtr1);
3824 // A conversion to an a non-id object pointer type or qualified 'id'
3825 // type is better than a conversion to 'id'.
3826 if (ToPtr1->isObjCIdType() &&
3827 (ToPtr2->isObjCQualifiedIdType() || ToPtr2->getInterfaceDecl()))
3828 return ImplicitConversionSequence::Worse;
3829 if (ToPtr2->isObjCIdType() &&
3830 (ToPtr1->isObjCQualifiedIdType() || ToPtr1->getInterfaceDecl()))
3831 return ImplicitConversionSequence::Better;
3833 // A conversion to a non-id object pointer type is better than a
3834 // conversion to a qualified 'id' type
3835 if (ToPtr1->isObjCQualifiedIdType() && ToPtr2->getInterfaceDecl())
3836 return ImplicitConversionSequence::Worse;
3837 if (ToPtr2->isObjCQualifiedIdType() && ToPtr1->getInterfaceDecl())
3838 return ImplicitConversionSequence::Better;
3840 // A conversion to an a non-Class object pointer type or qualified 'Class'
3841 // type is better than a conversion to 'Class'.
3842 if (ToPtr1->isObjCClassType() &&
3843 (ToPtr2->isObjCQualifiedClassType() || ToPtr2->getInterfaceDecl()))
3844 return ImplicitConversionSequence::Worse;
3845 if (ToPtr2->isObjCClassType() &&
3846 (ToPtr1->isObjCQualifiedClassType() || ToPtr1->getInterfaceDecl()))
3847 return ImplicitConversionSequence::Better;
3849 // A conversion to a non-Class object pointer type is better than a
3850 // conversion to a qualified 'Class' type.
3851 if (ToPtr1->isObjCQualifiedClassType() && ToPtr2->getInterfaceDecl())
3852 return ImplicitConversionSequence::Worse;
3853 if (ToPtr2->isObjCQualifiedClassType() && ToPtr1->getInterfaceDecl())
3854 return ImplicitConversionSequence::Better;
3856 // -- "conversion of C* to B* is better than conversion of C* to A*,"
3857 if (S.Context.hasSameType(FromType1, FromType2) &&
3858 !FromPtr1->isObjCIdType() && !FromPtr1->isObjCClassType() &&
3859 (ToAssignLeft != ToAssignRight))
3860 return ToAssignLeft? ImplicitConversionSequence::Worse
3861 : ImplicitConversionSequence::Better;
3863 // -- "conversion of B* to A* is better than conversion of C* to A*,"
3864 if (S.Context.hasSameUnqualifiedType(ToType1, ToType2) &&
3865 (FromAssignLeft != FromAssignRight))
3866 return FromAssignLeft? ImplicitConversionSequence::Better
3867 : ImplicitConversionSequence::Worse;
3871 // Ranking of member-pointer types.
3872 if (SCS1.Second == ICK_Pointer_Member && SCS2.Second == ICK_Pointer_Member &&
3873 FromType1->isMemberPointerType() && FromType2->isMemberPointerType() &&
3874 ToType1->isMemberPointerType() && ToType2->isMemberPointerType()) {
3875 const MemberPointerType * FromMemPointer1 =
3876 FromType1->getAs<MemberPointerType>();
3877 const MemberPointerType * ToMemPointer1 =
3878 ToType1->getAs<MemberPointerType>();
3879 const MemberPointerType * FromMemPointer2 =
3880 FromType2->getAs<MemberPointerType>();
3881 const MemberPointerType * ToMemPointer2 =
3882 ToType2->getAs<MemberPointerType>();
3883 const Type *FromPointeeType1 = FromMemPointer1->getClass();
3884 const Type *ToPointeeType1 = ToMemPointer1->getClass();
3885 const Type *FromPointeeType2 = FromMemPointer2->getClass();
3886 const Type *ToPointeeType2 = ToMemPointer2->getClass();
3887 QualType FromPointee1 = QualType(FromPointeeType1, 0).getUnqualifiedType();
3888 QualType ToPointee1 = QualType(ToPointeeType1, 0).getUnqualifiedType();
3889 QualType FromPointee2 = QualType(FromPointeeType2, 0).getUnqualifiedType();
3890 QualType ToPointee2 = QualType(ToPointeeType2, 0).getUnqualifiedType();
3891 // conversion of A::* to B::* is better than conversion of A::* to C::*,
3892 if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
3893 if (S.IsDerivedFrom(ToPointee1, ToPointee2))
3894 return ImplicitConversionSequence::Worse;
3895 else if (S.IsDerivedFrom(ToPointee2, ToPointee1))
3896 return ImplicitConversionSequence::Better;
3898 // conversion of B::* to C::* is better than conversion of A::* to C::*
3899 if (ToPointee1 == ToPointee2 && FromPointee1 != FromPointee2) {
3900 if (S.IsDerivedFrom(FromPointee1, FromPointee2))
3901 return ImplicitConversionSequence::Better;
3902 else if (S.IsDerivedFrom(FromPointee2, FromPointee1))
3903 return ImplicitConversionSequence::Worse;
3907 if (SCS1.Second == ICK_Derived_To_Base) {
3908 // -- conversion of C to B is better than conversion of C to A,
3909 // -- binding of an expression of type C to a reference of type
3910 // B& is better than binding an expression of type C to a
3911 // reference of type A&,
3912 if (S.Context.hasSameUnqualifiedType(FromType1, FromType2) &&
3913 !S.Context.hasSameUnqualifiedType(ToType1, ToType2)) {
3914 if (S.IsDerivedFrom(ToType1, ToType2))
3915 return ImplicitConversionSequence::Better;
3916 else if (S.IsDerivedFrom(ToType2, ToType1))
3917 return ImplicitConversionSequence::Worse;
3920 // -- conversion of B to A is better than conversion of C to A.
3921 // -- binding of an expression of type B to a reference of type
3922 // A& is better than binding an expression of type C to a
3923 // reference of type A&,
3924 if (!S.Context.hasSameUnqualifiedType(FromType1, FromType2) &&
3925 S.Context.hasSameUnqualifiedType(ToType1, ToType2)) {
3926 if (S.IsDerivedFrom(FromType2, FromType1))
3927 return ImplicitConversionSequence::Better;
3928 else if (S.IsDerivedFrom(FromType1, FromType2))
3929 return ImplicitConversionSequence::Worse;
3933 return ImplicitConversionSequence::Indistinguishable;
3936 /// \brief Determine whether the given type is valid, e.g., it is not an invalid
3938 static bool isTypeValid(QualType T) {
3939 if (CXXRecordDecl *Record = T->getAsCXXRecordDecl())
3940 return !Record->isInvalidDecl();
3945 /// CompareReferenceRelationship - Compare the two types T1 and T2 to
3946 /// determine whether they are reference-related,
3947 /// reference-compatible, reference-compatible with added
3948 /// qualification, or incompatible, for use in C++ initialization by
3949 /// reference (C++ [dcl.ref.init]p4). Neither type can be a reference
3950 /// type, and the first type (T1) is the pointee type of the reference
3951 /// type being initialized.
3952 Sema::ReferenceCompareResult
3953 Sema::CompareReferenceRelationship(SourceLocation Loc,
3954 QualType OrigT1, QualType OrigT2,
3955 bool &DerivedToBase,
3956 bool &ObjCConversion,
3957 bool &ObjCLifetimeConversion) {
3958 assert(!OrigT1->isReferenceType() &&
3959 "T1 must be the pointee type of the reference type");
3960 assert(!OrigT2->isReferenceType() && "T2 cannot be a reference type");
3962 QualType T1 = Context.getCanonicalType(OrigT1);
3963 QualType T2 = Context.getCanonicalType(OrigT2);
3964 Qualifiers T1Quals, T2Quals;
3965 QualType UnqualT1 = Context.getUnqualifiedArrayType(T1, T1Quals);
3966 QualType UnqualT2 = Context.getUnqualifiedArrayType(T2, T2Quals);
3968 // C++ [dcl.init.ref]p4:
3969 // Given types "cv1 T1" and "cv2 T2," "cv1 T1" is
3970 // reference-related to "cv2 T2" if T1 is the same type as T2, or
3971 // T1 is a base class of T2.
3972 DerivedToBase = false;
3973 ObjCConversion = false;
3974 ObjCLifetimeConversion = false;
3975 if (UnqualT1 == UnqualT2) {
3977 } else if (!RequireCompleteType(Loc, OrigT2, 0) &&
3978 isTypeValid(UnqualT1) && isTypeValid(UnqualT2) &&
3979 IsDerivedFrom(UnqualT2, UnqualT1))
3980 DerivedToBase = true;
3981 else if (UnqualT1->isObjCObjectOrInterfaceType() &&
3982 UnqualT2->isObjCObjectOrInterfaceType() &&
3983 Context.canBindObjCObjectType(UnqualT1, UnqualT2))
3984 ObjCConversion = true;
3986 return Ref_Incompatible;
3988 // At this point, we know that T1 and T2 are reference-related (at
3991 // If the type is an array type, promote the element qualifiers to the type
3993 if (isa<ArrayType>(T1) && T1Quals)
3994 T1 = Context.getQualifiedType(UnqualT1, T1Quals);
3995 if (isa<ArrayType>(T2) && T2Quals)
3996 T2 = Context.getQualifiedType(UnqualT2, T2Quals);
3998 // C++ [dcl.init.ref]p4:
3999 // "cv1 T1" is reference-compatible with "cv2 T2" if T1 is
4000 // reference-related to T2 and cv1 is the same cv-qualification
4001 // as, or greater cv-qualification than, cv2. For purposes of
4002 // overload resolution, cases for which cv1 is greater
4003 // cv-qualification than cv2 are identified as
4004 // reference-compatible with added qualification (see 13.3.3.2).
4006 // Note that we also require equivalence of Objective-C GC and address-space
4007 // qualifiers when performing these computations, so that e.g., an int in
4008 // address space 1 is not reference-compatible with an int in address
4010 if (T1Quals.getObjCLifetime() != T2Quals.getObjCLifetime() &&
4011 T1Quals.compatiblyIncludesObjCLifetime(T2Quals)) {
4012 if (isNonTrivialObjCLifetimeConversion(T2Quals, T1Quals))
4013 ObjCLifetimeConversion = true;
4015 T1Quals.removeObjCLifetime();
4016 T2Quals.removeObjCLifetime();
4019 if (T1Quals == T2Quals)
4020 return Ref_Compatible;
4021 else if (T1Quals.compatiblyIncludes(T2Quals))
4022 return Ref_Compatible_With_Added_Qualification;
4027 /// \brief Look for a user-defined conversion to an value reference-compatible
4028 /// with DeclType. Return true if something definite is found.
4030 FindConversionForRefInit(Sema &S, ImplicitConversionSequence &ICS,
4031 QualType DeclType, SourceLocation DeclLoc,
4032 Expr *Init, QualType T2, bool AllowRvalues,
4033 bool AllowExplicit) {
4034 assert(T2->isRecordType() && "Can only find conversions of record types.");
4035 CXXRecordDecl *T2RecordDecl
4036 = dyn_cast<CXXRecordDecl>(T2->getAs<RecordType>()->getDecl());
4038 OverloadCandidateSet CandidateSet(DeclLoc);
4039 std::pair<CXXRecordDecl::conversion_iterator,
4040 CXXRecordDecl::conversion_iterator>
4041 Conversions = T2RecordDecl->getVisibleConversionFunctions();
4042 for (CXXRecordDecl::conversion_iterator
4043 I = Conversions.first, E = Conversions.second; I != E; ++I) {
4045 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
4046 if (isa<UsingShadowDecl>(D))
4047 D = cast<UsingShadowDecl>(D)->getTargetDecl();
4049 FunctionTemplateDecl *ConvTemplate
4050 = dyn_cast<FunctionTemplateDecl>(D);
4051 CXXConversionDecl *Conv;
4053 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
4055 Conv = cast<CXXConversionDecl>(D);
4057 // If this is an explicit conversion, and we're not allowed to consider
4058 // explicit conversions, skip it.
4059 if (!AllowExplicit && Conv->isExplicit())
4063 bool DerivedToBase = false;
4064 bool ObjCConversion = false;
4065 bool ObjCLifetimeConversion = false;
4067 // If we are initializing an rvalue reference, don't permit conversion
4068 // functions that return lvalues.
4069 if (!ConvTemplate && DeclType->isRValueReferenceType()) {
4070 const ReferenceType *RefType
4071 = Conv->getConversionType()->getAs<LValueReferenceType>();
4072 if (RefType && !RefType->getPointeeType()->isFunctionType())
4076 if (!ConvTemplate &&
4077 S.CompareReferenceRelationship(
4079 Conv->getConversionType().getNonReferenceType()
4080 .getUnqualifiedType(),
4081 DeclType.getNonReferenceType().getUnqualifiedType(),
4082 DerivedToBase, ObjCConversion, ObjCLifetimeConversion) ==
4083 Sema::Ref_Incompatible)
4086 // If the conversion function doesn't return a reference type,
4087 // it can't be considered for this conversion. An rvalue reference
4088 // is only acceptable if its referencee is a function type.
4090 const ReferenceType *RefType =
4091 Conv->getConversionType()->getAs<ReferenceType>();
4093 (!RefType->isLValueReferenceType() &&
4094 !RefType->getPointeeType()->isFunctionType()))
4099 S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(), ActingDC,
4100 Init, DeclType, CandidateSet,
4101 /*AllowObjCConversionOnExplicit=*/false);
4103 S.AddConversionCandidate(Conv, I.getPair(), ActingDC, Init,
4104 DeclType, CandidateSet,
4105 /*AllowObjCConversionOnExplicit=*/false);
4108 bool HadMultipleCandidates = (CandidateSet.size() > 1);
4110 OverloadCandidateSet::iterator Best;
4111 switch (CandidateSet.BestViableFunction(S, DeclLoc, Best, true)) {
4113 // C++ [over.ics.ref]p1:
4115 // [...] If the parameter binds directly to the result of
4116 // applying a conversion function to the argument
4117 // expression, the implicit conversion sequence is a
4118 // user-defined conversion sequence (13.3.3.1.2), with the
4119 // second standard conversion sequence either an identity
4120 // conversion or, if the conversion function returns an
4121 // entity of a type that is a derived class of the parameter
4122 // type, a derived-to-base Conversion.
4123 if (!Best->FinalConversion.DirectBinding)
4126 ICS.setUserDefined();
4127 ICS.UserDefined.Before = Best->Conversions[0].Standard;
4128 ICS.UserDefined.After = Best->FinalConversion;
4129 ICS.UserDefined.HadMultipleCandidates = HadMultipleCandidates;
4130 ICS.UserDefined.ConversionFunction = Best->Function;
4131 ICS.UserDefined.FoundConversionFunction = Best->FoundDecl;
4132 ICS.UserDefined.EllipsisConversion = false;
4133 assert(ICS.UserDefined.After.ReferenceBinding &&
4134 ICS.UserDefined.After.DirectBinding &&
4135 "Expected a direct reference binding!");
4140 for (OverloadCandidateSet::iterator Cand = CandidateSet.begin();
4141 Cand != CandidateSet.end(); ++Cand)
4143 ICS.Ambiguous.addConversion(Cand->Function);
4146 case OR_No_Viable_Function:
4148 // There was no suitable conversion, or we found a deleted
4149 // conversion; continue with other checks.
4153 llvm_unreachable("Invalid OverloadResult!");
4156 /// \brief Compute an implicit conversion sequence for reference
4158 static ImplicitConversionSequence
4159 TryReferenceInit(Sema &S, Expr *Init, QualType DeclType,
4160 SourceLocation DeclLoc,
4161 bool SuppressUserConversions,
4162 bool AllowExplicit) {
4163 assert(DeclType->isReferenceType() && "Reference init needs a reference");
4165 // Most paths end in a failed conversion.
4166 ImplicitConversionSequence ICS;
4167 ICS.setBad(BadConversionSequence::no_conversion, Init, DeclType);
4169 QualType T1 = DeclType->getAs<ReferenceType>()->getPointeeType();
4170 QualType T2 = Init->getType();
4172 // If the initializer is the address of an overloaded function, try
4173 // to resolve the overloaded function. If all goes well, T2 is the
4174 // type of the resulting function.
4175 if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) {
4176 DeclAccessPair Found;
4177 if (FunctionDecl *Fn = S.ResolveAddressOfOverloadedFunction(Init, DeclType,
4182 // Compute some basic properties of the types and the initializer.
4183 bool isRValRef = DeclType->isRValueReferenceType();
4184 bool DerivedToBase = false;
4185 bool ObjCConversion = false;
4186 bool ObjCLifetimeConversion = false;
4187 Expr::Classification InitCategory = Init->Classify(S.Context);
4188 Sema::ReferenceCompareResult RefRelationship
4189 = S.CompareReferenceRelationship(DeclLoc, T1, T2, DerivedToBase,
4190 ObjCConversion, ObjCLifetimeConversion);
4193 // C++0x [dcl.init.ref]p5:
4194 // A reference to type "cv1 T1" is initialized by an expression
4195 // of type "cv2 T2" as follows:
4197 // -- If reference is an lvalue reference and the initializer expression
4199 // -- is an lvalue (but is not a bit-field), and "cv1 T1" is
4200 // reference-compatible with "cv2 T2," or
4202 // Per C++ [over.ics.ref]p4, we don't check the bit-field property here.
4203 if (InitCategory.isLValue() &&
4204 RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification) {
4205 // C++ [over.ics.ref]p1:
4206 // When a parameter of reference type binds directly (8.5.3)
4207 // to an argument expression, the implicit conversion sequence
4208 // is the identity conversion, unless the argument expression
4209 // has a type that is a derived class of the parameter type,
4210 // in which case the implicit conversion sequence is a
4211 // derived-to-base Conversion (13.3.3.1).
4213 ICS.Standard.First = ICK_Identity;
4214 ICS.Standard.Second = DerivedToBase? ICK_Derived_To_Base
4215 : ObjCConversion? ICK_Compatible_Conversion
4217 ICS.Standard.Third = ICK_Identity;
4218 ICS.Standard.FromTypePtr = T2.getAsOpaquePtr();
4219 ICS.Standard.setToType(0, T2);
4220 ICS.Standard.setToType(1, T1);
4221 ICS.Standard.setToType(2, T1);
4222 ICS.Standard.ReferenceBinding = true;
4223 ICS.Standard.DirectBinding = true;
4224 ICS.Standard.IsLvalueReference = !isRValRef;
4225 ICS.Standard.BindsToFunctionLvalue = T2->isFunctionType();
4226 ICS.Standard.BindsToRvalue = false;
4227 ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false;
4228 ICS.Standard.ObjCLifetimeConversionBinding = ObjCLifetimeConversion;
4229 ICS.Standard.CopyConstructor = 0;
4231 // Nothing more to do: the inaccessibility/ambiguity check for
4232 // derived-to-base conversions is suppressed when we're
4233 // computing the implicit conversion sequence (C++
4234 // [over.best.ics]p2).
4238 // -- has a class type (i.e., T2 is a class type), where T1 is
4239 // not reference-related to T2, and can be implicitly
4240 // converted to an lvalue of type "cv3 T3," where "cv1 T1"
4241 // is reference-compatible with "cv3 T3" 92) (this
4242 // conversion is selected by enumerating the applicable
4243 // conversion functions (13.3.1.6) and choosing the best
4244 // one through overload resolution (13.3)),
4245 if (!SuppressUserConversions && T2->isRecordType() &&
4246 !S.RequireCompleteType(DeclLoc, T2, 0) &&
4247 RefRelationship == Sema::Ref_Incompatible) {
4248 if (FindConversionForRefInit(S, ICS, DeclType, DeclLoc,
4249 Init, T2, /*AllowRvalues=*/false,
4255 // -- Otherwise, the reference shall be an lvalue reference to a
4256 // non-volatile const type (i.e., cv1 shall be const), or the reference
4257 // shall be an rvalue reference.
4259 // We actually handle one oddity of C++ [over.ics.ref] at this
4260 // point, which is that, due to p2 (which short-circuits reference
4261 // binding by only attempting a simple conversion for non-direct
4262 // bindings) and p3's strange wording, we allow a const volatile
4263 // reference to bind to an rvalue. Hence the check for the presence
4264 // of "const" rather than checking for "const" being the only
4266 // This is also the point where rvalue references and lvalue inits no longer
4268 if (!isRValRef && (!T1.isConstQualified() || T1.isVolatileQualified()))
4271 // -- If the initializer expression
4273 // -- is an xvalue, class prvalue, array prvalue or function
4274 // lvalue and "cv1 T1" is reference-compatible with "cv2 T2", or
4275 if (RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification &&
4276 (InitCategory.isXValue() ||
4277 (InitCategory.isPRValue() && (T2->isRecordType() || T2->isArrayType())) ||
4278 (InitCategory.isLValue() && T2->isFunctionType()))) {
4280 ICS.Standard.First = ICK_Identity;
4281 ICS.Standard.Second = DerivedToBase? ICK_Derived_To_Base
4282 : ObjCConversion? ICK_Compatible_Conversion
4284 ICS.Standard.Third = ICK_Identity;
4285 ICS.Standard.FromTypePtr = T2.getAsOpaquePtr();
4286 ICS.Standard.setToType(0, T2);
4287 ICS.Standard.setToType(1, T1);
4288 ICS.Standard.setToType(2, T1);
4289 ICS.Standard.ReferenceBinding = true;
4290 // In C++0x, this is always a direct binding. In C++98/03, it's a direct
4291 // binding unless we're binding to a class prvalue.
4292 // Note: Although xvalues wouldn't normally show up in C++98/03 code, we
4293 // allow the use of rvalue references in C++98/03 for the benefit of
4294 // standard library implementors; therefore, we need the xvalue check here.
4295 ICS.Standard.DirectBinding =
4296 S.getLangOpts().CPlusPlus11 ||
4297 (InitCategory.isPRValue() && !T2->isRecordType());
4298 ICS.Standard.IsLvalueReference = !isRValRef;
4299 ICS.Standard.BindsToFunctionLvalue = T2->isFunctionType();
4300 ICS.Standard.BindsToRvalue = InitCategory.isRValue();
4301 ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false;
4302 ICS.Standard.ObjCLifetimeConversionBinding = ObjCLifetimeConversion;
4303 ICS.Standard.CopyConstructor = 0;
4307 // -- has a class type (i.e., T2 is a class type), where T1 is not
4308 // reference-related to T2, and can be implicitly converted to
4309 // an xvalue, class prvalue, or function lvalue of type
4310 // "cv3 T3", where "cv1 T1" is reference-compatible with
4313 // then the reference is bound to the value of the initializer
4314 // expression in the first case and to the result of the conversion
4315 // in the second case (or, in either case, to an appropriate base
4316 // class subobject).
4317 if (!SuppressUserConversions && RefRelationship == Sema::Ref_Incompatible &&
4318 T2->isRecordType() && !S.RequireCompleteType(DeclLoc, T2, 0) &&
4319 FindConversionForRefInit(S, ICS, DeclType, DeclLoc,
4320 Init, T2, /*AllowRvalues=*/true,
4322 // In the second case, if the reference is an rvalue reference
4323 // and the second standard conversion sequence of the
4324 // user-defined conversion sequence includes an lvalue-to-rvalue
4325 // conversion, the program is ill-formed.
4326 if (ICS.isUserDefined() && isRValRef &&
4327 ICS.UserDefined.After.First == ICK_Lvalue_To_Rvalue)
4328 ICS.setBad(BadConversionSequence::no_conversion, Init, DeclType);
4333 // -- Otherwise, a temporary of type "cv1 T1" is created and
4334 // initialized from the initializer expression using the
4335 // rules for a non-reference copy initialization (8.5). The
4336 // reference is then bound to the temporary. If T1 is
4337 // reference-related to T2, cv1 must be the same
4338 // cv-qualification as, or greater cv-qualification than,
4339 // cv2; otherwise, the program is ill-formed.
4340 if (RefRelationship == Sema::Ref_Related) {
4341 // If cv1 == cv2 or cv1 is a greater cv-qualified than cv2, then
4342 // we would be reference-compatible or reference-compatible with
4343 // added qualification. But that wasn't the case, so the reference
4344 // initialization fails.
4346 // Note that we only want to check address spaces and cvr-qualifiers here.
4347 // ObjC GC and lifetime qualifiers aren't important.
4348 Qualifiers T1Quals = T1.getQualifiers();
4349 Qualifiers T2Quals = T2.getQualifiers();
4350 T1Quals.removeObjCGCAttr();
4351 T1Quals.removeObjCLifetime();
4352 T2Quals.removeObjCGCAttr();
4353 T2Quals.removeObjCLifetime();
4354 if (!T1Quals.compatiblyIncludes(T2Quals))
4358 // If at least one of the types is a class type, the types are not
4359 // related, and we aren't allowed any user conversions, the
4360 // reference binding fails. This case is important for breaking
4361 // recursion, since TryImplicitConversion below will attempt to
4362 // create a temporary through the use of a copy constructor.
4363 if (SuppressUserConversions && RefRelationship == Sema::Ref_Incompatible &&
4364 (T1->isRecordType() || T2->isRecordType()))
4367 // If T1 is reference-related to T2 and the reference is an rvalue
4368 // reference, the initializer expression shall not be an lvalue.
4369 if (RefRelationship >= Sema::Ref_Related &&
4370 isRValRef && Init->Classify(S.Context).isLValue())
4373 // C++ [over.ics.ref]p2:
4374 // When a parameter of reference type is not bound directly to
4375 // an argument expression, the conversion sequence is the one
4376 // required to convert the argument expression to the
4377 // underlying type of the reference according to
4378 // 13.3.3.1. Conceptually, this conversion sequence corresponds
4379 // to copy-initializing a temporary of the underlying type with
4380 // the argument expression. Any difference in top-level
4381 // cv-qualification is subsumed by the initialization itself
4382 // and does not constitute a conversion.
4383 ICS = TryImplicitConversion(S, Init, T1, SuppressUserConversions,
4384 /*AllowExplicit=*/false,
4385 /*InOverloadResolution=*/false,
4387 /*AllowObjCWritebackConversion=*/false,
4388 /*AllowObjCConversionOnExplicit=*/false);
4390 // Of course, that's still a reference binding.
4391 if (ICS.isStandard()) {
4392 ICS.Standard.ReferenceBinding = true;
4393 ICS.Standard.IsLvalueReference = !isRValRef;
4394 ICS.Standard.BindsToFunctionLvalue = T2->isFunctionType();
4395 ICS.Standard.BindsToRvalue = true;
4396 ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false;
4397 ICS.Standard.ObjCLifetimeConversionBinding = false;
4398 } else if (ICS.isUserDefined()) {
4399 // Don't allow rvalue references to bind to lvalues.
4400 if (DeclType->isRValueReferenceType()) {
4401 if (const ReferenceType *RefType
4402 = ICS.UserDefined.ConversionFunction->getResultType()
4403 ->getAs<LValueReferenceType>()) {
4404 if (!RefType->getPointeeType()->isFunctionType()) {
4405 ICS.setBad(BadConversionSequence::lvalue_ref_to_rvalue, Init,
4412 ICS.UserDefined.After.ReferenceBinding = true;
4413 ICS.UserDefined.After.IsLvalueReference = !isRValRef;
4414 ICS.UserDefined.After.BindsToFunctionLvalue = T2->isFunctionType();
4415 ICS.UserDefined.After.BindsToRvalue = true;
4416 ICS.UserDefined.After.BindsImplicitObjectArgumentWithoutRefQualifier = false;
4417 ICS.UserDefined.After.ObjCLifetimeConversionBinding = false;
4423 static ImplicitConversionSequence
4424 TryCopyInitialization(Sema &S, Expr *From, QualType ToType,
4425 bool SuppressUserConversions,
4426 bool InOverloadResolution,
4427 bool AllowObjCWritebackConversion,
4428 bool AllowExplicit = false);
4430 /// TryListConversion - Try to copy-initialize a value of type ToType from the
4431 /// initializer list From.
4432 static ImplicitConversionSequence
4433 TryListConversion(Sema &S, InitListExpr *From, QualType ToType,
4434 bool SuppressUserConversions,
4435 bool InOverloadResolution,
4436 bool AllowObjCWritebackConversion) {
4437 // C++11 [over.ics.list]p1:
4438 // When an argument is an initializer list, it is not an expression and
4439 // special rules apply for converting it to a parameter type.
4441 ImplicitConversionSequence Result;
4442 Result.setBad(BadConversionSequence::no_conversion, From, ToType);
4444 // We need a complete type for what follows. Incomplete types can never be
4445 // initialized from init lists.
4446 if (S.RequireCompleteType(From->getLocStart(), ToType, 0))
4449 // C++11 [over.ics.list]p2:
4450 // If the parameter type is std::initializer_list<X> or "array of X" and
4451 // all the elements can be implicitly converted to X, the implicit
4452 // conversion sequence is the worst conversion necessary to convert an
4453 // element of the list to X.
4454 bool toStdInitializerList = false;
4456 if (ToType->isArrayType())
4457 X = S.Context.getAsArrayType(ToType)->getElementType();
4459 toStdInitializerList = S.isStdInitializerList(ToType, &X);
4461 for (unsigned i = 0, e = From->getNumInits(); i < e; ++i) {
4462 Expr *Init = From->getInit(i);
4463 ImplicitConversionSequence ICS =
4464 TryCopyInitialization(S, Init, X, SuppressUserConversions,
4465 InOverloadResolution,
4466 AllowObjCWritebackConversion);
4467 // If a single element isn't convertible, fail.
4472 // Otherwise, look for the worst conversion.
4473 if (Result.isBad() ||
4474 CompareImplicitConversionSequences(S, ICS, Result) ==
4475 ImplicitConversionSequence::Worse)
4479 // For an empty list, we won't have computed any conversion sequence.
4480 // Introduce the identity conversion sequence.
4481 if (From->getNumInits() == 0) {
4482 Result.setStandard();
4483 Result.Standard.setAsIdentityConversion();
4484 Result.Standard.setFromType(ToType);
4485 Result.Standard.setAllToTypes(ToType);
4488 Result.setStdInitializerListElement(toStdInitializerList);
4492 // C++11 [over.ics.list]p3:
4493 // Otherwise, if the parameter is a non-aggregate class X and overload
4494 // resolution chooses a single best constructor [...] the implicit
4495 // conversion sequence is a user-defined conversion sequence. If multiple
4496 // constructors are viable but none is better than the others, the
4497 // implicit conversion sequence is a user-defined conversion sequence.
4498 if (ToType->isRecordType() && !ToType->isAggregateType()) {
4499 // This function can deal with initializer lists.
4500 return TryUserDefinedConversion(S, From, ToType, SuppressUserConversions,
4501 /*AllowExplicit=*/false,
4502 InOverloadResolution, /*CStyle=*/false,
4503 AllowObjCWritebackConversion,
4504 /*AllowObjCConversionOnExplicit=*/false);
4507 // C++11 [over.ics.list]p4:
4508 // Otherwise, if the parameter has an aggregate type which can be
4509 // initialized from the initializer list [...] the implicit conversion
4510 // sequence is a user-defined conversion sequence.
4511 if (ToType->isAggregateType()) {
4512 // Type is an aggregate, argument is an init list. At this point it comes
4513 // down to checking whether the initialization works.
4514 // FIXME: Find out whether this parameter is consumed or not.
4515 InitializedEntity Entity =
4516 InitializedEntity::InitializeParameter(S.Context, ToType,
4517 /*Consumed=*/false);
4518 if (S.CanPerformCopyInitialization(Entity, S.Owned(From))) {
4519 Result.setUserDefined();
4520 Result.UserDefined.Before.setAsIdentityConversion();
4521 // Initializer lists don't have a type.
4522 Result.UserDefined.Before.setFromType(QualType());
4523 Result.UserDefined.Before.setAllToTypes(QualType());
4525 Result.UserDefined.After.setAsIdentityConversion();
4526 Result.UserDefined.After.setFromType(ToType);
4527 Result.UserDefined.After.setAllToTypes(ToType);
4528 Result.UserDefined.ConversionFunction = 0;
4533 // C++11 [over.ics.list]p5:
4534 // Otherwise, if the parameter is a reference, see 13.3.3.1.4.
4535 if (ToType->isReferenceType()) {
4536 // The standard is notoriously unclear here, since 13.3.3.1.4 doesn't
4537 // mention initializer lists in any way. So we go by what list-
4538 // initialization would do and try to extrapolate from that.
4540 QualType T1 = ToType->getAs<ReferenceType>()->getPointeeType();
4542 // If the initializer list has a single element that is reference-related
4543 // to the parameter type, we initialize the reference from that.
4544 if (From->getNumInits() == 1) {
4545 Expr *Init = From->getInit(0);
4547 QualType T2 = Init->getType();
4549 // If the initializer is the address of an overloaded function, try
4550 // to resolve the overloaded function. If all goes well, T2 is the
4551 // type of the resulting function.
4552 if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) {
4553 DeclAccessPair Found;
4554 if (FunctionDecl *Fn = S.ResolveAddressOfOverloadedFunction(
4555 Init, ToType, false, Found))
4559 // Compute some basic properties of the types and the initializer.
4560 bool dummy1 = false;
4561 bool dummy2 = false;
4562 bool dummy3 = false;
4563 Sema::ReferenceCompareResult RefRelationship
4564 = S.CompareReferenceRelationship(From->getLocStart(), T1, T2, dummy1,
4567 if (RefRelationship >= Sema::Ref_Related) {
4568 return TryReferenceInit(S, Init, ToType, /*FIXME*/From->getLocStart(),
4569 SuppressUserConversions,
4570 /*AllowExplicit=*/false);
4574 // Otherwise, we bind the reference to a temporary created from the
4575 // initializer list.
4576 Result = TryListConversion(S, From, T1, SuppressUserConversions,
4577 InOverloadResolution,
4578 AllowObjCWritebackConversion);
4579 if (Result.isFailure())
4581 assert(!Result.isEllipsis() &&
4582 "Sub-initialization cannot result in ellipsis conversion.");
4584 // Can we even bind to a temporary?
4585 if (ToType->isRValueReferenceType() ||
4586 (T1.isConstQualified() && !T1.isVolatileQualified())) {
4587 StandardConversionSequence &SCS = Result.isStandard() ? Result.Standard :
4588 Result.UserDefined.After;
4589 SCS.ReferenceBinding = true;
4590 SCS.IsLvalueReference = ToType->isLValueReferenceType();
4591 SCS.BindsToRvalue = true;
4592 SCS.BindsToFunctionLvalue = false;
4593 SCS.BindsImplicitObjectArgumentWithoutRefQualifier = false;
4594 SCS.ObjCLifetimeConversionBinding = false;
4596 Result.setBad(BadConversionSequence::lvalue_ref_to_rvalue,
4601 // C++11 [over.ics.list]p6:
4602 // Otherwise, if the parameter type is not a class:
4603 if (!ToType->isRecordType()) {
4604 // - if the initializer list has one element, the implicit conversion
4605 // sequence is the one required to convert the element to the
4607 unsigned NumInits = From->getNumInits();
4609 Result = TryCopyInitialization(S, From->getInit(0), ToType,
4610 SuppressUserConversions,
4611 InOverloadResolution,
4612 AllowObjCWritebackConversion);
4613 // - if the initializer list has no elements, the implicit conversion
4614 // sequence is the identity conversion.
4615 else if (NumInits == 0) {
4616 Result.setStandard();
4617 Result.Standard.setAsIdentityConversion();
4618 Result.Standard.setFromType(ToType);
4619 Result.Standard.setAllToTypes(ToType);
4624 // C++11 [over.ics.list]p7:
4625 // In all cases other than those enumerated above, no conversion is possible
4629 /// TryCopyInitialization - Try to copy-initialize a value of type
4630 /// ToType from the expression From. Return the implicit conversion
4631 /// sequence required to pass this argument, which may be a bad
4632 /// conversion sequence (meaning that the argument cannot be passed to
4633 /// a parameter of this type). If @p SuppressUserConversions, then we
4634 /// do not permit any user-defined conversion sequences.
4635 static ImplicitConversionSequence
4636 TryCopyInitialization(Sema &S, Expr *From, QualType ToType,
4637 bool SuppressUserConversions,
4638 bool InOverloadResolution,
4639 bool AllowObjCWritebackConversion,
4640 bool AllowExplicit) {
4641 if (InitListExpr *FromInitList = dyn_cast<InitListExpr>(From))
4642 return TryListConversion(S, FromInitList, ToType, SuppressUserConversions,
4643 InOverloadResolution,AllowObjCWritebackConversion);
4645 if (ToType->isReferenceType())
4646 return TryReferenceInit(S, From, ToType,
4647 /*FIXME:*/From->getLocStart(),
4648 SuppressUserConversions,
4651 return TryImplicitConversion(S, From, ToType,
4652 SuppressUserConversions,
4653 /*AllowExplicit=*/false,
4654 InOverloadResolution,
4656 AllowObjCWritebackConversion,
4657 /*AllowObjCConversionOnExplicit=*/false);
4660 static bool TryCopyInitialization(const CanQualType FromQTy,
4661 const CanQualType ToQTy,
4664 ExprValueKind FromVK) {
4665 OpaqueValueExpr TmpExpr(Loc, FromQTy, FromVK);
4666 ImplicitConversionSequence ICS =
4667 TryCopyInitialization(S, &TmpExpr, ToQTy, true, true, false);
4669 return !ICS.isBad();
4672 /// TryObjectArgumentInitialization - Try to initialize the object
4673 /// parameter of the given member function (@c Method) from the
4674 /// expression @p From.
4675 static ImplicitConversionSequence
4676 TryObjectArgumentInitialization(Sema &S, QualType FromType,
4677 Expr::Classification FromClassification,
4678 CXXMethodDecl *Method,
4679 CXXRecordDecl *ActingContext) {
4680 QualType ClassType = S.Context.getTypeDeclType(ActingContext);
4681 // [class.dtor]p2: A destructor can be invoked for a const, volatile or
4682 // const volatile object.
4683 unsigned Quals = isa<CXXDestructorDecl>(Method) ?
4684 Qualifiers::Const | Qualifiers::Volatile : Method->getTypeQualifiers();
4685 QualType ImplicitParamType = S.Context.getCVRQualifiedType(ClassType, Quals);
4687 // Set up the conversion sequence as a "bad" conversion, to allow us
4689 ImplicitConversionSequence ICS;
4691 // We need to have an object of class type.
4692 if (const PointerType *PT = FromType->getAs<PointerType>()) {
4693 FromType = PT->getPointeeType();
4695 // When we had a pointer, it's implicitly dereferenced, so we
4696 // better have an lvalue.
4697 assert(FromClassification.isLValue());
4700 assert(FromType->isRecordType());
4702 // C++0x [over.match.funcs]p4:
4703 // For non-static member functions, the type of the implicit object
4706 // - "lvalue reference to cv X" for functions declared without a
4707 // ref-qualifier or with the & ref-qualifier
4708 // - "rvalue reference to cv X" for functions declared with the &&
4711 // where X is the class of which the function is a member and cv is the
4712 // cv-qualification on the member function declaration.
4714 // However, when finding an implicit conversion sequence for the argument, we
4715 // are not allowed to create temporaries or perform user-defined conversions
4716 // (C++ [over.match.funcs]p5). We perform a simplified version of
4717 // reference binding here, that allows class rvalues to bind to
4718 // non-constant references.
4720 // First check the qualifiers.
4721 QualType FromTypeCanon = S.Context.getCanonicalType(FromType);
4722 if (ImplicitParamType.getCVRQualifiers()
4723 != FromTypeCanon.getLocalCVRQualifiers() &&
4724 !ImplicitParamType.isAtLeastAsQualifiedAs(FromTypeCanon)) {
4725 ICS.setBad(BadConversionSequence::bad_qualifiers,
4726 FromType, ImplicitParamType);
4730 // Check that we have either the same type or a derived type. It
4731 // affects the conversion rank.
4732 QualType ClassTypeCanon = S.Context.getCanonicalType(ClassType);
4733 ImplicitConversionKind SecondKind;
4734 if (ClassTypeCanon == FromTypeCanon.getLocalUnqualifiedType()) {
4735 SecondKind = ICK_Identity;
4736 } else if (S.IsDerivedFrom(FromType, ClassType))
4737 SecondKind = ICK_Derived_To_Base;
4739 ICS.setBad(BadConversionSequence::unrelated_class,
4740 FromType, ImplicitParamType);
4744 // Check the ref-qualifier.
4745 switch (Method->getRefQualifier()) {
4747 // Do nothing; we don't care about lvalueness or rvalueness.
4751 if (!FromClassification.isLValue() && Quals != Qualifiers::Const) {
4752 // non-const lvalue reference cannot bind to an rvalue
4753 ICS.setBad(BadConversionSequence::lvalue_ref_to_rvalue, FromType,
4760 if (!FromClassification.isRValue()) {
4761 // rvalue reference cannot bind to an lvalue
4762 ICS.setBad(BadConversionSequence::rvalue_ref_to_lvalue, FromType,
4769 // Success. Mark this as a reference binding.
4771 ICS.Standard.setAsIdentityConversion();
4772 ICS.Standard.Second = SecondKind;
4773 ICS.Standard.setFromType(FromType);
4774 ICS.Standard.setAllToTypes(ImplicitParamType);
4775 ICS.Standard.ReferenceBinding = true;
4776 ICS.Standard.DirectBinding = true;
4777 ICS.Standard.IsLvalueReference = Method->getRefQualifier() != RQ_RValue;
4778 ICS.Standard.BindsToFunctionLvalue = false;
4779 ICS.Standard.BindsToRvalue = FromClassification.isRValue();
4780 ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier
4781 = (Method->getRefQualifier() == RQ_None);
4785 /// PerformObjectArgumentInitialization - Perform initialization of
4786 /// the implicit object parameter for the given Method with the given
4789 Sema::PerformObjectArgumentInitialization(Expr *From,
4790 NestedNameSpecifier *Qualifier,
4791 NamedDecl *FoundDecl,
4792 CXXMethodDecl *Method) {
4793 QualType FromRecordType, DestType;
4794 QualType ImplicitParamRecordType =
4795 Method->getThisType(Context)->getAs<PointerType>()->getPointeeType();
4797 Expr::Classification FromClassification;
4798 if (const PointerType *PT = From->getType()->getAs<PointerType>()) {
4799 FromRecordType = PT->getPointeeType();
4800 DestType = Method->getThisType(Context);
4801 FromClassification = Expr::Classification::makeSimpleLValue();
4803 FromRecordType = From->getType();
4804 DestType = ImplicitParamRecordType;
4805 FromClassification = From->Classify(Context);
4808 // Note that we always use the true parent context when performing
4809 // the actual argument initialization.
4810 ImplicitConversionSequence ICS
4811 = TryObjectArgumentInitialization(*this, From->getType(), FromClassification,
4812 Method, Method->getParent());
4814 if (ICS.Bad.Kind == BadConversionSequence::bad_qualifiers) {
4815 Qualifiers FromQs = FromRecordType.getQualifiers();
4816 Qualifiers ToQs = DestType.getQualifiers();
4817 unsigned CVR = FromQs.getCVRQualifiers() & ~ToQs.getCVRQualifiers();
4819 Diag(From->getLocStart(),
4820 diag::err_member_function_call_bad_cvr)
4821 << Method->getDeclName() << FromRecordType << (CVR - 1)
4822 << From->getSourceRange();
4823 Diag(Method->getLocation(), diag::note_previous_decl)
4824 << Method->getDeclName();
4829 return Diag(From->getLocStart(),
4830 diag::err_implicit_object_parameter_init)
4831 << ImplicitParamRecordType << FromRecordType << From->getSourceRange();
4834 if (ICS.Standard.Second == ICK_Derived_To_Base) {
4835 ExprResult FromRes =
4836 PerformObjectMemberConversion(From, Qualifier, FoundDecl, Method);
4837 if (FromRes.isInvalid())
4839 From = FromRes.take();
4842 if (!Context.hasSameType(From->getType(), DestType))
4843 From = ImpCastExprToType(From, DestType, CK_NoOp,
4844 From->getValueKind()).take();
4848 /// TryContextuallyConvertToBool - Attempt to contextually convert the
4849 /// expression From to bool (C++0x [conv]p3).
4850 static ImplicitConversionSequence
4851 TryContextuallyConvertToBool(Sema &S, Expr *From) {
4852 return TryImplicitConversion(S, From, S.Context.BoolTy,
4853 /*SuppressUserConversions=*/false,
4854 /*AllowExplicit=*/true,
4855 /*InOverloadResolution=*/false,
4857 /*AllowObjCWritebackConversion=*/false,
4858 /*AllowObjCConversionOnExplicit=*/false);
4861 /// PerformContextuallyConvertToBool - Perform a contextual conversion
4862 /// of the expression From to bool (C++0x [conv]p3).
4863 ExprResult Sema::PerformContextuallyConvertToBool(Expr *From) {
4864 if (checkPlaceholderForOverload(*this, From))
4867 ImplicitConversionSequence ICS = TryContextuallyConvertToBool(*this, From);
4869 return PerformImplicitConversion(From, Context.BoolTy, ICS, AA_Converting);
4871 if (!DiagnoseMultipleUserDefinedConversion(From, Context.BoolTy))
4872 return Diag(From->getLocStart(),
4873 diag::err_typecheck_bool_condition)
4874 << From->getType() << From->getSourceRange();
4878 /// Check that the specified conversion is permitted in a converted constant
4879 /// expression, according to C++11 [expr.const]p3. Return true if the conversion
4881 static bool CheckConvertedConstantConversions(Sema &S,
4882 StandardConversionSequence &SCS) {
4883 // Since we know that the target type is an integral or unscoped enumeration
4884 // type, most conversion kinds are impossible. All possible First and Third
4885 // conversions are fine.
4886 switch (SCS.Second) {
4888 case ICK_Integral_Promotion:
4889 case ICK_Integral_Conversion:
4890 case ICK_Zero_Event_Conversion:
4893 case ICK_Boolean_Conversion:
4894 // Conversion from an integral or unscoped enumeration type to bool is
4895 // classified as ICK_Boolean_Conversion, but it's also an integral
4896 // conversion, so it's permitted in a converted constant expression.
4897 return SCS.getFromType()->isIntegralOrUnscopedEnumerationType() &&
4898 SCS.getToType(2)->isBooleanType();
4900 case ICK_Floating_Integral:
4901 case ICK_Complex_Real:
4904 case ICK_Lvalue_To_Rvalue:
4905 case ICK_Array_To_Pointer:
4906 case ICK_Function_To_Pointer:
4907 case ICK_NoReturn_Adjustment:
4908 case ICK_Qualification:
4909 case ICK_Compatible_Conversion:
4910 case ICK_Vector_Conversion:
4911 case ICK_Vector_Splat:
4912 case ICK_Derived_To_Base:
4913 case ICK_Pointer_Conversion:
4914 case ICK_Pointer_Member:
4915 case ICK_Block_Pointer_Conversion:
4916 case ICK_Writeback_Conversion:
4917 case ICK_Floating_Promotion:
4918 case ICK_Complex_Promotion:
4919 case ICK_Complex_Conversion:
4920 case ICK_Floating_Conversion:
4921 case ICK_TransparentUnionConversion:
4922 llvm_unreachable("unexpected second conversion kind");
4924 case ICK_Num_Conversion_Kinds:
4928 llvm_unreachable("unknown conversion kind");
4931 /// CheckConvertedConstantExpression - Check that the expression From is a
4932 /// converted constant expression of type T, perform the conversion and produce
4933 /// the converted expression, per C++11 [expr.const]p3.
4934 ExprResult Sema::CheckConvertedConstantExpression(Expr *From, QualType T,
4935 llvm::APSInt &Value,
4937 assert(LangOpts.CPlusPlus11 && "converted constant expression outside C++11");
4938 assert(T->isIntegralOrEnumerationType() && "unexpected converted const type");
4940 if (checkPlaceholderForOverload(*this, From))
4943 // C++11 [expr.const]p3 with proposed wording fixes:
4944 // A converted constant expression of type T is a core constant expression,
4945 // implicitly converted to a prvalue of type T, where the converted
4946 // expression is a literal constant expression and the implicit conversion
4947 // sequence contains only user-defined conversions, lvalue-to-rvalue
4948 // conversions, integral promotions, and integral conversions other than
4949 // narrowing conversions.
4950 ImplicitConversionSequence ICS =
4951 TryImplicitConversion(From, T,
4952 /*SuppressUserConversions=*/false,
4953 /*AllowExplicit=*/false,
4954 /*InOverloadResolution=*/false,
4956 /*AllowObjcWritebackConversion=*/false);
4957 StandardConversionSequence *SCS = 0;
4958 switch (ICS.getKind()) {
4959 case ImplicitConversionSequence::StandardConversion:
4960 if (!CheckConvertedConstantConversions(*this, ICS.Standard))
4961 return Diag(From->getLocStart(),
4962 diag::err_typecheck_converted_constant_expression_disallowed)
4963 << From->getType() << From->getSourceRange() << T;
4964 SCS = &ICS.Standard;
4966 case ImplicitConversionSequence::UserDefinedConversion:
4967 // We are converting from class type to an integral or enumeration type, so
4968 // the Before sequence must be trivial.
4969 if (!CheckConvertedConstantConversions(*this, ICS.UserDefined.After))
4970 return Diag(From->getLocStart(),
4971 diag::err_typecheck_converted_constant_expression_disallowed)
4972 << From->getType() << From->getSourceRange() << T;
4973 SCS = &ICS.UserDefined.After;
4975 case ImplicitConversionSequence::AmbiguousConversion:
4976 case ImplicitConversionSequence::BadConversion:
4977 if (!DiagnoseMultipleUserDefinedConversion(From, T))
4978 return Diag(From->getLocStart(),
4979 diag::err_typecheck_converted_constant_expression)
4980 << From->getType() << From->getSourceRange() << T;
4983 case ImplicitConversionSequence::EllipsisConversion:
4984 llvm_unreachable("ellipsis conversion in converted constant expression");
4987 ExprResult Result = PerformImplicitConversion(From, T, ICS, AA_Converting);
4988 if (Result.isInvalid())
4991 // Check for a narrowing implicit conversion.
4992 APValue PreNarrowingValue;
4993 QualType PreNarrowingType;
4994 switch (SCS->getNarrowingKind(Context, Result.get(), PreNarrowingValue,
4995 PreNarrowingType)) {
4996 case NK_Variable_Narrowing:
4997 // Implicit conversion to a narrower type, and the value is not a constant
4998 // expression. We'll diagnose this in a moment.
4999 case NK_Not_Narrowing:
5002 case NK_Constant_Narrowing:
5003 Diag(From->getLocStart(), diag::ext_cce_narrowing)
5004 << CCE << /*Constant*/1
5005 << PreNarrowingValue.getAsString(Context, PreNarrowingType) << T;
5008 case NK_Type_Narrowing:
5009 Diag(From->getLocStart(), diag::ext_cce_narrowing)
5010 << CCE << /*Constant*/0 << From->getType() << T;
5014 // Check the expression is a constant expression.
5015 SmallVector<PartialDiagnosticAt, 8> Notes;
5016 Expr::EvalResult Eval;
5019 if (!Result.get()->EvaluateAsRValue(Eval, Context) || !Eval.Val.isInt()) {
5020 // The expression can't be folded, so we can't keep it at this position in
5022 Result = ExprError();
5024 Value = Eval.Val.getInt();
5026 if (Notes.empty()) {
5027 // It's a constant expression.
5032 // It's not a constant expression. Produce an appropriate diagnostic.
5033 if (Notes.size() == 1 &&
5034 Notes[0].second.getDiagID() == diag::note_invalid_subexpr_in_const_expr)
5035 Diag(Notes[0].first, diag::err_expr_not_cce) << CCE;
5037 Diag(From->getLocStart(), diag::err_expr_not_cce)
5038 << CCE << From->getSourceRange();
5039 for (unsigned I = 0; I < Notes.size(); ++I)
5040 Diag(Notes[I].first, Notes[I].second);
5045 /// dropPointerConversions - If the given standard conversion sequence
5046 /// involves any pointer conversions, remove them. This may change
5047 /// the result type of the conversion sequence.
5048 static void dropPointerConversion(StandardConversionSequence &SCS) {
5049 if (SCS.Second == ICK_Pointer_Conversion) {
5050 SCS.Second = ICK_Identity;
5051 SCS.Third = ICK_Identity;
5052 SCS.ToTypePtrs[2] = SCS.ToTypePtrs[1] = SCS.ToTypePtrs[0];
5056 /// TryContextuallyConvertToObjCPointer - Attempt to contextually
5057 /// convert the expression From to an Objective-C pointer type.
5058 static ImplicitConversionSequence
5059 TryContextuallyConvertToObjCPointer(Sema &S, Expr *From) {
5060 // Do an implicit conversion to 'id'.
5061 QualType Ty = S.Context.getObjCIdType();
5062 ImplicitConversionSequence ICS
5063 = TryImplicitConversion(S, From, Ty,
5064 // FIXME: Are these flags correct?
5065 /*SuppressUserConversions=*/false,
5066 /*AllowExplicit=*/true,
5067 /*InOverloadResolution=*/false,
5069 /*AllowObjCWritebackConversion=*/false,
5070 /*AllowObjCConversionOnExplicit=*/true);
5072 // Strip off any final conversions to 'id'.
5073 switch (ICS.getKind()) {
5074 case ImplicitConversionSequence::BadConversion:
5075 case ImplicitConversionSequence::AmbiguousConversion:
5076 case ImplicitConversionSequence::EllipsisConversion:
5079 case ImplicitConversionSequence::UserDefinedConversion:
5080 dropPointerConversion(ICS.UserDefined.After);
5083 case ImplicitConversionSequence::StandardConversion:
5084 dropPointerConversion(ICS.Standard);
5091 /// PerformContextuallyConvertToObjCPointer - Perform a contextual
5092 /// conversion of the expression From to an Objective-C pointer type.
5093 ExprResult Sema::PerformContextuallyConvertToObjCPointer(Expr *From) {
5094 if (checkPlaceholderForOverload(*this, From))
5097 QualType Ty = Context.getObjCIdType();
5098 ImplicitConversionSequence ICS =
5099 TryContextuallyConvertToObjCPointer(*this, From);
5101 return PerformImplicitConversion(From, Ty, ICS, AA_Converting);
5105 /// Determine whether the provided type is an integral type, or an enumeration
5106 /// type of a permitted flavor.
5107 bool Sema::ICEConvertDiagnoser::match(QualType T) {
5108 return AllowScopedEnumerations ? T->isIntegralOrEnumerationType()
5109 : T->isIntegralOrUnscopedEnumerationType();
5113 diagnoseAmbiguousConversion(Sema &SemaRef, SourceLocation Loc, Expr *From,
5114 Sema::ContextualImplicitConverter &Converter,
5115 QualType T, UnresolvedSetImpl &ViableConversions) {
5117 if (Converter.Suppress)
5120 Converter.diagnoseAmbiguous(SemaRef, Loc, T) << From->getSourceRange();
5121 for (unsigned I = 0, N = ViableConversions.size(); I != N; ++I) {
5122 CXXConversionDecl *Conv =
5123 cast<CXXConversionDecl>(ViableConversions[I]->getUnderlyingDecl());
5124 QualType ConvTy = Conv->getConversionType().getNonReferenceType();
5125 Converter.noteAmbiguous(SemaRef, Conv, ConvTy);
5127 return SemaRef.Owned(From);
5131 diagnoseNoViableConversion(Sema &SemaRef, SourceLocation Loc, Expr *&From,
5132 Sema::ContextualImplicitConverter &Converter,
5133 QualType T, bool HadMultipleCandidates,
5134 UnresolvedSetImpl &ExplicitConversions) {
5135 if (ExplicitConversions.size() == 1 && !Converter.Suppress) {
5136 DeclAccessPair Found = ExplicitConversions[0];
5137 CXXConversionDecl *Conversion =
5138 cast<CXXConversionDecl>(Found->getUnderlyingDecl());
5140 // The user probably meant to invoke the given explicit
5141 // conversion; use it.
5142 QualType ConvTy = Conversion->getConversionType().getNonReferenceType();
5143 std::string TypeStr;
5144 ConvTy.getAsStringInternal(TypeStr, SemaRef.getPrintingPolicy());
5146 Converter.diagnoseExplicitConv(SemaRef, Loc, T, ConvTy)
5147 << FixItHint::CreateInsertion(From->getLocStart(),
5148 "static_cast<" + TypeStr + ">(")
5149 << FixItHint::CreateInsertion(
5150 SemaRef.PP.getLocForEndOfToken(From->getLocEnd()), ")");
5151 Converter.noteExplicitConv(SemaRef, Conversion, ConvTy);
5153 // If we aren't in a SFINAE context, build a call to the
5154 // explicit conversion function.
5155 if (SemaRef.isSFINAEContext())
5158 SemaRef.CheckMemberOperatorAccess(From->getExprLoc(), From, 0, Found);
5159 ExprResult Result = SemaRef.BuildCXXMemberCallExpr(From, Found, Conversion,
5160 HadMultipleCandidates);
5161 if (Result.isInvalid())
5163 // Record usage of conversion in an implicit cast.
5164 From = ImplicitCastExpr::Create(SemaRef.Context, Result.get()->getType(),
5165 CK_UserDefinedConversion, Result.get(), 0,
5166 Result.get()->getValueKind());
5171 static bool recordConversion(Sema &SemaRef, SourceLocation Loc, Expr *&From,
5172 Sema::ContextualImplicitConverter &Converter,
5173 QualType T, bool HadMultipleCandidates,
5174 DeclAccessPair &Found) {
5175 CXXConversionDecl *Conversion =
5176 cast<CXXConversionDecl>(Found->getUnderlyingDecl());
5177 SemaRef.CheckMemberOperatorAccess(From->getExprLoc(), From, 0, Found);
5179 QualType ToType = Conversion->getConversionType().getNonReferenceType();
5180 if (!Converter.SuppressConversion) {
5181 if (SemaRef.isSFINAEContext())
5184 Converter.diagnoseConversion(SemaRef, Loc, T, ToType)
5185 << From->getSourceRange();
5188 ExprResult Result = SemaRef.BuildCXXMemberCallExpr(From, Found, Conversion,
5189 HadMultipleCandidates);
5190 if (Result.isInvalid())
5192 // Record usage of conversion in an implicit cast.
5193 From = ImplicitCastExpr::Create(SemaRef.Context, Result.get()->getType(),
5194 CK_UserDefinedConversion, Result.get(), 0,
5195 Result.get()->getValueKind());
5199 static ExprResult finishContextualImplicitConversion(
5200 Sema &SemaRef, SourceLocation Loc, Expr *From,
5201 Sema::ContextualImplicitConverter &Converter) {
5202 if (!Converter.match(From->getType()) && !Converter.Suppress)
5203 Converter.diagnoseNoMatch(SemaRef, Loc, From->getType())
5204 << From->getSourceRange();
5206 return SemaRef.DefaultLvalueConversion(From);
5210 collectViableConversionCandidates(Sema &SemaRef, Expr *From, QualType ToType,
5211 UnresolvedSetImpl &ViableConversions,
5212 OverloadCandidateSet &CandidateSet) {
5213 for (unsigned I = 0, N = ViableConversions.size(); I != N; ++I) {
5214 DeclAccessPair FoundDecl = ViableConversions[I];
5215 NamedDecl *D = FoundDecl.getDecl();
5216 CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext());
5217 if (isa<UsingShadowDecl>(D))
5218 D = cast<UsingShadowDecl>(D)->getTargetDecl();
5220 CXXConversionDecl *Conv;
5221 FunctionTemplateDecl *ConvTemplate;
5222 if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D)))
5223 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
5225 Conv = cast<CXXConversionDecl>(D);
5228 SemaRef.AddTemplateConversionCandidate(
5229 ConvTemplate, FoundDecl, ActingContext, From, ToType, CandidateSet,
5230 /*AllowObjCConversionOnExplicit=*/false);
5232 SemaRef.AddConversionCandidate(Conv, FoundDecl, ActingContext, From,
5233 ToType, CandidateSet,
5234 /*AllowObjCConversionOnExplicit=*/false);
5238 /// \brief Attempt to convert the given expression to a type which is accepted
5239 /// by the given converter.
5241 /// This routine will attempt to convert an expression of class type to a
5242 /// type accepted by the specified converter. In C++11 and before, the class
5243 /// must have a single non-explicit conversion function converting to a matching
5244 /// type. In C++1y, there can be multiple such conversion functions, but only
5245 /// one target type.
5247 /// \param Loc The source location of the construct that requires the
5250 /// \param From The expression we're converting from.
5252 /// \param Converter Used to control and diagnose the conversion process.
5254 /// \returns The expression, converted to an integral or enumeration type if
5256 ExprResult Sema::PerformContextualImplicitConversion(
5257 SourceLocation Loc, Expr *From, ContextualImplicitConverter &Converter) {
5258 // We can't perform any more checking for type-dependent expressions.
5259 if (From->isTypeDependent())
5262 // Process placeholders immediately.
5263 if (From->hasPlaceholderType()) {
5264 ExprResult result = CheckPlaceholderExpr(From);
5265 if (result.isInvalid())
5267 From = result.take();
5270 // If the expression already has a matching type, we're golden.
5271 QualType T = From->getType();
5272 if (Converter.match(T))
5273 return DefaultLvalueConversion(From);
5275 // FIXME: Check for missing '()' if T is a function type?
5277 // We can only perform contextual implicit conversions on objects of class
5279 const RecordType *RecordTy = T->getAs<RecordType>();
5280 if (!RecordTy || !getLangOpts().CPlusPlus) {
5281 if (!Converter.Suppress)
5282 Converter.diagnoseNoMatch(*this, Loc, T) << From->getSourceRange();
5286 // We must have a complete class type.
5287 struct TypeDiagnoserPartialDiag : TypeDiagnoser {
5288 ContextualImplicitConverter &Converter;
5291 TypeDiagnoserPartialDiag(ContextualImplicitConverter &Converter, Expr *From)
5292 : TypeDiagnoser(Converter.Suppress), Converter(Converter), From(From) {}
5294 virtual void diagnose(Sema &S, SourceLocation Loc, QualType T) {
5295 Converter.diagnoseIncomplete(S, Loc, T) << From->getSourceRange();
5297 } IncompleteDiagnoser(Converter, From);
5299 if (RequireCompleteType(Loc, T, IncompleteDiagnoser))
5302 // Look for a conversion to an integral or enumeration type.
5304 ViableConversions; // These are *potentially* viable in C++1y.
5305 UnresolvedSet<4> ExplicitConversions;
5306 std::pair<CXXRecordDecl::conversion_iterator,
5307 CXXRecordDecl::conversion_iterator> Conversions =
5308 cast<CXXRecordDecl>(RecordTy->getDecl())->getVisibleConversionFunctions();
5310 bool HadMultipleCandidates =
5311 (std::distance(Conversions.first, Conversions.second) > 1);
5313 // To check that there is only one target type, in C++1y:
5315 bool HasUniqueTargetType = true;
5317 // Collect explicit or viable (potentially in C++1y) conversions.
5318 for (CXXRecordDecl::conversion_iterator I = Conversions.first,
5319 E = Conversions.second;
5321 NamedDecl *D = (*I)->getUnderlyingDecl();
5322 CXXConversionDecl *Conversion;
5323 FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
5325 if (getLangOpts().CPlusPlus1y)
5326 Conversion = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
5328 continue; // C++11 does not consider conversion operator templates(?).
5330 Conversion = cast<CXXConversionDecl>(D);
5332 assert((!ConvTemplate || getLangOpts().CPlusPlus1y) &&
5333 "Conversion operator templates are considered potentially "
5336 QualType CurToType = Conversion->getConversionType().getNonReferenceType();
5337 if (Converter.match(CurToType) || ConvTemplate) {
5339 if (Conversion->isExplicit()) {
5340 // FIXME: For C++1y, do we need this restriction?
5341 // cf. diagnoseNoViableConversion()
5343 ExplicitConversions.addDecl(I.getDecl(), I.getAccess());
5345 if (!ConvTemplate && getLangOpts().CPlusPlus1y) {
5346 if (ToType.isNull())
5347 ToType = CurToType.getUnqualifiedType();
5348 else if (HasUniqueTargetType &&
5349 (CurToType.getUnqualifiedType() != ToType))
5350 HasUniqueTargetType = false;
5352 ViableConversions.addDecl(I.getDecl(), I.getAccess());
5357 if (getLangOpts().CPlusPlus1y) {
5359 // ... An expression e of class type E appearing in such a context
5360 // is said to be contextually implicitly converted to a specified
5361 // type T and is well-formed if and only if e can be implicitly
5362 // converted to a type T that is determined as follows: E is searched
5363 // for conversion functions whose return type is cv T or reference to
5364 // cv T such that T is allowed by the context. There shall be
5365 // exactly one such T.
5367 // If no unique T is found:
5368 if (ToType.isNull()) {
5369 if (diagnoseNoViableConversion(*this, Loc, From, Converter, T,
5370 HadMultipleCandidates,
5371 ExplicitConversions))
5373 return finishContextualImplicitConversion(*this, Loc, From, Converter);
5376 // If more than one unique Ts are found:
5377 if (!HasUniqueTargetType)
5378 return diagnoseAmbiguousConversion(*this, Loc, From, Converter, T,
5381 // If one unique T is found:
5382 // First, build a candidate set from the previously recorded
5383 // potentially viable conversions.
5384 OverloadCandidateSet CandidateSet(Loc);
5385 collectViableConversionCandidates(*this, From, ToType, ViableConversions,
5388 // Then, perform overload resolution over the candidate set.
5389 OverloadCandidateSet::iterator Best;
5390 switch (CandidateSet.BestViableFunction(*this, Loc, Best)) {
5392 // Apply this conversion.
5393 DeclAccessPair Found =
5394 DeclAccessPair::make(Best->Function, Best->FoundDecl.getAccess());
5395 if (recordConversion(*this, Loc, From, Converter, T,
5396 HadMultipleCandidates, Found))
5401 return diagnoseAmbiguousConversion(*this, Loc, From, Converter, T,
5403 case OR_No_Viable_Function:
5404 if (diagnoseNoViableConversion(*this, Loc, From, Converter, T,
5405 HadMultipleCandidates,
5406 ExplicitConversions))
5408 // fall through 'OR_Deleted' case.
5410 // We'll complain below about a non-integral condition type.
5414 switch (ViableConversions.size()) {
5416 if (diagnoseNoViableConversion(*this, Loc, From, Converter, T,
5417 HadMultipleCandidates,
5418 ExplicitConversions))
5421 // We'll complain below about a non-integral condition type.
5425 // Apply this conversion.
5426 DeclAccessPair Found = ViableConversions[0];
5427 if (recordConversion(*this, Loc, From, Converter, T,
5428 HadMultipleCandidates, Found))
5433 return diagnoseAmbiguousConversion(*this, Loc, From, Converter, T,
5438 return finishContextualImplicitConversion(*this, Loc, From, Converter);
5441 /// AddOverloadCandidate - Adds the given function to the set of
5442 /// candidate functions, using the given function call arguments. If
5443 /// @p SuppressUserConversions, then don't allow user-defined
5444 /// conversions via constructors or conversion operators.
5446 /// \param PartialOverloading true if we are performing "partial" overloading
5447 /// based on an incomplete set of function arguments. This feature is used by
5448 /// code completion.
5450 Sema::AddOverloadCandidate(FunctionDecl *Function,
5451 DeclAccessPair FoundDecl,
5452 ArrayRef<Expr *> Args,
5453 OverloadCandidateSet& CandidateSet,
5454 bool SuppressUserConversions,
5455 bool PartialOverloading,
5456 bool AllowExplicit) {
5457 const FunctionProtoType* Proto
5458 = dyn_cast<FunctionProtoType>(Function->getType()->getAs<FunctionType>());
5459 assert(Proto && "Functions without a prototype cannot be overloaded");
5460 assert(!Function->getDescribedFunctionTemplate() &&
5461 "Use AddTemplateOverloadCandidate for function templates");
5463 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Function)) {
5464 if (!isa<CXXConstructorDecl>(Method)) {
5465 // If we get here, it's because we're calling a member function
5466 // that is named without a member access expression (e.g.,
5467 // "this->f") that was either written explicitly or created
5468 // implicitly. This can happen with a qualified call to a member
5469 // function, e.g., X::f(). We use an empty type for the implied
5470 // object argument (C++ [over.call.func]p3), and the acting context
5472 AddMethodCandidate(Method, FoundDecl, Method->getParent(),
5473 QualType(), Expr::Classification::makeSimpleLValue(),
5474 Args, CandidateSet, SuppressUserConversions);
5477 // We treat a constructor like a non-member function, since its object
5478 // argument doesn't participate in overload resolution.
5481 if (!CandidateSet.isNewCandidate(Function))
5484 // C++11 [class.copy]p11: [DR1402]
5485 // A defaulted move constructor that is defined as deleted is ignored by
5486 // overload resolution.
5487 CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Function);
5488 if (Constructor && Constructor->isDefaulted() && Constructor->isDeleted() &&
5489 Constructor->isMoveConstructor())
5492 // Overload resolution is always an unevaluated context.
5493 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
5496 // C++ [class.copy]p3:
5497 // A member function template is never instantiated to perform the copy
5498 // of a class object to an object of its class type.
5499 QualType ClassType = Context.getTypeDeclType(Constructor->getParent());
5500 if (Args.size() == 1 &&
5501 Constructor->isSpecializationCopyingObject() &&
5502 (Context.hasSameUnqualifiedType(ClassType, Args[0]->getType()) ||
5503 IsDerivedFrom(Args[0]->getType(), ClassType)))
5507 // Add this candidate
5508 OverloadCandidate &Candidate = CandidateSet.addCandidate(Args.size());
5509 Candidate.FoundDecl = FoundDecl;
5510 Candidate.Function = Function;
5511 Candidate.Viable = true;
5512 Candidate.IsSurrogate = false;
5513 Candidate.IgnoreObjectArgument = false;
5514 Candidate.ExplicitCallArguments = Args.size();
5516 unsigned NumArgsInProto = Proto->getNumArgs();
5518 // (C++ 13.3.2p2): A candidate function having fewer than m
5519 // parameters is viable only if it has an ellipsis in its parameter
5521 if ((Args.size() + (PartialOverloading && Args.size())) > NumArgsInProto &&
5522 !Proto->isVariadic()) {
5523 Candidate.Viable = false;
5524 Candidate.FailureKind = ovl_fail_too_many_arguments;
5528 // (C++ 13.3.2p2): A candidate function having more than m parameters
5529 // is viable only if the (m+1)st parameter has a default argument
5530 // (8.3.6). For the purposes of overload resolution, the
5531 // parameter list is truncated on the right, so that there are
5532 // exactly m parameters.
5533 unsigned MinRequiredArgs = Function->getMinRequiredArguments();
5534 if (Args.size() < MinRequiredArgs && !PartialOverloading) {
5535 // Not enough arguments.
5536 Candidate.Viable = false;
5537 Candidate.FailureKind = ovl_fail_too_few_arguments;
5541 // (CUDA B.1): Check for invalid calls between targets.
5542 if (getLangOpts().CUDA)
5543 if (const FunctionDecl *Caller = dyn_cast<FunctionDecl>(CurContext))
5544 if (CheckCUDATarget(Caller, Function)) {
5545 Candidate.Viable = false;
5546 Candidate.FailureKind = ovl_fail_bad_target;
5550 // Determine the implicit conversion sequences for each of the
5552 for (unsigned ArgIdx = 0; ArgIdx < Args.size(); ++ArgIdx) {
5553 if (ArgIdx < NumArgsInProto) {
5554 // (C++ 13.3.2p3): for F to be a viable function, there shall
5555 // exist for each argument an implicit conversion sequence
5556 // (13.3.3.1) that converts that argument to the corresponding
5558 QualType ParamType = Proto->getArgType(ArgIdx);
5559 Candidate.Conversions[ArgIdx]
5560 = TryCopyInitialization(*this, Args[ArgIdx], ParamType,
5561 SuppressUserConversions,
5562 /*InOverloadResolution=*/true,
5563 /*AllowObjCWritebackConversion=*/
5564 getLangOpts().ObjCAutoRefCount,
5566 if (Candidate.Conversions[ArgIdx].isBad()) {
5567 Candidate.Viable = false;
5568 Candidate.FailureKind = ovl_fail_bad_conversion;
5572 // (C++ 13.3.2p2): For the purposes of overload resolution, any
5573 // argument for which there is no corresponding parameter is
5574 // considered to ""match the ellipsis" (C+ 13.3.3.1.3).
5575 Candidate.Conversions[ArgIdx].setEllipsis();
5580 /// \brief Add all of the function declarations in the given function set to
5581 /// the overload candidate set.
5582 void Sema::AddFunctionCandidates(const UnresolvedSetImpl &Fns,
5583 ArrayRef<Expr *> Args,
5584 OverloadCandidateSet& CandidateSet,
5585 bool SuppressUserConversions,
5586 TemplateArgumentListInfo *ExplicitTemplateArgs) {
5587 for (UnresolvedSetIterator F = Fns.begin(), E = Fns.end(); F != E; ++F) {
5588 NamedDecl *D = F.getDecl()->getUnderlyingDecl();
5589 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
5590 if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic())
5591 AddMethodCandidate(cast<CXXMethodDecl>(FD), F.getPair(),
5592 cast<CXXMethodDecl>(FD)->getParent(),
5593 Args[0]->getType(), Args[0]->Classify(Context),
5594 Args.slice(1), CandidateSet,
5595 SuppressUserConversions);
5597 AddOverloadCandidate(FD, F.getPair(), Args, CandidateSet,
5598 SuppressUserConversions);
5600 FunctionTemplateDecl *FunTmpl = cast<FunctionTemplateDecl>(D);
5601 if (isa<CXXMethodDecl>(FunTmpl->getTemplatedDecl()) &&
5602 !cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl())->isStatic())
5603 AddMethodTemplateCandidate(FunTmpl, F.getPair(),
5604 cast<CXXRecordDecl>(FunTmpl->getDeclContext()),
5605 ExplicitTemplateArgs,
5607 Args[0]->Classify(Context), Args.slice(1),
5608 CandidateSet, SuppressUserConversions);
5610 AddTemplateOverloadCandidate(FunTmpl, F.getPair(),
5611 ExplicitTemplateArgs, Args,
5612 CandidateSet, SuppressUserConversions);
5617 /// AddMethodCandidate - Adds a named decl (which is some kind of
5618 /// method) as a method candidate to the given overload set.
5619 void Sema::AddMethodCandidate(DeclAccessPair FoundDecl,
5620 QualType ObjectType,
5621 Expr::Classification ObjectClassification,
5622 ArrayRef<Expr *> Args,
5623 OverloadCandidateSet& CandidateSet,
5624 bool SuppressUserConversions) {
5625 NamedDecl *Decl = FoundDecl.getDecl();
5626 CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(Decl->getDeclContext());
5628 if (isa<UsingShadowDecl>(Decl))
5629 Decl = cast<UsingShadowDecl>(Decl)->getTargetDecl();
5631 if (FunctionTemplateDecl *TD = dyn_cast<FunctionTemplateDecl>(Decl)) {
5632 assert(isa<CXXMethodDecl>(TD->getTemplatedDecl()) &&
5633 "Expected a member function template");
5634 AddMethodTemplateCandidate(TD, FoundDecl, ActingContext,
5636 ObjectType, ObjectClassification,
5638 SuppressUserConversions);
5640 AddMethodCandidate(cast<CXXMethodDecl>(Decl), FoundDecl, ActingContext,
5641 ObjectType, ObjectClassification,
5643 CandidateSet, SuppressUserConversions);
5647 /// AddMethodCandidate - Adds the given C++ member function to the set
5648 /// of candidate functions, using the given function call arguments
5649 /// and the object argument (@c Object). For example, in a call
5650 /// @c o.f(a1,a2), @c Object will contain @c o and @c Args will contain
5651 /// both @c a1 and @c a2. If @p SuppressUserConversions, then don't
5652 /// allow user-defined conversions via constructors or conversion
5655 Sema::AddMethodCandidate(CXXMethodDecl *Method, DeclAccessPair FoundDecl,
5656 CXXRecordDecl *ActingContext, QualType ObjectType,
5657 Expr::Classification ObjectClassification,
5658 ArrayRef<Expr *> Args,
5659 OverloadCandidateSet& CandidateSet,
5660 bool SuppressUserConversions) {
5661 const FunctionProtoType* Proto
5662 = dyn_cast<FunctionProtoType>(Method->getType()->getAs<FunctionType>());
5663 assert(Proto && "Methods without a prototype cannot be overloaded");
5664 assert(!isa<CXXConstructorDecl>(Method) &&
5665 "Use AddOverloadCandidate for constructors");
5667 if (!CandidateSet.isNewCandidate(Method))
5670 // C++11 [class.copy]p23: [DR1402]
5671 // A defaulted move assignment operator that is defined as deleted is
5672 // ignored by overload resolution.
5673 if (Method->isDefaulted() && Method->isDeleted() &&
5674 Method->isMoveAssignmentOperator())
5677 // Overload resolution is always an unevaluated context.
5678 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
5680 // Add this candidate
5681 OverloadCandidate &Candidate = CandidateSet.addCandidate(Args.size() + 1);
5682 Candidate.FoundDecl = FoundDecl;
5683 Candidate.Function = Method;
5684 Candidate.IsSurrogate = false;
5685 Candidate.IgnoreObjectArgument = false;
5686 Candidate.ExplicitCallArguments = Args.size();
5688 unsigned NumArgsInProto = Proto->getNumArgs();
5690 // (C++ 13.3.2p2): A candidate function having fewer than m
5691 // parameters is viable only if it has an ellipsis in its parameter
5693 if (Args.size() > NumArgsInProto && !Proto->isVariadic()) {
5694 Candidate.Viable = false;
5695 Candidate.FailureKind = ovl_fail_too_many_arguments;
5699 // (C++ 13.3.2p2): A candidate function having more than m parameters
5700 // is viable only if the (m+1)st parameter has a default argument
5701 // (8.3.6). For the purposes of overload resolution, the
5702 // parameter list is truncated on the right, so that there are
5703 // exactly m parameters.
5704 unsigned MinRequiredArgs = Method->getMinRequiredArguments();
5705 if (Args.size() < MinRequiredArgs) {
5706 // Not enough arguments.
5707 Candidate.Viable = false;
5708 Candidate.FailureKind = ovl_fail_too_few_arguments;
5712 Candidate.Viable = true;
5714 if (Method->isStatic() || ObjectType.isNull())
5715 // The implicit object argument is ignored.
5716 Candidate.IgnoreObjectArgument = true;
5718 // Determine the implicit conversion sequence for the object
5720 Candidate.Conversions[0]
5721 = TryObjectArgumentInitialization(*this, ObjectType, ObjectClassification,
5722 Method, ActingContext);
5723 if (Candidate.Conversions[0].isBad()) {
5724 Candidate.Viable = false;
5725 Candidate.FailureKind = ovl_fail_bad_conversion;
5730 // Determine the implicit conversion sequences for each of the
5732 for (unsigned ArgIdx = 0; ArgIdx < Args.size(); ++ArgIdx) {
5733 if (ArgIdx < NumArgsInProto) {
5734 // (C++ 13.3.2p3): for F to be a viable function, there shall
5735 // exist for each argument an implicit conversion sequence
5736 // (13.3.3.1) that converts that argument to the corresponding
5738 QualType ParamType = Proto->getArgType(ArgIdx);
5739 Candidate.Conversions[ArgIdx + 1]
5740 = TryCopyInitialization(*this, Args[ArgIdx], ParamType,
5741 SuppressUserConversions,
5742 /*InOverloadResolution=*/true,
5743 /*AllowObjCWritebackConversion=*/
5744 getLangOpts().ObjCAutoRefCount);
5745 if (Candidate.Conversions[ArgIdx + 1].isBad()) {
5746 Candidate.Viable = false;
5747 Candidate.FailureKind = ovl_fail_bad_conversion;
5751 // (C++ 13.3.2p2): For the purposes of overload resolution, any
5752 // argument for which there is no corresponding parameter is
5753 // considered to ""match the ellipsis" (C+ 13.3.3.1.3).
5754 Candidate.Conversions[ArgIdx + 1].setEllipsis();
5759 /// \brief Add a C++ member function template as a candidate to the candidate
5760 /// set, using template argument deduction to produce an appropriate member
5761 /// function template specialization.
5763 Sema::AddMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl,
5764 DeclAccessPair FoundDecl,
5765 CXXRecordDecl *ActingContext,
5766 TemplateArgumentListInfo *ExplicitTemplateArgs,
5767 QualType ObjectType,
5768 Expr::Classification ObjectClassification,
5769 ArrayRef<Expr *> Args,
5770 OverloadCandidateSet& CandidateSet,
5771 bool SuppressUserConversions) {
5772 if (!CandidateSet.isNewCandidate(MethodTmpl))
5775 // C++ [over.match.funcs]p7:
5776 // In each case where a candidate is a function template, candidate
5777 // function template specializations are generated using template argument
5778 // deduction (14.8.3, 14.8.2). Those candidates are then handled as
5779 // candidate functions in the usual way.113) A given name can refer to one
5780 // or more function templates and also to a set of overloaded non-template
5781 // functions. In such a case, the candidate functions generated from each
5782 // function template are combined with the set of non-template candidate
5784 TemplateDeductionInfo Info(CandidateSet.getLocation());
5785 FunctionDecl *Specialization = 0;
5786 if (TemplateDeductionResult Result
5787 = DeduceTemplateArguments(MethodTmpl, ExplicitTemplateArgs, Args,
5788 Specialization, Info)) {
5789 OverloadCandidate &Candidate = CandidateSet.addCandidate();
5790 Candidate.FoundDecl = FoundDecl;
5791 Candidate.Function = MethodTmpl->getTemplatedDecl();
5792 Candidate.Viable = false;
5793 Candidate.FailureKind = ovl_fail_bad_deduction;
5794 Candidate.IsSurrogate = false;
5795 Candidate.IgnoreObjectArgument = false;
5796 Candidate.ExplicitCallArguments = Args.size();
5797 Candidate.DeductionFailure = MakeDeductionFailureInfo(Context, Result,
5802 // Add the function template specialization produced by template argument
5803 // deduction as a candidate.
5804 assert(Specialization && "Missing member function template specialization?");
5805 assert(isa<CXXMethodDecl>(Specialization) &&
5806 "Specialization is not a member function?");
5807 AddMethodCandidate(cast<CXXMethodDecl>(Specialization), FoundDecl,
5808 ActingContext, ObjectType, ObjectClassification, Args,
5809 CandidateSet, SuppressUserConversions);
5812 /// \brief Add a C++ function template specialization as a candidate
5813 /// in the candidate set, using template argument deduction to produce
5814 /// an appropriate function template specialization.
5816 Sema::AddTemplateOverloadCandidate(FunctionTemplateDecl *FunctionTemplate,
5817 DeclAccessPair FoundDecl,
5818 TemplateArgumentListInfo *ExplicitTemplateArgs,
5819 ArrayRef<Expr *> Args,
5820 OverloadCandidateSet& CandidateSet,
5821 bool SuppressUserConversions) {
5822 if (!CandidateSet.isNewCandidate(FunctionTemplate))
5825 // C++ [over.match.funcs]p7:
5826 // In each case where a candidate is a function template, candidate
5827 // function template specializations are generated using template argument
5828 // deduction (14.8.3, 14.8.2). Those candidates are then handled as
5829 // candidate functions in the usual way.113) A given name can refer to one
5830 // or more function templates and also to a set of overloaded non-template
5831 // functions. In such a case, the candidate functions generated from each
5832 // function template are combined with the set of non-template candidate
5834 TemplateDeductionInfo Info(CandidateSet.getLocation());
5835 FunctionDecl *Specialization = 0;
5836 if (TemplateDeductionResult Result
5837 = DeduceTemplateArguments(FunctionTemplate, ExplicitTemplateArgs, Args,
5838 Specialization, Info)) {
5839 OverloadCandidate &Candidate = CandidateSet.addCandidate();
5840 Candidate.FoundDecl = FoundDecl;
5841 Candidate.Function = FunctionTemplate->getTemplatedDecl();
5842 Candidate.Viable = false;
5843 Candidate.FailureKind = ovl_fail_bad_deduction;
5844 Candidate.IsSurrogate = false;
5845 Candidate.IgnoreObjectArgument = false;
5846 Candidate.ExplicitCallArguments = Args.size();
5847 Candidate.DeductionFailure = MakeDeductionFailureInfo(Context, Result,
5852 // Add the function template specialization produced by template argument
5853 // deduction as a candidate.
5854 assert(Specialization && "Missing function template specialization?");
5855 AddOverloadCandidate(Specialization, FoundDecl, Args, CandidateSet,
5856 SuppressUserConversions);
5859 /// Determine whether this is an allowable conversion from the result
5860 /// of an explicit conversion operator to the expected type, per C++
5861 /// [over.match.conv]p1 and [over.match.ref]p1.
5863 /// \param ConvType The return type of the conversion function.
5865 /// \param ToType The type we are converting to.
5867 /// \param AllowObjCPointerConversion Allow a conversion from one
5868 /// Objective-C pointer to another.
5870 /// \returns true if the conversion is allowable, false otherwise.
5871 static bool isAllowableExplicitConversion(Sema &S,
5872 QualType ConvType, QualType ToType,
5873 bool AllowObjCPointerConversion) {
5874 QualType ToNonRefType = ToType.getNonReferenceType();
5876 // Easy case: the types are the same.
5877 if (S.Context.hasSameUnqualifiedType(ConvType, ToNonRefType))
5880 // Allow qualification conversions.
5881 bool ObjCLifetimeConversion;
5882 if (S.IsQualificationConversion(ConvType, ToNonRefType, /*CStyle*/false,
5883 ObjCLifetimeConversion))
5886 // If we're not allowed to consider Objective-C pointer conversions,
5888 if (!AllowObjCPointerConversion)
5891 // Is this an Objective-C pointer conversion?
5892 bool IncompatibleObjC = false;
5893 QualType ConvertedType;
5894 return S.isObjCPointerConversion(ConvType, ToNonRefType, ConvertedType,
5898 /// AddConversionCandidate - Add a C++ conversion function as a
5899 /// candidate in the candidate set (C++ [over.match.conv],
5900 /// C++ [over.match.copy]). From is the expression we're converting from,
5901 /// and ToType is the type that we're eventually trying to convert to
5902 /// (which may or may not be the same type as the type that the
5903 /// conversion function produces).
5905 Sema::AddConversionCandidate(CXXConversionDecl *Conversion,
5906 DeclAccessPair FoundDecl,
5907 CXXRecordDecl *ActingContext,
5908 Expr *From, QualType ToType,
5909 OverloadCandidateSet& CandidateSet,
5910 bool AllowObjCConversionOnExplicit) {
5911 assert(!Conversion->getDescribedFunctionTemplate() &&
5912 "Conversion function templates use AddTemplateConversionCandidate");
5913 QualType ConvType = Conversion->getConversionType().getNonReferenceType();
5914 if (!CandidateSet.isNewCandidate(Conversion))
5917 // If the conversion function has an undeduced return type, trigger its
5919 if (getLangOpts().CPlusPlus1y && ConvType->isUndeducedType()) {
5920 if (DeduceReturnType(Conversion, From->getExprLoc()))
5922 ConvType = Conversion->getConversionType().getNonReferenceType();
5925 // Per C++ [over.match.conv]p1, [over.match.ref]p1, an explicit conversion
5926 // operator is only a candidate if its return type is the target type or
5927 // can be converted to the target type with a qualification conversion.
5928 if (Conversion->isExplicit() &&
5929 !isAllowableExplicitConversion(*this, ConvType, ToType,
5930 AllowObjCConversionOnExplicit))
5933 // Overload resolution is always an unevaluated context.
5934 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
5936 // Add this candidate
5937 OverloadCandidate &Candidate = CandidateSet.addCandidate(1);
5938 Candidate.FoundDecl = FoundDecl;
5939 Candidate.Function = Conversion;
5940 Candidate.IsSurrogate = false;
5941 Candidate.IgnoreObjectArgument = false;
5942 Candidate.FinalConversion.setAsIdentityConversion();
5943 Candidate.FinalConversion.setFromType(ConvType);
5944 Candidate.FinalConversion.setAllToTypes(ToType);
5945 Candidate.Viable = true;
5946 Candidate.ExplicitCallArguments = 1;
5948 // C++ [over.match.funcs]p4:
5949 // For conversion functions, the function is considered to be a member of
5950 // the class of the implicit implied object argument for the purpose of
5951 // defining the type of the implicit object parameter.
5953 // Determine the implicit conversion sequence for the implicit
5954 // object parameter.
5955 QualType ImplicitParamType = From->getType();
5956 if (const PointerType *FromPtrType = ImplicitParamType->getAs<PointerType>())
5957 ImplicitParamType = FromPtrType->getPointeeType();
5958 CXXRecordDecl *ConversionContext
5959 = cast<CXXRecordDecl>(ImplicitParamType->getAs<RecordType>()->getDecl());
5961 Candidate.Conversions[0]
5962 = TryObjectArgumentInitialization(*this, From->getType(),
5963 From->Classify(Context),
5964 Conversion, ConversionContext);
5966 if (Candidate.Conversions[0].isBad()) {
5967 Candidate.Viable = false;
5968 Candidate.FailureKind = ovl_fail_bad_conversion;
5972 // We won't go through a user-define type conversion function to convert a
5973 // derived to base as such conversions are given Conversion Rank. They only
5974 // go through a copy constructor. 13.3.3.1.2-p4 [over.ics.user]
5976 = Context.getCanonicalType(From->getType().getUnqualifiedType());
5977 QualType ToCanon = Context.getCanonicalType(ToType).getUnqualifiedType();
5978 if (FromCanon == ToCanon || IsDerivedFrom(FromCanon, ToCanon)) {
5979 Candidate.Viable = false;
5980 Candidate.FailureKind = ovl_fail_trivial_conversion;
5984 // To determine what the conversion from the result of calling the
5985 // conversion function to the type we're eventually trying to
5986 // convert to (ToType), we need to synthesize a call to the
5987 // conversion function and attempt copy initialization from it. This
5988 // makes sure that we get the right semantics with respect to
5989 // lvalues/rvalues and the type. Fortunately, we can allocate this
5990 // call on the stack and we don't need its arguments to be
5992 DeclRefExpr ConversionRef(Conversion, false, Conversion->getType(),
5993 VK_LValue, From->getLocStart());
5994 ImplicitCastExpr ConversionFn(ImplicitCastExpr::OnStack,
5995 Context.getPointerType(Conversion->getType()),
5996 CK_FunctionToPointerDecay,
5997 &ConversionRef, VK_RValue);
5999 QualType ConversionType = Conversion->getConversionType();
6000 if (RequireCompleteType(From->getLocStart(), ConversionType, 0)) {
6001 Candidate.Viable = false;
6002 Candidate.FailureKind = ovl_fail_bad_final_conversion;
6006 ExprValueKind VK = Expr::getValueKindForType(ConversionType);
6008 // Note that it is safe to allocate CallExpr on the stack here because
6009 // there are 0 arguments (i.e., nothing is allocated using ASTContext's
6011 QualType CallResultType = ConversionType.getNonLValueExprType(Context);
6012 CallExpr Call(Context, &ConversionFn, None, CallResultType, VK,
6013 From->getLocStart());
6014 ImplicitConversionSequence ICS =
6015 TryCopyInitialization(*this, &Call, ToType,
6016 /*SuppressUserConversions=*/true,
6017 /*InOverloadResolution=*/false,
6018 /*AllowObjCWritebackConversion=*/false);
6020 switch (ICS.getKind()) {
6021 case ImplicitConversionSequence::StandardConversion:
6022 Candidate.FinalConversion = ICS.Standard;
6024 // C++ [over.ics.user]p3:
6025 // If the user-defined conversion is specified by a specialization of a
6026 // conversion function template, the second standard conversion sequence
6027 // shall have exact match rank.
6028 if (Conversion->getPrimaryTemplate() &&
6029 GetConversionRank(ICS.Standard.Second) != ICR_Exact_Match) {
6030 Candidate.Viable = false;
6031 Candidate.FailureKind = ovl_fail_final_conversion_not_exact;
6034 // C++0x [dcl.init.ref]p5:
6035 // In the second case, if the reference is an rvalue reference and
6036 // the second standard conversion sequence of the user-defined
6037 // conversion sequence includes an lvalue-to-rvalue conversion, the
6038 // program is ill-formed.
6039 if (ToType->isRValueReferenceType() &&
6040 ICS.Standard.First == ICK_Lvalue_To_Rvalue) {
6041 Candidate.Viable = false;
6042 Candidate.FailureKind = ovl_fail_bad_final_conversion;
6046 case ImplicitConversionSequence::BadConversion:
6047 Candidate.Viable = false;
6048 Candidate.FailureKind = ovl_fail_bad_final_conversion;
6053 "Can only end up with a standard conversion sequence or failure");
6057 /// \brief Adds a conversion function template specialization
6058 /// candidate to the overload set, using template argument deduction
6059 /// to deduce the template arguments of the conversion function
6060 /// template from the type that we are converting to (C++
6061 /// [temp.deduct.conv]).
6063 Sema::AddTemplateConversionCandidate(FunctionTemplateDecl *FunctionTemplate,
6064 DeclAccessPair FoundDecl,
6065 CXXRecordDecl *ActingDC,
6066 Expr *From, QualType ToType,
6067 OverloadCandidateSet &CandidateSet,
6068 bool AllowObjCConversionOnExplicit) {
6069 assert(isa<CXXConversionDecl>(FunctionTemplate->getTemplatedDecl()) &&
6070 "Only conversion function templates permitted here");
6072 if (!CandidateSet.isNewCandidate(FunctionTemplate))
6075 TemplateDeductionInfo Info(CandidateSet.getLocation());
6076 CXXConversionDecl *Specialization = 0;
6077 if (TemplateDeductionResult Result
6078 = DeduceTemplateArguments(FunctionTemplate, ToType,
6079 Specialization, Info)) {
6080 OverloadCandidate &Candidate = CandidateSet.addCandidate();
6081 Candidate.FoundDecl = FoundDecl;
6082 Candidate.Function = FunctionTemplate->getTemplatedDecl();
6083 Candidate.Viable = false;
6084 Candidate.FailureKind = ovl_fail_bad_deduction;
6085 Candidate.IsSurrogate = false;
6086 Candidate.IgnoreObjectArgument = false;
6087 Candidate.ExplicitCallArguments = 1;
6088 Candidate.DeductionFailure = MakeDeductionFailureInfo(Context, Result,
6093 // Add the conversion function template specialization produced by
6094 // template argument deduction as a candidate.
6095 assert(Specialization && "Missing function template specialization?");
6096 AddConversionCandidate(Specialization, FoundDecl, ActingDC, From, ToType,
6097 CandidateSet, AllowObjCConversionOnExplicit);
6100 /// AddSurrogateCandidate - Adds a "surrogate" candidate function that
6101 /// converts the given @c Object to a function pointer via the
6102 /// conversion function @c Conversion, and then attempts to call it
6103 /// with the given arguments (C++ [over.call.object]p2-4). Proto is
6104 /// the type of function that we'll eventually be calling.
6105 void Sema::AddSurrogateCandidate(CXXConversionDecl *Conversion,
6106 DeclAccessPair FoundDecl,
6107 CXXRecordDecl *ActingContext,
6108 const FunctionProtoType *Proto,
6110 ArrayRef<Expr *> Args,
6111 OverloadCandidateSet& CandidateSet) {
6112 if (!CandidateSet.isNewCandidate(Conversion))
6115 // Overload resolution is always an unevaluated context.
6116 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
6118 OverloadCandidate &Candidate = CandidateSet.addCandidate(Args.size() + 1);
6119 Candidate.FoundDecl = FoundDecl;
6120 Candidate.Function = 0;
6121 Candidate.Surrogate = Conversion;
6122 Candidate.Viable = true;
6123 Candidate.IsSurrogate = true;
6124 Candidate.IgnoreObjectArgument = false;
6125 Candidate.ExplicitCallArguments = Args.size();
6127 // Determine the implicit conversion sequence for the implicit
6128 // object parameter.
6129 ImplicitConversionSequence ObjectInit
6130 = TryObjectArgumentInitialization(*this, Object->getType(),
6131 Object->Classify(Context),
6132 Conversion, ActingContext);
6133 if (ObjectInit.isBad()) {
6134 Candidate.Viable = false;
6135 Candidate.FailureKind = ovl_fail_bad_conversion;
6136 Candidate.Conversions[0] = ObjectInit;
6140 // The first conversion is actually a user-defined conversion whose
6141 // first conversion is ObjectInit's standard conversion (which is
6142 // effectively a reference binding). Record it as such.
6143 Candidate.Conversions[0].setUserDefined();
6144 Candidate.Conversions[0].UserDefined.Before = ObjectInit.Standard;
6145 Candidate.Conversions[0].UserDefined.EllipsisConversion = false;
6146 Candidate.Conversions[0].UserDefined.HadMultipleCandidates = false;
6147 Candidate.Conversions[0].UserDefined.ConversionFunction = Conversion;
6148 Candidate.Conversions[0].UserDefined.FoundConversionFunction = FoundDecl;
6149 Candidate.Conversions[0].UserDefined.After
6150 = Candidate.Conversions[0].UserDefined.Before;
6151 Candidate.Conversions[0].UserDefined.After.setAsIdentityConversion();
6154 unsigned NumArgsInProto = Proto->getNumArgs();
6156 // (C++ 13.3.2p2): A candidate function having fewer than m
6157 // parameters is viable only if it has an ellipsis in its parameter
6159 if (Args.size() > NumArgsInProto && !Proto->isVariadic()) {
6160 Candidate.Viable = false;
6161 Candidate.FailureKind = ovl_fail_too_many_arguments;
6165 // Function types don't have any default arguments, so just check if
6166 // we have enough arguments.
6167 if (Args.size() < NumArgsInProto) {
6168 // Not enough arguments.
6169 Candidate.Viable = false;
6170 Candidate.FailureKind = ovl_fail_too_few_arguments;
6174 // Determine the implicit conversion sequences for each of the
6176 for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
6177 if (ArgIdx < NumArgsInProto) {
6178 // (C++ 13.3.2p3): for F to be a viable function, there shall
6179 // exist for each argument an implicit conversion sequence
6180 // (13.3.3.1) that converts that argument to the corresponding
6182 QualType ParamType = Proto->getArgType(ArgIdx);
6183 Candidate.Conversions[ArgIdx + 1]
6184 = TryCopyInitialization(*this, Args[ArgIdx], ParamType,
6185 /*SuppressUserConversions=*/false,
6186 /*InOverloadResolution=*/false,
6187 /*AllowObjCWritebackConversion=*/
6188 getLangOpts().ObjCAutoRefCount);
6189 if (Candidate.Conversions[ArgIdx + 1].isBad()) {
6190 Candidate.Viable = false;
6191 Candidate.FailureKind = ovl_fail_bad_conversion;
6195 // (C++ 13.3.2p2): For the purposes of overload resolution, any
6196 // argument for which there is no corresponding parameter is
6197 // considered to ""match the ellipsis" (C+ 13.3.3.1.3).
6198 Candidate.Conversions[ArgIdx + 1].setEllipsis();
6203 /// \brief Add overload candidates for overloaded operators that are
6204 /// member functions.
6206 /// Add the overloaded operator candidates that are member functions
6207 /// for the operator Op that was used in an operator expression such
6208 /// as "x Op y". , Args/NumArgs provides the operator arguments, and
6209 /// CandidateSet will store the added overload candidates. (C++
6210 /// [over.match.oper]).
6211 void Sema::AddMemberOperatorCandidates(OverloadedOperatorKind Op,
6212 SourceLocation OpLoc,
6213 ArrayRef<Expr *> Args,
6214 OverloadCandidateSet& CandidateSet,
6215 SourceRange OpRange) {
6216 DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op);
6218 // C++ [over.match.oper]p3:
6219 // For a unary operator @ with an operand of a type whose
6220 // cv-unqualified version is T1, and for a binary operator @ with
6221 // a left operand of a type whose cv-unqualified version is T1 and
6222 // a right operand of a type whose cv-unqualified version is T2,
6223 // three sets of candidate functions, designated member
6224 // candidates, non-member candidates and built-in candidates, are
6225 // constructed as follows:
6226 QualType T1 = Args[0]->getType();
6228 // -- If T1 is a complete class type or a class currently being
6229 // defined, the set of member candidates is the result of the
6230 // qualified lookup of T1::operator@ (13.3.1.1.1); otherwise,
6231 // the set of member candidates is empty.
6232 if (const RecordType *T1Rec = T1->getAs<RecordType>()) {
6233 // Complete the type if it can be completed.
6234 RequireCompleteType(OpLoc, T1, 0);
6235 // If the type is neither complete nor being defined, bail out now.
6236 if (!T1Rec->getDecl()->getDefinition())
6239 LookupResult Operators(*this, OpName, OpLoc, LookupOrdinaryName);
6240 LookupQualifiedName(Operators, T1Rec->getDecl());
6241 Operators.suppressDiagnostics();
6243 for (LookupResult::iterator Oper = Operators.begin(),
6244 OperEnd = Operators.end();
6247 AddMethodCandidate(Oper.getPair(), Args[0]->getType(),
6248 Args[0]->Classify(Context),
6251 /* SuppressUserConversions = */ false);
6255 /// AddBuiltinCandidate - Add a candidate for a built-in
6256 /// operator. ResultTy and ParamTys are the result and parameter types
6257 /// of the built-in candidate, respectively. Args and NumArgs are the
6258 /// arguments being passed to the candidate. IsAssignmentOperator
6259 /// should be true when this built-in candidate is an assignment
6260 /// operator. NumContextualBoolArguments is the number of arguments
6261 /// (at the beginning of the argument list) that will be contextually
6262 /// converted to bool.
6263 void Sema::AddBuiltinCandidate(QualType ResultTy, QualType *ParamTys,
6264 ArrayRef<Expr *> Args,
6265 OverloadCandidateSet& CandidateSet,
6266 bool IsAssignmentOperator,
6267 unsigned NumContextualBoolArguments) {
6268 // Overload resolution is always an unevaluated context.
6269 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
6271 // Add this candidate
6272 OverloadCandidate &Candidate = CandidateSet.addCandidate(Args.size());
6273 Candidate.FoundDecl = DeclAccessPair::make(0, AS_none);
6274 Candidate.Function = 0;
6275 Candidate.IsSurrogate = false;
6276 Candidate.IgnoreObjectArgument = false;
6277 Candidate.BuiltinTypes.ResultTy = ResultTy;
6278 for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx)
6279 Candidate.BuiltinTypes.ParamTypes[ArgIdx] = ParamTys[ArgIdx];
6281 // Determine the implicit conversion sequences for each of the
6283 Candidate.Viable = true;
6284 Candidate.ExplicitCallArguments = Args.size();
6285 for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
6286 // C++ [over.match.oper]p4:
6287 // For the built-in assignment operators, conversions of the
6288 // left operand are restricted as follows:
6289 // -- no temporaries are introduced to hold the left operand, and
6290 // -- no user-defined conversions are applied to the left
6291 // operand to achieve a type match with the left-most
6292 // parameter of a built-in candidate.
6294 // We block these conversions by turning off user-defined
6295 // conversions, since that is the only way that initialization of
6296 // a reference to a non-class type can occur from something that
6297 // is not of the same type.
6298 if (ArgIdx < NumContextualBoolArguments) {
6299 assert(ParamTys[ArgIdx] == Context.BoolTy &&
6300 "Contextual conversion to bool requires bool type");
6301 Candidate.Conversions[ArgIdx]
6302 = TryContextuallyConvertToBool(*this, Args[ArgIdx]);
6304 Candidate.Conversions[ArgIdx]
6305 = TryCopyInitialization(*this, Args[ArgIdx], ParamTys[ArgIdx],
6306 ArgIdx == 0 && IsAssignmentOperator,
6307 /*InOverloadResolution=*/false,
6308 /*AllowObjCWritebackConversion=*/
6309 getLangOpts().ObjCAutoRefCount);
6311 if (Candidate.Conversions[ArgIdx].isBad()) {
6312 Candidate.Viable = false;
6313 Candidate.FailureKind = ovl_fail_bad_conversion;
6321 /// BuiltinCandidateTypeSet - A set of types that will be used for the
6322 /// candidate operator functions for built-in operators (C++
6323 /// [over.built]). The types are separated into pointer types and
6324 /// enumeration types.
6325 class BuiltinCandidateTypeSet {
6326 /// TypeSet - A set of types.
6327 typedef llvm::SmallPtrSet<QualType, 8> TypeSet;
6329 /// PointerTypes - The set of pointer types that will be used in the
6330 /// built-in candidates.
6331 TypeSet PointerTypes;
6333 /// MemberPointerTypes - The set of member pointer types that will be
6334 /// used in the built-in candidates.
6335 TypeSet MemberPointerTypes;
6337 /// EnumerationTypes - The set of enumeration types that will be
6338 /// used in the built-in candidates.
6339 TypeSet EnumerationTypes;
6341 /// \brief The set of vector types that will be used in the built-in
6343 TypeSet VectorTypes;
6345 /// \brief A flag indicating non-record types are viable candidates
6346 bool HasNonRecordTypes;
6348 /// \brief A flag indicating whether either arithmetic or enumeration types
6349 /// were present in the candidate set.
6350 bool HasArithmeticOrEnumeralTypes;
6352 /// \brief A flag indicating whether the nullptr type was present in the
6354 bool HasNullPtrType;
6356 /// Sema - The semantic analysis instance where we are building the
6357 /// candidate type set.
6360 /// Context - The AST context in which we will build the type sets.
6361 ASTContext &Context;
6363 bool AddPointerWithMoreQualifiedTypeVariants(QualType Ty,
6364 const Qualifiers &VisibleQuals);
6365 bool AddMemberPointerWithMoreQualifiedTypeVariants(QualType Ty);
6368 /// iterator - Iterates through the types that are part of the set.
6369 typedef TypeSet::iterator iterator;
6371 BuiltinCandidateTypeSet(Sema &SemaRef)
6372 : HasNonRecordTypes(false),
6373 HasArithmeticOrEnumeralTypes(false),
6374 HasNullPtrType(false),
6376 Context(SemaRef.Context) { }
6378 void AddTypesConvertedFrom(QualType Ty,
6380 bool AllowUserConversions,
6381 bool AllowExplicitConversions,
6382 const Qualifiers &VisibleTypeConversionsQuals);
6384 /// pointer_begin - First pointer type found;
6385 iterator pointer_begin() { return PointerTypes.begin(); }
6387 /// pointer_end - Past the last pointer type found;
6388 iterator pointer_end() { return PointerTypes.end(); }
6390 /// member_pointer_begin - First member pointer type found;
6391 iterator member_pointer_begin() { return MemberPointerTypes.begin(); }
6393 /// member_pointer_end - Past the last member pointer type found;
6394 iterator member_pointer_end() { return MemberPointerTypes.end(); }
6396 /// enumeration_begin - First enumeration type found;
6397 iterator enumeration_begin() { return EnumerationTypes.begin(); }
6399 /// enumeration_end - Past the last enumeration type found;
6400 iterator enumeration_end() { return EnumerationTypes.end(); }
6402 iterator vector_begin() { return VectorTypes.begin(); }
6403 iterator vector_end() { return VectorTypes.end(); }
6405 bool hasNonRecordTypes() { return HasNonRecordTypes; }
6406 bool hasArithmeticOrEnumeralTypes() { return HasArithmeticOrEnumeralTypes; }
6407 bool hasNullPtrType() const { return HasNullPtrType; }
6410 } // end anonymous namespace
6412 /// AddPointerWithMoreQualifiedTypeVariants - Add the pointer type @p Ty to
6413 /// the set of pointer types along with any more-qualified variants of
6414 /// that type. For example, if @p Ty is "int const *", this routine
6415 /// will add "int const *", "int const volatile *", "int const
6416 /// restrict *", and "int const volatile restrict *" to the set of
6417 /// pointer types. Returns true if the add of @p Ty itself succeeded,
6418 /// false otherwise.
6420 /// FIXME: what to do about extended qualifiers?
6422 BuiltinCandidateTypeSet::AddPointerWithMoreQualifiedTypeVariants(QualType Ty,
6423 const Qualifiers &VisibleQuals) {
6425 // Insert this type.
6426 if (!PointerTypes.insert(Ty))
6430 const PointerType *PointerTy = Ty->getAs<PointerType>();
6431 bool buildObjCPtr = false;
6433 const ObjCObjectPointerType *PTy = Ty->castAs<ObjCObjectPointerType>();
6434 PointeeTy = PTy->getPointeeType();
6435 buildObjCPtr = true;
6437 PointeeTy = PointerTy->getPointeeType();
6440 // Don't add qualified variants of arrays. For one, they're not allowed
6441 // (the qualifier would sink to the element type), and for another, the
6442 // only overload situation where it matters is subscript or pointer +- int,
6443 // and those shouldn't have qualifier variants anyway.
6444 if (PointeeTy->isArrayType())
6447 unsigned BaseCVR = PointeeTy.getCVRQualifiers();
6448 bool hasVolatile = VisibleQuals.hasVolatile();
6449 bool hasRestrict = VisibleQuals.hasRestrict();
6451 // Iterate through all strict supersets of BaseCVR.
6452 for (unsigned CVR = BaseCVR+1; CVR <= Qualifiers::CVRMask; ++CVR) {
6453 if ((CVR | BaseCVR) != CVR) continue;
6454 // Skip over volatile if no volatile found anywhere in the types.
6455 if ((CVR & Qualifiers::Volatile) && !hasVolatile) continue;
6457 // Skip over restrict if no restrict found anywhere in the types, or if
6458 // the type cannot be restrict-qualified.
6459 if ((CVR & Qualifiers::Restrict) &&
6461 (!(PointeeTy->isAnyPointerType() || PointeeTy->isReferenceType()))))
6464 // Build qualified pointee type.
6465 QualType QPointeeTy = Context.getCVRQualifiedType(PointeeTy, CVR);
6467 // Build qualified pointer type.
6468 QualType QPointerTy;
6470 QPointerTy = Context.getPointerType(QPointeeTy);
6472 QPointerTy = Context.getObjCObjectPointerType(QPointeeTy);
6474 // Insert qualified pointer type.
6475 PointerTypes.insert(QPointerTy);
6481 /// AddMemberPointerWithMoreQualifiedTypeVariants - Add the pointer type @p Ty
6482 /// to the set of pointer types along with any more-qualified variants of
6483 /// that type. For example, if @p Ty is "int const *", this routine
6484 /// will add "int const *", "int const volatile *", "int const
6485 /// restrict *", and "int const volatile restrict *" to the set of
6486 /// pointer types. Returns true if the add of @p Ty itself succeeded,
6487 /// false otherwise.
6489 /// FIXME: what to do about extended qualifiers?
6491 BuiltinCandidateTypeSet::AddMemberPointerWithMoreQualifiedTypeVariants(
6493 // Insert this type.
6494 if (!MemberPointerTypes.insert(Ty))
6497 const MemberPointerType *PointerTy = Ty->getAs<MemberPointerType>();
6498 assert(PointerTy && "type was not a member pointer type!");
6500 QualType PointeeTy = PointerTy->getPointeeType();
6501 // Don't add qualified variants of arrays. For one, they're not allowed
6502 // (the qualifier would sink to the element type), and for another, the
6503 // only overload situation where it matters is subscript or pointer +- int,
6504 // and those shouldn't have qualifier variants anyway.
6505 if (PointeeTy->isArrayType())
6507 const Type *ClassTy = PointerTy->getClass();
6509 // Iterate through all strict supersets of the pointee type's CVR
6511 unsigned BaseCVR = PointeeTy.getCVRQualifiers();
6512 for (unsigned CVR = BaseCVR+1; CVR <= Qualifiers::CVRMask; ++CVR) {
6513 if ((CVR | BaseCVR) != CVR) continue;
6515 QualType QPointeeTy = Context.getCVRQualifiedType(PointeeTy, CVR);
6516 MemberPointerTypes.insert(
6517 Context.getMemberPointerType(QPointeeTy, ClassTy));
6523 /// AddTypesConvertedFrom - Add each of the types to which the type @p
6524 /// Ty can be implicit converted to the given set of @p Types. We're
6525 /// primarily interested in pointer types and enumeration types. We also
6526 /// take member pointer types, for the conditional operator.
6527 /// AllowUserConversions is true if we should look at the conversion
6528 /// functions of a class type, and AllowExplicitConversions if we
6529 /// should also include the explicit conversion functions of a class
6532 BuiltinCandidateTypeSet::AddTypesConvertedFrom(QualType Ty,
6534 bool AllowUserConversions,
6535 bool AllowExplicitConversions,
6536 const Qualifiers &VisibleQuals) {
6537 // Only deal with canonical types.
6538 Ty = Context.getCanonicalType(Ty);
6540 // Look through reference types; they aren't part of the type of an
6541 // expression for the purposes of conversions.
6542 if (const ReferenceType *RefTy = Ty->getAs<ReferenceType>())
6543 Ty = RefTy->getPointeeType();
6545 // If we're dealing with an array type, decay to the pointer.
6546 if (Ty->isArrayType())
6547 Ty = SemaRef.Context.getArrayDecayedType(Ty);
6549 // Otherwise, we don't care about qualifiers on the type.
6550 Ty = Ty.getLocalUnqualifiedType();
6552 // Flag if we ever add a non-record type.
6553 const RecordType *TyRec = Ty->getAs<RecordType>();
6554 HasNonRecordTypes = HasNonRecordTypes || !TyRec;
6556 // Flag if we encounter an arithmetic type.
6557 HasArithmeticOrEnumeralTypes =
6558 HasArithmeticOrEnumeralTypes || Ty->isArithmeticType();
6560 if (Ty->isObjCIdType() || Ty->isObjCClassType())
6561 PointerTypes.insert(Ty);
6562 else if (Ty->getAs<PointerType>() || Ty->getAs<ObjCObjectPointerType>()) {
6563 // Insert our type, and its more-qualified variants, into the set
6565 if (!AddPointerWithMoreQualifiedTypeVariants(Ty, VisibleQuals))
6567 } else if (Ty->isMemberPointerType()) {
6568 // Member pointers are far easier, since the pointee can't be converted.
6569 if (!AddMemberPointerWithMoreQualifiedTypeVariants(Ty))
6571 } else if (Ty->isEnumeralType()) {
6572 HasArithmeticOrEnumeralTypes = true;
6573 EnumerationTypes.insert(Ty);
6574 } else if (Ty->isVectorType()) {
6575 // We treat vector types as arithmetic types in many contexts as an
6577 HasArithmeticOrEnumeralTypes = true;
6578 VectorTypes.insert(Ty);
6579 } else if (Ty->isNullPtrType()) {
6580 HasNullPtrType = true;
6581 } else if (AllowUserConversions && TyRec) {
6582 // No conversion functions in incomplete types.
6583 if (SemaRef.RequireCompleteType(Loc, Ty, 0))
6586 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(TyRec->getDecl());
6587 std::pair<CXXRecordDecl::conversion_iterator,
6588 CXXRecordDecl::conversion_iterator>
6589 Conversions = ClassDecl->getVisibleConversionFunctions();
6590 for (CXXRecordDecl::conversion_iterator
6591 I = Conversions.first, E = Conversions.second; I != E; ++I) {
6592 NamedDecl *D = I.getDecl();
6593 if (isa<UsingShadowDecl>(D))
6594 D = cast<UsingShadowDecl>(D)->getTargetDecl();
6596 // Skip conversion function templates; they don't tell us anything
6597 // about which builtin types we can convert to.
6598 if (isa<FunctionTemplateDecl>(D))
6601 CXXConversionDecl *Conv = cast<CXXConversionDecl>(D);
6602 if (AllowExplicitConversions || !Conv->isExplicit()) {
6603 AddTypesConvertedFrom(Conv->getConversionType(), Loc, false, false,
6610 /// \brief Helper function for AddBuiltinOperatorCandidates() that adds
6611 /// the volatile- and non-volatile-qualified assignment operators for the
6612 /// given type to the candidate set.
6613 static void AddBuiltinAssignmentOperatorCandidates(Sema &S,
6615 ArrayRef<Expr *> Args,
6616 OverloadCandidateSet &CandidateSet) {
6617 QualType ParamTypes[2];
6619 // T& operator=(T&, T)
6620 ParamTypes[0] = S.Context.getLValueReferenceType(T);
6622 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet,
6623 /*IsAssignmentOperator=*/true);
6625 if (!S.Context.getCanonicalType(T).isVolatileQualified()) {
6626 // volatile T& operator=(volatile T&, T)
6628 = S.Context.getLValueReferenceType(S.Context.getVolatileType(T));
6630 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet,
6631 /*IsAssignmentOperator=*/true);
6635 /// CollectVRQualifiers - This routine returns Volatile/Restrict qualifiers,
6636 /// if any, found in visible type conversion functions found in ArgExpr's type.
6637 static Qualifiers CollectVRQualifiers(ASTContext &Context, Expr* ArgExpr) {
6639 const RecordType *TyRec;
6640 if (const MemberPointerType *RHSMPType =
6641 ArgExpr->getType()->getAs<MemberPointerType>())
6642 TyRec = RHSMPType->getClass()->getAs<RecordType>();
6644 TyRec = ArgExpr->getType()->getAs<RecordType>();
6646 // Just to be safe, assume the worst case.
6647 VRQuals.addVolatile();
6648 VRQuals.addRestrict();
6652 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(TyRec->getDecl());
6653 if (!ClassDecl->hasDefinition())
6656 std::pair<CXXRecordDecl::conversion_iterator,
6657 CXXRecordDecl::conversion_iterator>
6658 Conversions = ClassDecl->getVisibleConversionFunctions();
6660 for (CXXRecordDecl::conversion_iterator
6661 I = Conversions.first, E = Conversions.second; I != E; ++I) {
6662 NamedDecl *D = I.getDecl();
6663 if (isa<UsingShadowDecl>(D))
6664 D = cast<UsingShadowDecl>(D)->getTargetDecl();
6665 if (CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(D)) {
6666 QualType CanTy = Context.getCanonicalType(Conv->getConversionType());
6667 if (const ReferenceType *ResTypeRef = CanTy->getAs<ReferenceType>())
6668 CanTy = ResTypeRef->getPointeeType();
6669 // Need to go down the pointer/mempointer chain and add qualifiers
6673 if (CanTy.isRestrictQualified())
6674 VRQuals.addRestrict();
6675 if (const PointerType *ResTypePtr = CanTy->getAs<PointerType>())
6676 CanTy = ResTypePtr->getPointeeType();
6677 else if (const MemberPointerType *ResTypeMPtr =
6678 CanTy->getAs<MemberPointerType>())
6679 CanTy = ResTypeMPtr->getPointeeType();
6682 if (CanTy.isVolatileQualified())
6683 VRQuals.addVolatile();
6684 if (VRQuals.hasRestrict() && VRQuals.hasVolatile())
6694 /// \brief Helper class to manage the addition of builtin operator overload
6695 /// candidates. It provides shared state and utility methods used throughout
6696 /// the process, as well as a helper method to add each group of builtin
6697 /// operator overloads from the standard to a candidate set.
6698 class BuiltinOperatorOverloadBuilder {
6699 // Common instance state available to all overload candidate addition methods.
6701 ArrayRef<Expr *> Args;
6702 Qualifiers VisibleTypeConversionsQuals;
6703 bool HasArithmeticOrEnumeralCandidateType;
6704 SmallVectorImpl<BuiltinCandidateTypeSet> &CandidateTypes;
6705 OverloadCandidateSet &CandidateSet;
6707 // Define some constants used to index and iterate over the arithemetic types
6708 // provided via the getArithmeticType() method below.
6709 // The "promoted arithmetic types" are the arithmetic
6710 // types are that preserved by promotion (C++ [over.built]p2).
6711 static const unsigned FirstIntegralType = 3;
6712 static const unsigned LastIntegralType = 20;
6713 static const unsigned FirstPromotedIntegralType = 3,
6714 LastPromotedIntegralType = 11;
6715 static const unsigned FirstPromotedArithmeticType = 0,
6716 LastPromotedArithmeticType = 11;
6717 static const unsigned NumArithmeticTypes = 20;
6719 /// \brief Get the canonical type for a given arithmetic type index.
6720 CanQualType getArithmeticType(unsigned index) {
6721 assert(index < NumArithmeticTypes);
6722 static CanQualType ASTContext::* const
6723 ArithmeticTypes[NumArithmeticTypes] = {
6724 // Start of promoted types.
6725 &ASTContext::FloatTy,
6726 &ASTContext::DoubleTy,
6727 &ASTContext::LongDoubleTy,
6729 // Start of integral types.
6731 &ASTContext::LongTy,
6732 &ASTContext::LongLongTy,
6733 &ASTContext::Int128Ty,
6734 &ASTContext::UnsignedIntTy,
6735 &ASTContext::UnsignedLongTy,
6736 &ASTContext::UnsignedLongLongTy,
6737 &ASTContext::UnsignedInt128Ty,
6738 // End of promoted types.
6740 &ASTContext::BoolTy,
6741 &ASTContext::CharTy,
6742 &ASTContext::WCharTy,
6743 &ASTContext::Char16Ty,
6744 &ASTContext::Char32Ty,
6745 &ASTContext::SignedCharTy,
6746 &ASTContext::ShortTy,
6747 &ASTContext::UnsignedCharTy,
6748 &ASTContext::UnsignedShortTy,
6749 // End of integral types.
6750 // FIXME: What about complex? What about half?
6752 return S.Context.*ArithmeticTypes[index];
6755 /// \brief Gets the canonical type resulting from the usual arithemetic
6756 /// converions for the given arithmetic types.
6757 CanQualType getUsualArithmeticConversions(unsigned L, unsigned R) {
6758 // Accelerator table for performing the usual arithmetic conversions.
6759 // The rules are basically:
6760 // - if either is floating-point, use the wider floating-point
6761 // - if same signedness, use the higher rank
6762 // - if same size, use unsigned of the higher rank
6763 // - use the larger type
6764 // These rules, together with the axiom that higher ranks are
6765 // never smaller, are sufficient to precompute all of these results
6766 // *except* when dealing with signed types of higher rank.
6767 // (we could precompute SLL x UI for all known platforms, but it's
6768 // better not to make any assumptions).
6769 // We assume that int128 has a higher rank than long long on all platforms.
6772 Flt, Dbl, LDbl, SI, SL, SLL, S128, UI, UL, ULL, U128
6774 static const PromotedType ConversionsTable[LastPromotedArithmeticType]
6775 [LastPromotedArithmeticType] = {
6776 /* Flt*/ { Flt, Dbl, LDbl, Flt, Flt, Flt, Flt, Flt, Flt, Flt, Flt },
6777 /* Dbl*/ { Dbl, Dbl, LDbl, Dbl, Dbl, Dbl, Dbl, Dbl, Dbl, Dbl, Dbl },
6778 /*LDbl*/ { LDbl, LDbl, LDbl, LDbl, LDbl, LDbl, LDbl, LDbl, LDbl, LDbl, LDbl },
6779 /* SI*/ { Flt, Dbl, LDbl, SI, SL, SLL, S128, UI, UL, ULL, U128 },
6780 /* SL*/ { Flt, Dbl, LDbl, SL, SL, SLL, S128, Dep, UL, ULL, U128 },
6781 /* SLL*/ { Flt, Dbl, LDbl, SLL, SLL, SLL, S128, Dep, Dep, ULL, U128 },
6782 /*S128*/ { Flt, Dbl, LDbl, S128, S128, S128, S128, S128, S128, S128, U128 },
6783 /* UI*/ { Flt, Dbl, LDbl, UI, Dep, Dep, S128, UI, UL, ULL, U128 },
6784 /* UL*/ { Flt, Dbl, LDbl, UL, UL, Dep, S128, UL, UL, ULL, U128 },
6785 /* ULL*/ { Flt, Dbl, LDbl, ULL, ULL, ULL, S128, ULL, ULL, ULL, U128 },
6786 /*U128*/ { Flt, Dbl, LDbl, U128, U128, U128, U128, U128, U128, U128, U128 },
6789 assert(L < LastPromotedArithmeticType);
6790 assert(R < LastPromotedArithmeticType);
6791 int Idx = ConversionsTable[L][R];
6793 // Fast path: the table gives us a concrete answer.
6794 if (Idx != Dep) return getArithmeticType(Idx);
6796 // Slow path: we need to compare widths.
6797 // An invariant is that the signed type has higher rank.
6798 CanQualType LT = getArithmeticType(L),
6799 RT = getArithmeticType(R);
6800 unsigned LW = S.Context.getIntWidth(LT),
6801 RW = S.Context.getIntWidth(RT);
6803 // If they're different widths, use the signed type.
6804 if (LW > RW) return LT;
6805 else if (LW < RW) return RT;
6807 // Otherwise, use the unsigned type of the signed type's rank.
6808 if (L == SL || R == SL) return S.Context.UnsignedLongTy;
6809 assert(L == SLL || R == SLL);
6810 return S.Context.UnsignedLongLongTy;
6813 /// \brief Helper method to factor out the common pattern of adding overloads
6814 /// for '++' and '--' builtin operators.
6815 void addPlusPlusMinusMinusStyleOverloads(QualType CandidateTy,
6818 QualType ParamTypes[2] = {
6819 S.Context.getLValueReferenceType(CandidateTy),
6823 // Non-volatile version.
6824 if (Args.size() == 1)
6825 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet);
6827 S.AddBuiltinCandidate(CandidateTy, ParamTypes, Args, CandidateSet);
6829 // Use a heuristic to reduce number of builtin candidates in the set:
6830 // add volatile version only if there are conversions to a volatile type.
6833 S.Context.getLValueReferenceType(
6834 S.Context.getVolatileType(CandidateTy));
6835 if (Args.size() == 1)
6836 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet);
6838 S.AddBuiltinCandidate(CandidateTy, ParamTypes, Args, CandidateSet);
6841 // Add restrict version only if there are conversions to a restrict type
6842 // and our candidate type is a non-restrict-qualified pointer.
6843 if (HasRestrict && CandidateTy->isAnyPointerType() &&
6844 !CandidateTy.isRestrictQualified()) {
6846 = S.Context.getLValueReferenceType(
6847 S.Context.getCVRQualifiedType(CandidateTy, Qualifiers::Restrict));
6848 if (Args.size() == 1)
6849 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet);
6851 S.AddBuiltinCandidate(CandidateTy, ParamTypes, Args, CandidateSet);
6855 = S.Context.getLValueReferenceType(
6856 S.Context.getCVRQualifiedType(CandidateTy,
6857 (Qualifiers::Volatile |
6858 Qualifiers::Restrict)));
6859 if (Args.size() == 1)
6860 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet);
6862 S.AddBuiltinCandidate(CandidateTy, ParamTypes, Args, CandidateSet);
6869 BuiltinOperatorOverloadBuilder(
6870 Sema &S, ArrayRef<Expr *> Args,
6871 Qualifiers VisibleTypeConversionsQuals,
6872 bool HasArithmeticOrEnumeralCandidateType,
6873 SmallVectorImpl<BuiltinCandidateTypeSet> &CandidateTypes,
6874 OverloadCandidateSet &CandidateSet)
6876 VisibleTypeConversionsQuals(VisibleTypeConversionsQuals),
6877 HasArithmeticOrEnumeralCandidateType(
6878 HasArithmeticOrEnumeralCandidateType),
6879 CandidateTypes(CandidateTypes),
6880 CandidateSet(CandidateSet) {
6881 // Validate some of our static helper constants in debug builds.
6882 assert(getArithmeticType(FirstPromotedIntegralType) == S.Context.IntTy &&
6883 "Invalid first promoted integral type");
6884 assert(getArithmeticType(LastPromotedIntegralType - 1)
6885 == S.Context.UnsignedInt128Ty &&
6886 "Invalid last promoted integral type");
6887 assert(getArithmeticType(FirstPromotedArithmeticType)
6888 == S.Context.FloatTy &&
6889 "Invalid first promoted arithmetic type");
6890 assert(getArithmeticType(LastPromotedArithmeticType - 1)
6891 == S.Context.UnsignedInt128Ty &&
6892 "Invalid last promoted arithmetic type");
6895 // C++ [over.built]p3:
6897 // For every pair (T, VQ), where T is an arithmetic type, and VQ
6898 // is either volatile or empty, there exist candidate operator
6899 // functions of the form
6901 // VQ T& operator++(VQ T&);
6902 // T operator++(VQ T&, int);
6904 // C++ [over.built]p4:
6906 // For every pair (T, VQ), where T is an arithmetic type other
6907 // than bool, and VQ is either volatile or empty, there exist
6908 // candidate operator functions of the form
6910 // VQ T& operator--(VQ T&);
6911 // T operator--(VQ T&, int);
6912 void addPlusPlusMinusMinusArithmeticOverloads(OverloadedOperatorKind Op) {
6913 if (!HasArithmeticOrEnumeralCandidateType)
6916 for (unsigned Arith = (Op == OO_PlusPlus? 0 : 1);
6917 Arith < NumArithmeticTypes; ++Arith) {
6918 addPlusPlusMinusMinusStyleOverloads(
6919 getArithmeticType(Arith),
6920 VisibleTypeConversionsQuals.hasVolatile(),
6921 VisibleTypeConversionsQuals.hasRestrict());
6925 // C++ [over.built]p5:
6927 // For every pair (T, VQ), where T is a cv-qualified or
6928 // cv-unqualified object type, and VQ is either volatile or
6929 // empty, there exist candidate operator functions of the form
6931 // T*VQ& operator++(T*VQ&);
6932 // T*VQ& operator--(T*VQ&);
6933 // T* operator++(T*VQ&, int);
6934 // T* operator--(T*VQ&, int);
6935 void addPlusPlusMinusMinusPointerOverloads() {
6936 for (BuiltinCandidateTypeSet::iterator
6937 Ptr = CandidateTypes[0].pointer_begin(),
6938 PtrEnd = CandidateTypes[0].pointer_end();
6939 Ptr != PtrEnd; ++Ptr) {
6940 // Skip pointer types that aren't pointers to object types.
6941 if (!(*Ptr)->getPointeeType()->isObjectType())
6944 addPlusPlusMinusMinusStyleOverloads(*Ptr,
6945 (!(*Ptr).isVolatileQualified() &&
6946 VisibleTypeConversionsQuals.hasVolatile()),
6947 (!(*Ptr).isRestrictQualified() &&
6948 VisibleTypeConversionsQuals.hasRestrict()));
6952 // C++ [over.built]p6:
6953 // For every cv-qualified or cv-unqualified object type T, there
6954 // exist candidate operator functions of the form
6956 // T& operator*(T*);
6958 // C++ [over.built]p7:
6959 // For every function type T that does not have cv-qualifiers or a
6960 // ref-qualifier, there exist candidate operator functions of the form
6961 // T& operator*(T*);
6962 void addUnaryStarPointerOverloads() {
6963 for (BuiltinCandidateTypeSet::iterator
6964 Ptr = CandidateTypes[0].pointer_begin(),
6965 PtrEnd = CandidateTypes[0].pointer_end();
6966 Ptr != PtrEnd; ++Ptr) {
6967 QualType ParamTy = *Ptr;
6968 QualType PointeeTy = ParamTy->getPointeeType();
6969 if (!PointeeTy->isObjectType() && !PointeeTy->isFunctionType())
6972 if (const FunctionProtoType *Proto =PointeeTy->getAs<FunctionProtoType>())
6973 if (Proto->getTypeQuals() || Proto->getRefQualifier())
6976 S.AddBuiltinCandidate(S.Context.getLValueReferenceType(PointeeTy),
6977 &ParamTy, Args, CandidateSet);
6981 // C++ [over.built]p9:
6982 // For every promoted arithmetic type T, there exist candidate
6983 // operator functions of the form
6987 void addUnaryPlusOrMinusArithmeticOverloads() {
6988 if (!HasArithmeticOrEnumeralCandidateType)
6991 for (unsigned Arith = FirstPromotedArithmeticType;
6992 Arith < LastPromotedArithmeticType; ++Arith) {
6993 QualType ArithTy = getArithmeticType(Arith);
6994 S.AddBuiltinCandidate(ArithTy, &ArithTy, Args, CandidateSet);
6997 // Extension: We also add these operators for vector types.
6998 for (BuiltinCandidateTypeSet::iterator
6999 Vec = CandidateTypes[0].vector_begin(),
7000 VecEnd = CandidateTypes[0].vector_end();
7001 Vec != VecEnd; ++Vec) {
7002 QualType VecTy = *Vec;
7003 S.AddBuiltinCandidate(VecTy, &VecTy, Args, CandidateSet);
7007 // C++ [over.built]p8:
7008 // For every type T, there exist candidate operator functions of
7011 // T* operator+(T*);
7012 void addUnaryPlusPointerOverloads() {
7013 for (BuiltinCandidateTypeSet::iterator
7014 Ptr = CandidateTypes[0].pointer_begin(),
7015 PtrEnd = CandidateTypes[0].pointer_end();
7016 Ptr != PtrEnd; ++Ptr) {
7017 QualType ParamTy = *Ptr;
7018 S.AddBuiltinCandidate(ParamTy, &ParamTy, Args, CandidateSet);
7022 // C++ [over.built]p10:
7023 // For every promoted integral type T, there exist candidate
7024 // operator functions of the form
7027 void addUnaryTildePromotedIntegralOverloads() {
7028 if (!HasArithmeticOrEnumeralCandidateType)
7031 for (unsigned Int = FirstPromotedIntegralType;
7032 Int < LastPromotedIntegralType; ++Int) {
7033 QualType IntTy = getArithmeticType(Int);
7034 S.AddBuiltinCandidate(IntTy, &IntTy, Args, CandidateSet);
7037 // Extension: We also add this operator for vector types.
7038 for (BuiltinCandidateTypeSet::iterator
7039 Vec = CandidateTypes[0].vector_begin(),
7040 VecEnd = CandidateTypes[0].vector_end();
7041 Vec != VecEnd; ++Vec) {
7042 QualType VecTy = *Vec;
7043 S.AddBuiltinCandidate(VecTy, &VecTy, Args, CandidateSet);
7047 // C++ [over.match.oper]p16:
7048 // For every pointer to member type T, there exist candidate operator
7049 // functions of the form
7051 // bool operator==(T,T);
7052 // bool operator!=(T,T);
7053 void addEqualEqualOrNotEqualMemberPointerOverloads() {
7054 /// Set of (canonical) types that we've already handled.
7055 llvm::SmallPtrSet<QualType, 8> AddedTypes;
7057 for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
7058 for (BuiltinCandidateTypeSet::iterator
7059 MemPtr = CandidateTypes[ArgIdx].member_pointer_begin(),
7060 MemPtrEnd = CandidateTypes[ArgIdx].member_pointer_end();
7061 MemPtr != MemPtrEnd;
7063 // Don't add the same builtin candidate twice.
7064 if (!AddedTypes.insert(S.Context.getCanonicalType(*MemPtr)))
7067 QualType ParamTypes[2] = { *MemPtr, *MemPtr };
7068 S.AddBuiltinCandidate(S.Context.BoolTy, ParamTypes, Args, CandidateSet);
7073 // C++ [over.built]p15:
7075 // For every T, where T is an enumeration type, a pointer type, or
7076 // std::nullptr_t, there exist candidate operator functions of the form
7078 // bool operator<(T, T);
7079 // bool operator>(T, T);
7080 // bool operator<=(T, T);
7081 // bool operator>=(T, T);
7082 // bool operator==(T, T);
7083 // bool operator!=(T, T);
7084 void addRelationalPointerOrEnumeralOverloads() {
7085 // C++ [over.match.oper]p3:
7086 // [...]the built-in candidates include all of the candidate operator
7087 // functions defined in 13.6 that, compared to the given operator, [...]
7088 // do not have the same parameter-type-list as any non-template non-member
7091 // Note that in practice, this only affects enumeration types because there
7092 // aren't any built-in candidates of record type, and a user-defined operator
7093 // must have an operand of record or enumeration type. Also, the only other
7094 // overloaded operator with enumeration arguments, operator=,
7095 // cannot be overloaded for enumeration types, so this is the only place
7096 // where we must suppress candidates like this.
7097 llvm::DenseSet<std::pair<CanQualType, CanQualType> >
7098 UserDefinedBinaryOperators;
7100 for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
7101 if (CandidateTypes[ArgIdx].enumeration_begin() !=
7102 CandidateTypes[ArgIdx].enumeration_end()) {
7103 for (OverloadCandidateSet::iterator C = CandidateSet.begin(),
7104 CEnd = CandidateSet.end();
7106 if (!C->Viable || !C->Function || C->Function->getNumParams() != 2)
7109 if (C->Function->isFunctionTemplateSpecialization())
7112 QualType FirstParamType =
7113 C->Function->getParamDecl(0)->getType().getUnqualifiedType();
7114 QualType SecondParamType =
7115 C->Function->getParamDecl(1)->getType().getUnqualifiedType();
7117 // Skip if either parameter isn't of enumeral type.
7118 if (!FirstParamType->isEnumeralType() ||
7119 !SecondParamType->isEnumeralType())
7122 // Add this operator to the set of known user-defined operators.
7123 UserDefinedBinaryOperators.insert(
7124 std::make_pair(S.Context.getCanonicalType(FirstParamType),
7125 S.Context.getCanonicalType(SecondParamType)));
7130 /// Set of (canonical) types that we've already handled.
7131 llvm::SmallPtrSet<QualType, 8> AddedTypes;
7133 for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
7134 for (BuiltinCandidateTypeSet::iterator
7135 Ptr = CandidateTypes[ArgIdx].pointer_begin(),
7136 PtrEnd = CandidateTypes[ArgIdx].pointer_end();
7137 Ptr != PtrEnd; ++Ptr) {
7138 // Don't add the same builtin candidate twice.
7139 if (!AddedTypes.insert(S.Context.getCanonicalType(*Ptr)))
7142 QualType ParamTypes[2] = { *Ptr, *Ptr };
7143 S.AddBuiltinCandidate(S.Context.BoolTy, ParamTypes, Args, CandidateSet);
7145 for (BuiltinCandidateTypeSet::iterator
7146 Enum = CandidateTypes[ArgIdx].enumeration_begin(),
7147 EnumEnd = CandidateTypes[ArgIdx].enumeration_end();
7148 Enum != EnumEnd; ++Enum) {
7149 CanQualType CanonType = S.Context.getCanonicalType(*Enum);
7151 // Don't add the same builtin candidate twice, or if a user defined
7152 // candidate exists.
7153 if (!AddedTypes.insert(CanonType) ||
7154 UserDefinedBinaryOperators.count(std::make_pair(CanonType,
7158 QualType ParamTypes[2] = { *Enum, *Enum };
7159 S.AddBuiltinCandidate(S.Context.BoolTy, ParamTypes, Args, CandidateSet);
7162 if (CandidateTypes[ArgIdx].hasNullPtrType()) {
7163 CanQualType NullPtrTy = S.Context.getCanonicalType(S.Context.NullPtrTy);
7164 if (AddedTypes.insert(NullPtrTy) &&
7165 !UserDefinedBinaryOperators.count(std::make_pair(NullPtrTy,
7167 QualType ParamTypes[2] = { NullPtrTy, NullPtrTy };
7168 S.AddBuiltinCandidate(S.Context.BoolTy, ParamTypes, Args,
7175 // C++ [over.built]p13:
7177 // For every cv-qualified or cv-unqualified object type T
7178 // there exist candidate operator functions of the form
7180 // T* operator+(T*, ptrdiff_t);
7181 // T& operator[](T*, ptrdiff_t); [BELOW]
7182 // T* operator-(T*, ptrdiff_t);
7183 // T* operator+(ptrdiff_t, T*);
7184 // T& operator[](ptrdiff_t, T*); [BELOW]
7186 // C++ [over.built]p14:
7188 // For every T, where T is a pointer to object type, there
7189 // exist candidate operator functions of the form
7191 // ptrdiff_t operator-(T, T);
7192 void addBinaryPlusOrMinusPointerOverloads(OverloadedOperatorKind Op) {
7193 /// Set of (canonical) types that we've already handled.
7194 llvm::SmallPtrSet<QualType, 8> AddedTypes;
7196 for (int Arg = 0; Arg < 2; ++Arg) {
7197 QualType AsymetricParamTypes[2] = {
7198 S.Context.getPointerDiffType(),
7199 S.Context.getPointerDiffType(),
7201 for (BuiltinCandidateTypeSet::iterator
7202 Ptr = CandidateTypes[Arg].pointer_begin(),
7203 PtrEnd = CandidateTypes[Arg].pointer_end();
7204 Ptr != PtrEnd; ++Ptr) {
7205 QualType PointeeTy = (*Ptr)->getPointeeType();
7206 if (!PointeeTy->isObjectType())
7209 AsymetricParamTypes[Arg] = *Ptr;
7210 if (Arg == 0 || Op == OO_Plus) {
7211 // operator+(T*, ptrdiff_t) or operator-(T*, ptrdiff_t)
7212 // T* operator+(ptrdiff_t, T*);
7213 S.AddBuiltinCandidate(*Ptr, AsymetricParamTypes, Args, CandidateSet);
7215 if (Op == OO_Minus) {
7216 // ptrdiff_t operator-(T, T);
7217 if (!AddedTypes.insert(S.Context.getCanonicalType(*Ptr)))
7220 QualType ParamTypes[2] = { *Ptr, *Ptr };
7221 S.AddBuiltinCandidate(S.Context.getPointerDiffType(), ParamTypes,
7222 Args, CandidateSet);
7228 // C++ [over.built]p12:
7230 // For every pair of promoted arithmetic types L and R, there
7231 // exist candidate operator functions of the form
7233 // LR operator*(L, R);
7234 // LR operator/(L, R);
7235 // LR operator+(L, R);
7236 // LR operator-(L, R);
7237 // bool operator<(L, R);
7238 // bool operator>(L, R);
7239 // bool operator<=(L, R);
7240 // bool operator>=(L, R);
7241 // bool operator==(L, R);
7242 // bool operator!=(L, R);
7244 // where LR is the result of the usual arithmetic conversions
7245 // between types L and R.
7247 // C++ [over.built]p24:
7249 // For every pair of promoted arithmetic types L and R, there exist
7250 // candidate operator functions of the form
7252 // LR operator?(bool, L, R);
7254 // where LR is the result of the usual arithmetic conversions
7255 // between types L and R.
7256 // Our candidates ignore the first parameter.
7257 void addGenericBinaryArithmeticOverloads(bool isComparison) {
7258 if (!HasArithmeticOrEnumeralCandidateType)
7261 for (unsigned Left = FirstPromotedArithmeticType;
7262 Left < LastPromotedArithmeticType; ++Left) {
7263 for (unsigned Right = FirstPromotedArithmeticType;
7264 Right < LastPromotedArithmeticType; ++Right) {
7265 QualType LandR[2] = { getArithmeticType(Left),
7266 getArithmeticType(Right) };
7268 isComparison ? S.Context.BoolTy
7269 : getUsualArithmeticConversions(Left, Right);
7270 S.AddBuiltinCandidate(Result, LandR, Args, CandidateSet);
7274 // Extension: Add the binary operators ==, !=, <, <=, >=, >, *, /, and the
7275 // conditional operator for vector types.
7276 for (BuiltinCandidateTypeSet::iterator
7277 Vec1 = CandidateTypes[0].vector_begin(),
7278 Vec1End = CandidateTypes[0].vector_end();
7279 Vec1 != Vec1End; ++Vec1) {
7280 for (BuiltinCandidateTypeSet::iterator
7281 Vec2 = CandidateTypes[1].vector_begin(),
7282 Vec2End = CandidateTypes[1].vector_end();
7283 Vec2 != Vec2End; ++Vec2) {
7284 QualType LandR[2] = { *Vec1, *Vec2 };
7285 QualType Result = S.Context.BoolTy;
7286 if (!isComparison) {
7287 if ((*Vec1)->isExtVectorType() || !(*Vec2)->isExtVectorType())
7293 S.AddBuiltinCandidate(Result, LandR, Args, CandidateSet);
7298 // C++ [over.built]p17:
7300 // For every pair of promoted integral types L and R, there
7301 // exist candidate operator functions of the form
7303 // LR operator%(L, R);
7304 // LR operator&(L, R);
7305 // LR operator^(L, R);
7306 // LR operator|(L, R);
7307 // L operator<<(L, R);
7308 // L operator>>(L, R);
7310 // where LR is the result of the usual arithmetic conversions
7311 // between types L and R.
7312 void addBinaryBitwiseArithmeticOverloads(OverloadedOperatorKind Op) {
7313 if (!HasArithmeticOrEnumeralCandidateType)
7316 for (unsigned Left = FirstPromotedIntegralType;
7317 Left < LastPromotedIntegralType; ++Left) {
7318 for (unsigned Right = FirstPromotedIntegralType;
7319 Right < LastPromotedIntegralType; ++Right) {
7320 QualType LandR[2] = { getArithmeticType(Left),
7321 getArithmeticType(Right) };
7322 QualType Result = (Op == OO_LessLess || Op == OO_GreaterGreater)
7324 : getUsualArithmeticConversions(Left, Right);
7325 S.AddBuiltinCandidate(Result, LandR, Args, CandidateSet);
7330 // C++ [over.built]p20:
7332 // For every pair (T, VQ), where T is an enumeration or
7333 // pointer to member type and VQ is either volatile or
7334 // empty, there exist candidate operator functions of the form
7336 // VQ T& operator=(VQ T&, T);
7337 void addAssignmentMemberPointerOrEnumeralOverloads() {
7338 /// Set of (canonical) types that we've already handled.
7339 llvm::SmallPtrSet<QualType, 8> AddedTypes;
7341 for (unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) {
7342 for (BuiltinCandidateTypeSet::iterator
7343 Enum = CandidateTypes[ArgIdx].enumeration_begin(),
7344 EnumEnd = CandidateTypes[ArgIdx].enumeration_end();
7345 Enum != EnumEnd; ++Enum) {
7346 if (!AddedTypes.insert(S.Context.getCanonicalType(*Enum)))
7349 AddBuiltinAssignmentOperatorCandidates(S, *Enum, Args, CandidateSet);
7352 for (BuiltinCandidateTypeSet::iterator
7353 MemPtr = CandidateTypes[ArgIdx].member_pointer_begin(),
7354 MemPtrEnd = CandidateTypes[ArgIdx].member_pointer_end();
7355 MemPtr != MemPtrEnd; ++MemPtr) {
7356 if (!AddedTypes.insert(S.Context.getCanonicalType(*MemPtr)))
7359 AddBuiltinAssignmentOperatorCandidates(S, *MemPtr, Args, CandidateSet);
7364 // C++ [over.built]p19:
7366 // For every pair (T, VQ), where T is any type and VQ is either
7367 // volatile or empty, there exist candidate operator functions
7370 // T*VQ& operator=(T*VQ&, T*);
7372 // C++ [over.built]p21:
7374 // For every pair (T, VQ), where T is a cv-qualified or
7375 // cv-unqualified object type and VQ is either volatile or
7376 // empty, there exist candidate operator functions of the form
7378 // T*VQ& operator+=(T*VQ&, ptrdiff_t);
7379 // T*VQ& operator-=(T*VQ&, ptrdiff_t);
7380 void addAssignmentPointerOverloads(bool isEqualOp) {
7381 /// Set of (canonical) types that we've already handled.
7382 llvm::SmallPtrSet<QualType, 8> AddedTypes;
7384 for (BuiltinCandidateTypeSet::iterator
7385 Ptr = CandidateTypes[0].pointer_begin(),
7386 PtrEnd = CandidateTypes[0].pointer_end();
7387 Ptr != PtrEnd; ++Ptr) {
7388 // If this is operator=, keep track of the builtin candidates we added.
7390 AddedTypes.insert(S.Context.getCanonicalType(*Ptr));
7391 else if (!(*Ptr)->getPointeeType()->isObjectType())
7394 // non-volatile version
7395 QualType ParamTypes[2] = {
7396 S.Context.getLValueReferenceType(*Ptr),
7397 isEqualOp ? *Ptr : S.Context.getPointerDiffType(),
7399 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet,
7400 /*IsAssigmentOperator=*/ isEqualOp);
7402 bool NeedVolatile = !(*Ptr).isVolatileQualified() &&
7403 VisibleTypeConversionsQuals.hasVolatile();
7407 S.Context.getLValueReferenceType(S.Context.getVolatileType(*Ptr));
7408 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet,
7409 /*IsAssigmentOperator=*/isEqualOp);
7412 if (!(*Ptr).isRestrictQualified() &&
7413 VisibleTypeConversionsQuals.hasRestrict()) {
7416 = S.Context.getLValueReferenceType(S.Context.getRestrictType(*Ptr));
7417 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet,
7418 /*IsAssigmentOperator=*/isEqualOp);
7421 // volatile restrict version
7423 = S.Context.getLValueReferenceType(
7424 S.Context.getCVRQualifiedType(*Ptr,
7425 (Qualifiers::Volatile |
7426 Qualifiers::Restrict)));
7427 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet,
7428 /*IsAssigmentOperator=*/isEqualOp);
7434 for (BuiltinCandidateTypeSet::iterator
7435 Ptr = CandidateTypes[1].pointer_begin(),
7436 PtrEnd = CandidateTypes[1].pointer_end();
7437 Ptr != PtrEnd; ++Ptr) {
7438 // Make sure we don't add the same candidate twice.
7439 if (!AddedTypes.insert(S.Context.getCanonicalType(*Ptr)))
7442 QualType ParamTypes[2] = {
7443 S.Context.getLValueReferenceType(*Ptr),
7447 // non-volatile version
7448 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet,
7449 /*IsAssigmentOperator=*/true);
7451 bool NeedVolatile = !(*Ptr).isVolatileQualified() &&
7452 VisibleTypeConversionsQuals.hasVolatile();
7456 S.Context.getLValueReferenceType(S.Context.getVolatileType(*Ptr));
7457 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet,
7458 /*IsAssigmentOperator=*/true);
7461 if (!(*Ptr).isRestrictQualified() &&
7462 VisibleTypeConversionsQuals.hasRestrict()) {
7465 = S.Context.getLValueReferenceType(S.Context.getRestrictType(*Ptr));
7466 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet,
7467 /*IsAssigmentOperator=*/true);
7470 // volatile restrict version
7472 = S.Context.getLValueReferenceType(
7473 S.Context.getCVRQualifiedType(*Ptr,
7474 (Qualifiers::Volatile |
7475 Qualifiers::Restrict)));
7476 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet,
7477 /*IsAssigmentOperator=*/true);
7484 // C++ [over.built]p18:
7486 // For every triple (L, VQ, R), where L is an arithmetic type,
7487 // VQ is either volatile or empty, and R is a promoted
7488 // arithmetic type, there exist candidate operator functions of
7491 // VQ L& operator=(VQ L&, R);
7492 // VQ L& operator*=(VQ L&, R);
7493 // VQ L& operator/=(VQ L&, R);
7494 // VQ L& operator+=(VQ L&, R);
7495 // VQ L& operator-=(VQ L&, R);
7496 void addAssignmentArithmeticOverloads(bool isEqualOp) {
7497 if (!HasArithmeticOrEnumeralCandidateType)
7500 for (unsigned Left = 0; Left < NumArithmeticTypes; ++Left) {
7501 for (unsigned Right = FirstPromotedArithmeticType;
7502 Right < LastPromotedArithmeticType; ++Right) {
7503 QualType ParamTypes[2];
7504 ParamTypes[1] = getArithmeticType(Right);
7506 // Add this built-in operator as a candidate (VQ is empty).
7508 S.Context.getLValueReferenceType(getArithmeticType(Left));
7509 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet,
7510 /*IsAssigmentOperator=*/isEqualOp);
7512 // Add this built-in operator as a candidate (VQ is 'volatile').
7513 if (VisibleTypeConversionsQuals.hasVolatile()) {
7515 S.Context.getVolatileType(getArithmeticType(Left));
7516 ParamTypes[0] = S.Context.getLValueReferenceType(ParamTypes[0]);
7517 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet,
7518 /*IsAssigmentOperator=*/isEqualOp);
7523 // Extension: Add the binary operators =, +=, -=, *=, /= for vector types.
7524 for (BuiltinCandidateTypeSet::iterator
7525 Vec1 = CandidateTypes[0].vector_begin(),
7526 Vec1End = CandidateTypes[0].vector_end();
7527 Vec1 != Vec1End; ++Vec1) {
7528 for (BuiltinCandidateTypeSet::iterator
7529 Vec2 = CandidateTypes[1].vector_begin(),
7530 Vec2End = CandidateTypes[1].vector_end();
7531 Vec2 != Vec2End; ++Vec2) {
7532 QualType ParamTypes[2];
7533 ParamTypes[1] = *Vec2;
7534 // Add this built-in operator as a candidate (VQ is empty).
7535 ParamTypes[0] = S.Context.getLValueReferenceType(*Vec1);
7536 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet,
7537 /*IsAssigmentOperator=*/isEqualOp);
7539 // Add this built-in operator as a candidate (VQ is 'volatile').
7540 if (VisibleTypeConversionsQuals.hasVolatile()) {
7541 ParamTypes[0] = S.Context.getVolatileType(*Vec1);
7542 ParamTypes[0] = S.Context.getLValueReferenceType(ParamTypes[0]);
7543 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet,
7544 /*IsAssigmentOperator=*/isEqualOp);
7550 // C++ [over.built]p22:
7552 // For every triple (L, VQ, R), where L is an integral type, VQ
7553 // is either volatile or empty, and R is a promoted integral
7554 // type, there exist candidate operator functions of the form
7556 // VQ L& operator%=(VQ L&, R);
7557 // VQ L& operator<<=(VQ L&, R);
7558 // VQ L& operator>>=(VQ L&, R);
7559 // VQ L& operator&=(VQ L&, R);
7560 // VQ L& operator^=(VQ L&, R);
7561 // VQ L& operator|=(VQ L&, R);
7562 void addAssignmentIntegralOverloads() {
7563 if (!HasArithmeticOrEnumeralCandidateType)
7566 for (unsigned Left = FirstIntegralType; Left < LastIntegralType; ++Left) {
7567 for (unsigned Right = FirstPromotedIntegralType;
7568 Right < LastPromotedIntegralType; ++Right) {
7569 QualType ParamTypes[2];
7570 ParamTypes[1] = getArithmeticType(Right);
7572 // Add this built-in operator as a candidate (VQ is empty).
7574 S.Context.getLValueReferenceType(getArithmeticType(Left));
7575 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet);
7576 if (VisibleTypeConversionsQuals.hasVolatile()) {
7577 // Add this built-in operator as a candidate (VQ is 'volatile').
7578 ParamTypes[0] = getArithmeticType(Left);
7579 ParamTypes[0] = S.Context.getVolatileType(ParamTypes[0]);
7580 ParamTypes[0] = S.Context.getLValueReferenceType(ParamTypes[0]);
7581 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, CandidateSet);
7587 // C++ [over.operator]p23:
7589 // There also exist candidate operator functions of the form
7591 // bool operator!(bool);
7592 // bool operator&&(bool, bool);
7593 // bool operator||(bool, bool);
7594 void addExclaimOverload() {
7595 QualType ParamTy = S.Context.BoolTy;
7596 S.AddBuiltinCandidate(ParamTy, &ParamTy, Args, CandidateSet,
7597 /*IsAssignmentOperator=*/false,
7598 /*NumContextualBoolArguments=*/1);
7600 void addAmpAmpOrPipePipeOverload() {
7601 QualType ParamTypes[2] = { S.Context.BoolTy, S.Context.BoolTy };
7602 S.AddBuiltinCandidate(S.Context.BoolTy, ParamTypes, Args, CandidateSet,
7603 /*IsAssignmentOperator=*/false,
7604 /*NumContextualBoolArguments=*/2);
7607 // C++ [over.built]p13:
7609 // For every cv-qualified or cv-unqualified object type T there
7610 // exist candidate operator functions of the form
7612 // T* operator+(T*, ptrdiff_t); [ABOVE]
7613 // T& operator[](T*, ptrdiff_t);
7614 // T* operator-(T*, ptrdiff_t); [ABOVE]
7615 // T* operator+(ptrdiff_t, T*); [ABOVE]
7616 // T& operator[](ptrdiff_t, T*);
7617 void addSubscriptOverloads() {
7618 for (BuiltinCandidateTypeSet::iterator
7619 Ptr = CandidateTypes[0].pointer_begin(),
7620 PtrEnd = CandidateTypes[0].pointer_end();
7621 Ptr != PtrEnd; ++Ptr) {
7622 QualType ParamTypes[2] = { *Ptr, S.Context.getPointerDiffType() };
7623 QualType PointeeType = (*Ptr)->getPointeeType();
7624 if (!PointeeType->isObjectType())
7627 QualType ResultTy = S.Context.getLValueReferenceType(PointeeType);
7629 // T& operator[](T*, ptrdiff_t)
7630 S.AddBuiltinCandidate(ResultTy, ParamTypes, Args, CandidateSet);
7633 for (BuiltinCandidateTypeSet::iterator
7634 Ptr = CandidateTypes[1].pointer_begin(),
7635 PtrEnd = CandidateTypes[1].pointer_end();
7636 Ptr != PtrEnd; ++Ptr) {
7637 QualType ParamTypes[2] = { S.Context.getPointerDiffType(), *Ptr };
7638 QualType PointeeType = (*Ptr)->getPointeeType();
7639 if (!PointeeType->isObjectType())
7642 QualType ResultTy = S.Context.getLValueReferenceType(PointeeType);
7644 // T& operator[](ptrdiff_t, T*)
7645 S.AddBuiltinCandidate(ResultTy, ParamTypes, Args, CandidateSet);
7649 // C++ [over.built]p11:
7650 // For every quintuple (C1, C2, T, CV1, CV2), where C2 is a class type,
7651 // C1 is the same type as C2 or is a derived class of C2, T is an object
7652 // type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
7653 // there exist candidate operator functions of the form
7655 // CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
7657 // where CV12 is the union of CV1 and CV2.
7658 void addArrowStarOverloads() {
7659 for (BuiltinCandidateTypeSet::iterator
7660 Ptr = CandidateTypes[0].pointer_begin(),
7661 PtrEnd = CandidateTypes[0].pointer_end();
7662 Ptr != PtrEnd; ++Ptr) {
7663 QualType C1Ty = (*Ptr);
7665 QualifierCollector Q1;
7666 C1 = QualType(Q1.strip(C1Ty->getPointeeType()), 0);
7667 if (!isa<RecordType>(C1))
7669 // heuristic to reduce number of builtin candidates in the set.
7670 // Add volatile/restrict version only if there are conversions to a
7671 // volatile/restrict type.
7672 if (!VisibleTypeConversionsQuals.hasVolatile() && Q1.hasVolatile())
7674 if (!VisibleTypeConversionsQuals.hasRestrict() && Q1.hasRestrict())
7676 for (BuiltinCandidateTypeSet::iterator
7677 MemPtr = CandidateTypes[1].member_pointer_begin(),
7678 MemPtrEnd = CandidateTypes[1].member_pointer_end();
7679 MemPtr != MemPtrEnd; ++MemPtr) {
7680 const MemberPointerType *mptr = cast<MemberPointerType>(*MemPtr);
7681 QualType C2 = QualType(mptr->getClass(), 0);
7682 C2 = C2.getUnqualifiedType();
7683 if (C1 != C2 && !S.IsDerivedFrom(C1, C2))
7685 QualType ParamTypes[2] = { *Ptr, *MemPtr };
7687 QualType T = mptr->getPointeeType();
7688 if (!VisibleTypeConversionsQuals.hasVolatile() &&
7689 T.isVolatileQualified())
7691 if (!VisibleTypeConversionsQuals.hasRestrict() &&
7692 T.isRestrictQualified())
7694 T = Q1.apply(S.Context, T);
7695 QualType ResultTy = S.Context.getLValueReferenceType(T);
7696 S.AddBuiltinCandidate(ResultTy, ParamTypes, Args, CandidateSet);
7701 // Note that we don't consider the first argument, since it has been
7702 // contextually converted to bool long ago. The candidates below are
7703 // therefore added as binary.
7705 // C++ [over.built]p25:
7706 // For every type T, where T is a pointer, pointer-to-member, or scoped
7707 // enumeration type, there exist candidate operator functions of the form
7709 // T operator?(bool, T, T);
7711 void addConditionalOperatorOverloads() {
7712 /// Set of (canonical) types that we've already handled.
7713 llvm::SmallPtrSet<QualType, 8> AddedTypes;
7715 for (unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) {
7716 for (BuiltinCandidateTypeSet::iterator
7717 Ptr = CandidateTypes[ArgIdx].pointer_begin(),
7718 PtrEnd = CandidateTypes[ArgIdx].pointer_end();
7719 Ptr != PtrEnd; ++Ptr) {
7720 if (!AddedTypes.insert(S.Context.getCanonicalType(*Ptr)))
7723 QualType ParamTypes[2] = { *Ptr, *Ptr };
7724 S.AddBuiltinCandidate(*Ptr, ParamTypes, Args, CandidateSet);
7727 for (BuiltinCandidateTypeSet::iterator
7728 MemPtr = CandidateTypes[ArgIdx].member_pointer_begin(),
7729 MemPtrEnd = CandidateTypes[ArgIdx].member_pointer_end();
7730 MemPtr != MemPtrEnd; ++MemPtr) {
7731 if (!AddedTypes.insert(S.Context.getCanonicalType(*MemPtr)))
7734 QualType ParamTypes[2] = { *MemPtr, *MemPtr };
7735 S.AddBuiltinCandidate(*MemPtr, ParamTypes, Args, CandidateSet);
7738 if (S.getLangOpts().CPlusPlus11) {
7739 for (BuiltinCandidateTypeSet::iterator
7740 Enum = CandidateTypes[ArgIdx].enumeration_begin(),
7741 EnumEnd = CandidateTypes[ArgIdx].enumeration_end();
7742 Enum != EnumEnd; ++Enum) {
7743 if (!(*Enum)->getAs<EnumType>()->getDecl()->isScoped())
7746 if (!AddedTypes.insert(S.Context.getCanonicalType(*Enum)))
7749 QualType ParamTypes[2] = { *Enum, *Enum };
7750 S.AddBuiltinCandidate(*Enum, ParamTypes, Args, CandidateSet);
7757 } // end anonymous namespace
7759 /// AddBuiltinOperatorCandidates - Add the appropriate built-in
7760 /// operator overloads to the candidate set (C++ [over.built]), based
7761 /// on the operator @p Op and the arguments given. For example, if the
7762 /// operator is a binary '+', this routine might add "int
7763 /// operator+(int, int)" to cover integer addition.
7764 void Sema::AddBuiltinOperatorCandidates(OverloadedOperatorKind Op,
7765 SourceLocation OpLoc,
7766 ArrayRef<Expr *> Args,
7767 OverloadCandidateSet &CandidateSet) {
7768 // Find all of the types that the arguments can convert to, but only
7769 // if the operator we're looking at has built-in operator candidates
7770 // that make use of these types. Also record whether we encounter non-record
7771 // candidate types or either arithmetic or enumeral candidate types.
7772 Qualifiers VisibleTypeConversionsQuals;
7773 VisibleTypeConversionsQuals.addConst();
7774 for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx)
7775 VisibleTypeConversionsQuals += CollectVRQualifiers(Context, Args[ArgIdx]);
7777 bool HasNonRecordCandidateType = false;
7778 bool HasArithmeticOrEnumeralCandidateType = false;
7779 SmallVector<BuiltinCandidateTypeSet, 2> CandidateTypes;
7780 for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
7781 CandidateTypes.push_back(BuiltinCandidateTypeSet(*this));
7782 CandidateTypes[ArgIdx].AddTypesConvertedFrom(Args[ArgIdx]->getType(),
7785 (Op == OO_Exclaim ||
7788 VisibleTypeConversionsQuals);
7789 HasNonRecordCandidateType = HasNonRecordCandidateType ||
7790 CandidateTypes[ArgIdx].hasNonRecordTypes();
7791 HasArithmeticOrEnumeralCandidateType =
7792 HasArithmeticOrEnumeralCandidateType ||
7793 CandidateTypes[ArgIdx].hasArithmeticOrEnumeralTypes();
7796 // Exit early when no non-record types have been added to the candidate set
7797 // for any of the arguments to the operator.
7799 // We can't exit early for !, ||, or &&, since there we have always have
7800 // 'bool' overloads.
7801 if (!HasNonRecordCandidateType &&
7802 !(Op == OO_Exclaim || Op == OO_AmpAmp || Op == OO_PipePipe))
7805 // Setup an object to manage the common state for building overloads.
7806 BuiltinOperatorOverloadBuilder OpBuilder(*this, Args,
7807 VisibleTypeConversionsQuals,
7808 HasArithmeticOrEnumeralCandidateType,
7809 CandidateTypes, CandidateSet);
7811 // Dispatch over the operation to add in only those overloads which apply.
7814 case NUM_OVERLOADED_OPERATORS:
7815 llvm_unreachable("Expected an overloaded operator");
7820 case OO_Array_Delete:
7823 "Special operators don't use AddBuiltinOperatorCandidates");
7827 // C++ [over.match.oper]p3:
7828 // -- For the operator ',', the unary operator '&', or the
7829 // operator '->', the built-in candidates set is empty.
7832 case OO_Plus: // '+' is either unary or binary
7833 if (Args.size() == 1)
7834 OpBuilder.addUnaryPlusPointerOverloads();
7837 case OO_Minus: // '-' is either unary or binary
7838 if (Args.size() == 1) {
7839 OpBuilder.addUnaryPlusOrMinusArithmeticOverloads();
7841 OpBuilder.addBinaryPlusOrMinusPointerOverloads(Op);
7842 OpBuilder.addGenericBinaryArithmeticOverloads(/*isComparison=*/false);
7846 case OO_Star: // '*' is either unary or binary
7847 if (Args.size() == 1)
7848 OpBuilder.addUnaryStarPointerOverloads();
7850 OpBuilder.addGenericBinaryArithmeticOverloads(/*isComparison=*/false);
7854 OpBuilder.addGenericBinaryArithmeticOverloads(/*isComparison=*/false);
7859 OpBuilder.addPlusPlusMinusMinusArithmeticOverloads(Op);
7860 OpBuilder.addPlusPlusMinusMinusPointerOverloads();
7864 case OO_ExclaimEqual:
7865 OpBuilder.addEqualEqualOrNotEqualMemberPointerOverloads();
7871 case OO_GreaterEqual:
7872 OpBuilder.addRelationalPointerOrEnumeralOverloads();
7873 OpBuilder.addGenericBinaryArithmeticOverloads(/*isComparison=*/true);
7880 case OO_GreaterGreater:
7881 OpBuilder.addBinaryBitwiseArithmeticOverloads(Op);
7884 case OO_Amp: // '&' is either unary or binary
7885 if (Args.size() == 1)
7886 // C++ [over.match.oper]p3:
7887 // -- For the operator ',', the unary operator '&', or the
7888 // operator '->', the built-in candidates set is empty.
7891 OpBuilder.addBinaryBitwiseArithmeticOverloads(Op);
7895 OpBuilder.addUnaryTildePromotedIntegralOverloads();
7899 OpBuilder.addAssignmentMemberPointerOrEnumeralOverloads();
7904 OpBuilder.addAssignmentPointerOverloads(Op == OO_Equal);
7909 OpBuilder.addAssignmentArithmeticOverloads(Op == OO_Equal);
7912 case OO_PercentEqual:
7913 case OO_LessLessEqual:
7914 case OO_GreaterGreaterEqual:
7918 OpBuilder.addAssignmentIntegralOverloads();
7922 OpBuilder.addExclaimOverload();
7927 OpBuilder.addAmpAmpOrPipePipeOverload();
7931 OpBuilder.addSubscriptOverloads();
7935 OpBuilder.addArrowStarOverloads();
7938 case OO_Conditional:
7939 OpBuilder.addConditionalOperatorOverloads();
7940 OpBuilder.addGenericBinaryArithmeticOverloads(/*isComparison=*/false);
7945 /// \brief Add function candidates found via argument-dependent lookup
7946 /// to the set of overloading candidates.
7948 /// This routine performs argument-dependent name lookup based on the
7949 /// given function name (which may also be an operator name) and adds
7950 /// all of the overload candidates found by ADL to the overload
7951 /// candidate set (C++ [basic.lookup.argdep]).
7953 Sema::AddArgumentDependentLookupCandidates(DeclarationName Name,
7954 bool Operator, SourceLocation Loc,
7955 ArrayRef<Expr *> Args,
7956 TemplateArgumentListInfo *ExplicitTemplateArgs,
7957 OverloadCandidateSet& CandidateSet,
7958 bool PartialOverloading) {
7961 // FIXME: This approach for uniquing ADL results (and removing
7962 // redundant candidates from the set) relies on pointer-equality,
7963 // which means we need to key off the canonical decl. However,
7964 // always going back to the canonical decl might not get us the
7965 // right set of default arguments. What default arguments are
7966 // we supposed to consider on ADL candidates, anyway?
7968 // FIXME: Pass in the explicit template arguments?
7969 ArgumentDependentLookup(Name, Operator, Loc, Args, Fns);
7971 // Erase all of the candidates we already knew about.
7972 for (OverloadCandidateSet::iterator Cand = CandidateSet.begin(),
7973 CandEnd = CandidateSet.end();
7974 Cand != CandEnd; ++Cand)
7975 if (Cand->Function) {
7976 Fns.erase(Cand->Function);
7977 if (FunctionTemplateDecl *FunTmpl = Cand->Function->getPrimaryTemplate())
7981 // For each of the ADL candidates we found, add it to the overload
7983 for (ADLResult::iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) {
7984 DeclAccessPair FoundDecl = DeclAccessPair::make(*I, AS_none);
7985 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
7986 if (ExplicitTemplateArgs)
7989 AddOverloadCandidate(FD, FoundDecl, Args, CandidateSet, false,
7990 PartialOverloading);
7992 AddTemplateOverloadCandidate(cast<FunctionTemplateDecl>(*I),
7993 FoundDecl, ExplicitTemplateArgs,
7994 Args, CandidateSet);
7998 /// isBetterOverloadCandidate - Determines whether the first overload
7999 /// candidate is a better candidate than the second (C++ 13.3.3p1).
8001 isBetterOverloadCandidate(Sema &S,
8002 const OverloadCandidate &Cand1,
8003 const OverloadCandidate &Cand2,
8005 bool UserDefinedConversion) {
8006 // Define viable functions to be better candidates than non-viable
8009 return Cand1.Viable;
8010 else if (!Cand1.Viable)
8013 // C++ [over.match.best]p1:
8015 // -- if F is a static member function, ICS1(F) is defined such
8016 // that ICS1(F) is neither better nor worse than ICS1(G) for
8017 // any function G, and, symmetrically, ICS1(G) is neither
8018 // better nor worse than ICS1(F).
8019 unsigned StartArg = 0;
8020 if (Cand1.IgnoreObjectArgument || Cand2.IgnoreObjectArgument)
8023 // C++ [over.match.best]p1:
8024 // A viable function F1 is defined to be a better function than another
8025 // viable function F2 if for all arguments i, ICSi(F1) is not a worse
8026 // conversion sequence than ICSi(F2), and then...
8027 unsigned NumArgs = Cand1.NumConversions;
8028 assert(Cand2.NumConversions == NumArgs && "Overload candidate mismatch");
8029 bool HasBetterConversion = false;
8030 for (unsigned ArgIdx = StartArg; ArgIdx < NumArgs; ++ArgIdx) {
8031 switch (CompareImplicitConversionSequences(S,
8032 Cand1.Conversions[ArgIdx],
8033 Cand2.Conversions[ArgIdx])) {
8034 case ImplicitConversionSequence::Better:
8035 // Cand1 has a better conversion sequence.
8036 HasBetterConversion = true;
8039 case ImplicitConversionSequence::Worse:
8040 // Cand1 can't be better than Cand2.
8043 case ImplicitConversionSequence::Indistinguishable:
8049 // -- for some argument j, ICSj(F1) is a better conversion sequence than
8050 // ICSj(F2), or, if not that,
8051 if (HasBetterConversion)
8054 // - F1 is a non-template function and F2 is a function template
8055 // specialization, or, if not that,
8056 if ((!Cand1.Function || !Cand1.Function->getPrimaryTemplate()) &&
8057 Cand2.Function && Cand2.Function->getPrimaryTemplate())
8060 // -- F1 and F2 are function template specializations, and the function
8061 // template for F1 is more specialized than the template for F2
8062 // according to the partial ordering rules described in 14.5.5.2, or,
8064 if (Cand1.Function && Cand1.Function->getPrimaryTemplate() &&
8065 Cand2.Function && Cand2.Function->getPrimaryTemplate()) {
8066 if (FunctionTemplateDecl *BetterTemplate
8067 = S.getMoreSpecializedTemplate(Cand1.Function->getPrimaryTemplate(),
8068 Cand2.Function->getPrimaryTemplate(),
8070 isa<CXXConversionDecl>(Cand1.Function)? TPOC_Conversion
8072 Cand1.ExplicitCallArguments,
8073 Cand2.ExplicitCallArguments))
8074 return BetterTemplate == Cand1.Function->getPrimaryTemplate();
8077 // -- the context is an initialization by user-defined conversion
8078 // (see 8.5, 13.3.1.5) and the standard conversion sequence
8079 // from the return type of F1 to the destination type (i.e.,
8080 // the type of the entity being initialized) is a better
8081 // conversion sequence than the standard conversion sequence
8082 // from the return type of F2 to the destination type.
8083 if (UserDefinedConversion && Cand1.Function && Cand2.Function &&
8084 isa<CXXConversionDecl>(Cand1.Function) &&
8085 isa<CXXConversionDecl>(Cand2.Function)) {
8086 // First check whether we prefer one of the conversion functions over the
8087 // other. This only distinguishes the results in non-standard, extension
8088 // cases such as the conversion from a lambda closure type to a function
8089 // pointer or block.
8090 ImplicitConversionSequence::CompareKind FuncResult
8091 = compareConversionFunctions(S, Cand1.Function, Cand2.Function);
8092 if (FuncResult != ImplicitConversionSequence::Indistinguishable)
8095 switch (CompareStandardConversionSequences(S,
8096 Cand1.FinalConversion,
8097 Cand2.FinalConversion)) {
8098 case ImplicitConversionSequence::Better:
8099 // Cand1 has a better conversion sequence.
8102 case ImplicitConversionSequence::Worse:
8103 // Cand1 can't be better than Cand2.
8106 case ImplicitConversionSequence::Indistinguishable:
8115 /// \brief Computes the best viable function (C++ 13.3.3)
8116 /// within an overload candidate set.
8118 /// \param Loc The location of the function name (or operator symbol) for
8119 /// which overload resolution occurs.
8121 /// \param Best If overload resolution was successful or found a deleted
8122 /// function, \p Best points to the candidate function found.
8124 /// \returns The result of overload resolution.
8126 OverloadCandidateSet::BestViableFunction(Sema &S, SourceLocation Loc,
8128 bool UserDefinedConversion) {
8129 // Find the best viable function.
8131 for (iterator Cand = begin(); Cand != end(); ++Cand) {
8133 if (Best == end() || isBetterOverloadCandidate(S, *Cand, *Best, Loc,
8134 UserDefinedConversion))
8138 // If we didn't find any viable functions, abort.
8140 return OR_No_Viable_Function;
8142 // Make sure that this function is better than every other viable
8143 // function. If not, we have an ambiguity.
8144 for (iterator Cand = begin(); Cand != end(); ++Cand) {
8147 !isBetterOverloadCandidate(S, *Best, *Cand, Loc,
8148 UserDefinedConversion)) {
8150 return OR_Ambiguous;
8154 // Best is the best viable function.
8155 if (Best->Function &&
8156 (Best->Function->isDeleted() ||
8157 S.isFunctionConsideredUnavailable(Best->Function)))
8165 enum OverloadCandidateKind {
8169 oc_function_template,
8171 oc_constructor_template,
8172 oc_implicit_default_constructor,
8173 oc_implicit_copy_constructor,
8174 oc_implicit_move_constructor,
8175 oc_implicit_copy_assignment,
8176 oc_implicit_move_assignment,
8177 oc_implicit_inherited_constructor
8180 OverloadCandidateKind ClassifyOverloadCandidate(Sema &S,
8182 std::string &Description) {
8183 bool isTemplate = false;
8185 if (FunctionTemplateDecl *FunTmpl = Fn->getPrimaryTemplate()) {
8187 Description = S.getTemplateArgumentBindingsText(
8188 FunTmpl->getTemplateParameters(), *Fn->getTemplateSpecializationArgs());
8191 if (CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(Fn)) {
8192 if (!Ctor->isImplicit())
8193 return isTemplate ? oc_constructor_template : oc_constructor;
8195 if (Ctor->getInheritedConstructor())
8196 return oc_implicit_inherited_constructor;
8198 if (Ctor->isDefaultConstructor())
8199 return oc_implicit_default_constructor;
8201 if (Ctor->isMoveConstructor())
8202 return oc_implicit_move_constructor;
8204 assert(Ctor->isCopyConstructor() &&
8205 "unexpected sort of implicit constructor");
8206 return oc_implicit_copy_constructor;
8209 if (CXXMethodDecl *Meth = dyn_cast<CXXMethodDecl>(Fn)) {
8210 // This actually gets spelled 'candidate function' for now, but
8211 // it doesn't hurt to split it out.
8212 if (!Meth->isImplicit())
8213 return isTemplate ? oc_method_template : oc_method;
8215 if (Meth->isMoveAssignmentOperator())
8216 return oc_implicit_move_assignment;
8218 if (Meth->isCopyAssignmentOperator())
8219 return oc_implicit_copy_assignment;
8221 assert(isa<CXXConversionDecl>(Meth) && "expected conversion");
8225 return isTemplate ? oc_function_template : oc_function;
8228 void MaybeEmitInheritedConstructorNote(Sema &S, Decl *Fn) {
8229 const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(Fn);
8232 Ctor = Ctor->getInheritedConstructor();
8235 S.Diag(Ctor->getLocation(), diag::note_ovl_candidate_inherited_constructor);
8238 } // end anonymous namespace
8240 // Notes the location of an overload candidate.
8241 void Sema::NoteOverloadCandidate(FunctionDecl *Fn, QualType DestType) {
8243 OverloadCandidateKind K = ClassifyOverloadCandidate(*this, Fn, FnDesc);
8244 PartialDiagnostic PD = PDiag(diag::note_ovl_candidate)
8245 << (unsigned) K << FnDesc;
8246 HandleFunctionTypeMismatch(PD, Fn->getType(), DestType);
8247 Diag(Fn->getLocation(), PD);
8248 MaybeEmitInheritedConstructorNote(*this, Fn);
8251 // Notes the location of all overload candidates designated through
8253 void Sema::NoteAllOverloadCandidates(Expr* OverloadedExpr, QualType DestType) {
8254 assert(OverloadedExpr->getType() == Context.OverloadTy);
8256 OverloadExpr::FindResult Ovl = OverloadExpr::find(OverloadedExpr);
8257 OverloadExpr *OvlExpr = Ovl.Expression;
8259 for (UnresolvedSetIterator I = OvlExpr->decls_begin(),
8260 IEnd = OvlExpr->decls_end();
8262 if (FunctionTemplateDecl *FunTmpl =
8263 dyn_cast<FunctionTemplateDecl>((*I)->getUnderlyingDecl()) ) {
8264 NoteOverloadCandidate(FunTmpl->getTemplatedDecl(), DestType);
8265 } else if (FunctionDecl *Fun
8266 = dyn_cast<FunctionDecl>((*I)->getUnderlyingDecl()) ) {
8267 NoteOverloadCandidate(Fun, DestType);
8272 /// Diagnoses an ambiguous conversion. The partial diagnostic is the
8273 /// "lead" diagnostic; it will be given two arguments, the source and
8274 /// target types of the conversion.
8275 void ImplicitConversionSequence::DiagnoseAmbiguousConversion(
8277 SourceLocation CaretLoc,
8278 const PartialDiagnostic &PDiag) const {
8279 S.Diag(CaretLoc, PDiag)
8280 << Ambiguous.getFromType() << Ambiguous.getToType();
8281 // FIXME: The note limiting machinery is borrowed from
8282 // OverloadCandidateSet::NoteCandidates; there's an opportunity for
8283 // refactoring here.
8284 const OverloadsShown ShowOverloads = S.Diags.getShowOverloads();
8285 unsigned CandsShown = 0;
8286 AmbiguousConversionSequence::const_iterator I, E;
8287 for (I = Ambiguous.begin(), E = Ambiguous.end(); I != E; ++I) {
8288 if (CandsShown >= 4 && ShowOverloads == Ovl_Best)
8291 S.NoteOverloadCandidate(*I);
8294 S.Diag(SourceLocation(), diag::note_ovl_too_many_candidates) << int(E - I);
8299 void DiagnoseBadConversion(Sema &S, OverloadCandidate *Cand, unsigned I) {
8300 const ImplicitConversionSequence &Conv = Cand->Conversions[I];
8301 assert(Conv.isBad());
8302 assert(Cand->Function && "for now, candidate must be a function");
8303 FunctionDecl *Fn = Cand->Function;
8305 // There's a conversion slot for the object argument if this is a
8306 // non-constructor method. Note that 'I' corresponds the
8307 // conversion-slot index.
8308 bool isObjectArgument = false;
8309 if (isa<CXXMethodDecl>(Fn) && !isa<CXXConstructorDecl>(Fn)) {
8311 isObjectArgument = true;
8317 OverloadCandidateKind FnKind = ClassifyOverloadCandidate(S, Fn, FnDesc);
8319 Expr *FromExpr = Conv.Bad.FromExpr;
8320 QualType FromTy = Conv.Bad.getFromType();
8321 QualType ToTy = Conv.Bad.getToType();
8323 if (FromTy == S.Context.OverloadTy) {
8324 assert(FromExpr && "overload set argument came from implicit argument?");
8325 Expr *E = FromExpr->IgnoreParens();
8326 if (isa<UnaryOperator>(E))
8327 E = cast<UnaryOperator>(E)->getSubExpr()->IgnoreParens();
8328 DeclarationName Name = cast<OverloadExpr>(E)->getName();
8330 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_overload)
8331 << (unsigned) FnKind << FnDesc
8332 << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
8333 << ToTy << Name << I+1;
8334 MaybeEmitInheritedConstructorNote(S, Fn);
8338 // Do some hand-waving analysis to see if the non-viability is due
8339 // to a qualifier mismatch.
8340 CanQualType CFromTy = S.Context.getCanonicalType(FromTy);
8341 CanQualType CToTy = S.Context.getCanonicalType(ToTy);
8342 if (CanQual<ReferenceType> RT = CToTy->getAs<ReferenceType>())
8343 CToTy = RT->getPointeeType();
8345 // TODO: detect and diagnose the full richness of const mismatches.
8346 if (CanQual<PointerType> FromPT = CFromTy->getAs<PointerType>())
8347 if (CanQual<PointerType> ToPT = CToTy->getAs<PointerType>())
8348 CFromTy = FromPT->getPointeeType(), CToTy = ToPT->getPointeeType();
8351 if (CToTy.getUnqualifiedType() == CFromTy.getUnqualifiedType() &&
8352 !CToTy.isAtLeastAsQualifiedAs(CFromTy)) {
8353 Qualifiers FromQs = CFromTy.getQualifiers();
8354 Qualifiers ToQs = CToTy.getQualifiers();
8356 if (FromQs.getAddressSpace() != ToQs.getAddressSpace()) {
8357 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_addrspace)
8358 << (unsigned) FnKind << FnDesc
8359 << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
8361 << FromQs.getAddressSpace() << ToQs.getAddressSpace()
8362 << (unsigned) isObjectArgument << I+1;
8363 MaybeEmitInheritedConstructorNote(S, Fn);
8367 if (FromQs.getObjCLifetime() != ToQs.getObjCLifetime()) {
8368 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_ownership)
8369 << (unsigned) FnKind << FnDesc
8370 << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
8372 << FromQs.getObjCLifetime() << ToQs.getObjCLifetime()
8373 << (unsigned) isObjectArgument << I+1;
8374 MaybeEmitInheritedConstructorNote(S, Fn);
8378 if (FromQs.getObjCGCAttr() != ToQs.getObjCGCAttr()) {
8379 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_gc)
8380 << (unsigned) FnKind << FnDesc
8381 << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
8383 << FromQs.getObjCGCAttr() << ToQs.getObjCGCAttr()
8384 << (unsigned) isObjectArgument << I+1;
8385 MaybeEmitInheritedConstructorNote(S, Fn);
8389 unsigned CVR = FromQs.getCVRQualifiers() & ~ToQs.getCVRQualifiers();
8390 assert(CVR && "unexpected qualifiers mismatch");
8392 if (isObjectArgument) {
8393 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_cvr_this)
8394 << (unsigned) FnKind << FnDesc
8395 << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
8396 << FromTy << (CVR - 1);
8398 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_cvr)
8399 << (unsigned) FnKind << FnDesc
8400 << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
8401 << FromTy << (CVR - 1) << I+1;
8403 MaybeEmitInheritedConstructorNote(S, Fn);
8407 // Special diagnostic for failure to convert an initializer list, since
8408 // telling the user that it has type void is not useful.
8409 if (FromExpr && isa<InitListExpr>(FromExpr)) {
8410 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_list_argument)
8411 << (unsigned) FnKind << FnDesc
8412 << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
8413 << FromTy << ToTy << (unsigned) isObjectArgument << I+1;
8414 MaybeEmitInheritedConstructorNote(S, Fn);
8418 // Diagnose references or pointers to incomplete types differently,
8419 // since it's far from impossible that the incompleteness triggered
8421 QualType TempFromTy = FromTy.getNonReferenceType();
8422 if (const PointerType *PTy = TempFromTy->getAs<PointerType>())
8423 TempFromTy = PTy->getPointeeType();
8424 if (TempFromTy->isIncompleteType()) {
8425 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_conv_incomplete)
8426 << (unsigned) FnKind << FnDesc
8427 << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
8428 << FromTy << ToTy << (unsigned) isObjectArgument << I+1;
8429 MaybeEmitInheritedConstructorNote(S, Fn);
8433 // Diagnose base -> derived pointer conversions.
8434 unsigned BaseToDerivedConversion = 0;
8435 if (const PointerType *FromPtrTy = FromTy->getAs<PointerType>()) {
8436 if (const PointerType *ToPtrTy = ToTy->getAs<PointerType>()) {
8437 if (ToPtrTy->getPointeeType().isAtLeastAsQualifiedAs(
8438 FromPtrTy->getPointeeType()) &&
8439 !FromPtrTy->getPointeeType()->isIncompleteType() &&
8440 !ToPtrTy->getPointeeType()->isIncompleteType() &&
8441 S.IsDerivedFrom(ToPtrTy->getPointeeType(),
8442 FromPtrTy->getPointeeType()))
8443 BaseToDerivedConversion = 1;
8445 } else if (const ObjCObjectPointerType *FromPtrTy
8446 = FromTy->getAs<ObjCObjectPointerType>()) {
8447 if (const ObjCObjectPointerType *ToPtrTy
8448 = ToTy->getAs<ObjCObjectPointerType>())
8449 if (const ObjCInterfaceDecl *FromIface = FromPtrTy->getInterfaceDecl())
8450 if (const ObjCInterfaceDecl *ToIface = ToPtrTy->getInterfaceDecl())
8451 if (ToPtrTy->getPointeeType().isAtLeastAsQualifiedAs(
8452 FromPtrTy->getPointeeType()) &&
8453 FromIface->isSuperClassOf(ToIface))
8454 BaseToDerivedConversion = 2;
8455 } else if (const ReferenceType *ToRefTy = ToTy->getAs<ReferenceType>()) {
8456 if (ToRefTy->getPointeeType().isAtLeastAsQualifiedAs(FromTy) &&
8457 !FromTy->isIncompleteType() &&
8458 !ToRefTy->getPointeeType()->isIncompleteType() &&
8459 S.IsDerivedFrom(ToRefTy->getPointeeType(), FromTy)) {
8460 BaseToDerivedConversion = 3;
8461 } else if (ToTy->isLValueReferenceType() && !FromExpr->isLValue() &&
8462 ToTy.getNonReferenceType().getCanonicalType() ==
8463 FromTy.getNonReferenceType().getCanonicalType()) {
8464 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_lvalue)
8465 << (unsigned) FnKind << FnDesc
8466 << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
8467 << (unsigned) isObjectArgument << I + 1;
8468 MaybeEmitInheritedConstructorNote(S, Fn);
8473 if (BaseToDerivedConversion) {
8474 S.Diag(Fn->getLocation(),
8475 diag::note_ovl_candidate_bad_base_to_derived_conv)
8476 << (unsigned) FnKind << FnDesc
8477 << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
8478 << (BaseToDerivedConversion - 1)
8479 << FromTy << ToTy << I+1;
8480 MaybeEmitInheritedConstructorNote(S, Fn);
8484 if (isa<ObjCObjectPointerType>(CFromTy) &&
8485 isa<PointerType>(CToTy)) {
8486 Qualifiers FromQs = CFromTy.getQualifiers();
8487 Qualifiers ToQs = CToTy.getQualifiers();
8488 if (FromQs.getObjCLifetime() != ToQs.getObjCLifetime()) {
8489 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_arc_conv)
8490 << (unsigned) FnKind << FnDesc
8491 << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
8492 << FromTy << ToTy << (unsigned) isObjectArgument << I+1;
8493 MaybeEmitInheritedConstructorNote(S, Fn);
8498 // Emit the generic diagnostic and, optionally, add the hints to it.
8499 PartialDiagnostic FDiag = S.PDiag(diag::note_ovl_candidate_bad_conv);
8500 FDiag << (unsigned) FnKind << FnDesc
8501 << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
8502 << FromTy << ToTy << (unsigned) isObjectArgument << I + 1
8503 << (unsigned) (Cand->Fix.Kind);
8505 // If we can fix the conversion, suggest the FixIts.
8506 for (std::vector<FixItHint>::iterator HI = Cand->Fix.Hints.begin(),
8507 HE = Cand->Fix.Hints.end(); HI != HE; ++HI)
8509 S.Diag(Fn->getLocation(), FDiag);
8511 MaybeEmitInheritedConstructorNote(S, Fn);
8514 /// Additional arity mismatch diagnosis specific to a function overload
8515 /// candidates. This is not covered by the more general DiagnoseArityMismatch()
8516 /// over a candidate in any candidate set.
8517 bool CheckArityMismatch(Sema &S, OverloadCandidate *Cand,
8519 FunctionDecl *Fn = Cand->Function;
8520 unsigned MinParams = Fn->getMinRequiredArguments();
8522 // With invalid overloaded operators, it's possible that we think we
8523 // have an arity mismatch when in fact it looks like we have the
8524 // right number of arguments, because only overloaded operators have
8525 // the weird behavior of overloading member and non-member functions.
8526 // Just don't report anything.
8527 if (Fn->isInvalidDecl() &&
8528 Fn->getDeclName().getNameKind() == DeclarationName::CXXOperatorName)
8531 if (NumArgs < MinParams) {
8532 assert((Cand->FailureKind == ovl_fail_too_few_arguments) ||
8533 (Cand->FailureKind == ovl_fail_bad_deduction &&
8534 Cand->DeductionFailure.Result == Sema::TDK_TooFewArguments));
8536 assert((Cand->FailureKind == ovl_fail_too_many_arguments) ||
8537 (Cand->FailureKind == ovl_fail_bad_deduction &&
8538 Cand->DeductionFailure.Result == Sema::TDK_TooManyArguments));
8544 /// General arity mismatch diagnosis over a candidate in a candidate set.
8545 void DiagnoseArityMismatch(Sema &S, Decl *D, unsigned NumFormalArgs) {
8546 assert(isa<FunctionDecl>(D) &&
8547 "The templated declaration should at least be a function"
8548 " when diagnosing bad template argument deduction due to too many"
8549 " or too few arguments");
8551 FunctionDecl *Fn = cast<FunctionDecl>(D);
8553 // TODO: treat calls to a missing default constructor as a special case
8554 const FunctionProtoType *FnTy = Fn->getType()->getAs<FunctionProtoType>();
8555 unsigned MinParams = Fn->getMinRequiredArguments();
8557 // at least / at most / exactly
8558 unsigned mode, modeCount;
8559 if (NumFormalArgs < MinParams) {
8560 if (MinParams != FnTy->getNumArgs() ||
8561 FnTy->isVariadic() || FnTy->isTemplateVariadic())
8562 mode = 0; // "at least"
8564 mode = 2; // "exactly"
8565 modeCount = MinParams;
8567 if (MinParams != FnTy->getNumArgs())
8568 mode = 1; // "at most"
8570 mode = 2; // "exactly"
8571 modeCount = FnTy->getNumArgs();
8574 std::string Description;
8575 OverloadCandidateKind FnKind = ClassifyOverloadCandidate(S, Fn, Description);
8577 if (modeCount == 1 && Fn->getParamDecl(0)->getDeclName())
8578 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_arity_one)
8579 << (unsigned) FnKind << (Fn->getDescribedFunctionTemplate() != 0) << mode
8580 << Fn->getParamDecl(0) << NumFormalArgs;
8582 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_arity)
8583 << (unsigned) FnKind << (Fn->getDescribedFunctionTemplate() != 0) << mode
8584 << modeCount << NumFormalArgs;
8585 MaybeEmitInheritedConstructorNote(S, Fn);
8588 /// Arity mismatch diagnosis specific to a function overload candidate.
8589 void DiagnoseArityMismatch(Sema &S, OverloadCandidate *Cand,
8590 unsigned NumFormalArgs) {
8591 if (!CheckArityMismatch(S, Cand, NumFormalArgs))
8592 DiagnoseArityMismatch(S, Cand->Function, NumFormalArgs);
8595 TemplateDecl *getDescribedTemplate(Decl *Templated) {
8596 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(Templated))
8597 return FD->getDescribedFunctionTemplate();
8598 else if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Templated))
8599 return RD->getDescribedClassTemplate();
8601 llvm_unreachable("Unsupported: Getting the described template declaration"
8602 " for bad deduction diagnosis");
8605 /// Diagnose a failed template-argument deduction.
8606 void DiagnoseBadDeduction(Sema &S, Decl *Templated,
8607 DeductionFailureInfo &DeductionFailure,
8609 TemplateParameter Param = DeductionFailure.getTemplateParameter();
8611 (ParamD = Param.dyn_cast<TemplateTypeParmDecl*>()) ||
8612 (ParamD = Param.dyn_cast<NonTypeTemplateParmDecl*>()) ||
8613 (ParamD = Param.dyn_cast<TemplateTemplateParmDecl*>());
8614 switch (DeductionFailure.Result) {
8615 case Sema::TDK_Success:
8616 llvm_unreachable("TDK_success while diagnosing bad deduction");
8618 case Sema::TDK_Incomplete: {
8619 assert(ParamD && "no parameter found for incomplete deduction result");
8620 S.Diag(Templated->getLocation(),
8621 diag::note_ovl_candidate_incomplete_deduction)
8622 << ParamD->getDeclName();
8623 MaybeEmitInheritedConstructorNote(S, Templated);
8627 case Sema::TDK_Underqualified: {
8628 assert(ParamD && "no parameter found for bad qualifiers deduction result");
8629 TemplateTypeParmDecl *TParam = cast<TemplateTypeParmDecl>(ParamD);
8631 QualType Param = DeductionFailure.getFirstArg()->getAsType();
8633 // Param will have been canonicalized, but it should just be a
8634 // qualified version of ParamD, so move the qualifiers to that.
8635 QualifierCollector Qs;
8637 QualType NonCanonParam = Qs.apply(S.Context, TParam->getTypeForDecl());
8638 assert(S.Context.hasSameType(Param, NonCanonParam));
8640 // Arg has also been canonicalized, but there's nothing we can do
8641 // about that. It also doesn't matter as much, because it won't
8642 // have any template parameters in it (because deduction isn't
8643 // done on dependent types).
8644 QualType Arg = DeductionFailure.getSecondArg()->getAsType();
8646 S.Diag(Templated->getLocation(), diag::note_ovl_candidate_underqualified)
8647 << ParamD->getDeclName() << Arg << NonCanonParam;
8648 MaybeEmitInheritedConstructorNote(S, Templated);
8652 case Sema::TDK_Inconsistent: {
8653 assert(ParamD && "no parameter found for inconsistent deduction result");
8655 if (isa<TemplateTypeParmDecl>(ParamD))
8657 else if (isa<NonTypeTemplateParmDecl>(ParamD))
8663 S.Diag(Templated->getLocation(),
8664 diag::note_ovl_candidate_inconsistent_deduction)
8665 << which << ParamD->getDeclName() << *DeductionFailure.getFirstArg()
8666 << *DeductionFailure.getSecondArg();
8667 MaybeEmitInheritedConstructorNote(S, Templated);
8671 case Sema::TDK_InvalidExplicitArguments:
8672 assert(ParamD && "no parameter found for invalid explicit arguments");
8673 if (ParamD->getDeclName())
8674 S.Diag(Templated->getLocation(),
8675 diag::note_ovl_candidate_explicit_arg_mismatch_named)
8676 << ParamD->getDeclName();
8679 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ParamD))
8680 index = TTP->getIndex();
8681 else if (NonTypeTemplateParmDecl *NTTP
8682 = dyn_cast<NonTypeTemplateParmDecl>(ParamD))
8683 index = NTTP->getIndex();
8685 index = cast<TemplateTemplateParmDecl>(ParamD)->getIndex();
8686 S.Diag(Templated->getLocation(),
8687 diag::note_ovl_candidate_explicit_arg_mismatch_unnamed)
8690 MaybeEmitInheritedConstructorNote(S, Templated);
8693 case Sema::TDK_TooManyArguments:
8694 case Sema::TDK_TooFewArguments:
8695 DiagnoseArityMismatch(S, Templated, NumArgs);
8698 case Sema::TDK_InstantiationDepth:
8699 S.Diag(Templated->getLocation(),
8700 diag::note_ovl_candidate_instantiation_depth);
8701 MaybeEmitInheritedConstructorNote(S, Templated);
8704 case Sema::TDK_SubstitutionFailure: {
8705 // Format the template argument list into the argument string.
8706 SmallString<128> TemplateArgString;
8707 if (TemplateArgumentList *Args =
8708 DeductionFailure.getTemplateArgumentList()) {
8709 TemplateArgString = " ";
8710 TemplateArgString += S.getTemplateArgumentBindingsText(
8711 getDescribedTemplate(Templated)->getTemplateParameters(), *Args);
8714 // If this candidate was disabled by enable_if, say so.
8715 PartialDiagnosticAt *PDiag = DeductionFailure.getSFINAEDiagnostic();
8716 if (PDiag && PDiag->second.getDiagID() ==
8717 diag::err_typename_nested_not_found_enable_if) {
8718 // FIXME: Use the source range of the condition, and the fully-qualified
8719 // name of the enable_if template. These are both present in PDiag.
8720 S.Diag(PDiag->first, diag::note_ovl_candidate_disabled_by_enable_if)
8721 << "'enable_if'" << TemplateArgString;
8725 // Format the SFINAE diagnostic into the argument string.
8726 // FIXME: Add a general mechanism to include a PartialDiagnostic *'s
8727 // formatted message in another diagnostic.
8728 SmallString<128> SFINAEArgString;
8731 SFINAEArgString = ": ";
8732 R = SourceRange(PDiag->first, PDiag->first);
8733 PDiag->second.EmitToString(S.getDiagnostics(), SFINAEArgString);
8736 S.Diag(Templated->getLocation(),
8737 diag::note_ovl_candidate_substitution_failure)
8738 << TemplateArgString << SFINAEArgString << R;
8739 MaybeEmitInheritedConstructorNote(S, Templated);
8743 case Sema::TDK_FailedOverloadResolution: {
8744 OverloadExpr::FindResult R = OverloadExpr::find(DeductionFailure.getExpr());
8745 S.Diag(Templated->getLocation(),
8746 diag::note_ovl_candidate_failed_overload_resolution)
8747 << R.Expression->getName();
8751 case Sema::TDK_NonDeducedMismatch: {
8752 // FIXME: Provide a source location to indicate what we couldn't match.
8753 TemplateArgument FirstTA = *DeductionFailure.getFirstArg();
8754 TemplateArgument SecondTA = *DeductionFailure.getSecondArg();
8755 if (FirstTA.getKind() == TemplateArgument::Template &&
8756 SecondTA.getKind() == TemplateArgument::Template) {
8757 TemplateName FirstTN = FirstTA.getAsTemplate();
8758 TemplateName SecondTN = SecondTA.getAsTemplate();
8759 if (FirstTN.getKind() == TemplateName::Template &&
8760 SecondTN.getKind() == TemplateName::Template) {
8761 if (FirstTN.getAsTemplateDecl()->getName() ==
8762 SecondTN.getAsTemplateDecl()->getName()) {
8763 // FIXME: This fixes a bad diagnostic where both templates are named
8764 // the same. This particular case is a bit difficult since:
8765 // 1) It is passed as a string to the diagnostic printer.
8766 // 2) The diagnostic printer only attempts to find a better
8767 // name for types, not decls.
8768 // Ideally, this should folded into the diagnostic printer.
8769 S.Diag(Templated->getLocation(),
8770 diag::note_ovl_candidate_non_deduced_mismatch_qualified)
8771 << FirstTN.getAsTemplateDecl() << SecondTN.getAsTemplateDecl();
8776 // FIXME: For generic lambda parameters, check if the function is a lambda
8777 // call operator, and if so, emit a prettier and more informative
8778 // diagnostic that mentions 'auto' and lambda in addition to
8779 // (or instead of?) the canonical template type parameters.
8780 S.Diag(Templated->getLocation(),
8781 diag::note_ovl_candidate_non_deduced_mismatch)
8782 << FirstTA << SecondTA;
8785 // TODO: diagnose these individually, then kill off
8786 // note_ovl_candidate_bad_deduction, which is uselessly vague.
8787 case Sema::TDK_MiscellaneousDeductionFailure:
8788 S.Diag(Templated->getLocation(), diag::note_ovl_candidate_bad_deduction);
8789 MaybeEmitInheritedConstructorNote(S, Templated);
8794 /// Diagnose a failed template-argument deduction, for function calls.
8795 void DiagnoseBadDeduction(Sema &S, OverloadCandidate *Cand, unsigned NumArgs) {
8796 unsigned TDK = Cand->DeductionFailure.Result;
8797 if (TDK == Sema::TDK_TooFewArguments || TDK == Sema::TDK_TooManyArguments) {
8798 if (CheckArityMismatch(S, Cand, NumArgs))
8801 DiagnoseBadDeduction(S, Cand->Function, // pattern
8802 Cand->DeductionFailure, NumArgs);
8805 /// CUDA: diagnose an invalid call across targets.
8806 void DiagnoseBadTarget(Sema &S, OverloadCandidate *Cand) {
8807 FunctionDecl *Caller = cast<FunctionDecl>(S.CurContext);
8808 FunctionDecl *Callee = Cand->Function;
8810 Sema::CUDAFunctionTarget CallerTarget = S.IdentifyCUDATarget(Caller),
8811 CalleeTarget = S.IdentifyCUDATarget(Callee);
8814 OverloadCandidateKind FnKind = ClassifyOverloadCandidate(S, Callee, FnDesc);
8816 S.Diag(Callee->getLocation(), diag::note_ovl_candidate_bad_target)
8817 << (unsigned) FnKind << CalleeTarget << CallerTarget;
8820 /// Generates a 'note' diagnostic for an overload candidate. We've
8821 /// already generated a primary error at the call site.
8823 /// It really does need to be a single diagnostic with its caret
8824 /// pointed at the candidate declaration. Yes, this creates some
8825 /// major challenges of technical writing. Yes, this makes pointing
8826 /// out problems with specific arguments quite awkward. It's still
8827 /// better than generating twenty screens of text for every failed
8830 /// It would be great to be able to express per-candidate problems
8831 /// more richly for those diagnostic clients that cared, but we'd
8832 /// still have to be just as careful with the default diagnostics.
8833 void NoteFunctionCandidate(Sema &S, OverloadCandidate *Cand,
8835 FunctionDecl *Fn = Cand->Function;
8837 // Note deleted candidates, but only if they're viable.
8838 if (Cand->Viable && (Fn->isDeleted() ||
8839 S.isFunctionConsideredUnavailable(Fn))) {
8841 OverloadCandidateKind FnKind = ClassifyOverloadCandidate(S, Fn, FnDesc);
8843 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_deleted)
8845 << (Fn->isDeleted() ? (Fn->isDeletedAsWritten() ? 1 : 2) : 0);
8846 MaybeEmitInheritedConstructorNote(S, Fn);
8850 // We don't really have anything else to say about viable candidates.
8852 S.NoteOverloadCandidate(Fn);
8856 switch (Cand->FailureKind) {
8857 case ovl_fail_too_many_arguments:
8858 case ovl_fail_too_few_arguments:
8859 return DiagnoseArityMismatch(S, Cand, NumArgs);
8861 case ovl_fail_bad_deduction:
8862 return DiagnoseBadDeduction(S, Cand, NumArgs);
8864 case ovl_fail_trivial_conversion:
8865 case ovl_fail_bad_final_conversion:
8866 case ovl_fail_final_conversion_not_exact:
8867 return S.NoteOverloadCandidate(Fn);
8869 case ovl_fail_bad_conversion: {
8870 unsigned I = (Cand->IgnoreObjectArgument ? 1 : 0);
8871 for (unsigned N = Cand->NumConversions; I != N; ++I)
8872 if (Cand->Conversions[I].isBad())
8873 return DiagnoseBadConversion(S, Cand, I);
8875 // FIXME: this currently happens when we're called from SemaInit
8876 // when user-conversion overload fails. Figure out how to handle
8877 // those conditions and diagnose them well.
8878 return S.NoteOverloadCandidate(Fn);
8881 case ovl_fail_bad_target:
8882 return DiagnoseBadTarget(S, Cand);
8886 void NoteSurrogateCandidate(Sema &S, OverloadCandidate *Cand) {
8887 // Desugar the type of the surrogate down to a function type,
8888 // retaining as many typedefs as possible while still showing
8889 // the function type (and, therefore, its parameter types).
8890 QualType FnType = Cand->Surrogate->getConversionType();
8891 bool isLValueReference = false;
8892 bool isRValueReference = false;
8893 bool isPointer = false;
8894 if (const LValueReferenceType *FnTypeRef =
8895 FnType->getAs<LValueReferenceType>()) {
8896 FnType = FnTypeRef->getPointeeType();
8897 isLValueReference = true;
8898 } else if (const RValueReferenceType *FnTypeRef =
8899 FnType->getAs<RValueReferenceType>()) {
8900 FnType = FnTypeRef->getPointeeType();
8901 isRValueReference = true;
8903 if (const PointerType *FnTypePtr = FnType->getAs<PointerType>()) {
8904 FnType = FnTypePtr->getPointeeType();
8907 // Desugar down to a function type.
8908 FnType = QualType(FnType->getAs<FunctionType>(), 0);
8909 // Reconstruct the pointer/reference as appropriate.
8910 if (isPointer) FnType = S.Context.getPointerType(FnType);
8911 if (isRValueReference) FnType = S.Context.getRValueReferenceType(FnType);
8912 if (isLValueReference) FnType = S.Context.getLValueReferenceType(FnType);
8914 S.Diag(Cand->Surrogate->getLocation(), diag::note_ovl_surrogate_cand)
8916 MaybeEmitInheritedConstructorNote(S, Cand->Surrogate);
8919 void NoteBuiltinOperatorCandidate(Sema &S,
8921 SourceLocation OpLoc,
8922 OverloadCandidate *Cand) {
8923 assert(Cand->NumConversions <= 2 && "builtin operator is not binary");
8924 std::string TypeStr("operator");
8927 TypeStr += Cand->BuiltinTypes.ParamTypes[0].getAsString();
8928 if (Cand->NumConversions == 1) {
8930 S.Diag(OpLoc, diag::note_ovl_builtin_unary_candidate) << TypeStr;
8933 TypeStr += Cand->BuiltinTypes.ParamTypes[1].getAsString();
8935 S.Diag(OpLoc, diag::note_ovl_builtin_binary_candidate) << TypeStr;
8939 void NoteAmbiguousUserConversions(Sema &S, SourceLocation OpLoc,
8940 OverloadCandidate *Cand) {
8941 unsigned NoOperands = Cand->NumConversions;
8942 for (unsigned ArgIdx = 0; ArgIdx < NoOperands; ++ArgIdx) {
8943 const ImplicitConversionSequence &ICS = Cand->Conversions[ArgIdx];
8944 if (ICS.isBad()) break; // all meaningless after first invalid
8945 if (!ICS.isAmbiguous()) continue;
8947 ICS.DiagnoseAmbiguousConversion(S, OpLoc,
8948 S.PDiag(diag::note_ambiguous_type_conversion));
8952 static SourceLocation GetLocationForCandidate(const OverloadCandidate *Cand) {
8954 return Cand->Function->getLocation();
8955 if (Cand->IsSurrogate)
8956 return Cand->Surrogate->getLocation();
8957 return SourceLocation();
8960 static unsigned RankDeductionFailure(const DeductionFailureInfo &DFI) {
8961 switch ((Sema::TemplateDeductionResult)DFI.Result) {
8962 case Sema::TDK_Success:
8963 llvm_unreachable("TDK_success while diagnosing bad deduction");
8965 case Sema::TDK_Invalid:
8966 case Sema::TDK_Incomplete:
8969 case Sema::TDK_Underqualified:
8970 case Sema::TDK_Inconsistent:
8973 case Sema::TDK_SubstitutionFailure:
8974 case Sema::TDK_NonDeducedMismatch:
8975 case Sema::TDK_MiscellaneousDeductionFailure:
8978 case Sema::TDK_InstantiationDepth:
8979 case Sema::TDK_FailedOverloadResolution:
8982 case Sema::TDK_InvalidExplicitArguments:
8985 case Sema::TDK_TooManyArguments:
8986 case Sema::TDK_TooFewArguments:
8989 llvm_unreachable("Unhandled deduction result");
8992 struct CompareOverloadCandidatesForDisplay {
8994 CompareOverloadCandidatesForDisplay(Sema &S) : S(S) {}
8996 bool operator()(const OverloadCandidate *L,
8997 const OverloadCandidate *R) {
8998 // Fast-path this check.
8999 if (L == R) return false;
9001 // Order first by viability.
9003 if (!R->Viable) return true;
9005 // TODO: introduce a tri-valued comparison for overload
9006 // candidates. Would be more worthwhile if we had a sort
9007 // that could exploit it.
9008 if (isBetterOverloadCandidate(S, *L, *R, SourceLocation())) return true;
9009 if (isBetterOverloadCandidate(S, *R, *L, SourceLocation())) return false;
9010 } else if (R->Viable)
9013 assert(L->Viable == R->Viable);
9015 // Criteria by which we can sort non-viable candidates:
9017 // 1. Arity mismatches come after other candidates.
9018 if (L->FailureKind == ovl_fail_too_many_arguments ||
9019 L->FailureKind == ovl_fail_too_few_arguments)
9021 if (R->FailureKind == ovl_fail_too_many_arguments ||
9022 R->FailureKind == ovl_fail_too_few_arguments)
9025 // 2. Bad conversions come first and are ordered by the number
9026 // of bad conversions and quality of good conversions.
9027 if (L->FailureKind == ovl_fail_bad_conversion) {
9028 if (R->FailureKind != ovl_fail_bad_conversion)
9031 // The conversion that can be fixed with a smaller number of changes,
9033 unsigned numLFixes = L->Fix.NumConversionsFixed;
9034 unsigned numRFixes = R->Fix.NumConversionsFixed;
9035 numLFixes = (numLFixes == 0) ? UINT_MAX : numLFixes;
9036 numRFixes = (numRFixes == 0) ? UINT_MAX : numRFixes;
9037 if (numLFixes != numRFixes) {
9038 if (numLFixes < numRFixes)
9044 // If there's any ordering between the defined conversions...
9045 // FIXME: this might not be transitive.
9046 assert(L->NumConversions == R->NumConversions);
9049 unsigned I = (L->IgnoreObjectArgument || R->IgnoreObjectArgument);
9050 for (unsigned E = L->NumConversions; I != E; ++I) {
9051 switch (CompareImplicitConversionSequences(S,
9053 R->Conversions[I])) {
9054 case ImplicitConversionSequence::Better:
9058 case ImplicitConversionSequence::Worse:
9062 case ImplicitConversionSequence::Indistinguishable:
9066 if (leftBetter > 0) return true;
9067 if (leftBetter < 0) return false;
9069 } else if (R->FailureKind == ovl_fail_bad_conversion)
9072 if (L->FailureKind == ovl_fail_bad_deduction) {
9073 if (R->FailureKind != ovl_fail_bad_deduction)
9076 if (L->DeductionFailure.Result != R->DeductionFailure.Result)
9077 return RankDeductionFailure(L->DeductionFailure)
9078 < RankDeductionFailure(R->DeductionFailure);
9079 } else if (R->FailureKind == ovl_fail_bad_deduction)
9085 // Sort everything else by location.
9086 SourceLocation LLoc = GetLocationForCandidate(L);
9087 SourceLocation RLoc = GetLocationForCandidate(R);
9089 // Put candidates without locations (e.g. builtins) at the end.
9090 if (LLoc.isInvalid()) return false;
9091 if (RLoc.isInvalid()) return true;
9093 return S.SourceMgr.isBeforeInTranslationUnit(LLoc, RLoc);
9097 /// CompleteNonViableCandidate - Normally, overload resolution only
9098 /// computes up to the first. Produces the FixIt set if possible.
9099 void CompleteNonViableCandidate(Sema &S, OverloadCandidate *Cand,
9100 ArrayRef<Expr *> Args) {
9101 assert(!Cand->Viable);
9103 // Don't do anything on failures other than bad conversion.
9104 if (Cand->FailureKind != ovl_fail_bad_conversion) return;
9106 // We only want the FixIts if all the arguments can be corrected.
9107 bool Unfixable = false;
9108 // Use a implicit copy initialization to check conversion fixes.
9109 Cand->Fix.setConversionChecker(TryCopyInitialization);
9111 // Skip forward to the first bad conversion.
9112 unsigned ConvIdx = (Cand->IgnoreObjectArgument ? 1 : 0);
9113 unsigned ConvCount = Cand->NumConversions;
9115 assert(ConvIdx != ConvCount && "no bad conversion in candidate");
9117 if (Cand->Conversions[ConvIdx - 1].isBad()) {
9118 Unfixable = !Cand->TryToFixBadConversion(ConvIdx - 1, S);
9123 if (ConvIdx == ConvCount)
9126 assert(!Cand->Conversions[ConvIdx].isInitialized() &&
9127 "remaining conversion is initialized?");
9129 // FIXME: this should probably be preserved from the overload
9130 // operation somehow.
9131 bool SuppressUserConversions = false;
9133 const FunctionProtoType* Proto;
9134 unsigned ArgIdx = ConvIdx;
9136 if (Cand->IsSurrogate) {
9138 = Cand->Surrogate->getConversionType().getNonReferenceType();
9139 if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>())
9140 ConvType = ConvPtrType->getPointeeType();
9141 Proto = ConvType->getAs<FunctionProtoType>();
9143 } else if (Cand->Function) {
9144 Proto = Cand->Function->getType()->getAs<FunctionProtoType>();
9145 if (isa<CXXMethodDecl>(Cand->Function) &&
9146 !isa<CXXConstructorDecl>(Cand->Function))
9149 // Builtin binary operator with a bad first conversion.
9150 assert(ConvCount <= 3);
9151 for (; ConvIdx != ConvCount; ++ConvIdx)
9152 Cand->Conversions[ConvIdx]
9153 = TryCopyInitialization(S, Args[ConvIdx],
9154 Cand->BuiltinTypes.ParamTypes[ConvIdx],
9155 SuppressUserConversions,
9156 /*InOverloadResolution*/ true,
9157 /*AllowObjCWritebackConversion=*/
9158 S.getLangOpts().ObjCAutoRefCount);
9162 // Fill in the rest of the conversions.
9163 unsigned NumArgsInProto = Proto->getNumArgs();
9164 for (; ConvIdx != ConvCount; ++ConvIdx, ++ArgIdx) {
9165 if (ArgIdx < NumArgsInProto) {
9166 Cand->Conversions[ConvIdx]
9167 = TryCopyInitialization(S, Args[ArgIdx], Proto->getArgType(ArgIdx),
9168 SuppressUserConversions,
9169 /*InOverloadResolution=*/true,
9170 /*AllowObjCWritebackConversion=*/
9171 S.getLangOpts().ObjCAutoRefCount);
9172 // Store the FixIt in the candidate if it exists.
9173 if (!Unfixable && Cand->Conversions[ConvIdx].isBad())
9174 Unfixable = !Cand->TryToFixBadConversion(ConvIdx, S);
9177 Cand->Conversions[ConvIdx].setEllipsis();
9181 } // end anonymous namespace
9183 /// PrintOverloadCandidates - When overload resolution fails, prints
9184 /// diagnostic messages containing the candidates in the candidate
9186 void OverloadCandidateSet::NoteCandidates(Sema &S,
9187 OverloadCandidateDisplayKind OCD,
9188 ArrayRef<Expr *> Args,
9190 SourceLocation OpLoc) {
9191 // Sort the candidates by viability and position. Sorting directly would
9192 // be prohibitive, so we make a set of pointers and sort those.
9193 SmallVector<OverloadCandidate*, 32> Cands;
9194 if (OCD == OCD_AllCandidates) Cands.reserve(size());
9195 for (iterator Cand = begin(), LastCand = end(); Cand != LastCand; ++Cand) {
9197 Cands.push_back(Cand);
9198 else if (OCD == OCD_AllCandidates) {
9199 CompleteNonViableCandidate(S, Cand, Args);
9200 if (Cand->Function || Cand->IsSurrogate)
9201 Cands.push_back(Cand);
9202 // Otherwise, this a non-viable builtin candidate. We do not, in general,
9203 // want to list every possible builtin candidate.
9207 std::sort(Cands.begin(), Cands.end(),
9208 CompareOverloadCandidatesForDisplay(S));
9210 bool ReportedAmbiguousConversions = false;
9212 SmallVectorImpl<OverloadCandidate*>::iterator I, E;
9213 const OverloadsShown ShowOverloads = S.Diags.getShowOverloads();
9214 unsigned CandsShown = 0;
9215 for (I = Cands.begin(), E = Cands.end(); I != E; ++I) {
9216 OverloadCandidate *Cand = *I;
9218 // Set an arbitrary limit on the number of candidate functions we'll spam
9219 // the user with. FIXME: This limit should depend on details of the
9221 if (CandsShown >= 4 && ShowOverloads == Ovl_Best) {
9227 NoteFunctionCandidate(S, Cand, Args.size());
9228 else if (Cand->IsSurrogate)
9229 NoteSurrogateCandidate(S, Cand);
9231 assert(Cand->Viable &&
9232 "Non-viable built-in candidates are not added to Cands.");
9233 // Generally we only see ambiguities including viable builtin
9234 // operators if overload resolution got screwed up by an
9235 // ambiguous user-defined conversion.
9237 // FIXME: It's quite possible for different conversions to see
9238 // different ambiguities, though.
9239 if (!ReportedAmbiguousConversions) {
9240 NoteAmbiguousUserConversions(S, OpLoc, Cand);
9241 ReportedAmbiguousConversions = true;
9244 // If this is a viable builtin, print it.
9245 NoteBuiltinOperatorCandidate(S, Opc, OpLoc, Cand);
9250 S.Diag(OpLoc, diag::note_ovl_too_many_candidates) << int(E - I);
9253 static SourceLocation
9254 GetLocationForCandidate(const TemplateSpecCandidate *Cand) {
9255 return Cand->Specialization ? Cand->Specialization->getLocation()
9259 struct CompareTemplateSpecCandidatesForDisplay {
9261 CompareTemplateSpecCandidatesForDisplay(Sema &S) : S(S) {}
9263 bool operator()(const TemplateSpecCandidate *L,
9264 const TemplateSpecCandidate *R) {
9265 // Fast-path this check.
9269 // Assuming that both candidates are not matches...
9271 // Sort by the ranking of deduction failures.
9272 if (L->DeductionFailure.Result != R->DeductionFailure.Result)
9273 return RankDeductionFailure(L->DeductionFailure) <
9274 RankDeductionFailure(R->DeductionFailure);
9276 // Sort everything else by location.
9277 SourceLocation LLoc = GetLocationForCandidate(L);
9278 SourceLocation RLoc = GetLocationForCandidate(R);
9280 // Put candidates without locations (e.g. builtins) at the end.
9281 if (LLoc.isInvalid())
9283 if (RLoc.isInvalid())
9286 return S.SourceMgr.isBeforeInTranslationUnit(LLoc, RLoc);
9290 /// Diagnose a template argument deduction failure.
9291 /// We are treating these failures as overload failures due to bad
9293 void TemplateSpecCandidate::NoteDeductionFailure(Sema &S) {
9294 DiagnoseBadDeduction(S, Specialization, // pattern
9295 DeductionFailure, /*NumArgs=*/0);
9298 void TemplateSpecCandidateSet::destroyCandidates() {
9299 for (iterator i = begin(), e = end(); i != e; ++i) {
9300 i->DeductionFailure.Destroy();
9304 void TemplateSpecCandidateSet::clear() {
9305 destroyCandidates();
9309 /// NoteCandidates - When no template specialization match is found, prints
9310 /// diagnostic messages containing the non-matching specializations that form
9311 /// the candidate set.
9312 /// This is analoguous to OverloadCandidateSet::NoteCandidates() with
9313 /// OCD == OCD_AllCandidates and Cand->Viable == false.
9314 void TemplateSpecCandidateSet::NoteCandidates(Sema &S, SourceLocation Loc) {
9315 // Sort the candidates by position (assuming no candidate is a match).
9316 // Sorting directly would be prohibitive, so we make a set of pointers
9318 SmallVector<TemplateSpecCandidate *, 32> Cands;
9319 Cands.reserve(size());
9320 for (iterator Cand = begin(), LastCand = end(); Cand != LastCand; ++Cand) {
9321 if (Cand->Specialization)
9322 Cands.push_back(Cand);
9323 // Otherwise, this is a non matching builtin candidate. We do not,
9324 // in general, want to list every possible builtin candidate.
9327 std::sort(Cands.begin(), Cands.end(),
9328 CompareTemplateSpecCandidatesForDisplay(S));
9330 // FIXME: Perhaps rename OverloadsShown and getShowOverloads()
9331 // for generalization purposes (?).
9332 const OverloadsShown ShowOverloads = S.Diags.getShowOverloads();
9334 SmallVectorImpl<TemplateSpecCandidate *>::iterator I, E;
9335 unsigned CandsShown = 0;
9336 for (I = Cands.begin(), E = Cands.end(); I != E; ++I) {
9337 TemplateSpecCandidate *Cand = *I;
9339 // Set an arbitrary limit on the number of candidates we'll spam
9340 // the user with. FIXME: This limit should depend on details of the
9342 if (CandsShown >= 4 && ShowOverloads == Ovl_Best)
9346 assert(Cand->Specialization &&
9347 "Non-matching built-in candidates are not added to Cands.");
9348 Cand->NoteDeductionFailure(S);
9352 S.Diag(Loc, diag::note_ovl_too_many_candidates) << int(E - I);
9355 // [PossiblyAFunctionType] --> [Return]
9356 // NonFunctionType --> NonFunctionType
9358 // R (*)(A) --> R (A)
9359 // R (&)(A) --> R (A)
9360 // R (S::*)(A) --> R (A)
9361 QualType Sema::ExtractUnqualifiedFunctionType(QualType PossiblyAFunctionType) {
9362 QualType Ret = PossiblyAFunctionType;
9363 if (const PointerType *ToTypePtr =
9364 PossiblyAFunctionType->getAs<PointerType>())
9365 Ret = ToTypePtr->getPointeeType();
9366 else if (const ReferenceType *ToTypeRef =
9367 PossiblyAFunctionType->getAs<ReferenceType>())
9368 Ret = ToTypeRef->getPointeeType();
9369 else if (const MemberPointerType *MemTypePtr =
9370 PossiblyAFunctionType->getAs<MemberPointerType>())
9371 Ret = MemTypePtr->getPointeeType();
9373 Context.getCanonicalType(Ret).getUnqualifiedType();
9377 // A helper class to help with address of function resolution
9378 // - allows us to avoid passing around all those ugly parameters
9379 class AddressOfFunctionResolver
9383 const QualType& TargetType;
9384 QualType TargetFunctionType; // Extracted function type from target type
9387 //DeclAccessPair& ResultFunctionAccessPair;
9388 ASTContext& Context;
9390 bool TargetTypeIsNonStaticMemberFunction;
9391 bool FoundNonTemplateFunction;
9392 bool StaticMemberFunctionFromBoundPointer;
9394 OverloadExpr::FindResult OvlExprInfo;
9395 OverloadExpr *OvlExpr;
9396 TemplateArgumentListInfo OvlExplicitTemplateArgs;
9397 SmallVector<std::pair<DeclAccessPair, FunctionDecl*>, 4> Matches;
9398 TemplateSpecCandidateSet FailedCandidates;
9401 AddressOfFunctionResolver(Sema &S, Expr *SourceExpr,
9402 const QualType &TargetType, bool Complain)
9403 : S(S), SourceExpr(SourceExpr), TargetType(TargetType),
9404 Complain(Complain), Context(S.getASTContext()),
9405 TargetTypeIsNonStaticMemberFunction(
9406 !!TargetType->getAs<MemberPointerType>()),
9407 FoundNonTemplateFunction(false),
9408 StaticMemberFunctionFromBoundPointer(false),
9409 OvlExprInfo(OverloadExpr::find(SourceExpr)),
9410 OvlExpr(OvlExprInfo.Expression),
9411 FailedCandidates(OvlExpr->getNameLoc()) {
9412 ExtractUnqualifiedFunctionTypeFromTargetType();
9414 if (TargetFunctionType->isFunctionType()) {
9415 if (UnresolvedMemberExpr *UME = dyn_cast<UnresolvedMemberExpr>(OvlExpr))
9416 if (!UME->isImplicitAccess() &&
9417 !S.ResolveSingleFunctionTemplateSpecialization(UME))
9418 StaticMemberFunctionFromBoundPointer = true;
9419 } else if (OvlExpr->hasExplicitTemplateArgs()) {
9421 if (FunctionDecl *Fn = S.ResolveSingleFunctionTemplateSpecialization(
9422 OvlExpr, false, &dap)) {
9423 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn))
9424 if (!Method->isStatic()) {
9425 // If the target type is a non-function type and the function found
9426 // is a non-static member function, pretend as if that was the
9427 // target, it's the only possible type to end up with.
9428 TargetTypeIsNonStaticMemberFunction = true;
9430 // And skip adding the function if its not in the proper form.
9431 // We'll diagnose this due to an empty set of functions.
9432 if (!OvlExprInfo.HasFormOfMemberPointer)
9436 Matches.push_back(std::make_pair(dap, Fn));
9441 if (OvlExpr->hasExplicitTemplateArgs())
9442 OvlExpr->getExplicitTemplateArgs().copyInto(OvlExplicitTemplateArgs);
9444 if (FindAllFunctionsThatMatchTargetTypeExactly()) {
9445 // C++ [over.over]p4:
9446 // If more than one function is selected, [...]
9447 if (Matches.size() > 1) {
9448 if (FoundNonTemplateFunction)
9449 EliminateAllTemplateMatches();
9451 EliminateAllExceptMostSpecializedTemplate();
9457 bool isTargetTypeAFunction() const {
9458 return TargetFunctionType->isFunctionType();
9461 // [ToType] [Return]
9463 // R (*)(A) --> R (A), IsNonStaticMemberFunction = false
9464 // R (&)(A) --> R (A), IsNonStaticMemberFunction = false
9465 // R (S::*)(A) --> R (A), IsNonStaticMemberFunction = true
9466 void inline ExtractUnqualifiedFunctionTypeFromTargetType() {
9467 TargetFunctionType = S.ExtractUnqualifiedFunctionType(TargetType);
9470 // return true if any matching specializations were found
9471 bool AddMatchingTemplateFunction(FunctionTemplateDecl* FunctionTemplate,
9472 const DeclAccessPair& CurAccessFunPair) {
9473 if (CXXMethodDecl *Method
9474 = dyn_cast<CXXMethodDecl>(FunctionTemplate->getTemplatedDecl())) {
9475 // Skip non-static function templates when converting to pointer, and
9476 // static when converting to member pointer.
9477 if (Method->isStatic() == TargetTypeIsNonStaticMemberFunction)
9480 else if (TargetTypeIsNonStaticMemberFunction)
9483 // C++ [over.over]p2:
9484 // If the name is a function template, template argument deduction is
9485 // done (14.8.2.2), and if the argument deduction succeeds, the
9486 // resulting template argument list is used to generate a single
9487 // function template specialization, which is added to the set of
9488 // overloaded functions considered.
9489 FunctionDecl *Specialization = 0;
9490 TemplateDeductionInfo Info(FailedCandidates.getLocation());
9491 if (Sema::TemplateDeductionResult Result
9492 = S.DeduceTemplateArguments(FunctionTemplate,
9493 &OvlExplicitTemplateArgs,
9494 TargetFunctionType, Specialization,
9495 Info, /*InOverloadResolution=*/true)) {
9496 // Make a note of the failed deduction for diagnostics.
9497 FailedCandidates.addCandidate()
9498 .set(FunctionTemplate->getTemplatedDecl(),
9499 MakeDeductionFailureInfo(Context, Result, Info));
9503 // Template argument deduction ensures that we have an exact match or
9504 // compatible pointer-to-function arguments that would be adjusted by ICS.
9505 // This function template specicalization works.
9506 Specialization = cast<FunctionDecl>(Specialization->getCanonicalDecl());
9507 assert(S.isSameOrCompatibleFunctionType(
9508 Context.getCanonicalType(Specialization->getType()),
9509 Context.getCanonicalType(TargetFunctionType)));
9510 Matches.push_back(std::make_pair(CurAccessFunPair, Specialization));
9514 bool AddMatchingNonTemplateFunction(NamedDecl* Fn,
9515 const DeclAccessPair& CurAccessFunPair) {
9516 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) {
9517 // Skip non-static functions when converting to pointer, and static
9518 // when converting to member pointer.
9519 if (Method->isStatic() == TargetTypeIsNonStaticMemberFunction)
9522 else if (TargetTypeIsNonStaticMemberFunction)
9525 if (FunctionDecl *FunDecl = dyn_cast<FunctionDecl>(Fn)) {
9526 if (S.getLangOpts().CUDA)
9527 if (FunctionDecl *Caller = dyn_cast<FunctionDecl>(S.CurContext))
9528 if (S.CheckCUDATarget(Caller, FunDecl))
9531 // If any candidate has a placeholder return type, trigger its deduction
9533 if (S.getLangOpts().CPlusPlus1y &&
9534 FunDecl->getResultType()->isUndeducedType() &&
9535 S.DeduceReturnType(FunDecl, SourceExpr->getLocStart(), Complain))
9539 if (Context.hasSameUnqualifiedType(TargetFunctionType,
9540 FunDecl->getType()) ||
9541 S.IsNoReturnConversion(FunDecl->getType(), TargetFunctionType,
9543 Matches.push_back(std::make_pair(CurAccessFunPair,
9544 cast<FunctionDecl>(FunDecl->getCanonicalDecl())));
9545 FoundNonTemplateFunction = true;
9553 bool FindAllFunctionsThatMatchTargetTypeExactly() {
9556 // If the overload expression doesn't have the form of a pointer to
9557 // member, don't try to convert it to a pointer-to-member type.
9558 if (IsInvalidFormOfPointerToMemberFunction())
9561 for (UnresolvedSetIterator I = OvlExpr->decls_begin(),
9562 E = OvlExpr->decls_end();
9564 // Look through any using declarations to find the underlying function.
9565 NamedDecl *Fn = (*I)->getUnderlyingDecl();
9567 // C++ [over.over]p3:
9568 // Non-member functions and static member functions match
9569 // targets of type "pointer-to-function" or "reference-to-function."
9570 // Nonstatic member functions match targets of
9571 // type "pointer-to-member-function."
9572 // Note that according to DR 247, the containing class does not matter.
9573 if (FunctionTemplateDecl *FunctionTemplate
9574 = dyn_cast<FunctionTemplateDecl>(Fn)) {
9575 if (AddMatchingTemplateFunction(FunctionTemplate, I.getPair()))
9578 // If we have explicit template arguments supplied, skip non-templates.
9579 else if (!OvlExpr->hasExplicitTemplateArgs() &&
9580 AddMatchingNonTemplateFunction(Fn, I.getPair()))
9583 assert(Ret || Matches.empty());
9587 void EliminateAllExceptMostSpecializedTemplate() {
9588 // [...] and any given function template specialization F1 is
9589 // eliminated if the set contains a second function template
9590 // specialization whose function template is more specialized
9591 // than the function template of F1 according to the partial
9592 // ordering rules of 14.5.5.2.
9594 // The algorithm specified above is quadratic. We instead use a
9595 // two-pass algorithm (similar to the one used to identify the
9596 // best viable function in an overload set) that identifies the
9597 // best function template (if it exists).
9599 UnresolvedSet<4> MatchesCopy; // TODO: avoid!
9600 for (unsigned I = 0, E = Matches.size(); I != E; ++I)
9601 MatchesCopy.addDecl(Matches[I].second, Matches[I].first.getAccess());
9603 // TODO: It looks like FailedCandidates does not serve much purpose
9604 // here, since the no_viable diagnostic has index 0.
9605 UnresolvedSetIterator Result = S.getMostSpecialized(
9606 MatchesCopy.begin(), MatchesCopy.end(), FailedCandidates,
9607 SourceExpr->getLocStart(), S.PDiag(),
9608 S.PDiag(diag::err_addr_ovl_ambiguous) << Matches[0]
9609 .second->getDeclName(),
9610 S.PDiag(diag::note_ovl_candidate) << (unsigned)oc_function_template,
9611 Complain, TargetFunctionType);
9613 if (Result != MatchesCopy.end()) {
9614 // Make it the first and only element
9615 Matches[0].first = Matches[Result - MatchesCopy.begin()].first;
9616 Matches[0].second = cast<FunctionDecl>(*Result);
9621 void EliminateAllTemplateMatches() {
9622 // [...] any function template specializations in the set are
9623 // eliminated if the set also contains a non-template function, [...]
9624 for (unsigned I = 0, N = Matches.size(); I != N; ) {
9625 if (Matches[I].second->getPrimaryTemplate() == 0)
9628 Matches[I] = Matches[--N];
9629 Matches.set_size(N);
9635 void ComplainNoMatchesFound() const {
9636 assert(Matches.empty());
9637 S.Diag(OvlExpr->getLocStart(), diag::err_addr_ovl_no_viable)
9638 << OvlExpr->getName() << TargetFunctionType
9639 << OvlExpr->getSourceRange();
9640 if (FailedCandidates.empty())
9641 S.NoteAllOverloadCandidates(OvlExpr, TargetFunctionType);
9643 // We have some deduction failure messages. Use them to diagnose
9644 // the function templates, and diagnose the non-template candidates
9646 for (UnresolvedSetIterator I = OvlExpr->decls_begin(),
9647 IEnd = OvlExpr->decls_end();
9649 if (FunctionDecl *Fun =
9650 dyn_cast<FunctionDecl>((*I)->getUnderlyingDecl()))
9651 S.NoteOverloadCandidate(Fun, TargetFunctionType);
9652 FailedCandidates.NoteCandidates(S, OvlExpr->getLocStart());
9656 bool IsInvalidFormOfPointerToMemberFunction() const {
9657 return TargetTypeIsNonStaticMemberFunction &&
9658 !OvlExprInfo.HasFormOfMemberPointer;
9661 void ComplainIsInvalidFormOfPointerToMemberFunction() const {
9662 // TODO: Should we condition this on whether any functions might
9663 // have matched, or is it more appropriate to do that in callers?
9664 // TODO: a fixit wouldn't hurt.
9665 S.Diag(OvlExpr->getNameLoc(), diag::err_addr_ovl_no_qualifier)
9666 << TargetType << OvlExpr->getSourceRange();
9669 bool IsStaticMemberFunctionFromBoundPointer() const {
9670 return StaticMemberFunctionFromBoundPointer;
9673 void ComplainIsStaticMemberFunctionFromBoundPointer() const {
9674 S.Diag(OvlExpr->getLocStart(),
9675 diag::err_invalid_form_pointer_member_function)
9676 << OvlExpr->getSourceRange();
9679 void ComplainOfInvalidConversion() const {
9680 S.Diag(OvlExpr->getLocStart(), diag::err_addr_ovl_not_func_ptrref)
9681 << OvlExpr->getName() << TargetType;
9684 void ComplainMultipleMatchesFound() const {
9685 assert(Matches.size() > 1);
9686 S.Diag(OvlExpr->getLocStart(), diag::err_addr_ovl_ambiguous)
9687 << OvlExpr->getName()
9688 << OvlExpr->getSourceRange();
9689 S.NoteAllOverloadCandidates(OvlExpr, TargetFunctionType);
9692 bool hadMultipleCandidates() const { return (OvlExpr->getNumDecls() > 1); }
9694 int getNumMatches() const { return Matches.size(); }
9696 FunctionDecl* getMatchingFunctionDecl() const {
9697 if (Matches.size() != 1) return 0;
9698 return Matches[0].second;
9701 const DeclAccessPair* getMatchingFunctionAccessPair() const {
9702 if (Matches.size() != 1) return 0;
9703 return &Matches[0].first;
9707 /// ResolveAddressOfOverloadedFunction - Try to resolve the address of
9708 /// an overloaded function (C++ [over.over]), where @p From is an
9709 /// expression with overloaded function type and @p ToType is the type
9710 /// we're trying to resolve to. For example:
9716 /// int (*pfd)(double) = f; // selects f(double)
9719 /// This routine returns the resulting FunctionDecl if it could be
9720 /// resolved, and NULL otherwise. When @p Complain is true, this
9721 /// routine will emit diagnostics if there is an error.
9723 Sema::ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr,
9724 QualType TargetType,
9726 DeclAccessPair &FoundResult,
9727 bool *pHadMultipleCandidates) {
9728 assert(AddressOfExpr->getType() == Context.OverloadTy);
9730 AddressOfFunctionResolver Resolver(*this, AddressOfExpr, TargetType,
9732 int NumMatches = Resolver.getNumMatches();
9733 FunctionDecl* Fn = 0;
9734 if (NumMatches == 0 && Complain) {
9735 if (Resolver.IsInvalidFormOfPointerToMemberFunction())
9736 Resolver.ComplainIsInvalidFormOfPointerToMemberFunction();
9738 Resolver.ComplainNoMatchesFound();
9740 else if (NumMatches > 1 && Complain)
9741 Resolver.ComplainMultipleMatchesFound();
9742 else if (NumMatches == 1) {
9743 Fn = Resolver.getMatchingFunctionDecl();
9745 FoundResult = *Resolver.getMatchingFunctionAccessPair();
9747 if (Resolver.IsStaticMemberFunctionFromBoundPointer())
9748 Resolver.ComplainIsStaticMemberFunctionFromBoundPointer();
9750 CheckAddressOfMemberAccess(AddressOfExpr, FoundResult);
9754 if (pHadMultipleCandidates)
9755 *pHadMultipleCandidates = Resolver.hadMultipleCandidates();
9759 /// \brief Given an expression that refers to an overloaded function, try to
9760 /// resolve that overloaded function expression down to a single function.
9762 /// This routine can only resolve template-ids that refer to a single function
9763 /// template, where that template-id refers to a single template whose template
9764 /// arguments are either provided by the template-id or have defaults,
9765 /// as described in C++0x [temp.arg.explicit]p3.
9767 /// If no template-ids are found, no diagnostics are emitted and NULL is
9770 Sema::ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl,
9772 DeclAccessPair *FoundResult) {
9773 // C++ [over.over]p1:
9774 // [...] [Note: any redundant set of parentheses surrounding the
9775 // overloaded function name is ignored (5.1). ]
9776 // C++ [over.over]p1:
9777 // [...] The overloaded function name can be preceded by the &
9780 // If we didn't actually find any template-ids, we're done.
9781 if (!ovl->hasExplicitTemplateArgs())
9784 TemplateArgumentListInfo ExplicitTemplateArgs;
9785 ovl->getExplicitTemplateArgs().copyInto(ExplicitTemplateArgs);
9786 TemplateSpecCandidateSet FailedCandidates(ovl->getNameLoc());
9788 // Look through all of the overloaded functions, searching for one
9789 // whose type matches exactly.
9790 FunctionDecl *Matched = 0;
9791 for (UnresolvedSetIterator I = ovl->decls_begin(),
9792 E = ovl->decls_end(); I != E; ++I) {
9793 // C++0x [temp.arg.explicit]p3:
9794 // [...] In contexts where deduction is done and fails, or in contexts
9795 // where deduction is not done, if a template argument list is
9796 // specified and it, along with any default template arguments,
9797 // identifies a single function template specialization, then the
9798 // template-id is an lvalue for the function template specialization.
9799 FunctionTemplateDecl *FunctionTemplate
9800 = cast<FunctionTemplateDecl>((*I)->getUnderlyingDecl());
9802 // C++ [over.over]p2:
9803 // If the name is a function template, template argument deduction is
9804 // done (14.8.2.2), and if the argument deduction succeeds, the
9805 // resulting template argument list is used to generate a single
9806 // function template specialization, which is added to the set of
9807 // overloaded functions considered.
9808 FunctionDecl *Specialization = 0;
9809 TemplateDeductionInfo Info(FailedCandidates.getLocation());
9810 if (TemplateDeductionResult Result
9811 = DeduceTemplateArguments(FunctionTemplate, &ExplicitTemplateArgs,
9812 Specialization, Info,
9813 /*InOverloadResolution=*/true)) {
9814 // Make a note of the failed deduction for diagnostics.
9815 // TODO: Actually use the failed-deduction info?
9816 FailedCandidates.addCandidate()
9817 .set(FunctionTemplate->getTemplatedDecl(),
9818 MakeDeductionFailureInfo(Context, Result, Info));
9822 assert(Specialization && "no specialization and no error?");
9824 // Multiple matches; we can't resolve to a single declaration.
9827 Diag(ovl->getExprLoc(), diag::err_addr_ovl_ambiguous)
9829 NoteAllOverloadCandidates(ovl);
9834 Matched = Specialization;
9835 if (FoundResult) *FoundResult = I.getPair();
9838 if (Matched && getLangOpts().CPlusPlus1y &&
9839 Matched->getResultType()->isUndeducedType() &&
9840 DeduceReturnType(Matched, ovl->getExprLoc(), Complain))
9849 // Resolve and fix an overloaded expression that can be resolved
9850 // because it identifies a single function template specialization.
9852 // Last three arguments should only be supplied if Complain = true
9854 // Return true if it was logically possible to so resolve the
9855 // expression, regardless of whether or not it succeeded. Always
9856 // returns true if 'complain' is set.
9857 bool Sema::ResolveAndFixSingleFunctionTemplateSpecialization(
9858 ExprResult &SrcExpr, bool doFunctionPointerConverion,
9859 bool complain, const SourceRange& OpRangeForComplaining,
9860 QualType DestTypeForComplaining,
9861 unsigned DiagIDForComplaining) {
9862 assert(SrcExpr.get()->getType() == Context.OverloadTy);
9864 OverloadExpr::FindResult ovl = OverloadExpr::find(SrcExpr.get());
9866 DeclAccessPair found;
9867 ExprResult SingleFunctionExpression;
9868 if (FunctionDecl *fn = ResolveSingleFunctionTemplateSpecialization(
9869 ovl.Expression, /*complain*/ false, &found)) {
9870 if (DiagnoseUseOfDecl(fn, SrcExpr.get()->getLocStart())) {
9871 SrcExpr = ExprError();
9875 // It is only correct to resolve to an instance method if we're
9876 // resolving a form that's permitted to be a pointer to member.
9877 // Otherwise we'll end up making a bound member expression, which
9878 // is illegal in all the contexts we resolve like this.
9879 if (!ovl.HasFormOfMemberPointer &&
9880 isa<CXXMethodDecl>(fn) &&
9881 cast<CXXMethodDecl>(fn)->isInstance()) {
9882 if (!complain) return false;
9884 Diag(ovl.Expression->getExprLoc(),
9885 diag::err_bound_member_function)
9886 << 0 << ovl.Expression->getSourceRange();
9888 // TODO: I believe we only end up here if there's a mix of
9889 // static and non-static candidates (otherwise the expression
9890 // would have 'bound member' type, not 'overload' type).
9891 // Ideally we would note which candidate was chosen and why
9892 // the static candidates were rejected.
9893 SrcExpr = ExprError();
9897 // Fix the expression to refer to 'fn'.
9898 SingleFunctionExpression =
9899 Owned(FixOverloadedFunctionReference(SrcExpr.take(), found, fn));
9901 // If desired, do function-to-pointer decay.
9902 if (doFunctionPointerConverion) {
9903 SingleFunctionExpression =
9904 DefaultFunctionArrayLvalueConversion(SingleFunctionExpression.take());
9905 if (SingleFunctionExpression.isInvalid()) {
9906 SrcExpr = ExprError();
9912 if (!SingleFunctionExpression.isUsable()) {
9914 Diag(OpRangeForComplaining.getBegin(), DiagIDForComplaining)
9915 << ovl.Expression->getName()
9916 << DestTypeForComplaining
9917 << OpRangeForComplaining
9918 << ovl.Expression->getQualifierLoc().getSourceRange();
9919 NoteAllOverloadCandidates(SrcExpr.get());
9921 SrcExpr = ExprError();
9928 SrcExpr = SingleFunctionExpression;
9932 /// \brief Add a single candidate to the overload set.
9933 static void AddOverloadedCallCandidate(Sema &S,
9934 DeclAccessPair FoundDecl,
9935 TemplateArgumentListInfo *ExplicitTemplateArgs,
9936 ArrayRef<Expr *> Args,
9937 OverloadCandidateSet &CandidateSet,
9938 bool PartialOverloading,
9940 NamedDecl *Callee = FoundDecl.getDecl();
9941 if (isa<UsingShadowDecl>(Callee))
9942 Callee = cast<UsingShadowDecl>(Callee)->getTargetDecl();
9944 if (FunctionDecl *Func = dyn_cast<FunctionDecl>(Callee)) {
9945 if (ExplicitTemplateArgs) {
9946 assert(!KnownValid && "Explicit template arguments?");
9949 S.AddOverloadCandidate(Func, FoundDecl, Args, CandidateSet, false,
9950 PartialOverloading);
9954 if (FunctionTemplateDecl *FuncTemplate
9955 = dyn_cast<FunctionTemplateDecl>(Callee)) {
9956 S.AddTemplateOverloadCandidate(FuncTemplate, FoundDecl,
9957 ExplicitTemplateArgs, Args, CandidateSet);
9961 assert(!KnownValid && "unhandled case in overloaded call candidate");
9964 /// \brief Add the overload candidates named by callee and/or found by argument
9965 /// dependent lookup to the given overload set.
9966 void Sema::AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE,
9967 ArrayRef<Expr *> Args,
9968 OverloadCandidateSet &CandidateSet,
9969 bool PartialOverloading) {
9972 // Verify that ArgumentDependentLookup is consistent with the rules
9973 // in C++0x [basic.lookup.argdep]p3:
9975 // Let X be the lookup set produced by unqualified lookup (3.4.1)
9976 // and let Y be the lookup set produced by argument dependent
9977 // lookup (defined as follows). If X contains
9979 // -- a declaration of a class member, or
9981 // -- a block-scope function declaration that is not a
9982 // using-declaration, or
9984 // -- a declaration that is neither a function or a function
9989 if (ULE->requiresADL()) {
9990 for (UnresolvedLookupExpr::decls_iterator I = ULE->decls_begin(),
9991 E = ULE->decls_end(); I != E; ++I) {
9992 assert(!(*I)->getDeclContext()->isRecord());
9993 assert(isa<UsingShadowDecl>(*I) ||
9994 !(*I)->getDeclContext()->isFunctionOrMethod());
9995 assert((*I)->getUnderlyingDecl()->isFunctionOrFunctionTemplate());
10000 // It would be nice to avoid this copy.
10001 TemplateArgumentListInfo TABuffer;
10002 TemplateArgumentListInfo *ExplicitTemplateArgs = 0;
10003 if (ULE->hasExplicitTemplateArgs()) {
10004 ULE->copyTemplateArgumentsInto(TABuffer);
10005 ExplicitTemplateArgs = &TABuffer;
10008 for (UnresolvedLookupExpr::decls_iterator I = ULE->decls_begin(),
10009 E = ULE->decls_end(); I != E; ++I)
10010 AddOverloadedCallCandidate(*this, I.getPair(), ExplicitTemplateArgs, Args,
10011 CandidateSet, PartialOverloading,
10012 /*KnownValid*/ true);
10014 if (ULE->requiresADL())
10015 AddArgumentDependentLookupCandidates(ULE->getName(), /*Operator*/ false,
10017 Args, ExplicitTemplateArgs,
10018 CandidateSet, PartialOverloading);
10021 /// Determine whether a declaration with the specified name could be moved into
10022 /// a different namespace.
10023 static bool canBeDeclaredInNamespace(const DeclarationName &Name) {
10024 switch (Name.getCXXOverloadedOperator()) {
10025 case OO_New: case OO_Array_New:
10026 case OO_Delete: case OO_Array_Delete:
10034 /// Attempt to recover from an ill-formed use of a non-dependent name in a
10035 /// template, where the non-dependent name was declared after the template
10036 /// was defined. This is common in code written for a compilers which do not
10037 /// correctly implement two-stage name lookup.
10039 /// Returns true if a viable candidate was found and a diagnostic was issued.
10041 DiagnoseTwoPhaseLookup(Sema &SemaRef, SourceLocation FnLoc,
10042 const CXXScopeSpec &SS, LookupResult &R,
10043 TemplateArgumentListInfo *ExplicitTemplateArgs,
10044 ArrayRef<Expr *> Args) {
10045 if (SemaRef.ActiveTemplateInstantiations.empty() || !SS.isEmpty())
10048 for (DeclContext *DC = SemaRef.CurContext; DC; DC = DC->getParent()) {
10049 if (DC->isTransparentContext())
10052 SemaRef.LookupQualifiedName(R, DC);
10055 R.suppressDiagnostics();
10057 if (isa<CXXRecordDecl>(DC)) {
10058 // Don't diagnose names we find in classes; we get much better
10059 // diagnostics for these from DiagnoseEmptyLookup.
10064 OverloadCandidateSet Candidates(FnLoc);
10065 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I)
10066 AddOverloadedCallCandidate(SemaRef, I.getPair(),
10067 ExplicitTemplateArgs, Args,
10068 Candidates, false, /*KnownValid*/ false);
10070 OverloadCandidateSet::iterator Best;
10071 if (Candidates.BestViableFunction(SemaRef, FnLoc, Best) != OR_Success) {
10072 // No viable functions. Don't bother the user with notes for functions
10073 // which don't work and shouldn't be found anyway.
10078 // Find the namespaces where ADL would have looked, and suggest
10079 // declaring the function there instead.
10080 Sema::AssociatedNamespaceSet AssociatedNamespaces;
10081 Sema::AssociatedClassSet AssociatedClasses;
10082 SemaRef.FindAssociatedClassesAndNamespaces(FnLoc, Args,
10083 AssociatedNamespaces,
10084 AssociatedClasses);
10085 Sema::AssociatedNamespaceSet SuggestedNamespaces;
10086 if (canBeDeclaredInNamespace(R.getLookupName())) {
10087 DeclContext *Std = SemaRef.getStdNamespace();
10088 for (Sema::AssociatedNamespaceSet::iterator
10089 it = AssociatedNamespaces.begin(),
10090 end = AssociatedNamespaces.end(); it != end; ++it) {
10091 // Never suggest declaring a function within namespace 'std'.
10092 if (Std && Std->Encloses(*it))
10095 // Never suggest declaring a function within a namespace with a
10096 // reserved name, like __gnu_cxx.
10097 NamespaceDecl *NS = dyn_cast<NamespaceDecl>(*it);
10099 NS->getQualifiedNameAsString().find("__") != std::string::npos)
10102 SuggestedNamespaces.insert(*it);
10106 SemaRef.Diag(R.getNameLoc(), diag::err_not_found_by_two_phase_lookup)
10107 << R.getLookupName();
10108 if (SuggestedNamespaces.empty()) {
10109 SemaRef.Diag(Best->Function->getLocation(),
10110 diag::note_not_found_by_two_phase_lookup)
10111 << R.getLookupName() << 0;
10112 } else if (SuggestedNamespaces.size() == 1) {
10113 SemaRef.Diag(Best->Function->getLocation(),
10114 diag::note_not_found_by_two_phase_lookup)
10115 << R.getLookupName() << 1 << *SuggestedNamespaces.begin();
10117 // FIXME: It would be useful to list the associated namespaces here,
10118 // but the diagnostics infrastructure doesn't provide a way to produce
10119 // a localized representation of a list of items.
10120 SemaRef.Diag(Best->Function->getLocation(),
10121 diag::note_not_found_by_two_phase_lookup)
10122 << R.getLookupName() << 2;
10125 // Try to recover by calling this function.
10135 /// Attempt to recover from ill-formed use of a non-dependent operator in a
10136 /// template, where the non-dependent operator was declared after the template
10139 /// Returns true if a viable candidate was found and a diagnostic was issued.
10141 DiagnoseTwoPhaseOperatorLookup(Sema &SemaRef, OverloadedOperatorKind Op,
10142 SourceLocation OpLoc,
10143 ArrayRef<Expr *> Args) {
10144 DeclarationName OpName =
10145 SemaRef.Context.DeclarationNames.getCXXOperatorName(Op);
10146 LookupResult R(SemaRef, OpName, OpLoc, Sema::LookupOperatorName);
10147 return DiagnoseTwoPhaseLookup(SemaRef, OpLoc, CXXScopeSpec(), R,
10148 /*ExplicitTemplateArgs=*/0, Args);
10152 class BuildRecoveryCallExprRAII {
10155 BuildRecoveryCallExprRAII(Sema &S) : SemaRef(S) {
10156 assert(SemaRef.IsBuildingRecoveryCallExpr == false);
10157 SemaRef.IsBuildingRecoveryCallExpr = true;
10160 ~BuildRecoveryCallExprRAII() {
10161 SemaRef.IsBuildingRecoveryCallExpr = false;
10167 /// Attempts to recover from a call where no functions were found.
10169 /// Returns true if new candidates were found.
10171 BuildRecoveryCallExpr(Sema &SemaRef, Scope *S, Expr *Fn,
10172 UnresolvedLookupExpr *ULE,
10173 SourceLocation LParenLoc,
10174 llvm::MutableArrayRef<Expr *> Args,
10175 SourceLocation RParenLoc,
10176 bool EmptyLookup, bool AllowTypoCorrection) {
10177 // Do not try to recover if it is already building a recovery call.
10178 // This stops infinite loops for template instantiations like
10180 // template <typename T> auto foo(T t) -> decltype(foo(t)) {}
10181 // template <typename T> auto foo(T t) -> decltype(foo(&t)) {}
10183 if (SemaRef.IsBuildingRecoveryCallExpr)
10184 return ExprError();
10185 BuildRecoveryCallExprRAII RCE(SemaRef);
10188 SS.Adopt(ULE->getQualifierLoc());
10189 SourceLocation TemplateKWLoc = ULE->getTemplateKeywordLoc();
10191 TemplateArgumentListInfo TABuffer;
10192 TemplateArgumentListInfo *ExplicitTemplateArgs = 0;
10193 if (ULE->hasExplicitTemplateArgs()) {
10194 ULE->copyTemplateArgumentsInto(TABuffer);
10195 ExplicitTemplateArgs = &TABuffer;
10198 LookupResult R(SemaRef, ULE->getName(), ULE->getNameLoc(),
10199 Sema::LookupOrdinaryName);
10200 FunctionCallFilterCCC Validator(SemaRef, Args.size(),
10201 ExplicitTemplateArgs != 0);
10202 NoTypoCorrectionCCC RejectAll;
10203 CorrectionCandidateCallback *CCC = AllowTypoCorrection ?
10204 (CorrectionCandidateCallback*)&Validator :
10205 (CorrectionCandidateCallback*)&RejectAll;
10206 if (!DiagnoseTwoPhaseLookup(SemaRef, Fn->getExprLoc(), SS, R,
10207 ExplicitTemplateArgs, Args) &&
10209 SemaRef.DiagnoseEmptyLookup(S, SS, R, *CCC,
10210 ExplicitTemplateArgs, Args)))
10211 return ExprError();
10213 assert(!R.empty() && "lookup results empty despite recovery");
10215 // Build an implicit member call if appropriate. Just drop the
10216 // casts and such from the call, we don't really care.
10217 ExprResult NewFn = ExprError();
10218 if ((*R.begin())->isCXXClassMember())
10219 NewFn = SemaRef.BuildPossibleImplicitMemberExpr(SS, TemplateKWLoc,
10220 R, ExplicitTemplateArgs);
10221 else if (ExplicitTemplateArgs || TemplateKWLoc.isValid())
10222 NewFn = SemaRef.BuildTemplateIdExpr(SS, TemplateKWLoc, R, false,
10223 ExplicitTemplateArgs);
10225 NewFn = SemaRef.BuildDeclarationNameExpr(SS, R, false);
10227 if (NewFn.isInvalid())
10228 return ExprError();
10230 // This shouldn't cause an infinite loop because we're giving it
10231 // an expression with viable lookup results, which should never
10233 return SemaRef.ActOnCallExpr(/*Scope*/ 0, NewFn.take(), LParenLoc,
10234 MultiExprArg(Args.data(), Args.size()),
10238 /// \brief Constructs and populates an OverloadedCandidateSet from
10239 /// the given function.
10240 /// \returns true when an the ExprResult output parameter has been set.
10241 bool Sema::buildOverloadedCallSet(Scope *S, Expr *Fn,
10242 UnresolvedLookupExpr *ULE,
10244 SourceLocation RParenLoc,
10245 OverloadCandidateSet *CandidateSet,
10246 ExprResult *Result) {
10248 if (ULE->requiresADL()) {
10249 // To do ADL, we must have found an unqualified name.
10250 assert(!ULE->getQualifier() && "qualified name with ADL");
10252 // We don't perform ADL for implicit declarations of builtins.
10253 // Verify that this was correctly set up.
10255 if (ULE->decls_begin() + 1 == ULE->decls_end() &&
10256 (F = dyn_cast<FunctionDecl>(*ULE->decls_begin())) &&
10257 F->getBuiltinID() && F->isImplicit())
10258 llvm_unreachable("performing ADL for builtin");
10260 // We don't perform ADL in C.
10261 assert(getLangOpts().CPlusPlus && "ADL enabled in C");
10265 UnbridgedCastsSet UnbridgedCasts;
10266 if (checkArgPlaceholdersForOverload(*this, Args, UnbridgedCasts)) {
10267 *Result = ExprError();
10271 // Add the functions denoted by the callee to the set of candidate
10272 // functions, including those from argument-dependent lookup.
10273 AddOverloadedCallCandidates(ULE, Args, *CandidateSet);
10275 // If we found nothing, try to recover.
10276 // BuildRecoveryCallExpr diagnoses the error itself, so we just bail
10277 // out if it fails.
10278 if (CandidateSet->empty()) {
10279 // In Microsoft mode, if we are inside a template class member function then
10280 // create a type dependent CallExpr. The goal is to postpone name lookup
10281 // to instantiation time to be able to search into type dependent base
10283 if (getLangOpts().MicrosoftMode && CurContext->isDependentContext() &&
10284 (isa<FunctionDecl>(CurContext) || isa<CXXRecordDecl>(CurContext))) {
10285 CallExpr *CE = new (Context) CallExpr(Context, Fn, Args,
10286 Context.DependentTy, VK_RValue,
10288 CE->setTypeDependent(true);
10289 *Result = Owned(CE);
10295 UnbridgedCasts.restore();
10299 /// FinishOverloadedCallExpr - given an OverloadCandidateSet, builds and returns
10300 /// the completed call expression. If overload resolution fails, emits
10301 /// diagnostics and returns ExprError()
10302 static ExprResult FinishOverloadedCallExpr(Sema &SemaRef, Scope *S, Expr *Fn,
10303 UnresolvedLookupExpr *ULE,
10304 SourceLocation LParenLoc,
10306 SourceLocation RParenLoc,
10308 OverloadCandidateSet *CandidateSet,
10309 OverloadCandidateSet::iterator *Best,
10310 OverloadingResult OverloadResult,
10311 bool AllowTypoCorrection) {
10312 if (CandidateSet->empty())
10313 return BuildRecoveryCallExpr(SemaRef, S, Fn, ULE, LParenLoc, Args,
10314 RParenLoc, /*EmptyLookup=*/true,
10315 AllowTypoCorrection);
10317 switch (OverloadResult) {
10319 FunctionDecl *FDecl = (*Best)->Function;
10320 SemaRef.CheckUnresolvedLookupAccess(ULE, (*Best)->FoundDecl);
10321 if (SemaRef.DiagnoseUseOfDecl(FDecl, ULE->getNameLoc()))
10322 return ExprError();
10323 Fn = SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl);
10324 return SemaRef.BuildResolvedCallExpr(Fn, FDecl, LParenLoc, Args, RParenLoc,
10328 case OR_No_Viable_Function: {
10329 // Try to recover by looking for viable functions which the user might
10330 // have meant to call.
10331 ExprResult Recovery = BuildRecoveryCallExpr(SemaRef, S, Fn, ULE, LParenLoc,
10333 /*EmptyLookup=*/false,
10334 AllowTypoCorrection);
10335 if (!Recovery.isInvalid())
10338 SemaRef.Diag(Fn->getLocStart(),
10339 diag::err_ovl_no_viable_function_in_call)
10340 << ULE->getName() << Fn->getSourceRange();
10341 CandidateSet->NoteCandidates(SemaRef, OCD_AllCandidates, Args);
10346 SemaRef.Diag(Fn->getLocStart(), diag::err_ovl_ambiguous_call)
10347 << ULE->getName() << Fn->getSourceRange();
10348 CandidateSet->NoteCandidates(SemaRef, OCD_ViableCandidates, Args);
10352 SemaRef.Diag(Fn->getLocStart(), diag::err_ovl_deleted_call)
10353 << (*Best)->Function->isDeleted()
10355 << SemaRef.getDeletedOrUnavailableSuffix((*Best)->Function)
10356 << Fn->getSourceRange();
10357 CandidateSet->NoteCandidates(SemaRef, OCD_AllCandidates, Args);
10359 // We emitted an error for the unvailable/deleted function call but keep
10360 // the call in the AST.
10361 FunctionDecl *FDecl = (*Best)->Function;
10362 Fn = SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl);
10363 return SemaRef.BuildResolvedCallExpr(Fn, FDecl, LParenLoc, Args, RParenLoc,
10368 // Overload resolution failed.
10369 return ExprError();
10372 /// BuildOverloadedCallExpr - Given the call expression that calls Fn
10373 /// (which eventually refers to the declaration Func) and the call
10374 /// arguments Args/NumArgs, attempt to resolve the function call down
10375 /// to a specific function. If overload resolution succeeds, returns
10376 /// the call expression produced by overload resolution.
10377 /// Otherwise, emits diagnostics and returns ExprError.
10378 ExprResult Sema::BuildOverloadedCallExpr(Scope *S, Expr *Fn,
10379 UnresolvedLookupExpr *ULE,
10380 SourceLocation LParenLoc,
10382 SourceLocation RParenLoc,
10384 bool AllowTypoCorrection) {
10385 OverloadCandidateSet CandidateSet(Fn->getExprLoc());
10388 if (buildOverloadedCallSet(S, Fn, ULE, Args, LParenLoc, &CandidateSet,
10392 OverloadCandidateSet::iterator Best;
10393 OverloadingResult OverloadResult =
10394 CandidateSet.BestViableFunction(*this, Fn->getLocStart(), Best);
10396 return FinishOverloadedCallExpr(*this, S, Fn, ULE, LParenLoc, Args,
10397 RParenLoc, ExecConfig, &CandidateSet,
10398 &Best, OverloadResult,
10399 AllowTypoCorrection);
10402 static bool IsOverloaded(const UnresolvedSetImpl &Functions) {
10403 return Functions.size() > 1 ||
10404 (Functions.size() == 1 && isa<FunctionTemplateDecl>(*Functions.begin()));
10407 /// \brief Create a unary operation that may resolve to an overloaded
10410 /// \param OpLoc The location of the operator itself (e.g., '*').
10412 /// \param OpcIn The UnaryOperator::Opcode that describes this
10415 /// \param Fns The set of non-member functions that will be
10416 /// considered by overload resolution. The caller needs to build this
10417 /// set based on the context using, e.g.,
10418 /// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This
10419 /// set should not contain any member functions; those will be added
10420 /// by CreateOverloadedUnaryOp().
10422 /// \param Input The input argument.
10424 Sema::CreateOverloadedUnaryOp(SourceLocation OpLoc, unsigned OpcIn,
10425 const UnresolvedSetImpl &Fns,
10427 UnaryOperator::Opcode Opc = static_cast<UnaryOperator::Opcode>(OpcIn);
10429 OverloadedOperatorKind Op = UnaryOperator::getOverloadedOperator(Opc);
10430 assert(Op != OO_None && "Invalid opcode for overloaded unary operator");
10431 DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op);
10432 // TODO: provide better source location info.
10433 DeclarationNameInfo OpNameInfo(OpName, OpLoc);
10435 if (checkPlaceholderForOverload(*this, Input))
10436 return ExprError();
10438 Expr *Args[2] = { Input, 0 };
10439 unsigned NumArgs = 1;
10441 // For post-increment and post-decrement, add the implicit '0' as
10442 // the second argument, so that we know this is a post-increment or
10444 if (Opc == UO_PostInc || Opc == UO_PostDec) {
10445 llvm::APSInt Zero(Context.getTypeSize(Context.IntTy), false);
10446 Args[1] = IntegerLiteral::Create(Context, Zero, Context.IntTy,
10451 ArrayRef<Expr *> ArgsArray(Args, NumArgs);
10453 if (Input->isTypeDependent()) {
10455 return Owned(new (Context) UnaryOperator(Input,
10457 Context.DependentTy,
10458 VK_RValue, OK_Ordinary,
10461 CXXRecordDecl *NamingClass = 0; // because lookup ignores member operators
10462 UnresolvedLookupExpr *Fn
10463 = UnresolvedLookupExpr::Create(Context, NamingClass,
10464 NestedNameSpecifierLoc(), OpNameInfo,
10465 /*ADL*/ true, IsOverloaded(Fns),
10466 Fns.begin(), Fns.end());
10467 return Owned(new (Context) CXXOperatorCallExpr(Context, Op, Fn, ArgsArray,
10468 Context.DependentTy,
10473 // Build an empty overload set.
10474 OverloadCandidateSet CandidateSet(OpLoc);
10476 // Add the candidates from the given function set.
10477 AddFunctionCandidates(Fns, ArgsArray, CandidateSet, false);
10479 // Add operator candidates that are member functions.
10480 AddMemberOperatorCandidates(Op, OpLoc, ArgsArray, CandidateSet);
10482 // Add candidates from ADL.
10483 AddArgumentDependentLookupCandidates(OpName, /*Operator*/ true, OpLoc,
10484 ArgsArray, /*ExplicitTemplateArgs*/ 0,
10487 // Add builtin operator candidates.
10488 AddBuiltinOperatorCandidates(Op, OpLoc, ArgsArray, CandidateSet);
10490 bool HadMultipleCandidates = (CandidateSet.size() > 1);
10492 // Perform overload resolution.
10493 OverloadCandidateSet::iterator Best;
10494 switch (CandidateSet.BestViableFunction(*this, OpLoc, Best)) {
10496 // We found a built-in operator or an overloaded operator.
10497 FunctionDecl *FnDecl = Best->Function;
10500 // We matched an overloaded operator. Build a call to that
10503 // Convert the arguments.
10504 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) {
10505 CheckMemberOperatorAccess(OpLoc, Args[0], 0, Best->FoundDecl);
10507 ExprResult InputRes =
10508 PerformObjectArgumentInitialization(Input, /*Qualifier=*/0,
10509 Best->FoundDecl, Method);
10510 if (InputRes.isInvalid())
10511 return ExprError();
10512 Input = InputRes.take();
10514 // Convert the arguments.
10515 ExprResult InputInit
10516 = PerformCopyInitialization(InitializedEntity::InitializeParameter(
10518 FnDecl->getParamDecl(0)),
10521 if (InputInit.isInvalid())
10522 return ExprError();
10523 Input = InputInit.take();
10526 // Build the actual expression node.
10527 ExprResult FnExpr = CreateFunctionRefExpr(*this, FnDecl, Best->FoundDecl,
10528 HadMultipleCandidates, OpLoc);
10529 if (FnExpr.isInvalid())
10530 return ExprError();
10532 // Determine the result type.
10533 QualType ResultTy = FnDecl->getResultType();
10534 ExprValueKind VK = Expr::getValueKindForType(ResultTy);
10535 ResultTy = ResultTy.getNonLValueExprType(Context);
10538 CallExpr *TheCall =
10539 new (Context) CXXOperatorCallExpr(Context, Op, FnExpr.take(), ArgsArray,
10540 ResultTy, VK, OpLoc, false);
10542 if (CheckCallReturnType(FnDecl->getResultType(), OpLoc, TheCall,
10544 return ExprError();
10546 return MaybeBindToTemporary(TheCall);
10548 // We matched a built-in operator. Convert the arguments, then
10549 // break out so that we will build the appropriate built-in
10551 ExprResult InputRes =
10552 PerformImplicitConversion(Input, Best->BuiltinTypes.ParamTypes[0],
10553 Best->Conversions[0], AA_Passing);
10554 if (InputRes.isInvalid())
10555 return ExprError();
10556 Input = InputRes.take();
10561 case OR_No_Viable_Function:
10562 // This is an erroneous use of an operator which can be overloaded by
10563 // a non-member function. Check for non-member operators which were
10564 // defined too late to be candidates.
10565 if (DiagnoseTwoPhaseOperatorLookup(*this, Op, OpLoc, ArgsArray))
10566 // FIXME: Recover by calling the found function.
10567 return ExprError();
10569 // No viable function; fall through to handling this as a
10570 // built-in operator, which will produce an error message for us.
10574 Diag(OpLoc, diag::err_ovl_ambiguous_oper_unary)
10575 << UnaryOperator::getOpcodeStr(Opc)
10576 << Input->getType()
10577 << Input->getSourceRange();
10578 CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, ArgsArray,
10579 UnaryOperator::getOpcodeStr(Opc), OpLoc);
10580 return ExprError();
10583 Diag(OpLoc, diag::err_ovl_deleted_oper)
10584 << Best->Function->isDeleted()
10585 << UnaryOperator::getOpcodeStr(Opc)
10586 << getDeletedOrUnavailableSuffix(Best->Function)
10587 << Input->getSourceRange();
10588 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, ArgsArray,
10589 UnaryOperator::getOpcodeStr(Opc), OpLoc);
10590 return ExprError();
10593 // Either we found no viable overloaded operator or we matched a
10594 // built-in operator. In either case, fall through to trying to
10595 // build a built-in operation.
10596 return CreateBuiltinUnaryOp(OpLoc, Opc, Input);
10599 /// \brief Create a binary operation that may resolve to an overloaded
10602 /// \param OpLoc The location of the operator itself (e.g., '+').
10604 /// \param OpcIn The BinaryOperator::Opcode that describes this
10607 /// \param Fns The set of non-member functions that will be
10608 /// considered by overload resolution. The caller needs to build this
10609 /// set based on the context using, e.g.,
10610 /// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This
10611 /// set should not contain any member functions; those will be added
10612 /// by CreateOverloadedBinOp().
10614 /// \param LHS Left-hand argument.
10615 /// \param RHS Right-hand argument.
10617 Sema::CreateOverloadedBinOp(SourceLocation OpLoc,
10619 const UnresolvedSetImpl &Fns,
10620 Expr *LHS, Expr *RHS) {
10621 Expr *Args[2] = { LHS, RHS };
10622 LHS=RHS=0; //Please use only Args instead of LHS/RHS couple
10624 BinaryOperator::Opcode Opc = static_cast<BinaryOperator::Opcode>(OpcIn);
10625 OverloadedOperatorKind Op = BinaryOperator::getOverloadedOperator(Opc);
10626 DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op);
10628 // If either side is type-dependent, create an appropriate dependent
10630 if (Args[0]->isTypeDependent() || Args[1]->isTypeDependent()) {
10632 // If there are no functions to store, just build a dependent
10633 // BinaryOperator or CompoundAssignment.
10634 if (Opc <= BO_Assign || Opc > BO_OrAssign)
10635 return Owned(new (Context) BinaryOperator(Args[0], Args[1], Opc,
10636 Context.DependentTy,
10637 VK_RValue, OK_Ordinary,
10639 FPFeatures.fp_contract));
10641 return Owned(new (Context) CompoundAssignOperator(Args[0], Args[1], Opc,
10642 Context.DependentTy,
10645 Context.DependentTy,
10646 Context.DependentTy,
10648 FPFeatures.fp_contract));
10651 // FIXME: save results of ADL from here?
10652 CXXRecordDecl *NamingClass = 0; // because lookup ignores member operators
10653 // TODO: provide better source location info in DNLoc component.
10654 DeclarationNameInfo OpNameInfo(OpName, OpLoc);
10655 UnresolvedLookupExpr *Fn
10656 = UnresolvedLookupExpr::Create(Context, NamingClass,
10657 NestedNameSpecifierLoc(), OpNameInfo,
10658 /*ADL*/ true, IsOverloaded(Fns),
10659 Fns.begin(), Fns.end());
10660 return Owned(new (Context) CXXOperatorCallExpr(Context, Op, Fn, Args,
10661 Context.DependentTy, VK_RValue,
10662 OpLoc, FPFeatures.fp_contract));
10665 // Always do placeholder-like conversions on the RHS.
10666 if (checkPlaceholderForOverload(*this, Args[1]))
10667 return ExprError();
10669 // Do placeholder-like conversion on the LHS; note that we should
10670 // not get here with a PseudoObject LHS.
10671 assert(Args[0]->getObjectKind() != OK_ObjCProperty);
10672 if (checkPlaceholderForOverload(*this, Args[0]))
10673 return ExprError();
10675 // If this is the assignment operator, we only perform overload resolution
10676 // if the left-hand side is a class or enumeration type. This is actually
10677 // a hack. The standard requires that we do overload resolution between the
10678 // various built-in candidates, but as DR507 points out, this can lead to
10679 // problems. So we do it this way, which pretty much follows what GCC does.
10680 // Note that we go the traditional code path for compound assignment forms.
10681 if (Opc == BO_Assign && !Args[0]->getType()->isOverloadableType())
10682 return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
10684 // If this is the .* operator, which is not overloadable, just
10685 // create a built-in binary operator.
10686 if (Opc == BO_PtrMemD)
10687 return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
10689 // Build an empty overload set.
10690 OverloadCandidateSet CandidateSet(OpLoc);
10692 // Add the candidates from the given function set.
10693 AddFunctionCandidates(Fns, Args, CandidateSet, false);
10695 // Add operator candidates that are member functions.
10696 AddMemberOperatorCandidates(Op, OpLoc, Args, CandidateSet);
10698 // Add candidates from ADL.
10699 AddArgumentDependentLookupCandidates(OpName, /*Operator*/ true,
10701 /*ExplicitTemplateArgs*/ 0,
10704 // Add builtin operator candidates.
10705 AddBuiltinOperatorCandidates(Op, OpLoc, Args, CandidateSet);
10707 bool HadMultipleCandidates = (CandidateSet.size() > 1);
10709 // Perform overload resolution.
10710 OverloadCandidateSet::iterator Best;
10711 switch (CandidateSet.BestViableFunction(*this, OpLoc, Best)) {
10713 // We found a built-in operator or an overloaded operator.
10714 FunctionDecl *FnDecl = Best->Function;
10717 // We matched an overloaded operator. Build a call to that
10720 // Convert the arguments.
10721 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) {
10722 // Best->Access is only meaningful for class members.
10723 CheckMemberOperatorAccess(OpLoc, Args[0], Args[1], Best->FoundDecl);
10726 PerformCopyInitialization(
10727 InitializedEntity::InitializeParameter(Context,
10728 FnDecl->getParamDecl(0)),
10729 SourceLocation(), Owned(Args[1]));
10730 if (Arg1.isInvalid())
10731 return ExprError();
10734 PerformObjectArgumentInitialization(Args[0], /*Qualifier=*/0,
10735 Best->FoundDecl, Method);
10736 if (Arg0.isInvalid())
10737 return ExprError();
10738 Args[0] = Arg0.takeAs<Expr>();
10739 Args[1] = RHS = Arg1.takeAs<Expr>();
10741 // Convert the arguments.
10742 ExprResult Arg0 = PerformCopyInitialization(
10743 InitializedEntity::InitializeParameter(Context,
10744 FnDecl->getParamDecl(0)),
10745 SourceLocation(), Owned(Args[0]));
10746 if (Arg0.isInvalid())
10747 return ExprError();
10750 PerformCopyInitialization(
10751 InitializedEntity::InitializeParameter(Context,
10752 FnDecl->getParamDecl(1)),
10753 SourceLocation(), Owned(Args[1]));
10754 if (Arg1.isInvalid())
10755 return ExprError();
10756 Args[0] = LHS = Arg0.takeAs<Expr>();
10757 Args[1] = RHS = Arg1.takeAs<Expr>();
10760 // Build the actual expression node.
10761 ExprResult FnExpr = CreateFunctionRefExpr(*this, FnDecl,
10763 HadMultipleCandidates, OpLoc);
10764 if (FnExpr.isInvalid())
10765 return ExprError();
10767 // Determine the result type.
10768 QualType ResultTy = FnDecl->getResultType();
10769 ExprValueKind VK = Expr::getValueKindForType(ResultTy);
10770 ResultTy = ResultTy.getNonLValueExprType(Context);
10772 CXXOperatorCallExpr *TheCall =
10773 new (Context) CXXOperatorCallExpr(Context, Op, FnExpr.take(),
10774 Args, ResultTy, VK, OpLoc,
10775 FPFeatures.fp_contract);
10777 if (CheckCallReturnType(FnDecl->getResultType(), OpLoc, TheCall,
10779 return ExprError();
10781 ArrayRef<const Expr *> ArgsArray(Args, 2);
10782 // Cut off the implicit 'this'.
10783 if (isa<CXXMethodDecl>(FnDecl))
10784 ArgsArray = ArgsArray.slice(1);
10785 checkCall(FnDecl, ArgsArray, 0, isa<CXXMethodDecl>(FnDecl), OpLoc,
10786 TheCall->getSourceRange(), VariadicDoesNotApply);
10788 return MaybeBindToTemporary(TheCall);
10790 // We matched a built-in operator. Convert the arguments, then
10791 // break out so that we will build the appropriate built-in
10793 ExprResult ArgsRes0 =
10794 PerformImplicitConversion(Args[0], Best->BuiltinTypes.ParamTypes[0],
10795 Best->Conversions[0], AA_Passing);
10796 if (ArgsRes0.isInvalid())
10797 return ExprError();
10798 Args[0] = ArgsRes0.take();
10800 ExprResult ArgsRes1 =
10801 PerformImplicitConversion(Args[1], Best->BuiltinTypes.ParamTypes[1],
10802 Best->Conversions[1], AA_Passing);
10803 if (ArgsRes1.isInvalid())
10804 return ExprError();
10805 Args[1] = ArgsRes1.take();
10810 case OR_No_Viable_Function: {
10811 // C++ [over.match.oper]p9:
10812 // If the operator is the operator , [...] and there are no
10813 // viable functions, then the operator is assumed to be the
10814 // built-in operator and interpreted according to clause 5.
10815 if (Opc == BO_Comma)
10818 // For class as left operand for assignment or compound assigment
10819 // operator do not fall through to handling in built-in, but report that
10820 // no overloaded assignment operator found
10821 ExprResult Result = ExprError();
10822 if (Args[0]->getType()->isRecordType() &&
10823 Opc >= BO_Assign && Opc <= BO_OrAssign) {
10824 Diag(OpLoc, diag::err_ovl_no_viable_oper)
10825 << BinaryOperator::getOpcodeStr(Opc)
10826 << Args[0]->getSourceRange() << Args[1]->getSourceRange();
10827 if (Args[0]->getType()->isIncompleteType()) {
10828 Diag(OpLoc, diag::note_assign_lhs_incomplete)
10829 << Args[0]->getType()
10830 << Args[0]->getSourceRange() << Args[1]->getSourceRange();
10833 // This is an erroneous use of an operator which can be overloaded by
10834 // a non-member function. Check for non-member operators which were
10835 // defined too late to be candidates.
10836 if (DiagnoseTwoPhaseOperatorLookup(*this, Op, OpLoc, Args))
10837 // FIXME: Recover by calling the found function.
10838 return ExprError();
10840 // No viable function; try to create a built-in operation, which will
10841 // produce an error. Then, show the non-viable candidates.
10842 Result = CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
10844 assert(Result.isInvalid() &&
10845 "C++ binary operator overloading is missing candidates!");
10846 if (Result.isInvalid())
10847 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args,
10848 BinaryOperator::getOpcodeStr(Opc), OpLoc);
10853 Diag(OpLoc, diag::err_ovl_ambiguous_oper_binary)
10854 << BinaryOperator::getOpcodeStr(Opc)
10855 << Args[0]->getType() << Args[1]->getType()
10856 << Args[0]->getSourceRange() << Args[1]->getSourceRange();
10857 CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, Args,
10858 BinaryOperator::getOpcodeStr(Opc), OpLoc);
10859 return ExprError();
10862 if (isImplicitlyDeleted(Best->Function)) {
10863 CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
10864 Diag(OpLoc, diag::err_ovl_deleted_special_oper)
10865 << Context.getRecordType(Method->getParent())
10866 << getSpecialMember(Method);
10868 // The user probably meant to call this special member. Just
10869 // explain why it's deleted.
10870 NoteDeletedFunction(Method);
10871 return ExprError();
10873 Diag(OpLoc, diag::err_ovl_deleted_oper)
10874 << Best->Function->isDeleted()
10875 << BinaryOperator::getOpcodeStr(Opc)
10876 << getDeletedOrUnavailableSuffix(Best->Function)
10877 << Args[0]->getSourceRange() << Args[1]->getSourceRange();
10879 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args,
10880 BinaryOperator::getOpcodeStr(Opc), OpLoc);
10881 return ExprError();
10884 // We matched a built-in operator; build it.
10885 return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
10889 Sema::CreateOverloadedArraySubscriptExpr(SourceLocation LLoc,
10890 SourceLocation RLoc,
10891 Expr *Base, Expr *Idx) {
10892 Expr *Args[2] = { Base, Idx };
10893 DeclarationName OpName =
10894 Context.DeclarationNames.getCXXOperatorName(OO_Subscript);
10896 // If either side is type-dependent, create an appropriate dependent
10898 if (Args[0]->isTypeDependent() || Args[1]->isTypeDependent()) {
10900 CXXRecordDecl *NamingClass = 0; // because lookup ignores member operators
10901 // CHECKME: no 'operator' keyword?
10902 DeclarationNameInfo OpNameInfo(OpName, LLoc);
10903 OpNameInfo.setCXXOperatorNameRange(SourceRange(LLoc, RLoc));
10904 UnresolvedLookupExpr *Fn
10905 = UnresolvedLookupExpr::Create(Context, NamingClass,
10906 NestedNameSpecifierLoc(), OpNameInfo,
10907 /*ADL*/ true, /*Overloaded*/ false,
10908 UnresolvedSetIterator(),
10909 UnresolvedSetIterator());
10910 // Can't add any actual overloads yet
10912 return Owned(new (Context) CXXOperatorCallExpr(Context, OO_Subscript, Fn,
10914 Context.DependentTy,
10919 // Handle placeholders on both operands.
10920 if (checkPlaceholderForOverload(*this, Args[0]))
10921 return ExprError();
10922 if (checkPlaceholderForOverload(*this, Args[1]))
10923 return ExprError();
10925 // Build an empty overload set.
10926 OverloadCandidateSet CandidateSet(LLoc);
10928 // Subscript can only be overloaded as a member function.
10930 // Add operator candidates that are member functions.
10931 AddMemberOperatorCandidates(OO_Subscript, LLoc, Args, CandidateSet);
10933 // Add builtin operator candidates.
10934 AddBuiltinOperatorCandidates(OO_Subscript, LLoc, Args, CandidateSet);
10936 bool HadMultipleCandidates = (CandidateSet.size() > 1);
10938 // Perform overload resolution.
10939 OverloadCandidateSet::iterator Best;
10940 switch (CandidateSet.BestViableFunction(*this, LLoc, Best)) {
10942 // We found a built-in operator or an overloaded operator.
10943 FunctionDecl *FnDecl = Best->Function;
10946 // We matched an overloaded operator. Build a call to that
10949 CheckMemberOperatorAccess(LLoc, Args[0], Args[1], Best->FoundDecl);
10951 // Convert the arguments.
10952 CXXMethodDecl *Method = cast<CXXMethodDecl>(FnDecl);
10954 PerformObjectArgumentInitialization(Args[0], /*Qualifier=*/0,
10955 Best->FoundDecl, Method);
10956 if (Arg0.isInvalid())
10957 return ExprError();
10958 Args[0] = Arg0.take();
10960 // Convert the arguments.
10961 ExprResult InputInit
10962 = PerformCopyInitialization(InitializedEntity::InitializeParameter(
10964 FnDecl->getParamDecl(0)),
10967 if (InputInit.isInvalid())
10968 return ExprError();
10970 Args[1] = InputInit.takeAs<Expr>();
10972 // Build the actual expression node.
10973 DeclarationNameInfo OpLocInfo(OpName, LLoc);
10974 OpLocInfo.setCXXOperatorNameRange(SourceRange(LLoc, RLoc));
10975 ExprResult FnExpr = CreateFunctionRefExpr(*this, FnDecl,
10977 HadMultipleCandidates,
10978 OpLocInfo.getLoc(),
10979 OpLocInfo.getInfo());
10980 if (FnExpr.isInvalid())
10981 return ExprError();
10983 // Determine the result type
10984 QualType ResultTy = FnDecl->getResultType();
10985 ExprValueKind VK = Expr::getValueKindForType(ResultTy);
10986 ResultTy = ResultTy.getNonLValueExprType(Context);
10988 CXXOperatorCallExpr *TheCall =
10989 new (Context) CXXOperatorCallExpr(Context, OO_Subscript,
10990 FnExpr.take(), Args,
10991 ResultTy, VK, RLoc,
10994 if (CheckCallReturnType(FnDecl->getResultType(), LLoc, TheCall,
10996 return ExprError();
10998 return MaybeBindToTemporary(TheCall);
11000 // We matched a built-in operator. Convert the arguments, then
11001 // break out so that we will build the appropriate built-in
11003 ExprResult ArgsRes0 =
11004 PerformImplicitConversion(Args[0], Best->BuiltinTypes.ParamTypes[0],
11005 Best->Conversions[0], AA_Passing);
11006 if (ArgsRes0.isInvalid())
11007 return ExprError();
11008 Args[0] = ArgsRes0.take();
11010 ExprResult ArgsRes1 =
11011 PerformImplicitConversion(Args[1], Best->BuiltinTypes.ParamTypes[1],
11012 Best->Conversions[1], AA_Passing);
11013 if (ArgsRes1.isInvalid())
11014 return ExprError();
11015 Args[1] = ArgsRes1.take();
11021 case OR_No_Viable_Function: {
11022 if (CandidateSet.empty())
11023 Diag(LLoc, diag::err_ovl_no_oper)
11024 << Args[0]->getType() << /*subscript*/ 0
11025 << Args[0]->getSourceRange() << Args[1]->getSourceRange();
11027 Diag(LLoc, diag::err_ovl_no_viable_subscript)
11028 << Args[0]->getType()
11029 << Args[0]->getSourceRange() << Args[1]->getSourceRange();
11030 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args,
11032 return ExprError();
11036 Diag(LLoc, diag::err_ovl_ambiguous_oper_binary)
11038 << Args[0]->getType() << Args[1]->getType()
11039 << Args[0]->getSourceRange() << Args[1]->getSourceRange();
11040 CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, Args,
11042 return ExprError();
11045 Diag(LLoc, diag::err_ovl_deleted_oper)
11046 << Best->Function->isDeleted() << "[]"
11047 << getDeletedOrUnavailableSuffix(Best->Function)
11048 << Args[0]->getSourceRange() << Args[1]->getSourceRange();
11049 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args,
11051 return ExprError();
11054 // We matched a built-in operator; build it.
11055 return CreateBuiltinArraySubscriptExpr(Args[0], LLoc, Args[1], RLoc);
11058 /// BuildCallToMemberFunction - Build a call to a member
11059 /// function. MemExpr is the expression that refers to the member
11060 /// function (and includes the object parameter), Args/NumArgs are the
11061 /// arguments to the function call (not including the object
11062 /// parameter). The caller needs to validate that the member
11063 /// expression refers to a non-static member function or an overloaded
11064 /// member function.
11066 Sema::BuildCallToMemberFunction(Scope *S, Expr *MemExprE,
11067 SourceLocation LParenLoc,
11069 SourceLocation RParenLoc) {
11070 assert(MemExprE->getType() == Context.BoundMemberTy ||
11071 MemExprE->getType() == Context.OverloadTy);
11073 // Dig out the member expression. This holds both the object
11074 // argument and the member function we're referring to.
11075 Expr *NakedMemExpr = MemExprE->IgnoreParens();
11077 // Determine whether this is a call to a pointer-to-member function.
11078 if (BinaryOperator *op = dyn_cast<BinaryOperator>(NakedMemExpr)) {
11079 assert(op->getType() == Context.BoundMemberTy);
11080 assert(op->getOpcode() == BO_PtrMemD || op->getOpcode() == BO_PtrMemI);
11083 op->getRHS()->getType()->castAs<MemberPointerType>()->getPointeeType();
11085 const FunctionProtoType *proto = fnType->castAs<FunctionProtoType>();
11086 QualType resultType = proto->getCallResultType(Context);
11087 ExprValueKind valueKind = Expr::getValueKindForType(proto->getResultType());
11089 // Check that the object type isn't more qualified than the
11090 // member function we're calling.
11091 Qualifiers funcQuals = Qualifiers::fromCVRMask(proto->getTypeQuals());
11093 QualType objectType = op->getLHS()->getType();
11094 if (op->getOpcode() == BO_PtrMemI)
11095 objectType = objectType->castAs<PointerType>()->getPointeeType();
11096 Qualifiers objectQuals = objectType.getQualifiers();
11098 Qualifiers difference = objectQuals - funcQuals;
11099 difference.removeObjCGCAttr();
11100 difference.removeAddressSpace();
11102 std::string qualsString = difference.getAsString();
11103 Diag(LParenLoc, diag::err_pointer_to_member_call_drops_quals)
11104 << fnType.getUnqualifiedType()
11106 << (qualsString.find(' ') == std::string::npos ? 1 : 2);
11109 CXXMemberCallExpr *call
11110 = new (Context) CXXMemberCallExpr(Context, MemExprE, Args,
11111 resultType, valueKind, RParenLoc);
11113 if (CheckCallReturnType(proto->getResultType(),
11114 op->getRHS()->getLocStart(),
11116 return ExprError();
11118 if (ConvertArgumentsForCall(call, op, 0, proto, Args, RParenLoc))
11119 return ExprError();
11121 if (CheckOtherCall(call, proto))
11122 return ExprError();
11124 return MaybeBindToTemporary(call);
11127 UnbridgedCastsSet UnbridgedCasts;
11128 if (checkArgPlaceholdersForOverload(*this, Args, UnbridgedCasts))
11129 return ExprError();
11131 MemberExpr *MemExpr;
11132 CXXMethodDecl *Method = 0;
11133 DeclAccessPair FoundDecl = DeclAccessPair::make(0, AS_public);
11134 NestedNameSpecifier *Qualifier = 0;
11135 if (isa<MemberExpr>(NakedMemExpr)) {
11136 MemExpr = cast<MemberExpr>(NakedMemExpr);
11137 Method = cast<CXXMethodDecl>(MemExpr->getMemberDecl());
11138 FoundDecl = MemExpr->getFoundDecl();
11139 Qualifier = MemExpr->getQualifier();
11140 UnbridgedCasts.restore();
11142 UnresolvedMemberExpr *UnresExpr = cast<UnresolvedMemberExpr>(NakedMemExpr);
11143 Qualifier = UnresExpr->getQualifier();
11145 QualType ObjectType = UnresExpr->getBaseType();
11146 Expr::Classification ObjectClassification
11147 = UnresExpr->isArrow()? Expr::Classification::makeSimpleLValue()
11148 : UnresExpr->getBase()->Classify(Context);
11150 // Add overload candidates
11151 OverloadCandidateSet CandidateSet(UnresExpr->getMemberLoc());
11153 // FIXME: avoid copy.
11154 TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = 0;
11155 if (UnresExpr->hasExplicitTemplateArgs()) {
11156 UnresExpr->copyTemplateArgumentsInto(TemplateArgsBuffer);
11157 TemplateArgs = &TemplateArgsBuffer;
11160 for (UnresolvedMemberExpr::decls_iterator I = UnresExpr->decls_begin(),
11161 E = UnresExpr->decls_end(); I != E; ++I) {
11163 NamedDecl *Func = *I;
11164 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(Func->getDeclContext());
11165 if (isa<UsingShadowDecl>(Func))
11166 Func = cast<UsingShadowDecl>(Func)->getTargetDecl();
11169 // Microsoft supports direct constructor calls.
11170 if (getLangOpts().MicrosoftExt && isa<CXXConstructorDecl>(Func)) {
11171 AddOverloadCandidate(cast<CXXConstructorDecl>(Func), I.getPair(),
11172 Args, CandidateSet);
11173 } else if ((Method = dyn_cast<CXXMethodDecl>(Func))) {
11174 // If explicit template arguments were provided, we can't call a
11175 // non-template member function.
11179 AddMethodCandidate(Method, I.getPair(), ActingDC, ObjectType,
11180 ObjectClassification, Args, CandidateSet,
11181 /*SuppressUserConversions=*/false);
11183 AddMethodTemplateCandidate(cast<FunctionTemplateDecl>(Func),
11184 I.getPair(), ActingDC, TemplateArgs,
11185 ObjectType, ObjectClassification,
11186 Args, CandidateSet,
11187 /*SuppressUsedConversions=*/false);
11191 DeclarationName DeclName = UnresExpr->getMemberName();
11193 UnbridgedCasts.restore();
11195 OverloadCandidateSet::iterator Best;
11196 switch (CandidateSet.BestViableFunction(*this, UnresExpr->getLocStart(),
11199 Method = cast<CXXMethodDecl>(Best->Function);
11200 FoundDecl = Best->FoundDecl;
11201 CheckUnresolvedMemberAccess(UnresExpr, Best->FoundDecl);
11202 if (DiagnoseUseOfDecl(Best->FoundDecl, UnresExpr->getNameLoc()))
11203 return ExprError();
11204 // If FoundDecl is different from Method (such as if one is a template
11205 // and the other a specialization), make sure DiagnoseUseOfDecl is
11207 // FIXME: This would be more comprehensively addressed by modifying
11208 // DiagnoseUseOfDecl to accept both the FoundDecl and the decl
11210 if (Method != FoundDecl.getDecl() &&
11211 DiagnoseUseOfDecl(Method, UnresExpr->getNameLoc()))
11212 return ExprError();
11215 case OR_No_Viable_Function:
11216 Diag(UnresExpr->getMemberLoc(),
11217 diag::err_ovl_no_viable_member_function_in_call)
11218 << DeclName << MemExprE->getSourceRange();
11219 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args);
11220 // FIXME: Leaking incoming expressions!
11221 return ExprError();
11224 Diag(UnresExpr->getMemberLoc(), diag::err_ovl_ambiguous_member_call)
11225 << DeclName << MemExprE->getSourceRange();
11226 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args);
11227 // FIXME: Leaking incoming expressions!
11228 return ExprError();
11231 Diag(UnresExpr->getMemberLoc(), diag::err_ovl_deleted_member_call)
11232 << Best->Function->isDeleted()
11234 << getDeletedOrUnavailableSuffix(Best->Function)
11235 << MemExprE->getSourceRange();
11236 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args);
11237 // FIXME: Leaking incoming expressions!
11238 return ExprError();
11241 MemExprE = FixOverloadedFunctionReference(MemExprE, FoundDecl, Method);
11243 // If overload resolution picked a static member, build a
11244 // non-member call based on that function.
11245 if (Method->isStatic()) {
11246 return BuildResolvedCallExpr(MemExprE, Method, LParenLoc, Args,
11250 MemExpr = cast<MemberExpr>(MemExprE->IgnoreParens());
11253 QualType ResultType = Method->getResultType();
11254 ExprValueKind VK = Expr::getValueKindForType(ResultType);
11255 ResultType = ResultType.getNonLValueExprType(Context);
11257 assert(Method && "Member call to something that isn't a method?");
11258 CXXMemberCallExpr *TheCall =
11259 new (Context) CXXMemberCallExpr(Context, MemExprE, Args,
11260 ResultType, VK, RParenLoc);
11262 // Check for a valid return type.
11263 if (CheckCallReturnType(Method->getResultType(), MemExpr->getMemberLoc(),
11265 return ExprError();
11267 // Convert the object argument (for a non-static member function call).
11268 // We only need to do this if there was actually an overload; otherwise
11269 // it was done at lookup.
11270 if (!Method->isStatic()) {
11271 ExprResult ObjectArg =
11272 PerformObjectArgumentInitialization(MemExpr->getBase(), Qualifier,
11273 FoundDecl, Method);
11274 if (ObjectArg.isInvalid())
11275 return ExprError();
11276 MemExpr->setBase(ObjectArg.take());
11279 // Convert the rest of the arguments
11280 const FunctionProtoType *Proto =
11281 Method->getType()->getAs<FunctionProtoType>();
11282 if (ConvertArgumentsForCall(TheCall, MemExpr, Method, Proto, Args,
11284 return ExprError();
11286 DiagnoseSentinelCalls(Method, LParenLoc, Args);
11288 if (CheckFunctionCall(Method, TheCall, Proto))
11289 return ExprError();
11291 if ((isa<CXXConstructorDecl>(CurContext) ||
11292 isa<CXXDestructorDecl>(CurContext)) &&
11293 TheCall->getMethodDecl()->isPure()) {
11294 const CXXMethodDecl *MD = TheCall->getMethodDecl();
11296 if (isa<CXXThisExpr>(MemExpr->getBase()->IgnoreParenCasts())) {
11297 Diag(MemExpr->getLocStart(),
11298 diag::warn_call_to_pure_virtual_member_function_from_ctor_dtor)
11299 << MD->getDeclName() << isa<CXXDestructorDecl>(CurContext)
11300 << MD->getParent()->getDeclName();
11302 Diag(MD->getLocStart(), diag::note_previous_decl) << MD->getDeclName();
11305 return MaybeBindToTemporary(TheCall);
11308 /// BuildCallToObjectOfClassType - Build a call to an object of class
11309 /// type (C++ [over.call.object]), which can end up invoking an
11310 /// overloaded function call operator (@c operator()) or performing a
11311 /// user-defined conversion on the object argument.
11313 Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Obj,
11314 SourceLocation LParenLoc,
11316 SourceLocation RParenLoc) {
11317 if (checkPlaceholderForOverload(*this, Obj))
11318 return ExprError();
11319 ExprResult Object = Owned(Obj);
11321 UnbridgedCastsSet UnbridgedCasts;
11322 if (checkArgPlaceholdersForOverload(*this, Args, UnbridgedCasts))
11323 return ExprError();
11325 assert(Object.get()->getType()->isRecordType() && "Requires object type argument");
11326 const RecordType *Record = Object.get()->getType()->getAs<RecordType>();
11328 // C++ [over.call.object]p1:
11329 // If the primary-expression E in the function call syntax
11330 // evaluates to a class object of type "cv T", then the set of
11331 // candidate functions includes at least the function call
11332 // operators of T. The function call operators of T are obtained by
11333 // ordinary lookup of the name operator() in the context of
11335 OverloadCandidateSet CandidateSet(LParenLoc);
11336 DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(OO_Call);
11338 if (RequireCompleteType(LParenLoc, Object.get()->getType(),
11339 diag::err_incomplete_object_call, Object.get()))
11342 LookupResult R(*this, OpName, LParenLoc, LookupOrdinaryName);
11343 LookupQualifiedName(R, Record->getDecl());
11344 R.suppressDiagnostics();
11346 for (LookupResult::iterator Oper = R.begin(), OperEnd = R.end();
11347 Oper != OperEnd; ++Oper) {
11348 AddMethodCandidate(Oper.getPair(), Object.get()->getType(),
11349 Object.get()->Classify(Context),
11350 Args, CandidateSet,
11351 /*SuppressUserConversions=*/ false);
11354 // C++ [over.call.object]p2:
11355 // In addition, for each (non-explicit in C++0x) conversion function
11356 // declared in T of the form
11358 // operator conversion-type-id () cv-qualifier;
11360 // where cv-qualifier is the same cv-qualification as, or a
11361 // greater cv-qualification than, cv, and where conversion-type-id
11362 // denotes the type "pointer to function of (P1,...,Pn) returning
11363 // R", or the type "reference to pointer to function of
11364 // (P1,...,Pn) returning R", or the type "reference to function
11365 // of (P1,...,Pn) returning R", a surrogate call function [...]
11366 // is also considered as a candidate function. Similarly,
11367 // surrogate call functions are added to the set of candidate
11368 // functions for each conversion function declared in an
11369 // accessible base class provided the function is not hidden
11370 // within T by another intervening declaration.
11371 std::pair<CXXRecordDecl::conversion_iterator,
11372 CXXRecordDecl::conversion_iterator> Conversions
11373 = cast<CXXRecordDecl>(Record->getDecl())->getVisibleConversionFunctions();
11374 for (CXXRecordDecl::conversion_iterator
11375 I = Conversions.first, E = Conversions.second; I != E; ++I) {
11377 CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext());
11378 if (isa<UsingShadowDecl>(D))
11379 D = cast<UsingShadowDecl>(D)->getTargetDecl();
11381 // Skip over templated conversion functions; they aren't
11383 if (isa<FunctionTemplateDecl>(D))
11386 CXXConversionDecl *Conv = cast<CXXConversionDecl>(D);
11387 if (!Conv->isExplicit()) {
11388 // Strip the reference type (if any) and then the pointer type (if
11389 // any) to get down to what might be a function type.
11390 QualType ConvType = Conv->getConversionType().getNonReferenceType();
11391 if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>())
11392 ConvType = ConvPtrType->getPointeeType();
11394 if (const FunctionProtoType *Proto = ConvType->getAs<FunctionProtoType>())
11396 AddSurrogateCandidate(Conv, I.getPair(), ActingContext, Proto,
11397 Object.get(), Args, CandidateSet);
11402 bool HadMultipleCandidates = (CandidateSet.size() > 1);
11404 // Perform overload resolution.
11405 OverloadCandidateSet::iterator Best;
11406 switch (CandidateSet.BestViableFunction(*this, Object.get()->getLocStart(),
11409 // Overload resolution succeeded; we'll build the appropriate call
11413 case OR_No_Viable_Function:
11414 if (CandidateSet.empty())
11415 Diag(Object.get()->getLocStart(), diag::err_ovl_no_oper)
11416 << Object.get()->getType() << /*call*/ 1
11417 << Object.get()->getSourceRange();
11419 Diag(Object.get()->getLocStart(),
11420 diag::err_ovl_no_viable_object_call)
11421 << Object.get()->getType() << Object.get()->getSourceRange();
11422 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args);
11426 Diag(Object.get()->getLocStart(),
11427 diag::err_ovl_ambiguous_object_call)
11428 << Object.get()->getType() << Object.get()->getSourceRange();
11429 CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, Args);
11433 Diag(Object.get()->getLocStart(),
11434 diag::err_ovl_deleted_object_call)
11435 << Best->Function->isDeleted()
11436 << Object.get()->getType()
11437 << getDeletedOrUnavailableSuffix(Best->Function)
11438 << Object.get()->getSourceRange();
11439 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args);
11443 if (Best == CandidateSet.end())
11446 UnbridgedCasts.restore();
11448 if (Best->Function == 0) {
11449 // Since there is no function declaration, this is one of the
11450 // surrogate candidates. Dig out the conversion function.
11451 CXXConversionDecl *Conv
11452 = cast<CXXConversionDecl>(
11453 Best->Conversions[0].UserDefined.ConversionFunction);
11455 CheckMemberOperatorAccess(LParenLoc, Object.get(), 0, Best->FoundDecl);
11456 if (DiagnoseUseOfDecl(Best->FoundDecl, LParenLoc))
11457 return ExprError();
11458 assert(Conv == Best->FoundDecl.getDecl() &&
11459 "Found Decl & conversion-to-functionptr should be same, right?!");
11460 // We selected one of the surrogate functions that converts the
11461 // object parameter to a function pointer. Perform the conversion
11462 // on the object argument, then let ActOnCallExpr finish the job.
11464 // Create an implicit member expr to refer to the conversion operator.
11465 // and then call it.
11466 ExprResult Call = BuildCXXMemberCallExpr(Object.get(), Best->FoundDecl,
11467 Conv, HadMultipleCandidates);
11468 if (Call.isInvalid())
11469 return ExprError();
11470 // Record usage of conversion in an implicit cast.
11471 Call = Owned(ImplicitCastExpr::Create(Context, Call.get()->getType(),
11472 CK_UserDefinedConversion,
11473 Call.get(), 0, VK_RValue));
11475 return ActOnCallExpr(S, Call.get(), LParenLoc, Args, RParenLoc);
11478 CheckMemberOperatorAccess(LParenLoc, Object.get(), 0, Best->FoundDecl);
11480 // We found an overloaded operator(). Build a CXXOperatorCallExpr
11481 // that calls this method, using Object for the implicit object
11482 // parameter and passing along the remaining arguments.
11483 CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
11485 // An error diagnostic has already been printed when parsing the declaration.
11486 if (Method->isInvalidDecl())
11487 return ExprError();
11489 const FunctionProtoType *Proto =
11490 Method->getType()->getAs<FunctionProtoType>();
11492 unsigned NumArgsInProto = Proto->getNumArgs();
11494 DeclarationNameInfo OpLocInfo(
11495 Context.DeclarationNames.getCXXOperatorName(OO_Call), LParenLoc);
11496 OpLocInfo.setCXXOperatorNameRange(SourceRange(LParenLoc, RParenLoc));
11497 ExprResult NewFn = CreateFunctionRefExpr(*this, Method, Best->FoundDecl,
11498 HadMultipleCandidates,
11499 OpLocInfo.getLoc(),
11500 OpLocInfo.getInfo());
11501 if (NewFn.isInvalid())
11504 // Build the full argument list for the method call (the implicit object
11505 // parameter is placed at the beginning of the list).
11506 llvm::OwningArrayPtr<Expr *> MethodArgs(new Expr*[Args.size() + 1]);
11507 MethodArgs[0] = Object.get();
11508 std::copy(Args.begin(), Args.end(), &MethodArgs[1]);
11510 // Once we've built TheCall, all of the expressions are properly
11512 QualType ResultTy = Method->getResultType();
11513 ExprValueKind VK = Expr::getValueKindForType(ResultTy);
11514 ResultTy = ResultTy.getNonLValueExprType(Context);
11516 CXXOperatorCallExpr *TheCall = new (Context)
11517 CXXOperatorCallExpr(Context, OO_Call, NewFn.take(),
11518 llvm::makeArrayRef(MethodArgs.get(), Args.size() + 1),
11519 ResultTy, VK, RParenLoc, false);
11520 MethodArgs.reset();
11522 if (CheckCallReturnType(Method->getResultType(), LParenLoc, TheCall,
11526 // We may have default arguments. If so, we need to allocate more
11527 // slots in the call for them.
11528 if (Args.size() < NumArgsInProto)
11529 TheCall->setNumArgs(Context, NumArgsInProto + 1);
11531 bool IsError = false;
11533 // Initialize the implicit object parameter.
11534 ExprResult ObjRes =
11535 PerformObjectArgumentInitialization(Object.get(), /*Qualifier=*/0,
11536 Best->FoundDecl, Method);
11537 if (ObjRes.isInvalid())
11541 TheCall->setArg(0, Object.take());
11543 // Check the argument types.
11544 for (unsigned i = 0; i != NumArgsInProto; i++) {
11546 if (i < Args.size()) {
11549 // Pass the argument.
11551 ExprResult InputInit
11552 = PerformCopyInitialization(InitializedEntity::InitializeParameter(
11554 Method->getParamDecl(i)),
11555 SourceLocation(), Arg);
11557 IsError |= InputInit.isInvalid();
11558 Arg = InputInit.takeAs<Expr>();
11561 = BuildCXXDefaultArgExpr(LParenLoc, Method, Method->getParamDecl(i));
11562 if (DefArg.isInvalid()) {
11567 Arg = DefArg.takeAs<Expr>();
11570 TheCall->setArg(i + 1, Arg);
11573 // If this is a variadic call, handle args passed through "...".
11574 if (Proto->isVariadic()) {
11575 // Promote the arguments (C99 6.5.2.2p7).
11576 for (unsigned i = NumArgsInProto, e = Args.size(); i < e; i++) {
11577 ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], VariadicMethod, 0);
11578 IsError |= Arg.isInvalid();
11579 TheCall->setArg(i + 1, Arg.take());
11583 if (IsError) return true;
11585 DiagnoseSentinelCalls(Method, LParenLoc, Args);
11587 if (CheckFunctionCall(Method, TheCall, Proto))
11590 return MaybeBindToTemporary(TheCall);
11593 /// BuildOverloadedArrowExpr - Build a call to an overloaded @c operator->
11594 /// (if one exists), where @c Base is an expression of class type and
11595 /// @c Member is the name of the member we're trying to find.
11597 Sema::BuildOverloadedArrowExpr(Scope *S, Expr *Base, SourceLocation OpLoc,
11598 bool *NoArrowOperatorFound) {
11599 assert(Base->getType()->isRecordType() &&
11600 "left-hand side must have class type");
11602 if (checkPlaceholderForOverload(*this, Base))
11603 return ExprError();
11605 SourceLocation Loc = Base->getExprLoc();
11607 // C++ [over.ref]p1:
11609 // [...] An expression x->m is interpreted as (x.operator->())->m
11610 // for a class object x of type T if T::operator->() exists and if
11611 // the operator is selected as the best match function by the
11612 // overload resolution mechanism (13.3).
11613 DeclarationName OpName =
11614 Context.DeclarationNames.getCXXOperatorName(OO_Arrow);
11615 OverloadCandidateSet CandidateSet(Loc);
11616 const RecordType *BaseRecord = Base->getType()->getAs<RecordType>();
11618 if (RequireCompleteType(Loc, Base->getType(),
11619 diag::err_typecheck_incomplete_tag, Base))
11620 return ExprError();
11622 LookupResult R(*this, OpName, OpLoc, LookupOrdinaryName);
11623 LookupQualifiedName(R, BaseRecord->getDecl());
11624 R.suppressDiagnostics();
11626 for (LookupResult::iterator Oper = R.begin(), OperEnd = R.end();
11627 Oper != OperEnd; ++Oper) {
11628 AddMethodCandidate(Oper.getPair(), Base->getType(), Base->Classify(Context),
11629 None, CandidateSet, /*SuppressUserConversions=*/false);
11632 bool HadMultipleCandidates = (CandidateSet.size() > 1);
11634 // Perform overload resolution.
11635 OverloadCandidateSet::iterator Best;
11636 switch (CandidateSet.BestViableFunction(*this, OpLoc, Best)) {
11638 // Overload resolution succeeded; we'll build the call below.
11641 case OR_No_Viable_Function:
11642 if (CandidateSet.empty()) {
11643 QualType BaseType = Base->getType();
11644 if (NoArrowOperatorFound) {
11645 // Report this specific error to the caller instead of emitting a
11646 // diagnostic, as requested.
11647 *NoArrowOperatorFound = true;
11648 return ExprError();
11650 Diag(OpLoc, diag::err_typecheck_member_reference_arrow)
11651 << BaseType << Base->getSourceRange();
11652 if (BaseType->isRecordType() && !BaseType->isPointerType()) {
11653 Diag(OpLoc, diag::note_typecheck_member_reference_suggestion)
11654 << FixItHint::CreateReplacement(OpLoc, ".");
11657 Diag(OpLoc, diag::err_ovl_no_viable_oper)
11658 << "operator->" << Base->getSourceRange();
11659 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Base);
11660 return ExprError();
11663 Diag(OpLoc, diag::err_ovl_ambiguous_oper_unary)
11664 << "->" << Base->getType() << Base->getSourceRange();
11665 CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, Base);
11666 return ExprError();
11669 Diag(OpLoc, diag::err_ovl_deleted_oper)
11670 << Best->Function->isDeleted()
11672 << getDeletedOrUnavailableSuffix(Best->Function)
11673 << Base->getSourceRange();
11674 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Base);
11675 return ExprError();
11678 CheckMemberOperatorAccess(OpLoc, Base, 0, Best->FoundDecl);
11680 // Convert the object parameter.
11681 CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
11682 ExprResult BaseResult =
11683 PerformObjectArgumentInitialization(Base, /*Qualifier=*/0,
11684 Best->FoundDecl, Method);
11685 if (BaseResult.isInvalid())
11686 return ExprError();
11687 Base = BaseResult.take();
11689 // Build the operator call.
11690 ExprResult FnExpr = CreateFunctionRefExpr(*this, Method, Best->FoundDecl,
11691 HadMultipleCandidates, OpLoc);
11692 if (FnExpr.isInvalid())
11693 return ExprError();
11695 QualType ResultTy = Method->getResultType();
11696 ExprValueKind VK = Expr::getValueKindForType(ResultTy);
11697 ResultTy = ResultTy.getNonLValueExprType(Context);
11698 CXXOperatorCallExpr *TheCall =
11699 new (Context) CXXOperatorCallExpr(Context, OO_Arrow, FnExpr.take(),
11700 Base, ResultTy, VK, OpLoc, false);
11702 if (CheckCallReturnType(Method->getResultType(), OpLoc, TheCall,
11704 return ExprError();
11706 return MaybeBindToTemporary(TheCall);
11709 /// BuildLiteralOperatorCall - Build a UserDefinedLiteral by creating a call to
11710 /// a literal operator described by the provided lookup results.
11711 ExprResult Sema::BuildLiteralOperatorCall(LookupResult &R,
11712 DeclarationNameInfo &SuffixInfo,
11713 ArrayRef<Expr*> Args,
11714 SourceLocation LitEndLoc,
11715 TemplateArgumentListInfo *TemplateArgs) {
11716 SourceLocation UDSuffixLoc = SuffixInfo.getCXXLiteralOperatorNameLoc();
11718 OverloadCandidateSet CandidateSet(UDSuffixLoc);
11719 AddFunctionCandidates(R.asUnresolvedSet(), Args, CandidateSet, true,
11722 bool HadMultipleCandidates = (CandidateSet.size() > 1);
11724 // Perform overload resolution. This will usually be trivial, but might need
11725 // to perform substitutions for a literal operator template.
11726 OverloadCandidateSet::iterator Best;
11727 switch (CandidateSet.BestViableFunction(*this, UDSuffixLoc, Best)) {
11732 case OR_No_Viable_Function:
11733 Diag(UDSuffixLoc, diag::err_ovl_no_viable_function_in_call)
11734 << R.getLookupName();
11735 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args);
11736 return ExprError();
11739 Diag(R.getNameLoc(), diag::err_ovl_ambiguous_call) << R.getLookupName();
11740 CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, Args);
11741 return ExprError();
11744 FunctionDecl *FD = Best->Function;
11745 ExprResult Fn = CreateFunctionRefExpr(*this, FD, Best->FoundDecl,
11746 HadMultipleCandidates,
11747 SuffixInfo.getLoc(),
11748 SuffixInfo.getInfo());
11749 if (Fn.isInvalid())
11752 // Check the argument types. This should almost always be a no-op, except
11753 // that array-to-pointer decay is applied to string literals.
11755 for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
11756 ExprResult InputInit = PerformCopyInitialization(
11757 InitializedEntity::InitializeParameter(Context, FD->getParamDecl(ArgIdx)),
11758 SourceLocation(), Args[ArgIdx]);
11759 if (InputInit.isInvalid())
11761 ConvArgs[ArgIdx] = InputInit.take();
11764 QualType ResultTy = FD->getResultType();
11765 ExprValueKind VK = Expr::getValueKindForType(ResultTy);
11766 ResultTy = ResultTy.getNonLValueExprType(Context);
11768 UserDefinedLiteral *UDL =
11769 new (Context) UserDefinedLiteral(Context, Fn.take(),
11770 llvm::makeArrayRef(ConvArgs, Args.size()),
11771 ResultTy, VK, LitEndLoc, UDSuffixLoc);
11773 if (CheckCallReturnType(FD->getResultType(), UDSuffixLoc, UDL, FD))
11774 return ExprError();
11776 if (CheckFunctionCall(FD, UDL, NULL))
11777 return ExprError();
11779 return MaybeBindToTemporary(UDL);
11782 /// Build a call to 'begin' or 'end' for a C++11 for-range statement. If the
11783 /// given LookupResult is non-empty, it is assumed to describe a member which
11784 /// will be invoked. Otherwise, the function will be found via argument
11785 /// dependent lookup.
11786 /// CallExpr is set to a valid expression and FRS_Success returned on success,
11787 /// otherwise CallExpr is set to ExprError() and some non-success value
11789 Sema::ForRangeStatus
11790 Sema::BuildForRangeBeginEndCall(Scope *S, SourceLocation Loc,
11791 SourceLocation RangeLoc, VarDecl *Decl,
11792 BeginEndFunction BEF,
11793 const DeclarationNameInfo &NameInfo,
11794 LookupResult &MemberLookup,
11795 OverloadCandidateSet *CandidateSet,
11796 Expr *Range, ExprResult *CallExpr) {
11797 CandidateSet->clear();
11798 if (!MemberLookup.empty()) {
11799 ExprResult MemberRef =
11800 BuildMemberReferenceExpr(Range, Range->getType(), Loc,
11801 /*IsPtr=*/false, CXXScopeSpec(),
11802 /*TemplateKWLoc=*/SourceLocation(),
11803 /*FirstQualifierInScope=*/0,
11805 /*TemplateArgs=*/0);
11806 if (MemberRef.isInvalid()) {
11807 *CallExpr = ExprError();
11808 Diag(Range->getLocStart(), diag::note_in_for_range)
11809 << RangeLoc << BEF << Range->getType();
11810 return FRS_DiagnosticIssued;
11812 *CallExpr = ActOnCallExpr(S, MemberRef.get(), Loc, None, Loc, 0);
11813 if (CallExpr->isInvalid()) {
11814 *CallExpr = ExprError();
11815 Diag(Range->getLocStart(), diag::note_in_for_range)
11816 << RangeLoc << BEF << Range->getType();
11817 return FRS_DiagnosticIssued;
11820 UnresolvedSet<0> FoundNames;
11821 UnresolvedLookupExpr *Fn =
11822 UnresolvedLookupExpr::Create(Context, /*NamingClass=*/0,
11823 NestedNameSpecifierLoc(), NameInfo,
11824 /*NeedsADL=*/true, /*Overloaded=*/false,
11825 FoundNames.begin(), FoundNames.end());
11827 bool CandidateSetError = buildOverloadedCallSet(S, Fn, Fn, Range, Loc,
11828 CandidateSet, CallExpr);
11829 if (CandidateSet->empty() || CandidateSetError) {
11830 *CallExpr = ExprError();
11831 return FRS_NoViableFunction;
11833 OverloadCandidateSet::iterator Best;
11834 OverloadingResult OverloadResult =
11835 CandidateSet->BestViableFunction(*this, Fn->getLocStart(), Best);
11837 if (OverloadResult == OR_No_Viable_Function) {
11838 *CallExpr = ExprError();
11839 return FRS_NoViableFunction;
11841 *CallExpr = FinishOverloadedCallExpr(*this, S, Fn, Fn, Loc, Range,
11842 Loc, 0, CandidateSet, &Best,
11844 /*AllowTypoCorrection=*/false);
11845 if (CallExpr->isInvalid() || OverloadResult != OR_Success) {
11846 *CallExpr = ExprError();
11847 Diag(Range->getLocStart(), diag::note_in_for_range)
11848 << RangeLoc << BEF << Range->getType();
11849 return FRS_DiagnosticIssued;
11852 return FRS_Success;
11856 /// FixOverloadedFunctionReference - E is an expression that refers to
11857 /// a C++ overloaded function (possibly with some parentheses and
11858 /// perhaps a '&' around it). We have resolved the overloaded function
11859 /// to the function declaration Fn, so patch up the expression E to
11860 /// refer (possibly indirectly) to Fn. Returns the new expr.
11861 Expr *Sema::FixOverloadedFunctionReference(Expr *E, DeclAccessPair Found,
11862 FunctionDecl *Fn) {
11863 if (ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
11864 Expr *SubExpr = FixOverloadedFunctionReference(PE->getSubExpr(),
11866 if (SubExpr == PE->getSubExpr())
11869 return new (Context) ParenExpr(PE->getLParen(), PE->getRParen(), SubExpr);
11872 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
11873 Expr *SubExpr = FixOverloadedFunctionReference(ICE->getSubExpr(),
11875 assert(Context.hasSameType(ICE->getSubExpr()->getType(),
11876 SubExpr->getType()) &&
11877 "Implicit cast type cannot be determined from overload");
11878 assert(ICE->path_empty() && "fixing up hierarchy conversion?");
11879 if (SubExpr == ICE->getSubExpr())
11882 return ImplicitCastExpr::Create(Context, ICE->getType(),
11883 ICE->getCastKind(),
11885 ICE->getValueKind());
11888 if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(E)) {
11889 assert(UnOp->getOpcode() == UO_AddrOf &&
11890 "Can only take the address of an overloaded function");
11891 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) {
11892 if (Method->isStatic()) {
11893 // Do nothing: static member functions aren't any different
11894 // from non-member functions.
11896 // Fix the sub expression, which really has to be an
11897 // UnresolvedLookupExpr holding an overloaded member function
11899 Expr *SubExpr = FixOverloadedFunctionReference(UnOp->getSubExpr(),
11901 if (SubExpr == UnOp->getSubExpr())
11904 assert(isa<DeclRefExpr>(SubExpr)
11905 && "fixed to something other than a decl ref");
11906 assert(cast<DeclRefExpr>(SubExpr)->getQualifier()
11907 && "fixed to a member ref with no nested name qualifier");
11909 // We have taken the address of a pointer to member
11910 // function. Perform the computation here so that we get the
11911 // appropriate pointer to member type.
11913 = Context.getTypeDeclType(cast<RecordDecl>(Method->getDeclContext()));
11914 QualType MemPtrType
11915 = Context.getMemberPointerType(Fn->getType(), ClassType.getTypePtr());
11917 return new (Context) UnaryOperator(SubExpr, UO_AddrOf, MemPtrType,
11918 VK_RValue, OK_Ordinary,
11919 UnOp->getOperatorLoc());
11922 Expr *SubExpr = FixOverloadedFunctionReference(UnOp->getSubExpr(),
11924 if (SubExpr == UnOp->getSubExpr())
11927 return new (Context) UnaryOperator(SubExpr, UO_AddrOf,
11928 Context.getPointerType(SubExpr->getType()),
11929 VK_RValue, OK_Ordinary,
11930 UnOp->getOperatorLoc());
11933 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
11934 // FIXME: avoid copy.
11935 TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = 0;
11936 if (ULE->hasExplicitTemplateArgs()) {
11937 ULE->copyTemplateArgumentsInto(TemplateArgsBuffer);
11938 TemplateArgs = &TemplateArgsBuffer;
11941 DeclRefExpr *DRE = DeclRefExpr::Create(Context,
11942 ULE->getQualifierLoc(),
11943 ULE->getTemplateKeywordLoc(),
11945 /*enclosing*/ false, // FIXME?
11951 MarkDeclRefReferenced(DRE);
11952 DRE->setHadMultipleCandidates(ULE->getNumDecls() > 1);
11956 if (UnresolvedMemberExpr *MemExpr = dyn_cast<UnresolvedMemberExpr>(E)) {
11957 // FIXME: avoid copy.
11958 TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = 0;
11959 if (MemExpr->hasExplicitTemplateArgs()) {
11960 MemExpr->copyTemplateArgumentsInto(TemplateArgsBuffer);
11961 TemplateArgs = &TemplateArgsBuffer;
11966 // If we're filling in a static method where we used to have an
11967 // implicit member access, rewrite to a simple decl ref.
11968 if (MemExpr->isImplicitAccess()) {
11969 if (cast<CXXMethodDecl>(Fn)->isStatic()) {
11970 DeclRefExpr *DRE = DeclRefExpr::Create(Context,
11971 MemExpr->getQualifierLoc(),
11972 MemExpr->getTemplateKeywordLoc(),
11974 /*enclosing*/ false,
11975 MemExpr->getMemberLoc(),
11980 MarkDeclRefReferenced(DRE);
11981 DRE->setHadMultipleCandidates(MemExpr->getNumDecls() > 1);
11984 SourceLocation Loc = MemExpr->getMemberLoc();
11985 if (MemExpr->getQualifier())
11986 Loc = MemExpr->getQualifierLoc().getBeginLoc();
11987 CheckCXXThisCapture(Loc);
11988 Base = new (Context) CXXThisExpr(Loc,
11989 MemExpr->getBaseType(),
11990 /*isImplicit=*/true);
11993 Base = MemExpr->getBase();
11995 ExprValueKind valueKind;
11997 if (cast<CXXMethodDecl>(Fn)->isStatic()) {
11998 valueKind = VK_LValue;
11999 type = Fn->getType();
12001 valueKind = VK_RValue;
12002 type = Context.BoundMemberTy;
12005 MemberExpr *ME = MemberExpr::Create(Context, Base,
12006 MemExpr->isArrow(),
12007 MemExpr->getQualifierLoc(),
12008 MemExpr->getTemplateKeywordLoc(),
12011 MemExpr->getMemberNameInfo(),
12013 type, valueKind, OK_Ordinary);
12014 ME->setHadMultipleCandidates(true);
12015 MarkMemberReferenced(ME);
12019 llvm_unreachable("Invalid reference to overloaded function");
12022 ExprResult Sema::FixOverloadedFunctionReference(ExprResult E,
12023 DeclAccessPair Found,
12024 FunctionDecl *Fn) {
12025 return Owned(FixOverloadedFunctionReference((Expr *)E.get(), Found, Fn));
12028 } // end namespace clang