gcc/testsuite/g++.dg/cpp0x/rv2p.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 // 2 at a time
  32
  33 one   sink_2_12(               A&);
  34 two   sink_2_12(const          A&);
  35
  36 int test2_12()
  37 {
  38                    A a;
  39     const          A ca = a;
  40           volatile A va;
  41     const volatile A cva = a;
  42     sa<sizeof(sink_2_12(a))           == 1> t1;
  43     sa<sizeof(sink_2_12(ca))          == 2> t2;
  44     sa<sizeof(sink_2_12(source()))    == 2> t5;
  45     sa<sizeof(sink_2_12(c_source()))  == 2> t6;
  46     return 0;
  47 }
  48
  49 one   sink_2_13(               A&);
  50 three sink_2_13(volatile       A&);
  51
  52 int test2_13()
  53 {
  54                    A a;
  55     const          A ca = a;
  56           volatile A va;
  57     const volatile A cva = a;
  58     sa<sizeof(sink_2_13(a))           == 1> t1;
  59     sa<sizeof(sink_2_13(va))          == 3> t3;
  60     return 0;
  61 }
  62
  63 one   sink_2_14(               A&);
  64 four  sink_2_14(const volatile A&);
  65
  66 int test2_14()
  67 {
  68                    A a;
  69     const          A ca = a;
  70           volatile A va;
  71     const volatile A cva = a;
  72     sa<sizeof(sink_2_14(a))           == 1> t1;
  73     sa<sizeof(sink_2_14(ca))          == 4> t2;
  74     sa<sizeof(sink_2_14(va))          == 4> t3;
  75     sa<sizeof(sink_2_14(cva))         == 4> t4;
  76     return 0;
  77 }
  78
  79 one   sink_2_15(               A&);
  80 five  sink_2_15(               A&&);
  81
  82 int test2_15()
  83 {
  84                    A a;
  85     const          A ca = a;
  86           volatile A va;
  87     const volatile A cva = a;
  88     sa<sizeof(sink_2_15(a))           == 1> t1;
  89     sa<sizeof(sink_2_15(source()))    == 5> t5;
  90     return 0;
  91 }
  92
  93 one   sink_2_16(               A&);
  94 six   sink_2_16(const          A&&);
  95
  96 int test2_16()
  97 {
  98                    A a;
  99     const          A ca = a;
 100           volatile A va;
 101     const volatile A cva = a;
 102     sa<sizeof(sink_2_16(a))           == 1> t1;
 103     sa<sizeof(sink_2_16(ca))          == 6> t2;
 104     sa<sizeof(sink_2_16(source()))    == 6> t5;
 105     sa<sizeof(sink_2_16(c_source()))  == 6> t6;
 106     return 0;
 107 }
 108
 109 one   sink_2_17(               A&);
 110 seven sink_2_17(volatile       A&&);
 111
 112 int test2_17()
 113 {
 114                    A a;
 115     const          A ca = a;
 116           volatile A va;
 117     const volatile A cva = a;
 118     sa<sizeof(sink_2_17(a))           == 1> t1;
 119     sa<sizeof(sink_2_17(va))          == 7> t3;
 120     sa<sizeof(sink_2_17(source()))    == 7> t5;
 121     sa<sizeof(sink_2_17(v_source()))  == 7> t7;
 122     return 0;
 123 }
 124
 125 one   sink_2_18(               A&);
 126 eight sink_2_18(const volatile A&&);
 127
 128 int test2_18()
 129 {
 130                    A a;
 131     const          A ca = a;
 132           volatile A va;
 133     const volatile A cva = a;
 134     sa<sizeof(sink_2_18(a))           == 1> t1;
 135     sa<sizeof(sink_2_18(ca))          == 8> t2;
 136     sa<sizeof(sink_2_18(va))          == 8> t3;
 137     sa<sizeof(sink_2_18(cva))         == 8> t4;
 138     sa<sizeof(sink_2_18(source()))    == 8> t5;
 139     sa<sizeof(sink_2_18(c_source()))  == 8> t6;
 140     sa<sizeof(sink_2_18(v_source()))  == 8> t7;
 141     sa<sizeof(sink_2_18(cv_source())) == 8> t8;
 142     return 0;
 143 }
 144
 145 two   sink_2_23(const          A&);
 146 three sink_2_23(volatile       A&);
 147
 148 int test2_23()
 149 {
 150                    A a;
 151     const          A ca = a;
 152           volatile A va;
 153     const volatile A cva = a;
 154     sa<sizeof(sink_2_23(ca))          == 2> t2;
 155     sa<sizeof(sink_2_23(va))          == 3> t3;
 156     sa<sizeof(sink_2_23(source()))    == 2> t5;
 157     sa<sizeof(sink_2_23(c_source()))  == 2> t6;
 158     return 0;
 159 }
 160
 161 two   sink_2_24(const          A&);
 162 four  sink_2_24(const volatile A&);
 163
 164 int test2_24()
 165 {
 166                    A a;
 167     const          A ca = a;
 168           volatile A va;
 169     const volatile A cva = a;
 170     sa<sizeof(sink_2_24(a))           == 2> t1;
 171     sa<sizeof(sink_2_24(ca))          == 2> t2;
 172     sa<sizeof(sink_2_24(va))          == 4> t3;
 173     sa<sizeof(sink_2_24(cva))         == 4> t4;
 174     sa<sizeof(sink_2_24(source()))    == 2> t5;
 175     sa<sizeof(sink_2_24(c_source()))  == 2> t6;
 176 //    sa<sizeof(sink_2_24(v_source()))  == 4> t7;
 177 //    sa<sizeof(sink_2_24(cv_source())) == 4> t8;
 178     return 0;
 179 }
 180
 181 two   sink_2_25(const          A&);
 182 five  sink_2_25(               A&&);
 183
 184 int test2_25()
 185 {
 186                    A a;
 187     const          A ca = a;
 188           volatile A va;
 189     const volatile A cva = a;
 190     sa<sizeof(sink_2_25(a))           == 2> t1;
 191     sa<sizeof(sink_2_25(ca))          == 2> t2;
 192     sa<sizeof(sink_2_25(source()))    == 5> t5;
 193     sa<sizeof(sink_2_25(c_source()))  == 2> t6;
 194     return 0;
 195 }
 196
 197 two   sink_2_26(const          A&);
 198 six   sink_2_26(const          A&&);
 199
 200 int test2_26()
 201 {
 202                    A a;
 203     const          A ca = a;
 204           volatile A va;
 205     const volatile A cva = a;
 206     sa<sizeof(sink_2_26(a))           == 2> t1;
 207     sa<sizeof(sink_2_26(ca))          == 2> t2;
 208     sa<sizeof(sink_2_26(source()))    == 6> t5;
 209     sa<sizeof(sink_2_26(c_source()))  == 6> t6;
 210     return 0;
 211 }
 212
 213 two   sink_2_27(const          A&);
 214 seven sink_2_27(volatile       A&&);
 215
 216 int test2_27()
 217 {
 218                    A a;
 219     const          A ca = a;
 220           volatile A va;
 221     const volatile A cva = a;
 222     sa<sizeof(sink_2_27(a))           == 2> t1;
 223     sa<sizeof(sink_2_27(ca))          == 2> t2;
 224     sa<sizeof(sink_2_27(va))          == 7> t3;
 225     sa<sizeof(sink_2_27(source()))    == 7> t5;
 226     sa<sizeof(sink_2_27(c_source()))  == 2> t6;
 227     sa<sizeof(sink_2_27(v_source()))  == 7> t7;
 228     return 0;
 229 }
 230
 231 two   sink_2_28(const          A&);
 232 eight sink_2_28(const volatile A&&);
 233
 234 int test2_28()
 235 {
 236                    A a;
 237     const          A ca = a;
 238           volatile A va;
 239     const volatile A cva = a;
 240     sa<sizeof(sink_2_28(a))           == 2> t1;
 241     sa<sizeof(sink_2_28(ca))          == 2> t2;
 242     sa<sizeof(sink_2_28(va))          == 8> t3;
 243     sa<sizeof(sink_2_28(cva))         == 8> t4;
 244     sa<sizeof(sink_2_28(source()))    == 8> t5;
 245     sa<sizeof(sink_2_28(c_source()))  == 8> t6;
 246     sa<sizeof(sink_2_28(v_source()))  == 8> t7;
 247     sa<sizeof(sink_2_28(cv_source())) == 8> t8;
 248     return 0;
 249 }
 250
 251 three sink_2_34(volatile       A&);
 252 four  sink_2_34(const volatile A&);
 253
 254 int test2_34()
 255 {
 256                    A a;
 257     const          A ca = a;
 258           volatile A va;
 259     const volatile A cva = a;
 260     sa<sizeof(sink_2_34(a))           == 3> t1;
 261     sa<sizeof(sink_2_34(ca))          == 4> t2;
 262     sa<sizeof(sink_2_34(va))          == 3> t3;
 263     sa<sizeof(sink_2_34(cva))         == 4> t4;
 264 //    sa<sizeof(sink_2_34(source()))    == 4> t5;
 265 //    sa<sizeof(sink_2_34(c_source()))  == 4> t6;
 266 //    sa<sizeof(sink_2_34(v_source()))  == 4> t7;
 267 //    sa<sizeof(sink_2_34(cv_source())) == 4> t8;
 268     return 0;
 269 }
 270
 271 three sink_2_35(volatile       A&);
 272 five  sink_2_35(               A&&);
 273
 274 int test2_35()
 275 {
 276                    A a;
 277     const          A ca = a;
 278           volatile A va;
 279     const volatile A cva = a;
 280     sa<sizeof(sink_2_35(a))           == 3> t1;
 281     sa<sizeof(sink_2_35(va))          == 3> t3;
 282     sa<sizeof(sink_2_35(source()))    == 5> t5;
 283     return 0;
 284 }
 285
 286 three sink_2_36(volatile       A&);
 287 six   sink_2_36(const          A&&);
 288
 289 int test2_36()
 290 {
 291                    A a;
 292     const          A ca = a;
 293           volatile A va;
 294     const volatile A cva = a;
 295     sa<sizeof(sink_2_36(a))           == 3> t1;
 296     sa<sizeof(sink_2_36(ca))          == 6> t2;
 297     sa<sizeof(sink_2_36(va))          == 3> t3;
 298     sa<sizeof(sink_2_36(source()))    == 6> t5;
 299     sa<sizeof(sink_2_36(c_source()))  == 6> t6;
 300     return 0;
 301 }
 302
 303 three sink_2_37(volatile       A&);
 304 seven sink_2_37(volatile       A&&);
 305
 306 int test2_37()
 307 {
 308                    A a;
 309     const          A ca = a;
 310           volatile A va;
 311     const volatile A cva = a;
 312     sa<sizeof(sink_2_37(a))           == 3> t1;
 313     sa<sizeof(sink_2_37(va))          == 3> t3;
 314     sa<sizeof(sink_2_37(source()))    == 7> t5;
 315     sa<sizeof(sink_2_37(v_source()))  == 7> t7;
 316     return 0;
 317 }
 318
 319 three sink_2_38(volatile       A&);
 320 eight sink_2_38(const volatile A&&);
 321
 322 int test2_38()
 323 {
 324                    A a;
 325     const          A ca = a;
 326           volatile A va;
 327     const volatile A cva = a;
 328     sa<sizeof(sink_2_38(a))           == 3> t1;
 329     sa<sizeof(sink_2_38(ca))          == 8> t2;
 330     sa<sizeof(sink_2_38(va))          == 3> t3;
 331     sa<sizeof(sink_2_38(cva))         == 8> t4;
 332     sa<sizeof(sink_2_38(source()))    == 8> t5;
 333     sa<sizeof(sink_2_38(c_source()))  == 8> t6;
 334     sa<sizeof(sink_2_38(v_source()))  == 8> t7;
 335     sa<sizeof(sink_2_38(cv_source())) == 8> t8;
 336     return 0;
 337 }
 338
 339 four  sink_2_45(const volatile A&);
 340 five  sink_2_45(               A&&);
 341
 342 int test2_45()
 343 {
 344                    A a;
 345     const          A ca = a;
 346           volatile A va;
 347     const volatile A cva = a;
 348     sa<sizeof(sink_2_45(a))           == 4> t1;
 349     sa<sizeof(sink_2_45(ca))          == 4> t2;
 350     sa<sizeof(sink_2_45(va))          == 4> t3;
 351     sa<sizeof(sink_2_45(cva))         == 4> t4;
 352     sa<sizeof(sink_2_45(source()))    == 5> t5;
 353 //    sa<sizeof(sink_2_45(c_source()))  == 4> t6;
 354 //    sa<sizeof(sink_2_45(v_source()))  == 4> t7;
 355 //    sa<sizeof(sink_2_45(cv_source())) == 4> t8;
 356     return 0;
 357 }
 358
 359 four  sink_2_46(const volatile A&);
 360 six   sink_2_46(const          A&&);
 361
 362 int test2_46()
 363 {
 364                    A a;
 365     const          A ca = a;
 366           volatile A va;
 367     const volatile A cva = a;
 368     sa<sizeof(sink_2_46(a))           == 4> t1;
 369     sa<sizeof(sink_2_46(ca))          == 4> t2;
 370     sa<sizeof(sink_2_46(va))          == 4> t3;
 371     sa<sizeof(sink_2_46(cva))         == 4> t4;
 372     sa<sizeof(sink_2_46(source()))    == 6> t5;
 373     sa<sizeof(sink_2_46(c_source()))  == 6> t6;
 374 //    sa<sizeof(sink_2_46(v_source()))  == 4> t7;
 375 //    sa<sizeof(sink_2_46(cv_source())) == 4> t8;
 376     return 0;
 377 }
 378
 379 four  sink_2_47(const volatile A&);
 380 seven sink_2_47(volatile       A&&);
 381
 382 int test2_47()
 383 {
 384                    A a;
 385     const          A ca = a;
 386           volatile A va;
 387     const volatile A cva = a;
 388     sa<sizeof(sink_2_47(a))           == 4> t1;
 389     sa<sizeof(sink_2_47(ca))          == 4> t2;
 390     sa<sizeof(sink_2_47(va))          == 4> t3;
 391     sa<sizeof(sink_2_47(cva))         == 4> t4;
 392     sa<sizeof(sink_2_47(source()))    == 7> t5;
 393 //    sa<sizeof(sink_2_47(c_source()))  == 4> t6;
 394     sa<sizeof(sink_2_47(v_source()))  == 7> t7;
 395 //    sa<sizeof(sink_2_47(cv_source())) == 4> t8;
 396     return 0;
 397 }
 398
 399 four  sink_2_48(const volatile A&);
 400 eight sink_2_48(const volatile A&&);
 401
 402 int test2_48()
 403 {
 404                    A a;
 405     const          A ca = a;
 406           volatile A va;
 407     const volatile A cva = a;
 408     sa<sizeof(sink_2_48(a))           == 4> t1;
 409     sa<sizeof(sink_2_48(ca))          == 4> t2;
 410     sa<sizeof(sink_2_48(va))          == 4> t3;
 411     sa<sizeof(sink_2_48(cva))         == 4> t4;
 412     sa<sizeof(sink_2_48(source()))    == 8> t5;
 413     sa<sizeof(sink_2_48(c_source()))  == 8> t6;
 414     sa<sizeof(sink_2_48(v_source()))  == 8> t7;
 415     sa<sizeof(sink_2_48(cv_source())) == 8> t8;
 416     return 0;
 417 }
 418
 419 five  sink_2_56(               A&&);
 420 six   sink_2_56(const          A&&);
 421
 422 int test2_56()
 423 {
 424                    A a;
 425     const          A ca = a;
 426           volatile A va;
 427     const volatile A cva = a;
 428     sa<sizeof(sink_2_56(a))           == 5> t1;
 429     sa<sizeof(sink_2_56(ca))          == 6> t2;
 430     sa<sizeof(sink_2_56(source()))    == 5> t5;
 431     sa<sizeof(sink_2_56(c_source()))  == 6> t6;
 432     return 0;
 433 }
 434
 435 five  sink_2_57(               A&&);
 436 seven sink_2_57(volatile       A&&);
 437
 438 int test2_57()
 439 {
 440                    A a;
 441     const          A ca = a;
 442           volatile A va;
 443     const volatile A cva = a;
 444     sa<sizeof(sink_2_57(a))           == 5> t1;
 445     sa<sizeof(sink_2_57(va))          == 7> t3;
 446     sa<sizeof(sink_2_57(source()))    == 5> t5;
 447     sa<sizeof(sink_2_57(v_source()))  == 7> t7;
 448     return 0;
 449 }
 450
 451 five  sink_2_58(               A&&);
 452 eight sink_2_58(const volatile A&&);
 453
 454 int test2_58()
 455 {
 456                    A a;
 457     const          A ca = a;
 458           volatile A va;
 459     const volatile A cva = a;
 460     sa<sizeof(sink_2_58(a))           == 5> t1;
 461     sa<sizeof(sink_2_58(ca))          == 8> t2;
 462     sa<sizeof(sink_2_58(va))          == 8> t3;
 463     sa<sizeof(sink_2_58(cva))         == 8> t4;
 464     sa<sizeof(sink_2_58(source()))    == 5> t5;
 465     sa<sizeof(sink_2_58(c_source()))  == 8> t6;
 466     sa<sizeof(sink_2_58(v_source()))  == 8> t7;
 467     sa<sizeof(sink_2_58(cv_source())) == 8> t8;
 468     return 0;
 469 }
 470
 471 six   sink_2_67(const          A&&);
 472 seven sink_2_67(volatile       A&&);
 473
 474 int test2_67()
 475 {
 476                    A a;
 477     const          A ca = a;
 478           volatile A va;
 479     const volatile A cva = a;
 480     sa<sizeof(sink_2_67(ca))          == 6> t2;
 481     sa<sizeof(sink_2_67(va))          == 7> t3;
 482     sa<sizeof(sink_2_67(c_source()))  == 6> t6;
 483     sa<sizeof(sink_2_67(v_source()))  == 7> t7;
 484     return 0;
 485 }
 486
 487 six   sink_2_68(const          A&&);
 488 eight sink_2_68(const volatile A&&);
 489
 490 int test2_68()
 491 {
 492                    A a;
 493     const          A ca = a;
 494           volatile A va;
 495     const volatile A cva = a;
 496     sa<sizeof(sink_2_68(a))           == 6> t1;
 497     sa<sizeof(sink_2_68(ca))          == 6> t2;
 498     sa<sizeof(sink_2_68(va))          == 8> t3;
 499     sa<sizeof(sink_2_68(cva))         == 8> t4;
 500     sa<sizeof(sink_2_68(source()))    == 6> t5;
 501     sa<sizeof(sink_2_68(c_source()))  == 6> t6;
 502     sa<sizeof(sink_2_68(v_source()))  == 8> t7;
 503     sa<sizeof(sink_2_68(cv_source())) == 8> t8;
 504     return 0;
 505 }
 506
 507 seven sink_2_78(volatile       A&&);
 508 eight sink_2_78(const volatile A&&);
 509
 510 int test2_78()
 511 {
 512                    A a;
 513     const          A ca = a;
 514           volatile A va;
 515     const volatile A cva = a;
 516     sa<sizeof(sink_2_78(a))           == 7> t1;
 517     sa<sizeof(sink_2_78(ca))          == 8> t2;
 518     sa<sizeof(sink_2_78(va))          == 7> t3;
 519     sa<sizeof(sink_2_78(cva))         == 8> t4;
 520     sa<sizeof(sink_2_78(source()))    == 7> t5;
 521     sa<sizeof(sink_2_78(c_source()))  == 8> t6;
 522     sa<sizeof(sink_2_78(v_source()))  == 7> t7;
 523     sa<sizeof(sink_2_78(cv_source())) == 8> t8;
 524     return 0;
 525 }
 526
 527 int main()
 528 {
 529     return test2_12() + test2_13() + test2_14() + test2_15() +
 530            test2_16() + test2_17() + test2_18() + test2_23() +
 531            test2_24() + test2_25() + test2_26() + test2_27() +
 532            test2_28() + test2_34() + test2_35() + test2_36() +
 533            test2_37() + test2_38() + test2_45() + test2_46() +
 534            test2_47() + test2_48() + test2_56() + test2_57() +
 535            test2_58() + test2_67() + test2_68() + test2_78();
 536 }