Commit 86aae782 authored by Marek Kurdej's avatar Marek Kurdej
Browse files

[libc++] [P0325] Implement to_array from LFTS with updates. 

Summary:
This patch implements https://wg21.link/P0325.
Please mind that at it is my first contribution to libc++, so I may have forgotten to abide to some conventions.

Reviewers: EricWF, mclow.lists, ldionne, lichray

Reviewed By: ldionne, lichray

Subscribers: lichray, dexonsmith, zoecarver, christof, ldionne, libcxx-commits

Tags: #libc

Differential Revision: https://reviews.llvm.org/D69882
parent 57b0d332

libcxx/docs/FeatureTestMacroTable.rst

+2 −0
Original line number Diff line number Diff line
@@ -199,6 +199,8 @@ Status 
    ``__cpp_lib_ranges``                              *unimplemented*  

    ------------------------------------------------- -----------------

    ``__cpp_lib_three_way_comparison``                *unimplemented*  

    ------------------------------------------------- -----------------

    ``__cpp_lib_to_array``                            ``201907L``      

    ================================================= =================

libcxx/include/array

+41 −0
Original line number Diff line number Diff line
@@ -479,6 +479,47 @@ get(const array<_Tp, _Size>&& __a) _NOEXCEPT 


#endif  // !_LIBCPP_CXX03_LANG



#if _LIBCPP_STD_VER > 17



template <typename _Tp, size_t _Size, size_t... _Index>

_LIBCPP_INLINE_VISIBILITY constexpr array<remove_cv_t<_Tp>, _Size>

__to_array_lvalue_impl(_Tp (&__arr)[_Size], index_sequence<_Index...>) {

  return {{__arr[_Index]...}};

}



template <typename _Tp, size_t _Size, size_t... _Index>

_LIBCPP_INLINE_VISIBILITY constexpr array<remove_cv_t<_Tp>, _Size>

__to_array_rvalue_impl(_Tp(&&__arr)[_Size], index_sequence<_Index...>) {

  return {{_VSTD::move(__arr[_Index])...}};

}



template <typename _Tp, size_t _Size>

_LIBCPP_INLINE_VISIBILITY constexpr array<remove_cv_t<_Tp>, _Size>

to_array(_Tp (&__arr)[_Size]) noexcept(is_nothrow_constructible_v<_Tp, _Tp&>) {

  static_assert(

      !is_array_v<_Tp>,

      "[array.creation]/1: to_array does not accept multidimensional arrays.");

  static_assert(

      is_constructible_v<_Tp, _Tp&>,

      "[array.creation]/1: to_array requires copy constructible elements.");

  return __to_array_lvalue_impl(__arr, make_index_sequence<_Size>());

}



template <typename _Tp, size_t _Size>

_LIBCPP_INLINE_VISIBILITY constexpr array<remove_cv_t<_Tp>, _Size>

to_array(_Tp(&&__arr)[_Size]) noexcept(is_nothrow_move_constructible_v<_Tp>) {

  static_assert(

      !is_array_v<_Tp>,

      "[array.creation]/4: to_array does not accept multidimensional arrays.");

  static_assert(

      is_move_constructible_v<_Tp>,

      "[array.creation]/4: to_array requires move constructible elements.");

  return __to_array_rvalue_impl(_VSTD::move(__arr),

                                make_index_sequence<_Size>());

}



#endif // _LIBCPP_STD_VER > 17



_LIBCPP_END_NAMESPACE_STD



#endif  // _LIBCPP_ARRAY

libcxx/include/version

+2 −0
Original line number Diff line number Diff line
@@ -101,6 +101,7 @@ __cpp_lib_shared_timed_mutex 201402L <shared_mutex> 
__cpp_lib_string_udls                                   201304L <string>

__cpp_lib_string_view                                   201606L <string> <string_view>

__cpp_lib_three_way_comparison                          201711L <compare>

__cpp_lib_to_array                                      201907L <array>

__cpp_lib_to_chars                                      201611L <utility>

__cpp_lib_transformation_trait_aliases                  201304L <type_traits>

__cpp_lib_transparent_operators                         201510L <functional>
@@ -233,6 +234,7 @@ __cpp_lib_void_t 201411L <type_traits> 
# endif

// # define __cpp_lib_list_remove_return_type              201806L

// # define __cpp_lib_ranges                               201811L

# define __cpp_lib_to_array                                201907L

// # define __cpp_lib_three_way_comparison                 201711L

#endif

