[libc++][test] Remove disable_missing_braces_warning.h from tests

[jloser]

Summary

Several tests include disable_missing_braces_warning.h but do not need
to. Remove the include.

Inspired from discussion at https://reviews.llvm.org/D109668

[• Quuxplusone]

If buildkite is actually OK with this, then I'm OK with it.

But I assume that buildkite would not be OK with this as-is; I assume it'll produce that warning diagnostic. But I think we should fix the warning appropriately, e.g. by changing const std::array<long, 5> arr = {4, 5, 6, 7, 8}; to const std::array<long, 5> arr = {{4, 5, 6, 7, 8}};. I believe such changes will be trivially easy, except for apply_extended_types.pass.cpp, where the missing braces are inside a template that's used sometimes with array (which needs double braces) and sometimes with tuple (which needs single braces).

I don't understand why you changed only these few tests. E.g. why not any of the tests under std/containers/sequences/array/? and why not std/iterators/iterator.range/begin-end.pass.cpp?

[Mordante]

LGTM. But I too would prefer remove all no longer needed #include "disable_missing_braces_warning.h" in this commit and remove the then obsolete header.

@Quuxplusone Am I missing something? AFAIK const std::array<long, 5> arr = {4, 5, 6, 7, 8}; is valid C++11.

[• Quuxplusone]

@Quuxplusone Am I missing something? AFAIK const std::array<long, 5> arr = {4, 5, 6, 7, 8}; is valid C++11.

It's definitely valid, but I had assumed (wrongly, it seems) that it would still trigger a non-fatal warning on Clang and/or GCC, which would have been the point of the header: to avoid that non-fatal warning.
However, at least on Godbolt,

• I cannot reproduce any such warning on Clang at all
• I can reproduce it on GCC but only by explicitly passing -Wmissing-braces; it's not part of -Wall -Wextra

So yeah, @jloser, can we see what happens if you just git rm disable_missing_braces_warning.h and remove all its uses? I now predict that we'll see buildkite totally happy with that.

[ldionne]

Agreed with the other reviewers, please try removing disable_missing_braces_warning,h entirely.

[jloser]

Remove rest of disable_missing_braces_warning.h from other tests.
Remove header disable_missing_braces_warning.h

[ldionne]

Thanks! LGTM if CI passes.

[jloser]

In D109711#3010490, @ldionne wrote:

Thanks! LGTM if CI passes.

