9a88aa0e2b
According to [temp.expl.spec] p2:
> The declaration in an _explicit-specialization_ shall not be an
_export-declaration_. An explicit specialization shall not use a
_storage-class-specifier_ other than `thread_local`.
Clang partially implements this, but a number of issues exist:
1. We don't diagnose class scope explicit specializations of variable
templates with _storage-class-specifiers_, e.g.
```
struct A
{
template<typename T>
static constexpr int x = 0;
template<>
static constexpr int x<void> = 1; // ill-formed, but clang accepts
};
````
2. We incorrectly reject class scope explicit specializations of
variable templates when `static` is not used, e.g.
```
struct A
{
template<typename T>
static constexpr int x = 0;
template<>
constexpr int x<void> = 1; // error: non-static data member cannot be
constexpr; did you intend to make it static?
};
````
3. We don't diagnose dependent class scope explicit specializations of
function templates with storage class specifiers, e.g.
```
template<typename T>
struct A
{
template<typename U>
static void f();
template<>
static void f<int>(); // ill-formed, but clang accepts
};
````
This patch addresses these issues as follows:
- # 1 is fixed by issuing a diagnostic when an explicit
specialization of a variable template has storage class specifier
- # 2 is fixed by considering any non-function declaration with any
template parameter lists at class scope to be a static data member. This
also allows for better error recovery (it's more likely the user
intended to declare a variable template than a "field template").
- # 3 is fixed by checking whether a function template explicit
specialization has a storage class specifier even when the primary
template is not yet known.
One thing to note is that it would be far simpler to diagnose this when
parsing the _decl-specifier-seq_, but such an implementation would
necessitate a refactor of `ParsedTemplateInfo` which I believe to be
outside the scope of this patch.
96 lines
2.5 KiB
C++
96 lines
2.5 KiB
C++
// RUN: %clang_cc1 -fsyntax-only -std=c++17 -verify %s -fcxx-exceptions
|
|
template<typename T>
|
|
struct X0 {
|
|
typedef T* type;
|
|
|
|
void f0(T);
|
|
void f1(type);
|
|
};
|
|
|
|
template<> void X0<char>::f0(char);
|
|
template<> void X0<char>::f1(type);
|
|
|
|
namespace PR6161 {
|
|
template<typename _CharT>
|
|
class numpunct : public locale::facet // expected-error{{use of undeclared identifier 'locale'}} \
|
|
// expected-error{{expected class name}}
|
|
{
|
|
static locale::id id; // expected-error{{use of undeclared identifier}}
|
|
};
|
|
numpunct<char>::~numpunct();
|
|
}
|
|
|
|
namespace PR12331 {
|
|
template<typename T> struct S {
|
|
struct U { static const int n = 5; };
|
|
enum E { e = U::n }; // expected-note {{implicit instantiation first required here}}
|
|
int arr[e];
|
|
};
|
|
template<> struct S<int>::U { static const int n = sizeof(int); }; // expected-error {{explicit specialization of 'U' after instantiation}}
|
|
}
|
|
|
|
namespace PR18246 {
|
|
template<typename T>
|
|
class Baz {
|
|
public:
|
|
template<int N> void bar();
|
|
};
|
|
|
|
template<typename T>
|
|
template<int N>
|
|
void Baz<T>::bar() {
|
|
}
|
|
|
|
template<typename T>
|
|
void Baz<T>::bar<0>() { // expected-error {{cannot specialize a member of an unspecialized template}}
|
|
}
|
|
}
|
|
|
|
namespace PR19340 {
|
|
template<typename T> struct Helper {
|
|
template<int N> static void func(const T *m) {}
|
|
};
|
|
|
|
template<typename T> void Helper<T>::func<2>() {} // expected-error {{cannot specialize a member}}
|
|
}
|
|
|
|
namespace SpecLoc {
|
|
template <typename T> struct A {
|
|
static int n; // expected-note {{previous}}
|
|
static void f(); // expected-note {{previous}}
|
|
};
|
|
template<> float A<int>::n; // expected-error {{different type}}
|
|
template<> void A<int>::f() throw(); // expected-error {{does not match}}
|
|
}
|
|
|
|
namespace PR41607 {
|
|
template<int N> struct Outer {
|
|
template<typename...> struct Inner;
|
|
template<> struct Inner<> {
|
|
static constexpr int f() { return N; }
|
|
};
|
|
|
|
template<typename...> static int a;
|
|
template<> constexpr int a<> = N;
|
|
|
|
template<typename...> static inline int b;
|
|
template<> inline constexpr int b<> = N;
|
|
|
|
template<typename...> static constexpr int f();
|
|
template<> constexpr int f() {
|
|
return N;
|
|
}
|
|
};
|
|
static_assert(Outer<123>::Inner<>::f() == 123, "");
|
|
static_assert(Outer<123>::Inner<>::f() != 125, "");
|
|
|
|
static_assert(Outer<123>::a<> == 123, "");
|
|
static_assert(Outer<123>::a<> != 125, "");
|
|
|
|
static_assert(Outer<123>::b<> == 123, "");
|
|
static_assert(Outer<123>::b<> != 125, "");
|
|
|
|
static_assert(Outer<123>::f<>() == 123, "");
|
|
static_assert(Outer<123>::f<>() != 125, "");
|
|
}
|