[libc] Adjust the `cpp:function` type to support lambdas

[jhuber6]

Summary

The current function type does not support generic lambdas because it
relies on the lambda being implicitly convertible to a function pointer.
This patch adds support for this by copying the existing lightweight
function_ref type.

[jhuber6]

Add l-value forward.

[jhuber6]

Add second SFINAE check required for overloading.

[tschuett]

libc/src/__support/CPP/functional.h

22

I am a bit confused by the naming. ISO C++ is going to call it std::function_ref.

[jhuber6]

libc/src/__support/CPP/functional.h

22

It used to be called cpp::function and I'm basically copying llvm::function_ref, so I just changed the name for consistency.

[sivachandra]

libc/src/__support/CPP/functional.h

46

As suggested on discord, can we just replace this with __is_convertible? Minimum clang version we support is 11 and gcc version 12.2: https://libc.llvm.org/compiler_support.html

[jhuber6]

libc/src/__support/CPP/functional.h

46

Since I ended up writing it the more generic way I'm somewhat tempted to keep it, but I try to change it.

[sivachandra]

libc/src/__support/CPP/type_traits.h

173

Can you add commentary to explain what is going on here?

176

Ditto.

[jhuber6]

Add comments

[sivachandra]

libc/src/__support/CPP/type_traits.h

173

Sorry, I meant commentary for void(static_cast<T (*)()>(nullptr)) in line 175 and for void(declval<void (&)(T)>()(declval<F>())) on line 179.

[jhuber6]

The impolementation was too complicated to explain so I used one provided by "philnik" on Discord.

[jhuber6]

Clean up.

[sivachandra]

libc/src/__support/CPP/type_traits.h

184

I think I can reason this out but I am not sure if it comprehensive. At the same time, we don't have to be comprehensive in the libc.

libc/src/__support/CPP/functional.h

 //===-- Self contained functional header ------------------------*- C++ -*-===//
 //
 // 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 LLVM_LIBC_SRC_SUPPORT_CPP_FUNCTIONAL_H
 #define LLVM_LIBC_SRC_SUPPORT_CPP_FUNCTIONAL_H
 
