Mercurial > hg > CbC > CbC_gcc
view gcc/testsuite/g++.dg/cpp2a/concepts-pr67862.C @ 145:1830386684a0
gcc-9.2.0
author | anatofuz |
---|---|
date | Thu, 13 Feb 2020 11:34:05 +0900 |
parents | |
children |
line wrap: on
line source
// { dg-do compile { target c++2a } } // { dg-additional-options "-fconcepts-ts" } typedef int size_t; template <typename _Tp> struct A { static constexpr _Tp value = 1; }; template <typename _Tp> _Tp declval(); template <typename _From, typename _To> struct __is_convertible_helper { template <typename, typename> static A<bool> __test(int); typedef decltype(__test<_From, _To>(0)) type; }; template <typename, typename> struct is_convertible : __is_convertible_helper<int, int>::type {}; template <typename> struct remove_reference; template <typename _Tp> struct remove_reference<_Tp &> { typedef _Tp type; }; struct base; struct general; template <typename _Tp, _Tp...> struct B; template <typename _Tp, _Tp> using make_integer_sequence = B<int>; template <size_t... _Idx> using index_sequence = B<size_t, _Idx...>; template <size_t _Num> using make_index_sequence = make_integer_sequence<size_t, _Num>; template <bool...> struct and_c_impl { static constexpr bool value = true; }; template <bool...> constexpr bool and_c() { return and_c_impl<>::value; } template <class X, class Y> concept bool cpt_Convertible() { return is_convertible<X, Y>::value; } template <class T> using uncvref_t = typename remove_reference<T>::type; struct Plus; using index_t = int; template <class> bool cpt_Index; template <class... Extents> requires and_c<cpt_Index<Extents>()...>() class Dimensionality; namespace detail_concept { template <class> bool match_dimensionality; template <class... Extents> constexpr bool match_dimensionality<Dimensionality<Extents...>> = true; } template <class X> concept bool cpt_Dimensionality() { return detail_concept::match_dimensionality<X>; } template <class X> concept bool cpt_Shaped() { return requires(X x){{x};}; } template <class X> concept bool cpt_Dimensioned() { return cpt_Shaped<X>(); } template <class... Extents> requires and_c<cpt_Index<Extents>()...>() class Dimensionality { public: static constexpr size_t num_dimensions = sizeof...(Extents); }; template <index_t...> using DimensionalityC = Dimensionality<>; template <class> struct dimensionality_type_impl; template <cpt_Dimensioned X> struct dimensionality_type_impl<X> { using type = uncvref_t<decltype(declval<X>().dimensionality())>; }; template <cpt_Dimensioned X> using dimensionality_type = typename dimensionality_type_impl<X>::type; template <class Functor, class... Expressibles> requires requires(Functor functor, Expressibles... expressibles) { map_expressions_impl(functor, expressibles...); } decltype(auto) map_impl(Functor, Expressibles...); void cpt_ContinualScalar(); template <class> concept bool cpt_Scalar() { return cpt_ContinualScalar; } template <class X> concept bool cpt_FlatEvaluator() { return requires(X x){{x}->cpt_Scalar;}; } template <class, class> bool k_evaluator_impl; template <size_t... Indexes, class Evaluator> constexpr bool k_evaluator_impl<index_sequence<Indexes...>, Evaluator> = true; template <class X, size_t K> concept bool cpt_KEvaluator() { return k_evaluator_impl<make_index_sequence<K>, X>; } template <class X, size_t K> concept bool cpt_KCompatibleEvaluator() { return cpt_KEvaluator<X, K>(); } template <class X> concept bool cpt_Structure() { return cpt_Convertible<X, base>(); } template <cpt_Dimensionality Dimensionality, cpt_Structure, cpt_KCompatibleEvaluator<Dimensionality::num_dimensions> Evaluator> class NumericArrayExpression; namespace detail_concept { template <class> bool match_numeric_array_expression; template <cpt_Dimensionality Dimensionality, cpt_Structure Structure, cpt_KCompatibleEvaluator<Dimensionality::num_dimensions> Evaluator> constexpr bool match_numeric_array_expression< NumericArrayExpression<Dimensionality, Structure, Evaluator>> = true; } template <class X> concept bool cpt_NumericArrayExpression() { return detail_concept::match_numeric_array_expression<X>; } namespace expression_traits { namespace detail_expression_traits { template <class...> struct first_numeric_array_expression_impl; template <cpt_NumericArrayExpression ExpressionFirst, class... ExpressionsRest> struct first_numeric_array_expression_impl<ExpressionFirst, ExpressionsRest...> { using type = ExpressionFirst; }; } template <class... Expressions> using first_numeric_array_expression = typename detail_expression_traits::first_numeric_array_expression_impl< Expressions...>::type; template <class... Expressions> using first_expression_dimensionality = dimensionality_type<first_numeric_array_expression<Expressions...>>; } template <cpt_Dimensionality Dimensionality, cpt_Structure, cpt_KCompatibleEvaluator<Dimensionality::num_dimensions> Evaluator> class NumericArrayExpression { public: NumericArrayExpression(Dimensionality, Evaluator) {} Dimensionality &dimensionality(); }; template <cpt_Structure Structure, cpt_Dimensionality Dimensionality, cpt_KCompatibleEvaluator<Dimensionality::num_dimensions> Evaluator> auto make_numeric_array_expression(Dimensionality dimensionality, Evaluator evaluator) { return NumericArrayExpression<Dimensionality, Structure, Evaluator>( dimensionality, evaluator); } template <size_t, class Functor, class... Evaluators> auto make_map_evaluator_impl(Functor) requires and_(cpt_FlatEvaluator<Evaluators>()...); template <class Functor, class... Expressions> requires requires(Expressions... expressions, expression_traits::first_expression_dimensionality<Expressions...> dimensionality) { make_map_evaluator_impl<decltype(dimensionality)::num_dimensions>( expressions...); } decltype(auto) map_expressions_impl(Functor, Expressions...); template <class Functor, class... Expressibles> concept bool cpt_Mappable() { return requires(Functor functor, Expressibles... expressibles) { map_impl(functor, expressibles...); }; } void ____C_A_T_C_H____T_E_S_T____8() { auto e1 = make_numeric_array_expression<general>(DimensionalityC<>(), [] {}); using E1 = decltype(e1); cpt_Mappable<Plus, E1>(); }