1 // RUN: %clang_cc1 -fsyntax-only -verify %s
2 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
3 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
4
5 // PR4607
6 template <class T> struct X {};
7
8 template <> struct X<char>
9 {
10 static char* g();
11 };
12
13 template <class T> struct X2 {};
14
15 template <class U>
16 struct X2<U*> {
fX217 static void f() {
18 X<U>::g();
19 }
20 };
21
a(char * a,char * b)22 void a(char *a, char *b) {X2<char*>::f();}
23
24 namespace WonkyAccess {
25 template<typename T>
26 struct X {
27 int m;
28 };
29
30 template<typename U>
31 class Y;
32
33 template<typename U>
34 struct Y<U*> : X<U> { };
35
36 template<>
37 struct Y<float*> : X<float> { };
38
f(Y<int * > y,Y<float * > y2)39 int f(Y<int*> y, Y<float*> y2) {
40 return y.m + y2.m;
41 }
42 }
43
44 // <rdar://problem/9169404>
45 namespace rdar9169404 {
46 template<typename T, T N> struct X { };
47 template<bool C> struct X<bool, C> {
48 typedef int type;
49 };
50
51 X<bool, -1>::type value;
52 #if __cplusplus >= 201103L
53 // expected-error@-2 {{non-type template argument evaluates to -1, which cannot be narrowed to type 'bool'}}
54 #else
55 // expected-no-diagnostics
56 #endif
57 }
58
59 // rdar://problem/39524996
60 namespace rdar39524996 {
61 template <typename T, typename U>
62 struct enable_if_not_same
63 {
64 typedef void type;
65 };
66 template <typename T>
67 struct enable_if_not_same<T, T>;
68
69 template <typename T>
70 struct Wrapper {
71 // Assertion triggered on trying to set twice the same partial specialization
72 // enable_if_not_same<int, int>
73 template <class U>
Wrapperrdar39524996::Wrapper74 Wrapper(const Wrapper<U>& other,
75 typename enable_if_not_same<U, T>::type* = 0) {}
76
Wrapperrdar39524996::Wrapper77 explicit Wrapper(int i) {}
78 };
79
80 template <class T>
81 struct Container {
82 // It is important that the struct has implicit copy and move constructors.
Containerrdar39524996::Container83 Container() : x() {}
84
85 template <class U>
Containerrdar39524996::Container86 Container(const Container<U>& other) : x(static_cast<T>(other.x)) {}
87
88 // Implicit constructors are member-wise, so the field triggers instantiation
89 // of T constructors and we instantiate all of them for overloading purposes.
90 T x;
91 };
92
93 void takesWrapperInContainer(const Container< Wrapper<int> >& c);
test()94 void test() {
95 // Type mismatch triggers initialization with conversion which requires
96 // implicit constructors to be instantiated.
97 Container<int> c;
98 takesWrapperInContainer(c);
99 }
100 }
101