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

   1 // I, Howard Hinnant, hereby place this code in the public domain.
   2
   3 // Test overload resolution among reference 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(source()))    == 6> t5;
 104     sa<sizeof(sink_2_16(c_source()))  == 6> t6;
 105     return 0;
 106 }
 107
 108 one   sink_2_17(               A&);
 109 seven sink_2_17(volatile       A&&);
 110
 111 int test2_17()
 112 {
 113                    A a;
 114     const          A ca = a;
 115           volatile A va;
 116     const volatile A cva = a;
 117     sa<sizeof(sink_2_17(a))           == 1> t1;
 118     sa<sizeof(sink_2_17(source()))    == 7> t5;
 119     sa<sizeof(sink_2_17(v_source()))  == 7> t7;
 120     return 0;
 121 }
 122
 123 one   sink_2_18(               A&);
 124 eight sink_2_18(const volatile A&&);
 125
 126 int test2_18()
 127 {
 128                    A a;
 129     const          A ca = a;
 130           volatile A va;
 131     const volatile A cva = a;
 132     sa<sizeof(sink_2_18(a))           == 1> t1;
 133     sa<sizeof(sink_2_18(source()))    == 8> t5;
 134     sa<sizeof(sink_2_18(c_source()))  == 8> t6;
 135     sa<sizeof(sink_2_18(v_source()))  == 8> t7;
 136     sa<sizeof(sink_2_18(cv_source())) == 8> t8;
 137     return 0;
 138 }
 139
 140 two   sink_2_23(const          A&);
 141 three sink_2_23(volatile       A&);
 142
 143 int test2_23()
 144 {
 145                    A a;
 146     const          A ca = a;
 147           volatile A va;
 148     const volatile A cva = a;
 149     sa<sizeof(sink_2_23(ca))          == 2> t2;
 150     sa<sizeof(sink_2_23(va))          == 3> t3;
 151     sa<sizeof(sink_2_23(source()))    == 2> t5;
 152     sa<sizeof(sink_2_23(c_source()))  == 2> t6;
 153     return 0;
 154 }
 155
 156 two   sink_2_24(const          A&);
 157 four  sink_2_24(const volatile A&);
 158
 159 int test2_24()
 160 {
 161                    A a;
 162     const          A ca = a;
 163           volatile A va;
 164     const volatile A cva = a;
 165     sa<sizeof(sink_2_24(a))           == 2> t1;
 166     sa<sizeof(sink_2_24(ca))          == 2> t2;
 167     sa<sizeof(sink_2_24(va))          == 4> t3;
 168     sa<sizeof(sink_2_24(cva))         == 4> t4;
 169     sa<sizeof(sink_2_24(source()))    == 2> t5;
 170     sa<sizeof(sink_2_24(c_source()))  == 2> t6;
 171 //    sa<sizeof(sink_2_24(v_source()))  == 4> t7;
 172 //    sa<sizeof(sink_2_24(cv_source())) == 4> t8;
 173     return 0;
 174 }
 175
 176 two   sink_2_25(const          A&);
 177 five  sink_2_25(               A&&);
 178
 179 int test2_25()
 180 {
 181                    A a;
 182     const          A ca = a;
 183           volatile A va;
 184     const volatile A cva = a;
 185     sa<sizeof(sink_2_25(a))           == 2> t1;
 186     sa<sizeof(sink_2_25(ca))          == 2> t2;
 187     sa<sizeof(sink_2_25(source()))    == 5> t5;
 188     sa<sizeof(sink_2_25(c_source()))  == 2> t6;
 189     return 0;
 190 }
 191
 192 two   sink_2_26(const          A&);
 193 six   sink_2_26(const          A&&);
 194
 195 int test2_26()
 196 {
 197                    A a;
 198     const          A ca = a;
 199           volatile A va;
 200     const volatile A cva = a;
 201     sa<sizeof(sink_2_26(a))           == 2> t1;
 202     sa<sizeof(sink_2_26(ca))          == 2> t2;
 203     sa<sizeof(sink_2_26(source()))    == 6> t5;
 204     sa<sizeof(sink_2_26(c_source()))  == 6> t6;
 205     return 0;
 206 }
 207
 208 two   sink_2_27(const          A&);
 209 seven sink_2_27(volatile       A&&);
 210
 211 int test2_27()
 212 {
 213                    A a;
 214     const          A ca = a;
 215           volatile A va;
 216     const volatile A cva = a;
 217     sa<sizeof(sink_2_27(a))           == 2> t1;
 218     sa<sizeof(sink_2_27(ca))          == 2> t2;
 219     sa<sizeof(sink_2_27(source()))    == 7> t5;
 220     sa<sizeof(sink_2_27(c_source()))  == 2> t6;
 221     sa<sizeof(sink_2_27(v_source()))  == 7> t7;
 222     return 0;
 223 }
 224
 225 two   sink_2_28(const          A&);
 226 eight sink_2_28(const volatile A&&);
 227
 228 int test2_28()
 229 {
 230                    A a;
 231     const          A ca = a;
 232           volatile A va;
 233     const volatile A cva = a;
 234     sa<sizeof(sink_2_28(a))           == 2> t1;
 235     sa<sizeof(sink_2_28(ca))          == 2> t2;
 236     sa<sizeof(sink_2_28(source()))    == 8> t5;
 237     sa<sizeof(sink_2_28(c_source()))  == 8> t6;
 238     sa<sizeof(sink_2_28(v_source()))  == 8> t7;
 239     sa<sizeof(sink_2_28(cv_source())) == 8> t8;
 240     return 0;
 241 }
 242
 243 three sink_2_34(volatile       A&);
 244 four  sink_2_34(const volatile A&);
 245
 246 int test2_34()
 247 {
 248                    A a;
 249     const          A ca = a;
 250           volatile A va;
 251     const volatile A cva = a;
 252     sa<sizeof(sink_2_34(a))           == 3> t1;
 253     sa<sizeof(sink_2_34(ca))          == 4> t2;
 254     sa<sizeof(sink_2_34(va))          == 3> t3;
 255     sa<sizeof(sink_2_34(cva))         == 4> t4;
 256 //    sa<sizeof(sink_2_34(source()))    == 4> t5;
 257 //    sa<sizeof(sink_2_34(c_source()))  == 4> t6;
 258 //    sa<sizeof(sink_2_34(v_source()))  == 4> t7;
 259 //    sa<sizeof(sink_2_34(cv_source())) == 4> t8;
 260     return 0;
 261 }
 262
 263 three sink_2_35(volatile       A&);
 264 five  sink_2_35(               A&&);
 265
 266 int test2_35()
 267 {
 268                    A a;
 269     const          A ca = a;
 270           volatile A va;
 271     const volatile A cva = a;
 272     sa<sizeof(sink_2_35(a))           == 3> t1;
 273     sa<sizeof(sink_2_35(va))          == 3> t3;
 274     sa<sizeof(sink_2_35(source()))    == 5> t5;
 275     return 0;
 276 }
 277
 278 three sink_2_36(volatile       A&);
 279 six   sink_2_36(const          A&&);
 280
 281 int test2_36()
 282 {
 283                    A a;
 284     const          A ca = a;
 285           volatile A va;
 286     const volatile A cva = a;
 287     sa<sizeof(sink_2_36(a))           == 3> t1;
 288     sa<sizeof(sink_2_36(va))          == 3> t3;
 289     sa<sizeof(sink_2_36(source()))    == 6> t5;
 290     sa<sizeof(sink_2_36(c_source()))  == 6> t6;
 291     return 0;
 292 }
 293
 294 three sink_2_37(volatile       A&);
 295 seven sink_2_37(volatile       A&&);
 296
 297 int test2_37()
 298 {
 299                    A a;
 300     const          A ca = a;
 301           volatile A va;
 302     const volatile A cva = a;
 303     sa<sizeof(sink_2_37(a))           == 3> t1;
 304     sa<sizeof(sink_2_37(va))          == 3> t3;
 305     sa<sizeof(sink_2_37(source()))    == 7> t5;
 306     sa<sizeof(sink_2_37(v_source()))  == 7> t7;
 307     return 0;
 308 }
 309
 310 three sink_2_38(volatile       A&);
 311 eight sink_2_38(const volatile A&&);
 312
 313 int test2_38()
 314 {
 315                    A a;
 316     const          A ca = a;
 317           volatile A va;
 318     const volatile A cva = a;
 319     sa<sizeof(sink_2_38(a))           == 3> t1;
 320     sa<sizeof(sink_2_38(va))          == 3> t3;
 321     sa<sizeof(sink_2_38(source()))    == 8> t5;
 322     sa<sizeof(sink_2_38(c_source()))  == 8> t6;
 323     sa<sizeof(sink_2_38(v_source()))  == 8> t7;
 324     sa<sizeof(sink_2_38(cv_source())) == 8> t8;
 325     return 0;
 326 }
 327
 328 four  sink_2_45(const volatile A&);
 329 five  sink_2_45(               A&&);
 330
 331 int test2_45()
 332 {
 333                    A a;
 334     const          A ca = a;
 335           volatile A va;
 336     const volatile A cva = a;
 337     sa<sizeof(sink_2_45(a))           == 4> t1;
 338     sa<sizeof(sink_2_45(ca))          == 4> t2;
 339     sa<sizeof(sink_2_45(va))          == 4> t3;
 340     sa<sizeof(sink_2_45(cva))         == 4> t4;
 341     sa<sizeof(sink_2_45(source()))    == 5> t5;
 342 //    sa<sizeof(sink_2_45(c_source()))  == 4> t6;
 343 //    sa<sizeof(sink_2_45(v_source()))  == 4> t7;
 344 //    sa<sizeof(sink_2_45(cv_source())) == 4> t8;
 345     return 0;
 346 }
 347
 348 four  sink_2_46(const volatile A&);
 349 six   sink_2_46(const          A&&);
 350
 351 int test2_46()
 352 {
 353                    A a;
 354     const          A ca = a;
 355           volatile A va;
 356     const volatile A cva = a;
 357     sa<sizeof(sink_2_46(a))           == 4> t1;
 358     sa<sizeof(sink_2_46(ca))          == 4> t2;
 359     sa<sizeof(sink_2_46(va))          == 4> t3;
 360     sa<sizeof(sink_2_46(cva))         == 4> t4;
 361     sa<sizeof(sink_2_46(source()))    == 6> t5;
 362     sa<sizeof(sink_2_46(c_source()))  == 6> t6;
 363 //    sa<sizeof(sink_2_46(v_source()))  == 4> t7;
 364 //    sa<sizeof(sink_2_46(cv_source())) == 4> t8;
 365     return 0;
 366 }
 367
 368 four  sink_2_47(const volatile A&);
 369 seven sink_2_47(volatile       A&&);
 370
 371 int test2_47()
 372 {
 373                    A a;
 374     const          A ca = a;
 375           volatile A va;
 376     const volatile A cva = a;
 377     sa<sizeof(sink_2_47(a))           == 4> t1;
 378     sa<sizeof(sink_2_47(ca))          == 4> t2;
 379     sa<sizeof(sink_2_47(va))          == 4> t3;
 380     sa<sizeof(sink_2_47(cva))         == 4> t4;
 381     sa<sizeof(sink_2_47(source()))    == 7> t5;
 382 //    sa<sizeof(sink_2_47(c_source()))  == 4> t6;
 383     sa<sizeof(sink_2_47(v_source()))  == 7> t7;
 384 //    sa<sizeof(sink_2_47(cv_source())) == 4> t8;
 385     return 0;
 386 }
 387
 388 four  sink_2_48(const volatile A&);
 389 eight sink_2_48(const volatile A&&);
 390
 391 int test2_48()
 392 {
 393                    A a;
 394     const          A ca = a;
 395           volatile A va;
 396     const volatile A cva = a;
 397     sa<sizeof(sink_2_48(a))           == 4> t1;
 398     sa<sizeof(sink_2_48(ca))          == 4> t2;
 399     sa<sizeof(sink_2_48(va))          == 4> t3;
 400     sa<sizeof(sink_2_48(cva))         == 4> t4;
 401     sa<sizeof(sink_2_48(source()))    == 8> t5;
 402     sa<sizeof(sink_2_48(c_source()))  == 8> t6;
 403     sa<sizeof(sink_2_48(v_source()))  == 8> t7;
 404     sa<sizeof(sink_2_48(cv_source())) == 8> t8;
 405     return 0;
 406 }
 407
 408 five  sink_2_56(               A&&);
 409 six   sink_2_56(const          A&&);
 410
 411 int test2_56()
 412 {
 413                    A a;
 414     const          A ca = a;
 415           volatile A va;
 416     const volatile A cva = a;
 417     sa<sizeof(sink_2_56(source()))    == 5> t5;
 418     sa<sizeof(sink_2_56(c_source()))  == 6> t6;
 419     return 0;
 420 }
 421
 422 five  sink_2_57(               A&&);
 423 seven sink_2_57(volatile       A&&);
 424
 425 int test2_57()
 426 {
 427                    A a;
 428     const          A ca = a;
 429           volatile A va;
 430     const volatile A cva = a;
 431     sa<sizeof(sink_2_57(source()))    == 5> t5;
 432     sa<sizeof(sink_2_57(v_source()))  == 7> t7;
 433     return 0;
 434 }
 435
 436 five  sink_2_58(               A&&);
 437 eight sink_2_58(const volatile A&&);
 438
 439 int test2_58()
 440 {
 441                    A a;
 442     const          A ca = a;
 443           volatile A va;
 444     const volatile A cva = a;
 445     sa<sizeof(sink_2_58(source()))    == 5> t5;
 446     sa<sizeof(sink_2_58(c_source()))  == 8> t6;
 447     sa<sizeof(sink_2_58(v_source()))  == 8> t7;
 448     sa<sizeof(sink_2_58(cv_source())) == 8> t8;
 449     return 0;
 450 }
 451
 452 six   sink_2_67(const          A&&);
 453 seven sink_2_67(volatile       A&&);
 454
 455 int test2_67()
 456 {
 457                    A a;
 458     const          A ca = a;
 459           volatile A va;
 460     const volatile A cva = a;
 461     sa<sizeof(sink_2_67(c_source()))  == 6> t6;
 462     sa<sizeof(sink_2_67(v_source()))  == 7> t7;
 463     return 0;
 464 }
 465
 466 six   sink_2_68(const          A&&);
 467 eight sink_2_68(const volatile A&&);
 468
 469 int test2_68()
 470 {
 471                    A a;
 472     const          A ca = a;
 473           volatile A va;
 474     const volatile A cva = a;
 475     sa<sizeof(sink_2_68(source()))    == 6> t5;
 476     sa<sizeof(sink_2_68(c_source()))  == 6> t6;
 477     sa<sizeof(sink_2_68(v_source()))  == 8> t7;
 478     sa<sizeof(sink_2_68(cv_source())) == 8> t8;
 479     return 0;
 480 }
 481
 482 seven sink_2_78(volatile       A&&);
 483 eight sink_2_78(const volatile A&&);
 484
 485 int test2_78()
 486 {
 487                    A a;
 488     const          A ca = a;
 489           volatile A va;
 490     const volatile A cva = a;
 491     sa<sizeof(sink_2_78(source()))    == 7> t5;
 492     sa<sizeof(sink_2_78(c_source()))  == 8> t6;
 493     sa<sizeof(sink_2_78(v_source()))  == 7> t7;
 494     sa<sizeof(sink_2_78(cv_source())) == 8> t8;
 495     return 0;
 496 }
 497
 498 int main()
 499 {
 500     return test2_12() + test2_13() + test2_14() + test2_15() +
 501            test2_16() + test2_17() + test2_18() + test2_23() +
 502            test2_24() + test2_25() + test2_26() + test2_27() +
 503            test2_28() + test2_34() + test2_35() + test2_36() +
 504            test2_37() + test2_38() + test2_45() + test2_46() +
 505            test2_47() + test2_48() + test2_56() + test2_57() +
 506            test2_58() + test2_67() + test2_68() + test2_78();
 507 }