Test pointer and template lambdas with Fn/Mut/Once

The pointer path can't be constexpr unfortunately,
but you can always wrap the pointer in a lambda to
make it constexpr if needed.

Author: danakj

subspace/CMakeLists.txt

@@ -51,7 +51,7 @@ target_sources(subspace PUBLIC
     "fn/bind.h"
     "fn/box_fn_defn.h"
     "fn/box_fn_impl.h"
-    "fn/stackfn_defn.h"
+    "fn/fn_defn.h"
     "iter/__private/into_iterator_archetype.h"
     "iter/__private/iterator_end.h"
     "iter/__private/iterator_loop.h"
@@ -152,7 +152,7 @@ add_executable(subspace_unittests
     "construct/into_unittest.cc"
     "construct/default_unittest.cc"
     "fn/box_fn_unittest.cc"
-    "fn/stackfn_unittest.cc"
+    "fn/fn_unittest.cc"
     "iter/iterator_unittest.cc"
     "mem/addressof_unittest.cc"
     "mem/clone_unittest.cc"

subspace/fn/fn.h

@@ -17,4 +17,4 @@
 #include "subspace/fn/bind.h"
 #include "subspace/fn/box_fn_defn.h"
 #include "subspace/fn/box_fn_impl.h"
-#include "subspace/fn/stackfn_defn.h"
+#include "subspace/fn/fn_defn.h"

subspace/fn/stackfn_defn.h renamed to subspace/fn/fn_defn.h

@@ -53,7 +53,7 @@ template <class F>
 struct Invoker {
   template <class R, class... Args>
   static R fnptr_call_mut(const union Storage& s, Args... args) {
-    F f = static_cast<F>(s.fnptr);
+    F f = reinterpret_cast<F>(s.fnptr);
     return (*f)(::sus::forward<Args>(args)...);
   }
 
@@ -65,7 +65,7 @@ struct Invoker {
 
   template <class R, class... Args>
   static R fnptr_call_const(const union Storage& s, Args... args) {
-    const F f = static_cast<const F>(s.fnptr);
+    const F f = reinterpret_cast<const F>(s.fnptr);
     return (*f)(::sus::forward<Args>(args)...);
   }
 
@@ -131,9 +131,9 @@ class [[sus_trivial_abi]] Fn<R(CallArgs...)> {
   ///
   /// #[doc.overloads=ctor.fnpointer]
   template <__private::FunctionPointer<R, CallArgs...> F>
-  constexpr Fn(F ptr) noexcept {
+  Fn(F ptr) noexcept {
     ::sus::check(ptr != nullptr);
-    storage_.fnptr = static_cast<void (*)()>(ptr);
+    storage_.fnptr = reinterpret_cast<void (*)()>(ptr);
     invoke_ = &__private::Invoker<F>::template fnptr_call_const<R, CallArgs...>;
   }
 
@@ -253,9 +253,9 @@ class [[sus_trivial_abi]] FnMut<R(CallArgs...)> {
   ///
   /// #[doc.overloads=ctor.fnpointer]
   template <__private::FunctionPointer<R, CallArgs...> F>
-  constexpr FnMut(F ptr) noexcept {
+  FnMut(F ptr) noexcept {
     ::sus::check(ptr != nullptr);
-    storage_.fnptr = static_cast<void (*)()>(ptr);
+    storage_.fnptr = reinterpret_cast<void (*)()>(ptr);
     invoke_ = &__private::Invoker<F>::template fnptr_call_mut<R, CallArgs...>;
   }
 
@@ -332,7 +332,7 @@ class [[sus_trivial_abi]] FnMut<R(CallArgs...)> {
   friend class FnOnce;
 
   constexpr FnMut(union __private::Storage storage,
-        __private::InvokeFnPtr<R, CallArgs...> invoke)
+                  __private::InvokeFnPtr<R, CallArgs...> invoke)
       : storage_(storage), invoke_(invoke) {}
 
   union __private::Storage storage_;
@@ -383,9 +383,9 @@ class [[sus_trivial_abi]] FnOnce<R(CallArgs...)> {
   ///
   /// #[doc.overloads=ctor.fnpointer]
   template <__private::FunctionPointer<R, CallArgs...> F>
-  constexpr FnOnce(F ptr) noexcept {
+  FnOnce(F ptr) noexcept {
     ::sus::check(ptr != nullptr);
-    storage_.fnptr = static_cast<void (*)()>(ptr);
+    storage_.fnptr = reinterpret_cast<void (*)()>(ptr);
     invoke_ = &__private::Invoker<F>::template fnptr_call_mut<R, CallArgs...>;
   }
 

subspace/fn/stackfn_unittest.cc renamed to subspace/fn/fn_unittest.cc

@@ -12,11 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include "subspace/fn/fn.h"
+
 #include <concepts>
 
 #include "googletest/include/gtest/gtest.h"
 #include "subspace/construct/into.h"
-#include "subspace/fn/fn.h"
 #include "subspace/mem/forward.h"
 #include "subspace/mem/move.h"
 #include "subspace/mem/replace.h"
@@ -116,9 +117,9 @@ static_assert(sus::mem::relocate_by_memcpy<Fn<void()>>);
 static_assert(std::is_constructible_v<FnOnce<void()>, decltype([]() {})>);
 static_assert(std::is_constructible_v<FnMut<void()>, decltype([]() {})>);
 static_assert(std::is_constructible_v<Fn<void()>, decltype([]() {})>);
-static_assert(std::is_constructible_v<FnOnce<void()>, decltype(&v_v_function)>);
-static_assert(std::is_constructible_v<FnMut<void()>, decltype(&v_v_function)>);
-static_assert(std::is_constructible_v<Fn<void()>, decltype(&v_v_function)>);
+static_assert(std::is_constructible_v<FnOnce<void()>, decltype(v_v_function)>);
+static_assert(std::is_constructible_v<FnMut<void()>, decltype(v_v_function)>);
+static_assert(std::is_constructible_v<Fn<void()>, decltype(v_v_function)>);
 //  Non-void types for the same.
 static_assert(std::is_constructible_v<FnOnce<int(float)>,
                                       decltype([](float) { return 1; })>);
@@ -127,10 +128,10 @@ static_assert(std::is_constructible_v<FnMut<int(float)>,
 static_assert(
     std::is_constructible_v<Fn<int(float)>, decltype([](float) { return 1; })>);
 static_assert(
-    std::is_constructible_v<FnOnce<int(float)>, decltype(&i_f_function)>);
+    std::is_constructible_v<FnOnce<int(float)>, decltype(i_f_function)>);
 static_assert(
-    std::is_constructible_v<FnMut<int(float)>, decltype(&i_f_function)>);
-static_assert(std::is_constructible_v<Fn<int(float)>, decltype(&i_f_function)>);
+    std::is_constructible_v<FnMut<int(float)>, decltype(i_f_function)>);
+static_assert(std::is_constructible_v<Fn<int(float)>, decltype(i_f_function)>);
 //  Lambdas with bound args can be bound to FnOnce, FnMut and Fn.
 static_assert(std::is_constructible_v<FnOnce<void()>,
                                       decltype([i = int(1)]() { (void)i; })>);
@@ -148,11 +149,11 @@ static_assert(std::is_constructible_v<
 // The return type of the FnOnce must match that of the lambda. It will not
 // allow converting to void.
 static_assert(std::is_constructible_v<FnOnce<SubClass*(BaseClass*)>,
-                                      decltype(&s_b_function)>);
-static_assert(!std::is_constructible_v<FnOnce<void(BaseClass*)>,
-                                       decltype(&b_b_function)>);
+                                      decltype(s_b_function)>);
+static_assert(
+    !std::is_constructible_v<FnOnce<void(BaseClass*)>, decltype(b_b_function)>);
 static_assert(!std::is_constructible_v<FnOnce<SubClass*(BaseClass*)>,
-                                       decltype(&b_b_function)>);
+                                       decltype(b_b_function)>);
 static_assert(std::is_constructible_v<FnOnce<SubClass*(BaseClass*)>,
                                       decltype(s_b_lambda)>);
 static_assert(
@@ -161,9 +162,9 @@ static_assert(!std::is_constructible_v<FnOnce<SubClass*(BaseClass*)>,
                                        decltype(b_b_lambda)>);
 // Similarly, argument types can't be converted to a different type.
 static_assert(std::is_constructible_v<FnOnce<SubClass*(SubClass*)>,
-                                      decltype(&s_s_function)>);
+                                      decltype(s_s_function)>);
 static_assert(!std::is_constructible_v<FnOnce<SubClass*(BaseClass*)>,
-                                       decltype(&s_s_function)>);
+                                       decltype(s_s_function)>);
 static_assert(std::is_constructible_v<FnOnce<SubClass*(SubClass*)>,
                                       decltype(s_s_lambda)>);
 static_assert(!std::is_constructible_v<FnOnce<SubClass*(BaseClass*)>,
@@ -234,6 +235,34 @@ static_assert(!can_run<void, int&, int&&>);
 static_assert(!can_run<void, int&, const int&&>);
 
 TEST(Fn, Pointer) {
+  {
+    auto receive_fn = [](FnOnce<i32(i32, i32)> f, i32 a, i32 b) {
+      return sus::move(f)(a, b);
+    };
+    auto* ptr = +[](i32 a, i32 b) { return a * 2 + b; };
+    EXPECT_EQ(receive_fn(ptr, 1, 2), 4);
+  }
+  {
+    auto receive_fn = [](FnMut<i32(i32, i32)> f, i32 a, i32 b) {
+      f(a, b);
+      return sus::move(f)(a, b);
+    };
+    auto* ptr = +[](i32 a, i32 b) { return a * 2 + b; };
+    EXPECT_EQ(receive_fn(ptr, 1, 2), 4);
+  }
+  {
+    {
+      auto receive_fn = [](Fn<i32(i32, i32)> f, i32 a, i32 b) {
+        f(a, b);
+        return sus::move(f)(a, b);
+      };
+      auto* ptr = +[](i32 a, i32 b) { return a * 2 + b; };
+      EXPECT_EQ(receive_fn(ptr, 1, 2), 4);
+    }
+  }
+}
+
+TEST(Fn, CapturelessLambda) {
   {
     auto receive_fn = [](FnOnce<i32(i32, i32)> f, i32 a, i32 b) {
       return sus::move(f)(a, b);
@@ -291,7 +320,32 @@ TEST(Fn, Lambda) {
   }
 }
 
-void g() {}
+TEST(Fn, TemplateLambda) {
+  {
+    auto receive_fn = [](FnOnce<i32(i32)> f, i32 b) { return sus::move(f)(b); };
+    auto lambda = [a = 1_i32](auto b) { return a * 2 + b; };
+    EXPECT_EQ(receive_fn(lambda, 2), 4);
+  }
+  {
+    auto receive_fn = [](FnMut<i32(i32)> f, i32 b) {
+      f(b);
+      return sus::move(f)(b);
+    };
+    auto lambda = [a = 1_i32](auto b) mutable {
+      a += 1;
+      return a * 2 + b;
+    };
+    EXPECT_EQ(receive_fn(lambda, 2), 8);
+  }
+  {
+    auto receive_fn = [](Fn<i32(i32)> f, i32 b) {
+      f(b);
+      return sus::move(f)(b);
+    };
+    auto lambda = [a = 1_i32](auto b) { return a * 2 + b; };
+    EXPECT_EQ(receive_fn(lambda, 2), 4);
+  }
+}
 
 TEST(FnDeathTest, NullPointer) {
   void (*f)() = nullptr;