https://github.com/zyn0217 created
https://github.com/llvm/llvm-project/pull/139066
Instead of merely suggesting the template arguments are invalid, we now provide
an explanation of why the explicit template argument is invalid, following the
last diagnostic note.
For example,
```cpp
template<int*>
void f();
void g() {
f<42>();
}
```
We now have diagnostics
1. no matching function for call to 'f'
2. candidate template ignored: invalid explicitly-specified argument for 1st
template parameter
But don't explain why the 1st is invalid. With this patch, we will have an
additional note
3. value of type 'int' is not implicitly convertible to 'int *'
>From 9c6d80ecefcbd5152c7ad72d0376c9b27328cefb Mon Sep 17 00:00:00 2001
From: Younan Zhang <zyn7...@gmail.com>
Date: Thu, 8 May 2025 19:42:51 +0800
Subject: [PATCH] [Clang] Do not eat SFINAE diagnostics for explicit template
arguments
---
clang/lib/Sema/SemaOverload.cpp | 17 ++++++++++++++++-
clang/test/AST/ByteCode/builtin-align-cxx.cpp | 3 ++-
clang/test/AST/ByteCode/cxx20.cpp | 3 ++-
.../basic.namespace/namespace.udecl/p12.cpp | 12 ++++++++----
clang/test/CXX/drs/cwg2xx.cpp | 4 ++++
clang/test/CXX/drs/cwg3xx.cpp | 2 ++
clang/test/CXX/expr/expr.const/p3-0x.cpp | 3 ++-
clang/test/CXX/temp/temp.param/p8-cxx20.cpp | 3 ++-
clang/test/CXX/temp/temp.res/temp.local/p1.cpp | 6 ++++--
clang/test/Modules/cxx-templates.cpp | 2 ++
clang/test/SemaCXX/builtin-align-cxx.cpp | 3 ++-
clang/test/SemaCXX/calling-conv-compat.cpp | 3 ++-
.../constexpr-function-recovery-crash.cpp | 3 ++-
clang/test/SemaCXX/cxx2a-template-lambdas.cpp | 6 ++++--
clang/test/SemaCXX/typo-correction.cpp | 3 ++-
clang/test/SemaTemplate/concepts-using-decl.cpp | 6 ++++--
clang/test/SemaTemplate/overload-candidates.cpp | 10 ++++++----
.../SemaTemplate/temp_arg_nontype_cxx11.cpp | 5 +++--
18 files changed, 69 insertions(+), 25 deletions(-)
diff --git a/clang/lib/Sema/SemaOverload.cpp b/clang/lib/Sema/SemaOverload.cpp
index 5b224b6c08fef..1b714aee02e67 100644
--- a/clang/lib/Sema/SemaOverload.cpp
+++ b/clang/lib/Sema/SemaOverload.cpp
@@ -751,6 +751,12 @@ clang::MakeDeductionFailureInfo(ASTContext &Context,
case TemplateDeductionResult::Incomplete:
case TemplateDeductionResult::InvalidExplicitArguments:
Result.Data = Info.Param.getOpaqueValue();
+ if (Info.hasSFINAEDiagnostic()) {
+ PartialDiagnosticAt *Diag = new (Result.Diagnostic) PartialDiagnosticAt(
+ SourceLocation(), PartialDiagnostic::NullDiagnostic());
+ Info.takeSFINAEDiagnostic(*Diag);
+ Result.HasDiagnostic = true;
+ }
break;
case TemplateDeductionResult::DeducedMismatch:
@@ -822,7 +828,6 @@ void DeductionFailureInfo::Destroy() {
case TemplateDeductionResult::Incomplete:
case TemplateDeductionResult::TooManyArguments:
case TemplateDeductionResult::TooFewArguments:
- case TemplateDeductionResult::InvalidExplicitArguments:
case TemplateDeductionResult::CUDATargetMismatch:
case TemplateDeductionResult::NonDependentConversionFailure:
break;
@@ -837,6 +842,7 @@ void DeductionFailureInfo::Destroy() {
Data = nullptr;
break;
+ case TemplateDeductionResult::InvalidExplicitArguments:
case TemplateDeductionResult::SubstitutionFailure:
// FIXME: Destroy the template argument list?
Data = nullptr;
@@ -12166,6 +12172,15 @@ static void DiagnoseBadDeduction(Sema &S, NamedDecl
*Found, Decl *Templated,
diag::note_ovl_candidate_explicit_arg_mismatch_unnamed)
<< (index + 1);
}
+
+ if (PartialDiagnosticAt *PDiag = DeductionFailure.getSFINAEDiagnostic()) {
+ unsigned DiagID =
+ S.getDiagnostics().getCustomDiagID(DiagnosticsEngine::Note, "%0");
+ SmallString<128> SFINAEArgString;
+ PDiag->second.EmitToString(S.getDiagnostics(), SFINAEArgString);
+ S.Diag(Templated->getLocation(), DiagID) << SFINAEArgString;
+ }
+
MaybeEmitInheritedConstructorNote(S, Found);
return;
diff --git a/clang/test/AST/ByteCode/builtin-align-cxx.cpp
b/clang/test/AST/ByteCode/builtin-align-cxx.cpp
index a1edf307d6c47..973fd1b620525 100644
--- a/clang/test/AST/ByteCode/builtin-align-cxx.cpp
+++ b/clang/test/AST/ByteCode/builtin-align-cxx.cpp
@@ -4,7 +4,8 @@
// Check that we don't crash when using dependent types in __builtin_align:
template <typename a, a b>
-void *c(void *d) { // both-note{{candidate template ignored}}
+void *c(void *d) { // both-note{{candidate template ignored}} \
+// both-note {{a non-type template parameter cannot have type 'struct x'
before C++20}}
return __builtin_align_down(d, b);
}
diff --git a/clang/test/AST/ByteCode/cxx20.cpp
b/clang/test/AST/ByteCode/cxx20.cpp
index 42e6ae33e92e4..1625f8eee8425 100644
--- a/clang/test/AST/ByteCode/cxx20.cpp
+++ b/clang/test/AST/ByteCode/cxx20.cpp
@@ -753,7 +753,8 @@ namespace FailingDestructor {
}
};
template<D d>
- void f() {} // both-note {{invalid explicitly-specified argument}}
+ void f() {} // both-note {{invalid explicitly-specified argument}} \
+ // both-note {{non-type template argument is not a constant
expression}}
void g() {
f<D{0, false}>(); // both-error {{no matching function}}
diff --git a/clang/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p12.cpp
b/clang/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p12.cpp
index f12e0083fb0c9..ee38418acfb32 100644
--- a/clang/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p12.cpp
+++ b/clang/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p12.cpp
@@ -113,21 +113,25 @@ namespace test3 {
struct Derived1 : Base {
using Base::foo;
- template <int n> Opaque<2> foo() { return Opaque<2>(); } // expected-note
{{invalid explicitly-specified argument for template parameter 'n'}}
+ template <int n> Opaque<2> foo() { return Opaque<2>(); } // expected-note
{{invalid explicitly-specified argument for template parameter 'n'}} \
+ // expected-note {{template argument for non-type template parameter must
be an expression}}
};
struct Derived2 : Base {
- template <int n> Opaque<2> foo() { return Opaque<2>(); } // expected-note
{{invalid explicitly-specified argument for template parameter 'n'}}
+ template <int n> Opaque<2> foo() { return Opaque<2>(); } // expected-note
{{invalid explicitly-specified argument for template parameter 'n'}} \
+ // expected-note {{template argument for non-type template parameter must
be an expression}}
using Base::foo;
};
struct Derived3 : Base {
using Base::foo;
- template <class T> Opaque<3> foo() { return Opaque<3>(); } //
expected-note {{invalid explicitly-specified argument for template parameter
'T'}}
+ template <class T> Opaque<3> foo() { return Opaque<3>(); } //
expected-note {{invalid explicitly-specified argument for template parameter
'T'}} \
+ // expected-note {{template argument for template type parameter must be a
type}}
};
struct Derived4 : Base {
- template <class T> Opaque<3> foo() { return Opaque<3>(); } //
expected-note {{invalid explicitly-specified argument for template parameter
'T'}}
+ template <class T> Opaque<3> foo() { return Opaque<3>(); } //
expected-note {{invalid explicitly-specified argument for template parameter
'T'}} \
+ // expected-note {{template argument for template type parameter must be a
type}}
using Base::foo;
};
diff --git a/clang/test/CXX/drs/cwg2xx.cpp b/clang/test/CXX/drs/cwg2xx.cpp
index b2ae8f88ead74..604a60c9fa0c9 100644
--- a/clang/test/CXX/drs/cwg2xx.cpp
+++ b/clang/test/CXX/drs/cwg2xx.cpp
@@ -650,14 +650,17 @@ namespace cwg241 { // cwg241: 9
C::f<3>(b);
// expected-error@-1 {{no matching function for call to 'f'}}
// expected-note@#cwg241-C-f {{candidate template ignored: invalid
explicitly-specified argument for template parameter 'T'}}
+ // expected-note@#cwg241-C-f {{template argument for template type
parameter must be a type}}
C::g<3>(b);
// expected-error@-1 {{no matching function for call to 'g'}}
// expected-note@#cwg241-C-g {{candidate template ignored: invalid
explicitly-specified argument for template parameter 'T'}}
+ // expected-note@#cwg241-C-g {{template argument for template type
parameter must be a type}}
using C::f;
using C::g;
f<3>(b);
// expected-error@-1 {{no matching function for call to 'f'}}
// expected-note@#cwg241-C-f {{candidate template ignored: invalid
explicitly-specified argument for template parameter 'T'}}
+ // expected-note@#cwg241-C-f {{template argument for template type
parameter must be a type}}
// expected-note@#cwg241-A-f {{candidate function template not viable:
requires 0 arguments, but 1 was provided}}
g<3>(b);
}
@@ -952,6 +955,7 @@ namespace cwg258 { // cwg258: 2.8
int &x = b.g<int>(0);
// expected-error@-1 {{no matching member function for call to 'g'}}
// expected-note@#cwg258-B-g {{candidate template ignored: invalid
explicitly-specified argument for 1st template parameter}}
+ // expected-note@#cwg258-B-g {{template argument for non-type template
parameter must be an expression}}
int &y = b.h();
float &z = const_cast<const B&>(b).h();
diff --git a/clang/test/CXX/drs/cwg3xx.cpp b/clang/test/CXX/drs/cwg3xx.cpp
index 8b035cf6f2370..b1b8d20187dcb 100644
--- a/clang/test/CXX/drs/cwg3xx.cpp
+++ b/clang/test/CXX/drs/cwg3xx.cpp
@@ -985,7 +985,9 @@ namespace cwg354 { // cwg354: 3.1 c++11
int b1 = both<(int*)0>();
// cxx98-error@-1 {{no matching function for call to 'both'}}
// cxx98-note@#cwg354-both-int-ptr {{candidate template ignored: invalid
explicitly-specified argument for 1st template parameter}}
+ // cxx98-note@#cwg354-both-int-ptr {{non-type template argument does not
refer to any declaration}}
// cxx98-note@#cwg354-both-int {{candidate template ignored: invalid
explicitly-specified argument for 1st template parameter}}
+ // cxx98-note@#cwg354-both-int {{non-type template argument of type 'int
*' must have an integral or enumeration type}}
template<int S::*> struct ptr_mem {}; // #cwg354-ptr_mem
ptr_mem<0> m0; // #cwg354-m0
diff --git a/clang/test/CXX/expr/expr.const/p3-0x.cpp
b/clang/test/CXX/expr/expr.const/p3-0x.cpp
index 3eedef3cf7712..c7dafc59599dd 100644
--- a/clang/test/CXX/expr/expr.const/p3-0x.cpp
+++ b/clang/test/CXX/expr/expr.const/p3-0x.cpp
@@ -107,7 +107,8 @@ void c() {
break;
}
}
-template <bool B> int f() { return B; } // expected-note {{candidate template
ignored: invalid explicitly-specified argument for template parameter 'B'}}
+template <bool B> int f() { return B; } // expected-note {{candidate template
ignored: invalid explicitly-specified argument for template parameter 'B'}} \
+// expected-note {{conversion from 'int (S::*)() const' to 'bool' is not
allowed in a converted constant expression}}
template int f<&S::operator int>(); // expected-error {{does not refer to a
function template}}
template int f<(bool)&S::operator int>();
diff --git a/clang/test/CXX/temp/temp.param/p8-cxx20.cpp
b/clang/test/CXX/temp/temp.param/p8-cxx20.cpp
index a3478c0669661..953b613eeef4a 100644
--- a/clang/test/CXX/temp/temp.param/p8-cxx20.cpp
+++ b/clang/test/CXX/temp/temp.param/p8-cxx20.cpp
@@ -40,7 +40,8 @@ namespace ConstDestruction {
};
template<D d>
- void f() {} // expected-note 2{{invalid explicitly-specified argument}}
+ void f() {} // expected-note 2{{invalid explicitly-specified argument}} \
+ // expected-note 2{{non-type template argument is not a constant expression}}
void g() {
f<D{0, true}>();
diff --git a/clang/test/CXX/temp/temp.res/temp.local/p1.cpp
b/clang/test/CXX/temp/temp.res/temp.local/p1.cpp
index faa85cb5fce30..8a49fc39e2d2b 100644
--- a/clang/test/CXX/temp/temp.res/temp.local/p1.cpp
+++ b/clang/test/CXX/temp/temp.res/temp.local/p1.cpp
@@ -10,9 +10,11 @@ template<typename> char id;
template<typename> struct TempType {};
template<template<typename> class> struct TempTemp {};
-template<typename> void use(int&); // expected-note {{invalid
explicitly-specified argument}} expected-note {{no known conversion}}
+template<typename> void use(int&); // expected-note {{invalid
explicitly-specified argument}} expected-note {{no known conversion}} \
+// expected-note {{use of class template 'B::template C' requires template
arguments}}
template<template<typename> class> void use(float&); // expected-note 2{{no
known conversion}}
-template<int> void use(char&); // expected-note 2{{invalid
explicitly-specified argument}}
+template<int> void use(char&); // expected-note 2{{invalid
explicitly-specified argument}} \
+// expected-note 2{{template argument for non-type template parameter must be
an expression}}
template<typename T> struct A {
template<typename> struct C {};
diff --git a/clang/test/Modules/cxx-templates.cpp
b/clang/test/Modules/cxx-templates.cpp
index f587af4beb7ce..dce93f866b15c 100644
--- a/clang/test/Modules/cxx-templates.cpp
+++ b/clang/test/Modules/cxx-templates.cpp
@@ -43,11 +43,13 @@ void g() {
template_param_kinds_2<Tmpl_T_C>(); // expected-error {{no matching function
for call}}
// expected-note@Inputs/cxx-templates-a.h:11 {{candidate}}
+ // expected-note@Inputs/cxx-templates-a.h:11 {{too many template arguments
for class template 'Tmpl_T_C'}}
// expected-note@Inputs/cxx-templates-b.h:11 {{candidate}}
template_param_kinds_2<Tmpl_T_I_I>(); // expected-error {{ambiguous}}
// expected-note@Inputs/cxx-templates-a.h:11 {{candidate}}
// expected-note@Inputs/cxx-templates-b.h:11 {{candidate}}
+ // expected-note@Inputs/cxx-templates-b.h:11 {{non-type parameter of
template template parameter cannot be narrowed from type 'int' to 'char'}}
template_param_kinds_3<Tmpl_T_T_A>();
template_param_kinds_3<Tmpl_T_T_B>();
diff --git a/clang/test/SemaCXX/builtin-align-cxx.cpp
b/clang/test/SemaCXX/builtin-align-cxx.cpp
index d18bc2bf66551..a680ac2aaa763 100644
--- a/clang/test/SemaCXX/builtin-align-cxx.cpp
+++ b/clang/test/SemaCXX/builtin-align-cxx.cpp
@@ -3,7 +3,8 @@
// Check that we don't crash when using dependent types in __builtin_align:
template <typename a, a b>
-void *c(void *d) { // expected-note{{candidate template ignored}}
+void *c(void *d) { // expected-note{{candidate template ignored}} \
+// expected-note {{a non-type template parameter cannot have type 'struct x'
before C++20}}
return __builtin_align_down(d, b);
}
diff --git a/clang/test/SemaCXX/calling-conv-compat.cpp
b/clang/test/SemaCXX/calling-conv-compat.cpp
index 9bb448ffef225..8e67528717c5b 100644
--- a/clang/test/SemaCXX/calling-conv-compat.cpp
+++ b/clang/test/SemaCXX/calling-conv-compat.cpp
@@ -425,6 +425,7 @@ namespace D50526 {
void h() { g<void, h>(); }
#if !_M_X64
// expected-error@-2 {{no matching function for call to}}
- // expected-note@-4 {{invalid explicitly-specified argument}}
+ // expected-note@-4 {{invalid explicitly-specified argument}} \
+ // expected-note@-4 {{non-type template argument of type 'void ()' cannot be
converted to a value of type 'void (*)() __attribute__((stdcall))'}}
#endif
}
diff --git a/clang/test/SemaCXX/constexpr-function-recovery-crash.cpp
b/clang/test/SemaCXX/constexpr-function-recovery-crash.cpp
index 90ee7892b2fc2..086bfa15fe0ea 100644
--- a/clang/test/SemaCXX/constexpr-function-recovery-crash.cpp
+++ b/clang/test/SemaCXX/constexpr-function-recovery-crash.cpp
@@ -60,7 +60,8 @@ constexpr void test8() {
throw "bad";
}
-template<int x> constexpr int f(int y) { // expected-note {{candidate template
ignored}}
+template<int x> constexpr int f(int y) { // expected-note {{candidate template
ignored}} \
+ // expected-note {{non-type template
argument is not a constant expression}}
return x * y;
}
constexpr int test9(int x) {
diff --git a/clang/test/SemaCXX/cxx2a-template-lambdas.cpp
b/clang/test/SemaCXX/cxx2a-template-lambdas.cpp
index 00ba291fbd198..413bf7cd09667 100644
--- a/clang/test/SemaCXX/cxx2a-template-lambdas.cpp
+++ b/clang/test/SemaCXX/cxx2a-template-lambdas.cpp
@@ -1,8 +1,8 @@
// RUN: %clang_cc1 -std=c++03 -verify -Dstatic_assert=_Static_assert
-Wno-c++11-extensions -Wno-c++14-extensions -Wno-c++17-extensions
-Wno-c++20-extensions %s
// RUN: %clang_cc1 -std=c++11 -verify=expected,cxx11,cxx11-cxx14
-Wno-c++20-extensions -Wno-c++17-extensions -Wno-c++14-extensions %s
// RUN: %clang_cc1 -std=c++14 -verify=expected,cxx11-cxx14,cxx14
-Wno-c++20-extensions -Wno-c++17-extensions %s
-// RUN: %clang_cc1 -std=c++17 -verify -Wno-c++20-extensions %s
-// RUN: %clang_cc1 -std=c++20 -verify %s
+// RUN: %clang_cc1 -std=c++17 -verify=expected,cxx17,cxx17-cxx20
-Wno-c++20-extensions %s
+// RUN: %clang_cc1 -std=c++20 -verify=expected,cxx20,cxx17-cxx20 %s
template<typename, typename>
inline const bool is_same = false;
@@ -47,6 +47,8 @@ constexpr T outer() {
return []<T x>() { return x; }.template operator()<123>(); // expected-error
{{no matching member function}} \
expected-note
{{candidate template ignored}} \
cxx11-note {{non-literal type '<dependent type>' cannot be used in a
constant expression}} \
+ cxx11-cxx14-note {{non-type template argument does not refer to any
declaration}} \
+ cxx17-cxx20-note {{value of type 'int' is not implicitly convertible
to 'int *'}} \
cxx14-note {{non-literal type}}
}
static_assert(outer<int>() == 123); // cxx11-cxx14-error {{not an integral
constant expression}} cxx11-cxx14-note {{in call}}
diff --git a/clang/test/SemaCXX/typo-correction.cpp
b/clang/test/SemaCXX/typo-correction.cpp
index 45f42c4260358..c25d01eade890 100644
--- a/clang/test/SemaCXX/typo-correction.cpp
+++ b/clang/test/SemaCXX/typo-correction.cpp
@@ -614,7 +614,8 @@ int bar() {
namespace testIncludeTypeInTemplateArgument {
template <typename T, typename U>
-void foo(T t = {}, U = {}); // expected-note {{candidate template ignored}}
+void foo(T t = {}, U = {}); // expected-note {{candidate template ignored}} \
+ // expected-note {{template argument for template
type parameter must be a type}}
class AddObservation {}; // expected-note {{declared here}}
int bar1() {
diff --git a/clang/test/SemaTemplate/concepts-using-decl.cpp
b/clang/test/SemaTemplate/concepts-using-decl.cpp
index fca69dea5c88f..cad160fd585c0 100644
--- a/clang/test/SemaTemplate/concepts-using-decl.cpp
+++ b/clang/test/SemaTemplate/concepts-using-decl.cpp
@@ -165,8 +165,10 @@ struct base {
struct bar : public base {
using base::foo;
- template <int N>
- int foo() { return 2; }; // expected-note {{candidate template ignored:
substitution failure: too many template arguments for function template 'foo'}}
+ template <int N>
+ int foo() { return 2; };
+ // expected-note@-1 {{candidate template ignored: invalid
explicitly-specified argument for template parameter 'N'}} \
+ // expected-note@-1 {{too many template arguments for function template
'foo'}}
};
void func() {
diff --git a/clang/test/SemaTemplate/overload-candidates.cpp
b/clang/test/SemaTemplate/overload-candidates.cpp
index de998d74f9af6..25f0492a71729 100644
--- a/clang/test/SemaTemplate/overload-candidates.cpp
+++ b/clang/test/SemaTemplate/overload-candidates.cpp
@@ -16,10 +16,12 @@ void test_dyn_cast(int* ptr) {
(void)dyn_cast(ptr); // expected-error{{no matching function for call to
'dyn_cast'}}
}
-template<int I, typename T>
- void get(const T&); // expected-note{{candidate template ignored: invalid
explicitly-specified argument for template parameter 'I'}}
-template<template<class T> class, typename T>
- void get(const T&); // expected-note{{candidate template ignored: invalid
explicitly-specified argument for 1st template parameter}}
+template<int I, typename T>
+ void get(const T&); // expected-note{{candidate template ignored: invalid
explicitly-specified argument for template parameter 'I'}} \
+ // expected-note {{template argument for non-type template parameter must be
an expression}}
+template<template<class T> class, typename T>
+ void get(const T&); // expected-note{{candidate template ignored: invalid
explicitly-specified argument for 1st template parameter}} \
+ // expected-note {{template argument for template template parameter must be
a class template}}
void test_get(void *ptr) {
get<int>(ptr); // expected-error{{no matching function for call to 'get'}}
diff --git a/clang/test/SemaTemplate/temp_arg_nontype_cxx11.cpp
b/clang/test/SemaTemplate/temp_arg_nontype_cxx11.cpp
index 5752cbac0291d..44bc5b7642f76 100644
--- a/clang/test/SemaTemplate/temp_arg_nontype_cxx11.cpp
+++ b/clang/test/SemaTemplate/temp_arg_nontype_cxx11.cpp
@@ -42,8 +42,9 @@ template <int a, unsigned b, int c>
void TempFunc() {}
void Useage() {
- //expected-error@+2 {{no matching function}}
- //expected-note@-4 {{candidate template ignored: invalid
explicitly-specified argument for template parameter 'b'}}
+ //expected-error@+3 {{no matching function}}
+ //expected-note@-4 {{candidate template ignored: invalid
explicitly-specified argument for template parameter 'b'}} \
+ //expected-note@-4 {{non-type template argument evaluates to -1, which
cannot be narrowed to type 'unsigned int'}}
TempFunc<1, -1, 1>();
}
}
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
