Add option to limit empty callable propagation to known types

This approach roughly matches the one used by std::function, explicitly
enumerating the types which are supported for empty propagation.

Fixes #48

Author: mystor

Diff for: CMakeLists.txt

@@ -113,6 +113,9 @@ if (FU2_IS_TOP_LEVEL_PROJECT)
   option(FU2_WITH_CPP_LATEST
       "Enable the highest C++ standard available for testing polyfills"
       OFF)
+  option(FU2_WITH_LIMITED_EMPTY_PROPAGATION
+      "Test limiting empty propagation to only function pointers, member pointers, std::function, and specializations of fu2::function_base"
+      OFF)
 
   if (BUILD_TESTING)
     if (FU2_WITH_NO_EXCEPTIONS)
@@ -125,6 +128,11 @@ if (FU2_IS_TOP_LEVEL_PROJECT)
       add_definitions(-DTESTS_NO_DEATH_TESTS)
     endif()
 
+    if (FU2_WITH_LIMITED_EMPTY_PROPAGATION)
+      message(STATUS "Testing with limited empty propagation")
+      add_definitions(-DFU2_WITH_LIMITED_EMPTY_PROPAGATION)
+    endif()
+
     add_subdirectory(test)
   endif()
 endif ()

Diff for: include/function2/function2.hpp

@@ -35,10 +35,15 @@
 #endif
 #endif
 #endif // FU2_WITH_DISABLED_EXCEPTIONS
+// - FU2_HAS_LIMITED_EMPTY_PROPAGATION
+#if defined(FU2_WITH_LIMITED_EMPTY_PROPAGATION)
+#define FU2_HAS_LIMITED_EMPTY_PROPAGATION
+#endif // FU2_WITH_NO_EMPTY_PROPAGATION
 // - FU2_HAS_NO_FUNCTIONAL_HEADER
 #if !defined(FU2_WITH_NO_FUNCTIONAL_HEADER) &&                                 \
     !defined(FU2_NO_FUNCTIONAL_HEADER) &&                                      \
-    !defined(FU2_HAS_DISABLED_EXCEPTIONS)
+    (!defined(FU2_HAS_DISABLED_EXCEPTIONS) ||                                  \
+     defined(FU2_HAS_LIMITED_EMPTY_PROPAGATION))
 #include <functional>
 #else
 #define FU2_HAS_NO_FUNCTIONAL_HEADER
@@ -1381,13 +1386,29 @@ struct accepts_all<
     void_t<std::enable_if_t<accepts_one<T, Signatures>::value>...>>
     : std::true_type {};
 
-/// Deduces to a true_type if the type T is implementing operator bool()
-/// or if the type is convertible to bool directly, this also implements an
-/// optimizations for function references `void(&)()` which are can never
-/// be null and for such a conversion to bool would never return false.
 #if defined(FU2_HAS_NO_EMPTY_PROPAGATION)
 template <typename T>
 struct use_bool_op : std::false_type {};
+#elif defined(FU2_HAS_LIMITED_EMPTY_PROPAGATION)
+/// Implementation for use_bool_op based on the behaviour of std::function,
+/// propagating empty state for pointers, `std::function` and
+/// `fu2::detail::function` types only.
+template <typename T>
+struct use_bool_op : std::false_type {};
+
+#if !defined(FU2_HAS_NO_FUNCTIONAL_HEADER)
+template <typename Signature>
+struct use_bool_op<std::function<Signature>> : std::true_type {};
+#endif
+
+template <typename Config, typename Property>
+struct use_bool_op<function<Config, Property>> : std::true_type {};
+
+template <typename T>
+struct use_bool_op<T*> : std::true_type {};
+
+template <typename Class, typename T>
+struct use_bool_op<T Class::*> : std::true_type {};
 #else
 template <typename T, typename = void>
 struct has_bool_op : std::false_type {};
@@ -1400,6 +1421,10 @@ struct has_bool_op<T, void_t<decltype(bool(std::declval<T>()))>>
 #endif
 };
 
+/// Deduces to a true_type if the type T is implementing operator bool()
+/// or if the type is convertible to bool directly, this also implements an
+/// optimizations for function references `void(&)()` which are can never
+/// be null and for such a conversion to bool would never return false.
 template <typename T>
 struct use_bool_op : has_bool_op<T> {};
 

Diff for: test/empty-function-call-test.cpp

@@ -96,7 +96,12 @@ TYPED_TEST(AllEmptyFunctionCallTests, CallPropagatesEmptyCustom) {
   {
     typename TestFixture::template left_t<void(some_tag)> fn(
         my_callable_empty{});
+#if defined(FU2_HAS_LIMITED_EMPTY_PROPAGATION) ||                              \
+    defined(FU2_HAS_NO_EMPTY_PROPAGATION)
+    ASSERT_FALSE(fn.empty());
+#else
     ASSERT_TRUE(fn.empty());
+#endif
   }
 }
 #endif // FU2_HAS_NO_EMPTY_PROPAGATION

Diff for: test/regressions.cpp

@@ -127,11 +127,11 @@ TEST(regression_tests, can_assign_nonowning_noncopyable_view) {
 
 static fu2::unique_function<void()> issue_14_create() {
   // remove the commented dummy capture to be compilable
-  fu2::unique_function<void()>
-      func = [i = std::vector<std::vector<std::unique_ptr<int>>>{}
-              // ,dummy = std::unique_ptr<int>()
-  ](){
-          // ...
+  fu2::unique_function<void()> func =
+      [i = std::vector<std::vector<std::unique_ptr<int>>>{}
+       // ,dummy = std::unique_ptr<int>()
+  ]() {
+        // ...
       };
 
   return std::move(func);
@@ -199,6 +199,35 @@ TEST(regression_tests, unique_non_copyable) {
   ASSERT_EQ(view(), 5);
 }*/
 
+// https://github.com/Naios/function2/issues/48
+// -Waddress warning generated for non-capturing lambdas on gcc <= 9.2 #48
+TEST(regression_tests, no_address_warning_in_constexpr_lambda) {
+  using fun_t = fu2::function<int()>;
+  fun_t f([] { return 3836474; });
+
+  ASSERT_EQ(f(), 3836474);
+}
+
+struct custom_falsy_invocable {
+  operator bool() const {
+    return false;
+  }
+  int operator()() const {
+    return 0;
+  }
+};
+
+TEST(regression_tests, custom_falsy_invocable) {
+  fu2::function<int()> f(custom_falsy_invocable{});
+
+#if defined(FU2_HAS_LIMITED_EMPTY_PROPAGATION) ||                              \
+    defined(FU2_HAS_NO_EMPTY_PROPAGATION)
+  ASSERT_TRUE(static_cast<bool>(f));
+#else
+  ASSERT_FALSE(static_cast<bool>(f));
+#endif
+}
+
 namespace issue_35 {
 class ref_obj {
 public: