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