Mercurial > hg > CbC > CbC_llvm

comparison clang/test/PCH/cxx1y-variable-templates.cpp @ 150:1d019706d866

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
LLVM10
author anatofuz
date Thu, 13 Feb 2020 15:10:13 +0900
parents
children 2e18cbf3894f
comparison
equal deleted inserted replaced
147:c2174574ed3a 150:1d019706d866
1 // No PCH:
2 // RUN: %clang_cc1 -pedantic -std=c++1y -include %s -include %s -verify %s -DNONPCH
3 // RUN: %clang_cc1 -pedantic -std=c++1y -include %s -include %s -verify %s -DNONPCH -DERROR
4 //
5 // With PCH:
6 // RUN: %clang_cc1 -pedantic -std=c++1y -emit-pch %s -o %t.a -DHEADER1
7 // RUN: %clang_cc1 -pedantic -std=c++1y -include-pch %t.a -emit-pch %s -o %t.b -DHEADER2
8 // RUN: %clang_cc1 -pedantic -std=c++1y -include-pch %t.b -verify %s -DHEADERUSE
9
10 #ifndef ERROR
11 // expected-no-diagnostics
12 #endif
13
14 #ifdef NONPCH
15 #if !defined(HEADER1)
16 #define HEADER1
17 #undef HEADER2
18 #undef HEADERUSE
19 #elif !defined(HEADER2)
20 #define HEADER2
21 #undef HEADERUSE
22 #else
23 #define HEADERUSE
24 #undef HEADER1
25 #undef HEADER2
26 #endif
27 #endif
28
29
30 // *** HEADER1: First header file
31 #if defined(HEADER1) && !defined(HEADER2) && !defined(HEADERUSE)
32
33 template<typename T> T var0a = T();
34 template<typename T> extern T var0b;
35
36 namespace join {
37 template<typename T> T va = T(100);
38 template<typename T> extern T vb;
39
40 namespace diff_types {
41 #ifdef ERROR
42 template<typename T> extern float err0;
43 template<typename T> extern T err1;
44 #endif
45 template<typename T> extern T def;
46 }
47
48 }
49
50 namespace spec {
51 template<typename T> constexpr T va = T(10);
52 template<> constexpr float va<float> = 1.5;
53 template constexpr int va<int>;
54
55 template<typename T> T vb = T();
56 template<> constexpr float vb<float> = 1.5;
57
58 template<typename T> T vc = T();
59
60 template<typename T> constexpr T vd = T(10);
61 template<typename T> T* vd<T*> = new T();
62 }
63
64 namespace spec_join1 {
65 template<typename T> T va = T(10);
66 template<> extern float va<float>;
67 extern template int va<int>;
68
69 template<typename T> T vb = T(10);
70 template<> extern float vb<float>;
71
72 template<typename T> T vc = T(10);
73
74 template<typename T> T vd = T(10);
75 template<typename T> extern T* vd<T*>;
76 }
77
78 #endif
79
80
81 // *** HEADER2: Second header file -- including HEADER1
82 #if defined(HEADER2) && !defined(HEADERUSE)
83
84 namespace join {
85 template<typename T> extern T va;
86 template<> constexpr float va<float> = 2.5;
87
88 template<typename T> T vb = T(100);
89
90 namespace diff_types {
91 #ifdef ERROR
92 template<typename T> extern T err0; // expected-error {{redeclaration of 'err0' with a different type: 'T' vs 'float'}} // expected-note@42 {{previous declaration is here}}
93 template<typename T> extern float err1; // expected-error {{redeclaration of 'err1' with a different type: 'float' vs 'T'}} // expected-note@43 {{previous declaration is here}}
94 #endif
95 template<typename T> extern T def;
96 }
97 }
98
99 namespace spec_join1 {
100 template<typename T> extern T va;
101 template<> float va<float> = 1.5;
102 extern template int va<int>;
103
104 template<> float vb<float> = 1.5;
105 template int vb<int>;
106
107 template<> float vc<float> = 1.5;
108 template int vc<int>;
109
110 template<typename T> extern T vd;
111 template<typename T> T* vd<T*> = new T();
112 }
113
114 #endif
115
116 // *** HEADERUSE: File using both header files -- including HEADER2
117 #ifdef HEADERUSE
118
119 template int var0a<int>;
120 float fvara = var0a<float>;
121
122 template<typename T> extern T var0a;
123
124 template<typename T> T var0b = T();
125 template int var0b<int>;
126 float fvarb = var0b<float>;
127
128 namespace join {
129 template const int va<const int>;
130 template<> const int va<int> = 50;
131 static_assert(va<float> == 2.5, "");
132 static_assert(va<int> == 50, "");
133
134 template<> constexpr float vb<float> = 2.5;
135 template const int vb<const int>;
136 static_assert(vb<float> == 2.5, "");
137 static_assert(vb<const int> == 100, "");
138
139 namespace diff_types {
140 template<typename T> T def = T();
141 }
142
143 }
144
145 namespace spec {
146 static_assert(va<float> == 1.5, "");
147 static_assert(va<int> == 10, "");
148
149 template<typename T> T* vb<T*> = new T();
150 int* intpb = vb<int*>;
151 static_assert(vb<float> == 1.5, "");
152
153 template<typename T> T* vc<T*> = new T();
154 template<> constexpr float vc<float> = 1.5;
155 int* intpc = vc<int*>;
156 static_assert(vc<float> == 1.5, "");
157
158 char* intpd = vd<char*>;
159 }
160
161 namespace spec_join1 {
162 template int va<int>;
163 int a = va<int>;
164
165 template<typename T> extern T vb;
166 int b = vb<int>;
167
168 int* intpb = vd<int*>;
169 }
170
171 #endif