On Thu, Aug 28, 2025 at 6:40 PM Jakub Jelinek <[email protected]> wrote:
> On Thu, Aug 28, 2025 at 06:06:28PM +0200, Tomasz Kaminski wrote:
> > For example, this type should be implicit lifetime (std:::string
> obviously
> > isn't):
> > struct S1 { std::string a; std::string b; };
> > And also this one:
> > struct S2 { std::string a; std::string b; ~S2() = default; };
> > But not this:
> > struct S3 { std::string a; std::string b; ~S3() {} };
> >
> > Because aggregates can also now have base classes, similar rules
> > apply to base classes.
> >
> > I would like to see a test for above cases, of course not on std::string,
> > but one of the implicit lifetime types that you have, like Q.
>
> This adds the AA, AB and AC cases both to the g++.dg test and libstdc++
> test. Anything else you'd like to see?
>
Similar test, for Q being a base class, this is also aggregate in C++20.
And if you could reorganize the library test so satic_assert follows the
type definition,
that would be great.
>
> 2025-08-28 Jakub Jelinek <[email protected]>
>
> gcc/cp/
> * cp-trait.def: Implement C++23 P2674R1 - A trait for implicit
> lifetime types.
> (IS_IMPLICIT_LIFETIME): New unary trait.
> * semantics.cc (trait_expr_value): Handle
> CPTK_IS_IMPLICIT_LIFETIME.
> (finish_trait_expr): Likewise.
> * constraint.cc (diagnose_trait_expr): Likewise.
> gcc/testsuite/
> * g++.dg/ext/is_implicit_lifetime.C: New test.
> libstdc++-v3/
> * include/bits/version.def (is_implicit_lifetime): New.
> * include/bits/version.h: Regenerate.
> * include/std/type_traits (std::is_implicit_lifetime,
> std::is_implicit_lifetime_v): New trait.
> * src/c++23/std.cc.in (std::is_implicit_lifetime,
> std::is_implicit_lifetime_v): Export.
> * testsuite/20_util/is_implicit_lifetime/version.cc: New test.
> * testsuite/20_util/is_implicit_lifetime/value.cc: New test.
>
> --- gcc/cp/cp-trait.def.jj 2025-08-15 22:38:28.866872528 +0200
> +++ gcc/cp/cp-trait.def 2025-08-28 14:40:24.828249392 +0200
> @@ -76,6 +76,7 @@ DEFTRAIT_EXPR (IS_EMPTY, "__is_empty", 1
> DEFTRAIT_EXPR (IS_ENUM, "__is_enum", 1)
> DEFTRAIT_EXPR (IS_FINAL, "__is_final", 1)
> DEFTRAIT_EXPR (IS_FUNCTION, "__is_function", 1)
> +DEFTRAIT_EXPR (IS_IMPLICIT_LIFETIME, "__builtin_is_implicit_lifetime", 1)
> DEFTRAIT_EXPR (IS_INVOCABLE, "__is_invocable", -1)
> DEFTRAIT_EXPR (IS_LAYOUT_COMPATIBLE, "__is_layout_compatible", 2)
> DEFTRAIT_EXPR (IS_LITERAL_TYPE, "__is_literal_type", 1)
> --- gcc/cp/semantics.cc.jj 2025-08-28 10:50:43.432763513 +0200
> +++ gcc/cp/semantics.cc 2025-08-28 16:52:48.006806831 +0200
> @@ -13591,6 +13591,38 @@ trait_expr_value (cp_trait_kind kind, tr
> case CPTK_IS_FUNCTION:
> return type_code1 == FUNCTION_TYPE;
>
> + case CPTK_IS_IMPLICIT_LIFETIME:
> + if (SCALAR_TYPE_P (type1)
> + || (type_code1 == ARRAY_TYPE
> + && !(TYPE_SIZE (type1) && integer_zerop (TYPE_SIZE (type1))))
> + /* GNU extension. */
> + || type_code1 == VECTOR_TYPE)
> + return true;
> + if (!CLASS_TYPE_P (type1))
> + return false;
> + type1 = TYPE_MAIN_VARIANT (type1);
> + if (CP_AGGREGATE_TYPE_P (type1)
> + && (!CLASSTYPE_DESTRUCTOR (type1)
> + || !user_provided_p (CLASSTYPE_DESTRUCTOR (type1))))
> + return true;
> + if (is_trivially_xible (BIT_NOT_EXPR, type1, NULL_TREE))
> + {
> + if (is_trivially_xible (INIT_EXPR, type1, make_tree_vec (0)))
> + return true;
> + tree arg = make_tree_vec (1);
> + tree ctype1 = cp_build_qualified_type (type1, (cp_type_quals
> (type1)
> + |
> TYPE_QUAL_CONST));
> + TREE_VEC_ELT (arg, 0)
> + = cp_build_reference_type (ctype1, /*rval=*/false);
> + if (is_trivially_xible (INIT_EXPR, type1, arg))
> + return true;
> + TREE_VEC_ELT (arg, 0)
> + = cp_build_reference_type (type1, /*rval=*/true);
> + if (is_trivially_xible (INIT_EXPR, type1, arg))
> + return true;
> + }
> + return false;
> +
> case CPTK_IS_INVOCABLE:
> return !error_operand_p (build_invoke (type1, type2, tf_none));
>
> @@ -13910,6 +13942,7 @@ finish_trait_expr (location_t loc, cp_tr
> type to know whether an array is an aggregate, so use kind=4
> here. */
> case CPTK_IS_AGGREGATE:
> case CPTK_IS_FINAL:
> + case CPTK_IS_IMPLICIT_LIFETIME:
> if (!check_trait_type (type1, /* kind = */ 4))
> return error_mark_node;
> break;
> --- gcc/cp/constraint.cc.jj 2025-08-15 22:38:29.017870706 +0200
> +++ gcc/cp/constraint.cc 2025-08-28 13:02:19.197985274 +0200
> @@ -3170,6 +3170,9 @@ diagnose_trait_expr (location_t loc, tre
> case CPTK_IS_FUNCTION:
> inform (loc, "%qT is not a function", t1);
> break;
> + case CPTK_IS_IMPLICIT_LIFETIME:
> + inform (decl_loc, "%qT is not an implicit lifetime type", t1);
> + break;
> case CPTK_IS_INVOCABLE:
> {
> if (!TREE_VEC_LENGTH (t2))
> --- gcc/testsuite/g++.dg/ext/is_implicit_lifetime.C.jj 2025-08-28
> 14:14:33.475719420 +0200
> +++ gcc/testsuite/g++.dg/ext/is_implicit_lifetime.C 2025-08-28
> 18:34:32.032953565 +0200
> @@ -0,0 +1,128 @@
> +// { dg-do compile { target c++11 } }
> +// { dg-options "" }
> +// { dg-add-options float16 }
> +// { dg-add-options float32 }
> +// { dg-add-options float64 }
> +// { dg-add-options float128 }
> +
> +struct A { int a, b, c; };
> +class B { static int a; private: static int b; public: int c; };
> +struct C { C () {} int a, b, c; };
> +struct D { explicit D (int) {} int a, b, c; };
> +struct E : public A { int d, e, f; };
> +struct F : public C { using C::C; int d, e, f; };
> +class G { int a, b; };
> +struct H { private: int a, b; };
> +struct I { protected: int a, b; };
> +struct J { int a, b; void foo (); };
> +struct K { int a, b; virtual void foo (); };
> +struct L : virtual public A { int d, e; };
> +struct M : protected A { int d, e; };
> +struct N : private A { int d, e; };
> +struct O { O () = delete; int a, b, c; };
> +struct P { P () = default; int a, b, c; };
> +struct Q { Q (); Q (const Q &); int a, b, c; };
> +struct R { R (); R (const R &); R (R &&) = default; int a, b, c; };
> +struct S { S (); ~S (); int a, b, c; };
> +struct T { T (); ~T () = default; int a, b, c; };
> +struct U { U (); U (const U &) = default; int a, b, c; };
> +struct V { V () = default; V (const V &); int a, b, c; };
> +enum W { W1 };
> +enum class X : int { X1 };
> +struct Y { int g; int foo (int); };
> +struct Z;
> +struct AA { Q a; Q b; };
> +struct AB { Q a; Q b; ~AB () = default; };
> +struct AC { Q a; Q b; ~AC () {} };
> +
> +#define SA(X) static_assert ((X), #X)
> +
> +SA (!__builtin_is_implicit_lifetime (void));
> +SA (!__builtin_is_implicit_lifetime (const void));
> +SA (!__builtin_is_implicit_lifetime (volatile void));
> +SA (__builtin_is_implicit_lifetime (char));
> +SA (__builtin_is_implicit_lifetime (signed char));
> +SA (__builtin_is_implicit_lifetime (const unsigned char));
> +SA (__builtin_is_implicit_lifetime (short));
> +SA (__builtin_is_implicit_lifetime (volatile unsigned short));
> +SA (__builtin_is_implicit_lifetime (int));
> +SA (__builtin_is_implicit_lifetime (unsigned int));
> +SA (__builtin_is_implicit_lifetime (const volatile long));
> +SA (__builtin_is_implicit_lifetime (unsigned long));
> +SA (__builtin_is_implicit_lifetime (long long));
> +SA (__builtin_is_implicit_lifetime (unsigned long long));
> +#ifdef __SIZEOF_INT128__
> +SA (__builtin_is_implicit_lifetime (__int128));
> +SA (__builtin_is_implicit_lifetime (unsigned __int128));
> +#endif
> +SA (__builtin_is_implicit_lifetime (float));
> +SA (__builtin_is_implicit_lifetime (double));
> +SA (__builtin_is_implicit_lifetime (long double volatile));
> +#ifdef __STDCPP_FLOAT16_T__
> +SA (__builtin_is_implicit_lifetime (_Float16));
> +#endif
> +#ifdef __STDCPP_FLOAT32_T__
> +SA (__builtin_is_implicit_lifetime (_Float32));
> +#endif
> +#ifdef __STDCPP_FLOAT64_T__
> +SA (__builtin_is_implicit_lifetime (const _Float64));
> +#endif
> +#ifdef __STDCPP_FLOAT128_T__
> +SA (__builtin_is_implicit_lifetime (_Float128));
> +#endif
> +#ifdef __STDCPP_BFLOAT16_T__
> +SA (__builtin_is_implicit_lifetime (decltype(0.bf16)));
> +#endif
> +SA (__builtin_is_implicit_lifetime (W));
> +SA (__builtin_is_implicit_lifetime (const volatile X));
> +SA (__builtin_is_implicit_lifetime (int *));
> +SA (__builtin_is_implicit_lifetime (int (*) (int)));
> +SA (__builtin_is_implicit_lifetime (int (Y::*)));
> +SA (__builtin_is_implicit_lifetime (int (Y::*) (int)));
> +SA (!__builtin_is_implicit_lifetime (int &));
> +SA (!__builtin_is_implicit_lifetime (char &&));
> +SA (__builtin_is_implicit_lifetime (int []));
> +SA (!__builtin_is_implicit_lifetime (int [0]));
> +SA (__builtin_is_implicit_lifetime (int [1]));
> +SA (__builtin_is_implicit_lifetime (const Y [42]));
> +SA (!__builtin_is_implicit_lifetime (int ()));
> +SA (!__builtin_is_implicit_lifetime (int () &));
> +SA (!__builtin_is_implicit_lifetime (int () const));
> +SA (!__builtin_is_implicit_lifetime (int (&) ()));
> +SA (!__builtin_is_implicit_lifetime (Z)); // { dg-error
> "invalid use of incomplete type 'struct Z'" }
> +SA (__builtin_is_implicit_lifetime (Z []));
> +SA (__builtin_is_implicit_lifetime (Z [5]));
> +SA (__builtin_is_implicit_lifetime (A));
> +SA (__builtin_is_implicit_lifetime (B));
> +SA (__builtin_is_implicit_lifetime (C));
> +SA (__builtin_is_implicit_lifetime (D));
> +SA (__builtin_is_implicit_lifetime (E));
> +SA (__builtin_is_implicit_lifetime (F));
> +SA (__builtin_is_implicit_lifetime (G));
> +SA (__builtin_is_implicit_lifetime (H));
> +SA (__builtin_is_implicit_lifetime (I));
> +SA (__builtin_is_implicit_lifetime (J));
> +SA (!__builtin_is_implicit_lifetime (K));
> +SA (!__builtin_is_implicit_lifetime (L));
> +SA (__builtin_is_implicit_lifetime (M));
> +SA (__builtin_is_implicit_lifetime (N));
> +SA (__builtin_is_implicit_lifetime (O));
> +SA (__builtin_is_implicit_lifetime (P));
> +SA (!__builtin_is_implicit_lifetime (Q));
> +SA (__builtin_is_implicit_lifetime (R));
> +SA (!__builtin_is_implicit_lifetime (S));
> +SA (__builtin_is_implicit_lifetime (S [3]));
> +SA (__builtin_is_implicit_lifetime (T));
> +SA (__builtin_is_implicit_lifetime (U));
> +SA (__builtin_is_implicit_lifetime (V));
> +SA (__builtin_is_implicit_lifetime (_Complex double));
> +SA (__builtin_is_implicit_lifetime (int [[gnu::vector_size (4 * sizeof
> (int))]]));
> +SA (__builtin_is_implicit_lifetime (AA));
> +SA (__builtin_is_implicit_lifetime (AB));
> +SA (!__builtin_is_implicit_lifetime (AC));
> +
> +void
> +foo (int n)
> +{
> + SA (__builtin_is_implicit_lifetime (char [n]));
> +}
> --- libstdc++-v3/include/bits/version.def.jj 2025-08-23
> 15:00:05.175775859 +0200
> +++ libstdc++-v3/include/bits/version.def 2025-08-28
> 17:06:44.190031458 +0200
> @@ -2091,6 +2091,15 @@ ftms = {
> };
> };
>
> +ftms = {
> + name = is_implicit_lifetime;
> + values = {
> + v = 202302;
> + cxxmin = 23;
> + extra_cond = "__has_builtin(__builtin_is_implicit_lifetime)";
> + };
> +};
> +
> // Standard test specifications.
> stds[97] = ">= 199711L";
> stds[03] = ">= 199711L";
> --- libstdc++-v3/include/bits/version.h.jj 2025-08-23
> 15:00:05.176775846 +0200
> +++ libstdc++-v3/include/bits/version.h 2025-08-28 17:06:49.160883915 +0200
> @@ -2343,4 +2343,14 @@
> #endif /* !defined(__cpp_lib_constexpr_exceptions) &&
> defined(__glibcxx_want_constexpr_exceptions) */
> #undef __glibcxx_want_constexpr_exceptions
>
> +#if !defined(__cpp_lib_is_implicit_lifetime)
> +# if (__cplusplus >= 202100L) &&
> (__has_builtin(__builtin_is_implicit_lifetime))
> +# define __glibcxx_is_implicit_lifetime 202302L
> +# if defined(__glibcxx_want_all) ||
> defined(__glibcxx_want_is_implicit_lifetime)
> +# define __cpp_lib_is_implicit_lifetime 202302L
> +# endif
> +# endif
> +#endif /* !defined(__cpp_lib_is_implicit_lifetime) &&
> defined(__glibcxx_want_is_implicit_lifetime) */
> +#undef __glibcxx_want_is_implicit_lifetime
> +
> #undef __glibcxx_want_all
> --- libstdc++-v3/include/std/type_traits.jj 2025-07-16
> 13:10:11.054411335 +0200
> +++ libstdc++-v3/include/std/type_traits 2025-08-28
> 17:36:11.404329402 +0200
> @@ -46,6 +46,7 @@
> #define __glibcxx_want_is_aggregate
> #define __glibcxx_want_is_constant_evaluated
> #define __glibcxx_want_is_final
> +#define __glibcxx_want_is_implicit_lifetime
> #define __glibcxx_want_is_invocable
> #define __glibcxx_want_is_layout_compatible
> #define __glibcxx_want_is_nothrow_convertible
> @@ -4052,6 +4053,22 @@ template<typename _Ret, typename _Fn, ty
> # endif
> #endif
>
> +#ifdef __cpp_lib_is_implicit_lifetime // C++ >= 23
> + /// True if the type is an implicit-lifetime type.
> + /// @since C++23
> +
> + template<typename _Tp>
> + struct is_implicit_lifetime
> + : bool_constant<__builtin_is_implicit_lifetime(_Tp)>
> + { };
> +
> + /// @ingroup variable_templates
> + /// @since C++23
> + template<typename _Tp>
> + inline constexpr bool is_implicit_lifetime_v
> + = __builtin_is_implicit_lifetime(_Tp);
> +#endif
> +
> #ifdef __cpp_lib_reference_from_temporary // C++ >= 23 &&
> ref_{converts,constructs}_from_temp
> /// True if _Tp is a reference type, a _Up value can be bound to _Tp in
> /// direct-initialization, and a temporary object would be bound to
> --- libstdc++-v3/src/c++23/std.cc.in.jj 2025-08-23 15:00:05.209775407 +0200
> +++ libstdc++-v3/src/c++23/std.cc.in 2025-08-28 17:10:43.784942152
> +0200
> @@ -3216,6 +3216,10 @@ export namespace std
> using std::is_scoped_enum;
> using std::is_scoped_enum_v;
> #endif
> +#if __cpp_lib_is_implicit_lifetime
> + using std::is_implicit_lifetime;
> + using std::is_implicit_lifetime_v;
> +#endif
> }
>
> // <typeindex>
> --- libstdc++-v3/testsuite/20_util/is_implicit_lifetime/version.cc.jj
> 2025-08-28 17:16:17.590650275 +0200
> +++ libstdc++-v3/testsuite/20_util/is_implicit_lifetime/version.cc
> 2025-08-28 17:17:07.215014852 +0200
> @@ -0,0 +1,27 @@
> +// Copyright (C) 2025 Free Software Foundation, Inc.
> +//
> +// This file is part of the GNU ISO C++ Library. This library is free
> +// software; you can redistribute it and/or modify it under the
> +// terms of the GNU General Public License as published by the
> +// Free Software Foundation; either version 3, or (at your option)
> +// any later version.
> +
> +// This library is distributed in the hope that it will be useful,
> +// but WITHOUT ANY WARRANTY; without even the implied warranty of
> +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> +// GNU General Public License for more details.
> +
> +// You should have received a copy of the GNU General Public License along
> +// with this library; see the file COPYING3. If not see
> +// <http://www.gnu.org/licenses/>.
> +
> +// { dg-do compile { target c++23 } }
> +// { dg-add-options no_pch }
> +
> +#include <version>
> +
> +#ifndef __cpp_lib_is_implicit_lifetime
> +# error "Feature test macro for is_implicit_lifetime is missing in
> <version>"
> +#elif __cpp_lib_is_implicit_lifetime < 202302L
> +# error "Feature test macro for is_implicit_lifetime has wrong value in
> <version>"
> +#endif
> --- libstdc++-v3/testsuite/20_util/is_implicit_lifetime/value.cc.jj
> 2025-08-28 17:16:20.746609864 +0200
> +++ libstdc++-v3/testsuite/20_util/is_implicit_lifetime/value.cc
> 2025-08-28 18:35:36.540128767 +0200
> @@ -0,0 +1,128 @@
> +// Copyright (C) 2025 Free Software Foundation, Inc.
> +//
> +// This file is part of the GNU ISO C++ Library. This library is free
> +// software; you can redistribute it and/or modify it under the
> +// terms of the GNU General Public License as published by the
> +// Free Software Foundation; either version 3, or (at your option)
> +// any later version.
> +
> +// This library is distributed in the hope that it will be useful,
> +// but WITHOUT ANY WARRANTY; without even the implied warranty of
> +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> +// GNU General Public License for more details.
> +
> +// You should have received a copy of the GNU General Public License along
> +// with this library; see the file COPYING3. If not see
> +// <http://www.gnu.org/licenses/>.
> +
> +// { dg-do compile { target c++23 } }
> +// { dg-add-options no_pch }
> +
> +#include <type_traits>
> +
> +#ifndef __cpp_lib_is_implicit_lifetime
> +# error "Feature test macro for is_implicit_lifetime is missing in
> <type_traits>"
> +#elif __cpp_lib_is_implicit_lifetime < 202302L
> +# error "Feature test macro for is_implicit_lifetime has wrong value in
> <type_traits>"
> +#endif
> +
> +#include <testsuite_tr1.h>
> +
> +template<typename T>
> + concept Is_implicit_lifetime
> + = __gnu_test::test_category<std::is_implicit_lifetime, T>(true);
> +
> +struct A { int a, b, c; };
> +class B { static int a; private: static int b; public: int c; };
> +struct C { C () {} int a, b, c; };
> +struct D { explicit D (int) {} int a, b, c; };
> +struct E : public A { int d, e, f; };
> +struct F : public C { using C::C; int d, e, f; };
> +class G { int a, b; };
> +struct H { private: int a, b; };
> +struct I { protected: int a, b; };
> +struct J { int a, b; void foo (); };
> +struct K { int a, b; virtual void foo (); };
> +struct L : virtual public A { int d, e; };
> +struct M : protected A { int d, e; };
> +struct N : private A { int d, e; };
> +struct O { O () = delete; int a, b, c; };
> +struct P { P () = default; int a, b, c; };
> +struct Q { Q (); Q (const Q &); int a, b, c; };
> +struct R { R (); R (const R &); R (R &&) = default; int a, b, c; };
> +struct S { S (); ~S (); int a, b, c; };
> +struct T { T (); ~T () = default; int a, b, c; };
> +struct U { U (); U (const U &) = default; int a, b, c; };
> +struct V { V () = default; V (const V &); int a, b, c; };
> +enum W { W1 };
> +enum class X : int { X1 };
> +struct Y { int g; int foo (int); };
> +struct Z;
> +struct AA { Q a; Q b; };
> +struct AB { Q a; Q b; ~AB () = default; };
> +struct AC { Q a; Q b; ~AC () {} };
> +
> +void
> +test01()
> +{
> + static_assert( ! Is_implicit_lifetime<void> );
> + static_assert( ! Is_implicit_lifetime<const void> );
> + static_assert( ! Is_implicit_lifetime<volatile void> );
> + static_assert( Is_implicit_lifetime<char> );
> + static_assert( Is_implicit_lifetime<signed char> );
> + static_assert( Is_implicit_lifetime<const unsigned char> );
> + static_assert( Is_implicit_lifetime<short> );
> + static_assert( Is_implicit_lifetime<volatile unsigned short> );
> + static_assert( Is_implicit_lifetime<int> );
> + static_assert( Is_implicit_lifetime<unsigned int> );
> + static_assert( Is_implicit_lifetime<const volatile long> );
> + static_assert( Is_implicit_lifetime<unsigned long> );
> + static_assert( Is_implicit_lifetime<long long> );
> + static_assert( Is_implicit_lifetime<unsigned long long> );
> + static_assert( Is_implicit_lifetime<float> );
> + static_assert( Is_implicit_lifetime<double> );
> + static_assert( Is_implicit_lifetime<long double volatile> );
> + static_assert( Is_implicit_lifetime<W> );
> + static_assert( Is_implicit_lifetime<const volatile X> );
> + static_assert( Is_implicit_lifetime<int *> );
> + static_assert( Is_implicit_lifetime<int (*) (int)> );
> + static_assert( Is_implicit_lifetime<int (Y::*)> );
> + static_assert( Is_implicit_lifetime<int (Y::*) (int)> );
> + static_assert( ! Is_implicit_lifetime<int &> );
> + static_assert( ! Is_implicit_lifetime<char &&> );
> + static_assert( Is_implicit_lifetime<int []> );
> + static_assert( Is_implicit_lifetime<int [1]> );
> + static_assert( Is_implicit_lifetime<const Y [42]> );
> + static_assert( ! Is_implicit_lifetime<int ()> );
> + static_assert( ! Is_implicit_lifetime<int () &> );
> + static_assert( ! Is_implicit_lifetime<int () const> );
> + static_assert( ! Is_implicit_lifetime<int (&) ()> );
> + static_assert( Is_implicit_lifetime<Z []> );
> + static_assert( Is_implicit_lifetime<Z [5]> );
> + static_assert( Is_implicit_lifetime<A> );
> + static_assert( Is_implicit_lifetime<B> );
> + static_assert( Is_implicit_lifetime<C> );
> + static_assert( Is_implicit_lifetime<D> );
> + static_assert( Is_implicit_lifetime<E> );
> + static_assert( Is_implicit_lifetime<F> );
> + static_assert( Is_implicit_lifetime<G> );
> + static_assert( Is_implicit_lifetime<H> );
> + static_assert( Is_implicit_lifetime<I> );
> + static_assert( Is_implicit_lifetime<J> );
> + static_assert( ! Is_implicit_lifetime<K> );
> + static_assert( ! Is_implicit_lifetime<L> );
> + static_assert( Is_implicit_lifetime<M> );
> + static_assert( Is_implicit_lifetime<N> );
> + static_assert( Is_implicit_lifetime<O> );
> + static_assert( Is_implicit_lifetime<P> );
> + static_assert( ! Is_implicit_lifetime<Q> );
> + static_assert( Is_implicit_lifetime<R> );
> + static_assert( ! Is_implicit_lifetime<S> );
> + static_assert( Is_implicit_lifetime<S [3]> );
> + static_assert( Is_implicit_lifetime<T> );
> + static_assert( Is_implicit_lifetime<U> );
> + static_assert( Is_implicit_lifetime<V> );
> + static_assert( Is_implicit_lifetime<AA> );
> + static_assert( Is_implicit_lifetime<AB> );
> + static_assert( ! Is_implicit_lifetime<AC> );
> +}
>
>
> Jakub
>
>
