blob: 3c7111d058389566f8f503ada6236d10fd373450 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
|
// RUN: %clang_cc1 -fms-extensions -fsyntax-only -verify %s
// RUN: %clang_cc1 -fms-extensions -fdelayed-template-parsing -fsyntax-only -verify %s
class A {
public:
template<class U> A(U p) {}
template<> A(int p) {
// expected-warning@-1 {{explicit specialization of 'A' within class scope is a Microsoft extension}}
}
template<class U> void f(U p) {}
template<> void f(int p) {
// expected-warning@-1 {{explicit specialization of 'f' within class scope is a Microsoft extension}}
}
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) {
// expected-warning@-1 {{explicit specialization of 'B<T>' within class scope is a Microsoft extension}}
}
template<class U> void f(U p) { T y = 9; }
template<> void f(int p) {
// expected-warning@-1 {{explicit specialization of 'f' within class scope is a Microsoft extension}}
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>() {
// expected-warning@-1 {{explicit specialization of 'specialized_member_template' within class scope is a Microsoft extension}}
}
};
void f() { TemplateClass<int> t; }
}
namespace Duplicates {
template<typename T> struct A {
template<typename U> void f();
template<> void f<int>() {} // expected-warning {{Microsoft extension}}
template<> void f<T>() {} // expected-warning {{Microsoft extension}}
};
// 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); // expected-warning {{Microsoft extension}}
};
}
|
