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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
| // RUN: %clang_cc1 -fsyntax-only -verify %s
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
// PR4607
template <class T> struct X {};
template <> struct X<char>
{
static char* g();
};
template <class T> struct X2 {};
template <class U>
struct X2<U*> {
static void f() {
X<U>::g();
}
};
void a(char *a, char *b) {X2<char*>::f();}
namespace WonkyAccess {
template<typename T>
struct X {
int m;
};
template<typename U>
class Y;
template<typename U>
struct Y<U*> : X<U> { };
template<>
struct Y<float*> : X<float> { };
int f(Y<int*> y, Y<float*> y2) {
return y.m + y2.m;
}
}
// <rdar://problem/9169404>
namespace rdar9169404 {
template<typename T, T N> struct X { };
template<bool C> struct X<bool, C> {
typedef int type;
};
X<bool, -1>::type value;
#if __cplusplus >= 201103L
// expected-error@-2 {{non-type template argument evaluates to -1, which cannot be narrowed to type 'bool'}}
#else
// expected-no-diagnostics
#endif
}
// rdar://problem/39524996
namespace rdar39524996 {
template <typename T, typename U>
struct enable_if_not_same
{
typedef void type;
};
template <typename T>
struct enable_if_not_same<T, T>;
template <typename T>
struct Wrapper {
// Assertion triggered on trying to set twice the same partial specialization
// enable_if_not_same<int, int>
template <class U>
Wrapper(const Wrapper<U>& other,
typename enable_if_not_same<U, T>::type* = 0) {}
explicit Wrapper(int i) {}
};
template <class T>
struct Container {
// It is important that the struct has implicit copy and move constructors.
Container() : x() {}
template <class U>
Container(const Container<U>& other) : x(static_cast<T>(other.x)) {}
// Implicit constructors are member-wise, so the field triggers instantiation
// of T constructors and we instantiate all of them for overloading purposes.
T x;
};
void takesWrapperInContainer(const Container< Wrapper<int> >& c);
void test() {
// Type mismatch triggers initialization with conversion which requires
// implicit constructors to be instantiated.
Container<int> c;
takesWrapperInContainer(c);
}
}
|