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