From fa9a0a0683bbfa968b19ed5170538a56a01f889c Mon Sep 17 00:00:00 2001
From: Travis Geiselbrecht <travisg@gmail.com>
Date: Mon, 13 Dec 2021 00:05:09 -0800
Subject: [PATCH] [lib][cpp] add a type_traits header

mostly for std::move and friends.
---
 lib/libcpp/include/type_traits | 502 +++++++++++++++++++++++++++++++++
 1 file changed, 502 insertions(+)
 create mode 100644 lib/libcpp/include/type_traits

diff --git a/lib/libcpp/include/type_traits b/lib/libcpp/include/type_traits
new file mode 100644
index 00000000..365f1597
--- /dev/null
+++ b/lib/libcpp/include/type_traits
@@ -0,0 +1,502 @@
+// Copyright 2016 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#pragma once
+
+namespace std {
+
+template <typename T, T v>
+struct integral_constant {
+    static constexpr T value = v;
+
+    using value_type = T;
+    using type = integral_constant<T, v>;
+};
+
+using true_type = integral_constant<bool, true>;
+using false_type = integral_constant<bool, false>;
+
+// is_void:
+template <typename T>
+struct is_void : false_type {};
+
+template <>
+struct is_void<void> : true_type {};
+
+template <>
+struct is_void<const void> : true_type {};
+
+template <>
+struct is_void<volatile void> : true_type {};
+
+template <>
+struct is_void<const volatile void> : true_type {};
+
+// is_null_pointer:
+template <typename T>
+struct is_null_pointer : false_type {};
+
+template <>
+struct is_null_pointer<decltype(nullptr)> : true_type {};
+
+template <>
+struct is_null_pointer<const decltype(nullptr)> : true_type {};
+
+template <>
+struct is_null_pointer<volatile decltype(nullptr)> : true_type {};
+
+template <>
+struct is_null_pointer<const volatile decltype(nullptr)> : true_type {};
+
+// is_const:
+
+template <typename T>
+struct is_const : false_type {};
+
+template <typename T>
+struct is_const<const T> : true_type {};
+
+// is_lvalue_reference:
+
+template <typename T>
+struct is_lvalue_reference : false_type {};
+
+template <typename T>
+struct is_lvalue_reference<T&> : true_type {};
+
+// is_rvalue_reference:
+
+template <typename T>
+struct is_rvalue_reference : false_type {};
+
+template <typename T>
+struct is_rvalue_reference<T&&> : true_type {};
+
+// is_reference:
+template <typename T>
+struct is_reference : false_type {};
+
+template <typename T>
+struct is_reference<T&> : true_type {};
+
+template <typename T>
+struct is_reference<T&&> : true_type {};
+
+// remove_reference:
+
+template <typename T>
+struct remove_reference {
+    using type = T;
+};
+
+template <typename T>
+struct remove_reference<T&> {
+    using type = T;
+};
+
+template <typename T>
+struct remove_reference<T&&> {
+    using type = T;
+};
+
+// remove_pointer:
+
+template <typename T>
+struct remove_pointer {
+    using type = T;
+};
+
+template <typename T>
+struct remove_pointer<T*> {
+    using type = T;
+};
+
+// remove_const:
+
+template <typename T>
+struct remove_const {
+    typedef T type;
+};
+
+template <typename T>
+struct remove_const<const T> {
+    typedef T type;
+};
+
+// remove_volatile:
+
+template <typename T>
+struct remove_volatile {
+    typedef T type;
+};
+
+template <typename T>
+struct remove_volatile<volatile T> {
+    typedef T type;
+};
+
+// remove_cv:
+
+template <typename T>
+struct remove_cv {
+    typedef typename remove_volatile<typename remove_const<T>::type>::type type;
+};
+
+// remove_extent:
+
+template <typename T>
+struct remove_extent {
+    using type = T;
+};
+
+template <typename T>
+struct remove_extent<T[]> {
+    using type = T;
+};
+
+// Avoid having to pull in a header to name size_t; just use sizeof to
+// get at it.
+template <typename T, decltype(sizeof(nullptr)) N>
+struct remove_extent<T[N]> {
+    using type = T;
+};
+
+// move
+
+template <typename T>
+constexpr typename remove_reference<T>::type&& move(T&& t) {
+    return static_cast<typename remove_reference<T>::type&&>(t);
+}
+
+// forward:
+
+template <typename T>
+constexpr T&& forward(typename remove_reference<T>::type& t) {
+    return static_cast<T&&>(t);
+}
+
+template <typename T>
+constexpr T&& forward(typename remove_reference<T>::type&& t) {
+    static_assert(!is_lvalue_reference<T>::value, "bad std::forward call");
+    return static_cast<T&&>(t);
+}
+
+// is_same:
+
+template<class T, class U> struct is_same : false_type {};
+template<class T> struct is_same<T, T> : true_type {};
+
+// enable_if:
+
+template<bool B, class T = void> struct enable_if { };
+template<class T> struct enable_if<true, T> {
+    typedef T type;
+};
+
+// conditional:
+
+template<bool B, class T, class F>
+struct conditional { typedef T type; };
+
+template<class T, class F>
+struct conditional<false, T, F> { typedef F type; };
+
+// is_integral.  By default, T is not integral (aka, not an integer)
+template <typename T>
+struct is_integral : false_type {};
+
+// Specializations.  Every basic integral type needs to be called out.
+template <> struct is_integral<bool>                   : true_type {};
+template <> struct is_integral<char>                   : true_type {};
+template <> struct is_integral<char16_t>               : true_type {};
+template <> struct is_integral<char32_t>               : true_type {};
+template <> struct is_integral<wchar_t>                : true_type {};
+template <> struct is_integral<signed char>            : true_type {};
+template <> struct is_integral<unsigned char>          : true_type {};
+template <> struct is_integral<short int>              : true_type {};
+template <> struct is_integral<unsigned short int>     : true_type {};
+template <> struct is_integral<int>                    : true_type {};
+template <> struct is_integral<unsigned int>           : true_type {};
+template <> struct is_integral<long int>               : true_type {};
+template <> struct is_integral<unsigned long int>      : true_type {};
+template <> struct is_integral<long long int>          : true_type {};
+template <> struct is_integral<unsigned long long int> : true_type {};
+
+// is_floating_point.  By default, T is not a floating point type.
+template <typename T>
+struct is_floating_point : false_type {};
+
+// Specializations.  Every basic floating point type needs to be called out.
+template <> struct is_floating_point<float>       : true_type {};
+template <> struct is_floating_point<double>      : true_type {};
+template <> struct is_floating_point<long double> : true_type {};
+
+// Arithmetic data types are either floats or integers
+template <typename T>
+struct is_arithmetic :
+    integral_constant<bool, is_integral<T>::value || is_floating_point<T>::value> { };
+
+namespace internal {
+
+template<typename T, bool = is_arithmetic<T>::value>
+struct is_signed : integral_constant<bool, T(-1) < T(0)> {};
+template<typename T>
+struct is_signed<T, false> : std::false_type {};
+
+template<typename T, bool = is_arithmetic<T>::value>
+struct is_unsigned : integral_constant<bool, T(0) < T(-1)> {};
+template<typename T>
+struct is_unsigned<T, false> : std::false_type {};
+
+template<typename T, bool = is_integral<T>::value>
+struct is_signed_integer : integral_constant<bool, T(-1) < T(0)> {};
+template<typename T>
+struct is_signed_integer<T, false> : std::false_type {};
+
+template<typename T, bool = is_integral<T>::value>
+struct is_unsigned_integer : integral_constant<bool, T(0) < T(-1)> {};
+template<typename T>
+struct is_unsigned_integer<T, false> : std::false_type {};
+
+} // namespace internal
+
+template <typename T>
+struct is_signed : internal::is_signed<T>::type {};
+
+template <typename T>
+struct is_unsigned : internal::is_unsigned<T>::type {};
+
+template <typename T>
+struct is_signed_integer : internal::is_signed_integer<T>::type {};
+
+template <typename T>
+struct is_unsigned_integer : internal::is_unsigned_integer<T>::type {};
+
+// is_enum is a builtin
+template<typename T>
+struct is_enum : integral_constant<bool, __is_enum(T)> { };
+
+// is_pod is a builtin
+template<typename T>
+struct is_pod : integral_constant<bool, __is_pod(T)> { };
+
+// is_standard_layout is a builtin
+template<typename T>
+struct is_standard_layout : integral_constant<bool, __is_standard_layout(T)> { };
+
+// underlying_type is a builtin
+template<typename T>
+struct underlying_type {
+  using type = __underlying_type(T);
+};
+
+// match_cv: match_cv<SrcType, DestType>::type is DestType cv-qualified in the same way as SrcType.
+
+// Primary template:
+template <typename SrcType, typename DestType>
+struct match_cv {
+  using type = typename remove_cv<DestType>::type;
+};
+
+// Specializations for const/volatile/const volatile:
+template <typename SrcType, typename DestType>
+struct match_cv<const SrcType, DestType> {
+  using type = typename remove_cv<DestType>::type const;
+};
+template <typename SrcType, typename DestType>
+struct match_cv<volatile SrcType, DestType> {
+  using type = typename remove_cv<DestType>::type volatile;
+};
+template <typename SrcType, typename DestType>
+struct match_cv<const volatile SrcType, DestType> {
+  using type = typename remove_cv<DestType>::type const volatile;
+};
+
+// is_class builtin
+template <typename T>
+struct is_class : public integral_constant<bool, __is_class(T)> { };
+
+// is_union builtin
+template <typename T>
+struct is_union : public integral_constant<bool, __is_union(T)> { };
+
+// is_base_of builtin
+template <typename Base, typename Derived>
+struct is_base_of : public integral_constant<bool, __is_base_of(Base, Derived)> { };
+
+// has_virtual_destructor
+template <typename T>
+struct has_virtual_destructor : public integral_constant<bool, __has_virtual_destructor(T)> { };
+
+// has_trivial_destructor
+template <typename T>
+struct has_trivial_destructor : public integral_constant<bool, __has_trivial_destructor(T)> { };
+
+// is_pointer
+namespace internal {
+template <typename T>
+struct is_pointer : public false_type { };
+
+template <typename T>
+struct is_pointer<T*> : public true_type { };
+}  // namespace internal
+
+template <typename T>
+struct is_pointer :
+    public integral_constant<bool,
+                             internal::is_pointer<typename remove_cv<T>::type>::value> { };
+
+// is_convertible_pointer
+//
+// Note: this is a simplified version of std::is_convertible.  Whereas
+// std::is_convertible will check to see if any two types are implicitly
+// convertible, is_convertible_pointer will only check to see if two pointer
+// types are implicitly convertible.  Additionally, no explicit support or tests
+// have been added for function pointers conversion.
+template <typename From, typename To>
+struct is_convertible_pointer {
+private:
+    static true_type  test(To);
+    static false_type test(...);
+    static From       make_from_type();
+
+public:
+    static constexpr bool value =
+        is_pointer<From>::value &&
+        is_pointer<To>::value &&
+        decltype(test(make_from_type()))::value;
+};
+
+// Macro for defining a trait that checks if a type T has a method with the
+// given name. This is not as strong as using is_same to check function
+// signatures, but checking this trait first gives a better static_assert
+// message than the compiler warnings from is_same if the function doesn't
+// exist.
+// Note that the resulting trait_name will be in the namespace where the macro
+// is used.
+//
+// Example:
+//
+// DECLARE_HAS_MEMBER_FN(has_bar, Bar);
+// template <typname T>
+// class Foo {
+//   static_assert(has_bar<T>::value, "Foo classes must implement Bar()!");
+//   // TODO: use 'if constexpr' to avoid this next static_assert once c++17
+//   lands.
+//   static_assert(is_same<decltype(&T::Bar), void (T::*)(int)>::value,
+//                 "Bar must be a non-static member function with signature "
+//                 "'void Bar(int)', and must be visible to Foo (either "
+//                 "because it is public, or due to friendship).");
+//  };
+#define DECLARE_HAS_MEMBER_FN(trait_name, fn_name)                                \
+template <typename T>                                                             \
+struct trait_name {                                                               \
+private:                                                                          \
+    template <typename C> static ::std::true_type test( decltype(&C::fn_name) ); \
+    template <typename C> static ::std::false_type test(...);                    \
+                                                                                  \
+public:                                                                           \
+    static constexpr bool value = decltype(test<T>(nullptr))::value;              \
+}
+
+// Similar to DECLARE_HAS_MEMBER_FN but also checks the function signature.
+// This is especially useful when the desired function may be overloaded.
+// The signature must take the form "ResultType (C::*)(ArgType1, ArgType2)".
+//
+// Example:
+//
+// DECLARE_HAS_MEMBER_FN_WITH_SIGNATURE(has_c_str, c_str, const char* (C::*)() const);
+#define DECLARE_HAS_MEMBER_FN_WITH_SIGNATURE(trait_name, fn_name, sig)            \
+template <typename T>                                                             \
+struct trait_name {                                                               \
+private:                                                                          \
+    template <typename C> static ::std::true_type test( decltype(static_cast<sig>(&C::fn_name)) ); \
+    template <typename C> static ::std::false_type test(...);                     \
+                                                                                  \
+public:                                                                           \
+    static constexpr bool value = decltype(test<T>(nullptr))::value;              \
+}
+
+namespace internal {
+
+template <typename...>
+struct make_void {
+    using type = void;
+};
+
+} // namespace internal
+
+// Utility type for SFINAE expression evaluation, equivalent to C++17 std::void_t.
+template <typename... Ts>
+using void_t = typename internal::make_void<Ts...>::type;
+
+// is_function:
+
+// Morally, is_function could be implemented in the same style as
+// e.g. is_reference: a base case of false, and specializations of
+// true for every kind of function. However, listing all of those
+// cases is brittle and language version dependent. For instance,
+// C++17 makes noexcept specifiers as part of the type.
+
+// Instead, this implementation uses a pair of tricky overloaded
+// functions to detect every type that _isn't_ a function. This
+// includes:
+// - objects (classes, unions, and primitives) (including incomplete types)
+// - references (including references to functions)
+// - nullptr_t
+// - void
+// - pointers (including pointers to functions)
+// - pointers to members
+// - arrays of both complete and incomplete type
+
+namespace internal {
+
+// This leaves pointers, pointer-to-members, arrays, and functions.
+template <typename T>
+struct is_object_void_reference_or_null_pointer {
+    static constexpr bool value =
+        is_class<T>::value ||
+        is_union<T>::value ||
+        is_void<T>::value ||
+        is_reference<T>::value ||
+        is_null_pointer<T>::value;
+};
+
+struct dummy {};
+
+struct func_tag {};
+
+struct nonfunc_tag {};
+
+template <typename T>
+func_tag choose(T*);
+
+template <typename T>
+func_tag choose(dummy);
+
+template <typename T>
+nonfunc_tag choose(...);
+
+template <typename T>
+T& make(int);
+
+template <typename T>
+dummy make(...);
+
+} // namespace internal
+
+template <typename T,
+          bool = internal::is_object_void_reference_or_null_pointer<T>::value>
+struct is_function : public integral_constant<bool,
+                                              is_same<internal::func_tag,
+                                                      decltype(internal::choose<T>(internal::make<T>(0)))
+                                                      >::value> {
+};
+
+template <typename T>
+struct is_function<T, true> : public false_type {
+};
+
+}  // namespace std
+// vim: syntax=cpp