1 //===--- SemaOverload.cpp - C++ Overloading ---------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file provides Sema routines for C++ overloading.
12 //===----------------------------------------------------------------------===//
14 #include "clang/Sema/SemaInternal.h"
15 #include "clang/Sema/Lookup.h"
16 #include "clang/Sema/Initialization.h"
17 #include "clang/Sema/Template.h"
18 #include "clang/Sema/TemplateDeduction.h"
19 #include "clang/Basic/Diagnostic.h"
20 #include "clang/Lex/Preprocessor.h"
21 #include "clang/AST/ASTContext.h"
22 #include "clang/AST/CXXInheritance.h"
23 #include "clang/AST/DeclObjC.h"
24 #include "clang/AST/Expr.h"
25 #include "clang/AST/ExprCXX.h"
26 #include "clang/AST/TypeOrdering.h"
27 #include "clang/Basic/PartialDiagnostic.h"
28 #include "llvm/ADT/SmallPtrSet.h"
29 #include "llvm/ADT/STLExtras.h"
35 static bool IsStandardConversion(Sema
&S
, Expr
* From
, QualType ToType
,
36 bool InOverloadResolution
,
37 StandardConversionSequence
&SCS
);
38 static OverloadingResult
39 IsUserDefinedConversion(Sema
&S
, Expr
*From
, QualType ToType
,
40 UserDefinedConversionSequence
& User
,
41 OverloadCandidateSet
& Conversions
,
45 static ImplicitConversionSequence::CompareKind
46 CompareStandardConversionSequences(Sema
&S
,
47 const StandardConversionSequence
& SCS1
,
48 const StandardConversionSequence
& SCS2
);
50 static ImplicitConversionSequence::CompareKind
51 CompareQualificationConversions(Sema
&S
,
52 const StandardConversionSequence
& SCS1
,
53 const StandardConversionSequence
& SCS2
);
55 static ImplicitConversionSequence::CompareKind
56 CompareDerivedToBaseConversions(Sema
&S
,
57 const StandardConversionSequence
& SCS1
,
58 const StandardConversionSequence
& SCS2
);
62 /// GetConversionCategory - Retrieve the implicit conversion
63 /// category corresponding to the given implicit conversion kind.
64 ImplicitConversionCategory
65 GetConversionCategory(ImplicitConversionKind Kind
) {
66 static const ImplicitConversionCategory
67 Category
[(int)ICK_Num_Conversion_Kinds
] = {
69 ICC_Lvalue_Transformation
,
70 ICC_Lvalue_Transformation
,
71 ICC_Lvalue_Transformation
,
73 ICC_Qualification_Adjustment
,
90 return Category
[(int)Kind
];
93 /// GetConversionRank - Retrieve the implicit conversion rank
94 /// corresponding to the given implicit conversion kind.
95 ImplicitConversionRank
GetConversionRank(ImplicitConversionKind Kind
) {
96 static const ImplicitConversionRank
97 Rank
[(int)ICK_Num_Conversion_Kinds
] = {
118 ICR_Complex_Real_Conversion
120 return Rank
[(int)Kind
];
123 /// GetImplicitConversionName - Return the name of this kind of
124 /// implicit conversion.
125 const char* GetImplicitConversionName(ImplicitConversionKind Kind
) {
126 static const char* const Name
[(int)ICK_Num_Conversion_Kinds
] = {
130 "Function-to-pointer",
131 "Noreturn adjustment",
133 "Integral promotion",
134 "Floating point promotion",
136 "Integral conversion",
137 "Floating conversion",
138 "Complex conversion",
139 "Floating-integral conversion",
140 "Pointer conversion",
141 "Pointer-to-member conversion",
142 "Boolean conversion",
143 "Compatible-types conversion",
144 "Derived-to-base conversion",
147 "Complex-real conversion"
152 /// StandardConversionSequence - Set the standard conversion
153 /// sequence to the identity conversion.
154 void StandardConversionSequence::setAsIdentityConversion() {
155 First
= ICK_Identity
;
156 Second
= ICK_Identity
;
157 Third
= ICK_Identity
;
158 DeprecatedStringLiteralToCharPtr
= false;
159 ReferenceBinding
= false;
160 DirectBinding
= false;
165 /// getRank - Retrieve the rank of this standard conversion sequence
166 /// (C++ 13.3.3.1.1p3). The rank is the largest rank of each of the
167 /// implicit conversions.
168 ImplicitConversionRank
StandardConversionSequence::getRank() const {
169 ImplicitConversionRank Rank
= ICR_Exact_Match
;
170 if (GetConversionRank(First
) > Rank
)
171 Rank
= GetConversionRank(First
);
172 if (GetConversionRank(Second
) > Rank
)
173 Rank
= GetConversionRank(Second
);
174 if (GetConversionRank(Third
) > Rank
)
175 Rank
= GetConversionRank(Third
);
179 /// isPointerConversionToBool - Determines whether this conversion is
180 /// a conversion of a pointer or pointer-to-member to bool. This is
181 /// used as part of the ranking of standard conversion sequences
182 /// (C++ 13.3.3.2p4).
183 bool StandardConversionSequence::isPointerConversionToBool() const {
184 // Note that FromType has not necessarily been transformed by the
185 // array-to-pointer or function-to-pointer implicit conversions, so
186 // check for their presence as well as checking whether FromType is
188 if (getToType(1)->isBooleanType() &&
189 (getFromType()->isPointerType() ||
190 getFromType()->isObjCObjectPointerType() ||
191 getFromType()->isBlockPointerType() ||
192 First
== ICK_Array_To_Pointer
|| First
== ICK_Function_To_Pointer
))
198 /// isPointerConversionToVoidPointer - Determines whether this
199 /// conversion is a conversion of a pointer to a void pointer. This is
200 /// used as part of the ranking of standard conversion sequences (C++
203 StandardConversionSequence::
204 isPointerConversionToVoidPointer(ASTContext
& Context
) const {
205 QualType FromType
= getFromType();
206 QualType ToType
= getToType(1);
208 // Note that FromType has not necessarily been transformed by the
209 // array-to-pointer implicit conversion, so check for its presence
210 // and redo the conversion to get a pointer.
211 if (First
== ICK_Array_To_Pointer
)
212 FromType
= Context
.getArrayDecayedType(FromType
);
214 if (Second
== ICK_Pointer_Conversion
&& FromType
->isPointerType())
215 if (const PointerType
* ToPtrType
= ToType
->getAs
<PointerType
>())
216 return ToPtrType
->getPointeeType()->isVoidType();
221 /// DebugPrint - Print this standard conversion sequence to standard
222 /// error. Useful for debugging overloading issues.
223 void StandardConversionSequence::DebugPrint() const {
224 llvm::raw_ostream
&OS
= llvm::errs();
225 bool PrintedSomething
= false;
226 if (First
!= ICK_Identity
) {
227 OS
<< GetImplicitConversionName(First
);
228 PrintedSomething
= true;
231 if (Second
!= ICK_Identity
) {
232 if (PrintedSomething
) {
235 OS
<< GetImplicitConversionName(Second
);
237 if (CopyConstructor
) {
238 OS
<< " (by copy constructor)";
239 } else if (DirectBinding
) {
240 OS
<< " (direct reference binding)";
241 } else if (ReferenceBinding
) {
242 OS
<< " (reference binding)";
244 PrintedSomething
= true;
247 if (Third
!= ICK_Identity
) {
248 if (PrintedSomething
) {
251 OS
<< GetImplicitConversionName(Third
);
252 PrintedSomething
= true;
255 if (!PrintedSomething
) {
256 OS
<< "No conversions required";
260 /// DebugPrint - Print this user-defined conversion sequence to standard
261 /// error. Useful for debugging overloading issues.
262 void UserDefinedConversionSequence::DebugPrint() const {
263 llvm::raw_ostream
&OS
= llvm::errs();
264 if (Before
.First
|| Before
.Second
|| Before
.Third
) {
268 OS
<< '\'' << ConversionFunction
<< '\'';
269 if (After
.First
|| After
.Second
|| After
.Third
) {
275 /// DebugPrint - Print this implicit conversion sequence to standard
276 /// error. Useful for debugging overloading issues.
277 void ImplicitConversionSequence::DebugPrint() const {
278 llvm::raw_ostream
&OS
= llvm::errs();
279 switch (ConversionKind
) {
280 case StandardConversion
:
281 OS
<< "Standard conversion: ";
282 Standard
.DebugPrint();
284 case UserDefinedConversion
:
285 OS
<< "User-defined conversion: ";
286 UserDefined
.DebugPrint();
288 case EllipsisConversion
:
289 OS
<< "Ellipsis conversion";
291 case AmbiguousConversion
:
292 OS
<< "Ambiguous conversion";
295 OS
<< "Bad conversion";
302 void AmbiguousConversionSequence::construct() {
303 new (&conversions()) ConversionSet();
306 void AmbiguousConversionSequence::destruct() {
307 conversions().~ConversionSet();
311 AmbiguousConversionSequence::copyFrom(const AmbiguousConversionSequence
&O
) {
312 FromTypePtr
= O
.FromTypePtr
;
313 ToTypePtr
= O
.ToTypePtr
;
314 new (&conversions()) ConversionSet(O
.conversions());
318 // Structure used by OverloadCandidate::DeductionFailureInfo to store
319 // template parameter and template argument information.
320 struct DFIParamWithArguments
{
321 TemplateParameter Param
;
322 TemplateArgument FirstArg
;
323 TemplateArgument SecondArg
;
327 /// \brief Convert from Sema's representation of template deduction information
328 /// to the form used in overload-candidate information.
329 OverloadCandidate::DeductionFailureInfo
330 static MakeDeductionFailureInfo(ASTContext
&Context
,
331 Sema::TemplateDeductionResult TDK
,
332 TemplateDeductionInfo
&Info
) {
333 OverloadCandidate::DeductionFailureInfo Result
;
334 Result
.Result
= static_cast<unsigned>(TDK
);
337 case Sema::TDK_Success
:
338 case Sema::TDK_InstantiationDepth
:
339 case Sema::TDK_TooManyArguments
:
340 case Sema::TDK_TooFewArguments
:
343 case Sema::TDK_Incomplete
:
344 case Sema::TDK_InvalidExplicitArguments
:
345 Result
.Data
= Info
.Param
.getOpaqueValue();
348 case Sema::TDK_Inconsistent
:
349 case Sema::TDK_Underqualified
: {
350 // FIXME: Should allocate from normal heap so that we can free this later.
351 DFIParamWithArguments
*Saved
= new (Context
) DFIParamWithArguments
;
352 Saved
->Param
= Info
.Param
;
353 Saved
->FirstArg
= Info
.FirstArg
;
354 Saved
->SecondArg
= Info
.SecondArg
;
359 case Sema::TDK_SubstitutionFailure
:
360 Result
.Data
= Info
.take();
363 case Sema::TDK_NonDeducedMismatch
:
364 case Sema::TDK_FailedOverloadResolution
:
371 void OverloadCandidate::DeductionFailureInfo::Destroy() {
372 switch (static_cast<Sema::TemplateDeductionResult
>(Result
)) {
373 case Sema::TDK_Success
:
374 case Sema::TDK_InstantiationDepth
:
375 case Sema::TDK_Incomplete
:
376 case Sema::TDK_TooManyArguments
:
377 case Sema::TDK_TooFewArguments
:
378 case Sema::TDK_InvalidExplicitArguments
:
381 case Sema::TDK_Inconsistent
:
382 case Sema::TDK_Underqualified
:
383 // FIXME: Destroy the data?
387 case Sema::TDK_SubstitutionFailure
:
388 // FIXME: Destroy the template arugment list?
393 case Sema::TDK_NonDeducedMismatch
:
394 case Sema::TDK_FailedOverloadResolution
:
400 OverloadCandidate::DeductionFailureInfo::getTemplateParameter() {
401 switch (static_cast<Sema::TemplateDeductionResult
>(Result
)) {
402 case Sema::TDK_Success
:
403 case Sema::TDK_InstantiationDepth
:
404 case Sema::TDK_TooManyArguments
:
405 case Sema::TDK_TooFewArguments
:
406 case Sema::TDK_SubstitutionFailure
:
407 return TemplateParameter();
409 case Sema::TDK_Incomplete
:
410 case Sema::TDK_InvalidExplicitArguments
:
411 return TemplateParameter::getFromOpaqueValue(Data
);
413 case Sema::TDK_Inconsistent
:
414 case Sema::TDK_Underqualified
:
415 return static_cast<DFIParamWithArguments
*>(Data
)->Param
;
418 case Sema::TDK_NonDeducedMismatch
:
419 case Sema::TDK_FailedOverloadResolution
:
423 return TemplateParameter();
426 TemplateArgumentList
*
427 OverloadCandidate::DeductionFailureInfo::getTemplateArgumentList() {
428 switch (static_cast<Sema::TemplateDeductionResult
>(Result
)) {
429 case Sema::TDK_Success
:
430 case Sema::TDK_InstantiationDepth
:
431 case Sema::TDK_TooManyArguments
:
432 case Sema::TDK_TooFewArguments
:
433 case Sema::TDK_Incomplete
:
434 case Sema::TDK_InvalidExplicitArguments
:
435 case Sema::TDK_Inconsistent
:
436 case Sema::TDK_Underqualified
:
439 case Sema::TDK_SubstitutionFailure
:
440 return static_cast<TemplateArgumentList
*>(Data
);
443 case Sema::TDK_NonDeducedMismatch
:
444 case Sema::TDK_FailedOverloadResolution
:
451 const TemplateArgument
*OverloadCandidate::DeductionFailureInfo::getFirstArg() {
452 switch (static_cast<Sema::TemplateDeductionResult
>(Result
)) {
453 case Sema::TDK_Success
:
454 case Sema::TDK_InstantiationDepth
:
455 case Sema::TDK_Incomplete
:
456 case Sema::TDK_TooManyArguments
:
457 case Sema::TDK_TooFewArguments
:
458 case Sema::TDK_InvalidExplicitArguments
:
459 case Sema::TDK_SubstitutionFailure
:
462 case Sema::TDK_Inconsistent
:
463 case Sema::TDK_Underqualified
:
464 return &static_cast<DFIParamWithArguments
*>(Data
)->FirstArg
;
467 case Sema::TDK_NonDeducedMismatch
:
468 case Sema::TDK_FailedOverloadResolution
:
475 const TemplateArgument
*
476 OverloadCandidate::DeductionFailureInfo::getSecondArg() {
477 switch (static_cast<Sema::TemplateDeductionResult
>(Result
)) {
478 case Sema::TDK_Success
:
479 case Sema::TDK_InstantiationDepth
:
480 case Sema::TDK_Incomplete
:
481 case Sema::TDK_TooManyArguments
:
482 case Sema::TDK_TooFewArguments
:
483 case Sema::TDK_InvalidExplicitArguments
:
484 case Sema::TDK_SubstitutionFailure
:
487 case Sema::TDK_Inconsistent
:
488 case Sema::TDK_Underqualified
:
489 return &static_cast<DFIParamWithArguments
*>(Data
)->SecondArg
;
492 case Sema::TDK_NonDeducedMismatch
:
493 case Sema::TDK_FailedOverloadResolution
:
500 void OverloadCandidateSet::clear() {
505 // IsOverload - Determine whether the given New declaration is an
506 // overload of the declarations in Old. This routine returns false if
507 // New and Old cannot be overloaded, e.g., if New has the same
508 // signature as some function in Old (C++ 1.3.10) or if the Old
509 // declarations aren't functions (or function templates) at all. When
510 // it does return false, MatchedDecl will point to the decl that New
511 // cannot be overloaded with. This decl may be a UsingShadowDecl on
512 // top of the underlying declaration.
514 // Example: Given the following input:
516 // void f(int, float); // #1
517 // void f(int, int); // #2
518 // int f(int, int); // #3
520 // When we process #1, there is no previous declaration of "f",
521 // so IsOverload will not be used.
523 // When we process #2, Old contains only the FunctionDecl for #1. By
524 // comparing the parameter types, we see that #1 and #2 are overloaded
525 // (since they have different signatures), so this routine returns
526 // false; MatchedDecl is unchanged.
528 // When we process #3, Old is an overload set containing #1 and #2. We
529 // compare the signatures of #3 to #1 (they're overloaded, so we do
530 // nothing) and then #3 to #2. Since the signatures of #3 and #2 are
531 // identical (return types of functions are not part of the
532 // signature), IsOverload returns false and MatchedDecl will be set to
533 // point to the FunctionDecl for #2.
535 // 'NewIsUsingShadowDecl' indicates that 'New' is being introduced
536 // into a class by a using declaration. The rules for whether to hide
537 // shadow declarations ignore some properties which otherwise figure
538 // into a function template's signature.
540 Sema::CheckOverload(Scope
*S
, FunctionDecl
*New
, const LookupResult
&Old
,
541 NamedDecl
*&Match
, bool NewIsUsingDecl
) {
542 for (LookupResult::iterator I
= Old
.begin(), E
= Old
.end();
544 NamedDecl
*OldD
= *I
;
546 bool OldIsUsingDecl
= false;
547 if (isa
<UsingShadowDecl
>(OldD
)) {
548 OldIsUsingDecl
= true;
550 // We can always introduce two using declarations into the same
551 // context, even if they have identical signatures.
552 if (NewIsUsingDecl
) continue;
554 OldD
= cast
<UsingShadowDecl
>(OldD
)->getTargetDecl();
557 // If either declaration was introduced by a using declaration,
558 // we'll need to use slightly different rules for matching.
559 // Essentially, these rules are the normal rules, except that
560 // function templates hide function templates with different
561 // return types or template parameter lists.
562 bool UseMemberUsingDeclRules
=
563 (OldIsUsingDecl
|| NewIsUsingDecl
) && CurContext
->isRecord();
565 if (FunctionTemplateDecl
*OldT
= dyn_cast
<FunctionTemplateDecl
>(OldD
)) {
566 if (!IsOverload(New
, OldT
->getTemplatedDecl(), UseMemberUsingDeclRules
)) {
567 if (UseMemberUsingDeclRules
&& OldIsUsingDecl
) {
568 HideUsingShadowDecl(S
, cast
<UsingShadowDecl
>(*I
));
575 } else if (FunctionDecl
*OldF
= dyn_cast
<FunctionDecl
>(OldD
)) {
576 if (!IsOverload(New
, OldF
, UseMemberUsingDeclRules
)) {
577 if (UseMemberUsingDeclRules
&& OldIsUsingDecl
) {
578 HideUsingShadowDecl(S
, cast
<UsingShadowDecl
>(*I
));
585 } else if (isa
<UsingDecl
>(OldD
) || isa
<TagDecl
>(OldD
)) {
586 // We can overload with these, which can show up when doing
587 // redeclaration checks for UsingDecls.
588 assert(Old
.getLookupKind() == LookupUsingDeclName
);
589 } else if (isa
<UnresolvedUsingValueDecl
>(OldD
)) {
590 // Optimistically assume that an unresolved using decl will
591 // overload; if it doesn't, we'll have to diagnose during
592 // template instantiation.
595 // Only function declarations can be overloaded; object and type
596 // declarations cannot be overloaded.
598 return Ovl_NonFunction
;
605 bool Sema::IsOverload(FunctionDecl
*New
, FunctionDecl
*Old
,
606 bool UseUsingDeclRules
) {
607 // If both of the functions are extern "C", then they are not
609 if (Old
->isExternC() && New
->isExternC())
612 FunctionTemplateDecl
*OldTemplate
= Old
->getDescribedFunctionTemplate();
613 FunctionTemplateDecl
*NewTemplate
= New
->getDescribedFunctionTemplate();
616 // A function template can be overloaded with other function templates
617 // and with normal (non-template) functions.
618 if ((OldTemplate
== 0) != (NewTemplate
== 0))
621 // Is the function New an overload of the function Old?
622 QualType OldQType
= Context
.getCanonicalType(Old
->getType());
623 QualType NewQType
= Context
.getCanonicalType(New
->getType());
625 // Compare the signatures (C++ 1.3.10) of the two functions to
626 // determine whether they are overloads. If we find any mismatch
627 // in the signature, they are overloads.
629 // If either of these functions is a K&R-style function (no
630 // prototype), then we consider them to have matching signatures.
631 if (isa
<FunctionNoProtoType
>(OldQType
.getTypePtr()) ||
632 isa
<FunctionNoProtoType
>(NewQType
.getTypePtr()))
635 FunctionProtoType
* OldType
= cast
<FunctionProtoType
>(OldQType
);
636 FunctionProtoType
* NewType
= cast
<FunctionProtoType
>(NewQType
);
638 // The signature of a function includes the types of its
639 // parameters (C++ 1.3.10), which includes the presence or absence
640 // of the ellipsis; see C++ DR 357).
641 if (OldQType
!= NewQType
&&
642 (OldType
->getNumArgs() != NewType
->getNumArgs() ||
643 OldType
->isVariadic() != NewType
->isVariadic() ||
644 !FunctionArgTypesAreEqual(OldType
, NewType
)))
647 // C++ [temp.over.link]p4:
648 // The signature of a function template consists of its function
649 // signature, its return type and its template parameter list. The names
650 // of the template parameters are significant only for establishing the
651 // relationship between the template parameters and the rest of the
654 // We check the return type and template parameter lists for function
655 // templates first; the remaining checks follow.
657 // However, we don't consider either of these when deciding whether
658 // a member introduced by a shadow declaration is hidden.
659 if (!UseUsingDeclRules
&& NewTemplate
&&
660 (!TemplateParameterListsAreEqual(NewTemplate
->getTemplateParameters(),
661 OldTemplate
->getTemplateParameters(),
662 false, TPL_TemplateMatch
) ||
663 OldType
->getResultType() != NewType
->getResultType()))
666 // If the function is a class member, its signature includes the
667 // cv-qualifiers (if any) on the function itself.
669 // As part of this, also check whether one of the member functions
670 // is static, in which case they are not overloads (C++
671 // 13.1p2). While not part of the definition of the signature,
672 // this check is important to determine whether these functions
673 // can be overloaded.
674 CXXMethodDecl
* OldMethod
= dyn_cast
<CXXMethodDecl
>(Old
);
675 CXXMethodDecl
* NewMethod
= dyn_cast
<CXXMethodDecl
>(New
);
676 if (OldMethod
&& NewMethod
&&
677 !OldMethod
->isStatic() && !NewMethod
->isStatic() &&
678 OldMethod
->getTypeQualifiers() != NewMethod
->getTypeQualifiers())
681 // The signatures match; this is not an overload.
685 /// TryImplicitConversion - Attempt to perform an implicit conversion
686 /// from the given expression (Expr) to the given type (ToType). This
687 /// function returns an implicit conversion sequence that can be used
688 /// to perform the initialization. Given
691 /// void g(int i) { f(i); }
693 /// this routine would produce an implicit conversion sequence to
694 /// describe the initialization of f from i, which will be a standard
695 /// conversion sequence containing an lvalue-to-rvalue conversion (C++
696 /// 4.1) followed by a floating-integral conversion (C++ 4.9).
698 /// Note that this routine only determines how the conversion can be
699 /// performed; it does not actually perform the conversion. As such,
700 /// it will not produce any diagnostics if no conversion is available,
701 /// but will instead return an implicit conversion sequence of kind
704 /// If @p SuppressUserConversions, then user-defined conversions are
706 /// If @p AllowExplicit, then explicit user-defined conversions are
708 static ImplicitConversionSequence
709 TryImplicitConversion(Sema
&S
, Expr
*From
, QualType ToType
,
710 bool SuppressUserConversions
,
712 bool InOverloadResolution
) {
713 ImplicitConversionSequence ICS
;
714 if (IsStandardConversion(S
, From
, ToType
, InOverloadResolution
,
720 if (!S
.getLangOptions().CPlusPlus
) {
721 ICS
.setBad(BadConversionSequence::no_conversion
, From
, ToType
);
725 // C++ [over.ics.user]p4:
726 // A conversion of an expression of class type to the same class
727 // type is given Exact Match rank, and a conversion of an
728 // expression of class type to a base class of that type is
729 // given Conversion rank, in spite of the fact that a copy/move
730 // constructor (i.e., a user-defined conversion function) is
731 // called for those cases.
732 QualType FromType
= From
->getType();
733 if (ToType
->getAs
<RecordType
>() && FromType
->getAs
<RecordType
>() &&
734 (S
.Context
.hasSameUnqualifiedType(FromType
, ToType
) ||
735 S
.IsDerivedFrom(FromType
, ToType
))) {
737 ICS
.Standard
.setAsIdentityConversion();
738 ICS
.Standard
.setFromType(FromType
);
739 ICS
.Standard
.setAllToTypes(ToType
);
741 // We don't actually check at this point whether there is a valid
742 // copy/move constructor, since overloading just assumes that it
743 // exists. When we actually perform initialization, we'll find the
744 // appropriate constructor to copy the returned object, if needed.
745 ICS
.Standard
.CopyConstructor
= 0;
747 // Determine whether this is considered a derived-to-base conversion.
748 if (!S
.Context
.hasSameUnqualifiedType(FromType
, ToType
))
749 ICS
.Standard
.Second
= ICK_Derived_To_Base
;
754 if (SuppressUserConversions
) {
755 // We're not in the case above, so there is no conversion that
757 ICS
.setBad(BadConversionSequence::no_conversion
, From
, ToType
);
761 // Attempt user-defined conversion.
762 OverloadCandidateSet
Conversions(From
->getExprLoc());
763 OverloadingResult UserDefResult
764 = IsUserDefinedConversion(S
, From
, ToType
, ICS
.UserDefined
, Conversions
,
767 if (UserDefResult
== OR_Success
) {
768 ICS
.setUserDefined();
769 // C++ [over.ics.user]p4:
770 // A conversion of an expression of class type to the same class
771 // type is given Exact Match rank, and a conversion of an
772 // expression of class type to a base class of that type is
773 // given Conversion rank, in spite of the fact that a copy
774 // constructor (i.e., a user-defined conversion function) is
775 // called for those cases.
776 if (CXXConstructorDecl
*Constructor
777 = dyn_cast
<CXXConstructorDecl
>(ICS
.UserDefined
.ConversionFunction
)) {
779 = S
.Context
.getCanonicalType(From
->getType().getUnqualifiedType());
781 = S
.Context
.getCanonicalType(ToType
).getUnqualifiedType();
782 if (Constructor
->isCopyConstructor() &&
783 (FromCanon
== ToCanon
|| S
.IsDerivedFrom(FromCanon
, ToCanon
))) {
784 // Turn this into a "standard" conversion sequence, so that it
785 // gets ranked with standard conversion sequences.
787 ICS
.Standard
.setAsIdentityConversion();
788 ICS
.Standard
.setFromType(From
->getType());
789 ICS
.Standard
.setAllToTypes(ToType
);
790 ICS
.Standard
.CopyConstructor
= Constructor
;
791 if (ToCanon
!= FromCanon
)
792 ICS
.Standard
.Second
= ICK_Derived_To_Base
;
796 // C++ [over.best.ics]p4:
797 // However, when considering the argument of a user-defined
798 // conversion function that is a candidate by 13.3.1.3 when
799 // invoked for the copying of the temporary in the second step
800 // of a class copy-initialization, or by 13.3.1.4, 13.3.1.5, or
801 // 13.3.1.6 in all cases, only standard conversion sequences and
802 // ellipsis conversion sequences are allowed.
803 if (SuppressUserConversions
&& ICS
.isUserDefined()) {
804 ICS
.setBad(BadConversionSequence::suppressed_user
, From
, ToType
);
806 } else if (UserDefResult
== OR_Ambiguous
&& !SuppressUserConversions
) {
808 ICS
.Ambiguous
.setFromType(From
->getType());
809 ICS
.Ambiguous
.setToType(ToType
);
810 for (OverloadCandidateSet::iterator Cand
= Conversions
.begin();
811 Cand
!= Conversions
.end(); ++Cand
)
813 ICS
.Ambiguous
.addConversion(Cand
->Function
);
815 ICS
.setBad(BadConversionSequence::no_conversion
, From
, ToType
);
821 bool Sema::TryImplicitConversion(InitializationSequence
&Sequence
,
822 const InitializedEntity
&Entity
,
824 bool SuppressUserConversions
,
825 bool AllowExplicitConversions
,
826 bool InOverloadResolution
) {
827 ImplicitConversionSequence ICS
828 = clang::TryImplicitConversion(*this, Initializer
, Entity
.getType(),
829 SuppressUserConversions
,
830 AllowExplicitConversions
,
831 InOverloadResolution
);
832 if (ICS
.isBad()) return true;
834 // Perform the actual conversion.
835 Sequence
.AddConversionSequenceStep(ICS
, Entity
.getType());
839 /// PerformImplicitConversion - Perform an implicit conversion of the
840 /// expression From to the type ToType. Returns true if there was an
841 /// error, false otherwise. The expression From is replaced with the
842 /// converted expression. Flavor is the kind of conversion we're
843 /// performing, used in the error message. If @p AllowExplicit,
844 /// explicit user-defined conversions are permitted.
846 Sema::PerformImplicitConversion(Expr
*&From
, QualType ToType
,
847 AssignmentAction Action
, bool AllowExplicit
) {
848 ImplicitConversionSequence ICS
;
849 return PerformImplicitConversion(From
, ToType
, Action
, AllowExplicit
, ICS
);
853 Sema::PerformImplicitConversion(Expr
*&From
, QualType ToType
,
854 AssignmentAction Action
, bool AllowExplicit
,
855 ImplicitConversionSequence
& ICS
) {
856 ICS
= clang::TryImplicitConversion(*this, From
, ToType
,
857 /*SuppressUserConversions=*/false,
859 /*InOverloadResolution=*/false);
860 return PerformImplicitConversion(From
, ToType
, ICS
, Action
);
863 /// \brief Determine whether the conversion from FromType to ToType is a valid
864 /// conversion that strips "noreturn" off the nested function type.
865 static bool IsNoReturnConversion(ASTContext
&Context
, QualType FromType
,
866 QualType ToType
, QualType
&ResultTy
) {
867 if (Context
.hasSameUnqualifiedType(FromType
, ToType
))
870 // Strip the noreturn off the type we're converting from; noreturn can
871 // safely be removed.
872 FromType
= Context
.getNoReturnType(FromType
, false);
873 if (!Context
.hasSameUnqualifiedType(FromType
, ToType
))
880 /// \brief Determine whether the conversion from FromType to ToType is a valid
881 /// vector conversion.
883 /// \param ICK Will be set to the vector conversion kind, if this is a vector
885 static bool IsVectorConversion(ASTContext
&Context
, QualType FromType
,
886 QualType ToType
, ImplicitConversionKind
&ICK
) {
887 // We need at least one of these types to be a vector type to have a vector
889 if (!ToType
->isVectorType() && !FromType
->isVectorType())
892 // Identical types require no conversions.
893 if (Context
.hasSameUnqualifiedType(FromType
, ToType
))
896 // There are no conversions between extended vector types, only identity.
897 if (ToType
->isExtVectorType()) {
898 // There are no conversions between extended vector types other than the
899 // identity conversion.
900 if (FromType
->isExtVectorType())
903 // Vector splat from any arithmetic type to a vector.
904 if (FromType
->isArithmeticType()) {
905 ICK
= ICK_Vector_Splat
;
910 // We can perform the conversion between vector types in the following cases:
911 // 1)vector types are equivalent AltiVec and GCC vector types
912 // 2)lax vector conversions are permitted and the vector types are of the
914 if (ToType
->isVectorType() && FromType
->isVectorType()) {
915 if (Context
.areCompatibleVectorTypes(FromType
, ToType
) ||
916 (Context
.getLangOptions().LaxVectorConversions
&&
917 (Context
.getTypeSize(FromType
) == Context
.getTypeSize(ToType
)))) {
918 ICK
= ICK_Vector_Conversion
;
926 /// IsStandardConversion - Determines whether there is a standard
927 /// conversion sequence (C++ [conv], C++ [over.ics.scs]) from the
928 /// expression From to the type ToType. Standard conversion sequences
929 /// only consider non-class types; for conversions that involve class
930 /// types, use TryImplicitConversion. If a conversion exists, SCS will
931 /// contain the standard conversion sequence required to perform this
932 /// conversion and this routine will return true. Otherwise, this
933 /// routine will return false and the value of SCS is unspecified.
934 static bool IsStandardConversion(Sema
&S
, Expr
* From
, QualType ToType
,
935 bool InOverloadResolution
,
936 StandardConversionSequence
&SCS
) {
937 QualType FromType
= From
->getType();
939 // Standard conversions (C++ [conv])
940 SCS
.setAsIdentityConversion();
941 SCS
.DeprecatedStringLiteralToCharPtr
= false;
942 SCS
.IncompatibleObjC
= false;
943 SCS
.setFromType(FromType
);
944 SCS
.CopyConstructor
= 0;
946 // There are no standard conversions for class types in C++, so
947 // abort early. When overloading in C, however, we do permit
948 if (FromType
->isRecordType() || ToType
->isRecordType()) {
949 if (S
.getLangOptions().CPlusPlus
)
952 // When we're overloading in C, we allow, as standard conversions,
955 // The first conversion can be an lvalue-to-rvalue conversion,
956 // array-to-pointer conversion, or function-to-pointer conversion
959 if (FromType
== S
.Context
.OverloadTy
) {
960 DeclAccessPair AccessPair
;
962 = S
.ResolveAddressOfOverloadedFunction(From
, ToType
, false,
964 // We were able to resolve the address of the overloaded function,
965 // so we can convert to the type of that function.
966 FromType
= Fn
->getType();
967 if (CXXMethodDecl
*Method
= dyn_cast
<CXXMethodDecl
>(Fn
)) {
968 if (!Method
->isStatic()) {
970 = S
.Context
.getTypeDeclType(Method
->getParent()).getTypePtr();
971 FromType
= S
.Context
.getMemberPointerType(FromType
, ClassType
);
975 // If the "from" expression takes the address of the overloaded
976 // function, update the type of the resulting expression accordingly.
977 if (FromType
->getAs
<FunctionType
>())
978 if (UnaryOperator
*UnOp
= dyn_cast
<UnaryOperator
>(From
->IgnoreParens()))
979 if (UnOp
->getOpcode() == UO_AddrOf
)
980 FromType
= S
.Context
.getPointerType(FromType
);
982 // Check that we've computed the proper type after overload resolution.
983 assert(S
.Context
.hasSameType(FromType
,
984 S
.FixOverloadedFunctionReference(From
, AccessPair
, Fn
)->getType()));
989 // Lvalue-to-rvalue conversion (C++ 4.1):
990 // An lvalue (3.10) of a non-function, non-array type T can be
991 // converted to an rvalue.
992 Expr::isLvalueResult argIsLvalue
= From
->isLvalue(S
.Context
);
993 if (argIsLvalue
== Expr::LV_Valid
&&
994 !FromType
->isFunctionType() && !FromType
->isArrayType() &&
995 S
.Context
.getCanonicalType(FromType
) != S
.Context
.OverloadTy
) {
996 SCS
.First
= ICK_Lvalue_To_Rvalue
;
998 // If T is a non-class type, the type of the rvalue is the
999 // cv-unqualified version of T. Otherwise, the type of the rvalue
1000 // is T (C++ 4.1p1). C++ can't get here with class types; in C, we
1001 // just strip the qualifiers because they don't matter.
1002 FromType
= FromType
.getUnqualifiedType();
1003 } else if (FromType
->isArrayType()) {
1004 // Array-to-pointer conversion (C++ 4.2)
1005 SCS
.First
= ICK_Array_To_Pointer
;
1007 // An lvalue or rvalue of type "array of N T" or "array of unknown
1008 // bound of T" can be converted to an rvalue of type "pointer to
1010 FromType
= S
.Context
.getArrayDecayedType(FromType
);
1012 if (S
.IsStringLiteralToNonConstPointerConversion(From
, ToType
)) {
1013 // This conversion is deprecated. (C++ D.4).
1014 SCS
.DeprecatedStringLiteralToCharPtr
= true;
1016 // For the purpose of ranking in overload resolution
1017 // (13.3.3.1.1), this conversion is considered an
1018 // array-to-pointer conversion followed by a qualification
1019 // conversion (4.4). (C++ 4.2p2)
1020 SCS
.Second
= ICK_Identity
;
1021 SCS
.Third
= ICK_Qualification
;
1022 SCS
.setAllToTypes(FromType
);
1025 } else if (FromType
->isFunctionType() && argIsLvalue
== Expr::LV_Valid
) {
1026 // Function-to-pointer conversion (C++ 4.3).
1027 SCS
.First
= ICK_Function_To_Pointer
;
1029 // An lvalue of function type T can be converted to an rvalue of
1030 // type "pointer to T." The result is a pointer to the
1031 // function. (C++ 4.3p1).
1032 FromType
= S
.Context
.getPointerType(FromType
);
1034 // We don't require any conversions for the first step.
1035 SCS
.First
= ICK_Identity
;
1037 SCS
.setToType(0, FromType
);
1039 // The second conversion can be an integral promotion, floating
1040 // point promotion, integral conversion, floating point conversion,
1041 // floating-integral conversion, pointer conversion,
1042 // pointer-to-member conversion, or boolean conversion (C++ 4p1).
1043 // For overloading in C, this can also be a "compatible-type"
1045 bool IncompatibleObjC
= false;
1046 ImplicitConversionKind SecondICK
= ICK_Identity
;
1047 if (S
.Context
.hasSameUnqualifiedType(FromType
, ToType
)) {
1048 // The unqualified versions of the types are the same: there's no
1049 // conversion to do.
1050 SCS
.Second
= ICK_Identity
;
1051 } else if (S
.IsIntegralPromotion(From
, FromType
, ToType
)) {
1052 // Integral promotion (C++ 4.5).
1053 SCS
.Second
= ICK_Integral_Promotion
;
1054 FromType
= ToType
.getUnqualifiedType();
1055 } else if (S
.IsFloatingPointPromotion(FromType
, ToType
)) {
1056 // Floating point promotion (C++ 4.6).
1057 SCS
.Second
= ICK_Floating_Promotion
;
1058 FromType
= ToType
.getUnqualifiedType();
1059 } else if (S
.IsComplexPromotion(FromType
, ToType
)) {
1060 // Complex promotion (Clang extension)
1061 SCS
.Second
= ICK_Complex_Promotion
;
1062 FromType
= ToType
.getUnqualifiedType();
1063 } else if (FromType
->isIntegralOrEnumerationType() &&
1064 ToType
->isIntegralType(S
.Context
)) {
1065 // Integral conversions (C++ 4.7).
1066 SCS
.Second
= ICK_Integral_Conversion
;
1067 FromType
= ToType
.getUnqualifiedType();
1068 } else if (FromType
->isComplexType() && ToType
->isComplexType()) {
1069 // Complex conversions (C99 6.3.1.6)
1070 SCS
.Second
= ICK_Complex_Conversion
;
1071 FromType
= ToType
.getUnqualifiedType();
1072 } else if ((FromType
->isComplexType() && ToType
->isArithmeticType()) ||
1073 (ToType
->isComplexType() && FromType
->isArithmeticType())) {
1074 // Complex-real conversions (C99 6.3.1.7)
1075 SCS
.Second
= ICK_Complex_Real
;
1076 FromType
= ToType
.getUnqualifiedType();
1077 } else if (FromType
->isRealFloatingType() && ToType
->isRealFloatingType()) {
1078 // Floating point conversions (C++ 4.8).
1079 SCS
.Second
= ICK_Floating_Conversion
;
1080 FromType
= ToType
.getUnqualifiedType();
1081 } else if ((FromType
->isRealFloatingType() &&
1082 ToType
->isIntegralType(S
.Context
) && !ToType
->isBooleanType()) ||
1083 (FromType
->isIntegralOrEnumerationType() &&
1084 ToType
->isRealFloatingType())) {
1085 // Floating-integral conversions (C++ 4.9).
1086 SCS
.Second
= ICK_Floating_Integral
;
1087 FromType
= ToType
.getUnqualifiedType();
1088 } else if (S
.IsPointerConversion(From
, FromType
, ToType
, InOverloadResolution
,
1089 FromType
, IncompatibleObjC
)) {
1090 // Pointer conversions (C++ 4.10).
1091 SCS
.Second
= ICK_Pointer_Conversion
;
1092 SCS
.IncompatibleObjC
= IncompatibleObjC
;
1093 } else if (S
.IsMemberPointerConversion(From
, FromType
, ToType
,
1094 InOverloadResolution
, FromType
)) {
1095 // Pointer to member conversions (4.11).
1096 SCS
.Second
= ICK_Pointer_Member
;
1097 } else if (ToType
->isBooleanType() &&
1098 (FromType
->isArithmeticType() ||
1099 FromType
->isEnumeralType() ||
1100 FromType
->isAnyPointerType() ||
1101 FromType
->isBlockPointerType() ||
1102 FromType
->isMemberPointerType() ||
1103 FromType
->isNullPtrType())) {
1104 // Boolean conversions (C++ 4.12).
1105 SCS
.Second
= ICK_Boolean_Conversion
;
1106 FromType
= S
.Context
.BoolTy
;
1107 } else if (IsVectorConversion(S
.Context
, FromType
, ToType
, SecondICK
)) {
1108 SCS
.Second
= SecondICK
;
1109 FromType
= ToType
.getUnqualifiedType();
1110 } else if (!S
.getLangOptions().CPlusPlus
&&
1111 S
.Context
.typesAreCompatible(ToType
, FromType
)) {
1112 // Compatible conversions (Clang extension for C function overloading)
1113 SCS
.Second
= ICK_Compatible_Conversion
;
1114 FromType
= ToType
.getUnqualifiedType();
1115 } else if (IsNoReturnConversion(S
.Context
, FromType
, ToType
, FromType
)) {
1116 // Treat a conversion that strips "noreturn" as an identity conversion.
1117 SCS
.Second
= ICK_NoReturn_Adjustment
;
1119 // No second conversion required.
1120 SCS
.Second
= ICK_Identity
;
1122 SCS
.setToType(1, FromType
);
1126 // The third conversion can be a qualification conversion (C++ 4p1).
1127 if (S
.IsQualificationConversion(FromType
, ToType
)) {
1128 SCS
.Third
= ICK_Qualification
;
1130 CanonFrom
= S
.Context
.getCanonicalType(FromType
);
1131 CanonTo
= S
.Context
.getCanonicalType(ToType
);
1133 // No conversion required
1134 SCS
.Third
= ICK_Identity
;
1136 // C++ [over.best.ics]p6:
1137 // [...] Any difference in top-level cv-qualification is
1138 // subsumed by the initialization itself and does not constitute
1139 // a conversion. [...]
1140 CanonFrom
= S
.Context
.getCanonicalType(FromType
);
1141 CanonTo
= S
.Context
.getCanonicalType(ToType
);
1142 if (CanonFrom
.getLocalUnqualifiedType()
1143 == CanonTo
.getLocalUnqualifiedType() &&
1144 (CanonFrom
.getLocalCVRQualifiers() != CanonTo
.getLocalCVRQualifiers()
1145 || CanonFrom
.getObjCGCAttr() != CanonTo
.getObjCGCAttr())) {
1147 CanonFrom
= CanonTo
;
1150 SCS
.setToType(2, FromType
);
1152 // If we have not converted the argument type to the parameter type,
1153 // this is a bad conversion sequence.
1154 if (CanonFrom
!= CanonTo
)
1160 /// IsIntegralPromotion - Determines whether the conversion from the
1161 /// expression From (whose potentially-adjusted type is FromType) to
1162 /// ToType is an integral promotion (C++ 4.5). If so, returns true and
1163 /// sets PromotedType to the promoted type.
1164 bool Sema::IsIntegralPromotion(Expr
*From
, QualType FromType
, QualType ToType
) {
1165 const BuiltinType
*To
= ToType
->getAs
<BuiltinType
>();
1166 // All integers are built-in.
1171 // An rvalue of type char, signed char, unsigned char, short int, or
1172 // unsigned short int can be converted to an rvalue of type int if
1173 // int can represent all the values of the source type; otherwise,
1174 // the source rvalue can be converted to an rvalue of type unsigned
1176 if (FromType
->isPromotableIntegerType() && !FromType
->isBooleanType() &&
1177 !FromType
->isEnumeralType()) {
1178 if (// We can promote any signed, promotable integer type to an int
1179 (FromType
->isSignedIntegerType() ||
1180 // We can promote any unsigned integer type whose size is
1181 // less than int to an int.
1182 (!FromType
->isSignedIntegerType() &&
1183 Context
.getTypeSize(FromType
) < Context
.getTypeSize(ToType
)))) {
1184 return To
->getKind() == BuiltinType::Int
;
1187 return To
->getKind() == BuiltinType::UInt
;
1190 // An rvalue of type wchar_t (3.9.1) or an enumeration type (7.2)
1191 // can be converted to an rvalue of the first of the following types
1192 // that can represent all the values of its underlying type: int,
1193 // unsigned int, long, or unsigned long (C++ 4.5p2).
1195 // We pre-calculate the promotion type for enum types.
1196 if (const EnumType
*FromEnumType
= FromType
->getAs
<EnumType
>())
1197 if (ToType
->isIntegerType())
1198 return Context
.hasSameUnqualifiedType(ToType
,
1199 FromEnumType
->getDecl()->getPromotionType());
1201 if (FromType
->isWideCharType() && ToType
->isIntegerType()) {
1202 // Determine whether the type we're converting from is signed or
1205 uint64_t FromSize
= Context
.getTypeSize(FromType
);
1207 // FIXME: Is wchar_t signed or unsigned? We assume it's signed for now.
1208 FromIsSigned
= true;
1210 // The types we'll try to promote to, in the appropriate
1211 // order. Try each of these types.
1212 QualType PromoteTypes
[6] = {
1213 Context
.IntTy
, Context
.UnsignedIntTy
,
1214 Context
.LongTy
, Context
.UnsignedLongTy
,
1215 Context
.LongLongTy
, Context
.UnsignedLongLongTy
1217 for (int Idx
= 0; Idx
< 6; ++Idx
) {
1218 uint64_t ToSize
= Context
.getTypeSize(PromoteTypes
[Idx
]);
1219 if (FromSize
< ToSize
||
1220 (FromSize
== ToSize
&&
1221 FromIsSigned
== PromoteTypes
[Idx
]->isSignedIntegerType())) {
1222 // We found the type that we can promote to. If this is the
1223 // type we wanted, we have a promotion. Otherwise, no
1225 return Context
.hasSameUnqualifiedType(ToType
, PromoteTypes
[Idx
]);
1230 // An rvalue for an integral bit-field (9.6) can be converted to an
1231 // rvalue of type int if int can represent all the values of the
1232 // bit-field; otherwise, it can be converted to unsigned int if
1233 // unsigned int can represent all the values of the bit-field. If
1234 // the bit-field is larger yet, no integral promotion applies to
1235 // it. If the bit-field has an enumerated type, it is treated as any
1236 // other value of that type for promotion purposes (C++ 4.5p3).
1237 // FIXME: We should delay checking of bit-fields until we actually perform the
1241 if (FieldDecl
*MemberDecl
= From
->getBitField()) {
1243 if (FromType
->isIntegralType(Context
) &&
1244 MemberDecl
->getBitWidth()->isIntegerConstantExpr(BitWidth
, Context
)) {
1245 APSInt
ToSize(BitWidth
.getBitWidth(), BitWidth
.isUnsigned());
1246 ToSize
= Context
.getTypeSize(ToType
);
1248 // Are we promoting to an int from a bitfield that fits in an int?
1249 if (BitWidth
< ToSize
||
1250 (FromType
->isSignedIntegerType() && BitWidth
<= ToSize
)) {
1251 return To
->getKind() == BuiltinType::Int
;
1254 // Are we promoting to an unsigned int from an unsigned bitfield
1255 // that fits into an unsigned int?
1256 if (FromType
->isUnsignedIntegerType() && BitWidth
<= ToSize
) {
1257 return To
->getKind() == BuiltinType::UInt
;
1264 // An rvalue of type bool can be converted to an rvalue of type int,
1265 // with false becoming zero and true becoming one (C++ 4.5p4).
1266 if (FromType
->isBooleanType() && To
->getKind() == BuiltinType::Int
) {
1273 /// IsFloatingPointPromotion - Determines whether the conversion from
1274 /// FromType to ToType is a floating point promotion (C++ 4.6). If so,
1275 /// returns true and sets PromotedType to the promoted type.
1276 bool Sema::IsFloatingPointPromotion(QualType FromType
, QualType ToType
) {
1277 /// An rvalue of type float can be converted to an rvalue of type
1278 /// double. (C++ 4.6p1).
1279 if (const BuiltinType
*FromBuiltin
= FromType
->getAs
<BuiltinType
>())
1280 if (const BuiltinType
*ToBuiltin
= ToType
->getAs
<BuiltinType
>()) {
1281 if (FromBuiltin
->getKind() == BuiltinType::Float
&&
1282 ToBuiltin
->getKind() == BuiltinType::Double
)
1286 // When a float is promoted to double or long double, or a
1287 // double is promoted to long double [...].
1288 if (!getLangOptions().CPlusPlus
&&
1289 (FromBuiltin
->getKind() == BuiltinType::Float
||
1290 FromBuiltin
->getKind() == BuiltinType::Double
) &&
1291 (ToBuiltin
->getKind() == BuiltinType::LongDouble
))
1298 /// \brief Determine if a conversion is a complex promotion.
1300 /// A complex promotion is defined as a complex -> complex conversion
1301 /// where the conversion between the underlying real types is a
1302 /// floating-point or integral promotion.
1303 bool Sema::IsComplexPromotion(QualType FromType
, QualType ToType
) {
1304 const ComplexType
*FromComplex
= FromType
->getAs
<ComplexType
>();
1308 const ComplexType
*ToComplex
= ToType
->getAs
<ComplexType
>();
1312 return IsFloatingPointPromotion(FromComplex
->getElementType(),
1313 ToComplex
->getElementType()) ||
1314 IsIntegralPromotion(0, FromComplex
->getElementType(),
1315 ToComplex
->getElementType());
1318 /// BuildSimilarlyQualifiedPointerType - In a pointer conversion from
1319 /// the pointer type FromPtr to a pointer to type ToPointee, with the
1320 /// same type qualifiers as FromPtr has on its pointee type. ToType,
1321 /// if non-empty, will be a pointer to ToType that may or may not have
1322 /// the right set of qualifiers on its pointee.
1324 BuildSimilarlyQualifiedPointerType(const PointerType
*FromPtr
,
1325 QualType ToPointee
, QualType ToType
,
1326 ASTContext
&Context
) {
1327 QualType CanonFromPointee
= Context
.getCanonicalType(FromPtr
->getPointeeType());
1328 QualType CanonToPointee
= Context
.getCanonicalType(ToPointee
);
1329 Qualifiers Quals
= CanonFromPointee
.getQualifiers();
1331 // Exact qualifier match -> return the pointer type we're converting to.
1332 if (CanonToPointee
.getLocalQualifiers() == Quals
) {
1333 // ToType is exactly what we need. Return it.
1334 if (!ToType
.isNull())
1335 return ToType
.getUnqualifiedType();
1337 // Build a pointer to ToPointee. It has the right qualifiers
1339 return Context
.getPointerType(ToPointee
);
1342 // Just build a canonical type that has the right qualifiers.
1343 return Context
.getPointerType(
1344 Context
.getQualifiedType(CanonToPointee
.getLocalUnqualifiedType(),
1348 /// BuildSimilarlyQualifiedObjCObjectPointerType - In a pointer conversion from
1349 /// the FromType, which is an objective-c pointer, to ToType, which may or may
1350 /// not have the right set of qualifiers.
1352 BuildSimilarlyQualifiedObjCObjectPointerType(QualType FromType
,
1354 ASTContext
&Context
) {
1355 QualType CanonFromType
= Context
.getCanonicalType(FromType
);
1356 QualType CanonToType
= Context
.getCanonicalType(ToType
);
1357 Qualifiers Quals
= CanonFromType
.getQualifiers();
1359 // Exact qualifier match -> return the pointer type we're converting to.
1360 if (CanonToType
.getLocalQualifiers() == Quals
)
1363 // Just build a canonical type that has the right qualifiers.
1364 return Context
.getQualifiedType(CanonToType
.getLocalUnqualifiedType(), Quals
);
1367 static bool isNullPointerConstantForConversion(Expr
*Expr
,
1368 bool InOverloadResolution
,
1369 ASTContext
&Context
) {
1370 // Handle value-dependent integral null pointer constants correctly.
1371 // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#903
1372 if (Expr
->isValueDependent() && !Expr
->isTypeDependent() &&
1373 Expr
->getType()->isIntegerType() && !Expr
->getType()->isEnumeralType())
1374 return !InOverloadResolution
;
1376 return Expr
->isNullPointerConstant(Context
,
1377 InOverloadResolution
? Expr::NPC_ValueDependentIsNotNull
1378 : Expr::NPC_ValueDependentIsNull
);
1381 /// IsPointerConversion - Determines whether the conversion of the
1382 /// expression From, which has the (possibly adjusted) type FromType,
1383 /// can be converted to the type ToType via a pointer conversion (C++
1384 /// 4.10). If so, returns true and places the converted type (that
1385 /// might differ from ToType in its cv-qualifiers at some level) into
1388 /// This routine also supports conversions to and from block pointers
1389 /// and conversions with Objective-C's 'id', 'id<protocols...>', and
1390 /// pointers to interfaces. FIXME: Once we've determined the
1391 /// appropriate overloading rules for Objective-C, we may want to
1392 /// split the Objective-C checks into a different routine; however,
1393 /// GCC seems to consider all of these conversions to be pointer
1394 /// conversions, so for now they live here. IncompatibleObjC will be
1395 /// set if the conversion is an allowed Objective-C conversion that
1396 /// should result in a warning.
1397 bool Sema::IsPointerConversion(Expr
*From
, QualType FromType
, QualType ToType
,
1398 bool InOverloadResolution
,
1399 QualType
& ConvertedType
,
1400 bool &IncompatibleObjC
) {
1401 IncompatibleObjC
= false;
1402 if (isObjCPointerConversion(FromType
, ToType
, ConvertedType
, IncompatibleObjC
))
1405 // Conversion from a null pointer constant to any Objective-C pointer type.
1406 if (ToType
->isObjCObjectPointerType() &&
1407 isNullPointerConstantForConversion(From
, InOverloadResolution
, Context
)) {
1408 ConvertedType
= ToType
;
1412 // Blocks: Block pointers can be converted to void*.
1413 if (FromType
->isBlockPointerType() && ToType
->isPointerType() &&
1414 ToType
->getAs
<PointerType
>()->getPointeeType()->isVoidType()) {
1415 ConvertedType
= ToType
;
1418 // Blocks: A null pointer constant can be converted to a block
1420 if (ToType
->isBlockPointerType() &&
1421 isNullPointerConstantForConversion(From
, InOverloadResolution
, Context
)) {
1422 ConvertedType
= ToType
;
1426 // If the left-hand-side is nullptr_t, the right side can be a null
1427 // pointer constant.
1428 if (ToType
->isNullPtrType() &&
1429 isNullPointerConstantForConversion(From
, InOverloadResolution
, Context
)) {
1430 ConvertedType
= ToType
;
1434 const PointerType
* ToTypePtr
= ToType
->getAs
<PointerType
>();
1438 // A null pointer constant can be converted to a pointer type (C++ 4.10p1).
1439 if (isNullPointerConstantForConversion(From
, InOverloadResolution
, Context
)) {
1440 ConvertedType
= ToType
;
1444 // Beyond this point, both types need to be pointers
1445 // , including objective-c pointers.
1446 QualType ToPointeeType
= ToTypePtr
->getPointeeType();
1447 if (FromType
->isObjCObjectPointerType() && ToPointeeType
->isVoidType()) {
1448 ConvertedType
= BuildSimilarlyQualifiedObjCObjectPointerType(FromType
,
1453 const PointerType
*FromTypePtr
= FromType
->getAs
<PointerType
>();
1457 QualType FromPointeeType
= FromTypePtr
->getPointeeType();
1459 // If the unqualified pointee types are the same, this can't be a
1460 // pointer conversion, so don't do all of the work below.
1461 if (Context
.hasSameUnqualifiedType(FromPointeeType
, ToPointeeType
))
1464 // An rvalue of type "pointer to cv T," where T is an object type,
1465 // can be converted to an rvalue of type "pointer to cv void" (C++
1467 if (FromPointeeType
->isIncompleteOrObjectType() &&
1468 ToPointeeType
->isVoidType()) {
1469 ConvertedType
= BuildSimilarlyQualifiedPointerType(FromTypePtr
,
1475 // When we're overloading in C, we allow a special kind of pointer
1476 // conversion for compatible-but-not-identical pointee types.
1477 if (!getLangOptions().CPlusPlus
&&
1478 Context
.typesAreCompatible(FromPointeeType
, ToPointeeType
)) {
1479 ConvertedType
= BuildSimilarlyQualifiedPointerType(FromTypePtr
,
1485 // C++ [conv.ptr]p3:
1487 // An rvalue of type "pointer to cv D," where D is a class type,
1488 // can be converted to an rvalue of type "pointer to cv B," where
1489 // B is a base class (clause 10) of D. If B is an inaccessible
1490 // (clause 11) or ambiguous (10.2) base class of D, a program that
1491 // necessitates this conversion is ill-formed. The result of the
1492 // conversion is a pointer to the base class sub-object of the
1493 // derived class object. The null pointer value is converted to
1494 // the null pointer value of the destination type.
1496 // Note that we do not check for ambiguity or inaccessibility
1497 // here. That is handled by CheckPointerConversion.
1498 if (getLangOptions().CPlusPlus
&&
1499 FromPointeeType
->isRecordType() && ToPointeeType
->isRecordType() &&
1500 !Context
.hasSameUnqualifiedType(FromPointeeType
, ToPointeeType
) &&
1501 !RequireCompleteType(From
->getLocStart(), FromPointeeType
, PDiag()) &&
1502 IsDerivedFrom(FromPointeeType
, ToPointeeType
)) {
1503 ConvertedType
= BuildSimilarlyQualifiedPointerType(FromTypePtr
,
1512 /// isObjCPointerConversion - Determines whether this is an
1513 /// Objective-C pointer conversion. Subroutine of IsPointerConversion,
1514 /// with the same arguments and return values.
1515 bool Sema::isObjCPointerConversion(QualType FromType
, QualType ToType
,
1516 QualType
& ConvertedType
,
1517 bool &IncompatibleObjC
) {
1518 if (!getLangOptions().ObjC1
)
1521 // First, we handle all conversions on ObjC object pointer types.
1522 const ObjCObjectPointerType
* ToObjCPtr
= ToType
->getAs
<ObjCObjectPointerType
>();
1523 const ObjCObjectPointerType
*FromObjCPtr
=
1524 FromType
->getAs
<ObjCObjectPointerType
>();
1526 if (ToObjCPtr
&& FromObjCPtr
) {
1527 // Objective C++: We're able to convert between "id" or "Class" and a
1528 // pointer to any interface (in both directions).
1529 if (ToObjCPtr
->isObjCBuiltinType() && FromObjCPtr
->isObjCBuiltinType()) {
1530 ConvertedType
= ToType
;
1533 // Conversions with Objective-C's id<...>.
1534 if ((FromObjCPtr
->isObjCQualifiedIdType() ||
1535 ToObjCPtr
->isObjCQualifiedIdType()) &&
1536 Context
.ObjCQualifiedIdTypesAreCompatible(ToType
, FromType
,
1537 /*compare=*/false)) {
1538 ConvertedType
= ToType
;
1541 // Objective C++: We're able to convert from a pointer to an
1542 // interface to a pointer to a different interface.
1543 if (Context
.canAssignObjCInterfaces(ToObjCPtr
, FromObjCPtr
)) {
1544 const ObjCInterfaceType
* LHS
= ToObjCPtr
->getInterfaceType();
1545 const ObjCInterfaceType
* RHS
= FromObjCPtr
->getInterfaceType();
1546 if (getLangOptions().CPlusPlus
&& LHS
&& RHS
&&
1547 !ToObjCPtr
->getPointeeType().isAtLeastAsQualifiedAs(
1548 FromObjCPtr
->getPointeeType()))
1550 ConvertedType
= ToType
;
1554 if (Context
.canAssignObjCInterfaces(FromObjCPtr
, ToObjCPtr
)) {
1555 // Okay: this is some kind of implicit downcast of Objective-C
1556 // interfaces, which is permitted. However, we're going to
1557 // complain about it.
1558 IncompatibleObjC
= true;
1559 ConvertedType
= FromType
;
1563 // Beyond this point, both types need to be C pointers or block pointers.
1564 QualType ToPointeeType
;
1565 if (const PointerType
*ToCPtr
= ToType
->getAs
<PointerType
>())
1566 ToPointeeType
= ToCPtr
->getPointeeType();
1567 else if (const BlockPointerType
*ToBlockPtr
=
1568 ToType
->getAs
<BlockPointerType
>()) {
1569 // Objective C++: We're able to convert from a pointer to any object
1570 // to a block pointer type.
1571 if (FromObjCPtr
&& FromObjCPtr
->isObjCBuiltinType()) {
1572 ConvertedType
= ToType
;
1575 ToPointeeType
= ToBlockPtr
->getPointeeType();
1577 else if (FromType
->getAs
<BlockPointerType
>() &&
1578 ToObjCPtr
&& ToObjCPtr
->isObjCBuiltinType()) {
1579 // Objective C++: We're able to convert from a block pointer type to a
1580 // pointer to any object.
1581 ConvertedType
= ToType
;
1587 QualType FromPointeeType
;
1588 if (const PointerType
*FromCPtr
= FromType
->getAs
<PointerType
>())
1589 FromPointeeType
= FromCPtr
->getPointeeType();
1590 else if (const BlockPointerType
*FromBlockPtr
= FromType
->getAs
<BlockPointerType
>())
1591 FromPointeeType
= FromBlockPtr
->getPointeeType();
1595 // If we have pointers to pointers, recursively check whether this
1596 // is an Objective-C conversion.
1597 if (FromPointeeType
->isPointerType() && ToPointeeType
->isPointerType() &&
1598 isObjCPointerConversion(FromPointeeType
, ToPointeeType
, ConvertedType
,
1599 IncompatibleObjC
)) {
1600 // We always complain about this conversion.
1601 IncompatibleObjC
= true;
1602 ConvertedType
= ToType
;
1605 // Allow conversion of pointee being objective-c pointer to another one;
1607 if (FromPointeeType
->getAs
<ObjCObjectPointerType
>() &&
1608 ToPointeeType
->getAs
<ObjCObjectPointerType
>() &&
1609 isObjCPointerConversion(FromPointeeType
, ToPointeeType
, ConvertedType
,
1610 IncompatibleObjC
)) {
1611 ConvertedType
= ToType
;
1615 // If we have pointers to functions or blocks, check whether the only
1616 // differences in the argument and result types are in Objective-C
1617 // pointer conversions. If so, we permit the conversion (but
1618 // complain about it).
1619 const FunctionProtoType
*FromFunctionType
1620 = FromPointeeType
->getAs
<FunctionProtoType
>();
1621 const FunctionProtoType
*ToFunctionType
1622 = ToPointeeType
->getAs
<FunctionProtoType
>();
1623 if (FromFunctionType
&& ToFunctionType
) {
1624 // If the function types are exactly the same, this isn't an
1625 // Objective-C pointer conversion.
1626 if (Context
.getCanonicalType(FromPointeeType
)
1627 == Context
.getCanonicalType(ToPointeeType
))
1630 // Perform the quick checks that will tell us whether these
1631 // function types are obviously different.
1632 if (FromFunctionType
->getNumArgs() != ToFunctionType
->getNumArgs() ||
1633 FromFunctionType
->isVariadic() != ToFunctionType
->isVariadic() ||
1634 FromFunctionType
->getTypeQuals() != ToFunctionType
->getTypeQuals())
1637 bool HasObjCConversion
= false;
1638 if (Context
.getCanonicalType(FromFunctionType
->getResultType())
1639 == Context
.getCanonicalType(ToFunctionType
->getResultType())) {
1640 // Okay, the types match exactly. Nothing to do.
1641 } else if (isObjCPointerConversion(FromFunctionType
->getResultType(),
1642 ToFunctionType
->getResultType(),
1643 ConvertedType
, IncompatibleObjC
)) {
1644 // Okay, we have an Objective-C pointer conversion.
1645 HasObjCConversion
= true;
1647 // Function types are too different. Abort.
1651 // Check argument types.
1652 for (unsigned ArgIdx
= 0, NumArgs
= FromFunctionType
->getNumArgs();
1653 ArgIdx
!= NumArgs
; ++ArgIdx
) {
1654 QualType FromArgType
= FromFunctionType
->getArgType(ArgIdx
);
1655 QualType ToArgType
= ToFunctionType
->getArgType(ArgIdx
);
1656 if (Context
.getCanonicalType(FromArgType
)
1657 == Context
.getCanonicalType(ToArgType
)) {
1658 // Okay, the types match exactly. Nothing to do.
1659 } else if (isObjCPointerConversion(FromArgType
, ToArgType
,
1660 ConvertedType
, IncompatibleObjC
)) {
1661 // Okay, we have an Objective-C pointer conversion.
1662 HasObjCConversion
= true;
1664 // Argument types are too different. Abort.
1669 if (HasObjCConversion
) {
1670 // We had an Objective-C conversion. Allow this pointer
1671 // conversion, but complain about it.
1672 ConvertedType
= ToType
;
1673 IncompatibleObjC
= true;
1681 /// FunctionArgTypesAreEqual - This routine checks two function proto types
1682 /// for equlity of their argument types. Caller has already checked that
1683 /// they have same number of arguments. This routine assumes that Objective-C
1684 /// pointer types which only differ in their protocol qualifiers are equal.
1685 bool Sema::FunctionArgTypesAreEqual(FunctionProtoType
* OldType
,
1686 FunctionProtoType
* NewType
){
1687 if (!getLangOptions().ObjC1
)
1688 return std::equal(OldType
->arg_type_begin(), OldType
->arg_type_end(),
1689 NewType
->arg_type_begin());
1691 for (FunctionProtoType::arg_type_iterator O
= OldType
->arg_type_begin(),
1692 N
= NewType
->arg_type_begin(),
1693 E
= OldType
->arg_type_end(); O
&& (O
!= E
); ++O
, ++N
) {
1694 QualType ToType
= (*O
);
1695 QualType FromType
= (*N
);
1696 if (ToType
!= FromType
) {
1697 if (const PointerType
*PTTo
= ToType
->getAs
<PointerType
>()) {
1698 if (const PointerType
*PTFr
= FromType
->getAs
<PointerType
>())
1699 if ((PTTo
->getPointeeType()->isObjCQualifiedIdType() &&
1700 PTFr
->getPointeeType()->isObjCQualifiedIdType()) ||
1701 (PTTo
->getPointeeType()->isObjCQualifiedClassType() &&
1702 PTFr
->getPointeeType()->isObjCQualifiedClassType()))
1705 else if (const ObjCObjectPointerType
*PTTo
=
1706 ToType
->getAs
<ObjCObjectPointerType
>()) {
1707 if (const ObjCObjectPointerType
*PTFr
=
1708 FromType
->getAs
<ObjCObjectPointerType
>())
1709 if (PTTo
->getInterfaceDecl() == PTFr
->getInterfaceDecl())
1718 /// CheckPointerConversion - Check the pointer conversion from the
1719 /// expression From to the type ToType. This routine checks for
1720 /// ambiguous or inaccessible derived-to-base pointer
1721 /// conversions for which IsPointerConversion has already returned
1722 /// true. It returns true and produces a diagnostic if there was an
1723 /// error, or returns false otherwise.
1724 bool Sema::CheckPointerConversion(Expr
*From
, QualType ToType
,
1726 CXXCastPath
& BasePath
,
1727 bool IgnoreBaseAccess
) {
1728 QualType FromType
= From
->getType();
1730 if (CXXBoolLiteralExpr
* LitBool
1731 = dyn_cast
<CXXBoolLiteralExpr
>(From
->IgnoreParens()))
1732 if (LitBool
->getValue() == false)
1733 Diag(LitBool
->getExprLoc(), diag::warn_init_pointer_from_false
)
1736 if (const PointerType
*FromPtrType
= FromType
->getAs
<PointerType
>())
1737 if (const PointerType
*ToPtrType
= ToType
->getAs
<PointerType
>()) {
1738 QualType FromPointeeType
= FromPtrType
->getPointeeType(),
1739 ToPointeeType
= ToPtrType
->getPointeeType();
1741 if (FromPointeeType
->isRecordType() && ToPointeeType
->isRecordType() &&
1742 !Context
.hasSameUnqualifiedType(FromPointeeType
, ToPointeeType
)) {
1743 // We must have a derived-to-base conversion. Check an
1744 // ambiguous or inaccessible conversion.
1745 if (CheckDerivedToBaseConversion(FromPointeeType
, ToPointeeType
,
1747 From
->getSourceRange(), &BasePath
,
1751 // The conversion was successful.
1752 Kind
= CK_DerivedToBase
;
1755 if (const ObjCObjectPointerType
*FromPtrType
=
1756 FromType
->getAs
<ObjCObjectPointerType
>())
1757 if (const ObjCObjectPointerType
*ToPtrType
=
1758 ToType
->getAs
<ObjCObjectPointerType
>()) {
1759 // Objective-C++ conversions are always okay.
1760 // FIXME: We should have a different class of conversions for the
1761 // Objective-C++ implicit conversions.
1762 if (FromPtrType
->isObjCBuiltinType() || ToPtrType
->isObjCBuiltinType())
1769 /// IsMemberPointerConversion - Determines whether the conversion of the
1770 /// expression From, which has the (possibly adjusted) type FromType, can be
1771 /// converted to the type ToType via a member pointer conversion (C++ 4.11).
1772 /// If so, returns true and places the converted type (that might differ from
1773 /// ToType in its cv-qualifiers at some level) into ConvertedType.
1774 bool Sema::IsMemberPointerConversion(Expr
*From
, QualType FromType
,
1776 bool InOverloadResolution
,
1777 QualType
&ConvertedType
) {
1778 const MemberPointerType
*ToTypePtr
= ToType
->getAs
<MemberPointerType
>();
1782 // A null pointer constant can be converted to a member pointer (C++ 4.11p1)
1783 if (From
->isNullPointerConstant(Context
,
1784 InOverloadResolution
? Expr::NPC_ValueDependentIsNotNull
1785 : Expr::NPC_ValueDependentIsNull
)) {
1786 ConvertedType
= ToType
;
1790 // Otherwise, both types have to be member pointers.
1791 const MemberPointerType
*FromTypePtr
= FromType
->getAs
<MemberPointerType
>();
1795 // A pointer to member of B can be converted to a pointer to member of D,
1796 // where D is derived from B (C++ 4.11p2).
1797 QualType
FromClass(FromTypePtr
->getClass(), 0);
1798 QualType
ToClass(ToTypePtr
->getClass(), 0);
1799 // FIXME: What happens when these are dependent? Is this function even called?
1801 if (IsDerivedFrom(ToClass
, FromClass
)) {
1802 ConvertedType
= Context
.getMemberPointerType(FromTypePtr
->getPointeeType(),
1803 ToClass
.getTypePtr());
1810 /// CheckMemberPointerConversion - Check the member pointer conversion from the
1811 /// expression From to the type ToType. This routine checks for ambiguous or
1812 /// virtual or inaccessible base-to-derived member pointer conversions
1813 /// for which IsMemberPointerConversion has already returned true. It returns
1814 /// true and produces a diagnostic if there was an error, or returns false
1816 bool Sema::CheckMemberPointerConversion(Expr
*From
, QualType ToType
,
1818 CXXCastPath
&BasePath
,
1819 bool IgnoreBaseAccess
) {
1820 QualType FromType
= From
->getType();
1821 const MemberPointerType
*FromPtrType
= FromType
->getAs
<MemberPointerType
>();
1823 // This must be a null pointer to member pointer conversion
1824 assert(From
->isNullPointerConstant(Context
,
1825 Expr::NPC_ValueDependentIsNull
) &&
1826 "Expr must be null pointer constant!");
1827 Kind
= CK_NullToMemberPointer
;
1831 const MemberPointerType
*ToPtrType
= ToType
->getAs
<MemberPointerType
>();
1832 assert(ToPtrType
&& "No member pointer cast has a target type "
1833 "that is not a member pointer.");
1835 QualType FromClass
= QualType(FromPtrType
->getClass(), 0);
1836 QualType ToClass
= QualType(ToPtrType
->getClass(), 0);
1838 // FIXME: What about dependent types?
1839 assert(FromClass
->isRecordType() && "Pointer into non-class.");
1840 assert(ToClass
->isRecordType() && "Pointer into non-class.");
1842 CXXBasePaths
Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
1843 /*DetectVirtual=*/true);
1844 bool DerivationOkay
= IsDerivedFrom(ToClass
, FromClass
, Paths
);
1845 assert(DerivationOkay
&&
1846 "Should not have been called if derivation isn't OK.");
1847 (void)DerivationOkay
;
1849 if (Paths
.isAmbiguous(Context
.getCanonicalType(FromClass
).
1850 getUnqualifiedType())) {
1851 std::string PathDisplayStr
= getAmbiguousPathsDisplayString(Paths
);
1852 Diag(From
->getExprLoc(), diag::err_ambiguous_memptr_conv
)
1853 << 0 << FromClass
<< ToClass
<< PathDisplayStr
<< From
->getSourceRange();
1857 if (const RecordType
*VBase
= Paths
.getDetectedVirtual()) {
1858 Diag(From
->getExprLoc(), diag::err_memptr_conv_via_virtual
)
1859 << FromClass
<< ToClass
<< QualType(VBase
, 0)
1860 << From
->getSourceRange();
1864 if (!IgnoreBaseAccess
)
1865 CheckBaseClassAccess(From
->getExprLoc(), FromClass
, ToClass
,
1867 diag::err_downcast_from_inaccessible_base
);
1869 // Must be a base to derived member conversion.
1870 BuildBasePathArray(Paths
, BasePath
);
1871 Kind
= CK_BaseToDerivedMemberPointer
;
1875 /// IsQualificationConversion - Determines whether the conversion from
1876 /// an rvalue of type FromType to ToType is a qualification conversion
1879 Sema::IsQualificationConversion(QualType FromType
, QualType ToType
) {
1880 FromType
= Context
.getCanonicalType(FromType
);
1881 ToType
= Context
.getCanonicalType(ToType
);
1883 // If FromType and ToType are the same type, this is not a
1884 // qualification conversion.
1885 if (FromType
.getUnqualifiedType() == ToType
.getUnqualifiedType())
1889 // A conversion can add cv-qualifiers at levels other than the first
1890 // in multi-level pointers, subject to the following rules: [...]
1891 bool PreviousToQualsIncludeConst
= true;
1892 bool UnwrappedAnyPointer
= false;
1893 while (Context
.UnwrapSimilarPointerTypes(FromType
, ToType
)) {
1894 // Within each iteration of the loop, we check the qualifiers to
1895 // determine if this still looks like a qualification
1896 // conversion. Then, if all is well, we unwrap one more level of
1897 // pointers or pointers-to-members and do it all again
1898 // until there are no more pointers or pointers-to-members left to
1900 UnwrappedAnyPointer
= true;
1902 // -- for every j > 0, if const is in cv 1,j then const is in cv
1903 // 2,j, and similarly for volatile.
1904 if (!ToType
.isAtLeastAsQualifiedAs(FromType
))
1907 // -- if the cv 1,j and cv 2,j are different, then const is in
1908 // every cv for 0 < k < j.
1909 if (FromType
.getCVRQualifiers() != ToType
.getCVRQualifiers()
1910 && !PreviousToQualsIncludeConst
)
1913 // Keep track of whether all prior cv-qualifiers in the "to" type
1915 PreviousToQualsIncludeConst
1916 = PreviousToQualsIncludeConst
&& ToType
.isConstQualified();
1919 // We are left with FromType and ToType being the pointee types
1920 // after unwrapping the original FromType and ToType the same number
1921 // of types. If we unwrapped any pointers, and if FromType and
1922 // ToType have the same unqualified type (since we checked
1923 // qualifiers above), then this is a qualification conversion.
1924 return UnwrappedAnyPointer
&& Context
.hasSameUnqualifiedType(FromType
,ToType
);
1927 /// Determines whether there is a user-defined conversion sequence
1928 /// (C++ [over.ics.user]) that converts expression From to the type
1929 /// ToType. If such a conversion exists, User will contain the
1930 /// user-defined conversion sequence that performs such a conversion
1931 /// and this routine will return true. Otherwise, this routine returns
1932 /// false and User is unspecified.
1934 /// \param AllowExplicit true if the conversion should consider C++0x
1935 /// "explicit" conversion functions as well as non-explicit conversion
1936 /// functions (C++0x [class.conv.fct]p2).
1937 static OverloadingResult
1938 IsUserDefinedConversion(Sema
&S
, Expr
*From
, QualType ToType
,
1939 UserDefinedConversionSequence
& User
,
1940 OverloadCandidateSet
& CandidateSet
,
1941 bool AllowExplicit
) {
1942 // Whether we will only visit constructors.
1943 bool ConstructorsOnly
= false;
1945 // If the type we are conversion to is a class type, enumerate its
1947 if (const RecordType
*ToRecordType
= ToType
->getAs
<RecordType
>()) {
1948 // C++ [over.match.ctor]p1:
1949 // When objects of class type are direct-initialized (8.5), or
1950 // copy-initialized from an expression of the same or a
1951 // derived class type (8.5), overload resolution selects the
1952 // constructor. [...] For copy-initialization, the candidate
1953 // functions are all the converting constructors (12.3.1) of
1954 // that class. The argument list is the expression-list within
1955 // the parentheses of the initializer.
1956 if (S
.Context
.hasSameUnqualifiedType(ToType
, From
->getType()) ||
1957 (From
->getType()->getAs
<RecordType
>() &&
1958 S
.IsDerivedFrom(From
->getType(), ToType
)))
1959 ConstructorsOnly
= true;
1961 if (S
.RequireCompleteType(From
->getLocStart(), ToType
, S
.PDiag())) {
1962 // We're not going to find any constructors.
1963 } else if (CXXRecordDecl
*ToRecordDecl
1964 = dyn_cast
<CXXRecordDecl
>(ToRecordType
->getDecl())) {
1965 DeclContext::lookup_iterator Con
, ConEnd
;
1966 for (llvm::tie(Con
, ConEnd
) = S
.LookupConstructors(ToRecordDecl
);
1967 Con
!= ConEnd
; ++Con
) {
1968 NamedDecl
*D
= *Con
;
1969 DeclAccessPair FoundDecl
= DeclAccessPair::make(D
, D
->getAccess());
1971 // Find the constructor (which may be a template).
1972 CXXConstructorDecl
*Constructor
= 0;
1973 FunctionTemplateDecl
*ConstructorTmpl
1974 = dyn_cast
<FunctionTemplateDecl
>(D
);
1975 if (ConstructorTmpl
)
1977 = cast
<CXXConstructorDecl
>(ConstructorTmpl
->getTemplatedDecl());
1979 Constructor
= cast
<CXXConstructorDecl
>(D
);
1981 if (!Constructor
->isInvalidDecl() &&
1982 Constructor
->isConvertingConstructor(AllowExplicit
)) {
1983 if (ConstructorTmpl
)
1984 S
.AddTemplateOverloadCandidate(ConstructorTmpl
, FoundDecl
,
1986 &From
, 1, CandidateSet
,
1987 /*SuppressUserConversions=*/
1990 // Allow one user-defined conversion when user specifies a
1991 // From->ToType conversion via an static cast (c-style, etc).
1992 S
.AddOverloadCandidate(Constructor
, FoundDecl
,
1993 &From
, 1, CandidateSet
,
1994 /*SuppressUserConversions=*/
2001 // Enumerate conversion functions, if we're allowed to.
2002 if (ConstructorsOnly
) {
2003 } else if (S
.RequireCompleteType(From
->getLocStart(), From
->getType(),
2004 S
.PDiag(0) << From
->getSourceRange())) {
2005 // No conversion functions from incomplete types.
2006 } else if (const RecordType
*FromRecordType
2007 = From
->getType()->getAs
<RecordType
>()) {
2008 if (CXXRecordDecl
*FromRecordDecl
2009 = dyn_cast
<CXXRecordDecl
>(FromRecordType
->getDecl())) {
2010 // Add all of the conversion functions as candidates.
2011 const UnresolvedSetImpl
*Conversions
2012 = FromRecordDecl
->getVisibleConversionFunctions();
2013 for (UnresolvedSetImpl::iterator I
= Conversions
->begin(),
2014 E
= Conversions
->end(); I
!= E
; ++I
) {
2015 DeclAccessPair FoundDecl
= I
.getPair();
2016 NamedDecl
*D
= FoundDecl
.getDecl();
2017 CXXRecordDecl
*ActingContext
= cast
<CXXRecordDecl
>(D
->getDeclContext());
2018 if (isa
<UsingShadowDecl
>(D
))
2019 D
= cast
<UsingShadowDecl
>(D
)->getTargetDecl();
2021 CXXConversionDecl
*Conv
;
2022 FunctionTemplateDecl
*ConvTemplate
;
2023 if ((ConvTemplate
= dyn_cast
<FunctionTemplateDecl
>(D
)))
2024 Conv
= cast
<CXXConversionDecl
>(ConvTemplate
->getTemplatedDecl());
2026 Conv
= cast
<CXXConversionDecl
>(D
);
2028 if (AllowExplicit
|| !Conv
->isExplicit()) {
2030 S
.AddTemplateConversionCandidate(ConvTemplate
, FoundDecl
,
2031 ActingContext
, From
, ToType
,
2034 S
.AddConversionCandidate(Conv
, FoundDecl
, ActingContext
,
2035 From
, ToType
, CandidateSet
);
2041 OverloadCandidateSet::iterator Best
;
2042 switch (CandidateSet
.BestViableFunction(S
, From
->getLocStart(), Best
)) {
2044 // Record the standard conversion we used and the conversion function.
2045 if (CXXConstructorDecl
*Constructor
2046 = dyn_cast
<CXXConstructorDecl
>(Best
->Function
)) {
2047 // C++ [over.ics.user]p1:
2048 // If the user-defined conversion is specified by a
2049 // constructor (12.3.1), the initial standard conversion
2050 // sequence converts the source type to the type required by
2051 // the argument of the constructor.
2053 QualType ThisType
= Constructor
->getThisType(S
.Context
);
2054 if (Best
->Conversions
[0].isEllipsis())
2055 User
.EllipsisConversion
= true;
2057 User
.Before
= Best
->Conversions
[0].Standard
;
2058 User
.EllipsisConversion
= false;
2060 User
.ConversionFunction
= Constructor
;
2061 User
.After
.setAsIdentityConversion();
2062 User
.After
.setFromType(ThisType
->getAs
<PointerType
>()->getPointeeType());
2063 User
.After
.setAllToTypes(ToType
);
2065 } else if (CXXConversionDecl
*Conversion
2066 = dyn_cast
<CXXConversionDecl
>(Best
->Function
)) {
2067 // C++ [over.ics.user]p1:
2069 // [...] If the user-defined conversion is specified by a
2070 // conversion function (12.3.2), the initial standard
2071 // conversion sequence converts the source type to the
2072 // implicit object parameter of the conversion function.
2073 User
.Before
= Best
->Conversions
[0].Standard
;
2074 User
.ConversionFunction
= Conversion
;
2075 User
.EllipsisConversion
= false;
2077 // C++ [over.ics.user]p2:
2078 // The second standard conversion sequence converts the
2079 // result of the user-defined conversion to the target type
2080 // for the sequence. Since an implicit conversion sequence
2081 // is an initialization, the special rules for
2082 // initialization by user-defined conversion apply when
2083 // selecting the best user-defined conversion for a
2084 // user-defined conversion sequence (see 13.3.3 and
2086 User
.After
= Best
->FinalConversion
;
2089 llvm_unreachable("Not a constructor or conversion function?");
2090 return OR_No_Viable_Function
;
2093 case OR_No_Viable_Function
:
2094 return OR_No_Viable_Function
;
2096 // No conversion here! We're done.
2100 return OR_Ambiguous
;
2103 return OR_No_Viable_Function
;
2107 Sema::DiagnoseMultipleUserDefinedConversion(Expr
*From
, QualType ToType
) {
2108 ImplicitConversionSequence ICS
;
2109 OverloadCandidateSet
CandidateSet(From
->getExprLoc());
2110 OverloadingResult OvResult
=
2111 IsUserDefinedConversion(*this, From
, ToType
, ICS
.UserDefined
,
2112 CandidateSet
, false);
2113 if (OvResult
== OR_Ambiguous
)
2114 Diag(From
->getSourceRange().getBegin(),
2115 diag::err_typecheck_ambiguous_condition
)
2116 << From
->getType() << ToType
<< From
->getSourceRange();
2117 else if (OvResult
== OR_No_Viable_Function
&& !CandidateSet
.empty())
2118 Diag(From
->getSourceRange().getBegin(),
2119 diag::err_typecheck_nonviable_condition
)
2120 << From
->getType() << ToType
<< From
->getSourceRange();
2123 CandidateSet
.NoteCandidates(*this, OCD_AllCandidates
, &From
, 1);
2127 /// CompareImplicitConversionSequences - Compare two implicit
2128 /// conversion sequences to determine whether one is better than the
2129 /// other or if they are indistinguishable (C++ 13.3.3.2).
2130 static ImplicitConversionSequence::CompareKind
2131 CompareImplicitConversionSequences(Sema
&S
,
2132 const ImplicitConversionSequence
& ICS1
,
2133 const ImplicitConversionSequence
& ICS2
)
2135 // (C++ 13.3.3.2p2): When comparing the basic forms of implicit
2136 // conversion sequences (as defined in 13.3.3.1)
2137 // -- a standard conversion sequence (13.3.3.1.1) is a better
2138 // conversion sequence than a user-defined conversion sequence or
2139 // an ellipsis conversion sequence, and
2140 // -- a user-defined conversion sequence (13.3.3.1.2) is a better
2141 // conversion sequence than an ellipsis conversion sequence
2144 // C++0x [over.best.ics]p10:
2145 // For the purpose of ranking implicit conversion sequences as
2146 // described in 13.3.3.2, the ambiguous conversion sequence is
2147 // treated as a user-defined sequence that is indistinguishable
2148 // from any other user-defined conversion sequence.
2149 if (ICS1
.getKindRank() < ICS2
.getKindRank())
2150 return ImplicitConversionSequence::Better
;
2151 else if (ICS2
.getKindRank() < ICS1
.getKindRank())
2152 return ImplicitConversionSequence::Worse
;
2154 // The following checks require both conversion sequences to be of
2156 if (ICS1
.getKind() != ICS2
.getKind())
2157 return ImplicitConversionSequence::Indistinguishable
;
2159 // Two implicit conversion sequences of the same form are
2160 // indistinguishable conversion sequences unless one of the
2161 // following rules apply: (C++ 13.3.3.2p3):
2162 if (ICS1
.isStandard())
2163 return CompareStandardConversionSequences(S
, ICS1
.Standard
, ICS2
.Standard
);
2164 else if (ICS1
.isUserDefined()) {
2165 // User-defined conversion sequence U1 is a better conversion
2166 // sequence than another user-defined conversion sequence U2 if
2167 // they contain the same user-defined conversion function or
2168 // constructor and if the second standard conversion sequence of
2169 // U1 is better than the second standard conversion sequence of
2170 // U2 (C++ 13.3.3.2p3).
2171 if (ICS1
.UserDefined
.ConversionFunction
==
2172 ICS2
.UserDefined
.ConversionFunction
)
2173 return CompareStandardConversionSequences(S
,
2174 ICS1
.UserDefined
.After
,
2175 ICS2
.UserDefined
.After
);
2178 return ImplicitConversionSequence::Indistinguishable
;
2181 static bool hasSimilarType(ASTContext
&Context
, QualType T1
, QualType T2
) {
2182 while (Context
.UnwrapSimilarPointerTypes(T1
, T2
)) {
2184 T1
= Context
.getUnqualifiedArrayType(T1
, Quals
);
2185 T2
= Context
.getUnqualifiedArrayType(T2
, Quals
);
2188 return Context
.hasSameUnqualifiedType(T1
, T2
);
2191 // Per 13.3.3.2p3, compare the given standard conversion sequences to
2192 // determine if one is a proper subset of the other.
2193 static ImplicitConversionSequence::CompareKind
2194 compareStandardConversionSubsets(ASTContext
&Context
,
2195 const StandardConversionSequence
& SCS1
,
2196 const StandardConversionSequence
& SCS2
) {
2197 ImplicitConversionSequence::CompareKind Result
2198 = ImplicitConversionSequence::Indistinguishable
;
2200 // the identity conversion sequence is considered to be a subsequence of
2201 // any non-identity conversion sequence
2202 if (SCS1
.ReferenceBinding
== SCS2
.ReferenceBinding
) {
2203 if (SCS1
.isIdentityConversion() && !SCS2
.isIdentityConversion())
2204 return ImplicitConversionSequence::Better
;
2205 else if (!SCS1
.isIdentityConversion() && SCS2
.isIdentityConversion())
2206 return ImplicitConversionSequence::Worse
;
2209 if (SCS1
.Second
!= SCS2
.Second
) {
2210 if (SCS1
.Second
== ICK_Identity
)
2211 Result
= ImplicitConversionSequence::Better
;
2212 else if (SCS2
.Second
== ICK_Identity
)
2213 Result
= ImplicitConversionSequence::Worse
;
2215 return ImplicitConversionSequence::Indistinguishable
;
2216 } else if (!hasSimilarType(Context
, SCS1
.getToType(1), SCS2
.getToType(1)))
2217 return ImplicitConversionSequence::Indistinguishable
;
2219 if (SCS1
.Third
== SCS2
.Third
) {
2220 return Context
.hasSameType(SCS1
.getToType(2), SCS2
.getToType(2))? Result
2221 : ImplicitConversionSequence::Indistinguishable
;
2224 if (SCS1
.Third
== ICK_Identity
)
2225 return Result
== ImplicitConversionSequence::Worse
2226 ? ImplicitConversionSequence::Indistinguishable
2227 : ImplicitConversionSequence::Better
;
2229 if (SCS2
.Third
== ICK_Identity
)
2230 return Result
== ImplicitConversionSequence::Better
2231 ? ImplicitConversionSequence::Indistinguishable
2232 : ImplicitConversionSequence::Worse
;
2234 return ImplicitConversionSequence::Indistinguishable
;
2237 /// CompareStandardConversionSequences - Compare two standard
2238 /// conversion sequences to determine whether one is better than the
2239 /// other or if they are indistinguishable (C++ 13.3.3.2p3).
2240 static ImplicitConversionSequence::CompareKind
2241 CompareStandardConversionSequences(Sema
&S
,
2242 const StandardConversionSequence
& SCS1
,
2243 const StandardConversionSequence
& SCS2
)
2245 // Standard conversion sequence S1 is a better conversion sequence
2246 // than standard conversion sequence S2 if (C++ 13.3.3.2p3):
2248 // -- S1 is a proper subsequence of S2 (comparing the conversion
2249 // sequences in the canonical form defined by 13.3.3.1.1,
2250 // excluding any Lvalue Transformation; the identity conversion
2251 // sequence is considered to be a subsequence of any
2252 // non-identity conversion sequence) or, if not that,
2253 if (ImplicitConversionSequence::CompareKind CK
2254 = compareStandardConversionSubsets(S
.Context
, SCS1
, SCS2
))
2257 // -- the rank of S1 is better than the rank of S2 (by the rules
2258 // defined below), or, if not that,
2259 ImplicitConversionRank Rank1
= SCS1
.getRank();
2260 ImplicitConversionRank Rank2
= SCS2
.getRank();
2262 return ImplicitConversionSequence::Better
;
2263 else if (Rank2
< Rank1
)
2264 return ImplicitConversionSequence::Worse
;
2266 // (C++ 13.3.3.2p4): Two conversion sequences with the same rank
2267 // are indistinguishable unless one of the following rules
2270 // A conversion that is not a conversion of a pointer, or
2271 // pointer to member, to bool is better than another conversion
2272 // that is such a conversion.
2273 if (SCS1
.isPointerConversionToBool() != SCS2
.isPointerConversionToBool())
2274 return SCS2
.isPointerConversionToBool()
2275 ? ImplicitConversionSequence::Better
2276 : ImplicitConversionSequence::Worse
;
2278 // C++ [over.ics.rank]p4b2:
2280 // If class B is derived directly or indirectly from class A,
2281 // conversion of B* to A* is better than conversion of B* to
2282 // void*, and conversion of A* to void* is better than conversion
2284 bool SCS1ConvertsToVoid
2285 = SCS1
.isPointerConversionToVoidPointer(S
.Context
);
2286 bool SCS2ConvertsToVoid
2287 = SCS2
.isPointerConversionToVoidPointer(S
.Context
);
2288 if (SCS1ConvertsToVoid
!= SCS2ConvertsToVoid
) {
2289 // Exactly one of the conversion sequences is a conversion to
2290 // a void pointer; it's the worse conversion.
2291 return SCS2ConvertsToVoid
? ImplicitConversionSequence::Better
2292 : ImplicitConversionSequence::Worse
;
2293 } else if (!SCS1ConvertsToVoid
&& !SCS2ConvertsToVoid
) {
2294 // Neither conversion sequence converts to a void pointer; compare
2295 // their derived-to-base conversions.
2296 if (ImplicitConversionSequence::CompareKind DerivedCK
2297 = CompareDerivedToBaseConversions(S
, SCS1
, SCS2
))
2299 } else if (SCS1ConvertsToVoid
&& SCS2ConvertsToVoid
) {
2300 // Both conversion sequences are conversions to void
2301 // pointers. Compare the source types to determine if there's an
2302 // inheritance relationship in their sources.
2303 QualType FromType1
= SCS1
.getFromType();
2304 QualType FromType2
= SCS2
.getFromType();
2306 // Adjust the types we're converting from via the array-to-pointer
2307 // conversion, if we need to.
2308 if (SCS1
.First
== ICK_Array_To_Pointer
)
2309 FromType1
= S
.Context
.getArrayDecayedType(FromType1
);
2310 if (SCS2
.First
== ICK_Array_To_Pointer
)
2311 FromType2
= S
.Context
.getArrayDecayedType(FromType2
);
2313 QualType FromPointee1
2314 = FromType1
->getAs
<PointerType
>()->getPointeeType().getUnqualifiedType();
2315 QualType FromPointee2
2316 = FromType2
->getAs
<PointerType
>()->getPointeeType().getUnqualifiedType();
2318 if (S
.IsDerivedFrom(FromPointee2
, FromPointee1
))
2319 return ImplicitConversionSequence::Better
;
2320 else if (S
.IsDerivedFrom(FromPointee1
, FromPointee2
))
2321 return ImplicitConversionSequence::Worse
;
2323 // Objective-C++: If one interface is more specific than the
2324 // other, it is the better one.
2325 const ObjCObjectType
* FromIface1
= FromPointee1
->getAs
<ObjCObjectType
>();
2326 const ObjCObjectType
* FromIface2
= FromPointee2
->getAs
<ObjCObjectType
>();
2327 if (FromIface1
&& FromIface1
) {
2328 if (S
.Context
.canAssignObjCInterfaces(FromIface2
, FromIface1
))
2329 return ImplicitConversionSequence::Better
;
2330 else if (S
.Context
.canAssignObjCInterfaces(FromIface1
, FromIface2
))
2331 return ImplicitConversionSequence::Worse
;
2335 // Compare based on qualification conversions (C++ 13.3.3.2p3,
2337 if (ImplicitConversionSequence::CompareKind QualCK
2338 = CompareQualificationConversions(S
, SCS1
, SCS2
))
2341 if (SCS1
.ReferenceBinding
&& SCS2
.ReferenceBinding
) {
2342 // C++0x [over.ics.rank]p3b4:
2343 // -- S1 and S2 are reference bindings (8.5.3) and neither refers to an
2344 // implicit object parameter of a non-static member function declared
2345 // without a ref-qualifier, and S1 binds an rvalue reference to an
2346 // rvalue and S2 binds an lvalue reference.
2347 // FIXME: We don't know if we're dealing with the implicit object parameter,
2348 // or if the member function in this case has a ref qualifier.
2349 // (Of course, we don't have ref qualifiers yet.)
2350 if (SCS1
.RRefBinding
!= SCS2
.RRefBinding
)
2351 return SCS1
.RRefBinding
? ImplicitConversionSequence::Better
2352 : ImplicitConversionSequence::Worse
;
2354 // C++ [over.ics.rank]p3b4:
2355 // -- S1 and S2 are reference bindings (8.5.3), and the types to
2356 // which the references refer are the same type except for
2357 // top-level cv-qualifiers, and the type to which the reference
2358 // initialized by S2 refers is more cv-qualified than the type
2359 // to which the reference initialized by S1 refers.
2360 QualType T1
= SCS1
.getToType(2);
2361 QualType T2
= SCS2
.getToType(2);
2362 T1
= S
.Context
.getCanonicalType(T1
);
2363 T2
= S
.Context
.getCanonicalType(T2
);
2364 Qualifiers T1Quals
, T2Quals
;
2365 QualType UnqualT1
= S
.Context
.getUnqualifiedArrayType(T1
, T1Quals
);
2366 QualType UnqualT2
= S
.Context
.getUnqualifiedArrayType(T2
, T2Quals
);
2367 if (UnqualT1
== UnqualT2
) {
2368 // If the type is an array type, promote the element qualifiers to the type
2370 if (isa
<ArrayType
>(T1
) && T1Quals
)
2371 T1
= S
.Context
.getQualifiedType(UnqualT1
, T1Quals
);
2372 if (isa
<ArrayType
>(T2
) && T2Quals
)
2373 T2
= S
.Context
.getQualifiedType(UnqualT2
, T2Quals
);
2374 if (T2
.isMoreQualifiedThan(T1
))
2375 return ImplicitConversionSequence::Better
;
2376 else if (T1
.isMoreQualifiedThan(T2
))
2377 return ImplicitConversionSequence::Worse
;
2381 return ImplicitConversionSequence::Indistinguishable
;
2384 /// CompareQualificationConversions - Compares two standard conversion
2385 /// sequences to determine whether they can be ranked based on their
2386 /// qualification conversions (C++ 13.3.3.2p3 bullet 3).
2387 ImplicitConversionSequence::CompareKind
2388 CompareQualificationConversions(Sema
&S
,
2389 const StandardConversionSequence
& SCS1
,
2390 const StandardConversionSequence
& SCS2
) {
2392 // -- S1 and S2 differ only in their qualification conversion and
2393 // yield similar types T1 and T2 (C++ 4.4), respectively, and the
2394 // cv-qualification signature of type T1 is a proper subset of
2395 // the cv-qualification signature of type T2, and S1 is not the
2396 // deprecated string literal array-to-pointer conversion (4.2).
2397 if (SCS1
.First
!= SCS2
.First
|| SCS1
.Second
!= SCS2
.Second
||
2398 SCS1
.Third
!= SCS2
.Third
|| SCS1
.Third
!= ICK_Qualification
)
2399 return ImplicitConversionSequence::Indistinguishable
;
2401 // FIXME: the example in the standard doesn't use a qualification
2403 QualType T1
= SCS1
.getToType(2);
2404 QualType T2
= SCS2
.getToType(2);
2405 T1
= S
.Context
.getCanonicalType(T1
);
2406 T2
= S
.Context
.getCanonicalType(T2
);
2407 Qualifiers T1Quals
, T2Quals
;
2408 QualType UnqualT1
= S
.Context
.getUnqualifiedArrayType(T1
, T1Quals
);
2409 QualType UnqualT2
= S
.Context
.getUnqualifiedArrayType(T2
, T2Quals
);
2411 // If the types are the same, we won't learn anything by unwrapped
2413 if (UnqualT1
== UnqualT2
)
2414 return ImplicitConversionSequence::Indistinguishable
;
2416 // If the type is an array type, promote the element qualifiers to the type
2418 if (isa
<ArrayType
>(T1
) && T1Quals
)
2419 T1
= S
.Context
.getQualifiedType(UnqualT1
, T1Quals
);
2420 if (isa
<ArrayType
>(T2
) && T2Quals
)
2421 T2
= S
.Context
.getQualifiedType(UnqualT2
, T2Quals
);
2423 ImplicitConversionSequence::CompareKind Result
2424 = ImplicitConversionSequence::Indistinguishable
;
2425 while (S
.Context
.UnwrapSimilarPointerTypes(T1
, T2
)) {
2426 // Within each iteration of the loop, we check the qualifiers to
2427 // determine if this still looks like a qualification
2428 // conversion. Then, if all is well, we unwrap one more level of
2429 // pointers or pointers-to-members and do it all again
2430 // until there are no more pointers or pointers-to-members left
2431 // to unwrap. This essentially mimics what
2432 // IsQualificationConversion does, but here we're checking for a
2433 // strict subset of qualifiers.
2434 if (T1
.getCVRQualifiers() == T2
.getCVRQualifiers())
2435 // The qualifiers are the same, so this doesn't tell us anything
2436 // about how the sequences rank.
2438 else if (T2
.isMoreQualifiedThan(T1
)) {
2439 // T1 has fewer qualifiers, so it could be the better sequence.
2440 if (Result
== ImplicitConversionSequence::Worse
)
2441 // Neither has qualifiers that are a subset of the other's
2443 return ImplicitConversionSequence::Indistinguishable
;
2445 Result
= ImplicitConversionSequence::Better
;
2446 } else if (T1
.isMoreQualifiedThan(T2
)) {
2447 // T2 has fewer qualifiers, so it could be the better sequence.
2448 if (Result
== ImplicitConversionSequence::Better
)
2449 // Neither has qualifiers that are a subset of the other's
2451 return ImplicitConversionSequence::Indistinguishable
;
2453 Result
= ImplicitConversionSequence::Worse
;
2455 // Qualifiers are disjoint.
2456 return ImplicitConversionSequence::Indistinguishable
;
2459 // If the types after this point are equivalent, we're done.
2460 if (S
.Context
.hasSameUnqualifiedType(T1
, T2
))
2464 // Check that the winning standard conversion sequence isn't using
2465 // the deprecated string literal array to pointer conversion.
2467 case ImplicitConversionSequence::Better
:
2468 if (SCS1
.DeprecatedStringLiteralToCharPtr
)
2469 Result
= ImplicitConversionSequence::Indistinguishable
;
2472 case ImplicitConversionSequence::Indistinguishable
:
2475 case ImplicitConversionSequence::Worse
:
2476 if (SCS2
.DeprecatedStringLiteralToCharPtr
)
2477 Result
= ImplicitConversionSequence::Indistinguishable
;
2484 /// CompareDerivedToBaseConversions - Compares two standard conversion
2485 /// sequences to determine whether they can be ranked based on their
2486 /// various kinds of derived-to-base conversions (C++
2487 /// [over.ics.rank]p4b3). As part of these checks, we also look at
2488 /// conversions between Objective-C interface types.
2489 ImplicitConversionSequence::CompareKind
2490 CompareDerivedToBaseConversions(Sema
&S
,
2491 const StandardConversionSequence
& SCS1
,
2492 const StandardConversionSequence
& SCS2
) {
2493 QualType FromType1
= SCS1
.getFromType();
2494 QualType ToType1
= SCS1
.getToType(1);
2495 QualType FromType2
= SCS2
.getFromType();
2496 QualType ToType2
= SCS2
.getToType(1);
2498 // Adjust the types we're converting from via the array-to-pointer
2499 // conversion, if we need to.
2500 if (SCS1
.First
== ICK_Array_To_Pointer
)
2501 FromType1
= S
.Context
.getArrayDecayedType(FromType1
);
2502 if (SCS2
.First
== ICK_Array_To_Pointer
)
2503 FromType2
= S
.Context
.getArrayDecayedType(FromType2
);
2505 // Canonicalize all of the types.
2506 FromType1
= S
.Context
.getCanonicalType(FromType1
);
2507 ToType1
= S
.Context
.getCanonicalType(ToType1
);
2508 FromType2
= S
.Context
.getCanonicalType(FromType2
);
2509 ToType2
= S
.Context
.getCanonicalType(ToType2
);
2511 // C++ [over.ics.rank]p4b3:
2513 // If class B is derived directly or indirectly from class A and
2514 // class C is derived directly or indirectly from B,
2516 // For Objective-C, we let A, B, and C also be Objective-C
2519 // Compare based on pointer conversions.
2520 if (SCS1
.Second
== ICK_Pointer_Conversion
&&
2521 SCS2
.Second
== ICK_Pointer_Conversion
&&
2522 /*FIXME: Remove if Objective-C id conversions get their own rank*/
2523 FromType1
->isPointerType() && FromType2
->isPointerType() &&
2524 ToType1
->isPointerType() && ToType2
->isPointerType()) {
2525 QualType FromPointee1
2526 = FromType1
->getAs
<PointerType
>()->getPointeeType().getUnqualifiedType();
2528 = ToType1
->getAs
<PointerType
>()->getPointeeType().getUnqualifiedType();
2529 QualType FromPointee2
2530 = FromType2
->getAs
<PointerType
>()->getPointeeType().getUnqualifiedType();
2532 = ToType2
->getAs
<PointerType
>()->getPointeeType().getUnqualifiedType();
2534 const ObjCObjectType
* FromIface1
= FromPointee1
->getAs
<ObjCObjectType
>();
2535 const ObjCObjectType
* FromIface2
= FromPointee2
->getAs
<ObjCObjectType
>();
2536 const ObjCObjectType
* ToIface1
= ToPointee1
->getAs
<ObjCObjectType
>();
2537 const ObjCObjectType
* ToIface2
= ToPointee2
->getAs
<ObjCObjectType
>();
2539 // -- conversion of C* to B* is better than conversion of C* to A*,
2540 if (FromPointee1
== FromPointee2
&& ToPointee1
!= ToPointee2
) {
2541 if (S
.IsDerivedFrom(ToPointee1
, ToPointee2
))
2542 return ImplicitConversionSequence::Better
;
2543 else if (S
.IsDerivedFrom(ToPointee2
, ToPointee1
))
2544 return ImplicitConversionSequence::Worse
;
2546 if (ToIface1
&& ToIface2
) {
2547 if (S
.Context
.canAssignObjCInterfaces(ToIface2
, ToIface1
))
2548 return ImplicitConversionSequence::Better
;
2549 else if (S
.Context
.canAssignObjCInterfaces(ToIface1
, ToIface2
))
2550 return ImplicitConversionSequence::Worse
;
2554 // -- conversion of B* to A* is better than conversion of C* to A*,
2555 if (FromPointee1
!= FromPointee2
&& ToPointee1
== ToPointee2
) {
2556 if (S
.IsDerivedFrom(FromPointee2
, FromPointee1
))
2557 return ImplicitConversionSequence::Better
;
2558 else if (S
.IsDerivedFrom(FromPointee1
, FromPointee2
))
2559 return ImplicitConversionSequence::Worse
;
2561 if (FromIface1
&& FromIface2
) {
2562 if (S
.Context
.canAssignObjCInterfaces(FromIface1
, FromIface2
))
2563 return ImplicitConversionSequence::Better
;
2564 else if (S
.Context
.canAssignObjCInterfaces(FromIface2
, FromIface1
))
2565 return ImplicitConversionSequence::Worse
;
2570 // Ranking of member-pointer types.
2571 if (SCS1
.Second
== ICK_Pointer_Member
&& SCS2
.Second
== ICK_Pointer_Member
&&
2572 FromType1
->isMemberPointerType() && FromType2
->isMemberPointerType() &&
2573 ToType1
->isMemberPointerType() && ToType2
->isMemberPointerType()) {
2574 const MemberPointerType
* FromMemPointer1
=
2575 FromType1
->getAs
<MemberPointerType
>();
2576 const MemberPointerType
* ToMemPointer1
=
2577 ToType1
->getAs
<MemberPointerType
>();
2578 const MemberPointerType
* FromMemPointer2
=
2579 FromType2
->getAs
<MemberPointerType
>();
2580 const MemberPointerType
* ToMemPointer2
=
2581 ToType2
->getAs
<MemberPointerType
>();
2582 const Type
*FromPointeeType1
= FromMemPointer1
->getClass();
2583 const Type
*ToPointeeType1
= ToMemPointer1
->getClass();
2584 const Type
*FromPointeeType2
= FromMemPointer2
->getClass();
2585 const Type
*ToPointeeType2
= ToMemPointer2
->getClass();
2586 QualType FromPointee1
= QualType(FromPointeeType1
, 0).getUnqualifiedType();
2587 QualType ToPointee1
= QualType(ToPointeeType1
, 0).getUnqualifiedType();
2588 QualType FromPointee2
= QualType(FromPointeeType2
, 0).getUnqualifiedType();
2589 QualType ToPointee2
= QualType(ToPointeeType2
, 0).getUnqualifiedType();
2590 // conversion of A::* to B::* is better than conversion of A::* to C::*,
2591 if (FromPointee1
== FromPointee2
&& ToPointee1
!= ToPointee2
) {
2592 if (S
.IsDerivedFrom(ToPointee1
, ToPointee2
))
2593 return ImplicitConversionSequence::Worse
;
2594 else if (S
.IsDerivedFrom(ToPointee2
, ToPointee1
))
2595 return ImplicitConversionSequence::Better
;
2597 // conversion of B::* to C::* is better than conversion of A::* to C::*
2598 if (ToPointee1
== ToPointee2
&& FromPointee1
!= FromPointee2
) {
2599 if (S
.IsDerivedFrom(FromPointee1
, FromPointee2
))
2600 return ImplicitConversionSequence::Better
;
2601 else if (S
.IsDerivedFrom(FromPointee2
, FromPointee1
))
2602 return ImplicitConversionSequence::Worse
;
2606 if (SCS1
.Second
== ICK_Derived_To_Base
) {
2607 // -- conversion of C to B is better than conversion of C to A,
2608 // -- binding of an expression of type C to a reference of type
2609 // B& is better than binding an expression of type C to a
2610 // reference of type A&,
2611 if (S
.Context
.hasSameUnqualifiedType(FromType1
, FromType2
) &&
2612 !S
.Context
.hasSameUnqualifiedType(ToType1
, ToType2
)) {
2613 if (S
.IsDerivedFrom(ToType1
, ToType2
))
2614 return ImplicitConversionSequence::Better
;
2615 else if (S
.IsDerivedFrom(ToType2
, ToType1
))
2616 return ImplicitConversionSequence::Worse
;
2619 // -- conversion of B to A is better than conversion of C to A.
2620 // -- binding of an expression of type B to a reference of type
2621 // A& is better than binding an expression of type C to a
2622 // reference of type A&,
2623 if (!S
.Context
.hasSameUnqualifiedType(FromType1
, FromType2
) &&
2624 S
.Context
.hasSameUnqualifiedType(ToType1
, ToType2
)) {
2625 if (S
.IsDerivedFrom(FromType2
, FromType1
))
2626 return ImplicitConversionSequence::Better
;
2627 else if (S
.IsDerivedFrom(FromType1
, FromType2
))
2628 return ImplicitConversionSequence::Worse
;
2632 return ImplicitConversionSequence::Indistinguishable
;
2635 /// CompareReferenceRelationship - Compare the two types T1 and T2 to
2636 /// determine whether they are reference-related,
2637 /// reference-compatible, reference-compatible with added
2638 /// qualification, or incompatible, for use in C++ initialization by
2639 /// reference (C++ [dcl.ref.init]p4). Neither type can be a reference
2640 /// type, and the first type (T1) is the pointee type of the reference
2641 /// type being initialized.
2642 Sema::ReferenceCompareResult
2643 Sema::CompareReferenceRelationship(SourceLocation Loc
,
2644 QualType OrigT1
, QualType OrigT2
,
2645 bool &DerivedToBase
,
2646 bool &ObjCConversion
) {
2647 assert(!OrigT1
->isReferenceType() &&
2648 "T1 must be the pointee type of the reference type");
2649 assert(!OrigT2
->isReferenceType() && "T2 cannot be a reference type");
2651 QualType T1
= Context
.getCanonicalType(OrigT1
);
2652 QualType T2
= Context
.getCanonicalType(OrigT2
);
2653 Qualifiers T1Quals
, T2Quals
;
2654 QualType UnqualT1
= Context
.getUnqualifiedArrayType(T1
, T1Quals
);
2655 QualType UnqualT2
= Context
.getUnqualifiedArrayType(T2
, T2Quals
);
2657 // C++ [dcl.init.ref]p4:
2658 // Given types "cv1 T1" and "cv2 T2," "cv1 T1" is
2659 // reference-related to "cv2 T2" if T1 is the same type as T2, or
2660 // T1 is a base class of T2.
2661 DerivedToBase
= false;
2662 ObjCConversion
= false;
2663 if (UnqualT1
== UnqualT2
) {
2665 } else if (!RequireCompleteType(Loc
, OrigT2
, PDiag()) &&
2666 IsDerivedFrom(UnqualT2
, UnqualT1
))
2667 DerivedToBase
= true;
2668 else if (UnqualT1
->isObjCObjectOrInterfaceType() &&
2669 UnqualT2
->isObjCObjectOrInterfaceType() &&
2670 Context
.canBindObjCObjectType(UnqualT1
, UnqualT2
))
2671 ObjCConversion
= true;
2673 return Ref_Incompatible
;
2675 // At this point, we know that T1 and T2 are reference-related (at
2678 // If the type is an array type, promote the element qualifiers to the type
2680 if (isa
<ArrayType
>(T1
) && T1Quals
)
2681 T1
= Context
.getQualifiedType(UnqualT1
, T1Quals
);
2682 if (isa
<ArrayType
>(T2
) && T2Quals
)
2683 T2
= Context
.getQualifiedType(UnqualT2
, T2Quals
);
2685 // C++ [dcl.init.ref]p4:
2686 // "cv1 T1" is reference-compatible with "cv2 T2" if T1 is
2687 // reference-related to T2 and cv1 is the same cv-qualification
2688 // as, or greater cv-qualification than, cv2. For purposes of
2689 // overload resolution, cases for which cv1 is greater
2690 // cv-qualification than cv2 are identified as
2691 // reference-compatible with added qualification (see 13.3.3.2).
2692 if (T1Quals
.getCVRQualifiers() == T2Quals
.getCVRQualifiers())
2693 return Ref_Compatible
;
2694 else if (T1
.isMoreQualifiedThan(T2
))
2695 return Ref_Compatible_With_Added_Qualification
;
2700 /// \brief Look for a user-defined conversion to an value reference-compatible
2701 /// with DeclType. Return true if something definite is found.
2703 FindConversionForRefInit(Sema
&S
, ImplicitConversionSequence
&ICS
,
2704 QualType DeclType
, SourceLocation DeclLoc
,
2705 Expr
*Init
, QualType T2
, bool AllowRvalues
,
2706 bool AllowExplicit
) {
2707 assert(T2
->isRecordType() && "Can only find conversions of record types.");
2708 CXXRecordDecl
*T2RecordDecl
2709 = dyn_cast
<CXXRecordDecl
>(T2
->getAs
<RecordType
>()->getDecl());
2712 = AllowRvalues
? DeclType
->getAs
<ReferenceType
>()->getPointeeType()
2715 OverloadCandidateSet
CandidateSet(DeclLoc
);
2716 const UnresolvedSetImpl
*Conversions
2717 = T2RecordDecl
->getVisibleConversionFunctions();
2718 for (UnresolvedSetImpl::iterator I
= Conversions
->begin(),
2719 E
= Conversions
->end(); I
!= E
; ++I
) {
2721 CXXRecordDecl
*ActingDC
= cast
<CXXRecordDecl
>(D
->getDeclContext());
2722 if (isa
<UsingShadowDecl
>(D
))
2723 D
= cast
<UsingShadowDecl
>(D
)->getTargetDecl();
2725 FunctionTemplateDecl
*ConvTemplate
2726 = dyn_cast
<FunctionTemplateDecl
>(D
);
2727 CXXConversionDecl
*Conv
;
2729 Conv
= cast
<CXXConversionDecl
>(ConvTemplate
->getTemplatedDecl());
2731 Conv
= cast
<CXXConversionDecl
>(D
);
2733 // If this is an explicit conversion, and we're not allowed to consider
2734 // explicit conversions, skip it.
2735 if (!AllowExplicit
&& Conv
->isExplicit())
2739 bool DerivedToBase
= false;
2740 bool ObjCConversion
= false;
2741 if (!ConvTemplate
&&
2742 S
.CompareReferenceRelationship(DeclLoc
,
2743 Conv
->getConversionType().getNonReferenceType().getUnqualifiedType(),
2744 DeclType
.getNonReferenceType().getUnqualifiedType(),
2745 DerivedToBase
, ObjCConversion
)
2746 == Sema::Ref_Incompatible
)
2749 // If the conversion function doesn't return a reference type,
2750 // it can't be considered for this conversion. An rvalue reference
2751 // is only acceptable if its referencee is a function type.
2753 const ReferenceType
*RefType
=
2754 Conv
->getConversionType()->getAs
<ReferenceType
>();
2756 (!RefType
->isLValueReferenceType() &&
2757 !RefType
->getPointeeType()->isFunctionType()))
2762 S
.AddTemplateConversionCandidate(ConvTemplate
, I
.getPair(), ActingDC
,
2763 Init
, ToType
, CandidateSet
);
2765 S
.AddConversionCandidate(Conv
, I
.getPair(), ActingDC
, Init
,
2766 ToType
, CandidateSet
);
2769 OverloadCandidateSet::iterator Best
;
2770 switch (CandidateSet
.BestViableFunction(S
, DeclLoc
, Best
)) {
2772 // C++ [over.ics.ref]p1:
2774 // [...] If the parameter binds directly to the result of
2775 // applying a conversion function to the argument
2776 // expression, the implicit conversion sequence is a
2777 // user-defined conversion sequence (13.3.3.1.2), with the
2778 // second standard conversion sequence either an identity
2779 // conversion or, if the conversion function returns an
2780 // entity of a type that is a derived class of the parameter
2781 // type, a derived-to-base Conversion.
2782 if (!Best
->FinalConversion
.DirectBinding
)
2785 ICS
.setUserDefined();
2786 ICS
.UserDefined
.Before
= Best
->Conversions
[0].Standard
;
2787 ICS
.UserDefined
.After
= Best
->FinalConversion
;
2788 ICS
.UserDefined
.ConversionFunction
= Best
->Function
;
2789 ICS
.UserDefined
.EllipsisConversion
= false;
2790 assert(ICS
.UserDefined
.After
.ReferenceBinding
&&
2791 ICS
.UserDefined
.After
.DirectBinding
&&
2792 "Expected a direct reference binding!");
2797 for (OverloadCandidateSet::iterator Cand
= CandidateSet
.begin();
2798 Cand
!= CandidateSet
.end(); ++Cand
)
2800 ICS
.Ambiguous
.addConversion(Cand
->Function
);
2803 case OR_No_Viable_Function
:
2805 // There was no suitable conversion, or we found a deleted
2806 // conversion; continue with other checks.
2813 /// \brief Compute an implicit conversion sequence for reference
2815 static ImplicitConversionSequence
2816 TryReferenceInit(Sema
&S
, Expr
*&Init
, QualType DeclType
,
2817 SourceLocation DeclLoc
,
2818 bool SuppressUserConversions
,
2819 bool AllowExplicit
) {
2820 assert(DeclType
->isReferenceType() && "Reference init needs a reference");
2822 // Most paths end in a failed conversion.
2823 ImplicitConversionSequence ICS
;
2824 ICS
.setBad(BadConversionSequence::no_conversion
, Init
, DeclType
);
2826 QualType T1
= DeclType
->getAs
<ReferenceType
>()->getPointeeType();
2827 QualType T2
= Init
->getType();
2829 // If the initializer is the address of an overloaded function, try
2830 // to resolve the overloaded function. If all goes well, T2 is the
2831 // type of the resulting function.
2832 if (S
.Context
.getCanonicalType(T2
) == S
.Context
.OverloadTy
) {
2833 DeclAccessPair Found
;
2834 if (FunctionDecl
*Fn
= S
.ResolveAddressOfOverloadedFunction(Init
, DeclType
,
2839 // Compute some basic properties of the types and the initializer.
2840 bool isRValRef
= DeclType
->isRValueReferenceType();
2841 bool DerivedToBase
= false;
2842 bool ObjCConversion
= false;
2843 Expr::Classification InitCategory
= Init
->Classify(S
.Context
);
2844 Sema::ReferenceCompareResult RefRelationship
2845 = S
.CompareReferenceRelationship(DeclLoc
, T1
, T2
, DerivedToBase
,
2849 // C++0x [dcl.init.ref]p5:
2850 // A reference to type "cv1 T1" is initialized by an expression
2851 // of type "cv2 T2" as follows:
2853 // -- If reference is an lvalue reference and the initializer expression
2854 // The next bullet point (T1 is a function) is pretty much equivalent to this
2855 // one, so it's handled here.
2856 if (!isRValRef
|| T1
->isFunctionType()) {
2857 // -- is an lvalue (but is not a bit-field), and "cv1 T1" is
2858 // reference-compatible with "cv2 T2," or
2860 // Per C++ [over.ics.ref]p4, we don't check the bit-field property here.
2861 if (InitCategory
.isLValue() &&
2862 RefRelationship
>= Sema::Ref_Compatible_With_Added_Qualification
) {
2863 // C++ [over.ics.ref]p1:
2864 // When a parameter of reference type binds directly (8.5.3)
2865 // to an argument expression, the implicit conversion sequence
2866 // is the identity conversion, unless the argument expression
2867 // has a type that is a derived class of the parameter type,
2868 // in which case the implicit conversion sequence is a
2869 // derived-to-base Conversion (13.3.3.1).
2871 ICS
.Standard
.First
= ICK_Identity
;
2872 ICS
.Standard
.Second
= DerivedToBase
? ICK_Derived_To_Base
2873 : ObjCConversion
? ICK_Compatible_Conversion
2875 ICS
.Standard
.Third
= ICK_Identity
;
2876 ICS
.Standard
.FromTypePtr
= T2
.getAsOpaquePtr();
2877 ICS
.Standard
.setToType(0, T2
);
2878 ICS
.Standard
.setToType(1, T1
);
2879 ICS
.Standard
.setToType(2, T1
);
2880 ICS
.Standard
.ReferenceBinding
= true;
2881 ICS
.Standard
.DirectBinding
= true;
2882 ICS
.Standard
.RRefBinding
= isRValRef
;
2883 ICS
.Standard
.CopyConstructor
= 0;
2885 // Nothing more to do: the inaccessibility/ambiguity check for
2886 // derived-to-base conversions is suppressed when we're
2887 // computing the implicit conversion sequence (C++
2888 // [over.best.ics]p2).
2892 // -- has a class type (i.e., T2 is a class type), where T1 is
2893 // not reference-related to T2, and can be implicitly
2894 // converted to an lvalue of type "cv3 T3," where "cv1 T1"
2895 // is reference-compatible with "cv3 T3" 92) (this
2896 // conversion is selected by enumerating the applicable
2897 // conversion functions (13.3.1.6) and choosing the best
2898 // one through overload resolution (13.3)),
2899 if (!SuppressUserConversions
&& T2
->isRecordType() &&
2900 !S
.RequireCompleteType(DeclLoc
, T2
, 0) &&
2901 RefRelationship
== Sema::Ref_Incompatible
) {
2902 if (FindConversionForRefInit(S
, ICS
, DeclType
, DeclLoc
,
2903 Init
, T2
, /*AllowRvalues=*/false,
2909 // -- Otherwise, the reference shall be an lvalue reference to a
2910 // non-volatile const type (i.e., cv1 shall be const), or the reference
2911 // shall be an rvalue reference and the initializer expression shall be
2912 // an rvalue or have a function type.
2914 // We actually handle one oddity of C++ [over.ics.ref] at this
2915 // point, which is that, due to p2 (which short-circuits reference
2916 // binding by only attempting a simple conversion for non-direct
2917 // bindings) and p3's strange wording, we allow a const volatile
2918 // reference to bind to an rvalue. Hence the check for the presence
2919 // of "const" rather than checking for "const" being the only
2921 // This is also the point where rvalue references and lvalue inits no longer
2923 if ((!isRValRef
&& !T1
.isConstQualified()) ||
2924 (isRValRef
&& InitCategory
.isLValue()))
2927 // -- If T1 is a function type, then
2928 // -- if T2 is the same type as T1, the reference is bound to the
2929 // initializer expression lvalue;
2930 // -- if T2 is a class type and the initializer expression can be
2931 // implicitly converted to an lvalue of type T1 [...], the
2932 // reference is bound to the function lvalue that is the result
2933 // of the conversion;
2934 // This is the same as for the lvalue case above, so it was handled there.
2935 // -- otherwise, the program is ill-formed.
2936 // This is the one difference to the lvalue case.
2937 if (T1
->isFunctionType())
2940 // -- Otherwise, if T2 is a class type and
2941 // -- the initializer expression is an rvalue and "cv1 T1"
2942 // is reference-compatible with "cv2 T2," or
2944 // -- T1 is not reference-related to T2 and the initializer
2945 // expression can be implicitly converted to an rvalue
2946 // of type "cv3 T3" (this conversion is selected by
2947 // enumerating the applicable conversion functions
2948 // (13.3.1.6) and choosing the best one through overload
2949 // resolution (13.3)),
2951 // then the reference is bound to the initializer
2952 // expression rvalue in the first case and to the object
2953 // that is the result of the conversion in the second case
2954 // (or, in either case, to the appropriate base class
2955 // subobject of the object).
2956 if (T2
->isRecordType()) {
2957 // First case: "cv1 T1" is reference-compatible with "cv2 T2". This is a
2958 // direct binding in C++0x but not in C++03.
2959 if (InitCategory
.isRValue() &&
2960 RefRelationship
>= Sema::Ref_Compatible_With_Added_Qualification
) {
2962 ICS
.Standard
.First
= ICK_Identity
;
2963 ICS
.Standard
.Second
= DerivedToBase
? ICK_Derived_To_Base
2964 : ObjCConversion
? ICK_Compatible_Conversion
2966 ICS
.Standard
.Third
= ICK_Identity
;
2967 ICS
.Standard
.FromTypePtr
= T2
.getAsOpaquePtr();
2968 ICS
.Standard
.setToType(0, T2
);
2969 ICS
.Standard
.setToType(1, T1
);
2970 ICS
.Standard
.setToType(2, T1
);
2971 ICS
.Standard
.ReferenceBinding
= true;
2972 ICS
.Standard
.DirectBinding
= S
.getLangOptions().CPlusPlus0x
;
2973 ICS
.Standard
.RRefBinding
= isRValRef
;
2974 ICS
.Standard
.CopyConstructor
= 0;
2978 // Second case: not reference-related.
2979 if (RefRelationship
== Sema::Ref_Incompatible
&&
2980 !S
.RequireCompleteType(DeclLoc
, T2
, 0) &&
2981 FindConversionForRefInit(S
, ICS
, DeclType
, DeclLoc
,
2982 Init
, T2
, /*AllowRvalues=*/true,
2987 // -- Otherwise, a temporary of type "cv1 T1" is created and
2988 // initialized from the initializer expression using the
2989 // rules for a non-reference copy initialization (8.5). The
2990 // reference is then bound to the temporary. If T1 is
2991 // reference-related to T2, cv1 must be the same
2992 // cv-qualification as, or greater cv-qualification than,
2993 // cv2; otherwise, the program is ill-formed.
2994 if (RefRelationship
== Sema::Ref_Related
) {
2995 // If cv1 == cv2 or cv1 is a greater cv-qualified than cv2, then
2996 // we would be reference-compatible or reference-compatible with
2997 // added qualification. But that wasn't the case, so the reference
2998 // initialization fails.
3002 // If at least one of the types is a class type, the types are not
3003 // related, and we aren't allowed any user conversions, the
3004 // reference binding fails. This case is important for breaking
3005 // recursion, since TryImplicitConversion below will attempt to
3006 // create a temporary through the use of a copy constructor.
3007 if (SuppressUserConversions
&& RefRelationship
== Sema::Ref_Incompatible
&&
3008 (T1
->isRecordType() || T2
->isRecordType()))
3011 // C++ [over.ics.ref]p2:
3012 // When a parameter of reference type is not bound directly to
3013 // an argument expression, the conversion sequence is the one
3014 // required to convert the argument expression to the
3015 // underlying type of the reference according to
3016 // 13.3.3.1. Conceptually, this conversion sequence corresponds
3017 // to copy-initializing a temporary of the underlying type with
3018 // the argument expression. Any difference in top-level
3019 // cv-qualification is subsumed by the initialization itself
3020 // and does not constitute a conversion.
3021 ICS
= TryImplicitConversion(S
, Init
, T1
, SuppressUserConversions
,
3022 /*AllowExplicit=*/false,
3023 /*InOverloadResolution=*/false);
3025 // Of course, that's still a reference binding.
3026 if (ICS
.isStandard()) {
3027 ICS
.Standard
.ReferenceBinding
= true;
3028 ICS
.Standard
.RRefBinding
= isRValRef
;
3029 } else if (ICS
.isUserDefined()) {
3030 ICS
.UserDefined
.After
.ReferenceBinding
= true;
3031 ICS
.UserDefined
.After
.RRefBinding
= isRValRef
;
3036 /// TryCopyInitialization - Try to copy-initialize a value of type
3037 /// ToType from the expression From. Return the implicit conversion
3038 /// sequence required to pass this argument, which may be a bad
3039 /// conversion sequence (meaning that the argument cannot be passed to
3040 /// a parameter of this type). If @p SuppressUserConversions, then we
3041 /// do not permit any user-defined conversion sequences.
3042 static ImplicitConversionSequence
3043 TryCopyInitialization(Sema
&S
, Expr
*From
, QualType ToType
,
3044 bool SuppressUserConversions
,
3045 bool InOverloadResolution
) {
3046 if (ToType
->isReferenceType())
3047 return TryReferenceInit(S
, From
, ToType
,
3048 /*FIXME:*/From
->getLocStart(),
3049 SuppressUserConversions
,
3050 /*AllowExplicit=*/false);
3052 return TryImplicitConversion(S
, From
, ToType
,
3053 SuppressUserConversions
,
3054 /*AllowExplicit=*/false,
3055 InOverloadResolution
);
3058 /// TryObjectArgumentInitialization - Try to initialize the object
3059 /// parameter of the given member function (@c Method) from the
3060 /// expression @p From.
3061 static ImplicitConversionSequence
3062 TryObjectArgumentInitialization(Sema
&S
, QualType OrigFromType
,
3063 CXXMethodDecl
*Method
,
3064 CXXRecordDecl
*ActingContext
) {
3065 QualType ClassType
= S
.Context
.getTypeDeclType(ActingContext
);
3066 // [class.dtor]p2: A destructor can be invoked for a const, volatile or
3067 // const volatile object.
3068 unsigned Quals
= isa
<CXXDestructorDecl
>(Method
) ?
3069 Qualifiers::Const
| Qualifiers::Volatile
: Method
->getTypeQualifiers();
3070 QualType ImplicitParamType
= S
.Context
.getCVRQualifiedType(ClassType
, Quals
);
3072 // Set up the conversion sequence as a "bad" conversion, to allow us
3074 ImplicitConversionSequence ICS
;
3076 // We need to have an object of class type.
3077 QualType FromType
= OrigFromType
;
3078 if (const PointerType
*PT
= FromType
->getAs
<PointerType
>())
3079 FromType
= PT
->getPointeeType();
3081 assert(FromType
->isRecordType());
3083 // The implicit object parameter is has the type "reference to cv X",
3084 // where X is the class of which the function is a member
3085 // (C++ [over.match.funcs]p4). However, when finding an implicit
3086 // conversion sequence for the argument, we are not allowed to
3087 // create temporaries or perform user-defined conversions
3088 // (C++ [over.match.funcs]p5). We perform a simplified version of
3089 // reference binding here, that allows class rvalues to bind to
3090 // non-constant references.
3092 // First check the qualifiers. We don't care about lvalue-vs-rvalue
3093 // with the implicit object parameter (C++ [over.match.funcs]p5).
3094 QualType FromTypeCanon
= S
.Context
.getCanonicalType(FromType
);
3095 if (ImplicitParamType
.getCVRQualifiers()
3096 != FromTypeCanon
.getLocalCVRQualifiers() &&
3097 !ImplicitParamType
.isAtLeastAsQualifiedAs(FromTypeCanon
)) {
3098 ICS
.setBad(BadConversionSequence::bad_qualifiers
,
3099 OrigFromType
, ImplicitParamType
);
3103 // Check that we have either the same type or a derived type. It
3104 // affects the conversion rank.
3105 QualType ClassTypeCanon
= S
.Context
.getCanonicalType(ClassType
);
3106 ImplicitConversionKind SecondKind
;
3107 if (ClassTypeCanon
== FromTypeCanon
.getLocalUnqualifiedType()) {
3108 SecondKind
= ICK_Identity
;
3109 } else if (S
.IsDerivedFrom(FromType
, ClassType
))
3110 SecondKind
= ICK_Derived_To_Base
;
3112 ICS
.setBad(BadConversionSequence::unrelated_class
,
3113 FromType
, ImplicitParamType
);
3117 // Success. Mark this as a reference binding.
3119 ICS
.Standard
.setAsIdentityConversion();
3120 ICS
.Standard
.Second
= SecondKind
;
3121 ICS
.Standard
.setFromType(FromType
);
3122 ICS
.Standard
.setAllToTypes(ImplicitParamType
);
3123 ICS
.Standard
.ReferenceBinding
= true;
3124 ICS
.Standard
.DirectBinding
= true;
3125 ICS
.Standard
.RRefBinding
= false;
3129 /// PerformObjectArgumentInitialization - Perform initialization of
3130 /// the implicit object parameter for the given Method with the given
3133 Sema::PerformObjectArgumentInitialization(Expr
*&From
,
3134 NestedNameSpecifier
*Qualifier
,
3135 NamedDecl
*FoundDecl
,
3136 CXXMethodDecl
*Method
) {
3137 QualType FromRecordType
, DestType
;
3138 QualType ImplicitParamRecordType
=
3139 Method
->getThisType(Context
)->getAs
<PointerType
>()->getPointeeType();
3141 if (const PointerType
*PT
= From
->getType()->getAs
<PointerType
>()) {
3142 FromRecordType
= PT
->getPointeeType();
3143 DestType
= Method
->getThisType(Context
);
3145 FromRecordType
= From
->getType();
3146 DestType
= ImplicitParamRecordType
;
3149 // Note that we always use the true parent context when performing
3150 // the actual argument initialization.
3151 ImplicitConversionSequence ICS
3152 = TryObjectArgumentInitialization(*this, From
->getType(), Method
,
3153 Method
->getParent());
3155 return Diag(From
->getSourceRange().getBegin(),
3156 diag::err_implicit_object_parameter_init
)
3157 << ImplicitParamRecordType
<< FromRecordType
<< From
->getSourceRange();
3159 if (ICS
.Standard
.Second
== ICK_Derived_To_Base
)
3160 return PerformObjectMemberConversion(From
, Qualifier
, FoundDecl
, Method
);
3162 if (!Context
.hasSameType(From
->getType(), DestType
))
3163 ImpCastExprToType(From
, DestType
, CK_NoOp
,
3164 From
->getType()->isPointerType() ? VK_RValue
: VK_LValue
);
3168 /// TryContextuallyConvertToBool - Attempt to contextually convert the
3169 /// expression From to bool (C++0x [conv]p3).
3170 static ImplicitConversionSequence
3171 TryContextuallyConvertToBool(Sema
&S
, Expr
*From
) {
3172 // FIXME: This is pretty broken.
3173 return TryImplicitConversion(S
, From
, S
.Context
.BoolTy
,
3174 // FIXME: Are these flags correct?
3175 /*SuppressUserConversions=*/false,
3176 /*AllowExplicit=*/true,
3177 /*InOverloadResolution=*/false);
3180 /// PerformContextuallyConvertToBool - Perform a contextual conversion
3181 /// of the expression From to bool (C++0x [conv]p3).
3182 bool Sema::PerformContextuallyConvertToBool(Expr
*&From
) {
3183 ImplicitConversionSequence ICS
= TryContextuallyConvertToBool(*this, From
);
3185 return PerformImplicitConversion(From
, Context
.BoolTy
, ICS
, AA_Converting
);
3187 if (!DiagnoseMultipleUserDefinedConversion(From
, Context
.BoolTy
))
3188 return Diag(From
->getSourceRange().getBegin(),
3189 diag::err_typecheck_bool_condition
)
3190 << From
->getType() << From
->getSourceRange();
3194 /// TryContextuallyConvertToObjCId - Attempt to contextually convert the
3195 /// expression From to 'id'.
3196 static ImplicitConversionSequence
3197 TryContextuallyConvertToObjCId(Sema
&S
, Expr
*From
) {
3198 QualType Ty
= S
.Context
.getObjCIdType();
3199 return TryImplicitConversion(S
, From
, Ty
,
3200 // FIXME: Are these flags correct?
3201 /*SuppressUserConversions=*/false,
3202 /*AllowExplicit=*/true,
3203 /*InOverloadResolution=*/false);
3206 /// PerformContextuallyConvertToObjCId - Perform a contextual conversion
3207 /// of the expression From to 'id'.
3208 bool Sema::PerformContextuallyConvertToObjCId(Expr
*&From
) {
3209 QualType Ty
= Context
.getObjCIdType();
3210 ImplicitConversionSequence ICS
= TryContextuallyConvertToObjCId(*this, From
);
3212 return PerformImplicitConversion(From
, Ty
, ICS
, AA_Converting
);
3216 /// \brief Attempt to convert the given expression to an integral or
3217 /// enumeration type.
3219 /// This routine will attempt to convert an expression of class type to an
3220 /// integral or enumeration type, if that class type only has a single
3221 /// conversion to an integral or enumeration type.
3223 /// \param Loc The source location of the construct that requires the
3226 /// \param FromE The expression we're converting from.
3228 /// \param NotIntDiag The diagnostic to be emitted if the expression does not
3229 /// have integral or enumeration type.
3231 /// \param IncompleteDiag The diagnostic to be emitted if the expression has
3232 /// incomplete class type.
3234 /// \param ExplicitConvDiag The diagnostic to be emitted if we're calling an
3235 /// explicit conversion function (because no implicit conversion functions
3236 /// were available). This is a recovery mode.
3238 /// \param ExplicitConvNote The note to be emitted with \p ExplicitConvDiag,
3239 /// showing which conversion was picked.
3241 /// \param AmbigDiag The diagnostic to be emitted if there is more than one
3242 /// conversion function that could convert to integral or enumeration type.
3244 /// \param AmbigNote The note to be emitted with \p AmbigDiag for each
3245 /// usable conversion function.
3247 /// \param ConvDiag The diagnostic to be emitted if we are calling a conversion
3248 /// function, which may be an extension in this case.
3250 /// \returns The expression, converted to an integral or enumeration type if
3253 Sema::ConvertToIntegralOrEnumerationType(SourceLocation Loc
, Expr
*From
,
3254 const PartialDiagnostic
&NotIntDiag
,
3255 const PartialDiagnostic
&IncompleteDiag
,
3256 const PartialDiagnostic
&ExplicitConvDiag
,
3257 const PartialDiagnostic
&ExplicitConvNote
,
3258 const PartialDiagnostic
&AmbigDiag
,
3259 const PartialDiagnostic
&AmbigNote
,
3260 const PartialDiagnostic
&ConvDiag
) {
3261 // We can't perform any more checking for type-dependent expressions.
3262 if (From
->isTypeDependent())
3265 // If the expression already has integral or enumeration type, we're golden.
3266 QualType T
= From
->getType();
3267 if (T
->isIntegralOrEnumerationType())
3270 // FIXME: Check for missing '()' if T is a function type?
3272 // If we don't have a class type in C++, there's no way we can get an
3273 // expression of integral or enumeration type.
3274 const RecordType
*RecordTy
= T
->getAs
<RecordType
>();
3275 if (!RecordTy
|| !getLangOptions().CPlusPlus
) {
3276 Diag(Loc
, NotIntDiag
)
3277 << T
<< From
->getSourceRange();
3281 // We must have a complete class type.
3282 if (RequireCompleteType(Loc
, T
, IncompleteDiag
))
3285 // Look for a conversion to an integral or enumeration type.
3286 UnresolvedSet
<4> ViableConversions
;
3287 UnresolvedSet
<4> ExplicitConversions
;
3288 const UnresolvedSetImpl
*Conversions
3289 = cast
<CXXRecordDecl
>(RecordTy
->getDecl())->getVisibleConversionFunctions();
3291 for (UnresolvedSetImpl::iterator I
= Conversions
->begin(),
3292 E
= Conversions
->end();
3295 if (CXXConversionDecl
*Conversion
3296 = dyn_cast
<CXXConversionDecl
>((*I
)->getUnderlyingDecl()))
3297 if (Conversion
->getConversionType().getNonReferenceType()
3298 ->isIntegralOrEnumerationType()) {
3299 if (Conversion
->isExplicit())
3300 ExplicitConversions
.addDecl(I
.getDecl(), I
.getAccess());
3302 ViableConversions
.addDecl(I
.getDecl(), I
.getAccess());
3306 switch (ViableConversions
.size()) {
3308 if (ExplicitConversions
.size() == 1) {
3309 DeclAccessPair Found
= ExplicitConversions
[0];
3310 CXXConversionDecl
*Conversion
3311 = cast
<CXXConversionDecl
>(Found
->getUnderlyingDecl());
3313 // The user probably meant to invoke the given explicit
3314 // conversion; use it.
3316 = Conversion
->getConversionType().getNonReferenceType();
3317 std::string TypeStr
;
3318 ConvTy
.getAsStringInternal(TypeStr
, Context
.PrintingPolicy
);
3320 Diag(Loc
, ExplicitConvDiag
)
3322 << FixItHint::CreateInsertion(From
->getLocStart(),
3323 "static_cast<" + TypeStr
+ ">(")
3324 << FixItHint::CreateInsertion(PP
.getLocForEndOfToken(From
->getLocEnd()),
3326 Diag(Conversion
->getLocation(), ExplicitConvNote
)
3327 << ConvTy
->isEnumeralType() << ConvTy
;
3329 // If we aren't in a SFINAE context, build a call to the
3330 // explicit conversion function.
3331 if (isSFINAEContext())
3334 CheckMemberOperatorAccess(From
->getExprLoc(), From
, 0, Found
);
3335 From
= BuildCXXMemberCallExpr(From
, Found
, Conversion
);
3338 // We'll complain below about a non-integral condition type.
3342 // Apply this conversion.
3343 DeclAccessPair Found
= ViableConversions
[0];
3344 CheckMemberOperatorAccess(From
->getExprLoc(), From
, 0, Found
);
3346 CXXConversionDecl
*Conversion
3347 = cast
<CXXConversionDecl
>(Found
->getUnderlyingDecl());
3349 = Conversion
->getConversionType().getNonReferenceType();
3350 if (ConvDiag
.getDiagID()) {
3351 if (isSFINAEContext())
3355 << T
<< ConvTy
->isEnumeralType() << ConvTy
<< From
->getSourceRange();
3358 From
= BuildCXXMemberCallExpr(From
, Found
,
3359 cast
<CXXConversionDecl
>(Found
->getUnderlyingDecl()));
3364 Diag(Loc
, AmbigDiag
)
3365 << T
<< From
->getSourceRange();
3366 for (unsigned I
= 0, N
= ViableConversions
.size(); I
!= N
; ++I
) {
3367 CXXConversionDecl
*Conv
3368 = cast
<CXXConversionDecl
>(ViableConversions
[I
]->getUnderlyingDecl());
3369 QualType ConvTy
= Conv
->getConversionType().getNonReferenceType();
3370 Diag(Conv
->getLocation(), AmbigNote
)
3371 << ConvTy
->isEnumeralType() << ConvTy
;
3376 if (!From
->getType()->isIntegralOrEnumerationType())
3377 Diag(Loc
, NotIntDiag
)
3378 << From
->getType() << From
->getSourceRange();
3383 /// AddOverloadCandidate - Adds the given function to the set of
3384 /// candidate functions, using the given function call arguments. If
3385 /// @p SuppressUserConversions, then don't allow user-defined
3386 /// conversions via constructors or conversion operators.
3388 /// \para PartialOverloading true if we are performing "partial" overloading
3389 /// based on an incomplete set of function arguments. This feature is used by
3390 /// code completion.
3392 Sema::AddOverloadCandidate(FunctionDecl
*Function
,
3393 DeclAccessPair FoundDecl
,
3394 Expr
**Args
, unsigned NumArgs
,
3395 OverloadCandidateSet
& CandidateSet
,
3396 bool SuppressUserConversions
,
3397 bool PartialOverloading
) {
3398 const FunctionProtoType
* Proto
3399 = dyn_cast
<FunctionProtoType
>(Function
->getType()->getAs
<FunctionType
>());
3400 assert(Proto
&& "Functions without a prototype cannot be overloaded");
3401 assert(!Function
->getDescribedFunctionTemplate() &&
3402 "Use AddTemplateOverloadCandidate for function templates");
3404 if (CXXMethodDecl
*Method
= dyn_cast
<CXXMethodDecl
>(Function
)) {
3405 if (!isa
<CXXConstructorDecl
>(Method
)) {
3406 // If we get here, it's because we're calling a member function
3407 // that is named without a member access expression (e.g.,
3408 // "this->f") that was either written explicitly or created
3409 // implicitly. This can happen with a qualified call to a member
3410 // function, e.g., X::f(). We use an empty type for the implied
3411 // object argument (C++ [over.call.func]p3), and the acting context
3413 AddMethodCandidate(Method
, FoundDecl
, Method
->getParent(),
3414 QualType(), Args
, NumArgs
, CandidateSet
,
3415 SuppressUserConversions
);
3418 // We treat a constructor like a non-member function, since its object
3419 // argument doesn't participate in overload resolution.
3422 if (!CandidateSet
.isNewCandidate(Function
))
3425 // Overload resolution is always an unevaluated context.
3426 EnterExpressionEvaluationContext
Unevaluated(*this, Sema::Unevaluated
);
3428 if (CXXConstructorDecl
*Constructor
= dyn_cast
<CXXConstructorDecl
>(Function
)){
3429 // C++ [class.copy]p3:
3430 // A member function template is never instantiated to perform the copy
3431 // of a class object to an object of its class type.
3432 QualType ClassType
= Context
.getTypeDeclType(Constructor
->getParent());
3434 Constructor
->isCopyConstructorLikeSpecialization() &&
3435 (Context
.hasSameUnqualifiedType(ClassType
, Args
[0]->getType()) ||
3436 IsDerivedFrom(Args
[0]->getType(), ClassType
)))
3440 // Add this candidate
3441 CandidateSet
.push_back(OverloadCandidate());
3442 OverloadCandidate
& Candidate
= CandidateSet
.back();
3443 Candidate
.FoundDecl
= FoundDecl
;
3444 Candidate
.Function
= Function
;
3445 Candidate
.Viable
= true;
3446 Candidate
.IsSurrogate
= false;
3447 Candidate
.IgnoreObjectArgument
= false;
3449 unsigned NumArgsInProto
= Proto
->getNumArgs();
3451 // (C++ 13.3.2p2): A candidate function having fewer than m
3452 // parameters is viable only if it has an ellipsis in its parameter
3454 if ((NumArgs
+ (PartialOverloading
&& NumArgs
)) > NumArgsInProto
&&
3455 !Proto
->isVariadic()) {
3456 Candidate
.Viable
= false;
3457 Candidate
.FailureKind
= ovl_fail_too_many_arguments
;
3461 // (C++ 13.3.2p2): A candidate function having more than m parameters
3462 // is viable only if the (m+1)st parameter has a default argument
3463 // (8.3.6). For the purposes of overload resolution, the
3464 // parameter list is truncated on the right, so that there are
3465 // exactly m parameters.
3466 unsigned MinRequiredArgs
= Function
->getMinRequiredArguments();
3467 if (NumArgs
< MinRequiredArgs
&& !PartialOverloading
) {
3468 // Not enough arguments.
3469 Candidate
.Viable
= false;
3470 Candidate
.FailureKind
= ovl_fail_too_few_arguments
;
3474 // Determine the implicit conversion sequences for each of the
3476 Candidate
.Conversions
.resize(NumArgs
);
3477 for (unsigned ArgIdx
= 0; ArgIdx
< NumArgs
; ++ArgIdx
) {
3478 if (ArgIdx
< NumArgsInProto
) {
3479 // (C++ 13.3.2p3): for F to be a viable function, there shall
3480 // exist for each argument an implicit conversion sequence
3481 // (13.3.3.1) that converts that argument to the corresponding
3483 QualType ParamType
= Proto
->getArgType(ArgIdx
);
3484 Candidate
.Conversions
[ArgIdx
]
3485 = TryCopyInitialization(*this, Args
[ArgIdx
], ParamType
,
3486 SuppressUserConversions
,
3487 /*InOverloadResolution=*/true);
3488 if (Candidate
.Conversions
[ArgIdx
].isBad()) {
3489 Candidate
.Viable
= false;
3490 Candidate
.FailureKind
= ovl_fail_bad_conversion
;
3494 // (C++ 13.3.2p2): For the purposes of overload resolution, any
3495 // argument for which there is no corresponding parameter is
3496 // considered to ""match the ellipsis" (C+ 13.3.3.1.3).
3497 Candidate
.Conversions
[ArgIdx
].setEllipsis();
3502 /// \brief Add all of the function declarations in the given function set to
3503 /// the overload canddiate set.
3504 void Sema::AddFunctionCandidates(const UnresolvedSetImpl
&Fns
,
3505 Expr
**Args
, unsigned NumArgs
,
3506 OverloadCandidateSet
& CandidateSet
,
3507 bool SuppressUserConversions
) {
3508 for (UnresolvedSetIterator F
= Fns
.begin(), E
= Fns
.end(); F
!= E
; ++F
) {
3509 NamedDecl
*D
= F
.getDecl()->getUnderlyingDecl();
3510 if (FunctionDecl
*FD
= dyn_cast
<FunctionDecl
>(D
)) {
3511 if (isa
<CXXMethodDecl
>(FD
) && !cast
<CXXMethodDecl
>(FD
)->isStatic())
3512 AddMethodCandidate(cast
<CXXMethodDecl
>(FD
), F
.getPair(),
3513 cast
<CXXMethodDecl
>(FD
)->getParent(),
3514 Args
[0]->getType(), Args
+ 1, NumArgs
- 1,
3515 CandidateSet
, SuppressUserConversions
);
3517 AddOverloadCandidate(FD
, F
.getPair(), Args
, NumArgs
, CandidateSet
,
3518 SuppressUserConversions
);
3520 FunctionTemplateDecl
*FunTmpl
= cast
<FunctionTemplateDecl
>(D
);
3521 if (isa
<CXXMethodDecl
>(FunTmpl
->getTemplatedDecl()) &&
3522 !cast
<CXXMethodDecl
>(FunTmpl
->getTemplatedDecl())->isStatic())
3523 AddMethodTemplateCandidate(FunTmpl
, F
.getPair(),
3524 cast
<CXXRecordDecl
>(FunTmpl
->getDeclContext()),
3525 /*FIXME: explicit args */ 0,
3526 Args
[0]->getType(), Args
+ 1, NumArgs
- 1,
3528 SuppressUserConversions
);
3530 AddTemplateOverloadCandidate(FunTmpl
, F
.getPair(),
3531 /*FIXME: explicit args */ 0,
3532 Args
, NumArgs
, CandidateSet
,
3533 SuppressUserConversions
);
3538 /// AddMethodCandidate - Adds a named decl (which is some kind of
3539 /// method) as a method candidate to the given overload set.
3540 void Sema::AddMethodCandidate(DeclAccessPair FoundDecl
,
3541 QualType ObjectType
,
3542 Expr
**Args
, unsigned NumArgs
,
3543 OverloadCandidateSet
& CandidateSet
,
3544 bool SuppressUserConversions
) {
3545 NamedDecl
*Decl
= FoundDecl
.getDecl();
3546 CXXRecordDecl
*ActingContext
= cast
<CXXRecordDecl
>(Decl
->getDeclContext());
3548 if (isa
<UsingShadowDecl
>(Decl
))
3549 Decl
= cast
<UsingShadowDecl
>(Decl
)->getTargetDecl();
3551 if (FunctionTemplateDecl
*TD
= dyn_cast
<FunctionTemplateDecl
>(Decl
)) {
3552 assert(isa
<CXXMethodDecl
>(TD
->getTemplatedDecl()) &&
3553 "Expected a member function template");
3554 AddMethodTemplateCandidate(TD
, FoundDecl
, ActingContext
,
3556 ObjectType
, Args
, NumArgs
,
3558 SuppressUserConversions
);
3560 AddMethodCandidate(cast
<CXXMethodDecl
>(Decl
), FoundDecl
, ActingContext
,
3561 ObjectType
, Args
, NumArgs
,
3562 CandidateSet
, SuppressUserConversions
);
3566 /// AddMethodCandidate - Adds the given C++ member function to the set
3567 /// of candidate functions, using the given function call arguments
3568 /// and the object argument (@c Object). For example, in a call
3569 /// @c o.f(a1,a2), @c Object will contain @c o and @c Args will contain
3570 /// both @c a1 and @c a2. If @p SuppressUserConversions, then don't
3571 /// allow user-defined conversions via constructors or conversion
3574 Sema::AddMethodCandidate(CXXMethodDecl
*Method
, DeclAccessPair FoundDecl
,
3575 CXXRecordDecl
*ActingContext
, QualType ObjectType
,
3576 Expr
**Args
, unsigned NumArgs
,
3577 OverloadCandidateSet
& CandidateSet
,
3578 bool SuppressUserConversions
) {
3579 const FunctionProtoType
* Proto
3580 = dyn_cast
<FunctionProtoType
>(Method
->getType()->getAs
<FunctionType
>());
3581 assert(Proto
&& "Methods without a prototype cannot be overloaded");
3582 assert(!isa
<CXXConstructorDecl
>(Method
) &&
3583 "Use AddOverloadCandidate for constructors");
3585 if (!CandidateSet
.isNewCandidate(Method
))
3588 // Overload resolution is always an unevaluated context.
3589 EnterExpressionEvaluationContext
Unevaluated(*this, Sema::Unevaluated
);
3591 // Add this candidate
3592 CandidateSet
.push_back(OverloadCandidate());
3593 OverloadCandidate
& Candidate
= CandidateSet
.back();
3594 Candidate
.FoundDecl
= FoundDecl
;
3595 Candidate
.Function
= Method
;
3596 Candidate
.IsSurrogate
= false;
3597 Candidate
.IgnoreObjectArgument
= false;
3599 unsigned NumArgsInProto
= Proto
->getNumArgs();
3601 // (C++ 13.3.2p2): A candidate function having fewer than m
3602 // parameters is viable only if it has an ellipsis in its parameter
3604 if (NumArgs
> NumArgsInProto
&& !Proto
->isVariadic()) {
3605 Candidate
.Viable
= false;
3606 Candidate
.FailureKind
= ovl_fail_too_many_arguments
;
3610 // (C++ 13.3.2p2): A candidate function having more than m parameters
3611 // is viable only if the (m+1)st parameter has a default argument
3612 // (8.3.6). For the purposes of overload resolution, the
3613 // parameter list is truncated on the right, so that there are
3614 // exactly m parameters.
3615 unsigned MinRequiredArgs
= Method
->getMinRequiredArguments();
3616 if (NumArgs
< MinRequiredArgs
) {
3617 // Not enough arguments.
3618 Candidate
.Viable
= false;
3619 Candidate
.FailureKind
= ovl_fail_too_few_arguments
;
3623 Candidate
.Viable
= true;
3624 Candidate
.Conversions
.resize(NumArgs
+ 1);
3626 if (Method
->isStatic() || ObjectType
.isNull())
3627 // The implicit object argument is ignored.
3628 Candidate
.IgnoreObjectArgument
= true;
3630 // Determine the implicit conversion sequence for the object
3632 Candidate
.Conversions
[0]
3633 = TryObjectArgumentInitialization(*this, ObjectType
, Method
,
3635 if (Candidate
.Conversions
[0].isBad()) {
3636 Candidate
.Viable
= false;
3637 Candidate
.FailureKind
= ovl_fail_bad_conversion
;
3642 // Determine the implicit conversion sequences for each of the
3644 for (unsigned ArgIdx
= 0; ArgIdx
< NumArgs
; ++ArgIdx
) {
3645 if (ArgIdx
< NumArgsInProto
) {
3646 // (C++ 13.3.2p3): for F to be a viable function, there shall
3647 // exist for each argument an implicit conversion sequence
3648 // (13.3.3.1) that converts that argument to the corresponding
3650 QualType ParamType
= Proto
->getArgType(ArgIdx
);
3651 Candidate
.Conversions
[ArgIdx
+ 1]
3652 = TryCopyInitialization(*this, Args
[ArgIdx
], ParamType
,
3653 SuppressUserConversions
,
3654 /*InOverloadResolution=*/true);
3655 if (Candidate
.Conversions
[ArgIdx
+ 1].isBad()) {
3656 Candidate
.Viable
= false;
3657 Candidate
.FailureKind
= ovl_fail_bad_conversion
;
3661 // (C++ 13.3.2p2): For the purposes of overload resolution, any
3662 // argument for which there is no corresponding parameter is
3663 // considered to ""match the ellipsis" (C+ 13.3.3.1.3).
3664 Candidate
.Conversions
[ArgIdx
+ 1].setEllipsis();
3669 /// \brief Add a C++ member function template as a candidate to the candidate
3670 /// set, using template argument deduction to produce an appropriate member
3671 /// function template specialization.
3673 Sema::AddMethodTemplateCandidate(FunctionTemplateDecl
*MethodTmpl
,
3674 DeclAccessPair FoundDecl
,
3675 CXXRecordDecl
*ActingContext
,
3676 const TemplateArgumentListInfo
*ExplicitTemplateArgs
,
3677 QualType ObjectType
,
3678 Expr
**Args
, unsigned NumArgs
,
3679 OverloadCandidateSet
& CandidateSet
,
3680 bool SuppressUserConversions
) {
3681 if (!CandidateSet
.isNewCandidate(MethodTmpl
))
3684 // C++ [over.match.funcs]p7:
3685 // In each case where a candidate is a function template, candidate
3686 // function template specializations are generated using template argument
3687 // deduction (14.8.3, 14.8.2). Those candidates are then handled as
3688 // candidate functions in the usual way.113) A given name can refer to one
3689 // or more function templates and also to a set of overloaded non-template
3690 // functions. In such a case, the candidate functions generated from each
3691 // function template are combined with the set of non-template candidate
3693 TemplateDeductionInfo
Info(Context
, CandidateSet
.getLocation());
3694 FunctionDecl
*Specialization
= 0;
3695 if (TemplateDeductionResult Result
3696 = DeduceTemplateArguments(MethodTmpl
, ExplicitTemplateArgs
,
3697 Args
, NumArgs
, Specialization
, Info
)) {
3698 CandidateSet
.push_back(OverloadCandidate());
3699 OverloadCandidate
&Candidate
= CandidateSet
.back();
3700 Candidate
.FoundDecl
= FoundDecl
;
3701 Candidate
.Function
= MethodTmpl
->getTemplatedDecl();
3702 Candidate
.Viable
= false;
3703 Candidate
.FailureKind
= ovl_fail_bad_deduction
;
3704 Candidate
.IsSurrogate
= false;
3705 Candidate
.IgnoreObjectArgument
= false;
3706 Candidate
.DeductionFailure
= MakeDeductionFailureInfo(Context
, Result
,
3711 // Add the function template specialization produced by template argument
3712 // deduction as a candidate.
3713 assert(Specialization
&& "Missing member function template specialization?");
3714 assert(isa
<CXXMethodDecl
>(Specialization
) &&
3715 "Specialization is not a member function?");
3716 AddMethodCandidate(cast
<CXXMethodDecl
>(Specialization
), FoundDecl
,
3717 ActingContext
, ObjectType
, Args
, NumArgs
,
3718 CandidateSet
, SuppressUserConversions
);
3721 /// \brief Add a C++ function template specialization as a candidate
3722 /// in the candidate set, using template argument deduction to produce
3723 /// an appropriate function template specialization.
3725 Sema::AddTemplateOverloadCandidate(FunctionTemplateDecl
*FunctionTemplate
,
3726 DeclAccessPair FoundDecl
,
3727 const TemplateArgumentListInfo
*ExplicitTemplateArgs
,
3728 Expr
**Args
, unsigned NumArgs
,
3729 OverloadCandidateSet
& CandidateSet
,
3730 bool SuppressUserConversions
) {
3731 if (!CandidateSet
.isNewCandidate(FunctionTemplate
))
3734 // C++ [over.match.funcs]p7:
3735 // In each case where a candidate is a function template, candidate
3736 // function template specializations are generated using template argument
3737 // deduction (14.8.3, 14.8.2). Those candidates are then handled as
3738 // candidate functions in the usual way.113) A given name can refer to one
3739 // or more function templates and also to a set of overloaded non-template
3740 // functions. In such a case, the candidate functions generated from each
3741 // function template are combined with the set of non-template candidate
3743 TemplateDeductionInfo
Info(Context
, CandidateSet
.getLocation());
3744 FunctionDecl
*Specialization
= 0;
3745 if (TemplateDeductionResult Result
3746 = DeduceTemplateArguments(FunctionTemplate
, ExplicitTemplateArgs
,
3747 Args
, NumArgs
, Specialization
, Info
)) {
3748 CandidateSet
.push_back(OverloadCandidate());
3749 OverloadCandidate
&Candidate
= CandidateSet
.back();
3750 Candidate
.FoundDecl
= FoundDecl
;
3751 Candidate
.Function
= FunctionTemplate
->getTemplatedDecl();
3752 Candidate
.Viable
= false;
3753 Candidate
.FailureKind
= ovl_fail_bad_deduction
;
3754 Candidate
.IsSurrogate
= false;
3755 Candidate
.IgnoreObjectArgument
= false;
3756 Candidate
.DeductionFailure
= MakeDeductionFailureInfo(Context
, Result
,
3761 // Add the function template specialization produced by template argument
3762 // deduction as a candidate.
3763 assert(Specialization
&& "Missing function template specialization?");
3764 AddOverloadCandidate(Specialization
, FoundDecl
, Args
, NumArgs
, CandidateSet
,
3765 SuppressUserConversions
);
3768 /// AddConversionCandidate - Add a C++ conversion function as a
3769 /// candidate in the candidate set (C++ [over.match.conv],
3770 /// C++ [over.match.copy]). From is the expression we're converting from,
3771 /// and ToType is the type that we're eventually trying to convert to
3772 /// (which may or may not be the same type as the type that the
3773 /// conversion function produces).
3775 Sema::AddConversionCandidate(CXXConversionDecl
*Conversion
,
3776 DeclAccessPair FoundDecl
,
3777 CXXRecordDecl
*ActingContext
,
3778 Expr
*From
, QualType ToType
,
3779 OverloadCandidateSet
& CandidateSet
) {
3780 assert(!Conversion
->getDescribedFunctionTemplate() &&
3781 "Conversion function templates use AddTemplateConversionCandidate");
3782 QualType ConvType
= Conversion
->getConversionType().getNonReferenceType();
3783 if (!CandidateSet
.isNewCandidate(Conversion
))
3786 // Overload resolution is always an unevaluated context.
3787 EnterExpressionEvaluationContext
Unevaluated(*this, Sema::Unevaluated
);
3789 // Add this candidate
3790 CandidateSet
.push_back(OverloadCandidate());
3791 OverloadCandidate
& Candidate
= CandidateSet
.back();
3792 Candidate
.FoundDecl
= FoundDecl
;
3793 Candidate
.Function
= Conversion
;
3794 Candidate
.IsSurrogate
= false;
3795 Candidate
.IgnoreObjectArgument
= false;
3796 Candidate
.FinalConversion
.setAsIdentityConversion();
3797 Candidate
.FinalConversion
.setFromType(ConvType
);
3798 Candidate
.FinalConversion
.setAllToTypes(ToType
);
3799 Candidate
.Viable
= true;
3800 Candidate
.Conversions
.resize(1);
3802 // C++ [over.match.funcs]p4:
3803 // For conversion functions, the function is considered to be a member of
3804 // the class of the implicit implied object argument for the purpose of
3805 // defining the type of the implicit object parameter.
3807 // Determine the implicit conversion sequence for the implicit
3808 // object parameter.
3809 QualType ImplicitParamType
= From
->getType();
3810 if (const PointerType
*FromPtrType
= ImplicitParamType
->getAs
<PointerType
>())
3811 ImplicitParamType
= FromPtrType
->getPointeeType();
3812 CXXRecordDecl
*ConversionContext
3813 = cast
<CXXRecordDecl
>(ImplicitParamType
->getAs
<RecordType
>()->getDecl());
3815 Candidate
.Conversions
[0]
3816 = TryObjectArgumentInitialization(*this, From
->getType(), Conversion
,
3819 if (Candidate
.Conversions
[0].isBad()) {
3820 Candidate
.Viable
= false;
3821 Candidate
.FailureKind
= ovl_fail_bad_conversion
;
3825 // We won't go through a user-define type conversion function to convert a
3826 // derived to base as such conversions are given Conversion Rank. They only
3827 // go through a copy constructor. 13.3.3.1.2-p4 [over.ics.user]
3829 = Context
.getCanonicalType(From
->getType().getUnqualifiedType());
3830 QualType ToCanon
= Context
.getCanonicalType(ToType
).getUnqualifiedType();
3831 if (FromCanon
== ToCanon
|| IsDerivedFrom(FromCanon
, ToCanon
)) {
3832 Candidate
.Viable
= false;
3833 Candidate
.FailureKind
= ovl_fail_trivial_conversion
;
3837 // To determine what the conversion from the result of calling the
3838 // conversion function to the type we're eventually trying to
3839 // convert to (ToType), we need to synthesize a call to the
3840 // conversion function and attempt copy initialization from it. This
3841 // makes sure that we get the right semantics with respect to
3842 // lvalues/rvalues and the type. Fortunately, we can allocate this
3843 // call on the stack and we don't need its arguments to be
3845 DeclRefExpr
ConversionRef(Conversion
, Conversion
->getType(),
3846 From
->getLocStart());
3847 ImplicitCastExpr
ConversionFn(ImplicitCastExpr::OnStack
,
3848 Context
.getPointerType(Conversion
->getType()),
3849 CK_FunctionToPointerDecay
,
3850 &ConversionRef
, VK_RValue
);
3852 // Note that it is safe to allocate CallExpr on the stack here because
3853 // there are 0 arguments (i.e., nothing is allocated using ASTContext's
3855 CallExpr
Call(Context
, &ConversionFn
, 0, 0,
3856 Conversion
->getConversionType().getNonLValueExprType(Context
),
3857 From
->getLocStart());
3858 ImplicitConversionSequence ICS
=
3859 TryCopyInitialization(*this, &Call
, ToType
,
3860 /*SuppressUserConversions=*/true,
3861 /*InOverloadResolution=*/false);
3863 switch (ICS
.getKind()) {
3864 case ImplicitConversionSequence::StandardConversion
:
3865 Candidate
.FinalConversion
= ICS
.Standard
;
3867 // C++ [over.ics.user]p3:
3868 // If the user-defined conversion is specified by a specialization of a
3869 // conversion function template, the second standard conversion sequence
3870 // shall have exact match rank.
3871 if (Conversion
->getPrimaryTemplate() &&
3872 GetConversionRank(ICS
.Standard
.Second
) != ICR_Exact_Match
) {
3873 Candidate
.Viable
= false;
3874 Candidate
.FailureKind
= ovl_fail_final_conversion_not_exact
;
3879 case ImplicitConversionSequence::BadConversion
:
3880 Candidate
.Viable
= false;
3881 Candidate
.FailureKind
= ovl_fail_bad_final_conversion
;
3886 "Can only end up with a standard conversion sequence or failure");
3890 /// \brief Adds a conversion function template specialization
3891 /// candidate to the overload set, using template argument deduction
3892 /// to deduce the template arguments of the conversion function
3893 /// template from the type that we are converting to (C++
3894 /// [temp.deduct.conv]).
3896 Sema::AddTemplateConversionCandidate(FunctionTemplateDecl
*FunctionTemplate
,
3897 DeclAccessPair FoundDecl
,
3898 CXXRecordDecl
*ActingDC
,
3899 Expr
*From
, QualType ToType
,
3900 OverloadCandidateSet
&CandidateSet
) {
3901 assert(isa
<CXXConversionDecl
>(FunctionTemplate
->getTemplatedDecl()) &&
3902 "Only conversion function templates permitted here");
3904 if (!CandidateSet
.isNewCandidate(FunctionTemplate
))
3907 TemplateDeductionInfo
Info(Context
, CandidateSet
.getLocation());
3908 CXXConversionDecl
*Specialization
= 0;
3909 if (TemplateDeductionResult Result
3910 = DeduceTemplateArguments(FunctionTemplate
, ToType
,
3911 Specialization
, Info
)) {
3912 CandidateSet
.push_back(OverloadCandidate());
3913 OverloadCandidate
&Candidate
= CandidateSet
.back();
3914 Candidate
.FoundDecl
= FoundDecl
;
3915 Candidate
.Function
= FunctionTemplate
->getTemplatedDecl();
3916 Candidate
.Viable
= false;
3917 Candidate
.FailureKind
= ovl_fail_bad_deduction
;
3918 Candidate
.IsSurrogate
= false;
3919 Candidate
.IgnoreObjectArgument
= false;
3920 Candidate
.DeductionFailure
= MakeDeductionFailureInfo(Context
, Result
,
3925 // Add the conversion function template specialization produced by
3926 // template argument deduction as a candidate.
3927 assert(Specialization
&& "Missing function template specialization?");
3928 AddConversionCandidate(Specialization
, FoundDecl
, ActingDC
, From
, ToType
,
3932 /// AddSurrogateCandidate - Adds a "surrogate" candidate function that
3933 /// converts the given @c Object to a function pointer via the
3934 /// conversion function @c Conversion, and then attempts to call it
3935 /// with the given arguments (C++ [over.call.object]p2-4). Proto is
3936 /// the type of function that we'll eventually be calling.
3937 void Sema::AddSurrogateCandidate(CXXConversionDecl
*Conversion
,
3938 DeclAccessPair FoundDecl
,
3939 CXXRecordDecl
*ActingContext
,
3940 const FunctionProtoType
*Proto
,
3941 QualType ObjectType
,
3942 Expr
**Args
, unsigned NumArgs
,
3943 OverloadCandidateSet
& CandidateSet
) {
3944 if (!CandidateSet
.isNewCandidate(Conversion
))
3947 // Overload resolution is always an unevaluated context.
3948 EnterExpressionEvaluationContext
Unevaluated(*this, Sema::Unevaluated
);
3950 CandidateSet
.push_back(OverloadCandidate());
3951 OverloadCandidate
& Candidate
= CandidateSet
.back();
3952 Candidate
.FoundDecl
= FoundDecl
;
3953 Candidate
.Function
= 0;
3954 Candidate
.Surrogate
= Conversion
;
3955 Candidate
.Viable
= true;
3956 Candidate
.IsSurrogate
= true;
3957 Candidate
.IgnoreObjectArgument
= false;
3958 Candidate
.Conversions
.resize(NumArgs
+ 1);
3960 // Determine the implicit conversion sequence for the implicit
3961 // object parameter.
3962 ImplicitConversionSequence ObjectInit
3963 = TryObjectArgumentInitialization(*this, ObjectType
, Conversion
,
3965 if (ObjectInit
.isBad()) {
3966 Candidate
.Viable
= false;
3967 Candidate
.FailureKind
= ovl_fail_bad_conversion
;
3968 Candidate
.Conversions
[0] = ObjectInit
;
3972 // The first conversion is actually a user-defined conversion whose
3973 // first conversion is ObjectInit's standard conversion (which is
3974 // effectively a reference binding). Record it as such.
3975 Candidate
.Conversions
[0].setUserDefined();
3976 Candidate
.Conversions
[0].UserDefined
.Before
= ObjectInit
.Standard
;
3977 Candidate
.Conversions
[0].UserDefined
.EllipsisConversion
= false;
3978 Candidate
.Conversions
[0].UserDefined
.ConversionFunction
= Conversion
;
3979 Candidate
.Conversions
[0].UserDefined
.After
3980 = Candidate
.Conversions
[0].UserDefined
.Before
;
3981 Candidate
.Conversions
[0].UserDefined
.After
.setAsIdentityConversion();
3984 unsigned NumArgsInProto
= Proto
->getNumArgs();
3986 // (C++ 13.3.2p2): A candidate function having fewer than m
3987 // parameters is viable only if it has an ellipsis in its parameter
3989 if (NumArgs
> NumArgsInProto
&& !Proto
->isVariadic()) {
3990 Candidate
.Viable
= false;
3991 Candidate
.FailureKind
= ovl_fail_too_many_arguments
;
3995 // Function types don't have any default arguments, so just check if
3996 // we have enough arguments.
3997 if (NumArgs
< NumArgsInProto
) {
3998 // Not enough arguments.
3999 Candidate
.Viable
= false;
4000 Candidate
.FailureKind
= ovl_fail_too_few_arguments
;
4004 // Determine the implicit conversion sequences for each of the
4006 for (unsigned ArgIdx
= 0; ArgIdx
< NumArgs
; ++ArgIdx
) {
4007 if (ArgIdx
< NumArgsInProto
) {
4008 // (C++ 13.3.2p3): for F to be a viable function, there shall
4009 // exist for each argument an implicit conversion sequence
4010 // (13.3.3.1) that converts that argument to the corresponding
4012 QualType ParamType
= Proto
->getArgType(ArgIdx
);
4013 Candidate
.Conversions
[ArgIdx
+ 1]
4014 = TryCopyInitialization(*this, Args
[ArgIdx
], ParamType
,
4015 /*SuppressUserConversions=*/false,
4016 /*InOverloadResolution=*/false);
4017 if (Candidate
.Conversions
[ArgIdx
+ 1].isBad()) {
4018 Candidate
.Viable
= false;
4019 Candidate
.FailureKind
= ovl_fail_bad_conversion
;
4023 // (C++ 13.3.2p2): For the purposes of overload resolution, any
4024 // argument for which there is no corresponding parameter is
4025 // considered to ""match the ellipsis" (C+ 13.3.3.1.3).
4026 Candidate
.Conversions
[ArgIdx
+ 1].setEllipsis();
4031 /// \brief Add overload candidates for overloaded operators that are
4032 /// member functions.
4034 /// Add the overloaded operator candidates that are member functions
4035 /// for the operator Op that was used in an operator expression such
4036 /// as "x Op y". , Args/NumArgs provides the operator arguments, and
4037 /// CandidateSet will store the added overload candidates. (C++
4038 /// [over.match.oper]).
4039 void Sema::AddMemberOperatorCandidates(OverloadedOperatorKind Op
,
4040 SourceLocation OpLoc
,
4041 Expr
**Args
, unsigned NumArgs
,
4042 OverloadCandidateSet
& CandidateSet
,
4043 SourceRange OpRange
) {
4044 DeclarationName OpName
= Context
.DeclarationNames
.getCXXOperatorName(Op
);
4046 // C++ [over.match.oper]p3:
4047 // For a unary operator @ with an operand of a type whose
4048 // cv-unqualified version is T1, and for a binary operator @ with
4049 // a left operand of a type whose cv-unqualified version is T1 and
4050 // a right operand of a type whose cv-unqualified version is T2,
4051 // three sets of candidate functions, designated member
4052 // candidates, non-member candidates and built-in candidates, are
4053 // constructed as follows:
4054 QualType T1
= Args
[0]->getType();
4056 // -- If T1 is a class type, the set of member candidates is the
4057 // result of the qualified lookup of T1::operator@
4058 // (13.3.1.1.1); otherwise, the set of member candidates is
4060 if (const RecordType
*T1Rec
= T1
->getAs
<RecordType
>()) {
4061 // Complete the type if it can be completed. Otherwise, we're done.
4062 if (RequireCompleteType(OpLoc
, T1
, PDiag()))
4065 LookupResult
Operators(*this, OpName
, OpLoc
, LookupOrdinaryName
);
4066 LookupQualifiedName(Operators
, T1Rec
->getDecl());
4067 Operators
.suppressDiagnostics();
4069 for (LookupResult::iterator Oper
= Operators
.begin(),
4070 OperEnd
= Operators
.end();
4073 AddMethodCandidate(Oper
.getPair(), Args
[0]->getType(),
4074 Args
+ 1, NumArgs
- 1, CandidateSet
,
4075 /* SuppressUserConversions = */ false);
4079 /// AddBuiltinCandidate - Add a candidate for a built-in
4080 /// operator. ResultTy and ParamTys are the result and parameter types
4081 /// of the built-in candidate, respectively. Args and NumArgs are the
4082 /// arguments being passed to the candidate. IsAssignmentOperator
4083 /// should be true when this built-in candidate is an assignment
4084 /// operator. NumContextualBoolArguments is the number of arguments
4085 /// (at the beginning of the argument list) that will be contextually
4086 /// converted to bool.
4087 void Sema::AddBuiltinCandidate(QualType ResultTy
, QualType
*ParamTys
,
4088 Expr
**Args
, unsigned NumArgs
,
4089 OverloadCandidateSet
& CandidateSet
,
4090 bool IsAssignmentOperator
,
4091 unsigned NumContextualBoolArguments
) {
4092 // Overload resolution is always an unevaluated context.
4093 EnterExpressionEvaluationContext
Unevaluated(*this, Sema::Unevaluated
);
4095 // Add this candidate
4096 CandidateSet
.push_back(OverloadCandidate());
4097 OverloadCandidate
& Candidate
= CandidateSet
.back();
4098 Candidate
.FoundDecl
= DeclAccessPair::make(0, AS_none
);
4099 Candidate
.Function
= 0;
4100 Candidate
.IsSurrogate
= false;
4101 Candidate
.IgnoreObjectArgument
= false;
4102 Candidate
.BuiltinTypes
.ResultTy
= ResultTy
;
4103 for (unsigned ArgIdx
= 0; ArgIdx
< NumArgs
; ++ArgIdx
)
4104 Candidate
.BuiltinTypes
.ParamTypes
[ArgIdx
] = ParamTys
[ArgIdx
];
4106 // Determine the implicit conversion sequences for each of the
4108 Candidate
.Viable
= true;
4109 Candidate
.Conversions
.resize(NumArgs
);
4110 for (unsigned ArgIdx
= 0; ArgIdx
< NumArgs
; ++ArgIdx
) {
4111 // C++ [over.match.oper]p4:
4112 // For the built-in assignment operators, conversions of the
4113 // left operand are restricted as follows:
4114 // -- no temporaries are introduced to hold the left operand, and
4115 // -- no user-defined conversions are applied to the left
4116 // operand to achieve a type match with the left-most
4117 // parameter of a built-in candidate.
4119 // We block these conversions by turning off user-defined
4120 // conversions, since that is the only way that initialization of
4121 // a reference to a non-class type can occur from something that
4122 // is not of the same type.
4123 if (ArgIdx
< NumContextualBoolArguments
) {
4124 assert(ParamTys
[ArgIdx
] == Context
.BoolTy
&&
4125 "Contextual conversion to bool requires bool type");
4126 Candidate
.Conversions
[ArgIdx
]
4127 = TryContextuallyConvertToBool(*this, Args
[ArgIdx
]);
4129 Candidate
.Conversions
[ArgIdx
]
4130 = TryCopyInitialization(*this, Args
[ArgIdx
], ParamTys
[ArgIdx
],
4131 ArgIdx
== 0 && IsAssignmentOperator
,
4132 /*InOverloadResolution=*/false);
4134 if (Candidate
.Conversions
[ArgIdx
].isBad()) {
4135 Candidate
.Viable
= false;
4136 Candidate
.FailureKind
= ovl_fail_bad_conversion
;
4142 /// BuiltinCandidateTypeSet - A set of types that will be used for the
4143 /// candidate operator functions for built-in operators (C++
4144 /// [over.built]). The types are separated into pointer types and
4145 /// enumeration types.
4146 class BuiltinCandidateTypeSet
{
4147 /// TypeSet - A set of types.
4148 typedef llvm::SmallPtrSet
<QualType
, 8> TypeSet
;
4150 /// PointerTypes - The set of pointer types that will be used in the
4151 /// built-in candidates.
4152 TypeSet PointerTypes
;
4154 /// MemberPointerTypes - The set of member pointer types that will be
4155 /// used in the built-in candidates.
4156 TypeSet MemberPointerTypes
;
4158 /// EnumerationTypes - The set of enumeration types that will be
4159 /// used in the built-in candidates.
4160 TypeSet EnumerationTypes
;
4162 /// \brief The set of vector types that will be used in the built-in
4164 TypeSet VectorTypes
;
4166 /// Sema - The semantic analysis instance where we are building the
4167 /// candidate type set.
4170 /// Context - The AST context in which we will build the type sets.
4171 ASTContext
&Context
;
4173 bool AddPointerWithMoreQualifiedTypeVariants(QualType Ty
,
4174 const Qualifiers
&VisibleQuals
);
4175 bool AddMemberPointerWithMoreQualifiedTypeVariants(QualType Ty
);
4178 /// iterator - Iterates through the types that are part of the set.
4179 typedef TypeSet::iterator iterator
;
4181 BuiltinCandidateTypeSet(Sema
&SemaRef
)
4182 : SemaRef(SemaRef
), Context(SemaRef
.Context
) { }
4184 void AddTypesConvertedFrom(QualType Ty
,
4186 bool AllowUserConversions
,
4187 bool AllowExplicitConversions
,
4188 const Qualifiers
&VisibleTypeConversionsQuals
);
4190 /// pointer_begin - First pointer type found;
4191 iterator
pointer_begin() { return PointerTypes
.begin(); }
4193 /// pointer_end - Past the last pointer type found;
4194 iterator
pointer_end() { return PointerTypes
.end(); }
4196 /// member_pointer_begin - First member pointer type found;
4197 iterator
member_pointer_begin() { return MemberPointerTypes
.begin(); }
4199 /// member_pointer_end - Past the last member pointer type found;
4200 iterator
member_pointer_end() { return MemberPointerTypes
.end(); }
4202 /// enumeration_begin - First enumeration type found;
4203 iterator
enumeration_begin() { return EnumerationTypes
.begin(); }
4205 /// enumeration_end - Past the last enumeration type found;
4206 iterator
enumeration_end() { return EnumerationTypes
.end(); }
4208 iterator
vector_begin() { return VectorTypes
.begin(); }
4209 iterator
vector_end() { return VectorTypes
.end(); }
4212 /// AddPointerWithMoreQualifiedTypeVariants - Add the pointer type @p Ty to
4213 /// the set of pointer types along with any more-qualified variants of
4214 /// that type. For example, if @p Ty is "int const *", this routine
4215 /// will add "int const *", "int const volatile *", "int const
4216 /// restrict *", and "int const volatile restrict *" to the set of
4217 /// pointer types. Returns true if the add of @p Ty itself succeeded,
4218 /// false otherwise.
4220 /// FIXME: what to do about extended qualifiers?
4222 BuiltinCandidateTypeSet::AddPointerWithMoreQualifiedTypeVariants(QualType Ty
,
4223 const Qualifiers
&VisibleQuals
) {
4225 // Insert this type.
4226 if (!PointerTypes
.insert(Ty
))
4230 const PointerType
*PointerTy
= Ty
->getAs
<PointerType
>();
4231 bool buildObjCPtr
= false;
4233 if (const ObjCObjectPointerType
*PTy
= Ty
->getAs
<ObjCObjectPointerType
>()) {
4234 PointeeTy
= PTy
->getPointeeType();
4235 buildObjCPtr
= true;
4238 assert(false && "type was not a pointer type!");
4241 PointeeTy
= PointerTy
->getPointeeType();
4243 // Don't add qualified variants of arrays. For one, they're not allowed
4244 // (the qualifier would sink to the element type), and for another, the
4245 // only overload situation where it matters is subscript or pointer +- int,
4246 // and those shouldn't have qualifier variants anyway.
4247 if (PointeeTy
->isArrayType())
4249 unsigned BaseCVR
= PointeeTy
.getCVRQualifiers();
4250 if (const ConstantArrayType
*Array
=Context
.getAsConstantArrayType(PointeeTy
))
4251 BaseCVR
= Array
->getElementType().getCVRQualifiers();
4252 bool hasVolatile
= VisibleQuals
.hasVolatile();
4253 bool hasRestrict
= VisibleQuals
.hasRestrict();
4255 // Iterate through all strict supersets of BaseCVR.
4256 for (unsigned CVR
= BaseCVR
+1; CVR
<= Qualifiers::CVRMask
; ++CVR
) {
4257 if ((CVR
| BaseCVR
) != CVR
) continue;
4258 // Skip over Volatile/Restrict if no Volatile/Restrict found anywhere
4260 if ((CVR
& Qualifiers::Volatile
) && !hasVolatile
) continue;
4261 if ((CVR
& Qualifiers::Restrict
) && !hasRestrict
) continue;
4262 QualType QPointeeTy
= Context
.getCVRQualifiedType(PointeeTy
, CVR
);
4264 PointerTypes
.insert(Context
.getPointerType(QPointeeTy
));
4266 PointerTypes
.insert(Context
.getObjCObjectPointerType(QPointeeTy
));
4272 /// AddMemberPointerWithMoreQualifiedTypeVariants - Add the pointer type @p Ty
4273 /// to the set of pointer types along with any more-qualified variants of
4274 /// that type. For example, if @p Ty is "int const *", this routine
4275 /// will add "int const *", "int const volatile *", "int const
4276 /// restrict *", and "int const volatile restrict *" to the set of
4277 /// pointer types. Returns true if the add of @p Ty itself succeeded,
4278 /// false otherwise.
4280 /// FIXME: what to do about extended qualifiers?
4282 BuiltinCandidateTypeSet::AddMemberPointerWithMoreQualifiedTypeVariants(
4284 // Insert this type.
4285 if (!MemberPointerTypes
.insert(Ty
))
4288 const MemberPointerType
*PointerTy
= Ty
->getAs
<MemberPointerType
>();
4289 assert(PointerTy
&& "type was not a member pointer type!");
4291 QualType PointeeTy
= PointerTy
->getPointeeType();
4292 // Don't add qualified variants of arrays. For one, they're not allowed
4293 // (the qualifier would sink to the element type), and for another, the
4294 // only overload situation where it matters is subscript or pointer +- int,
4295 // and those shouldn't have qualifier variants anyway.
4296 if (PointeeTy
->isArrayType())
4298 const Type
*ClassTy
= PointerTy
->getClass();
4300 // Iterate through all strict supersets of the pointee type's CVR
4302 unsigned BaseCVR
= PointeeTy
.getCVRQualifiers();
4303 for (unsigned CVR
= BaseCVR
+1; CVR
<= Qualifiers::CVRMask
; ++CVR
) {
4304 if ((CVR
| BaseCVR
) != CVR
) continue;
4306 QualType QPointeeTy
= Context
.getCVRQualifiedType(PointeeTy
, CVR
);
4307 MemberPointerTypes
.insert(Context
.getMemberPointerType(QPointeeTy
, ClassTy
));
4313 /// AddTypesConvertedFrom - Add each of the types to which the type @p
4314 /// Ty can be implicit converted to the given set of @p Types. We're
4315 /// primarily interested in pointer types and enumeration types. We also
4316 /// take member pointer types, for the conditional operator.
4317 /// AllowUserConversions is true if we should look at the conversion
4318 /// functions of a class type, and AllowExplicitConversions if we
4319 /// should also include the explicit conversion functions of a class
4322 BuiltinCandidateTypeSet::AddTypesConvertedFrom(QualType Ty
,
4324 bool AllowUserConversions
,
4325 bool AllowExplicitConversions
,
4326 const Qualifiers
&VisibleQuals
) {
4327 // Only deal with canonical types.
4328 Ty
= Context
.getCanonicalType(Ty
);
4330 // Look through reference types; they aren't part of the type of an
4331 // expression for the purposes of conversions.
4332 if (const ReferenceType
*RefTy
= Ty
->getAs
<ReferenceType
>())
4333 Ty
= RefTy
->getPointeeType();
4335 // We don't care about qualifiers on the type.
4336 Ty
= Ty
.getLocalUnqualifiedType();
4338 // If we're dealing with an array type, decay to the pointer.
4339 if (Ty
->isArrayType())
4340 Ty
= SemaRef
.Context
.getArrayDecayedType(Ty
);
4341 if (Ty
->isObjCIdType() || Ty
->isObjCClassType())
4342 PointerTypes
.insert(Ty
);
4343 else if (Ty
->getAs
<PointerType
>() || Ty
->getAs
<ObjCObjectPointerType
>()) {
4344 // Insert our type, and its more-qualified variants, into the set
4346 if (!AddPointerWithMoreQualifiedTypeVariants(Ty
, VisibleQuals
))
4348 } else if (Ty
->isMemberPointerType()) {
4349 // Member pointers are far easier, since the pointee can't be converted.
4350 if (!AddMemberPointerWithMoreQualifiedTypeVariants(Ty
))
4352 } else if (Ty
->isEnumeralType()) {
4353 EnumerationTypes
.insert(Ty
);
4354 } else if (Ty
->isVectorType()) {
4355 VectorTypes
.insert(Ty
);
4356 } else if (AllowUserConversions
) {
4357 if (const RecordType
*TyRec
= Ty
->getAs
<RecordType
>()) {
4358 if (SemaRef
.RequireCompleteType(Loc
, Ty
, 0)) {
4359 // No conversion functions in incomplete types.
4363 CXXRecordDecl
*ClassDecl
= cast
<CXXRecordDecl
>(TyRec
->getDecl());
4364 const UnresolvedSetImpl
*Conversions
4365 = ClassDecl
->getVisibleConversionFunctions();
4366 for (UnresolvedSetImpl::iterator I
= Conversions
->begin(),
4367 E
= Conversions
->end(); I
!= E
; ++I
) {
4368 NamedDecl
*D
= I
.getDecl();
4369 if (isa
<UsingShadowDecl
>(D
))
4370 D
= cast
<UsingShadowDecl
>(D
)->getTargetDecl();
4372 // Skip conversion function templates; they don't tell us anything
4373 // about which builtin types we can convert to.
4374 if (isa
<FunctionTemplateDecl
>(D
))
4377 CXXConversionDecl
*Conv
= cast
<CXXConversionDecl
>(D
);
4378 if (AllowExplicitConversions
|| !Conv
->isExplicit()) {
4379 AddTypesConvertedFrom(Conv
->getConversionType(), Loc
, false, false,
4387 /// \brief Helper function for AddBuiltinOperatorCandidates() that adds
4388 /// the volatile- and non-volatile-qualified assignment operators for the
4389 /// given type to the candidate set.
4390 static void AddBuiltinAssignmentOperatorCandidates(Sema
&S
,
4394 OverloadCandidateSet
&CandidateSet
) {
4395 QualType ParamTypes
[2];
4397 // T& operator=(T&, T)
4398 ParamTypes
[0] = S
.Context
.getLValueReferenceType(T
);
4400 S
.AddBuiltinCandidate(ParamTypes
[0], ParamTypes
, Args
, 2, CandidateSet
,
4401 /*IsAssignmentOperator=*/true);
4403 if (!S
.Context
.getCanonicalType(T
).isVolatileQualified()) {
4404 // volatile T& operator=(volatile T&, T)
4406 = S
.Context
.getLValueReferenceType(S
.Context
.getVolatileType(T
));
4408 S
.AddBuiltinCandidate(ParamTypes
[0], ParamTypes
, Args
, 2, CandidateSet
,
4409 /*IsAssignmentOperator=*/true);
4413 /// CollectVRQualifiers - This routine returns Volatile/Restrict qualifiers,
4414 /// if any, found in visible type conversion functions found in ArgExpr's type.
4415 static Qualifiers
CollectVRQualifiers(ASTContext
&Context
, Expr
* ArgExpr
) {
4417 const RecordType
*TyRec
;
4418 if (const MemberPointerType
*RHSMPType
=
4419 ArgExpr
->getType()->getAs
<MemberPointerType
>())
4420 TyRec
= RHSMPType
->getClass()->getAs
<RecordType
>();
4422 TyRec
= ArgExpr
->getType()->getAs
<RecordType
>();
4424 // Just to be safe, assume the worst case.
4425 VRQuals
.addVolatile();
4426 VRQuals
.addRestrict();
4430 CXXRecordDecl
*ClassDecl
= cast
<CXXRecordDecl
>(TyRec
->getDecl());
4431 if (!ClassDecl
->hasDefinition())
4434 const UnresolvedSetImpl
*Conversions
=
4435 ClassDecl
->getVisibleConversionFunctions();
4437 for (UnresolvedSetImpl::iterator I
= Conversions
->begin(),
4438 E
= Conversions
->end(); I
!= E
; ++I
) {
4439 NamedDecl
*D
= I
.getDecl();
4440 if (isa
<UsingShadowDecl
>(D
))
4441 D
= cast
<UsingShadowDecl
>(D
)->getTargetDecl();
4442 if (CXXConversionDecl
*Conv
= dyn_cast
<CXXConversionDecl
>(D
)) {
4443 QualType CanTy
= Context
.getCanonicalType(Conv
->getConversionType());
4444 if (const ReferenceType
*ResTypeRef
= CanTy
->getAs
<ReferenceType
>())
4445 CanTy
= ResTypeRef
->getPointeeType();
4446 // Need to go down the pointer/mempointer chain and add qualifiers
4450 if (const PointerType
*ResTypePtr
= CanTy
->getAs
<PointerType
>())
4451 CanTy
= ResTypePtr
->getPointeeType();
4452 else if (const MemberPointerType
*ResTypeMPtr
=
4453 CanTy
->getAs
<MemberPointerType
>())
4454 CanTy
= ResTypeMPtr
->getPointeeType();
4457 if (CanTy
.isVolatileQualified())
4458 VRQuals
.addVolatile();
4459 if (CanTy
.isRestrictQualified())
4460 VRQuals
.addRestrict();
4461 if (VRQuals
.hasRestrict() && VRQuals
.hasVolatile())
4469 /// AddBuiltinOperatorCandidates - Add the appropriate built-in
4470 /// operator overloads to the candidate set (C++ [over.built]), based
4471 /// on the operator @p Op and the arguments given. For example, if the
4472 /// operator is a binary '+', this routine might add "int
4473 /// operator+(int, int)" to cover integer addition.
4475 Sema::AddBuiltinOperatorCandidates(OverloadedOperatorKind Op
,
4476 SourceLocation OpLoc
,
4477 Expr
**Args
, unsigned NumArgs
,
4478 OverloadCandidateSet
& CandidateSet
) {
4479 // The set of "promoted arithmetic types", which are the arithmetic
4480 // types are that preserved by promotion (C++ [over.built]p2). Note
4481 // that the first few of these types are the promoted integral
4482 // types; these types need to be first.
4483 // FIXME: What about complex?
4484 const unsigned FirstIntegralType
= 0;
4485 const unsigned LastIntegralType
= 13;
4486 const unsigned FirstPromotedIntegralType
= 7,
4487 LastPromotedIntegralType
= 13;
4488 const unsigned FirstPromotedArithmeticType
= 7,
4489 LastPromotedArithmeticType
= 16;
4490 const unsigned NumArithmeticTypes
= 16;
4491 QualType ArithmeticTypes
[NumArithmeticTypes
] = {
4492 Context
.BoolTy
, Context
.CharTy
, Context
.WCharTy
,
4493 // FIXME: Context.Char16Ty, Context.Char32Ty,
4494 Context
.SignedCharTy
, Context
.ShortTy
,
4495 Context
.UnsignedCharTy
, Context
.UnsignedShortTy
,
4496 Context
.IntTy
, Context
.LongTy
, Context
.LongLongTy
,
4497 Context
.UnsignedIntTy
, Context
.UnsignedLongTy
, Context
.UnsignedLongLongTy
,
4498 Context
.FloatTy
, Context
.DoubleTy
, Context
.LongDoubleTy
4500 assert(ArithmeticTypes
[FirstPromotedIntegralType
] == Context
.IntTy
&&
4501 "Invalid first promoted integral type");
4502 assert(ArithmeticTypes
[LastPromotedIntegralType
- 1]
4503 == Context
.UnsignedLongLongTy
&&
4504 "Invalid last promoted integral type");
4505 assert(ArithmeticTypes
[FirstPromotedArithmeticType
] == Context
.IntTy
&&
4506 "Invalid first promoted arithmetic type");
4507 assert(ArithmeticTypes
[LastPromotedArithmeticType
- 1]
4508 == Context
.LongDoubleTy
&&
4509 "Invalid last promoted arithmetic type");
4511 // Find all of the types that the arguments can convert to, but only
4512 // if the operator we're looking at has built-in operator candidates
4513 // that make use of these types.
4514 Qualifiers VisibleTypeConversionsQuals
;
4515 VisibleTypeConversionsQuals
.addConst();
4516 for (unsigned ArgIdx
= 0; ArgIdx
< NumArgs
; ++ArgIdx
)
4517 VisibleTypeConversionsQuals
+= CollectVRQualifiers(Context
, Args
[ArgIdx
]);
4519 BuiltinCandidateTypeSet
CandidateTypes(*this);
4520 for (unsigned ArgIdx
= 0; ArgIdx
< NumArgs
; ++ArgIdx
)
4521 CandidateTypes
.AddTypesConvertedFrom(Args
[ArgIdx
]->getType(),
4524 (Op
== OO_Exclaim
||
4527 VisibleTypeConversionsQuals
);
4529 bool isComparison
= false;
4532 case NUM_OVERLOADED_OPERATORS
:
4533 assert(false && "Expected an overloaded operator");
4536 case OO_Star
: // '*' is either unary or binary
4543 case OO_Plus
: // '+' is either unary or binary
4550 case OO_Minus
: // '-' is either unary or binary
4557 case OO_Amp
: // '&' is either unary or binary
4565 // C++ [over.built]p3:
4567 // For every pair (T, VQ), where T is an arithmetic type, and VQ
4568 // is either volatile or empty, there exist candidate operator
4569 // functions of the form
4571 // VQ T& operator++(VQ T&);
4572 // T operator++(VQ T&, int);
4574 // C++ [over.built]p4:
4576 // For every pair (T, VQ), where T is an arithmetic type other
4577 // than bool, and VQ is either volatile or empty, there exist
4578 // candidate operator functions of the form
4580 // VQ T& operator--(VQ T&);
4581 // T operator--(VQ T&, int);
4582 for (unsigned Arith
= (Op
== OO_PlusPlus
? 0 : 1);
4583 Arith
< NumArithmeticTypes
; ++Arith
) {
4584 QualType ArithTy
= ArithmeticTypes
[Arith
];
4585 QualType ParamTypes
[2]
4586 = { Context
.getLValueReferenceType(ArithTy
), Context
.IntTy
};
4588 // Non-volatile version.
4590 AddBuiltinCandidate(ParamTypes
[0], ParamTypes
, Args
, 1, CandidateSet
);
4592 AddBuiltinCandidate(ArithTy
, ParamTypes
, Args
, 2, CandidateSet
);
4593 // heuristic to reduce number of builtin candidates in the set.
4594 // Add volatile version only if there are conversions to a volatile type.
4595 if (VisibleTypeConversionsQuals
.hasVolatile()) {
4598 = Context
.getLValueReferenceType(Context
.getVolatileType(ArithTy
));
4600 AddBuiltinCandidate(ParamTypes
[0], ParamTypes
, Args
, 1, CandidateSet
);
4602 AddBuiltinCandidate(ArithTy
, ParamTypes
, Args
, 2, CandidateSet
);
4606 // C++ [over.built]p5:
4608 // For every pair (T, VQ), where T is a cv-qualified or
4609 // cv-unqualified object type, and VQ is either volatile or
4610 // empty, there exist candidate operator functions of the form
4612 // T*VQ& operator++(T*VQ&);
4613 // T*VQ& operator--(T*VQ&);
4614 // T* operator++(T*VQ&, int);
4615 // T* operator--(T*VQ&, int);
4616 for (BuiltinCandidateTypeSet::iterator Ptr
= CandidateTypes
.pointer_begin();
4617 Ptr
!= CandidateTypes
.pointer_end(); ++Ptr
) {
4618 // Skip pointer types that aren't pointers to object types.
4619 if (!(*Ptr
)->getPointeeType()->isIncompleteOrObjectType())
4622 QualType ParamTypes
[2] = {
4623 Context
.getLValueReferenceType(*Ptr
), Context
.IntTy
4628 AddBuiltinCandidate(ParamTypes
[0], ParamTypes
, Args
, 1, CandidateSet
);
4630 AddBuiltinCandidate(*Ptr
, ParamTypes
, Args
, 2, CandidateSet
);
4632 if (!Context
.getCanonicalType(*Ptr
).isVolatileQualified() &&
4633 VisibleTypeConversionsQuals
.hasVolatile()) {
4636 = Context
.getLValueReferenceType(Context
.getVolatileType(*Ptr
));
4638 AddBuiltinCandidate(ParamTypes
[0], ParamTypes
, Args
, 1, CandidateSet
);
4640 AddBuiltinCandidate(*Ptr
, ParamTypes
, Args
, 2, CandidateSet
);
4646 // C++ [over.built]p6:
4647 // For every cv-qualified or cv-unqualified object type T, there
4648 // exist candidate operator functions of the form
4650 // T& operator*(T*);
4652 // C++ [over.built]p7:
4653 // For every function type T, there exist candidate operator
4654 // functions of the form
4655 // T& operator*(T*);
4656 for (BuiltinCandidateTypeSet::iterator Ptr
= CandidateTypes
.pointer_begin();
4657 Ptr
!= CandidateTypes
.pointer_end(); ++Ptr
) {
4658 QualType ParamTy
= *Ptr
;
4659 QualType PointeeTy
= ParamTy
->getPointeeType();
4660 AddBuiltinCandidate(Context
.getLValueReferenceType(PointeeTy
),
4661 &ParamTy
, Args
, 1, CandidateSet
);
4666 // C++ [over.built]p8:
4667 // For every type T, there exist candidate operator functions of
4670 // T* operator+(T*);
4671 for (BuiltinCandidateTypeSet::iterator Ptr
= CandidateTypes
.pointer_begin();
4672 Ptr
!= CandidateTypes
.pointer_end(); ++Ptr
) {
4673 QualType ParamTy
= *Ptr
;
4674 AddBuiltinCandidate(ParamTy
, &ParamTy
, Args
, 1, CandidateSet
);
4680 // C++ [over.built]p9:
4681 // For every promoted arithmetic type T, there exist candidate
4682 // operator functions of the form
4686 for (unsigned Arith
= FirstPromotedArithmeticType
;
4687 Arith
< LastPromotedArithmeticType
; ++Arith
) {
4688 QualType ArithTy
= ArithmeticTypes
[Arith
];
4689 AddBuiltinCandidate(ArithTy
, &ArithTy
, Args
, 1, CandidateSet
);
4692 // Extension: We also add these operators for vector types.
4693 for (BuiltinCandidateTypeSet::iterator Vec
= CandidateTypes
.vector_begin(),
4694 VecEnd
= CandidateTypes
.vector_end();
4695 Vec
!= VecEnd
; ++Vec
) {
4696 QualType VecTy
= *Vec
;
4697 AddBuiltinCandidate(VecTy
, &VecTy
, Args
, 1, CandidateSet
);
4702 // C++ [over.built]p10:
4703 // For every promoted integral type T, there exist candidate
4704 // operator functions of the form
4707 for (unsigned Int
= FirstPromotedIntegralType
;
4708 Int
< LastPromotedIntegralType
; ++Int
) {
4709 QualType IntTy
= ArithmeticTypes
[Int
];
4710 AddBuiltinCandidate(IntTy
, &IntTy
, Args
, 1, CandidateSet
);
4713 // Extension: We also add this operator for vector types.
4714 for (BuiltinCandidateTypeSet::iterator Vec
= CandidateTypes
.vector_begin(),
4715 VecEnd
= CandidateTypes
.vector_end();
4716 Vec
!= VecEnd
; ++Vec
) {
4717 QualType VecTy
= *Vec
;
4718 AddBuiltinCandidate(VecTy
, &VecTy
, Args
, 1, CandidateSet
);
4725 case OO_Array_Delete
:
4727 assert(false && "Special operators don't use AddBuiltinOperatorCandidates");
4733 // C++ [over.match.oper]p3:
4734 // -- For the operator ',', the unary operator '&', or the
4735 // operator '->', the built-in candidates set is empty.
4739 case OO_ExclaimEqual
:
4740 // C++ [over.match.oper]p16:
4741 // For every pointer to member type T, there exist candidate operator
4742 // functions of the form
4744 // bool operator==(T,T);
4745 // bool operator!=(T,T);
4746 for (BuiltinCandidateTypeSet::iterator
4747 MemPtr
= CandidateTypes
.member_pointer_begin(),
4748 MemPtrEnd
= CandidateTypes
.member_pointer_end();
4749 MemPtr
!= MemPtrEnd
;
4751 QualType ParamTypes
[2] = { *MemPtr
, *MemPtr
};
4752 AddBuiltinCandidate(Context
.BoolTy
, ParamTypes
, Args
, 2, CandidateSet
);
4760 case OO_GreaterEqual
:
4761 // C++ [over.built]p15:
4763 // For every pointer or enumeration type T, there exist
4764 // candidate operator functions of the form
4766 // bool operator<(T, T);
4767 // bool operator>(T, T);
4768 // bool operator<=(T, T);
4769 // bool operator>=(T, T);
4770 // bool operator==(T, T);
4771 // bool operator!=(T, T);
4772 for (BuiltinCandidateTypeSet::iterator Ptr
= CandidateTypes
.pointer_begin();
4773 Ptr
!= CandidateTypes
.pointer_end(); ++Ptr
) {
4774 QualType ParamTypes
[2] = { *Ptr
, *Ptr
};
4775 AddBuiltinCandidate(Context
.BoolTy
, ParamTypes
, Args
, 2, CandidateSet
);
4777 for (BuiltinCandidateTypeSet::iterator Enum
4778 = CandidateTypes
.enumeration_begin();
4779 Enum
!= CandidateTypes
.enumeration_end(); ++Enum
) {
4780 QualType ParamTypes
[2] = { *Enum
, *Enum
};
4781 AddBuiltinCandidate(Context
.BoolTy
, ParamTypes
, Args
, 2, CandidateSet
);
4785 isComparison
= true;
4789 if (!isComparison
) {
4790 // We didn't fall through, so we must have OO_Plus or OO_Minus.
4792 // C++ [over.built]p13:
4794 // For every cv-qualified or cv-unqualified object type T
4795 // there exist candidate operator functions of the form
4797 // T* operator+(T*, ptrdiff_t);
4798 // T& operator[](T*, ptrdiff_t); [BELOW]
4799 // T* operator-(T*, ptrdiff_t);
4800 // T* operator+(ptrdiff_t, T*);
4801 // T& operator[](ptrdiff_t, T*); [BELOW]
4803 // C++ [over.built]p14:
4805 // For every T, where T is a pointer to object type, there
4806 // exist candidate operator functions of the form
4808 // ptrdiff_t operator-(T, T);
4809 for (BuiltinCandidateTypeSet::iterator Ptr
4810 = CandidateTypes
.pointer_begin();
4811 Ptr
!= CandidateTypes
.pointer_end(); ++Ptr
) {
4812 QualType ParamTypes
[2] = { *Ptr
, Context
.getPointerDiffType() };
4814 // operator+(T*, ptrdiff_t) or operator-(T*, ptrdiff_t)
4815 AddBuiltinCandidate(*Ptr
, ParamTypes
, Args
, 2, CandidateSet
);
4817 if (Op
== OO_Plus
) {
4818 // T* operator+(ptrdiff_t, T*);
4819 ParamTypes
[0] = ParamTypes
[1];
4820 ParamTypes
[1] = *Ptr
;
4821 AddBuiltinCandidate(*Ptr
, ParamTypes
, Args
, 2, CandidateSet
);
4823 // ptrdiff_t operator-(T, T);
4824 ParamTypes
[1] = *Ptr
;
4825 AddBuiltinCandidate(Context
.getPointerDiffType(), ParamTypes
,
4826 Args
, 2, CandidateSet
);
4835 // C++ [over.built]p12:
4837 // For every pair of promoted arithmetic types L and R, there
4838 // exist candidate operator functions of the form
4840 // LR operator*(L, R);
4841 // LR operator/(L, R);
4842 // LR operator+(L, R);
4843 // LR operator-(L, R);
4844 // bool operator<(L, R);
4845 // bool operator>(L, R);
4846 // bool operator<=(L, R);
4847 // bool operator>=(L, R);
4848 // bool operator==(L, R);
4849 // bool operator!=(L, R);
4851 // where LR is the result of the usual arithmetic conversions
4852 // between types L and R.
4854 // C++ [over.built]p24:
4856 // For every pair of promoted arithmetic types L and R, there exist
4857 // candidate operator functions of the form
4859 // LR operator?(bool, L, R);
4861 // where LR is the result of the usual arithmetic conversions
4862 // between types L and R.
4863 // Our candidates ignore the first parameter.
4864 for (unsigned Left
= FirstPromotedArithmeticType
;
4865 Left
< LastPromotedArithmeticType
; ++Left
) {
4866 for (unsigned Right
= FirstPromotedArithmeticType
;
4867 Right
< LastPromotedArithmeticType
; ++Right
) {
4868 QualType LandR
[2] = { ArithmeticTypes
[Left
], ArithmeticTypes
[Right
] };
4872 : Context
.UsualArithmeticConversionsType(LandR
[0], LandR
[1]);
4873 AddBuiltinCandidate(Result
, LandR
, Args
, 2, CandidateSet
);
4877 // Extension: Add the binary operators ==, !=, <, <=, >=, >, *, /, and the
4878 // conditional operator for vector types.
4879 for (BuiltinCandidateTypeSet::iterator Vec1
= CandidateTypes
.vector_begin(),
4880 Vec1End
= CandidateTypes
.vector_end();
4881 Vec1
!= Vec1End
; ++Vec1
)
4882 for (BuiltinCandidateTypeSet::iterator
4883 Vec2
= CandidateTypes
.vector_begin(),
4884 Vec2End
= CandidateTypes
.vector_end();
4885 Vec2
!= Vec2End
; ++Vec2
) {
4886 QualType LandR
[2] = { *Vec1
, *Vec2
};
4889 Result
= Context
.BoolTy
;
4891 if ((*Vec1
)->isExtVectorType() || !(*Vec2
)->isExtVectorType())
4897 AddBuiltinCandidate(Result
, LandR
, Args
, 2, CandidateSet
);
4907 case OO_GreaterGreater
:
4908 // C++ [over.built]p17:
4910 // For every pair of promoted integral types L and R, there
4911 // exist candidate operator functions of the form
4913 // LR operator%(L, R);
4914 // LR operator&(L, R);
4915 // LR operator^(L, R);
4916 // LR operator|(L, R);
4917 // L operator<<(L, R);
4918 // L operator>>(L, R);
4920 // where LR is the result of the usual arithmetic conversions
4921 // between types L and R.
4922 for (unsigned Left
= FirstPromotedIntegralType
;
4923 Left
< LastPromotedIntegralType
; ++Left
) {
4924 for (unsigned Right
= FirstPromotedIntegralType
;
4925 Right
< LastPromotedIntegralType
; ++Right
) {
4926 QualType LandR
[2] = { ArithmeticTypes
[Left
], ArithmeticTypes
[Right
] };
4927 QualType Result
= (Op
== OO_LessLess
|| Op
== OO_GreaterGreater
)
4929 : Context
.UsualArithmeticConversionsType(LandR
[0], LandR
[1]);
4930 AddBuiltinCandidate(Result
, LandR
, Args
, 2, CandidateSet
);
4936 // C++ [over.built]p20:
4938 // For every pair (T, VQ), where T is an enumeration or
4939 // pointer to member type and VQ is either volatile or
4940 // empty, there exist candidate operator functions of the form
4942 // VQ T& operator=(VQ T&, T);
4943 for (BuiltinCandidateTypeSet::iterator
4944 Enum
= CandidateTypes
.enumeration_begin(),
4945 EnumEnd
= CandidateTypes
.enumeration_end();
4946 Enum
!= EnumEnd
; ++Enum
)
4947 AddBuiltinAssignmentOperatorCandidates(*this, *Enum
, Args
, 2,
4949 for (BuiltinCandidateTypeSet::iterator
4950 MemPtr
= CandidateTypes
.member_pointer_begin(),
4951 MemPtrEnd
= CandidateTypes
.member_pointer_end();
4952 MemPtr
!= MemPtrEnd
; ++MemPtr
)
4953 AddBuiltinAssignmentOperatorCandidates(*this, *MemPtr
, Args
, 2,
4960 // C++ [over.built]p19:
4962 // For every pair (T, VQ), where T is any type and VQ is either
4963 // volatile or empty, there exist candidate operator functions
4966 // T*VQ& operator=(T*VQ&, T*);
4968 // C++ [over.built]p21:
4970 // For every pair (T, VQ), where T is a cv-qualified or
4971 // cv-unqualified object type and VQ is either volatile or
4972 // empty, there exist candidate operator functions of the form
4974 // T*VQ& operator+=(T*VQ&, ptrdiff_t);
4975 // T*VQ& operator-=(T*VQ&, ptrdiff_t);
4976 for (BuiltinCandidateTypeSet::iterator Ptr
= CandidateTypes
.pointer_begin();
4977 Ptr
!= CandidateTypes
.pointer_end(); ++Ptr
) {
4978 QualType ParamTypes
[2];
4979 ParamTypes
[1] = (Op
== OO_Equal
)? *Ptr
: Context
.getPointerDiffType();
4981 // non-volatile version
4982 ParamTypes
[0] = Context
.getLValueReferenceType(*Ptr
);
4983 AddBuiltinCandidate(ParamTypes
[0], ParamTypes
, Args
, 2, CandidateSet
,
4984 /*IsAssigmentOperator=*/Op
== OO_Equal
);
4986 if (!Context
.getCanonicalType(*Ptr
).isVolatileQualified() &&
4987 VisibleTypeConversionsQuals
.hasVolatile()) {
4990 = Context
.getLValueReferenceType(Context
.getVolatileType(*Ptr
));
4991 AddBuiltinCandidate(ParamTypes
[0], ParamTypes
, Args
, 2, CandidateSet
,
4992 /*IsAssigmentOperator=*/Op
== OO_Equal
);
4999 // C++ [over.built]p18:
5001 // For every triple (L, VQ, R), where L is an arithmetic type,
5002 // VQ is either volatile or empty, and R is a promoted
5003 // arithmetic type, there exist candidate operator functions of
5006 // VQ L& operator=(VQ L&, R);
5007 // VQ L& operator*=(VQ L&, R);
5008 // VQ L& operator/=(VQ L&, R);
5009 // VQ L& operator+=(VQ L&, R);
5010 // VQ L& operator-=(VQ L&, R);
5011 for (unsigned Left
= 0; Left
< NumArithmeticTypes
; ++Left
) {
5012 for (unsigned Right
= FirstPromotedArithmeticType
;
5013 Right
< LastPromotedArithmeticType
; ++Right
) {
5014 QualType ParamTypes
[2];
5015 ParamTypes
[1] = ArithmeticTypes
[Right
];
5017 // Add this built-in operator as a candidate (VQ is empty).
5018 ParamTypes
[0] = Context
.getLValueReferenceType(ArithmeticTypes
[Left
]);
5019 AddBuiltinCandidate(ParamTypes
[0], ParamTypes
, Args
, 2, CandidateSet
,
5020 /*IsAssigmentOperator=*/Op
== OO_Equal
);
5022 // Add this built-in operator as a candidate (VQ is 'volatile').
5023 if (VisibleTypeConversionsQuals
.hasVolatile()) {
5024 ParamTypes
[0] = Context
.getVolatileType(ArithmeticTypes
[Left
]);
5025 ParamTypes
[0] = Context
.getLValueReferenceType(ParamTypes
[0]);
5026 AddBuiltinCandidate(ParamTypes
[0], ParamTypes
, Args
, 2, CandidateSet
,
5027 /*IsAssigmentOperator=*/Op
== OO_Equal
);
5032 // Extension: Add the binary operators =, +=, -=, *=, /= for vector types.
5033 for (BuiltinCandidateTypeSet::iterator Vec1
= CandidateTypes
.vector_begin(),
5034 Vec1End
= CandidateTypes
.vector_end();
5035 Vec1
!= Vec1End
; ++Vec1
)
5036 for (BuiltinCandidateTypeSet::iterator
5037 Vec2
= CandidateTypes
.vector_begin(),
5038 Vec2End
= CandidateTypes
.vector_end();
5039 Vec2
!= Vec2End
; ++Vec2
) {
5040 QualType ParamTypes
[2];
5041 ParamTypes
[1] = *Vec2
;
5042 // Add this built-in operator as a candidate (VQ is empty).
5043 ParamTypes
[0] = Context
.getLValueReferenceType(*Vec1
);
5044 AddBuiltinCandidate(ParamTypes
[0], ParamTypes
, Args
, 2, CandidateSet
,
5045 /*IsAssigmentOperator=*/Op
== OO_Equal
);
5047 // Add this built-in operator as a candidate (VQ is 'volatile').
5048 if (VisibleTypeConversionsQuals
.hasVolatile()) {
5049 ParamTypes
[0] = Context
.getVolatileType(*Vec1
);
5050 ParamTypes
[0] = Context
.getLValueReferenceType(ParamTypes
[0]);
5051 AddBuiltinCandidate(ParamTypes
[0], ParamTypes
, Args
, 2, CandidateSet
,
5052 /*IsAssigmentOperator=*/Op
== OO_Equal
);
5057 case OO_PercentEqual
:
5058 case OO_LessLessEqual
:
5059 case OO_GreaterGreaterEqual
:
5063 // C++ [over.built]p22:
5065 // For every triple (L, VQ, R), where L is an integral type, VQ
5066 // is either volatile or empty, and R is a promoted integral
5067 // type, there exist candidate operator functions of the form
5069 // VQ L& operator%=(VQ L&, R);
5070 // VQ L& operator<<=(VQ L&, R);
5071 // VQ L& operator>>=(VQ L&, R);
5072 // VQ L& operator&=(VQ L&, R);
5073 // VQ L& operator^=(VQ L&, R);
5074 // VQ L& operator|=(VQ L&, R);
5075 for (unsigned Left
= FirstIntegralType
; Left
< LastIntegralType
; ++Left
) {
5076 for (unsigned Right
= FirstPromotedIntegralType
;
5077 Right
< LastPromotedIntegralType
; ++Right
) {
5078 QualType ParamTypes
[2];
5079 ParamTypes
[1] = ArithmeticTypes
[Right
];
5081 // Add this built-in operator as a candidate (VQ is empty).
5082 ParamTypes
[0] = Context
.getLValueReferenceType(ArithmeticTypes
[Left
]);
5083 AddBuiltinCandidate(ParamTypes
[0], ParamTypes
, Args
, 2, CandidateSet
);
5084 if (VisibleTypeConversionsQuals
.hasVolatile()) {
5085 // Add this built-in operator as a candidate (VQ is 'volatile').
5086 ParamTypes
[0] = ArithmeticTypes
[Left
];
5087 ParamTypes
[0] = Context
.getVolatileType(ParamTypes
[0]);
5088 ParamTypes
[0] = Context
.getLValueReferenceType(ParamTypes
[0]);
5089 AddBuiltinCandidate(ParamTypes
[0], ParamTypes
, Args
, 2, CandidateSet
);
5096 // C++ [over.operator]p23:
5098 // There also exist candidate operator functions of the form
5100 // bool operator!(bool);
5101 // bool operator&&(bool, bool); [BELOW]
5102 // bool operator||(bool, bool); [BELOW]
5103 QualType ParamTy
= Context
.BoolTy
;
5104 AddBuiltinCandidate(ParamTy
, &ParamTy
, Args
, 1, CandidateSet
,
5105 /*IsAssignmentOperator=*/false,
5106 /*NumContextualBoolArguments=*/1);
5112 // C++ [over.operator]p23:
5114 // There also exist candidate operator functions of the form
5116 // bool operator!(bool); [ABOVE]
5117 // bool operator&&(bool, bool);
5118 // bool operator||(bool, bool);
5119 QualType ParamTypes
[2] = { Context
.BoolTy
, Context
.BoolTy
};
5120 AddBuiltinCandidate(Context
.BoolTy
, ParamTypes
, Args
, 2, CandidateSet
,
5121 /*IsAssignmentOperator=*/false,
5122 /*NumContextualBoolArguments=*/2);
5127 // C++ [over.built]p13:
5129 // For every cv-qualified or cv-unqualified object type T there
5130 // exist candidate operator functions of the form
5132 // T* operator+(T*, ptrdiff_t); [ABOVE]
5133 // T& operator[](T*, ptrdiff_t);
5134 // T* operator-(T*, ptrdiff_t); [ABOVE]
5135 // T* operator+(ptrdiff_t, T*); [ABOVE]
5136 // T& operator[](ptrdiff_t, T*);
5137 for (BuiltinCandidateTypeSet::iterator Ptr
= CandidateTypes
.pointer_begin();
5138 Ptr
!= CandidateTypes
.pointer_end(); ++Ptr
) {
5139 QualType ParamTypes
[2] = { *Ptr
, Context
.getPointerDiffType() };
5140 QualType PointeeType
= (*Ptr
)->getPointeeType();
5141 QualType ResultTy
= Context
.getLValueReferenceType(PointeeType
);
5143 // T& operator[](T*, ptrdiff_t)
5144 AddBuiltinCandidate(ResultTy
, ParamTypes
, Args
, 2, CandidateSet
);
5146 // T& operator[](ptrdiff_t, T*);
5147 ParamTypes
[0] = ParamTypes
[1];
5148 ParamTypes
[1] = *Ptr
;
5149 AddBuiltinCandidate(ResultTy
, ParamTypes
, Args
, 2, CandidateSet
);
5154 // C++ [over.built]p11:
5155 // For every quintuple (C1, C2, T, CV1, CV2), where C2 is a class type,
5156 // C1 is the same type as C2 or is a derived class of C2, T is an object
5157 // type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
5158 // there exist candidate operator functions of the form
5159 // CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
5160 // where CV12 is the union of CV1 and CV2.
5162 for (BuiltinCandidateTypeSet::iterator Ptr
=
5163 CandidateTypes
.pointer_begin();
5164 Ptr
!= CandidateTypes
.pointer_end(); ++Ptr
) {
5165 QualType C1Ty
= (*Ptr
);
5167 QualifierCollector Q1
;
5168 C1
= QualType(Q1
.strip(C1Ty
->getPointeeType()), 0);
5169 if (!isa
<RecordType
>(C1
))
5171 // heuristic to reduce number of builtin candidates in the set.
5172 // Add volatile/restrict version only if there are conversions to a
5173 // volatile/restrict type.
5174 if (!VisibleTypeConversionsQuals
.hasVolatile() && Q1
.hasVolatile())
5176 if (!VisibleTypeConversionsQuals
.hasRestrict() && Q1
.hasRestrict())
5178 for (BuiltinCandidateTypeSet::iterator
5179 MemPtr
= CandidateTypes
.member_pointer_begin(),
5180 MemPtrEnd
= CandidateTypes
.member_pointer_end();
5181 MemPtr
!= MemPtrEnd
; ++MemPtr
) {
5182 const MemberPointerType
*mptr
= cast
<MemberPointerType
>(*MemPtr
);
5183 QualType C2
= QualType(mptr
->getClass(), 0);
5184 C2
= C2
.getUnqualifiedType();
5185 if (C1
!= C2
&& !IsDerivedFrom(C1
, C2
))
5187 QualType ParamTypes
[2] = { *Ptr
, *MemPtr
};
5189 QualType T
= mptr
->getPointeeType();
5190 if (!VisibleTypeConversionsQuals
.hasVolatile() &&
5191 T
.isVolatileQualified())
5193 if (!VisibleTypeConversionsQuals
.hasRestrict() &&
5194 T
.isRestrictQualified())
5197 QualType ResultTy
= Context
.getLValueReferenceType(T
);
5198 AddBuiltinCandidate(ResultTy
, ParamTypes
, Args
, 2, CandidateSet
);
5204 case OO_Conditional
:
5205 // Note that we don't consider the first argument, since it has been
5206 // contextually converted to bool long ago. The candidates below are
5207 // therefore added as binary.
5209 // C++ [over.built]p24:
5210 // For every type T, where T is a pointer or pointer-to-member type,
5211 // there exist candidate operator functions of the form
5213 // T operator?(bool, T, T);
5215 for (BuiltinCandidateTypeSet::iterator Ptr
= CandidateTypes
.pointer_begin(),
5216 E
= CandidateTypes
.pointer_end(); Ptr
!= E
; ++Ptr
) {
5217 QualType ParamTypes
[2] = { *Ptr
, *Ptr
};
5218 AddBuiltinCandidate(*Ptr
, ParamTypes
, Args
, 2, CandidateSet
);
5220 for (BuiltinCandidateTypeSet::iterator Ptr
=
5221 CandidateTypes
.member_pointer_begin(),
5222 E
= CandidateTypes
.member_pointer_end(); Ptr
!= E
; ++Ptr
) {
5223 QualType ParamTypes
[2] = { *Ptr
, *Ptr
};
5224 AddBuiltinCandidate(*Ptr
, ParamTypes
, Args
, 2, CandidateSet
);
5230 /// \brief Add function candidates found via argument-dependent lookup
5231 /// to the set of overloading candidates.
5233 /// This routine performs argument-dependent name lookup based on the
5234 /// given function name (which may also be an operator name) and adds
5235 /// all of the overload candidates found by ADL to the overload
5236 /// candidate set (C++ [basic.lookup.argdep]).
5238 Sema::AddArgumentDependentLookupCandidates(DeclarationName Name
,
5240 Expr
**Args
, unsigned NumArgs
,
5241 const TemplateArgumentListInfo
*ExplicitTemplateArgs
,
5242 OverloadCandidateSet
& CandidateSet
,
5243 bool PartialOverloading
) {
5246 // FIXME: This approach for uniquing ADL results (and removing
5247 // redundant candidates from the set) relies on pointer-equality,
5248 // which means we need to key off the canonical decl. However,
5249 // always going back to the canonical decl might not get us the
5250 // right set of default arguments. What default arguments are
5251 // we supposed to consider on ADL candidates, anyway?
5253 // FIXME: Pass in the explicit template arguments?
5254 ArgumentDependentLookup(Name
, Operator
, Args
, NumArgs
, Fns
);
5256 // Erase all of the candidates we already knew about.
5257 for (OverloadCandidateSet::iterator Cand
= CandidateSet
.begin(),
5258 CandEnd
= CandidateSet
.end();
5259 Cand
!= CandEnd
; ++Cand
)
5260 if (Cand
->Function
) {
5261 Fns
.erase(Cand
->Function
);
5262 if (FunctionTemplateDecl
*FunTmpl
= Cand
->Function
->getPrimaryTemplate())
5266 // For each of the ADL candidates we found, add it to the overload
5268 for (ADLResult::iterator I
= Fns
.begin(), E
= Fns
.end(); I
!= E
; ++I
) {
5269 DeclAccessPair FoundDecl
= DeclAccessPair::make(*I
, AS_none
);
5270 if (FunctionDecl
*FD
= dyn_cast
<FunctionDecl
>(*I
)) {
5271 if (ExplicitTemplateArgs
)
5274 AddOverloadCandidate(FD
, FoundDecl
, Args
, NumArgs
, CandidateSet
,
5275 false, PartialOverloading
);
5277 AddTemplateOverloadCandidate(cast
<FunctionTemplateDecl
>(*I
),
5278 FoundDecl
, ExplicitTemplateArgs
,
5279 Args
, NumArgs
, CandidateSet
);
5283 /// isBetterOverloadCandidate - Determines whether the first overload
5284 /// candidate is a better candidate than the second (C++ 13.3.3p1).
5286 isBetterOverloadCandidate(Sema
&S
,
5287 const OverloadCandidate
& Cand1
,
5288 const OverloadCandidate
& Cand2
,
5289 SourceLocation Loc
) {
5290 // Define viable functions to be better candidates than non-viable
5293 return Cand1
.Viable
;
5294 else if (!Cand1
.Viable
)
5297 // C++ [over.match.best]p1:
5299 // -- if F is a static member function, ICS1(F) is defined such
5300 // that ICS1(F) is neither better nor worse than ICS1(G) for
5301 // any function G, and, symmetrically, ICS1(G) is neither
5302 // better nor worse than ICS1(F).
5303 unsigned StartArg
= 0;
5304 if (Cand1
.IgnoreObjectArgument
|| Cand2
.IgnoreObjectArgument
)
5307 // C++ [over.match.best]p1:
5308 // A viable function F1 is defined to be a better function than another
5309 // viable function F2 if for all arguments i, ICSi(F1) is not a worse
5310 // conversion sequence than ICSi(F2), and then...
5311 unsigned NumArgs
= Cand1
.Conversions
.size();
5312 assert(Cand2
.Conversions
.size() == NumArgs
&& "Overload candidate mismatch");
5313 bool HasBetterConversion
= false;
5314 for (unsigned ArgIdx
= StartArg
; ArgIdx
< NumArgs
; ++ArgIdx
) {
5315 switch (CompareImplicitConversionSequences(S
,
5316 Cand1
.Conversions
[ArgIdx
],
5317 Cand2
.Conversions
[ArgIdx
])) {
5318 case ImplicitConversionSequence::Better
:
5319 // Cand1 has a better conversion sequence.
5320 HasBetterConversion
= true;
5323 case ImplicitConversionSequence::Worse
:
5324 // Cand1 can't be better than Cand2.
5327 case ImplicitConversionSequence::Indistinguishable
:
5333 // -- for some argument j, ICSj(F1) is a better conversion sequence than
5334 // ICSj(F2), or, if not that,
5335 if (HasBetterConversion
)
5338 // - F1 is a non-template function and F2 is a function template
5339 // specialization, or, if not that,
5340 if ((!Cand1
.Function
|| !Cand1
.Function
->getPrimaryTemplate()) &&
5341 Cand2
.Function
&& Cand2
.Function
->getPrimaryTemplate())
5344 // -- F1 and F2 are function template specializations, and the function
5345 // template for F1 is more specialized than the template for F2
5346 // according to the partial ordering rules described in 14.5.5.2, or,
5348 if (Cand1
.Function
&& Cand1
.Function
->getPrimaryTemplate() &&
5349 Cand2
.Function
&& Cand2
.Function
->getPrimaryTemplate())
5350 if (FunctionTemplateDecl
*BetterTemplate
5351 = S
.getMoreSpecializedTemplate(Cand1
.Function
->getPrimaryTemplate(),
5352 Cand2
.Function
->getPrimaryTemplate(),
5354 isa
<CXXConversionDecl
>(Cand1
.Function
)? TPOC_Conversion
5356 return BetterTemplate
== Cand1
.Function
->getPrimaryTemplate();
5358 // -- the context is an initialization by user-defined conversion
5359 // (see 8.5, 13.3.1.5) and the standard conversion sequence
5360 // from the return type of F1 to the destination type (i.e.,
5361 // the type of the entity being initialized) is a better
5362 // conversion sequence than the standard conversion sequence
5363 // from the return type of F2 to the destination type.
5364 if (Cand1
.Function
&& Cand2
.Function
&&
5365 isa
<CXXConversionDecl
>(Cand1
.Function
) &&
5366 isa
<CXXConversionDecl
>(Cand2
.Function
)) {
5367 switch (CompareStandardConversionSequences(S
,
5368 Cand1
.FinalConversion
,
5369 Cand2
.FinalConversion
)) {
5370 case ImplicitConversionSequence::Better
:
5371 // Cand1 has a better conversion sequence.
5374 case ImplicitConversionSequence::Worse
:
5375 // Cand1 can't be better than Cand2.
5378 case ImplicitConversionSequence::Indistinguishable
:
5387 /// \brief Computes the best viable function (C++ 13.3.3)
5388 /// within an overload candidate set.
5390 /// \param CandidateSet the set of candidate functions.
5392 /// \param Loc the location of the function name (or operator symbol) for
5393 /// which overload resolution occurs.
5395 /// \param Best f overload resolution was successful or found a deleted
5396 /// function, Best points to the candidate function found.
5398 /// \returns The result of overload resolution.
5400 OverloadCandidateSet::BestViableFunction(Sema
&S
, SourceLocation Loc
,
5402 // Find the best viable function.
5404 for (iterator Cand
= begin(); Cand
!= end(); ++Cand
) {
5406 if (Best
== end() || isBetterOverloadCandidate(S
, *Cand
, *Best
, Loc
))
5410 // If we didn't find any viable functions, abort.
5412 return OR_No_Viable_Function
;
5414 // Make sure that this function is better than every other viable
5415 // function. If not, we have an ambiguity.
5416 for (iterator Cand
= begin(); Cand
!= end(); ++Cand
) {
5419 !isBetterOverloadCandidate(S
, *Best
, *Cand
, Loc
)) {
5421 return OR_Ambiguous
;
5425 // Best is the best viable function.
5426 if (Best
->Function
&&
5427 (Best
->Function
->isDeleted() ||
5428 Best
->Function
->getAttr
<UnavailableAttr
>()))
5431 // C++ [basic.def.odr]p2:
5432 // An overloaded function is used if it is selected by overload resolution
5433 // when referred to from a potentially-evaluated expression. [Note: this
5434 // covers calls to named functions (5.2.2), operator overloading
5435 // (clause 13), user-defined conversions (12.3.2), allocation function for
5436 // placement new (5.3.4), as well as non-default initialization (8.5).
5438 S
.MarkDeclarationReferenced(Loc
, Best
->Function
);
5444 enum OverloadCandidateKind
{
5448 oc_function_template
,
5450 oc_constructor_template
,
5451 oc_implicit_default_constructor
,
5452 oc_implicit_copy_constructor
,
5453 oc_implicit_copy_assignment
5456 OverloadCandidateKind
ClassifyOverloadCandidate(Sema
&S
,
5458 std::string
&Description
) {
5459 bool isTemplate
= false;
5461 if (FunctionTemplateDecl
*FunTmpl
= Fn
->getPrimaryTemplate()) {
5463 Description
= S
.getTemplateArgumentBindingsText(
5464 FunTmpl
->getTemplateParameters(), *Fn
->getTemplateSpecializationArgs());
5467 if (CXXConstructorDecl
*Ctor
= dyn_cast
<CXXConstructorDecl
>(Fn
)) {
5468 if (!Ctor
->isImplicit())
5469 return isTemplate
? oc_constructor_template
: oc_constructor
;
5471 return Ctor
->isCopyConstructor() ? oc_implicit_copy_constructor
5472 : oc_implicit_default_constructor
;
5475 if (CXXMethodDecl
*Meth
= dyn_cast
<CXXMethodDecl
>(Fn
)) {
5476 // This actually gets spelled 'candidate function' for now, but
5477 // it doesn't hurt to split it out.
5478 if (!Meth
->isImplicit())
5479 return isTemplate
? oc_method_template
: oc_method
;
5481 assert(Meth
->isCopyAssignment()
5482 && "implicit method is not copy assignment operator?");
5483 return oc_implicit_copy_assignment
;
5486 return isTemplate
? oc_function_template
: oc_function
;
5489 } // end anonymous namespace
5491 // Notes the location of an overload candidate.
5492 void Sema::NoteOverloadCandidate(FunctionDecl
*Fn
) {
5494 OverloadCandidateKind K
= ClassifyOverloadCandidate(*this, Fn
, FnDesc
);
5495 Diag(Fn
->getLocation(), diag::note_ovl_candidate
)
5496 << (unsigned) K
<< FnDesc
;
5499 /// Diagnoses an ambiguous conversion. The partial diagnostic is the
5500 /// "lead" diagnostic; it will be given two arguments, the source and
5501 /// target types of the conversion.
5502 void ImplicitConversionSequence::DiagnoseAmbiguousConversion(
5504 SourceLocation CaretLoc
,
5505 const PartialDiagnostic
&PDiag
) const {
5506 S
.Diag(CaretLoc
, PDiag
)
5507 << Ambiguous
.getFromType() << Ambiguous
.getToType();
5508 for (AmbiguousConversionSequence::const_iterator
5509 I
= Ambiguous
.begin(), E
= Ambiguous
.end(); I
!= E
; ++I
) {
5510 S
.NoteOverloadCandidate(*I
);
5516 void DiagnoseBadConversion(Sema
&S
, OverloadCandidate
*Cand
, unsigned I
) {
5517 const ImplicitConversionSequence
&Conv
= Cand
->Conversions
[I
];
5518 assert(Conv
.isBad());
5519 assert(Cand
->Function
&& "for now, candidate must be a function");
5520 FunctionDecl
*Fn
= Cand
->Function
;
5522 // There's a conversion slot for the object argument if this is a
5523 // non-constructor method. Note that 'I' corresponds the
5524 // conversion-slot index.
5525 bool isObjectArgument
= false;
5526 if (isa
<CXXMethodDecl
>(Fn
) && !isa
<CXXConstructorDecl
>(Fn
)) {
5528 isObjectArgument
= true;
5534 OverloadCandidateKind FnKind
= ClassifyOverloadCandidate(S
, Fn
, FnDesc
);
5536 Expr
*FromExpr
= Conv
.Bad
.FromExpr
;
5537 QualType FromTy
= Conv
.Bad
.getFromType();
5538 QualType ToTy
= Conv
.Bad
.getToType();
5540 if (FromTy
== S
.Context
.OverloadTy
) {
5541 assert(FromExpr
&& "overload set argument came from implicit argument?");
5542 Expr
*E
= FromExpr
->IgnoreParens();
5543 if (isa
<UnaryOperator
>(E
))
5544 E
= cast
<UnaryOperator
>(E
)->getSubExpr()->IgnoreParens();
5545 DeclarationName Name
= cast
<OverloadExpr
>(E
)->getName();
5547 S
.Diag(Fn
->getLocation(), diag::note_ovl_candidate_bad_overload
)
5548 << (unsigned) FnKind
<< FnDesc
5549 << (FromExpr
? FromExpr
->getSourceRange() : SourceRange())
5550 << ToTy
<< Name
<< I
+1;
5554 // Do some hand-waving analysis to see if the non-viability is due
5555 // to a qualifier mismatch.
5556 CanQualType CFromTy
= S
.Context
.getCanonicalType(FromTy
);
5557 CanQualType CToTy
= S
.Context
.getCanonicalType(ToTy
);
5558 if (CanQual
<ReferenceType
> RT
= CToTy
->getAs
<ReferenceType
>())
5559 CToTy
= RT
->getPointeeType();
5561 // TODO: detect and diagnose the full richness of const mismatches.
5562 if (CanQual
<PointerType
> FromPT
= CFromTy
->getAs
<PointerType
>())
5563 if (CanQual
<PointerType
> ToPT
= CToTy
->getAs
<PointerType
>())
5564 CFromTy
= FromPT
->getPointeeType(), CToTy
= ToPT
->getPointeeType();
5567 if (CToTy
.getUnqualifiedType() == CFromTy
.getUnqualifiedType() &&
5568 !CToTy
.isAtLeastAsQualifiedAs(CFromTy
)) {
5569 // It is dumb that we have to do this here.
5570 while (isa
<ArrayType
>(CFromTy
))
5571 CFromTy
= CFromTy
->getAs
<ArrayType
>()->getElementType();
5572 while (isa
<ArrayType
>(CToTy
))
5573 CToTy
= CFromTy
->getAs
<ArrayType
>()->getElementType();
5575 Qualifiers FromQs
= CFromTy
.getQualifiers();
5576 Qualifiers ToQs
= CToTy
.getQualifiers();
5578 if (FromQs
.getAddressSpace() != ToQs
.getAddressSpace()) {
5579 S
.Diag(Fn
->getLocation(), diag::note_ovl_candidate_bad_addrspace
)
5580 << (unsigned) FnKind
<< FnDesc
5581 << (FromExpr
? FromExpr
->getSourceRange() : SourceRange())
5583 << FromQs
.getAddressSpace() << ToQs
.getAddressSpace()
5584 << (unsigned) isObjectArgument
<< I
+1;
5588 unsigned CVR
= FromQs
.getCVRQualifiers() & ~ToQs
.getCVRQualifiers();
5589 assert(CVR
&& "unexpected qualifiers mismatch");
5591 if (isObjectArgument
) {
5592 S
.Diag(Fn
->getLocation(), diag::note_ovl_candidate_bad_cvr_this
)
5593 << (unsigned) FnKind
<< FnDesc
5594 << (FromExpr
? FromExpr
->getSourceRange() : SourceRange())
5595 << FromTy
<< (CVR
- 1);
5597 S
.Diag(Fn
->getLocation(), diag::note_ovl_candidate_bad_cvr
)
5598 << (unsigned) FnKind
<< FnDesc
5599 << (FromExpr
? FromExpr
->getSourceRange() : SourceRange())
5600 << FromTy
<< (CVR
- 1) << I
+1;
5605 // Diagnose references or pointers to incomplete types differently,
5606 // since it's far from impossible that the incompleteness triggered
5608 QualType TempFromTy
= FromTy
.getNonReferenceType();
5609 if (const PointerType
*PTy
= TempFromTy
->getAs
<PointerType
>())
5610 TempFromTy
= PTy
->getPointeeType();
5611 if (TempFromTy
->isIncompleteType()) {
5612 S
.Diag(Fn
->getLocation(), diag::note_ovl_candidate_bad_conv_incomplete
)
5613 << (unsigned) FnKind
<< FnDesc
5614 << (FromExpr
? FromExpr
->getSourceRange() : SourceRange())
5615 << FromTy
<< ToTy
<< (unsigned) isObjectArgument
<< I
+1;
5619 // Diagnose base -> derived pointer conversions.
5620 unsigned BaseToDerivedConversion
= 0;
5621 if (const PointerType
*FromPtrTy
= FromTy
->getAs
<PointerType
>()) {
5622 if (const PointerType
*ToPtrTy
= ToTy
->getAs
<PointerType
>()) {
5623 if (ToPtrTy
->getPointeeType().isAtLeastAsQualifiedAs(
5624 FromPtrTy
->getPointeeType()) &&
5625 !FromPtrTy
->getPointeeType()->isIncompleteType() &&
5626 !ToPtrTy
->getPointeeType()->isIncompleteType() &&
5627 S
.IsDerivedFrom(ToPtrTy
->getPointeeType(),
5628 FromPtrTy
->getPointeeType()))
5629 BaseToDerivedConversion
= 1;
5631 } else if (const ObjCObjectPointerType
*FromPtrTy
5632 = FromTy
->getAs
<ObjCObjectPointerType
>()) {
5633 if (const ObjCObjectPointerType
*ToPtrTy
5634 = ToTy
->getAs
<ObjCObjectPointerType
>())
5635 if (const ObjCInterfaceDecl
*FromIface
= FromPtrTy
->getInterfaceDecl())
5636 if (const ObjCInterfaceDecl
*ToIface
= ToPtrTy
->getInterfaceDecl())
5637 if (ToPtrTy
->getPointeeType().isAtLeastAsQualifiedAs(
5638 FromPtrTy
->getPointeeType()) &&
5639 FromIface
->isSuperClassOf(ToIface
))
5640 BaseToDerivedConversion
= 2;
5641 } else if (const ReferenceType
*ToRefTy
= ToTy
->getAs
<ReferenceType
>()) {
5642 if (ToRefTy
->getPointeeType().isAtLeastAsQualifiedAs(FromTy
) &&
5643 !FromTy
->isIncompleteType() &&
5644 !ToRefTy
->getPointeeType()->isIncompleteType() &&
5645 S
.IsDerivedFrom(ToRefTy
->getPointeeType(), FromTy
))
5646 BaseToDerivedConversion
= 3;
5649 if (BaseToDerivedConversion
) {
5650 S
.Diag(Fn
->getLocation(),
5651 diag::note_ovl_candidate_bad_base_to_derived_conv
)
5652 << (unsigned) FnKind
<< FnDesc
5653 << (FromExpr
? FromExpr
->getSourceRange() : SourceRange())
5654 << (BaseToDerivedConversion
- 1)
5655 << FromTy
<< ToTy
<< I
+1;
5659 // TODO: specialize more based on the kind of mismatch
5660 S
.Diag(Fn
->getLocation(), diag::note_ovl_candidate_bad_conv
)
5661 << (unsigned) FnKind
<< FnDesc
5662 << (FromExpr
? FromExpr
->getSourceRange() : SourceRange())
5663 << FromTy
<< ToTy
<< (unsigned) isObjectArgument
<< I
+1;
5666 void DiagnoseArityMismatch(Sema
&S
, OverloadCandidate
*Cand
,
5667 unsigned NumFormalArgs
) {
5668 // TODO: treat calls to a missing default constructor as a special case
5670 FunctionDecl
*Fn
= Cand
->Function
;
5671 const FunctionProtoType
*FnTy
= Fn
->getType()->getAs
<FunctionProtoType
>();
5673 unsigned MinParams
= Fn
->getMinRequiredArguments();
5675 // at least / at most / exactly
5676 // FIXME: variadic templates "at most" should account for parameter packs
5677 unsigned mode
, modeCount
;
5678 if (NumFormalArgs
< MinParams
) {
5679 assert((Cand
->FailureKind
== ovl_fail_too_few_arguments
) ||
5680 (Cand
->FailureKind
== ovl_fail_bad_deduction
&&
5681 Cand
->DeductionFailure
.Result
== Sema::TDK_TooFewArguments
));
5682 if (MinParams
!= FnTy
->getNumArgs() || FnTy
->isVariadic())
5683 mode
= 0; // "at least"
5685 mode
= 2; // "exactly"
5686 modeCount
= MinParams
;
5688 assert((Cand
->FailureKind
== ovl_fail_too_many_arguments
) ||
5689 (Cand
->FailureKind
== ovl_fail_bad_deduction
&&
5690 Cand
->DeductionFailure
.Result
== Sema::TDK_TooManyArguments
));
5691 if (MinParams
!= FnTy
->getNumArgs())
5692 mode
= 1; // "at most"
5694 mode
= 2; // "exactly"
5695 modeCount
= FnTy
->getNumArgs();
5698 std::string Description
;
5699 OverloadCandidateKind FnKind
= ClassifyOverloadCandidate(S
, Fn
, Description
);
5701 S
.Diag(Fn
->getLocation(), diag::note_ovl_candidate_arity
)
5702 << (unsigned) FnKind
<< (Fn
->getDescribedFunctionTemplate() != 0) << mode
5703 << modeCount
<< NumFormalArgs
;
5706 /// Diagnose a failed template-argument deduction.
5707 void DiagnoseBadDeduction(Sema
&S
, OverloadCandidate
*Cand
,
5708 Expr
**Args
, unsigned NumArgs
) {
5709 FunctionDecl
*Fn
= Cand
->Function
; // pattern
5711 TemplateParameter Param
= Cand
->DeductionFailure
.getTemplateParameter();
5713 (ParamD
= Param
.dyn_cast
<TemplateTypeParmDecl
*>()) ||
5714 (ParamD
= Param
.dyn_cast
<NonTypeTemplateParmDecl
*>()) ||
5715 (ParamD
= Param
.dyn_cast
<TemplateTemplateParmDecl
*>());
5716 switch (Cand
->DeductionFailure
.Result
) {
5717 case Sema::TDK_Success
:
5718 llvm_unreachable("TDK_success while diagnosing bad deduction");
5720 case Sema::TDK_Incomplete
: {
5721 assert(ParamD
&& "no parameter found for incomplete deduction result");
5722 S
.Diag(Fn
->getLocation(), diag::note_ovl_candidate_incomplete_deduction
)
5723 << ParamD
->getDeclName();
5727 case Sema::TDK_Underqualified
: {
5728 assert(ParamD
&& "no parameter found for bad qualifiers deduction result");
5729 TemplateTypeParmDecl
*TParam
= cast
<TemplateTypeParmDecl
>(ParamD
);
5731 QualType Param
= Cand
->DeductionFailure
.getFirstArg()->getAsType();
5733 // Param will have been canonicalized, but it should just be a
5734 // qualified version of ParamD, so move the qualifiers to that.
5735 QualifierCollector
Qs(S
.Context
);
5737 QualType NonCanonParam
= Qs
.apply(TParam
->getTypeForDecl());
5738 assert(S
.Context
.hasSameType(Param
, NonCanonParam
));
5740 // Arg has also been canonicalized, but there's nothing we can do
5741 // about that. It also doesn't matter as much, because it won't
5742 // have any template parameters in it (because deduction isn't
5743 // done on dependent types).
5744 QualType Arg
= Cand
->DeductionFailure
.getSecondArg()->getAsType();
5746 S
.Diag(Fn
->getLocation(), diag::note_ovl_candidate_underqualified
)
5747 << ParamD
->getDeclName() << Arg
<< NonCanonParam
;
5751 case Sema::TDK_Inconsistent
: {
5752 assert(ParamD
&& "no parameter found for inconsistent deduction result");
5754 if (isa
<TemplateTypeParmDecl
>(ParamD
))
5756 else if (isa
<NonTypeTemplateParmDecl
>(ParamD
))
5762 S
.Diag(Fn
->getLocation(), diag::note_ovl_candidate_inconsistent_deduction
)
5763 << which
<< ParamD
->getDeclName()
5764 << *Cand
->DeductionFailure
.getFirstArg()
5765 << *Cand
->DeductionFailure
.getSecondArg();
5769 case Sema::TDK_InvalidExplicitArguments
:
5770 assert(ParamD
&& "no parameter found for invalid explicit arguments");
5771 if (ParamD
->getDeclName())
5772 S
.Diag(Fn
->getLocation(),
5773 diag::note_ovl_candidate_explicit_arg_mismatch_named
)
5774 << ParamD
->getDeclName();
5777 if (TemplateTypeParmDecl
*TTP
= dyn_cast
<TemplateTypeParmDecl
>(ParamD
))
5778 index
= TTP
->getIndex();
5779 else if (NonTypeTemplateParmDecl
*NTTP
5780 = dyn_cast
<NonTypeTemplateParmDecl
>(ParamD
))
5781 index
= NTTP
->getIndex();
5783 index
= cast
<TemplateTemplateParmDecl
>(ParamD
)->getIndex();
5784 S
.Diag(Fn
->getLocation(),
5785 diag::note_ovl_candidate_explicit_arg_mismatch_unnamed
)
5790 case Sema::TDK_TooManyArguments
:
5791 case Sema::TDK_TooFewArguments
:
5792 DiagnoseArityMismatch(S
, Cand
, NumArgs
);
5795 case Sema::TDK_InstantiationDepth
:
5796 S
.Diag(Fn
->getLocation(), diag::note_ovl_candidate_instantiation_depth
);
5799 case Sema::TDK_SubstitutionFailure
: {
5800 std::string ArgString
;
5801 if (TemplateArgumentList
*Args
5802 = Cand
->DeductionFailure
.getTemplateArgumentList())
5803 ArgString
= S
.getTemplateArgumentBindingsText(
5804 Fn
->getDescribedFunctionTemplate()->getTemplateParameters(),
5806 S
.Diag(Fn
->getLocation(), diag::note_ovl_candidate_substitution_failure
)
5811 // TODO: diagnose these individually, then kill off
5812 // note_ovl_candidate_bad_deduction, which is uselessly vague.
5813 case Sema::TDK_NonDeducedMismatch
:
5814 case Sema::TDK_FailedOverloadResolution
:
5815 S
.Diag(Fn
->getLocation(), diag::note_ovl_candidate_bad_deduction
);
5820 /// Generates a 'note' diagnostic for an overload candidate. We've
5821 /// already generated a primary error at the call site.
5823 /// It really does need to be a single diagnostic with its caret
5824 /// pointed at the candidate declaration. Yes, this creates some
5825 /// major challenges of technical writing. Yes, this makes pointing
5826 /// out problems with specific arguments quite awkward. It's still
5827 /// better than generating twenty screens of text for every failed
5830 /// It would be great to be able to express per-candidate problems
5831 /// more richly for those diagnostic clients that cared, but we'd
5832 /// still have to be just as careful with the default diagnostics.
5833 void NoteFunctionCandidate(Sema
&S
, OverloadCandidate
*Cand
,
5834 Expr
**Args
, unsigned NumArgs
) {
5835 FunctionDecl
*Fn
= Cand
->Function
;
5837 // Note deleted candidates, but only if they're viable.
5838 if (Cand
->Viable
&& (Fn
->isDeleted() || Fn
->hasAttr
<UnavailableAttr
>())) {
5840 OverloadCandidateKind FnKind
= ClassifyOverloadCandidate(S
, Fn
, FnDesc
);
5842 S
.Diag(Fn
->getLocation(), diag::note_ovl_candidate_deleted
)
5843 << FnKind
<< FnDesc
<< Fn
->isDeleted();
5847 // We don't really have anything else to say about viable candidates.
5849 S
.NoteOverloadCandidate(Fn
);
5853 switch (Cand
->FailureKind
) {
5854 case ovl_fail_too_many_arguments
:
5855 case ovl_fail_too_few_arguments
:
5856 return DiagnoseArityMismatch(S
, Cand
, NumArgs
);
5858 case ovl_fail_bad_deduction
:
5859 return DiagnoseBadDeduction(S
, Cand
, Args
, NumArgs
);
5861 case ovl_fail_trivial_conversion
:
5862 case ovl_fail_bad_final_conversion
:
5863 case ovl_fail_final_conversion_not_exact
:
5864 return S
.NoteOverloadCandidate(Fn
);
5866 case ovl_fail_bad_conversion
: {
5867 unsigned I
= (Cand
->IgnoreObjectArgument
? 1 : 0);
5868 for (unsigned N
= Cand
->Conversions
.size(); I
!= N
; ++I
)
5869 if (Cand
->Conversions
[I
].isBad())
5870 return DiagnoseBadConversion(S
, Cand
, I
);
5872 // FIXME: this currently happens when we're called from SemaInit
5873 // when user-conversion overload fails. Figure out how to handle
5874 // those conditions and diagnose them well.
5875 return S
.NoteOverloadCandidate(Fn
);
5880 void NoteSurrogateCandidate(Sema
&S
, OverloadCandidate
*Cand
) {
5881 // Desugar the type of the surrogate down to a function type,
5882 // retaining as many typedefs as possible while still showing
5883 // the function type (and, therefore, its parameter types).
5884 QualType FnType
= Cand
->Surrogate
->getConversionType();
5885 bool isLValueReference
= false;
5886 bool isRValueReference
= false;
5887 bool isPointer
= false;
5888 if (const LValueReferenceType
*FnTypeRef
=
5889 FnType
->getAs
<LValueReferenceType
>()) {
5890 FnType
= FnTypeRef
->getPointeeType();
5891 isLValueReference
= true;
5892 } else if (const RValueReferenceType
*FnTypeRef
=
5893 FnType
->getAs
<RValueReferenceType
>()) {
5894 FnType
= FnTypeRef
->getPointeeType();
5895 isRValueReference
= true;
5897 if (const PointerType
*FnTypePtr
= FnType
->getAs
<PointerType
>()) {
5898 FnType
= FnTypePtr
->getPointeeType();
5901 // Desugar down to a function type.
5902 FnType
= QualType(FnType
->getAs
<FunctionType
>(), 0);
5903 // Reconstruct the pointer/reference as appropriate.
5904 if (isPointer
) FnType
= S
.Context
.getPointerType(FnType
);
5905 if (isRValueReference
) FnType
= S
.Context
.getRValueReferenceType(FnType
);
5906 if (isLValueReference
) FnType
= S
.Context
.getLValueReferenceType(FnType
);
5908 S
.Diag(Cand
->Surrogate
->getLocation(), diag::note_ovl_surrogate_cand
)
5912 void NoteBuiltinOperatorCandidate(Sema
&S
,
5914 SourceLocation OpLoc
,
5915 OverloadCandidate
*Cand
) {
5916 assert(Cand
->Conversions
.size() <= 2 && "builtin operator is not binary");
5917 std::string
TypeStr("operator");
5920 TypeStr
+= Cand
->BuiltinTypes
.ParamTypes
[0].getAsString();
5921 if (Cand
->Conversions
.size() == 1) {
5923 S
.Diag(OpLoc
, diag::note_ovl_builtin_unary_candidate
) << TypeStr
;
5926 TypeStr
+= Cand
->BuiltinTypes
.ParamTypes
[1].getAsString();
5928 S
.Diag(OpLoc
, diag::note_ovl_builtin_binary_candidate
) << TypeStr
;
5932 void NoteAmbiguousUserConversions(Sema
&S
, SourceLocation OpLoc
,
5933 OverloadCandidate
*Cand
) {
5934 unsigned NoOperands
= Cand
->Conversions
.size();
5935 for (unsigned ArgIdx
= 0; ArgIdx
< NoOperands
; ++ArgIdx
) {
5936 const ImplicitConversionSequence
&ICS
= Cand
->Conversions
[ArgIdx
];
5937 if (ICS
.isBad()) break; // all meaningless after first invalid
5938 if (!ICS
.isAmbiguous()) continue;
5940 ICS
.DiagnoseAmbiguousConversion(S
, OpLoc
,
5941 S
.PDiag(diag::note_ambiguous_type_conversion
));
5945 SourceLocation
GetLocationForCandidate(const OverloadCandidate
*Cand
) {
5947 return Cand
->Function
->getLocation();
5948 if (Cand
->IsSurrogate
)
5949 return Cand
->Surrogate
->getLocation();
5950 return SourceLocation();
5953 struct CompareOverloadCandidatesForDisplay
{
5955 CompareOverloadCandidatesForDisplay(Sema
&S
) : S(S
) {}
5957 bool operator()(const OverloadCandidate
*L
,
5958 const OverloadCandidate
*R
) {
5959 // Fast-path this check.
5960 if (L
== R
) return false;
5962 // Order first by viability.
5964 if (!R
->Viable
) return true;
5966 // TODO: introduce a tri-valued comparison for overload
5967 // candidates. Would be more worthwhile if we had a sort
5968 // that could exploit it.
5969 if (isBetterOverloadCandidate(S
, *L
, *R
, SourceLocation())) return true;
5970 if (isBetterOverloadCandidate(S
, *R
, *L
, SourceLocation())) return false;
5971 } else if (R
->Viable
)
5974 assert(L
->Viable
== R
->Viable
);
5976 // Criteria by which we can sort non-viable candidates:
5978 // 1. Arity mismatches come after other candidates.
5979 if (L
->FailureKind
== ovl_fail_too_many_arguments
||
5980 L
->FailureKind
== ovl_fail_too_few_arguments
)
5982 if (R
->FailureKind
== ovl_fail_too_many_arguments
||
5983 R
->FailureKind
== ovl_fail_too_few_arguments
)
5986 // 2. Bad conversions come first and are ordered by the number
5987 // of bad conversions and quality of good conversions.
5988 if (L
->FailureKind
== ovl_fail_bad_conversion
) {
5989 if (R
->FailureKind
!= ovl_fail_bad_conversion
)
5992 // If there's any ordering between the defined conversions...
5993 // FIXME: this might not be transitive.
5994 assert(L
->Conversions
.size() == R
->Conversions
.size());
5997 unsigned I
= (L
->IgnoreObjectArgument
|| R
->IgnoreObjectArgument
);
5998 for (unsigned E
= L
->Conversions
.size(); I
!= E
; ++I
) {
5999 switch (CompareImplicitConversionSequences(S
,
6001 R
->Conversions
[I
])) {
6002 case ImplicitConversionSequence::Better
:
6006 case ImplicitConversionSequence::Worse
:
6010 case ImplicitConversionSequence::Indistinguishable
:
6014 if (leftBetter
> 0) return true;
6015 if (leftBetter
< 0) return false;
6017 } else if (R
->FailureKind
== ovl_fail_bad_conversion
)
6023 // Sort everything else by location.
6024 SourceLocation LLoc
= GetLocationForCandidate(L
);
6025 SourceLocation RLoc
= GetLocationForCandidate(R
);
6027 // Put candidates without locations (e.g. builtins) at the end.
6028 if (LLoc
.isInvalid()) return false;
6029 if (RLoc
.isInvalid()) return true;
6031 return S
.SourceMgr
.isBeforeInTranslationUnit(LLoc
, RLoc
);
6035 /// CompleteNonViableCandidate - Normally, overload resolution only
6036 /// computes up to the first
6037 void CompleteNonViableCandidate(Sema
&S
, OverloadCandidate
*Cand
,
6038 Expr
**Args
, unsigned NumArgs
) {
6039 assert(!Cand
->Viable
);
6041 // Don't do anything on failures other than bad conversion.
6042 if (Cand
->FailureKind
!= ovl_fail_bad_conversion
) return;
6044 // Skip forward to the first bad conversion.
6045 unsigned ConvIdx
= (Cand
->IgnoreObjectArgument
? 1 : 0);
6046 unsigned ConvCount
= Cand
->Conversions
.size();
6048 assert(ConvIdx
!= ConvCount
&& "no bad conversion in candidate");
6050 if (Cand
->Conversions
[ConvIdx
- 1].isBad())
6054 if (ConvIdx
== ConvCount
)
6057 assert(!Cand
->Conversions
[ConvIdx
].isInitialized() &&
6058 "remaining conversion is initialized?");
6060 // FIXME: this should probably be preserved from the overload
6061 // operation somehow.
6062 bool SuppressUserConversions
= false;
6064 const FunctionProtoType
* Proto
;
6065 unsigned ArgIdx
= ConvIdx
;
6067 if (Cand
->IsSurrogate
) {
6069 = Cand
->Surrogate
->getConversionType().getNonReferenceType();
6070 if (const PointerType
*ConvPtrType
= ConvType
->getAs
<PointerType
>())
6071 ConvType
= ConvPtrType
->getPointeeType();
6072 Proto
= ConvType
->getAs
<FunctionProtoType
>();
6074 } else if (Cand
->Function
) {
6075 Proto
= Cand
->Function
->getType()->getAs
<FunctionProtoType
>();
6076 if (isa
<CXXMethodDecl
>(Cand
->Function
) &&
6077 !isa
<CXXConstructorDecl
>(Cand
->Function
))
6080 // Builtin binary operator with a bad first conversion.
6081 assert(ConvCount
<= 3);
6082 for (; ConvIdx
!= ConvCount
; ++ConvIdx
)
6083 Cand
->Conversions
[ConvIdx
]
6084 = TryCopyInitialization(S
, Args
[ConvIdx
],
6085 Cand
->BuiltinTypes
.ParamTypes
[ConvIdx
],
6086 SuppressUserConversions
,
6087 /*InOverloadResolution*/ true);
6091 // Fill in the rest of the conversions.
6092 unsigned NumArgsInProto
= Proto
->getNumArgs();
6093 for (; ConvIdx
!= ConvCount
; ++ConvIdx
, ++ArgIdx
) {
6094 if (ArgIdx
< NumArgsInProto
)
6095 Cand
->Conversions
[ConvIdx
]
6096 = TryCopyInitialization(S
, Args
[ArgIdx
], Proto
->getArgType(ArgIdx
),
6097 SuppressUserConversions
,
6098 /*InOverloadResolution=*/true);
6100 Cand
->Conversions
[ConvIdx
].setEllipsis();
6104 } // end anonymous namespace
6106 /// PrintOverloadCandidates - When overload resolution fails, prints
6107 /// diagnostic messages containing the candidates in the candidate
6109 void OverloadCandidateSet::NoteCandidates(Sema
&S
,
6110 OverloadCandidateDisplayKind OCD
,
6111 Expr
**Args
, unsigned NumArgs
,
6113 SourceLocation OpLoc
) {
6114 // Sort the candidates by viability and position. Sorting directly would
6115 // be prohibitive, so we make a set of pointers and sort those.
6116 llvm::SmallVector
<OverloadCandidate
*, 32> Cands
;
6117 if (OCD
== OCD_AllCandidates
) Cands
.reserve(size());
6118 for (iterator Cand
= begin(), LastCand
= end(); Cand
!= LastCand
; ++Cand
) {
6120 Cands
.push_back(Cand
);
6121 else if (OCD
== OCD_AllCandidates
) {
6122 CompleteNonViableCandidate(S
, Cand
, Args
, NumArgs
);
6123 if (Cand
->Function
|| Cand
->IsSurrogate
)
6124 Cands
.push_back(Cand
);
6125 // Otherwise, this a non-viable builtin candidate. We do not, in general,
6126 // want to list every possible builtin candidate.
6130 std::sort(Cands
.begin(), Cands
.end(),
6131 CompareOverloadCandidatesForDisplay(S
));
6133 bool ReportedAmbiguousConversions
= false;
6135 llvm::SmallVectorImpl
<OverloadCandidate
*>::iterator I
, E
;
6136 const Diagnostic::OverloadsShown ShowOverloads
= S
.Diags
.getShowOverloads();
6137 unsigned CandsShown
= 0;
6138 for (I
= Cands
.begin(), E
= Cands
.end(); I
!= E
; ++I
) {
6139 OverloadCandidate
*Cand
= *I
;
6141 // Set an arbitrary limit on the number of candidate functions we'll spam
6142 // the user with. FIXME: This limit should depend on details of the
6144 if (CandsShown
>= 4 && ShowOverloads
== Diagnostic::Ovl_Best
) {
6150 NoteFunctionCandidate(S
, Cand
, Args
, NumArgs
);
6151 else if (Cand
->IsSurrogate
)
6152 NoteSurrogateCandidate(S
, Cand
);
6154 assert(Cand
->Viable
&&
6155 "Non-viable built-in candidates are not added to Cands.");
6156 // Generally we only see ambiguities including viable builtin
6157 // operators if overload resolution got screwed up by an
6158 // ambiguous user-defined conversion.
6160 // FIXME: It's quite possible for different conversions to see
6161 // different ambiguities, though.
6162 if (!ReportedAmbiguousConversions
) {
6163 NoteAmbiguousUserConversions(S
, OpLoc
, Cand
);
6164 ReportedAmbiguousConversions
= true;
6167 // If this is a viable builtin, print it.
6168 NoteBuiltinOperatorCandidate(S
, Opc
, OpLoc
, Cand
);
6173 S
.Diag(OpLoc
, diag::note_ovl_too_many_candidates
) << int(E
- I
);
6176 static bool CheckUnresolvedAccess(Sema
&S
, OverloadExpr
*E
, DeclAccessPair D
) {
6177 if (isa
<UnresolvedLookupExpr
>(E
))
6178 return S
.CheckUnresolvedLookupAccess(cast
<UnresolvedLookupExpr
>(E
), D
);
6180 return S
.CheckUnresolvedMemberAccess(cast
<UnresolvedMemberExpr
>(E
), D
);
6183 /// ResolveAddressOfOverloadedFunction - Try to resolve the address of
6184 /// an overloaded function (C++ [over.over]), where @p From is an
6185 /// expression with overloaded function type and @p ToType is the type
6186 /// we're trying to resolve to. For example:
6192 /// int (*pfd)(double) = f; // selects f(double)
6195 /// This routine returns the resulting FunctionDecl if it could be
6196 /// resolved, and NULL otherwise. When @p Complain is true, this
6197 /// routine will emit diagnostics if there is an error.
6199 Sema::ResolveAddressOfOverloadedFunction(Expr
*From
, QualType ToType
,
6201 DeclAccessPair
&FoundResult
) {
6202 QualType FunctionType
= ToType
;
6203 bool IsMember
= false;
6204 if (const PointerType
*ToTypePtr
= ToType
->getAs
<PointerType
>())
6205 FunctionType
= ToTypePtr
->getPointeeType();
6206 else if (const ReferenceType
*ToTypeRef
= ToType
->getAs
<ReferenceType
>())
6207 FunctionType
= ToTypeRef
->getPointeeType();
6208 else if (const MemberPointerType
*MemTypePtr
=
6209 ToType
->getAs
<MemberPointerType
>()) {
6210 FunctionType
= MemTypePtr
->getPointeeType();
6214 // C++ [over.over]p1:
6215 // [...] [Note: any redundant set of parentheses surrounding the
6216 // overloaded function name is ignored (5.1). ]
6217 // C++ [over.over]p1:
6218 // [...] The overloaded function name can be preceded by the &
6220 // However, remember whether the expression has member-pointer form:
6221 // C++ [expr.unary.op]p4:
6222 // A pointer to member is only formed when an explicit & is used
6223 // and its operand is a qualified-id not enclosed in
6225 OverloadExpr::FindResult Ovl
= OverloadExpr::find(From
);
6226 OverloadExpr
*OvlExpr
= Ovl
.Expression
;
6228 // We expect a pointer or reference to function, or a function pointer.
6229 FunctionType
= Context
.getCanonicalType(FunctionType
).getUnqualifiedType();
6230 if (!FunctionType
->isFunctionType()) {
6232 Diag(From
->getLocStart(), diag::err_addr_ovl_not_func_ptrref
)
6233 << OvlExpr
->getName() << ToType
;
6238 // If the overload expression doesn't have the form of a pointer to
6239 // member, don't try to convert it to a pointer-to-member type.
6240 if (IsMember
&& !Ovl
.HasFormOfMemberPointer
) {
6241 if (!Complain
) return 0;
6243 // TODO: Should we condition this on whether any functions might
6244 // have matched, or is it more appropriate to do that in callers?
6245 // TODO: a fixit wouldn't hurt.
6246 Diag(OvlExpr
->getNameLoc(), diag::err_addr_ovl_no_qualifier
)
6247 << ToType
<< OvlExpr
->getSourceRange();
6251 TemplateArgumentListInfo ETABuffer
, *ExplicitTemplateArgs
= 0;
6252 if (OvlExpr
->hasExplicitTemplateArgs()) {
6253 OvlExpr
->getExplicitTemplateArgs().copyInto(ETABuffer
);
6254 ExplicitTemplateArgs
= &ETABuffer
;
6257 assert(From
->getType() == Context
.OverloadTy
);
6259 // Look through all of the overloaded functions, searching for one
6260 // whose type matches exactly.
6261 llvm::SmallVector
<std::pair
<DeclAccessPair
, FunctionDecl
*>, 4> Matches
;
6262 llvm::SmallVector
<FunctionDecl
*, 4> NonMatches
;
6264 bool FoundNonTemplateFunction
= false;
6265 for (UnresolvedSetIterator I
= OvlExpr
->decls_begin(),
6266 E
= OvlExpr
->decls_end(); I
!= E
; ++I
) {
6267 // Look through any using declarations to find the underlying function.
6268 NamedDecl
*Fn
= (*I
)->getUnderlyingDecl();
6270 // C++ [over.over]p3:
6271 // Non-member functions and static member functions match
6272 // targets of type "pointer-to-function" or "reference-to-function."
6273 // Nonstatic member functions match targets of
6274 // type "pointer-to-member-function."
6275 // Note that according to DR 247, the containing class does not matter.
6277 if (FunctionTemplateDecl
*FunctionTemplate
6278 = dyn_cast
<FunctionTemplateDecl
>(Fn
)) {
6279 if (CXXMethodDecl
*Method
6280 = dyn_cast
<CXXMethodDecl
>(FunctionTemplate
->getTemplatedDecl())) {
6281 // Skip non-static function templates when converting to pointer, and
6282 // static when converting to member pointer.
6283 if (Method
->isStatic() == IsMember
)
6285 } else if (IsMember
)
6288 // C++ [over.over]p2:
6289 // If the name is a function template, template argument deduction is
6290 // done (14.8.2.2), and if the argument deduction succeeds, the
6291 // resulting template argument list is used to generate a single
6292 // function template specialization, which is added to the set of
6293 // overloaded functions considered.
6294 // FIXME: We don't really want to build the specialization here, do we?
6295 FunctionDecl
*Specialization
= 0;
6296 TemplateDeductionInfo
Info(Context
, OvlExpr
->getNameLoc());
6297 if (TemplateDeductionResult Result
6298 = DeduceTemplateArguments(FunctionTemplate
, ExplicitTemplateArgs
,
6299 FunctionType
, Specialization
, Info
)) {
6300 // FIXME: make a note of the failed deduction for diagnostics.
6303 // FIXME: If the match isn't exact, shouldn't we just drop this as
6304 // a candidate? Find a testcase before changing the code.
6306 == Context
.getCanonicalType(Specialization
->getType()));
6307 Matches
.push_back(std::make_pair(I
.getPair(),
6308 cast
<FunctionDecl
>(Specialization
->getCanonicalDecl())));
6314 if (CXXMethodDecl
*Method
= dyn_cast
<CXXMethodDecl
>(Fn
)) {
6315 // Skip non-static functions when converting to pointer, and static
6316 // when converting to member pointer.
6317 if (Method
->isStatic() == IsMember
)
6320 // If we have explicit template arguments, skip non-templates.
6321 if (OvlExpr
->hasExplicitTemplateArgs())
6323 } else if (IsMember
)
6326 if (FunctionDecl
*FunDecl
= dyn_cast
<FunctionDecl
>(Fn
)) {
6328 if (Context
.hasSameUnqualifiedType(FunctionType
, FunDecl
->getType()) ||
6329 IsNoReturnConversion(Context
, FunDecl
->getType(), FunctionType
,
6331 Matches
.push_back(std::make_pair(I
.getPair(),
6332 cast
<FunctionDecl
>(FunDecl
->getCanonicalDecl())));
6333 FoundNonTemplateFunction
= true;
6338 // If there were 0 or 1 matches, we're done.
6339 if (Matches
.empty()) {
6341 Diag(From
->getLocStart(), diag::err_addr_ovl_no_viable
)
6342 << OvlExpr
->getName() << FunctionType
;
6343 for (UnresolvedSetIterator I
= OvlExpr
->decls_begin(),
6344 E
= OvlExpr
->decls_end();
6346 if (FunctionDecl
*F
= dyn_cast
<FunctionDecl
>((*I
)->getUnderlyingDecl()))
6347 NoteOverloadCandidate(F
);
6351 } else if (Matches
.size() == 1) {
6352 FunctionDecl
*Result
= Matches
[0].second
;
6353 FoundResult
= Matches
[0].first
;
6354 MarkDeclarationReferenced(From
->getLocStart(), Result
);
6356 CheckAddressOfMemberAccess(OvlExpr
, Matches
[0].first
);
6360 // C++ [over.over]p4:
6361 // If more than one function is selected, [...]
6362 if (!FoundNonTemplateFunction
) {
6363 // [...] and any given function template specialization F1 is
6364 // eliminated if the set contains a second function template
6365 // specialization whose function template is more specialized
6366 // than the function template of F1 according to the partial
6367 // ordering rules of 14.5.5.2.
6369 // The algorithm specified above is quadratic. We instead use a
6370 // two-pass algorithm (similar to the one used to identify the
6371 // best viable function in an overload set) that identifies the
6372 // best function template (if it exists).
6374 UnresolvedSet
<4> MatchesCopy
; // TODO: avoid!
6375 for (unsigned I
= 0, E
= Matches
.size(); I
!= E
; ++I
)
6376 MatchesCopy
.addDecl(Matches
[I
].second
, Matches
[I
].first
.getAccess());
6378 UnresolvedSetIterator Result
=
6379 getMostSpecialized(MatchesCopy
.begin(), MatchesCopy
.end(),
6380 TPOC_Other
, From
->getLocStart(),
6382 PDiag(diag::err_addr_ovl_ambiguous
)
6383 << Matches
[0].second
->getDeclName(),
6384 PDiag(diag::note_ovl_candidate
)
6385 << (unsigned) oc_function_template
);
6386 assert(Result
!= MatchesCopy
.end() && "no most-specialized template");
6387 MarkDeclarationReferenced(From
->getLocStart(), *Result
);
6388 FoundResult
= Matches
[Result
- MatchesCopy
.begin()].first
;
6390 CheckUnresolvedAccess(*this, OvlExpr
, FoundResult
);
6391 DiagnoseUseOfDecl(FoundResult
, OvlExpr
->getNameLoc());
6393 return cast
<FunctionDecl
>(*Result
);
6396 // [...] any function template specializations in the set are
6397 // eliminated if the set also contains a non-template function, [...]
6398 for (unsigned I
= 0, N
= Matches
.size(); I
!= N
; ) {
6399 if (Matches
[I
].second
->getPrimaryTemplate() == 0)
6402 Matches
[I
] = Matches
[--N
];
6403 Matches
.set_size(N
);
6407 // [...] After such eliminations, if any, there shall remain exactly one
6408 // selected function.
6409 if (Matches
.size() == 1) {
6410 MarkDeclarationReferenced(From
->getLocStart(), Matches
[0].second
);
6411 FoundResult
= Matches
[0].first
;
6413 CheckUnresolvedAccess(*this, OvlExpr
, Matches
[0].first
);
6414 DiagnoseUseOfDecl(Matches
[0].first
, OvlExpr
->getNameLoc());
6416 return cast
<FunctionDecl
>(Matches
[0].second
);
6419 // FIXME: We should probably return the same thing that BestViableFunction
6420 // returns (even if we issue the diagnostics here).
6421 Diag(From
->getLocStart(), diag::err_addr_ovl_ambiguous
)
6422 << Matches
[0].second
->getDeclName();
6423 for (unsigned I
= 0, E
= Matches
.size(); I
!= E
; ++I
)
6424 NoteOverloadCandidate(Matches
[I
].second
);
6428 /// \brief Given an expression that refers to an overloaded function, try to
6429 /// resolve that overloaded function expression down to a single function.
6431 /// This routine can only resolve template-ids that refer to a single function
6432 /// template, where that template-id refers to a single template whose template
6433 /// arguments are either provided by the template-id or have defaults,
6434 /// as described in C++0x [temp.arg.explicit]p3.
6435 FunctionDecl
*Sema::ResolveSingleFunctionTemplateSpecialization(Expr
*From
) {
6436 // C++ [over.over]p1:
6437 // [...] [Note: any redundant set of parentheses surrounding the
6438 // overloaded function name is ignored (5.1). ]
6439 // C++ [over.over]p1:
6440 // [...] The overloaded function name can be preceded by the &
6443 if (From
->getType() != Context
.OverloadTy
)
6446 OverloadExpr
*OvlExpr
= OverloadExpr::find(From
).Expression
;
6448 // If we didn't actually find any template-ids, we're done.
6449 if (!OvlExpr
->hasExplicitTemplateArgs())
6452 TemplateArgumentListInfo ExplicitTemplateArgs
;
6453 OvlExpr
->getExplicitTemplateArgs().copyInto(ExplicitTemplateArgs
);
6455 // Look through all of the overloaded functions, searching for one
6456 // whose type matches exactly.
6457 FunctionDecl
*Matched
= 0;
6458 for (UnresolvedSetIterator I
= OvlExpr
->decls_begin(),
6459 E
= OvlExpr
->decls_end(); I
!= E
; ++I
) {
6460 // C++0x [temp.arg.explicit]p3:
6461 // [...] In contexts where deduction is done and fails, or in contexts
6462 // where deduction is not done, if a template argument list is
6463 // specified and it, along with any default template arguments,
6464 // identifies a single function template specialization, then the
6465 // template-id is an lvalue for the function template specialization.
6466 FunctionTemplateDecl
*FunctionTemplate
6467 = cast
<FunctionTemplateDecl
>((*I
)->getUnderlyingDecl());
6469 // C++ [over.over]p2:
6470 // If the name is a function template, template argument deduction is
6471 // done (14.8.2.2), and if the argument deduction succeeds, the
6472 // resulting template argument list is used to generate a single
6473 // function template specialization, which is added to the set of
6474 // overloaded functions considered.
6475 FunctionDecl
*Specialization
= 0;
6476 TemplateDeductionInfo
Info(Context
, OvlExpr
->getNameLoc());
6477 if (TemplateDeductionResult Result
6478 = DeduceTemplateArguments(FunctionTemplate
, &ExplicitTemplateArgs
,
6479 Specialization
, Info
)) {
6480 // FIXME: make a note of the failed deduction for diagnostics.
6485 // Multiple matches; we can't resolve to a single declaration.
6489 Matched
= Specialization
;
6495 /// \brief Add a single candidate to the overload set.
6496 static void AddOverloadedCallCandidate(Sema
&S
,
6497 DeclAccessPair FoundDecl
,
6498 const TemplateArgumentListInfo
*ExplicitTemplateArgs
,
6499 Expr
**Args
, unsigned NumArgs
,
6500 OverloadCandidateSet
&CandidateSet
,
6501 bool PartialOverloading
) {
6502 NamedDecl
*Callee
= FoundDecl
.getDecl();
6503 if (isa
<UsingShadowDecl
>(Callee
))
6504 Callee
= cast
<UsingShadowDecl
>(Callee
)->getTargetDecl();
6506 if (FunctionDecl
*Func
= dyn_cast
<FunctionDecl
>(Callee
)) {
6507 assert(!ExplicitTemplateArgs
&& "Explicit template arguments?");
6508 S
.AddOverloadCandidate(Func
, FoundDecl
, Args
, NumArgs
, CandidateSet
,
6509 false, PartialOverloading
);
6513 if (FunctionTemplateDecl
*FuncTemplate
6514 = dyn_cast
<FunctionTemplateDecl
>(Callee
)) {
6515 S
.AddTemplateOverloadCandidate(FuncTemplate
, FoundDecl
,
6516 ExplicitTemplateArgs
,
6517 Args
, NumArgs
, CandidateSet
);
6521 assert(false && "unhandled case in overloaded call candidate");
6526 /// \brief Add the overload candidates named by callee and/or found by argument
6527 /// dependent lookup to the given overload set.
6528 void Sema::AddOverloadedCallCandidates(UnresolvedLookupExpr
*ULE
,
6529 Expr
**Args
, unsigned NumArgs
,
6530 OverloadCandidateSet
&CandidateSet
,
6531 bool PartialOverloading
) {
6534 // Verify that ArgumentDependentLookup is consistent with the rules
6535 // in C++0x [basic.lookup.argdep]p3:
6537 // Let X be the lookup set produced by unqualified lookup (3.4.1)
6538 // and let Y be the lookup set produced by argument dependent
6539 // lookup (defined as follows). If X contains
6541 // -- a declaration of a class member, or
6543 // -- a block-scope function declaration that is not a
6544 // using-declaration, or
6546 // -- a declaration that is neither a function or a function
6551 if (ULE
->requiresADL()) {
6552 for (UnresolvedLookupExpr::decls_iterator I
= ULE
->decls_begin(),
6553 E
= ULE
->decls_end(); I
!= E
; ++I
) {
6554 assert(!(*I
)->getDeclContext()->isRecord());
6555 assert(isa
<UsingShadowDecl
>(*I
) ||
6556 !(*I
)->getDeclContext()->isFunctionOrMethod());
6557 assert((*I
)->getUnderlyingDecl()->isFunctionOrFunctionTemplate());
6562 // It would be nice to avoid this copy.
6563 TemplateArgumentListInfo TABuffer
;
6564 const TemplateArgumentListInfo
*ExplicitTemplateArgs
= 0;
6565 if (ULE
->hasExplicitTemplateArgs()) {
6566 ULE
->copyTemplateArgumentsInto(TABuffer
);
6567 ExplicitTemplateArgs
= &TABuffer
;
6570 for (UnresolvedLookupExpr::decls_iterator I
= ULE
->decls_begin(),
6571 E
= ULE
->decls_end(); I
!= E
; ++I
)
6572 AddOverloadedCallCandidate(*this, I
.getPair(), ExplicitTemplateArgs
,
6573 Args
, NumArgs
, CandidateSet
,
6574 PartialOverloading
);
6576 if (ULE
->requiresADL())
6577 AddArgumentDependentLookupCandidates(ULE
->getName(), /*Operator*/ false,
6579 ExplicitTemplateArgs
,
6581 PartialOverloading
);
6584 /// Attempts to recover from a call where no functions were found.
6586 /// Returns true if new candidates were found.
6588 BuildRecoveryCallExpr(Sema
&SemaRef
, Scope
*S
, Expr
*Fn
,
6589 UnresolvedLookupExpr
*ULE
,
6590 SourceLocation LParenLoc
,
6591 Expr
**Args
, unsigned NumArgs
,
6592 SourceLocation
*CommaLocs
,
6593 SourceLocation RParenLoc
) {
6596 if (ULE
->getQualifier()) {
6597 SS
.setScopeRep(ULE
->getQualifier());
6598 SS
.setRange(ULE
->getQualifierRange());
6601 TemplateArgumentListInfo TABuffer
;
6602 const TemplateArgumentListInfo
*ExplicitTemplateArgs
= 0;
6603 if (ULE
->hasExplicitTemplateArgs()) {
6604 ULE
->copyTemplateArgumentsInto(TABuffer
);
6605 ExplicitTemplateArgs
= &TABuffer
;
6608 LookupResult
R(SemaRef
, ULE
->getName(), ULE
->getNameLoc(),
6609 Sema::LookupOrdinaryName
);
6610 if (SemaRef
.DiagnoseEmptyLookup(S
, SS
, R
, Sema::CTC_Expression
))
6613 assert(!R
.empty() && "lookup results empty despite recovery");
6615 // Build an implicit member call if appropriate. Just drop the
6616 // casts and such from the call, we don't really care.
6617 ExprResult NewFn
= ExprError();
6618 if ((*R
.begin())->isCXXClassMember())
6619 NewFn
= SemaRef
.BuildPossibleImplicitMemberExpr(SS
, R
, ExplicitTemplateArgs
);
6620 else if (ExplicitTemplateArgs
)
6621 NewFn
= SemaRef
.BuildTemplateIdExpr(SS
, R
, false, *ExplicitTemplateArgs
);
6623 NewFn
= SemaRef
.BuildDeclarationNameExpr(SS
, R
, false);
6625 if (NewFn
.isInvalid())
6628 // This shouldn't cause an infinite loop because we're giving it
6629 // an expression with non-empty lookup results, which should never
6631 return SemaRef
.ActOnCallExpr(/*Scope*/ 0, NewFn
.take(), LParenLoc
,
6632 MultiExprArg(Args
, NumArgs
),
6633 CommaLocs
, RParenLoc
);
6636 /// ResolveOverloadedCallFn - Given the call expression that calls Fn
6637 /// (which eventually refers to the declaration Func) and the call
6638 /// arguments Args/NumArgs, attempt to resolve the function call down
6639 /// to a specific function. If overload resolution succeeds, returns
6640 /// the function declaration produced by overload
6641 /// resolution. Otherwise, emits diagnostics, deletes all of the
6642 /// arguments and Fn, and returns NULL.
6644 Sema::BuildOverloadedCallExpr(Scope
*S
, Expr
*Fn
, UnresolvedLookupExpr
*ULE
,
6645 SourceLocation LParenLoc
,
6646 Expr
**Args
, unsigned NumArgs
,
6647 SourceLocation
*CommaLocs
,
6648 SourceLocation RParenLoc
) {
6650 if (ULE
->requiresADL()) {
6651 // To do ADL, we must have found an unqualified name.
6652 assert(!ULE
->getQualifier() && "qualified name with ADL");
6654 // We don't perform ADL for implicit declarations of builtins.
6655 // Verify that this was correctly set up.
6657 if (ULE
->decls_begin() + 1 == ULE
->decls_end() &&
6658 (F
= dyn_cast
<FunctionDecl
>(*ULE
->decls_begin())) &&
6659 F
->getBuiltinID() && F
->isImplicit())
6660 assert(0 && "performing ADL for builtin");
6662 // We don't perform ADL in C.
6663 assert(getLangOptions().CPlusPlus
&& "ADL enabled in C");
6667 OverloadCandidateSet
CandidateSet(Fn
->getExprLoc());
6669 // Add the functions denoted by the callee to the set of candidate
6670 // functions, including those from argument-dependent lookup.
6671 AddOverloadedCallCandidates(ULE
, Args
, NumArgs
, CandidateSet
);
6673 // If we found nothing, try to recover.
6674 // AddRecoveryCallCandidates diagnoses the error itself, so we just
6675 // bailout out if it fails.
6676 if (CandidateSet
.empty())
6677 return BuildRecoveryCallExpr(*this, S
, Fn
, ULE
, LParenLoc
, Args
, NumArgs
,
6678 CommaLocs
, RParenLoc
);
6680 OverloadCandidateSet::iterator Best
;
6681 switch (CandidateSet
.BestViableFunction(*this, Fn
->getLocStart(), Best
)) {
6683 FunctionDecl
*FDecl
= Best
->Function
;
6684 CheckUnresolvedLookupAccess(ULE
, Best
->FoundDecl
);
6685 DiagnoseUseOfDecl(Best
->FoundDecl
, ULE
->getNameLoc());
6686 Fn
= FixOverloadedFunctionReference(Fn
, Best
->FoundDecl
, FDecl
);
6687 return BuildResolvedCallExpr(Fn
, FDecl
, LParenLoc
, Args
, NumArgs
, RParenLoc
);
6690 case OR_No_Viable_Function
:
6691 Diag(Fn
->getSourceRange().getBegin(),
6692 diag::err_ovl_no_viable_function_in_call
)
6693 << ULE
->getName() << Fn
->getSourceRange();
6694 CandidateSet
.NoteCandidates(*this, OCD_AllCandidates
, Args
, NumArgs
);
6698 Diag(Fn
->getSourceRange().getBegin(), diag::err_ovl_ambiguous_call
)
6699 << ULE
->getName() << Fn
->getSourceRange();
6700 CandidateSet
.NoteCandidates(*this, OCD_ViableCandidates
, Args
, NumArgs
);
6704 Diag(Fn
->getSourceRange().getBegin(), diag::err_ovl_deleted_call
)
6705 << Best
->Function
->isDeleted()
6707 << Fn
->getSourceRange();
6708 CandidateSet
.NoteCandidates(*this, OCD_AllCandidates
, Args
, NumArgs
);
6712 // Overload resolution failed.
6716 static bool IsOverloaded(const UnresolvedSetImpl
&Functions
) {
6717 return Functions
.size() > 1 ||
6718 (Functions
.size() == 1 && isa
<FunctionTemplateDecl
>(*Functions
.begin()));
6721 /// \brief Create a unary operation that may resolve to an overloaded
6724 /// \param OpLoc The location of the operator itself (e.g., '*').
6726 /// \param OpcIn The UnaryOperator::Opcode that describes this
6729 /// \param Functions The set of non-member functions that will be
6730 /// considered by overload resolution. The caller needs to build this
6731 /// set based on the context using, e.g.,
6732 /// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This
6733 /// set should not contain any member functions; those will be added
6734 /// by CreateOverloadedUnaryOp().
6736 /// \param input The input argument.
6738 Sema::CreateOverloadedUnaryOp(SourceLocation OpLoc
, unsigned OpcIn
,
6739 const UnresolvedSetImpl
&Fns
,
6741 UnaryOperator::Opcode Opc
= static_cast<UnaryOperator::Opcode
>(OpcIn
);
6743 OverloadedOperatorKind Op
= UnaryOperator::getOverloadedOperator(Opc
);
6744 assert(Op
!= OO_None
&& "Invalid opcode for overloaded unary operator");
6745 DeclarationName OpName
= Context
.DeclarationNames
.getCXXOperatorName(Op
);
6746 // TODO: provide better source location info.
6747 DeclarationNameInfo
OpNameInfo(OpName
, OpLoc
);
6749 Expr
*Args
[2] = { Input
, 0 };
6750 unsigned NumArgs
= 1;
6752 // For post-increment and post-decrement, add the implicit '0' as
6753 // the second argument, so that we know this is a post-increment or
6755 if (Opc
== UO_PostInc
|| Opc
== UO_PostDec
) {
6756 llvm::APSInt
Zero(Context
.getTypeSize(Context
.IntTy
), false);
6757 Args
[1] = IntegerLiteral::Create(Context
, Zero
, Context
.IntTy
,
6762 if (Input
->isTypeDependent()) {
6764 return Owned(new (Context
) UnaryOperator(Input
,
6766 Context
.DependentTy
,
6769 CXXRecordDecl
*NamingClass
= 0; // because lookup ignores member operators
6770 UnresolvedLookupExpr
*Fn
6771 = UnresolvedLookupExpr::Create(Context
, /*Dependent*/ true, NamingClass
,
6772 0, SourceRange(), OpNameInfo
,
6773 /*ADL*/ true, IsOverloaded(Fns
),
6774 Fns
.begin(), Fns
.end());
6775 return Owned(new (Context
) CXXOperatorCallExpr(Context
, Op
, Fn
,
6777 Context
.DependentTy
,
6781 // Build an empty overload set.
6782 OverloadCandidateSet
CandidateSet(OpLoc
);
6784 // Add the candidates from the given function set.
6785 AddFunctionCandidates(Fns
, &Args
[0], NumArgs
, CandidateSet
, false);
6787 // Add operator candidates that are member functions.
6788 AddMemberOperatorCandidates(Op
, OpLoc
, &Args
[0], NumArgs
, CandidateSet
);
6790 // Add candidates from ADL.
6791 AddArgumentDependentLookupCandidates(OpName
, /*Operator*/ true,
6793 /*ExplicitTemplateArgs*/ 0,
6796 // Add builtin operator candidates.
6797 AddBuiltinOperatorCandidates(Op
, OpLoc
, &Args
[0], NumArgs
, CandidateSet
);
6799 // Perform overload resolution.
6800 OverloadCandidateSet::iterator Best
;
6801 switch (CandidateSet
.BestViableFunction(*this, OpLoc
, Best
)) {
6803 // We found a built-in operator or an overloaded operator.
6804 FunctionDecl
*FnDecl
= Best
->Function
;
6807 // We matched an overloaded operator. Build a call to that
6810 // Convert the arguments.
6811 if (CXXMethodDecl
*Method
= dyn_cast
<CXXMethodDecl
>(FnDecl
)) {
6812 CheckMemberOperatorAccess(OpLoc
, Args
[0], 0, Best
->FoundDecl
);
6814 if (PerformObjectArgumentInitialization(Input
, /*Qualifier=*/0,
6815 Best
->FoundDecl
, Method
))
6818 // Convert the arguments.
6819 ExprResult InputInit
6820 = PerformCopyInitialization(InitializedEntity::InitializeParameter(
6821 FnDecl
->getParamDecl(0)),
6824 if (InputInit
.isInvalid())
6826 Input
= InputInit
.take();
6829 DiagnoseUseOfDecl(Best
->FoundDecl
, OpLoc
);
6831 // Determine the result type
6832 QualType ResultTy
= FnDecl
->getCallResultType();
6834 // Build the actual expression node.
6835 Expr
*FnExpr
= new (Context
) DeclRefExpr(FnDecl
, FnDecl
->getType(),
6837 UsualUnaryConversions(FnExpr
);
6841 new (Context
) CXXOperatorCallExpr(Context
, Op
, FnExpr
,
6842 Args
, NumArgs
, ResultTy
, OpLoc
);
6844 if (CheckCallReturnType(FnDecl
->getResultType(), OpLoc
, TheCall
,
6848 return MaybeBindToTemporary(TheCall
);
6850 // We matched a built-in operator. Convert the arguments, then
6851 // break out so that we will build the appropriate built-in
6853 if (PerformImplicitConversion(Input
, Best
->BuiltinTypes
.ParamTypes
[0],
6854 Best
->Conversions
[0], AA_Passing
))
6861 case OR_No_Viable_Function
:
6862 // No viable function; fall through to handling this as a
6863 // built-in operator, which will produce an error message for us.
6867 Diag(OpLoc
, diag::err_ovl_ambiguous_oper
)
6868 << UnaryOperator::getOpcodeStr(Opc
)
6869 << Input
->getSourceRange();
6870 CandidateSet
.NoteCandidates(*this, OCD_ViableCandidates
,
6872 UnaryOperator::getOpcodeStr(Opc
), OpLoc
);
6876 Diag(OpLoc
, diag::err_ovl_deleted_oper
)
6877 << Best
->Function
->isDeleted()
6878 << UnaryOperator::getOpcodeStr(Opc
)
6879 << Input
->getSourceRange();
6880 CandidateSet
.NoteCandidates(*this, OCD_AllCandidates
, Args
, NumArgs
);
6884 // Either we found no viable overloaded operator or we matched a
6885 // built-in operator. In either case, fall through to trying to
6886 // build a built-in operation.
6887 return CreateBuiltinUnaryOp(OpLoc
, Opc
, Input
);
6890 /// \brief Create a binary operation that may resolve to an overloaded
6893 /// \param OpLoc The location of the operator itself (e.g., '+').
6895 /// \param OpcIn The BinaryOperator::Opcode that describes this
6898 /// \param Functions The set of non-member functions that will be
6899 /// considered by overload resolution. The caller needs to build this
6900 /// set based on the context using, e.g.,
6901 /// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This
6902 /// set should not contain any member functions; those will be added
6903 /// by CreateOverloadedBinOp().
6905 /// \param LHS Left-hand argument.
6906 /// \param RHS Right-hand argument.
6908 Sema::CreateOverloadedBinOp(SourceLocation OpLoc
,
6910 const UnresolvedSetImpl
&Fns
,
6911 Expr
*LHS
, Expr
*RHS
) {
6912 Expr
*Args
[2] = { LHS
, RHS
};
6913 LHS
=RHS
=0; //Please use only Args instead of LHS/RHS couple
6915 BinaryOperator::Opcode Opc
= static_cast<BinaryOperator::Opcode
>(OpcIn
);
6916 OverloadedOperatorKind Op
= BinaryOperator::getOverloadedOperator(Opc
);
6917 DeclarationName OpName
= Context
.DeclarationNames
.getCXXOperatorName(Op
);
6919 // If either side is type-dependent, create an appropriate dependent
6921 if (Args
[0]->isTypeDependent() || Args
[1]->isTypeDependent()) {
6923 // If there are no functions to store, just build a dependent
6924 // BinaryOperator or CompoundAssignment.
6925 if (Opc
<= BO_Assign
|| Opc
> BO_OrAssign
)
6926 return Owned(new (Context
) BinaryOperator(Args
[0], Args
[1], Opc
,
6927 Context
.DependentTy
, OpLoc
));
6929 return Owned(new (Context
) CompoundAssignOperator(Args
[0], Args
[1], Opc
,
6930 Context
.DependentTy
,
6931 Context
.DependentTy
,
6932 Context
.DependentTy
,
6936 // FIXME: save results of ADL from here?
6937 CXXRecordDecl
*NamingClass
= 0; // because lookup ignores member operators
6938 // TODO: provide better source location info in DNLoc component.
6939 DeclarationNameInfo
OpNameInfo(OpName
, OpLoc
);
6940 UnresolvedLookupExpr
*Fn
6941 = UnresolvedLookupExpr::Create(Context
, /*Dependent*/ true, NamingClass
,
6942 0, SourceRange(), OpNameInfo
,
6943 /*ADL*/ true, IsOverloaded(Fns
),
6944 Fns
.begin(), Fns
.end());
6945 return Owned(new (Context
) CXXOperatorCallExpr(Context
, Op
, Fn
,
6947 Context
.DependentTy
,
6951 // If this is the .* operator, which is not overloadable, just
6952 // create a built-in binary operator.
6953 if (Opc
== BO_PtrMemD
)
6954 return CreateBuiltinBinOp(OpLoc
, Opc
, Args
[0], Args
[1]);
6956 // If this is the assignment operator, we only perform overload resolution
6957 // if the left-hand side is a class or enumeration type. This is actually
6958 // a hack. The standard requires that we do overload resolution between the
6959 // various built-in candidates, but as DR507 points out, this can lead to
6960 // problems. So we do it this way, which pretty much follows what GCC does.
6961 // Note that we go the traditional code path for compound assignment forms.
6962 if (Opc
== BO_Assign
&& !Args
[0]->getType()->isOverloadableType())
6963 return CreateBuiltinBinOp(OpLoc
, Opc
, Args
[0], Args
[1]);
6965 // Build an empty overload set.
6966 OverloadCandidateSet
CandidateSet(OpLoc
);
6968 // Add the candidates from the given function set.
6969 AddFunctionCandidates(Fns
, Args
, 2, CandidateSet
, false);
6971 // Add operator candidates that are member functions.
6972 AddMemberOperatorCandidates(Op
, OpLoc
, Args
, 2, CandidateSet
);
6974 // Add candidates from ADL.
6975 AddArgumentDependentLookupCandidates(OpName
, /*Operator*/ true,
6977 /*ExplicitTemplateArgs*/ 0,
6980 // Add builtin operator candidates.
6981 AddBuiltinOperatorCandidates(Op
, OpLoc
, Args
, 2, CandidateSet
);
6983 // Perform overload resolution.
6984 OverloadCandidateSet::iterator Best
;
6985 switch (CandidateSet
.BestViableFunction(*this, OpLoc
, Best
)) {
6987 // We found a built-in operator or an overloaded operator.
6988 FunctionDecl
*FnDecl
= Best
->Function
;
6991 // We matched an overloaded operator. Build a call to that
6994 // Convert the arguments.
6995 if (CXXMethodDecl
*Method
= dyn_cast
<CXXMethodDecl
>(FnDecl
)) {
6996 // Best->Access is only meaningful for class members.
6997 CheckMemberOperatorAccess(OpLoc
, Args
[0], Args
[1], Best
->FoundDecl
);
7000 = PerformCopyInitialization(
7001 InitializedEntity::InitializeParameter(
7002 FnDecl
->getParamDecl(0)),
7005 if (Arg1
.isInvalid())
7008 if (PerformObjectArgumentInitialization(Args
[0], /*Qualifier=*/0,
7009 Best
->FoundDecl
, Method
))
7012 Args
[1] = RHS
= Arg1
.takeAs
<Expr
>();
7014 // Convert the arguments.
7016 = PerformCopyInitialization(
7017 InitializedEntity::InitializeParameter(
7018 FnDecl
->getParamDecl(0)),
7021 if (Arg0
.isInvalid())
7025 = PerformCopyInitialization(
7026 InitializedEntity::InitializeParameter(
7027 FnDecl
->getParamDecl(1)),
7030 if (Arg1
.isInvalid())
7032 Args
[0] = LHS
= Arg0
.takeAs
<Expr
>();
7033 Args
[1] = RHS
= Arg1
.takeAs
<Expr
>();
7036 DiagnoseUseOfDecl(Best
->FoundDecl
, OpLoc
);
7038 // Determine the result type
7040 = FnDecl
->getType()->getAs
<FunctionType
>()
7041 ->getCallResultType(Context
);
7043 // Build the actual expression node.
7044 Expr
*FnExpr
= new (Context
) DeclRefExpr(FnDecl
, FnDecl
->getType(),
7046 UsualUnaryConversions(FnExpr
);
7048 CXXOperatorCallExpr
*TheCall
=
7049 new (Context
) CXXOperatorCallExpr(Context
, Op
, FnExpr
,
7050 Args
, 2, ResultTy
, OpLoc
);
7052 if (CheckCallReturnType(FnDecl
->getResultType(), OpLoc
, TheCall
,
7056 return MaybeBindToTemporary(TheCall
);
7058 // We matched a built-in operator. Convert the arguments, then
7059 // break out so that we will build the appropriate built-in
7061 if (PerformImplicitConversion(Args
[0], Best
->BuiltinTypes
.ParamTypes
[0],
7062 Best
->Conversions
[0], AA_Passing
) ||
7063 PerformImplicitConversion(Args
[1], Best
->BuiltinTypes
.ParamTypes
[1],
7064 Best
->Conversions
[1], AA_Passing
))
7071 case OR_No_Viable_Function
: {
7072 // C++ [over.match.oper]p9:
7073 // If the operator is the operator , [...] and there are no
7074 // viable functions, then the operator is assumed to be the
7075 // built-in operator and interpreted according to clause 5.
7076 if (Opc
== BO_Comma
)
7079 // For class as left operand for assignment or compound assigment operator
7080 // do not fall through to handling in built-in, but report that no overloaded
7081 // assignment operator found
7082 ExprResult Result
= ExprError();
7083 if (Args
[0]->getType()->isRecordType() &&
7084 Opc
>= BO_Assign
&& Opc
<= BO_OrAssign
) {
7085 Diag(OpLoc
, diag::err_ovl_no_viable_oper
)
7086 << BinaryOperator::getOpcodeStr(Opc
)
7087 << Args
[0]->getSourceRange() << Args
[1]->getSourceRange();
7089 // No viable function; try to create a built-in operation, which will
7090 // produce an error. Then, show the non-viable candidates.
7091 Result
= CreateBuiltinBinOp(OpLoc
, Opc
, Args
[0], Args
[1]);
7093 assert(Result
.isInvalid() &&
7094 "C++ binary operator overloading is missing candidates!");
7095 if (Result
.isInvalid())
7096 CandidateSet
.NoteCandidates(*this, OCD_AllCandidates
, Args
, 2,
7097 BinaryOperator::getOpcodeStr(Opc
), OpLoc
);
7098 return move(Result
);
7102 Diag(OpLoc
, diag::err_ovl_ambiguous_oper
)
7103 << BinaryOperator::getOpcodeStr(Opc
)
7104 << Args
[0]->getSourceRange() << Args
[1]->getSourceRange();
7105 CandidateSet
.NoteCandidates(*this, OCD_ViableCandidates
, Args
, 2,
7106 BinaryOperator::getOpcodeStr(Opc
), OpLoc
);
7110 Diag(OpLoc
, diag::err_ovl_deleted_oper
)
7111 << Best
->Function
->isDeleted()
7112 << BinaryOperator::getOpcodeStr(Opc
)
7113 << Args
[0]->getSourceRange() << Args
[1]->getSourceRange();
7114 CandidateSet
.NoteCandidates(*this, OCD_AllCandidates
, Args
, 2);
7118 // We matched a built-in operator; build it.
7119 return CreateBuiltinBinOp(OpLoc
, Opc
, Args
[0], Args
[1]);
7123 Sema::CreateOverloadedArraySubscriptExpr(SourceLocation LLoc
,
7124 SourceLocation RLoc
,
7125 Expr
*Base
, Expr
*Idx
) {
7126 Expr
*Args
[2] = { Base
, Idx
};
7127 DeclarationName OpName
=
7128 Context
.DeclarationNames
.getCXXOperatorName(OO_Subscript
);
7130 // If either side is type-dependent, create an appropriate dependent
7132 if (Args
[0]->isTypeDependent() || Args
[1]->isTypeDependent()) {
7134 CXXRecordDecl
*NamingClass
= 0; // because lookup ignores member operators
7135 // CHECKME: no 'operator' keyword?
7136 DeclarationNameInfo
OpNameInfo(OpName
, LLoc
);
7137 OpNameInfo
.setCXXOperatorNameRange(SourceRange(LLoc
, RLoc
));
7138 UnresolvedLookupExpr
*Fn
7139 = UnresolvedLookupExpr::Create(Context
, /*Dependent*/ true, NamingClass
,
7140 0, SourceRange(), OpNameInfo
,
7141 /*ADL*/ true, /*Overloaded*/ false,
7142 UnresolvedSetIterator(),
7143 UnresolvedSetIterator());
7144 // Can't add any actual overloads yet
7146 return Owned(new (Context
) CXXOperatorCallExpr(Context
, OO_Subscript
, Fn
,
7148 Context
.DependentTy
,
7152 // Build an empty overload set.
7153 OverloadCandidateSet
CandidateSet(LLoc
);
7155 // Subscript can only be overloaded as a member function.
7157 // Add operator candidates that are member functions.
7158 AddMemberOperatorCandidates(OO_Subscript
, LLoc
, Args
, 2, CandidateSet
);
7160 // Add builtin operator candidates.
7161 AddBuiltinOperatorCandidates(OO_Subscript
, LLoc
, Args
, 2, CandidateSet
);
7163 // Perform overload resolution.
7164 OverloadCandidateSet::iterator Best
;
7165 switch (CandidateSet
.BestViableFunction(*this, LLoc
, Best
)) {
7167 // We found a built-in operator or an overloaded operator.
7168 FunctionDecl
*FnDecl
= Best
->Function
;
7171 // We matched an overloaded operator. Build a call to that
7174 CheckMemberOperatorAccess(LLoc
, Args
[0], Args
[1], Best
->FoundDecl
);
7175 DiagnoseUseOfDecl(Best
->FoundDecl
, LLoc
);
7177 // Convert the arguments.
7178 CXXMethodDecl
*Method
= cast
<CXXMethodDecl
>(FnDecl
);
7179 if (PerformObjectArgumentInitialization(Args
[0], /*Qualifier=*/0,
7180 Best
->FoundDecl
, Method
))
7183 // Convert the arguments.
7184 ExprResult InputInit
7185 = PerformCopyInitialization(InitializedEntity::InitializeParameter(
7186 FnDecl
->getParamDecl(0)),
7189 if (InputInit
.isInvalid())
7192 Args
[1] = InputInit
.takeAs
<Expr
>();
7194 // Determine the result type
7196 = FnDecl
->getType()->getAs
<FunctionType
>()
7197 ->getCallResultType(Context
);
7199 // Build the actual expression node.
7200 Expr
*FnExpr
= new (Context
) DeclRefExpr(FnDecl
, FnDecl
->getType(),
7202 UsualUnaryConversions(FnExpr
);
7204 CXXOperatorCallExpr
*TheCall
=
7205 new (Context
) CXXOperatorCallExpr(Context
, OO_Subscript
,
7209 if (CheckCallReturnType(FnDecl
->getResultType(), LLoc
, TheCall
,
7213 return MaybeBindToTemporary(TheCall
);
7215 // We matched a built-in operator. Convert the arguments, then
7216 // break out so that we will build the appropriate built-in
7218 if (PerformImplicitConversion(Args
[0], Best
->BuiltinTypes
.ParamTypes
[0],
7219 Best
->Conversions
[0], AA_Passing
) ||
7220 PerformImplicitConversion(Args
[1], Best
->BuiltinTypes
.ParamTypes
[1],
7221 Best
->Conversions
[1], AA_Passing
))
7228 case OR_No_Viable_Function
: {
7229 if (CandidateSet
.empty())
7230 Diag(LLoc
, diag::err_ovl_no_oper
)
7231 << Args
[0]->getType() << /*subscript*/ 0
7232 << Args
[0]->getSourceRange() << Args
[1]->getSourceRange();
7234 Diag(LLoc
, diag::err_ovl_no_viable_subscript
)
7235 << Args
[0]->getType()
7236 << Args
[0]->getSourceRange() << Args
[1]->getSourceRange();
7237 CandidateSet
.NoteCandidates(*this, OCD_AllCandidates
, Args
, 2,
7243 Diag(LLoc
, diag::err_ovl_ambiguous_oper
)
7244 << "[]" << Args
[0]->getSourceRange() << Args
[1]->getSourceRange();
7245 CandidateSet
.NoteCandidates(*this, OCD_ViableCandidates
, Args
, 2,
7250 Diag(LLoc
, diag::err_ovl_deleted_oper
)
7251 << Best
->Function
->isDeleted() << "[]"
7252 << Args
[0]->getSourceRange() << Args
[1]->getSourceRange();
7253 CandidateSet
.NoteCandidates(*this, OCD_AllCandidates
, Args
, 2,
7258 // We matched a built-in operator; build it.
7259 return CreateBuiltinArraySubscriptExpr(Args
[0], LLoc
, Args
[1], RLoc
);
7262 /// BuildCallToMemberFunction - Build a call to a member
7263 /// function. MemExpr is the expression that refers to the member
7264 /// function (and includes the object parameter), Args/NumArgs are the
7265 /// arguments to the function call (not including the object
7266 /// parameter). The caller needs to validate that the member
7267 /// expression refers to a member function or an overloaded member
7270 Sema::BuildCallToMemberFunction(Scope
*S
, Expr
*MemExprE
,
7271 SourceLocation LParenLoc
, Expr
**Args
,
7272 unsigned NumArgs
, SourceLocation
*CommaLocs
,
7273 SourceLocation RParenLoc
) {
7274 // Dig out the member expression. This holds both the object
7275 // argument and the member function we're referring to.
7276 Expr
*NakedMemExpr
= MemExprE
->IgnoreParens();
7278 MemberExpr
*MemExpr
;
7279 CXXMethodDecl
*Method
= 0;
7280 DeclAccessPair FoundDecl
= DeclAccessPair::make(0, AS_public
);
7281 NestedNameSpecifier
*Qualifier
= 0;
7282 if (isa
<MemberExpr
>(NakedMemExpr
)) {
7283 MemExpr
= cast
<MemberExpr
>(NakedMemExpr
);
7284 Method
= cast
<CXXMethodDecl
>(MemExpr
->getMemberDecl());
7285 FoundDecl
= MemExpr
->getFoundDecl();
7286 Qualifier
= MemExpr
->getQualifier();
7288 UnresolvedMemberExpr
*UnresExpr
= cast
<UnresolvedMemberExpr
>(NakedMemExpr
);
7289 Qualifier
= UnresExpr
->getQualifier();
7291 QualType ObjectType
= UnresExpr
->getBaseType();
7293 // Add overload candidates
7294 OverloadCandidateSet
CandidateSet(UnresExpr
->getMemberLoc());
7296 // FIXME: avoid copy.
7297 TemplateArgumentListInfo TemplateArgsBuffer
, *TemplateArgs
= 0;
7298 if (UnresExpr
->hasExplicitTemplateArgs()) {
7299 UnresExpr
->copyTemplateArgumentsInto(TemplateArgsBuffer
);
7300 TemplateArgs
= &TemplateArgsBuffer
;
7303 for (UnresolvedMemberExpr::decls_iterator I
= UnresExpr
->decls_begin(),
7304 E
= UnresExpr
->decls_end(); I
!= E
; ++I
) {
7306 NamedDecl
*Func
= *I
;
7307 CXXRecordDecl
*ActingDC
= cast
<CXXRecordDecl
>(Func
->getDeclContext());
7308 if (isa
<UsingShadowDecl
>(Func
))
7309 Func
= cast
<UsingShadowDecl
>(Func
)->getTargetDecl();
7311 if ((Method
= dyn_cast
<CXXMethodDecl
>(Func
))) {
7312 // If explicit template arguments were provided, we can't call a
7313 // non-template member function.
7317 AddMethodCandidate(Method
, I
.getPair(), ActingDC
, ObjectType
,
7319 CandidateSet
, /*SuppressUserConversions=*/false);
7321 AddMethodTemplateCandidate(cast
<FunctionTemplateDecl
>(Func
),
7322 I
.getPair(), ActingDC
, TemplateArgs
,
7323 ObjectType
, Args
, NumArgs
,
7325 /*SuppressUsedConversions=*/false);
7329 DeclarationName DeclName
= UnresExpr
->getMemberName();
7331 OverloadCandidateSet::iterator Best
;
7332 switch (CandidateSet
.BestViableFunction(*this, UnresExpr
->getLocStart(),
7335 Method
= cast
<CXXMethodDecl
>(Best
->Function
);
7336 FoundDecl
= Best
->FoundDecl
;
7337 CheckUnresolvedMemberAccess(UnresExpr
, Best
->FoundDecl
);
7338 DiagnoseUseOfDecl(Best
->FoundDecl
, UnresExpr
->getNameLoc());
7341 case OR_No_Viable_Function
:
7342 Diag(UnresExpr
->getMemberLoc(),
7343 diag::err_ovl_no_viable_member_function_in_call
)
7344 << DeclName
<< MemExprE
->getSourceRange();
7345 CandidateSet
.NoteCandidates(*this, OCD_AllCandidates
, Args
, NumArgs
);
7346 // FIXME: Leaking incoming expressions!
7350 Diag(UnresExpr
->getMemberLoc(), diag::err_ovl_ambiguous_member_call
)
7351 << DeclName
<< MemExprE
->getSourceRange();
7352 CandidateSet
.NoteCandidates(*this, OCD_AllCandidates
, Args
, NumArgs
);
7353 // FIXME: Leaking incoming expressions!
7357 Diag(UnresExpr
->getMemberLoc(), diag::err_ovl_deleted_member_call
)
7358 << Best
->Function
->isDeleted()
7359 << DeclName
<< MemExprE
->getSourceRange();
7360 CandidateSet
.NoteCandidates(*this, OCD_AllCandidates
, Args
, NumArgs
);
7361 // FIXME: Leaking incoming expressions!
7365 MemExprE
= FixOverloadedFunctionReference(MemExprE
, FoundDecl
, Method
);
7367 // If overload resolution picked a static member, build a
7368 // non-member call based on that function.
7369 if (Method
->isStatic()) {
7370 return BuildResolvedCallExpr(MemExprE
, Method
, LParenLoc
,
7371 Args
, NumArgs
, RParenLoc
);
7374 MemExpr
= cast
<MemberExpr
>(MemExprE
->IgnoreParens());
7377 assert(Method
&& "Member call to something that isn't a method?");
7378 CXXMemberCallExpr
*TheCall
=
7379 new (Context
) CXXMemberCallExpr(Context
, MemExprE
, Args
, NumArgs
,
7380 Method
->getCallResultType(),
7383 // Check for a valid return type.
7384 if (CheckCallReturnType(Method
->getResultType(), MemExpr
->getMemberLoc(),
7388 // Convert the object argument (for a non-static member function call).
7389 // We only need to do this if there was actually an overload; otherwise
7390 // it was done at lookup.
7391 Expr
*ObjectArg
= MemExpr
->getBase();
7392 if (!Method
->isStatic() &&
7393 PerformObjectArgumentInitialization(ObjectArg
, Qualifier
,
7396 MemExpr
->setBase(ObjectArg
);
7398 // Convert the rest of the arguments
7399 const FunctionProtoType
*Proto
= Method
->getType()->getAs
<FunctionProtoType
>();
7400 if (ConvertArgumentsForCall(TheCall
, MemExpr
, Method
, Proto
, Args
, NumArgs
,
7404 if (CheckFunctionCall(Method
, TheCall
))
7407 return MaybeBindToTemporary(TheCall
);
7410 /// BuildCallToObjectOfClassType - Build a call to an object of class
7411 /// type (C++ [over.call.object]), which can end up invoking an
7412 /// overloaded function call operator (@c operator()) or performing a
7413 /// user-defined conversion on the object argument.
7415 Sema::BuildCallToObjectOfClassType(Scope
*S
, Expr
*Object
,
7416 SourceLocation LParenLoc
,
7417 Expr
**Args
, unsigned NumArgs
,
7418 SourceLocation
*CommaLocs
,
7419 SourceLocation RParenLoc
) {
7420 assert(Object
->getType()->isRecordType() && "Requires object type argument");
7421 const RecordType
*Record
= Object
->getType()->getAs
<RecordType
>();
7423 // C++ [over.call.object]p1:
7424 // If the primary-expression E in the function call syntax
7425 // evaluates to a class object of type "cv T", then the set of
7426 // candidate functions includes at least the function call
7427 // operators of T. The function call operators of T are obtained by
7428 // ordinary lookup of the name operator() in the context of
7430 OverloadCandidateSet
CandidateSet(LParenLoc
);
7431 DeclarationName OpName
= Context
.DeclarationNames
.getCXXOperatorName(OO_Call
);
7433 if (RequireCompleteType(LParenLoc
, Object
->getType(),
7434 PDiag(diag::err_incomplete_object_call
)
7435 << Object
->getSourceRange()))
7438 LookupResult
R(*this, OpName
, LParenLoc
, LookupOrdinaryName
);
7439 LookupQualifiedName(R
, Record
->getDecl());
7440 R
.suppressDiagnostics();
7442 for (LookupResult::iterator Oper
= R
.begin(), OperEnd
= R
.end();
7443 Oper
!= OperEnd
; ++Oper
) {
7444 AddMethodCandidate(Oper
.getPair(), Object
->getType(),
7445 Args
, NumArgs
, CandidateSet
,
7446 /*SuppressUserConversions=*/ false);
7449 // C++ [over.call.object]p2:
7450 // In addition, for each conversion function declared in T of the
7453 // operator conversion-type-id () cv-qualifier;
7455 // where cv-qualifier is the same cv-qualification as, or a
7456 // greater cv-qualification than, cv, and where conversion-type-id
7457 // denotes the type "pointer to function of (P1,...,Pn) returning
7458 // R", or the type "reference to pointer to function of
7459 // (P1,...,Pn) returning R", or the type "reference to function
7460 // of (P1,...,Pn) returning R", a surrogate call function [...]
7461 // is also considered as a candidate function. Similarly,
7462 // surrogate call functions are added to the set of candidate
7463 // functions for each conversion function declared in an
7464 // accessible base class provided the function is not hidden
7465 // within T by another intervening declaration.
7466 const UnresolvedSetImpl
*Conversions
7467 = cast
<CXXRecordDecl
>(Record
->getDecl())->getVisibleConversionFunctions();
7468 for (UnresolvedSetImpl::iterator I
= Conversions
->begin(),
7469 E
= Conversions
->end(); I
!= E
; ++I
) {
7471 CXXRecordDecl
*ActingContext
= cast
<CXXRecordDecl
>(D
->getDeclContext());
7472 if (isa
<UsingShadowDecl
>(D
))
7473 D
= cast
<UsingShadowDecl
>(D
)->getTargetDecl();
7475 // Skip over templated conversion functions; they aren't
7477 if (isa
<FunctionTemplateDecl
>(D
))
7480 CXXConversionDecl
*Conv
= cast
<CXXConversionDecl
>(D
);
7482 // Strip the reference type (if any) and then the pointer type (if
7483 // any) to get down to what might be a function type.
7484 QualType ConvType
= Conv
->getConversionType().getNonReferenceType();
7485 if (const PointerType
*ConvPtrType
= ConvType
->getAs
<PointerType
>())
7486 ConvType
= ConvPtrType
->getPointeeType();
7488 if (const FunctionProtoType
*Proto
= ConvType
->getAs
<FunctionProtoType
>())
7489 AddSurrogateCandidate(Conv
, I
.getPair(), ActingContext
, Proto
,
7490 Object
->getType(), Args
, NumArgs
,
7494 // Perform overload resolution.
7495 OverloadCandidateSet::iterator Best
;
7496 switch (CandidateSet
.BestViableFunction(*this, Object
->getLocStart(),
7499 // Overload resolution succeeded; we'll build the appropriate call
7503 case OR_No_Viable_Function
:
7504 if (CandidateSet
.empty())
7505 Diag(Object
->getSourceRange().getBegin(), diag::err_ovl_no_oper
)
7506 << Object
->getType() << /*call*/ 1
7507 << Object
->getSourceRange();
7509 Diag(Object
->getSourceRange().getBegin(),
7510 diag::err_ovl_no_viable_object_call
)
7511 << Object
->getType() << Object
->getSourceRange();
7512 CandidateSet
.NoteCandidates(*this, OCD_AllCandidates
, Args
, NumArgs
);
7516 Diag(Object
->getSourceRange().getBegin(),
7517 diag::err_ovl_ambiguous_object_call
)
7518 << Object
->getType() << Object
->getSourceRange();
7519 CandidateSet
.NoteCandidates(*this, OCD_ViableCandidates
, Args
, NumArgs
);
7523 Diag(Object
->getSourceRange().getBegin(),
7524 diag::err_ovl_deleted_object_call
)
7525 << Best
->Function
->isDeleted()
7526 << Object
->getType() << Object
->getSourceRange();
7527 CandidateSet
.NoteCandidates(*this, OCD_AllCandidates
, Args
, NumArgs
);
7531 if (Best
== CandidateSet
.end())
7534 if (Best
->Function
== 0) {
7535 // Since there is no function declaration, this is one of the
7536 // surrogate candidates. Dig out the conversion function.
7537 CXXConversionDecl
*Conv
7538 = cast
<CXXConversionDecl
>(
7539 Best
->Conversions
[0].UserDefined
.ConversionFunction
);
7541 CheckMemberOperatorAccess(LParenLoc
, Object
, 0, Best
->FoundDecl
);
7542 DiagnoseUseOfDecl(Best
->FoundDecl
, LParenLoc
);
7544 // We selected one of the surrogate functions that converts the
7545 // object parameter to a function pointer. Perform the conversion
7546 // on the object argument, then let ActOnCallExpr finish the job.
7548 // Create an implicit member expr to refer to the conversion operator.
7549 // and then call it.
7550 CXXMemberCallExpr
*CE
= BuildCXXMemberCallExpr(Object
, Best
->FoundDecl
,
7553 return ActOnCallExpr(S
, CE
, LParenLoc
, MultiExprArg(Args
, NumArgs
),
7554 CommaLocs
, RParenLoc
);
7557 CheckMemberOperatorAccess(LParenLoc
, Object
, 0, Best
->FoundDecl
);
7558 DiagnoseUseOfDecl(Best
->FoundDecl
, LParenLoc
);
7560 // We found an overloaded operator(). Build a CXXOperatorCallExpr
7561 // that calls this method, using Object for the implicit object
7562 // parameter and passing along the remaining arguments.
7563 CXXMethodDecl
*Method
= cast
<CXXMethodDecl
>(Best
->Function
);
7564 const FunctionProtoType
*Proto
= Method
->getType()->getAs
<FunctionProtoType
>();
7566 unsigned NumArgsInProto
= Proto
->getNumArgs();
7567 unsigned NumArgsToCheck
= NumArgs
;
7569 // Build the full argument list for the method call (the
7570 // implicit object parameter is placed at the beginning of the
7573 if (NumArgs
< NumArgsInProto
) {
7574 NumArgsToCheck
= NumArgsInProto
;
7575 MethodArgs
= new Expr
*[NumArgsInProto
+ 1];
7577 MethodArgs
= new Expr
*[NumArgs
+ 1];
7579 MethodArgs
[0] = Object
;
7580 for (unsigned ArgIdx
= 0; ArgIdx
< NumArgs
; ++ArgIdx
)
7581 MethodArgs
[ArgIdx
+ 1] = Args
[ArgIdx
];
7583 Expr
*NewFn
= new (Context
) DeclRefExpr(Method
, Method
->getType(),
7585 UsualUnaryConversions(NewFn
);
7587 // Once we've built TheCall, all of the expressions are properly
7589 QualType ResultTy
= Method
->getCallResultType();
7590 CXXOperatorCallExpr
*TheCall
=
7591 new (Context
) CXXOperatorCallExpr(Context
, OO_Call
, NewFn
,
7592 MethodArgs
, NumArgs
+ 1,
7593 ResultTy
, RParenLoc
);
7594 delete [] MethodArgs
;
7596 if (CheckCallReturnType(Method
->getResultType(), LParenLoc
, TheCall
,
7600 // We may have default arguments. If so, we need to allocate more
7601 // slots in the call for them.
7602 if (NumArgs
< NumArgsInProto
)
7603 TheCall
->setNumArgs(Context
, NumArgsInProto
+ 1);
7604 else if (NumArgs
> NumArgsInProto
)
7605 NumArgsToCheck
= NumArgsInProto
;
7607 bool IsError
= false;
7609 // Initialize the implicit object parameter.
7610 IsError
|= PerformObjectArgumentInitialization(Object
, /*Qualifier=*/0,
7611 Best
->FoundDecl
, Method
);
7612 TheCall
->setArg(0, Object
);
7615 // Check the argument types.
7616 for (unsigned i
= 0; i
!= NumArgsToCheck
; i
++) {
7621 // Pass the argument.
7623 ExprResult InputInit
7624 = PerformCopyInitialization(InitializedEntity::InitializeParameter(
7625 Method
->getParamDecl(i
)),
7626 SourceLocation(), Arg
);
7628 IsError
|= InputInit
.isInvalid();
7629 Arg
= InputInit
.takeAs
<Expr
>();
7632 = BuildCXXDefaultArgExpr(LParenLoc
, Method
, Method
->getParamDecl(i
));
7633 if (DefArg
.isInvalid()) {
7638 Arg
= DefArg
.takeAs
<Expr
>();
7641 TheCall
->setArg(i
+ 1, Arg
);
7644 // If this is a variadic call, handle args passed through "...".
7645 if (Proto
->isVariadic()) {
7646 // Promote the arguments (C99 6.5.2.2p7).
7647 for (unsigned i
= NumArgsInProto
; i
!= NumArgs
; i
++) {
7648 Expr
*Arg
= Args
[i
];
7649 IsError
|= DefaultVariadicArgumentPromotion(Arg
, VariadicMethod
, 0);
7650 TheCall
->setArg(i
+ 1, Arg
);
7654 if (IsError
) return true;
7656 if (CheckFunctionCall(Method
, TheCall
))
7659 return MaybeBindToTemporary(TheCall
);
7662 /// BuildOverloadedArrowExpr - Build a call to an overloaded @c operator->
7663 /// (if one exists), where @c Base is an expression of class type and
7664 /// @c Member is the name of the member we're trying to find.
7666 Sema::BuildOverloadedArrowExpr(Scope
*S
, Expr
*Base
, SourceLocation OpLoc
) {
7667 assert(Base
->getType()->isRecordType() && "left-hand side must have class type");
7669 SourceLocation Loc
= Base
->getExprLoc();
7671 // C++ [over.ref]p1:
7673 // [...] An expression x->m is interpreted as (x.operator->())->m
7674 // for a class object x of type T if T::operator->() exists and if
7675 // the operator is selected as the best match function by the
7676 // overload resolution mechanism (13.3).
7677 DeclarationName OpName
= Context
.DeclarationNames
.getCXXOperatorName(OO_Arrow
);
7678 OverloadCandidateSet
CandidateSet(Loc
);
7679 const RecordType
*BaseRecord
= Base
->getType()->getAs
<RecordType
>();
7681 if (RequireCompleteType(Loc
, Base
->getType(),
7682 PDiag(diag::err_typecheck_incomplete_tag
)
7683 << Base
->getSourceRange()))
7686 LookupResult
R(*this, OpName
, OpLoc
, LookupOrdinaryName
);
7687 LookupQualifiedName(R
, BaseRecord
->getDecl());
7688 R
.suppressDiagnostics();
7690 for (LookupResult::iterator Oper
= R
.begin(), OperEnd
= R
.end();
7691 Oper
!= OperEnd
; ++Oper
) {
7692 AddMethodCandidate(Oper
.getPair(), Base
->getType(), 0, 0, CandidateSet
,
7693 /*SuppressUserConversions=*/false);
7696 // Perform overload resolution.
7697 OverloadCandidateSet::iterator Best
;
7698 switch (CandidateSet
.BestViableFunction(*this, OpLoc
, Best
)) {
7700 // Overload resolution succeeded; we'll build the call below.
7703 case OR_No_Viable_Function
:
7704 if (CandidateSet
.empty())
7705 Diag(OpLoc
, diag::err_typecheck_member_reference_arrow
)
7706 << Base
->getType() << Base
->getSourceRange();
7708 Diag(OpLoc
, diag::err_ovl_no_viable_oper
)
7709 << "operator->" << Base
->getSourceRange();
7710 CandidateSet
.NoteCandidates(*this, OCD_AllCandidates
, &Base
, 1);
7714 Diag(OpLoc
, diag::err_ovl_ambiguous_oper
)
7715 << "->" << Base
->getSourceRange();
7716 CandidateSet
.NoteCandidates(*this, OCD_ViableCandidates
, &Base
, 1);
7720 Diag(OpLoc
, diag::err_ovl_deleted_oper
)
7721 << Best
->Function
->isDeleted()
7722 << "->" << Base
->getSourceRange();
7723 CandidateSet
.NoteCandidates(*this, OCD_AllCandidates
, &Base
, 1);
7727 CheckMemberOperatorAccess(OpLoc
, Base
, 0, Best
->FoundDecl
);
7728 DiagnoseUseOfDecl(Best
->FoundDecl
, OpLoc
);
7730 // Convert the object parameter.
7731 CXXMethodDecl
*Method
= cast
<CXXMethodDecl
>(Best
->Function
);
7732 if (PerformObjectArgumentInitialization(Base
, /*Qualifier=*/0,
7733 Best
->FoundDecl
, Method
))
7736 // Build the operator call.
7737 Expr
*FnExpr
= new (Context
) DeclRefExpr(Method
, Method
->getType(),
7739 UsualUnaryConversions(FnExpr
);
7741 QualType ResultTy
= Method
->getCallResultType();
7742 CXXOperatorCallExpr
*TheCall
=
7743 new (Context
) CXXOperatorCallExpr(Context
, OO_Arrow
, FnExpr
,
7744 &Base
, 1, ResultTy
, OpLoc
);
7746 if (CheckCallReturnType(Method
->getResultType(), OpLoc
, TheCall
,
7749 return Owned(TheCall
);
7752 /// FixOverloadedFunctionReference - E is an expression that refers to
7753 /// a C++ overloaded function (possibly with some parentheses and
7754 /// perhaps a '&' around it). We have resolved the overloaded function
7755 /// to the function declaration Fn, so patch up the expression E to
7756 /// refer (possibly indirectly) to Fn. Returns the new expr.
7757 Expr
*Sema::FixOverloadedFunctionReference(Expr
*E
, DeclAccessPair Found
,
7759 if (ParenExpr
*PE
= dyn_cast
<ParenExpr
>(E
)) {
7760 Expr
*SubExpr
= FixOverloadedFunctionReference(PE
->getSubExpr(),
7762 if (SubExpr
== PE
->getSubExpr())
7763 return PE
->Retain();
7765 return new (Context
) ParenExpr(PE
->getLParen(), PE
->getRParen(), SubExpr
);
7768 if (ImplicitCastExpr
*ICE
= dyn_cast
<ImplicitCastExpr
>(E
)) {
7769 Expr
*SubExpr
= FixOverloadedFunctionReference(ICE
->getSubExpr(),
7771 assert(Context
.hasSameType(ICE
->getSubExpr()->getType(),
7772 SubExpr
->getType()) &&
7773 "Implicit cast type cannot be determined from overload");
7774 assert(ICE
->path_empty() && "fixing up hierarchy conversion?");
7775 if (SubExpr
== ICE
->getSubExpr())
7776 return ICE
->Retain();
7778 return ImplicitCastExpr::Create(Context
, ICE
->getType(),
7781 ICE
->getValueKind());
7784 if (UnaryOperator
*UnOp
= dyn_cast
<UnaryOperator
>(E
)) {
7785 assert(UnOp
->getOpcode() == UO_AddrOf
&&
7786 "Can only take the address of an overloaded function");
7787 if (CXXMethodDecl
*Method
= dyn_cast
<CXXMethodDecl
>(Fn
)) {
7788 if (Method
->isStatic()) {
7789 // Do nothing: static member functions aren't any different
7790 // from non-member functions.
7792 // Fix the sub expression, which really has to be an
7793 // UnresolvedLookupExpr holding an overloaded member function
7795 Expr
*SubExpr
= FixOverloadedFunctionReference(UnOp
->getSubExpr(),
7797 if (SubExpr
== UnOp
->getSubExpr())
7798 return UnOp
->Retain();
7800 assert(isa
<DeclRefExpr
>(SubExpr
)
7801 && "fixed to something other than a decl ref");
7802 assert(cast
<DeclRefExpr
>(SubExpr
)->getQualifier()
7803 && "fixed to a member ref with no nested name qualifier");
7805 // We have taken the address of a pointer to member
7806 // function. Perform the computation here so that we get the
7807 // appropriate pointer to member type.
7809 = Context
.getTypeDeclType(cast
<RecordDecl
>(Method
->getDeclContext()));
7811 = Context
.getMemberPointerType(Fn
->getType(), ClassType
.getTypePtr());
7813 return new (Context
) UnaryOperator(SubExpr
, UO_AddrOf
,
7814 MemPtrType
, UnOp
->getOperatorLoc());
7817 Expr
*SubExpr
= FixOverloadedFunctionReference(UnOp
->getSubExpr(),
7819 if (SubExpr
== UnOp
->getSubExpr())
7820 return UnOp
->Retain();
7822 return new (Context
) UnaryOperator(SubExpr
, UO_AddrOf
,
7823 Context
.getPointerType(SubExpr
->getType()),
7824 UnOp
->getOperatorLoc());
7827 if (UnresolvedLookupExpr
*ULE
= dyn_cast
<UnresolvedLookupExpr
>(E
)) {
7828 // FIXME: avoid copy.
7829 TemplateArgumentListInfo TemplateArgsBuffer
, *TemplateArgs
= 0;
7830 if (ULE
->hasExplicitTemplateArgs()) {
7831 ULE
->copyTemplateArgumentsInto(TemplateArgsBuffer
);
7832 TemplateArgs
= &TemplateArgsBuffer
;
7835 return DeclRefExpr::Create(Context
,
7836 ULE
->getQualifier(),
7837 ULE
->getQualifierRange(),
7844 if (UnresolvedMemberExpr
*MemExpr
= dyn_cast
<UnresolvedMemberExpr
>(E
)) {
7845 // FIXME: avoid copy.
7846 TemplateArgumentListInfo TemplateArgsBuffer
, *TemplateArgs
= 0;
7847 if (MemExpr
->hasExplicitTemplateArgs()) {
7848 MemExpr
->copyTemplateArgumentsInto(TemplateArgsBuffer
);
7849 TemplateArgs
= &TemplateArgsBuffer
;
7854 // If we're filling in
7855 if (MemExpr
->isImplicitAccess()) {
7856 if (cast
<CXXMethodDecl
>(Fn
)->isStatic()) {
7857 return DeclRefExpr::Create(Context
,
7858 MemExpr
->getQualifier(),
7859 MemExpr
->getQualifierRange(),
7861 MemExpr
->getMemberLoc(),
7865 SourceLocation Loc
= MemExpr
->getMemberLoc();
7866 if (MemExpr
->getQualifier())
7867 Loc
= MemExpr
->getQualifierRange().getBegin();
7868 Base
= new (Context
) CXXThisExpr(Loc
,
7869 MemExpr
->getBaseType(),
7870 /*isImplicit=*/true);
7873 Base
= MemExpr
->getBase()->Retain();
7875 return MemberExpr::Create(Context
, Base
,
7877 MemExpr
->getQualifier(),
7878 MemExpr
->getQualifierRange(),
7881 MemExpr
->getMemberNameInfo(),
7886 assert(false && "Invalid reference to overloaded function");
7890 ExprResult
Sema::FixOverloadedFunctionReference(ExprResult E
,
7891 DeclAccessPair Found
,
7893 return Owned(FixOverloadedFunctionReference((Expr
*)E
.get(), Found
, Fn
));
7896 } // end namespace clang