[gcc r15-3933] c++: ICE with structured bindings and m-d array [PR102594]

[Marek Polacek via Gcc-cvs]

https://gcc.gnu.org/g:96e0370f4daef29b918aafcff68c7f5e4ef397fd

commit r15-3933-g96e0370f4daef29b918aafcff68c7f5e4ef397fd
Author: Marek Polacek <pola...@redhat.com>
Date:   Thu Sep 5 16:45:32 2024 -0400

    c++: ICE with structured bindings and m-d array [PR102594]
    
    We ICE in decay_conversion with this test:
    
      struct S {
        S() {}
      };
      S arr[1][1];
      auto [m](arr3);
    
    But not when the last line is:
    
      auto [n] = arr3;
    
    Therefore the difference is between copy- and direct-init.  In
    particular, in build_vec_init we have:
    
      if (direct_init)
        from = build_tree_list (NULL_TREE, from);
    
    and then we call build_vec_init again with init==from.  Then
    decay_conversion gets the TREE_LIST and it crashes.
    
    build_aggr_init has:
    
                  /* Wrap the initializer in a CONSTRUCTOR so that 
build_vec_init
                     recognizes it as direct-initialization.  */
                  init = build_constructor_single (init_list_type_node,
                                                   NULL_TREE, init);
                  CONSTRUCTOR_IS_DIRECT_INIT (init) = true;
    
    so I propose to do the same in build_vec_init.
    
            PR c++/102594
    
    gcc/cp/ChangeLog:
    
            * init.cc (build_vec_init): Build up a CONSTRUCTOR to signal
            direct-initialization rather than a TREE_LIST.
    
    gcc/testsuite/ChangeLog:
    
            * g++.dg/cpp1z/decomp61.C: New test.
    
    Reviewed-by: Jason Merrill <ja...@redhat.com>

Diff:
---
 gcc/cp/init.cc                        |  8 +++++++-
 gcc/testsuite/g++.dg/cpp1z/decomp61.C | 28 ++++++++++++++++++++++++++++
 2 files changed, 35 insertions(+), 1 deletion(-)

diff --git a/gcc/cp/init.cc b/gcc/cp/init.cc
index be7fdb40dd6c..f785015e4774 100644
--- a/gcc/cp/init.cc
+++ b/gcc/cp/init.cc
@@ -4958,7 +4958,13 @@ build_vec_init (tree base, tree maxindex, tree init,
              if (xvalue)
                from = move (from);
              if (direct_init)
-               from = build_tree_list (NULL_TREE, from);
+               {
+                 /* Wrap the initializer in a CONSTRUCTOR so that
+                    build_vec_init recognizes it as direct-initialization.  */
+                 from = build_constructor_single (init_list_type_node,
+                                                  NULL_TREE, from);
+                 CONSTRUCTOR_IS_DIRECT_INIT (from) = true;
+               }
            }
          else
            from = NULL_TREE;
diff --git a/gcc/testsuite/g++.dg/cpp1z/decomp61.C 
b/gcc/testsuite/g++.dg/cpp1z/decomp61.C
new file mode 100644
index 000000000000..ad0a20c1addd
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp1z/decomp61.C
@@ -0,0 +1,28 @@
+// PR c++/102594
+// { dg-do compile { target c++17 } }
+
+struct S {
+  S() {}
+};
+S arr1[2];
+S arr2[2][1];
+S arr3[1][1];
+auto [m](arr3);
+auto [n] = arr3;
+
+struct X {
+  int i;
+};
+
+void
+g (X x)
+{
+  auto [a, b](arr2);
+  auto [c, d] = arr2;
+  auto [e, f] = (arr2);
+  auto [i, j](arr1);
+  auto [k, l] = arr1;
+  auto [m, n] = (arr1);
+  auto [z] = x;
+  auto [y](x);
+}