Lines Matching refs:arr
117 { int arr[T(__is_pod(int))]; }
118 { int arr[T(__is_pod(Enum))]; }
119 { int arr[T(__is_pod(POD))]; }
120 { int arr[T(__is_pod(Int))]; }
121 { int arr[T(__is_pod(IntAr))]; }
122 { int arr[T(__is_pod(Statics))]; }
123 { int arr[T(__is_pod(Empty))]; }
124 { int arr[T(__is_pod(EmptyUnion))]; }
125 { int arr[T(__is_pod(Union))]; }
126 { int arr[T(__is_pod(HasFunc))]; }
127 { int arr[T(__is_pod(HasOp))]; }
128 { int arr[T(__is_pod(HasConv))]; }
129 { int arr[T(__is_pod(HasAssign))]; }
130 { int arr[T(__is_pod(IntArNB))]; }
131 { int arr[T(__is_pod(HasAnonymousUnion))]; }
132 { int arr[T(__is_pod(Vector))]; }
133 { int arr[T(__is_pod(VectorExt))]; }
134 { int arr[T(__is_pod(Derives))]; }
135 { int arr[T(__is_pod(DerivesAr))]; }
136 { int arr[T(__is_pod(DerivesArNB))]; }
137 { int arr[T(__is_pod(DerivesEmpty))]; }
138 { int arr[T(__is_pod(HasPriv))]; }
139 { int arr[T(__is_pod(HasProt))]; }
140 { int arr[T(__is_pod(DerivesHasPriv))]; }
141 { int arr[T(__is_pod(DerivesHasProt))]; }
143 { int arr[F(__is_pod(HasCons))]; }
144 { int arr[F(__is_pod(HasCopyAssign))]; }
145 { int arr[F(__is_pod(HasMoveAssign))]; }
146 { int arr[F(__is_pod(HasDest))]; }
147 { int arr[F(__is_pod(HasRef))]; }
148 { int arr[F(__is_pod(HasVirt))]; }
149 { int arr[F(__is_pod(DerivesHasCons))]; }
150 { int arr[F(__is_pod(DerivesHasCopyAssign))]; }
151 { int arr[F(__is_pod(DerivesHasMoveAssign))]; }
152 { int arr[F(__is_pod(DerivesHasDest))]; }
153 { int arr[F(__is_pod(DerivesHasRef))]; }
154 { int arr[F(__is_pod(DerivesHasVirt))]; }
155 { int arr[F(__is_pod(NonPOD))]; }
156 { int arr[F(__is_pod(HasNonPOD))]; }
157 { int arr[F(__is_pod(NonPODAr))]; }
158 { int arr[F(__is_pod(NonPODArNB))]; }
159 { int arr[F(__is_pod(void))]; }
160 { int arr[F(__is_pod(cvoid))]; }
161 // { int arr[F(__is_pod(NonPODUnion))]; }
172 { int arr[T(__is_empty(Empty))]; }
173 { int arr[T(__is_empty(DerivesEmpty))]; }
174 { int arr[T(__is_empty(HasCons))]; }
175 { int arr[T(__is_empty(HasCopyAssign))]; }
176 { int arr[T(__is_empty(HasMoveAssign))]; }
177 { int arr[T(__is_empty(HasDest))]; }
178 { int arr[T(__is_empty(HasFunc))]; }
179 { int arr[T(__is_empty(HasOp))]; }
180 { int arr[T(__is_empty(HasConv))]; }
181 { int arr[T(__is_empty(HasAssign))]; }
182 { int arr[T(__is_empty(Bit0))]; }
183 { int arr[T(__is_empty(Bit0Cons))]; }
185 { int arr[F(__is_empty(Int))]; }
186 { int arr[F(__is_empty(POD))]; }
187 { int arr[F(__is_empty(EmptyUnion))]; }
188 { int arr[F(__is_empty(EmptyAr))]; }
189 { int arr[F(__is_empty(HasRef))]; }
190 { int arr[F(__is_empty(HasVirt))]; }
191 { int arr[F(__is_empty(BitOnly))]; }
192 { int arr[F(__is_empty(void))]; }
193 { int arr[F(__is_empty(IntArNB))]; }
194 { int arr[F(__is_empty(HasAnonymousUnion))]; }
195 // { int arr[F(__is_empty(DerivesVirt))]; }
202 { int arr[T(__is_class(Derives))]; }
203 { int arr[T(__is_class(HasPriv))]; }
204 { int arr[T(__is_class(ClassType))]; }
205 { int arr[T(__is_class(HasAnonymousUnion))]; }
207 { int arr[F(__is_class(int))]; }
208 { int arr[F(__is_class(Enum))]; }
209 { int arr[F(__is_class(Int))]; }
210 { int arr[F(__is_class(IntAr))]; }
211 { int arr[F(__is_class(DerivesAr))]; }
212 { int arr[F(__is_class(Union))]; }
213 { int arr[F(__is_class(cvoid))]; }
214 { int arr[F(__is_class(IntArNB))]; }
222 { int arr[T(__is_union(Union))]; }
223 { int arr[T(__is_union(UnionType))]; }
225 { int arr[F(__is_union(int))]; }
226 { int arr[F(__is_union(Enum))]; }
227 { int arr[F(__is_union(Int))]; }
228 { int arr[F(__is_union(IntAr))]; }
229 { int arr[F(__is_union(UnionAr))]; }
230 { int arr[F(__is_union(cvoid))]; }
231 { int arr[F(__is_union(IntArNB))]; }
232 { int arr[F(__is_union(HasAnonymousUnion))]; }
239 { int arr[T(__is_enum(Enum))]; }
240 { int arr[T(__is_enum(EnumType))]; }
242 { int arr[F(__is_enum(int))]; }
243 { int arr[F(__is_enum(Union))]; }
244 { int arr[F(__is_enum(Int))]; }
245 { int arr[F(__is_enum(IntAr))]; }
246 { int arr[F(__is_enum(UnionAr))]; }
247 { int arr[F(__is_enum(Derives))]; }
248 { int arr[F(__is_enum(ClassType))]; }
249 { int arr[F(__is_enum(cvoid))]; }
250 { int arr[F(__is_enum(IntArNB))]; }
251 { int arr[F(__is_enum(HasAnonymousUnion))]; }
268 { int arr[T(__is_final(FinalClass))]; }
269 { int arr[T(__is_final(PotentiallyFinal<float*>))]; }
270 { int arr[T(__is_final(PotentiallyFinal<int>))]; }
272 { int arr[F(__is_final(int))]; }
273 { int arr[F(__is_final(Union))]; }
274 { int arr[F(__is_final(Int))]; }
275 { int arr[F(__is_final(IntAr))]; }
276 { int arr[F(__is_final(UnionAr))]; }
277 { int arr[F(__is_final(Derives))]; }
278 { int arr[F(__is_final(ClassType))]; }
279 { int arr[F(__is_final(cvoid))]; }
280 { int arr[F(__is_final(IntArNB))]; }
281 { int arr[F(__is_final(HasAnonymousUnion))]; }
282 { int arr[F(__is_final(PotentiallyFinal<float>))]; }
290 { int arr[T(__is_polymorphic(Polymorph))]; }
291 { int arr[T(__is_polymorphic(InheritPolymorph))]; }
293 { int arr[F(__is_polymorphic(int))]; }
294 { int arr[F(__is_polymorphic(Union))]; }
295 { int arr[F(__is_polymorphic(Int))]; }
296 { int arr[F(__is_polymorphic(IntAr))]; }
297 { int arr[F(__is_polymorphic(UnionAr))]; }
298 { int arr[F(__is_polymorphic(Derives))]; }
299 { int arr[F(__is_polymorphic(ClassType))]; }
300 { int arr[F(__is_polymorphic(Enum))]; }
301 { int arr[F(__is_polymorphic(cvoid))]; }
302 { int arr[F(__is_polymorphic(IntArNB))]; }
1177 { int arr[T(__has_trivial_constructor(Int))]; }
1178 { int arr[T(__has_trivial_constructor(IntAr))]; }
1179 { int arr[T(__has_trivial_constructor(Union))]; }
1180 { int arr[T(__has_trivial_constructor(UnionAr))]; }
1181 { int arr[T(__has_trivial_constructor(POD))]; }
1182 { int arr[T(__has_trivial_constructor(Derives))]; }
1183 { int arr[T(__has_trivial_constructor(DerivesAr))]; }
1184 { int arr[T(__has_trivial_constructor(ConstIntAr))]; }
1185 { int arr[T(__has_trivial_constructor(ConstIntArAr))]; }
1186 { int arr[T(__has_trivial_constructor(HasDest))]; }
1187 { int arr[T(__has_trivial_constructor(HasPriv))]; }
1188 { int arr[T(__has_trivial_constructor(HasCopyAssign))]; }
1189 { int arr[T(__has_trivial_constructor(HasMoveAssign))]; }
1190 { int arr[T(__has_trivial_constructor(const Int))]; }
1191 { int arr[T(__has_trivial_constructor(AllDefaulted))]; }
1192 { int arr[T(__has_trivial_constructor(AllDeleted))]; }
1194 { int arr[F(__has_trivial_constructor(HasCons))]; }
1195 { int arr[F(__has_trivial_constructor(HasRef))]; }
1196 { int arr[F(__has_trivial_constructor(HasCopy))]; }
1197 { int arr[F(__has_trivial_constructor(IntRef))]; }
1198 { int arr[F(__has_trivial_constructor(VirtAr))]; }
1199 { int arr[F(__has_trivial_constructor(void))]; }
1200 { int arr[F(__has_trivial_constructor(cvoid))]; }
1201 { int arr[F(__has_trivial_constructor(HasTemplateCons))]; }
1202 { int arr[F(__has_trivial_constructor(AllPrivate))]; }
1203 { int arr[F(__has_trivial_constructor(ExtDefaulted))]; }
1207 { int arr[T(__has_trivial_copy(Int))]; }
1208 { int arr[T(__has_trivial_copy(IntAr))]; }
1209 { int arr[T(__has_trivial_copy(Union))]; }
1210 { int arr[T(__has_trivial_copy(UnionAr))]; }
1211 { int arr[T(__has_trivial_copy(POD))]; }
1212 { int arr[T(__has_trivial_copy(Derives))]; }
1213 { int arr[T(__has_trivial_copy(ConstIntAr))]; }
1214 { int arr[T(__has_trivial_copy(ConstIntArAr))]; }
1215 { int arr[T(__has_trivial_copy(HasDest))]; }
1216 { int arr[T(__has_trivial_copy(HasPriv))]; }
1217 { int arr[T(__has_trivial_copy(HasCons))]; }
1218 { int arr[T(__has_trivial_copy(HasRef))]; }
1219 { int arr[T(__has_trivial_copy(HasMove))]; }
1220 { int arr[T(__has_trivial_copy(IntRef))]; }
1221 { int arr[T(__has_trivial_copy(HasCopyAssign))]; }
1222 { int arr[T(__has_trivial_copy(HasMoveAssign))]; }
1223 { int arr[T(__has_trivial_copy(const Int))]; }
1224 { int arr[T(__has_trivial_copy(AllDefaulted))]; }
1225 { int arr[T(__has_trivial_copy(AllDeleted))]; }
1226 { int arr[T(__has_trivial_copy(DerivesAr))]; }
1227 { int arr[T(__has_trivial_copy(DerivesHasRef))]; }
1229 { int arr[F(__has_trivial_copy(HasCopy))]; }
1230 { int arr[F(__has_trivial_copy(HasTemplateCons))]; }
1231 { int arr[F(__has_trivial_copy(VirtAr))]; }
1232 { int arr[F(__has_trivial_copy(void))]; }
1233 { int arr[F(__has_trivial_copy(cvoid))]; }
1234 { int arr[F(__has_trivial_copy(AllPrivate))]; }
1235 { int arr[F(__has_trivial_copy(ExtDefaulted))]; }
1239 { int arr[T(__has_trivial_assign(Int))]; }
1240 { int arr[T(__has_trivial_assign(IntAr))]; }
1241 { int arr[T(__has_trivial_assign(Union))]; }
1242 { int arr[T(__has_trivial_assign(UnionAr))]; }
1243 { int arr[T(__has_trivial_assign(POD))]; }
1244 { int arr[T(__has_trivial_assign(Derives))]; }
1245 { int arr[T(__has_trivial_assign(HasDest))]; }
1246 { int arr[T(__has_trivial_assign(HasPriv))]; }
1247 { int arr[T(__has_trivial_assign(HasCons))]; }
1248 { int arr[T(__has_trivial_assign(HasRef))]; }
1249 { int arr[T(__has_trivial_assign(HasCopy))]; }
1250 { int arr[T(__has_trivial_assign(HasMove))]; }
1251 { int arr[T(__has_trivial_assign(HasMoveAssign))]; }
1252 { int arr[T(__has_trivial_assign(AllDefaulted))]; }
1253 { int arr[T(__has_trivial_assign(AllDeleted))]; }
1254 { int arr[T(__has_trivial_assign(DerivesAr))]; }
1255 { int arr[T(__has_trivial_assign(DerivesHasRef))]; }
1257 { int arr[F(__has_trivial_assign(IntRef))]; }
1258 { int arr[F(__has_trivial_assign(HasCopyAssign))]; }
1259 { int arr[F(__has_trivial_assign(const Int))]; }
1260 { int arr[F(__has_trivial_assign(ConstIntAr))]; }
1261 { int arr[F(__has_trivial_assign(ConstIntArAr))]; }
1262 { int arr[F(__has_trivial_assign(VirtAr))]; }
1263 { int arr[F(__has_trivial_assign(void))]; }
1264 { int arr[F(__has_trivial_assign(cvoid))]; }
1265 { int arr[F(__has_trivial_assign(AllPrivate))]; }
1266 { int arr[F(__has_trivial_assign(ExtDefaulted))]; }
1270 { int arr[T(__has_trivial_destructor(Int))]; }
1271 { int arr[T(__has_trivial_destructor(IntAr))]; }
1272 { int arr[T(__has_trivial_destructor(Union))]; }
1273 { int arr[T(__has_trivial_destructor(UnionAr))]; }
1274 { int arr[T(__has_trivial_destructor(POD))]; }
1275 { int arr[T(__has_trivial_destructor(Derives))]; }
1276 { int arr[T(__has_trivial_destructor(ConstIntAr))]; }
1277 { int arr[T(__has_trivial_destructor(ConstIntArAr))]; }
1278 { int arr[T(__has_trivial_destructor(HasPriv))]; }
1279 { int arr[T(__has_trivial_destructor(HasCons))]; }
1280 { int arr[T(__has_trivial_destructor(HasRef))]; }
1281 { int arr[T(__has_trivial_destructor(HasCopy))]; }
1282 { int arr[T(__has_trivial_destructor(HasMove))]; }
1283 { int arr[T(__has_trivial_destructor(IntRef))]; }
1284 { int arr[T(__has_trivial_destructor(HasCopyAssign))]; }
1285 { int arr[T(__has_trivial_destructor(HasMoveAssign))]; }
1286 { int arr[T(__has_trivial_destructor(const Int))]; }
1287 { int arr[T(__has_trivial_destructor(DerivesAr))]; }
1288 { int arr[T(__has_trivial_destructor(VirtAr))]; }
1289 { int arr[T(__has_trivial_destructor(AllDefaulted))]; }
1290 { int arr[T(__has_trivial_destructor(AllDeleted))]; }
1291 { int arr[T(__has_trivial_destructor(DerivesHasRef))]; }
1293 { int arr[F(__has_trivial_destructor(HasDest))]; }
1294 { int arr[F(__has_trivial_destructor(void))]; }
1295 { int arr[F(__has_trivial_destructor(cvoid))]; }
1296 { int arr[F(__has_trivial_destructor(AllPrivate))]; }
1297 { int arr[F(__has_trivial_destructor(ExtDefaulted))]; }
1304 { int arr[F(__has_trivial_destructor(A))]; }
1305 { int arr[F(__has_trivial_destructor(B<int>))]; }
1326 { int arr[T(__has_nothrow_assign(Int))]; }
1327 { int arr[T(__has_nothrow_assign(IntAr))]; }
1328 { int arr[T(__has_nothrow_assign(Union))]; }
1329 { int arr[T(__has_nothrow_assign(UnionAr))]; }
1330 { int arr[T(__has_nothrow_assign(POD))]; }
1331 { int arr[T(__has_nothrow_assign(Derives))]; }
1332 { int arr[T(__has_nothrow_assign(HasDest))]; }
1333 { int arr[T(__has_nothrow_assign(HasPriv))]; }
1334 { int arr[T(__has_nothrow_assign(HasCons))]; }
1335 { int arr[T(__has_nothrow_assign(HasRef))]; }
1336 { int arr[T(__has_nothrow_assign(HasCopy))]; }
1337 { int arr[T(__has_nothrow_assign(HasMove))]; }
1338 { int arr[T(__has_nothrow_assign(HasMoveAssign))]; }
1339 { int arr[T(__has_nothrow_assign(HasNoThrowCopyAssign))]; }
1340 { int arr[T(__has_nothrow_assign(HasMultipleNoThrowCopyAssign))]; }
1341 { int arr[T(__has_nothrow_assign(HasVirtDest))]; }
1342 { int arr[T(__has_nothrow_assign(AllPrivate))]; }
1343 { int arr[T(__has_nothrow_assign(UsingAssign))]; }
1344 { int arr[T(__has_nothrow_assign(DerivesAr))]; }
1346 { int arr[F(__has_nothrow_assign(IntRef))]; }
1347 { int arr[F(__has_nothrow_assign(HasCopyAssign))]; }
1348 { int arr[F(__has_nothrow_assign(HasMultipleCopyAssign))]; }
1349 { int arr[F(__has_nothrow_assign(const Int))]; }
1350 { int arr[F(__has_nothrow_assign(ConstIntAr))]; }
1351 { int arr[F(__has_nothrow_assign(ConstIntArAr))]; }
1352 { int arr[F(__has_nothrow_assign(VirtAr))]; }
1353 { int arr[F(__has_nothrow_assign(void))]; }
1354 { int arr[F(__has_nothrow_assign(cvoid))]; }
1355 { int arr[F(__has_nothrow_assign(PR11110))]; }
1359 { int arr[T(__has_nothrow_copy(Int))]; }
1360 { int arr[T(__has_nothrow_copy(IntAr))]; }
1361 { int arr[T(__has_nothrow_copy(Union))]; }
1362 { int arr[T(__has_nothrow_copy(UnionAr))]; }
1363 { int arr[T(__has_nothrow_copy(POD))]; }
1364 { int arr[T(__has_nothrow_copy(const Int))]; }
1365 { int arr[T(__has_nothrow_copy(ConstIntAr))]; }
1366 { int arr[T(__has_nothrow_copy(ConstIntArAr))]; }
1367 { int arr[T(__has_nothrow_copy(Derives))]; }
1368 { int arr[T(__has_nothrow_copy(IntRef))]; }
1369 { int arr[T(__has_nothrow_copy(HasDest))]; }
1370 { int arr[T(__has_nothrow_copy(HasPriv))]; }
1371 { int arr[T(__has_nothrow_copy(HasCons))]; }
1372 { int arr[T(__has_nothrow_copy(HasRef))]; }
1373 { int arr[T(__has_nothrow_copy(HasMove))]; }
1374 { int arr[T(__has_nothrow_copy(HasCopyAssign))]; }
1375 { int arr[T(__has_nothrow_copy(HasMoveAssign))]; }
1376 { int arr[T(__has_nothrow_copy(HasNoThrowCopy))]; }
1377 { int arr[T(__has_nothrow_copy(HasMultipleNoThrowCopy))]; }
1378 { int arr[T(__has_nothrow_copy(HasVirtDest))]; }
1379 { int arr[T(__has_nothrow_copy(HasTemplateCons))]; }
1380 { int arr[T(__has_nothrow_copy(AllPrivate))]; }
1381 { int arr[T(__has_nothrow_copy(DerivesAr))]; }
1383 { int arr[F(__has_nothrow_copy(HasCopy))]; }
1384 { int arr[F(__has_nothrow_copy(HasMultipleCopy))]; }
1385 { int arr[F(__has_nothrow_copy(VirtAr))]; }
1386 { int arr[F(__has_nothrow_copy(void))]; }
1387 { int arr[F(__has_nothrow_copy(cvoid))]; }
1391 { int arr[T(__has_nothrow_constructor(Int))]; }
1392 { int arr[T(__has_nothrow_constructor(IntAr))]; }
1393 { int arr[T(__has_nothrow_constructor(Union))]; }
1394 { int arr[T(__has_nothrow_constructor(UnionAr))]; }
1395 { int arr[T(__has_nothrow_constructor(POD))]; }
1396 { int arr[T(__has_nothrow_constructor(Derives))]; }
1397 { int arr[T(__has_nothrow_constructor(DerivesAr))]; }
1398 { int arr[T(__has_nothrow_constructor(ConstIntAr))]; }
1399 { int arr[T(__has_nothrow_constructor(ConstIntArAr))]; }
1400 { int arr[T(__has_nothrow_constructor(HasDest))]; }
1401 { int arr[T(__has_nothrow_constructor(HasPriv))]; }
1402 { int arr[T(__has_nothrow_constructor(HasCopyAssign))]; }
1403 { int arr[T(__has_nothrow_constructor(const Int))]; }
1404 { int arr[T(__has_nothrow_constructor(HasNoThrowConstructor))]; }
1405 { int arr[T(__has_nothrow_constructor(HasVirtDest))]; }
1406 // { int arr[T(__has_nothrow_constructor(VirtAr))]; } // not implemented
1407 { int arr[T(__has_nothrow_constructor(AllPrivate))]; }
1409 { int arr[F(__has_nothrow_constructor(HasCons))]; }
1410 { int arr[F(__has_nothrow_constructor(HasRef))]; }
1411 { int arr[F(__has_nothrow_constructor(HasCopy))]; }
1412 { int arr[F(__has_nothrow_constructor(HasMove))]; }
1413 { int arr[F(__has_nothrow_constructor(HasNoThrowConstructorWithArgs))]; }
1414 { int arr[F(__has_nothrow_constructor(IntRef))]; }
1415 { int arr[F(__has_nothrow_constructor(void))]; }
1416 { int arr[F(__has_nothrow_constructor(cvoid))]; }
1417 { int arr[F(__has_nothrow_constructor(HasTemplateCons))]; }
1421 { int arr[F(__has_virtual_destructor(Int))]; }
1422 { int arr[F(__has_virtual_destructor(IntAr))]; }
1423 { int arr[F(__has_virtual_destructor(Union))]; }
1424 { int arr[F(__has_virtual_destructor(UnionAr))]; }
1425 { int arr[F(__has_virtual_destructor(POD))]; }
1426 { int arr[F(__has_virtual_destructor(Derives))]; }
1427 { int arr[F(__has_virtual_destructor(DerivesAr))]; }
1428 { int arr[F(__has_virtual_destructor(const Int))]; }
1429 { int arr[F(__has_virtual_destructor(ConstIntAr))]; }
1430 { int arr[F(__has_virtual_destructor(ConstIntArAr))]; }
1431 { int arr[F(__has_virtual_destructor(HasDest))]; }
1432 { int arr[F(__has_virtual_destructor(HasPriv))]; }
1433 { int arr[F(__has_virtual_destructor(HasCons))]; }
1434 { int arr[F(__has_virtual_destructor(HasRef))]; }
1435 { int arr[F(__has_virtual_destructor(HasCopy))]; }
1436 { int arr[F(__has_virtual_destructor(HasMove))]; }
1437 { int arr[F(__has_virtual_destructor(HasCopyAssign))]; }
1438 { int arr[F(__has_virtual_destructor(HasMoveAssign))]; }
1439 { int arr[F(__has_virtual_destructor(IntRef))]; }
1440 { int arr[F(__has_virtual_destructor(VirtAr))]; }
1442 { int arr[T(__has_virtual_destructor(HasVirtDest))]; }
1443 { int arr[T(__has_virtual_destructor(DerivedVirtDest))]; }
1444 { int arr[F(__has_virtual_destructor(VirtDestAr))]; }
1445 { int arr[F(__has_virtual_destructor(void))]; }
1446 { int arr[F(__has_virtual_destructor(cvoid))]; }
1447 { int arr[F(__has_virtual_destructor(AllPrivate))]; }
1477 { int arr[T(__is_base_of(Base, Derived))]; }
1478 { int arr[T(__is_base_of(const Base, Derived))]; }
1479 { int arr[F(__is_base_of(Derived, Base))]; }
1480 { int arr[F(__is_base_of(Derived, int))]; }
1481 { int arr[T(__is_base_of(Base, Base))]; }
1482 { int arr[T(__is_base_of(Base, Derived3))]; }
1483 { int arr[T(__is_base_of(Derived, Derived3))]; }
1484 { int arr[T(__is_base_of(Derived2b, Derived3))]; }
1485 { int arr[T(__is_base_of(Derived2a, Derived3))]; }
1486 { int arr[T(__is_base_of(BaseA<int>, DerivedB<int>))]; }
1487 { int arr[F(__is_base_of(DerivedB<int>, BaseA<int>))]; }
1488 { int arr[T(__is_base_of(Base, CrazyDerived<Base>))]; }
1489 { int arr[F(__is_base_of(Union, Union))]; }
1490 { int arr[T(__is_base_of(Empty, Empty))]; }
1491 { int arr[T(__is_base_of(class_forward, class_forward))]; }
1492 { int arr[F(__is_base_of(Empty, class_forward))]; } // expected-error {{incomplete type 'class_forward' used in type trait expression}}
1493 { int arr[F(__is_base_of(Base&, Derived&))]; }
1495 { int arr[F(__is_base_of(int, int))]; }
1496 { int arr[F(__is_base_of(long, int))]; }
1497 { int arr[T(__is_base_of(Base, DerivedTemp<int>))]; }
1498 { int arr[F(__is_base_of(Base, NonderivedTemp<int>))]; }
1499 { int arr[F(__is_base_of(Base, UndefinedTemp<int>))]; } // expected-error {{implicit instantiation of undefined template 'UndefinedTemp<int>'}}
1583 { int arr[T(__is_convertible_to(Int, Int))]; }
1584 { int arr[F(__is_convertible_to(Int, IntAr))]; }
1585 { int arr[F(__is_convertible_to(IntAr, IntAr))]; }
1586 { int arr[T(__is_convertible_to(void, void))]; }
1587 { int arr[T(__is_convertible_to(cvoid, void))]; }
1588 { int arr[T(__is_convertible_to(void, cvoid))]; }
1589 { int arr[T(__is_convertible_to(cvoid, cvoid))]; }
1590 { int arr[T(__is_convertible_to(int, FromInt))]; }
1591 { int arr[T(__is_convertible_to(long, FromInt))]; }
1592 { int arr[T(__is_convertible_to(double, FromInt))]; }
1593 { int arr[T(__is_convertible_to(const int, FromInt))]; }
1594 { int arr[T(__is_convertible_to(const int&, FromInt))]; }
1595 { int arr[T(__is_convertible_to(ToInt, int))]; }
1596 { int arr[T(__is_convertible_to(ToInt, const int&))]; }
1597 { int arr[T(__is_convertible_to(ToInt, long))]; }
1598 { int arr[F(__is_convertible_to(ToInt, int&))]; }
1599 { int arr[F(__is_convertible_to(ToInt, FromInt))]; }
1600 { int arr[T(__is_convertible_to(IntAr&, IntAr&))]; }
1601 { int arr[T(__is_convertible_to(IntAr&, const IntAr&))]; }
1602 { int arr[F(__is_convertible_to(const IntAr&, IntAr&))]; }
1603 { int arr[F(__is_convertible_to(Function, Function))]; }
1604 { int arr[F(__is_convertible_to(PrivateCopy, PrivateCopy))]; }
1605 { int arr[T(__is_convertible_to(X0<int>, X0<float>))]; }
1606 { int arr[F(__is_convertible_to(Abstract, Abstract))]; }
1617 { int arr[T(__is_trivial(int))]; }
1618 { int arr[T(__is_trivial(Enum))]; }
1619 { int arr[T(__is_trivial(POD))]; }
1620 { int arr[T(__is_trivial(Int))]; }
1621 { int arr[T(__is_trivial(IntAr))]; }
1622 { int arr[T(__is_trivial(IntArNB))]; }
1623 { int arr[T(__is_trivial(Statics))]; }
1624 { int arr[T(__is_trivial(Empty))]; }
1625 { int arr[T(__is_trivial(EmptyUnion))]; }
1626 { int arr[T(__is_trivial(Union))]; }
1627 { int arr[T(__is_trivial(Derives))]; }
1628 { int arr[T(__is_trivial(DerivesAr))]; }
1629 { int arr[T(__is_trivial(DerivesArNB))]; }
1630 { int arr[T(__is_trivial(DerivesEmpty))]; }
1631 { int arr[T(__is_trivial(HasFunc))]; }
1632 { int arr[T(__is_trivial(HasOp))]; }
1633 { int arr[T(__is_trivial(HasConv))]; }
1634 { int arr[T(__is_trivial(HasAssign))]; }
1635 { int arr[T(__is_trivial(HasAnonymousUnion))]; }
1636 { int arr[T(__is_trivial(HasPriv))]; }
1637 { int arr[T(__is_trivial(HasProt))]; }
1638 { int arr[T(__is_trivial(DerivesHasPriv))]; }
1639 { int arr[T(__is_trivial(DerivesHasProt))]; }
1640 { int arr[T(__is_trivial(Vector))]; }
1641 { int arr[T(__is_trivial(VectorExt))]; }
1643 { int arr[F(__is_trivial(HasCons))]; }
1644 { int arr[F(__is_trivial(HasCopyAssign))]; }
1645 { int arr[F(__is_trivial(HasMoveAssign))]; }
1646 { int arr[F(__is_trivial(HasDest))]; }
1647 { int arr[F(__is_trivial(HasRef))]; }
1648 { int arr[F(__is_trivial(HasNonPOD))]; }
1649 { int arr[F(__is_trivial(HasVirt))]; }
1650 { int arr[F(__is_trivial(DerivesHasCons))]; }
1651 { int arr[F(__is_trivial(DerivesHasCopyAssign))]; }
1652 { int arr[F(__is_trivial(DerivesHasMoveAssign))]; }
1653 { int arr[F(__is_trivial(DerivesHasDest))]; }
1654 { int arr[F(__is_trivial(DerivesHasRef))]; }
1655 { int arr[F(__is_trivial(DerivesHasVirt))]; }
1656 { int arr[F(__is_trivial(void))]; }
1657 { int arr[F(__is_trivial(cvoid))]; }
1662 { int arr[T(__is_trivially_copyable(int))]; }
1663 { int arr[T(__is_trivially_copyable(Enum))]; }
1664 { int arr[T(__is_trivially_copyable(POD))]; }
1665 { int arr[T(__is_trivially_copyable(Int))]; }
1666 { int arr[T(__is_trivially_copyable(IntAr))]; }
1667 { int arr[T(__is_trivially_copyable(IntArNB))]; }
1668 { int arr[T(__is_trivially_copyable(Statics))]; }
1669 { int arr[T(__is_trivially_copyable(Empty))]; }
1670 { int arr[T(__is_trivially_copyable(EmptyUnion))]; }
1671 { int arr[T(__is_trivially_copyable(Union))]; }
1672 { int arr[T(__is_trivially_copyable(Derives))]; }
1673 { int arr[T(__is_trivially_copyable(DerivesAr))]; }
1674 { int arr[T(__is_trivially_copyable(DerivesArNB))]; }
1675 { int arr[T(__is_trivially_copyable(DerivesEmpty))]; }
1676 { int arr[T(__is_trivially_copyable(HasFunc))]; }
1677 { int arr[T(__is_trivially_copyable(HasOp))]; }
1678 { int arr[T(__is_trivially_copyable(HasConv))]; }
1679 { int arr[T(__is_trivially_copyable(HasAssign))]; }
1680 { int arr[T(__is_trivially_copyable(HasAnonymousUnion))]; }
1681 { int arr[T(__is_trivially_copyable(HasPriv))]; }
1682 { int arr[T(__is_trivially_copyable(HasProt))]; }
1683 { int arr[T(__is_trivially_copyable(DerivesHasPriv))]; }
1684 { int arr[T(__is_trivially_copyable(DerivesHasProt))]; }
1685 { int arr[T(__is_trivially_copyable(Vector))]; }
1686 { int arr[T(__is_trivially_copyable(VectorExt))]; }
1687 { int arr[T(__is_trivially_copyable(HasCons))]; }
1688 { int arr[T(__is_trivially_copyable(HasRef))]; }
1689 { int arr[T(__is_trivially_copyable(HasNonPOD))]; }
1690 { int arr[T(__is_trivially_copyable(DerivesHasCons))]; }
1691 { int arr[T(__is_trivially_copyable(DerivesHasRef))]; }
1693 { int arr[F(__is_trivially_copyable(HasCopyAssign))]; }
1694 { int arr[F(__is_trivially_copyable(HasMoveAssign))]; }
1695 { int arr[F(__is_trivially_copyable(HasDest))]; }
1696 { int arr[F(__is_trivially_copyable(HasVirt))]; }
1697 { int arr[F(__is_trivially_copyable(DerivesHasCopyAssign))]; }
1698 { int arr[F(__is_trivially_copyable(DerivesHasMoveAssign))]; }
1699 { int arr[F(__is_trivially_copyable(DerivesHasDest))]; }
1700 { int arr[F(__is_trivially_copyable(DerivesHasVirt))]; }
1701 { int arr[F(__is_trivially_copyable(void))]; }
1702 { int arr[F(__is_trivially_copyable(cvoid))]; }
1704 { int arr[T((__is_trivially_constructible(int)))]; }
1705 { int arr[T((__is_trivially_constructible(int, int)))]; }
1706 { int arr[T((__is_trivially_constructible(int, float)))]; }
1707 { int arr[T((__is_trivially_constructible(int, int&)))]; }
1708 { int arr[T((__is_trivially_constructible(int, const int&)))]; }
1709 { int arr[T((__is_trivially_constructible(int, int)))]; }
1710 { int arr[T((__is_trivially_constructible(HasCopyAssign, HasCopyAssign)))]; }
1711 { int arr[T((__is_trivially_constructible(HasCopyAssign, const HasCopyAssign&)))]; }
1712 { int arr[T((__is_trivially_constructible(HasCopyAssign, HasCopyAssign&&)))]; }
1713 { int arr[T((__is_trivially_constructible(HasCopyAssign)))]; }
1714 { int arr[T((__is_trivially_constructible(NonTrivialDefault,
1716 { int arr[T((__is_trivially_constructible(NonTrivialDefault,
1718 { int arr[T((__is_trivially_constructible(AllDefaulted)))]; }
1719 { int arr[T((__is_trivially_constructible(AllDefaulted,
1721 { int arr[T((__is_trivially_constructible(AllDefaulted,
1724 { int arr[F((__is_trivially_constructible(int, int*)))]; }
1725 { int arr[F((__is_trivially_constructible(NonTrivialDefault)))]; }
1726 { int arr[F((__is_trivially_constructible(ThreeArgCtor, int*, char*, int&)))]; }
1727 { int arr[F((__is_trivially_constructible(AllDeleted)))]; }
1728 { int arr[F((__is_trivially_constructible(AllDeleted,
1730 { int arr[F((__is_trivially_constructible(AllDeleted,
1732 { int arr[F((__is_trivially_constructible(ExtDefaulted)))]; }
1733 { int arr[F((__is_trivially_constructible(ExtDefaulted,
1735 { int arr[F((__is_trivially_constructible(ExtDefaulted,
1738 { int arr[T((__is_trivially_assignable(int&, int)))]; }
1739 { int arr[T((__is_trivially_assignable(int&, int&)))]; }
1740 { int arr[T((__is_trivially_assignable(int&, int&&)))]; }
1741 { int arr[T((__is_trivially_assignable(int&, const int&)))]; }
1742 { int arr[T((__is_trivially_assignable(POD&, POD)))]; }
1743 { int arr[T((__is_trivially_assignable(POD&, POD&)))]; }
1744 { int arr[T((__is_trivially_assignable(POD&, POD&&)))]; }
1745 { int arr[T((__is_trivially_assignable(POD&, const POD&)))]; }
1746 { int arr[T((__is_trivially_assignable(int*&, int*)))]; }
1747 { int arr[T((__is_trivially_assignable(AllDefaulted,
1749 { int arr[T((__is_trivially_assignable(AllDefaulted,
1752 { int arr[F((__is_trivially_assignable(int*&, float*)))]; }
1753 { int arr[F((__is_trivially_assignable(HasCopyAssign&, HasCopyAssign)))]; }
1754 { int arr[F((__is_trivially_assignable(HasCopyAssign&, HasCopyAssign&)))]; }
1755 { int arr[F((__is_trivially_assignable(HasCopyAssign&, const HasCopyAssign&)))]; }
1756 { int arr[F((__is_trivially_assignable(HasCopyAssign&, HasCopyAssign&&)))]; }
1757 { int arr[F((__is_trivially_assignable(TrivialMoveButNotCopy&,
1759 { int arr[F((__is_trivially_assignable(TrivialMoveButNotCopy&,
1761 { int arr[F((__is_trivially_assignable(AllDeleted,
1763 { int arr[F((__is_trivially_assignable(AllDeleted,
1765 { int arr[F((__is_trivially_assignable(ExtDefaulted,
1767 { int arr[F((__is_trivially_assignable(ExtDefaulted,
1770 { int arr[T((__is_trivially_assignable(HasDefaultTrivialCopyAssign&,
1772 { int arr[T((__is_trivially_assignable(HasDefaultTrivialCopyAssign&,
1774 { int arr[T((__is_trivially_assignable(TrivialMoveButNotCopy&,
1776 { int arr[T((__is_trivially_assignable(TrivialMoveButNotCopy&,
1787 { int arr[T((is_trivially_constructible<int>::value))]; }
1788 { int arr[T((is_trivially_constructible<int, int>::value))]; }
1789 { int arr[T((is_trivially_constructible<int, float>::value))]; }
1790 { int arr[T((is_trivially_constructible<int, int&>::value))]; }
1791 { int arr[T((is_trivially_constructible<int, const int&>::value))]; }
1792 { int arr[T((is_trivially_constructible<int, int>::value))]; }
1793 { int arr[T((is_trivially_constructible<HasCopyAssign, HasCopyAssign>::value))]; }
1794 { int arr[T((is_trivially_constructible<HasCopyAssign, const HasCopyAssign&>::value))]; }
1795 { int arr[T((is_trivially_constructible<HasCopyAssign, HasCopyAssign&&>::value))]; }
1796 { int arr[T((is_trivially_constructible<HasCopyAssign>::value))]; }
1797 { int arr[T((is_trivially_constructible<NonTrivialDefault,
1799 { int arr[T((is_trivially_constructible<NonTrivialDefault,
1802 { int arr[F((is_trivially_constructible<int, int*>::value))]; }
1803 { int arr[F((is_trivially_constructible<NonTrivialDefault>::value))]; }
1804 { int arr[F((is_trivially_constructible<ThreeArgCtor, int*, char*, int&>::value))]; }