[clang] [Clang][Sema] Fix wrong initialization kind when handling initializing structured bindings from an array with direct-list-initialization (PR #124793)

[Yanzuo Liu via cfe-commits]

https://github.com/zwuis created https://github.com/llvm/llvm-project/pull/124793

In my PR #102581, elements of structured bindings is copy-initialized. They should be direct-initialized because the form of the initializer of the whole structured bindings is direct-list-initialization.

[[dcl.struct.bind]/1](https://eel.is/c++draft/dcl.struct.bind#1.sentence-8):
> ... and each element is copy-initialized or direct-initialized from the corresponding element of the assignment-expression as specified by the form of the initializer. ...

```cpp
int arr[2]{};
// elements of `[a, b]` should be direct-initialized
auto [a, b]{arr};
```

>From 16596add29b63ee0282e026dec7b1d5946863113 Mon Sep 17 00:00:00 2001
From: Yanzuo Liu <zwuis at outlook.com>
Date: Wed, 29 Jan 2025 00:38:15 +0800
Subject: [PATCH] Fix wrong initialization kind

---
 clang/lib/Sema/SemaInit.cpp                |  5 +++--
 clang/test/SemaCXX/cxx1z-decomposition.cpp | 21 ++++++++++-----------
 2 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/clang/lib/Sema/SemaInit.cpp b/clang/lib/Sema/SemaInit.cpp
index b95cbbf4222056..5552fce55f1310 100644
--- a/clang/lib/Sema/SemaInit.cpp
+++ b/clang/lib/Sema/SemaInit.cpp
@@ -4861,8 +4861,9 @@ static void TryListInitialization(Sema &S,
             S.Context.hasSameUnqualifiedType(SubInit[0]->getType(), DestType) &&
             "Deduced to other type?");
         TryArrayCopy(S,
-                     InitializationKind::CreateCopy(Kind.getLocation(),
-                                                    InitList->getLBraceLoc()),
+                     InitializationKind::CreateDirect(Kind.getLocation(),
+                                                      InitList->getLBraceLoc(),
+                                                      InitList->getRBraceLoc()),
                      Entity, SubInit[0], DestType, Sequence,
                      TreatUnavailableAsInvalid);
         if (Sequence)
diff --git a/clang/test/SemaCXX/cxx1z-decomposition.cpp b/clang/test/SemaCXX/cxx1z-decomposition.cpp
index a8914fe4e9cd82..b3d98e44990f61 100644
--- a/clang/test/SemaCXX/cxx1z-decomposition.cpp
+++ b/clang/test/SemaCXX/cxx1z-decomposition.cpp
@@ -200,38 +200,37 @@ namespace lambdas {
 
 namespace by_value_array_copy {
   struct explicit_copy {
-    explicit_copy() = default; // expected-note 2{{candidate constructor not viable: requires 0 arguments, but 1 was provided}}
-    explicit explicit_copy(const explicit_copy&) = default; // expected-note 2{{explicit constructor is not a candidate}}
+    explicit_copy() = default; // expected-note {{candidate constructor not viable: requires 0 arguments, but 1 was provided}}
+    explicit explicit_copy(const explicit_copy&) = default; // expected-note {{explicit constructor is not a candidate}}
   };
 
   constexpr int direct_initialization_for_elements() {
     explicit_copy ec_arr[2];
     auto [a1, b1](ec_arr);
+    auto [a2, b2]{ec_arr};
 
     int arr[3]{1, 2, 3};
-    auto [a2, b2, c2](arr);
+    auto [a3, b3, c3](arr);
+    auto [a4, b4, c4]{arr}; // GH31813
     arr[0]--;
-    return a2 + b2 + c2 + arr[0];
+    return a3 + b3 + c3 + a4 + b4 + c4 + arr[0];
   }
-  static_assert(direct_initialization_for_elements() == 6);
+  static_assert(direct_initialization_for_elements() == 12);
 
   constexpr int copy_initialization_for_elements() {
     int arr[2]{4, 5};
     auto [a1, b1] = arr;
-    auto [a2, b2]{arr}; // GH31813
     arr[0] = 0;
-    return a1 + b1 + a2 + b2 + arr[0];
+    return a1 + b1 + arr[0];
   }
-  static_assert(copy_initialization_for_elements() == 18);
+  static_assert(copy_initialization_for_elements() == 9);
 
   void copy_initialization_for_elements_with_explicit_copy_ctor() {
     explicit_copy ec_arr[2];
     auto [a1, b1] = ec_arr; // expected-error {{no matching constructor for initialization of 'explicit_copy[2]'}}
-    auto [a2, b2]{ec_arr}; // expected-error {{no matching constructor for initialization of 'explicit_copy[2]'}}
 
     // Test prvalue
     using T = explicit_copy[2];
-    auto [a3, b3] = T{};
-    auto [a4, b4]{T{}};
+    auto [a2, b2] = T{};
   }
 } // namespace by_value_array_copy