libcxx/test/std/containers/sequences/array/array.creation/to_array.fail.cpp

0 → 100644
+34 −0
Original line number Diff line number Diff line 
//===----------------------------------------------------------------------===//

//

// 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>

// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17



#include <array>



#include "test_macros.h"

#include "MoveOnly.h"



int main(int, char**) {

  {

    char source[3][6] = {"hi", "world"};

    std::to_array(source); // expected-error {{here}}

  }



  {

    MoveOnly mo[] = {MoveOnly{3}};

    std::to_array(mo); // expected-error {{here}}

  }



  {

    const MoveOnly cmo[] = {MoveOnly{3}};

    std::to_array(std::move(cmo)); // expected-error {{here}}

  }



  return 0;

}

libcxx/test/std/containers/sequences/array/array.creation/to_array.pass.cpp

0 → 100644
+122 −0
Original line number Diff line number Diff line 
//===----------------------------------------------------------------------===//

//

// 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>

// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17



// template <typename T, size_t Size>

// constexpr auto to_array(T (&arr)[Size])

//    -> array<remove_cv_t<T>, Size>;



// template <typename T, size_t Size>

// constexpr auto to_array(T (&&arr)[Size])

//    -> array<remove_cv_t<T>, Size>;



#include <array>

#include <cassert>



#include "test_macros.h"

#include "MoveOnly.h"



int main(int, char**) {

  //  Test deduced type.

  {

    auto arr = std::to_array({1, 2, 3});

    ASSERT_SAME_TYPE(decltype(arr), std::array<int, 3>);

    assert(arr[0] == 1);

    assert(arr[1] == 2);

    assert(arr[2] == 3);

  }



  {

    const long l1 = 42;

    auto arr = std::to_array({1L, 4L, 9L, l1});

    ASSERT_SAME_TYPE(decltype(arr)::value_type, long);

    static_assert(arr.size() == 4, "");

    assert(arr[0] == 1);

    assert(arr[1] == 4);

    assert(arr[2] == 9);

    assert(arr[3] == l1);

  }



  {

    auto arr = std::to_array("meow");

    ASSERT_SAME_TYPE(decltype(arr), std::array<char, 5>);

    assert(arr[0] == 'm');

    assert(arr[1] == 'e');

    assert(arr[2] == 'o');

    assert(arr[3] == 'w');

    assert(arr[4] == '\0');

  }



  {

    double source[3] = {4.0, 5.0, 6.0};

    auto arr = std::to_array(source);

    ASSERT_SAME_TYPE(decltype(arr), std::array<double, 3>);

    assert(arr[0] == 4.0);

    assert(arr[1] == 5.0);

    assert(arr[2] == 6.0);

  }



  {

    double source[3] = {4.0, 5.0, 6.0};

    auto arr = std::to_array(std::move(source));

    ASSERT_SAME_TYPE(decltype(arr), std::array<double, 3>);

    assert(arr[0] == 4.0);

    assert(arr[1] == 5.0);

    assert(arr[2] == 6.0);

  }



  {

    MoveOnly source[] = {MoveOnly{0}, MoveOnly{1}, MoveOnly{2}};



    auto arr = std::to_array(std::move(source));

    ASSERT_SAME_TYPE(decltype(arr), std::array<MoveOnly, 3>);

    for (int i = 0; i < 3; ++i)

      assert(arr[i].get() == i && source[i].get() == 0);

  }



  // Test C99 compound literal.

  {

    auto arr = std::to_array((int[]){3, 4});

    ASSERT_SAME_TYPE(decltype(arr), std::array<int, 2>);

    assert(arr[0] == 3);

    assert(arr[1] == 4);

  }



  //  Test explicit type.

  {

    auto arr = std::to_array<long>({1, 2, 3});

    ASSERT_SAME_TYPE(decltype(arr), std::array<long, 3>);

    assert(arr[0] == 1);

    assert(arr[1] == 2);

    assert(arr[2] == 3);

  }



  {

    struct A {

      int a;

      double b;

    };



    auto arr = std::to_array<A>({{3, .1}});

    ASSERT_SAME_TYPE(decltype(arr), std::array<A, 1>);

    assert(arr[0].a == 3);

    assert(arr[0].b == .1);

  }



  // Test constexpr.

  {

    constexpr std::array<int, 3> arr = std::to_array({1, 2, 3});

    static_assert(arr[0] == 1);

    static_assert(arr[1] == 2);

    static_assert(arr[2] == 3);

  }



  return 0;

}