m4/ax_cxx_compile_stdcxx.m4

   1 # ===========================================================================
   2 #  https://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx.html
   3 # ===========================================================================
   4 #
   5 # SYNOPSIS
   6 #
   7 #   AX_CXX_COMPILE_STDCXX(VERSION, [ext|noext], [mandatory|optional])
   8 #
   9 # DESCRIPTION
  10 #
  11 #   Check for baseline language coverage in the compiler for the specified
  12 #   version of the C++ standard.  If necessary, add switches to CXX and
  13 #   CXXCPP to enable support.  VERSION may be '11' (for the C++11 standard)
  14 #   or '14' (for the C++14 standard).
  15 #
  16 #   The second argument, if specified, indicates whether you insist on an
  17 #   extended mode (e.g. -std=gnu++11) or a strict conformance mode (e.g.
  18 #   -std=c++11).  If neither is specified, you get whatever works, with
  19 #   preference for an extended mode.
  20 #
  21 #   The third argument, if specified 'mandatory' or if left unspecified,
  22 #   indicates that baseline support for the specified C++ standard is
  23 #   required and that the macro should error out if no mode with that
  24 #   support is found.  If specified 'optional', then configuration proceeds
  25 #   regardless, after defining HAVE_CXX${VERSION} if and only if a
  26 #   supporting mode is found.
  27 #
  28 # LICENSE
  29 #
  30 #   Copyright (c) 2008 Benjamin Kosnik <bkoz@redhat.com>
  31 #   Copyright (c) 2012 Zack Weinberg <zackw@panix.com>
  32 #   Copyright (c) 2013 Roy Stogner <roystgnr@ices.utexas.edu>
  33 #   Copyright (c) 2014, 2015 Google Inc.; contributed by Alexey Sokolov <sokolov@google.com>
  34 #   Copyright (c) 2015 Paul Norman <penorman@mac.com>
  35 #   Copyright (c) 2015 Moritz Klammler <moritz@klammler.eu>
  36 #   Copyright (c) 2016, 2018 Krzesimir Nowak <qdlacz@gmail.com>
  37 #   Copyright (c) 2019 Enji Cooper <yaneurabeya@gmail.com>
  38 #
  39 #   Copying and distribution of this file, with or without modification, are
  40 #   permitted in any medium without royalty provided the copyright notice
  41 #   and this notice are preserved.  This file is offered as-is, without any
  42 #   warranty.
  43
  44 #serial 11
  45
  46 dnl  This macro is based on the code from the AX_CXX_COMPILE_STDCXX_11 macro
  47 dnl  (serial version number 13).
  48
  49 AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl
  50   m4_if([$1], [11], [ax_cxx_compile_alternatives="11 0x"],
  51         [$1], [14], [ax_cxx_compile_alternatives="14 1y"],
  52         [$1], [17], [ax_cxx_compile_alternatives="17 1z"],
  53         [m4_fatal([invalid first argument `$1' to AX_CXX_COMPILE_STDCXX])])dnl
  54   m4_if([$2], [], [],
  55         [$2], [ext], [],
  56         [$2], [noext], [],
  57         [m4_fatal([invalid second argument `$2' to AX_CXX_COMPILE_STDCXX])])dnl
  58   m4_if([$3], [], [ax_cxx_compile_cxx$1_required=true],
  59         [$3], [mandatory], [ax_cxx_compile_cxx$1_required=true],
  60         [$3], [optional], [ax_cxx_compile_cxx$1_required=false],
  61         [m4_fatal([invalid third argument `$3' to AX_CXX_COMPILE_STDCXX])])
  62   AC_LANG_PUSH([C++])dnl
  63   ac_success=no
  64
  65   m4_if([$2], [noext], [], [dnl
  66   if test x$ac_success = xno; then
  67     for alternative in ${ax_cxx_compile_alternatives}; do
  68       switch="-std=gnu++${alternative}"
  69       cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch])
  70       AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,
  71                      $cachevar,
  72         [ac_save_CXX="$CXX"
  73          CXX="$CXX $switch"
  74          AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
  75           [eval $cachevar=yes],
  76           [eval $cachevar=no])
  77          CXX="$ac_save_CXX"])
  78       if eval test x\$$cachevar = xyes; then
  79         CXX="$CXX $switch"
  80         if test -n "$CXXCPP" ; then
  81           CXXCPP="$CXXCPP $switch"
  82         fi
  83         ac_success=yes
  84         break
  85       fi
  86     done
  87   fi])
  88
  89   m4_if([$2], [ext], [], [dnl
  90   if test x$ac_success = xno; then
  91     dnl HP's aCC needs +std=c++11 according to:
  92     dnl http://h21007.www2.hp.com/portal/download/files/unprot/aCxx/PDF_Release_Notes/769149-001.pdf
  93     dnl Cray's crayCC needs "-h std=c++11"
  94     for alternative in ${ax_cxx_compile_alternatives}; do
  95       for switch in -std=c++${alternative} +std=c++${alternative} "-h std=c++${alternative}"; do
  96         cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch])
  97         AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,
  98                        $cachevar,
  99           [ac_save_CXX="$CXX"
 100            CXX="$CXX $switch"
 101            AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
 102             [eval $cachevar=yes],
 103             [eval $cachevar=no])
 104            CXX="$ac_save_CXX"])
 105         if eval test x\$$cachevar = xyes; then
 106           CXX="$CXX $switch"
 107           if test -n "$CXXCPP" ; then
 108             CXXCPP="$CXXCPP $switch"
 109           fi
 110           ac_success=yes
 111           break
 112         fi
 113       done
 114       if test x$ac_success = xyes; then
 115         break
 116       fi
 117     done
 118   fi])
 119   AC_LANG_POP([C++])
 120   if test x$ax_cxx_compile_cxx$1_required = xtrue; then
 121     if test x$ac_success = xno; then
 122       AC_MSG_ERROR([*** A compiler with support for C++$1 language features is required.])
 123     fi
 124   fi
 125   if test x$ac_success = xno; then
 126     HAVE_CXX$1=0
 127     AC_MSG_NOTICE([No compiler with C++$1 support was found])
 128   else
 129     HAVE_CXX$1=1
 130     AC_DEFINE(HAVE_CXX$1,1,
 131               [define if the compiler supports basic C++$1 syntax])
 132   fi
 133   AC_SUBST(HAVE_CXX$1)
 134 ])
 135
 136
 137 dnl  Test body for checking C++11 support
 138
 139 m4_define([_AX_CXX_COMPILE_STDCXX_testbody_11],
 140   _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
 141 )
 142
 143
 144 dnl  Test body for checking C++14 support
 145
 146 m4_define([_AX_CXX_COMPILE_STDCXX_testbody_14],
 147   _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
 148   _AX_CXX_COMPILE_STDCXX_testbody_new_in_14
 149 )
 150
 151 m4_define([_AX_CXX_COMPILE_STDCXX_testbody_17],
 152   _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
 153   _AX_CXX_COMPILE_STDCXX_testbody_new_in_14
 154   _AX_CXX_COMPILE_STDCXX_testbody_new_in_17
 155 )
 156
 157 dnl  Tests for new features in C++11
 158
 159 m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_11], [[
 160
 161 // If the compiler admits that it is not ready for C++11, why torture it?
 162 // Hopefully, this will speed up the test.
 163
 164 #ifndef __cplusplus
 165
 166 #error "This is not a C++ compiler"
 167
 168 #elif __cplusplus < 201103L
 169
 170 #error "This is not a C++11 compiler"
 171
 172 #else
 173
 174 namespace cxx11
 175 {
 176
 177   namespace test_static_assert
 178   {
 179
 180     template <typename T>
 181     struct check
 182     {
 183       static_assert(sizeof(int) <= sizeof(T), "not big enough");
 184     };
 185
 186   }
 187
 188   namespace test_final_override
 189   {
 190
 191     struct Base
 192     {
 193       virtual ~Base() {}
 194       virtual void f() {}
 195     };
 196
 197     struct Derived : public Base
 198     {
 199       virtual ~Derived() override {}
 200       virtual void f() override {}
 201     };
 202
 203   }
 204
 205   namespace test_double_right_angle_brackets
 206   {
 207
 208     template < typename T >
 209     struct check {};
 210
 211     typedef check<void> single_type;
 212     typedef check<check<void>> double_type;
 213     typedef check<check<check<void>>> triple_type;
 214     typedef check<check<check<check<void>>>> quadruple_type;
 215
 216   }
 217
 218   namespace test_decltype
 219   {
 220
 221     int
 222     f()
 223     {
 224       int a = 1;
 225       decltype(a) b = 2;
 226       return a + b;
 227     }
 228
 229   }
 230
 231   namespace test_type_deduction
 232   {
 233
 234     template < typename T1, typename T2 >
 235     struct is_same
 236     {
 237       static const bool value = false;
 238     };
 239
 240     template < typename T >
 241     struct is_same<T, T>
 242     {
 243       static const bool value = true;
 244     };
 245
 246     template < typename T1, typename T2 >
 247     auto
 248     add(T1 a1, T2 a2) -> decltype(a1 + a2)
 249     {
 250       return a1 + a2;
 251     }
 252
 253     int
 254     test(const int c, volatile int v)
 255     {
 256       static_assert(is_same<int, decltype(0)>::value == true, "");
 257       static_assert(is_same<int, decltype(c)>::value == false, "");
 258       static_assert(is_same<int, decltype(v)>::value == false, "");
 259       auto ac = c;
 260       auto av = v;
 261       auto sumi = ac + av + 'x';
 262       auto sumf = ac + av + 1.0;
 263       static_assert(is_same<int, decltype(ac)>::value == true, "");
 264       static_assert(is_same<int, decltype(av)>::value == true, "");
 265       static_assert(is_same<int, decltype(sumi)>::value == true, "");
 266       static_assert(is_same<int, decltype(sumf)>::value == false, "");
 267       static_assert(is_same<int, decltype(add(c, v))>::value == true, "");
 268       return (sumf > 0.0) ? sumi : add(c, v);
 269     }
 270
 271   }
 272
 273   namespace test_noexcept
 274   {
 275
 276     int f() { return 0; }
 277     int g() noexcept { return 0; }
 278
 279     static_assert(noexcept(f()) == false, "");
 280     static_assert(noexcept(g()) == true, "");
 281
 282   }
 283
 284   namespace test_constexpr
 285   {
 286
 287     template < typename CharT >
 288     unsigned long constexpr
 289     strlen_c_r(const CharT *const s, const unsigned long acc) noexcept
 290     {
 291       return *s ? strlen_c_r(s + 1, acc + 1) : acc;
 292     }
 293
 294     template < typename CharT >
 295     unsigned long constexpr
 296     strlen_c(const CharT *const s) noexcept
 297     {
 298       return strlen_c_r(s, 0UL);
 299     }
 300
 301     static_assert(strlen_c("") == 0UL, "");
 302     static_assert(strlen_c("1") == 1UL, "");
 303     static_assert(strlen_c("example") == 7UL, "");
 304     static_assert(strlen_c("another\0example") == 7UL, "");
 305
 306   }
 307
 308   namespace test_rvalue_references
 309   {
 310
 311     template < int N >
 312     struct answer
 313     {
 314       static constexpr int value = N;
 315     };
 316
 317     answer<1> f(int&)       { return answer<1>(); }
 318     answer<2> f(const int&) { return answer<2>(); }
 319     answer<3> f(int&&)      { return answer<3>(); }
 320
 321     void
 322     test()
 323     {
 324       int i = 0;
 325       const int c = 0;
 326       static_assert(decltype(f(i))::value == 1, "");
 327       static_assert(decltype(f(c))::value == 2, "");
 328       static_assert(decltype(f(0))::value == 3, "");
 329     }
 330
 331   }
 332
 333   namespace test_uniform_initialization
 334   {
 335
 336     struct test
 337     {
 338       static const int zero {};
 339       static const int one {1};
 340     };
 341
 342     static_assert(test::zero == 0, "");
 343     static_assert(test::one == 1, "");
 344
 345   }
 346
 347   namespace test_lambdas
 348   {
 349
 350     void
 351     test1()
 352     {
 353       auto lambda1 = [](){};
 354       auto lambda2 = lambda1;
 355       lambda1();
 356       lambda2();
 357     }
 358
 359     int
 360     test2()
 361     {
 362       auto a = [](int i, int j){ return i + j; }(1, 2);
 363       auto b = []() -> int { return '0'; }();
 364       auto c = [=](){ return a + b; }();
 365       auto d = [&](){ return c; }();
 366       auto e = [a, &b](int x) mutable {
 367         const auto identity = [](int y){ return y; };
 368         for (auto i = 0; i < a; ++i)
 369           a += b--;
 370         return x + identity(a + b);
 371       }(0);
 372       return a + b + c + d + e;
 373     }
 374
 375     int
 376     test3()
 377     {
 378       const auto nullary = [](){ return 0; };
 379       const auto unary = [](int x){ return x; };
 380       using nullary_t = decltype(nullary);
 381       using unary_t = decltype(unary);
 382       const auto higher1st = [](nullary_t f){ return f(); };
 383       const auto higher2nd = [unary](nullary_t f1){
 384         return [unary, f1](unary_t f2){ return f2(unary(f1())); };
 385       };
 386       return higher1st(nullary) + higher2nd(nullary)(unary);
 387     }
 388
 389   }
 390
 391   namespace test_variadic_templates
 392   {
 393
 394     template <int...>
 395     struct sum;
 396
 397     template <int N0, int... N1toN>
 398     struct sum<N0, N1toN...>
 399     {
 400       static constexpr auto value = N0 + sum<N1toN...>::value;
 401     };
 402
 403     template <>
 404     struct sum<>
 405     {
 406       static constexpr auto value = 0;
 407     };
 408
 409     static_assert(sum<>::value == 0, "");
 410     static_assert(sum<1>::value == 1, "");
 411     static_assert(sum<23>::value == 23, "");
 412     static_assert(sum<1, 2>::value == 3, "");
 413     static_assert(sum<5, 5, 11>::value == 21, "");
 414     static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, "");
 415
 416   }
 417
 418   // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae
 419   // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function
 420   // because of this.
 421   namespace test_template_alias_sfinae
 422   {
 423
 424     struct foo {};
 425
 426     template<typename T>
 427     using member = typename T::member_type;
 428
 429     template<typename T>
 430     void func(...) {}
 431
 432     template<typename T>
 433     void func(member<T>*) {}
 434
 435     void test();
 436
 437     void test() { func<foo>(0); }
 438
 439   }
 440
 441 }  // namespace cxx11
 442
 443 #endif  // __cplusplus >= 201103L
 444
 445 ]])
 446
 447
 448 dnl  Tests for new features in C++14
 449
 450 m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_14], [[
 451
 452 // If the compiler admits that it is not ready for C++14, why torture it?
 453 // Hopefully, this will speed up the test.
 454
 455 #ifndef __cplusplus
 456
 457 #error "This is not a C++ compiler"
 458
 459 #elif __cplusplus < 201402L
 460
 461 #error "This is not a C++14 compiler"
 462
 463 #else
 464
 465 namespace cxx14
 466 {
 467
 468   namespace test_polymorphic_lambdas
 469   {
 470
 471     int
 472     test()
 473     {
 474       const auto lambda = [](auto&&... args){
 475         const auto istiny = [](auto x){
 476           return (sizeof(x) == 1UL) ? 1 : 0;
 477         };
 478         const int aretiny[] = { istiny(args)... };
 479         return aretiny[0];
 480       };
 481       return lambda(1, 1L, 1.0f, '1');
 482     }
 483
 484   }
 485
 486   namespace test_binary_literals
 487   {
 488
 489     constexpr auto ivii = 0b0000000000101010;
 490     static_assert(ivii == 42, "wrong value");
 491
 492   }
 493
 494   namespace test_generalized_constexpr
 495   {
 496
 497     template < typename CharT >
 498     constexpr unsigned long
 499     strlen_c(const CharT *const s) noexcept
 500     {
 501       auto length = 0UL;
 502       for (auto p = s; *p; ++p)
 503         ++length;
 504       return length;
 505     }
 506
 507     static_assert(strlen_c("") == 0UL, "");
 508     static_assert(strlen_c("x") == 1UL, "");
 509     static_assert(strlen_c("test") == 4UL, "");
 510     static_assert(strlen_c("another\0test") == 7UL, "");
 511
 512   }
 513
 514   namespace test_lambda_init_capture
 515   {
 516
 517     int
 518     test()
 519     {
 520       auto x = 0;
 521       const auto lambda1 = [a = x](int b){ return a + b; };
 522       const auto lambda2 = [a = lambda1(x)](){ return a; };
 523       return lambda2();
 524     }
 525
 526   }
 527
 528   namespace test_digit_separators
 529   {
 530
 531     constexpr auto ten_million = 100'000'000;
 532     static_assert(ten_million == 100000000, "");
 533
 534   }
 535
 536   namespace test_return_type_deduction
 537   {
 538
 539     auto f(int& x) { return x; }
 540     decltype(auto) g(int& x) { return x; }
 541
 542     template < typename T1, typename T2 >
 543     struct is_same
 544     {
 545       static constexpr auto value = false;
 546     };
 547
 548     template < typename T >
 549     struct is_same<T, T>
 550     {
 551       static constexpr auto value = true;
 552     };
 553
 554     int
 555     test()
 556     {
 557       auto x = 0;
 558       static_assert(is_same<int, decltype(f(x))>::value, "");
 559       static_assert(is_same<int&, decltype(g(x))>::value, "");
 560       return x;
 561     }
 562
 563   }
 564
 565 }  // namespace cxx14
 566
 567 #endif  // __cplusplus >= 201402L
 568
 569 ]])
 570
 571
 572 dnl  Tests for new features in C++17
 573
 574 m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_17], [[
 575
 576 // If the compiler admits that it is not ready for C++17, why torture it?
 577 // Hopefully, this will speed up the test.
 578
 579 #ifndef __cplusplus
 580
 581 #error "This is not a C++ compiler"
 582
 583 #elif __cplusplus < 201703L
 584
 585 #error "This is not a C++17 compiler"
 586
 587 #else
 588
 589 #include <initializer_list>
 590 #include <utility>
 591 #include <type_traits>
 592
 593 namespace cxx17
 594 {
 595
 596   namespace test_constexpr_lambdas
 597   {
 598
 599     constexpr int foo = [](){return 42;}();
 600
 601   }
 602
 603   namespace test::nested_namespace::definitions
 604   {
 605
 606   }
 607
 608   namespace test_fold_expression
 609   {
 610
 611     template<typename... Args>
 612     int multiply(Args... args)
 613     {
 614       return (args * ... * 1);
 615     }
 616
 617     template<typename... Args>
 618     bool all(Args... args)
 619     {
 620       return (args && ...);
 621     }
 622
 623   }
 624
 625   namespace test_extended_static_assert
 626   {
 627
 628     static_assert (true);
 629
 630   }
 631
 632   namespace test_auto_brace_init_list
 633   {
 634
 635     auto foo = {5};
 636     auto bar {5};
 637
 638     static_assert(std::is_same<std::initializer_list<int>, decltype(foo)>::value);
 639     static_assert(std::is_same<int, decltype(bar)>::value);
 640   }
 641
 642   namespace test_typename_in_template_template_parameter
 643   {
 644
 645     template<template<typename> typename X> struct D;
 646
 647   }
 648
 649   namespace test_fallthrough_nodiscard_maybe_unused_attributes
 650   {
 651
 652     int f1()
 653     {
 654       return 42;
 655     }
 656
 657     [[nodiscard]] int f2()
 658     {
 659       [[maybe_unused]] auto unused = f1();
 660
 661       switch (f1())
 662       {
 663       case 17:
 664         f1();
 665         [[fallthrough]];
 666       case 42:
 667         f1();
 668       }
 669       return f1();
 670     }
 671
 672   }
 673
 674   namespace test_extended_aggregate_initialization
 675   {
 676
 677     struct base1
 678     {
 679       int b1, b2 = 42;
 680     };
 681
 682     struct base2
 683     {
 684       base2() {
 685         b3 = 42;
 686       }
 687       int b3;
 688     };
 689
 690     struct derived : base1, base2
 691     {
 692         int d;
 693     };
 694
 695     derived d1 {{1, 2}, {}, 4};  // full initialization
 696     derived d2 {{}, {}, 4};      // value-initialized bases
 697
 698   }
 699
 700   namespace test_general_range_based_for_loop
 701   {
 702
 703     struct iter
 704     {
 705       int i;
 706
 707       int& operator* ()
 708       {
 709         return i;
 710       }
 711
 712       const int& operator* () const
 713       {
 714         return i;
 715       }
 716
 717       iter& operator++()
 718       {
 719         ++i;
 720         return *this;
 721       }
 722     };
 723
 724     struct sentinel
 725     {
 726       int i;
 727     };
 728
 729     bool operator== (const iter& i, const sentinel& s)
 730     {
 731       return i.i == s.i;
 732     }
 733
 734     bool operator!= (const iter& i, const sentinel& s)
 735     {
 736       return !(i == s);
 737     }
 738
 739     struct range
 740     {
 741       iter begin() const
 742       {
 743         return {0};
 744       }
 745
 746       sentinel end() const
 747       {
 748         return {5};
 749       }
 750     };
 751
 752     void f()
 753     {
 754       range r {};
 755
 756       for (auto i : r)
 757       {
 758         [[maybe_unused]] auto v = i;
 759       }
 760     }
 761
 762   }
 763
 764   namespace test_lambda_capture_asterisk_this_by_value
 765   {
 766
 767     struct t
 768     {
 769       int i;
 770       int foo()
 771       {
 772         return [*this]()
 773         {
 774           return i;
 775         }();
 776       }
 777     };
 778
 779   }
 780
 781   namespace test_enum_class_construction
 782   {
 783
 784     enum class byte : unsigned char
 785     {};
 786
 787     byte foo {42};
 788
 789   }
 790
 791   namespace test_constexpr_if
 792   {
 793
 794     template <bool cond>
 795     int f ()
 796     {
 797       if constexpr(cond)
 798       {
 799         return 13;
 800       }
 801       else
 802       {
 803         return 42;
 804       }
 805     }
 806
 807   }
 808
 809   namespace test_selection_statement_with_initializer
 810   {
 811
 812     int f()
 813     {
 814       return 13;
 815     }
 816
 817     int f2()
 818     {
 819       if (auto i = f(); i > 0)
 820       {
 821         return 3;
 822       }
 823
 824       switch (auto i = f(); i + 4)
 825       {
 826       case 17:
 827         return 2;
 828
 829       default:
 830         return 1;
 831       }
 832     }
 833
 834   }
 835
 836   namespace test_template_argument_deduction_for_class_templates
 837   {
 838
 839     template <typename T1, typename T2>
 840     struct pair
 841     {
 842       pair (T1 p1, T2 p2)
 843         : m1 {p1},
 844           m2 {p2}
 845       {}
 846
 847       T1 m1;
 848       T2 m2;
 849     };
 850
 851     void f()
 852     {
 853       [[maybe_unused]] auto p = pair{13, 42u};
 854     }
 855
 856   }
 857
 858   namespace test_non_type_auto_template_parameters
 859   {
 860
 861     template <auto n>
 862     struct B
 863     {};
 864
 865     B<5> b1;
 866     B<'a'> b2;
 867
 868   }
 869
 870   namespace test_structured_bindings
 871   {
 872
 873     int arr[2] = { 1, 2 };
 874     std::pair<int, int> pr = { 1, 2 };
 875
 876     auto f1() -> int(&)[2]
 877     {
 878       return arr;
 879     }
 880
 881     auto f2() -> std::pair<int, int>&
 882     {
 883       return pr;
 884     }
 885
 886     struct S
 887     {
 888       int x1 : 2;
 889       volatile double y1;
 890     };
 891
 892     S f3()
 893     {
 894       return {};
 895     }
 896
 897     auto [ x1, y1 ] = f1();
 898     auto& [ xr1, yr1 ] = f1();
 899     auto [ x2, y2 ] = f2();
 900     auto& [ xr2, yr2 ] = f2();
 901     const auto [ x3, y3 ] = f3();
 902
 903   }
 904
 905   namespace test_exception_spec_type_system
 906   {
 907
 908     struct Good {};
 909     struct Bad {};
 910
 911     void g1() noexcept;
 912     void g2();
 913
 914     template<typename T>
 915     Bad
 916     f(T*, T*);
 917
 918     template<typename T1, typename T2>
 919     Good
 920     f(T1*, T2*);
 921
 922     static_assert (std::is_same_v<Good, decltype(f(g1, g2))>);
 923
 924   }
 925
 926   namespace test_inline_variables
 927   {
 928
 929     template<class T> void f(T)
 930     {}
 931
 932     template<class T> inline T g(T)
 933     {
 934       return T{};
 935     }
 936
 937     template<> inline void f<>(int)
 938     {}
 939
 940     template<> int g<>(int)
 941     {
 942       return 5;
 943     }
 944
 945   }
 946
 947 }  // namespace cxx17
 948
 949 #endif  // __cplusplus < 201703L
 950
 951 ]])