[libcxx] adds concept `std::copy_constructible`

[cjdb]

Summary

Implements parts of:

• P0898R3 Standard Library Concepts
• P1754 Rename concepts to standard_case for C++20, while we still can

Depends on D96230

[Mordante]

Also look at the remarks in D96230 that are applicable here.

libcxx/test/std/concepts/lang/copyconstructible.pass.cpp

12 ↗

(On Diff #322016)

This seems to be a copy-paste. copy_constructible has only one template argument.

libcxx/test/std/concepts/lang/moveconstructible.h

1 ↗

(On Diff #322016)

Misses the header block. Would it make sense to implement this header already in D96230?

[cjdb]

applies fixes wrt comments

[cjdb]

fixes rebase issue

[cjdb]

In D96232#2548949, @Mordante wrote:

Also look at the remarks in D96230 that are applicable here.

Same comments apply.

[Mordante]

LGTM!

[cjdb]

adds #include "test_macros.h"

[ldionne]

libcxx/test/std/concepts/lang/copyconstructible.compile.pass.cpp

22

I'm not sure I follow that comment, but it's non-blocking.

[cjdb]

rebases to make sure CI is happy

[cjdb]

libcxx/test/std/concepts/lang/copyconstructible.compile.pass.cpp

22

Does s/common/shared/ make it a little clearer?

[ldionne]

libcxx/test/std/concepts/lang/copyconstructible.compile.pass.cpp

22

Ah, I looked at the rev for move_constructible and I understand better. Feel free to change the comment or not.

If we have to duplicate this list of types in a bunch of places, we should consider storing it in a single place with a way to reuse it across tests.

[cjdb]

libcxx/test/std/concepts/lang/copyconstructible.compile.pass.cpp

22

I'd like to do that, but it's not feasible without macros (concepts can't be template parameters). Your call here, but I'm... not in favour of that.

libcxx/include/concepts

 concept default_initializable = constructible_from<_Tp> &&
     requires { _Tp{}; } && __default_initializable<_Tp>;
 
 // [concept.moveconstructible]
 template<class _Tp>
 concept move_constructible =
   constructible_from<_Tp, _Tp> && convertible_to<_Tp, _Tp>;
 
+// [concept.copyconstructible]
+template<class _Tp>
+concept copy_constructible =
+  move_constructible<_Tp> &&
+  constructible_from<_Tp, _Tp&> && convertible_to<_Tp&, _Tp> &&
+  constructible_from<_Tp, const _Tp&> && convertible_to<const _Tp&, _Tp> &&
+  constructible_from<_Tp, const _Tp> && convertible_to<const _Tp, _Tp>;
+
 #endif //_LIBCPP_STD_VER > 17 && defined(__cpp_concepts) && __cpp_concepts >= 201811L
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_CONCEPTS

libcxx/test/std/concepts/lang/copyconstructible.compile.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// template<class T>
+// concept copy_constructible;
+
+#include <concepts>
+#include <type_traits>
+
+#include "moveconstructible.h"
+
+// Tests in this namespace are shared with moveconstructible.pass.cpp
+// There are some interesting differences, so it's best if they're tested here
+// too.
+namespace MoveConstructibleTests {
+static_assert(std::copy_constructible<int>);
+static_assert(std::copy_constructible<int*>);
+static_assert(std::copy_constructible<int&>);
+static_assert(std::copy_constructible<const int>);
+static_assert(std::copy_constructible<const int&>);
+static_assert(std::copy_constructible<volatile int>);
+static_assert(std::copy_constructible<volatile int&>);
+static_assert(std::copy_constructible<int (*)()>);
+static_assert(std::copy_constructible<int (&)()>);
+static_assert(std::copy_constructible<HasDefaultOps>);
+static_assert(std::copy_constructible<const CustomMoveCtor&>);
+static_assert(std::copy_constructible<volatile CustomMoveCtor&>);
+static_assert(std::copy_constructible<const CustomMoveAssign&>);
+static_assert(std::copy_constructible<volatile CustomMoveAssign&>);
+static_assert(std::copy_constructible<int HasDefaultOps::*>);
+static_assert(std::copy_constructible<void (HasDefaultOps::*)(int)>);
+static_assert(std::copy_constructible<MemberLvalueReference>);
+
+static_assert(!std::copy_constructible<void>);
+static_assert(!std::copy_constructible<CustomMoveAssign>);
+static_assert(!std::copy_constructible<const CustomMoveCtor>);
+static_assert(!std::copy_constructible<volatile CustomMoveCtor>);
+static_assert(!std::copy_constructible<const CustomMoveAssign>);
+static_assert(!std::copy_constructible<volatile CustomMoveAssign>);
+static_assert(!std::copy_constructible<int[10]>);
+static_assert(!std::copy_constructible<DeletedMoveCtor>);
+static_assert(!std::copy_constructible<ImplicitlyDeletedMoveCtor>);
+static_assert(!std::copy_constructible<DeletedMoveAssign>);
+static_assert(!std::copy_constructible<ImplicitlyDeletedMoveAssign>);
+
+static_assert(std::copy_constructible<DeletedMoveCtor&>);
+static_assert(std::copy_constructible<const DeletedMoveCtor&>);
+static_assert(std::copy_constructible<ImplicitlyDeletedMoveCtor&>);
+static_assert(std::copy_constructible<const ImplicitlyDeletedMoveCtor&>);
+static_assert(std::copy_constructible<DeletedMoveAssign&>);
+static_assert(std::copy_constructible<const DeletedMoveAssign&>);
+static_assert(std::copy_constructible<ImplicitlyDeletedMoveAssign&>);
+static_assert(std::copy_constructible<const ImplicitlyDeletedMoveAssign&>);
+
+// different to moveconstructible.pass.cpp
+static_assert(!std::copy_constructible<int&&>);
+static_assert(!std::copy_constructible<const int&&>);
+static_assert(!std::copy_constructible<volatile int&&>);
+static_assert(!std::copy_constructible<CustomMoveCtor>);
+static_assert(!std::copy_constructible<MoveOnly>);
+static_assert(!std::copy_constructible<const CustomMoveCtor&&>);
+static_assert(!std::copy_constructible<volatile CustomMoveCtor&&>);
+static_assert(!std::copy_constructible<const CustomMoveAssign&&>);
+static_assert(!std::copy_constructible<volatile CustomMoveAssign&&>);
+static_assert(!std::copy_constructible<DeletedMoveCtor&&>);
+static_assert(!std::copy_constructible<const DeletedMoveCtor&&>);
+static_assert(!std::copy_constructible<ImplicitlyDeletedMoveCtor&&>);
+static_assert(!std::copy_constructible<const ImplicitlyDeletedMoveCtor&&>);
+static_assert(!std::copy_constructible<DeletedMoveAssign&&>);
+static_assert(!std::copy_constructible<const DeletedMoveAssign&&>);
+static_assert(!std::copy_constructible<ImplicitlyDeletedMoveAssign&&>);
+static_assert(!std::copy_constructible<const ImplicitlyDeletedMoveAssign&&>);
+static_assert(!std::copy_constructible<MemberRvalueReference>);
+} // namespace MoveConstructibleTests
+
+namespace CopyConstructibleTests {
+struct CopyCtorUserDefined {
+  CopyCtorUserDefined(CopyCtorUserDefined&&) noexcept = default;
+  CopyCtorUserDefined(const CopyCtorUserDefined&);
+};
+static_assert(std::copy_constructible<CopyCtorUserDefined>);
+
+struct CopyAssignUserDefined {
+  CopyAssignUserDefined& operator=(CopyAssignUserDefined&&) noexcept = default;
+  CopyAssignUserDefined& operator=(const CopyAssignUserDefined&);
+};
+static_assert(!std::copy_constructible<CopyAssignUserDefined>);
+
+struct CopyCtorAndAssignUserDefined {
+  CopyCtorAndAssignUserDefined(CopyCtorAndAssignUserDefined&&) noexcept =
+      default;
+  CopyCtorAndAssignUserDefined(const CopyCtorAndAssignUserDefined&);
+  CopyCtorAndAssignUserDefined&
+  operator=(CopyCtorAndAssignUserDefined&&) noexcept = default;
+  CopyCtorAndAssignUserDefined& operator=(const CopyCtorAndAssignUserDefined&);
+};
+static_assert(std::copy_constructible<CopyCtorAndAssignUserDefined>);
+
+struct CopyCtorDeleted {
+  CopyCtorDeleted(CopyCtorDeleted&&) noexcept = default;
+  CopyCtorDeleted(const CopyCtorDeleted&) = delete;
+};
+static_assert(!std::copy_constructible<CopyCtorDeleted>);
+
+struct CopyAssignDeleted {
+  CopyAssignDeleted(CopyAssignDeleted&&) noexcept = default;
+  CopyAssignDeleted(const CopyAssignDeleted&) = delete;
+};
+static_assert(!std::copy_constructible<CopyAssignDeleted>);
+
+struct CopyCtorHasMutableRef {
+  CopyCtorHasMutableRef(CopyCtorHasMutableRef&&) noexcept = default;
+  CopyCtorHasMutableRef(CopyCtorHasMutableRef&) = default;
+};
+static_assert(!std::copy_constructible<CopyCtorHasMutableRef>);
+
+struct CopyCtorProhibitsMutableRef {
+  CopyCtorProhibitsMutableRef(CopyCtorProhibitsMutableRef&&) noexcept = default;
+  CopyCtorProhibitsMutableRef(const CopyCtorProhibitsMutableRef&) = default;
+  CopyCtorProhibitsMutableRef(CopyCtorProhibitsMutableRef&) = delete;
+};
+static_assert(!std::copy_constructible<CopyCtorProhibitsMutableRef>);
+
+struct CopyAssignHasMutableRef {
+  CopyAssignHasMutableRef&
+  operator=(CopyAssignHasMutableRef&&) noexcept = default;
+  CopyAssignHasMutableRef& operator=(CopyAssignHasMutableRef&) = default;
+};
+static_assert(!std::copy_constructible<CopyAssignHasMutableRef>);
+
+struct CopyAssignProhibitsMutableRef {
+  CopyAssignProhibitsMutableRef&
+  operator=(CopyAssignProhibitsMutableRef&&) noexcept = default;
+  CopyAssignProhibitsMutableRef&
+  operator=(const CopyAssignProhibitsMutableRef&) = default;
+  CopyAssignProhibitsMutableRef&
+  operator=(CopyAssignProhibitsMutableRef&) = delete;
+};
+static_assert(!std::copy_constructible<CopyAssignProhibitsMutableRef>);
+
+struct CopyCtorOnly {
+  CopyCtorOnly(CopyCtorOnly&&) noexcept = delete;
+  CopyCtorOnly(const CopyCtorOnly&) = default;
+};
+static_assert(!std::copy_constructible<CopyCtorOnly>);
+
+struct CopyAssignOnly {
+  CopyAssignOnly& operator=(CopyAssignOnly&&) noexcept = delete;
+  CopyAssignOnly& operator=(const CopyAssignOnly&) = default;
+};
+static_assert(!std::copy_constructible<CopyAssignOnly>);
+
+struct CopyOnly {
+  CopyOnly(CopyOnly&&) noexcept = delete;
+  CopyOnly(const CopyOnly&) = default;
+
+  CopyOnly& operator=(CopyOnly&&) noexcept = delete;
+  CopyOnly& operator=(const CopyOnly&) = default;
+};
+static_assert(!std::copy_constructible<CopyOnly>);
+
+struct ExplicitlyCopyable {
+  ExplicitlyCopyable(ExplicitlyCopyable&&) = default;
+  explicit ExplicitlyCopyable(const ExplicitlyCopyable&);
+};
+static_assert(!std::copy_constructible<ExplicitlyCopyable>);
+} // namespace CopyConstructibleTests
+
+int main(int, char**) { return 0; }