CI is failing in the runtimes build (https://buildkite.com/llvm-project/libcxx-ci/builds/5444#eabe837f-7b55-4767-a14b-24ef963ad3dc) but this looks unrelated to my changes. I didn't touch this test so its behavior should be unchanged. Safe to land this, or what would you like me to do?

[jloser]

Rebase to kick the bots

[jloser]

Rebase with main to fix CI

[jloser]

Poke buildbots due to failure from out-of-space on build bot

[jloser]

Kick the bots again...

libcxx/test/std/containers/sequences/array/array.cons/deduct.fail.cpp

 //
 //  Requires: (is_same_v<T, U> && ...) is true. Otherwise the program is ill-formed.
 
 
 #include <array>
 #include <cassert>
 #include <cstddef>
 
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#include "disable_missing_braces_warning.h"
-
-
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
     std::array arr{1,2,3L}; // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'array'}}
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/array/array.cons/deduct.pass.cpp

 //   array(T, U...) -> array<T, 1 + sizeof...(U)>;
 //
 //  Requires: (is_same_v<T, U> && ...) is true. Otherwise the program is ill-formed.
 
 #include <array>
 #include <cassert>
 #include <cstddef>
 
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#include "disable_missing_braces_warning.h"
-
 #include "test_macros.h"
 
 constexpr bool tests()
 {
     //  Test the explicit deduction guides
     {
         std::array arr{1,2,3};  // array(T, U...)
         static_assert(std::is_same_v<decltype(arr), std::array<int, 3>>, "");

libcxx/test/std/containers/sequences/array/array.cons/implicit_copy.pass.cpp

 
 // implicitly generated array constructors / assignment operators
 
 #include <array>
 #include <type_traits>
 #include <cassert>
 #include "test_macros.h"
 
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#include "disable_missing_braces_warning.h"
-
 // In C++03 the copy assignment operator is not deleted when the implicitly
 // generated operator would be ill-formed; like in the case of a struct with a
 // const member.
 #if TEST_STD_VER < 11
 #   define TEST_NOT_COPY_ASSIGNABLE(T) ((void)0)
 #else
 #   define TEST_NOT_COPY_ASSIGNABLE(T) static_assert(!std::is_copy_assignable<T>::value, "")
 #endif

libcxx/test/std/containers/sequences/array/array.data/data.pass.cpp

 // T *data();
 
 #include <array>
 #include <cassert>
 #include <cstddef>       // for std::max_align_t
 
 #include "test_macros.h"
 
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#include "disable_missing_braces_warning.h"
-
 struct NoDefault {
     TEST_CONSTEXPR NoDefault(int) { }
 };
 
 #if TEST_STD_VER < 11
 struct natural_alignment {
     long t1;
     long long t2;

libcxx/test/std/containers/sequences/array/array.data/data_const.pass.cpp

 // const T* data() const;
 
 #include <array>
 #include <cassert>
 #include <cstddef>       // for std::max_align_t
 
 #include "test_macros.h"
 
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#include "disable_missing_braces_warning.h"
-
 struct NoDefault {
     TEST_CONSTEXPR NoDefault(int) { }
 };
 
 #if TEST_STD_VER < 11
 struct natural_alignment {
     long t1;
     long long t2;

libcxx/test/std/containers/sequences/array/array.fill/fill.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <array>
 
 // void fill(const T& u);
 
 #include <array>
 #include <cassert>
 
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#include "disable_missing_braces_warning.h"
-
 int main(int, char**) {
   {
     typedef double T;
     typedef std::array<const T, 0> C;
     C c = {};
     // expected-error-re@array:* {{static_assert failed {{.*}}"cannot fill zero-sized array of type 'const T'"}}
     c.fill(5.5); // expected-note {{requested here}}
   }
 
   return 0;
 }

libcxx/test/std/containers/sequences/array/array.fill/fill.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <array>
 
 // void fill(const T& u);
 
 #include <array>
 #include <cassert>
 
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
 #include "test_macros.h"
-#include "disable_missing_braces_warning.h"
 
 TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         typedef double T;
         typedef std::array<T, 3> C;
         C c = {1, 2, 3.5};
         c.fill(5.5);

libcxx/test/std/containers/sequences/array/array.size/size.pass.cpp

 
 // template <class T, size_t N> constexpr size_type array<T,N>::size();
 
 #include <array>
 #include <cassert>
 
 #include "test_macros.h"
 
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#include "disable_missing_braces_warning.h"
-
 int main(int, char**)
 {
     {
         typedef double T;
         typedef std::array<T, 3> C;
         C c = {1, 2, 3.5};
         assert(c.size() == 3);
         assert(c.max_size() == 3);

libcxx/test/std/containers/sequences/array/array.special/swap.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <array>
 
 // template <class T, size_t N> void swap(array<T,N>& x, array<T,N>& y);
 
 #include <array>
 #include <cassert>
 
 #include "test_macros.h"
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#include "disable_missing_braces_warning.h"
 
 struct NonSwappable {
     TEST_CONSTEXPR NonSwappable() { }
 private:
     NonSwappable(NonSwappable const&);
     NonSwappable& operator=(NonSwappable const&);
 };
 

libcxx/test/std/containers/sequences/array/array.swap/swap.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <array>
 
 // void swap(array& a);
 
 #include <array>
 #include <cassert>
 
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#include "disable_missing_braces_warning.h"
-
 int main(int, char**) {
   {
     typedef double T;
     typedef std::array<const T, 0> C;
     C c = {};
     C c2 = {};
     // expected-error-re@array:* {{static_assert failed {{.*}}"cannot swap zero-sized array of type 'const T'"}}
     c.swap(c2); // expected-note {{requested here}}
   }
 
   return 0;
 }

libcxx/test/std/containers/sequences/array/array.swap/swap.pass.cpp

 // void swap(array& a);
 // namespace std { void swap(array<T, N> &x, array<T, N> &y);
 
 #include <cassert>
 #include <array>
 
 #include "test_macros.h"
 
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#include "disable_missing_braces_warning.h"
-
 struct NonSwappable {
     TEST_CONSTEXPR NonSwappable() { }
 private:
     NonSwappable(NonSwappable const&);
     NonSwappable& operator=(NonSwappable const&);
 };
 
 TEST_CONSTEXPR_CXX20 bool tests()

libcxx/test/std/containers/sequences/array/array.tuple/get.fail.cpp

 // Prevent -Warray-bounds from issuing a diagnostic when testing with clang verify.
 #if defined(__clang__)
 #pragma clang diagnostic ignored "-Warray-bounds"
 #endif
 
 #include <array>
 #include <cassert>
 
-
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#include "disable_missing_braces_warning.h"
-
 int main(int, char**)
 {
     {
         typedef double T;
         typedef std::array<T, 3> C;
         C c = {1, 2, 3.5};
         std::get<3>(c) = 5.5; // expected-note {{requested here}}
         // expected-error-re@array:* {{static_assert failed{{( due to requirement '3U[L]{0,2} < 3U[L]{0,2}')?}} "Index out of bounds in std::get<> (std::array)"}}
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/array/array.tuple/get.pass.cpp

 
 // template <size_t I, class T, size_t N> T& get(array<T, N>& a);
 
 #include <array>
 #include <cassert>
 
 #include "test_macros.h"
 
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#include "disable_missing_braces_warning.h"
-
-
 template <typename ...T>
 TEST_CONSTEXPR std::array<int, sizeof...(T)> tempArray(T ...args)
 {
     return {args...};
 }
 
 TEST_CONSTEXPR_CXX14 bool tests()
 {

libcxx/test/std/containers/sequences/array/array.tuple/get_const.pass.cpp

 
 // template <size_t I, class T, size_t N> const T& get(const array<T, N>& a);
 
 #include <array>
 #include <cassert>
 
 #include "test_macros.h"
 
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#include "disable_missing_braces_warning.h"
-
 TEST_CONSTEXPR_CXX14 bool tests()
 {
     {
         std::array<double, 1> const array = {3.3};
         assert(std::get<0>(array) == 3.3);
     }
     {
         std::array<double, 2> const array = {3.3, 4.4};

libcxx/test/std/containers/sequences/array/array.tuple/get_const_rv.pass.cpp

 #include <array>
 #include <memory>
 #include <type_traits>
 #include <utility>
 #include <cassert>
 
 #include "test_macros.h"
 
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#include "disable_missing_braces_warning.h"
-
 int main(int, char**)
 {
 
     {
         typedef std::unique_ptr<double> T;
         typedef std::array<T, 1> C;
         const C c = {std::unique_ptr<double>(new double(3.5))};
         static_assert(std::is_same<const T&&, decltype(std::get<0>(std::move(c)))>::value, "");

libcxx/test/std/containers/sequences/array/array.tuple/get_rv.pass.cpp

 
 // UNSUPPORTED: c++03
 
 #include <array>
 #include <memory>
 #include <utility>
 #include <cassert>
 
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
 #include "test_macros.h"
-#include "disable_missing_braces_warning.h"
 
 int main(int, char**)
 {
-
     {
         typedef std::unique_ptr<double> T;
         typedef std::array<T, 1> C;
         C c = {std::unique_ptr<double>(new double(3.5))};
         T t = std::get<0>(std::move(c));
         assert(*t == 3.5);
     }
 
     return 0;
 }

libcxx/test/std/containers/sequences/array/array.tuple/tuple_element.fail.cpp

 // Prevent -Warray-bounds from issuing a diagnostic when testing with clang verify.
 #if defined(__clang__)
 #pragma clang diagnostic ignored "-Warray-bounds"
 #endif
 
 #include <array>
 #include <cassert>
 
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#include "disable_missing_braces_warning.h"
-
 int main(int, char**)
 {
     {
         typedef double T;
         typedef std::array<T, 3> C;
         std::tuple_element<3, C> foo; // expected-note {{requested here}}
         // expected-error-re@array:* {{static_assert failed{{( due to requirement '3U[L]{0,2} < 3U[L]{0,2}')?}} "Index out of bounds in std::tuple_element<> (std::array)"}}
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/array/at.pass.cpp

 #include <cassert>
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 #include <stdexcept>
 #endif
 
 #include "test_macros.h"
 
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#include "disable_missing_braces_warning.h"
-
-
 TEST_CONSTEXPR_CXX17 bool tests()
 {
     {
         typedef double T;
         typedef std::array<T, 3> C;
         C c = {1, 2, 3.5};
         typename C::reference r1 = c.at(0);
         assert(r1 == 1);

libcxx/test/std/containers/sequences/array/at_const.pass.cpp

 #include <cassert>
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 #include <stdexcept>
 #endif
 
 #include "test_macros.h"
 
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#include "disable_missing_braces_warning.h"
-
-
 TEST_CONSTEXPR_CXX14 bool tests()
 {
     {
         typedef double T;
         typedef std::array<T, 3> C;
         C const c = {1, 2, 3.5};
         typename C::const_reference r1 = c.at(0);
         assert(r1 == 1);

libcxx/test/std/containers/sequences/array/compare.fail.cpp

 
 
 #include <array>
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#include "disable_missing_braces_warning.h"
-
 template <class Array>
 void test_compare(const Array& LHS, const Array& RHS) {
   typedef std::vector<typename Array::value_type> Vector;
   const Vector LHSV(LHS.begin(), LHS.end());
   const Vector RHSV(RHS.begin(), RHS.end());
   assert((LHS == RHS) == (LHSV == RHSV));
   assert((LHS != RHS) == (LHSV != RHSV));
   assert((LHS < RHS) == (LHSV < RHSV));

libcxx/test/std/containers/sequences/array/compare.pass.cpp

 
 
 #include <array>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#include "disable_missing_braces_warning.h"
-
 TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         typedef std::array<int, 3> C;
         C c1 = {1, 2, 3};
         C c2 = {1, 2, 3};
         C c3 = {3, 2, 1};
         C c4 = {1, 2, 1};

libcxx/test/std/containers/sequences/array/front_back.pass.cpp

 // reference front();  // constexpr in C++17
 // reference back();   // constexpr in C++17
 
 #include <array>
 #include <cassert>
 
 #include "test_macros.h"
 
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#include "disable_missing_braces_warning.h"
-
-
 TEST_CONSTEXPR_CXX17 bool tests()
 {
     {
         typedef double T;
         typedef std::array<T, 3> C;
         C c = {1, 2, 3.5};
 
         C::reference r1 = c.front();

libcxx/test/std/containers/sequences/array/front_back_const.pass.cpp

 // const_reference front() const; // constexpr in C++14
 // const_reference back() const;  // constexpr in C++14
 
 #include <array>
 #include <cassert>
 
 #include "test_macros.h"
 
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#include "disable_missing_braces_warning.h"
-
-
 TEST_CONSTEXPR_CXX14 bool tests()
 {
     {
         typedef double T;
         typedef std::array<T, 3> C;
         C const c = {1, 2, 3.5};
         C::const_reference r1 = c.front();
         assert(r1 == 1);

libcxx/test/std/containers/sequences/array/indexing.pass.cpp

 // reference operator[](size_type); // constexpr in C++17
 // Libc++ marks it as noexcept
 
 #include <array>
 #include <cassert>
 
 #include "test_macros.h"
 
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#include "disable_missing_braces_warning.h"
-
-
 TEST_CONSTEXPR_CXX17 bool tests()
 {
     {
         typedef double T;
         typedef std::array<T, 3> C;
         C c = {1, 2, 3.5};
         LIBCPP_ASSERT_NOEXCEPT(c[0]);
         ASSERT_SAME_TYPE(C::reference, decltype(c[0]));

libcxx/test/std/containers/sequences/array/indexing_const.pass.cpp

 // const_reference operator[](size_type) const; // constexpr in C++14
 // Libc++ marks it as noexcept
 
 #include <array>
 #include <cassert>
 
 #include "test_macros.h"
 
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#include "disable_missing_braces_warning.h"
-
-
 TEST_CONSTEXPR_CXX14 bool tests()
 {
     {
         typedef double T;
         typedef std::array<T, 3> C;
         C const c = {1, 2, 3.5};
         LIBCPP_ASSERT_NOEXCEPT(c[0]);
         ASSERT_SAME_TYPE(C::const_reference, decltype(c[0]));

libcxx/test/std/containers/sequences/array/iterators.pass.cpp

 // const_reverse_iterator crend() const noexcept;     // constexpr in C++17
 
 #include <array>
 #include <iterator>
 #include <cassert>
 
 #include "test_macros.h"
 
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#include "disable_missing_braces_warning.h"
-
 struct NoDefault {
     TEST_CONSTEXPR NoDefault(int) { }
 };
 
 TEST_CONSTEXPR_CXX17 bool tests()
 {
     {
         typedef std::array<int, 5> C;

libcxx/test/std/containers/views/span.cons/stdarray.pass.cpp

 
 
 #include <span>
 #include <array>
 #include <cassert>
 #include <string>
 
 #include "test_macros.h"
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#include "disable_missing_braces_warning.h"
-
 
 void checkCV()
 {
     std::array<int, 3> arr  = {1,2,3};
 //  STL says these are not cromulent
 //  std::array<const int,3> carr = {4,5,6};
 //  std::array<volatile int, 3> varr = {7,8,9};
 //  std::array<const volatile int, 3> cvarr = {1,3,5};

libcxx/test/std/iterators/iterator.range/begin-end.pass.cpp

 
 #include <iterator>
 #include <cassert>
 #include <vector>
 #include <array>
 #include <list>
 #include <initializer_list>
 
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#include "disable_missing_braces_warning.h"
-
 template<typename C>
 void test_const_container( const C & c, typename C::value_type val ) {
     assert ( std::begin(c)   == c.begin());
     assert (*std::begin(c)   ==  val );
     assert ( std::begin(c)   != c.end());
     assert ( std::end(c)     == c.end());
 #if TEST_STD_VER > 11
     assert ( std::cbegin(c)  == c.cbegin());

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply.pass.cpp

 #include <tuple>
 #include <array>
 #include <utility>
 #include <cassert>
 
 #include "test_macros.h"
 #include "type_id.h"
 
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#include "disable_missing_braces_warning.h"
-
-
 constexpr int constexpr_sum_fn() { return 0; }
 
 template <class ...Ints>
 constexpr int constexpr_sum_fn(int x1, Ints... rest) { return x1 + constexpr_sum_fn(rest...); }
 
 struct ConstexprSumT {
   constexpr ConstexprSumT() = default;
   template <class ...Ints>

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply_extended_types.pass.cpp

 // named by INVOKE but that are not actual callable objects. These include
 // bullets 1-4 of invoke.
 
 #include <tuple>
 #include <array>
 #include <utility>
 #include <cassert>
 
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
 #include "test_macros.h"
-#include "disable_missing_braces_warning.h"
 
 int count = 0;
 
 struct A_int_0
 {
     A_int_0() : obj1(0){}
     A_int_0(int x) : obj1(x) {}
     int mem1() { return ++count; }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.apply/make_from_tuple.pass.cpp

 #include <array>
 #include <utility>
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "type_id.h"
 
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#include "disable_missing_braces_warning.h"
-
 template <class Tuple>
 struct ConstexprConstructibleFromTuple {
   template <class ...Args>
   explicit constexpr ConstexprConstructibleFromTuple(Args&&... xargs)
       : args{std::forward<Args>(xargs)...} {}
   Tuple args;
 };
 

libcxx/test/support/disable_missing_braces_warning.h

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-#ifndef SUPPORT_DISABLE_MISSING_BRACES_WARNING_H
-#define SUPPORT_DISABLE_MISSING_BRACES_WARNING_H
-
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#if defined(__GNUC__)
-#pragma GCC diagnostic ignored "-Wmissing-braces"
-#elif defined(__clang__)
-#pragma clang diagnostic ignored "-Wmissing-braces"
-#endif
-
-#endif // SUPPORT_DISABLE_MISSING_BRACES_WARNING_H