shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
llvm-project/clang/test/SemaTemplate/ms-function-specialization-class-scope.cpp
Matheus Izvekov 017b504b46
[clang] Don't lose track of explicit specializations of member function templates (#111267) 
When instantiating a class template, we would lose track of function
template explicit specializations, marking them with the wrong
specialization kind.

This would lead to improperly using the explcit specialization arguments
to instantiate the function body.

This also better matches MSVC on the behaviour of explicitly vs
implicitly instantiating these.

Fixes #111266
2024-10-07 16:46:27 -03:00

608 lines
16 KiB
C++
Raw Permalink Blame History

// RUN: %clang_cc1 -fms-extensions -fsyntax-only -Wno-unused-value -verify %s
// RUN: %clang_cc1 -fms-extensions -fdelayed-template-parsing -fsyntax-only -Wno-unused-value -verify %s
class A {
public:
template<class U> A(U p) {}
template<> A(int p) {}
template<class U> void f(U p) {}
template<> void f(int p) {}
void f(int p) {}
};
void test1() {
A a(3);
char *b;
a.f(b);
a.f<int>(99);
a.f(100);
}
template<class T> class B {
public:
template<class U> B(U p) {}
template<> B(int p) {}
template<class U> void f(U p) { T y = 9; }
template<> void f(int p) {
T a = 3;
}
void f(int p) { T a = 3; }
};
void test2() {
B<char> b(3);
char *ptr;
b.f(ptr);
b.f<int>(99);
b.f(100);
}
namespace PR12709 {
template<class T> class TemplateClass {
void member_function() { specialized_member_template<false>(); }
template<bool b> void specialized_member_template() {}
template<> void specialized_member_template<false>() {}
};
void f() { TemplateClass<int> t; }
}
namespace Duplicates {
template<typename T> struct A {
template<typename U> void f();
template<> void f<int>() {}
template<> void f<T>() {}
};
// FIXME: We should diagnose the duplicate explicit specialization definitions
// here.
template struct A<int>;
}
namespace PR28082 {
struct S {
template <int>
int f(int = 0);
template <>
int f<0>(int);
};
}
namespace UsesThis {
template<typename T>
struct A {
int x;
static inline int y;
template<typename U = void>
static void f();
template<typename U = void>
void g();
template<typename U>
static auto h() -> A*;
void i();
static void j();
template<>
void f<int>() {
this->x; // expected-error {{invalid use of 'this' outside of a non-static member function}}
x; // expected-error {{invalid use of member 'x' in static member function}}
A::x; // expected-error {{invalid use of member 'x' in static member function}}
+x; // expected-error {{invalid use of member 'x' in static member function}}
+A::x; // expected-error {{invalid use of member 'x' in static member function}}
&x; // expected-error {{invalid use of member 'x' in static member function}}
&A::x;
this->y; // expected-error {{invalid use of 'this' outside of a non-static member function}}
y;
A::y;
+y;
+A::y;
&y;
&A::y;
f();
f<void>();
g(); // expected-error {{call to non-static member function without an object argument}}
g<void>(); // expected-error {{call to non-static member function without an object argument}}
i(); // expected-error {{call to non-static member function without an object argument}}
j();
&i; // expected-error 2{{must explicitly qualify name of member function when taking its address}}
&j;
&A::i;
&A::j;
}
template<>
void g<int>() {
this->x;
x;
A::x;
+x;
+A::x;
&x;
&A::x;
this->y;
y;
A::y;
+y;
+A::y;
&y;
&A::y;
f();
f<void>();
g();
g<void>();
i();
j();
&i; // expected-error 2{{must explicitly qualify name of member function when taking its address}}
&j;
&A::i;
&A::j;
}
template<>
auto h<int>() -> decltype(this); // expected-error {{'this' cannot be used in a static member function declaration}}
};
template struct A<int>; // expected-note {{in instantiation of}}
template<> template<> void A<int>::f<int>();
template<> template<> void A<int>::g<int>();
void test1() {
A<int>().f<int>(); // expected-note {{in instantiation of}}
A<int>().g<int>(); // expected-note {{in instantiation of}}
}
template <typename T>
struct Foo {
template <typename X>
int bar(X x) {
return 0;
}
template <>
int bar(int x) {
return bar(5.0); // ok
}
};
void call() {
Foo<double> f;
f.bar(1);
}
struct B {
int x0;
static inline int y0;
int f0(int);
static int g0(int);
int x2;
static inline int y2;
int f2(int);
static int g2(int);
};
template<typename T>
struct D : B {
int x1;
static inline int y1;
int f1(int);
static int g1(int);
using B::x2;
using B::y2;
using B::f2;
using B::g2;
template<typename U>
void non_static_spec(U);
template<typename U>
static void static_spec(U);
template<>
void non_static_spec(int z) {
++z;
++x0;
++x1;
++x2;
++y0;
++y1;
++y2;
&z;
&x0;
&x1;
&x2;
&y0;
&y1;
&y2;
&f0; // expected-error {{must explicitly qualify name of member function when taking its address}}
&f1; // expected-error 2{{must explicitly qualify name of member function when taking its address}}
&f2; // expected-error 2{{must explicitly qualify name of member function when taking its address}}
&g0;
&g1;
&g2;
&B::x0;
&D::x1;
&B::x2;
&B::y0;
&D::y1;
&B::y2;
&B::f0;
&D::f1;
&B::f2;
&B::g0;
&D::g1;
&B::g2;
f0(0);
f0(z);
f0(x0);
f0(x1);
f0(x2);
f0(y0);
f0(y1);
f0(y2);
g0(0);
g0(z);
g0(x0);
g0(x1);
g0(x2);
g0(y0);
g0(y1);
g0(y2);
f1(0);
f1(z);
f1(x0);
f1(x1);
f1(x2);
f1(y0);
f1(y1);
f1(y2);
g1(0);
g1(z);
g1(x0);
g1(x1);
g1(x2);
g1(y0);
g1(y1);
g1(y2);
f2(0);
f2(z);
f2(x0);
f2(x1);
f2(x2);
f2(y0);
f2(y1);
f2(y2);
g2(0);
g2(z);
g2(x0);
g2(x1);
g2(x2);
g2(y0);
g2(y1);
g2(y2);
}
template<>
void static_spec(int z) {
++z;
++x0; // expected-error {{invalid use of member 'x0' in static member function}}
++x1; // expected-error {{invalid use of member 'x1' in static member function}}
++x2; // expected-error {{invalid use of member 'x2' in static member function}}
++y0;
++y1;
++y2;
&z;
&x0; // expected-error {{invalid use of member 'x0' in static member function}}
&x1; // expected-error {{invalid use of member 'x1' in static member function}}
&x2; // expected-error {{invalid use of member 'x2' in static member function}}
&y0;
&y1;
&y2;
&f0; // expected-error {{must explicitly qualify name of member function when taking its address}}
&f1; // expected-error 2{{must explicitly qualify name of member function when taking its address}}
&f2; // expected-error 2{{must explicitly qualify name of member function when taking its address}}
&g0;
&g1;
&g2;
&B::x0;
&D::x1;
&B::x2;
&B::y0;
&D::y1;
&B::y2;
&B::f0;
&D::f1;
&B::f2;
&B::g0;
&D::g1;
&B::g2;
f0(0); // expected-error {{call to non-static member function without an object argument}}
f0(z); // expected-error {{call to non-static member function without an object argument}}
f0(x0); // expected-error {{call to non-static member function without an object argument}}
f0(x1); // expected-error {{call to non-static member function without an object argument}}
f0(x2); // expected-error {{call to non-static member function without an object argument}}
f0(y0); // expected-error {{call to non-static member function without an object argument}}
f0(y1); // expected-error {{call to non-static member function without an object argument}}
f0(y2); // expected-error {{call to non-static member function without an object argument}}
g0(0);
g0(z);
g0(x0); // expected-error {{invalid use of member 'x0' in static member function}}
g0(x1); // expected-error {{invalid use of member 'x1' in static member function}}
g0(x2); // expected-error {{invalid use of member 'x2' in static member function}}
g0(y0);
g0(y1);
g0(y2);
f1(0); // expected-error {{call to non-static member function without an object argument}}
f1(z); // expected-error {{call to non-static member function without an object argument}}
f1(x0); // expected-error {{call to non-static member function without an object argument}}
f1(x1); // expected-error {{call to non-static member function without an object argument}}
f1(x2); // expected-error {{call to non-static member function without an object argument}}
f1(y0); // expected-error {{call to non-static member function without an object argument}}
f1(y1); // expected-error {{call to non-static member function without an object argument}}
f1(y2); // expected-error {{call to non-static member function without an object argument}}
g1(0);
g1(z);
g1(x0); // expected-error {{invalid use of member 'x0' in static member function}}
g1(x1); // expected-error {{invalid use of member 'x1' in static member function}}
g1(x2); // expected-error {{invalid use of member 'x2' in static member function}}
g1(y0);
g1(y1);
g1(y2);
f2(0); // expected-error {{call to non-static member function without an object argument}}
f2(z); // expected-error {{call to non-static member function without an object argument}}
f2(x0); // expected-error {{call to non-static member function without an object argument}}
f2(x1); // expected-error {{call to non-static member function without an object argument}}
f2(x2); // expected-error {{call to non-static member function without an object argument}}
f2(y0); // expected-error {{call to non-static member function without an object argument}}
f2(y1); // expected-error {{call to non-static member function without an object argument}}
f2(y2); // expected-error {{call to non-static member function without an object argument}}
g2(0);
g2(z);
g2(x0); // expected-error {{invalid use of member 'x0' in static member function}}
g2(x1); // expected-error {{invalid use of member 'x1' in static member function}}
g2(x2); // expected-error {{invalid use of member 'x2' in static member function}}
g2(y0);
g2(y1);
g2(y2);
}
};
template struct D<int>;
void test2() {
D<int>().non_static_spec(0); // expected-note {{in instantiation of}}
D<int>().static_spec(0); // expected-note {{in instantiation of}}
}
template<typename T>
struct E : T {
int x1;
static inline int y1;
int f1(int);
static int g1(int);
using T::x0;
using T::y0;
using T::f0;
using T::g0;
template<typename U>
void non_static_spec(U);
template<typename U>
static void static_spec(U);
template<>
void non_static_spec(int z) {
++z;
++x0;
++x1;
++y0;
++y1;
&z;
&x0;
&x1;
&y0;
&y1;
&f0; // expected-error {{must explicitly qualify name of member function when taking its address}}
&f1; // expected-error 2{{must explicitly qualify name of member function when taking its address}}
&g0;
&g1;
&T::x0;
&E::x1;
&T::y0;
&E::y1;
&T::f0;
&E::f1;
&T::g0;
&E::g1;
f0(0);
f0(z);
f0(x0);
f0(x1);
f0(y0);
f0(y1);
g0(0);
g0(z);
g0(x0);
g0(x1);
g0(y0);
g0(y1);
f1(0);
f1(z);
f1(x0);
f1(x1);
f1(y0);
f1(y1);
g1(0);
g1(z);
g1(x0);
g1(x1);
g1(y0);
g1(y1);
T::f0(0);
T::f0(z);
T::f0(x0);
T::f0(x1);
T::f0(y0);
T::f0(y1);
T::g0(0);
T::g0(z);
T::g0(x0);
T::g0(x1);
T::g0(y0);
T::g0(y1);
E::f1(0);
E::f1(z);
E::f1(x0);
E::f1(x1);
E::f1(y0);
E::f1(y1);
E::g1(0);
E::g1(z);
E::g1(x0);
E::g1(x1);
E::g1(y0);
E::g1(y1);
}
template<>
void static_spec(int z) {
++z;
++x0; // expected-error {{invalid use of member 'x0' in static member function}}
++x1; // expected-error {{invalid use of member 'x1' in static member function}}
++y0;
++y1;
&z;
&x0; // expected-error {{invalid use of member 'x0' in static member function}}
&x1; // expected-error {{invalid use of member 'x1' in static member function}}
&y0;
&y1;
&f0; // expected-error {{must explicitly qualify name of member function when taking its address}}
&f1; // expected-error 2{{must explicitly qualify name of member function when taking its address}}
&g0;
&g1;
&T::x0;
&E::x1;
&T::y0;
&E::y1;
&T::f0;
&E::f1;
&T::g0;
&E::g1;
f0(0); // expected-error {{call to non-static member function without an object argument}}
f0(z); // expected-error {{call to non-static member function without an object argument}}
f0(x0); // expected-error {{call to non-static member function without an object argument}}
f0(x1); // expected-error {{call to non-static member function without an object argument}}
f0(y0); // expected-error {{call to non-static member function without an object argument}}
f0(y1); // expected-error {{call to non-static member function without an object argument}}
g0(0);
g0(z);
g0(x0); // expected-error {{invalid use of member 'x0' in static member function}}
g0(x1); // expected-error {{invalid use of member 'x1' in static member function}}
g0(y0);
g0(y1);
f1(0); // expected-error {{call to non-static member function without an object argument}}
f1(z); // expected-error {{call to non-static member function without an object argument}}
f1(x0); // expected-error {{call to non-static member function without an object argument}}
f1(x1); // expected-error {{call to non-static member function without an object argument}}
f1(y0); // expected-error {{call to non-static member function without an object argument}}
f1(y1); // expected-error {{call to non-static member function without an object argument}}
g1(0);
g1(z);
g1(x0); // expected-error {{invalid use of member 'x0' in static member function}}
g1(x1); // expected-error {{invalid use of member 'x1' in static member function}}
g1(y0);
g1(y1);
T::f0(0); // expected-error {{call to non-static member function without an object argument}}
T::f0(z); // expected-error {{call to non-static member function without an object argument}}
T::f0(x0); // expected-error {{call to non-static member function without an object argument}}
T::f0(x1); // expected-error {{call to non-static member function without an object argument}}
T::f0(y0); // expected-error {{call to non-static member function without an object argument}}
T::f0(y1); // expected-error {{call to non-static member function without an object argument}}
T::g0(0);
T::g0(z);
T::g0(x0); // expected-error {{invalid use of member 'x0' in static member function}}
T::g0(x1); // expected-error {{invalid use of member 'x1' in static member function}}
T::g0(y0);
T::g0(y1);
E::f1(0); // expected-error {{call to non-static member function without an object argument}}
E::f1(z); // expected-error {{call to non-static member function without an object argument}}
E::f1(x0); // expected-error {{call to non-static member function without an object argument}}
E::f1(x1); // expected-error {{call to non-static member function without an object argument}}
E::f1(y0); // expected-error {{call to non-static member function without an object argument}}
E::f1(y1); // expected-error {{call to non-static member function without an object argument}}
E::g1(0);
E::g1(z);
E::g1(x0); // expected-error {{invalid use of member 'x0' in static member function}}
E::g1(x1); // expected-error {{invalid use of member 'x1' in static member function}}
E::g1(y0);
E::g1(y1);
}
};
template struct E<B>;
void test3() {
E<B>().non_static_spec(0); // expected-note {{in instantiation of}}
E<B>().static_spec(0); // expected-note {{in instantiation of}}
}
}
namespace GH111266 {
template<class T> struct S {
template<int> auto foo();
template<> auto foo<1>() {
return [](auto x) { return x; };
}
};
template struct S<void>;
void test() {
S<void>().foo<1>();
}
} // namespace GH111266
Reference in New Issue View Git Blame Copy Permalink