+#include "src/__support/CPP/type_traits.h"
+#include "src/__support/CPP/utility.h"
+#include "src/__support/macros/attributes.h"
+
+#include <stdint.h>
+
 namespace __llvm_libc {
 namespace cpp {
 
-template <typename F> class function;
-
-template <typename R, typename... Args> class function<R(Args...)> {
-  R (*func)(Args...) = nullptr;
+/// A function type adapted from LLVM's function_ref type. This class does not
+/// own the callable, so it is not in general safe to store a function_ref.
+template <typename Fn> class function;
+
+template <typename Ret, typename... Params> class function<Ret(Params...)> {
+  Ret (*callback)(intptr_t callable, Params... params) = nullptr;
+  intptr_t callable;
+
+  template <typename Callable>
+  LIBC_INLINE static Ret callback_fn(intptr_t callable, Params... params) {
+    return (*reinterpret_cast<Callable *>(callable))(
+        forward<Params>(params)...);
+  }
 
 public:
-  constexpr function() = default;
-  template <typename F> constexpr function(F &&f) : func(f) {}
+  LIBC_INLINE function() = default;
+  LIBC_INLINE function(decltype(nullptr)) {}
+  LIBC_INLINE ~function() = default;
+
+  template <typename Callable>
+  LIBC_INLINE function(
+      Callable &&callable,
+      enable_if_t<!is_same<remove_cvref_t<Callable>, function>::value> * =
+          nullptr,
+      cpp::enable_if_t<cpp::is_void<Ret>::value ||
+                       cpp::is_convertible<decltype(cpp::declval<Callable>()(
+                                               cpp::declval<Params>()...)),
+                                           Ret>::value> * = nullptr)
+      : callback(callback_fn<remove_reference_t<Callable>>),
+        callable(reinterpret_cast<intptr_t>(&callable)) {}
+
+  LIBC_INLINE Ret operator()(Params... params) const {
+    return callback(callable, forward<Params>(params)...);
+  }
 
-  constexpr R operator()(Args... params) { return func(params...); }
+  LIBC_INLINE explicit operator bool() const { return callback; }
 };
 
 } // namespace cpp
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_CPP_FUNCTIONAL_H

libc/src/__support/CPP/type_traits.h

 //===-- Self contained C++ type traits --------------------------*- C++ -*-===//
 //
 // 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 LLVM_LIBC_SRC_SUPPORT_CPP_TYPETRAITS_H
 #define LLVM_LIBC_SRC_SUPPORT_CPP_TYPETRAITS_H
 
 namespace __llvm_libc {
 namespace cpp {
 
-template <typename T> struct type_identity { using type = T; };
+template <typename T> struct type_identity {
+  using type = T;
+};
 
 template <bool B, typename T> struct enable_if;
 template <typename T> struct enable_if<true, T> : type_identity<T> {};
 template <bool B, typename T = void>
 using enable_if_t = typename enable_if<B, T>::type;
 
 template <typename T, T v> struct integral_constant {
   using value_type = T;

 template <class T> inline constexpr bool is_const_v = is_const<T>::value;
 
 template <typename T> struct remove_cv : type_identity<T> {};
 template <typename T> struct remove_cv<const T> : type_identity<T> {};
 template <typename T> struct remove_cv<volatile T> : type_identity<T> {};
 template <typename T> struct remove_cv<const volatile T> : type_identity<T> {};
 template <typename T> using remove_cv_t = typename remove_cv<T>::type;
 
+template <typename T> struct remove_reference : type_identity<T> {};
+template <typename T> struct remove_reference<T &> : type_identity<T> {};
+template <typename T> struct remove_reference<T &&> : type_identity<T> {};
+template <typename T>
+using remove_reference_t = typename remove_reference<T>::type;
+
+template <typename T> struct add_rvalue_reference : type_identity<T &&> {};
+
+template <typename T> struct remove_cvref {
+  using type = remove_cv_t<remove_reference_t<T>>;
+};
+template <typename T> using remove_cvref_t = typename remove_cvref<T>::type;
+
 namespace details {
 template <typename T, typename... Args> constexpr bool is_unqualified_any_of() {
   return (... || is_same_v<remove_cv_t<T>, Args>);
 }
 } // namespace details
 
 template <typename T> struct is_integral {
   static constexpr bool value = details::is_unqualified_any_of<

 // Compile time type selection.
 template <bool B, typename T, typename F>
 struct conditional : type_identity<T> {};
 template <typename T, typename F>
 struct conditional<false, T, F> : type_identity<F> {};
 template <bool B, typename T, typename F>
 using conditional_t = typename conditional<B, T, F>::type;
 
+template <typename T> typename add_rvalue_reference<T>::type declval() {}
+
+template <typename T>
+struct is_void : cpp::is_same<void, typename remove_cv<T>::type> {};
+
+namespace details {
+template <typename T>
+decltype(void(static_cast<T (*)()>(nullptr)), true_type{}) returnable(int);
+template <typename> false_type returnable(...);
+template <typename F, typename T>
+decltype(void(declval<void (&)(T)>()(declval<F>())), true_type{})
+implicitly_convertible(int);
+template <typename, typename> false_type implicitly_convertible(...);
+} // namespace details
+
+template <typename F, typename T>
+struct is_convertible
+    : integral_constant<bool, (decltype(details::returnable<T>(0))::value &&
+                               decltype(details::implicitly_convertible<F, T>(
+                                   0))::value) ||
+                                  (is_void<F>::value && is_void<T>::value)> {};
+
 } // namespace cpp
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_CPP_TYPETRAITS_H

libc/src/__support/CPP/utility.h

 //===-- Analogous to <utility> ----------------------------------*- C++ -*-===//
 //
 // 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 LLVM_LIBC_SRC_SUPPORT_CPP_UTILITY_H
 #define LLVM_LIBC_SRC_SUPPORT_CPP_UTILITY_H
 
 #include "src/__support/CPP/type_traits.h"
+#include "src/__support/macros/attributes.h"
 
 namespace __llvm_libc::cpp {
 
 template <typename T, T... Ints> struct integer_sequence {
   static_assert(is_integral_v<T>);
   template <T Next> using append = integer_sequence<T, Ints..., Next>;
 };
 

 };
 
 } // namespace internal
 
 template <typename T, int N>
 using make_integer_sequence =
     typename internal::make_integer_sequence<T, N - 1>::type;
 
+template <typename T>
+LIBC_INLINE constexpr T &&forward(typename remove_reference<T>::type &value) {
+  return static_cast<T &&>(value);
+}
+
+template <typename T>
+LIBC_INLINE constexpr T &&forward(typename remove_reference<T>::type &&value) {
+  return static_cast<T &&>(value);
+}
+
+template <typename T>
+LIBC_INLINE constexpr typename remove_reference<T>::type &&move(T &&value) {
+  return static_cast<typename remove_reference<T>::type &&>(value);
+}
+
 } // namespace __llvm_libc::cpp
 
 #endif // LLVM_LIBC_SRC_SUPPORT_CPP_UTILITY_H