gcc/testsuite/g++.dg/cpp0x/rv4p.C

   1 // I, Howard Hinnant, hereby place this code in the public domain.
   2
   3 // Test overlaod resolution among referece types
   4
   5 // { dg-do compile }
   6 // { dg-options "-std=c++0x" }
   7
   8 template <bool> struct sa;
   9 template <> struct sa<true> {};
  10
  11 struct one   {char x[1];};
  12 struct two   {char x[2];};
  13 struct three {char x[3];};
  14 struct four  {char x[4];};
  15 struct five  {char x[5];};
  16 struct six   {char x[6];};
  17 struct seven {char x[7];};
  18 struct eight {char x[8];};
  19
  20 struct A
  21 {
  22     A();
  23     A(const volatile A&&);
  24 };
  25
  26                A    source();
  27 const          A  c_source();
  28       volatile A  v_source();
  29 const volatile A cv_source();
  30
  31 // 4 at a time
  32
  33 one   sink_4_1234(               A&);
  34 two   sink_4_1234(const          A&);
  35 three sink_4_1234(volatile       A&);
  36 four  sink_4_1234(const volatile A&);
  37
  38 int test4_1234()
  39 {
  40                    A a;
  41     const          A ca = a;
  42           volatile A va;
  43     const volatile A cva = a;
  44     sa<sizeof(sink_4_1234(a))           == 1> t1;
  45     sa<sizeof(sink_4_1234(ca))          == 2> t2;
  46     sa<sizeof(sink_4_1234(va))          == 3> t3;
  47     sa<sizeof(sink_4_1234(cva))         == 4> t4;
  48     sa<sizeof(sink_4_1234(source()))    == 2> t5;
  49     sa<sizeof(sink_4_1234(c_source()))  == 2> t6;
  50     return 0;
  51 }
  52
  53 one   sink_4_1235(               A&);
  54 two   sink_4_1235(const          A&);
  55 three sink_4_1235(volatile       A&);
  56 five  sink_4_1235(               A&&);
  57
  58 int test4_1235()
  59 {
  60                    A a;
  61     const          A ca = a;
  62           volatile A va;
  63     const volatile A cva = a;
  64     sa<sizeof(sink_4_1235(a))           == 1> t1;
  65     sa<sizeof(sink_4_1235(ca))          == 2> t2;
  66     sa<sizeof(sink_4_1235(va))          == 3> t3;
  67     sa<sizeof(sink_4_1235(source()))    == 5> t5;
  68     sa<sizeof(sink_4_1235(c_source()))  == 2> t6;
  69     return 0;
  70 }
  71
  72 one   sink_4_1236(               A&);
  73 two   sink_4_1236(const          A&);
  74 three sink_4_1236(volatile       A&);
  75 six   sink_4_1236(const          A&&);
  76
  77 int test4_1236()
  78 {
  79                    A a;
  80     const          A ca = a;
  81           volatile A va;
  82     const volatile A cva = a;
  83     sa<sizeof(sink_4_1236(a))           == 1> t1;
  84     sa<sizeof(sink_4_1236(ca))          == 2> t2;
  85     sa<sizeof(sink_4_1236(va))          == 3> t3;
  86     sa<sizeof(sink_4_1236(source()))    == 6> t5;
  87     sa<sizeof(sink_4_1236(c_source()))  == 6> t6;
  88     return 0;
  89 }
  90
  91 one   sink_4_1237(               A&);
  92 two   sink_4_1237(const          A&);
  93 three sink_4_1237(volatile       A&);
  94 seven sink_4_1237(volatile       A&&);
  95
  96 int test4_1237()
  97 {
  98                    A a;
  99     const          A ca = a;
 100           volatile A va;
 101     const volatile A cva = a;
 102     sa<sizeof(sink_4_1237(a))           == 1> t1;
 103     sa<sizeof(sink_4_1237(ca))          == 2> t2;
 104     sa<sizeof(sink_4_1237(va))          == 3> t3;
 105     sa<sizeof(sink_4_1237(source()))    == 7> t5;
 106     sa<sizeof(sink_4_1237(c_source()))  == 2> t6;
 107     sa<sizeof(sink_4_1237(v_source()))  == 7> t7;
 108     return 0;
 109 }
 110
 111 one   sink_4_1238(               A&);
 112 two   sink_4_1238(const          A&);
 113 three sink_4_1238(volatile       A&);
 114 eight sink_4_1238(const volatile A&&);
 115
 116 int test4_1238()
 117 {
 118                    A a;
 119     const          A ca = a;
 120           volatile A va;
 121     const volatile A cva = a;
 122     sa<sizeof(sink_4_1238(a))           == 1> t1;
 123     sa<sizeof(sink_4_1238(ca))          == 2> t2;
 124     sa<sizeof(sink_4_1238(va))          == 3> t3;
 125     sa<sizeof(sink_4_1238(cva))         == 8> t4;
 126     sa<sizeof(sink_4_1238(source()))    == 8> t5;
 127     sa<sizeof(sink_4_1238(c_source()))  == 8> t6;
 128     sa<sizeof(sink_4_1238(v_source()))  == 8> t7;
 129     sa<sizeof(sink_4_1238(cv_source())) == 8> t8;
 130     return 0;
 131 }
 132
 133 one   sink_4_1245(               A&);
 134 two   sink_4_1245(const          A&);
 135 four  sink_4_1245(const volatile A&);
 136 five  sink_4_1245(               A&&);
 137
 138 int test4_1245()
 139 {
 140                    A a;
 141     const          A ca = a;
 142           volatile A va;
 143     const volatile A cva = a;
 144     sa<sizeof(sink_4_1245(a))           == 1> t1;
 145     sa<sizeof(sink_4_1245(ca))          == 2> t2;
 146     sa<sizeof(sink_4_1245(va))          == 4> t3;
 147     sa<sizeof(sink_4_1245(cva))         == 4> t4;
 148     sa<sizeof(sink_4_1245(source()))    == 5> t5;
 149     sa<sizeof(sink_4_1245(c_source()))  == 2> t6;
 150     return 0;
 151 }
 152
 153 one   sink_4_1246(               A&);
 154 two   sink_4_1246(const          A&);
 155 four  sink_4_1246(const volatile A&);
 156 six   sink_4_1246(const          A&&);
 157
 158 int test4_1246()
 159 {
 160                    A a;
 161     const          A ca = a;
 162           volatile A va;
 163     const volatile A cva = a;
 164     sa<sizeof(sink_4_1246(a))           == 1> t1;
 165     sa<sizeof(sink_4_1246(ca))          == 2> t2;
 166     sa<sizeof(sink_4_1246(va))          == 4> t3;
 167     sa<sizeof(sink_4_1246(cva))         == 4> t4;
 168     sa<sizeof(sink_4_1246(source()))    == 6> t5;
 169     sa<sizeof(sink_4_1246(c_source()))  == 6> t6;
 170     return 0;
 171 }
 172
 173 one   sink_4_1247(               A&);
 174 two   sink_4_1247(const          A&);
 175 four  sink_4_1247(const volatile A&);
 176 seven sink_4_1247(volatile       A&&);
 177
 178 int test4_1247()
 179 {
 180                    A a;
 181     const          A ca = a;
 182           volatile A va;
 183     const volatile A cva = a;
 184     sa<sizeof(sink_4_1247(a))           == 1> t1;
 185     sa<sizeof(sink_4_1247(ca))          == 2> t2;
 186     sa<sizeof(sink_4_1247(va))          == 4> t3;
 187     sa<sizeof(sink_4_1247(cva))         == 4> t4;
 188     sa<sizeof(sink_4_1247(source()))    == 7> t5;
 189     sa<sizeof(sink_4_1247(c_source()))  == 2> t6;
 190     sa<sizeof(sink_4_1247(v_source()))  == 7> t7;
 191     return 0;
 192 }
 193
 194 one   sink_4_1248(               A&);
 195 two   sink_4_1248(const          A&);
 196 four  sink_4_1248(const volatile A&);
 197 eight sink_4_1248(const volatile A&&);
 198
 199 int test4_1248()
 200 {
 201                    A a;
 202     const          A ca = a;
 203           volatile A va;
 204     const volatile A cva = a;
 205     sa<sizeof(sink_4_1248(a))           == 1> t1;
 206     sa<sizeof(sink_4_1248(ca))          == 2> t2;
 207     sa<sizeof(sink_4_1248(va))          == 4> t3;
 208     sa<sizeof(sink_4_1248(cva))         == 4> t4;
 209     sa<sizeof(sink_4_1248(source()))    == 8> t5;
 210     sa<sizeof(sink_4_1248(c_source()))  == 8> t6;
 211     sa<sizeof(sink_4_1248(v_source()))  == 8> t7;
 212     sa<sizeof(sink_4_1248(cv_source())) == 8> t8;
 213     return 0;
 214 }
 215
 216 one   sink_4_1256(               A&);
 217 two   sink_4_1256(const          A&);
 218 five  sink_4_1256(               A&&);
 219 six   sink_4_1256(const          A&&);
 220
 221 int test4_1256()
 222 {
 223                    A a;
 224     const          A ca = a;
 225           volatile A va;
 226     const volatile A cva = a;
 227     sa<sizeof(sink_4_1256(a))           == 1> t1;
 228     sa<sizeof(sink_4_1256(ca))          == 2> t2;
 229     sa<sizeof(sink_4_1256(source()))    == 5> t5;
 230     sa<sizeof(sink_4_1256(c_source()))  == 6> t6;
 231     return 0;
 232 }
 233
 234 one   sink_4_1257(               A&);
 235 two   sink_4_1257(const          A&);
 236 five  sink_4_1257(               A&&);
 237 seven sink_4_1257(volatile       A&&);
 238
 239 int test4_1257()
 240 {
 241                    A a;
 242     const          A ca = a;
 243           volatile A va;
 244     const volatile A cva = a;
 245     sa<sizeof(sink_4_1257(a))           == 1> t1;
 246     sa<sizeof(sink_4_1257(ca))          == 2> t2;
 247     sa<sizeof(sink_4_1257(va))          == 7> t3;
 248     sa<sizeof(sink_4_1257(source()))    == 5> t5;
 249     sa<sizeof(sink_4_1257(c_source()))  == 2> t6;
 250     sa<sizeof(sink_4_1257(v_source()))  == 7> t7;
 251     return 0;
 252 }
 253
 254 one   sink_4_1258(               A&);
 255 two   sink_4_1258(const          A&);
 256 five  sink_4_1258(               A&&);
 257 eight sink_4_1258(const volatile A&&);
 258
 259 int test4_1258()
 260 {
 261                    A a;
 262     const          A ca = a;
 263           volatile A va;
 264     const volatile A cva = a;
 265     sa<sizeof(sink_4_1258(a))           == 1> t1;
 266     sa<sizeof(sink_4_1258(ca))          == 2> t2;
 267     sa<sizeof(sink_4_1258(va))          == 8> t3;
 268     sa<sizeof(sink_4_1258(cva))         == 8> t4;
 269     sa<sizeof(sink_4_1258(source()))    == 5> t5;
 270     sa<sizeof(sink_4_1258(c_source()))  == 8> t6;
 271     sa<sizeof(sink_4_1258(v_source()))  == 8> t7;
 272     sa<sizeof(sink_4_1258(cv_source())) == 8> t8;
 273     return 0;
 274 }
 275
 276 one   sink_4_1267(               A&);
 277 two   sink_4_1267(const          A&);
 278 six   sink_4_1267(const          A&&);
 279 seven sink_4_1267(volatile       A&&);
 280
 281 int test4_1267()
 282 {
 283                    A a;
 284     const          A ca = a;
 285           volatile A va;
 286     const volatile A cva = a;
 287     sa<sizeof(sink_4_1267(a))           == 1> t1;
 288     sa<sizeof(sink_4_1267(ca))          == 2> t2;
 289     sa<sizeof(sink_4_1267(va))          == 7> t3;
 290     sa<sizeof(sink_4_1267(c_source()))  == 6> t6;
 291     sa<sizeof(sink_4_1267(v_source()))  == 7> t7;
 292     return 0;
 293 }
 294
 295 one   sink_4_1268(               A&);
 296 two   sink_4_1268(const          A&);
 297 six   sink_4_1268(const          A&&);
 298 eight sink_4_1268(const volatile A&&);
 299
 300 int test4_1268()
 301 {
 302                    A a;
 303     const          A ca = a;
 304           volatile A va;
 305     const volatile A cva = a;
 306     sa<sizeof(sink_4_1268(a))           == 1> t1;
 307     sa<sizeof(sink_4_1268(ca))          == 2> t2;
 308     sa<sizeof(sink_4_1268(va))          == 8> t3;
 309     sa<sizeof(sink_4_1268(cva))         == 8> t4;
 310     sa<sizeof(sink_4_1268(source()))    == 6> t5;
 311     sa<sizeof(sink_4_1268(c_source()))  == 6> t6;
 312     sa<sizeof(sink_4_1268(v_source()))  == 8> t7;
 313     sa<sizeof(sink_4_1268(cv_source())) == 8> t8;
 314     return 0;
 315 }
 316
 317 one   sink_4_1278(               A&);
 318 two   sink_4_1278(const          A&);
 319 seven sink_4_1278(volatile       A&&);
 320 eight sink_4_1278(const volatile A&&);
 321
 322 int test4_1278()
 323 {
 324                    A a;
 325     const          A ca = a;
 326           volatile A va;
 327     const volatile A cva = a;
 328     sa<sizeof(sink_4_1278(a))           == 1> t1;
 329     sa<sizeof(sink_4_1278(ca))          == 2> t2;
 330     sa<sizeof(sink_4_1278(va))          == 7> t3;
 331     sa<sizeof(sink_4_1278(cva))         == 8> t4;
 332     sa<sizeof(sink_4_1278(source()))    == 7> t5;
 333     sa<sizeof(sink_4_1278(c_source()))  == 8> t6;
 334     sa<sizeof(sink_4_1278(v_source()))  == 7> t7;
 335     sa<sizeof(sink_4_1278(cv_source())) == 8> t8;
 336     return 0;
 337 }
 338
 339 one   sink_4_1345(               A&);
 340 three sink_4_1345(volatile       A&);
 341 four  sink_4_1345(const volatile A&);
 342 five  sink_4_1345(               A&&);
 343
 344 int test4_1345()
 345 {
 346                    A a;
 347     const          A ca = a;
 348           volatile A va;
 349     const volatile A cva = a;
 350     sa<sizeof(sink_4_1345(a))           == 1> t1;
 351     sa<sizeof(sink_4_1345(ca))          == 4> t2;
 352     sa<sizeof(sink_4_1345(va))          == 3> t3;
 353     sa<sizeof(sink_4_1345(cva))         == 4> t4;
 354     sa<sizeof(sink_4_1345(source()))    == 5> t5;
 355     return 0;
 356 }
 357
 358 one   sink_4_1346(               A&);
 359 three sink_4_1346(volatile       A&);
 360 four  sink_4_1346(const volatile A&);
 361 six   sink_4_1346(const          A&&);
 362
 363 int test4_1346()
 364 {
 365                    A a;
 366     const          A ca = a;
 367           volatile A va;
 368     const volatile A cva = a;
 369     sa<sizeof(sink_4_1346(a))           == 1> t1;
 370     sa<sizeof(sink_4_1346(ca))          == 4> t2;
 371     sa<sizeof(sink_4_1346(va))          == 3> t3;
 372     sa<sizeof(sink_4_1346(cva))         == 4> t4;
 373     sa<sizeof(sink_4_1346(source()))    == 6> t5;
 374     sa<sizeof(sink_4_1346(c_source()))  == 6> t6;
 375     return 0;
 376 }
 377
 378 one   sink_4_1347(               A&);
 379 three sink_4_1347(volatile       A&);
 380 four  sink_4_1347(const volatile A&);
 381 seven sink_4_1347(volatile       A&&);
 382
 383 int test4_1347()
 384 {
 385                    A a;
 386     const          A ca = a;
 387           volatile A va;
 388     const volatile A cva = a;
 389     sa<sizeof(sink_4_1347(a))           == 1> t1;
 390     sa<sizeof(sink_4_1347(ca))          == 4> t2;
 391     sa<sizeof(sink_4_1347(va))          == 3> t3;
 392     sa<sizeof(sink_4_1347(cva))         == 4> t4;
 393     sa<sizeof(sink_4_1347(source()))    == 7> t5;
 394     sa<sizeof(sink_4_1347(v_source()))  == 7> t7;
 395     return 0;
 396 }
 397
 398 one   sink_4_1348(               A&);
 399 three sink_4_1348(volatile       A&);
 400 four  sink_4_1348(const volatile A&);
 401 eight sink_4_1348(const volatile A&&);
 402
 403 int test4_1348()
 404 {
 405                    A a;
 406     const          A ca = a;
 407           volatile A va;
 408     const volatile A cva = a;
 409     sa<sizeof(sink_4_1348(a))           == 1> t1;
 410     sa<sizeof(sink_4_1348(ca))          == 4> t2;
 411     sa<sizeof(sink_4_1348(va))          == 3> t3;
 412     sa<sizeof(sink_4_1348(cva))         == 4> t4;
 413     sa<sizeof(sink_4_1348(source()))    == 8> t5;
 414     sa<sizeof(sink_4_1348(c_source()))  == 8> t6;
 415     sa<sizeof(sink_4_1348(v_source()))  == 8> t7;
 416     sa<sizeof(sink_4_1348(cv_source())) == 8> t8;
 417     return 0;
 418 }
 419
 420 one   sink_4_1356(               A&);
 421 three sink_4_1356(volatile       A&);
 422 five  sink_4_1356(               A&&);
 423 six   sink_4_1356(const          A&&);
 424
 425 int test4_1356()
 426 {
 427                    A a;
 428     const          A ca = a;
 429           volatile A va;
 430     const volatile A cva = a;
 431     sa<sizeof(sink_4_1356(a))           == 1> t1;
 432     sa<sizeof(sink_4_1356(ca))          == 6> t2;
 433     sa<sizeof(sink_4_1356(va))          == 3> t3;
 434     sa<sizeof(sink_4_1356(source()))    == 5> t5;
 435     sa<sizeof(sink_4_1356(c_source()))  == 6> t6;
 436     return 0;
 437 }
 438
 439 one   sink_4_1357(               A&);
 440 three sink_4_1357(volatile       A&);
 441 five  sink_4_1357(               A&&);
 442 seven sink_4_1357(volatile       A&&);
 443
 444 int test4_1357()
 445 {
 446                    A a;
 447     const          A ca = a;
 448           volatile A va;
 449     const volatile A cva = a;
 450     sa<sizeof(sink_4_1357(a))           == 1> t1;
 451     sa<sizeof(sink_4_1357(va))          == 3> t3;
 452     sa<sizeof(sink_4_1357(source()))    == 5> t5;
 453     sa<sizeof(sink_4_1357(v_source()))  == 7> t7;
 454     return 0;
 455 }
 456
 457 one   sink_4_1358(               A&);
 458 three sink_4_1358(volatile       A&);
 459 five  sink_4_1358(               A&&);
 460 eight sink_4_1358(const volatile A&&);
 461
 462 int test4_1358()
 463 {
 464                    A a;
 465     const          A ca = a;
 466           volatile A va;
 467     const volatile A cva = a;
 468     sa<sizeof(sink_4_1358(a))           == 1> t1;
 469     sa<sizeof(sink_4_1358(ca))          == 8> t2;
 470     sa<sizeof(sink_4_1358(va))          == 3> t3;
 471     sa<sizeof(sink_4_1358(cva))         == 8> t4;
 472     sa<sizeof(sink_4_1358(source()))    == 5> t5;
 473     sa<sizeof(sink_4_1358(c_source()))  == 8> t6;
 474     sa<sizeof(sink_4_1358(v_source()))  == 8> t7;
 475     sa<sizeof(sink_4_1358(cv_source())) == 8> t8;
 476     return 0;
 477 }
 478
 479 one   sink_4_1367(               A&);
 480 three sink_4_1367(volatile       A&);
 481 six   sink_4_1367(const          A&&);
 482 seven sink_4_1367(volatile       A&&);
 483
 484 int test4_1367()
 485 {
 486                    A a;
 487     const          A ca = a;
 488           volatile A va;
 489     const volatile A cva = a;
 490     sa<sizeof(sink_4_1367(a))           == 1> t1;
 491     sa<sizeof(sink_4_1367(ca))          == 6> t2;
 492     sa<sizeof(sink_4_1367(va))          == 3> t3;
 493     sa<sizeof(sink_4_1367(c_source()))  == 6> t6;
 494     sa<sizeof(sink_4_1367(v_source()))  == 7> t7;
 495     return 0;
 496 }
 497
 498 one   sink_4_1368(               A&);
 499 three sink_4_1368(volatile       A&);
 500 six   sink_4_1368(const          A&&);
 501 eight sink_4_1368(const volatile A&&);
 502
 503 int test4_1368()
 504 {
 505                    A a;
 506     const          A ca = a;
 507           volatile A va;
 508     const volatile A cva = a;
 509     sa<sizeof(sink_4_1368(a))           == 1> t1;
 510     sa<sizeof(sink_4_1368(ca))          == 6> t2;
 511     sa<sizeof(sink_4_1368(va))          == 3> t3;
 512     sa<sizeof(sink_4_1368(cva))         == 8> t4;
 513     sa<sizeof(sink_4_1368(source()))    == 6> t5;
 514     sa<sizeof(sink_4_1368(c_source()))  == 6> t6;
 515     sa<sizeof(sink_4_1368(v_source()))  == 8> t7;
 516     sa<sizeof(sink_4_1368(cv_source())) == 8> t8;
 517     return 0;
 518 }
 519
 520 one   sink_4_1378(               A&);
 521 three sink_4_1378(volatile       A&);
 522 seven sink_4_1378(volatile       A&&);
 523 eight sink_4_1378(const volatile A&&);
 524
 525 int test4_1378()
 526 {
 527                    A a;
 528     const          A ca = a;
 529           volatile A va;
 530     const volatile A cva = a;
 531     sa<sizeof(sink_4_1378(a))           == 1> t1;
 532     sa<sizeof(sink_4_1378(ca))          == 8> t2;
 533     sa<sizeof(sink_4_1378(va))          == 3> t3;
 534     sa<sizeof(sink_4_1378(cva))         == 8> t4;
 535     sa<sizeof(sink_4_1378(source()))    == 7> t5;
 536     sa<sizeof(sink_4_1378(c_source()))  == 8> t6;
 537     sa<sizeof(sink_4_1378(v_source()))  == 7> t7;
 538     sa<sizeof(sink_4_1378(cv_source())) == 8> t8;
 539     return 0;
 540 }
 541
 542 one   sink_4_1456(               A&);
 543 four  sink_4_1456(const volatile A&);
 544 five  sink_4_1456(               A&&);
 545 six   sink_4_1456(const          A&&);
 546
 547 int test4_1456()
 548 {
 549                    A a;
 550     const          A ca = a;
 551           volatile A va;
 552     const volatile A cva = a;
 553     sa<sizeof(sink_4_1456(a))           == 1> t1;
 554     sa<sizeof(sink_4_1456(ca))          == 4> t2;
 555     sa<sizeof(sink_4_1456(va))          == 4> t3;
 556     sa<sizeof(sink_4_1456(cva))         == 4> t4;
 557     sa<sizeof(sink_4_1456(source()))    == 5> t5;
 558     sa<sizeof(sink_4_1456(c_source()))  == 6> t6;
 559     return 0;
 560 }
 561
 562 one   sink_4_1457(               A&);
 563 four  sink_4_1457(const volatile A&);
 564 five  sink_4_1457(               A&&);
 565 seven sink_4_1457(volatile       A&&);
 566
 567 int test4_1457()
 568 {
 569                    A a;
 570     const          A ca = a;
 571           volatile A va;
 572     const volatile A cva = a;
 573     sa<sizeof(sink_4_1457(a))           == 1> t1;
 574     sa<sizeof(sink_4_1457(ca))          == 4> t2;
 575     sa<sizeof(sink_4_1457(va))          == 4> t3;
 576     sa<sizeof(sink_4_1457(cva))         == 4> t4;
 577     sa<sizeof(sink_4_1457(source()))    == 5> t5;
 578     sa<sizeof(sink_4_1457(v_source()))  == 7> t7;
 579     return 0;
 580 }
 581
 582 one   sink_4_1458(               A&);
 583 four  sink_4_1458(const volatile A&);
 584 five  sink_4_1458(               A&&);
 585 eight sink_4_1458(const volatile A&&);
 586
 587 int test4_1458()
 588 {
 589                    A a;
 590     const          A ca = a;
 591           volatile A va;
 592     const volatile A cva = a;
 593     sa<sizeof(sink_4_1458(a))           == 1> t1;
 594     sa<sizeof(sink_4_1458(ca))          == 4> t2;
 595     sa<sizeof(sink_4_1458(va))          == 4> t3;
 596     sa<sizeof(sink_4_1458(cva))         == 4> t4;
 597     sa<sizeof(sink_4_1458(source()))    == 5> t5;
 598     sa<sizeof(sink_4_1458(c_source()))  == 8> t6;
 599     sa<sizeof(sink_4_1458(v_source()))  == 8> t7;
 600     sa<sizeof(sink_4_1458(cv_source())) == 8> t8;
 601     return 0;
 602 }
 603
 604 one   sink_4_1467(               A&);
 605 four  sink_4_1467(const volatile A&);
 606 six   sink_4_1467(const          A&&);
 607 seven sink_4_1467(volatile       A&&);
 608
 609 int test4_1467()
 610 {
 611                    A a;
 612     const          A ca = a;
 613           volatile A va;
 614     const volatile A cva = a;
 615     sa<sizeof(sink_4_1467(a))           == 1> t1;
 616     sa<sizeof(sink_4_1467(ca))          == 4> t2;
 617     sa<sizeof(sink_4_1467(va))          == 4> t3;
 618     sa<sizeof(sink_4_1467(cva))         == 4> t4;
 619     sa<sizeof(sink_4_1467(c_source()))  == 6> t6;
 620     sa<sizeof(sink_4_1467(v_source()))  == 7> t7;
 621     return 0;
 622 }
 623
 624 one   sink_4_1468(               A&);
 625 four  sink_4_1468(const volatile A&);
 626 six   sink_4_1468(const          A&&);
 627 eight sink_4_1468(const volatile A&&);
 628
 629 int test4_1468()
 630 {
 631                    A a;
 632     const          A ca = a;
 633           volatile A va;
 634     const volatile A cva = a;
 635     sa<sizeof(sink_4_1468(a))           == 1> t1;
 636     sa<sizeof(sink_4_1468(ca))          == 4> t2;
 637     sa<sizeof(sink_4_1468(va))          == 4> t3;
 638     sa<sizeof(sink_4_1468(cva))         == 4> t4;
 639     sa<sizeof(sink_4_1468(source()))    == 6> t5;
 640     sa<sizeof(sink_4_1468(c_source()))  == 6> t6;
 641     sa<sizeof(sink_4_1468(v_source()))  == 8> t7;
 642     sa<sizeof(sink_4_1468(cv_source())) == 8> t8;
 643     return 0;
 644 }
 645
 646 one   sink_4_1478(               A&);
 647 four  sink_4_1478(const volatile A&);
 648 seven sink_4_1478(volatile       A&&);
 649 eight sink_4_1478(const volatile A&&);
 650
 651 int test4_1478()
 652 {
 653                    A a;
 654     const          A ca = a;
 655           volatile A va;
 656     const volatile A cva = a;
 657     sa<sizeof(sink_4_1478(a))           == 1> t1;
 658     sa<sizeof(sink_4_1478(ca))          == 4> t2;
 659     sa<sizeof(sink_4_1478(va))          == 4> t3;
 660     sa<sizeof(sink_4_1478(cva))         == 4> t4;
 661     sa<sizeof(sink_4_1478(source()))    == 7> t5;
 662     sa<sizeof(sink_4_1478(c_source()))  == 8> t6;
 663     sa<sizeof(sink_4_1478(v_source()))  == 7> t7;
 664     sa<sizeof(sink_4_1478(cv_source())) == 8> t8;
 665     return 0;
 666 }
 667
 668 one   sink_4_1567(               A&);
 669 five  sink_4_1567(               A&&);
 670 six   sink_4_1567(const          A&&);
 671 seven sink_4_1567(volatile       A&&);
 672
 673 int test4_1567()
 674 {
 675                    A a;
 676     const          A ca = a;
 677           volatile A va;
 678     const volatile A cva = a;
 679     sa<sizeof(sink_4_1567(a))           == 1> t1;
 680     sa<sizeof(sink_4_1567(ca))          == 6> t2;
 681     sa<sizeof(sink_4_1567(va))          == 7> t3;
 682     sa<sizeof(sink_4_1567(source()))    == 5> t5;
 683     sa<sizeof(sink_4_1567(c_source()))  == 6> t6;
 684     sa<sizeof(sink_4_1567(v_source()))  == 7> t7;
 685     return 0;
 686 }
 687
 688 one   sink_4_1568(               A&);
 689 five  sink_4_1568(               A&&);
 690 six   sink_4_1568(const          A&&);
 691 eight sink_4_1568(const volatile A&&);
 692
 693 int test4_1568()
 694 {
 695                    A a;
 696     const          A ca = a;
 697           volatile A va;
 698     const volatile A cva = a;
 699     sa<sizeof(sink_4_1568(a))           == 1> t1;
 700     sa<sizeof(sink_4_1568(ca))          == 6> t2;
 701     sa<sizeof(sink_4_1568(va))          == 8> t3;
 702     sa<sizeof(sink_4_1568(cva))         == 8> t4;
 703     sa<sizeof(sink_4_1568(source()))    == 5> t5;
 704     sa<sizeof(sink_4_1568(c_source()))  == 6> t6;
 705     sa<sizeof(sink_4_1568(v_source()))  == 8> t7;
 706     sa<sizeof(sink_4_1568(cv_source())) == 8> t8;
 707     return 0;
 708 }
 709
 710 one   sink_4_1578(               A&);
 711 five  sink_4_1578(               A&&);
 712 seven sink_4_1578(volatile       A&&);
 713 eight sink_4_1578(const volatile A&&);
 714
 715 int test4_1578()
 716 {
 717                    A a;
 718     const          A ca = a;
 719           volatile A va;
 720     const volatile A cva = a;
 721     sa<sizeof(sink_4_1578(a))           == 1> t1;
 722     sa<sizeof(sink_4_1578(ca))          == 8> t2;
 723     sa<sizeof(sink_4_1578(va))          == 7> t3;
 724     sa<sizeof(sink_4_1578(cva))         == 8> t4;
 725     sa<sizeof(sink_4_1578(source()))    == 5> t5;
 726     sa<sizeof(sink_4_1578(c_source()))  == 8> t6;
 727     sa<sizeof(sink_4_1578(v_source()))  == 7> t7;
 728     sa<sizeof(sink_4_1578(cv_source())) == 8> t8;
 729     return 0;
 730 }
 731
 732 one   sink_4_1678(               A&);
 733 six   sink_4_1678(const          A&&);
 734 seven sink_4_1678(volatile       A&&);
 735 eight sink_4_1678(const volatile A&&);
 736
 737 int test4_1678()
 738 {
 739                    A a;
 740     const          A ca = a;
 741           volatile A va;
 742     const volatile A cva = a;
 743     sa<sizeof(sink_4_1678(a))           == 1> t1;
 744     sa<sizeof(sink_4_1678(ca))          == 6> t2;
 745     sa<sizeof(sink_4_1678(va))          == 7> t3;
 746     sa<sizeof(sink_4_1678(cva))         == 8> t4;
 747     sa<sizeof(sink_4_1678(c_source()))  == 6> t6;
 748     sa<sizeof(sink_4_1678(v_source()))  == 7> t7;
 749     sa<sizeof(sink_4_1678(cv_source())) == 8> t8;
 750     return 0;
 751 }
 752
 753 two   sink_4_2345(const          A&);
 754 three sink_4_2345(volatile       A&);
 755 four  sink_4_2345(const volatile A&);
 756 five  sink_4_2345(               A&&);
 757
 758 int test4_2345()
 759 {
 760                    A a;
 761     const          A ca = a;
 762           volatile A va;
 763     const volatile A cva = a;
 764     sa<sizeof(sink_4_2345(ca))          == 2> t2;
 765     sa<sizeof(sink_4_2345(va))          == 3> t3;
 766     sa<sizeof(sink_4_2345(cva))         == 4> t4;
 767     sa<sizeof(sink_4_2345(source()))    == 5> t5;
 768     sa<sizeof(sink_4_2345(c_source()))  == 2> t6;
 769     return 0;
 770 }
 771
 772 two   sink_4_2346(const          A&);
 773 three sink_4_2346(volatile       A&);
 774 four  sink_4_2346(const volatile A&);
 775 six   sink_4_2346(const          A&&);
 776
 777 int test4_2346()
 778 {
 779                    A a;
 780     const          A ca = a;
 781           volatile A va;
 782     const volatile A cva = a;
 783     sa<sizeof(sink_4_2346(ca))          == 2> t2;
 784     sa<sizeof(sink_4_2346(va))          == 3> t3;
 785     sa<sizeof(sink_4_2346(cva))         == 4> t4;
 786     sa<sizeof(sink_4_2346(source()))    == 6> t5;
 787     sa<sizeof(sink_4_2346(c_source()))  == 6> t6;
 788     return 0;
 789 }
 790
 791 two   sink_4_2347(const          A&);
 792 three sink_4_2347(volatile       A&);
 793 four  sink_4_2347(const volatile A&);
 794 seven sink_4_2347(volatile       A&&);
 795
 796 int test4_2347()
 797 {
 798                    A a;
 799     const          A ca = a;
 800           volatile A va;
 801     const volatile A cva = a;
 802     sa<sizeof(sink_4_2347(ca))          == 2> t2;
 803     sa<sizeof(sink_4_2347(va))          == 3> t3;
 804     sa<sizeof(sink_4_2347(cva))         == 4> t4;
 805     sa<sizeof(sink_4_2347(source()))    == 7> t5;
 806     sa<sizeof(sink_4_2347(c_source()))  == 2> t6;
 807     sa<sizeof(sink_4_2347(v_source()))  == 7> t7;
 808     return 0;
 809 }
 810
 811 two   sink_4_2348(const          A&);
 812 three sink_4_2348(volatile       A&);
 813 four  sink_4_2348(const volatile A&);
 814 eight sink_4_2348(const volatile A&&);
 815
 816 int test4_2348()
 817 {
 818                    A a;
 819     const          A ca = a;
 820           volatile A va;
 821     const volatile A cva = a;
 822     sa<sizeof(sink_4_2348(ca))          == 2> t2;
 823     sa<sizeof(sink_4_2348(va))          == 3> t3;
 824     sa<sizeof(sink_4_2348(cva))         == 4> t4;
 825     sa<sizeof(sink_4_2348(source()))    == 8> t5;
 826     sa<sizeof(sink_4_2348(c_source()))  == 8> t6;
 827     sa<sizeof(sink_4_2348(v_source()))  == 8> t7;
 828     sa<sizeof(sink_4_2348(cv_source())) == 8> t8;
 829     return 0;
 830 }
 831
 832 two   sink_4_2356(const          A&);
 833 three sink_4_2356(volatile       A&);
 834 five  sink_4_2356(               A&&);
 835 six   sink_4_2356(const          A&&);
 836
 837 int test4_2356()
 838 {
 839                    A a;
 840     const          A ca = a;
 841           volatile A va;
 842     const volatile A cva = a;
 843     sa<sizeof(sink_4_2356(ca))          == 2> t2;
 844     sa<sizeof(sink_4_2356(va))          == 3> t3;
 845     sa<sizeof(sink_4_2356(source()))    == 5> t5;
 846     sa<sizeof(sink_4_2356(c_source()))  == 6> t6;
 847     return 0;
 848 }
 849
 850 two   sink_4_2357(const          A&);
 851 three sink_4_2357(volatile       A&);
 852 five  sink_4_2357(               A&&);
 853 seven sink_4_2357(volatile       A&&);
 854
 855 int test4_2357()
 856 {
 857                    A a;
 858     const          A ca = a;
 859           volatile A va;
 860     const volatile A cva = a;
 861     sa<sizeof(sink_4_2357(ca))          == 2> t2;
 862     sa<sizeof(sink_4_2357(va))          == 3> t3;
 863     sa<sizeof(sink_4_2357(source()))    == 5> t5;
 864     sa<sizeof(sink_4_2357(c_source()))  == 2> t6;
 865     sa<sizeof(sink_4_2357(v_source()))  == 7> t7;
 866     return 0;
 867 }
 868
 869 two   sink_4_2358(const          A&);
 870 three sink_4_2358(volatile       A&);
 871 five  sink_4_2358(               A&&);
 872 eight sink_4_2358(const volatile A&&);
 873
 874 int test4_2358()
 875 {
 876                    A a;
 877     const          A ca = a;
 878           volatile A va;
 879     const volatile A cva = a;
 880     sa<sizeof(sink_4_2358(ca))          == 2> t2;
 881     sa<sizeof(sink_4_2358(va))          == 3> t3;
 882     sa<sizeof(sink_4_2358(cva))         == 8> t4;
 883     sa<sizeof(sink_4_2358(source()))    == 5> t5;
 884     sa<sizeof(sink_4_2358(c_source()))  == 8> t6;
 885     sa<sizeof(sink_4_2358(v_source()))  == 8> t7;
 886     sa<sizeof(sink_4_2358(cv_source())) == 8> t8;
 887     return 0;
 888 }
 889
 890 two   sink_4_2367(const          A&);
 891 three sink_4_2367(volatile       A&);
 892 six   sink_4_2367(const          A&&);
 893 seven sink_4_2367(volatile       A&&);
 894
 895 int test4_2367()
 896 {
 897                    A a;
 898     const          A ca = a;
 899           volatile A va;
 900     const volatile A cva = a;
 901     sa<sizeof(sink_4_2367(ca))          == 2> t2;
 902     sa<sizeof(sink_4_2367(va))          == 3> t3;
 903     sa<sizeof(sink_4_2367(c_source()))  == 6> t6;
 904     sa<sizeof(sink_4_2367(v_source()))  == 7> t7;
 905     return 0;
 906 }
 907
 908 two   sink_4_2368(const          A&);
 909 three sink_4_2368(volatile       A&);
 910 six   sink_4_2368(const          A&&);
 911 eight sink_4_2368(const volatile A&&);
 912
 913 int test4_2368()
 914 {
 915                    A a;
 916     const          A ca = a;
 917           volatile A va;
 918     const volatile A cva = a;
 919     sa<sizeof(sink_4_2368(ca))          == 2> t2;
 920     sa<sizeof(sink_4_2368(va))          == 3> t3;
 921     sa<sizeof(sink_4_2368(cva))         == 8> t4;
 922     sa<sizeof(sink_4_2368(source()))    == 6> t5;
 923     sa<sizeof(sink_4_2368(c_source()))  == 6> t6;
 924     sa<sizeof(sink_4_2368(v_source()))  == 8> t7;
 925     sa<sizeof(sink_4_2368(cv_source())) == 8> t8;
 926     return 0;
 927 }
 928
 929 two   sink_4_2378(const          A&);
 930 three sink_4_2378(volatile       A&);
 931 seven sink_4_2378(volatile       A&&);
 932 eight sink_4_2378(const volatile A&&);
 933
 934 int test4_2378()
 935 {
 936                    A a;
 937     const          A ca = a;
 938           volatile A va;
 939     const volatile A cva = a;
 940     sa<sizeof(sink_4_2378(ca))          == 2> t2;
 941     sa<sizeof(sink_4_2378(va))          == 3> t3;
 942     sa<sizeof(sink_4_2378(cva))         == 8> t4;
 943     sa<sizeof(sink_4_2378(source()))    == 7> t5;
 944     sa<sizeof(sink_4_2378(c_source()))  == 8> t6;
 945     sa<sizeof(sink_4_2378(v_source()))  == 7> t7;
 946     sa<sizeof(sink_4_2378(cv_source())) == 8> t8;
 947     return 0;
 948 }
 949
 950 two   sink_4_2456(const          A&);
 951 four  sink_4_2456(const volatile A&);
 952 five  sink_4_2456(               A&&);
 953 six   sink_4_2456(const          A&&);
 954
 955 int test4_2456()
 956 {
 957                    A a;
 958     const          A ca = a;
 959           volatile A va;
 960     const volatile A cva = a;
 961     sa<sizeof(sink_4_2456(a))           == 2> t1;
 962     sa<sizeof(sink_4_2456(ca))          == 2> t2;
 963     sa<sizeof(sink_4_2456(va))          == 4> t3;
 964     sa<sizeof(sink_4_2456(cva))         == 4> t4;
 965     sa<sizeof(sink_4_2456(source()))    == 5> t5;
 966     sa<sizeof(sink_4_2456(c_source()))  == 6> t6;
 967     return 0;
 968 }
 969
 970 two   sink_4_2457(const          A&);
 971 four  sink_4_2457(const volatile A&);
 972 five  sink_4_2457(               A&&);
 973 seven sink_4_2457(volatile       A&&);
 974
 975 int test4_2457()
 976 {
 977                    A a;
 978     const          A ca = a;
 979           volatile A va;
 980     const volatile A cva = a;
 981     sa<sizeof(sink_4_2457(a))           == 2> t1;
 982     sa<sizeof(sink_4_2457(ca))          == 2> t2;
 983     sa<sizeof(sink_4_2457(va))          == 4> t3;
 984     sa<sizeof(sink_4_2457(cva))         == 4> t4;
 985     sa<sizeof(sink_4_2457(source()))    == 5> t5;
 986     sa<sizeof(sink_4_2457(c_source()))  == 2> t6;
 987     sa<sizeof(sink_4_2457(v_source()))  == 7> t7;
 988     return 0;
 989 }
 990
 991 two   sink_4_2458(const          A&);
 992 four  sink_4_2458(const volatile A&);
 993 five  sink_4_2458(               A&&);
 994 eight sink_4_2458(const volatile A&&);
 995
 996 int test4_2458()
 997 {
 998                    A a;
 999     const          A ca = a;
1000           volatile A va;
1001     const volatile A cva = a;
1002     sa<sizeof(sink_4_2458(a))           == 2> t1;
1003     sa<sizeof(sink_4_2458(ca))          == 2> t2;
1004     sa<sizeof(sink_4_2458(va))          == 4> t3;
1005     sa<sizeof(sink_4_2458(cva))         == 4> t4;
1006     sa<sizeof(sink_4_2458(source()))    == 5> t5;
1007     sa<sizeof(sink_4_2458(c_source()))  == 8> t6;
1008     sa<sizeof(sink_4_2458(v_source()))  == 8> t7;
1009     sa<sizeof(sink_4_2458(cv_source())) == 8> t8;
1010     return 0;
1011 }
1012
1013 two   sink_4_2467(const          A&);
1014 four  sink_4_2467(const volatile A&);
1015 six   sink_4_2467(const          A&&);
1016 seven sink_4_2467(volatile       A&&);
1017
1018 int test4_2467()
1019 {
1020                    A a;
1021     const          A ca = a;
1022           volatile A va;
1023     const volatile A cva = a;
1024     sa<sizeof(sink_4_2467(a))           == 2> t1;
1025     sa<sizeof(sink_4_2467(ca))          == 2> t2;
1026     sa<sizeof(sink_4_2467(va))          == 4> t3;
1027     sa<sizeof(sink_4_2467(cva))         == 4> t4;
1028     sa<sizeof(sink_4_2467(c_source()))  == 6> t6;
1029     sa<sizeof(sink_4_2467(v_source()))  == 7> t7;
1030     return 0;
1031 }
1032
1033 two   sink_4_2468(const          A&);
1034 four  sink_4_2468(const volatile A&);
1035 six   sink_4_2468(const          A&&);
1036 eight sink_4_2468(const volatile A&&);
1037
1038 int test4_2468()
1039 {
1040                    A a;
1041     const          A ca = a;
1042           volatile A va;
1043     const volatile A cva = a;
1044     sa<sizeof(sink_4_2468(a))           == 2> t1;
1045     sa<sizeof(sink_4_2468(ca))          == 2> t2;
1046     sa<sizeof(sink_4_2468(va))          == 4> t3;
1047     sa<sizeof(sink_4_2468(cva))         == 4> t4;
1048     sa<sizeof(sink_4_2468(source()))    == 6> t5;
1049     sa<sizeof(sink_4_2468(c_source()))  == 6> t6;
1050     sa<sizeof(sink_4_2468(v_source()))  == 8> t7;
1051     sa<sizeof(sink_4_2468(cv_source())) == 8> t8;
1052     return 0;
1053 }
1054
1055 two   sink_4_2478(const          A&);
1056 four  sink_4_2478(const volatile A&);
1057 seven sink_4_2478(volatile       A&&);
1058 eight sink_4_2478(const volatile A&&);
1059
1060 int test4_2478()
1061 {
1062                    A a;
1063     const          A ca = a;
1064           volatile A va;
1065     const volatile A cva = a;
1066     sa<sizeof(sink_4_2478(a))           == 2> t1;
1067     sa<sizeof(sink_4_2478(ca))          == 2> t2;
1068     sa<sizeof(sink_4_2478(va))          == 4> t3;
1069     sa<sizeof(sink_4_2478(cva))         == 4> t4;
1070     sa<sizeof(sink_4_2478(source()))    == 7> t5;
1071     sa<sizeof(sink_4_2478(c_source()))  == 8> t6;
1072     sa<sizeof(sink_4_2478(v_source()))  == 7> t7;
1073     sa<sizeof(sink_4_2478(cv_source())) == 8> t8;
1074     return 0;
1075 }
1076
1077 two   sink_4_2567(const          A&);
1078 five  sink_4_2567(               A&&);
1079 six   sink_4_2567(const          A&&);
1080 seven sink_4_2567(volatile       A&&);
1081
1082 int test4_2567()
1083 {
1084                    A a;
1085     const          A ca = a;
1086           volatile A va;
1087     const volatile A cva = a;
1088     sa<sizeof(sink_4_2567(a))           == 2> t1;
1089     sa<sizeof(sink_4_2567(ca))          == 2> t2;
1090     sa<sizeof(sink_4_2567(va))          == 7> t3;
1091     sa<sizeof(sink_4_2567(source()))    == 5> t5;
1092     sa<sizeof(sink_4_2567(c_source()))  == 6> t6;
1093     sa<sizeof(sink_4_2567(v_source()))  == 7> t7;
1094     return 0;
1095 }
1096
1097 two   sink_4_2568(const          A&);
1098 five  sink_4_2568(               A&&);
1099 six   sink_4_2568(const          A&&);
1100 eight sink_4_2568(const volatile A&&);
1101
1102 int test4_2568()
1103 {
1104                    A a;
1105     const          A ca = a;
1106           volatile A va;
1107     const volatile A cva = a;
1108     sa<sizeof(sink_4_2568(a))           == 2> t1;
1109     sa<sizeof(sink_4_2568(ca))          == 2> t2;
1110     sa<sizeof(sink_4_2568(va))          == 8> t3;
1111     sa<sizeof(sink_4_2568(cva))         == 8> t4;
1112     sa<sizeof(sink_4_2568(source()))    == 5> t5;
1113     sa<sizeof(sink_4_2568(c_source()))  == 6> t6;
1114     sa<sizeof(sink_4_2568(v_source()))  == 8> t7;
1115     sa<sizeof(sink_4_2568(cv_source())) == 8> t8;
1116     return 0;
1117 }
1118
1119 two   sink_4_2578(const          A&);
1120 five  sink_4_2578(               A&&);
1121 seven sink_4_2578(volatile       A&&);
1122 eight sink_4_2578(const volatile A&&);
1123
1124 int test4_2578()
1125 {
1126                    A a;
1127     const          A ca = a;
1128           volatile A va;
1129     const volatile A cva = a;
1130     sa<sizeof(sink_4_2578(a))           == 2> t1;
1131     sa<sizeof(sink_4_2578(ca))          == 2> t2;
1132     sa<sizeof(sink_4_2578(va))          == 7> t3;
1133     sa<sizeof(sink_4_2578(cva))         == 8> t4;
1134     sa<sizeof(sink_4_2578(source()))    == 5> t5;
1135     sa<sizeof(sink_4_2578(c_source()))  == 8> t6;
1136     sa<sizeof(sink_4_2578(v_source()))  == 7> t7;
1137     sa<sizeof(sink_4_2578(cv_source())) == 8> t8;
1138     return 0;
1139 }
1140
1141 two   sink_4_2678(const          A&);
1142 six   sink_4_2678(const          A&&);
1143 seven sink_4_2678(volatile       A&&);
1144 eight sink_4_2678(const volatile A&&);
1145
1146 int test4_2678()
1147 {
1148                    A a;
1149     const          A ca = a;
1150           volatile A va;
1151     const volatile A cva = a;
1152     sa<sizeof(sink_4_2678(a))           == 2> t1;
1153     sa<sizeof(sink_4_2678(ca))          == 2> t2;
1154     sa<sizeof(sink_4_2678(va))          == 7> t3;
1155     sa<sizeof(sink_4_2678(cva))         == 8> t4;
1156     sa<sizeof(sink_4_2678(c_source()))  == 6> t6;
1157     sa<sizeof(sink_4_2678(v_source()))  == 7> t7;
1158     sa<sizeof(sink_4_2678(cv_source())) == 8> t8;
1159     return 0;
1160 }
1161
1162 three sink_4_3456(volatile       A&);
1163 four  sink_4_3456(const volatile A&);
1164 five  sink_4_3456(               A&&);
1165 six   sink_4_3456(const          A&&);
1166
1167 int test4_3456()
1168 {
1169                    A a;
1170     const          A ca = a;
1171           volatile A va;
1172     const volatile A cva = a;
1173     sa<sizeof(sink_4_3456(a))           == 3> t1;
1174     sa<sizeof(sink_4_3456(ca))          == 4> t2;
1175     sa<sizeof(sink_4_3456(va))          == 3> t3;
1176     sa<sizeof(sink_4_3456(cva))         == 4> t4;
1177     sa<sizeof(sink_4_3456(source()))    == 5> t5;
1178     sa<sizeof(sink_4_3456(c_source()))  == 6> t6;
1179     return 0;
1180 }
1181
1182 three sink_4_3457(volatile       A&);
1183 four  sink_4_3457(const volatile A&);
1184 five  sink_4_3457(               A&&);
1185 seven sink_4_3457(volatile       A&&);
1186
1187 int test4_3457()
1188 {
1189                    A a;
1190     const          A ca = a;
1191           volatile A va;
1192     const volatile A cva = a;
1193     sa<sizeof(sink_4_3457(a))           == 3> t1;
1194     sa<sizeof(sink_4_3457(ca))          == 4> t2;
1195     sa<sizeof(sink_4_3457(va))          == 3> t3;
1196     sa<sizeof(sink_4_3457(cva))         == 4> t4;
1197     sa<sizeof(sink_4_3457(source()))    == 5> t5;
1198     sa<sizeof(sink_4_3457(v_source()))  == 7> t7;
1199     return 0;
1200 }
1201
1202 three sink_4_3458(volatile       A&);
1203 four  sink_4_3458(const volatile A&);
1204 five  sink_4_3458(               A&&);
1205 eight sink_4_3458(const volatile A&&);
1206
1207 int test4_3458()
1208 {
1209                    A a;
1210     const          A ca = a;
1211           volatile A va;
1212     const volatile A cva = a;
1213     sa<sizeof(sink_4_3458(a))           == 3> t1;
1214     sa<sizeof(sink_4_3458(ca))          == 4> t2;
1215     sa<sizeof(sink_4_3458(va))          == 3> t3;
1216     sa<sizeof(sink_4_3458(cva))         == 4> t4;
1217     sa<sizeof(sink_4_3458(source()))    == 5> t5;
1218     sa<sizeof(sink_4_3458(c_source()))  == 8> t6;
1219     sa<sizeof(sink_4_3458(v_source()))  == 8> t7;
1220     sa<sizeof(sink_4_3458(cv_source())) == 8> t8;
1221     return 0;
1222 }
1223
1224 three sink_4_3467(volatile       A&);
1225 four  sink_4_3467(const volatile A&);
1226 six   sink_4_3467(const          A&&);
1227 seven sink_4_3467(volatile       A&&);
1228
1229 int test4_3467()
1230 {
1231                    A a;
1232     const          A ca = a;
1233           volatile A va;
1234     const volatile A cva = a;
1235     sa<sizeof(sink_4_3467(a))           == 3> t1;
1236     sa<sizeof(sink_4_3467(ca))          == 4> t2;
1237     sa<sizeof(sink_4_3467(va))          == 3> t3;
1238     sa<sizeof(sink_4_3467(cva))         == 4> t4;
1239     sa<sizeof(sink_4_3467(c_source()))  == 6> t6;
1240     sa<sizeof(sink_4_3467(v_source()))  == 7> t7;
1241     return 0;
1242 }
1243
1244 three sink_4_3468(volatile       A&);
1245 four  sink_4_3468(const volatile A&);
1246 six   sink_4_3468(const          A&&);
1247 eight sink_4_3468(const volatile A&&);
1248
1249 int test4_3468()
1250 {
1251                    A a;
1252     const          A ca = a;
1253           volatile A va;
1254     const volatile A cva = a;
1255     sa<sizeof(sink_4_3468(a))           == 3> t1;
1256     sa<sizeof(sink_4_3468(ca))          == 4> t2;
1257     sa<sizeof(sink_4_3468(va))          == 3> t3;
1258     sa<sizeof(sink_4_3468(cva))         == 4> t4;
1259     sa<sizeof(sink_4_3468(source()))    == 6> t5;
1260     sa<sizeof(sink_4_3468(c_source()))  == 6> t6;
1261     sa<sizeof(sink_4_3468(v_source()))  == 8> t7;
1262     sa<sizeof(sink_4_3468(cv_source())) == 8> t8;
1263     return 0;
1264 }
1265
1266 three sink_4_3478(volatile       A&);
1267 four  sink_4_3478(const volatile A&);
1268 seven sink_4_3478(volatile       A&&);
1269 eight sink_4_3478(const volatile A&&);
1270
1271 int test4_3478()
1272 {
1273                    A a;
1274     const          A ca = a;
1275           volatile A va;
1276     const volatile A cva = a;
1277     sa<sizeof(sink_4_3478(a))           == 3> t1;
1278     sa<sizeof(sink_4_3478(ca))          == 4> t2;
1279     sa<sizeof(sink_4_3478(va))          == 3> t3;
1280     sa<sizeof(sink_4_3478(cva))         == 4> t4;
1281     sa<sizeof(sink_4_3478(source()))    == 7> t5;
1282     sa<sizeof(sink_4_3478(c_source()))  == 8> t6;
1283     sa<sizeof(sink_4_3478(v_source()))  == 7> t7;
1284     sa<sizeof(sink_4_3478(cv_source())) == 8> t8;
1285     return 0;
1286 }
1287
1288 three sink_4_3567(volatile       A&);
1289 five  sink_4_3567(               A&&);
1290 six   sink_4_3567(const          A&&);
1291 seven sink_4_3567(volatile       A&&);
1292
1293 int test4_3567()
1294 {
1295                    A a;
1296     const          A ca = a;
1297           volatile A va;
1298     const volatile A cva = a;
1299     sa<sizeof(sink_4_3567(a))           == 3> t1;
1300     sa<sizeof(sink_4_3567(ca))          == 6> t2;
1301     sa<sizeof(sink_4_3567(va))          == 3> t3;
1302     sa<sizeof(sink_4_3567(source()))    == 5> t5;
1303     sa<sizeof(sink_4_3567(c_source()))  == 6> t6;
1304     sa<sizeof(sink_4_3567(v_source()))  == 7> t7;
1305     return 0;
1306 }
1307
1308 three sink_4_3568(volatile       A&);
1309 five  sink_4_3568(               A&&);
1310 six   sink_4_3568(const          A&&);
1311 eight sink_4_3568(const volatile A&&);
1312
1313 int test4_3568()
1314 {
1315                    A a;
1316     const          A ca = a;
1317           volatile A va;
1318     const volatile A cva = a;
1319     sa<sizeof(sink_4_3568(a))           == 3> t1;
1320     sa<sizeof(sink_4_3568(ca))          == 6> t2;
1321     sa<sizeof(sink_4_3568(va))          == 3> t3;
1322     sa<sizeof(sink_4_3568(cva))         == 8> t4;
1323     sa<sizeof(sink_4_3568(source()))    == 5> t5;
1324     sa<sizeof(sink_4_3568(c_source()))  == 6> t6;
1325     sa<sizeof(sink_4_3568(v_source()))  == 8> t7;
1326     sa<sizeof(sink_4_3568(cv_source())) == 8> t8;
1327     return 0;
1328 }
1329
1330 three sink_4_3578(volatile       A&);
1331 five  sink_4_3578(               A&&);
1332 seven sink_4_3578(volatile       A&&);
1333 eight sink_4_3578(const volatile A&&);
1334
1335 int test4_3578()
1336 {
1337                    A a;
1338     const          A ca = a;
1339           volatile A va;
1340     const volatile A cva = a;
1341     sa<sizeof(sink_4_3578(a))           == 3> t1;
1342     sa<sizeof(sink_4_3578(ca))          == 8> t2;
1343     sa<sizeof(sink_4_3578(va))          == 3> t3;
1344     sa<sizeof(sink_4_3578(cva))         == 8> t4;
1345     sa<sizeof(sink_4_3578(source()))    == 5> t5;
1346     sa<sizeof(sink_4_3578(c_source()))  == 8> t6;
1347     sa<sizeof(sink_4_3578(v_source()))  == 7> t7;
1348     sa<sizeof(sink_4_3578(cv_source())) == 8> t8;
1349     return 0;
1350 }
1351
1352 three sink_4_3678(volatile       A&);
1353 six   sink_4_3678(const          A&&);
1354 seven sink_4_3678(volatile       A&&);
1355 eight sink_4_3678(const volatile A&&);
1356
1357 int test4_3678()
1358 {
1359                    A a;
1360     const          A ca = a;
1361           volatile A va;
1362     const volatile A cva = a;
1363     sa<sizeof(sink_4_3678(a))           == 3> t1;
1364     sa<sizeof(sink_4_3678(ca))          == 6> t2;
1365     sa<sizeof(sink_4_3678(va))          == 3> t3;
1366     sa<sizeof(sink_4_3678(cva))         == 8> t4;
1367     sa<sizeof(sink_4_3678(c_source()))  == 6> t6;
1368     sa<sizeof(sink_4_3678(v_source()))  == 7> t7;
1369     sa<sizeof(sink_4_3678(cv_source())) == 8> t8;
1370     return 0;
1371 }
1372
1373 four  sink_4_4567(const volatile A&);
1374 five  sink_4_4567(               A&&);
1375 six   sink_4_4567(const          A&&);
1376 seven sink_4_4567(volatile       A&&);
1377
1378 int test4_4567()
1379 {
1380                    A a;
1381     const          A ca = a;
1382           volatile A va;
1383     const volatile A cva = a;
1384     sa<sizeof(sink_4_4567(a))           == 4> t1;
1385     sa<sizeof(sink_4_4567(ca))          == 4> t2;
1386     sa<sizeof(sink_4_4567(va))          == 4> t3;
1387     sa<sizeof(sink_4_4567(cva))         == 4> t4;
1388     sa<sizeof(sink_4_4567(source()))    == 5> t5;
1389     sa<sizeof(sink_4_4567(c_source()))  == 6> t6;
1390     sa<sizeof(sink_4_4567(v_source()))  == 7> t7;
1391     return 0;
1392 }
1393
1394 four  sink_4_4568(const volatile A&);
1395 five  sink_4_4568(               A&&);
1396 six   sink_4_4568(const          A&&);
1397 eight sink_4_4568(const volatile A&&);
1398
1399 int test4_4568()
1400 {
1401                    A a;
1402     const          A ca = a;
1403           volatile A va;
1404     const volatile A cva = a;
1405     sa<sizeof(sink_4_4568(a))           == 4> t1;
1406     sa<sizeof(sink_4_4568(ca))          == 4> t2;
1407     sa<sizeof(sink_4_4568(va))          == 4> t3;
1408     sa<sizeof(sink_4_4568(cva))         == 4> t4;
1409     sa<sizeof(sink_4_4568(source()))    == 5> t5;
1410     sa<sizeof(sink_4_4568(c_source()))  == 6> t6;
1411     sa<sizeof(sink_4_4568(v_source()))  == 8> t7;
1412     sa<sizeof(sink_4_4568(cv_source())) == 8> t8;
1413     return 0;
1414 }
1415
1416 four  sink_4_4578(const volatile A&);
1417 five  sink_4_4578(               A&&);
1418 seven sink_4_4578(volatile       A&&);
1419 eight sink_4_4578(const volatile A&&);
1420
1421 int test4_4578()
1422 {
1423                    A a;
1424     const          A ca = a;
1425           volatile A va;
1426     const volatile A cva = a;
1427     sa<sizeof(sink_4_4578(a))           == 4> t1;
1428     sa<sizeof(sink_4_4578(ca))          == 4> t2;
1429     sa<sizeof(sink_4_4578(va))          == 4> t3;
1430     sa<sizeof(sink_4_4578(cva))         == 4> t4;
1431     sa<sizeof(sink_4_4578(source()))    == 5> t5;
1432     sa<sizeof(sink_4_4578(c_source()))  == 8> t6;
1433     sa<sizeof(sink_4_4578(v_source()))  == 7> t7;
1434     sa<sizeof(sink_4_4578(cv_source())) == 8> t8;
1435     return 0;
1436 }
1437
1438 four  sink_4_4678(const volatile A&);
1439 six   sink_4_4678(const          A&&);
1440 seven sink_4_4678(volatile       A&&);
1441 eight sink_4_4678(const volatile A&&);
1442
1443 int test4_4678()
1444 {
1445                    A a;
1446     const          A ca = a;
1447           volatile A va;
1448     const volatile A cva = a;
1449     sa<sizeof(sink_4_4678(a))           == 4> t1;
1450     sa<sizeof(sink_4_4678(ca))          == 4> t2;
1451     sa<sizeof(sink_4_4678(va))          == 4> t3;
1452     sa<sizeof(sink_4_4678(cva))         == 4> t4;
1453     sa<sizeof(sink_4_4678(c_source()))  == 6> t6;
1454     sa<sizeof(sink_4_4678(v_source()))  == 7> t7;
1455     sa<sizeof(sink_4_4678(cv_source())) == 8> t8;
1456     return 0;
1457 }
1458
1459 five  sink_4_5678(               A&&);
1460 six   sink_4_5678(const          A&&);
1461 seven sink_4_5678(volatile       A&&);
1462 eight sink_4_5678(const volatile A&&);
1463
1464 int test4_5678()
1465 {
1466                    A a;
1467     const          A ca = a;
1468           volatile A va;
1469     const volatile A cva = a;
1470     sa<sizeof(sink_4_5678(a))           == 5> t1;
1471     sa<sizeof(sink_4_5678(ca))          == 6> t2;
1472     sa<sizeof(sink_4_5678(va))          == 7> t3;
1473     sa<sizeof(sink_4_5678(cva))         == 8> t4;
1474     sa<sizeof(sink_4_5678(source()))    == 5> t5;
1475     sa<sizeof(sink_4_5678(c_source()))  == 6> t6;
1476     sa<sizeof(sink_4_5678(v_source()))  == 7> t7;
1477     sa<sizeof(sink_4_5678(cv_source())) == 8> t8;
1478     return 0;
1479 }
1480
1481 int main()
1482 {
1483     return test4_1234() + test4_1235() + test4_1236() + test4_1237() + test4_1238() +
1484            test4_1245() + test4_1246() + test4_1247() + test4_1248() + test4_1256() +
1485            test4_1257() + test4_1258() + test4_1267() + test4_1268() + test4_1278() +
1486            test4_1345() + test4_1346() + test4_1347() + test4_1348() + test4_1356() +
1487            test4_1357() + test4_1358() + test4_1367() + test4_1368() + test4_1378() +
1488            test4_1456() + test4_1457() + test4_1458() + test4_1467() + test4_1468() +
1489            test4_1478() + test4_1567() + test4_1568() + test4_1578() + test4_1678() +
1490            test4_2345() + test4_2346() + test4_2347() + test4_2348() + test4_2356() +
1491            test4_2357() + test4_2358() + test4_2367() + test4_2368() + test4_2378() +
1492            test4_2456() + test4_2457() + test4_2458() + test4_2467() + test4_2468() +
1493            test4_2478() + test4_2567() + test4_2568() + test4_2578() + test4_2678() +
1494            test4_3456() + test4_3457() + test4_3458() + test4_3467() + test4_3468() +
1495            test4_3478() + test4_3567() + test4_3568() + test4_3578() + test4_3678() +
1496            test4_4567() + test4_4568() + test4_4578() + test4_4678() + test4_5678();
1497 }