[libcxx] adds concept std::semiregular

[cjdb]

Summary

Implements parts of:

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

Depends on D97443

[cjdb]

While this has mostly been copy/pasted from copyable.compile.pass.cpp, there are some differences, which I've highlighted.

libcxx/test/std/concepts/object/semiregular.compile.pass.cpp

82–83

New test.

104–108

New tests.

145–151

New tests.

[cjdb]

rebases to sync with dependencies

[• Quuxplusone]

Code looks good, tests look too long — you know the drill.

libcxx/test/std/concepts/object/copyable.h

39

I'm confused by this change. Was const_copy_assignment already used in the tests for std::copyable? Were those tests intended to check that it was std::copyable despite being not-default-initializable? By making it default-initializable (and thus std::semiregular), are you nerfing the existing std::copyable tests?

libcxx/test/std/concepts/object/semiregular.compile.pass.cpp

12

s/From/T/
(and this probably affects other patches as well)

libcxx/test/std/concepts/object/semiregular.h

18

We don't need to drag in a dependency on optional here. Also, it's not obvious to me that nullopt_t is inheritable-from; certainly users should not do that. Therefore I strongly recommend replacing this with the following:

struct no_default_ctor { no_default_ctor(int); };
struct derived_from_non_default_initializable : no_default_ctor {};
struct has_non_default_initializable { no_default_ctor x; };

// and/or perhaps also test one with a deleted default ctor? but that'll double the size of the tests again
struct deleted_default_ctor { deleted_default_ctor() = delete; };

[cjdb]

libcxx/test/std/concepts/object/copyable.h

39

