more clang-tidy fixes

Author: dietmarkuehl

include/beman/execution26/detail/product_type.hpp

@@ -48,18 +48,17 @@ struct product_type_base<::std::index_sequence<I...>, T...>
     }
     template <::std::size_t J>
     auto get() const& -> decltype(auto) {
-        return this->element_get<J>(::std::move(*this));
+        return this->element_get<J>(*this);
     }
 
     template <::std::size_t J, typename Allocator, typename Self>
     static auto make_element(Allocator&& alloc, Self&& self) -> decltype(auto) {
-        using type = ::std::remove_cvref_t<decltype(std::forward<Self>(self).template element_get<J>(
-            std::forward<Self>(self)))>;
+        using type = ::std::remove_cvref_t<decltype(product_type_base::element_get<J>(std::forward<Self>(self)))>;
         if constexpr (::std::uses_allocator_v<type, Allocator>)
-            return ::std::make_obj_using_allocator<type>(
-                alloc, std::forward<Self>(self).template element_get<J>(std::forward<Self>(self)));
+            return ::std::make_obj_using_allocator<type>(alloc,
+                                                         product_type_base::element_get<J>(std::forward<Self>(self)));
         else
-            return std::forward<Self>(self).template element_get<J>(std::forward<Self>(self));
+            return product_type_base::element_get<J>(std::forward<Self>(self));
     }
 
     auto operator==(const product_type_base&) const -> bool = default;
@@ -69,8 +68,7 @@ template <typename... T>
 struct product_type : ::beman::execution26::detail::product_type_base<::std::index_sequence_for<T...>, T...> {
     template <typename Allocator, typename Product, std::size_t... I>
     static auto make_from(Allocator&& allocator, Product&& product, std::index_sequence<I...>) -> product_type {
-        return {
-            ::std::forward<Product>(product).template make_element<I>(allocator, ::std::forward<Product>(product))...};
+        return {product_type::template make_element<I>(allocator, ::std::forward<Product>(product))...};
     }
 
     template <typename Allocator, typename Product>

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

@@ -17,7 +17,11 @@
 namespace {
 struct not_movable {
     not_movable()              = default;
+    not_movable(const not_movable&)                    = delete;
     not_movable(not_movable&&) = delete;
+    ~not_movable()                                     = default;
+    auto operator=(const not_movable&) -> not_movable& = delete;
+    auto operator=(not_movable&&) -> not_movable&      = delete;
 };
 template <bool Expect, typename Completion, typename CPO, typename... T>
 auto test_just_constraints(CPO const& cpo, T&&... args) -> void {
@@ -60,7 +64,7 @@ auto test_just_constraints() -> void {
 template <typename... T>
 struct value_receiver {
     using receiver_concept = test_std::receiver_t;
-    bool*                                         called;
+    bool*                                         called{};
     test_detail::product_type<std::decay_t<T>...> expect{};
 
     template <typename... A>
@@ -206,7 +210,7 @@ TEST(exec_just) {
         test_just();
         test_just_allocator();
     } catch (...) {
-        ASSERT(nullptr ==
-               "the just tests shouldn't throw"); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
+        // NOLINTNEXTLINE(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
+        ASSERT(nullptr == "the just tests shouldn't throw");
     }
 }

tests/beman/execution26/stoptoken-inplace-members.test.cpp

@@ -3,6 +3,7 @@
 
 #include "test/execution.hpp"
 
+namespace {
 auto test_inplace_stop_token_swap() -> void {
     // Plan:
     // - Given two inplace_stop_token objects which don't compare equal but
@@ -69,6 +70,7 @@ auto test_inplace_stop_token_stop_possible() -> void {
     ASSERT(connected.stop_possible() == true);
     ASSERT(disconnected.stop_requested() == false);
 }
+} // namespace
 
 TEST(stoptoken_inplace_members) {
     test_inplace_stop_token_swap();