[{"id":3675940,"web_url":"http://patchwork.ozlabs.org/comment/3675940/","msgid":"<CAKvuMXBJMd=813ixZmS-_+MuP8_EJf8SrtnbvEfueM2spptYZA@mail.gmail.com>","list_archive_url":null,"date":"2026-04-10T15:29:13","subject":"Re: [PATCH] c++, libstdc++: Implement LWG4483 - Multidimensional\n arrays are not supported by meta::reflect_constant_array and related\n functions","submitter":{"id":90409,"url":"http://patchwork.ozlabs.org/api/people/90409/","name":"Tomasz Kamiński","email":"tkaminsk@redhat.com"},"content":"On Fri, Apr 10, 2026 at 5:15 PM Jakub Jelinek <jakub@redhat.com> wrote:\n\n> Hi!\n>\n> The following patch attempts to implement LWG4483.  As written in the\n> approved resolution, some checks are done on strip_array_types (valuet)\n> rather than on valuet and one is skipped.  Tomasz on IRC reasoned why\n> input_range should otherwise already ensure we see similar type, so just\n> for the possibility of fuzzed <meta> the patch adds some verification.\n> And as the array cases are contiguous, instead of actually recursing (for\n> which we'd need to have lvalue of the *it rather than prvalue) it just\n> walks the CONSTRUCTORs for the arrays and handles the elts in there\n> recursively.\n> The <meta> changes do exactly what the LWG4483 change says to do.\n>\n> Tested on x86_64-linux, ok for trunk?\n>\nLibrary test looks good to me. Just a small suggestion for additional test.\n(It occurred to me after seeing the bar function).\n\n>\n> 2026-04-10  Jakub Jelinek  <jakub@redhat.com>\n>\n>         * reflect.cc (adjust_array_elt): New function.\n>         (get_range_elts): Implement LWG4483 - Multidimensional arrays are\n> not\n>         supported by meta::reflect_constant_array and related functions.\n>         Handle ARRAY_TYPE valuet.  Don't unshare_expr in the class valuet\n> case,\n>         get_template_param_object will unshare.\n>\n>         * g++.dg/reflect/reflect_constant_array9.C: New test.\n>         * g++.dg/reflect/reflect_constant_array10.C: New test.\n>         * g++.dg/reflect/reflect_constant_array11.C: New test.\n>         * g++.dg/reflect/define_static_array6.C: New test.\n>         * g++.dg/reflect/define_static_object2.C: Uncomment older tests and\n>         fix them, add tests for unions.\n>\n>         * include/std/meta (define_static_object): Adjust for LWG4483\n> changes\n>         - handle unions and arrays differently.\n>\n> --- gcc/cp/reflect.cc.jj        2026-04-10 08:45:20.716811803 +0200\n> +++ gcc/cp/reflect.cc   2026-04-10 15:32:30.747654790 +0200\n> @@ -394,6 +394,47 @@ replace_parm_r (tree *tp, int *walk_subt\n>  static tree throw_exception (location_t, const constexpr_ctx *, const\n> char *,\n>                              tree, bool *, tree *);\n>\n> +/* Helper function for get_range_elts, handle adjustment of ARRAY_TYPE\n> elts\n> +   of a retvec.  */\n> +\n> +static tree\n> +adjust_array_elt (location_t loc, const constexpr_ctx *ctx, tree valuet,\n> +                 tree expr, tree fun, bool *non_constant_p, tree\n> *jump_target)\n> +{\n> +  if (TREE_CODE (valuet) == ARRAY_TYPE)\n> +    {\n> +      if (TREE_CODE (expr) != CONSTRUCTOR\n> +         || TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)\n> +       return throw_exception (loc, ctx, \"reflect_constant_array failed\",\n> +                               fun, non_constant_p, jump_target);\n> +      unsigned int i;\n> +      tree val;\n> +      FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expr), i, val)\n> +       {\n> +         CONSTRUCTOR_ELT (expr, i)->value\n> +           = adjust_array_elt (loc, ctx, TREE_TYPE (valuet), val, fun,\n> +                               non_constant_p, jump_target);\n> +         if (*jump_target || *non_constant_p)\n> +           return NULL_TREE;\n> +       }\n> +      return expr;\n> +    }\n> +  else if (INTEGRAL_TYPE_P (valuet))\n> +    {\n> +      if (TREE_CODE (expr) == INTEGER_CST)\n> +       return expr;\n> +      return throw_exception (loc, ctx, \"array element not a constant\n> integer\",\n> +                             fun, non_constant_p, jump_target);\n> +    }\n> +  expr = convert_reflect_constant_arg (valuet, expr);\n> +  if (expr == error_mark_node)\n> +    return throw_exception (loc, ctx, \"reflect_constant failed\",\n> +                           fun, non_constant_p, jump_target);\n> +  if (VAR_P (expr))\n> +    expr = DECL_INITIAL (expr);\n> +  return expr;\n> +}\n> +\n>  /* Kinds for get_range_elts.  */\n>\n>  enum get_range_elts_kind {\n> @@ -513,23 +554,24 @@ get_range_elts (location_t loc, const co\n>         }\n>        if (kind == REFLECT_CONSTANT_ARRAY)\n>         {\n> -         if (!structural_type_p (valuet))\n> +         tree valuete = strip_array_types (valuet);\n> +         if (!structural_type_p (valuete))\n>             {\n>               if (!cxx_constexpr_quiet_p (ctx))\n>                 {\n>                   auto_diagnostic_group d;\n>                   error_at (loc, \"%<reflect_constant_array%> argument with\n> \"\n>                                  \"%qT which is not a structural type\",\n> inst);\n> -                 structural_type_p (valuet, true);\n> +                 structural_type_p (valuete, true);\n>                 }\n>               *non_constant_p = true;\n>               return NULL_TREE;\n>             }\n>           TREE_VEC_ELT (args, 0)\n> -           = build_stub_type (valuet,\n> -                              cp_type_quals (valuet) | TYPE_QUAL_CONST,\n> +           = build_stub_type (valuete,\n> +                              cp_type_quals (valuete) | TYPE_QUAL_CONST,\n>                                false);\n> -         if (!is_xible (INIT_EXPR, valuet, args))\n> +         if (!is_xible (INIT_EXPR, valuete, args))\n>             {\n>               if (!cxx_constexpr_quiet_p (ctx))\n>                 error_at (loc, \"%<reflect_constant_array%> argument with\n> %qT \"\n> @@ -551,7 +593,23 @@ get_range_elts (location_t loc, const co\n>             }\n>           tree referencet = TYPE_MAIN_VARIANT (instr);\n>           TREE_VEC_ELT (args, 0) = referencet;\n> -         if (!is_xible (INIT_EXPR, valuet, args))\n> +         if (valuete != valuet)\n> +           {\n> +             tree rt = referencet;\n> +             if (TYPE_REF_P (rt))\n> +               rt = TREE_TYPE (rt);\n> +             if (!same_type_ignoring_top_level_qualifiers_p (valuet, rt))\n> +               {\n> +                 if (!cxx_constexpr_quiet_p (ctx))\n> +                   error_at (loc, \"%<reflect_constant_array%> argument\n> with \"\n> +                                  \"%qT which is not compatible with %qT \"\n> +                                  \"%<std::ranges::range_reference_t%>\",\n> +                             inst, referencet);\n> +                 *non_constant_p = true;\n> +                 return NULL_TREE;\n> +               }\n> +           }\n> +         else if (!is_xible (INIT_EXPR, valuet, args))\n>             {\n>               if (!cxx_constexpr_quiet_p (ctx))\n>                 error_at (loc, \"%<reflect_constant_array%> argument with\n> %qT \"\n> @@ -595,12 +653,22 @@ get_range_elts (location_t loc, const co\n>         else\n>           {\n>             gcc_assert (kind == REFLECT_CONSTANT_ARRAY);\n> +           if (TREE_CODE (valuet) == ARRAY_TYPE)\n> +             {\n> +               retvec[i]\n> +                 = adjust_array_elt (loc, ctx, valuet,\n> +                                     unshare_expr (retvec[i]), fun,\n> +                                     non_constant_p, jump_target);\n> +               if (*jump_target || *non_constant_p)\n> +                 return NULL_TREE;\n> +               continue;\n> +             }\n>             tree expr = convert_reflect_constant_arg (valuet, retvec[i]);\n>             if (expr == error_mark_node)\n>               return throw_exception (loc, ctx, \"reflect_constant failed\",\n>                                       fun, non_constant_p, jump_target);\n>             if (VAR_P (expr))\n> -             expr = unshare_expr (DECL_INITIAL (expr));\n> +             expr = DECL_INITIAL (expr);\n>             retvec[i] = expr;\n>           }\n>        }\n> --- gcc/testsuite/g++.dg/reflect/reflect_constant_array9.C.jj   2026-04-10\n> 14:58:28.892432782 +0200\n> +++ gcc/testsuite/g++.dg/reflect/reflect_constant_array9.C      2026-04-10\n> 15:46:45.523823103 +0200\n> @@ -0,0 +1,28 @@\n> +// LWG4483 - Multidimensional arrays are not supported by\n> +// meta::reflect_constant_array and related functions.\n> +// { dg-do compile { target c++26 } }\n> +// { dg-additional-options \"-freflection\" }\n> +\n> +#include <meta>\n> +\n> +consteval auto\n> +foo ()\n> +{\n> +  int a[3][3][3];\n> +  for (int i = 0; i < 3; ++i)\n> +    for (int j = 0; j < 3; ++j)\n> +      for (int k = 0; k < 3; ++k)\n> +       a[i][j][k] = i + j + k;\n> +  return std::meta::reflect_constant_array (a);\n> +}\n> +\n> +static_assert (foo () == foo ());\n> +static_assert (type_of (foo ()) == ^^const int [3][3][3]);\n> +constexpr auto &m = [: foo () :];\n> +consteval {\n> +  for (int i = 0; i < 3; ++i)\n> +    for (int j = 0; j < 3; ++j)\n> +      for (int k = 0; k < 3; ++k)\n> +       if (m[i][j][k] != i + j + k)\n> +         throw 1;\n> +}\n> --- gcc/testsuite/g++.dg/reflect/reflect_constant_array10.C.jj  2026-04-10\n> 16:43:43.192287885 +0200\n> +++ gcc/testsuite/g++.dg/reflect/reflect_constant_array10.C     2026-04-10\n> 16:57:20.060192312 +0200\n> @@ -0,0 +1,53 @@\n> +// LWG4483 - Multidimensional arrays are not supported by\n> +// meta::reflect_constant_array and related functions.\n> +// { dg-do compile { target c++26 } }\n> +// { dg-additional-options \"-freflection\" }\n> +\n> +#include <ranges>\n> +#include <meta>\n> +\n> +consteval auto\n> +foo ()\n> +{\n> +  int a[3][3][3];\n> +  for (int i = 0; i < 3; ++i)\n> +    for (int j = 0; j < 3; ++j)\n> +      for (int k = 0; k < 3; ++k)\n> +       a[i][j][k] = i + 3 * j + 9 * k;\n> +  std::span <int[3][3]> b = a;\n> +  return std::meta::reflect_constant_array (b);\n> +}\n> +\n> +static_assert (foo () == foo ());\n> +static_assert (type_of (foo ()) == ^^const int [3][3][3]);\n> +constexpr auto &m = [: foo () :];\n>\nCould you add a line:\n     static_assert(foo() ==  std::meta::reflect_constant_array(std::span\n<int[3][3]>(m)));\nI.e. we check that only content matters, and not type of the range.\n\n> +consteval {\n> +  for (int i = 0; i < 3; ++i)\n> +    for (int j = 0; j < 3; ++j)\n> +      for (int k = 0; k < 3; ++k)\n> +       if (m[i][j][k] != i + 3 * j + 9 * k)\n> +         throw 1;\n> +}\n> +\n> +consteval auto\n> +bar ()\n> +{\n> +  int a[3][3][3];\n> +  for (int i = 0; i < 3; ++i)\n> +    for (int j = 0; j < 3; ++j)\n> +      for (int k = 0; k < 3; ++k)\n> +       a[i][j][k] = i + 3 * j + 9 * k;\n> +  std::span <int[3][3]> b = a;\n> +  return std::meta::reflect_constant_array (b | std::views::reverse);\n>\n+}\n> +\n> +static_assert (bar () == bar ());\n>\n\n\n> +static_assert (type_of (bar ()) == ^^const int [3][3][3]);\n> +constexpr auto &n = [: bar () :];\n> +consteval {\n> +  for (int i = 0; i < 3; ++i)\n> +    for (int j = 0; j < 3; ++j)\n> +      for (int k = 0; k < 3; ++k)\n> +       if (n[i][j][k] != (2 - i) + 3 * j + 9 * k)\n> +         throw 1;\n> +}\n> --- gcc/testsuite/g++.dg/reflect/reflect_constant_array11.C.jj  2026-04-10\n> 17:00:44.179663685 +0200\n> +++ gcc/testsuite/g++.dg/reflect/reflect_constant_array11.C     2026-04-10\n> 17:05:50.683365136 +0200\n> @@ -0,0 +1,18 @@\n> +// { dg-do compile { target c++26 } }\n> +// { dg-additional-options \"-freflection\" }\n> +// Test std::meta::reflect_constant_string.\n> +\n> +#include <meta>\n> +#include <ranges>\n> +#include <span>\n> +\n> +using namespace std::meta;\n> +\n> +struct A { int a, b; mutable int c; };\n> +constexpr A aa[2] = { { 1, 2, 3 }, { 4, 5, 6 } };\n> +constexpr auto a = reflect_constant_array (aa);\n> +// { dg-error \"'reflect_constant_array' argument with\n> 'std::ranges::range_value_t<const A \\\\\\[2\\\\\\]>' \\\\\\{aka 'A'\\\\\\} which is\n> not a structural type\" \"\" { target *-*-* } .-1 }\n> +struct B { constexpr B (int x, int y) : a (x), b (y) {} constexpr ~B ()\n> {} B (const B &) = delete; int a, b; };\n> +constexpr B b[2][2] = { { { 1, 2 }, { 2, 3 } }, { { 3, 4 }, { 4, 5 } } };\n> +constexpr auto c = reflect_constant_array (b);\n> +// { dg-error \"'reflect_constant_array' argument with\n> 'std::ranges::range_value_t<const B \\\\\\[2\\\\\\]\\\\\\[2\\\\\\]>' \\\\\\{aka 'B\n> \\\\\\[2\\\\\\]'\\\\\\} which is not copy constructible\" \"\" { target *-*-* } .-1 }\n> --- gcc/testsuite/g++.dg/reflect/define_static_array6.C.jj      2026-04-10\n> 15:44:52.229788936 +0200\n> +++ gcc/testsuite/g++.dg/reflect/define_static_array6.C 2026-04-10\n> 15:52:38.099857297 +0200\n> @@ -0,0 +1,27 @@\n> +// LWG4483 - Multidimensional arrays are not supported by\n> +// meta::reflect_constant_array and related functions.\n> +// { dg-do compile { target c++26 } }\n> +// { dg-additional-options \"-freflection\" }\n> +\n> +#include <meta>\n> +\n> +consteval auto\n> +foo ()\n> +{\n> +  int a[3][3][3];\n> +  for (int i = 0; i < 3; ++i)\n> +    for (int j = 0; j < 3; ++j)\n> +      for (int k = 0; k < 3; ++k)\n> +       a[i][j][k] = i + j + k;\n> +  return std::define_static_array (a);\n> +}\n> +\n> +static_assert (foo ().size () == 3);\n> +constexpr auto *m = foo ().data ();\n> +consteval {\n> +  for (int i = 0; i < 3; ++i)\n> +    for (int j = 0; j < 3; ++j)\n> +      for (int k = 0; k < 3; ++k)\n> +       if (m[i][j][k] != i + j + k)\n> +         throw 1;\n> +}\n> --- gcc/testsuite/g++.dg/reflect/define_static_object2.C.jj     2026-03-27\n> 10:17:16.120298331 +0100\n> +++ gcc/testsuite/g++.dg/reflect/define_static_object2.C        2026-04-10\n> 16:09:20.261858550 +0200\n> @@ -1,3 +1,5 @@\n> +// LWG4483 - Multidimensional arrays are not supported by\n> +// meta::reflect_constant_array and related functions.\n>  // { dg-do compile { target c++26 } }\n>  // { dg-additional-options \"-freflection\" }\n>  // Test std::define_static_object.\n> @@ -5,14 +7,19 @@\n>  #include <meta>\n>\n>  constexpr int arr[]{1, 2, 3};\n> -// LWG4483 use extract(reflect_constant_array())\n> -// constexpr const int(*ptr)[3] = std::define_static_object(arr);\n> -// static_assert( *ptr == std::define_static_array(arr).data() );\n> -// static_assert( ptr = &std::meta::constant_of(arr) );\n> +constexpr const int (*ptr)[3] = std::define_static_object (arr);\n> +static_assert (*ptr == std::define_static_array (arr).data ());\n> +static_assert (ptr == &[: std::meta::constant_of (^^arr) :]);\n>\n>  constexpr int marr[3][3]{1, 2, 3};\n> -// LWG4483 array are not structural so this fail\n> -// constexpr const int(*mptr)[3][3] = std::define_static_object(marr);\n> -// static_assert( *mptr == std::define_static_array(marr).data() );\n> -// static_assert( mptr = &std::meta::constant_of(marr) );\n> +constexpr const int (*mptr)[3][3] = std::define_static_object (marr);\n> +static_assert (*mptr == std::define_static_array (marr).data ());\n> +static_assert (mptr == &[: std::meta::constant_of (^^marr) :]);\n>\n> +union U { int a; long long b; };\n> +constexpr U u = { .a = 42 };\n> +constexpr const U *up = std::define_static_object (u);\n> +static_assert (up->a == 42);\n> +constexpr U v = { .b = 43LL };\n> +constexpr const U *vp = std::define_static_object (v);\n> +static_assert (vp->b == 43LL);\n> --- libstdc++-v3/include/std/meta.jj    2026-04-08 07:49:13.477647992 +0200\n> +++ libstdc++-v3/include/std/meta       2026-04-10 15:57:25.423013150 +0200\n> @@ -682,11 +682,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n>      define_static_object(_Tp&& __t)\n>      {\n>        using _Up = remove_cvref_t<_Tp>;\n> -      if constexpr (meta::is_class_type(^^_Up))\n> +      if constexpr (meta::is_class_type(^^_Up) ||\n> meta::is_union_type(^^_Up))\n>         {\n>           auto __cst = meta::reflect_constant(std::forward<_Tp>(__t));\n>           return std::addressof(meta::extract<const _Up&>(__cst));\n>         }\n> +      else if constexpr (meta::is_array_type(^^_Up))\n> +       {\n> +         auto __cst =\n> meta::reflect_constant_array(std::forward<_Tp>(__t));\n> +         return std::addressof(meta::extract<const _Up&>(__cst));\n> +       }\n>        else\n>         return std::define_static_array(span(std::addressof(__t),\n> 1)).data();\n>      }\n>\n>         Jakub\n>\n>","headers":{"Return-Path":"<gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org>","X-Original-To":["incoming@patchwork.ozlabs.org","gcc-patches@gcc.gnu.org"],"Delivered-To":["patchwork-incoming@legolas.ozlabs.org","gcc-patches@gcc.gnu.org"],"Authentication-Results":["legolas.ozlabs.org;\n\tdkim=pass (1024-bit key;\n unprotected) header.d=redhat.com header.i=@redhat.com header.a=rsa-sha256\n header.s=mimecast20190719 header.b=GCcnhBWl;\n\tdkim-atps=neutral","legolas.ozlabs.org;\n spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org\n (client-ip=2620:52:6:3111::32; helo=vm01.sourceware.org;\n envelope-from=gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org;\n receiver=patchwork.ozlabs.org)","sourceware.org;\n\tdkim=pass (1024-bit key,\n unprotected) header.d=redhat.com header.i=@redhat.com header.a=rsa-sha256\n header.s=mimecast20190719 header.b=GCcnhBWl","sourceware.org; dmarc=pass (p=quarantine dis=none)\n header.from=redhat.com","sourceware.org; spf=pass smtp.mailfrom=redhat.com","server2.sourceware.org;\n arc=none smtp.remote-ip=170.10.133.124"],"Received":["from vm01.sourceware.org (vm01.sourceware.org\n [IPv6:2620:52:6:3111::32])\n\t(using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits)\n\t key-exchange x25519 server-signature ECDSA (secp384r1) server-digest SHA384)\n\t(No client certificate requested)\n\tby legolas.ozlabs.org (Postfix) with ESMTPS id 4fsgjD5fzjz1yGb\n\tfor <incoming@patchwork.ozlabs.org>; Sat, 11 Apr 2026 01:30:07 +1000 (AEST)","from vm01.sourceware.org (localhost [127.0.0.1])\n\tby sourceware.org (Postfix) with ESMTP id 609E94BA23CD\n\tfor <incoming@patchwork.ozlabs.org>; Fri, 10 Apr 2026 15:30:05 +0000 (GMT)","from us-smtp-delivery-124.mimecast.com\n (us-smtp-delivery-124.mimecast.com [170.10.133.124])\n by sourceware.org (Postfix) with ESMTP id 8EC384BA2E15\n for <gcc-patches@gcc.gnu.org>; Fri, 10 Apr 2026 15:29:27 +0000 (GMT)","from mail-yw1-f197.google.com (mail-yw1-f197.google.com\n [209.85.128.197]) by relay.mimecast.com with ESMTP with STARTTLS\n (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id\n us-mta-196-NIFguEhWM4CCrLIXQqVFFA-1; Fri, 10 Apr 2026 11:29:25 -0400","by mail-yw1-f197.google.com with SMTP id\n 00721157ae682-7aa1e8734d4so47049997b3.0\n for <gcc-patches@gcc.gnu.org>; Fri, 10 Apr 2026 08:29:25 -0700 (PDT)"],"DKIM-Filter":["OpenDKIM Filter v2.11.0 sourceware.org 609E94BA23CD","OpenDKIM Filter v2.11.0 sourceware.org 8EC384BA2E15"],"DMARC-Filter":"OpenDMARC Filter v1.4.2 sourceware.org 8EC384BA2E15","ARC-Filter":"OpenARC Filter v1.0.0 sourceware.org 8EC384BA2E15","ARC-Seal":"i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1775834967; cv=none;\n b=nlshIuhDIVXtcF1ckwu0FEMekmpAmaYbeDdpRN9yF2YCZO4u/wYoatb/PCGo75VGeK4K6/Hu61ePpmMiBS8K9uNSGvvSHgx/BRnTSiqg0HhX+MVUFTovSv4eO0rGQBxiW4TR2Of3eadllGQFQJQHErH4T1Uvy1jRibAaHca/Htg=","ARC-Message-Signature":"i=1; a=rsa-sha256; d=sourceware.org; s=key;\n t=1775834967; c=relaxed/simple;\n bh=mtulQTkP/CUJnSDWW+zvy2I68fheu0AgHOL2LDROvA8=;\n h=DKIM-Signature:MIME-Version:From:Date:Message-ID:Subject:To;\n b=SNLIOFQgD8YVt2e46IxzKIJTn/4LKKXX4vgP7VDgMfWXMa1kgk+rmOvjyVwul0OZjcIMBe9/mEFcV0RaqgQrrDeF8ukmDZA1Jgt095UDlweZr/2uQpaLzx1aqEZeIIg6FwqjtfYdQlNn/xw2NeNgtyUfv/gdDJir5Lawh1A33w8=","ARC-Authentication-Results":"i=1; server2.sourceware.org","DKIM-Signature":"v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com;\n s=mimecast20190719; t=1775834967;\n h=from:from:reply-to:subject:subject:date:date:message-id:message-id:\n to:to:cc:cc:mime-version:mime-version:content-type:content-type:\n in-reply-to:in-reply-to:references:references;\n bh=Lp1QAkqclHJmmhJdLHr85pQ7GIzL0po62NUYe/BrAk8=;\n b=GCcnhBWlQJe6nzfHfRjvtL7BAvFwXAVdHDhl2wjVa5vzeg1ALSjpQRZkYA+bJeylZdlvHG\n mE0BvQBxalbAstFkiLLCRqz2JHPwqIaYaZyH9++UmV+gKYfg6bdn2aKWCSiwTbrDBNkG/h\n BBIm0NkCusVDnfCkj85xcF1hD+FL50Q=","X-MC-Unique":"NIFguEhWM4CCrLIXQqVFFA-1","X-Mimecast-MFC-AGG-ID":"NIFguEhWM4CCrLIXQqVFFA_1775834965","X-Google-DKIM-Signature":"v=1; a=rsa-sha256; c=relaxed/relaxed;\n d=1e100.net; s=20251104; t=1775834965; x=1776439765;\n h=cc:to:subject:message-id:date:from:in-reply-to:references\n :mime-version:x-gm-gg:x-gm-message-state:from:to:cc:subject:date\n :message-id:reply-to;\n bh=Lp1QAkqclHJmmhJdLHr85pQ7GIzL0po62NUYe/BrAk8=;\n b=anqN4I3+1E8q4g/HEzASRE0leg6r6ofOlhQqqTXAqcz3RuaJUJRdF6GV9AypEv0zdD\n C+Z5E6BxJShdXkV76TN1fEACrwu5ljcT6F+eRybndQr3ehCV16ZeFLaWzFf29wNCKwSj\n Q6AimytHQryZfDIYvG9tyKMRVixx/rXjwJUJBDIU5UPrqt44fdBDcWY1kDPM9oj3a2D/\n XbeDb6kHEqkhmbUhBZqyVAQeM4zLweN/wkzazdJeWAwR+U6e3ju5t0xQjJrRU74Uboxp\n xVAzDAuEIiaqXuFFZ9I+BXVQNOJzUtnnfnCxSebnHUlV6swZukixRJJ4Arfk8vIx0XFx\n H2pg==","X-Forwarded-Encrypted":"i=1;\n AJvYcCUkhhGPM+1xcCxM0CG92sWdM8cuCQWtY+0ssNXCa1JSyQrFH9W6PmxQgfAXtX8WqcXAXTX31xjeBFg6SA==@gcc.gnu.org","X-Gm-Message-State":"AOJu0YymWG+vNLQusMnCkfDsy0J6UhUTN1quAE4vB3zei9YGUlt3EOpO\n 8TQqljquMT2uXF4UdlMguO6rhLR5EpU5G9gJazeyodgPM+lFYKOny+PxFkZOckhVZDw6A+e9ZZY\n scB8Lwg0+UW0ZYvuz4AZQnyJHBmdfvYXDweyTl8+KeinJRkgi2YS0/8GjjQTXjNypcL/UY5403f\n 02+0FBpeFcGhKfAS7siJLIu/6K+Hm/2gkpew==","X-Gm-Gg":"AeBDievFDvUjpTJKy6hAA29vH+Hm1nZBSwxRQOC9sqw+RrKIScRd48obQvgvzjkOwv5\n rG3QMu0I/pHPBEFtmkpPPHRv54iYNlJS8FdNxVYMf25wty93762DDQlVIQr8tF+iLFgbNBIHvkX\n f81chX6vSSrQZUlgO1rRm8QHvbJ+aBMAg5Tjcl9dVXu2kZP9JJbrR2Sz8OOUswX5ZOlm2wPkYxg\n jernj3R8hsvPaRY291t6Y9cPtkt5rnFjeZOZHTcQChzcf1tBmzmQgHAAqEb/dpARgOc","X-Received":["by 2002:a05:690c:a041:b0:79a:7cae:f11a with SMTP id\n 00721157ae682-7af6f9095f7mr28630037b3.18.1775834964775;\n Fri, 10 Apr 2026 08:29:24 -0700 (PDT)","by 2002:a05:690c:a041:b0:79a:7cae:f11a with SMTP id\n 00721157ae682-7af6f9095f7mr28629837b3.18.1775834964191; Fri, 10 Apr 2026\n 08:29:24 -0700 (PDT)"],"MIME-Version":"1.0","References":"<adkUGggIiITbC-cp@tucnak>","In-Reply-To":"<adkUGggIiITbC-cp@tucnak>","From":"Tomasz Kaminski <tkaminsk@redhat.com>","Date":"Fri, 10 Apr 2026 17:29:13 +0200","X-Gm-Features":"AQROBzACF6Qbac8udJhm-MuEJDzzkmSzf2hGjA1erb5joLT9FOhpD5BJ3sHx0zM","Message-ID":"\n <CAKvuMXBJMd=813ixZmS-_+MuP8_EJf8SrtnbvEfueM2spptYZA@mail.gmail.com>","Subject":"Re: [PATCH] c++, libstdc++: Implement LWG4483 - Multidimensional\n arrays are not supported by meta::reflect_constant_array and related\n functions","To":"Jakub Jelinek <jakub@redhat.com>","Cc":"Jason Merrill <jason@redhat.com>, Marek Polacek <polacek@redhat.com>,\n Jonathan Wakely <jwakely@redhat.com>, gcc-patches@gcc.gnu.org,\n libstdc++@gcc.gnu.org","X-Mimecast-Spam-Score":"0","X-Mimecast-MFC-PROC-ID":"SLoNu37rHbvAsP3vcFhzAeDylKrhh0Bfq-8OZXTEKHo_1775834965","X-Mimecast-Originator":"redhat.com","Content-Type":"multipart/alternative; boundary=\"00000000000038dfd0064f1cccde\"","X-BeenThere":"gcc-patches@gcc.gnu.org","X-Mailman-Version":"2.1.30","Precedence":"list","List-Id":"Gcc-patches mailing list <gcc-patches.gcc.gnu.org>","List-Unsubscribe":"<https://gcc.gnu.org/mailman/options/gcc-patches>,\n <mailto:gcc-patches-request@gcc.gnu.org?subject=unsubscribe>","List-Archive":"<https://gcc.gnu.org/pipermail/gcc-patches/>","List-Post":"<mailto:gcc-patches@gcc.gnu.org>","List-Help":"<mailto:gcc-patches-request@gcc.gnu.org?subject=help>","List-Subscribe":"<https://gcc.gnu.org/mailman/listinfo/gcc-patches>,\n <mailto:gcc-patches-request@gcc.gnu.org?subject=subscribe>","Errors-To":"gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org"}}]