The name of the type describes what's going on. This type would have been automatically default-initalisable if I hadn't needed to supply the other constructors to get back copyability (and since the default constructor wasn't necessary at the time, I forgot to add it back in). This type never intended to exclude the default constructor, it just did by accident.

I don't consider it a nerf, because concepts aren't exclusive, and being default_initializable doesn't have any relation to copyable. However since D97443 hasn't landed, I've moved this change over there, along with others (e.g. line 58).

[cjdb]

applies @Quuxplusone's feedback (which I thought had already been done)

libcxx/include/concepts

 template<class _Tp>
 concept copyable =
   copy_constructible<_Tp> &&
   movable<_Tp> &&
   assignable_from<_Tp&, _Tp&> &&
   assignable_from<_Tp&, const _Tp&> &&
   assignable_from<_Tp&, const _Tp>;
 
+template<class _Tp>
+concept semiregular = copyable<_Tp> && default_initializable<_Tp>;
+
 // [concept.invocable]
 template<class _Fn, class... _Args>
 concept invocable = requires(_Fn&& __fn, _Args&&... __args) {
   _VSTD::invoke(_VSTD::forward<_Fn>(__fn), _VSTD::forward<_Args>(__args)...); // not required to be equality preserving
 };
 
 // [concept.regular.invocable]
 template<class _Fn, class... _Args>

libcxx/test/std/concepts/object/copyable.h

 
 struct derived_from_noncopyable : std::unique_ptr<int> {};
 
 struct has_noncopyable {
   std::unique_ptr<int> x;
 };
 
 struct const_copy_assignment {
+  const_copy_assignment();
+
   const_copy_assignment(const_copy_assignment const&);
   const_copy_assignment(const_copy_assignment&&);
 
   const_copy_assignment& operator=(const_copy_assignment&&);
   const_copy_assignment const& operator=(const_copy_assignment const&) const;
 };
 
 struct volatile_copy_assignment {
   volatile_copy_assignment(volatile_copy_assignment volatile&);
   volatile_copy_assignment(volatile_copy_assignment volatile&&);
 
   volatile_copy_assignment& operator=(volatile_copy_assignment&&);
   volatile_copy_assignment volatile&
   operator=(volatile_copy_assignment const&) volatile;
 };
 
 struct cv_copy_assignment {
+  cv_copy_assignment();
   cv_copy_assignment(cv_copy_assignment const volatile&);
   cv_copy_assignment(cv_copy_assignment const volatile&&);
 
   cv_copy_assignment const volatile&
   operator=(cv_copy_assignment const volatile&) const volatile;
   cv_copy_assignment const volatile&
   operator=(cv_copy_assignment const volatile&&) const volatile;
 };
 
 #endif // TEST_STD_CONCEPTS_OBJECT_COPYABLE_H

libcxx/test/std/concepts/object/semiregular.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 TEST_STD_CONCEPTS_OBJECT_SEMIREGULAR_H
+#define TEST_STD_CONCEPTS_OBJECT_SEMIREGULAR_H
+
+#include <optional>
+
+#include "copyable.h"
+
+struct derived_from_non_default_initializable : std::nullopt_t {};
+struct has_non_default_initializable {
+  std::in_place_t x;
+};
+
+#endif // TEST_STD_CONCEPTS_OBJECT_SEMIREGULAR_H

libcxx/test/std/concepts/object/semiregular.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++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// template<class From>
+// concept semiregular = see below;
+
+#include <concepts>
+
+#include <deque>
+#include <forward_list>
+#include <list>
+#include <map>
+#include <memory>
+#include <optional>
+#include <stdexcept>
+#include <tuple>
+#include <unordered_map>
+#include <vector>
+
+#include "semiregular.h"
+
+static_assert(std::semiregular<int>);
+static_assert(std::semiregular<int volatile>);
+static_assert(std::semiregular<int*>);
+static_assert(std::semiregular<int const*>);
+static_assert(std::semiregular<int volatile*>);
+static_assert(std::semiregular<int volatile const*>);
+static_assert(std::semiregular<int (*)()>);
+
+struct S {};
+static_assert(std::semiregular<S>);
+static_assert(std::semiregular<int S::*>);
+static_assert(std::semiregular<int (S::*)()>);
+static_assert(std::semiregular<int (S::*)() noexcept>);
+static_assert(std::semiregular<int (S::*)() &>);
+static_assert(std::semiregular<int (S::*)() & noexcept>);
+static_assert(std::semiregular<int (S::*)() &&>);
+static_assert(std::semiregular<int (S::*)() && noexcept>);
+static_assert(std::semiregular<int (S::*)() const>);
+static_assert(std::semiregular<int (S::*)() const noexcept>);
+static_assert(std::semiregular<int (S::*)() const&>);
+static_assert(std::semiregular<int (S::*)() const & noexcept>);
+static_assert(std::semiregular<int (S::*)() const&&>);
+static_assert(std::semiregular<int (S::*)() const && noexcept>);
+static_assert(std::semiregular<int (S::*)() volatile>);
+static_assert(std::semiregular<int (S::*)() volatile noexcept>);
+static_assert(std::semiregular<int (S::*)() volatile&>);
+static_assert(std::semiregular<int (S::*)() volatile & noexcept>);
+static_assert(std::semiregular<int (S::*)() volatile&&>);
+static_assert(std::semiregular<int (S::*)() volatile && noexcept>);
+static_assert(std::semiregular<int (S::*)() const volatile>);
+static_assert(std::semiregular<int (S::*)() const volatile noexcept>);
+static_assert(std::semiregular<int (S::*)() const volatile&>);
+static_assert(std::semiregular<int (S::*)() const volatile & noexcept>);
+static_assert(std::semiregular<int (S::*)() const volatile&&>);
+static_assert(std::semiregular<int (S::*)() const volatile && noexcept>);
+
+static_assert(std::semiregular<std::vector<int> >);
+static_assert(std::semiregular<std::deque<int> >);
+static_assert(std::semiregular<std::forward_list<int> >);
+static_assert(std::semiregular<std::list<int> >);
+static_assert(std::semiregular<std::shared_ptr<std::unique_ptr<int> > >);
+static_assert(std::semiregular<std::optional<std::vector<int> > >);
+static_assert(std::semiregular<std::vector<int> >);
+static_assert(std::semiregular<std::vector<std::unique_ptr<int> > >);
+
+static_assert(std::semiregular<has_volatile_member>);
+static_assert(std::semiregular<has_array_member>);
+
+// Not objects
+static_assert(!std::semiregular<void>);
+static_assert(!std::semiregular<int&>);
+static_assert(!std::semiregular<int const&>);
+static_assert(!std::semiregular<int volatile&>);
+static_assert(!std::semiregular<int const volatile&>);
+static_assert(!std::semiregular<int&&>);
+static_assert(!std::semiregular<int const&&>);
+static_assert(!std::semiregular<int volatile&&>);
+static_assert(!std::semiregular<int const volatile&&>);
+static_assert(!std::semiregular<int()>);
+static_assert(!std::semiregular<int (&)()>);
+static_assert(!std::semiregular<int[5]>);
+
+// Not copyable
+static_assert(!std::semiregular<std::unique_ptr<int> >);
+static_assert(!std::semiregular<int const>);
+static_assert(!std::semiregular<int const volatile>);
+static_assert(std::semiregular<const_copy_assignment const>);
+static_assert(!std::semiregular<volatile_copy_assignment volatile>);
+static_assert(std::semiregular<cv_copy_assignment const volatile>);
+static_assert(!std::semiregular<no_copy_constructor>);
+static_assert(!std::semiregular<no_copy_assignment>);
+static_assert(!std::semiregular<no_copy_assignment_mutable>);
+static_assert(!std::semiregular<derived_from_noncopyable>);
+static_assert(!std::semiregular<has_noncopyable>);
+static_assert(!std::semiregular<has_const_member>);
+static_assert(!std::semiregular<has_cv_member>);
+static_assert(!std::semiregular<has_lvalue_reference_member>);
+static_assert(!std::semiregular<has_rvalue_reference_member>);
+static_assert(!std::semiregular<has_function_ref_member>);
+static_assert(!std::semiregular<deleted_assignment_from_const_rvalue>);
+
+// Not default_initialzable
+static_assert(!std::semiregular<std::runtime_error>);
+static_assert(
+    !std::semiregular<std::tuple<std::runtime_error, std::overflow_error> >);
+static_assert(!std::semiregular<std::nullopt_t>);
+static_assert(!std::semiregular<no_copy_constructor>);
+static_assert(!std::semiregular<no_copy_assignment>);
+static_assert(std::is_copy_assignable_v<no_copy_assignment_mutable>);
+static_assert(!std::semiregular<no_copy_assignment_mutable>);
+static_assert(!std::semiregular<derived_from_noncopyable>);
+static_assert(!std::semiregular<has_noncopyable>);
+
+static_assert(!std::semiregular<derived_from_non_default_initializable>);
+static_assert(!std::semiregular<has_non_default_initializable>);
+
+int main(int, char**) { return 0; }