libstdc++-v3/testsuite/20_util/variant/compile.cc

   1 // { dg-options "-std=gnu++17" }
   2 // { dg-do compile }
   3
   4 // Copyright (C) 2016-2019 Free Software Foundation, Inc.
   5 //
   6 // This file is part of the GNU ISO C++ Library.  This library is free
   7 // software; you can redistribute it and/or modify it under the
   8 // terms of the GNU General Public License as published by the
   9 // Free Software Foundation; either version 3, or (at your option)
  10 // any later version.
  11
  12 // This library is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU General Public License for more details.
  16
  17 // You should have received a copy of the GNU General Public License along
  18 // with this library; see the file COPYING3.  If not see
  19 // <http://www.gnu.org/licenses/>.
  20
  21 #include <variant>
  22 #include <string>
  23 #include <vector>
  24
  25 using namespace std;
  26
  27 struct AllDeleted
  28 {
  29   AllDeleted() = delete;
  30   AllDeleted(const AllDeleted&) = delete;
  31   AllDeleted(AllDeleted&&) = delete;
  32   AllDeleted& operator=(const AllDeleted&) = delete;
  33   AllDeleted& operator=(AllDeleted&&) = delete;
  34 };
  35
  36 struct Empty
  37 {
  38   Empty() { };
  39   Empty(const Empty&) { };
  40   Empty(Empty&&) { };
  41   Empty& operator=(const Empty&) { return *this; };
  42   Empty& operator=(Empty&&) { return *this; };
  43 };
  44
  45 struct DefaultNoexcept
  46 {
  47   DefaultNoexcept() noexcept = default;
  48   DefaultNoexcept(const DefaultNoexcept&) noexcept = default;
  49   DefaultNoexcept(DefaultNoexcept&&) noexcept = default;
  50   DefaultNoexcept& operator=(const DefaultNoexcept&) noexcept = default;
  51   DefaultNoexcept& operator=(DefaultNoexcept&&) noexcept = default;
  52 };
  53
  54 struct MoveCtorOnly
  55 {
  56   MoveCtorOnly() noexcept = delete;
  57   MoveCtorOnly(const DefaultNoexcept&) noexcept = delete;
  58   MoveCtorOnly(DefaultNoexcept&&) noexcept { }
  59   MoveCtorOnly& operator=(const DefaultNoexcept&) noexcept = delete;
  60   MoveCtorOnly& operator=(DefaultNoexcept&&) noexcept = delete;
  61 };
  62
  63 struct nonliteral
  64 {
  65   nonliteral() { }
  66
  67   bool operator<(const nonliteral&) const;
  68   bool operator<=(const nonliteral&) const;
  69   bool operator==(const nonliteral&) const;
  70   bool operator!=(const nonliteral&) const;
  71   bool operator>=(const nonliteral&) const;
  72   bool operator>(const nonliteral&) const;
  73 };
  74
  75 void default_ctor()
  76 {
  77   static_assert(is_default_constructible_v<variant<int, string>>, "");
  78   static_assert(is_default_constructible_v<variant<string, string>>, "");
  79   static_assert(!is_default_constructible_v<variant<AllDeleted, string>>, "");
  80   static_assert(is_default_constructible_v<variant<string, AllDeleted>>, "");
  81
  82   static_assert(noexcept(variant<int>()), "");
  83   static_assert(!noexcept(variant<Empty>()), "");
  84   static_assert(noexcept(variant<DefaultNoexcept>()), "");
  85 }
  86
  87 void copy_ctor()
  88 {
  89   static_assert(is_copy_constructible_v<variant<int, string>>, "");
  90   static_assert(!is_copy_constructible_v<variant<AllDeleted, string>>, "");
  91   static_assert(is_trivially_copy_constructible_v<variant<int>>, "");
  92   static_assert(!is_trivially_copy_constructible_v<variant<std::string>>, "");
  93
  94   {
  95     variant<int> a;
  96     static_assert(noexcept(variant<int>(a)), "");
  97   }
  98   {
  99     variant<string> a;
 100     static_assert(!noexcept(variant<string>(a)), "");
 101   }
 102   {
 103     variant<int, string> a;
 104     static_assert(!noexcept(variant<int, string>(a)), "");
 105   }
 106   {
 107     variant<int, char> a;
 108     static_assert(noexcept(variant<int, char>(a)), "");
 109   }
 110 }
 111
 112 void move_ctor()
 113 {
 114   static_assert(is_move_constructible_v<variant<int, string>>, "");
 115   static_assert(!is_move_constructible_v<variant<AllDeleted, string>>, "");
 116   static_assert(is_trivially_move_constructible_v<variant<int>>, "");
 117   static_assert(!is_trivially_move_constructible_v<variant<std::string>>, "");
 118   static_assert(!noexcept(variant<int, Empty>(declval<variant<int, Empty>>())), "");
 119   static_assert(noexcept(variant<int, DefaultNoexcept>(declval<variant<int, DefaultNoexcept>>())), "");
 120 }
 121
 122 void arbitrary_ctor()
 123 {
 124   static_assert(!is_constructible_v<variant<string, string>, const char*>, "");
 125   static_assert(is_constructible_v<variant<int, string>, const char*>, "");
 126   static_assert(noexcept(variant<int, Empty>(int{})), "");
 127   static_assert(noexcept(variant<int, DefaultNoexcept>(int{})), "");
 128   static_assert(!noexcept(variant<int, Empty>(Empty{})), "");
 129   static_assert(noexcept(variant<int, DefaultNoexcept>(DefaultNoexcept{})), "");
 130 }
 131
 132 void in_place_index_ctor()
 133 {
 134   variant<string, string> a(in_place_index<0>, "a");
 135   variant<string, string> b(in_place_index<1>, {'a'});
 136 }
 137
 138 void in_place_type_ctor()
 139 {
 140   variant<int, string, int> a(in_place_type<string>, "a");
 141   variant<int, string, int> b(in_place_type<string>, {'a'});
 142   static_assert(!is_constructible_v<variant<string, string>, in_place_type_t<string>, const char*>, "");
 143 }
 144
 145 void dtor()
 146 {
 147   static_assert(is_destructible_v<variant<int, string>>, "");
 148   static_assert(is_destructible_v<variant<AllDeleted, string>>, "");
 149 }
 150
 151 void copy_assign()
 152 {
 153   static_assert(is_copy_assignable_v<variant<int, string>>, "");
 154   static_assert(!is_copy_assignable_v<variant<AllDeleted, string>>, "");
 155   static_assert(is_trivially_copy_assignable_v<variant<int>>, "");
 156   static_assert(!is_trivially_copy_assignable_v<variant<string>>, "");
 157   {
 158     variant<Empty> a;
 159     static_assert(!noexcept(a = a), "");
 160   }
 161   {
 162     variant<DefaultNoexcept> a;
 163     static_assert(noexcept(a = a), "");
 164   }
 165 }
 166
 167 void move_assign()
 168 {
 169   static_assert(is_move_assignable_v<variant<int, string>>, "");
 170   static_assert(!is_move_assignable_v<variant<AllDeleted, string>>, "");
 171   static_assert(is_trivially_move_assignable_v<variant<int>>, "");
 172   static_assert(!is_trivially_move_assignable_v<variant<string>>, "");
 173   {
 174     variant<Empty> a;
 175     static_assert(!noexcept(a = std::move(a)), "");
 176   }
 177   {
 178     variant<DefaultNoexcept> a;
 179     static_assert(noexcept(a = std::move(a)), "");
 180   }
 181 }
 182
 183 void arbitrary_assign()
 184 {
 185   static_assert(!is_assignable_v<variant<string, string>, const char*>, "");
 186   static_assert(is_assignable_v<variant<int, string>, const char*>, "");
 187   static_assert(noexcept(variant<int, Empty>() = int{}), "");
 188   static_assert(noexcept(variant<int, DefaultNoexcept>() = int{}), "");
 189   static_assert(!noexcept(variant<int, Empty>() = Empty{}), "");
 190   static_assert(noexcept(variant<int, DefaultNoexcept>() = DefaultNoexcept{}), "");
 191 }
 192
 193 void test_get()
 194 {
 195   static_assert(is_same<decltype(get<0>(variant<int, string>())), int&&>::value, "");
 196   static_assert(is_same<decltype(get<1>(variant<int, string>())), string&&>::value, "");
 197   static_assert(is_same<decltype(get<1>(variant<int, const string>())), const string&&>::value, "");
 198
 199   static_assert(is_same<decltype(get<int>(variant<int, string>())), int&&>::value, "");
 200   static_assert(is_same<decltype(get<string>(variant<int, string>())), string&&>::value, "");
 201   static_assert(is_same<decltype(get<const string>(variant<int, const string>())), const string&&>::value, "");
 202 }
 203
 204 void test_relational()
 205 {
 206   {
 207     constexpr variant<int, nonliteral> a(42), b(43);
 208     static_assert((a < b), "");
 209     static_assert(!(a > b), "");
 210     static_assert((a <= b), "");
 211     static_assert(!(a == b), "");
 212     static_assert((a != b), "");
 213     static_assert(!(a >= b), "");
 214   }
 215   {
 216     constexpr variant<int, nonliteral> a(42), b(42);
 217     static_assert(!(a < b), "");
 218     static_assert(!(a > b), "");
 219     static_assert((a <= b), "");
 220     static_assert((a == b), "");
 221     static_assert(!(a != b), "");
 222     static_assert((a >= b), "");
 223   }
 224   {
 225     constexpr variant<int, nonliteral> a(43), b(42);
 226     static_assert(!(a < b), "");
 227     static_assert((a > b), "");
 228     static_assert(!(a <= b), "");
 229     static_assert(!(a == b), "");
 230     static_assert((a != b), "");
 231     static_assert((a >= b), "");
 232   }
 233   {
 234     constexpr monostate a, b;
 235     static_assert(!(a < b), "");
 236     static_assert(!(a > b), "");
 237     static_assert((a <= b), "");
 238     static_assert((a == b), "");
 239     static_assert(!(a != b), "");
 240     static_assert((a >= b), "");
 241   }
 242 }
 243
 244 // Not swappable, and variant<C> not swappable via the generic std::swap.
 245 struct C { };
 246 void swap(C&, C&) = delete;
 247
 248 static_assert( !std::is_swappable_v<variant<C>> );
 249 static_assert( !std::is_swappable_v<variant<int, C>> );
 250 static_assert( !std::is_swappable_v<variant<C, int>> );
 251
 252 // Not swappable, and variant<D> not swappable via the generic std::swap.
 253 struct D { D(D&&) = delete; };
 254
 255 static_assert( !std::is_swappable_v<variant<D>> );
 256 static_assert( !std::is_swappable_v<variant<int, D>> );
 257 static_assert( !std::is_swappable_v<variant<D, int>> );
 258
 259 void test_swap()
 260 {
 261   static_assert(is_swappable_v<variant<int, string>>, "");
 262   static_assert(is_swappable_v<variant<MoveCtorOnly>>, "");
 263   static_assert(!is_swappable_v<variant<AllDeleted>>, "");
 264 }
 265
 266 void test_visit()
 267 {
 268   {
 269     struct Visitor
 270     {
 271       void operator()(monostate) {}
 272       void operator()(const int&) {}
 273     };
 274     struct CVisitor
 275     {
 276       void operator()(monostate) const {}
 277       void operator()(const int&) const {}
 278     };
 279   }
 280   {
 281     struct Visitor
 282     {
 283       bool operator()(int, float) { return false; }
 284       bool operator()(int, double) { return false; }
 285       bool operator()(char, float) { return false; }
 286       bool operator()(char, double) { return false; }
 287     };
 288     visit(Visitor(), variant<int, char>(), variant<float, double>());
 289   }
 290   {
 291     struct Visitor
 292     {
 293       constexpr bool operator()(const int&) { return true; }
 294       constexpr bool operator()(const nonliteral&) { return false; }
 295     };
 296     static_assert(visit(Visitor(), variant<int, nonliteral>(0)), "");
 297   }
 298   {
 299     struct Visitor
 300     {
 301       constexpr bool operator()(const int&) { return true; }
 302       constexpr bool operator()(const nonliteral&) { return false; }
 303     };
 304     static_assert(visit(Visitor(), variant<int, nonliteral>(0)), "");
 305   }
 306   // PR libstdc++/79513
 307   {
 308     std::variant<int> v [[gnu::unused]] (5);
 309     std::visit([](int&){}, v);
 310     std::visit([](int&&){}, std::move(v));
 311   }
 312 }
 313
 314 void test_constexpr()
 315 {
 316   constexpr variant<int> a;
 317   static_assert(holds_alternative<int>(a), "");
 318   constexpr variant<int, char> b(in_place_index<0>, int{});
 319   static_assert(holds_alternative<int>(b), "");
 320   constexpr variant<int, char> c(in_place_type<int>, int{});
 321   static_assert(holds_alternative<int>(c), "");
 322   constexpr variant<int, char> d(in_place_index<1>, char{});
 323   static_assert(holds_alternative<char>(d), "");
 324   constexpr variant<int, char> e(in_place_type<char>, char{});
 325   static_assert(holds_alternative<char>(e), "");
 326   constexpr variant<int, char> f(char{});
 327   static_assert(holds_alternative<char>(f), "");
 328
 329   {
 330     struct literal {
 331         constexpr literal() = default;
 332     };
 333
 334     constexpr variant<literal, nonliteral> v{};
 335     constexpr variant<literal, nonliteral> v1{in_place_type<literal>};
 336     constexpr variant<literal, nonliteral> v2{in_place_index<0>};
 337   }
 338
 339   {
 340     constexpr variant<int> a(42);
 341     static_assert(get<0>(a) == 42, "");
 342   }
 343   {
 344     constexpr variant<int, nonliteral> a(42);
 345     static_assert(get<0>(a) == 42, "");
 346   }
 347   {
 348     constexpr variant<nonliteral, int> a(42);
 349     static_assert(get<1>(a) == 42, "");
 350   }
 351   {
 352     constexpr variant<int> a(42);
 353     static_assert(get<int>(a) == 42, "");
 354   }
 355   {
 356     constexpr variant<int, nonliteral> a(42);
 357     static_assert(get<int>(a) == 42, "");
 358   }
 359   {
 360     constexpr variant<nonliteral, int> a(42);
 361     static_assert(get<int>(a) == 42, "");
 362   }
 363   {
 364     constexpr variant<int> a(42);
 365     static_assert(get<0>(std::move(a)) == 42, "");
 366   }
 367   {
 368     constexpr variant<int, nonliteral> a(42);
 369     static_assert(get<0>(std::move(a)) == 42, "");
 370   }
 371   {
 372     constexpr variant<nonliteral, int> a(42);
 373     static_assert(get<1>(std::move(a)) == 42, "");
 374   }
 375   {
 376     constexpr variant<int> a(42);
 377     static_assert(get<int>(std::move(a)) == 42, "");
 378   }
 379   {
 380     constexpr variant<int, nonliteral> a(42);
 381     static_assert(get<int>(std::move(a)) == 42, "");
 382   }
 383   {
 384     constexpr variant<nonliteral, int> a(42);
 385     static_assert(get<int>(std::move(a)) == 42, "");
 386   }
 387 }
 388
 389 void test_pr77641()
 390 {
 391   struct X {
 392     constexpr X() { }
 393   };
 394
 395   constexpr std::variant<X> v1 = X{};
 396 }
 397
 398 namespace adl_trap
 399 {
 400   struct X {
 401     X() = default;
 402     X(int) { }
 403     X(std::initializer_list<int>, const X&) { }
 404   };
 405   template<typename T> void move(T&) { }
 406   template<typename T> void forward(T&) { }
 407
 408   struct Visitor {
 409     template<typename T> void operator()(T&&) { }
 410   };
 411 }
 412
 413 void test_adl()
 414 {
 415    using adl_trap::X;
 416    X x;
 417    std::initializer_list<int> il;
 418    adl_trap::Visitor vis;
 419
 420    std::variant<X> v0(x);
 421    v0 = x;
 422    v0.emplace<0>(x);
 423    v0.emplace<0>(il, x);
 424    visit(vis, v0);
 425    variant<X> v1{in_place_index<0>, x};
 426    variant<X> v2{in_place_type<X>, x};
 427    variant<X> v3{in_place_index<0>, il, x};
 428    variant<X> v4{in_place_type<X>, il, x};
 429 }
 430
 431 void test_variant_alternative()
 432 {
 433   static_assert(is_same_v<variant_alternative_t<0, variant<int, string>>, int>, "");
 434   static_assert(is_same_v<variant_alternative_t<1, variant<int, string>>, string>, "");
 435
 436   static_assert(is_same_v<variant_alternative_t<0, const variant<int>>, const int>, "");
 437   static_assert(is_same_v<variant_alternative_t<0, volatile variant<int>>, volatile int>, "");
 438   static_assert(is_same_v<variant_alternative_t<0, const volatile variant<int>>, const volatile int>, "");
 439 }
 440
 441 template<typename V, typename T>
 442   constexpr auto has_type_emplace(int) -> decltype((declval<V>().template emplace<T>(), true))
 443   { return true; };
 444
 445 template<typename V, typename T>
 446   constexpr bool has_type_emplace(...)
 447   { return false; };
 448
 449 template<typename V, size_t N>
 450   constexpr auto has_index_emplace(int) -> decltype((declval<V>().template emplace<N>(), true))
 451   { return true; };
 452
 453 template<typename V, size_t T>
 454   constexpr bool has_index_emplace(...)
 455   { return false; };
 456
 457 void test_emplace()
 458 {
 459   static_assert(has_type_emplace<variant<int>, int>(0), "");
 460   static_assert(!has_type_emplace<variant<long>, int>(0), "");
 461   static_assert(has_index_emplace<variant<int>, 0>(0), "");
 462   static_assert(!has_type_emplace<variant<AllDeleted>, AllDeleted>(0), "");
 463   static_assert(!has_index_emplace<variant<AllDeleted>, 0>(0), "");
 464 }
 465
 466 void test_triviality()
 467 {
 468 #define TEST_TEMPLATE(DT, CC, MC, CA, MA, CC_VAL, MC_VAL, CA_VAL, MA_VAL) \
 469   { \
 470     struct A \
 471     { \
 472       ~A() DT; \
 473       A(const A&) CC; \
 474       A(A&&) MC; \
 475       A& operator=(const A&) CA; \
 476       A& operator=(A&&) MA; \
 477     }; \
 478     static_assert(CC_VAL == is_trivially_copy_constructible_v<variant<A>>, ""); \
 479     static_assert(MC_VAL == is_trivially_move_constructible_v<variant<A>>, ""); \
 480     static_assert(CA_VAL == is_trivially_copy_assignable_v<variant<A>>, ""); \
 481     static_assert(MA_VAL == is_trivially_move_assignable_v<variant<A>>, ""); \
 482   }
 483   TEST_TEMPLATE(=default, =default, =default, =default, =default,  true,  true,  true,  true)
 484   TEST_TEMPLATE(=default, =default, =default, =default,         ,  true,  true,  true, false)
 485   TEST_TEMPLATE(=default, =default, =default,         , =default,  true,  true, false,  true)
 486   TEST_TEMPLATE(=default, =default, =default,         ,         ,  true,  true, false, false)
 487   TEST_TEMPLATE(=default, =default,         , =default, =default,  true, false,  true,  true)
 488   TEST_TEMPLATE(=default, =default,         , =default,         ,  true, false,  true, false)
 489   TEST_TEMPLATE(=default, =default,         ,         , =default,  true, false, false,  true)
 490   TEST_TEMPLATE(=default, =default,         ,         ,         ,  true, false, false, false)
 491   TEST_TEMPLATE(=default,         , =default, =default, =default, false,  true,  true,  true)
 492   TEST_TEMPLATE(=default,         , =default, =default,         , false,  true,  true, false)
 493   TEST_TEMPLATE(=default,         , =default,         , =default, false,  true, false,  true)
 494   TEST_TEMPLATE(=default,         , =default,         ,         , false,  true, false, false)
 495   TEST_TEMPLATE(=default,         ,         , =default, =default, false, false,  true,  true)
 496   TEST_TEMPLATE(=default,         ,         , =default,         , false, false,  true, false)
 497   TEST_TEMPLATE(=default,         ,         ,         , =default, false, false, false,  true)
 498   TEST_TEMPLATE(=default,         ,         ,         ,         , false, false, false, false)
 499   TEST_TEMPLATE(        , =default, =default, =default, =default, false, false, false, false)
 500   TEST_TEMPLATE(        , =default, =default, =default,         , false, false, false, false)
 501   TEST_TEMPLATE(        , =default, =default,         , =default, false, false, false, false)
 502   TEST_TEMPLATE(        , =default, =default,         ,         , false, false, false, false)
 503   TEST_TEMPLATE(        , =default,         , =default, =default, false, false, false, false)
 504   TEST_TEMPLATE(        , =default,         , =default,         , false, false, false, false)
 505   TEST_TEMPLATE(        , =default,         ,         , =default, false, false, false, false)
 506   TEST_TEMPLATE(        , =default,         ,         ,         , false, false, false, false)
 507   TEST_TEMPLATE(        ,         , =default, =default, =default, false, false, false, false)
 508   TEST_TEMPLATE(        ,         , =default, =default,         , false, false, false, false)
 509   TEST_TEMPLATE(        ,         , =default,         , =default, false, false, false, false)
 510   TEST_TEMPLATE(        ,         , =default,         ,         , false, false, false, false)
 511   TEST_TEMPLATE(        ,         ,         , =default, =default, false, false, false, false)
 512   TEST_TEMPLATE(        ,         ,         , =default,         , false, false, false, false)
 513   TEST_TEMPLATE(        ,         ,         ,         , =default, false, false, false, false)
 514   TEST_TEMPLATE(        ,         ,         ,         ,         , false, false, false, false)
 515 #undef TEST_TEMPLATE
 516
 517 #define TEST_TEMPLATE(CC, MC, CA, MA) \
 518   { \
 519     struct A \
 520     { \
 521       A(const A&) CC; \
 522       A(A&&) MC; \
 523       A& operator=(const A&) CA; \
 524       A& operator=(A&&) MA; \
 525     }; \
 526     static_assert(!is_trivially_copy_constructible_v<variant<AllDeleted, A>>, ""); \
 527     static_assert(!is_trivially_move_constructible_v<variant<AllDeleted, A>>, ""); \
 528     static_assert(!is_trivially_copy_assignable_v<variant<AllDeleted, A>>, ""); \
 529     static_assert(!is_trivially_move_assignable_v<variant<AllDeleted, A>>, ""); \
 530   }
 531   TEST_TEMPLATE(=default, =default, =default, =default)
 532   TEST_TEMPLATE(=default, =default, =default,         )
 533   TEST_TEMPLATE(=default, =default,         , =default)
 534   TEST_TEMPLATE(=default, =default,         ,         )
 535   TEST_TEMPLATE(=default,         , =default, =default)
 536   TEST_TEMPLATE(=default,         , =default,         )
 537   TEST_TEMPLATE(=default,         ,         , =default)
 538   TEST_TEMPLATE(=default,         ,         ,         )
 539   TEST_TEMPLATE(        , =default, =default, =default)
 540   TEST_TEMPLATE(        , =default, =default,         )
 541   TEST_TEMPLATE(        , =default,         , =default)
 542   TEST_TEMPLATE(        , =default,         ,         )
 543   TEST_TEMPLATE(        ,         , =default, =default)
 544   TEST_TEMPLATE(        ,         , =default,         )
 545   TEST_TEMPLATE(        ,         ,         , =default)
 546   TEST_TEMPLATE(        ,         ,         ,         )
 547 #undef TEST_TEMPLATE
 548
 549   static_assert(is_trivially_copy_constructible_v<variant<DefaultNoexcept, int, char, float, double>>, "");
 550   static_assert(is_trivially_move_constructible_v<variant<DefaultNoexcept, int, char, float, double>>, "");
 551   static_assert(is_trivially_copy_assignable_v<variant<DefaultNoexcept, int, char, float, double>>, "");
 552   static_assert(is_trivially_move_assignable_v<variant<DefaultNoexcept, int, char, float, double>>, "");
 553 }