diff --git a/gcc/cp/cp-trait.def b/gcc/cp/cp-trait.def index bac593c0094..8b7fece0cc8 100644 --- a/gcc/cp/cp-trait.def +++ b/gcc/cp/cp-trait.def @@ -91,6 +91,7 @@ DEFTRAIT_TYPE (REMOVE_CV, "__remove_cv", 1) DEFTRAIT_TYPE (REMOVE_REFERENCE, "__remove_reference", 1) DEFTRAIT_TYPE (REMOVE_CVREF, "__remove_cvref", 1) DEFTRAIT_TYPE (UNDERLYING_TYPE, "__underlying_type", 1) +DEFTRAIT_TYPE (TYPE_PACK_ELEMENT, "__type_pack_element", -1) /* These traits yield a type pack, not a type, and are represented by cp_parser_trait as a special BASES tree instead of a TRAIT_TYPE tree. */ diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index a14eb8d0b9a..6c5920dcbe0 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -7761,7 +7761,7 @@ extern tree finish_decltype_type (tree, bool, tsubst_flags_t); extern tree fold_builtin_is_corresponding_member (location_t, int, tree *); extern tree fold_builtin_is_pointer_inverconvertible_with_class (location_t, int, tree *); extern tree finish_trait_expr (location_t, enum cp_trait_kind, tree, tree); -extern tree finish_trait_type (enum cp_trait_kind, tree, tree); +extern tree finish_trait_type (enum cp_trait_kind, tree, tree, tsubst_flags_t); extern tree build_lambda_expr (void); extern tree build_lambda_object (tree); extern tree begin_lambda_type (tree); diff --git a/gcc/cp/cxx-pretty-print.cc b/gcc/cp/cxx-pretty-print.cc index 7f4556d0da2..c33919873f1 100644 --- a/gcc/cp/cxx-pretty-print.cc +++ b/gcc/cp/cxx-pretty-print.cc @@ -2625,11 +2625,19 @@ pp_cxx_trait (cxx_pretty_printer *pp, tree t) #undef DEFTRAIT } - pp_cxx_left_paren (pp); - if (TYPE_P (type1)) - pp->type_id (type1); + if (kind == CPTK_TYPE_PACK_ELEMENT) + { + pp_cxx_begin_template_argument_list (pp); + pp->expression (type1); + } else - pp->expression (type1); + { + pp_cxx_left_paren (pp); + if (TYPE_P (type1)) + pp->type_id (type1); + else + pp->expression (type1); + } if (type2) { if (TREE_CODE (type2) != TREE_LIST) @@ -2644,7 +2652,10 @@ pp_cxx_trait (cxx_pretty_printer *pp, tree t) pp->type_id (TREE_VALUE (arg)); } } - pp_cxx_right_paren (pp); + if (kind == CPTK_TYPE_PACK_ELEMENT) + pp_cxx_end_template_argument_list (pp); + else + pp_cxx_right_paren (pp); } // requires-clause: diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc index a6341b98af2..ee1497b7071 100644 --- a/gcc/cp/parser.cc +++ b/gcc/cp/parser.cc @@ -10730,9 +10730,9 @@ cp_parser_expression (cp_parser* parser, cp_id_kind * pidk, static cp_expr cp_parser_constant_expression (cp_parser* parser, - int allow_non_constant_p, - bool *non_constant_p, - bool strict_p) + int allow_non_constant_p /* = 0 */, + bool *non_constant_p /* = NULL */, + bool strict_p /* = false */) { bool saved_integral_constant_expression_p; bool saved_allow_non_integral_constant_expression_p; @@ -10959,7 +10959,10 @@ cp_parser_trait (cp_parser* parser, enum rid keyword) cp_lexer_consume_token (parser->lexer); matching_parens parens; - parens.require_open (parser); + if (kind == CPTK_TYPE_PACK_ELEMENT) + cp_parser_require (parser, CPP_LESS, RT_LESS); + else + parens.require_open (parser); if (kind == CPTK_IS_DEDUCIBLE) { @@ -10972,6 +10975,12 @@ cp_parser_trait (cp_parser* parser, enum rid keyword) /*optional_p=*/false); type1 = cp_parser_lookup_name_simple (parser, type1, token->location); } + else if (kind == CPTK_TYPE_PACK_ELEMENT) + /* __type_pack_element takes an expression as its first argument and uses + template-id syntax instead of function call syntax (for consistency + with Clang). We special case these properties of __type_pack_element + here and elsewhere. */ + type1 = cp_parser_constant_expression (parser); else { type_id_in_expr_sentinel s (parser); @@ -10981,7 +10990,24 @@ cp_parser_trait (cp_parser* parser, enum rid keyword) if (type1 == error_mark_node) return error_mark_node; - if (binary) + if (kind == CPTK_TYPE_PACK_ELEMENT) + { + cp_parser_require (parser, CPP_COMMA, RT_COMMA); + tree rest = cp_parser_enclosed_template_argument_list (parser); + for (tree elt : tree_vec_range (rest)) + { + if (!TYPE_P (elt)) + { + error_at (cp_expr_loc_or_input_loc (elt), + "trailing argument to %<__type_pack_element%> " + "is not a type"); + return error_mark_node; + } + type2 = tree_cons (NULL_TREE, elt, type2); + } + type2 = nreverse (type2); + } + else if (binary) { cp_parser_require (parser, CPP_COMMA, RT_COMMA); @@ -11012,7 +11038,11 @@ cp_parser_trait (cp_parser* parser, enum rid keyword) } location_t finish_loc = cp_lexer_peek_token (parser->lexer)->location; - parens.require_close (parser); + if (kind == CPTK_TYPE_PACK_ELEMENT) + /* cp_parser_enclosed_template_argument_list above already took care + of parsing the closing '>'. */; + else + parens.require_close (parser); /* Construct a location of the form: __is_trivially_copyable(_Tp) @@ -11030,7 +11060,7 @@ cp_parser_trait (cp_parser* parser, enum rid keyword) return cp_expr (finish_bases (type1, true), trait_loc); default: if (type) - return finish_trait_type (kind, type1, type2); + return finish_trait_type (kind, type1, type2, tf_warning_or_error); else return finish_trait_expr (trait_loc, kind, type1, type2); } diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc index 68a056acf8b..f65f2d58b28 100644 --- a/gcc/cp/pt.cc +++ b/gcc/cp/pt.cc @@ -16696,9 +16696,13 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl) case TRAIT_TYPE: { - tree type1 = tsubst (TRAIT_TYPE_TYPE1 (t), args, complain, in_decl); + tree type1 = TRAIT_TYPE_TYPE1 (t); + if (TYPE_P (type1)) + type1 = tsubst (type1, args, complain, in_decl); + else + type1 = tsubst_copy_and_build (type1, args, complain, in_decl); tree type2 = tsubst (TRAIT_TYPE_TYPE2 (t), args, complain, in_decl); - type = finish_trait_type (TRAIT_TYPE_KIND (t), type1, type2); + type = finish_trait_type (TRAIT_TYPE_KIND (t), type1, type2, complain); return cp_build_qualified_type (type, cp_type_quals (t) | cp_type_quals (type), complain | tf_ignore_bad_quals); diff --git a/gcc/cp/semantics.cc b/gcc/cp/semantics.cc index 45e0b0e81d3..a4f30fdac11 100644 --- a/gcc/cp/semantics.cc +++ b/gcc/cp/semantics.cc @@ -4470,6 +4470,36 @@ finish_underlying_type (tree type) return underlying_type; } +/* Implement the __type_pack_element keyword: Return the type + at index IDX within TYPES. */ + +static tree +finish_type_pack_element (tree idx, tree types, tsubst_flags_t complain) +{ + idx = maybe_constant_value (idx); + if (TREE_CODE (idx) != INTEGER_CST || !INTEGRAL_TYPE_P (TREE_TYPE (idx))) + { + if (complain & tf_error) + error ("%<__type_pack_element%> index is not an integral constant"); + return error_mark_node; + } + HOST_WIDE_INT val = tree_to_shwi (idx); + if (val < 0) + { + if (complain & tf_error) + error ("%<__type_pack_element%> index is negative"); + return error_mark_node; + } + tree result = chain_index (val, types); + if (!result) + { + if (complain & tf_error) + error ("%<__type_pack_element%> index is out of range"); + return error_mark_node; + } + return TREE_VALUE (result); +} + /* Implement the __direct_bases keyword: Return the direct base classes of type. */ @@ -12245,7 +12275,8 @@ finish_trait_expr (location_t loc, cp_trait_kind kind, tree type1, tree type2) /* Process a trait type. */ tree -finish_trait_type (cp_trait_kind kind, tree type1, tree type2) +finish_trait_type (cp_trait_kind kind, tree type1, tree type2, + tsubst_flags_t complain) { if (type1 == error_mark_node || type2 == error_mark_node) @@ -12269,17 +12300,23 @@ finish_trait_type (cp_trait_kind kind, tree type1, tree type2) { case CPTK_UNDERLYING_TYPE: return finish_underlying_type (type1); + case CPTK_REMOVE_CV: return cv_unqualified (type1); + case CPTK_REMOVE_REFERENCE: if (TYPE_REF_P (type1)) type1 = TREE_TYPE (type1); return type1; + case CPTK_REMOVE_CVREF: if (TYPE_REF_P (type1)) type1 = TREE_TYPE (type1); return cv_unqualified (type1); + case CPTK_TYPE_PACK_ELEMENT: + return finish_type_pack_element (type1, type2, complain); + #define DEFTRAIT_EXPR(CODE, NAME, ARITY) \ case CPTK_##CODE: #include "cp-trait.def" diff --git a/gcc/cp/tree.cc b/gcc/cp/tree.cc index 16b8fcb7d57..2c22fac17ee 100644 --- a/gcc/cp/tree.cc +++ b/gcc/cp/tree.cc @@ -1792,14 +1792,18 @@ strip_typedefs (tree t, bool *remove_attributes /* = NULL */, break; case TRAIT_TYPE: { - tree type1 = strip_typedefs (TRAIT_TYPE_TYPE1 (t), - remove_attributes, flags); + tree type1 = TRAIT_TYPE_TYPE1 (t); + if (TYPE_P (type1)) + type1 = strip_typedefs (type1, remove_attributes, flags); + else + type1 = strip_typedefs_expr (type1, remove_attributes, flags); tree type2 = strip_typedefs (TRAIT_TYPE_TYPE2 (t), remove_attributes, flags); if (type1 == TRAIT_TYPE_TYPE1 (t) && type2 == TRAIT_TYPE_TYPE2 (t)) result = NULL_TREE; else - result = finish_trait_type (TRAIT_TYPE_KIND (t), type1, type2); + result = finish_trait_type (TRAIT_TYPE_KIND (t), type1, type2, + tf_warning_or_error); } break; case TYPE_PACK_EXPANSION: diff --git a/gcc/cp/typeck.cc b/gcc/cp/typeck.cc index 8b60cbbc167..53ac925a092 100644 --- a/gcc/cp/typeck.cc +++ b/gcc/cp/typeck.cc @@ -1632,7 +1632,7 @@ structural_comptypes (tree t1, tree t2, int strict) case TRAIT_TYPE: if (TRAIT_TYPE_KIND (t1) != TRAIT_TYPE_KIND (t2)) return false; - if (!same_type_p (TRAIT_TYPE_TYPE1 (t1), TRAIT_TYPE_TYPE1 (t2)) + if (!cp_tree_equal (TRAIT_TYPE_TYPE1 (t1), TRAIT_TYPE_TYPE1 (t2)) || !cp_tree_equal (TRAIT_TYPE_TYPE2 (t1), TRAIT_TYPE_TYPE2 (t2))) return false; break; diff --git a/gcc/testsuite/g++.dg/ext/type_pack_element1.C b/gcc/testsuite/g++.dg/ext/type_pack_element1.C new file mode 100644 index 00000000000..46858555502 --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/type_pack_element1.C @@ -0,0 +1,19 @@ +// { dg-do compile { target c++11 } } + +using ty0 = __type_pack_element<0, int>; +using ty0 = __type_pack_element<0, int, char>; +using ty0 = int; + +using ty1 = __type_pack_element<1, int, char>; +using ty1 = __type_pack_element<(6 - 5) * 1, int, char>; +using ty1 = char; + +template +using __const_type_pack_element_t = const __type_pack_element; + +using ty2 = __const_type_pack_element_t<2, int, char, long>; +using ty2 = const long; + +template struct A { }; +using ty3 = __type_pack_element<3, int, int, int, A>; +using ty3 = A; diff --git a/gcc/testsuite/g++.dg/ext/type_pack_element2.C b/gcc/testsuite/g++.dg/ext/type_pack_element2.C new file mode 100644 index 00000000000..1bf77534097 --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/type_pack_element2.C @@ -0,0 +1,14 @@ +// { dg-do compile { target c++11 } } + +int p; + +using type = __type_pack_element<&p, int>; // { dg-error "not an integral constant" } +using type = __type_pack_element<1, int>; // { dg-error "out of range" } +using type = __type_pack_element<2, int, char>; // { dg-error "out of range" } +using type = __type_pack_element<-1, int>; // { dg-error "negative" } + +template +using __type_pack_element_t = __type_pack_element; +// { dg-error "out of range" "" { target *-*-* } .-1 } + +using type = __type_pack_element_t<3, int, char, long>; // { dg-message "here" } diff --git a/gcc/testsuite/g++.dg/ext/type_pack_element3.C b/gcc/testsuite/g++.dg/ext/type_pack_element3.C new file mode 100644 index 00000000000..269f84f464f --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/type_pack_element3.C @@ -0,0 +1,22 @@ +// { dg-do compile { target c++11 } } + +template> +constexpr int f(int) { return 1; } + +template +constexpr int f(...) { return 2; }; + +int p; + +static_assert(f(0) == 1, ""); +static_assert(f(0) == 1, ""); +static_assert(f(0) == 2, ""); +static_assert(f(0) == 2, ""); + +template struct A; +template struct A> { }; +template struct A; + +template struct B; +template struct B> { }; +template struct B; diff --git a/libstdc++-v3/include/bits/utility.h b/libstdc++-v3/include/bits/utility.h index abaaae2dd33..4692aa0c9b0 100644 --- a/libstdc++-v3/include/bits/utility.h +++ b/libstdc++-v3/include/bits/utility.h @@ -224,6 +224,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION #endif // C++17 #endif // C++14 +#if __has_builtin(__type_pack_element) + template + struct _Nth_type + { using type = __type_pack_element<_Np, _Types...>; }; +#else template struct _Nth_type { }; @@ -262,6 +267,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION struct _Nth_type<1, _Tp0, _Tp1, _Tp2, _Rest...> { using type = _Tp1; }; #endif +#endif #if __cplusplus > 202002L #define __cpp_lib_ranges_zip 202110L // for and diff --git a/libstdc++-v3/testsuite/20_util/tuple/element_access/get_neg.cc b/libstdc++-v3/testsuite/20_util/tuple/element_access/get_neg.cc index 9bce0b1caa2..dd0df9be1ea 100644 --- a/libstdc++-v3/testsuite/20_util/tuple/element_access/get_neg.cc +++ b/libstdc++-v3/testsuite/20_util/tuple/element_access/get_neg.cc @@ -61,3 +61,4 @@ test03() // { dg-error "tuple index must be in range" "" { target *-*-* } 0 } // { dg-prune-output "no type named 'type' in .*_Nth_type" } +// { dg-prune-output "'__type_pack_element' index is out of range" }