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