[libc++] Implement copyable-box from Ranges

Differential Revision: https://reviews.llvm.org/D102135

Author: ldionne

libcxx/include/CMakeLists.txt

@@ -184,6 +184,7 @@ set(files
   __ranges/access.h
   __ranges/all.h
   __ranges/concepts.h
+  __ranges/copyable_box.h
   __ranges/data.h
   __ranges/drop_view.h
   __ranges/empty_view.h

libcxx/include/__ranges/copyable_box.h

@@ -0,0 +1,175 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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 _LIBCPP___RANGES_COPYABLE_BOX_H
+#define _LIBCPP___RANGES_COPYABLE_BOX_H
+
+#include <__config>
+#include <__memory/addressof.h>
+#include <__memory/construct_at.h>
+#include <__utility/move.h>
+#include <concepts>
+#include <optional>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if !defined(_LIBCPP_HAS_NO_RANGES)
+
+// __copyable_box allows turning a type that is copy-constructible (but maybe not copy-assignable) into
+// a type that is both copy-constructible and copy-assignable. It does that by introducing an empty state
+// and basically doing destroy-then-copy-construct in the assignment operator. The empty state is necessary
+// to handle the case where the copy construction fails after destroying the object.
+//
+// In some cases, we can completely avoid the use of an empty state; we provide a specialization of
+// __copyable_box that does this, see below for the details.
+
+template<class _Tp>
+concept __copy_constructible_object = copy_constructible<_Tp> && is_object_v<_Tp>;
+
+namespace ranges {
+  // Primary template - uses std::optional and introduces an empty state in case assignment fails.
+  template<__copy_constructible_object _Tp>
+  class __copyable_box {
+    [[no_unique_address]] optional<_Tp> __val_;
+
+  public:
+    template<class ..._Args>
+      requires is_constructible_v<_Tp, _Args...>
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr explicit __copyable_box(in_place_t, _Args&& ...__args)
+      noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
+      : __val_(in_place, _VSTD::forward<_Args>(__args)...)
+    { }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr __copyable_box() noexcept(is_nothrow_default_constructible_v<_Tp>)
+      requires default_initializable<_Tp>
+      : __val_(in_place)
+    { }
+
+    _LIBCPP_HIDE_FROM_ABI __copyable_box(__copyable_box const&) = default;
+    _LIBCPP_HIDE_FROM_ABI __copyable_box(__copyable_box&&) = default;
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr __copyable_box& operator=(__copyable_box const& __other)
+      noexcept(is_nothrow_copy_constructible_v<_Tp>)
+    {
+      if (this != _VSTD::addressof(__other)) {
+        if (__other.__has_value()) __val_.emplace(*__other);
+        else                       __val_.reset();
+      }
+      return *this;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    __copyable_box& operator=(__copyable_box&&) requires movable<_Tp> = default;
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr __copyable_box& operator=(__copyable_box&& __other)
+      noexcept(is_nothrow_move_constructible_v<_Tp>)
+    {
+      if (this != _VSTD::addressof(__other)) {
+        if (__other.__has_value()) __val_.emplace(_VSTD::move(*__other));
+        else                       __val_.reset();
+      }
+      return *this;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI constexpr _Tp const& operator*() const noexcept { return *__val_; }
+    _LIBCPP_HIDE_FROM_ABI constexpr _Tp& operator*() noexcept { return *__val_; }
+    _LIBCPP_HIDE_FROM_ABI constexpr bool __has_value() const noexcept { return __val_.has_value(); }
+  };
+
+  // This partial specialization implements an optimization for when we know we don't need to store
+  // an empty state to represent failure to perform an assignment. For copy-assignment, this happens:
+  //
+  // 1. If the type is copyable (which includes copy-assignment), we can use the type's own assignment operator
+  //    directly and avoid using std::optional.
+  // 2. If the type is not copyable, but it is nothrow-copy-constructible, then we can implement assignment as
+  //    destroy-and-then-construct and we know it will never fail, so we don't need an empty state.
+  //
+  // The exact same reasoning can be applied for move-assignment, with copyable replaced by movable and
+  // nothrow-copy-constructible replaced by nothrow-move-constructible. This specialization is enabled
+  // whenever we can apply any of these optimizations for both the copy assignment and the move assignment
+  // operator.
+  template<class _Tp>
+  concept __doesnt_need_empty_state_for_copy = copyable<_Tp> || is_nothrow_copy_constructible_v<_Tp>;
+
+  template<class _Tp>
+  concept __doesnt_need_empty_state_for_move = movable<_Tp> || is_nothrow_move_constructible_v<_Tp>;
+
+  template<__copy_constructible_object _Tp>
+    requires __doesnt_need_empty_state_for_copy<_Tp> && __doesnt_need_empty_state_for_move<_Tp>
+  class __copyable_box<_Tp> {
+    [[no_unique_address]] _Tp __val_;
+
+  public:
+    template<class ..._Args>
+      requires is_constructible_v<_Tp, _Args...>
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr explicit __copyable_box(in_place_t, _Args&& ...__args)
+      noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
+      : __val_(_VSTD::forward<_Args>(__args)...)
+    { }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr __copyable_box() noexcept(is_nothrow_default_constructible_v<_Tp>)
+      requires default_initializable<_Tp>
+      : __val_()
+    { }
+
+    _LIBCPP_HIDE_FROM_ABI __copyable_box(__copyable_box const&) = default;
+    _LIBCPP_HIDE_FROM_ABI __copyable_box(__copyable_box&&) = default;
+
+    // Implementation of assignment operators in case we perform optimization (1)
+    _LIBCPP_HIDE_FROM_ABI __copyable_box& operator=(__copyable_box const&) requires copyable<_Tp> = default;
+    _LIBCPP_HIDE_FROM_ABI __copyable_box& operator=(__copyable_box&&) requires movable<_Tp> = default;
+
+    // Implementation of assignment operators in case we perform optimization (2)
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr __copyable_box& operator=(__copyable_box const& __other) noexcept {
+      static_assert(is_nothrow_copy_constructible_v<_Tp>);
+      if (this != _VSTD::addressof(__other)) {
+        _VSTD::destroy_at(_VSTD::addressof(__val_));
+        _VSTD::construct_at(_VSTD::addressof(__val_), __other.__val_);
+      }
+      return *this;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr __copyable_box& operator=(__copyable_box&& __other) noexcept {
+      static_assert(is_nothrow_move_constructible_v<_Tp>);
+      if (this != _VSTD::addressof(__other)) {
+        _VSTD::destroy_at(_VSTD::addressof(__val_));
+        _VSTD::construct_at(_VSTD::addressof(__val_), _VSTD::move(__other.__val_));
+      }
+      return *this;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI constexpr _Tp const& operator*() const noexcept { return __val_; }
+    _LIBCPP_HIDE_FROM_ABI constexpr _Tp& operator*() noexcept { return __val_; }
+    _LIBCPP_HIDE_FROM_ABI constexpr bool __has_value() const noexcept { return true; }
+  };
+} // namespace ranges
+
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANGES_COPYABLE_BOX_H

libcxx/include/module.modulemap

@@ -600,6 +600,7 @@ module std [system] {
       module access                 { header "__ranges/access.h"                }
       module all                    { header "__ranges/all.h"                   }
       module concepts               { header "__ranges/concepts.h"              }
+      module copyable_box           { header "__ranges/copyable_box.h"          }
       module data                   { header "__ranges/data.h"                  }
       module empty                  { header "__ranges/empty.h"                 }
       module empty_view             { header "__ranges/empty_view.h"            }

libcxx/test/libcxx/ranges/range.adaptors/range.copy.wrap/assign.copy.pass.cpp

@@ -0,0 +1,170 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// <copyable-box>& operator=(<copyable-box> const&)
+
+// ADDITIONAL_COMPILE_FLAGS: -Wno-self-assign-overloaded
+
+#include <__ranges/copyable_box.h>
+
+#include <cassert>
+#include <type_traits>
+#include <utility> // in_place_t
+
+#include "test_macros.h"
+#include "types.h"
+
+constexpr bool test() {
+  // Test the primary template
+  {
+    using Box = std::ranges::__copyable_box<CopyConstructible>;
+    static_assert( std::is_copy_assignable_v<Box>);
+    static_assert(!std::is_nothrow_copy_assignable_v<Box>);
+
+    {
+      Box x(std::in_place, 5);
+      Box const y(std::in_place, 10);
+      Box& result = (x = y);
+
+      assert(&result == &x);
+      assert(x.__has_value());
+      assert(y.__has_value());
+      assert((*x).value == 10);
+    }
+    // check self-assignment
+    {
+      Box x(std::in_place, 5);
+      Box& result = (x = x);
+
+      assert(&result == &x);
+      assert(x.__has_value());
+      assert((*x).value == 5);
+    }
+  }
+
+  // Test optimization #1 for copy-assignment
+  {
+    using Box = std::ranges::__copyable_box<Copyable>;
+    static_assert( std::is_copy_assignable_v<Box>);
+    static_assert(!std::is_nothrow_copy_assignable_v<Box>);
+
+    {
+      Box x(std::in_place, 5);
+      Box const y(std::in_place, 10);
+      Box& result = (x = y);
+
+      assert(&result == &x);
+      assert(x.__has_value());
+      assert(y.__has_value());
+      assert((*x).value == 10);
+      assert((*x).did_copy_assign);
+    }
+    // check self-assignment (should use the underlying type's assignment too)
+    {
+      Box x(std::in_place, 5);
+      Box& result = (x = x);
+
+      assert(&result == &x);
+      assert(x.__has_value());
+      assert((*x).value == 5);
+      assert((*x).did_copy_assign);
+    }
+  }
+
+  // Test optimization #2 for copy-assignment
+  {
+    using Box = std::ranges::__copyable_box<NothrowCopyConstructible>;
+    static_assert(std::is_copy_assignable_v<Box>);
+    static_assert(std::is_nothrow_copy_assignable_v<Box>);
+
+    {
+      Box x(std::in_place, 5);
+      Box const y(std::in_place, 10);
+      Box& result = (x = y);
+
+      assert(&result == &x);
+      assert(x.__has_value());
+      assert(y.__has_value());
+      assert((*x).value == 10);
+    }
+    // check self-assignment
+    {
+      Box x(std::in_place, 5);
+      Box& result = (x = x);
+
+      assert(&result == &x);
+      assert(x.__has_value());
+      assert((*x).value == 5);
+    }
+  }
+
+  return true;
+}
+
+// Tests for the empty state. Those can't be constexpr, since they are only reached
+// through throwing an exception.
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+void test_empty_state() {
+  using Box = std::ranges::__copyable_box<ThrowsOnCopy>;
+
+  // assign non-empty to empty
+  {
+    Box x = create_empty_box();
+    Box const y(std::in_place, 10);
+    Box& result = (x = y);
+
+    assert(&result == &x);
+    assert(x.__has_value());
+    assert(y.__has_value());
+    assert((*x).value == 10);
+  }
+  // assign empty to non-empty
+  {
+    Box x(std::in_place, 5);
+    Box const y = create_empty_box();
+    Box& result = (x = y);
+
+    assert(&result == &x);
+    assert(!x.__has_value());
+    assert(!y.__has_value());
+  }
+  // assign empty to empty
+  {
+    Box x = create_empty_box();
+    Box const y = create_empty_box();
+    Box& result = (x = y);
+
+    assert(&result == &x);
+    assert(!x.__has_value());
+    assert(!y.__has_value());
+  }
+  // check self-assignment in empty case
+  {
+    Box x = create_empty_box();
+    Box& result = (x = x);
+
+    assert(&result == &x);
+    assert(!x.__has_value());
+  }
+}
+#endif // !defined(TEST_HAS_NO_EXCEPTIONS)
+
+int main(int, char**) {
+  assert(test());
+  static_assert(test());
+
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  test_empty_state();
+#endif
+
+  return 0;
+}