[clang] [clang] Bugfix for choosing the more specialized overload (PR #83279)
Botond István Horváth via cfe-commits
cfe-commits at lists.llvm.org
Fri Mar 1 05:41:01 PST 2024
https://github.com/HoBoIs updated https://github.com/llvm/llvm-project/pull/83279
>From 68200ecf3267d1b3940fa73c25c50ee706932a98 Mon Sep 17 00:00:00 2001
From: Botond Istvan Horvath <horvath.botond.istvan at gmail.com>
Date: Wed, 28 Feb 2024 13:09:15 +0100
Subject: [PATCH 1/5] Bugfix for choosing the more specialized overload
There was a bug in clang where it couldn't choose which overload candidate is
more specialized if it was comparing a member-function to a non-member
function. Previously, this was detected as an ambigouity, now clang chooses correctly.
This patch fixes the bug by fully implementing CWG2445 and moving the template
transformation described in [temp.func.order] paragraph 3 from
isAtLeastAsSpecializedAs to Sema::getMoreSpecializedTemplate so we have the
transformed parameter list during the whole comperrassion. Also, to be able
to add the correct type for the implicit object parameter
Sema::getMoreSpecializedTemplate has new parameters for the object type.
---
clang/include/clang/Sema/Sema.h | 4 +-
clang/lib/Sema/SemaOverload.cpp | 12 +-
clang/lib/Sema/SemaTemplateDeduction.cpp | 263 +++++++++++++++--------
3 files changed, 186 insertions(+), 93 deletions(-)
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index ef4b93fac95ce5..1a2a3a6bebd95e 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -9463,7 +9463,9 @@ class Sema final {
FunctionTemplateDecl *getMoreSpecializedTemplate(
FunctionTemplateDecl *FT1, FunctionTemplateDecl *FT2, SourceLocation Loc,
TemplatePartialOrderingContext TPOC, unsigned NumCallArguments1,
- unsigned NumCallArguments2, bool Reversed = false);
+ unsigned NumCallArguments2, QualType ObjType1 = {},
+ QualType ObjType2 = {}, bool Reversed = false);
+
UnresolvedSetIterator
getMostSpecialized(UnresolvedSetIterator SBegin, UnresolvedSetIterator SEnd,
TemplateSpecCandidateSet &FailedCandidates,
diff --git a/clang/lib/Sema/SemaOverload.cpp b/clang/lib/Sema/SemaOverload.cpp
index 7d38043890ca20..60138236abf1d8 100644
--- a/clang/lib/Sema/SemaOverload.cpp
+++ b/clang/lib/Sema/SemaOverload.cpp
@@ -10526,14 +10526,24 @@ bool clang::isBetterOverloadCandidate(
// according to the partial ordering rules described in 14.5.5.2, or,
// if not that,
if (Cand1IsSpecialization && Cand2IsSpecialization) {
+ const auto *ObjContext1 =
+ dyn_cast<CXXRecordDecl>(Cand1.FoundDecl->getDeclContext());
+ const auto *ObjContext2 =
+ dyn_cast<CXXRecordDecl>(Cand2.FoundDecl->getDeclContext());
if (FunctionTemplateDecl *BetterTemplate = S.getMoreSpecializedTemplate(
Cand1.Function->getPrimaryTemplate(),
Cand2.Function->getPrimaryTemplate(), Loc,
isa<CXXConversionDecl>(Cand1.Function) ? TPOC_Conversion
: TPOC_Call,
Cand1.ExplicitCallArguments, Cand2.ExplicitCallArguments,
- Cand1.isReversed() ^ Cand2.isReversed()))
+ ObjContext1 ? QualType(ObjContext1->getTypeForDecl(), 0)
+ : QualType{},
+ ObjContext2 ? QualType(ObjContext2->getTypeForDecl(), 0)
+ : QualType{},
+ Cand1.isReversed() ^ Cand2.isReversed())) {
return BetterTemplate == Cand1.Function->getPrimaryTemplate();
+ }
+
}
// -— F1 and F2 are non-template functions with the same
diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp
index 563491f76f5478..2af3c29ae1f1c4 100644
--- a/clang/lib/Sema/SemaTemplateDeduction.cpp
+++ b/clang/lib/Sema/SemaTemplateDeduction.cpp
@@ -5333,11 +5333,31 @@ bool Sema::CheckIfFunctionSpecializationIsImmediate(FunctionDecl *FD,
return false;
}
+static QualType GetImplicitObjectParameterTypeCXX20(ASTContext &Context,
+ const CXXMethodDecl *Method,
+ QualType rawType,
+ bool isOtherRvr) {
+ // C++20 [temp.func.order]p3.1, p3.2:
+ //- The type X(M ) is “rvalue reference to cv A” if the optional ref-qualifier
+ // of M is && or if M has no ref-qualifier and the positionally-corresponding
+ // parameter of the other transformed template has rvalue reference type;
+ // if this determination depends recursively upon whether X(M ) is an rvalue
+ // reference type, it is not considered to have rvalue reference type.
+ //- Otherwise, X(M ) is “lvalue reference to cv A”.
+ assert(Method && !Method->isExplicitObjectMemberFunction() &&
+ "expected a member function with no explicit object parameter");
+
+ rawType = Context.getQualifiedType(rawType, Method->getMethodQualifiers());
+ if (Method->getRefQualifier() == RQ_RValue ||
+ (isOtherRvr && Method->getRefQualifier() == RQ_None))
+ return Context.getRValueReferenceType(rawType);
+ return Context.getLValueReferenceType(rawType);
+}
+
/// If this is a non-static member function,
-static void
-AddImplicitObjectParameterType(ASTContext &Context,
- CXXMethodDecl *Method,
- SmallVectorImpl<QualType> &ArgTypes) {
+static QualType GetImplicitObjectParameterType(ASTContext &Context,
+ const CXXMethodDecl *Method,
+ QualType rawType) {
// C++11 [temp.func.order]p3:
// [...] The new parameter is of type "reference to cv A," where cv are
// the cv-qualifiers of the function template (if any) and A is
@@ -5347,24 +5367,21 @@ AddImplicitObjectParameterType(ASTContext &Context,
// reference type based on [over.match.funcs]p4.
assert(Method && Method->isImplicitObjectMemberFunction() &&
"expected an implicit objet function");
- QualType ArgTy = Context.getTypeDeclType(Method->getParent());
- ArgTy = Context.getQualifiedType(ArgTy, Method->getMethodQualifiers());
+ rawType = Context.getQualifiedType(rawType, Method->getMethodQualifiers());
if (Method->getRefQualifier() == RQ_RValue)
- ArgTy = Context.getRValueReferenceType(ArgTy);
- else
- ArgTy = Context.getLValueReferenceType(ArgTy);
- ArgTypes.push_back(ArgTy);
+ return Context.getRValueReferenceType(rawType);
+ return Context.getLValueReferenceType(rawType);
}
/// Determine whether the function template \p FT1 is at least as
/// specialized as \p FT2.
-static bool isAtLeastAsSpecializedAs(Sema &S,
- SourceLocation Loc,
- FunctionTemplateDecl *FT1,
- FunctionTemplateDecl *FT2,
+static bool isAtLeastAsSpecializedAs(Sema &S, SourceLocation Loc,
+ const FunctionTemplateDecl *FT1,
+ const FunctionTemplateDecl *FT2,
TemplatePartialOrderingContext TPOC,
- unsigned NumCallArguments1,
- bool Reversed) {
+ bool Reversed,
+ const SmallVector<QualType, 4> &Args1,
+ const SmallVector<QualType, 4> &Args2) {
assert(!Reversed || TPOC == TPOC_Call);
FunctionDecl *FD1 = FT1->getTemplatedDecl();
@@ -5381,66 +5398,8 @@ static bool isAtLeastAsSpecializedAs(Sema &S,
// The types used to determine the ordering depend on the context in which
// the partial ordering is done:
TemplateDeductionInfo Info(Loc);
- SmallVector<QualType, 4> Args2;
switch (TPOC) {
- case TPOC_Call: {
- // - In the context of a function call, the function parameter types are
- // used.
- CXXMethodDecl *Method1 = dyn_cast<CXXMethodDecl>(FD1);
- CXXMethodDecl *Method2 = dyn_cast<CXXMethodDecl>(FD2);
-
- // C++11 [temp.func.order]p3:
- // [...] If only one of the function templates is a non-static
- // member, that function template is considered to have a new
- // first parameter inserted in its function parameter list. The
- // new parameter is of type "reference to cv A," where cv are
- // the cv-qualifiers of the function template (if any) and A is
- // the class of which the function template is a member.
- //
- // Note that we interpret this to mean "if one of the function
- // templates is a non-static member and the other is a non-member";
- // otherwise, the ordering rules for static functions against non-static
- // functions don't make any sense.
- //
- // C++98/03 doesn't have this provision but we've extended DR532 to cover
- // it as wording was broken prior to it.
- SmallVector<QualType, 4> Args1;
-
- unsigned NumComparedArguments = NumCallArguments1;
-
- if (!Method2 && Method1 && Method1->isImplicitObjectMemberFunction()) {
- // Compare 'this' from Method1 against first parameter from Method2.
- AddImplicitObjectParameterType(S.Context, Method1, Args1);
- ++NumComparedArguments;
- } else if (!Method1 && Method2 &&
- Method2->isImplicitObjectMemberFunction()) {
- // Compare 'this' from Method2 against first parameter from Method1.
- AddImplicitObjectParameterType(S.Context, Method2, Args2);
- } else if (Method1 && Method2 && Reversed &&
- Method1->isImplicitObjectMemberFunction() &&
- Method2->isImplicitObjectMemberFunction()) {
- // Compare 'this' from Method1 against second parameter from Method2
- // and 'this' from Method2 against second parameter from Method1.
- AddImplicitObjectParameterType(S.Context, Method1, Args1);
- AddImplicitObjectParameterType(S.Context, Method2, Args2);
- ++NumComparedArguments;
- }
-
- Args1.insert(Args1.end(), Proto1->param_type_begin(),
- Proto1->param_type_end());
- Args2.insert(Args2.end(), Proto2->param_type_begin(),
- Proto2->param_type_end());
-
- // C++ [temp.func.order]p5:
- // The presence of unused ellipsis and default arguments has no effect on
- // the partial ordering of function templates.
- if (Args1.size() > NumComparedArguments)
- Args1.resize(NumComparedArguments);
- if (Args2.size() > NumComparedArguments)
- Args2.resize(NumComparedArguments);
- if (Reversed)
- std::reverse(Args2.begin(), Args2.end());
-
+ case TPOC_Call:
if (DeduceTemplateArguments(S, TemplateParams, Args2.data(), Args2.size(),
Args1.data(), Args1.size(), Info, Deduced,
TDF_None, /*PartialOrdering=*/true) !=
@@ -5448,7 +5407,6 @@ static bool isAtLeastAsSpecializedAs(Sema &S,
return false;
break;
- }
case TPOC_Conversion:
// - In the context of a call to a conversion operator, the return types
@@ -5539,6 +5497,14 @@ static bool isAtLeastAsSpecializedAs(Sema &S,
/// \param NumCallArguments2 The number of arguments in the call to FT2, used
/// only when \c TPOC is \c TPOC_Call.
///
+/// \param RawObjType1 The type of the object parameter of FT1 if a member
+/// function only used if \c TPOC is \c TPOC_Call and FT1 is a Function
+/// template from a member function
+///
+/// \param RawObjType2 The type of the object parameter of FT2 if a member
+/// function only used if \c TPOC is \c TPOC_Call and FT2 is a Function
+/// template from a member function
+///
/// \param Reversed If \c true, exactly one of FT1 and FT2 is an overload
/// candidate with a reversed parameter order. In this case, the corresponding
/// P/A pairs between FT1 and FT2 are reversed.
@@ -5548,13 +5514,113 @@ static bool isAtLeastAsSpecializedAs(Sema &S,
FunctionTemplateDecl *Sema::getMoreSpecializedTemplate(
FunctionTemplateDecl *FT1, FunctionTemplateDecl *FT2, SourceLocation Loc,
TemplatePartialOrderingContext TPOC, unsigned NumCallArguments1,
- unsigned NumCallArguments2, bool Reversed) {
+ unsigned NumCallArguments2, QualType RawObjType1, QualType RawObjType2,
+ bool Reversed) {
+ SmallVector<QualType, 4> Args1;
+ SmallVector<QualType, 4> Args2;
+ const FunctionDecl *FD1 = FT1->getTemplatedDecl();
+ const FunctionDecl *FD2 = FT2->getTemplatedDecl();
+ bool shouldConvert1 = false;
+ bool shouldConvert2 = false;
+ QualType ObjType1;
+ QualType ObjType2;
+ if (TPOC == TPOC_Call) {
+ const FunctionProtoType *Proto1 =
+ FD1->getType()->getAs<FunctionProtoType>();
+ const FunctionProtoType *Proto2 =
+ FD2->getType()->getAs<FunctionProtoType>();
- bool Better1 = isAtLeastAsSpecializedAs(*this, Loc, FT1, FT2, TPOC,
- NumCallArguments1, Reversed);
- bool Better2 = isAtLeastAsSpecializedAs(*this, Loc, FT2, FT1, TPOC,
- NumCallArguments2, Reversed);
+ // - In the context of a function call, the function parameter types are
+ // used.
+ const CXXMethodDecl *Method1 = dyn_cast<CXXMethodDecl>(FD1);
+ const CXXMethodDecl *Method2 = dyn_cast<CXXMethodDecl>(FD2);
+
+ if (getLangOpts().CPlusPlus20) {
+ // C++20 [temp.func.order]p3
+ // [...] Each function template M that is a member function is
+ // considered to have a new first parameter of type
+ // X(M), described below, inserted in its function parameter list.
+ //
+ // Note that we interpret "that is a member function" as
+ // "that is a member function with no expicit object argument".
+ // Otherwise the ordering rules for methods with expicit objet arguments
+ // against anything else make no sense.
+ shouldConvert1 = Method1 && !Method1->isExplicitObjectMemberFunction();
+ shouldConvert2 = Method2 && !Method2->isExplicitObjectMemberFunction();
+ if (shouldConvert1) {
+ bool isR2 =
+ Method2 && !Method2->isExplicitObjectMemberFunction()
+ ? Method2->getRefQualifier() == RQ_RValue
+ : Proto2->param_type_begin()[0]->isRValueReferenceType();
+ // Compare 'this' from Method1 against first parameter from Method2.
+ ObjType1 = GetImplicitObjectParameterTypeCXX20(this->Context, Method1,
+ RawObjType1, isR2);
+ Args1.push_back(ObjType1);
+ }
+ if (shouldConvert2) {
+ bool isR1 =
+ Method1 && !Method1->isExplicitObjectMemberFunction()
+ ? Method1->getRefQualifier() == RQ_RValue
+ : Proto1->param_type_begin()[0]->isRValueReferenceType();
+ // Compare 'this' from Method2 against first parameter from Method1.
+ ObjType2 = GetImplicitObjectParameterTypeCXX20(this->Context, Method2,
+ RawObjType2, isR1);
+ Args2.push_back(ObjType2);
+ }
+ } else {
+ // C++11 [temp.func.order]p3:
+ // [...] If only one of the function templates is a non-static
+ // member, that function template is considered to have a new
+ // first parameter inserted in its function parameter list. The
+ // new parameter is of type "reference to cv A," where cv are
+ // the cv-qualifiers of the function template (if any) and A is
+ // the class of which the function template is a member.
+ //
+ // Note that we interpret this to mean "if one of the function
+ // templates is a non-static member and the other is a non-member";
+ // otherwise, the ordering rules for static functions against non-static
+ // functions don't make any sense.
+ //
+ // C++98/03 doesn't have this provision but we've extended DR532 to cover
+ // it as wording was broken prior to it.
+ shouldConvert1 =
+ !Method2 && Method1 && Method1->isImplicitObjectMemberFunction();
+ shouldConvert2 =
+ !Method1 && Method2 && Method2->isImplicitObjectMemberFunction();
+ if (shouldConvert1) {
+ // Compare 'this' from Method1 against first parameter from Method2.
+ ObjType1 =
+ GetImplicitObjectParameterType(this->Context, Method1, RawObjType1);
+ Args1.push_back(ObjType1);
+ }
+ if (shouldConvert2) {
+ // Compare 'this' from Method2 against first parameter from Method1.
+ ObjType2 =
+ GetImplicitObjectParameterType(this->Context, Method2, RawObjType2);
+ Args2.push_back(ObjType2);
+ }
+ }
+ unsigned NumComparedArguments = NumCallArguments1 + shouldConvert1;
+
+ Args1.insert(Args1.end(), Proto1->param_type_begin(),
+ Proto1->param_type_end());
+ Args2.insert(Args2.end(), Proto2->param_type_begin(),
+ Proto2->param_type_end());
+ // C++ [temp.func.order]p5:
+ // The presence of unused ellipsis and default arguments has no effect on
+ // the partial ordering of function templates.
+ if (Args1.size() > NumComparedArguments)
+ Args1.resize(NumComparedArguments);
+ if (Args2.size() > NumComparedArguments)
+ Args2.resize(NumComparedArguments);
+ if (Reversed)
+ std::reverse(Args2.begin(), Args2.end());
+ }
+ bool Better1 = isAtLeastAsSpecializedAs(*this, Loc, FT1, FT2, TPOC, Reversed,
+ Args1, Args2);
+ bool Better2 = isAtLeastAsSpecializedAs(*this, Loc, FT2, FT1, TPOC, Reversed,
+ Args2, Args1);
// C++ [temp.deduct.partial]p10:
// F is more specialized than G if F is at least as specialized as G and G
// is not at least as specialized as F.
@@ -5568,12 +5634,28 @@ FunctionTemplateDecl *Sema::getMoreSpecializedTemplate(
// ... and if G has a trailing function parameter pack for which F does not
// have a corresponding parameter, and if F does not have a trailing
// function parameter pack, then F is more specialized than G.
- FunctionDecl *FD1 = FT1->getTemplatedDecl();
- FunctionDecl *FD2 = FT2->getTemplatedDecl();
- unsigned NumParams1 = FD1->getNumParams();
- unsigned NumParams2 = FD2->getNumParams();
- bool Variadic1 = NumParams1 && FD1->parameters().back()->isParameterPack();
- bool Variadic2 = NumParams2 && FD2->parameters().back()->isParameterPack();
+
+ SmallVector<QualType> param1;
+ param1.reserve(FD1->param_size() + shouldConvert1);
+ if (shouldConvert1)
+ param1.push_back(ObjType1);
+ for (const auto &x : FD1->parameters())
+ param1.push_back(x->getType());
+
+ SmallVector<QualType> param2;
+ param2.reserve(FD2->param_size() + shouldConvert2);
+ if (shouldConvert2)
+ param2.push_back(ObjType2);
+ for (const auto &x : FD2->parameters())
+ param2.push_back(x->getType());
+
+ unsigned NumParams1 = param1.size();
+ unsigned NumParams2 = param2.size();
+
+ bool Variadic1 =
+ FD1->param_size() && FD1->parameters().back()->isParameterPack();
+ bool Variadic2 =
+ FD2->param_size() && FD2->parameters().back()->isParameterPack();
if (Variadic1 != Variadic2) {
if (Variadic1 && NumParams1 > NumParams2)
return FT2;
@@ -5584,8 +5666,8 @@ FunctionTemplateDecl *Sema::getMoreSpecializedTemplate(
// This a speculative fix for CWG1432 (Similar to the fix for CWG1395) that
// there is no wording or even resolution for this issue.
for (int i = 0, e = std::min(NumParams1, NumParams2); i < e; ++i) {
- QualType T1 = FD1->getParamDecl(i)->getType().getCanonicalType();
- QualType T2 = FD2->getParamDecl(i)->getType().getCanonicalType();
+ QualType T1 = param1[i].getCanonicalType();
+ QualType T2 = param2[i].getCanonicalType();
auto *TST1 = dyn_cast<TemplateSpecializationType>(T1);
auto *TST2 = dyn_cast<TemplateSpecializationType>(T2);
if (!TST1 || !TST2)
@@ -5644,8 +5726,7 @@ FunctionTemplateDecl *Sema::getMoreSpecializedTemplate(
// Any top-level cv-qualifiers modifying a parameter type are deleted when
// forming the function type.
for (unsigned i = 0; i < NumParams1; ++i)
- if (!Context.hasSameUnqualifiedType(FD1->getParamDecl(i)->getType(),
- FD2->getParamDecl(i)->getType()))
+ if (!Context.hasSameUnqualifiedType(param1[i], param2[i]))
return nullptr;
// C++20 [temp.func.order]p6.3:
>From 3cb51452a25227afb0750ae65fcca9bf281433ac Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Botond=20Istv=C3=A1n=20Horv=C3=A1th?=
<56926027+HoBoIs at users.noreply.github.com>
Date: Wed, 28 Feb 2024 16:50:30 +0100
Subject: [PATCH 2/5] Formatting SemaOverload.cpp
---
clang/lib/Sema/SemaOverload.cpp | 1 -
1 file changed, 1 deletion(-)
diff --git a/clang/lib/Sema/SemaOverload.cpp b/clang/lib/Sema/SemaOverload.cpp
index 60138236abf1d8..74d714ad308af1 100644
--- a/clang/lib/Sema/SemaOverload.cpp
+++ b/clang/lib/Sema/SemaOverload.cpp
@@ -10543,7 +10543,6 @@ bool clang::isBetterOverloadCandidate(
Cand1.isReversed() ^ Cand2.isReversed())) {
return BetterTemplate == Cand1.Function->getPrimaryTemplate();
}
-
}
// -— F1 and F2 are non-template functions with the same
>From 54e7fb1ae193196538423a0c1cbb62fc518f77ef Mon Sep 17 00:00:00 2001
From: Botond Istvan Horvath <horvath.botond.istvan at gmail.com>
Date: Wed, 28 Feb 2024 18:46:07 +0100
Subject: [PATCH 3/5] Unified the branches for newer and older standards
---
clang/lib/Sema/SemaTemplateDeduction.cpp | 97 +++++++++---------------
1 file changed, 37 insertions(+), 60 deletions(-)
diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp
index 2af3c29ae1f1c4..f7526933be12f4 100644
--- a/clang/lib/Sema/SemaTemplateDeduction.cpp
+++ b/clang/lib/Sema/SemaTemplateDeduction.cpp
@@ -5333,10 +5333,10 @@ bool Sema::CheckIfFunctionSpecializationIsImmediate(FunctionDecl *FD,
return false;
}
-static QualType GetImplicitObjectParameterTypeCXX20(ASTContext &Context,
- const CXXMethodDecl *Method,
- QualType rawType,
- bool isOtherRvr) {
+static QualType GetImplicitObjectParameterType(ASTContext &Context,
+ const CXXMethodDecl *Method,
+ QualType RawType,
+ bool IsOtherRvr) {
// C++20 [temp.func.order]p3.1, p3.2:
//- The type X(M ) is “rvalue reference to cv A” if the optional ref-qualifier
// of M is && or if M has no ref-qualifier and the positionally-corresponding
@@ -5344,20 +5344,7 @@ static QualType GetImplicitObjectParameterTypeCXX20(ASTContext &Context,
// if this determination depends recursively upon whether X(M ) is an rvalue
// reference type, it is not considered to have rvalue reference type.
//- Otherwise, X(M ) is “lvalue reference to cv A”.
- assert(Method && !Method->isExplicitObjectMemberFunction() &&
- "expected a member function with no explicit object parameter");
-
- rawType = Context.getQualifiedType(rawType, Method->getMethodQualifiers());
- if (Method->getRefQualifier() == RQ_RValue ||
- (isOtherRvr && Method->getRefQualifier() == RQ_None))
- return Context.getRValueReferenceType(rawType);
- return Context.getLValueReferenceType(rawType);
-}
-
-/// If this is a non-static member function,
-static QualType GetImplicitObjectParameterType(ASTContext &Context,
- const CXXMethodDecl *Method,
- QualType rawType) {
+ //
// C++11 [temp.func.order]p3:
// [...] The new parameter is of type "reference to cv A," where cv are
// the cv-qualifiers of the function template (if any) and A is
@@ -5365,12 +5352,15 @@ static QualType GetImplicitObjectParameterType(ASTContext &Context,
//
// The standard doesn't say explicitly, but we pick the appropriate kind of
// reference type based on [over.match.funcs]p4.
- assert(Method && Method->isImplicitObjectMemberFunction() &&
- "expected an implicit objet function");
- rawType = Context.getQualifiedType(rawType, Method->getMethodQualifiers());
- if (Method->getRefQualifier() == RQ_RValue)
- return Context.getRValueReferenceType(rawType);
- return Context.getLValueReferenceType(rawType);
+
+ assert(Method && !Method->isExplicitObjectMemberFunction() &&
+ "expected a member function with no explicit object parameter");
+
+ RawType = Context.getQualifiedType(RawType, Method->getMethodQualifiers());
+ if (Method->getRefQualifier() == RQ_RValue ||
+ (IsOtherRvr && Method->getRefQualifier() == RQ_None))
+ return Context.getRValueReferenceType(RawType);
+ return Context.getLValueReferenceType(RawType);
}
/// Determine whether the function template \p FT1 is at least as
@@ -5547,34 +5537,11 @@ FunctionTemplateDecl *Sema::getMoreSpecializedTemplate(
// against anything else make no sense.
shouldConvert1 = Method1 && !Method1->isExplicitObjectMemberFunction();
shouldConvert2 = Method2 && !Method2->isExplicitObjectMemberFunction();
- if (shouldConvert1) {
- bool isR2 =
- Method2 && !Method2->isExplicitObjectMemberFunction()
- ? Method2->getRefQualifier() == RQ_RValue
- : Proto2->param_type_begin()[0]->isRValueReferenceType();
- // Compare 'this' from Method1 against first parameter from Method2.
- ObjType1 = GetImplicitObjectParameterTypeCXX20(this->Context, Method1,
- RawObjType1, isR2);
- Args1.push_back(ObjType1);
- }
- if (shouldConvert2) {
- bool isR1 =
- Method1 && !Method1->isExplicitObjectMemberFunction()
- ? Method1->getRefQualifier() == RQ_RValue
- : Proto1->param_type_begin()[0]->isRValueReferenceType();
- // Compare 'this' from Method2 against first parameter from Method1.
- ObjType2 = GetImplicitObjectParameterTypeCXX20(this->Context, Method2,
- RawObjType2, isR1);
- Args2.push_back(ObjType2);
- }
} else {
// C++11 [temp.func.order]p3:
// [...] If only one of the function templates is a non-static
// member, that function template is considered to have a new
- // first parameter inserted in its function parameter list. The
- // new parameter is of type "reference to cv A," where cv are
- // the cv-qualifiers of the function template (if any) and A is
- // the class of which the function template is a member.
+ // first parameter inserted in its function parameter list.
//
// Note that we interpret this to mean "if one of the function
// templates is a non-static member and the other is a non-member";
@@ -5587,18 +5554,28 @@ FunctionTemplateDecl *Sema::getMoreSpecializedTemplate(
!Method2 && Method1 && Method1->isImplicitObjectMemberFunction();
shouldConvert2 =
!Method1 && Method2 && Method2->isImplicitObjectMemberFunction();
- if (shouldConvert1) {
- // Compare 'this' from Method1 against first parameter from Method2.
- ObjType1 =
- GetImplicitObjectParameterType(this->Context, Method1, RawObjType1);
- Args1.push_back(ObjType1);
- }
- if (shouldConvert2) {
- // Compare 'this' from Method2 against first parameter from Method1.
- ObjType2 =
- GetImplicitObjectParameterType(this->Context, Method2, RawObjType2);
- Args2.push_back(ObjType2);
- }
+ }
+ if (shouldConvert1) {
+ bool isR2 =
+ getLangOpts().CPlusPlus20 &&
+ (shouldConvert1
+ ? Method2->getRefQualifier() == RQ_RValue
+ : Proto2->param_type_begin()[0]->isRValueReferenceType());
+ // Compare 'this' from Method1 against first parameter from Method2.
+ ObjType1 = GetImplicitObjectParameterType(this->Context, Method1,
+ RawObjType1, isR2);
+ Args1.push_back(ObjType1);
+ }
+ if (shouldConvert2) {
+ bool isR1 =
+ getLangOpts().CPlusPlus20 &&
+ (shouldConvert2
+ ? Method1->getRefQualifier() == RQ_RValue
+ : Proto1->param_type_begin()[0]->isRValueReferenceType());
+ // Compare 'this' from Method2 against first parameter from Method1.
+ ObjType2 = GetImplicitObjectParameterType(this->Context, Method2,
+ RawObjType2, isR1);
+ Args2.push_back(ObjType2);
}
unsigned NumComparedArguments = NumCallArguments1 + shouldConvert1;
>From e377e6e320d5c280e9364bbd14be456aab57ea46 Mon Sep 17 00:00:00 2001
From: Botond Istvan Horvath <horvath.botond.istvan at gmail.com>
Date: Thu, 29 Feb 2024 15:35:12 +0100
Subject: [PATCH 4/5] minor fix + tests + release notes
---
clang/docs/ReleaseNotes.rst | 6 ++++
clang/lib/Sema/SemaTemplateDeduction.cpp | 12 +++----
clang/test/SemaCXX/overload-template.cpp | 25 +++++++++++++++
clang/test/SemaCXX/overloaded-operator.cpp | 37 ++++++++++++++++++++++
4 files changed, 74 insertions(+), 6 deletions(-)
diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst
index 7e16b9f0c67dbd..6a1b93db9f6486 100644
--- a/clang/docs/ReleaseNotes.rst
+++ b/clang/docs/ReleaseNotes.rst
@@ -290,6 +290,12 @@ Bug Fixes to C++ Support
lookup searches the bases of an incomplete class.
- Fix a crash when an unresolved overload set is encountered on the RHS of a ``.*`` operator.
(`#53815 <https://github.com/llvm/llvm-project/issues/53815>`_)
+- Fix a bug where overload resolution falsly reported an ambiguity when it was compearing
+ a member-function against a non member function or a member-function with an
+ explicit object parameter against a member function with no explicit object parameter
+ when one of the function had more specialized templates.
+ Fixes (`#82509 <https://github.com/llvm/llvm-project/issues/82509>`_)
+ and (`#74494 <https://github.com/llvm/llvm-project/issues/74494>`_)
Bug Fixes to AST Handling
^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp
index f7526933be12f4..04e46ab69876f6 100644
--- a/clang/lib/Sema/SemaTemplateDeduction.cpp
+++ b/clang/lib/Sema/SemaTemplateDeduction.cpp
@@ -5556,25 +5556,25 @@ FunctionTemplateDecl *Sema::getMoreSpecializedTemplate(
!Method1 && Method2 && Method2->isImplicitObjectMemberFunction();
}
if (shouldConvert1) {
- bool isR2 =
+ bool isRValRef2 =
getLangOpts().CPlusPlus20 &&
- (shouldConvert1
+ (shouldConvert2
? Method2->getRefQualifier() == RQ_RValue
: Proto2->param_type_begin()[0]->isRValueReferenceType());
// Compare 'this' from Method1 against first parameter from Method2.
ObjType1 = GetImplicitObjectParameterType(this->Context, Method1,
- RawObjType1, isR2);
+ RawObjType1, isRValRef2);
Args1.push_back(ObjType1);
}
if (shouldConvert2) {
- bool isR1 =
+ bool isRValRef1 =
getLangOpts().CPlusPlus20 &&
- (shouldConvert2
+ (shouldConvert1
? Method1->getRefQualifier() == RQ_RValue
: Proto1->param_type_begin()[0]->isRValueReferenceType());
// Compare 'this' from Method2 against first parameter from Method1.
ObjType2 = GetImplicitObjectParameterType(this->Context, Method2,
- RawObjType2, isR1);
+ RawObjType2, isRValRef1);
Args2.push_back(ObjType2);
}
unsigned NumComparedArguments = NumCallArguments1 + shouldConvert1;
diff --git a/clang/test/SemaCXX/overload-template.cpp b/clang/test/SemaCXX/overload-template.cpp
index 0a23788ef3da6a..0fe13c479cce22 100644
--- a/clang/test/SemaCXX/overload-template.cpp
+++ b/clang/test/SemaCXX/overload-template.cpp
@@ -1,4 +1,5 @@
// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -std=c++23 -verify -fsyntax-only %s
enum copy_traits { movable = 1 };
@@ -33,3 +34,27 @@ void ReproducesBugSimply() {
InsertRow(3, B{}); // expected-error {{no matching function for call to 'InsertRow'}}
}
+#if __cplusplus >= 202302L
+namespace overloadCheck{
+ template<typename T>
+ concept AlwaysTrue = true;
+
+ struct S {
+ int f(AlwaysTrue auto) { return 1; }
+ void f(this S&&, auto) {}
+
+ void g(auto) {}
+ int g(this S&&,AlwaysTrue auto) {return 1;}
+
+ int h(AlwaysTrue auto) { return 1; } //expected-note {{previous definition is here}}
+ int h(this S&&,AlwaysTrue auto) { // expected-error {{class member cannot be redeclared}}
+ return 1;
+ }
+ };
+
+ int main() {
+ int x = S{}.f(0);
+ int y = S{}.g(0);
+ }
+}
+#endif
diff --git a/clang/test/SemaCXX/overloaded-operator.cpp b/clang/test/SemaCXX/overloaded-operator.cpp
index 887848c29b83c5..49311625d7ab2d 100644
--- a/clang/test/SemaCXX/overloaded-operator.cpp
+++ b/clang/test/SemaCXX/overloaded-operator.cpp
@@ -645,3 +645,40 @@ class b {
}
+
+#if __cplusplus >= 202002L
+namespace nw{
+ template<class T>
+ concept AlwaysTrue=true;
+
+ struct S{
+ template<class T>
+ void operator+(const T&)const{}
+
+ template<AlwaysTrue T>
+ int operator-(const T&)const{return 0;}
+
+ template<AlwaysTrue T>
+ int operator*(const T&)const{ // expected-note {{candidate function}}
+ return 0;
+ }
+ };
+
+ template<AlwaysTrue T>
+ int operator+(const S&, const T&){return 0;}
+
+ template<class T>
+ void operator-(const S&, const T&){}
+
+ template<AlwaysTrue T>
+ int operator*(const S&, const T&){ // expected-note {{candidate function}}
+ return 0;
+ }
+
+ void foo(){
+ int a = S{} + 1;
+ int b = S{} - 1;
+ int c = S{} * 1; // expected-error {{use of overloaded operator '*' is ambiguous (with operand types 'S' and 'int')}}
+ }
+}
+#endif
>From 74e69bf423645f98e342710f8e251365cdb7cd3b Mon Sep 17 00:00:00 2001
From: Botond Istvan Horvath <horvath.botond.istvan at gmail.com>
Date: Fri, 1 Mar 2024 14:40:35 +0100
Subject: [PATCH 5/5] Set DR CWG2445 status
---
clang/www/cxx_dr_status.html | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/clang/www/cxx_dr_status.html b/clang/www/cxx_dr_status.html
index 8b638e06f4aab6..5973d825433463 100755
--- a/clang/www/cxx_dr_status.html
+++ b/clang/www/cxx_dr_status.html
@@ -14478,7 +14478,7 @@ <h2 id="cxxdr">C++ defect report implementation status</h2>
<td><a href="https://cplusplus.github.io/CWG/issues/2445.html">2445</a></td>
<td>C++20</td>
<td>Partial ordering with rewritten candidates</td>
- <td class="unknown" align="center">Unknown</td>
+ <td class="unreleased" align="center">Clang 18</td>
</tr>
<tr id="2446">
<td><a href="https://cplusplus.github.io/CWG/issues/2446.html">2446</a></td>
More information about the cfe-commits
mailing list