From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by sourceware.org (Postfix) with ESMTPS id 5562B3858C2F for ; Mon, 9 Jan 2023 15:53:40 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 5562B3858C2F Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=redhat.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=redhat.com DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1673279619; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: in-reply-to:in-reply-to:references:references; bh=8cRDpm9/F27Xu4ctSGrHjpi1SpqytDe8VwAic/ZApD4=; b=e4Oq6dkPNKcIGb6eNx5TJJO3K6MXBD8YwcP2EUfQyM+53p7n0swO/AS+vM5a/LsrsamHLX z4tiEIM8g6BjtHFVSiPQZUpb/iT/E/fsAAUEh4U+Ekvgie7F8g64V1RCCnnP2T5ils8sxl i6libAqfFOlJ9lNDvO1ozpebnkPOlg0= Received: from mail-qv1-f72.google.com (mail-qv1-f72.google.com [209.85.219.72]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_128_GCM_SHA256) id us-mta-149-AJAp7B-RPieWfkv2FsKBdw-1; Mon, 09 Jan 2023 10:53:38 -0500 X-MC-Unique: AJAp7B-RPieWfkv2FsKBdw-1 Received: by mail-qv1-f72.google.com with SMTP id on32-20020a05621444a000b005319444bd2fso5391117qvb.11 for ; Mon, 09 Jan 2023 07:53:37 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=mime-version:references:message-id:in-reply-to:subject:cc:to:date :from:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=8cRDpm9/F27Xu4ctSGrHjpi1SpqytDe8VwAic/ZApD4=; b=ePas622+RWhN26H/5WDko6z09ELHVRam7tufU56EmiUDiscrElPS6RkK1HKlieQe94 OafObfQzldqBHinJ1emTwF34b2EY+W2VvEzy5wZuLtePEKCmRnxs6Qd2y5Np5JiG3prE IM+5ETByoLtcl2Th6Jm5Pk5sbxaPJ0s/dQopLcP6vPhqXyZJ/uchaDZoAAAuLRrDM+YG XF/EXgp8bDvy7/sUFRqZLoX8pWX7+ibduy7qWfQKAV2z5aMhEDAKdxjRWXt9Y+4f5cRw TipNNNPztoyfaKGFkU4Z6Txp703iImI6pbYmqfkog3P6zx7p83X4iA+btP8FI97JJm1c TIOQ== X-Gm-Message-State: AFqh2kpyMi6J1fnuBeiMMVY+tMFs7h+v+hbxlcmx8mK78sGl7HBmIcQv BAEnLkrsbqJiSJ6NtV6y9RzNYd+UetF2i2iTE+nM1p1LhTyJhYz9qxbR+tmqDLSiUn5OtS6ACgt QIOrKi68xF78rMCRcVw== X-Received: by 2002:ac8:5213:0:b0:3a9:87fa:533a with SMTP id r19-20020ac85213000000b003a987fa533amr88342487qtn.1.1673279617403; Mon, 09 Jan 2023 07:53:37 -0800 (PST) X-Google-Smtp-Source: AMrXdXtHjTf34cSWoWKYVByLW1q8+JhKC7ilx64utriZ3u56W/sv92jiHqgDKU6hJbJfLwBlKnAE2w== X-Received: by 2002:ac8:5213:0:b0:3a9:87fa:533a with SMTP id r19-20020ac85213000000b003a987fa533amr88342461qtn.1.1673279617056; Mon, 09 Jan 2023 07:53:37 -0800 (PST) Received: from [192.168.1.130] (ool-457670bb.dyn.optonline.net. [69.118.112.187]) by smtp.gmail.com with ESMTPSA id u15-20020a05620a454f00b006ce76811a07sm5592750qkp.75.2023.01.09.07.53.36 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 09 Jan 2023 07:53:36 -0800 (PST) From: Patrick Palka X-Google-Original-From: Patrick Palka Date: Mon, 9 Jan 2023 10:53:35 -0500 (EST) To: Patrick Palka cc: Jonathan Wakely , libstdc++@gcc.gnu.org, gcc-patches@gcc.gnu.org, Marek Polacek Subject: Re: [PATCH] c++: Define built-in for std::tuple_element [PR100157] In-Reply-To: <2c2d32db-170d-d6b7-d04f-6cf27e157321@idea> Message-ID: References: <20220707171436.1419387-1-jwakely@redhat.com> <2c2d32db-170d-d6b7-d04f-6cf27e157321@idea> MIME-Version: 1.0 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Type: text/plain; charset=US-ASCII X-Spam-Status: No, score=-13.9 required=5.0 tests=BAYES_00,DKIMWL_WL_HIGH,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,GIT_PATCH_0,RCVD_IN_DNSWL_NONE,RCVD_IN_MSPIKE_H2,SPF_HELO_NONE,SPF_NONE,TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: On Wed, 5 Oct 2022, Patrick Palka wrote: > On Thu, 7 Jul 2022, Jonathan Wakely via Gcc-patches wrote: > > > This adds a new built-in to replace the recursive class template > > instantiations done by traits such as std::tuple_element and > > std::variant_alternative. The purpose is to select the Nth type from a > > list of types, e.g. __builtin_type_pack_element(1, char, int, float) is > > int. > > > > For a pathological example tuple_element_t<1000, tuple<2000 types...>> > > the compilation time is reduced by more than 90% and the memory used by > > the compiler is reduced by 97%. In realistic examples the gains will be > > much smaller, but still relevant. > > > > Clang has a similar built-in, __type_pack_element, but that's a > > "magic template" built-in using <> syntax, which GCC doesn't support. So > > this provides an equivalent feature, but as a built-in function using > > parens instead of <>. I don't really like the name "type pack element" > > (it gives you an element from a pack of types) but the semi-consistency > > with Clang seems like a reasonable argument in favour of keeping the > > name. I'd be open to alternative names though, e.g. __builtin_nth_type > > or __builtin_type_at_index. > > Rather than giving the trait a different name from __type_pack_element, > I wonder if we could just special case cp_parser_trait to expect <> > instead of parens for this trait? > > Btw the frontend recently got a generic TRAIT_TYPE tree code, which gets > rid of much of the boilerplate of adding a new type-yielding built-in > trait, see e.g. cp-trait.def. Here's a tested patch based on Jonathan's original patch that implements the built-in in terms of TRAIT_TYPE, names it __type_pack_element instead of __builtin_type_pack_element, and treats invocations of it like a template-id instead of a call (to match Clang). -- >8 -- Subject: [PATCH] c++: Define built-in for std::tuple_element [PR100157] This adds a new built-in to replace the recursive class template instantiations done by traits such as std::tuple_element and std::variant_alternative. The purpose is to select the Nth type from a list of types, e.g. __type_pack_element<1, char, int, float> is int. We implement it as a special kind of TRAIT_TYPE. For a pathological example tuple_element_t<1000, tuple<2000 types...>> the compilation time is reduced by more than 90% and the memory used by the compiler is reduced by 97%. In realistic examples the gains will be much smaller, but still relevant. Unlike the other built-in traits, __type_pack_element uses template-id syntax instead of call syntax and is SFINAE-enabled, matching Clang's implementation. And like the other built-in traits, it's not mangleable so we can't use it directly in function signatures. Some caveats: * Clang's version of the built-in seems to act like a "magic template" that can e.g. be used as a template template argument. For simplicity we implement it in a more ad-hoc way. * Our parsing of the <>'s in __type_pack_element<...> is currently rudimentary and doesn't try to disambiguate a trailing >> vs > > as cp_parser_enclosed_template_argument_list does. Co-authored-by: Jonathan Wakely PR c++/100157 gcc/cp/ChangeLog: * cp-trait.def (TYPE_PACK_ELEMENT): Define. * cp-tree.h (finish_trait_type): Add complain parameter. * cxx-pretty-print.cc (pp_cxx_trait): Handle CPTK_TYPE_PACK_ELEMENT. * parser.cc (cp_parser_constant_expression): Document default arguments. (cp_parser_trait): Handle CPTK_TYPE_PACK_ELEMENT. Pass tf_warning_or_error to finish_trait_type. * pt.cc (tsubst) : Handle CPTK_TYPE_PACK_ELEMENT. * semantics.cc (finish_type_pack_element): Define. (finish_trait_type): Add complain parameter. Handle CPTK_TYPE_PACK_ELEMENT. * tree.cc (strip_typedefs): Pass tf_warning_or_error to finish_trait_type. * typeck.cc (structural_comptypes) : Use cp_tree_equal instead of same_type_p for TRAIT_TYPE_TYPE. libstdc++-v3/ChangeLog: * include/bits/utility.h (_Nth_type): Conditionally define using __type_pack_element. gcc/testsuite/ChangeLog: * g++.dg/ext/type_pack_element1.C: New test. * g++.dg/ext/type_pack_element2.C: New test. * g++.dg/ext/type_pack_element3.C: New test. --- gcc/cp/cp-trait.def | 1 + gcc/cp/cp-tree.h | 2 +- gcc/cp/cxx-pretty-print.cc | 17 ++++++-- gcc/cp/parser.cc | 36 ++++++++++++----- gcc/cp/pt.cc | 8 +++- gcc/cp/semantics.cc | 39 ++++++++++++++++++- gcc/cp/tree.cc | 3 +- gcc/cp/typeck.cc | 2 +- gcc/testsuite/g++.dg/ext/type_pack_element1.C | 19 +++++++++ gcc/testsuite/g++.dg/ext/type_pack_element2.C | 14 +++++++ gcc/testsuite/g++.dg/ext/type_pack_element3.C | 14 +++++++ libstdc++-v3/include/bits/utility.h | 6 +++ 12 files changed, 142 insertions(+), 19 deletions(-) create mode 100644 gcc/testsuite/g++.dg/ext/type_pack_element1.C create mode 100644 gcc/testsuite/g++.dg/ext/type_pack_element2.C create mode 100644 gcc/testsuite/g++.dg/ext/type_pack_element3.C diff --git a/gcc/cp/cp-trait.def b/gcc/cp/cp-trait.def index 823899a26c5..63f6b101eeb 100644 --- a/gcc/cp/cp-trait.def +++ b/gcc/cp/cp-trait.def @@ -89,6 +89,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 1f4967c2ba0..f3cc2c5874c 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -7764,7 +7764,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 8ca1b8f234a..07a0406e491 100644 --- a/gcc/cp/cxx-pretty-print.cc +++ b/gcc/cp/cxx-pretty-print.cc @@ -2625,8 +2625,16 @@ pp_cxx_trait (cxx_pretty_printer *pp, tree t) #undef DEFTRAIT } - pp_cxx_left_paren (pp); - pp->type_id (type1); + if (kind == CPTK_TYPE_PACK_ELEMENT) + { + pp_cxx_begin_template_argument_list (pp); + pp->expression (type1); + } + else + { + pp_cxx_left_paren (pp); + pp->type_id (type1); + } if (type2) { if (TREE_CODE (type2) != TREE_LIST) @@ -2641,7 +2649,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 8b1658decba..c6e31aa6f3f 100644 --- a/gcc/cp/parser.cc +++ b/gcc/cp/parser.cc @@ -10683,9 +10683,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; @@ -10912,12 +10912,25 @@ cp_parser_trait (cp_parser* parser, enum rid keyword) cp_lexer_consume_token (parser->lexer); matching_parens parens; - parens.require_open (parser); - { - type_id_in_expr_sentinel s (parser); - type1 = cp_parser_type_id (parser); - } + /* Unlike the other built-in traits, __type_pack_element is unique in that + it takes an expression as its first argument and it uses template-id + syntax instead of function call syntax (for compatibility with Clang). + We special case these properties of __type_pack_element here and elsewhere. + + TODO: Generalize the trait infrastructure so that __type_pack_element + is no longer a special case. */ + if (kind == CPTK_TYPE_PACK_ELEMENT) + { + cp_parser_require (parser, CPP_LESS, RT_LESS); + type1 = cp_parser_constant_expression (parser); + } + else + { + parens.require_open (parser); + type_id_in_expr_sentinel s (parser); + type1 = cp_parser_type_id (parser); + } if (type1 == error_mark_node) return error_mark_node; @@ -10953,7 +10966,10 @@ 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_require (parser, CPP_GREATER, RT_GREATER); + else + parens.require_close (parser); /* Construct a location of the form: __is_trivially_copyable(_Tp) @@ -10971,7 +10987,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 cbe5898b553..2e83970a252 100644 --- a/gcc/cp/pt.cc +++ b/gcc/cp/pt.cc @@ -16576,9 +16576,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 (TRAIT_TYPE_KIND (t) != CPTK_TYPE_PACK_ELEMENT) + 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 ef5bf2430b1..af9edf59b3b 100644 --- a/gcc/cp/semantics.cc +++ b/gcc/cp/semantics.cc @@ -4457,6 +4457,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. */ @@ -12213,7 +12243,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) @@ -12237,17 +12268,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 faf01616f87..dd5b0662235 100644 --- a/gcc/cp/tree.cc +++ b/gcc/cp/tree.cc @@ -1799,7 +1799,8 @@ strip_typedefs (tree t, bool *remove_attributes /* = NULL */, 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 69b1268cfec..f5548737e4c 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..363cfa92514 --- /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<-1, int>; // { dg-error "negative" } +using type = __type_pack_element<2, int, char>; // { dg-error "out of range" } + +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..5cba03d4b81 --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/type_pack_element3.C @@ -0,0 +1,14 @@ +// { 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, ""); diff --git a/libstdc++-v3/include/bits/utility.h b/libstdc++-v3/include/bits/utility.h index 6a192e27836..5d524d33b4c 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 _GLIBCXX_END_NAMESPACE_VERSION } // namespace -- 2.39.0.198.ga38d39a4c5