[Clang][Sema] Do not mark template parameters in the exception specification as used during partial ordering #91534
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
llvmbot
added
clang
|
@llvm/pr-subscribers-clang Author: Krystian Stasiowski (sdkrystian) ChangesWe do not deduce template arguments from the exception specification when determining the primary template of a function template specialization or when taking the address of a function template. Therefore, this patch changes template<typename T, typename U>
void f(U) noexcept(noexcept(T())); // #<!-- -->1
template<typename T>
void f(T*) noexcept; // #<!-- -->2
template<>
void f<int>(int*) noexcept; // currently ambiguous, selects #<!-- -->2 with this patch applied Although there is no corresponding wording in the standard, this seems to be the intended behavior given the definition of deduction substitution loci in [[temp.deduct.general] p7](http://eel.is/c++draft/temp.deduct.general#7) (and EDG does the same thing). Full diff: https://github.com/llvm/llvm-project/pull/91534.diff 2 Files Affected:
diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp
index fe7e35d841510..c17c5838803a8 100644
--- a/clang/lib/Sema/SemaTemplateDeduction.cpp
+++ b/clang/lib/Sema/SemaTemplateDeduction.cpp
@@ -5453,7 +5453,7 @@ static bool isAtLeastAsSpecializedAs(Sema &S, SourceLocation Loc,
// is used.
if (DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, FD2->getType(), FD1->getType(), Info, Deduced,
- TDF_None,
+ TDF_AllowCompatibleFunctionType,
/*PartialOrdering=*/true) != TemplateDeductionResult::Success)
return false;
break;
@@ -5485,20 +5485,40 @@ static bool isAtLeastAsSpecializedAs(Sema &S, SourceLocation Loc,
switch (TPOC) {
case TPOC_Call:
for (unsigned I = 0, N = Args2.size(); I != N; ++I)
- ::MarkUsedTemplateParameters(S.Context, Args2[I], false,
- TemplateParams->getDepth(),
- UsedParameters);
+ ::MarkUsedTemplateParameters(S.Context, Args2[I], /*OnlyDeduced=*/false,
+ TemplateParams->getDepth(), UsedParameters);
break;
case TPOC_Conversion:
- ::MarkUsedTemplateParameters(S.Context, Proto2->getReturnType(), false,
+ ::MarkUsedTemplateParameters(S.Context, Proto2->getReturnType(),
+ /*OnlyDeduced=*/false,
TemplateParams->getDepth(), UsedParameters);
break;
case TPOC_Other:
- ::MarkUsedTemplateParameters(S.Context, FD2->getType(), false,
- TemplateParams->getDepth(),
- UsedParameters);
+ // We do not deduce template arguments from the exception specification
+ // when determining the primary template of a function template
+ // specialization or when taking the address of a function template.
+ // Therefore, we do not mark template parameters in the exception
+ // specification as used during partial ordering to prevent the following
+ // from being ambiguous:
+ //
+ // template<typename T, typename U>
+ // void f(U) noexcept(noexcept(T())); // #1
+ //
+ // template<typename T>
+ // void f(T*) noexcept; // #2
+ //
+ // template<>
+ // void f<int>(int*) noexcept; // explicit specialization of #2
+ //
+ // Although there is no corresponding wording in the standard, this seems
+ // to be the intended behavior given the definition of
+ // 'deduction substitution loci' in [temp.deduct].
+ ::MarkUsedTemplateParameters(
+ S.Context,
+ S.Context.getFunctionTypeWithExceptionSpec(FD2->getType(), EST_None),
+ /*OnlyDeduced=*/false, TemplateParams->getDepth(), UsedParameters);
break;
}
diff --git a/clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.partial/p3.cpp b/clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.partial/p3.cpp
new file mode 100644
index 0000000000000..cc1d4ecda2ecc
--- /dev/null
+++ b/clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.partial/p3.cpp
@@ -0,0 +1,72 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+// expected-no-diagnostics
+
+template<bool B>
+struct A { };
+
+constexpr A<false> a;
+constexpr A<false> b;
+
+constexpr int* x = nullptr;
+constexpr short* y = nullptr;
+
+namespace ExplicitArgs {
+ template<typename T, typename U>
+ constexpr int f(U) noexcept(noexcept(T())) {
+ return 0;
+ }
+
+ template<typename T>
+ constexpr int f(T*) noexcept {
+ return 1;
+ }
+
+ template<>
+ constexpr int f<int>(int*) noexcept {
+ return 2;
+ }
+
+ static_assert(f<int>(1) == 0);
+ static_assert(f<short>(y) == 1);
+ static_assert(f<int>(x) == 2);
+
+ template<typename T, typename U>
+ constexpr int g(U*) noexcept(noexcept(T())) {
+ return 3;
+ }
+
+ template<typename T>
+ constexpr int g(T) noexcept {
+ return 4;
+ }
+
+ template<>
+ constexpr int g<int>(int*) noexcept {
+ return 5;
+ }
+
+ static_assert(g<int>(y) == 3);
+ static_assert(g<short>(1) == 4);
+ static_assert(g<int>(x) == 5);
+} // namespace ExplicitArgs
+
+namespace DeducedArgs {
+ template<typename T, bool B>
+ constexpr int f(T, A<B>) noexcept(B) {
+ return 0;
+ }
+
+ template<typename T, bool B>
+ constexpr int f(T*, A<B>) noexcept(B && B) {
+ return 1;
+ }
+
+ template<>
+ constexpr int f(int*, A<false>) {
+ return 2;
+ }
+
+ static_assert(f<int*>(x, a) == 0);
+ static_assert(f<short>(y, a) == 1);
+ static_assert(f<int>(x, a) == 2);
+} // namespace DeducedArgs
|
erichkeane
approved these changes
May 8, 2024
| // template<> | ||
| // void f<int>(int*) noexcept; // explicit specialization of #2 | ||
| // | ||
| // Although there is no corresponding wording in the standard, this seems |
There was a problem hiding this comment.
@erichkeane Filed an issue here. It might be a little while before an actual core issue is opened, so would it be alright to merge this before that happens?
There was a problem hiding this comment.
Jens is usually really quick at assigning a core issue, right? That said, you can merge this before getting one as long as you come back afterwards and fill it in.
There was a problem hiding this comment.
I've seen it take anywhere from a day to a month. I'll be sure to update this once the issue is opened!
sdkrystian
force-pushed
the
partial-order-noexcept
branch
from
0ef86c6
to
7d62b17
Compare
|
@erichkeane Release note added |
erichkeane
approved these changes
May 9, 2024
…ication as used during partial ordering
sdkrystian
force-pushed
the
partial-order-noexcept
branch
from
7d62b17
to
d53c7fa
Compare
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
We do not deduce template arguments from the exception specification when determining the primary template of a function template specialization or when taking the address of a function template. Therefore, this patch changes
isAtLeastAsSpecializedAssuch that we do not mark template parameters in the exception specification as 'used' during partial ordering (per [temp.deduct.partial] p12) to prevent the following from being ambiguous:Although there is no corresponding wording in the standard, this seems to be the intended behavior given the definition of deduction substitution loci in [temp.deduct.general] p7 (and EDG does the same thing).