more clang-tidy fixes

Author: dietmarkuehl

include/beman/execution26/detail/basic_operation.hpp

@@ -38,8 +38,11 @@ template <typename Sender, typename Receiver>
     basic_operation(Sender&& sender, Receiver&& receiver) noexcept(true /*-dk:TODO*/)
         : ::beman::execution26::detail::basic_state<Sender, Receiver>(::std::forward<Sender>(sender),
                                                                       ::std::move(receiver)),
+          // NOLINTBEGIN(bugprone-use-after-move,hicpp-invalid-access-moved)
+          //-dk:TODO deal with moving the sender twice
           inner_ops(::beman::execution26::detail::connect_all(
               this, ::std::forward<Sender>(sender), ::beman::execution26::detail::indices_for<Sender>())) {}
+    // NOLINTEND(bugprone-use-after-move,hicpp-invalid-access-moved)
 
   private:
     auto start() & noexcept -> void {

include/beman/execution26/detail/basic_sender.hpp

@@ -42,6 +42,7 @@ struct basic_sender : ::beman::execution26::detail::product_type<Tag, Data, Chil
     template <typename Receiver>
         requires(not::beman::execution26::receiver<Receiver>)
     auto connect(Receiver receiver) = BEMAN_EXECUTION26_DELETE("the passed receiver doesn't model receiver");
+
   private:
 #if __cpp_explicit_this_parameter < 202110L
     template <::beman::execution26::receiver Receiver>

include/beman/execution26/detail/notify.hpp

@@ -13,8 +13,7 @@
 
 namespace beman::execution26::detail {
 struct notify_t;
-class notifier
-: ::beman::execution26::detail::immovable {
+class notifier : ::beman::execution26::detail::immovable {
   public:
     auto complete() -> void {
         ::std::unique_lock kerberos(this->lock);

include/beman/execution26/detail/product_type.hpp

@@ -75,7 +75,7 @@ struct product_type : ::beman::execution26::detail::product_type_base<::std::ind
 
     template <typename Allocator, typename Product>
     static auto make_from(Allocator&& allocator, Product&& product) -> product_type {
-        return std::forward<Product>(product).make_from(
+        return product_type::make_from(
             ::std::forward<Allocator>(allocator), ::std::forward<Product>(product), ::std::index_sequence_for<T...>{});
     }
 

include/beman/execution26/detail/simple_counting_scope.hpp

@@ -20,8 +20,7 @@ class simple_counting_scope;
 
 // ----------------------------------------------------------------------------
 
-class beman::execution26::simple_counting_scope
-: ::beman::execution26::detail::immovable {
+class beman::execution26::simple_counting_scope : ::beman::execution26::detail::immovable {
   public:
     class token;
     class assoc;
@@ -58,7 +57,15 @@ class beman::execution26::simple_counting_scope
     }
 
   private:
-    enum class state_t: unsigned char { unused, open, open_and_joining, closed, closed_and_joining, unused_and_closed, joined };
+    enum class state_t : unsigned char {
+        unused,
+        open,
+        open_and_joining,
+        closed,
+        closed_and_joining,
+        unused_and_closed,
+        joined
+    };
     friend class assoc;
     auto try_associate() noexcept -> simple_counting_scope* {
         ::std::lock_guard lock(this->mutex);
@@ -90,7 +97,7 @@ class beman::execution26::simple_counting_scope
 
 // ----------------------------------------------------------------------------
 
-// NOLINTBEGIN(misc-unconventional-assign-operator)
+// NOLINTBEGIN(misc-unconventional-assign-operator,hicpp-special-member-functions)
 class beman::execution26::simple_counting_scope::assoc {
   public:
     assoc() = default;
@@ -114,7 +121,7 @@ class beman::execution26::simple_counting_scope::assoc {
         : scope(scope ? scope->try_associate() : nullptr) {}
     beman::execution26::simple_counting_scope* scope{};
 };
-// NOLINTEND(misc-unconventional-assign-operator)
+// NOLINTEND(misc-unconventional-assign-operator,hicpp-special-member-functions)
 
 // ----------------------------------------------------------------------------
 

include/beman/execution26/detail/starts_on.hpp

@@ -43,9 +43,8 @@ struct starts_on_t {
 
     template <::beman::execution26::scheduler Scheduler, ::beman::execution26::sender Sender>
     auto operator()(Scheduler&& scheduler, Sender&& sender) const {
-        auto domain{::beman::execution26::detail::query_with_default(::beman::execution26::get_domain,
-                                                                     ::std::forward<Scheduler>(scheduler),
-                                                                     ::beman::execution26::default_domain{})};
+        auto domain{::beman::execution26::detail::query_with_default(
+            ::beman::execution26::get_domain, scheduler, ::beman::execution26::default_domain{})};
         return ::beman::execution26::transform_sender(
             domain,
             ::beman::execution26::detail::make_sender(

tests/beman/execution26/allocator-requirements-general.test.cpp

@@ -65,7 +65,12 @@ struct deallocate_size_type_mismatch {
 struct not_copy_constructible {
     using value_type = int;
 
-    not_copy_constructible(const not_copy_constructible&) = delete;
+    not_copy_constructible()                                                = default;
+    not_copy_constructible(not_copy_constructible&&)                        = delete;
+    not_copy_constructible(const not_copy_constructible&)                   = delete;
+    ~not_copy_constructible()                                               = default;
+    auto operator=(not_copy_constructible&&) -> not_copy_constructible      = delete;
+    auto operator=(const not_copy_constructible&) -> not_copy_constructible = delete;
     auto allocate(::std::size_t n) -> int* { return new int[n]; }
     auto deallocate(/*long*/ int*, ::std::size_t) -> void {}
 

tests/beman/execution26/exec-connect.test.cpp

@@ -23,8 +23,11 @@ struct state {
 
     template <typename R>
     state(int value, R&& r) : value(value), receiver(std::forward<R>(r)) {}
+    state(const state&)                    = delete;
     state(state&&) = delete;
-    ~state()       = default;
+    ~state()                               = default;
+    auto operator=(const state&) -> state& = delete;
+    auto operator=(state&&) -> state&      = delete;
     auto start() noexcept -> void {}
 };
 
@@ -43,8 +46,11 @@ struct rvalue_sender {
     int value{};
 
     explicit rvalue_sender(int value) : value(value) {}
+    rvalue_sender(const rvalue_sender&)                    = delete;
     rvalue_sender(rvalue_sender&&) = default;
-    auto operator=(rvalue_sender&&) -> rvalue_sender& = default;
+    auto operator=(const rvalue_sender&) -> rvalue_sender& = delete;
+    auto operator=(rvalue_sender&&) -> rvalue_sender&      = default;
+    ~rvalue_sender()                                       = default;
 
     template <typename Receiver>
     auto connect(Receiver&& receiver) && -> state<kind::plain, Receiver> {
@@ -64,7 +70,10 @@ struct receiver {
     explicit receiver(int value, bool* set_stopped_called = {})
         : value(value), set_stopped_called(set_stopped_called) {}
     receiver(receiver&&)                           = default;
+    receiver(const receiver&)                      = delete;
+    ~receiver()                                    = default;
     auto operator=(receiver&&) -> receiver&        = default;
+    auto operator=(const receiver&) -> receiver&   = delete;
     auto operator==(const receiver&) const -> bool = default;
 
     auto get_env() const noexcept -> env { return {this->value + 2}; }
@@ -97,7 +106,10 @@ struct domain_receiver {
 
     explicit domain_receiver(int value) : value(value) {}
     domain_receiver(domain_receiver&&)                    = default;
-    auto operator=(domain_receiver&&) -> domain_receiver& = default;
+    domain_receiver(const domain_receiver&)                    = delete;
+    ~domain_receiver()                                         = default;
+    auto operator=(domain_receiver&&) -> domain_receiver&      = default;
+    auto operator=(const domain_receiver&) -> domain_receiver& = delete;
 
     auto operator==(const domain_receiver&) const -> bool = default;
 

tests/beman/execution26/exec-general.test.cpp

@@ -29,8 +29,8 @@ auto test_movable_value() -> void {
 
     static_assert(not test_detail::movable_value<non_movable>);
     static_assert(not test_detail::movable_value<const non_copyable>);
-    static_assert(not test_detail::movable_value<int[1]>);
-    static_assert(not test_detail::movable_value<int(&)[1]>);
+    static_assert(not test_detail::movable_value<int[1]>);    // NOLINT(hicpp-avoid-c-arrays)
+    static_assert(not test_detail::movable_value<int(&)[1]>); // NOLINT(hicpp-avoid-c-arrays)
 }
 
 auto test_matching_sig() -> void {

tests/beman/execution26/exec-just.test.cpp

@@ -196,11 +196,17 @@ auto test_just_allocator() -> void {
 } // namespace
 
 TEST(exec_just) {
-    test_just_constraints();
-    test_just();
-    test_just_allocator();
+
     using type = test_detail::
         call_result_t<test_std::get_completion_signatures_t, decltype(test_std::just()), test_std::empty_env>;
 
     static_assert(std::same_as<test_std::completion_signatures<test_std::set_value_t()>, type>);
+    try {
+        test_just_constraints();
+        test_just();
+        test_just_allocator();
+    } catch (...) {
+        ASSERT(nullptr ==
+               "the just tests shouldn't throw"); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
+    }
 }