vasilito
cb424d7448
verify-patch-sanity.py validates every active recipe .patch has internally- consistent hunk line counts — catching the 'malformed patch at line N' failure at commit/CI/preflight time instead of hours into a cook. This cycle hit that class three times (qtwaylandscanner, sddm, xwayland), each only discovered when cookbook tried to apply the patch. Running it across the repo found 29 latent malformed patches (validated against GNU patch: e.g. relibc/P3-sysv-ipc reproduces 'malformed patch at line 22'). They were harmless only because they sit in vendored recipes (baked, not re- applied) — but would fail on any version-bump re-derivation. --fix recounts the hunk headers (body untouched) and repaired all 29. Wired into build-preflight.sh (Phase 1.0D) and redbear-ci.yml, with a unit test (test-patch-sanity.sh). Skips archived/legacy trees and unvalidatable formats (empty placeholders, bare-@@ git hunks).
608 lines
16 KiB
C++
608 lines
16 KiB
C++
// 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
|